diff --git a/.github/workflows/refman.yml b/.github/workflows/refman.yml
index 3a9db4edddc..328c70f903b 100644
--- a/.github/workflows/refman.yml
+++ b/.github/workflows/refman.yml
@@ -15,15 +15,14 @@ jobs:
      with:
        branch: master
 
-  build:
+  build-refman:
     needs: check-deep-tests
     if: always() && (( github.event_name == 'pull_request' && (needs.check-deep-tests.result == 'success' || contains(github.event.pull_request.labels.*.name, 'run-deep-tests'))) || ( github.event_name == 'push' && ( github.ref_name == 'master' || vars.TEST_ON_FORK == 'true' )))
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        os: [ macos-latest ]
-        # os: [macos-latest, ubuntu-latest ]
+        os: [ ubuntu-latest ]
     steps:
     - name: OS
       run: echo ${{ runner.os }} ${{ matrix.os }}
@@ -41,28 +40,10 @@ jobs:
     - name: Install latex pandoc - Linux
       if: runner.os == 'Linux'
       run: |
-        sudo apt-get install texlive texlive-xetex
-        wget https://github.com/jgm/pandoc/releases/download/2.10.1/pandoc-2.10.1-1-amd64.deb
+        sudo apt-get install texlive-full
+        wget https://github.com/jgm/pandoc/releases/download/3.1.7/pandoc-3.1.7-1-amd64.deb
         sudo dpkg -i *.deb
         rm -rf *.deb
-      # apt-get has pandoc, but it is outdated
-    - name: Extra linux packages
-      if: matrix.os == 'ubuntu-latest'
-      run: |
-        sudo apt-get install texlive-science
-        sudo tlmgr init-usertree
-        sudo tlmgr update --self
-        sudo tlmgr install framed tcolorbox environ trimspaces unicode-math
-        pandoc -v
-        which latex || echo NOT FOUND latex
-        which xelatex || echo NOT FOUND xelatex
-        sudo gem install rouge
-    - if: matrix.os != 'ubuntu-latest' && runner.os == 'Linux'
-      run: |
-        sudo apt-get install texlive-math-extra
-        sudo tlmgr init-usertree
-        sudo tlmgr update --self
-        sudo tlmgr install framed tcolorbox environ trimspaces unicode-math
         pandoc -v
         which latex || echo NOT FOUND latex
         which xelatex || echo NOT FOUND xelatex
diff --git a/Source/DafnyCore/AST/Members/Field.cs b/Source/DafnyCore/AST/Members/Field.cs
index 719834ab2e0..c764d3279b8 100644
--- a/Source/DafnyCore/AST/Members/Field.cs
+++ b/Source/DafnyCore/AST/Members/Field.cs
@@ -9,14 +9,15 @@ public class Field : MemberDecl, ICanFormat, IHasDocstring, ISymbol {
   public readonly bool IsMutable;  // says whether or not the field can ever change values
   public readonly bool IsUserMutable;  // says whether or not code is allowed to assign to the field (IsUserMutable implies IsMutable)
   public PreType PreType;
-  public readonly Type Type;
+
+  public readonly Type Type; // Might be null after parsing and set during resolution
   [ContractInvariantMethod]
   void ObjectInvariant() {
     Contract.Invariant(Type != null);
     Contract.Invariant(!IsUserMutable || IsMutable);  // IsUserMutable ==> IsMutable
   }
 
-  public override IEnumerable<INode> Children => Type.Nodes;
+  public override IEnumerable<INode> Children => Type?.Nodes ?? Enumerable.Empty<INode>();
 
   public Field(RangeToken rangeToken, Name name, bool isGhost, Type type, Attributes attributes)
     : this(rangeToken, name, false, isGhost, true, true, type, attributes) {
diff --git a/Source/DafnyCore/AST/Modules/LiteralModuleDecl.cs b/Source/DafnyCore/AST/Modules/LiteralModuleDecl.cs
index a92c7d99c33..f5393c1246c 100644
--- a/Source/DafnyCore/AST/Modules/LiteralModuleDecl.cs
+++ b/Source/DafnyCore/AST/Modules/LiteralModuleDecl.cs
@@ -177,7 +177,8 @@ public LiteralModuleDecl(ModuleDefinition module, ModuleDefinition parent, Guid
 
     var bindings = ModuleDef.BindModuleNames(resolver, parentBindings);
     if (!parentBindings.BindName(Name, this, bindings)) {
-      resolver.Reporter.Error(MessageSource.Resolver, tok, "Duplicate module name: {0}", Name);
+      parentBindings.TryLookup(Name, out var otherModule);
+      resolver.Reporter.Error(MessageSource.Resolver, new NestedToken(tok, otherModule.tok), "Duplicate module name: {0}", Name);
     }
   }
 
diff --git a/Source/DafnyCore/AST/Modules/ModuleBindings.cs b/Source/DafnyCore/AST/Modules/ModuleBindings.cs
index 68c65c349c4..2ce4e22f9de 100644
--- a/Source/DafnyCore/AST/Modules/ModuleBindings.cs
+++ b/Source/DafnyCore/AST/Modules/ModuleBindings.cs
@@ -25,14 +25,14 @@ public class ModuleBindings {
     }
   }
 
-  public bool TryLookup(IToken name, out ModuleDecl m) {
+  public bool TryLookup(string name, out ModuleDecl m) {
     Contract.Requires(name != null);
     return TryLookupFilter(name, out m, l => true);
   }
 
-  public bool TryLookupFilter(IToken name, out ModuleDecl m, Func<ModuleDecl, bool> filter) {
+  public bool TryLookupFilter(string name, out ModuleDecl m, Func<ModuleDecl, bool> filter) {
     Contract.Requires(name != null);
-    if (modules.TryGetValue(name.val, out m) && filter(m)) {
+    if (modules.TryGetValue(name, out m) && filter(m)) {
       return true;
     } else if (parent != null) {
       return parent.TryLookupFilter(name, out m, filter);
@@ -56,7 +56,7 @@ public class ModuleBindings {
     Contract.Assert(qid != null);
     IToken root = qid.Path[0].StartToken;
     result = null;
-    bool res = TryLookupFilter(root, out result,
+    bool res = TryLookupFilter(root.val, out result,
       m => context != m && ((context.EnclosingModuleDefinition == m.EnclosingModuleDefinition && context.Exports.Count == 0) || m is LiteralModuleDecl));
     return res;
   }
@@ -72,7 +72,7 @@ public class ModuleBindings {
     Contract.Assert(qid != null);
     IToken root = qid.Path[0].StartToken;
     result = null;
-    bool res = TryLookupFilter(root, out result,
+    bool res = TryLookupFilter(root.val, out result,
       m => context != m && ((context.EnclosingModuleDefinition == m.EnclosingModuleDefinition && context.Exports.Count == 0) || m is LiteralModuleDecl));
     return res;
   }
@@ -82,7 +82,7 @@ public class ModuleBindings {
     Contract.Assert(qid != null);
     IToken root = qid.Path[0].StartToken;
     result = null;
-    bool res = TryLookupFilter(root, out result, m => m.EnclosingModuleDefinition != context);
+    bool res = TryLookupFilter(root.val, out result, m => m.EnclosingModuleDefinition != context);
     return res;
   }
 }
\ No newline at end of file
diff --git a/Source/DafnyCore/AST/Modules/ModuleDefinition.cs b/Source/DafnyCore/AST/Modules/ModuleDefinition.cs
index 9ea473870c2..2baf5a8f228 100644
--- a/Source/DafnyCore/AST/Modules/ModuleDefinition.cs
+++ b/Source/DafnyCore/AST/Modules/ModuleDefinition.cs
@@ -646,7 +646,7 @@ public class AccessibleMember {
         // the add was successful
       } else {
         // there's already something with this name
-        var yes = bindings.TryLookup(subDecl.tok, out var prevDecl);
+        var yes = bindings.TryLookup(subDecl.tok.val, out var prevDecl);
         Contract.Assert(yes);
         if (prevDecl is AbstractModuleDecl || prevDecl is AliasModuleDecl) {
           resolver.Reporter.Error(MessageSource.Resolver, subDecl.tok, "Duplicate name of import: {0}", subDecl.Name);
diff --git a/Source/DafnyCore/AST/Types/UserDefinedType.cs b/Source/DafnyCore/AST/Types/UserDefinedType.cs
index 8962848f4be..b9592d00534 100644
--- a/Source/DafnyCore/AST/Types/UserDefinedType.cs
+++ b/Source/DafnyCore/AST/Types/UserDefinedType.cs
@@ -110,13 +110,26 @@ public UserDefinedType(Cloner cloner, UserDefinedType original)
   ///   Return the upcast of "receiverType" that has base type "member.EnclosingClass".
   ///   Assumes that "receiverType" normalizes to a UserDefinedFunction with a .ResolveClass that is a subtype
   ///   of "member.EnclosingClass".
+  ///   Preserves non-null-ness of "receiverType" if it is a non-null reference.
   /// Otherwise:
   ///   Return "receiverType" (expanded).
   /// </summary>
   public static Type UpcastToMemberEnclosingType(Type receiverType, MemberDecl/*?*/ member) {
     Contract.Requires(receiverType != null);
     if (member != null && member.EnclosingClass != null && !(member.EnclosingClass is ValuetypeDecl)) {
-      return receiverType.AsParentType(member.EnclosingClass);
+      var parentType = receiverType.AsParentType(member.EnclosingClass);
+
+      if (receiverType.IsNonNullRefType) {
+        if (parentType == null) {
+          return null;
+        } else if (parentType.ResolvedClass is ClassLikeDecl { IsReferenceTypeDecl: true }) {
+          return CreateNonNullType(parentType);
+        } else {
+          return parentType;
+        }
+      } else {
+        return parentType;
+      }
     }
     return receiverType.NormalizeExpandKeepConstraints();
   }
diff --git a/Source/DafnyCore/Compilers/Dafny/AST.dfy b/Source/DafnyCore/Compilers/Dafny/AST.dfy
index 06d2a51cf48..fcdb4de16ff 100644
--- a/Source/DafnyCore/Compilers/Dafny/AST.dfy
+++ b/Source/DafnyCore/Compilers/Dafny/AST.dfy
@@ -5,6 +5,7 @@ module {:extern "DAST"} DAST {
 
   datatype Type =
     Path(seq<Ident>, typeArgs: seq<Type>, resolved: ResolvedType) |
+    Nullable(Type) |
     Tuple(seq<Type>) |
     Array(element: Type) |
     Seq(element: Type) |
@@ -49,6 +50,8 @@ module {:extern "DAST"} DAST {
     Call(on: Expression, name: string, typeArgs: seq<Type>, args: seq<Expression>, outs: Optional<seq<Ident>>) |
     Return(expr: Expression) |
     EarlyReturn() |
+    TailRecursive(body: seq<Statement>) |
+    JumpTailCallStart() |
     Halt() |
     Print(Expression)
 
diff --git a/Source/DafnyCore/Compilers/Dafny/ASTBuilder.cs b/Source/DafnyCore/Compilers/Dafny/ASTBuilder.cs
index 58643f30038..41f928fbe60 100644
--- a/Source/DafnyCore/Compilers/Dafny/ASTBuilder.cs
+++ b/Source/DafnyCore/Compilers/Dafny/ASTBuilder.cs
@@ -382,6 +382,12 @@ interface StatementContainer {
       return ret;
     }
 
+    public TailRecursiveBuilder TailRecursive() {
+      var ret = new TailRecursiveBuilder();
+      AddBuildable(ret);
+      return ret;
+    }
+
     public CallStmtBuilder Call() {
       var ret = new CallStmtBuilder();
       AddBuildable(ret);
@@ -640,6 +646,35 @@ class WhileBuilder : ExprContainer, StatementContainer, BuildableStatement {
     }
   }
 
+  class TailRecursiveBuilder : StatementContainer, BuildableStatement {
+    readonly List<object> body = new();
+
+    public TailRecursiveBuilder() { }
+
+    public void AddStatement(DAST.Statement item) {
+      body.Add(item);
+    }
+
+    public void AddBuildable(BuildableStatement item) {
+      body.Add(item);
+    }
+
+    public List<object> ForkList() {
+      var ret = new List<object>();
+      this.body.Add(ret);
+      return ret;
+    }
+
+    public DAST.Statement Build() {
+      List<DAST.Statement> builtStatements = new();
+      StatementContainer.RecursivelyBuild(body, builtStatements);
+
+      return (DAST.Statement)DAST.Statement.create_TailRecursive(
+        Sequence<DAST.Statement>.FromArray(builtStatements.ToArray())
+      );
+    }
+  }
+
   class CallStmtBuilder : ExprContainer, BuildableStatement {
     object on = null;
     string name = null;
diff --git a/Source/DafnyCore/Compilers/Dafny/Compiler-dafny.cs b/Source/DafnyCore/Compilers/Dafny/Compiler-dafny.cs
index 6f38a2264d5..0615e56568f 100644
--- a/Source/DafnyCore/Compilers/Dafny/Compiler-dafny.cs
+++ b/Source/DafnyCore/Compilers/Dafny/Compiler-dafny.cs
@@ -130,13 +130,29 @@ class DafnyCompiler : SinglePassCompiler {
     }
 
     protected override ConcreteSyntaxTree EmitCoercionIfNecessary(Type from, Type to, IToken tok, ConcreteSyntaxTree wr) {
-      if (from.AsSubsetType == null && to.AsSubsetType != null) {
+      if (from != null && to != null && from.IsNonNullRefType != to.IsNonNullRefType) {
+        if (wr is BuilderSyntaxTree<ExprContainer> stmt) {
+          var nullConvert = stmt.Builder.Convert(GenType(from), GenType(to));
+
+          if (from is UserDefinedType fromUdt && fromUdt.ResolvedClass is NonNullTypeDecl fromNonNull) {
+            from = fromNonNull.RhsWithArgument(fromUdt.TypeArgs);
+          }
+
+          if (to is UserDefinedType toUdt && toUdt.ResolvedClass is NonNullTypeDecl toNonNull) {
+            to = toNonNull.RhsWithArgument(toUdt.TypeArgs);
+          }
+
+          return EmitCoercionIfNecessary(from, to, tok, new BuilderSyntaxTree<ExprContainer>(nullConvert));
+        } else {
+          return base.EmitCoercionIfNecessary(from, to, tok, wr);
+        }
+      } else if (from != null && to != null && from.AsSubsetType == null && to.AsSubsetType != null) {
         if (wr is BuilderSyntaxTree<ExprContainer> stmt) {
           return new BuilderSyntaxTree<ExprContainer>(stmt.Builder.Convert(GenType(from), GenType(to)));
         } else {
           return base.EmitCoercionIfNecessary(from, to, tok, wr);
         }
-      } else if (from.AsSubsetType != null && to.AsSubsetType == null) {
+      } else if (from != null && to != null && from.AsSubsetType != null && to.AsSubsetType == null) {
         if (wr is BuilderSyntaxTree<ExprContainer> stmt) {
           return new BuilderSyntaxTree<ExprContainer>(stmt.Builder.Convert(GenType(from), GenType(to)));
         } else {
@@ -515,12 +531,27 @@ private class ClassWriter : IClassWriter {
       return type.ToString();
     }
 
+    protected override ConcreteSyntaxTree EmitMethodReturns(Method m, ConcreteSyntaxTree wr) {
+      var beforeReturnBlock = wr.Fork();
+      EmitReturn(m.Outs, wr);
+      return beforeReturnBlock;
+    }
+
     protected override ConcreteSyntaxTree EmitTailCallStructure(MemberDecl member, ConcreteSyntaxTree wr) {
-      throw new NotImplementedException();
+      if (wr is BuilderSyntaxTree<StatementContainer> stmtContainer) {
+        var recBuilder = stmtContainer.Builder.TailRecursive();
+        return new BuilderSyntaxTree<StatementContainer>(recBuilder);
+      } else {
+        throw new InvalidOperationException();
+      }
     }
 
     protected override void EmitJumpToTailCallStart(ConcreteSyntaxTree wr) {
-      throw new NotImplementedException();
+      if (wr is BuilderSyntaxTree<StatementContainer> stmtContainer) {
+        stmtContainer.Builder.AddStatement((DAST.Statement)DAST.Statement.create_JumpTailCallStart());
+      } else {
+        throw new InvalidOperationException();
+      }
     }
 
     internal override string TypeName(Type type, ConcreteSyntaxTree wr, IToken tok, MemberDecl/*?*/ member = null) {
@@ -701,8 +732,12 @@ private class ClassWriter : IClassWriter {
 
     protected override void TrCallStmt(CallStmt s, string receiverReplacement, ConcreteSyntaxTree wr, ConcreteSyntaxTree wrStmts, ConcreteSyntaxTree wrStmtsAfterCall) {
       if (wr is BuilderSyntaxTree<StatementContainer> stmtContainer) {
-        var callBuilder = stmtContainer.Builder.Call();
-        base.TrCallStmt(s, receiverReplacement, new BuilderSyntaxTree<ExprContainer>(callBuilder), wrStmts, wrStmtsAfterCall);
+        if (s.Method == enclosingMethod && enclosingMethod.IsTailRecursive) {
+          base.TrCallStmt(s, receiverReplacement, wr, wrStmts, wrStmtsAfterCall);
+        } else {
+          var callBuilder = stmtContainer.Builder.Call();
+          base.TrCallStmt(s, receiverReplacement, new BuilderSyntaxTree<ExprContainer>(callBuilder), wrStmts, wrStmtsAfterCall);
+        }
       } else {
         throw new InvalidOperationException("Cannot call statement in this context: " + currentBuilder);
       }
@@ -795,6 +830,10 @@ private class ExprLvalue : ILvalue {
       }
     }
 
+    protected override void EmitAssignment(string lhs, Type/*?*/ lhsType, string rhs, Type/*?*/ rhsType, ConcreteSyntaxTree wr) {
+      throw new InvalidOperationException("Cannot use stringified version of assignment");
+    }
+
     protected override ILvalue IdentLvalue(string var) {
       return new BuilderLvalue(var);
     }
@@ -1019,7 +1058,13 @@ private class ExprLvalue : ILvalue {
             ));
             break;
           case StaticReceiverExpr:
-            throw new NotImplementedException();
+            if (e.Type.NormalizeExpandKeepConstraints() is UserDefinedType udt && udt.ResolvedClass is DatatypeDecl dt &&
+                DatatypeWrapperEraser.IsErasableDatatypeWrapper(Options, dt, out _)) {
+              baseExpr = (DAST.Expression)DAST.Expression.create_Companion(PathFromTopLevel(udt.ResolvedClass));
+            } else {
+              baseExpr = (DAST.Expression)DAST.Expression.create_Companion(PathFromTopLevel(e.Type.AsTopLevelTypeWithMembers));
+            }
+            break;
           default:
             DAST.Type baseType;
             if (e.Type.AsNewtype != null) {
@@ -1152,11 +1197,11 @@ private class ExprLvalue : ILvalue {
     private DAST.Type TypeNameASTFromTopLevel(TopLevelDecl topLevel, List<Type> typeArgs) {
       var path = PathFromTopLevel(topLevel);
 
-      // TODO(shadaj): do something with nullable references
-      // bool nonNull = false;
+      bool nonNull = true;
       if (topLevel is NonNullTypeDecl non) {
-        // nonNull = true;
         topLevel = non.Rhs.AsTopLevelTypeWithMembers;
+      } else if (topLevel is ClassLikeDecl) {
+        nonNull = false;
       }
 
       ResolvedType resolvedType;
@@ -1175,11 +1220,17 @@ private class ExprLvalue : ILvalue {
         throw new InvalidOperationException(topLevel.GetType().ToString());
       }
 
-      return (DAST.Type)DAST.Type.create_Path(
+      DAST.Type baseType = (DAST.Type)DAST.Type.create_Path(
         path,
         Sequence<DAST.Type>.FromArray(typeArgs.Select(m => GenType(m)).ToArray()),
         resolvedType
       );
+
+      if (nonNull) {
+        return baseType;
+      } else {
+        return (DAST.Type)DAST.Type.create_Nullable(baseType);
+      }
     }
 
     public override ConcreteSyntaxTree Expr(Expression expr, bool inLetExprBody, ConcreteSyntaxTree wStmts) {
@@ -1495,6 +1546,20 @@ private class ExprLvalue : ILvalue {
       }
     }
 
+    protected override void EmitLambdaApply(ConcreteSyntaxTree wr, out ConcreteSyntaxTree wLambda, out ConcreteSyntaxTree wArg) {
+      if (wr is BuilderSyntaxTree<StatementContainer> builder) {
+        var lambda = builder.Builder.Call();
+        wLambda = new BuilderSyntaxTree<ExprContainer>(lambda);
+        wArg = new BuilderSyntaxTree<ExprContainer>(lambda);
+      } else if (wr is BuilderSyntaxTree<ExprContainer> exprBuilder) {
+        var lambda = exprBuilder.Builder.Call();
+        wLambda = new BuilderSyntaxTree<ExprContainer>(lambda);
+        wArg = new BuilderSyntaxTree<ExprContainer>(lambda);
+      } else {
+        throw new InvalidOperationException();
+      }
+    }
+
     protected override void CreateIIFE(string bvName, Type bvType, IToken bvTok, Type bodyType, IToken bodyTok,
       ConcreteSyntaxTree wr, ref ConcreteSyntaxTree wStmts, out ConcreteSyntaxTree wrRhs, out ConcreteSyntaxTree wrBody) {
       if (wr is BuilderSyntaxTree<ExprContainer> builder) {
diff --git a/Source/DafnyCore/Compilers/GoLang/Compiler-go.cs b/Source/DafnyCore/Compilers/GoLang/Compiler-go.cs
index b25267075c5..d4a54c542aa 100644
--- a/Source/DafnyCore/Compilers/GoLang/Compiler-go.cs
+++ b/Source/DafnyCore/Compilers/GoLang/Compiler-go.cs
@@ -3734,15 +3734,14 @@ protected class ClassWriter : IClassWriter {
 
     protected override void EmitMapDisplay(MapType mt, IToken tok, List<ExpressionPair> elements,
         bool inLetExprBody, ConcreteSyntaxTree wr, ConcreteSyntaxTree wStmts) {
-      wr.Write("_dafny.NewMapBuilder()");
+      wr.Write("_dafny.NewMapBuilder().ToMap()");
       foreach (ExpressionPair p in elements) {
-        wr.Write(".Add(");
+        wr.Write(".UpdateUnsafe(");
         wr.Append(Expr(p.A, inLetExprBody, wStmts));
         wr.Write(", ");
         wr.Append(Expr(p.B, inLetExprBody, wStmts));
         wr.Write(')');
       }
-      wr.Write(".ToMap()");
     }
 
     protected override void EmitSetBuilder_New(ConcreteSyntaxTree wr, SetComprehension e, string collectionName) {
diff --git a/Source/DafnyCore/Compilers/JavaScript/Compiler-js.cs b/Source/DafnyCore/Compilers/JavaScript/Compiler-js.cs
index fa7f0465afc..8df2a87ce83 100644
--- a/Source/DafnyCore/Compilers/JavaScript/Compiler-js.cs
+++ b/Source/DafnyCore/Compilers/JavaScript/Compiler-js.cs
@@ -2478,18 +2478,14 @@ protected class ClassWriter : IClassWriter {
 
     protected override void EmitMapDisplay(MapType mt, IToken tok, List<ExpressionPair> elements,
         bool inLetExprBody, ConcreteSyntaxTree wr, ConcreteSyntaxTree wStmts) {
-      wr.Write($"{DafnyMapClass}.of(");
-      string sep = "";
+      wr.Write($"{DafnyMapClass}.Empty.slice()");
       foreach (ExpressionPair p in elements) {
-        wr.Write(sep);
-        wr.Write("[");
+        wr.Write(".updateUnsafe(");
         wr.Append(Expr(p.A, inLetExprBody, wStmts));
         wr.Write(",");
         wr.Append(Expr(p.B, inLetExprBody, wStmts));
-        wr.Write("]");
-        sep = ", ";
+        wr.Write(")");
       }
-      wr.Write(")");
     }
 
     protected override void EmitSetBuilder_New(ConcreteSyntaxTree wr, SetComprehension e, string collectionName) {
diff --git a/Source/DafnyCore/Compilers/Rust/Dafny-compiler-rust.dfy b/Source/DafnyCore/Compilers/Rust/Dafny-compiler-rust.dfy
index 665343a197f..dc4e1d361a4 100644
--- a/Source/DafnyCore/Compilers/Rust/Dafny-compiler-rust.dfy
+++ b/Source/DafnyCore/Compilers/Rust/Dafny-compiler-rust.dfy
@@ -79,7 +79,7 @@ module {:extern "DCOMP"} DCOMP {
 
         match field.defaultValue {
           case Some(e) => {
-            var eStr, _, _, _ := GenExpr(e, [], true);
+            var eStr, _, _, _ := GenExpr(e, None, [], true);
             fieldInits := fieldInits + "r#" + field.formal.name + ": ::std::cell::RefCell::new(" + eStr + "),\n";
           }
           case None => {
@@ -215,7 +215,7 @@ module {:extern "DCOMP"} DCOMP {
       match c.witnessExpr {
         case Some(e) => {
           // TODO(shadaj): generate statements
-          var eStr, _, _, _ := GenExpr(e, [], true);
+          var eStr, _, _, _ := GenExpr(e, None, [], true);
           s := s + "r#" + c.name + "(" + eStr + ")\n";
         }
         case None => {
@@ -453,6 +453,10 @@ module {:extern "DCOMP"} DCOMP {
             case Primitive => {}
           }
         }
+        case Nullable(inner) => {
+          var innerStr := GenType(inner, inBinding, inFn);
+          s := "::std::option::Option<" + innerStr + ">";
+        }
         case Tuple(types) => {
           s := "(";
           var i := 0;
@@ -683,7 +687,7 @@ module {:extern "DCOMP"} DCOMP {
           case None => {}
         }
 
-        var body, _ := GenStmts(m.body, paramNames, true, earlyReturn);
+        var body, _ := GenStmts(m.body, if m.isStatic then None else Some("self"), paramNames, true, earlyReturn);
         match m.outVars {
           case Some(outVars) => {
             body := body + "\n" + earlyReturn;
@@ -697,13 +701,13 @@ module {:extern "DCOMP"} DCOMP {
       }
     }
 
-    static method GenStmts(stmts: seq<Statement>, params: seq<string>, isLast: bool, earlyReturn: string) returns (generated: string, readIdents: set<string>) {
+    static method GenStmts(stmts: seq<Statement>, selfIdent: Optional<string>, params: seq<string>, isLast: bool, earlyReturn: string) returns (generated: string, readIdents: set<string>) {
       generated := "";
       readIdents := {};
       var i := 0;
       while i < |stmts| {
         var stmt := stmts[i];
-        var stmtString, recIdents := GenStmt(stmt, params, isLast && (i == |stmts| - 1), earlyReturn);
+        var stmtString, recIdents := GenStmt(stmt, selfIdent, params, isLast && (i == |stmts| - 1), earlyReturn);
         readIdents := readIdents + recIdents;
 
         if i > 0 {
@@ -715,7 +719,7 @@ module {:extern "DCOMP"} DCOMP {
       }
     }
 
-    static method GenAssignLhs(lhs: AssignLhs, rhs: string, params: seq<string>) returns (generated: string, needsIIFE: bool, readIdents: set<string>) {
+    static method GenAssignLhs(lhs: AssignLhs, rhs: string, selfIdent: Optional<string>, params: seq<string>) returns (generated: string, needsIIFE: bool, readIdents: set<string>) {
       match lhs {
         case Ident(Ident(id)) => {
           if id in params {
@@ -729,7 +733,7 @@ module {:extern "DCOMP"} DCOMP {
         }
 
         case Select(on, field) => {
-          var onExpr, onOwned, onErased, recIdents := GenExpr(on, params, false);
+          var onExpr, onOwned, onErased, recIdents := GenExpr(on, selfIdent, params, false);
           if !onErased {
             var eraseFn := if onOwned then "erase_owned" else "erase";
             onExpr := "::dafny_runtime::DafnyErasable::" + eraseFn + "(" + onExpr + ")";
@@ -741,13 +745,13 @@ module {:extern "DCOMP"} DCOMP {
         }
 
         case Index(on, idx) => {
-          var onExpr, onOwned, onErased, recIdents := GenExpr(on, params, false);
+          var onExpr, onOwned, onErased, recIdents := GenExpr(on, selfIdent, params, false);
           if !onErased {
             var eraseFn := if onOwned then "erase_owned" else "erase";
             onExpr := "::dafny_runtime::DafnyErasable::" + eraseFn + "(" + onExpr + ")";
           }
 
-          var idxString, _, idxErased, idxIdents := GenExpr(idx, params, true);
+          var idxString, _, idxErased, idxIdents := GenExpr(idx, selfIdent, params, true);
           if !idxErased {
             idxString := "::dafny_runtime::DafnyErasable::erase_owned(" + idxString + ")";
           }
@@ -760,10 +764,10 @@ module {:extern "DCOMP"} DCOMP {
       }
     }
 
-    static method GenStmt(stmt: Statement, params: seq<string>, isLast: bool, earlyReturn: string) returns (generated: string, readIdents: set<string>) {
+    static method GenStmt(stmt: Statement, selfIdent: Optional<string>, params: seq<string>, isLast: bool, earlyReturn: string) returns (generated: string, readIdents: set<string>) {
       match stmt {
         case DeclareVar(name, typ, Some(expression)) => {
-          var expr, _, recErased, recIdents := GenExpr(expression, params, true);
+          var expr, _, recErased, recIdents := GenExpr(expression, selfIdent, params, true);
           if recErased {
             expr := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + expr + ")";
           }
@@ -778,8 +782,8 @@ module {:extern "DCOMP"} DCOMP {
           readIdents := {};
         }
         case Assign(lhs, expression) => {
-          var lhsGen, needsIIFE, recIdents := GenAssignLhs(lhs, "__rhs", params);
-          var exprGen, _, exprErased, exprIdents := GenExpr(expression, params, true);
+          var lhsGen, needsIIFE, recIdents := GenAssignLhs(lhs, "__rhs", selfIdent, params);
+          var exprGen, _, exprErased, exprIdents := GenExpr(expression, selfIdent, params, true);
           if exprErased {
             exprGen := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + exprGen + ")";
           }
@@ -793,29 +797,52 @@ module {:extern "DCOMP"} DCOMP {
           readIdents := recIdents + exprIdents;
         }
         case If(cond, thn, els) => {
-          var condString, _, condErased, recIdents := GenExpr(cond, params, true);
+          var condString, _, condErased, recIdents := GenExpr(cond, selfIdent, params, true);
           if !condErased {
             condString := "::dafny_runtime::DafnyErasable::erase_owned(" + condString + ")";
           }
 
           readIdents := recIdents;
-          var thnString, thnIdents := GenStmts(thn, params, isLast, earlyReturn);
+          var thnString, thnIdents := GenStmts(thn, selfIdent, params, isLast, earlyReturn);
           readIdents := readIdents + thnIdents;
-          var elsString, elsIdents := GenStmts(els, params, isLast, earlyReturn);
+          var elsString, elsIdents := GenStmts(els, selfIdent, params, isLast, earlyReturn);
           readIdents := readIdents + elsIdents;
           generated := "if " + condString + " {\n" + thnString + "\n} else {\n" + elsString + "\n}";
         }
         case While(cond, body) => {
-          var condString, _, condErased, recIdents := GenExpr(cond, params, true);
+          var condString, _, condErased, recIdents := GenExpr(cond, selfIdent, params, true);
           if !condErased {
             condString := "::dafny_runtime::DafnyErasable::erase(" + condString + ")";
           }
 
           readIdents := recIdents;
-          var bodyString, bodyIdents := GenStmts(body, params, false, earlyReturn);
+          var bodyString, bodyIdents := GenStmts(body, selfIdent, params, false, earlyReturn);
           readIdents := readIdents + bodyIdents;
           generated := "while " + condString + " {\n" + bodyString + "\n}";
         }
+        case TailRecursive(body) => {
+          // clone the parameters to make them mutable
+          generated := "";
+
+          if selfIdent != None {
+            generated := generated + "let mut r#_this = self.clone();\n";
+          }
+
+          var paramI := 0;
+          while paramI < |params| {
+            var param := params[paramI];
+            generated := generated + "let mut r#" + param + " = r#" + param + ".clone();\n";
+            paramI := paramI + 1;
+          }
+
+          var bodyString, bodyIdents := GenStmts(body, if selfIdent != None then Some("_this") else None, [], false, earlyReturn);
+          readIdents := bodyIdents;
+          generated := generated + "'TAIL_CALL_START: loop {\n" + bodyString + "\n}";
+        }
+        case JumpTailCallStart() => {
+          generated := "continue 'TAIL_CALL_START;";
+          readIdents := {};
+        }
         case Call(on, name, typeArgs, args, maybeOutVars) => {
           readIdents := {};
 
@@ -843,7 +870,7 @@ module {:extern "DCOMP"} DCOMP {
               argString := argString + ", ";
             }
 
-            var argExpr, isOwned, argErased, argIdents := GenExpr(args[i], params, false);
+            var argExpr, isOwned, argErased, argIdents := GenExpr(args[i], selfIdent, params, false);
             if isOwned {
               argExpr := "&" + argExpr;
             }
@@ -854,7 +881,7 @@ module {:extern "DCOMP"} DCOMP {
             i := i + 1;
           }
 
-          var enclosingString, _, _, enclosingIdents := GenExpr(on, params, false);
+          var enclosingString, _, _, enclosingIdents := GenExpr(on, selfIdent, params, false);
           readIdents := readIdents + enclosingIdents;
           match on {
             case Companion(_) => {
@@ -894,7 +921,7 @@ module {:extern "DCOMP"} DCOMP {
             enclosingString + "r#" + name + typeArgString + "(" + argString + ");";
         }
         case Return(expr) => {
-          var exprString, _, recErased, recIdents := GenExpr(expr, params, true);
+          var exprString, _, recErased, recIdents := GenExpr(expr, selfIdent, params, true);
           exprString := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + exprString + ")";
           readIdents := recIdents;
 
@@ -913,14 +940,14 @@ module {:extern "DCOMP"} DCOMP {
           readIdents := {};
         }
         case Print(e) => {
-          var printedExpr, isOwned, _, recIdents := GenExpr(e, params, false);
+          var printedExpr, isOwned, _, recIdents := GenExpr(e, selfIdent, params, false);
           generated := "print!(\"{}\", ::dafny_runtime::DafnyPrintWrapper(" + (if isOwned then "&" else "") + printedExpr + "));";
           readIdents := recIdents;
         }
       }
     }
 
-    static method GenExpr(e: Expression, params: seq<string>, mustOwn: bool) returns (s: string, isOwned: bool, isErased: bool, readIdents: set<string>)
+    static method GenExpr(e: Expression, selfIdent: Optional<string>, params: seq<string>, mustOwn: bool) returns (s: string, isOwned: bool, isErased: bool, readIdents: set<string>)
       ensures mustOwn ==> isOwned
       decreases e {
       match e {
@@ -1020,7 +1047,7 @@ module {:extern "DCOMP"} DCOMP {
 
           var allErased := true;
           while i < |values| {
-            var _, _, isErased, _ := GenExpr(values[i], params, true);
+            var _, _, isErased, _ := GenExpr(values[i], selfIdent, params, true);
             allErased := allErased && isErased;
             i := i + 1;
           }
@@ -1031,7 +1058,7 @@ module {:extern "DCOMP"} DCOMP {
               s := s + " ";
             }
 
-            var recursiveGen, _, isErased, recIdents := GenExpr(values[i], params, true);
+            var recursiveGen, _, isErased, recIdents := GenExpr(values[i], selfIdent, params, true);
             if isErased && !allErased {
               recursiveGen := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + recursiveGen + ")";
             }
@@ -1055,7 +1082,7 @@ module {:extern "DCOMP"} DCOMP {
               s := s + ", ";
             }
 
-            var recursiveGen, _, isErased, recIdents := GenExpr(args[i], params, true);
+            var recursiveGen, _, isErased, recIdents := GenExpr(args[i], selfIdent, params, true);
             if isErased {
               recursiveGen := "::dafny_runtime::DafnyUnerasable::<_>::unerase_owned(" + recursiveGen + ")";
             }
@@ -1073,7 +1100,7 @@ module {:extern "DCOMP"} DCOMP {
           s := "::std::default::Default::default()";
           readIdents := {};
           while i >= 0 {
-            var recursiveGen, _, isErased, recIdents := GenExpr(dims[i], params, true);
+            var recursiveGen, _, isErased, recIdents := GenExpr(dims[i], selfIdent, params, true);
             if !isErased {
               recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")";
             }
@@ -1101,7 +1128,7 @@ module {:extern "DCOMP"} DCOMP {
             }
 
             if isCo {
-              var recursiveGen, _, isErased, recIdents := GenExpr(value, [], true);
+              var recursiveGen, _, isErased, recIdents := GenExpr(value, selfIdent, [], true);
               if !isErased {
                 recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")";
               }
@@ -1116,7 +1143,7 @@ module {:extern "DCOMP"} DCOMP {
               }
               s := s + "r#" + name + ": ::dafny_runtime::LazyFieldWrapper(::dafny_runtime::Lazy::new(::std::boxed::Box::new({\n" + allReadCloned + "move || (" + recursiveGen + ")})))";
             } else {
-              var recursiveGen, _, isErased, recIdents := GenExpr(value, params, true);
+              var recursiveGen, _, isErased, recIdents := GenExpr(value, selfIdent, params, true);
               if !isErased {
                 recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")";
               }
@@ -1133,16 +1160,38 @@ module {:extern "DCOMP"} DCOMP {
         }
         case Convert(expr, fromTpe, toTpe) => {
           if fromTpe == toTpe {
-            var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, params, mustOwn);
+            var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, selfIdent, params, mustOwn);
             s := recursiveGen;
             isOwned := recOwned;
             isErased := recErased;
             readIdents := recIdents;
           } else {
             match (fromTpe, toTpe) {
+              case (Nullable(_), _) => {
+                var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, selfIdent, params, mustOwn);
+                if !recOwned {
+                  recursiveGen := recursiveGen + ".as_ref()";
+                }
+
+                s := recursiveGen + ".unwrap()";
+                isOwned := recOwned;
+                isErased := recErased;
+                readIdents := recIdents;
+              }
+              case (_, Nullable(_)) => {
+                var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, selfIdent, params, mustOwn);
+                if !recOwned {
+                  recursiveGen := recursiveGen + ".clone()";
+                }
+
+                s := "Some(" + recursiveGen + ")";
+                isOwned := true;
+                isErased := recErased;
+                readIdents := recIdents;
+              }
               case (_, Path(_, _, Newtype(b))) => {
                 if fromTpe == b {
-                  var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, params, mustOwn);
+                  var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, selfIdent, params, mustOwn);
 
                   var rhsType := GenType(toTpe, true, false);
 
@@ -1153,12 +1202,12 @@ module {:extern "DCOMP"} DCOMP {
                   readIdents := recIdents;
                 } else {
                   assume {:axiom} Convert(Convert(expr, fromTpe, b), b, toTpe) < e; // make termination go through
-                  s, isOwned, isErased, readIdents := GenExpr(Convert(Convert(expr, fromTpe, b), b, toTpe), params, mustOwn);
+                  s, isOwned, isErased, readIdents := GenExpr(Convert(Convert(expr, fromTpe, b), b, toTpe), selfIdent, params, mustOwn);
                 }
               }
               case (Path(_, _, Newtype(b)), _) => {
                 if b == toTpe {
-                  var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, params, mustOwn);
+                  var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, selfIdent, params, mustOwn);
                   var uneraseFn := if recOwned then "erase_owned" else "erase";
                   s := "::dafny_runtime::DafnyErasable::" + uneraseFn + "(" + recursiveGen + ")";
                   isOwned := recOwned;
@@ -1166,18 +1215,18 @@ module {:extern "DCOMP"} DCOMP {
                   readIdents := recIdents;
                 } else {
                   assume {:axiom} Convert(Convert(expr, fromTpe, b), b, toTpe) < e; // make termination go through
-                  s, isOwned, isErased, readIdents := GenExpr(Convert(Convert(expr, fromTpe, b), b, toTpe), params, mustOwn);
+                  s, isOwned, isErased, readIdents := GenExpr(Convert(Convert(expr, fromTpe, b), b, toTpe), selfIdent, params, mustOwn);
                 }
               }
               case (Primitive(Int), Primitive(Real)) => {
-                var recursiveGen, _, _, recIdents := GenExpr(expr, params, true);
+                var recursiveGen, _, _, recIdents := GenExpr(expr, selfIdent, params, true);
                 s := "::dafny_runtime::BigRational::from_integer(" + recursiveGen + ")";
                 isOwned := true;
                 isErased := true;
                 readIdents := recIdents;
               }
               case (Primitive(Real), Primitive(Int)) => {
-                var recursiveGen, _, _, recIdents := GenExpr(expr, params, false);
+                var recursiveGen, _, _, recIdents := GenExpr(expr, selfIdent, params, false);
                 s := "::dafny_runtime::dafny_rational_to_int(" + recursiveGen + ")";
                 isOwned := true;
                 isErased := true;
@@ -1185,7 +1234,7 @@ module {:extern "DCOMP"} DCOMP {
               }
               case (Primitive(Int), Passthrough(_)) => {
                 var rhsType := GenType(toTpe, true, false);
-                var recursiveGen, _, _, recIdents := GenExpr(expr, params, true);
+                var recursiveGen, _, _, recIdents := GenExpr(expr, selfIdent, params, true);
                 s := "<" + rhsType + " as ::dafny_runtime::NumCast>::from(" + recursiveGen + ").unwrap()";
                 isOwned := true;
                 isErased := true;
@@ -1193,7 +1242,7 @@ module {:extern "DCOMP"} DCOMP {
               }
               case (Passthrough(_), Primitive(Int)) => {
                 var rhsType := GenType(fromTpe, true, false);
-                var recursiveGen, _, _, recIdents := GenExpr(expr, params, true);
+                var recursiveGen, _, _, recIdents := GenExpr(expr, selfIdent, params, true);
                 s := "::dafny_runtime::BigInt::from(" + recursiveGen + ")";
                 isOwned := true;
                 isErased := true;
@@ -1201,7 +1250,7 @@ module {:extern "DCOMP"} DCOMP {
               }
               case (Primitive(Int), Primitive(Char)) => {
                 var rhsType := GenType(toTpe, true, false);
-                var recursiveGen, _, _, recIdents := GenExpr(expr, params, true);
+                var recursiveGen, _, _, recIdents := GenExpr(expr, selfIdent, params, true);
                 s := "char::from_u32(<u32 as ::dafny_runtime::NumCast>::from(" + recursiveGen + ").unwrap()).unwrap()";
                 isOwned := true;
                 isErased := true;
@@ -1209,14 +1258,14 @@ module {:extern "DCOMP"} DCOMP {
               }
               case (Primitive(Char), Primitive(Int)) => {
                 var rhsType := GenType(fromTpe, true, false);
-                var recursiveGen, _, _, recIdents := GenExpr(expr, params, true);
+                var recursiveGen, _, _, recIdents := GenExpr(expr, selfIdent, params, true);
                 s := "::dafny_runtime::BigInt::from(" + recursiveGen + " as u32)";
                 isOwned := true;
                 isErased := true;
                 readIdents := recIdents;
               }
               case (Passthrough(_), Passthrough(_)) => {
-                var recursiveGen, _, _, recIdents := GenExpr(expr, params, true);
+                var recursiveGen, _, _, recIdents := GenExpr(expr, selfIdent, params, true);
                 var toTpeGen := GenType(toTpe, true, false);
 
                 s := "((" + recursiveGen + ") as " + toTpeGen + ")";
@@ -1226,7 +1275,7 @@ module {:extern "DCOMP"} DCOMP {
                 readIdents := recIdents;
               }
               case _ => {
-                var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, params, mustOwn);
+                var recursiveGen, recOwned, recErased, recIdents := GenExpr(expr, selfIdent, params, mustOwn);
                 s := "(" + recursiveGen + "/* conversion not yet implemented */)";
                 isOwned := recOwned;
                 isErased := recErased;
@@ -1241,7 +1290,7 @@ module {:extern "DCOMP"} DCOMP {
           var i := 0;
           var allErased := true;
           while i < |exprs| {
-            var recursiveGen, _, isErased, recIdents := GenExpr(exprs[i], params, true);
+            var recursiveGen, _, isErased, recIdents := GenExpr(exprs[i], selfIdent, params, true);
             allErased := allErased && isErased;
 
             generatedValues := generatedValues + [(recursiveGen, isErased)];
@@ -1275,7 +1324,7 @@ module {:extern "DCOMP"} DCOMP {
           var i := 0;
           var allErased := true;
           while i < |exprs| {
-            var recursiveGen, _, isErased, recIdents := GenExpr(exprs[i], params, true);
+            var recursiveGen, _, isErased, recIdents := GenExpr(exprs[i], selfIdent, params, true);
             allErased := allErased && isErased;
 
             generatedValues := generatedValues + [(recursiveGen, isErased)];
@@ -1304,26 +1353,40 @@ module {:extern "DCOMP"} DCOMP {
           isErased := true;
         }
         case This() => {
-          if mustOwn {
-            s := "self.clone()";
-            isOwned := true;
-          } else {
-            s := "self";
-            isOwned := false;
-          }
+          match selfIdent {
+            case Some(id) => {
+              if mustOwn {
+                s := id + ".clone()";
+                isOwned := true;
+              } else {
+                if id == "self" {
+                  s := "self";
+                } else {
+                  s := "&" + id;
+                }
+                isOwned := false;
+              }
 
-          readIdents := {"self"};
-          isErased := false;
+              readIdents := {id};
+              isErased := false;
+            }
+            case None => {
+              s := "panic!(\"this outside of a method\")";
+              isOwned := true;
+              readIdents := {};
+              isErased := true;
+            }
+          }
         }
         case Ite(cond, t, f) => {
-          var condString, _, condErased, recIdentsCond := GenExpr(cond, params, true);
+          var condString, _, condErased, recIdentsCond := GenExpr(cond, selfIdent, params, true);
           if !condErased {
             condString := "::dafny_runtime::DafnyErasable::erase_owned(" + condString + ")";
           }
 
-          var _, tHasToBeOwned, _, _ := GenExpr(t, params, mustOwn); // check if t has to be owned even if not requested
-          var fString, fOwned, fErased, recIdentsF := GenExpr(f, params, tHasToBeOwned);
-          var tString, _, tErased, recIdentsT := GenExpr(t, params, fOwned); // there's a chance that f forced ownership
+          var _, tHasToBeOwned, _, _ := GenExpr(t, selfIdent, params, mustOwn); // check if t has to be owned even if not requested
+          var fString, fOwned, fErased, recIdentsF := GenExpr(f, selfIdent, params, tHasToBeOwned);
+          var tString, _, tErased, recIdentsT := GenExpr(t, selfIdent, params, fOwned); // there's a chance that f forced ownership
 
           if !fErased || !tErased {
             if fErased {
@@ -1341,7 +1404,7 @@ module {:extern "DCOMP"} DCOMP {
           isErased := fErased || tErased;
         }
         case UnOp(Not, e) => {
-          var recursiveGen, _, recErased, recIdents := GenExpr(e, params, true);
+          var recursiveGen, _, recErased, recIdents := GenExpr(e, selfIdent, params, true);
           if !recErased {
             recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")";
           }
@@ -1352,7 +1415,7 @@ module {:extern "DCOMP"} DCOMP {
           isErased := true;
         }
         case UnOp(BitwiseNot, e) => {
-          var recursiveGen, _, recErased, recIdents := GenExpr(e, params, true);
+          var recursiveGen, _, recErased, recIdents := GenExpr(e, selfIdent, params, true);
           if !recErased {
             recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")";
           }
@@ -1363,7 +1426,7 @@ module {:extern "DCOMP"} DCOMP {
           isErased := true;
         }
         case UnOp(Cardinality, e) => {
-          var recursiveGen, recOwned, recErased, recIdents := GenExpr(e, params, false);
+          var recursiveGen, recOwned, recErased, recIdents := GenExpr(e, selfIdent, params, false);
           if !recErased {
             var eraseFn := if recOwned then "erase_owned" else "erase";
             recursiveGen := "::dafny_runtime::DafnyErasable::" + eraseFn + "(" + recursiveGen + ")";
@@ -1375,8 +1438,8 @@ module {:extern "DCOMP"} DCOMP {
           isErased := true;
         }
         case BinOp(op, l, r) => {
-          var left, _, leftErased, recIdentsL := GenExpr(l, params, true);
-          var right, _, rightErased, recIdentsR := GenExpr(r, params, true);
+          var left, _, leftErased, recIdentsL := GenExpr(l, selfIdent, params, true);
+          var right, _, rightErased, recIdentsR := GenExpr(r, selfIdent, params, true);
 
           if !leftErased {
             left := "::dafny_runtime::DafnyErasable::erase_owned(" + left + ")";
@@ -1399,7 +1462,7 @@ module {:extern "DCOMP"} DCOMP {
           isErased := true;
         }
         case ArrayLen(expr) => {
-          var recursiveGen, _, recErased, recIdents := GenExpr(expr, params, true);
+          var recursiveGen, _, recErased, recIdents := GenExpr(expr, selfIdent, params, true);
           if !recErased {
             recursiveGen := "::dafny_runtime::DafnyErasable::erase_owned(" + recursiveGen + ")";
           }
@@ -1410,7 +1473,7 @@ module {:extern "DCOMP"} DCOMP {
           isErased := true;
         }
         case SelectFn(on, field, isDatatype, isStatic, arity) => {
-          var onString, onOwned, _, recIdents := GenExpr(on, params, false);
+          var onString, onOwned, _, recIdents := GenExpr(on, selfIdent, params, false);
 
           if isStatic {
             s := onString + "::" + field;
@@ -1438,8 +1501,17 @@ module {:extern "DCOMP"} DCOMP {
           isErased := true;
           readIdents := recIdents;
         }
+        case Select(Companion(c), field, isConstant, isDatatype) => {
+          var onString, onOwned, onErased, recIdents := GenExpr(Companion(c), selfIdent, params, false);
+
+          s := onString + "::r#" + field + "()";
+
+          isOwned := true;
+          isErased := false;
+          readIdents := recIdents;
+        }
         case Select(on, field, isConstant, isDatatype) => {
-          var onString, onOwned, onErased, recIdents := GenExpr(on, params, false);
+          var onString, onOwned, onErased, recIdents := GenExpr(on, selfIdent, params, false);
           if !onErased {
             var eraseFn := if onOwned then "erase_owned" else "erase";
             onString := "::dafny_runtime::DafnyErasable::" + eraseFn + "(" + onString + ")";
@@ -1467,13 +1539,13 @@ module {:extern "DCOMP"} DCOMP {
           readIdents := recIdents;
         }
         case Index(on, idx) => {
-          var onString, onOwned, onErased, recIdents := GenExpr(on, params, false);
+          var onString, onOwned, onErased, recIdents := GenExpr(on, selfIdent, params, false);
           if !onErased {
             var eraseFn := if onOwned then "erase_owned" else "erase";
             onString := "::dafny_runtime::DafnyErasable::" + eraseFn + "(" + onString + ")";
           }
 
-          var idxString, _, idxErased, recIdentsIdx := GenExpr(idx, params, true);
+          var idxString, _, idxErased, recIdentsIdx := GenExpr(idx, selfIdent, params, true);
           if !idxErased {
             idxString := "::dafny_runtime::DafnyErasable::erase_owned(" + idxString + ")";
           }
@@ -1483,6 +1555,7 @@ module {:extern "DCOMP"} DCOMP {
             s := "(" + s + ").clone()";
             isOwned := true;
           } else {
+            s := "(&" + s + ")";
             isOwned := false;
           }
 
@@ -1490,7 +1563,7 @@ module {:extern "DCOMP"} DCOMP {
           readIdents := recIdents + recIdentsIdx;
         }
         case TupleSelect(on, idx) => {
-          var onString, _, tupErased, recIdents := GenExpr(on, params, false);
+          var onString, _, tupErased, recIdents := GenExpr(on, selfIdent, params, false);
           s := "(" + onString + ")." + natToString(idx);
           if mustOwn {
             s := "(" + s + ")" + ".clone()";
@@ -1529,7 +1602,7 @@ module {:extern "DCOMP"} DCOMP {
               argString := argString + ", ";
             }
 
-            var argExpr, isOwned, argErased, argIdents := GenExpr(args[i], params, false);
+            var argExpr, isOwned, argErased, argIdents := GenExpr(args[i], selfIdent, params, false);
             if isOwned {
               argExpr := "&" + argExpr;
             }
@@ -1540,7 +1613,7 @@ module {:extern "DCOMP"} DCOMP {
             i := i + 1;
           }
 
-          var enclosingString, _, _, recIdents := GenExpr(on, params, false);
+          var enclosingString, _, _, recIdents := GenExpr(on, selfIdent, params, false);
           readIdents := readIdents + recIdents;
           match on {
             case Companion(_) => {
@@ -1563,7 +1636,7 @@ module {:extern "DCOMP"} DCOMP {
             i := i + 1;
           }
 
-          var recursiveGen, recIdents := GenStmts(body, paramNames, true, "");
+          var recursiveGen, recIdents := GenStmts(body, None, paramNames, true, "");
           readIdents := {};
           var allReadCloned := "";
           while recIdents != {} decreases recIdents {
@@ -1597,7 +1670,7 @@ module {:extern "DCOMP"} DCOMP {
           isErased := true;
         }
         case IIFE(name, tpe, value, iifeBody) => {
-          var valueGen, valueOwned, valueErased, recIdents := GenExpr(value, params, false);
+          var valueGen, valueOwned, valueErased, recIdents := GenExpr(value, selfIdent, params, false);
           if valueErased {
             var eraseFn := if valueOwned then "unerase_owned" else "unerase";
             valueGen := "::dafny_runtime::DafnyUnerasable::<_>::" + eraseFn + "(" + valueGen + ")";
@@ -1605,7 +1678,7 @@ module {:extern "DCOMP"} DCOMP {
 
           readIdents := recIdents;
           var valueTypeGen := GenType(tpe, false, true);
-          var bodyGen, bodyOwned, bodyErased, bodyIdents := GenExpr(iifeBody, params + if valueOwned then [] else [name.id], mustOwn);
+          var bodyGen, bodyOwned, bodyErased, bodyIdents := GenExpr(iifeBody, selfIdent, params + if valueOwned then [] else [name.id], mustOwn);
           readIdents := readIdents + bodyIdents;
 
           var eraseFn := if valueOwned then "unerase_owned" else "unerase";
@@ -1615,7 +1688,7 @@ module {:extern "DCOMP"} DCOMP {
           isErased := bodyErased;
         }
         case Apply(func, args) => {
-          var funcString, _, funcErased, recIdents := GenExpr(func, params, false);
+          var funcString, _, funcErased, recIdents := GenExpr(func, selfIdent, params, false);
           readIdents := recIdents;
 
           var argString := "";
@@ -1625,7 +1698,7 @@ module {:extern "DCOMP"} DCOMP {
               argString := argString + ", ";
             }
 
-            var argExpr, isOwned, argErased, argIdents := GenExpr(args[i], params, false);
+            var argExpr, isOwned, argErased, argIdents := GenExpr(args[i], selfIdent, params, false);
             if isOwned {
               argExpr := "&" + argExpr;
             }
@@ -1641,7 +1714,7 @@ module {:extern "DCOMP"} DCOMP {
           isErased := false;
         }
         case TypeTest(on, dType, variant) => {
-          var exprGen, _, exprErased, recIdents := GenExpr(on, params, false);
+          var exprGen, _, exprErased, recIdents := GenExpr(on, selfIdent, params, false);
           var dTypePath := GenPath(dType);
           s := "matches!(" + exprGen + ".as_ref(), " + dTypePath + "::r#" + variant + "{ .. })";
           isOwned := true;
diff --git a/Source/DafnyCore/Compilers/SinglePassCompiler.cs b/Source/DafnyCore/Compilers/SinglePassCompiler.cs
index f7dbb5be29a..761e038057b 100644
--- a/Source/DafnyCore/Compilers/SinglePassCompiler.cs
+++ b/Source/DafnyCore/Compilers/SinglePassCompiler.cs
@@ -334,7 +334,7 @@ protected interface IClassWriter {
     /// </summary>
     protected virtual void DeclareLocalVar(string name, Type/*?*/ type, IToken/*?*/ tok, Expression rhs, bool inLetExprBody, ConcreteSyntaxTree wr) {
       var wStmts = wr.Fork();
-      var w = DeclareLocalVar(name, type, tok, wr);
+      var w = DeclareLocalVar(name, type ?? rhs.Type, tok, wr);
       EmitExpr(rhs, inLetExprBody, w, wStmts);
     }
 
@@ -394,7 +394,7 @@ protected interface IClassWriter {
       wRhs = w.Fork();
       EndStmt(wr);
     }
-    protected void EmitAssignment(string lhs, Type/*?*/ lhsType, string rhs, Type/*?*/ rhsType, ConcreteSyntaxTree wr) {
+    protected virtual void EmitAssignment(string lhs, Type/*?*/ lhsType, string rhs, Type/*?*/ rhsType, ConcreteSyntaxTree wr) {
       EmitAssignment(out var wLhs, lhsType, out var wRhs, rhsType, wr);
       wLhs.Write(lhs);
       wRhs.Write(rhs);
@@ -2803,21 +2803,29 @@ void TrCasePatternOpt<VT>(CasePattern<VT> pat, Expression rhs, Action<ConcreteSy
         // Now, assign to the formals
         int n = 0;
         if (!e.Function.IsStatic) {
-          wr.Write("_this = ");
-          ConcreteSyntaxTree wRHS;
+          ConcreteSyntaxTree wRHS = EmitAssignment(IdentLvalue("_this"), null, null, wr, e.tok);
           if (thisContext == null) {
             wRHS = wr;
           } else {
             var instantiatedType = e.Receiver.Type.Subst(thisContext.ParentFormalTypeParametersToActuals);
-            wRHS = EmitCoercionIfNecessary(instantiatedType, UserDefinedType.FromTopLevelDecl(e.tok, thisContext), e.tok, wr);
+
+            var contextType = UserDefinedType.FromTopLevelDecl(e.tok, thisContext);
+            if (contextType.ResolvedClass is ClassLikeDecl { NonNullTypeDecl: { } } cls) {
+              contextType = UserDefinedType.FromTopLevelDecl(e.tok, cls.NonNullTypeDecl);
+            }
+
+            wRHS = EmitCoercionIfNecessary(instantiatedType, contextType, e.tok, wRHS);
           }
-          wRHS.Write(inTmps[n]);
+          EmitIdentifier(inTmps[n], wRHS);
           EndStmt(wr);
           n++;
         }
         foreach (var p in e.Function.Formals) {
           if (!p.IsGhost) {
-            EmitAssignment(IdName(p), p.Type, inTmps[n], inTypes[n], wr);
+            EmitIdentifier(
+              inTmps[n],
+              EmitAssignment(IdentLvalue(IdName(p)), p.Type, inTypes[n], wr, e.tok)
+            );
             n++;
           }
         }
@@ -2854,8 +2862,7 @@ void TrCasePatternOpt<VT>(CasePattern<VT> pat, Expression rhs, Action<ConcreteSy
         }
 
         var wStmts = wr.Fork();
-        EmitAssignment(out var wLhs, enclosingFunction.ResultType, out var wRhs, enclosingFunction.ResultType, wr);
-        EmitExpr(acc, false, wLhs, wStmts);
+        var wRhs = EmitAssignment(VariableLvalue(accumulatorVar), enclosingFunction.ResultType, enclosingFunction.ResultType, wr, expr.tok);
         EmitExpr(rhs, false, wRhs, wStmts);
         TrExprOpt(tailTerm, resultType, wr, accumulatorVar);
 
@@ -4713,21 +4720,29 @@ private class ArrayLvalueImpl : ILvalue {
       // Now, assign to the formals
       int n = 0;
       if (!method.IsStatic) {
-        wr.Write("_this = ");
-        ConcreteSyntaxTree wRHS;
+        ConcreteSyntaxTree wRHS = EmitAssignment(IdentLvalue("_this"), null, null, wr, tok);
         if (thisContext == null) {
           wRHS = wr;
         } else {
           var instantiatedType = receiver.Type.Subst(thisContext.ParentFormalTypeParametersToActuals);
-          wRHS = EmitCoercionIfNecessary(instantiatedType, UserDefinedType.FromTopLevelDecl(tok, thisContext), tok, wr);
+
+          var contextType = UserDefinedType.FromTopLevelDecl(tok, thisContext);
+          if (contextType.ResolvedClass is ClassLikeDecl { NonNullTypeDecl: { } } cls) {
+            contextType = UserDefinedType.FromTopLevelDecl(tok, cls.NonNullTypeDecl);
+          }
+
+          wRHS = EmitCoercionIfNecessary(instantiatedType, contextType, tok, wRHS);
         }
-        wRHS.Write(inTmps[n]);
+        EmitIdentifier(inTmps[n], wRHS);
         EndStmt(wr);
         n++;
       }
       foreach (var p in method.Ins) {
         if (!p.IsGhost) {
-          EmitAssignment(IdName(p), p.Type, inTmps[n], inTypes[n], wr);
+          EmitIdentifier(
+            inTmps[n],
+            EmitAssignment(IdentLvalue(IdName(p)), p.Type, inTypes[n], wr, tok)
+          );
           n++;
         }
       }
@@ -4883,7 +4898,12 @@ private class ArrayLvalueImpl : ILvalue {
       } else if (expr is ThisExpr) {
         if (thisContext != null) {
           var instantiatedType = expr.Type.Subst(thisContext.ParentFormalTypeParametersToActuals);
-          wr = EmitCoercionIfNecessary(UserDefinedType.FromTopLevelDecl(expr.tok, thisContext), instantiatedType, expr.tok, wr);
+          var contextType = UserDefinedType.FromTopLevelDecl(expr.tok, thisContext);
+          if (contextType.ResolvedClass is ClassLikeDecl { NonNullTypeDecl: { } } cls) {
+            contextType = UserDefinedType.FromTopLevelDecl(expr.tok, cls.NonNullTypeDecl);
+          }
+
+          wr = EmitCoercionIfNecessary(contextType, instantiatedType, expr.tok, wr);
         }
         EmitThis(wr);
 
@@ -4953,7 +4973,7 @@ private class ArrayLvalueImpl : ILvalue {
               // need to eta-expand wrap the receiver
               var etaReceiver = ProtectedFreshId("_eta_this");
               wr = CreateIIFE_ExprBody(etaReceiver, e.Obj.Type, e.Obj.tok, e.Obj, inLetExprBody, e.Type.Subst(typeMap), e.tok, wr, ref wStmts);
-              obj = w => w.Write(etaReceiver);
+              obj = w => EmitIdentifier(etaReceiver, w);
             } else {
               obj = w => EmitExpr(e.Obj, inLetExprBody, w, wStmts);
             }
@@ -5233,9 +5253,11 @@ private class ArrayLvalueImpl : ILvalue {
         //   }
         // }))(src)
 
+        EmitLambdaApply(wr, out var wLambda, out var wArg);
+
         string source = ProtectedFreshId("_source");
         ConcreteSyntaxTree w;
-        w = CreateLambda(new List<Type>() { e.Source.Type }, e.tok, new List<string>() { source }, e.Type, wr, wStmts);
+        w = CreateLambda(new List<Type>() { e.Source.Type }, e.tok, new List<string>() { source }, e.Type, wLambda, wStmts);
 
         if (e.Cases.Count == 0) {
           // the verifier would have proved we never get here; still, we need some code that will compile
@@ -5250,8 +5272,7 @@ private class ArrayLvalueImpl : ILvalue {
           }
         }
         // We end with applying the source expression to the delegate we just built
-        wr.Write(LambdaExecute);
-        TrParenExpr(e.Source, wr, inLetExprBody, wStmts);
+        EmitExpr(e.Source, inLetExprBody, wArg, wStmts);
 
       } else if (expr is QuantifierExpr) {
         var e = (QuantifierExpr)expr;
@@ -5415,6 +5436,12 @@ private class ArrayLvalueImpl : ILvalue {
       }
     }
 
+    protected virtual void EmitLambdaApply(ConcreteSyntaxTree wr, out ConcreteSyntaxTree wLambda, out ConcreteSyntaxTree wArg) {
+      wLambda = wr.Fork();
+      wr.Write(LambdaExecute);
+      wArg = wr.ForkInParens();
+    }
+
     protected void WriteTypeDescriptors(TopLevelDecl decl, List<Type> typeArguments, ConcreteSyntaxTree wrArgumentList, ref string sep) {
       Contract.Requires(decl.TypeArgs.Count == typeArguments.Count);
       var typeParameters = decl.TypeArgs;
diff --git a/Source/DafnyCore/GeneratedFromDafnyRust.cs b/Source/DafnyCore/GeneratedFromDafnyRust.cs
index 1f1910fc352..4b391d07e69 100644
--- a/Source/DafnyCore/GeneratedFromDafnyRust.cs
+++ b/Source/DafnyCore/GeneratedFromDafnyRust.cs
@@ -289,6 +289,7 @@ public class ModuleItem_Datatype : ModuleItem {
 
   public interface _IType {
     bool is_Path { get; }
+    bool is_Nullable { get; }
     bool is_Tuple { get; }
     bool is_Array { get; }
     bool is_Seq { get; }
@@ -302,6 +303,7 @@ public interface _IType {
     Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> dtor_Path_a0 { get; }
     Dafny.ISequence<DAST._IType> dtor_typeArgs { get; }
     DAST._IResolvedType dtor_resolved { get; }
+    DAST._IType dtor_Nullable_a0 { get; }
     Dafny.ISequence<DAST._IType> dtor_Tuple_a0 { get; }
     DAST._IType dtor_element { get; }
     DAST._IType dtor_key { get; }
@@ -327,6 +329,9 @@ public abstract class Type : _IType {
     public static _IType create_Path(Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _a0, Dafny.ISequence<DAST._IType> typeArgs, DAST._IResolvedType resolved) {
       return new Type_Path(_a0, typeArgs, resolved);
     }
+    public static _IType create_Nullable(DAST._IType _a0) {
+      return new Type_Nullable(_a0);
+    }
     public static _IType create_Tuple(Dafny.ISequence<DAST._IType> _a0) {
       return new Type_Tuple(_a0);
     }
@@ -358,6 +363,7 @@ public abstract class Type : _IType {
       return new Type_TypeArg(_a0);
     }
     public bool is_Path { get { return this is Type_Path; } }
+    public bool is_Nullable { get { return this is Type_Nullable; } }
     public bool is_Tuple { get { return this is Type_Tuple; } }
     public bool is_Array { get { return this is Type_Array; } }
     public bool is_Seq { get { return this is Type_Seq; } }
@@ -386,6 +392,12 @@ public abstract class Type : _IType {
         return ((Type_Path)d)._resolved;
       }
     }
+    public DAST._IType dtor_Nullable_a0 {
+      get {
+        var d = this;
+        return ((Type_Nullable)d)._a0;
+      }
+    }
     public Dafny.ISequence<DAST._IType> dtor_Tuple_a0 {
       get {
         var d = this;
@@ -482,6 +494,33 @@ public class Type_Path : Type {
       return s;
     }
   }
+  public class Type_Nullable : Type {
+    public readonly DAST._IType _a0;
+    public Type_Nullable(DAST._IType _a0) : base() {
+      this._a0 = _a0;
+    }
+    public override _IType DowncastClone() {
+      if (this is _IType dt) { return dt; }
+      return new Type_Nullable(_a0);
+    }
+    public override bool Equals(object other) {
+      var oth = other as DAST.Type_Nullable;
+      return oth != null && object.Equals(this._a0, oth._a0);
+    }
+    public override int GetHashCode() {
+      ulong hash = 5381;
+      hash = ((hash << 5) + hash) + 1;
+      hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._a0));
+      return (int)hash;
+    }
+    public override string ToString() {
+      string s = "DAST.Type.Nullable";
+      s += "(";
+      s += Dafny.Helpers.ToString(this._a0);
+      s += ")";
+      return s;
+    }
+  }
   public class Type_Tuple : Type {
     public readonly Dafny.ISequence<DAST._IType> _a0;
     public Type_Tuple(Dafny.ISequence<DAST._IType> _a0) : base() {
@@ -497,7 +536,7 @@ public class Type_Tuple : Type {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 1;
+      hash = ((hash << 5) + hash) + 2;
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._a0));
       return (int)hash;
     }
@@ -524,7 +563,7 @@ public class Type_Array : Type {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 2;
+      hash = ((hash << 5) + hash) + 3;
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._element));
       return (int)hash;
     }
@@ -551,7 +590,7 @@ public class Type_Seq : Type {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 3;
+      hash = ((hash << 5) + hash) + 4;
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._element));
       return (int)hash;
     }
@@ -578,7 +617,7 @@ public class Type_Set : Type {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 4;
+      hash = ((hash << 5) + hash) + 5;
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._element));
       return (int)hash;
     }
@@ -605,7 +644,7 @@ public class Type_Multiset : Type {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 5;
+      hash = ((hash << 5) + hash) + 6;
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._element));
       return (int)hash;
     }
@@ -634,7 +673,7 @@ public class Type_Map : Type {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 6;
+      hash = ((hash << 5) + hash) + 7;
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._key));
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._value));
       return (int)hash;
@@ -666,7 +705,7 @@ public class Type_Arrow : Type {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 7;
+      hash = ((hash << 5) + hash) + 8;
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._args));
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._result));
       return (int)hash;
@@ -696,7 +735,7 @@ public class Type_Primitive : Type {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 8;
+      hash = ((hash << 5) + hash) + 9;
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._a0));
       return (int)hash;
     }
@@ -723,7 +762,7 @@ public class Type_Passthrough : Type {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 9;
+      hash = ((hash << 5) + hash) + 10;
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._a0));
       return (int)hash;
     }
@@ -750,7 +789,7 @@ public class Type_TypeArg : Type {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 10;
+      hash = ((hash << 5) + hash) + 11;
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._a0));
       return (int)hash;
     }
@@ -1969,6 +2008,8 @@ public interface _IStatement {
     bool is_Call { get; }
     bool is_Return { get; }
     bool is_EarlyReturn { get; }
+    bool is_TailRecursive { get; }
+    bool is_JumpTailCallStart { get; }
     bool is_Halt { get; }
     bool is_Print { get; }
     Dafny.ISequence<Dafny.Rune> dtor_name { get; }
@@ -2020,6 +2061,12 @@ public abstract class Statement : _IStatement {
     public static _IStatement create_EarlyReturn() {
       return new Statement_EarlyReturn();
     }
+    public static _IStatement create_TailRecursive(Dafny.ISequence<DAST._IStatement> body) {
+      return new Statement_TailRecursive(body);
+    }
+    public static _IStatement create_JumpTailCallStart() {
+      return new Statement_JumpTailCallStart();
+    }
     public static _IStatement create_Halt() {
       return new Statement_Halt();
     }
@@ -2033,6 +2080,8 @@ public abstract class Statement : _IStatement {
     public bool is_Call { get { return this is Statement_Call; } }
     public bool is_Return { get { return this is Statement_Return; } }
     public bool is_EarlyReturn { get { return this is Statement_EarlyReturn; } }
+    public bool is_TailRecursive { get { return this is Statement_TailRecursive; } }
+    public bool is_JumpTailCallStart { get { return this is Statement_JumpTailCallStart; } }
     public bool is_Halt { get { return this is Statement_Halt; } }
     public bool is_Print { get { return this is Statement_Print; } }
     public Dafny.ISequence<Dafny.Rune> dtor_name {
@@ -2088,7 +2137,8 @@ public abstract class Statement : _IStatement {
     public Dafny.ISequence<DAST._IStatement> dtor_body {
       get {
         var d = this;
-        return ((Statement_While)d)._body;
+        if (d is Statement_While) { return ((Statement_While)d)._body; }
+        return ((Statement_TailRecursive)d)._body;
       }
     }
     public DAST._IExpression dtor_on {
@@ -2362,6 +2412,54 @@ public class Statement_EarlyReturn : Statement {
       return s;
     }
   }
+  public class Statement_TailRecursive : Statement {
+    public readonly Dafny.ISequence<DAST._IStatement> _body;
+    public Statement_TailRecursive(Dafny.ISequence<DAST._IStatement> body) : base() {
+      this._body = body;
+    }
+    public override _IStatement DowncastClone() {
+      if (this is _IStatement dt) { return dt; }
+      return new Statement_TailRecursive(_body);
+    }
+    public override bool Equals(object other) {
+      var oth = other as DAST.Statement_TailRecursive;
+      return oth != null && object.Equals(this._body, oth._body);
+    }
+    public override int GetHashCode() {
+      ulong hash = 5381;
+      hash = ((hash << 5) + hash) + 7;
+      hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._body));
+      return (int)hash;
+    }
+    public override string ToString() {
+      string s = "DAST.Statement.TailRecursive";
+      s += "(";
+      s += Dafny.Helpers.ToString(this._body);
+      s += ")";
+      return s;
+    }
+  }
+  public class Statement_JumpTailCallStart : Statement {
+    public Statement_JumpTailCallStart() : base() {
+    }
+    public override _IStatement DowncastClone() {
+      if (this is _IStatement dt) { return dt; }
+      return new Statement_JumpTailCallStart();
+    }
+    public override bool Equals(object other) {
+      var oth = other as DAST.Statement_JumpTailCallStart;
+      return oth != null;
+    }
+    public override int GetHashCode() {
+      ulong hash = 5381;
+      hash = ((hash << 5) + hash) + 8;
+      return (int)hash;
+    }
+    public override string ToString() {
+      string s = "DAST.Statement.JumpTailCallStart";
+      return s;
+    }
+  }
   public class Statement_Halt : Statement {
     public Statement_Halt() : base() {
     }
@@ -2375,7 +2473,7 @@ public class Statement_Halt : Statement {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 7;
+      hash = ((hash << 5) + hash) + 9;
       return (int)hash;
     }
     public override string ToString() {
@@ -2398,7 +2496,7 @@ public class Statement_Print : Statement {
     }
     public override int GetHashCode() {
       ulong hash = 5381;
-      hash = ((hash << 5) + hash) + 8;
+      hash = ((hash << 5) + hash) + 10;
       hash = ((hash << 5) + hash) + ((ulong)Dafny.Helpers.GetHashCode(this._a0));
       return (int)hash;
     }
@@ -4349,7 +4447,7 @@ public partial class COMP {
             bool _out12;
             bool _out13;
             Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out14;
-            DCOMP.COMP.GenExpr(_25_e, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements(), true, out _out11, out _out12, out _out13, out _out14);
+            DCOMP.COMP.GenExpr(_25_e, DAST.Optional<Dafny.ISequence<Dafny.Rune>>.create_None(), Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements(), true, out _out11, out _out12, out _out13, out _out14);
             _26_eStr = _out11;
             _27___v1 = _out12;
             _28___v2 = _out13;
@@ -4425,118 +4523,120 @@ public partial class COMP {
             } else {
               DAST._IType _47___mcc_h11 = _source3.dtor_Newtype_a0;
             }
+          } else if (_source2.is_Nullable) {
+            DAST._IType _48___mcc_h13 = _source2.dtor_Nullable_a0;
           } else if (_source2.is_Tuple) {
-            Dafny.ISequence<DAST._IType> _48___mcc_h13 = _source2.dtor_Tuple_a0;
+            Dafny.ISequence<DAST._IType> _49___mcc_h15 = _source2.dtor_Tuple_a0;
           } else if (_source2.is_Array) {
-            DAST._IType _49___mcc_h15 = _source2.dtor_element;
-          } else if (_source2.is_Seq) {
             DAST._IType _50___mcc_h17 = _source2.dtor_element;
-          } else if (_source2.is_Set) {
+          } else if (_source2.is_Seq) {
             DAST._IType _51___mcc_h19 = _source2.dtor_element;
-          } else if (_source2.is_Multiset) {
+          } else if (_source2.is_Set) {
             DAST._IType _52___mcc_h21 = _source2.dtor_element;
+          } else if (_source2.is_Multiset) {
+            DAST._IType _53___mcc_h23 = _source2.dtor_element;
           } else if (_source2.is_Map) {
-            DAST._IType _53___mcc_h23 = _source2.dtor_key;
-            DAST._IType _54___mcc_h24 = _source2.dtor_value;
+            DAST._IType _54___mcc_h25 = _source2.dtor_key;
+            DAST._IType _55___mcc_h26 = _source2.dtor_value;
           } else if (_source2.is_Arrow) {
-            Dafny.ISequence<DAST._IType> _55___mcc_h27 = _source2.dtor_args;
-            DAST._IType _56___mcc_h28 = _source2.dtor_result;
+            Dafny.ISequence<DAST._IType> _56___mcc_h29 = _source2.dtor_args;
+            DAST._IType _57___mcc_h30 = _source2.dtor_result;
           } else if (_source2.is_Primitive) {
-            DAST._IPrimitive _57___mcc_h31 = _source2.dtor_Primitive_a0;
+            DAST._IPrimitive _58___mcc_h33 = _source2.dtor_Primitive_a0;
           } else if (_source2.is_Passthrough) {
-            Dafny.ISequence<Dafny.Rune> _58___mcc_h33 = _source2.dtor_Passthrough_a0;
+            Dafny.ISequence<Dafny.Rune> _59___mcc_h35 = _source2.dtor_Passthrough_a0;
           } else {
-            Dafny.ISequence<Dafny.Rune> _59___mcc_h35 = _source2.dtor_TypeArg_a0;
+            Dafny.ISequence<Dafny.Rune> _60___mcc_h37 = _source2.dtor_TypeArg_a0;
           }
           _34_i = (_34_i) + (BigInteger.One);
         }
       }
-      Dafny.ISequence<Dafny.Rune> _60_defaultImpl;
-      _60_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _18_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::std::default::Default for r#")), (c).dtor_name), _17_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
-      _60_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(_60_defaultImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn default() -> Self {\n"));
-      _60_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_60_defaultImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::new()\n"));
-      _60_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(_60_defaultImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
-      _60_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(_60_defaultImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
-      Dafny.ISequence<Dafny.Rune> _61_printImpl;
-      _61_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _18_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyPrint for r#")), (c).dtor_name), _17_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn fmt_print(&self, __fmt_print_formatter: &mut ::std::fmt::Formatter, _in_seq: bool) -> std::fmt::Result {\n"));
-      _61_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_61_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("write!(__fmt_print_formatter, \"")), ((c).dtor_enclosingModule)), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".")), (c).dtor_name), (((new BigInteger(((c).dtor_fields).Count)).Sign == 1) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("")))), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\")?;"));
-      BigInteger _62_i;
-      _62_i = BigInteger.Zero;
-      while ((_62_i) < (new BigInteger(((c).dtor_fields).Count))) {
-        DAST._IField _63_field;
-        _63_field = ((c).dtor_fields).Select(_62_i);
-        if ((_62_i).Sign == 1) {
-          _61_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(_61_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nwrite!(__fmt_print_formatter, \", \")?;"));
+      Dafny.ISequence<Dafny.Rune> _61_defaultImpl;
+      _61_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _18_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::std::default::Default for r#")), (c).dtor_name), _17_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
+      _61_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(_61_defaultImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn default() -> Self {\n"));
+      _61_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_61_defaultImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::new()\n"));
+      _61_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(_61_defaultImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
+      _61_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(_61_defaultImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
+      Dafny.ISequence<Dafny.Rune> _62_printImpl;
+      _62_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _18_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyPrint for r#")), (c).dtor_name), _17_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn fmt_print(&self, __fmt_print_formatter: &mut ::std::fmt::Formatter, _in_seq: bool) -> std::fmt::Result {\n"));
+      _62_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_62_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("write!(__fmt_print_formatter, \"")), ((c).dtor_enclosingModule)), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".")), (c).dtor_name), (((new BigInteger(((c).dtor_fields).Count)).Sign == 1) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("")))), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\")?;"));
+      BigInteger _63_i;
+      _63_i = BigInteger.Zero;
+      while ((_63_i) < (new BigInteger(((c).dtor_fields).Count))) {
+        DAST._IField _64_field;
+        _64_field = ((c).dtor_fields).Select(_63_i);
+        if ((_63_i).Sign == 1) {
+          _62_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(_62_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nwrite!(__fmt_print_formatter, \", \")?;"));
         }
-        _61_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_61_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n::dafny_runtime::DafnyPrint::fmt_print(::std::ops::Deref::deref(&(self.r#")), ((_63_field).dtor_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow())), __fmt_print_formatter, false)?;"));
-        _62_i = (_62_i) + (BigInteger.One);
+        _62_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_62_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n::dafny_runtime::DafnyPrint::fmt_print(::std::ops::Deref::deref(&(self.r#")), ((_64_field).dtor_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow())), __fmt_print_formatter, false)?;"));
+        _63_i = (_63_i) + (BigInteger.One);
       }
       if ((new BigInteger(((c).dtor_fields).Count)).Sign == 1) {
-        _61_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(_61_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nwrite!(__fmt_print_formatter, \")\")?;"));
-      }
-      _61_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(_61_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nOk(())\n}\n}\n"));
-      Dafny.ISequence<Dafny.Rune> _64_ptrPartialEqImpl;
-      _64_ptrPartialEqImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _18_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::std::cmp::PartialEq for r#")), (c).dtor_name), _17_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
-      _64_ptrPartialEqImpl = Dafny.Sequence<Dafny.Rune>.Concat(_64_ptrPartialEqImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn eq(&self, other: &Self) -> bool {\n"));
-      _64_ptrPartialEqImpl = Dafny.Sequence<Dafny.Rune>.Concat(_64_ptrPartialEqImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ptr::eq(self, other)"));
-      _64_ptrPartialEqImpl = Dafny.Sequence<Dafny.Rune>.Concat(_64_ptrPartialEqImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}\n}\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _60_defaultImpl), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _61_printImpl), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _64_ptrPartialEqImpl);
+        _62_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(_62_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nwrite!(__fmt_print_formatter, \")\")?;"));
+      }
+      _62_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(_62_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nOk(())\n}\n}\n"));
+      Dafny.ISequence<Dafny.Rune> _65_ptrPartialEqImpl;
+      _65_ptrPartialEqImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _18_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::std::cmp::PartialEq for r#")), (c).dtor_name), _17_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
+      _65_ptrPartialEqImpl = Dafny.Sequence<Dafny.Rune>.Concat(_65_ptrPartialEqImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn eq(&self, other: &Self) -> bool {\n"));
+      _65_ptrPartialEqImpl = Dafny.Sequence<Dafny.Rune>.Concat(_65_ptrPartialEqImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ptr::eq(self, other)"));
+      _65_ptrPartialEqImpl = Dafny.Sequence<Dafny.Rune>.Concat(_65_ptrPartialEqImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}\n}\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _61_defaultImpl), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _62_printImpl), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _65_ptrPartialEqImpl);
       return s;
     }
     public static Dafny.ISequence<Dafny.Rune> GenTrait(DAST._ITrait t, Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> containingPath) {
       Dafny.ISequence<Dafny.Rune> s = Dafny.Sequence<Dafny.Rune>.Empty;
-      Dafny.ISet<DAST._IType> _65_typeParamsSet;
-      _65_typeParamsSet = Dafny.Set<DAST._IType>.FromElements();
-      Dafny.ISequence<Dafny.Rune> _66_typeParams;
-      _66_typeParams = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-      BigInteger _67_tpI;
-      _67_tpI = BigInteger.Zero;
+      Dafny.ISet<DAST._IType> _66_typeParamsSet;
+      _66_typeParamsSet = Dafny.Set<DAST._IType>.FromElements();
+      Dafny.ISequence<Dafny.Rune> _67_typeParams;
+      _67_typeParams = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+      BigInteger _68_tpI;
+      _68_tpI = BigInteger.Zero;
       if ((new BigInteger(((t).dtor_typeParams).Count)).Sign == 1) {
-        _66_typeParams = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<");
-        while ((_67_tpI) < (new BigInteger(((t).dtor_typeParams).Count))) {
-          DAST._IType _68_tp;
-          _68_tp = ((t).dtor_typeParams).Select(_67_tpI);
-          _65_typeParamsSet = Dafny.Set<DAST._IType>.Union(_65_typeParamsSet, Dafny.Set<DAST._IType>.FromElements(_68_tp));
-          Dafny.ISequence<Dafny.Rune> _69_genTp;
+        _67_typeParams = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<");
+        while ((_68_tpI) < (new BigInteger(((t).dtor_typeParams).Count))) {
+          DAST._IType _69_tp;
+          _69_tp = ((t).dtor_typeParams).Select(_68_tpI);
+          _66_typeParamsSet = Dafny.Set<DAST._IType>.Union(_66_typeParamsSet, Dafny.Set<DAST._IType>.FromElements(_69_tp));
+          Dafny.ISequence<Dafny.Rune> _70_genTp;
           Dafny.ISequence<Dafny.Rune> _out21;
-          _out21 = DCOMP.COMP.GenType(_68_tp, false, false);
-          _69_genTp = _out21;
-          _66_typeParams = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_66_typeParams, _69_genTp), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
-          _67_tpI = (_67_tpI) + (BigInteger.One);
+          _out21 = DCOMP.COMP.GenType(_69_tp, false, false);
+          _70_genTp = _out21;
+          _67_typeParams = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_67_typeParams, _70_genTp), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+          _68_tpI = (_68_tpI) + (BigInteger.One);
         }
-        _66_typeParams = Dafny.Sequence<Dafny.Rune>.Concat(_66_typeParams, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
+        _67_typeParams = Dafny.Sequence<Dafny.Rune>.Concat(_67_typeParams, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
       }
-      Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _70_fullPath;
-      _70_fullPath = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.Concat(containingPath, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements((t).dtor_name));
-      Dafny.ISequence<Dafny.Rune> _71_implBody;
-      Dafny.IMap<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>> _72___v6;
+      Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _71_fullPath;
+      _71_fullPath = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.Concat(containingPath, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements((t).dtor_name));
+      Dafny.ISequence<Dafny.Rune> _72_implBody;
+      Dafny.IMap<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>> _73___v6;
       Dafny.ISequence<Dafny.Rune> _out22;
       Dafny.IMap<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>> _out23;
-      DCOMP.COMP.GenClassImplBody((t).dtor_body, true, DAST.Type.create_Path(_70_fullPath, Dafny.Sequence<DAST._IType>.FromElements(), DAST.ResolvedType.create_Trait(_70_fullPath)), _65_typeParamsSet, out _out22, out _out23);
-      _71_implBody = _out22;
-      _72___v6 = _out23;
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("pub trait r#"), (t).dtor_name), _66_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _71_implBody), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
+      DCOMP.COMP.GenClassImplBody((t).dtor_body, true, DAST.Type.create_Path(_71_fullPath, Dafny.Sequence<DAST._IType>.FromElements(), DAST.ResolvedType.create_Trait(_71_fullPath)), _66_typeParamsSet, out _out22, out _out23);
+      _72_implBody = _out22;
+      _73___v6 = _out23;
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("pub trait r#"), (t).dtor_name), _67_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _72_implBody), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
       return s;
     }
     public static Dafny.ISequence<Dafny.Rune> GenNewtype(DAST._INewtype c) {
       Dafny.ISequence<Dafny.Rune> s = Dafny.Sequence<Dafny.Rune>.Empty;
-      Dafny.ISet<DAST._IType> _73_typeParamsSet;
-      Dafny.ISequence<Dafny.Rune> _74_typeParams;
-      Dafny.ISequence<Dafny.Rune> _75_constrainedTypeParams;
+      Dafny.ISet<DAST._IType> _74_typeParamsSet;
+      Dafny.ISequence<Dafny.Rune> _75_typeParams;
+      Dafny.ISequence<Dafny.Rune> _76_constrainedTypeParams;
       Dafny.ISet<DAST._IType> _out24;
       Dafny.ISequence<Dafny.Rune> _out25;
       Dafny.ISequence<Dafny.Rune> _out26;
       DCOMP.COMP.GenTypeParameters((c).dtor_typeParams, out _out24, out _out25, out _out26);
-      _73_typeParamsSet = _out24;
-      _74_typeParams = _out25;
-      _75_constrainedTypeParams = _out26;
-      Dafny.ISequence<Dafny.Rune> _76_underlyingType;
+      _74_typeParamsSet = _out24;
+      _75_typeParams = _out25;
+      _76_constrainedTypeParams = _out26;
+      Dafny.ISequence<Dafny.Rune> _77_underlyingType;
       Dafny.ISequence<Dafny.Rune> _out27;
       _out27 = DCOMP.COMP.GenType((c).dtor_base, false, false);
-      _76_underlyingType = _out27;
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[derive(Clone, PartialEq)]\n#[repr(transparent)]\npub struct r#"), (c).dtor_name), _74_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(pub ")), _76_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(");\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _75_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyErasable for r#")), (c).dtor_name), _74_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("type Erased = ")), _76_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";\n"));
+      _77_underlyingType = _out27;
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[derive(Clone, PartialEq)]\n#[repr(transparent)]\npub struct r#"), (c).dtor_name), _75_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(pub ")), _77_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(");\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _76_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyErasable for r#")), (c).dtor_name), _75_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("type Erased = ")), _77_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[inline]\nfn erase(&self) -> &Self::Erased {\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&self.0\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
@@ -4544,43 +4644,43 @@ public partial class COMP {
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("self.0\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _75_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyUnerasable<")), _76_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("> for r#")), (c).dtor_name), _74_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[inline]\nfn unerase(x: &")), _76_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> &Self {\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unsafe { &*(x as *const ")), _76_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as *const r#")), (c).dtor_name), _74_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") }\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _76_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyUnerasable<")), _77_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("> for r#")), (c).dtor_name), _75_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[inline]\nfn unerase(x: &")), _77_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> &Self {\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unsafe { &*(x as *const ")), _77_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as *const r#")), (c).dtor_name), _75_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") }\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[inline]\nfn unerase_owned(x: ")), _76_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> Self {\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[inline]\nfn unerase_owned(x: ")), _77_underlyingType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> Self {\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(x)\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _75_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyUnerasable<r#")), (c).dtor_name), _74_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("> for r#")), (c).dtor_name), _74_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[inline]\nfn unerase(x: &r#")), (c).dtor_name), _74_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> &Self {\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _76_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyUnerasable<r#")), (c).dtor_name), _75_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("> for r#")), (c).dtor_name), _75_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[inline]\nfn unerase(x: &r#")), (c).dtor_name), _75_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> &Self {\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("x\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[inline]\nfn unerase_owned(x: r#")), (c).dtor_name), _74_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> Self {\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[inline]\nfn unerase_owned(x: r#")), (c).dtor_name), _75_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> Self {\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("x\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _75_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::std::default::Default for r#")), (c).dtor_name), _74_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _76_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::std::default::Default for r#")), (c).dtor_name), _75_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn default() -> Self {\n"));
       DAST._IOptional<DAST._IExpression> _source4 = (c).dtor_witnessExpr;
       if (_source4.is_Some) {
-        DAST._IExpression _77___mcc_h0 = _source4.dtor_Some_a0;
-        DAST._IExpression _78_e = _77___mcc_h0;
+        DAST._IExpression _78___mcc_h0 = _source4.dtor_Some_a0;
+        DAST._IExpression _79_e = _78___mcc_h0;
         {
-          Dafny.ISequence<Dafny.Rune> _79_eStr;
-          bool _80___v7;
-          bool _81___v8;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _82___v9;
+          Dafny.ISequence<Dafny.Rune> _80_eStr;
+          bool _81___v7;
+          bool _82___v8;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _83___v9;
           Dafny.ISequence<Dafny.Rune> _out28;
           bool _out29;
           bool _out30;
           Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out31;
-          DCOMP.COMP.GenExpr(_78_e, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements(), true, out _out28, out _out29, out _out30, out _out31);
-          _79_eStr = _out28;
-          _80___v7 = _out29;
-          _81___v8 = _out30;
-          _82___v9 = _out31;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _79_eStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")\n"));
+          DCOMP.COMP.GenExpr(_79_e, DAST.Optional<Dafny.ISequence<Dafny.Rune>>.create_None(), Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements(), true, out _out28, out _out29, out _out30, out _out31);
+          _80_eStr = _out28;
+          _81___v7 = _out29;
+          _82___v8 = _out30;
+          _83___v9 = _out31;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _80_eStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")\n"));
         }
       } else {
         {
@@ -4589,7 +4689,7 @@ public partial class COMP {
       }
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _75_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyPrint for r#")), (c).dtor_name), _74_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _76_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyPrint for r#")), (c).dtor_name), _75_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn fmt_print(&self, __fmt_print_formatter: &mut ::std::fmt::Formatter, in_seq: bool) -> ::std::fmt::Result {\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyPrint::fmt_print(&self.0, __fmt_print_formatter, in_seq)\n"));
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
@@ -4598,187 +4698,187 @@ public partial class COMP {
     }
     public static Dafny.ISequence<Dafny.Rune> GenDatatype(DAST._IDatatype c) {
       Dafny.ISequence<Dafny.Rune> s = Dafny.Sequence<Dafny.Rune>.Empty;
-      Dafny.ISet<DAST._IType> _83_typeParamsSet;
-      Dafny.ISequence<Dafny.Rune> _84_typeParams;
-      Dafny.ISequence<Dafny.Rune> _85_constrainedTypeParams;
+      Dafny.ISet<DAST._IType> _84_typeParamsSet;
+      Dafny.ISequence<Dafny.Rune> _85_typeParams;
+      Dafny.ISequence<Dafny.Rune> _86_constrainedTypeParams;
       Dafny.ISet<DAST._IType> _out32;
       Dafny.ISequence<Dafny.Rune> _out33;
       Dafny.ISequence<Dafny.Rune> _out34;
       DCOMP.COMP.GenTypeParameters((c).dtor_typeParams, out _out32, out _out33, out _out34);
-      _83_typeParamsSet = _out32;
-      _84_typeParams = _out33;
-      _85_constrainedTypeParams = _out34;
-      Dafny.ISequence<Dafny.Rune> _86_ctors;
-      _86_ctors = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-      BigInteger _87_i;
-      _87_i = BigInteger.Zero;
-      while ((_87_i) < (new BigInteger(((c).dtor_ctors).Count))) {
-        DAST._IDatatypeCtor _88_ctor;
-        _88_ctor = ((c).dtor_ctors).Select(_87_i);
-        Dafny.ISequence<Dafny.Rune> _89_ctorBody;
-        _89_ctorBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), (_88_ctor).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" { "));
-        BigInteger _90_j;
-        _90_j = BigInteger.Zero;
-        while ((_90_j) < (new BigInteger(((_88_ctor).dtor_args).Count))) {
-          DAST._IFormal _91_formal;
-          _91_formal = ((_88_ctor).dtor_args).Select(_90_j);
-          Dafny.ISequence<Dafny.Rune> _92_formalType;
+      _84_typeParamsSet = _out32;
+      _85_typeParams = _out33;
+      _86_constrainedTypeParams = _out34;
+      Dafny.ISequence<Dafny.Rune> _87_ctors;
+      _87_ctors = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+      BigInteger _88_i;
+      _88_i = BigInteger.Zero;
+      while ((_88_i) < (new BigInteger(((c).dtor_ctors).Count))) {
+        DAST._IDatatypeCtor _89_ctor;
+        _89_ctor = ((c).dtor_ctors).Select(_88_i);
+        Dafny.ISequence<Dafny.Rune> _90_ctorBody;
+        _90_ctorBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), (_89_ctor).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" { "));
+        BigInteger _91_j;
+        _91_j = BigInteger.Zero;
+        while ((_91_j) < (new BigInteger(((_89_ctor).dtor_args).Count))) {
+          DAST._IFormal _92_formal;
+          _92_formal = ((_89_ctor).dtor_args).Select(_91_j);
+          Dafny.ISequence<Dafny.Rune> _93_formalType;
           Dafny.ISequence<Dafny.Rune> _out35;
-          _out35 = DCOMP.COMP.GenType((_91_formal).dtor_typ, false, false);
-          _92_formalType = _out35;
+          _out35 = DCOMP.COMP.GenType((_92_formal).dtor_typ, false, false);
+          _93_formalType = _out35;
           if ((c).dtor_isCo) {
-            _89_ctorBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_89_ctorBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_91_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ::dafny_runtime::LazyFieldWrapper<")), _92_formalType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">, "));
+            _90_ctorBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_90_ctorBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_92_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ::dafny_runtime::LazyFieldWrapper<")), _93_formalType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">, "));
           } else {
-            _89_ctorBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_89_ctorBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_91_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ")), _92_formalType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+            _90_ctorBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_90_ctorBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_92_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ")), _93_formalType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
           }
-          _90_j = (_90_j) + (BigInteger.One);
+          _91_j = (_91_j) + (BigInteger.One);
         }
-        _89_ctorBody = Dafny.Sequence<Dafny.Rune>.Concat(_89_ctorBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}"));
-        _86_ctors = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_86_ctors, _89_ctorBody), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(",\n"));
-        _87_i = (_87_i) + (BigInteger.One);
-      }
-      Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _93_selfPath;
-      _93_selfPath = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements((c).dtor_name);
-      Dafny.ISequence<Dafny.Rune> _94_implBody;
-      Dafny.IMap<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>> _95_traitBodies;
+        _90_ctorBody = Dafny.Sequence<Dafny.Rune>.Concat(_90_ctorBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}"));
+        _87_ctors = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_87_ctors, _90_ctorBody), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(",\n"));
+        _88_i = (_88_i) + (BigInteger.One);
+      }
+      Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _94_selfPath;
+      _94_selfPath = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements((c).dtor_name);
+      Dafny.ISequence<Dafny.Rune> _95_implBody;
+      Dafny.IMap<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>> _96_traitBodies;
       Dafny.ISequence<Dafny.Rune> _out36;
       Dafny.IMap<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>> _out37;
-      DCOMP.COMP.GenClassImplBody((c).dtor_body, false, DAST.Type.create_Path(Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements(), Dafny.Sequence<DAST._IType>.FromElements(), DAST.ResolvedType.create_Datatype(_93_selfPath)), _83_typeParamsSet, out _out36, out _out37);
-      _94_implBody = _out36;
-      _95_traitBodies = _out37;
-      _87_i = BigInteger.Zero;
-      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _96_emittedFields;
-      _96_emittedFields = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
-      while ((_87_i) < (new BigInteger(((c).dtor_ctors).Count))) {
-        DAST._IDatatypeCtor _97_ctor;
-        _97_ctor = ((c).dtor_ctors).Select(_87_i);
-        BigInteger _98_j;
-        _98_j = BigInteger.Zero;
-        while ((_98_j) < (new BigInteger(((_97_ctor).dtor_args).Count))) {
-          DAST._IFormal _99_formal;
-          _99_formal = ((_97_ctor).dtor_args).Select(_98_j);
-          if (!((_96_emittedFields).Contains((_99_formal).dtor_name))) {
-            _96_emittedFields = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_96_emittedFields, Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements((_99_formal).dtor_name));
-            Dafny.ISequence<Dafny.Rune> _100_formalType;
+      DCOMP.COMP.GenClassImplBody((c).dtor_body, false, DAST.Type.create_Path(Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements(), Dafny.Sequence<DAST._IType>.FromElements(), DAST.ResolvedType.create_Datatype(_94_selfPath)), _84_typeParamsSet, out _out36, out _out37);
+      _95_implBody = _out36;
+      _96_traitBodies = _out37;
+      _88_i = BigInteger.Zero;
+      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _97_emittedFields;
+      _97_emittedFields = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
+      while ((_88_i) < (new BigInteger(((c).dtor_ctors).Count))) {
+        DAST._IDatatypeCtor _98_ctor;
+        _98_ctor = ((c).dtor_ctors).Select(_88_i);
+        BigInteger _99_j;
+        _99_j = BigInteger.Zero;
+        while ((_99_j) < (new BigInteger(((_98_ctor).dtor_args).Count))) {
+          DAST._IFormal _100_formal;
+          _100_formal = ((_98_ctor).dtor_args).Select(_99_j);
+          if (!((_97_emittedFields).Contains((_100_formal).dtor_name))) {
+            _97_emittedFields = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_97_emittedFields, Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements((_100_formal).dtor_name));
+            Dafny.ISequence<Dafny.Rune> _101_formalType;
             Dafny.ISequence<Dafny.Rune> _out38;
-            _out38 = DCOMP.COMP.GenType((_99_formal).dtor_typ, false, false);
-            _100_formalType = _out38;
-            Dafny.ISequence<Dafny.Rune> _101_methodBody;
-            _101_methodBody = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("match self {\n");
-            BigInteger _102_k;
-            _102_k = BigInteger.Zero;
-            while ((_102_k) < (new BigInteger(((c).dtor_ctors).Count))) {
-              DAST._IDatatypeCtor _103_ctor2;
-              _103_ctor2 = ((c).dtor_ctors).Select(_102_k);
-              Dafny.ISequence<Dafny.Rune> _104_ctorMatch;
-              _104_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_103_ctor2).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" { "));
-              BigInteger _105_l;
-              _105_l = BigInteger.Zero;
-              bool _106_hasMatchingField;
-              _106_hasMatchingField = false;
-              while ((_105_l) < (new BigInteger(((_103_ctor2).dtor_args).Count))) {
-                DAST._IFormal _107_formal2;
-                _107_formal2 = ((_103_ctor2).dtor_args).Select(_105_l);
-                if (((_99_formal).dtor_name).Equals((_107_formal2).dtor_name)) {
-                  _106_hasMatchingField = true;
-                }
-                _104_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_104_ctorMatch, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_107_formal2).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
-                _105_l = (_105_l) + (BigInteger.One);
+            _out38 = DCOMP.COMP.GenType((_100_formal).dtor_typ, false, false);
+            _101_formalType = _out38;
+            Dafny.ISequence<Dafny.Rune> _102_methodBody;
+            _102_methodBody = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("match self {\n");
+            BigInteger _103_k;
+            _103_k = BigInteger.Zero;
+            while ((_103_k) < (new BigInteger(((c).dtor_ctors).Count))) {
+              DAST._IDatatypeCtor _104_ctor2;
+              _104_ctor2 = ((c).dtor_ctors).Select(_103_k);
+              Dafny.ISequence<Dafny.Rune> _105_ctorMatch;
+              _105_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_104_ctor2).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" { "));
+              BigInteger _106_l;
+              _106_l = BigInteger.Zero;
+              bool _107_hasMatchingField;
+              _107_hasMatchingField = false;
+              while ((_106_l) < (new BigInteger(((_104_ctor2).dtor_args).Count))) {
+                DAST._IFormal _108_formal2;
+                _108_formal2 = ((_104_ctor2).dtor_args).Select(_106_l);
+                if (((_100_formal).dtor_name).Equals((_108_formal2).dtor_name)) {
+                  _107_hasMatchingField = true;
+                }
+                _105_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_105_ctorMatch, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_108_formal2).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+                _106_l = (_106_l) + (BigInteger.One);
               }
-              if (_106_hasMatchingField) {
+              if (_107_hasMatchingField) {
                 if ((c).dtor_isCo) {
-                  _104_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_104_ctorMatch, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("} => ::std::ops::Deref::deref(&")), (_99_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0),\n"));
+                  _105_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_105_ctorMatch, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("} => ::std::ops::Deref::deref(&")), (_100_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0),\n"));
                 } else {
-                  _104_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_104_ctorMatch, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("} => ")), (_99_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(",\n"));
+                  _105_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_105_ctorMatch, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("} => ")), (_100_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(",\n"));
                 }
               } else {
-                _104_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(_104_ctorMatch, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("} => panic!(\"field does not exist on this variant\"),\n"));
+                _105_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(_105_ctorMatch, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("} => panic!(\"field does not exist on this variant\"),\n"));
               }
-              _101_methodBody = Dafny.Sequence<Dafny.Rune>.Concat(_101_methodBody, _104_ctorMatch);
-              _102_k = (_102_k) + (BigInteger.One);
+              _102_methodBody = Dafny.Sequence<Dafny.Rune>.Concat(_102_methodBody, _105_ctorMatch);
+              _103_k = (_103_k) + (BigInteger.One);
             }
             if ((new BigInteger(((c).dtor_typeParams).Count)).Sign == 1) {
-              _101_methodBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_101_methodBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::_PhantomVariant(..) => panic!(),\n"));
+              _102_methodBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_102_methodBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::_PhantomVariant(..) => panic!(),\n"));
             }
-            _101_methodBody = Dafny.Sequence<Dafny.Rune>.Concat(_101_methodBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
-            _94_implBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_94_implBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("pub fn r#")), (_99_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(&self) -> &")), _100_formalType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _101_methodBody), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
+            _102_methodBody = Dafny.Sequence<Dafny.Rune>.Concat(_102_methodBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
+            _95_implBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_95_implBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("pub fn r#")), (_100_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(&self) -> &")), _101_formalType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _102_methodBody), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
           }
-          _98_j = (_98_j) + (BigInteger.One);
+          _99_j = (_99_j) + (BigInteger.One);
         }
-        _87_i = (_87_i) + (BigInteger.One);
+        _88_i = (_88_i) + (BigInteger.One);
       }
       if ((new BigInteger(((c).dtor_typeParams).Count)).Sign == 1) {
-        _86_ctors = Dafny.Sequence<Dafny.Rune>.Concat(_86_ctors, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("_PhantomVariant("));
-        BigInteger _108_typeI;
-        _108_typeI = BigInteger.Zero;
-        while ((_108_typeI) < (new BigInteger(((c).dtor_typeParams).Count))) {
-          if ((_108_typeI).Sign == 1) {
-            _86_ctors = Dafny.Sequence<Dafny.Rune>.Concat(_86_ctors, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+        _87_ctors = Dafny.Sequence<Dafny.Rune>.Concat(_87_ctors, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("_PhantomVariant("));
+        BigInteger _109_typeI;
+        _109_typeI = BigInteger.Zero;
+        while ((_109_typeI) < (new BigInteger(((c).dtor_typeParams).Count))) {
+          if ((_109_typeI).Sign == 1) {
+            _87_ctors = Dafny.Sequence<Dafny.Rune>.Concat(_87_ctors, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
           }
-          Dafny.ISequence<Dafny.Rune> _109_genTp;
+          Dafny.ISequence<Dafny.Rune> _110_genTp;
           Dafny.ISequence<Dafny.Rune> _out39;
-          _out39 = DCOMP.COMP.GenType(((c).dtor_typeParams).Select(_108_typeI), false, false);
-          _109_genTp = _out39;
-          _86_ctors = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_86_ctors, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::marker::PhantomData::<")), _109_genTp), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
-          _108_typeI = (_108_typeI) + (BigInteger.One);
+          _out39 = DCOMP.COMP.GenType(((c).dtor_typeParams).Select(_109_typeI), false, false);
+          _110_genTp = _out39;
+          _87_ctors = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_87_ctors, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::marker::PhantomData::<")), _110_genTp), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
+          _109_typeI = (_109_typeI) + (BigInteger.One);
         }
-        _86_ctors = Dafny.Sequence<Dafny.Rune>.Concat(_86_ctors, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-      }
-      Dafny.ISequence<Dafny.Rune> _110_enumBody;
-      _110_enumBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[derive(PartialEq)]\npub enum r#"), (c).dtor_name), _84_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _86_ctors), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _85_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" r#")), (c).dtor_name), _84_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _94_implBody), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
-      Dafny.ISequence<Dafny.Rune> _111_identEraseImpls;
-      _111_identEraseImpls = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _85_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyErasable for r#")), (c).dtor_name), _84_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("type Erased = Self;\nfn erase(&self) -> &Self::Erased { self }\nfn erase_owned(self) -> Self::Erased { self }}\n"));
-      _111_identEraseImpls = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_111_identEraseImpls, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _85_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyUnerasable<r#")), (c).dtor_name), _84_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("> for r#")), (c).dtor_name), _84_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn unerase(x: &Self) -> &Self { x }\nfn unerase_owned(x: Self) -> Self { x }}\n"));
-      Dafny.ISequence<Dafny.Rune> _112_printImpl;
-      _112_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _85_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyPrint for r#")), (c).dtor_name), _84_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn fmt_print(&self, __fmt_print_formatter: &mut ::std::fmt::Formatter, _in_seq: bool) -> std::fmt::Result {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("match self {\n"));
-      _87_i = BigInteger.Zero;
-      while ((_87_i) < (new BigInteger(((c).dtor_ctors).Count))) {
-        DAST._IDatatypeCtor _113_ctor;
-        _113_ctor = ((c).dtor_ctors).Select(_87_i);
-        Dafny.ISequence<Dafny.Rune> _114_ctorMatch;
-        _114_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), (_113_ctor).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" { "));
-        Dafny.ISequence<Dafny.Rune> _115_modulePrefix;
-        _115_modulePrefix = (((((c).dtor_enclosingModule)).Equals(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("_module"))) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("")) : (Dafny.Sequence<Dafny.Rune>.Concat(((c).dtor_enclosingModule), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("."))));
-        Dafny.ISequence<Dafny.Rune> _116_printRhs;
-        _116_printRhs = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("write!(__fmt_print_formatter, \""), _115_modulePrefix), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".")), (_113_ctor).dtor_name), (((_113_ctor).dtor_hasAnyArgs) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(\")?;")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\")?;"))));
-        BigInteger _117_j;
-        _117_j = BigInteger.Zero;
-        while ((_117_j) < (new BigInteger(((_113_ctor).dtor_args).Count))) {
-          DAST._IFormal _118_formal;
-          _118_formal = ((_113_ctor).dtor_args).Select(_117_j);
-          _114_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_114_ctorMatch, (_118_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
-          if ((_117_j).Sign == 1) {
-            _116_printRhs = Dafny.Sequence<Dafny.Rune>.Concat(_116_printRhs, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nwrite!(__fmt_print_formatter, \", \")?;"));
+        _87_ctors = Dafny.Sequence<Dafny.Rune>.Concat(_87_ctors, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+      }
+      Dafny.ISequence<Dafny.Rune> _111_enumBody;
+      _111_enumBody = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#[derive(PartialEq)]\npub enum r#"), (c).dtor_name), _85_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _87_ctors), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _86_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" r#")), (c).dtor_name), _85_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _95_implBody), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
+      Dafny.ISequence<Dafny.Rune> _112_identEraseImpls;
+      _112_identEraseImpls = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _86_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyErasable for r#")), (c).dtor_name), _85_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("type Erased = Self;\nfn erase(&self) -> &Self::Erased { self }\nfn erase_owned(self) -> Self::Erased { self }}\n"));
+      _112_identEraseImpls = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_112_identEraseImpls, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl ")), _86_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyUnerasable<r#")), (c).dtor_name), _85_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("> for r#")), (c).dtor_name), _85_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn unerase(x: &Self) -> &Self { x }\nfn unerase_owned(x: Self) -> Self { x }}\n"));
+      Dafny.ISequence<Dafny.Rune> _113_printImpl;
+      _113_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _86_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::dafny_runtime::DafnyPrint for r#")), (c).dtor_name), _85_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn fmt_print(&self, __fmt_print_formatter: &mut ::std::fmt::Formatter, _in_seq: bool) -> std::fmt::Result {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("match self {\n"));
+      _88_i = BigInteger.Zero;
+      while ((_88_i) < (new BigInteger(((c).dtor_ctors).Count))) {
+        DAST._IDatatypeCtor _114_ctor;
+        _114_ctor = ((c).dtor_ctors).Select(_88_i);
+        Dafny.ISequence<Dafny.Rune> _115_ctorMatch;
+        _115_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), (_114_ctor).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" { "));
+        Dafny.ISequence<Dafny.Rune> _116_modulePrefix;
+        _116_modulePrefix = (((((c).dtor_enclosingModule)).Equals(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("_module"))) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("")) : (Dafny.Sequence<Dafny.Rune>.Concat(((c).dtor_enclosingModule), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("."))));
+        Dafny.ISequence<Dafny.Rune> _117_printRhs;
+        _117_printRhs = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("write!(__fmt_print_formatter, \""), _116_modulePrefix), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".")), (_114_ctor).dtor_name), (((_114_ctor).dtor_hasAnyArgs) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(\")?;")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\")?;"))));
+        BigInteger _118_j;
+        _118_j = BigInteger.Zero;
+        while ((_118_j) < (new BigInteger(((_114_ctor).dtor_args).Count))) {
+          DAST._IFormal _119_formal;
+          _119_formal = ((_114_ctor).dtor_args).Select(_118_j);
+          _115_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_115_ctorMatch, (_119_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+          if ((_118_j).Sign == 1) {
+            _117_printRhs = Dafny.Sequence<Dafny.Rune>.Concat(_117_printRhs, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nwrite!(__fmt_print_formatter, \", \")?;"));
           }
-          _116_printRhs = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_116_printRhs, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n::dafny_runtime::DafnyPrint::fmt_print(")), (_118_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", __fmt_print_formatter, false)?;"));
-          _117_j = (_117_j) + (BigInteger.One);
+          _117_printRhs = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_117_printRhs, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n::dafny_runtime::DafnyPrint::fmt_print(")), (_119_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", __fmt_print_formatter, false)?;"));
+          _118_j = (_118_j) + (BigInteger.One);
         }
-        _114_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(_114_ctorMatch, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}"));
-        if ((_113_ctor).dtor_hasAnyArgs) {
-          _116_printRhs = Dafny.Sequence<Dafny.Rune>.Concat(_116_printRhs, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nwrite!(__fmt_print_formatter, \")\")?;"));
+        _115_ctorMatch = Dafny.Sequence<Dafny.Rune>.Concat(_115_ctorMatch, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}"));
+        if ((_114_ctor).dtor_hasAnyArgs) {
+          _117_printRhs = Dafny.Sequence<Dafny.Rune>.Concat(_117_printRhs, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nwrite!(__fmt_print_formatter, \")\")?;"));
         }
-        _116_printRhs = Dafny.Sequence<Dafny.Rune>.Concat(_116_printRhs, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nOk(())"));
-        _112_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_112_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::")), _114_ctorMatch), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" => {\n")), _116_printRhs), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}\n"));
-        _87_i = (_87_i) + (BigInteger.One);
+        _117_printRhs = Dafny.Sequence<Dafny.Rune>.Concat(_117_printRhs, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nOk(())"));
+        _113_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_113_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::")), _115_ctorMatch), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" => {\n")), _117_printRhs), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}\n"));
+        _88_i = (_88_i) + (BigInteger.One);
       }
       if ((new BigInteger(((c).dtor_typeParams).Count)).Sign == 1) {
-        _112_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_112_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::_PhantomVariant(..) => {panic!()\n}\n"));
+        _113_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_113_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::_PhantomVariant(..) => {panic!()\n}\n"));
       }
-      _112_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(_112_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n}\n}\n"));
-      Dafny.ISequence<Dafny.Rune> _119_defaultImpl;
-      _119_defaultImpl = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+      _113_printImpl = Dafny.Sequence<Dafny.Rune>.Concat(_113_printImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n}\n}\n"));
+      Dafny.ISequence<Dafny.Rune> _120_defaultImpl;
+      _120_defaultImpl = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
       if ((new BigInteger(((c).dtor_ctors).Count)).Sign == 1) {
-        _119_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _85_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::std::default::Default for r#")), (c).dtor_name), _84_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn default() -> Self {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::r#")), (((c).dtor_ctors).Select(BigInteger.Zero)).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
-        _87_i = BigInteger.Zero;
-        while ((_87_i) < (new BigInteger(((((c).dtor_ctors).Select(BigInteger.Zero)).dtor_args).Count))) {
-          DAST._IFormal _120_formal;
-          _120_formal = ((((c).dtor_ctors).Select(BigInteger.Zero)).dtor_args).Select(_87_i);
-          _119_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_119_defaultImpl, (_120_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": std::default::Default::default(),\n"));
-          _87_i = (_87_i) + (BigInteger.One);
+        _120_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("impl "), _86_constrainedTypeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ::std::default::Default for r#")), (c).dtor_name), _85_typeParams), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn default() -> Self {\n")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (c).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::r#")), (((c).dtor_ctors).Select(BigInteger.Zero)).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n"));
+        _88_i = BigInteger.Zero;
+        while ((_88_i) < (new BigInteger(((((c).dtor_ctors).Select(BigInteger.Zero)).dtor_args).Count))) {
+          DAST._IFormal _121_formal;
+          _121_formal = ((((c).dtor_ctors).Select(BigInteger.Zero)).dtor_args).Select(_88_i);
+          _120_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_120_defaultImpl, (_121_formal).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": std::default::Default::default(),\n"));
+          _88_i = (_88_i) + (BigInteger.One);
         }
-        _119_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(_119_defaultImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n}\n}\n"));
+        _120_defaultImpl = Dafny.Sequence<Dafny.Rune>.Concat(_120_defaultImpl, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n}\n}\n"));
       }
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_110_enumBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _111_identEraseImpls), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _112_printImpl), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _119_defaultImpl);
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_111_enumBody, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _112_identEraseImpls), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _113_printImpl), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _120_defaultImpl);
       return s;
     }
     public static Dafny.ISequence<Dafny.Rune> GenPath(Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> p) {
@@ -4788,14 +4888,14 @@ public partial class COMP {
         return s;
       } else {
         s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("super::");
-        BigInteger _121_i;
-        _121_i = BigInteger.Zero;
-        while ((_121_i) < (new BigInteger((p).Count))) {
-          if ((_121_i).Sign == 1) {
+        BigInteger _122_i;
+        _122_i = BigInteger.Zero;
+        while ((_122_i) < (new BigInteger((p).Count))) {
+          if ((_122_i).Sign == 1) {
             s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::"));
           }
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), ((p).Select(_121_i)));
-          _121_i = (_121_i) + (BigInteger.One);
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), ((p).Select(_122_i)));
+          _122_i = (_122_i) + (BigInteger.One);
         }
       }
       return s;
@@ -4805,18 +4905,18 @@ public partial class COMP {
       s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
       if ((new BigInteger((args).Count)).Sign == 1) {
         s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"));
-        BigInteger _122_i;
-        _122_i = BigInteger.Zero;
-        while ((_122_i) < (new BigInteger((args).Count))) {
-          if ((_122_i).Sign == 1) {
+        BigInteger _123_i;
+        _123_i = BigInteger.Zero;
+        while ((_123_i) < (new BigInteger((args).Count))) {
+          if ((_123_i).Sign == 1) {
             s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
           }
-          Dafny.ISequence<Dafny.Rune> _123_genTp;
+          Dafny.ISequence<Dafny.Rune> _124_genTp;
           Dafny.ISequence<Dafny.Rune> _out40;
-          _out40 = DCOMP.COMP.GenType((args).Select(_122_i), inBinding, inFn);
-          _123_genTp = _out40;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(s, _123_genTp);
-          _122_i = (_122_i) + (BigInteger.One);
+          _out40 = DCOMP.COMP.GenType((args).Select(_123_i), inBinding, inFn);
+          _124_genTp = _out40;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(s, _124_genTp);
+          _123_i = (_123_i) + (BigInteger.One);
         }
         s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
       }
@@ -4826,29 +4926,29 @@ public partial class COMP {
       Dafny.ISequence<Dafny.Rune> s = Dafny.Sequence<Dafny.Rune>.Empty;
       DAST._IType _source5 = c;
       if (_source5.is_Path) {
-        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _124___mcc_h0 = _source5.dtor_Path_a0;
-        Dafny.ISequence<DAST._IType> _125___mcc_h1 = _source5.dtor_typeArgs;
-        DAST._IResolvedType _126___mcc_h2 = _source5.dtor_resolved;
-        DAST._IResolvedType _127_resolved = _126___mcc_h2;
-        Dafny.ISequence<DAST._IType> _128_args = _125___mcc_h1;
-        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _129_p = _124___mcc_h0;
+        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _125___mcc_h0 = _source5.dtor_Path_a0;
+        Dafny.ISequence<DAST._IType> _126___mcc_h1 = _source5.dtor_typeArgs;
+        DAST._IResolvedType _127___mcc_h2 = _source5.dtor_resolved;
+        DAST._IResolvedType _128_resolved = _127___mcc_h2;
+        Dafny.ISequence<DAST._IType> _129_args = _126___mcc_h1;
+        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _130_p = _125___mcc_h0;
         {
           Dafny.ISequence<Dafny.Rune> _out41;
-          _out41 = DCOMP.COMP.GenPath(_129_p);
+          _out41 = DCOMP.COMP.GenPath(_130_p);
           s = _out41;
-          Dafny.ISequence<Dafny.Rune> _130_typeArgs;
+          Dafny.ISequence<Dafny.Rune> _131_typeArgs;
           Dafny.ISequence<Dafny.Rune> _out42;
-          _out42 = DCOMP.COMP.GenTypeArgs(_128_args, inBinding, inFn);
-          _130_typeArgs = _out42;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(s, _130_typeArgs);
-          DAST._IResolvedType _source6 = _127_resolved;
+          _out42 = DCOMP.COMP.GenTypeArgs(_129_args, inBinding, inFn);
+          _131_typeArgs = _out42;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(s, _131_typeArgs);
+          DAST._IResolvedType _source6 = _128_resolved;
           if (_source6.is_Datatype) {
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _131___mcc_h16 = _source6.dtor_path;
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _132___mcc_h17 = _source6.dtor_path;
             {
               s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::rc::Rc<"), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
             }
           } else if (_source6.is_Trait) {
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _132___mcc_h18 = _source6.dtor_path;
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _133___mcc_h19 = _source6.dtor_path;
             {
               if (inBinding) {
                 s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("_");
@@ -4857,91 +4957,101 @@ public partial class COMP {
               }
             }
           } else {
-            DAST._IType _133___mcc_h20 = _source6.dtor_Newtype_a0;
-            DAST._IResolvedType _134_Primitive = _127_resolved;
+            DAST._IType _134___mcc_h21 = _source6.dtor_Newtype_a0;
+            DAST._IResolvedType _135_Primitive = _128_resolved;
           }
         }
+      } else if (_source5.is_Nullable) {
+        DAST._IType _136___mcc_h3 = _source5.dtor_Nullable_a0;
+        DAST._IType _137_inner = _136___mcc_h3;
+        {
+          Dafny.ISequence<Dafny.Rune> _138_innerStr;
+          Dafny.ISequence<Dafny.Rune> _out43;
+          _out43 = DCOMP.COMP.GenType(_137_inner, inBinding, inFn);
+          _138_innerStr = _out43;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::option::Option<"), _138_innerStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
+        }
       } else if (_source5.is_Tuple) {
-        Dafny.ISequence<DAST._IType> _135___mcc_h3 = _source5.dtor_Tuple_a0;
-        Dafny.ISequence<DAST._IType> _136_types = _135___mcc_h3;
+        Dafny.ISequence<DAST._IType> _139___mcc_h4 = _source5.dtor_Tuple_a0;
+        Dafny.ISequence<DAST._IType> _140_types = _139___mcc_h4;
         {
           s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(");
-          BigInteger _137_i;
-          _137_i = BigInteger.Zero;
-          while ((_137_i) < (new BigInteger((_136_types).Count))) {
-            if ((_137_i).Sign == 1) {
+          BigInteger _141_i;
+          _141_i = BigInteger.Zero;
+          while ((_141_i) < (new BigInteger((_140_types).Count))) {
+            if ((_141_i).Sign == 1) {
               s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" "));
             }
-            Dafny.ISequence<Dafny.Rune> _138_generated;
-            Dafny.ISequence<Dafny.Rune> _out43;
-            _out43 = DCOMP.COMP.GenType((_136_types).Select(_137_i), inBinding, inFn);
-            _138_generated = _out43;
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, _138_generated), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(","));
-            _137_i = (_137_i) + (BigInteger.One);
+            Dafny.ISequence<Dafny.Rune> _142_generated;
+            Dafny.ISequence<Dafny.Rune> _out44;
+            _out44 = DCOMP.COMP.GenType((_140_types).Select(_141_i), inBinding, inFn);
+            _142_generated = _out44;
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, _142_generated), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(","));
+            _141_i = (_141_i) + (BigInteger.One);
           }
           s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
         }
       } else if (_source5.is_Array) {
-        DAST._IType _139___mcc_h4 = _source5.dtor_element;
-        DAST._IType _140_element = _139___mcc_h4;
+        DAST._IType _143___mcc_h5 = _source5.dtor_element;
+        DAST._IType _144_element = _143___mcc_h5;
         {
-          Dafny.ISequence<Dafny.Rune> _141_elemStr;
-          Dafny.ISequence<Dafny.Rune> _out44;
-          _out44 = DCOMP.COMP.GenType(_140_element, inBinding, inFn);
-          _141_elemStr = _out44;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::rc::Rc<::std::cell::RefCell<::std::vec::Vec<"), _141_elemStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">>>"));
+          Dafny.ISequence<Dafny.Rune> _145_elemStr;
+          Dafny.ISequence<Dafny.Rune> _out45;
+          _out45 = DCOMP.COMP.GenType(_144_element, inBinding, inFn);
+          _145_elemStr = _out45;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::rc::Rc<::std::cell::RefCell<::std::vec::Vec<"), _145_elemStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">>>"));
         }
       } else if (_source5.is_Seq) {
-        DAST._IType _142___mcc_h5 = _source5.dtor_element;
-        DAST._IType _143_element = _142___mcc_h5;
+        DAST._IType _146___mcc_h6 = _source5.dtor_element;
+        DAST._IType _147_element = _146___mcc_h6;
         {
-          Dafny.ISequence<Dafny.Rune> _144_elemStr;
-          Dafny.ISequence<Dafny.Rune> _out45;
-          _out45 = DCOMP.COMP.GenType(_143_element, inBinding, inFn);
-          _144_elemStr = _out45;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::vec::Vec<"), _144_elemStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
+          Dafny.ISequence<Dafny.Rune> _148_elemStr;
+          Dafny.ISequence<Dafny.Rune> _out46;
+          _out46 = DCOMP.COMP.GenType(_147_element, inBinding, inFn);
+          _148_elemStr = _out46;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::vec::Vec<"), _148_elemStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
         }
       } else if (_source5.is_Set) {
-        DAST._IType _145___mcc_h6 = _source5.dtor_element;
-        DAST._IType _146_element = _145___mcc_h6;
+        DAST._IType _149___mcc_h7 = _source5.dtor_element;
+        DAST._IType _150_element = _149___mcc_h7;
         {
-          Dafny.ISequence<Dafny.Rune> _147_elemStr;
-          Dafny.ISequence<Dafny.Rune> _out46;
-          _out46 = DCOMP.COMP.GenType(_146_element, inBinding, inFn);
-          _147_elemStr = _out46;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::collections::HashSet<"), _147_elemStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
+          Dafny.ISequence<Dafny.Rune> _151_elemStr;
+          Dafny.ISequence<Dafny.Rune> _out47;
+          _out47 = DCOMP.COMP.GenType(_150_element, inBinding, inFn);
+          _151_elemStr = _out47;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::collections::HashSet<"), _151_elemStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
         }
       } else if (_source5.is_Multiset) {
-        DAST._IType _148___mcc_h7 = _source5.dtor_element;
-        DAST._IType _149_element = _148___mcc_h7;
+        DAST._IType _152___mcc_h8 = _source5.dtor_element;
+        DAST._IType _153_element = _152___mcc_h8;
         {
-          Dafny.ISequence<Dafny.Rune> _150_elemStr;
-          Dafny.ISequence<Dafny.Rune> _out47;
-          _out47 = DCOMP.COMP.GenType(_149_element, inBinding, inFn);
-          _150_elemStr = _out47;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::collections::HashMap<"), _150_elemStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", u64>"));
+          Dafny.ISequence<Dafny.Rune> _154_elemStr;
+          Dafny.ISequence<Dafny.Rune> _out48;
+          _out48 = DCOMP.COMP.GenType(_153_element, inBinding, inFn);
+          _154_elemStr = _out48;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::collections::HashMap<"), _154_elemStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", u64>"));
         }
       } else if (_source5.is_Map) {
-        DAST._IType _151___mcc_h8 = _source5.dtor_key;
-        DAST._IType _152___mcc_h9 = _source5.dtor_value;
-        DAST._IType _153_value = _152___mcc_h9;
-        DAST._IType _154_key = _151___mcc_h8;
+        DAST._IType _155___mcc_h9 = _source5.dtor_key;
+        DAST._IType _156___mcc_h10 = _source5.dtor_value;
+        DAST._IType _157_value = _156___mcc_h10;
+        DAST._IType _158_key = _155___mcc_h9;
         {
-          Dafny.ISequence<Dafny.Rune> _155_keyStr;
-          Dafny.ISequence<Dafny.Rune> _out48;
-          _out48 = DCOMP.COMP.GenType(_154_key, inBinding, inFn);
-          _155_keyStr = _out48;
-          Dafny.ISequence<Dafny.Rune> _156_valueStr;
+          Dafny.ISequence<Dafny.Rune> _159_keyStr;
           Dafny.ISequence<Dafny.Rune> _out49;
-          _out49 = DCOMP.COMP.GenType(_153_value, inBinding, inFn);
-          _156_valueStr = _out49;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::collections::HashMap<"), _155_keyStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", ")), _156_valueStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
+          _out49 = DCOMP.COMP.GenType(_158_key, inBinding, inFn);
+          _159_keyStr = _out49;
+          Dafny.ISequence<Dafny.Rune> _160_valueStr;
+          Dafny.ISequence<Dafny.Rune> _out50;
+          _out50 = DCOMP.COMP.GenType(_157_value, inBinding, inFn);
+          _160_valueStr = _out50;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::collections::HashMap<"), _159_keyStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", ")), _160_valueStr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
         }
       } else if (_source5.is_Arrow) {
-        Dafny.ISequence<DAST._IType> _157___mcc_h10 = _source5.dtor_args;
-        DAST._IType _158___mcc_h11 = _source5.dtor_result;
-        DAST._IType _159_result = _158___mcc_h11;
-        Dafny.ISequence<DAST._IType> _160_args = _157___mcc_h10;
+        Dafny.ISequence<DAST._IType> _161___mcc_h11 = _source5.dtor_args;
+        DAST._IType _162___mcc_h12 = _source5.dtor_result;
+        DAST._IType _163_result = _162___mcc_h12;
+        Dafny.ISequence<DAST._IType> _164_args = _161___mcc_h11;
         {
           if (inBinding) {
             s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::FunctionWrapper<_>");
@@ -4951,35 +5061,35 @@ public partial class COMP {
             } else {
               s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::FunctionWrapper<impl ::std::ops::Fn(");
             }
-            BigInteger _161_i;
-            _161_i = BigInteger.Zero;
-            while ((_161_i) < (new BigInteger((_160_args).Count))) {
-              if ((_161_i).Sign == 1) {
+            BigInteger _165_i;
+            _165_i = BigInteger.Zero;
+            while ((_165_i) < (new BigInteger((_164_args).Count))) {
+              if ((_165_i).Sign == 1) {
                 s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
               }
-              Dafny.ISequence<Dafny.Rune> _162_generated;
-              Dafny.ISequence<Dafny.Rune> _out50;
-              _out50 = DCOMP.COMP.GenType((_160_args).Select(_161_i), inBinding, true);
-              _162_generated = _out50;
-              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&")), _162_generated);
-              _161_i = (_161_i) + (BigInteger.One);
-            }
-            Dafny.ISequence<Dafny.Rune> _163_resultType;
-            Dafny.ISequence<Dafny.Rune> _out51;
-            _out51 = DCOMP.COMP.GenType(_159_result, inBinding, inFn);
-            _163_resultType = _out51;
+              Dafny.ISequence<Dafny.Rune> _166_generated;
+              Dafny.ISequence<Dafny.Rune> _out51;
+              _out51 = DCOMP.COMP.GenType((_164_args).Select(_165_i), inBinding, true);
+              _166_generated = _out51;
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&")), _166_generated);
+              _165_i = (_165_i) + (BigInteger.One);
+            }
+            Dafny.ISequence<Dafny.Rune> _167_resultType;
+            Dafny.ISequence<Dafny.Rune> _out52;
+            _out52 = DCOMP.COMP.GenType(_163_result, inBinding, inFn);
+            _167_resultType = _out52;
             if (inFn) {
-              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> ")), _163_resultType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" + 'static>>"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> ")), _167_resultType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" + 'static>>"));
             } else {
-              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> ")), _163_resultType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" + Clone + 'static>"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> ")), _167_resultType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" + Clone + 'static>"));
             }
           }
         }
       } else if (_source5.is_Primitive) {
-        DAST._IPrimitive _164___mcc_h12 = _source5.dtor_Primitive_a0;
-        DAST._IPrimitive _165_p = _164___mcc_h12;
+        DAST._IPrimitive _168___mcc_h13 = _source5.dtor_Primitive_a0;
+        DAST._IPrimitive _169_p = _168___mcc_h13;
         {
-          DAST._IPrimitive _source7 = _165_p;
+          DAST._IPrimitive _source7 = _169_p;
           if (_source7.is_Int) {
             s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigInt");
           } else if (_source7.is_Real) {
@@ -4993,15 +5103,15 @@ public partial class COMP {
           }
         }
       } else if (_source5.is_Passthrough) {
-        Dafny.ISequence<Dafny.Rune> _166___mcc_h13 = _source5.dtor_Passthrough_a0;
-        Dafny.ISequence<Dafny.Rune> _167_v = _166___mcc_h13;
-        s = _167_v;
+        Dafny.ISequence<Dafny.Rune> _170___mcc_h14 = _source5.dtor_Passthrough_a0;
+        Dafny.ISequence<Dafny.Rune> _171_v = _170___mcc_h14;
+        s = _171_v;
       } else {
-        Dafny.ISequence<Dafny.Rune> _168___mcc_h14 = _source5.dtor_TypeArg_a0;
-        Dafny.ISequence<Dafny.Rune> _source8 = _168___mcc_h14;
-        Dafny.ISequence<Dafny.Rune> _169___mcc_h15 = _source8;
-        Dafny.ISequence<Dafny.Rune> _170_name = _169___mcc_h15;
-        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), _170_name);
+        Dafny.ISequence<Dafny.Rune> _172___mcc_h15 = _source5.dtor_TypeArg_a0;
+        Dafny.ISequence<Dafny.Rune> _source8 = _172___mcc_h15;
+        Dafny.ISequence<Dafny.Rune> _173___mcc_h16 = _source8;
+        Dafny.ISequence<Dafny.Rune> _174_name = _173___mcc_h16;
+        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), _174_name);
       }
       return s;
     }
@@ -5010,760 +5120,760 @@ public partial class COMP {
       traitBodies = Dafny.Map<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>>.Empty;
       s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
       traitBodies = Dafny.Map<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>>.FromElements();
-      BigInteger _171_i;
-      _171_i = BigInteger.Zero;
-      while ((_171_i) < (new BigInteger((body).Count))) {
-        DAST._IMethod _source9 = (body).Select(_171_i);
-        DAST._IMethod _172___mcc_h0 = _source9;
-        DAST._IMethod _173_m = _172___mcc_h0;
+      BigInteger _175_i;
+      _175_i = BigInteger.Zero;
+      while ((_175_i) < (new BigInteger((body).Count))) {
+        DAST._IMethod _source9 = (body).Select(_175_i);
+        DAST._IMethod _176___mcc_h0 = _source9;
+        DAST._IMethod _177_m = _176___mcc_h0;
         {
-          DAST._IOptional<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>> _source10 = (_173_m).dtor_overridingPath;
+          DAST._IOptional<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>> _source10 = (_177_m).dtor_overridingPath;
           if (_source10.is_Some) {
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _174___mcc_h1 = _source10.dtor_Some_a0;
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _175_p = _174___mcc_h1;
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _178___mcc_h1 = _source10.dtor_Some_a0;
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _179_p = _178___mcc_h1;
             {
-              Dafny.ISequence<Dafny.Rune> _176_existing;
-              _176_existing = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-              if ((traitBodies).Contains(_175_p)) {
-                _176_existing = Dafny.Map<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>>.Select(traitBodies, _175_p);
+              Dafny.ISequence<Dafny.Rune> _180_existing;
+              _180_existing = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+              if ((traitBodies).Contains(_179_p)) {
+                _180_existing = Dafny.Map<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>>.Select(traitBodies, _179_p);
               }
-              if ((new BigInteger((_176_existing).Count)).Sign == 1) {
-                _176_existing = Dafny.Sequence<Dafny.Rune>.Concat(_176_existing, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n"));
+              if ((new BigInteger((_180_existing).Count)).Sign == 1) {
+                _180_existing = Dafny.Sequence<Dafny.Rune>.Concat(_180_existing, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n"));
               }
-              Dafny.ISequence<Dafny.Rune> _177_genMethod;
-              Dafny.ISequence<Dafny.Rune> _out52;
-              _out52 = DCOMP.COMP.GenMethod(_173_m, true, enclosingType, enclosingTypeParams);
-              _177_genMethod = _out52;
-              _176_existing = Dafny.Sequence<Dafny.Rune>.Concat(_176_existing, _177_genMethod);
-              traitBodies = Dafny.Map<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>>.Merge(traitBodies, Dafny.Map<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>>.FromElements(new Dafny.Pair<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>>(_175_p, _176_existing)));
+              Dafny.ISequence<Dafny.Rune> _181_genMethod;
+              Dafny.ISequence<Dafny.Rune> _out53;
+              _out53 = DCOMP.COMP.GenMethod(_177_m, true, enclosingType, enclosingTypeParams);
+              _181_genMethod = _out53;
+              _180_existing = Dafny.Sequence<Dafny.Rune>.Concat(_180_existing, _181_genMethod);
+              traitBodies = Dafny.Map<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>>.Merge(traitBodies, Dafny.Map<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>>.FromElements(new Dafny.Pair<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>, Dafny.ISequence<Dafny.Rune>>(_179_p, _180_existing)));
             }
           } else {
             {
-              Dafny.ISequence<Dafny.Rune> _178_generated;
-              Dafny.ISequence<Dafny.Rune> _out53;
-              _out53 = DCOMP.COMP.GenMethod(_173_m, forTrait, enclosingType, enclosingTypeParams);
-              _178_generated = _out53;
-              s = Dafny.Sequence<Dafny.Rune>.Concat(s, _178_generated);
+              Dafny.ISequence<Dafny.Rune> _182_generated;
+              Dafny.ISequence<Dafny.Rune> _out54;
+              _out54 = DCOMP.COMP.GenMethod(_177_m, forTrait, enclosingType, enclosingTypeParams);
+              _182_generated = _out54;
+              s = Dafny.Sequence<Dafny.Rune>.Concat(s, _182_generated);
             }
           }
         }
         if ((new BigInteger((s).Count)).Sign == 1) {
           s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n"));
         }
-        _171_i = (_171_i) + (BigInteger.One);
+        _175_i = (_175_i) + (BigInteger.One);
       }
     }
     public static Dafny.ISequence<Dafny.Rune> GenParams(Dafny.ISequence<DAST._IFormal> @params) {
       Dafny.ISequence<Dafny.Rune> s = Dafny.Sequence<Dafny.Rune>.Empty;
       s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-      BigInteger _179_i;
-      _179_i = BigInteger.Zero;
-      while ((_179_i) < (new BigInteger((@params).Count))) {
-        DAST._IFormal _180_param;
-        _180_param = (@params).Select(_179_i);
-        Dafny.ISequence<Dafny.Rune> _181_paramType;
-        Dafny.ISequence<Dafny.Rune> _out54;
-        _out54 = DCOMP.COMP.GenType((_180_param).dtor_typ, false, false);
-        _181_paramType = _out54;
-        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_180_param).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": &")), _181_paramType);
-        if ((_179_i) < ((new BigInteger((@params).Count)) - (BigInteger.One))) {
+      BigInteger _183_i;
+      _183_i = BigInteger.Zero;
+      while ((_183_i) < (new BigInteger((@params).Count))) {
+        DAST._IFormal _184_param;
+        _184_param = (@params).Select(_183_i);
+        Dafny.ISequence<Dafny.Rune> _185_paramType;
+        Dafny.ISequence<Dafny.Rune> _out55;
+        _out55 = DCOMP.COMP.GenType((_184_param).dtor_typ, false, false);
+        _185_paramType = _out55;
+        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_184_param).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": &")), _185_paramType);
+        if ((_183_i) < ((new BigInteger((@params).Count)) - (BigInteger.One))) {
           s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
         }
-        _179_i = (_179_i) + (BigInteger.One);
+        _183_i = (_183_i) + (BigInteger.One);
       }
       return s;
     }
     public static Dafny.ISequence<Dafny.Rune> GenMethod(DAST._IMethod m, bool forTrait, DAST._IType enclosingType, Dafny.ISet<DAST._IType> enclosingTypeParams) {
       Dafny.ISequence<Dafny.Rune> s = Dafny.Sequence<Dafny.Rune>.Empty;
-      Dafny.ISequence<Dafny.Rune> _182_params;
-      Dafny.ISequence<Dafny.Rune> _out55;
-      _out55 = DCOMP.COMP.GenParams((m).dtor_params);
-      _182_params = _out55;
-      Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _183_paramNames;
-      _183_paramNames = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements();
-      BigInteger _184_paramI;
-      _184_paramI = BigInteger.Zero;
-      while ((_184_paramI) < (new BigInteger(((m).dtor_params).Count))) {
-        _183_paramNames = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.Concat(_183_paramNames, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements((((m).dtor_params).Select(_184_paramI)).dtor_name));
-        _184_paramI = (_184_paramI) + (BigInteger.One);
+      Dafny.ISequence<Dafny.Rune> _186_params;
+      Dafny.ISequence<Dafny.Rune> _out56;
+      _out56 = DCOMP.COMP.GenParams((m).dtor_params);
+      _186_params = _out56;
+      Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _187_paramNames;
+      _187_paramNames = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements();
+      BigInteger _188_paramI;
+      _188_paramI = BigInteger.Zero;
+      while ((_188_paramI) < (new BigInteger(((m).dtor_params).Count))) {
+        _187_paramNames = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.Concat(_187_paramNames, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements((((m).dtor_params).Select(_188_paramI)).dtor_name));
+        _188_paramI = (_188_paramI) + (BigInteger.One);
       }
       if (!((m).dtor_isStatic)) {
         if (forTrait) {
-          _182_params = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&self"), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", ")), _182_params);
+          _186_params = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&self"), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", ")), _186_params);
         } else {
-          Dafny.ISequence<Dafny.Rune> _185_enclosingTypeString;
-          Dafny.ISequence<Dafny.Rune> _out56;
-          _out56 = DCOMP.COMP.GenType(enclosingType, false, false);
-          _185_enclosingTypeString = _out56;
-          _182_params = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("self: &"), _185_enclosingTypeString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", ")), _182_params);
+          Dafny.ISequence<Dafny.Rune> _189_enclosingTypeString;
+          Dafny.ISequence<Dafny.Rune> _out57;
+          _out57 = DCOMP.COMP.GenType(enclosingType, false, false);
+          _189_enclosingTypeString = _out57;
+          _186_params = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("self: &"), _189_enclosingTypeString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", ")), _186_params);
         }
       }
-      Dafny.ISequence<Dafny.Rune> _186_retType;
-      _186_retType = (((new BigInteger(((m).dtor_outTypes).Count)) != (BigInteger.One)) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("")));
-      BigInteger _187_typeI;
-      _187_typeI = BigInteger.Zero;
-      while ((_187_typeI) < (new BigInteger(((m).dtor_outTypes).Count))) {
-        if ((_187_typeI).Sign == 1) {
-          _186_retType = Dafny.Sequence<Dafny.Rune>.Concat(_186_retType, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+      Dafny.ISequence<Dafny.Rune> _190_retType;
+      _190_retType = (((new BigInteger(((m).dtor_outTypes).Count)) != (BigInteger.One)) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("")));
+      BigInteger _191_typeI;
+      _191_typeI = BigInteger.Zero;
+      while ((_191_typeI) < (new BigInteger(((m).dtor_outTypes).Count))) {
+        if ((_191_typeI).Sign == 1) {
+          _190_retType = Dafny.Sequence<Dafny.Rune>.Concat(_190_retType, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
         }
-        Dafny.ISequence<Dafny.Rune> _188_typeString;
-        Dafny.ISequence<Dafny.Rune> _out57;
-        _out57 = DCOMP.COMP.GenType(((m).dtor_outTypes).Select(_187_typeI), false, false);
-        _188_typeString = _out57;
-        _186_retType = Dafny.Sequence<Dafny.Rune>.Concat(_186_retType, _188_typeString);
-        _187_typeI = (_187_typeI) + (BigInteger.One);
+        Dafny.ISequence<Dafny.Rune> _192_typeString;
+        Dafny.ISequence<Dafny.Rune> _out58;
+        _out58 = DCOMP.COMP.GenType(((m).dtor_outTypes).Select(_191_typeI), false, false);
+        _192_typeString = _out58;
+        _190_retType = Dafny.Sequence<Dafny.Rune>.Concat(_190_retType, _192_typeString);
+        _191_typeI = (_191_typeI) + (BigInteger.One);
       }
       if ((new BigInteger(((m).dtor_outTypes).Count)) != (BigInteger.One)) {
-        _186_retType = Dafny.Sequence<Dafny.Rune>.Concat(_186_retType, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+        _190_retType = Dafny.Sequence<Dafny.Rune>.Concat(_190_retType, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
       }
       if (forTrait) {
         s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("fn r#"), (m).dtor_name);
       } else {
         s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("pub fn r#"), (m).dtor_name);
       }
-      Dafny.ISequence<DAST._IType> _189_typeParamsFiltered;
-      _189_typeParamsFiltered = Dafny.Sequence<DAST._IType>.FromElements();
-      BigInteger _190_typeParamI;
-      _190_typeParamI = BigInteger.Zero;
-      while ((_190_typeParamI) < (new BigInteger(((m).dtor_typeParams).Count))) {
-        DAST._IType _191_typeParam;
-        _191_typeParam = ((m).dtor_typeParams).Select(_190_typeParamI);
-        if (!((enclosingTypeParams).Contains(_191_typeParam))) {
-          _189_typeParamsFiltered = Dafny.Sequence<DAST._IType>.Concat(_189_typeParamsFiltered, Dafny.Sequence<DAST._IType>.FromElements(_191_typeParam));
+      Dafny.ISequence<DAST._IType> _193_typeParamsFiltered;
+      _193_typeParamsFiltered = Dafny.Sequence<DAST._IType>.FromElements();
+      BigInteger _194_typeParamI;
+      _194_typeParamI = BigInteger.Zero;
+      while ((_194_typeParamI) < (new BigInteger(((m).dtor_typeParams).Count))) {
+        DAST._IType _195_typeParam;
+        _195_typeParam = ((m).dtor_typeParams).Select(_194_typeParamI);
+        if (!((enclosingTypeParams).Contains(_195_typeParam))) {
+          _193_typeParamsFiltered = Dafny.Sequence<DAST._IType>.Concat(_193_typeParamsFiltered, Dafny.Sequence<DAST._IType>.FromElements(_195_typeParam));
         }
-        _190_typeParamI = (_190_typeParamI) + (BigInteger.One);
+        _194_typeParamI = (_194_typeParamI) + (BigInteger.One);
       }
-      if ((new BigInteger((_189_typeParamsFiltered).Count)).Sign == 1) {
+      if ((new BigInteger((_193_typeParamsFiltered).Count)).Sign == 1) {
         s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"));
-        BigInteger _192_i;
-        _192_i = BigInteger.Zero;
-        while ((_192_i) < (new BigInteger((_189_typeParamsFiltered).Count))) {
-          if ((_192_i).Sign == 1) {
+        BigInteger _196_i;
+        _196_i = BigInteger.Zero;
+        while ((_196_i) < (new BigInteger((_193_typeParamsFiltered).Count))) {
+          if ((_196_i).Sign == 1) {
             s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
           }
-          Dafny.ISequence<Dafny.Rune> _193_typeString;
-          Dafny.ISequence<Dafny.Rune> _out58;
-          _out58 = DCOMP.COMP.GenType((_189_typeParamsFiltered).Select(_192_i), false, false);
-          _193_typeString = _out58;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, _193_typeString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ::dafny_runtime::DafnyErasable + ::dafny_runtime::DafnyUnerasable<")), _193_typeString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("> + Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static"));
-          _192_i = (_192_i) + (BigInteger.One);
+          Dafny.ISequence<Dafny.Rune> _197_typeString;
+          Dafny.ISequence<Dafny.Rune> _out59;
+          _out59 = DCOMP.COMP.GenType((_193_typeParamsFiltered).Select(_196_i), false, false);
+          _197_typeString = _out59;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, _197_typeString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ::dafny_runtime::DafnyErasable + ::dafny_runtime::DafnyUnerasable<")), _197_typeString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("> + Clone + ::std::cmp::PartialEq + ::dafny_runtime::DafnyPrint + ::std::default::Default + 'static"));
+          _196_i = (_196_i) + (BigInteger.One);
         }
         s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
       }
-      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _182_params), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> ")), _186_retType);
+      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _186_params), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") -> ")), _190_retType);
       if ((m).dtor_hasBody) {
-        Dafny.ISequence<Dafny.Rune> _194_earlyReturn;
-        _194_earlyReturn = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("return;");
+        Dafny.ISequence<Dafny.Rune> _198_earlyReturn;
+        _198_earlyReturn = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("return;");
         DAST._IOptional<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>> _source11 = (m).dtor_outVars;
         if (_source11.is_Some) {
-          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _195___mcc_h0 = _source11.dtor_Some_a0;
-          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _196_outVars = _195___mcc_h0;
+          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _199___mcc_h0 = _source11.dtor_Some_a0;
+          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _200_outVars = _199___mcc_h0;
           {
-            _194_earlyReturn = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("return (");
-            BigInteger _197_outI;
-            _197_outI = BigInteger.Zero;
-            while ((_197_outI) < (new BigInteger((_196_outVars).Count))) {
-              if ((_197_outI).Sign == 1) {
-                _194_earlyReturn = Dafny.Sequence<Dafny.Rune>.Concat(_194_earlyReturn, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+            _198_earlyReturn = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("return (");
+            BigInteger _201_outI;
+            _201_outI = BigInteger.Zero;
+            while ((_201_outI) < (new BigInteger((_200_outVars).Count))) {
+              if ((_201_outI).Sign == 1) {
+                _198_earlyReturn = Dafny.Sequence<Dafny.Rune>.Concat(_198_earlyReturn, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
               }
-              Dafny.ISequence<Dafny.Rune> _198_outVar;
-              _198_outVar = (_196_outVars).Select(_197_outI);
-              _194_earlyReturn = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_194_earlyReturn, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_198_outVar));
-              _197_outI = (_197_outI) + (BigInteger.One);
+              Dafny.ISequence<Dafny.Rune> _202_outVar;
+              _202_outVar = (_200_outVars).Select(_201_outI);
+              _198_earlyReturn = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_198_earlyReturn, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_202_outVar));
+              _201_outI = (_201_outI) + (BigInteger.One);
             }
-            _194_earlyReturn = Dafny.Sequence<Dafny.Rune>.Concat(_194_earlyReturn, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(");"));
+            _198_earlyReturn = Dafny.Sequence<Dafny.Rune>.Concat(_198_earlyReturn, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(");"));
           }
         } else {
         }
-        Dafny.ISequence<Dafny.Rune> _199_body;
-        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _200___v12;
-        Dafny.ISequence<Dafny.Rune> _out59;
-        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out60;
-        DCOMP.COMP.GenStmts((m).dtor_body, _183_paramNames, true, _194_earlyReturn, out _out59, out _out60);
-        _199_body = _out59;
-        _200___v12 = _out60;
+        Dafny.ISequence<Dafny.Rune> _203_body;
+        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _204___v12;
+        Dafny.ISequence<Dafny.Rune> _out60;
+        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out61;
+        DCOMP.COMP.GenStmts((m).dtor_body, (((m).dtor_isStatic) ? (DAST.Optional<Dafny.ISequence<Dafny.Rune>>.create_None()) : (DAST.Optional<Dafny.ISequence<Dafny.Rune>>.create_Some(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("self")))), _187_paramNames, true, _198_earlyReturn, out _out60, out _out61);
+        _203_body = _out60;
+        _204___v12 = _out61;
         DAST._IOptional<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>> _source12 = (m).dtor_outVars;
         if (_source12.is_Some) {
-          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _201___mcc_h1 = _source12.dtor_Some_a0;
-          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _202_outVars = _201___mcc_h1;
+          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _205___mcc_h1 = _source12.dtor_Some_a0;
+          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _206_outVars = _205___mcc_h1;
           {
-            _199_body = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_199_body, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _194_earlyReturn);
+            _203_body = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_203_body, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n")), _198_earlyReturn);
           }
         } else {
         }
-        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _199_body), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}\n"));
+        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _203_body), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}\n"));
       } else {
         s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";\n"));
       }
       return s;
     }
-    public static void GenStmts(Dafny.ISequence<DAST._IStatement> stmts, Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> @params, bool isLast, Dafny.ISequence<Dafny.Rune> earlyReturn, out Dafny.ISequence<Dafny.Rune> generated, out Dafny.ISet<Dafny.ISequence<Dafny.Rune>> readIdents) {
+    public static void GenStmts(Dafny.ISequence<DAST._IStatement> stmts, DAST._IOptional<Dafny.ISequence<Dafny.Rune>> selfIdent, Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> @params, bool isLast, Dafny.ISequence<Dafny.Rune> earlyReturn, out Dafny.ISequence<Dafny.Rune> generated, out Dafny.ISet<Dafny.ISequence<Dafny.Rune>> readIdents) {
       generated = Dafny.Sequence<Dafny.Rune>.Empty;
       readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Empty;
       generated = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
       readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
-      BigInteger _203_i;
-      _203_i = BigInteger.Zero;
-      while ((_203_i) < (new BigInteger((stmts).Count))) {
-        DAST._IStatement _204_stmt;
-        _204_stmt = (stmts).Select(_203_i);
-        Dafny.ISequence<Dafny.Rune> _205_stmtString;
-        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _206_recIdents;
-        Dafny.ISequence<Dafny.Rune> _out61;
-        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out62;
-        DCOMP.COMP.GenStmt(_204_stmt, @params, (isLast) && ((_203_i) == ((new BigInteger((stmts).Count)) - (BigInteger.One))), earlyReturn, out _out61, out _out62);
-        _205_stmtString = _out61;
-        _206_recIdents = _out62;
-        readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _206_recIdents);
-        if ((_203_i).Sign == 1) {
+      BigInteger _207_i;
+      _207_i = BigInteger.Zero;
+      while ((_207_i) < (new BigInteger((stmts).Count))) {
+        DAST._IStatement _208_stmt;
+        _208_stmt = (stmts).Select(_207_i);
+        Dafny.ISequence<Dafny.Rune> _209_stmtString;
+        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _210_recIdents;
+        Dafny.ISequence<Dafny.Rune> _out62;
+        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out63;
+        DCOMP.COMP.GenStmt(_208_stmt, selfIdent, @params, (isLast) && ((_207_i) == ((new BigInteger((stmts).Count)) - (BigInteger.One))), earlyReturn, out _out62, out _out63);
+        _209_stmtString = _out62;
+        _210_recIdents = _out63;
+        readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _210_recIdents);
+        if ((_207_i).Sign == 1) {
           generated = Dafny.Sequence<Dafny.Rune>.Concat(generated, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n"));
         }
-        generated = Dafny.Sequence<Dafny.Rune>.Concat(generated, _205_stmtString);
-        _203_i = (_203_i) + (BigInteger.One);
+        generated = Dafny.Sequence<Dafny.Rune>.Concat(generated, _209_stmtString);
+        _207_i = (_207_i) + (BigInteger.One);
       }
     }
-    public static void GenAssignLhs(DAST._IAssignLhs lhs, Dafny.ISequence<Dafny.Rune> rhs, Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> @params, out Dafny.ISequence<Dafny.Rune> generated, out bool needsIIFE, out Dafny.ISet<Dafny.ISequence<Dafny.Rune>> readIdents) {
+    public static void GenAssignLhs(DAST._IAssignLhs lhs, Dafny.ISequence<Dafny.Rune> rhs, DAST._IOptional<Dafny.ISequence<Dafny.Rune>> selfIdent, Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> @params, out Dafny.ISequence<Dafny.Rune> generated, out bool needsIIFE, out Dafny.ISet<Dafny.ISequence<Dafny.Rune>> readIdents) {
       generated = Dafny.Sequence<Dafny.Rune>.Empty;
       needsIIFE = false;
       readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Empty;
       DAST._IAssignLhs _source13 = lhs;
       if (_source13.is_Ident) {
-        Dafny.ISequence<Dafny.Rune> _207___mcc_h0 = _source13.dtor_Ident_a0;
-        Dafny.ISequence<Dafny.Rune> _source14 = _207___mcc_h0;
-        Dafny.ISequence<Dafny.Rune> _208___mcc_h1 = _source14;
-        Dafny.ISequence<Dafny.Rune> _209_id = _208___mcc_h1;
+        Dafny.ISequence<Dafny.Rune> _211___mcc_h0 = _source13.dtor_Ident_a0;
+        Dafny.ISequence<Dafny.Rune> _source14 = _211___mcc_h0;
+        Dafny.ISequence<Dafny.Rune> _212___mcc_h1 = _source14;
+        Dafny.ISequence<Dafny.Rune> _213_id = _212___mcc_h1;
         {
-          if ((@params).Contains(_209_id)) {
-            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("*r#"), _209_id);
+          if ((@params).Contains(_213_id)) {
+            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("*r#"), _213_id);
           } else {
-            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), _209_id);
+            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), _213_id);
           }
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(_209_id);
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(_213_id);
           needsIIFE = false;
         }
       } else if (_source13.is_Select) {
-        DAST._IExpression _210___mcc_h2 = _source13.dtor_expr;
-        Dafny.ISequence<Dafny.Rune> _211___mcc_h3 = _source13.dtor_field;
-        Dafny.ISequence<Dafny.Rune> _212_field = _211___mcc_h3;
-        DAST._IExpression _213_on = _210___mcc_h2;
+        DAST._IExpression _214___mcc_h2 = _source13.dtor_expr;
+        Dafny.ISequence<Dafny.Rune> _215___mcc_h3 = _source13.dtor_field;
+        Dafny.ISequence<Dafny.Rune> _216_field = _215___mcc_h3;
+        DAST._IExpression _217_on = _214___mcc_h2;
         {
-          Dafny.ISequence<Dafny.Rune> _214_onExpr;
-          bool _215_onOwned;
-          bool _216_onErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _217_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out63;
-          bool _out64;
+          Dafny.ISequence<Dafny.Rune> _218_onExpr;
+          bool _219_onOwned;
+          bool _220_onErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _221_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out64;
           bool _out65;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out66;
-          DCOMP.COMP.GenExpr(_213_on, @params, false, out _out63, out _out64, out _out65, out _out66);
-          _214_onExpr = _out63;
-          _215_onOwned = _out64;
-          _216_onErased = _out65;
-          _217_recIdents = _out66;
-          if (!(_216_onErased)) {
-            Dafny.ISequence<Dafny.Rune> _218_eraseFn;
-            _218_eraseFn = ((_215_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-            _214_onExpr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _218_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _214_onExpr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          bool _out66;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out67;
+          DCOMP.COMP.GenExpr(_217_on, selfIdent, @params, false, out _out64, out _out65, out _out66, out _out67);
+          _218_onExpr = _out64;
+          _219_onOwned = _out65;
+          _220_onErased = _out66;
+          _221_recIdents = _out67;
+          if (!(_220_onErased)) {
+            Dafny.ISequence<Dafny.Rune> _222_eraseFn;
+            _222_eraseFn = ((_219_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+            _218_onExpr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _222_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _218_onExpr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("*("), _214_onExpr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".")), _212_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow_mut()) = ")), rhs), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";"));
-          readIdents = _217_recIdents;
+          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("*("), _218_onExpr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".")), _216_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow_mut()) = ")), rhs), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";"));
+          readIdents = _221_recIdents;
           needsIIFE = true;
         }
       } else {
-        DAST._IExpression _219___mcc_h4 = _source13.dtor_expr;
-        DAST._IExpression _220___mcc_h5 = _source13.dtor_idx;
-        DAST._IExpression _221_idx = _220___mcc_h5;
-        DAST._IExpression _222_on = _219___mcc_h4;
+        DAST._IExpression _223___mcc_h4 = _source13.dtor_expr;
+        DAST._IExpression _224___mcc_h5 = _source13.dtor_idx;
+        DAST._IExpression _225_idx = _224___mcc_h5;
+        DAST._IExpression _226_on = _223___mcc_h4;
         {
-          Dafny.ISequence<Dafny.Rune> _223_onExpr;
-          bool _224_onOwned;
-          bool _225_onErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _226_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out67;
-          bool _out68;
+          Dafny.ISequence<Dafny.Rune> _227_onExpr;
+          bool _228_onOwned;
+          bool _229_onErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _230_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out68;
           bool _out69;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out70;
-          DCOMP.COMP.GenExpr(_222_on, @params, false, out _out67, out _out68, out _out69, out _out70);
-          _223_onExpr = _out67;
-          _224_onOwned = _out68;
-          _225_onErased = _out69;
-          _226_recIdents = _out70;
-          if (!(_225_onErased)) {
-            Dafny.ISequence<Dafny.Rune> _227_eraseFn;
-            _227_eraseFn = ((_224_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-            _223_onExpr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _227_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _223_onExpr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          bool _out70;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out71;
+          DCOMP.COMP.GenExpr(_226_on, selfIdent, @params, false, out _out68, out _out69, out _out70, out _out71);
+          _227_onExpr = _out68;
+          _228_onOwned = _out69;
+          _229_onErased = _out70;
+          _230_recIdents = _out71;
+          if (!(_229_onErased)) {
+            Dafny.ISequence<Dafny.Rune> _231_eraseFn;
+            _231_eraseFn = ((_228_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+            _227_onExpr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _231_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _227_onExpr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          Dafny.ISequence<Dafny.Rune> _228_idxString;
-          bool _229___v13;
-          bool _230_idxErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _231_idxIdents;
-          Dafny.ISequence<Dafny.Rune> _out71;
-          bool _out72;
+          Dafny.ISequence<Dafny.Rune> _232_idxString;
+          bool _233___v13;
+          bool _234_idxErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _235_idxIdents;
+          Dafny.ISequence<Dafny.Rune> _out72;
           bool _out73;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out74;
-          DCOMP.COMP.GenExpr(_221_idx, @params, true, out _out71, out _out72, out _out73, out _out74);
-          _228_idxString = _out71;
-          _229___v13 = _out72;
-          _230_idxErased = _out73;
-          _231_idxIdents = _out74;
-          if (!(_230_idxErased)) {
-            _228_idxString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _228_idxString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          bool _out74;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out75;
+          DCOMP.COMP.GenExpr(_225_idx, selfIdent, @params, true, out _out72, out _out73, out _out74, out _out75);
+          _232_idxString = _out72;
+          _233___v13 = _out73;
+          _234_idxErased = _out74;
+          _235_idxIdents = _out75;
+          if (!(_234_idxErased)) {
+            _232_idxString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _232_idxString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("{\nlet __idx = <usize as ::dafny_runtime::NumCast>::from("), _228_idxString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap();\n"));
-          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(generated, _223_onExpr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow_mut()[__idx] = ")), rhs), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";\n}"));
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_226_recIdents, _231_idxIdents);
+          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("{\nlet __idx = <usize as ::dafny_runtime::NumCast>::from("), _232_idxString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap();\n"));
+          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(generated, _227_onExpr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow_mut()[__idx] = ")), rhs), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";\n}"));
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_230_recIdents, _235_idxIdents);
           needsIIFE = true;
         }
       }
     }
-    public static void GenStmt(DAST._IStatement stmt, Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> @params, bool isLast, Dafny.ISequence<Dafny.Rune> earlyReturn, out Dafny.ISequence<Dafny.Rune> generated, out Dafny.ISet<Dafny.ISequence<Dafny.Rune>> readIdents) {
+    public static void GenStmt(DAST._IStatement stmt, DAST._IOptional<Dafny.ISequence<Dafny.Rune>> selfIdent, Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> @params, bool isLast, Dafny.ISequence<Dafny.Rune> earlyReturn, out Dafny.ISequence<Dafny.Rune> generated, out Dafny.ISet<Dafny.ISequence<Dafny.Rune>> readIdents) {
       generated = Dafny.Sequence<Dafny.Rune>.Empty;
       readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Empty;
       DAST._IStatement _source15 = stmt;
       if (_source15.is_DeclareVar) {
-        Dafny.ISequence<Dafny.Rune> _232___mcc_h0 = _source15.dtor_name;
-        DAST._IType _233___mcc_h1 = _source15.dtor_typ;
-        DAST._IOptional<DAST._IExpression> _234___mcc_h2 = _source15.dtor_maybeValue;
-        DAST._IOptional<DAST._IExpression> _source16 = _234___mcc_h2;
+        Dafny.ISequence<Dafny.Rune> _236___mcc_h0 = _source15.dtor_name;
+        DAST._IType _237___mcc_h1 = _source15.dtor_typ;
+        DAST._IOptional<DAST._IExpression> _238___mcc_h2 = _source15.dtor_maybeValue;
+        DAST._IOptional<DAST._IExpression> _source16 = _238___mcc_h2;
         if (_source16.is_Some) {
-          DAST._IExpression _235___mcc_h3 = _source16.dtor_Some_a0;
-          DAST._IExpression _236_expression = _235___mcc_h3;
-          DAST._IType _237_typ = _233___mcc_h1;
-          Dafny.ISequence<Dafny.Rune> _238_name = _232___mcc_h0;
+          DAST._IExpression _239___mcc_h3 = _source16.dtor_Some_a0;
+          DAST._IExpression _240_expression = _239___mcc_h3;
+          DAST._IType _241_typ = _237___mcc_h1;
+          Dafny.ISequence<Dafny.Rune> _242_name = _236___mcc_h0;
           {
-            Dafny.ISequence<Dafny.Rune> _239_expr;
-            bool _240___v14;
-            bool _241_recErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _242_recIdents;
-            Dafny.ISequence<Dafny.Rune> _out75;
-            bool _out76;
+            Dafny.ISequence<Dafny.Rune> _243_expr;
+            bool _244___v14;
+            bool _245_recErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _246_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out76;
             bool _out77;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out78;
-            DCOMP.COMP.GenExpr(_236_expression, @params, true, out _out75, out _out76, out _out77, out _out78);
-            _239_expr = _out75;
-            _240___v14 = _out76;
-            _241_recErased = _out77;
-            _242_recIdents = _out78;
-            if (_241_recErased) {
-              _239_expr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _239_expr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-            }
-            Dafny.ISequence<Dafny.Rune> _243_typeString;
-            Dafny.ISequence<Dafny.Rune> _out79;
-            _out79 = DCOMP.COMP.GenType(_237_typ, true, false);
-            _243_typeString = _out79;
-            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let mut r#"), _238_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ")), _243_typeString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = ")), _239_expr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";"));
-            readIdents = _242_recIdents;
+            bool _out78;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out79;
+            DCOMP.COMP.GenExpr(_240_expression, selfIdent, @params, true, out _out76, out _out77, out _out78, out _out79);
+            _243_expr = _out76;
+            _244___v14 = _out77;
+            _245_recErased = _out78;
+            _246_recIdents = _out79;
+            if (_245_recErased) {
+              _243_expr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _243_expr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            Dafny.ISequence<Dafny.Rune> _247_typeString;
+            Dafny.ISequence<Dafny.Rune> _out80;
+            _out80 = DCOMP.COMP.GenType(_241_typ, true, false);
+            _247_typeString = _out80;
+            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let mut r#"), _242_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ")), _247_typeString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = ")), _243_expr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";"));
+            readIdents = _246_recIdents;
           }
         } else {
-          DAST._IType _244_typ = _233___mcc_h1;
-          Dafny.ISequence<Dafny.Rune> _245_name = _232___mcc_h0;
+          DAST._IType _248_typ = _237___mcc_h1;
+          Dafny.ISequence<Dafny.Rune> _249_name = _236___mcc_h0;
           {
-            Dafny.ISequence<Dafny.Rune> _246_typeString;
-            Dafny.ISequence<Dafny.Rune> _out80;
-            _out80 = DCOMP.COMP.GenType(_244_typ, true, false);
-            _246_typeString = _out80;
-            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let mut r#"), _245_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ")), _246_typeString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";"));
+            Dafny.ISequence<Dafny.Rune> _250_typeString;
+            Dafny.ISequence<Dafny.Rune> _out81;
+            _out81 = DCOMP.COMP.GenType(_248_typ, true, false);
+            _250_typeString = _out81;
+            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let mut r#"), _249_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ")), _250_typeString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";"));
             readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
           }
         }
       } else if (_source15.is_Assign) {
-        DAST._IAssignLhs _247___mcc_h4 = _source15.dtor_lhs;
-        DAST._IExpression _248___mcc_h5 = _source15.dtor_value;
-        DAST._IExpression _249_expression = _248___mcc_h5;
-        DAST._IAssignLhs _250_lhs = _247___mcc_h4;
+        DAST._IAssignLhs _251___mcc_h4 = _source15.dtor_lhs;
+        DAST._IExpression _252___mcc_h5 = _source15.dtor_value;
+        DAST._IExpression _253_expression = _252___mcc_h5;
+        DAST._IAssignLhs _254_lhs = _251___mcc_h4;
         {
-          Dafny.ISequence<Dafny.Rune> _251_lhsGen;
-          bool _252_needsIIFE;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _253_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out81;
-          bool _out82;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out83;
-          DCOMP.COMP.GenAssignLhs(_250_lhs, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("__rhs"), @params, out _out81, out _out82, out _out83);
-          _251_lhsGen = _out81;
-          _252_needsIIFE = _out82;
-          _253_recIdents = _out83;
-          Dafny.ISequence<Dafny.Rune> _254_exprGen;
-          bool _255___v15;
-          bool _256_exprErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _257_exprIdents;
-          Dafny.ISequence<Dafny.Rune> _out84;
-          bool _out85;
+          Dafny.ISequence<Dafny.Rune> _255_lhsGen;
+          bool _256_needsIIFE;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _257_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out82;
+          bool _out83;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out84;
+          DCOMP.COMP.GenAssignLhs(_254_lhs, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("__rhs"), selfIdent, @params, out _out82, out _out83, out _out84);
+          _255_lhsGen = _out82;
+          _256_needsIIFE = _out83;
+          _257_recIdents = _out84;
+          Dafny.ISequence<Dafny.Rune> _258_exprGen;
+          bool _259___v15;
+          bool _260_exprErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _261_exprIdents;
+          Dafny.ISequence<Dafny.Rune> _out85;
           bool _out86;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out87;
-          DCOMP.COMP.GenExpr(_249_expression, @params, true, out _out84, out _out85, out _out86, out _out87);
-          _254_exprGen = _out84;
-          _255___v15 = _out85;
-          _256_exprErased = _out86;
-          _257_exprIdents = _out87;
-          if (_256_exprErased) {
-            _254_exprGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _254_exprGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          bool _out87;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out88;
+          DCOMP.COMP.GenExpr(_253_expression, selfIdent, @params, true, out _out85, out _out86, out _out87, out _out88);
+          _258_exprGen = _out85;
+          _259___v15 = _out86;
+          _260_exprErased = _out87;
+          _261_exprIdents = _out88;
+          if (_260_exprErased) {
+            _258_exprGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _258_exprGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          if (_252_needsIIFE) {
-            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("{\nlet __rhs = "), _254_exprGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";\n")), _251_lhsGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
+          if (_256_needsIIFE) {
+            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("{\nlet __rhs = "), _258_exprGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";\n")), _255_lhsGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
           } else {
-            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_251_lhsGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = ")), _254_exprGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";"));
+            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_255_lhsGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = ")), _258_exprGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";"));
           }
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_253_recIdents, _257_exprIdents);
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_257_recIdents, _261_exprIdents);
         }
       } else if (_source15.is_If) {
-        DAST._IExpression _258___mcc_h6 = _source15.dtor_cond;
-        Dafny.ISequence<DAST._IStatement> _259___mcc_h7 = _source15.dtor_thn;
-        Dafny.ISequence<DAST._IStatement> _260___mcc_h8 = _source15.dtor_els;
-        Dafny.ISequence<DAST._IStatement> _261_els = _260___mcc_h8;
-        Dafny.ISequence<DAST._IStatement> _262_thn = _259___mcc_h7;
-        DAST._IExpression _263_cond = _258___mcc_h6;
+        DAST._IExpression _262___mcc_h6 = _source15.dtor_cond;
+        Dafny.ISequence<DAST._IStatement> _263___mcc_h7 = _source15.dtor_thn;
+        Dafny.ISequence<DAST._IStatement> _264___mcc_h8 = _source15.dtor_els;
+        Dafny.ISequence<DAST._IStatement> _265_els = _264___mcc_h8;
+        Dafny.ISequence<DAST._IStatement> _266_thn = _263___mcc_h7;
+        DAST._IExpression _267_cond = _262___mcc_h6;
         {
-          Dafny.ISequence<Dafny.Rune> _264_condString;
-          bool _265___v16;
-          bool _266_condErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _267_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out88;
-          bool _out89;
+          Dafny.ISequence<Dafny.Rune> _268_condString;
+          bool _269___v16;
+          bool _270_condErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _271_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out89;
           bool _out90;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out91;
-          DCOMP.COMP.GenExpr(_263_cond, @params, true, out _out88, out _out89, out _out90, out _out91);
-          _264_condString = _out88;
-          _265___v16 = _out89;
-          _266_condErased = _out90;
-          _267_recIdents = _out91;
-          if (!(_266_condErased)) {
-            _264_condString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _264_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          bool _out91;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out92;
+          DCOMP.COMP.GenExpr(_267_cond, selfIdent, @params, true, out _out89, out _out90, out _out91, out _out92);
+          _268_condString = _out89;
+          _269___v16 = _out90;
+          _270_condErased = _out91;
+          _271_recIdents = _out92;
+          if (!(_270_condErased)) {
+            _268_condString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _268_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          readIdents = _267_recIdents;
-          Dafny.ISequence<Dafny.Rune> _268_thnString;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _269_thnIdents;
-          Dafny.ISequence<Dafny.Rune> _out92;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out93;
-          DCOMP.COMP.GenStmts(_262_thn, @params, isLast, earlyReturn, out _out92, out _out93);
-          _268_thnString = _out92;
-          _269_thnIdents = _out93;
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _269_thnIdents);
-          Dafny.ISequence<Dafny.Rune> _270_elsString;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _271_elsIdents;
-          Dafny.ISequence<Dafny.Rune> _out94;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out95;
-          DCOMP.COMP.GenStmts(_261_els, @params, isLast, earlyReturn, out _out94, out _out95);
-          _270_elsString = _out94;
-          _271_elsIdents = _out95;
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _271_elsIdents);
-          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("if "), _264_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _268_thnString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n} else {\n")), _270_elsString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
+          readIdents = _271_recIdents;
+          Dafny.ISequence<Dafny.Rune> _272_thnString;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _273_thnIdents;
+          Dafny.ISequence<Dafny.Rune> _out93;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out94;
+          DCOMP.COMP.GenStmts(_266_thn, selfIdent, @params, isLast, earlyReturn, out _out93, out _out94);
+          _272_thnString = _out93;
+          _273_thnIdents = _out94;
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _273_thnIdents);
+          Dafny.ISequence<Dafny.Rune> _274_elsString;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _275_elsIdents;
+          Dafny.ISequence<Dafny.Rune> _out95;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out96;
+          DCOMP.COMP.GenStmts(_265_els, selfIdent, @params, isLast, earlyReturn, out _out95, out _out96);
+          _274_elsString = _out95;
+          _275_elsIdents = _out96;
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _275_elsIdents);
+          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("if "), _268_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _272_thnString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n} else {\n")), _274_elsString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
         }
       } else if (_source15.is_While) {
-        DAST._IExpression _272___mcc_h9 = _source15.dtor_cond;
-        Dafny.ISequence<DAST._IStatement> _273___mcc_h10 = _source15.dtor_body;
-        Dafny.ISequence<DAST._IStatement> _274_body = _273___mcc_h10;
-        DAST._IExpression _275_cond = _272___mcc_h9;
+        DAST._IExpression _276___mcc_h9 = _source15.dtor_cond;
+        Dafny.ISequence<DAST._IStatement> _277___mcc_h10 = _source15.dtor_body;
+        Dafny.ISequence<DAST._IStatement> _278_body = _277___mcc_h10;
+        DAST._IExpression _279_cond = _276___mcc_h9;
         {
-          Dafny.ISequence<Dafny.Rune> _276_condString;
-          bool _277___v17;
-          bool _278_condErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _279_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out96;
-          bool _out97;
+          Dafny.ISequence<Dafny.Rune> _280_condString;
+          bool _281___v17;
+          bool _282_condErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _283_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out97;
           bool _out98;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out99;
-          DCOMP.COMP.GenExpr(_275_cond, @params, true, out _out96, out _out97, out _out98, out _out99);
-          _276_condString = _out96;
-          _277___v17 = _out97;
-          _278_condErased = _out98;
-          _279_recIdents = _out99;
-          if (!(_278_condErased)) {
-            _276_condString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase("), _276_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          bool _out99;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out100;
+          DCOMP.COMP.GenExpr(_279_cond, selfIdent, @params, true, out _out97, out _out98, out _out99, out _out100);
+          _280_condString = _out97;
+          _281___v17 = _out98;
+          _282_condErased = _out99;
+          _283_recIdents = _out100;
+          if (!(_282_condErased)) {
+            _280_condString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase("), _280_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          readIdents = _279_recIdents;
-          Dafny.ISequence<Dafny.Rune> _280_bodyString;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _281_bodyIdents;
-          Dafny.ISequence<Dafny.Rune> _out100;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out101;
-          DCOMP.COMP.GenStmts(_274_body, @params, false, earlyReturn, out _out100, out _out101);
-          _280_bodyString = _out100;
-          _281_bodyIdents = _out101;
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _281_bodyIdents);
-          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("while "), _276_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _280_bodyString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
+          readIdents = _283_recIdents;
+          Dafny.ISequence<Dafny.Rune> _284_bodyString;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _285_bodyIdents;
+          Dafny.ISequence<Dafny.Rune> _out101;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out102;
+          DCOMP.COMP.GenStmts(_278_body, selfIdent, @params, false, earlyReturn, out _out101, out _out102);
+          _284_bodyString = _out101;
+          _285_bodyIdents = _out102;
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _285_bodyIdents);
+          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("while "), _280_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _284_bodyString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
         }
       } else if (_source15.is_Call) {
-        DAST._IExpression _282___mcc_h11 = _source15.dtor_on;
-        Dafny.ISequence<Dafny.Rune> _283___mcc_h12 = _source15.dtor_name;
-        Dafny.ISequence<DAST._IType> _284___mcc_h13 = _source15.dtor_typeArgs;
-        Dafny.ISequence<DAST._IExpression> _285___mcc_h14 = _source15.dtor_args;
-        DAST._IOptional<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>> _286___mcc_h15 = _source15.dtor_outs;
-        DAST._IOptional<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>> _287_maybeOutVars = _286___mcc_h15;
-        Dafny.ISequence<DAST._IExpression> _288_args = _285___mcc_h14;
-        Dafny.ISequence<DAST._IType> _289_typeArgs = _284___mcc_h13;
-        Dafny.ISequence<Dafny.Rune> _290_name = _283___mcc_h12;
-        DAST._IExpression _291_on = _282___mcc_h11;
+        DAST._IExpression _286___mcc_h11 = _source15.dtor_on;
+        Dafny.ISequence<Dafny.Rune> _287___mcc_h12 = _source15.dtor_name;
+        Dafny.ISequence<DAST._IType> _288___mcc_h13 = _source15.dtor_typeArgs;
+        Dafny.ISequence<DAST._IExpression> _289___mcc_h14 = _source15.dtor_args;
+        DAST._IOptional<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>> _290___mcc_h15 = _source15.dtor_outs;
+        DAST._IOptional<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>> _291_maybeOutVars = _290___mcc_h15;
+        Dafny.ISequence<DAST._IExpression> _292_args = _289___mcc_h14;
+        Dafny.ISequence<DAST._IType> _293_typeArgs = _288___mcc_h13;
+        Dafny.ISequence<Dafny.Rune> _294_name = _287___mcc_h12;
+        DAST._IExpression _295_on = _286___mcc_h11;
         {
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
-          Dafny.ISequence<Dafny.Rune> _292_typeArgString;
-          _292_typeArgString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-          if ((new BigInteger((_289_typeArgs).Count)) >= (BigInteger.One)) {
-            BigInteger _293_typeI;
-            _293_typeI = BigInteger.Zero;
-            _292_typeArgString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::<");
-            while ((_293_typeI) < (new BigInteger((_289_typeArgs).Count))) {
-              if ((_293_typeI).Sign == 1) {
-                _292_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_292_typeArgString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+          Dafny.ISequence<Dafny.Rune> _296_typeArgString;
+          _296_typeArgString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+          if ((new BigInteger((_293_typeArgs).Count)) >= (BigInteger.One)) {
+            BigInteger _297_typeI;
+            _297_typeI = BigInteger.Zero;
+            _296_typeArgString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::<");
+            while ((_297_typeI) < (new BigInteger((_293_typeArgs).Count))) {
+              if ((_297_typeI).Sign == 1) {
+                _296_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_296_typeArgString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
               }
-              Dafny.ISequence<Dafny.Rune> _294_typeString;
-              Dafny.ISequence<Dafny.Rune> _out102;
-              _out102 = DCOMP.COMP.GenType((_289_typeArgs).Select(_293_typeI), false, false);
-              _294_typeString = _out102;
-              _292_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_292_typeArgString, _294_typeString);
-              _293_typeI = (_293_typeI) + (BigInteger.One);
-            }
-            _292_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_292_typeArgString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
+              Dafny.ISequence<Dafny.Rune> _298_typeString;
+              Dafny.ISequence<Dafny.Rune> _out103;
+              _out103 = DCOMP.COMP.GenType((_293_typeArgs).Select(_297_typeI), false, false);
+              _298_typeString = _out103;
+              _296_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_296_typeArgString, _298_typeString);
+              _297_typeI = (_297_typeI) + (BigInteger.One);
+            }
+            _296_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_296_typeArgString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
           }
-          Dafny.ISequence<Dafny.Rune> _295_argString;
-          _295_argString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-          BigInteger _296_i;
-          _296_i = BigInteger.Zero;
-          while ((_296_i) < (new BigInteger((_288_args).Count))) {
-            if ((_296_i).Sign == 1) {
-              _295_argString = Dafny.Sequence<Dafny.Rune>.Concat(_295_argString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
-            }
-            Dafny.ISequence<Dafny.Rune> _297_argExpr;
-            bool _298_isOwned;
-            bool _299_argErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _300_argIdents;
-            Dafny.ISequence<Dafny.Rune> _out103;
-            bool _out104;
+          Dafny.ISequence<Dafny.Rune> _299_argString;
+          _299_argString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+          BigInteger _300_i;
+          _300_i = BigInteger.Zero;
+          while ((_300_i) < (new BigInteger((_292_args).Count))) {
+            if ((_300_i).Sign == 1) {
+              _299_argString = Dafny.Sequence<Dafny.Rune>.Concat(_299_argString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+            }
+            Dafny.ISequence<Dafny.Rune> _301_argExpr;
+            bool _302_isOwned;
+            bool _303_argErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _304_argIdents;
+            Dafny.ISequence<Dafny.Rune> _out104;
             bool _out105;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out106;
-            DCOMP.COMP.GenExpr((_288_args).Select(_296_i), @params, false, out _out103, out _out104, out _out105, out _out106);
-            _297_argExpr = _out103;
-            _298_isOwned = _out104;
-            _299_argErased = _out105;
-            _300_argIdents = _out106;
-            if (_298_isOwned) {
-              _297_argExpr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), _297_argExpr);
-            }
-            _295_argString = Dafny.Sequence<Dafny.Rune>.Concat(_295_argString, _297_argExpr);
-            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _300_argIdents);
-            _296_i = (_296_i) + (BigInteger.One);
+            bool _out106;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out107;
+            DCOMP.COMP.GenExpr((_292_args).Select(_300_i), selfIdent, @params, false, out _out104, out _out105, out _out106, out _out107);
+            _301_argExpr = _out104;
+            _302_isOwned = _out105;
+            _303_argErased = _out106;
+            _304_argIdents = _out107;
+            if (_302_isOwned) {
+              _301_argExpr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), _301_argExpr);
+            }
+            _299_argString = Dafny.Sequence<Dafny.Rune>.Concat(_299_argString, _301_argExpr);
+            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _304_argIdents);
+            _300_i = (_300_i) + (BigInteger.One);
           }
-          Dafny.ISequence<Dafny.Rune> _301_enclosingString;
-          bool _302___v18;
-          bool _303___v19;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _304_enclosingIdents;
-          Dafny.ISequence<Dafny.Rune> _out107;
-          bool _out108;
+          Dafny.ISequence<Dafny.Rune> _305_enclosingString;
+          bool _306___v18;
+          bool _307___v19;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _308_enclosingIdents;
+          Dafny.ISequence<Dafny.Rune> _out108;
           bool _out109;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out110;
-          DCOMP.COMP.GenExpr(_291_on, @params, false, out _out107, out _out108, out _out109, out _out110);
-          _301_enclosingString = _out107;
-          _302___v18 = _out108;
-          _303___v19 = _out109;
-          _304_enclosingIdents = _out110;
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _304_enclosingIdents);
-          DAST._IExpression _source17 = _291_on;
+          bool _out110;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out111;
+          DCOMP.COMP.GenExpr(_295_on, selfIdent, @params, false, out _out108, out _out109, out _out110, out _out111);
+          _305_enclosingString = _out108;
+          _306___v18 = _out109;
+          _307___v19 = _out110;
+          _308_enclosingIdents = _out111;
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _308_enclosingIdents);
+          DAST._IExpression _source17 = _295_on;
           if (_source17.is_Literal) {
-            DAST._ILiteral _305___mcc_h18 = _source17.dtor_Literal_a0;
+            DAST._ILiteral _309___mcc_h19 = _source17.dtor_Literal_a0;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_Ident) {
-            Dafny.ISequence<Dafny.Rune> _306___mcc_h20 = _source17.dtor_Ident_a0;
+            Dafny.ISequence<Dafny.Rune> _310___mcc_h21 = _source17.dtor_Ident_a0;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_Companion) {
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _307___mcc_h22 = _source17.dtor_Companion_a0;
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _311___mcc_h23 = _source17.dtor_Companion_a0;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(_301_enclosingString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::"));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(_305_enclosingString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::"));
             }
           } else if (_source17.is_Tuple) {
-            Dafny.ISequence<DAST._IExpression> _308___mcc_h24 = _source17.dtor_Tuple_a0;
+            Dafny.ISequence<DAST._IExpression> _312___mcc_h25 = _source17.dtor_Tuple_a0;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_New) {
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _309___mcc_h26 = _source17.dtor_path;
-            Dafny.ISequence<DAST._IExpression> _310___mcc_h27 = _source17.dtor_args;
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _313___mcc_h27 = _source17.dtor_path;
+            Dafny.ISequence<DAST._IExpression> _314___mcc_h28 = _source17.dtor_args;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_NewArray) {
-            Dafny.ISequence<DAST._IExpression> _311___mcc_h30 = _source17.dtor_dims;
+            Dafny.ISequence<DAST._IExpression> _315___mcc_h31 = _source17.dtor_dims;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_DatatypeValue) {
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _312___mcc_h32 = _source17.dtor_path;
-            Dafny.ISequence<Dafny.Rune> _313___mcc_h33 = _source17.dtor_variant;
-            bool _314___mcc_h34 = _source17.dtor_isCo;
-            Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, DAST._IExpression>> _315___mcc_h35 = _source17.dtor_contents;
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _316___mcc_h33 = _source17.dtor_path;
+            Dafny.ISequence<Dafny.Rune> _317___mcc_h34 = _source17.dtor_variant;
+            bool _318___mcc_h35 = _source17.dtor_isCo;
+            Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, DAST._IExpression>> _319___mcc_h36 = _source17.dtor_contents;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_Convert) {
-            DAST._IExpression _316___mcc_h40 = _source17.dtor_value;
-            DAST._IType _317___mcc_h41 = _source17.dtor_from;
-            DAST._IType _318___mcc_h42 = _source17.dtor_typ;
+            DAST._IExpression _320___mcc_h41 = _source17.dtor_value;
+            DAST._IType _321___mcc_h42 = _source17.dtor_from;
+            DAST._IType _322___mcc_h43 = _source17.dtor_typ;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_SeqValue) {
-            Dafny.ISequence<DAST._IExpression> _319___mcc_h46 = _source17.dtor_elements;
+            Dafny.ISequence<DAST._IExpression> _323___mcc_h47 = _source17.dtor_elements;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_SetValue) {
-            Dafny.ISequence<DAST._IExpression> _320___mcc_h48 = _source17.dtor_elements;
+            Dafny.ISequence<DAST._IExpression> _324___mcc_h49 = _source17.dtor_elements;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_This) {
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_Ite) {
-            DAST._IExpression _321___mcc_h50 = _source17.dtor_cond;
-            DAST._IExpression _322___mcc_h51 = _source17.dtor_thn;
-            DAST._IExpression _323___mcc_h52 = _source17.dtor_els;
+            DAST._IExpression _325___mcc_h51 = _source17.dtor_cond;
+            DAST._IExpression _326___mcc_h52 = _source17.dtor_thn;
+            DAST._IExpression _327___mcc_h53 = _source17.dtor_els;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_UnOp) {
-            DAST._IUnaryOp _324___mcc_h56 = _source17.dtor_unOp;
-            DAST._IExpression _325___mcc_h57 = _source17.dtor_expr;
+            DAST._IUnaryOp _328___mcc_h57 = _source17.dtor_unOp;
+            DAST._IExpression _329___mcc_h58 = _source17.dtor_expr;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_BinOp) {
-            Dafny.ISequence<Dafny.Rune> _326___mcc_h60 = _source17.dtor_op;
-            DAST._IExpression _327___mcc_h61 = _source17.dtor_left;
-            DAST._IExpression _328___mcc_h62 = _source17.dtor_right;
+            Dafny.ISequence<Dafny.Rune> _330___mcc_h61 = _source17.dtor_op;
+            DAST._IExpression _331___mcc_h62 = _source17.dtor_left;
+            DAST._IExpression _332___mcc_h63 = _source17.dtor_right;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_ArrayLen) {
-            DAST._IExpression _329___mcc_h66 = _source17.dtor_expr;
+            DAST._IExpression _333___mcc_h67 = _source17.dtor_expr;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_Select) {
-            DAST._IExpression _330___mcc_h68 = _source17.dtor_expr;
-            Dafny.ISequence<Dafny.Rune> _331___mcc_h69 = _source17.dtor_field;
-            bool _332___mcc_h70 = _source17.dtor_isConstant;
-            bool _333___mcc_h71 = _source17.dtor_onDatatype;
+            DAST._IExpression _334___mcc_h69 = _source17.dtor_expr;
+            Dafny.ISequence<Dafny.Rune> _335___mcc_h70 = _source17.dtor_field;
+            bool _336___mcc_h71 = _source17.dtor_isConstant;
+            bool _337___mcc_h72 = _source17.dtor_onDatatype;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_SelectFn) {
-            DAST._IExpression _334___mcc_h76 = _source17.dtor_expr;
-            Dafny.ISequence<Dafny.Rune> _335___mcc_h77 = _source17.dtor_field;
-            bool _336___mcc_h78 = _source17.dtor_onDatatype;
-            bool _337___mcc_h79 = _source17.dtor_isStatic;
-            BigInteger _338___mcc_h80 = _source17.dtor_arity;
+            DAST._IExpression _338___mcc_h77 = _source17.dtor_expr;
+            Dafny.ISequence<Dafny.Rune> _339___mcc_h78 = _source17.dtor_field;
+            bool _340___mcc_h79 = _source17.dtor_onDatatype;
+            bool _341___mcc_h80 = _source17.dtor_isStatic;
+            BigInteger _342___mcc_h81 = _source17.dtor_arity;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_Index) {
-            DAST._IExpression _339___mcc_h86 = _source17.dtor_expr;
-            DAST._IExpression _340___mcc_h87 = _source17.dtor_idx;
+            DAST._IExpression _343___mcc_h87 = _source17.dtor_expr;
+            DAST._IExpression _344___mcc_h88 = _source17.dtor_idx;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_TupleSelect) {
-            DAST._IExpression _341___mcc_h90 = _source17.dtor_expr;
-            BigInteger _342___mcc_h91 = _source17.dtor_index;
+            DAST._IExpression _345___mcc_h91 = _source17.dtor_expr;
+            BigInteger _346___mcc_h92 = _source17.dtor_index;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_Call) {
-            DAST._IExpression _343___mcc_h94 = _source17.dtor_on;
-            Dafny.ISequence<Dafny.Rune> _344___mcc_h95 = _source17.dtor_name;
-            Dafny.ISequence<DAST._IType> _345___mcc_h96 = _source17.dtor_typeArgs;
-            Dafny.ISequence<DAST._IExpression> _346___mcc_h97 = _source17.dtor_args;
+            DAST._IExpression _347___mcc_h95 = _source17.dtor_on;
+            Dafny.ISequence<Dafny.Rune> _348___mcc_h96 = _source17.dtor_name;
+            Dafny.ISequence<DAST._IType> _349___mcc_h97 = _source17.dtor_typeArgs;
+            Dafny.ISequence<DAST._IExpression> _350___mcc_h98 = _source17.dtor_args;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_Lambda) {
-            Dafny.ISequence<DAST._IFormal> _347___mcc_h102 = _source17.dtor_params;
-            DAST._IType _348___mcc_h103 = _source17.dtor_retType;
-            Dafny.ISequence<DAST._IStatement> _349___mcc_h104 = _source17.dtor_body;
+            Dafny.ISequence<DAST._IFormal> _351___mcc_h103 = _source17.dtor_params;
+            DAST._IType _352___mcc_h104 = _source17.dtor_retType;
+            Dafny.ISequence<DAST._IStatement> _353___mcc_h105 = _source17.dtor_body;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_IIFE) {
-            Dafny.ISequence<Dafny.Rune> _350___mcc_h108 = _source17.dtor_name;
-            DAST._IType _351___mcc_h109 = _source17.dtor_typ;
-            DAST._IExpression _352___mcc_h110 = _source17.dtor_value;
-            DAST._IExpression _353___mcc_h111 = _source17.dtor_iifeBody;
+            Dafny.ISequence<Dafny.Rune> _354___mcc_h109 = _source17.dtor_name;
+            DAST._IType _355___mcc_h110 = _source17.dtor_typ;
+            DAST._IExpression _356___mcc_h111 = _source17.dtor_value;
+            DAST._IExpression _357___mcc_h112 = _source17.dtor_iifeBody;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_Apply) {
-            DAST._IExpression _354___mcc_h116 = _source17.dtor_expr;
-            Dafny.ISequence<DAST._IExpression> _355___mcc_h117 = _source17.dtor_args;
+            DAST._IExpression _358___mcc_h117 = _source17.dtor_expr;
+            Dafny.ISequence<DAST._IExpression> _359___mcc_h118 = _source17.dtor_args;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else if (_source17.is_TypeTest) {
-            DAST._IExpression _356___mcc_h120 = _source17.dtor_on;
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _357___mcc_h121 = _source17.dtor_dType;
-            Dafny.ISequence<Dafny.Rune> _358___mcc_h122 = _source17.dtor_variant;
+            DAST._IExpression _360___mcc_h121 = _source17.dtor_on;
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _361___mcc_h122 = _source17.dtor_dType;
+            Dafny.ISequence<Dafny.Rune> _362___mcc_h123 = _source17.dtor_variant;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else {
-            DAST._IType _359___mcc_h126 = _source17.dtor_typ;
+            DAST._IType _363___mcc_h127 = _source17.dtor_typ;
             {
-              _301_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _305_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           }
-          Dafny.ISequence<Dafny.Rune> _360_receiver;
-          _360_receiver = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-          DAST._IOptional<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>> _source18 = _287_maybeOutVars;
+          Dafny.ISequence<Dafny.Rune> _364_receiver;
+          _364_receiver = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+          DAST._IOptional<Dafny.ISequence<Dafny.ISequence<Dafny.Rune>>> _source18 = _291_maybeOutVars;
           if (_source18.is_Some) {
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _361___mcc_h128 = _source18.dtor_Some_a0;
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _362_outVars = _361___mcc_h128;
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _365___mcc_h129 = _source18.dtor_Some_a0;
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _366_outVars = _365___mcc_h129;
             {
-              if ((new BigInteger((_362_outVars).Count)) > (BigInteger.One)) {
-                _360_receiver = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(");
+              if ((new BigInteger((_366_outVars).Count)) > (BigInteger.One)) {
+                _364_receiver = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(");
               }
-              BigInteger _363_outI;
-              _363_outI = BigInteger.Zero;
-              while ((_363_outI) < (new BigInteger((_362_outVars).Count))) {
-                if ((_363_outI).Sign == 1) {
-                  _360_receiver = Dafny.Sequence<Dafny.Rune>.Concat(_360_receiver, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
-                }
-                Dafny.ISequence<Dafny.Rune> _364_outVar;
-                _364_outVar = (_362_outVars).Select(_363_outI);
-                _360_receiver = Dafny.Sequence<Dafny.Rune>.Concat(_360_receiver, (_364_outVar));
-                _363_outI = (_363_outI) + (BigInteger.One);
+              BigInteger _367_outI;
+              _367_outI = BigInteger.Zero;
+              while ((_367_outI) < (new BigInteger((_366_outVars).Count))) {
+                if ((_367_outI).Sign == 1) {
+                  _364_receiver = Dafny.Sequence<Dafny.Rune>.Concat(_364_receiver, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+                }
+                Dafny.ISequence<Dafny.Rune> _368_outVar;
+                _368_outVar = (_366_outVars).Select(_367_outI);
+                _364_receiver = Dafny.Sequence<Dafny.Rune>.Concat(_364_receiver, (_368_outVar));
+                _367_outI = (_367_outI) + (BigInteger.One);
               }
-              if ((new BigInteger((_362_outVars).Count)) > (BigInteger.One)) {
-                _360_receiver = Dafny.Sequence<Dafny.Rune>.Concat(_360_receiver, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+              if ((new BigInteger((_366_outVars).Count)) > (BigInteger.One)) {
+                _364_receiver = Dafny.Sequence<Dafny.Rune>.Concat(_364_receiver, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
               }
             }
           } else {
           }
-          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(((!(_360_receiver).Equals(Dafny.Sequence<Dafny.Rune>.UnicodeFromString(""))) ? (Dafny.Sequence<Dafny.Rune>.Concat(_360_receiver, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = "))) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString(""))), _301_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), _290_name), _292_typeArgString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _295_argString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(");"));
+          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(((!(_364_receiver).Equals(Dafny.Sequence<Dafny.Rune>.UnicodeFromString(""))) ? (Dafny.Sequence<Dafny.Rune>.Concat(_364_receiver, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = "))) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString(""))), _305_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), _294_name), _296_typeArgString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _299_argString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(");"));
         }
       } else if (_source15.is_Return) {
-        DAST._IExpression _365___mcc_h16 = _source15.dtor_expr;
-        DAST._IExpression _366_expr = _365___mcc_h16;
+        DAST._IExpression _369___mcc_h16 = _source15.dtor_expr;
+        DAST._IExpression _370_expr = _369___mcc_h16;
         {
-          Dafny.ISequence<Dafny.Rune> _367_exprString;
-          bool _368___v22;
-          bool _369_recErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _370_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out111;
-          bool _out112;
+          Dafny.ISequence<Dafny.Rune> _371_exprString;
+          bool _372___v22;
+          bool _373_recErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _374_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out112;
           bool _out113;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out114;
-          DCOMP.COMP.GenExpr(_366_expr, @params, true, out _out111, out _out112, out _out113, out _out114);
-          _367_exprString = _out111;
-          _368___v22 = _out112;
-          _369_recErased = _out113;
-          _370_recIdents = _out114;
-          _367_exprString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _367_exprString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-          readIdents = _370_recIdents;
+          bool _out114;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out115;
+          DCOMP.COMP.GenExpr(_370_expr, selfIdent, @params, true, out _out112, out _out113, out _out114, out _out115);
+          _371_exprString = _out112;
+          _372___v22 = _out113;
+          _373_recErased = _out114;
+          _374_recIdents = _out115;
+          _371_exprString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _371_exprString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          readIdents = _374_recIdents;
           if (isLast) {
-            generated = _367_exprString;
+            generated = _371_exprString;
           } else {
-            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("return "), _367_exprString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";"));
+            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("return "), _371_exprString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";"));
           }
         }
       } else if (_source15.is_EarlyReturn) {
@@ -5771,45 +5881,76 @@ public partial class COMP {
           generated = earlyReturn;
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
         }
+      } else if (_source15.is_TailRecursive) {
+        Dafny.ISequence<DAST._IStatement> _375___mcc_h17 = _source15.dtor_body;
+        Dafny.ISequence<DAST._IStatement> _376_body = _375___mcc_h17;
+        {
+          generated = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+          if (!object.Equals(selfIdent, DAST.Optional<Dafny.ISequence<Dafny.Rune>>.create_None())) {
+            generated = Dafny.Sequence<Dafny.Rune>.Concat(generated, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let mut r#_this = self.clone();\n"));
+          }
+          BigInteger _377_paramI;
+          _377_paramI = BigInteger.Zero;
+          while ((_377_paramI) < (new BigInteger((@params).Count))) {
+            Dafny.ISequence<Dafny.Rune> _378_param;
+            _378_param = (@params).Select(_377_paramI);
+            generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(generated, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let mut r#")), _378_param), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = r#")), _378_param), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone();\n"));
+            _377_paramI = (_377_paramI) + (BigInteger.One);
+          }
+          Dafny.ISequence<Dafny.Rune> _379_bodyString;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _380_bodyIdents;
+          Dafny.ISequence<Dafny.Rune> _out116;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out117;
+          DCOMP.COMP.GenStmts(_376_body, ((!object.Equals(selfIdent, DAST.Optional<Dafny.ISequence<Dafny.Rune>>.create_None())) ? (DAST.Optional<Dafny.ISequence<Dafny.Rune>>.create_Some(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("_this"))) : (DAST.Optional<Dafny.ISequence<Dafny.Rune>>.create_None())), Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements(), false, earlyReturn, out _out116, out _out117);
+          _379_bodyString = _out116;
+          _380_bodyIdents = _out117;
+          readIdents = _380_bodyIdents;
+          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(generated, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("'TAIL_CALL_START: loop {\n")), _379_bodyString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
+        }
+      } else if (_source15.is_JumpTailCallStart) {
+        {
+          generated = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("continue 'TAIL_CALL_START;");
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
+        }
       } else if (_source15.is_Halt) {
         {
           generated = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("panic!(\"Halt\");");
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
         }
       } else {
-        DAST._IExpression _371___mcc_h17 = _source15.dtor_Print_a0;
-        DAST._IExpression _372_e = _371___mcc_h17;
+        DAST._IExpression _381___mcc_h18 = _source15.dtor_Print_a0;
+        DAST._IExpression _382_e = _381___mcc_h18;
         {
-          Dafny.ISequence<Dafny.Rune> _373_printedExpr;
-          bool _374_isOwned;
-          bool _375___v23;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _376_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out115;
-          bool _out116;
-          bool _out117;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out118;
-          DCOMP.COMP.GenExpr(_372_e, @params, false, out _out115, out _out116, out _out117, out _out118);
-          _373_printedExpr = _out115;
-          _374_isOwned = _out116;
-          _375___v23 = _out117;
-          _376_recIdents = _out118;
-          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("print!(\"{}\", ::dafny_runtime::DafnyPrintWrapper("), ((_374_isOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("")))), _373_printedExpr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("));"));
-          readIdents = _376_recIdents;
+          Dafny.ISequence<Dafny.Rune> _383_printedExpr;
+          bool _384_isOwned;
+          bool _385___v23;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _386_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out118;
+          bool _out119;
+          bool _out120;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out121;
+          DCOMP.COMP.GenExpr(_382_e, selfIdent, @params, false, out _out118, out _out119, out _out120, out _out121);
+          _383_printedExpr = _out118;
+          _384_isOwned = _out119;
+          _385___v23 = _out120;
+          _386_recIdents = _out121;
+          generated = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("print!(\"{}\", ::dafny_runtime::DafnyPrintWrapper("), ((_384_isOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("")))), _383_printedExpr), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("));"));
+          readIdents = _386_recIdents;
         }
       }
     }
-    public static void GenExpr(DAST._IExpression e, Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> @params, bool mustOwn, out Dafny.ISequence<Dafny.Rune> s, out bool isOwned, out bool isErased, out Dafny.ISet<Dafny.ISequence<Dafny.Rune>> readIdents) {
+    public static void GenExpr(DAST._IExpression e, DAST._IOptional<Dafny.ISequence<Dafny.Rune>> selfIdent, Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> @params, bool mustOwn, out Dafny.ISequence<Dafny.Rune> s, out bool isOwned, out bool isErased, out Dafny.ISet<Dafny.ISequence<Dafny.Rune>> readIdents) {
       s = Dafny.Sequence<Dafny.Rune>.Empty;
       isOwned = false;
       isErased = false;
       readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Empty;
       DAST._IExpression _source19 = e;
       if (_source19.is_Literal) {
-        DAST._ILiteral _377___mcc_h0 = _source19.dtor_Literal_a0;
-        DAST._ILiteral _source20 = _377___mcc_h0;
+        DAST._ILiteral _387___mcc_h0 = _source19.dtor_Literal_a0;
+        DAST._ILiteral _source20 = _387___mcc_h0;
         if (_source20.is_BoolLiteral) {
-          bool _378___mcc_h1 = _source20.dtor_BoolLiteral_a0;
-          if ((_378___mcc_h1) == (false)) {
+          bool _388___mcc_h1 = _source20.dtor_BoolLiteral_a0;
+          if ((_388___mcc_h1) == (false)) {
             {
               s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("false");
               isOwned = true;
@@ -5825,89 +5966,94 @@ public partial class COMP {
             }
           }
         } else if (_source20.is_IntLiteral) {
-          Dafny.ISequence<Dafny.Rune> _379___mcc_h2 = _source20.dtor_IntLiteral_a0;
-          DAST._IType _380___mcc_h3 = _source20.dtor_IntLiteral_a1;
-          DAST._IType _381_t = _380___mcc_h3;
-          Dafny.ISequence<Dafny.Rune> _382_i = _379___mcc_h2;
+          Dafny.ISequence<Dafny.Rune> _389___mcc_h2 = _source20.dtor_IntLiteral_a0;
+          DAST._IType _390___mcc_h3 = _source20.dtor_IntLiteral_a1;
+          DAST._IType _391_t = _390___mcc_h3;
+          Dafny.ISequence<Dafny.Rune> _392_i = _389___mcc_h2;
           {
-            DAST._IType _source21 = _381_t;
+            DAST._IType _source21 = _391_t;
             if (_source21.is_Path) {
-              Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _383___mcc_h63 = _source21.dtor_Path_a0;
-              Dafny.ISequence<DAST._IType> _384___mcc_h64 = _source21.dtor_typeArgs;
-              DAST._IResolvedType _385___mcc_h65 = _source21.dtor_resolved;
+              Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _393___mcc_h173 = _source21.dtor_Path_a0;
+              Dafny.ISequence<DAST._IType> _394___mcc_h174 = _source21.dtor_typeArgs;
+              DAST._IResolvedType _395___mcc_h175 = _source21.dtor_resolved;
               {
-                s = _382_i;
+                s = _392_i;
+              }
+            } else if (_source21.is_Nullable) {
+              DAST._IType _396___mcc_h179 = _source21.dtor_Nullable_a0;
+              {
+                s = _392_i;
               }
             } else if (_source21.is_Tuple) {
-              Dafny.ISequence<DAST._IType> _386___mcc_h69 = _source21.dtor_Tuple_a0;
+              Dafny.ISequence<DAST._IType> _397___mcc_h181 = _source21.dtor_Tuple_a0;
               {
-                s = _382_i;
+                s = _392_i;
               }
             } else if (_source21.is_Array) {
-              DAST._IType _387___mcc_h71 = _source21.dtor_element;
+              DAST._IType _398___mcc_h183 = _source21.dtor_element;
               {
-                s = _382_i;
+                s = _392_i;
               }
             } else if (_source21.is_Seq) {
-              DAST._IType _388___mcc_h73 = _source21.dtor_element;
+              DAST._IType _399___mcc_h185 = _source21.dtor_element;
               {
-                s = _382_i;
+                s = _392_i;
               }
             } else if (_source21.is_Set) {
-              DAST._IType _389___mcc_h75 = _source21.dtor_element;
+              DAST._IType _400___mcc_h187 = _source21.dtor_element;
               {
-                s = _382_i;
+                s = _392_i;
               }
             } else if (_source21.is_Multiset) {
-              DAST._IType _390___mcc_h77 = _source21.dtor_element;
+              DAST._IType _401___mcc_h189 = _source21.dtor_element;
               {
-                s = _382_i;
+                s = _392_i;
               }
             } else if (_source21.is_Map) {
-              DAST._IType _391___mcc_h79 = _source21.dtor_key;
-              DAST._IType _392___mcc_h80 = _source21.dtor_value;
+              DAST._IType _402___mcc_h191 = _source21.dtor_key;
+              DAST._IType _403___mcc_h192 = _source21.dtor_value;
               {
-                s = _382_i;
+                s = _392_i;
               }
             } else if (_source21.is_Arrow) {
-              Dafny.ISequence<DAST._IType> _393___mcc_h83 = _source21.dtor_args;
-              DAST._IType _394___mcc_h84 = _source21.dtor_result;
+              Dafny.ISequence<DAST._IType> _404___mcc_h195 = _source21.dtor_args;
+              DAST._IType _405___mcc_h196 = _source21.dtor_result;
               {
-                s = _382_i;
+                s = _392_i;
               }
             } else if (_source21.is_Primitive) {
-              DAST._IPrimitive _395___mcc_h87 = _source21.dtor_Primitive_a0;
-              DAST._IPrimitive _source22 = _395___mcc_h87;
+              DAST._IPrimitive _406___mcc_h199 = _source21.dtor_Primitive_a0;
+              DAST._IPrimitive _source22 = _406___mcc_h199;
               if (_source22.is_Int) {
                 {
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigInt::parse_bytes(b\""), _382_i), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\", 10).unwrap()"));
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigInt::parse_bytes(b\""), _392_i), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\", 10).unwrap()"));
                 }
               } else if (_source22.is_Real) {
                 {
-                  s = _382_i;
+                  s = _392_i;
                 }
               } else if (_source22.is_String) {
                 {
-                  s = _382_i;
+                  s = _392_i;
                 }
               } else if (_source22.is_Bool) {
                 {
-                  s = _382_i;
+                  s = _392_i;
                 }
               } else {
                 {
-                  s = _382_i;
+                  s = _392_i;
                 }
               }
             } else if (_source21.is_Passthrough) {
-              Dafny.ISequence<Dafny.Rune> _396___mcc_h89 = _source21.dtor_Passthrough_a0;
+              Dafny.ISequence<Dafny.Rune> _407___mcc_h201 = _source21.dtor_Passthrough_a0;
               {
-                s = _382_i;
+                s = _392_i;
               }
             } else {
-              Dafny.ISequence<Dafny.Rune> _397___mcc_h91 = _source21.dtor_TypeArg_a0;
+              Dafny.ISequence<Dafny.Rune> _408___mcc_h203 = _source21.dtor_TypeArg_a0;
               {
-                s = _382_i;
+                s = _392_i;
               }
             }
             isOwned = true;
@@ -5915,91 +6061,96 @@ public partial class COMP {
             readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
           }
         } else if (_source20.is_DecLiteral) {
-          Dafny.ISequence<Dafny.Rune> _398___mcc_h4 = _source20.dtor_DecLiteral_a0;
-          Dafny.ISequence<Dafny.Rune> _399___mcc_h5 = _source20.dtor_DecLiteral_a1;
-          DAST._IType _400___mcc_h6 = _source20.dtor_DecLiteral_a2;
-          DAST._IType _401_t = _400___mcc_h6;
-          Dafny.ISequence<Dafny.Rune> _402_d = _399___mcc_h5;
-          Dafny.ISequence<Dafny.Rune> _403_n = _398___mcc_h4;
+          Dafny.ISequence<Dafny.Rune> _409___mcc_h4 = _source20.dtor_DecLiteral_a0;
+          Dafny.ISequence<Dafny.Rune> _410___mcc_h5 = _source20.dtor_DecLiteral_a1;
+          DAST._IType _411___mcc_h6 = _source20.dtor_DecLiteral_a2;
+          DAST._IType _412_t = _411___mcc_h6;
+          Dafny.ISequence<Dafny.Rune> _413_d = _410___mcc_h5;
+          Dafny.ISequence<Dafny.Rune> _414_n = _409___mcc_h4;
           {
-            DAST._IType _source23 = _401_t;
+            DAST._IType _source23 = _412_t;
             if (_source23.is_Path) {
-              Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _404___mcc_h93 = _source23.dtor_Path_a0;
-              Dafny.ISequence<DAST._IType> _405___mcc_h94 = _source23.dtor_typeArgs;
-              DAST._IResolvedType _406___mcc_h95 = _source23.dtor_resolved;
+              Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _415___mcc_h205 = _source23.dtor_Path_a0;
+              Dafny.ISequence<DAST._IType> _416___mcc_h206 = _source23.dtor_typeArgs;
+              DAST._IResolvedType _417___mcc_h207 = _source23.dtor_resolved;
+              {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+              }
+            } else if (_source23.is_Nullable) {
+              DAST._IType _418___mcc_h211 = _source23.dtor_Nullable_a0;
               {
-                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
               }
             } else if (_source23.is_Tuple) {
-              Dafny.ISequence<DAST._IType> _407___mcc_h99 = _source23.dtor_Tuple_a0;
+              Dafny.ISequence<DAST._IType> _419___mcc_h213 = _source23.dtor_Tuple_a0;
               {
-                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
               }
             } else if (_source23.is_Array) {
-              DAST._IType _408___mcc_h101 = _source23.dtor_element;
+              DAST._IType _420___mcc_h215 = _source23.dtor_element;
               {
-                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
               }
             } else if (_source23.is_Seq) {
-              DAST._IType _409___mcc_h103 = _source23.dtor_element;
+              DAST._IType _421___mcc_h217 = _source23.dtor_element;
               {
-                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
               }
             } else if (_source23.is_Set) {
-              DAST._IType _410___mcc_h105 = _source23.dtor_element;
+              DAST._IType _422___mcc_h219 = _source23.dtor_element;
               {
-                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
               }
             } else if (_source23.is_Multiset) {
-              DAST._IType _411___mcc_h107 = _source23.dtor_element;
+              DAST._IType _423___mcc_h221 = _source23.dtor_element;
               {
-                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
               }
             } else if (_source23.is_Map) {
-              DAST._IType _412___mcc_h109 = _source23.dtor_key;
-              DAST._IType _413___mcc_h110 = _source23.dtor_value;
+              DAST._IType _424___mcc_h223 = _source23.dtor_key;
+              DAST._IType _425___mcc_h224 = _source23.dtor_value;
               {
-                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
               }
             } else if (_source23.is_Arrow) {
-              Dafny.ISequence<DAST._IType> _414___mcc_h113 = _source23.dtor_args;
-              DAST._IType _415___mcc_h114 = _source23.dtor_result;
+              Dafny.ISequence<DAST._IType> _426___mcc_h227 = _source23.dtor_args;
+              DAST._IType _427___mcc_h228 = _source23.dtor_result;
               {
-                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
               }
             } else if (_source23.is_Primitive) {
-              DAST._IPrimitive _416___mcc_h117 = _source23.dtor_Primitive_a0;
-              DAST._IPrimitive _source24 = _416___mcc_h117;
+              DAST._IPrimitive _428___mcc_h231 = _source23.dtor_Primitive_a0;
+              DAST._IPrimitive _source24 = _428___mcc_h231;
               if (_source24.is_Int) {
                 {
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
                 }
               } else if (_source24.is_Real) {
                 {
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigRational::new(::dafny_runtime::BigInt::parse_bytes(b\""), _403_n), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\", 10).unwrap(), ::dafny_runtime::BigInt::parse_bytes(b\"")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\", 10).unwrap())"));
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigRational::new(::dafny_runtime::BigInt::parse_bytes(b\""), _414_n), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\", 10).unwrap(), ::dafny_runtime::BigInt::parse_bytes(b\"")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\", 10).unwrap())"));
                 }
               } else if (_source24.is_String) {
                 {
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
                 }
               } else if (_source24.is_Bool) {
                 {
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
                 }
               } else {
                 {
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
                 }
               }
             } else if (_source23.is_Passthrough) {
-              Dafny.ISequence<Dafny.Rune> _417___mcc_h119 = _source23.dtor_Passthrough_a0;
+              Dafny.ISequence<Dafny.Rune> _429___mcc_h233 = _source23.dtor_Passthrough_a0;
               {
-                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
               }
             } else {
-              Dafny.ISequence<Dafny.Rune> _418___mcc_h121 = _source23.dtor_TypeArg_a0;
+              Dafny.ISequence<Dafny.Rune> _430___mcc_h235 = _source23.dtor_TypeArg_a0;
               {
-                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_403_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _402_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_414_n, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0 / ")), _413_d), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".0"));
               }
             }
             isOwned = true;
@@ -6007,19 +6158,19 @@ public partial class COMP {
             readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
           }
         } else if (_source20.is_StringLiteral) {
-          Dafny.ISequence<Dafny.Rune> _419___mcc_h7 = _source20.dtor_StringLiteral_a0;
-          Dafny.ISequence<Dafny.Rune> _420_l = _419___mcc_h7;
+          Dafny.ISequence<Dafny.Rune> _431___mcc_h7 = _source20.dtor_StringLiteral_a0;
+          Dafny.ISequence<Dafny.Rune> _432_l = _431___mcc_h7;
           {
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\""), _420_l), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\".chars().collect::<Vec<char>>()"));
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\""), _432_l), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\".chars().collect::<Vec<char>>()"));
             isOwned = true;
             isErased = true;
             readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
           }
         } else if (_source20.is_CharLiteral) {
-          Dafny.Rune _421___mcc_h8 = _source20.dtor_CharLiteral_a0;
-          Dafny.Rune _422_c = _421___mcc_h8;
+          Dafny.Rune _433___mcc_h8 = _source20.dtor_CharLiteral_a0;
+          Dafny.Rune _434_c = _433___mcc_h8;
           {
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::primitive::char::from_u32("), DCOMP.__default.natToString(new BigInteger((_422_c).Value))), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap()"));
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::primitive::char::from_u32("), DCOMP.__default.natToString(new BigInteger((_434_c).Value))), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap()"));
             isOwned = true;
             isErased = true;
             readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
@@ -6033,11 +6184,11 @@ public partial class COMP {
           }
         }
       } else if (_source19.is_Ident) {
-        Dafny.ISequence<Dafny.Rune> _423___mcc_h9 = _source19.dtor_Ident_a0;
-        Dafny.ISequence<Dafny.Rune> _424_name = _423___mcc_h9;
+        Dafny.ISequence<Dafny.Rune> _435___mcc_h9 = _source19.dtor_Ident_a0;
+        Dafny.ISequence<Dafny.Rune> _436_name = _435___mcc_h9;
         {
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), _424_name);
-          if (!((@params).Contains(_424_name))) {
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#"), _436_name);
+          if (!((@params).Contains(_436_name))) {
             s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(&"), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
           if (mustOwn) {
@@ -6047,6069 +6198,6825 @@ public partial class COMP {
             isOwned = false;
           }
           isErased = false;
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(_424_name);
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(_436_name);
         }
       } else if (_source19.is_Companion) {
-        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _425___mcc_h10 = _source19.dtor_Companion_a0;
-        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _426_path = _425___mcc_h10;
+        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _437___mcc_h10 = _source19.dtor_Companion_a0;
+        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _438_path = _437___mcc_h10;
         {
-          Dafny.ISequence<Dafny.Rune> _out119;
-          _out119 = DCOMP.COMP.GenPath(_426_path);
-          s = _out119;
+          Dafny.ISequence<Dafny.Rune> _out122;
+          _out122 = DCOMP.COMP.GenPath(_438_path);
+          s = _out122;
           isOwned = true;
           isErased = true;
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
         }
       } else if (_source19.is_Tuple) {
-        Dafny.ISequence<DAST._IExpression> _427___mcc_h11 = _source19.dtor_Tuple_a0;
-        Dafny.ISequence<DAST._IExpression> _428_values = _427___mcc_h11;
+        Dafny.ISequence<DAST._IExpression> _439___mcc_h11 = _source19.dtor_Tuple_a0;
+        Dafny.ISequence<DAST._IExpression> _440_values = _439___mcc_h11;
         {
           s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(");
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
-          BigInteger _429_i;
-          _429_i = BigInteger.Zero;
-          bool _430_allErased;
-          _430_allErased = true;
-          while ((_429_i) < (new BigInteger((_428_values).Count))) {
-            Dafny.ISequence<Dafny.Rune> _431___v26;
-            bool _432___v27;
-            bool _433_isErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _434___v28;
-            Dafny.ISequence<Dafny.Rune> _out120;
-            bool _out121;
-            bool _out122;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out123;
-            DCOMP.COMP.GenExpr((_428_values).Select(_429_i), @params, true, out _out120, out _out121, out _out122, out _out123);
-            _431___v26 = _out120;
-            _432___v27 = _out121;
-            _433_isErased = _out122;
-            _434___v28 = _out123;
-            _430_allErased = (_430_allErased) && (_433_isErased);
-            _429_i = (_429_i) + (BigInteger.One);
+          BigInteger _441_i;
+          _441_i = BigInteger.Zero;
+          bool _442_allErased;
+          _442_allErased = true;
+          while ((_441_i) < (new BigInteger((_440_values).Count))) {
+            Dafny.ISequence<Dafny.Rune> _443___v26;
+            bool _444___v27;
+            bool _445_isErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _446___v28;
+            Dafny.ISequence<Dafny.Rune> _out123;
+            bool _out124;
+            bool _out125;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out126;
+            DCOMP.COMP.GenExpr((_440_values).Select(_441_i), selfIdent, @params, true, out _out123, out _out124, out _out125, out _out126);
+            _443___v26 = _out123;
+            _444___v27 = _out124;
+            _445_isErased = _out125;
+            _446___v28 = _out126;
+            _442_allErased = (_442_allErased) && (_445_isErased);
+            _441_i = (_441_i) + (BigInteger.One);
           }
-          _429_i = BigInteger.Zero;
-          while ((_429_i) < (new BigInteger((_428_values).Count))) {
-            if ((_429_i).Sign == 1) {
+          _441_i = BigInteger.Zero;
+          while ((_441_i) < (new BigInteger((_440_values).Count))) {
+            if ((_441_i).Sign == 1) {
               s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" "));
             }
-            Dafny.ISequence<Dafny.Rune> _435_recursiveGen;
-            bool _436___v29;
-            bool _437_isErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _438_recIdents;
-            Dafny.ISequence<Dafny.Rune> _out124;
-            bool _out125;
-            bool _out126;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out127;
-            DCOMP.COMP.GenExpr((_428_values).Select(_429_i), @params, true, out _out124, out _out125, out _out126, out _out127);
-            _435_recursiveGen = _out124;
-            _436___v29 = _out125;
-            _437_isErased = _out126;
-            _438_recIdents = _out127;
-            if ((_437_isErased) && (!(_430_allErased))) {
-              _435_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _435_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-            }
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, _435_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(","));
-            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _438_recIdents);
-            _429_i = (_429_i) + (BigInteger.One);
+            Dafny.ISequence<Dafny.Rune> _447_recursiveGen;
+            bool _448___v29;
+            bool _449_isErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _450_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out127;
+            bool _out128;
+            bool _out129;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out130;
+            DCOMP.COMP.GenExpr((_440_values).Select(_441_i), selfIdent, @params, true, out _out127, out _out128, out _out129, out _out130);
+            _447_recursiveGen = _out127;
+            _448___v29 = _out128;
+            _449_isErased = _out129;
+            _450_recIdents = _out130;
+            if ((_449_isErased) && (!(_442_allErased))) {
+              _447_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _447_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, _447_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(","));
+            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _450_recIdents);
+            _441_i = (_441_i) + (BigInteger.One);
           }
           s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           isOwned = true;
-          isErased = _430_allErased;
+          isErased = _442_allErased;
         }
       } else if (_source19.is_New) {
-        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _439___mcc_h12 = _source19.dtor_path;
-        Dafny.ISequence<DAST._IExpression> _440___mcc_h13 = _source19.dtor_args;
-        Dafny.ISequence<DAST._IExpression> _441_args = _440___mcc_h13;
-        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _442_path = _439___mcc_h12;
+        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _451___mcc_h12 = _source19.dtor_path;
+        Dafny.ISequence<DAST._IExpression> _452___mcc_h13 = _source19.dtor_args;
+        Dafny.ISequence<DAST._IExpression> _453_args = _452___mcc_h13;
+        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _454_path = _451___mcc_h12;
         {
-          Dafny.ISequence<Dafny.Rune> _443_path;
-          Dafny.ISequence<Dafny.Rune> _out128;
-          _out128 = DCOMP.COMP.GenPath(_442_path);
-          _443_path = _out128;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::rc::Rc::new("), _443_path), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::new("));
+          Dafny.ISequence<Dafny.Rune> _455_path;
+          Dafny.ISequence<Dafny.Rune> _out131;
+          _out131 = DCOMP.COMP.GenPath(_454_path);
+          _455_path = _out131;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::rc::Rc::new("), _455_path), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::new("));
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
-          BigInteger _444_i;
-          _444_i = BigInteger.Zero;
-          while ((_444_i) < (new BigInteger((_441_args).Count))) {
-            if ((_444_i).Sign == 1) {
+          BigInteger _456_i;
+          _456_i = BigInteger.Zero;
+          while ((_456_i) < (new BigInteger((_453_args).Count))) {
+            if ((_456_i).Sign == 1) {
               s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
             }
-            Dafny.ISequence<Dafny.Rune> _445_recursiveGen;
-            bool _446___v30;
-            bool _447_isErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _448_recIdents;
-            Dafny.ISequence<Dafny.Rune> _out129;
-            bool _out130;
-            bool _out131;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out132;
-            DCOMP.COMP.GenExpr((_441_args).Select(_444_i), @params, true, out _out129, out _out130, out _out131, out _out132);
-            _445_recursiveGen = _out129;
-            _446___v30 = _out130;
-            _447_isErased = _out131;
-            _448_recIdents = _out132;
-            if (_447_isErased) {
-              _445_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _445_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-            }
-            s = Dafny.Sequence<Dafny.Rune>.Concat(s, _445_recursiveGen);
-            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _448_recIdents);
-            _444_i = (_444_i) + (BigInteger.One);
+            Dafny.ISequence<Dafny.Rune> _457_recursiveGen;
+            bool _458___v30;
+            bool _459_isErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _460_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out132;
+            bool _out133;
+            bool _out134;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out135;
+            DCOMP.COMP.GenExpr((_453_args).Select(_456_i), selfIdent, @params, true, out _out132, out _out133, out _out134, out _out135);
+            _457_recursiveGen = _out132;
+            _458___v30 = _out133;
+            _459_isErased = _out134;
+            _460_recIdents = _out135;
+            if (_459_isErased) {
+              _457_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _457_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            s = Dafny.Sequence<Dafny.Rune>.Concat(s, _457_recursiveGen);
+            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _460_recIdents);
+            _456_i = (_456_i) + (BigInteger.One);
           }
           s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("))"));
           isOwned = true;
           isErased = true;
         }
       } else if (_source19.is_NewArray) {
-        Dafny.ISequence<DAST._IExpression> _449___mcc_h14 = _source19.dtor_dims;
-        Dafny.ISequence<DAST._IExpression> _450_dims = _449___mcc_h14;
+        Dafny.ISequence<DAST._IExpression> _461___mcc_h14 = _source19.dtor_dims;
+        Dafny.ISequence<DAST._IExpression> _462_dims = _461___mcc_h14;
         {
-          BigInteger _451_i;
-          _451_i = (new BigInteger((_450_dims).Count)) - (BigInteger.One);
+          BigInteger _463_i;
+          _463_i = (new BigInteger((_462_dims).Count)) - (BigInteger.One);
           s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::default::Default::default()");
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
-          while ((_451_i).Sign != -1) {
-            Dafny.ISequence<Dafny.Rune> _452_recursiveGen;
-            bool _453___v31;
-            bool _454_isErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _455_recIdents;
-            Dafny.ISequence<Dafny.Rune> _out133;
-            bool _out134;
-            bool _out135;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out136;
-            DCOMP.COMP.GenExpr((_450_dims).Select(_451_i), @params, true, out _out133, out _out134, out _out135, out _out136);
-            _452_recursiveGen = _out133;
-            _453___v31 = _out134;
-            _454_isErased = _out135;
-            _455_recIdents = _out136;
-            if (!(_454_isErased)) {
-              _452_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _452_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-            }
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::rc::Rc::new(::std::cell::RefCell::new(vec!["), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("; <usize as ::dafny_runtime::NumCast>::from(")), _452_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap()]))"));
-            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _455_recIdents);
-            _451_i = (_451_i) - (BigInteger.One);
+          while ((_463_i).Sign != -1) {
+            Dafny.ISequence<Dafny.Rune> _464_recursiveGen;
+            bool _465___v31;
+            bool _466_isErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _467_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out136;
+            bool _out137;
+            bool _out138;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out139;
+            DCOMP.COMP.GenExpr((_462_dims).Select(_463_i), selfIdent, @params, true, out _out136, out _out137, out _out138, out _out139);
+            _464_recursiveGen = _out136;
+            _465___v31 = _out137;
+            _466_isErased = _out138;
+            _467_recIdents = _out139;
+            if (!(_466_isErased)) {
+              _464_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _464_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::rc::Rc::new(::std::cell::RefCell::new(vec!["), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("; <usize as ::dafny_runtime::NumCast>::from(")), _464_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap()]))"));
+            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _467_recIdents);
+            _463_i = (_463_i) - (BigInteger.One);
           }
           isOwned = true;
           isErased = true;
         }
       } else if (_source19.is_DatatypeValue) {
-        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _456___mcc_h15 = _source19.dtor_path;
-        Dafny.ISequence<Dafny.Rune> _457___mcc_h16 = _source19.dtor_variant;
-        bool _458___mcc_h17 = _source19.dtor_isCo;
-        Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, DAST._IExpression>> _459___mcc_h18 = _source19.dtor_contents;
-        Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, DAST._IExpression>> _460_values = _459___mcc_h18;
-        bool _461_isCo = _458___mcc_h17;
-        Dafny.ISequence<Dafny.Rune> _462_variant = _457___mcc_h16;
-        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _463_path = _456___mcc_h15;
+        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _468___mcc_h15 = _source19.dtor_path;
+        Dafny.ISequence<Dafny.Rune> _469___mcc_h16 = _source19.dtor_variant;
+        bool _470___mcc_h17 = _source19.dtor_isCo;
+        Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, DAST._IExpression>> _471___mcc_h18 = _source19.dtor_contents;
+        Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, DAST._IExpression>> _472_values = _471___mcc_h18;
+        bool _473_isCo = _470___mcc_h17;
+        Dafny.ISequence<Dafny.Rune> _474_variant = _469___mcc_h16;
+        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _475_path = _468___mcc_h15;
         {
-          Dafny.ISequence<Dafny.Rune> _464_path;
-          Dafny.ISequence<Dafny.Rune> _out137;
-          _out137 = DCOMP.COMP.GenPath(_463_path);
-          _464_path = _out137;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::rc::Rc::new("), _464_path), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::r#")), _462_variant);
+          Dafny.ISequence<Dafny.Rune> _476_path;
+          Dafny.ISequence<Dafny.Rune> _out140;
+          _out140 = DCOMP.COMP.GenPath(_475_path);
+          _476_path = _out140;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::rc::Rc::new("), _476_path), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::r#")), _474_variant);
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
-          BigInteger _465_i;
-          _465_i = BigInteger.Zero;
+          BigInteger _477_i;
+          _477_i = BigInteger.Zero;
           s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {"));
-          while ((_465_i) < (new BigInteger((_460_values).Count))) {
-            _System._ITuple2<Dafny.ISequence<Dafny.Rune>, DAST._IExpression> _let_tmp_rhs0 = (_460_values).Select(_465_i);
-            Dafny.ISequence<Dafny.Rune> _466_name = _let_tmp_rhs0.dtor__0;
-            DAST._IExpression _467_value = _let_tmp_rhs0.dtor__1;
-            if ((_465_i).Sign == 1) {
+          while ((_477_i) < (new BigInteger((_472_values).Count))) {
+            _System._ITuple2<Dafny.ISequence<Dafny.Rune>, DAST._IExpression> _let_tmp_rhs0 = (_472_values).Select(_477_i);
+            Dafny.ISequence<Dafny.Rune> _478_name = _let_tmp_rhs0.dtor__0;
+            DAST._IExpression _479_value = _let_tmp_rhs0.dtor__1;
+            if ((_477_i).Sign == 1) {
               s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
             }
-            if (_461_isCo) {
-              Dafny.ISequence<Dafny.Rune> _468_recursiveGen;
-              bool _469___v32;
-              bool _470_isErased;
-              Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _471_recIdents;
-              Dafny.ISequence<Dafny.Rune> _out138;
-              bool _out139;
-              bool _out140;
-              Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out141;
-              DCOMP.COMP.GenExpr(_467_value, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements(), true, out _out138, out _out139, out _out140, out _out141);
-              _468_recursiveGen = _out138;
-              _469___v32 = _out139;
-              _470_isErased = _out140;
-              _471_recIdents = _out141;
-              if (!(_470_isErased)) {
-                _468_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _468_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            if (_473_isCo) {
+              Dafny.ISequence<Dafny.Rune> _480_recursiveGen;
+              bool _481___v32;
+              bool _482_isErased;
+              Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _483_recIdents;
+              Dafny.ISequence<Dafny.Rune> _out141;
+              bool _out142;
+              bool _out143;
+              Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out144;
+              DCOMP.COMP.GenExpr(_479_value, selfIdent, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements(), true, out _out141, out _out142, out _out143, out _out144);
+              _480_recursiveGen = _out141;
+              _481___v32 = _out142;
+              _482_isErased = _out143;
+              _483_recIdents = _out144;
+              if (!(_482_isErased)) {
+                _480_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _480_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
               }
-              _468_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _468_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-              readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _471_recIdents);
-              Dafny.ISequence<Dafny.Rune> _472_allReadCloned;
-              _472_allReadCloned = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-              while (!(_471_recIdents).Equals(Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements())) {
-                Dafny.ISequence<Dafny.Rune> _473_next;
-                foreach (Dafny.ISequence<Dafny.Rune> _assign_such_that_0 in (_471_recIdents).Elements) {
-                  _473_next = (Dafny.ISequence<Dafny.Rune>)_assign_such_that_0;
-                  if ((_471_recIdents).Contains(_473_next)) {
+              _480_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _480_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+              readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _483_recIdents);
+              Dafny.ISequence<Dafny.Rune> _484_allReadCloned;
+              _484_allReadCloned = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+              while (!(_483_recIdents).Equals(Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements())) {
+                Dafny.ISequence<Dafny.Rune> _485_next;
+                foreach (Dafny.ISequence<Dafny.Rune> _assign_such_that_0 in (_483_recIdents).Elements) {
+                  _485_next = (Dafny.ISequence<Dafny.Rune>)_assign_such_that_0;
+                  if ((_483_recIdents).Contains(_485_next)) {
                     goto after__ASSIGN_SUCH_THAT_0;
                   }
                 }
-                throw new System.Exception("assign-such-that search produced no value (line 1113)");
+                throw new System.Exception("assign-such-that search produced no value (line 1140)");
               after__ASSIGN_SUCH_THAT_0:;
-                _472_allReadCloned = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_472_allReadCloned, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let r#")), _473_next), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = r#")), _473_next), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone();\n"));
-                _471_recIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Difference(_471_recIdents, Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(_473_next));
+                _484_allReadCloned = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_484_allReadCloned, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let r#")), _485_next), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = r#")), _485_next), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone();\n"));
+                _483_recIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Difference(_483_recIdents, Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(_485_next));
               }
-              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), _466_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ::dafny_runtime::LazyFieldWrapper(::dafny_runtime::Lazy::new(::std::boxed::Box::new({\n")), _472_allReadCloned), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("move || (")), _468_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")})))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), _478_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ::dafny_runtime::LazyFieldWrapper(::dafny_runtime::Lazy::new(::std::boxed::Box::new({\n")), _484_allReadCloned), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("move || (")), _480_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")})))"));
             } else {
-              Dafny.ISequence<Dafny.Rune> _474_recursiveGen;
-              bool _475___v33;
-              bool _476_isErased;
-              Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _477_recIdents;
-              Dafny.ISequence<Dafny.Rune> _out142;
-              bool _out143;
-              bool _out144;
-              Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out145;
-              DCOMP.COMP.GenExpr(_467_value, @params, true, out _out142, out _out143, out _out144, out _out145);
-              _474_recursiveGen = _out142;
-              _475___v33 = _out143;
-              _476_isErased = _out144;
-              _477_recIdents = _out145;
-              if (!(_476_isErased)) {
-                _474_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _474_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+              Dafny.ISequence<Dafny.Rune> _486_recursiveGen;
+              bool _487___v33;
+              bool _488_isErased;
+              Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _489_recIdents;
+              Dafny.ISequence<Dafny.Rune> _out145;
+              bool _out146;
+              bool _out147;
+              Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out148;
+              DCOMP.COMP.GenExpr(_479_value, selfIdent, @params, true, out _out145, out _out146, out _out147, out _out148);
+              _486_recursiveGen = _out145;
+              _487___v33 = _out146;
+              _488_isErased = _out147;
+              _489_recIdents = _out148;
+              if (!(_488_isErased)) {
+                _486_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _486_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
               }
-              _474_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _474_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), _466_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _474_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-              readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _477_recIdents);
+              _486_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _486_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), _478_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _486_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+              readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _489_recIdents);
             }
-            _465_i = (_465_i) + (BigInteger.One);
+            _477_i = (_477_i) + (BigInteger.One);
           }
           s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" })"));
           isOwned = true;
           isErased = true;
         }
       } else if (_source19.is_Convert) {
-        DAST._IExpression _478___mcc_h19 = _source19.dtor_value;
-        DAST._IType _479___mcc_h20 = _source19.dtor_from;
-        DAST._IType _480___mcc_h21 = _source19.dtor_typ;
-        DAST._IType _481_toTpe = _480___mcc_h21;
-        DAST._IType _482_fromTpe = _479___mcc_h20;
-        DAST._IExpression _483_expr = _478___mcc_h19;
+        DAST._IExpression _490___mcc_h19 = _source19.dtor_value;
+        DAST._IType _491___mcc_h20 = _source19.dtor_from;
+        DAST._IType _492___mcc_h21 = _source19.dtor_typ;
+        DAST._IType _493_toTpe = _492___mcc_h21;
+        DAST._IType _494_fromTpe = _491___mcc_h20;
+        DAST._IExpression _495_expr = _490___mcc_h19;
         {
-          if (object.Equals(_482_fromTpe, _481_toTpe)) {
-            Dafny.ISequence<Dafny.Rune> _484_recursiveGen;
-            bool _485_recOwned;
-            bool _486_recErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _487_recIdents;
-            Dafny.ISequence<Dafny.Rune> _out146;
-            bool _out147;
-            bool _out148;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out149;
-            DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out146, out _out147, out _out148, out _out149);
-            _484_recursiveGen = _out146;
-            _485_recOwned = _out147;
-            _486_recErased = _out148;
-            _487_recIdents = _out149;
-            s = _484_recursiveGen;
-            isOwned = _485_recOwned;
-            isErased = _486_recErased;
-            readIdents = _487_recIdents;
+          if (object.Equals(_494_fromTpe, _493_toTpe)) {
+            Dafny.ISequence<Dafny.Rune> _496_recursiveGen;
+            bool _497_recOwned;
+            bool _498_recErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _499_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out149;
+            bool _out150;
+            bool _out151;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out152;
+            DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out149, out _out150, out _out151, out _out152);
+            _496_recursiveGen = _out149;
+            _497_recOwned = _out150;
+            _498_recErased = _out151;
+            _499_recIdents = _out152;
+            s = _496_recursiveGen;
+            isOwned = _497_recOwned;
+            isErased = _498_recErased;
+            readIdents = _499_recIdents;
           } else {
-            _System._ITuple2<DAST._IType, DAST._IType> _source25 = _System.Tuple2<DAST._IType, DAST._IType>.create(_482_fromTpe, _481_toTpe);
-            DAST._IType _488___mcc_h123 = _source25.dtor__0;
-            DAST._IType _489___mcc_h124 = _source25.dtor__1;
-            DAST._IType _source26 = _488___mcc_h123;
+            _System._ITuple2<DAST._IType, DAST._IType> _source25 = _System.Tuple2<DAST._IType, DAST._IType>.create(_494_fromTpe, _493_toTpe);
+            DAST._IType _500___mcc_h237 = _source25.dtor__0;
+            DAST._IType _501___mcc_h238 = _source25.dtor__1;
+            DAST._IType _source26 = _500___mcc_h237;
             if (_source26.is_Path) {
-              Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _490___mcc_h127 = _source26.dtor_Path_a0;
-              Dafny.ISequence<DAST._IType> _491___mcc_h128 = _source26.dtor_typeArgs;
-              DAST._IResolvedType _492___mcc_h129 = _source26.dtor_resolved;
-              DAST._IResolvedType _source27 = _492___mcc_h129;
+              Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _502___mcc_h241 = _source26.dtor_Path_a0;
+              Dafny.ISequence<DAST._IType> _503___mcc_h242 = _source26.dtor_typeArgs;
+              DAST._IResolvedType _504___mcc_h243 = _source26.dtor_resolved;
+              DAST._IResolvedType _source27 = _504___mcc_h243;
               if (_source27.is_Datatype) {
-                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _493___mcc_h136 = _source27.dtor_path;
-                DAST._IType _source28 = _489___mcc_h124;
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _505___mcc_h253 = _source27.dtor_path;
+                DAST._IType _source28 = _501___mcc_h238;
                 if (_source28.is_Path) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _494___mcc_h139 = _source28.dtor_Path_a0;
-                  Dafny.ISequence<DAST._IType> _495___mcc_h140 = _source28.dtor_typeArgs;
-                  DAST._IResolvedType _496___mcc_h141 = _source28.dtor_resolved;
-                  DAST._IResolvedType _source29 = _496___mcc_h141;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _506___mcc_h257 = _source28.dtor_Path_a0;
+                  Dafny.ISequence<DAST._IType> _507___mcc_h258 = _source28.dtor_typeArgs;
+                  DAST._IResolvedType _508___mcc_h259 = _source28.dtor_resolved;
+                  DAST._IResolvedType _source29 = _508___mcc_h259;
                   if (_source29.is_Datatype) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _497___mcc_h145 = _source29.dtor_path;
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _509___mcc_h263 = _source29.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _498_recursiveGen;
-                      bool _499_recOwned;
-                      bool _500_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _501_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out150;
-                      bool _out151;
-                      bool _out152;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out153;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out150, out _out151, out _out152, out _out153);
-                      _498_recursiveGen = _out150;
-                      _499_recOwned = _out151;
-                      _500_recErased = _out152;
-                      _501_recIdents = _out153;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _498_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _499_recOwned;
-                      isErased = _500_recErased;
-                      readIdents = _501_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _510_recursiveGen;
+                      bool _511_recOwned;
+                      bool _512_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _513_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out153;
+                      bool _out154;
+                      bool _out155;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out156;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out153, out _out154, out _out155, out _out156);
+                      _510_recursiveGen = _out153;
+                      _511_recOwned = _out154;
+                      _512_recErased = _out155;
+                      _513_recIdents = _out156;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _510_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _511_recOwned;
+                      isErased = _512_recErased;
+                      readIdents = _513_recIdents;
                     }
                   } else if (_source29.is_Trait) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _502___mcc_h147 = _source29.dtor_path;
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _514___mcc_h265 = _source29.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _503_recursiveGen;
-                      bool _504_recOwned;
-                      bool _505_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _506_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out154;
-                      bool _out155;
-                      bool _out156;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out157;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out154, out _out155, out _out156, out _out157);
-                      _503_recursiveGen = _out154;
-                      _504_recOwned = _out155;
-                      _505_recErased = _out156;
-                      _506_recIdents = _out157;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _503_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _504_recOwned;
-                      isErased = _505_recErased;
-                      readIdents = _506_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _515_recursiveGen;
+                      bool _516_recOwned;
+                      bool _517_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _518_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out157;
+                      bool _out158;
+                      bool _out159;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out160;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out157, out _out158, out _out159, out _out160);
+                      _515_recursiveGen = _out157;
+                      _516_recOwned = _out158;
+                      _517_recErased = _out159;
+                      _518_recIdents = _out160;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _515_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _516_recOwned;
+                      isErased = _517_recErased;
+                      readIdents = _518_recIdents;
                     }
                   } else {
-                    DAST._IType _507___mcc_h149 = _source29.dtor_Newtype_a0;
-                    DAST._IType _508_b = _507___mcc_h149;
+                    DAST._IType _519___mcc_h267 = _source29.dtor_Newtype_a0;
+                    DAST._IType _520_b = _519___mcc_h267;
                     {
-                      if (object.Equals(_482_fromTpe, _508_b)) {
-                        Dafny.ISequence<Dafny.Rune> _509_recursiveGen;
-                        bool _510_recOwned;
-                        bool _511_recErased;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _512_recIdents;
-                        Dafny.ISequence<Dafny.Rune> _out158;
-                        bool _out159;
-                        bool _out160;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out161;
-                        DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out158, out _out159, out _out160, out _out161);
-                        _509_recursiveGen = _out158;
-                        _510_recOwned = _out159;
-                        _511_recErased = _out160;
-                        _512_recIdents = _out161;
-                        Dafny.ISequence<Dafny.Rune> _513_rhsType;
-                        Dafny.ISequence<Dafny.Rune> _out162;
-                        _out162 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                        _513_rhsType = _out162;
-                        Dafny.ISequence<Dafny.Rune> _514_uneraseFn;
-                        _514_uneraseFn = ((_510_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _513_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _514_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _509_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                        isOwned = _510_recOwned;
+                      if (object.Equals(_494_fromTpe, _520_b)) {
+                        Dafny.ISequence<Dafny.Rune> _521_recursiveGen;
+                        bool _522_recOwned;
+                        bool _523_recErased;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _524_recIdents;
+                        Dafny.ISequence<Dafny.Rune> _out161;
+                        bool _out162;
+                        bool _out163;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out164;
+                        DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out161, out _out162, out _out163, out _out164);
+                        _521_recursiveGen = _out161;
+                        _522_recOwned = _out162;
+                        _523_recErased = _out163;
+                        _524_recIdents = _out164;
+                        Dafny.ISequence<Dafny.Rune> _525_rhsType;
+                        Dafny.ISequence<Dafny.Rune> _out165;
+                        _out165 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                        _525_rhsType = _out165;
+                        Dafny.ISequence<Dafny.Rune> _526_uneraseFn;
+                        _526_uneraseFn = ((_522_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _525_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _526_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _521_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                        isOwned = _522_recOwned;
                         isErased = false;
-                        readIdents = _512_recIdents;
+                        readIdents = _524_recIdents;
                       } else {
-                        Dafny.ISequence<Dafny.Rune> _out163;
-                        bool _out164;
-                        bool _out165;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out166;
-                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _508_b), _508_b, _481_toTpe), @params, mustOwn, out _out163, out _out164, out _out165, out _out166);
-                        s = _out163;
-                        isOwned = _out164;
-                        isErased = _out165;
-                        readIdents = _out166;
+                        Dafny.ISequence<Dafny.Rune> _out166;
+                        bool _out167;
+                        bool _out168;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out169;
+                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _520_b), _520_b, _493_toTpe), selfIdent, @params, mustOwn, out _out166, out _out167, out _out168, out _out169);
+                        s = _out166;
+                        isOwned = _out167;
+                        isErased = _out168;
+                        readIdents = _out169;
                       }
                     }
                   }
-                } else if (_source28.is_Tuple) {
-                  Dafny.ISequence<DAST._IType> _515___mcc_h151 = _source28.dtor_Tuple_a0;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _516_recursiveGen;
-                    bool _517_recOwned;
-                    bool _518_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _519_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out167;
-                    bool _out168;
-                    bool _out169;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out170;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out167, out _out168, out _out169, out _out170);
-                    _516_recursiveGen = _out167;
-                    _517_recOwned = _out168;
-                    _518_recErased = _out169;
-                    _519_recIdents = _out170;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _516_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _517_recOwned;
-                    isErased = _518_recErased;
-                    readIdents = _519_recIdents;
-                  }
-                } else if (_source28.is_Array) {
-                  DAST._IType _520___mcc_h153 = _source28.dtor_element;
+                } else if (_source28.is_Nullable) {
+                  DAST._IType _527___mcc_h269 = _source28.dtor_Nullable_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _521_recursiveGen;
-                    bool _522_recOwned;
-                    bool _523_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _524_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out171;
+                    Dafny.ISequence<Dafny.Rune> _528_recursiveGen;
+                    bool _529_recOwned;
+                    bool _530_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _531_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out170;
+                    bool _out171;
                     bool _out172;
-                    bool _out173;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out174;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out171, out _out172, out _out173, out _out174);
-                    _521_recursiveGen = _out171;
-                    _522_recOwned = _out172;
-                    _523_recErased = _out173;
-                    _524_recIdents = _out174;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _521_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _522_recOwned;
-                    isErased = _523_recErased;
-                    readIdents = _524_recIdents;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out173;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out170, out _out171, out _out172, out _out173);
+                    _528_recursiveGen = _out170;
+                    _529_recOwned = _out171;
+                    _530_recErased = _out172;
+                    _531_recIdents = _out173;
+                    if (!(_529_recOwned)) {
+                      _528_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_528_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                    }
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _528_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                    isOwned = true;
+                    isErased = _530_recErased;
+                    readIdents = _531_recIdents;
                   }
-                } else if (_source28.is_Seq) {
-                  DAST._IType _525___mcc_h155 = _source28.dtor_element;
+                } else if (_source28.is_Tuple) {
+                  Dafny.ISequence<DAST._IType> _532___mcc_h271 = _source28.dtor_Tuple_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _526_recursiveGen;
-                    bool _527_recOwned;
-                    bool _528_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _529_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out175;
+                    Dafny.ISequence<Dafny.Rune> _533_recursiveGen;
+                    bool _534_recOwned;
+                    bool _535_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _536_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out174;
+                    bool _out175;
                     bool _out176;
-                    bool _out177;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out178;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out175, out _out176, out _out177, out _out178);
-                    _526_recursiveGen = _out175;
-                    _527_recOwned = _out176;
-                    _528_recErased = _out177;
-                    _529_recIdents = _out178;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _526_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _527_recOwned;
-                    isErased = _528_recErased;
-                    readIdents = _529_recIdents;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out177;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out174, out _out175, out _out176, out _out177);
+                    _533_recursiveGen = _out174;
+                    _534_recOwned = _out175;
+                    _535_recErased = _out176;
+                    _536_recIdents = _out177;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _533_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _534_recOwned;
+                    isErased = _535_recErased;
+                    readIdents = _536_recIdents;
                   }
-                } else if (_source28.is_Set) {
-                  DAST._IType _530___mcc_h157 = _source28.dtor_element;
+                } else if (_source28.is_Array) {
+                  DAST._IType _537___mcc_h273 = _source28.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _531_recursiveGen;
-                    bool _532_recOwned;
-                    bool _533_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _534_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out179;
+                    Dafny.ISequence<Dafny.Rune> _538_recursiveGen;
+                    bool _539_recOwned;
+                    bool _540_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _541_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out178;
+                    bool _out179;
                     bool _out180;
-                    bool _out181;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out182;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out179, out _out180, out _out181, out _out182);
-                    _531_recursiveGen = _out179;
-                    _532_recOwned = _out180;
-                    _533_recErased = _out181;
-                    _534_recIdents = _out182;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _531_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _532_recOwned;
-                    isErased = _533_recErased;
-                    readIdents = _534_recIdents;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out181;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out178, out _out179, out _out180, out _out181);
+                    _538_recursiveGen = _out178;
+                    _539_recOwned = _out179;
+                    _540_recErased = _out180;
+                    _541_recIdents = _out181;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _538_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _539_recOwned;
+                    isErased = _540_recErased;
+                    readIdents = _541_recIdents;
                   }
-                } else if (_source28.is_Multiset) {
-                  DAST._IType _535___mcc_h159 = _source28.dtor_element;
+                } else if (_source28.is_Seq) {
+                  DAST._IType _542___mcc_h275 = _source28.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _536_recursiveGen;
-                    bool _537_recOwned;
-                    bool _538_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _539_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out183;
+                    Dafny.ISequence<Dafny.Rune> _543_recursiveGen;
+                    bool _544_recOwned;
+                    bool _545_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _546_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out182;
+                    bool _out183;
                     bool _out184;
-                    bool _out185;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out186;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out183, out _out184, out _out185, out _out186);
-                    _536_recursiveGen = _out183;
-                    _537_recOwned = _out184;
-                    _538_recErased = _out185;
-                    _539_recIdents = _out186;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _536_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _537_recOwned;
-                    isErased = _538_recErased;
-                    readIdents = _539_recIdents;
-                  }
-                } else if (_source28.is_Map) {
-                  DAST._IType _540___mcc_h161 = _source28.dtor_key;
-                  DAST._IType _541___mcc_h162 = _source28.dtor_value;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _542_recursiveGen;
-                    bool _543_recOwned;
-                    bool _544_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _545_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out187;
-                    bool _out188;
-                    bool _out189;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out190;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out187, out _out188, out _out189, out _out190);
-                    _542_recursiveGen = _out187;
-                    _543_recOwned = _out188;
-                    _544_recErased = _out189;
-                    _545_recIdents = _out190;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _542_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _543_recOwned;
-                    isErased = _544_recErased;
-                    readIdents = _545_recIdents;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out185;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out182, out _out183, out _out184, out _out185);
+                    _543_recursiveGen = _out182;
+                    _544_recOwned = _out183;
+                    _545_recErased = _out184;
+                    _546_recIdents = _out185;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _543_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _544_recOwned;
+                    isErased = _545_recErased;
+                    readIdents = _546_recIdents;
                   }
-                } else if (_source28.is_Arrow) {
-                  Dafny.ISequence<DAST._IType> _546___mcc_h165 = _source28.dtor_args;
-                  DAST._IType _547___mcc_h166 = _source28.dtor_result;
+                } else if (_source28.is_Set) {
+                  DAST._IType _547___mcc_h277 = _source28.dtor_element;
                   {
                     Dafny.ISequence<Dafny.Rune> _548_recursiveGen;
                     bool _549_recOwned;
                     bool _550_recErased;
                     Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _551_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out191;
-                    bool _out192;
-                    bool _out193;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out194;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out191, out _out192, out _out193, out _out194);
-                    _548_recursiveGen = _out191;
-                    _549_recOwned = _out192;
-                    _550_recErased = _out193;
-                    _551_recIdents = _out194;
+                    Dafny.ISequence<Dafny.Rune> _out186;
+                    bool _out187;
+                    bool _out188;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out189;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out186, out _out187, out _out188, out _out189);
+                    _548_recursiveGen = _out186;
+                    _549_recOwned = _out187;
+                    _550_recErased = _out188;
+                    _551_recIdents = _out189;
                     s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _548_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
                     isOwned = _549_recOwned;
                     isErased = _550_recErased;
                     readIdents = _551_recIdents;
                   }
-                } else if (_source28.is_Primitive) {
-                  DAST._IPrimitive _552___mcc_h169 = _source28.dtor_Primitive_a0;
+                } else if (_source28.is_Multiset) {
+                  DAST._IType _552___mcc_h279 = _source28.dtor_element;
                   {
                     Dafny.ISequence<Dafny.Rune> _553_recursiveGen;
                     bool _554_recOwned;
                     bool _555_recErased;
                     Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _556_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out195;
-                    bool _out196;
-                    bool _out197;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out198;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out195, out _out196, out _out197, out _out198);
-                    _553_recursiveGen = _out195;
-                    _554_recOwned = _out196;
-                    _555_recErased = _out197;
-                    _556_recIdents = _out198;
+                    Dafny.ISequence<Dafny.Rune> _out190;
+                    bool _out191;
+                    bool _out192;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out193;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out190, out _out191, out _out192, out _out193);
+                    _553_recursiveGen = _out190;
+                    _554_recOwned = _out191;
+                    _555_recErased = _out192;
+                    _556_recIdents = _out193;
                     s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _553_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
                     isOwned = _554_recOwned;
                     isErased = _555_recErased;
                     readIdents = _556_recIdents;
                   }
-                } else if (_source28.is_Passthrough) {
-                  Dafny.ISequence<Dafny.Rune> _557___mcc_h171 = _source28.dtor_Passthrough_a0;
+                } else if (_source28.is_Map) {
+                  DAST._IType _557___mcc_h281 = _source28.dtor_key;
+                  DAST._IType _558___mcc_h282 = _source28.dtor_value;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _559_recursiveGen;
+                    bool _560_recOwned;
+                    bool _561_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _562_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out194;
+                    bool _out195;
+                    bool _out196;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out197;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out194, out _out195, out _out196, out _out197);
+                    _559_recursiveGen = _out194;
+                    _560_recOwned = _out195;
+                    _561_recErased = _out196;
+                    _562_recIdents = _out197;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _559_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _560_recOwned;
+                    isErased = _561_recErased;
+                    readIdents = _562_recIdents;
+                  }
+                } else if (_source28.is_Arrow) {
+                  Dafny.ISequence<DAST._IType> _563___mcc_h285 = _source28.dtor_args;
+                  DAST._IType _564___mcc_h286 = _source28.dtor_result;
                   {
-                    Dafny.ISequence<Dafny.Rune> _558_recursiveGen;
-                    bool _559_recOwned;
-                    bool _560_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _561_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out199;
+                    Dafny.ISequence<Dafny.Rune> _565_recursiveGen;
+                    bool _566_recOwned;
+                    bool _567_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _568_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out198;
+                    bool _out199;
                     bool _out200;
-                    bool _out201;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out202;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out199, out _out200, out _out201, out _out202);
-                    _558_recursiveGen = _out199;
-                    _559_recOwned = _out200;
-                    _560_recErased = _out201;
-                    _561_recIdents = _out202;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _558_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _559_recOwned;
-                    isErased = _560_recErased;
-                    readIdents = _561_recIdents;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out201;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out198, out _out199, out _out200, out _out201);
+                    _565_recursiveGen = _out198;
+                    _566_recOwned = _out199;
+                    _567_recErased = _out200;
+                    _568_recIdents = _out201;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _565_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _566_recOwned;
+                    isErased = _567_recErased;
+                    readIdents = _568_recIdents;
                   }
-                } else {
-                  Dafny.ISequence<Dafny.Rune> _562___mcc_h173 = _source28.dtor_TypeArg_a0;
+                } else if (_source28.is_Primitive) {
+                  DAST._IPrimitive _569___mcc_h289 = _source28.dtor_Primitive_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _563_recursiveGen;
-                    bool _564_recOwned;
-                    bool _565_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _566_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out203;
+                    Dafny.ISequence<Dafny.Rune> _570_recursiveGen;
+                    bool _571_recOwned;
+                    bool _572_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _573_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out202;
+                    bool _out203;
                     bool _out204;
-                    bool _out205;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out206;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out203, out _out204, out _out205, out _out206);
-                    _563_recursiveGen = _out203;
-                    _564_recOwned = _out204;
-                    _565_recErased = _out205;
-                    _566_recIdents = _out206;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _563_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _564_recOwned;
-                    isErased = _565_recErased;
-                    readIdents = _566_recIdents;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out205;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out202, out _out203, out _out204, out _out205);
+                    _570_recursiveGen = _out202;
+                    _571_recOwned = _out203;
+                    _572_recErased = _out204;
+                    _573_recIdents = _out205;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _570_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _571_recOwned;
+                    isErased = _572_recErased;
+                    readIdents = _573_recIdents;
+                  }
+                } else if (_source28.is_Passthrough) {
+                  Dafny.ISequence<Dafny.Rune> _574___mcc_h291 = _source28.dtor_Passthrough_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _575_recursiveGen;
+                    bool _576_recOwned;
+                    bool _577_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _578_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out206;
+                    bool _out207;
+                    bool _out208;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out209;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out206, out _out207, out _out208, out _out209);
+                    _575_recursiveGen = _out206;
+                    _576_recOwned = _out207;
+                    _577_recErased = _out208;
+                    _578_recIdents = _out209;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _575_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _576_recOwned;
+                    isErased = _577_recErased;
+                    readIdents = _578_recIdents;
+                  }
+                } else {
+                  Dafny.ISequence<Dafny.Rune> _579___mcc_h293 = _source28.dtor_TypeArg_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _580_recursiveGen;
+                    bool _581_recOwned;
+                    bool _582_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _583_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out210;
+                    bool _out211;
+                    bool _out212;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out213;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out210, out _out211, out _out212, out _out213);
+                    _580_recursiveGen = _out210;
+                    _581_recOwned = _out211;
+                    _582_recErased = _out212;
+                    _583_recIdents = _out213;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _580_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _581_recOwned;
+                    isErased = _582_recErased;
+                    readIdents = _583_recIdents;
                   }
                 }
               } else if (_source27.is_Trait) {
-                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _567___mcc_h175 = _source27.dtor_path;
-                DAST._IType _source30 = _489___mcc_h124;
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _584___mcc_h295 = _source27.dtor_path;
+                DAST._IType _source30 = _501___mcc_h238;
                 if (_source30.is_Path) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _568___mcc_h178 = _source30.dtor_Path_a0;
-                  Dafny.ISequence<DAST._IType> _569___mcc_h179 = _source30.dtor_typeArgs;
-                  DAST._IResolvedType _570___mcc_h180 = _source30.dtor_resolved;
-                  DAST._IResolvedType _source31 = _570___mcc_h180;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _585___mcc_h299 = _source30.dtor_Path_a0;
+                  Dafny.ISequence<DAST._IType> _586___mcc_h300 = _source30.dtor_typeArgs;
+                  DAST._IResolvedType _587___mcc_h301 = _source30.dtor_resolved;
+                  DAST._IResolvedType _source31 = _587___mcc_h301;
                   if (_source31.is_Datatype) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _571___mcc_h184 = _source31.dtor_path;
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _588___mcc_h305 = _source31.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _572_recursiveGen;
-                      bool _573_recOwned;
-                      bool _574_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _575_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out207;
-                      bool _out208;
-                      bool _out209;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out210;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out207, out _out208, out _out209, out _out210);
-                      _572_recursiveGen = _out207;
-                      _573_recOwned = _out208;
-                      _574_recErased = _out209;
-                      _575_recIdents = _out210;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _572_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _573_recOwned;
-                      isErased = _574_recErased;
-                      readIdents = _575_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _589_recursiveGen;
+                      bool _590_recOwned;
+                      bool _591_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _592_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out214;
+                      bool _out215;
+                      bool _out216;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out217;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out214, out _out215, out _out216, out _out217);
+                      _589_recursiveGen = _out214;
+                      _590_recOwned = _out215;
+                      _591_recErased = _out216;
+                      _592_recIdents = _out217;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _589_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _590_recOwned;
+                      isErased = _591_recErased;
+                      readIdents = _592_recIdents;
                     }
                   } else if (_source31.is_Trait) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _576___mcc_h186 = _source31.dtor_path;
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _593___mcc_h307 = _source31.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _577_recursiveGen;
-                      bool _578_recOwned;
-                      bool _579_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _580_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out211;
-                      bool _out212;
-                      bool _out213;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out214;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out211, out _out212, out _out213, out _out214);
-                      _577_recursiveGen = _out211;
-                      _578_recOwned = _out212;
-                      _579_recErased = _out213;
-                      _580_recIdents = _out214;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _577_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _578_recOwned;
-                      isErased = _579_recErased;
-                      readIdents = _580_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _594_recursiveGen;
+                      bool _595_recOwned;
+                      bool _596_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _597_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out218;
+                      bool _out219;
+                      bool _out220;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out221;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out218, out _out219, out _out220, out _out221);
+                      _594_recursiveGen = _out218;
+                      _595_recOwned = _out219;
+                      _596_recErased = _out220;
+                      _597_recIdents = _out221;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _594_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _595_recOwned;
+                      isErased = _596_recErased;
+                      readIdents = _597_recIdents;
                     }
                   } else {
-                    DAST._IType _581___mcc_h188 = _source31.dtor_Newtype_a0;
-                    DAST._IType _582_b = _581___mcc_h188;
+                    DAST._IType _598___mcc_h309 = _source31.dtor_Newtype_a0;
+                    DAST._IType _599_b = _598___mcc_h309;
                     {
-                      if (object.Equals(_482_fromTpe, _582_b)) {
-                        Dafny.ISequence<Dafny.Rune> _583_recursiveGen;
-                        bool _584_recOwned;
-                        bool _585_recErased;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _586_recIdents;
-                        Dafny.ISequence<Dafny.Rune> _out215;
-                        bool _out216;
-                        bool _out217;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out218;
-                        DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out215, out _out216, out _out217, out _out218);
-                        _583_recursiveGen = _out215;
-                        _584_recOwned = _out216;
-                        _585_recErased = _out217;
-                        _586_recIdents = _out218;
-                        Dafny.ISequence<Dafny.Rune> _587_rhsType;
-                        Dafny.ISequence<Dafny.Rune> _out219;
-                        _out219 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                        _587_rhsType = _out219;
-                        Dafny.ISequence<Dafny.Rune> _588_uneraseFn;
-                        _588_uneraseFn = ((_584_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _587_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _588_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _583_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                        isOwned = _584_recOwned;
+                      if (object.Equals(_494_fromTpe, _599_b)) {
+                        Dafny.ISequence<Dafny.Rune> _600_recursiveGen;
+                        bool _601_recOwned;
+                        bool _602_recErased;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _603_recIdents;
+                        Dafny.ISequence<Dafny.Rune> _out222;
+                        bool _out223;
+                        bool _out224;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out225;
+                        DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out222, out _out223, out _out224, out _out225);
+                        _600_recursiveGen = _out222;
+                        _601_recOwned = _out223;
+                        _602_recErased = _out224;
+                        _603_recIdents = _out225;
+                        Dafny.ISequence<Dafny.Rune> _604_rhsType;
+                        Dafny.ISequence<Dafny.Rune> _out226;
+                        _out226 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                        _604_rhsType = _out226;
+                        Dafny.ISequence<Dafny.Rune> _605_uneraseFn;
+                        _605_uneraseFn = ((_601_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _604_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _605_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _600_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                        isOwned = _601_recOwned;
                         isErased = false;
-                        readIdents = _586_recIdents;
+                        readIdents = _603_recIdents;
                       } else {
-                        Dafny.ISequence<Dafny.Rune> _out220;
-                        bool _out221;
-                        bool _out222;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out223;
-                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _582_b), _582_b, _481_toTpe), @params, mustOwn, out _out220, out _out221, out _out222, out _out223);
-                        s = _out220;
-                        isOwned = _out221;
-                        isErased = _out222;
-                        readIdents = _out223;
+                        Dafny.ISequence<Dafny.Rune> _out227;
+                        bool _out228;
+                        bool _out229;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out230;
+                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _599_b), _599_b, _493_toTpe), selfIdent, @params, mustOwn, out _out227, out _out228, out _out229, out _out230);
+                        s = _out227;
+                        isOwned = _out228;
+                        isErased = _out229;
+                        readIdents = _out230;
                       }
                     }
                   }
-                } else if (_source30.is_Tuple) {
-                  Dafny.ISequence<DAST._IType> _589___mcc_h190 = _source30.dtor_Tuple_a0;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _590_recursiveGen;
-                    bool _591_recOwned;
-                    bool _592_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _593_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out224;
-                    bool _out225;
-                    bool _out226;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out227;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out224, out _out225, out _out226, out _out227);
-                    _590_recursiveGen = _out224;
-                    _591_recOwned = _out225;
-                    _592_recErased = _out226;
-                    _593_recIdents = _out227;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _590_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _591_recOwned;
-                    isErased = _592_recErased;
-                    readIdents = _593_recIdents;
-                  }
-                } else if (_source30.is_Array) {
-                  DAST._IType _594___mcc_h192 = _source30.dtor_element;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _595_recursiveGen;
-                    bool _596_recOwned;
-                    bool _597_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _598_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out228;
-                    bool _out229;
-                    bool _out230;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out231;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out228, out _out229, out _out230, out _out231);
-                    _595_recursiveGen = _out228;
-                    _596_recOwned = _out229;
-                    _597_recErased = _out230;
-                    _598_recIdents = _out231;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _595_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _596_recOwned;
-                    isErased = _597_recErased;
-                    readIdents = _598_recIdents;
-                  }
-                } else if (_source30.is_Seq) {
-                  DAST._IType _599___mcc_h194 = _source30.dtor_element;
+                } else if (_source30.is_Nullable) {
+                  DAST._IType _606___mcc_h311 = _source30.dtor_Nullable_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _600_recursiveGen;
-                    bool _601_recOwned;
-                    bool _602_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _603_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out232;
+                    Dafny.ISequence<Dafny.Rune> _607_recursiveGen;
+                    bool _608_recOwned;
+                    bool _609_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _610_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out231;
+                    bool _out232;
                     bool _out233;
-                    bool _out234;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out235;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out232, out _out233, out _out234, out _out235);
-                    _600_recursiveGen = _out232;
-                    _601_recOwned = _out233;
-                    _602_recErased = _out234;
-                    _603_recIdents = _out235;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _600_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _601_recOwned;
-                    isErased = _602_recErased;
-                    readIdents = _603_recIdents;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out234;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out231, out _out232, out _out233, out _out234);
+                    _607_recursiveGen = _out231;
+                    _608_recOwned = _out232;
+                    _609_recErased = _out233;
+                    _610_recIdents = _out234;
+                    if (!(_608_recOwned)) {
+                      _607_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_607_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                    }
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _607_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                    isOwned = true;
+                    isErased = _609_recErased;
+                    readIdents = _610_recIdents;
                   }
-                } else if (_source30.is_Set) {
-                  DAST._IType _604___mcc_h196 = _source30.dtor_element;
+                } else if (_source30.is_Tuple) {
+                  Dafny.ISequence<DAST._IType> _611___mcc_h313 = _source30.dtor_Tuple_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _605_recursiveGen;
-                    bool _606_recOwned;
-                    bool _607_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _608_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out236;
+                    Dafny.ISequence<Dafny.Rune> _612_recursiveGen;
+                    bool _613_recOwned;
+                    bool _614_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _615_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out235;
+                    bool _out236;
                     bool _out237;
-                    bool _out238;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out239;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out236, out _out237, out _out238, out _out239);
-                    _605_recursiveGen = _out236;
-                    _606_recOwned = _out237;
-                    _607_recErased = _out238;
-                    _608_recIdents = _out239;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _605_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _606_recOwned;
-                    isErased = _607_recErased;
-                    readIdents = _608_recIdents;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out238;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out235, out _out236, out _out237, out _out238);
+                    _612_recursiveGen = _out235;
+                    _613_recOwned = _out236;
+                    _614_recErased = _out237;
+                    _615_recIdents = _out238;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _612_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _613_recOwned;
+                    isErased = _614_recErased;
+                    readIdents = _615_recIdents;
                   }
-                } else if (_source30.is_Multiset) {
-                  DAST._IType _609___mcc_h198 = _source30.dtor_element;
+                } else if (_source30.is_Array) {
+                  DAST._IType _616___mcc_h315 = _source30.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _610_recursiveGen;
-                    bool _611_recOwned;
-                    bool _612_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _613_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out240;
+                    Dafny.ISequence<Dafny.Rune> _617_recursiveGen;
+                    bool _618_recOwned;
+                    bool _619_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _620_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out239;
+                    bool _out240;
                     bool _out241;
-                    bool _out242;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out243;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out240, out _out241, out _out242, out _out243);
-                    _610_recursiveGen = _out240;
-                    _611_recOwned = _out241;
-                    _612_recErased = _out242;
-                    _613_recIdents = _out243;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _610_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _611_recOwned;
-                    isErased = _612_recErased;
-                    readIdents = _613_recIdents;
-                  }
-                } else if (_source30.is_Map) {
-                  DAST._IType _614___mcc_h200 = _source30.dtor_key;
-                  DAST._IType _615___mcc_h201 = _source30.dtor_value;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _616_recursiveGen;
-                    bool _617_recOwned;
-                    bool _618_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _619_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out244;
-                    bool _out245;
-                    bool _out246;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out247;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out244, out _out245, out _out246, out _out247);
-                    _616_recursiveGen = _out244;
-                    _617_recOwned = _out245;
-                    _618_recErased = _out246;
-                    _619_recIdents = _out247;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _616_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _617_recOwned;
-                    isErased = _618_recErased;
-                    readIdents = _619_recIdents;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out242;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out239, out _out240, out _out241, out _out242);
+                    _617_recursiveGen = _out239;
+                    _618_recOwned = _out240;
+                    _619_recErased = _out241;
+                    _620_recIdents = _out242;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _617_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _618_recOwned;
+                    isErased = _619_recErased;
+                    readIdents = _620_recIdents;
                   }
-                } else if (_source30.is_Arrow) {
-                  Dafny.ISequence<DAST._IType> _620___mcc_h204 = _source30.dtor_args;
-                  DAST._IType _621___mcc_h205 = _source30.dtor_result;
+                } else if (_source30.is_Seq) {
+                  DAST._IType _621___mcc_h317 = _source30.dtor_element;
                   {
                     Dafny.ISequence<Dafny.Rune> _622_recursiveGen;
                     bool _623_recOwned;
                     bool _624_recErased;
                     Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _625_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out248;
-                    bool _out249;
-                    bool _out250;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out251;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out248, out _out249, out _out250, out _out251);
-                    _622_recursiveGen = _out248;
-                    _623_recOwned = _out249;
-                    _624_recErased = _out250;
-                    _625_recIdents = _out251;
+                    Dafny.ISequence<Dafny.Rune> _out243;
+                    bool _out244;
+                    bool _out245;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out246;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out243, out _out244, out _out245, out _out246);
+                    _622_recursiveGen = _out243;
+                    _623_recOwned = _out244;
+                    _624_recErased = _out245;
+                    _625_recIdents = _out246;
                     s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _622_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
                     isOwned = _623_recOwned;
                     isErased = _624_recErased;
                     readIdents = _625_recIdents;
                   }
-                } else if (_source30.is_Primitive) {
-                  DAST._IPrimitive _626___mcc_h208 = _source30.dtor_Primitive_a0;
+                } else if (_source30.is_Set) {
+                  DAST._IType _626___mcc_h319 = _source30.dtor_element;
                   {
                     Dafny.ISequence<Dafny.Rune> _627_recursiveGen;
                     bool _628_recOwned;
                     bool _629_recErased;
                     Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _630_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out252;
-                    bool _out253;
-                    bool _out254;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out255;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out252, out _out253, out _out254, out _out255);
-                    _627_recursiveGen = _out252;
-                    _628_recOwned = _out253;
-                    _629_recErased = _out254;
-                    _630_recIdents = _out255;
+                    Dafny.ISequence<Dafny.Rune> _out247;
+                    bool _out248;
+                    bool _out249;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out250;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out247, out _out248, out _out249, out _out250);
+                    _627_recursiveGen = _out247;
+                    _628_recOwned = _out248;
+                    _629_recErased = _out249;
+                    _630_recIdents = _out250;
                     s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _627_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
                     isOwned = _628_recOwned;
                     isErased = _629_recErased;
                     readIdents = _630_recIdents;
                   }
-                } else if (_source30.is_Passthrough) {
-                  Dafny.ISequence<Dafny.Rune> _631___mcc_h210 = _source30.dtor_Passthrough_a0;
+                } else if (_source30.is_Multiset) {
+                  DAST._IType _631___mcc_h321 = _source30.dtor_element;
                   {
                     Dafny.ISequence<Dafny.Rune> _632_recursiveGen;
                     bool _633_recOwned;
                     bool _634_recErased;
                     Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _635_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out256;
-                    bool _out257;
-                    bool _out258;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out259;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out256, out _out257, out _out258, out _out259);
-                    _632_recursiveGen = _out256;
-                    _633_recOwned = _out257;
-                    _634_recErased = _out258;
-                    _635_recIdents = _out259;
+                    Dafny.ISequence<Dafny.Rune> _out251;
+                    bool _out252;
+                    bool _out253;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out254;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out251, out _out252, out _out253, out _out254);
+                    _632_recursiveGen = _out251;
+                    _633_recOwned = _out252;
+                    _634_recErased = _out253;
+                    _635_recIdents = _out254;
                     s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _632_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
                     isOwned = _633_recOwned;
                     isErased = _634_recErased;
                     readIdents = _635_recIdents;
                   }
-                } else {
-                  Dafny.ISequence<Dafny.Rune> _636___mcc_h212 = _source30.dtor_TypeArg_a0;
+                } else if (_source30.is_Map) {
+                  DAST._IType _636___mcc_h323 = _source30.dtor_key;
+                  DAST._IType _637___mcc_h324 = _source30.dtor_value;
                   {
-                    Dafny.ISequence<Dafny.Rune> _637_recursiveGen;
-                    bool _638_recOwned;
-                    bool _639_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _640_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out260;
+                    Dafny.ISequence<Dafny.Rune> _638_recursiveGen;
+                    bool _639_recOwned;
+                    bool _640_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _641_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out255;
+                    bool _out256;
+                    bool _out257;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out258;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out255, out _out256, out _out257, out _out258);
+                    _638_recursiveGen = _out255;
+                    _639_recOwned = _out256;
+                    _640_recErased = _out257;
+                    _641_recIdents = _out258;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _638_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _639_recOwned;
+                    isErased = _640_recErased;
+                    readIdents = _641_recIdents;
+                  }
+                } else if (_source30.is_Arrow) {
+                  Dafny.ISequence<DAST._IType> _642___mcc_h327 = _source30.dtor_args;
+                  DAST._IType _643___mcc_h328 = _source30.dtor_result;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _644_recursiveGen;
+                    bool _645_recOwned;
+                    bool _646_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _647_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out259;
+                    bool _out260;
                     bool _out261;
-                    bool _out262;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out263;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out260, out _out261, out _out262, out _out263);
-                    _637_recursiveGen = _out260;
-                    _638_recOwned = _out261;
-                    _639_recErased = _out262;
-                    _640_recIdents = _out263;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _637_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _638_recOwned;
-                    isErased = _639_recErased;
-                    readIdents = _640_recIdents;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out262;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out259, out _out260, out _out261, out _out262);
+                    _644_recursiveGen = _out259;
+                    _645_recOwned = _out260;
+                    _646_recErased = _out261;
+                    _647_recIdents = _out262;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _644_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _645_recOwned;
+                    isErased = _646_recErased;
+                    readIdents = _647_recIdents;
+                  }
+                } else if (_source30.is_Primitive) {
+                  DAST._IPrimitive _648___mcc_h331 = _source30.dtor_Primitive_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _649_recursiveGen;
+                    bool _650_recOwned;
+                    bool _651_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _652_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out263;
+                    bool _out264;
+                    bool _out265;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out266;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out263, out _out264, out _out265, out _out266);
+                    _649_recursiveGen = _out263;
+                    _650_recOwned = _out264;
+                    _651_recErased = _out265;
+                    _652_recIdents = _out266;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _649_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _650_recOwned;
+                    isErased = _651_recErased;
+                    readIdents = _652_recIdents;
+                  }
+                } else if (_source30.is_Passthrough) {
+                  Dafny.ISequence<Dafny.Rune> _653___mcc_h333 = _source30.dtor_Passthrough_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _654_recursiveGen;
+                    bool _655_recOwned;
+                    bool _656_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _657_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out267;
+                    bool _out268;
+                    bool _out269;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out270;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out267, out _out268, out _out269, out _out270);
+                    _654_recursiveGen = _out267;
+                    _655_recOwned = _out268;
+                    _656_recErased = _out269;
+                    _657_recIdents = _out270;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _654_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _655_recOwned;
+                    isErased = _656_recErased;
+                    readIdents = _657_recIdents;
+                  }
+                } else {
+                  Dafny.ISequence<Dafny.Rune> _658___mcc_h335 = _source30.dtor_TypeArg_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _659_recursiveGen;
+                    bool _660_recOwned;
+                    bool _661_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _662_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out271;
+                    bool _out272;
+                    bool _out273;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out274;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out271, out _out272, out _out273, out _out274);
+                    _659_recursiveGen = _out271;
+                    _660_recOwned = _out272;
+                    _661_recErased = _out273;
+                    _662_recIdents = _out274;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _659_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _660_recOwned;
+                    isErased = _661_recErased;
+                    readIdents = _662_recIdents;
                   }
                 }
               } else {
-                DAST._IType _641___mcc_h214 = _source27.dtor_Newtype_a0;
-                DAST._IType _source32 = _489___mcc_h124;
+                DAST._IType _663___mcc_h337 = _source27.dtor_Newtype_a0;
+                DAST._IType _source32 = _501___mcc_h238;
                 if (_source32.is_Path) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _642___mcc_h217 = _source32.dtor_Path_a0;
-                  Dafny.ISequence<DAST._IType> _643___mcc_h218 = _source32.dtor_typeArgs;
-                  DAST._IResolvedType _644___mcc_h219 = _source32.dtor_resolved;
-                  DAST._IResolvedType _source33 = _644___mcc_h219;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _664___mcc_h341 = _source32.dtor_Path_a0;
+                  Dafny.ISequence<DAST._IType> _665___mcc_h342 = _source32.dtor_typeArgs;
+                  DAST._IResolvedType _666___mcc_h343 = _source32.dtor_resolved;
+                  DAST._IResolvedType _source33 = _666___mcc_h343;
                   if (_source33.is_Datatype) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _645___mcc_h226 = _source33.dtor_path;
-                    DAST._IType _646_b = _641___mcc_h214;
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _667___mcc_h350 = _source33.dtor_path;
+                    DAST._IType _668_b = _663___mcc_h337;
                     {
-                      if (object.Equals(_646_b, _481_toTpe)) {
-                        Dafny.ISequence<Dafny.Rune> _647_recursiveGen;
-                        bool _648_recOwned;
-                        bool _649_recErased;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _650_recIdents;
-                        Dafny.ISequence<Dafny.Rune> _out264;
-                        bool _out265;
-                        bool _out266;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out267;
-                        DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out264, out _out265, out _out266, out _out267);
-                        _647_recursiveGen = _out264;
-                        _648_recOwned = _out265;
-                        _649_recErased = _out266;
-                        _650_recIdents = _out267;
-                        Dafny.ISequence<Dafny.Rune> _651_uneraseFn;
-                        _651_uneraseFn = ((_648_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _651_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _647_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                        isOwned = _648_recOwned;
+                      if (object.Equals(_668_b, _493_toTpe)) {
+                        Dafny.ISequence<Dafny.Rune> _669_recursiveGen;
+                        bool _670_recOwned;
+                        bool _671_recErased;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _672_recIdents;
+                        Dafny.ISequence<Dafny.Rune> _out275;
+                        bool _out276;
+                        bool _out277;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out278;
+                        DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out275, out _out276, out _out277, out _out278);
+                        _669_recursiveGen = _out275;
+                        _670_recOwned = _out276;
+                        _671_recErased = _out277;
+                        _672_recIdents = _out278;
+                        Dafny.ISequence<Dafny.Rune> _673_uneraseFn;
+                        _673_uneraseFn = ((_670_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _673_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _669_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                        isOwned = _670_recOwned;
                         isErased = true;
-                        readIdents = _650_recIdents;
+                        readIdents = _672_recIdents;
                       } else {
-                        Dafny.ISequence<Dafny.Rune> _out268;
-                        bool _out269;
-                        bool _out270;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out271;
-                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _646_b), _646_b, _481_toTpe), @params, mustOwn, out _out268, out _out269, out _out270, out _out271);
-                        s = _out268;
-                        isOwned = _out269;
-                        isErased = _out270;
-                        readIdents = _out271;
+                        Dafny.ISequence<Dafny.Rune> _out279;
+                        bool _out280;
+                        bool _out281;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out282;
+                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _668_b), _668_b, _493_toTpe), selfIdent, @params, mustOwn, out _out279, out _out280, out _out281, out _out282);
+                        s = _out279;
+                        isOwned = _out280;
+                        isErased = _out281;
+                        readIdents = _out282;
                       }
                     }
                   } else if (_source33.is_Trait) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _652___mcc_h229 = _source33.dtor_path;
-                    DAST._IType _653_b = _641___mcc_h214;
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _674___mcc_h353 = _source33.dtor_path;
+                    DAST._IType _675_b = _663___mcc_h337;
                     {
-                      if (object.Equals(_653_b, _481_toTpe)) {
-                        Dafny.ISequence<Dafny.Rune> _654_recursiveGen;
-                        bool _655_recOwned;
-                        bool _656_recErased;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _657_recIdents;
-                        Dafny.ISequence<Dafny.Rune> _out272;
-                        bool _out273;
-                        bool _out274;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out275;
-                        DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out272, out _out273, out _out274, out _out275);
-                        _654_recursiveGen = _out272;
-                        _655_recOwned = _out273;
-                        _656_recErased = _out274;
-                        _657_recIdents = _out275;
-                        Dafny.ISequence<Dafny.Rune> _658_uneraseFn;
-                        _658_uneraseFn = ((_655_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _658_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _654_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                        isOwned = _655_recOwned;
+                      if (object.Equals(_675_b, _493_toTpe)) {
+                        Dafny.ISequence<Dafny.Rune> _676_recursiveGen;
+                        bool _677_recOwned;
+                        bool _678_recErased;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _679_recIdents;
+                        Dafny.ISequence<Dafny.Rune> _out283;
+                        bool _out284;
+                        bool _out285;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out286;
+                        DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out283, out _out284, out _out285, out _out286);
+                        _676_recursiveGen = _out283;
+                        _677_recOwned = _out284;
+                        _678_recErased = _out285;
+                        _679_recIdents = _out286;
+                        Dafny.ISequence<Dafny.Rune> _680_uneraseFn;
+                        _680_uneraseFn = ((_677_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _680_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _676_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                        isOwned = _677_recOwned;
                         isErased = true;
-                        readIdents = _657_recIdents;
+                        readIdents = _679_recIdents;
                       } else {
-                        Dafny.ISequence<Dafny.Rune> _out276;
-                        bool _out277;
-                        bool _out278;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out279;
-                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _653_b), _653_b, _481_toTpe), @params, mustOwn, out _out276, out _out277, out _out278, out _out279);
-                        s = _out276;
-                        isOwned = _out277;
-                        isErased = _out278;
-                        readIdents = _out279;
+                        Dafny.ISequence<Dafny.Rune> _out287;
+                        bool _out288;
+                        bool _out289;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out290;
+                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _675_b), _675_b, _493_toTpe), selfIdent, @params, mustOwn, out _out287, out _out288, out _out289, out _out290);
+                        s = _out287;
+                        isOwned = _out288;
+                        isErased = _out289;
+                        readIdents = _out290;
                       }
                     }
                   } else {
-                    DAST._IType _659___mcc_h232 = _source33.dtor_Newtype_a0;
-                    DAST._IType _660_b = _659___mcc_h232;
+                    DAST._IType _681___mcc_h356 = _source33.dtor_Newtype_a0;
+                    DAST._IType _682_b = _681___mcc_h356;
                     {
-                      if (object.Equals(_482_fromTpe, _660_b)) {
-                        Dafny.ISequence<Dafny.Rune> _661_recursiveGen;
-                        bool _662_recOwned;
-                        bool _663_recErased;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _664_recIdents;
-                        Dafny.ISequence<Dafny.Rune> _out280;
-                        bool _out281;
-                        bool _out282;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out283;
-                        DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out280, out _out281, out _out282, out _out283);
-                        _661_recursiveGen = _out280;
-                        _662_recOwned = _out281;
-                        _663_recErased = _out282;
-                        _664_recIdents = _out283;
-                        Dafny.ISequence<Dafny.Rune> _665_rhsType;
-                        Dafny.ISequence<Dafny.Rune> _out284;
-                        _out284 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                        _665_rhsType = _out284;
-                        Dafny.ISequence<Dafny.Rune> _666_uneraseFn;
-                        _666_uneraseFn = ((_662_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _665_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _666_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _661_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                        isOwned = _662_recOwned;
+                      if (object.Equals(_494_fromTpe, _682_b)) {
+                        Dafny.ISequence<Dafny.Rune> _683_recursiveGen;
+                        bool _684_recOwned;
+                        bool _685_recErased;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _686_recIdents;
+                        Dafny.ISequence<Dafny.Rune> _out291;
+                        bool _out292;
+                        bool _out293;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out294;
+                        DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out291, out _out292, out _out293, out _out294);
+                        _683_recursiveGen = _out291;
+                        _684_recOwned = _out292;
+                        _685_recErased = _out293;
+                        _686_recIdents = _out294;
+                        Dafny.ISequence<Dafny.Rune> _687_rhsType;
+                        Dafny.ISequence<Dafny.Rune> _out295;
+                        _out295 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                        _687_rhsType = _out295;
+                        Dafny.ISequence<Dafny.Rune> _688_uneraseFn;
+                        _688_uneraseFn = ((_684_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _687_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _688_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _683_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                        isOwned = _684_recOwned;
                         isErased = false;
-                        readIdents = _664_recIdents;
+                        readIdents = _686_recIdents;
                       } else {
-                        Dafny.ISequence<Dafny.Rune> _out285;
-                        bool _out286;
-                        bool _out287;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out288;
-                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _660_b), _660_b, _481_toTpe), @params, mustOwn, out _out285, out _out286, out _out287, out _out288);
-                        s = _out285;
-                        isOwned = _out286;
-                        isErased = _out287;
-                        readIdents = _out288;
+                        Dafny.ISequence<Dafny.Rune> _out296;
+                        bool _out297;
+                        bool _out298;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out299;
+                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _682_b), _682_b, _493_toTpe), selfIdent, @params, mustOwn, out _out296, out _out297, out _out298, out _out299);
+                        s = _out296;
+                        isOwned = _out297;
+                        isErased = _out298;
+                        readIdents = _out299;
                       }
                     }
                   }
-                } else if (_source32.is_Tuple) {
-                  Dafny.ISequence<DAST._IType> _667___mcc_h235 = _source32.dtor_Tuple_a0;
-                  DAST._IType _668_b = _641___mcc_h214;
-                  {
-                    if (object.Equals(_668_b, _481_toTpe)) {
-                      Dafny.ISequence<Dafny.Rune> _669_recursiveGen;
-                      bool _670_recOwned;
-                      bool _671_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _672_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out289;
-                      bool _out290;
-                      bool _out291;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out292;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out289, out _out290, out _out291, out _out292);
-                      _669_recursiveGen = _out289;
-                      _670_recOwned = _out290;
-                      _671_recErased = _out291;
-                      _672_recIdents = _out292;
-                      Dafny.ISequence<Dafny.Rune> _673_uneraseFn;
-                      _673_uneraseFn = ((_670_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _673_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _669_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _670_recOwned;
-                      isErased = true;
-                      readIdents = _672_recIdents;
-                    } else {
-                      Dafny.ISequence<Dafny.Rune> _out293;
-                      bool _out294;
-                      bool _out295;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out296;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _668_b), _668_b, _481_toTpe), @params, mustOwn, out _out293, out _out294, out _out295, out _out296);
-                      s = _out293;
-                      isOwned = _out294;
-                      isErased = _out295;
-                      readIdents = _out296;
-                    }
-                  }
-                } else if (_source32.is_Array) {
-                  DAST._IType _674___mcc_h238 = _source32.dtor_element;
-                  DAST._IType _675_b = _641___mcc_h214;
+                } else if (_source32.is_Nullable) {
+                  DAST._IType _689___mcc_h359 = _source32.dtor_Nullable_a0;
                   {
-                    if (object.Equals(_675_b, _481_toTpe)) {
-                      Dafny.ISequence<Dafny.Rune> _676_recursiveGen;
-                      bool _677_recOwned;
-                      bool _678_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _679_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out297;
-                      bool _out298;
-                      bool _out299;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out300;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out297, out _out298, out _out299, out _out300);
-                      _676_recursiveGen = _out297;
-                      _677_recOwned = _out298;
-                      _678_recErased = _out299;
-                      _679_recIdents = _out300;
-                      Dafny.ISequence<Dafny.Rune> _680_uneraseFn;
-                      _680_uneraseFn = ((_677_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _680_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _676_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _677_recOwned;
-                      isErased = true;
-                      readIdents = _679_recIdents;
-                    } else {
-                      Dafny.ISequence<Dafny.Rune> _out301;
-                      bool _out302;
-                      bool _out303;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out304;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _675_b), _675_b, _481_toTpe), @params, mustOwn, out _out301, out _out302, out _out303, out _out304);
-                      s = _out301;
-                      isOwned = _out302;
-                      isErased = _out303;
-                      readIdents = _out304;
+                    Dafny.ISequence<Dafny.Rune> _690_recursiveGen;
+                    bool _691_recOwned;
+                    bool _692_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _693_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out300;
+                    bool _out301;
+                    bool _out302;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out303;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out300, out _out301, out _out302, out _out303);
+                    _690_recursiveGen = _out300;
+                    _691_recOwned = _out301;
+                    _692_recErased = _out302;
+                    _693_recIdents = _out303;
+                    if (!(_691_recOwned)) {
+                      _690_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_690_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
                     }
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _690_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                    isOwned = true;
+                    isErased = _692_recErased;
+                    readIdents = _693_recIdents;
                   }
-                } else if (_source32.is_Seq) {
-                  DAST._IType _681___mcc_h241 = _source32.dtor_element;
-                  DAST._IType _682_b = _641___mcc_h214;
+                } else if (_source32.is_Tuple) {
+                  Dafny.ISequence<DAST._IType> _694___mcc_h362 = _source32.dtor_Tuple_a0;
+                  DAST._IType _695_b = _663___mcc_h337;
                   {
-                    if (object.Equals(_682_b, _481_toTpe)) {
-                      Dafny.ISequence<Dafny.Rune> _683_recursiveGen;
-                      bool _684_recOwned;
-                      bool _685_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _686_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out305;
+                    if (object.Equals(_695_b, _493_toTpe)) {
+                      Dafny.ISequence<Dafny.Rune> _696_recursiveGen;
+                      bool _697_recOwned;
+                      bool _698_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _699_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out304;
+                      bool _out305;
                       bool _out306;
-                      bool _out307;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out308;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out305, out _out306, out _out307, out _out308);
-                      _683_recursiveGen = _out305;
-                      _684_recOwned = _out306;
-                      _685_recErased = _out307;
-                      _686_recIdents = _out308;
-                      Dafny.ISequence<Dafny.Rune> _687_uneraseFn;
-                      _687_uneraseFn = ((_684_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _687_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _683_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _684_recOwned;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out307;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out304, out _out305, out _out306, out _out307);
+                      _696_recursiveGen = _out304;
+                      _697_recOwned = _out305;
+                      _698_recErased = _out306;
+                      _699_recIdents = _out307;
+                      Dafny.ISequence<Dafny.Rune> _700_uneraseFn;
+                      _700_uneraseFn = ((_697_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _700_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _696_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _697_recOwned;
                       isErased = true;
-                      readIdents = _686_recIdents;
+                      readIdents = _699_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out309;
+                      Dafny.ISequence<Dafny.Rune> _out308;
+                      bool _out309;
                       bool _out310;
-                      bool _out311;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out312;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _682_b), _682_b, _481_toTpe), @params, mustOwn, out _out309, out _out310, out _out311, out _out312);
-                      s = _out309;
-                      isOwned = _out310;
-                      isErased = _out311;
-                      readIdents = _out312;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out311;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _695_b), _695_b, _493_toTpe), selfIdent, @params, mustOwn, out _out308, out _out309, out _out310, out _out311);
+                      s = _out308;
+                      isOwned = _out309;
+                      isErased = _out310;
+                      readIdents = _out311;
                     }
                   }
-                } else if (_source32.is_Set) {
-                  DAST._IType _688___mcc_h244 = _source32.dtor_element;
-                  DAST._IType _689_b = _641___mcc_h214;
+                } else if (_source32.is_Array) {
+                  DAST._IType _701___mcc_h365 = _source32.dtor_element;
+                  DAST._IType _702_b = _663___mcc_h337;
                   {
-                    if (object.Equals(_689_b, _481_toTpe)) {
-                      Dafny.ISequence<Dafny.Rune> _690_recursiveGen;
-                      bool _691_recOwned;
-                      bool _692_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _693_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out313;
+                    if (object.Equals(_702_b, _493_toTpe)) {
+                      Dafny.ISequence<Dafny.Rune> _703_recursiveGen;
+                      bool _704_recOwned;
+                      bool _705_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _706_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out312;
+                      bool _out313;
                       bool _out314;
-                      bool _out315;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out316;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out313, out _out314, out _out315, out _out316);
-                      _690_recursiveGen = _out313;
-                      _691_recOwned = _out314;
-                      _692_recErased = _out315;
-                      _693_recIdents = _out316;
-                      Dafny.ISequence<Dafny.Rune> _694_uneraseFn;
-                      _694_uneraseFn = ((_691_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _694_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _690_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _691_recOwned;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out315;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out312, out _out313, out _out314, out _out315);
+                      _703_recursiveGen = _out312;
+                      _704_recOwned = _out313;
+                      _705_recErased = _out314;
+                      _706_recIdents = _out315;
+                      Dafny.ISequence<Dafny.Rune> _707_uneraseFn;
+                      _707_uneraseFn = ((_704_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _707_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _703_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _704_recOwned;
                       isErased = true;
-                      readIdents = _693_recIdents;
+                      readIdents = _706_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out317;
+                      Dafny.ISequence<Dafny.Rune> _out316;
+                      bool _out317;
                       bool _out318;
-                      bool _out319;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out320;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _689_b), _689_b, _481_toTpe), @params, mustOwn, out _out317, out _out318, out _out319, out _out320);
-                      s = _out317;
-                      isOwned = _out318;
-                      isErased = _out319;
-                      readIdents = _out320;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out319;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _702_b), _702_b, _493_toTpe), selfIdent, @params, mustOwn, out _out316, out _out317, out _out318, out _out319);
+                      s = _out316;
+                      isOwned = _out317;
+                      isErased = _out318;
+                      readIdents = _out319;
                     }
                   }
-                } else if (_source32.is_Multiset) {
-                  DAST._IType _695___mcc_h247 = _source32.dtor_element;
-                  DAST._IType _696_b = _641___mcc_h214;
+                } else if (_source32.is_Seq) {
+                  DAST._IType _708___mcc_h368 = _source32.dtor_element;
+                  DAST._IType _709_b = _663___mcc_h337;
                   {
-                    if (object.Equals(_696_b, _481_toTpe)) {
-                      Dafny.ISequence<Dafny.Rune> _697_recursiveGen;
-                      bool _698_recOwned;
-                      bool _699_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _700_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out321;
+                    if (object.Equals(_709_b, _493_toTpe)) {
+                      Dafny.ISequence<Dafny.Rune> _710_recursiveGen;
+                      bool _711_recOwned;
+                      bool _712_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _713_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out320;
+                      bool _out321;
                       bool _out322;
-                      bool _out323;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out324;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out321, out _out322, out _out323, out _out324);
-                      _697_recursiveGen = _out321;
-                      _698_recOwned = _out322;
-                      _699_recErased = _out323;
-                      _700_recIdents = _out324;
-                      Dafny.ISequence<Dafny.Rune> _701_uneraseFn;
-                      _701_uneraseFn = ((_698_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _701_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _697_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _698_recOwned;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out323;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out320, out _out321, out _out322, out _out323);
+                      _710_recursiveGen = _out320;
+                      _711_recOwned = _out321;
+                      _712_recErased = _out322;
+                      _713_recIdents = _out323;
+                      Dafny.ISequence<Dafny.Rune> _714_uneraseFn;
+                      _714_uneraseFn = ((_711_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _714_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _710_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _711_recOwned;
                       isErased = true;
-                      readIdents = _700_recIdents;
+                      readIdents = _713_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out325;
+                      Dafny.ISequence<Dafny.Rune> _out324;
+                      bool _out325;
                       bool _out326;
-                      bool _out327;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out328;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _696_b), _696_b, _481_toTpe), @params, mustOwn, out _out325, out _out326, out _out327, out _out328);
-                      s = _out325;
-                      isOwned = _out326;
-                      isErased = _out327;
-                      readIdents = _out328;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out327;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _709_b), _709_b, _493_toTpe), selfIdent, @params, mustOwn, out _out324, out _out325, out _out326, out _out327);
+                      s = _out324;
+                      isOwned = _out325;
+                      isErased = _out326;
+                      readIdents = _out327;
                     }
                   }
-                } else if (_source32.is_Map) {
-                  DAST._IType _702___mcc_h250 = _source32.dtor_key;
-                  DAST._IType _703___mcc_h251 = _source32.dtor_value;
-                  DAST._IType _704_b = _641___mcc_h214;
+                } else if (_source32.is_Set) {
+                  DAST._IType _715___mcc_h371 = _source32.dtor_element;
+                  DAST._IType _716_b = _663___mcc_h337;
                   {
-                    if (object.Equals(_704_b, _481_toTpe)) {
-                      Dafny.ISequence<Dafny.Rune> _705_recursiveGen;
-                      bool _706_recOwned;
-                      bool _707_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _708_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out329;
+                    if (object.Equals(_716_b, _493_toTpe)) {
+                      Dafny.ISequence<Dafny.Rune> _717_recursiveGen;
+                      bool _718_recOwned;
+                      bool _719_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _720_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out328;
+                      bool _out329;
                       bool _out330;
-                      bool _out331;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out332;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out329, out _out330, out _out331, out _out332);
-                      _705_recursiveGen = _out329;
-                      _706_recOwned = _out330;
-                      _707_recErased = _out331;
-                      _708_recIdents = _out332;
-                      Dafny.ISequence<Dafny.Rune> _709_uneraseFn;
-                      _709_uneraseFn = ((_706_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _709_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _705_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _706_recOwned;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out331;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out328, out _out329, out _out330, out _out331);
+                      _717_recursiveGen = _out328;
+                      _718_recOwned = _out329;
+                      _719_recErased = _out330;
+                      _720_recIdents = _out331;
+                      Dafny.ISequence<Dafny.Rune> _721_uneraseFn;
+                      _721_uneraseFn = ((_718_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _721_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _717_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _718_recOwned;
                       isErased = true;
-                      readIdents = _708_recIdents;
+                      readIdents = _720_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out333;
+                      Dafny.ISequence<Dafny.Rune> _out332;
+                      bool _out333;
                       bool _out334;
-                      bool _out335;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out336;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _704_b), _704_b, _481_toTpe), @params, mustOwn, out _out333, out _out334, out _out335, out _out336);
-                      s = _out333;
-                      isOwned = _out334;
-                      isErased = _out335;
-                      readIdents = _out336;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out335;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _716_b), _716_b, _493_toTpe), selfIdent, @params, mustOwn, out _out332, out _out333, out _out334, out _out335);
+                      s = _out332;
+                      isOwned = _out333;
+                      isErased = _out334;
+                      readIdents = _out335;
                     }
                   }
-                } else if (_source32.is_Arrow) {
-                  Dafny.ISequence<DAST._IType> _710___mcc_h256 = _source32.dtor_args;
-                  DAST._IType _711___mcc_h257 = _source32.dtor_result;
-                  DAST._IType _712_b = _641___mcc_h214;
+                } else if (_source32.is_Multiset) {
+                  DAST._IType _722___mcc_h374 = _source32.dtor_element;
+                  DAST._IType _723_b = _663___mcc_h337;
                   {
-                    if (object.Equals(_712_b, _481_toTpe)) {
-                      Dafny.ISequence<Dafny.Rune> _713_recursiveGen;
-                      bool _714_recOwned;
-                      bool _715_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _716_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out337;
+                    if (object.Equals(_723_b, _493_toTpe)) {
+                      Dafny.ISequence<Dafny.Rune> _724_recursiveGen;
+                      bool _725_recOwned;
+                      bool _726_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _727_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out336;
+                      bool _out337;
                       bool _out338;
-                      bool _out339;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out340;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out337, out _out338, out _out339, out _out340);
-                      _713_recursiveGen = _out337;
-                      _714_recOwned = _out338;
-                      _715_recErased = _out339;
-                      _716_recIdents = _out340;
-                      Dafny.ISequence<Dafny.Rune> _717_uneraseFn;
-                      _717_uneraseFn = ((_714_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _717_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _713_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _714_recOwned;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out339;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out336, out _out337, out _out338, out _out339);
+                      _724_recursiveGen = _out336;
+                      _725_recOwned = _out337;
+                      _726_recErased = _out338;
+                      _727_recIdents = _out339;
+                      Dafny.ISequence<Dafny.Rune> _728_uneraseFn;
+                      _728_uneraseFn = ((_725_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _728_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _724_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _725_recOwned;
                       isErased = true;
-                      readIdents = _716_recIdents;
+                      readIdents = _727_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out341;
+                      Dafny.ISequence<Dafny.Rune> _out340;
+                      bool _out341;
                       bool _out342;
-                      bool _out343;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out344;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _712_b), _712_b, _481_toTpe), @params, mustOwn, out _out341, out _out342, out _out343, out _out344);
-                      s = _out341;
-                      isOwned = _out342;
-                      isErased = _out343;
-                      readIdents = _out344;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out343;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _723_b), _723_b, _493_toTpe), selfIdent, @params, mustOwn, out _out340, out _out341, out _out342, out _out343);
+                      s = _out340;
+                      isOwned = _out341;
+                      isErased = _out342;
+                      readIdents = _out343;
                     }
                   }
-                } else if (_source32.is_Primitive) {
-                  DAST._IPrimitive _718___mcc_h262 = _source32.dtor_Primitive_a0;
-                  DAST._IType _719_b = _641___mcc_h214;
+                } else if (_source32.is_Map) {
+                  DAST._IType _729___mcc_h377 = _source32.dtor_key;
+                  DAST._IType _730___mcc_h378 = _source32.dtor_value;
+                  DAST._IType _731_b = _663___mcc_h337;
                   {
-                    if (object.Equals(_719_b, _481_toTpe)) {
-                      Dafny.ISequence<Dafny.Rune> _720_recursiveGen;
-                      bool _721_recOwned;
-                      bool _722_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _723_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out345;
+                    if (object.Equals(_731_b, _493_toTpe)) {
+                      Dafny.ISequence<Dafny.Rune> _732_recursiveGen;
+                      bool _733_recOwned;
+                      bool _734_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _735_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out344;
+                      bool _out345;
                       bool _out346;
-                      bool _out347;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out348;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out345, out _out346, out _out347, out _out348);
-                      _720_recursiveGen = _out345;
-                      _721_recOwned = _out346;
-                      _722_recErased = _out347;
-                      _723_recIdents = _out348;
-                      Dafny.ISequence<Dafny.Rune> _724_uneraseFn;
-                      _724_uneraseFn = ((_721_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _724_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _720_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _721_recOwned;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out347;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out344, out _out345, out _out346, out _out347);
+                      _732_recursiveGen = _out344;
+                      _733_recOwned = _out345;
+                      _734_recErased = _out346;
+                      _735_recIdents = _out347;
+                      Dafny.ISequence<Dafny.Rune> _736_uneraseFn;
+                      _736_uneraseFn = ((_733_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _736_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _732_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _733_recOwned;
                       isErased = true;
-                      readIdents = _723_recIdents;
+                      readIdents = _735_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out349;
+                      Dafny.ISequence<Dafny.Rune> _out348;
+                      bool _out349;
                       bool _out350;
-                      bool _out351;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out352;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _719_b), _719_b, _481_toTpe), @params, mustOwn, out _out349, out _out350, out _out351, out _out352);
-                      s = _out349;
-                      isOwned = _out350;
-                      isErased = _out351;
-                      readIdents = _out352;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out351;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _731_b), _731_b, _493_toTpe), selfIdent, @params, mustOwn, out _out348, out _out349, out _out350, out _out351);
+                      s = _out348;
+                      isOwned = _out349;
+                      isErased = _out350;
+                      readIdents = _out351;
                     }
                   }
-                } else if (_source32.is_Passthrough) {
-                  Dafny.ISequence<Dafny.Rune> _725___mcc_h265 = _source32.dtor_Passthrough_a0;
-                  DAST._IType _726_b = _641___mcc_h214;
+                } else if (_source32.is_Arrow) {
+                  Dafny.ISequence<DAST._IType> _737___mcc_h383 = _source32.dtor_args;
+                  DAST._IType _738___mcc_h384 = _source32.dtor_result;
+                  DAST._IType _739_b = _663___mcc_h337;
                   {
-                    if (object.Equals(_726_b, _481_toTpe)) {
-                      Dafny.ISequence<Dafny.Rune> _727_recursiveGen;
-                      bool _728_recOwned;
-                      bool _729_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _730_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out353;
+                    if (object.Equals(_739_b, _493_toTpe)) {
+                      Dafny.ISequence<Dafny.Rune> _740_recursiveGen;
+                      bool _741_recOwned;
+                      bool _742_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _743_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out352;
+                      bool _out353;
                       bool _out354;
-                      bool _out355;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out356;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out353, out _out354, out _out355, out _out356);
-                      _727_recursiveGen = _out353;
-                      _728_recOwned = _out354;
-                      _729_recErased = _out355;
-                      _730_recIdents = _out356;
-                      Dafny.ISequence<Dafny.Rune> _731_uneraseFn;
-                      _731_uneraseFn = ((_728_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _731_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _727_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _728_recOwned;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out355;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out352, out _out353, out _out354, out _out355);
+                      _740_recursiveGen = _out352;
+                      _741_recOwned = _out353;
+                      _742_recErased = _out354;
+                      _743_recIdents = _out355;
+                      Dafny.ISequence<Dafny.Rune> _744_uneraseFn;
+                      _744_uneraseFn = ((_741_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _744_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _740_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _741_recOwned;
                       isErased = true;
-                      readIdents = _730_recIdents;
+                      readIdents = _743_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out357;
+                      Dafny.ISequence<Dafny.Rune> _out356;
+                      bool _out357;
                       bool _out358;
-                      bool _out359;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out360;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _726_b), _726_b, _481_toTpe), @params, mustOwn, out _out357, out _out358, out _out359, out _out360);
-                      s = _out357;
-                      isOwned = _out358;
-                      isErased = _out359;
-                      readIdents = _out360;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out359;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _739_b), _739_b, _493_toTpe), selfIdent, @params, mustOwn, out _out356, out _out357, out _out358, out _out359);
+                      s = _out356;
+                      isOwned = _out357;
+                      isErased = _out358;
+                      readIdents = _out359;
                     }
                   }
-                } else {
-                  Dafny.ISequence<Dafny.Rune> _732___mcc_h268 = _source32.dtor_TypeArg_a0;
-                  DAST._IType _733_b = _641___mcc_h214;
+                } else if (_source32.is_Primitive) {
+                  DAST._IPrimitive _745___mcc_h389 = _source32.dtor_Primitive_a0;
+                  DAST._IType _746_b = _663___mcc_h337;
                   {
-                    if (object.Equals(_733_b, _481_toTpe)) {
-                      Dafny.ISequence<Dafny.Rune> _734_recursiveGen;
-                      bool _735_recOwned;
-                      bool _736_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _737_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out361;
+                    if (object.Equals(_746_b, _493_toTpe)) {
+                      Dafny.ISequence<Dafny.Rune> _747_recursiveGen;
+                      bool _748_recOwned;
+                      bool _749_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _750_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out360;
+                      bool _out361;
                       bool _out362;
-                      bool _out363;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out364;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out361, out _out362, out _out363, out _out364);
-                      _734_recursiveGen = _out361;
-                      _735_recOwned = _out362;
-                      _736_recErased = _out363;
-                      _737_recIdents = _out364;
-                      Dafny.ISequence<Dafny.Rune> _738_uneraseFn;
-                      _738_uneraseFn = ((_735_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _738_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _734_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _735_recOwned;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out363;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out360, out _out361, out _out362, out _out363);
+                      _747_recursiveGen = _out360;
+                      _748_recOwned = _out361;
+                      _749_recErased = _out362;
+                      _750_recIdents = _out363;
+                      Dafny.ISequence<Dafny.Rune> _751_uneraseFn;
+                      _751_uneraseFn = ((_748_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _751_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _747_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _748_recOwned;
                       isErased = true;
-                      readIdents = _737_recIdents;
+                      readIdents = _750_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out365;
+                      Dafny.ISequence<Dafny.Rune> _out364;
+                      bool _out365;
                       bool _out366;
-                      bool _out367;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out368;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _733_b), _733_b, _481_toTpe), @params, mustOwn, out _out365, out _out366, out _out367, out _out368);
-                      s = _out365;
-                      isOwned = _out366;
-                      isErased = _out367;
-                      readIdents = _out368;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out367;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _746_b), _746_b, _493_toTpe), selfIdent, @params, mustOwn, out _out364, out _out365, out _out366, out _out367);
+                      s = _out364;
+                      isOwned = _out365;
+                      isErased = _out366;
+                      readIdents = _out367;
+                    }
+                  }
+                } else if (_source32.is_Passthrough) {
+                  Dafny.ISequence<Dafny.Rune> _752___mcc_h392 = _source32.dtor_Passthrough_a0;
+                  DAST._IType _753_b = _663___mcc_h337;
+                  {
+                    if (object.Equals(_753_b, _493_toTpe)) {
+                      Dafny.ISequence<Dafny.Rune> _754_recursiveGen;
+                      bool _755_recOwned;
+                      bool _756_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _757_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out368;
+                      bool _out369;
+                      bool _out370;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out371;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out368, out _out369, out _out370, out _out371);
+                      _754_recursiveGen = _out368;
+                      _755_recOwned = _out369;
+                      _756_recErased = _out370;
+                      _757_recIdents = _out371;
+                      Dafny.ISequence<Dafny.Rune> _758_uneraseFn;
+                      _758_uneraseFn = ((_755_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _758_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _754_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _755_recOwned;
+                      isErased = true;
+                      readIdents = _757_recIdents;
+                    } else {
+                      Dafny.ISequence<Dafny.Rune> _out372;
+                      bool _out373;
+                      bool _out374;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out375;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _753_b), _753_b, _493_toTpe), selfIdent, @params, mustOwn, out _out372, out _out373, out _out374, out _out375);
+                      s = _out372;
+                      isOwned = _out373;
+                      isErased = _out374;
+                      readIdents = _out375;
+                    }
+                  }
+                } else {
+                  Dafny.ISequence<Dafny.Rune> _759___mcc_h395 = _source32.dtor_TypeArg_a0;
+                  DAST._IType _760_b = _663___mcc_h337;
+                  {
+                    if (object.Equals(_760_b, _493_toTpe)) {
+                      Dafny.ISequence<Dafny.Rune> _761_recursiveGen;
+                      bool _762_recOwned;
+                      bool _763_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _764_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out376;
+                      bool _out377;
+                      bool _out378;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out379;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out376, out _out377, out _out378, out _out379);
+                      _761_recursiveGen = _out376;
+                      _762_recOwned = _out377;
+                      _763_recErased = _out378;
+                      _764_recIdents = _out379;
+                      Dafny.ISequence<Dafny.Rune> _765_uneraseFn;
+                      _765_uneraseFn = ((_762_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _765_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _761_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _762_recOwned;
+                      isErased = true;
+                      readIdents = _764_recIdents;
+                    } else {
+                      Dafny.ISequence<Dafny.Rune> _out380;
+                      bool _out381;
+                      bool _out382;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out383;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _760_b), _760_b, _493_toTpe), selfIdent, @params, mustOwn, out _out380, out _out381, out _out382, out _out383);
+                      s = _out380;
+                      isOwned = _out381;
+                      isErased = _out382;
+                      readIdents = _out383;
                     }
                   }
                 }
               }
-            } else if (_source26.is_Tuple) {
-              Dafny.ISequence<DAST._IType> _739___mcc_h271 = _source26.dtor_Tuple_a0;
-              DAST._IType _source34 = _489___mcc_h124;
+            } else if (_source26.is_Nullable) {
+              DAST._IType _766___mcc_h398 = _source26.dtor_Nullable_a0;
+              DAST._IType _source34 = _501___mcc_h238;
               if (_source34.is_Path) {
-                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _740___mcc_h274 = _source34.dtor_Path_a0;
-                Dafny.ISequence<DAST._IType> _741___mcc_h275 = _source34.dtor_typeArgs;
-                DAST._IResolvedType _742___mcc_h276 = _source34.dtor_resolved;
-                DAST._IResolvedType _source35 = _742___mcc_h276;
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _767___mcc_h402 = _source34.dtor_Path_a0;
+                Dafny.ISequence<DAST._IType> _768___mcc_h403 = _source34.dtor_typeArgs;
+                DAST._IResolvedType _769___mcc_h404 = _source34.dtor_resolved;
+                DAST._IResolvedType _source35 = _769___mcc_h404;
                 if (_source35.is_Datatype) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _743___mcc_h280 = _source35.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _770___mcc_h411 = _source35.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _744_recursiveGen;
-                    bool _745_recOwned;
-                    bool _746_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _747_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out369;
-                    bool _out370;
-                    bool _out371;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out372;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out369, out _out370, out _out371, out _out372);
-                    _744_recursiveGen = _out369;
-                    _745_recOwned = _out370;
-                    _746_recErased = _out371;
-                    _747_recIdents = _out372;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _744_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _745_recOwned;
-                    isErased = _746_recErased;
-                    readIdents = _747_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _771_recursiveGen;
+                    bool _772_recOwned;
+                    bool _773_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _774_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out384;
+                    bool _out385;
+                    bool _out386;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out387;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out384, out _out385, out _out386, out _out387);
+                    _771_recursiveGen = _out384;
+                    _772_recOwned = _out385;
+                    _773_recErased = _out386;
+                    _774_recIdents = _out387;
+                    if (!(_772_recOwned)) {
+                      _771_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_771_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                    }
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(_771_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                    isOwned = _772_recOwned;
+                    isErased = _773_recErased;
+                    readIdents = _774_recIdents;
                   }
                 } else if (_source35.is_Trait) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _748___mcc_h282 = _source35.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _775___mcc_h414 = _source35.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _749_recursiveGen;
-                    bool _750_recOwned;
-                    bool _751_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _752_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out373;
-                    bool _out374;
-                    bool _out375;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out376;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out373, out _out374, out _out375, out _out376);
-                    _749_recursiveGen = _out373;
-                    _750_recOwned = _out374;
-                    _751_recErased = _out375;
-                    _752_recIdents = _out376;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _749_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _750_recOwned;
-                    isErased = _751_recErased;
-                    readIdents = _752_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _776_recursiveGen;
+                    bool _777_recOwned;
+                    bool _778_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _779_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out388;
+                    bool _out389;
+                    bool _out390;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out391;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out388, out _out389, out _out390, out _out391);
+                    _776_recursiveGen = _out388;
+                    _777_recOwned = _out389;
+                    _778_recErased = _out390;
+                    _779_recIdents = _out391;
+                    if (!(_777_recOwned)) {
+                      _776_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_776_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                    }
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(_776_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                    isOwned = _777_recOwned;
+                    isErased = _778_recErased;
+                    readIdents = _779_recIdents;
                   }
                 } else {
-                  DAST._IType _753___mcc_h284 = _source35.dtor_Newtype_a0;
-                  DAST._IType _754_b = _753___mcc_h284;
+                  DAST._IType _780___mcc_h417 = _source35.dtor_Newtype_a0;
                   {
-                    if (object.Equals(_482_fromTpe, _754_b)) {
-                      Dafny.ISequence<Dafny.Rune> _755_recursiveGen;
-                      bool _756_recOwned;
-                      bool _757_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _758_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out377;
-                      bool _out378;
-                      bool _out379;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out380;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out377, out _out378, out _out379, out _out380);
-                      _755_recursiveGen = _out377;
-                      _756_recOwned = _out378;
-                      _757_recErased = _out379;
-                      _758_recIdents = _out380;
-                      Dafny.ISequence<Dafny.Rune> _759_rhsType;
-                      Dafny.ISequence<Dafny.Rune> _out381;
-                      _out381 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                      _759_rhsType = _out381;
-                      Dafny.ISequence<Dafny.Rune> _760_uneraseFn;
-                      _760_uneraseFn = ((_756_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _759_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _760_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _755_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _756_recOwned;
-                      isErased = false;
-                      readIdents = _758_recIdents;
-                    } else {
-                      Dafny.ISequence<Dafny.Rune> _out382;
-                      bool _out383;
-                      bool _out384;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out385;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _754_b), _754_b, _481_toTpe), @params, mustOwn, out _out382, out _out383, out _out384, out _out385);
-                      s = _out382;
-                      isOwned = _out383;
-                      isErased = _out384;
-                      readIdents = _out385;
+                    Dafny.ISequence<Dafny.Rune> _781_recursiveGen;
+                    bool _782_recOwned;
+                    bool _783_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _784_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out392;
+                    bool _out393;
+                    bool _out394;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out395;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out392, out _out393, out _out394, out _out395);
+                    _781_recursiveGen = _out392;
+                    _782_recOwned = _out393;
+                    _783_recErased = _out394;
+                    _784_recIdents = _out395;
+                    if (!(_782_recOwned)) {
+                      _781_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_781_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
                     }
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(_781_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                    isOwned = _782_recOwned;
+                    isErased = _783_recErased;
+                    readIdents = _784_recIdents;
+                  }
+                }
+              } else if (_source34.is_Nullable) {
+                DAST._IType _785___mcc_h420 = _source34.dtor_Nullable_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _786_recursiveGen;
+                  bool _787_recOwned;
+                  bool _788_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _789_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out396;
+                  bool _out397;
+                  bool _out398;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out399;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out396, out _out397, out _out398, out _out399);
+                  _786_recursiveGen = _out396;
+                  _787_recOwned = _out397;
+                  _788_recErased = _out398;
+                  _789_recIdents = _out399;
+                  if (!(_787_recOwned)) {
+                    _786_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_786_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
                   }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(_786_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                  isOwned = _787_recOwned;
+                  isErased = _788_recErased;
+                  readIdents = _789_recIdents;
                 }
               } else if (_source34.is_Tuple) {
-                Dafny.ISequence<DAST._IType> _761___mcc_h286 = _source34.dtor_Tuple_a0;
+                Dafny.ISequence<DAST._IType> _790___mcc_h423 = _source34.dtor_Tuple_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _762_recursiveGen;
-                  bool _763_recOwned;
-                  bool _764_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _765_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out386;
-                  bool _out387;
-                  bool _out388;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out389;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out386, out _out387, out _out388, out _out389);
-                  _762_recursiveGen = _out386;
-                  _763_recOwned = _out387;
-                  _764_recErased = _out388;
-                  _765_recIdents = _out389;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _762_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _763_recOwned;
-                  isErased = _764_recErased;
-                  readIdents = _765_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _791_recursiveGen;
+                  bool _792_recOwned;
+                  bool _793_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _794_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out400;
+                  bool _out401;
+                  bool _out402;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out403;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out400, out _out401, out _out402, out _out403);
+                  _791_recursiveGen = _out400;
+                  _792_recOwned = _out401;
+                  _793_recErased = _out402;
+                  _794_recIdents = _out403;
+                  if (!(_792_recOwned)) {
+                    _791_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_791_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(_791_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                  isOwned = _792_recOwned;
+                  isErased = _793_recErased;
+                  readIdents = _794_recIdents;
                 }
               } else if (_source34.is_Array) {
-                DAST._IType _766___mcc_h288 = _source34.dtor_element;
+                DAST._IType _795___mcc_h426 = _source34.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _767_recursiveGen;
-                  bool _768_recOwned;
-                  bool _769_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _770_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out390;
-                  bool _out391;
-                  bool _out392;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out393;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out390, out _out391, out _out392, out _out393);
-                  _767_recursiveGen = _out390;
-                  _768_recOwned = _out391;
-                  _769_recErased = _out392;
-                  _770_recIdents = _out393;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _767_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _768_recOwned;
-                  isErased = _769_recErased;
-                  readIdents = _770_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _796_recursiveGen;
+                  bool _797_recOwned;
+                  bool _798_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _799_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out404;
+                  bool _out405;
+                  bool _out406;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out407;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out404, out _out405, out _out406, out _out407);
+                  _796_recursiveGen = _out404;
+                  _797_recOwned = _out405;
+                  _798_recErased = _out406;
+                  _799_recIdents = _out407;
+                  if (!(_797_recOwned)) {
+                    _796_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_796_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(_796_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                  isOwned = _797_recOwned;
+                  isErased = _798_recErased;
+                  readIdents = _799_recIdents;
                 }
               } else if (_source34.is_Seq) {
-                DAST._IType _771___mcc_h290 = _source34.dtor_element;
+                DAST._IType _800___mcc_h429 = _source34.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _772_recursiveGen;
-                  bool _773_recOwned;
-                  bool _774_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _775_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out394;
-                  bool _out395;
-                  bool _out396;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out397;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out394, out _out395, out _out396, out _out397);
-                  _772_recursiveGen = _out394;
-                  _773_recOwned = _out395;
-                  _774_recErased = _out396;
-                  _775_recIdents = _out397;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _772_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _773_recOwned;
-                  isErased = _774_recErased;
-                  readIdents = _775_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _801_recursiveGen;
+                  bool _802_recOwned;
+                  bool _803_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _804_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out408;
+                  bool _out409;
+                  bool _out410;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out411;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out408, out _out409, out _out410, out _out411);
+                  _801_recursiveGen = _out408;
+                  _802_recOwned = _out409;
+                  _803_recErased = _out410;
+                  _804_recIdents = _out411;
+                  if (!(_802_recOwned)) {
+                    _801_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_801_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(_801_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                  isOwned = _802_recOwned;
+                  isErased = _803_recErased;
+                  readIdents = _804_recIdents;
                 }
               } else if (_source34.is_Set) {
-                DAST._IType _776___mcc_h292 = _source34.dtor_element;
+                DAST._IType _805___mcc_h432 = _source34.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _777_recursiveGen;
-                  bool _778_recOwned;
-                  bool _779_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _780_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out398;
-                  bool _out399;
-                  bool _out400;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out401;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out398, out _out399, out _out400, out _out401);
-                  _777_recursiveGen = _out398;
-                  _778_recOwned = _out399;
-                  _779_recErased = _out400;
-                  _780_recIdents = _out401;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _777_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _778_recOwned;
-                  isErased = _779_recErased;
-                  readIdents = _780_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _806_recursiveGen;
+                  bool _807_recOwned;
+                  bool _808_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _809_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out412;
+                  bool _out413;
+                  bool _out414;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out415;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out412, out _out413, out _out414, out _out415);
+                  _806_recursiveGen = _out412;
+                  _807_recOwned = _out413;
+                  _808_recErased = _out414;
+                  _809_recIdents = _out415;
+                  if (!(_807_recOwned)) {
+                    _806_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_806_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(_806_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                  isOwned = _807_recOwned;
+                  isErased = _808_recErased;
+                  readIdents = _809_recIdents;
                 }
               } else if (_source34.is_Multiset) {
-                DAST._IType _781___mcc_h294 = _source34.dtor_element;
+                DAST._IType _810___mcc_h435 = _source34.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _782_recursiveGen;
-                  bool _783_recOwned;
-                  bool _784_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _785_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out402;
-                  bool _out403;
-                  bool _out404;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out405;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out402, out _out403, out _out404, out _out405);
-                  _782_recursiveGen = _out402;
-                  _783_recOwned = _out403;
-                  _784_recErased = _out404;
-                  _785_recIdents = _out405;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _782_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _783_recOwned;
-                  isErased = _784_recErased;
-                  readIdents = _785_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _811_recursiveGen;
+                  bool _812_recOwned;
+                  bool _813_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _814_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out416;
+                  bool _out417;
+                  bool _out418;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out419;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out416, out _out417, out _out418, out _out419);
+                  _811_recursiveGen = _out416;
+                  _812_recOwned = _out417;
+                  _813_recErased = _out418;
+                  _814_recIdents = _out419;
+                  if (!(_812_recOwned)) {
+                    _811_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_811_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(_811_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                  isOwned = _812_recOwned;
+                  isErased = _813_recErased;
+                  readIdents = _814_recIdents;
                 }
               } else if (_source34.is_Map) {
-                DAST._IType _786___mcc_h296 = _source34.dtor_key;
-                DAST._IType _787___mcc_h297 = _source34.dtor_value;
+                DAST._IType _815___mcc_h438 = _source34.dtor_key;
+                DAST._IType _816___mcc_h439 = _source34.dtor_value;
                 {
-                  Dafny.ISequence<Dafny.Rune> _788_recursiveGen;
-                  bool _789_recOwned;
-                  bool _790_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _791_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out406;
-                  bool _out407;
-                  bool _out408;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out409;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out406, out _out407, out _out408, out _out409);
-                  _788_recursiveGen = _out406;
-                  _789_recOwned = _out407;
-                  _790_recErased = _out408;
-                  _791_recIdents = _out409;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _788_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _789_recOwned;
-                  isErased = _790_recErased;
-                  readIdents = _791_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _817_recursiveGen;
+                  bool _818_recOwned;
+                  bool _819_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _820_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out420;
+                  bool _out421;
+                  bool _out422;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out423;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out420, out _out421, out _out422, out _out423);
+                  _817_recursiveGen = _out420;
+                  _818_recOwned = _out421;
+                  _819_recErased = _out422;
+                  _820_recIdents = _out423;
+                  if (!(_818_recOwned)) {
+                    _817_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_817_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(_817_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                  isOwned = _818_recOwned;
+                  isErased = _819_recErased;
+                  readIdents = _820_recIdents;
                 }
               } else if (_source34.is_Arrow) {
-                Dafny.ISequence<DAST._IType> _792___mcc_h300 = _source34.dtor_args;
-                DAST._IType _793___mcc_h301 = _source34.dtor_result;
+                Dafny.ISequence<DAST._IType> _821___mcc_h444 = _source34.dtor_args;
+                DAST._IType _822___mcc_h445 = _source34.dtor_result;
                 {
-                  Dafny.ISequence<Dafny.Rune> _794_recursiveGen;
-                  bool _795_recOwned;
-                  bool _796_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _797_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out410;
-                  bool _out411;
-                  bool _out412;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out413;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out410, out _out411, out _out412, out _out413);
-                  _794_recursiveGen = _out410;
-                  _795_recOwned = _out411;
-                  _796_recErased = _out412;
-                  _797_recIdents = _out413;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _794_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _795_recOwned;
-                  isErased = _796_recErased;
-                  readIdents = _797_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _823_recursiveGen;
+                  bool _824_recOwned;
+                  bool _825_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _826_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out424;
+                  bool _out425;
+                  bool _out426;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out427;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out424, out _out425, out _out426, out _out427);
+                  _823_recursiveGen = _out424;
+                  _824_recOwned = _out425;
+                  _825_recErased = _out426;
+                  _826_recIdents = _out427;
+                  if (!(_824_recOwned)) {
+                    _823_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_823_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(_823_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                  isOwned = _824_recOwned;
+                  isErased = _825_recErased;
+                  readIdents = _826_recIdents;
                 }
               } else if (_source34.is_Primitive) {
-                DAST._IPrimitive _798___mcc_h304 = _source34.dtor_Primitive_a0;
+                DAST._IPrimitive _827___mcc_h450 = _source34.dtor_Primitive_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _799_recursiveGen;
-                  bool _800_recOwned;
-                  bool _801_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _802_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out414;
-                  bool _out415;
-                  bool _out416;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out417;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out414, out _out415, out _out416, out _out417);
-                  _799_recursiveGen = _out414;
-                  _800_recOwned = _out415;
-                  _801_recErased = _out416;
-                  _802_recIdents = _out417;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _799_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _800_recOwned;
-                  isErased = _801_recErased;
-                  readIdents = _802_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _828_recursiveGen;
+                  bool _829_recOwned;
+                  bool _830_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _831_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out428;
+                  bool _out429;
+                  bool _out430;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out431;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out428, out _out429, out _out430, out _out431);
+                  _828_recursiveGen = _out428;
+                  _829_recOwned = _out429;
+                  _830_recErased = _out430;
+                  _831_recIdents = _out431;
+                  if (!(_829_recOwned)) {
+                    _828_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_828_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(_828_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                  isOwned = _829_recOwned;
+                  isErased = _830_recErased;
+                  readIdents = _831_recIdents;
                 }
               } else if (_source34.is_Passthrough) {
-                Dafny.ISequence<Dafny.Rune> _803___mcc_h306 = _source34.dtor_Passthrough_a0;
+                Dafny.ISequence<Dafny.Rune> _832___mcc_h453 = _source34.dtor_Passthrough_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _804_recursiveGen;
-                  bool _805_recOwned;
-                  bool _806_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _807_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out418;
-                  bool _out419;
-                  bool _out420;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out421;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out418, out _out419, out _out420, out _out421);
-                  _804_recursiveGen = _out418;
-                  _805_recOwned = _out419;
-                  _806_recErased = _out420;
-                  _807_recIdents = _out421;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _804_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _805_recOwned;
-                  isErased = _806_recErased;
-                  readIdents = _807_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _833_recursiveGen;
+                  bool _834_recOwned;
+                  bool _835_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _836_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out432;
+                  bool _out433;
+                  bool _out434;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out435;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out432, out _out433, out _out434, out _out435);
+                  _833_recursiveGen = _out432;
+                  _834_recOwned = _out433;
+                  _835_recErased = _out434;
+                  _836_recIdents = _out435;
+                  if (!(_834_recOwned)) {
+                    _833_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_833_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(_833_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                  isOwned = _834_recOwned;
+                  isErased = _835_recErased;
+                  readIdents = _836_recIdents;
                 }
               } else {
-                Dafny.ISequence<Dafny.Rune> _808___mcc_h308 = _source34.dtor_TypeArg_a0;
+                Dafny.ISequence<Dafny.Rune> _837___mcc_h456 = _source34.dtor_TypeArg_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _809_recursiveGen;
-                  bool _810_recOwned;
-                  bool _811_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _812_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out422;
-                  bool _out423;
-                  bool _out424;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out425;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out422, out _out423, out _out424, out _out425);
-                  _809_recursiveGen = _out422;
-                  _810_recOwned = _out423;
-                  _811_recErased = _out424;
-                  _812_recIdents = _out425;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _809_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _810_recOwned;
-                  isErased = _811_recErased;
-                  readIdents = _812_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _838_recursiveGen;
+                  bool _839_recOwned;
+                  bool _840_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _841_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out436;
+                  bool _out437;
+                  bool _out438;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out439;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out436, out _out437, out _out438, out _out439);
+                  _838_recursiveGen = _out436;
+                  _839_recOwned = _out437;
+                  _840_recErased = _out438;
+                  _841_recIdents = _out439;
+                  if (!(_839_recOwned)) {
+                    _838_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_838_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(_838_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".unwrap()"));
+                  isOwned = _839_recOwned;
+                  isErased = _840_recErased;
+                  readIdents = _841_recIdents;
                 }
               }
-            } else if (_source26.is_Array) {
-              DAST._IType _813___mcc_h310 = _source26.dtor_element;
-              DAST._IType _source36 = _489___mcc_h124;
+            } else if (_source26.is_Tuple) {
+              Dafny.ISequence<DAST._IType> _842___mcc_h459 = _source26.dtor_Tuple_a0;
+              DAST._IType _source36 = _501___mcc_h238;
               if (_source36.is_Path) {
-                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _814___mcc_h313 = _source36.dtor_Path_a0;
-                Dafny.ISequence<DAST._IType> _815___mcc_h314 = _source36.dtor_typeArgs;
-                DAST._IResolvedType _816___mcc_h315 = _source36.dtor_resolved;
-                DAST._IResolvedType _source37 = _816___mcc_h315;
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _843___mcc_h463 = _source36.dtor_Path_a0;
+                Dafny.ISequence<DAST._IType> _844___mcc_h464 = _source36.dtor_typeArgs;
+                DAST._IResolvedType _845___mcc_h465 = _source36.dtor_resolved;
+                DAST._IResolvedType _source37 = _845___mcc_h465;
                 if (_source37.is_Datatype) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _817___mcc_h319 = _source37.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _846___mcc_h469 = _source37.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _818_recursiveGen;
-                    bool _819_recOwned;
-                    bool _820_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _821_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out426;
-                    bool _out427;
-                    bool _out428;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out429;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out426, out _out427, out _out428, out _out429);
-                    _818_recursiveGen = _out426;
-                    _819_recOwned = _out427;
-                    _820_recErased = _out428;
-                    _821_recIdents = _out429;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _818_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _819_recOwned;
-                    isErased = _820_recErased;
-                    readIdents = _821_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _847_recursiveGen;
+                    bool _848_recOwned;
+                    bool _849_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _850_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out440;
+                    bool _out441;
+                    bool _out442;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out443;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out440, out _out441, out _out442, out _out443);
+                    _847_recursiveGen = _out440;
+                    _848_recOwned = _out441;
+                    _849_recErased = _out442;
+                    _850_recIdents = _out443;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _847_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _848_recOwned;
+                    isErased = _849_recErased;
+                    readIdents = _850_recIdents;
                   }
                 } else if (_source37.is_Trait) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _822___mcc_h321 = _source37.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _851___mcc_h471 = _source37.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _823_recursiveGen;
-                    bool _824_recOwned;
-                    bool _825_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _826_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out430;
-                    bool _out431;
-                    bool _out432;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out433;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out430, out _out431, out _out432, out _out433);
-                    _823_recursiveGen = _out430;
-                    _824_recOwned = _out431;
-                    _825_recErased = _out432;
-                    _826_recIdents = _out433;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _823_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _824_recOwned;
-                    isErased = _825_recErased;
-                    readIdents = _826_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _852_recursiveGen;
+                    bool _853_recOwned;
+                    bool _854_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _855_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out444;
+                    bool _out445;
+                    bool _out446;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out447;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out444, out _out445, out _out446, out _out447);
+                    _852_recursiveGen = _out444;
+                    _853_recOwned = _out445;
+                    _854_recErased = _out446;
+                    _855_recIdents = _out447;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _852_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _853_recOwned;
+                    isErased = _854_recErased;
+                    readIdents = _855_recIdents;
                   }
                 } else {
-                  DAST._IType _827___mcc_h323 = _source37.dtor_Newtype_a0;
-                  DAST._IType _828_b = _827___mcc_h323;
+                  DAST._IType _856___mcc_h473 = _source37.dtor_Newtype_a0;
+                  DAST._IType _857_b = _856___mcc_h473;
                   {
-                    if (object.Equals(_482_fromTpe, _828_b)) {
-                      Dafny.ISequence<Dafny.Rune> _829_recursiveGen;
-                      bool _830_recOwned;
-                      bool _831_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _832_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out434;
-                      bool _out435;
-                      bool _out436;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out437;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out434, out _out435, out _out436, out _out437);
-                      _829_recursiveGen = _out434;
-                      _830_recOwned = _out435;
-                      _831_recErased = _out436;
-                      _832_recIdents = _out437;
-                      Dafny.ISequence<Dafny.Rune> _833_rhsType;
-                      Dafny.ISequence<Dafny.Rune> _out438;
-                      _out438 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                      _833_rhsType = _out438;
-                      Dafny.ISequence<Dafny.Rune> _834_uneraseFn;
-                      _834_uneraseFn = ((_830_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _833_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _834_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _829_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _830_recOwned;
+                    if (object.Equals(_494_fromTpe, _857_b)) {
+                      Dafny.ISequence<Dafny.Rune> _858_recursiveGen;
+                      bool _859_recOwned;
+                      bool _860_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _861_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out448;
+                      bool _out449;
+                      bool _out450;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out451;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out448, out _out449, out _out450, out _out451);
+                      _858_recursiveGen = _out448;
+                      _859_recOwned = _out449;
+                      _860_recErased = _out450;
+                      _861_recIdents = _out451;
+                      Dafny.ISequence<Dafny.Rune> _862_rhsType;
+                      Dafny.ISequence<Dafny.Rune> _out452;
+                      _out452 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                      _862_rhsType = _out452;
+                      Dafny.ISequence<Dafny.Rune> _863_uneraseFn;
+                      _863_uneraseFn = ((_859_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _862_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _863_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _858_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _859_recOwned;
                       isErased = false;
-                      readIdents = _832_recIdents;
+                      readIdents = _861_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out439;
-                      bool _out440;
-                      bool _out441;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out442;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _828_b), _828_b, _481_toTpe), @params, mustOwn, out _out439, out _out440, out _out441, out _out442);
-                      s = _out439;
-                      isOwned = _out440;
-                      isErased = _out441;
-                      readIdents = _out442;
+                      Dafny.ISequence<Dafny.Rune> _out453;
+                      bool _out454;
+                      bool _out455;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out456;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _857_b), _857_b, _493_toTpe), selfIdent, @params, mustOwn, out _out453, out _out454, out _out455, out _out456);
+                      s = _out453;
+                      isOwned = _out454;
+                      isErased = _out455;
+                      readIdents = _out456;
                     }
                   }
                 }
+              } else if (_source36.is_Nullable) {
+                DAST._IType _864___mcc_h475 = _source36.dtor_Nullable_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _865_recursiveGen;
+                  bool _866_recOwned;
+                  bool _867_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _868_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out457;
+                  bool _out458;
+                  bool _out459;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out460;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out457, out _out458, out _out459, out _out460);
+                  _865_recursiveGen = _out457;
+                  _866_recOwned = _out458;
+                  _867_recErased = _out459;
+                  _868_recIdents = _out460;
+                  if (!(_866_recOwned)) {
+                    _865_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_865_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _865_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                  isOwned = true;
+                  isErased = _867_recErased;
+                  readIdents = _868_recIdents;
+                }
               } else if (_source36.is_Tuple) {
-                Dafny.ISequence<DAST._IType> _835___mcc_h325 = _source36.dtor_Tuple_a0;
+                Dafny.ISequence<DAST._IType> _869___mcc_h477 = _source36.dtor_Tuple_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _836_recursiveGen;
-                  bool _837_recOwned;
-                  bool _838_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _839_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out443;
-                  bool _out444;
-                  bool _out445;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out446;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out443, out _out444, out _out445, out _out446);
-                  _836_recursiveGen = _out443;
-                  _837_recOwned = _out444;
-                  _838_recErased = _out445;
-                  _839_recIdents = _out446;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _836_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _837_recOwned;
-                  isErased = _838_recErased;
-                  readIdents = _839_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _870_recursiveGen;
+                  bool _871_recOwned;
+                  bool _872_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _873_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out461;
+                  bool _out462;
+                  bool _out463;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out464;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out461, out _out462, out _out463, out _out464);
+                  _870_recursiveGen = _out461;
+                  _871_recOwned = _out462;
+                  _872_recErased = _out463;
+                  _873_recIdents = _out464;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _870_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _871_recOwned;
+                  isErased = _872_recErased;
+                  readIdents = _873_recIdents;
                 }
               } else if (_source36.is_Array) {
-                DAST._IType _840___mcc_h327 = _source36.dtor_element;
+                DAST._IType _874___mcc_h479 = _source36.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _841_recursiveGen;
-                  bool _842_recOwned;
-                  bool _843_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _844_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out447;
-                  bool _out448;
-                  bool _out449;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out450;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out447, out _out448, out _out449, out _out450);
-                  _841_recursiveGen = _out447;
-                  _842_recOwned = _out448;
-                  _843_recErased = _out449;
-                  _844_recIdents = _out450;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _841_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _842_recOwned;
-                  isErased = _843_recErased;
-                  readIdents = _844_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _875_recursiveGen;
+                  bool _876_recOwned;
+                  bool _877_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _878_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out465;
+                  bool _out466;
+                  bool _out467;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out468;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out465, out _out466, out _out467, out _out468);
+                  _875_recursiveGen = _out465;
+                  _876_recOwned = _out466;
+                  _877_recErased = _out467;
+                  _878_recIdents = _out468;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _875_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _876_recOwned;
+                  isErased = _877_recErased;
+                  readIdents = _878_recIdents;
                 }
               } else if (_source36.is_Seq) {
-                DAST._IType _845___mcc_h329 = _source36.dtor_element;
+                DAST._IType _879___mcc_h481 = _source36.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _846_recursiveGen;
-                  bool _847_recOwned;
-                  bool _848_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _849_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out451;
-                  bool _out452;
-                  bool _out453;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out454;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out451, out _out452, out _out453, out _out454);
-                  _846_recursiveGen = _out451;
-                  _847_recOwned = _out452;
-                  _848_recErased = _out453;
-                  _849_recIdents = _out454;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _846_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _847_recOwned;
-                  isErased = _848_recErased;
-                  readIdents = _849_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _880_recursiveGen;
+                  bool _881_recOwned;
+                  bool _882_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _883_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out469;
+                  bool _out470;
+                  bool _out471;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out472;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out469, out _out470, out _out471, out _out472);
+                  _880_recursiveGen = _out469;
+                  _881_recOwned = _out470;
+                  _882_recErased = _out471;
+                  _883_recIdents = _out472;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _880_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _881_recOwned;
+                  isErased = _882_recErased;
+                  readIdents = _883_recIdents;
                 }
               } else if (_source36.is_Set) {
-                DAST._IType _850___mcc_h331 = _source36.dtor_element;
+                DAST._IType _884___mcc_h483 = _source36.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _851_recursiveGen;
-                  bool _852_recOwned;
-                  bool _853_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _854_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out455;
-                  bool _out456;
-                  bool _out457;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out458;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out455, out _out456, out _out457, out _out458);
-                  _851_recursiveGen = _out455;
-                  _852_recOwned = _out456;
-                  _853_recErased = _out457;
-                  _854_recIdents = _out458;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _851_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _852_recOwned;
-                  isErased = _853_recErased;
-                  readIdents = _854_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _885_recursiveGen;
+                  bool _886_recOwned;
+                  bool _887_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _888_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out473;
+                  bool _out474;
+                  bool _out475;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out476;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out473, out _out474, out _out475, out _out476);
+                  _885_recursiveGen = _out473;
+                  _886_recOwned = _out474;
+                  _887_recErased = _out475;
+                  _888_recIdents = _out476;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _885_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _886_recOwned;
+                  isErased = _887_recErased;
+                  readIdents = _888_recIdents;
                 }
               } else if (_source36.is_Multiset) {
-                DAST._IType _855___mcc_h333 = _source36.dtor_element;
+                DAST._IType _889___mcc_h485 = _source36.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _856_recursiveGen;
-                  bool _857_recOwned;
-                  bool _858_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _859_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out459;
-                  bool _out460;
-                  bool _out461;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out462;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out459, out _out460, out _out461, out _out462);
-                  _856_recursiveGen = _out459;
-                  _857_recOwned = _out460;
-                  _858_recErased = _out461;
-                  _859_recIdents = _out462;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _856_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _857_recOwned;
-                  isErased = _858_recErased;
-                  readIdents = _859_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _890_recursiveGen;
+                  bool _891_recOwned;
+                  bool _892_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _893_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out477;
+                  bool _out478;
+                  bool _out479;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out480;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out477, out _out478, out _out479, out _out480);
+                  _890_recursiveGen = _out477;
+                  _891_recOwned = _out478;
+                  _892_recErased = _out479;
+                  _893_recIdents = _out480;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _890_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _891_recOwned;
+                  isErased = _892_recErased;
+                  readIdents = _893_recIdents;
                 }
               } else if (_source36.is_Map) {
-                DAST._IType _860___mcc_h335 = _source36.dtor_key;
-                DAST._IType _861___mcc_h336 = _source36.dtor_value;
+                DAST._IType _894___mcc_h487 = _source36.dtor_key;
+                DAST._IType _895___mcc_h488 = _source36.dtor_value;
                 {
-                  Dafny.ISequence<Dafny.Rune> _862_recursiveGen;
-                  bool _863_recOwned;
-                  bool _864_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _865_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out463;
-                  bool _out464;
-                  bool _out465;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out466;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out463, out _out464, out _out465, out _out466);
-                  _862_recursiveGen = _out463;
-                  _863_recOwned = _out464;
-                  _864_recErased = _out465;
-                  _865_recIdents = _out466;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _862_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _863_recOwned;
-                  isErased = _864_recErased;
-                  readIdents = _865_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _896_recursiveGen;
+                  bool _897_recOwned;
+                  bool _898_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _899_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out481;
+                  bool _out482;
+                  bool _out483;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out484;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out481, out _out482, out _out483, out _out484);
+                  _896_recursiveGen = _out481;
+                  _897_recOwned = _out482;
+                  _898_recErased = _out483;
+                  _899_recIdents = _out484;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _896_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _897_recOwned;
+                  isErased = _898_recErased;
+                  readIdents = _899_recIdents;
                 }
               } else if (_source36.is_Arrow) {
-                Dafny.ISequence<DAST._IType> _866___mcc_h339 = _source36.dtor_args;
-                DAST._IType _867___mcc_h340 = _source36.dtor_result;
+                Dafny.ISequence<DAST._IType> _900___mcc_h491 = _source36.dtor_args;
+                DAST._IType _901___mcc_h492 = _source36.dtor_result;
                 {
-                  Dafny.ISequence<Dafny.Rune> _868_recursiveGen;
-                  bool _869_recOwned;
-                  bool _870_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _871_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out467;
-                  bool _out468;
-                  bool _out469;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out470;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out467, out _out468, out _out469, out _out470);
-                  _868_recursiveGen = _out467;
-                  _869_recOwned = _out468;
-                  _870_recErased = _out469;
-                  _871_recIdents = _out470;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _868_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _869_recOwned;
-                  isErased = _870_recErased;
-                  readIdents = _871_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _902_recursiveGen;
+                  bool _903_recOwned;
+                  bool _904_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _905_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out485;
+                  bool _out486;
+                  bool _out487;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out488;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out485, out _out486, out _out487, out _out488);
+                  _902_recursiveGen = _out485;
+                  _903_recOwned = _out486;
+                  _904_recErased = _out487;
+                  _905_recIdents = _out488;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _902_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _903_recOwned;
+                  isErased = _904_recErased;
+                  readIdents = _905_recIdents;
                 }
               } else if (_source36.is_Primitive) {
-                DAST._IPrimitive _872___mcc_h343 = _source36.dtor_Primitive_a0;
+                DAST._IPrimitive _906___mcc_h495 = _source36.dtor_Primitive_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _873_recursiveGen;
-                  bool _874_recOwned;
-                  bool _875_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _876_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out471;
-                  bool _out472;
-                  bool _out473;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out474;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out471, out _out472, out _out473, out _out474);
-                  _873_recursiveGen = _out471;
-                  _874_recOwned = _out472;
-                  _875_recErased = _out473;
-                  _876_recIdents = _out474;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _873_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _874_recOwned;
-                  isErased = _875_recErased;
-                  readIdents = _876_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _907_recursiveGen;
+                  bool _908_recOwned;
+                  bool _909_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _910_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out489;
+                  bool _out490;
+                  bool _out491;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out492;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out489, out _out490, out _out491, out _out492);
+                  _907_recursiveGen = _out489;
+                  _908_recOwned = _out490;
+                  _909_recErased = _out491;
+                  _910_recIdents = _out492;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _907_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _908_recOwned;
+                  isErased = _909_recErased;
+                  readIdents = _910_recIdents;
                 }
               } else if (_source36.is_Passthrough) {
-                Dafny.ISequence<Dafny.Rune> _877___mcc_h345 = _source36.dtor_Passthrough_a0;
+                Dafny.ISequence<Dafny.Rune> _911___mcc_h497 = _source36.dtor_Passthrough_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _878_recursiveGen;
-                  bool _879_recOwned;
-                  bool _880_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _881_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out475;
-                  bool _out476;
-                  bool _out477;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out478;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out475, out _out476, out _out477, out _out478);
-                  _878_recursiveGen = _out475;
-                  _879_recOwned = _out476;
-                  _880_recErased = _out477;
-                  _881_recIdents = _out478;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _878_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _879_recOwned;
-                  isErased = _880_recErased;
-                  readIdents = _881_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _912_recursiveGen;
+                  bool _913_recOwned;
+                  bool _914_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _915_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out493;
+                  bool _out494;
+                  bool _out495;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out496;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out493, out _out494, out _out495, out _out496);
+                  _912_recursiveGen = _out493;
+                  _913_recOwned = _out494;
+                  _914_recErased = _out495;
+                  _915_recIdents = _out496;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _912_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _913_recOwned;
+                  isErased = _914_recErased;
+                  readIdents = _915_recIdents;
                 }
               } else {
-                Dafny.ISequence<Dafny.Rune> _882___mcc_h347 = _source36.dtor_TypeArg_a0;
+                Dafny.ISequence<Dafny.Rune> _916___mcc_h499 = _source36.dtor_TypeArg_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _883_recursiveGen;
-                  bool _884_recOwned;
-                  bool _885_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _886_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out479;
-                  bool _out480;
-                  bool _out481;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out482;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out479, out _out480, out _out481, out _out482);
-                  _883_recursiveGen = _out479;
-                  _884_recOwned = _out480;
-                  _885_recErased = _out481;
-                  _886_recIdents = _out482;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _883_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _884_recOwned;
-                  isErased = _885_recErased;
-                  readIdents = _886_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _917_recursiveGen;
+                  bool _918_recOwned;
+                  bool _919_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _920_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out497;
+                  bool _out498;
+                  bool _out499;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out500;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out497, out _out498, out _out499, out _out500);
+                  _917_recursiveGen = _out497;
+                  _918_recOwned = _out498;
+                  _919_recErased = _out499;
+                  _920_recIdents = _out500;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _917_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _918_recOwned;
+                  isErased = _919_recErased;
+                  readIdents = _920_recIdents;
                 }
               }
-            } else if (_source26.is_Seq) {
-              DAST._IType _887___mcc_h349 = _source26.dtor_element;
-              DAST._IType _source38 = _489___mcc_h124;
+            } else if (_source26.is_Array) {
+              DAST._IType _921___mcc_h501 = _source26.dtor_element;
+              DAST._IType _source38 = _501___mcc_h238;
               if (_source38.is_Path) {
-                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _888___mcc_h352 = _source38.dtor_Path_a0;
-                Dafny.ISequence<DAST._IType> _889___mcc_h353 = _source38.dtor_typeArgs;
-                DAST._IResolvedType _890___mcc_h354 = _source38.dtor_resolved;
-                DAST._IResolvedType _source39 = _890___mcc_h354;
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _922___mcc_h505 = _source38.dtor_Path_a0;
+                Dafny.ISequence<DAST._IType> _923___mcc_h506 = _source38.dtor_typeArgs;
+                DAST._IResolvedType _924___mcc_h507 = _source38.dtor_resolved;
+                DAST._IResolvedType _source39 = _924___mcc_h507;
                 if (_source39.is_Datatype) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _891___mcc_h358 = _source39.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _925___mcc_h511 = _source39.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _892_recursiveGen;
-                    bool _893_recOwned;
-                    bool _894_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _895_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out483;
-                    bool _out484;
-                    bool _out485;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out486;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out483, out _out484, out _out485, out _out486);
-                    _892_recursiveGen = _out483;
-                    _893_recOwned = _out484;
-                    _894_recErased = _out485;
-                    _895_recIdents = _out486;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _892_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _893_recOwned;
-                    isErased = _894_recErased;
-                    readIdents = _895_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _926_recursiveGen;
+                    bool _927_recOwned;
+                    bool _928_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _929_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out501;
+                    bool _out502;
+                    bool _out503;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out504;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out501, out _out502, out _out503, out _out504);
+                    _926_recursiveGen = _out501;
+                    _927_recOwned = _out502;
+                    _928_recErased = _out503;
+                    _929_recIdents = _out504;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _926_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _927_recOwned;
+                    isErased = _928_recErased;
+                    readIdents = _929_recIdents;
                   }
                 } else if (_source39.is_Trait) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _896___mcc_h360 = _source39.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _930___mcc_h513 = _source39.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _897_recursiveGen;
-                    bool _898_recOwned;
-                    bool _899_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _900_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out487;
-                    bool _out488;
-                    bool _out489;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out490;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out487, out _out488, out _out489, out _out490);
-                    _897_recursiveGen = _out487;
-                    _898_recOwned = _out488;
-                    _899_recErased = _out489;
-                    _900_recIdents = _out490;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _897_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _898_recOwned;
-                    isErased = _899_recErased;
-                    readIdents = _900_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _931_recursiveGen;
+                    bool _932_recOwned;
+                    bool _933_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _934_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out505;
+                    bool _out506;
+                    bool _out507;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out508;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out505, out _out506, out _out507, out _out508);
+                    _931_recursiveGen = _out505;
+                    _932_recOwned = _out506;
+                    _933_recErased = _out507;
+                    _934_recIdents = _out508;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _931_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _932_recOwned;
+                    isErased = _933_recErased;
+                    readIdents = _934_recIdents;
                   }
                 } else {
-                  DAST._IType _901___mcc_h362 = _source39.dtor_Newtype_a0;
-                  DAST._IType _902_b = _901___mcc_h362;
+                  DAST._IType _935___mcc_h515 = _source39.dtor_Newtype_a0;
+                  DAST._IType _936_b = _935___mcc_h515;
                   {
-                    if (object.Equals(_482_fromTpe, _902_b)) {
-                      Dafny.ISequence<Dafny.Rune> _903_recursiveGen;
-                      bool _904_recOwned;
-                      bool _905_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _906_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out491;
-                      bool _out492;
-                      bool _out493;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out494;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out491, out _out492, out _out493, out _out494);
-                      _903_recursiveGen = _out491;
-                      _904_recOwned = _out492;
-                      _905_recErased = _out493;
-                      _906_recIdents = _out494;
-                      Dafny.ISequence<Dafny.Rune> _907_rhsType;
-                      Dafny.ISequence<Dafny.Rune> _out495;
-                      _out495 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                      _907_rhsType = _out495;
-                      Dafny.ISequence<Dafny.Rune> _908_uneraseFn;
-                      _908_uneraseFn = ((_904_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _907_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _908_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _903_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _904_recOwned;
+                    if (object.Equals(_494_fromTpe, _936_b)) {
+                      Dafny.ISequence<Dafny.Rune> _937_recursiveGen;
+                      bool _938_recOwned;
+                      bool _939_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _940_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out509;
+                      bool _out510;
+                      bool _out511;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out512;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out509, out _out510, out _out511, out _out512);
+                      _937_recursiveGen = _out509;
+                      _938_recOwned = _out510;
+                      _939_recErased = _out511;
+                      _940_recIdents = _out512;
+                      Dafny.ISequence<Dafny.Rune> _941_rhsType;
+                      Dafny.ISequence<Dafny.Rune> _out513;
+                      _out513 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                      _941_rhsType = _out513;
+                      Dafny.ISequence<Dafny.Rune> _942_uneraseFn;
+                      _942_uneraseFn = ((_938_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _941_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _942_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _937_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _938_recOwned;
                       isErased = false;
-                      readIdents = _906_recIdents;
+                      readIdents = _940_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out496;
-                      bool _out497;
-                      bool _out498;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out499;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _902_b), _902_b, _481_toTpe), @params, mustOwn, out _out496, out _out497, out _out498, out _out499);
-                      s = _out496;
-                      isOwned = _out497;
-                      isErased = _out498;
-                      readIdents = _out499;
+                      Dafny.ISequence<Dafny.Rune> _out514;
+                      bool _out515;
+                      bool _out516;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out517;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _936_b), _936_b, _493_toTpe), selfIdent, @params, mustOwn, out _out514, out _out515, out _out516, out _out517);
+                      s = _out514;
+                      isOwned = _out515;
+                      isErased = _out516;
+                      readIdents = _out517;
                     }
                   }
                 }
+              } else if (_source38.is_Nullable) {
+                DAST._IType _943___mcc_h517 = _source38.dtor_Nullable_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _944_recursiveGen;
+                  bool _945_recOwned;
+                  bool _946_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _947_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out518;
+                  bool _out519;
+                  bool _out520;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out521;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out518, out _out519, out _out520, out _out521);
+                  _944_recursiveGen = _out518;
+                  _945_recOwned = _out519;
+                  _946_recErased = _out520;
+                  _947_recIdents = _out521;
+                  if (!(_945_recOwned)) {
+                    _944_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_944_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _944_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                  isOwned = true;
+                  isErased = _946_recErased;
+                  readIdents = _947_recIdents;
+                }
               } else if (_source38.is_Tuple) {
-                Dafny.ISequence<DAST._IType> _909___mcc_h364 = _source38.dtor_Tuple_a0;
+                Dafny.ISequence<DAST._IType> _948___mcc_h519 = _source38.dtor_Tuple_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _910_recursiveGen;
-                  bool _911_recOwned;
-                  bool _912_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _913_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out500;
-                  bool _out501;
-                  bool _out502;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out503;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out500, out _out501, out _out502, out _out503);
-                  _910_recursiveGen = _out500;
-                  _911_recOwned = _out501;
-                  _912_recErased = _out502;
-                  _913_recIdents = _out503;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _910_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _911_recOwned;
-                  isErased = _912_recErased;
-                  readIdents = _913_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _949_recursiveGen;
+                  bool _950_recOwned;
+                  bool _951_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _952_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out522;
+                  bool _out523;
+                  bool _out524;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out525;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out522, out _out523, out _out524, out _out525);
+                  _949_recursiveGen = _out522;
+                  _950_recOwned = _out523;
+                  _951_recErased = _out524;
+                  _952_recIdents = _out525;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _949_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _950_recOwned;
+                  isErased = _951_recErased;
+                  readIdents = _952_recIdents;
                 }
               } else if (_source38.is_Array) {
-                DAST._IType _914___mcc_h366 = _source38.dtor_element;
+                DAST._IType _953___mcc_h521 = _source38.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _915_recursiveGen;
-                  bool _916_recOwned;
-                  bool _917_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _918_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out504;
-                  bool _out505;
-                  bool _out506;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out507;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out504, out _out505, out _out506, out _out507);
-                  _915_recursiveGen = _out504;
-                  _916_recOwned = _out505;
-                  _917_recErased = _out506;
-                  _918_recIdents = _out507;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _915_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _916_recOwned;
-                  isErased = _917_recErased;
-                  readIdents = _918_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _954_recursiveGen;
+                  bool _955_recOwned;
+                  bool _956_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _957_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out526;
+                  bool _out527;
+                  bool _out528;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out529;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out526, out _out527, out _out528, out _out529);
+                  _954_recursiveGen = _out526;
+                  _955_recOwned = _out527;
+                  _956_recErased = _out528;
+                  _957_recIdents = _out529;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _954_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _955_recOwned;
+                  isErased = _956_recErased;
+                  readIdents = _957_recIdents;
                 }
               } else if (_source38.is_Seq) {
-                DAST._IType _919___mcc_h368 = _source38.dtor_element;
+                DAST._IType _958___mcc_h523 = _source38.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _920_recursiveGen;
-                  bool _921_recOwned;
-                  bool _922_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _923_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out508;
-                  bool _out509;
-                  bool _out510;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out511;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out508, out _out509, out _out510, out _out511);
-                  _920_recursiveGen = _out508;
-                  _921_recOwned = _out509;
-                  _922_recErased = _out510;
-                  _923_recIdents = _out511;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _920_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _921_recOwned;
-                  isErased = _922_recErased;
-                  readIdents = _923_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _959_recursiveGen;
+                  bool _960_recOwned;
+                  bool _961_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _962_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out530;
+                  bool _out531;
+                  bool _out532;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out533;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out530, out _out531, out _out532, out _out533);
+                  _959_recursiveGen = _out530;
+                  _960_recOwned = _out531;
+                  _961_recErased = _out532;
+                  _962_recIdents = _out533;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _959_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _960_recOwned;
+                  isErased = _961_recErased;
+                  readIdents = _962_recIdents;
                 }
               } else if (_source38.is_Set) {
-                DAST._IType _924___mcc_h370 = _source38.dtor_element;
+                DAST._IType _963___mcc_h525 = _source38.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _925_recursiveGen;
-                  bool _926_recOwned;
-                  bool _927_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _928_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out512;
-                  bool _out513;
-                  bool _out514;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out515;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out512, out _out513, out _out514, out _out515);
-                  _925_recursiveGen = _out512;
-                  _926_recOwned = _out513;
-                  _927_recErased = _out514;
-                  _928_recIdents = _out515;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _925_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _926_recOwned;
-                  isErased = _927_recErased;
-                  readIdents = _928_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _964_recursiveGen;
+                  bool _965_recOwned;
+                  bool _966_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _967_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out534;
+                  bool _out535;
+                  bool _out536;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out537;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out534, out _out535, out _out536, out _out537);
+                  _964_recursiveGen = _out534;
+                  _965_recOwned = _out535;
+                  _966_recErased = _out536;
+                  _967_recIdents = _out537;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _964_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _965_recOwned;
+                  isErased = _966_recErased;
+                  readIdents = _967_recIdents;
                 }
               } else if (_source38.is_Multiset) {
-                DAST._IType _929___mcc_h372 = _source38.dtor_element;
+                DAST._IType _968___mcc_h527 = _source38.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _930_recursiveGen;
-                  bool _931_recOwned;
-                  bool _932_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _933_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out516;
-                  bool _out517;
-                  bool _out518;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out519;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out516, out _out517, out _out518, out _out519);
-                  _930_recursiveGen = _out516;
-                  _931_recOwned = _out517;
-                  _932_recErased = _out518;
-                  _933_recIdents = _out519;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _930_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _931_recOwned;
-                  isErased = _932_recErased;
-                  readIdents = _933_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _969_recursiveGen;
+                  bool _970_recOwned;
+                  bool _971_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _972_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out538;
+                  bool _out539;
+                  bool _out540;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out541;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out538, out _out539, out _out540, out _out541);
+                  _969_recursiveGen = _out538;
+                  _970_recOwned = _out539;
+                  _971_recErased = _out540;
+                  _972_recIdents = _out541;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _969_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _970_recOwned;
+                  isErased = _971_recErased;
+                  readIdents = _972_recIdents;
                 }
               } else if (_source38.is_Map) {
-                DAST._IType _934___mcc_h374 = _source38.dtor_key;
-                DAST._IType _935___mcc_h375 = _source38.dtor_value;
+                DAST._IType _973___mcc_h529 = _source38.dtor_key;
+                DAST._IType _974___mcc_h530 = _source38.dtor_value;
                 {
-                  Dafny.ISequence<Dafny.Rune> _936_recursiveGen;
-                  bool _937_recOwned;
-                  bool _938_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _939_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out520;
-                  bool _out521;
-                  bool _out522;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out523;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out520, out _out521, out _out522, out _out523);
-                  _936_recursiveGen = _out520;
-                  _937_recOwned = _out521;
-                  _938_recErased = _out522;
-                  _939_recIdents = _out523;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _936_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _937_recOwned;
-                  isErased = _938_recErased;
-                  readIdents = _939_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _975_recursiveGen;
+                  bool _976_recOwned;
+                  bool _977_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _978_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out542;
+                  bool _out543;
+                  bool _out544;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out545;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out542, out _out543, out _out544, out _out545);
+                  _975_recursiveGen = _out542;
+                  _976_recOwned = _out543;
+                  _977_recErased = _out544;
+                  _978_recIdents = _out545;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _975_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _976_recOwned;
+                  isErased = _977_recErased;
+                  readIdents = _978_recIdents;
                 }
               } else if (_source38.is_Arrow) {
-                Dafny.ISequence<DAST._IType> _940___mcc_h378 = _source38.dtor_args;
-                DAST._IType _941___mcc_h379 = _source38.dtor_result;
+                Dafny.ISequence<DAST._IType> _979___mcc_h533 = _source38.dtor_args;
+                DAST._IType _980___mcc_h534 = _source38.dtor_result;
                 {
-                  Dafny.ISequence<Dafny.Rune> _942_recursiveGen;
-                  bool _943_recOwned;
-                  bool _944_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _945_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out524;
-                  bool _out525;
-                  bool _out526;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out527;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out524, out _out525, out _out526, out _out527);
-                  _942_recursiveGen = _out524;
-                  _943_recOwned = _out525;
-                  _944_recErased = _out526;
-                  _945_recIdents = _out527;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _942_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _943_recOwned;
-                  isErased = _944_recErased;
-                  readIdents = _945_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _981_recursiveGen;
+                  bool _982_recOwned;
+                  bool _983_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _984_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out546;
+                  bool _out547;
+                  bool _out548;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out549;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out546, out _out547, out _out548, out _out549);
+                  _981_recursiveGen = _out546;
+                  _982_recOwned = _out547;
+                  _983_recErased = _out548;
+                  _984_recIdents = _out549;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _981_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _982_recOwned;
+                  isErased = _983_recErased;
+                  readIdents = _984_recIdents;
                 }
               } else if (_source38.is_Primitive) {
-                DAST._IPrimitive _946___mcc_h382 = _source38.dtor_Primitive_a0;
+                DAST._IPrimitive _985___mcc_h537 = _source38.dtor_Primitive_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _947_recursiveGen;
-                  bool _948_recOwned;
-                  bool _949_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _950_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out528;
-                  bool _out529;
-                  bool _out530;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out531;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out528, out _out529, out _out530, out _out531);
-                  _947_recursiveGen = _out528;
-                  _948_recOwned = _out529;
-                  _949_recErased = _out530;
-                  _950_recIdents = _out531;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _947_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _948_recOwned;
-                  isErased = _949_recErased;
-                  readIdents = _950_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _986_recursiveGen;
+                  bool _987_recOwned;
+                  bool _988_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _989_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out550;
+                  bool _out551;
+                  bool _out552;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out553;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out550, out _out551, out _out552, out _out553);
+                  _986_recursiveGen = _out550;
+                  _987_recOwned = _out551;
+                  _988_recErased = _out552;
+                  _989_recIdents = _out553;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _986_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _987_recOwned;
+                  isErased = _988_recErased;
+                  readIdents = _989_recIdents;
                 }
               } else if (_source38.is_Passthrough) {
-                Dafny.ISequence<Dafny.Rune> _951___mcc_h384 = _source38.dtor_Passthrough_a0;
+                Dafny.ISequence<Dafny.Rune> _990___mcc_h539 = _source38.dtor_Passthrough_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _952_recursiveGen;
-                  bool _953_recOwned;
-                  bool _954_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _955_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out532;
-                  bool _out533;
-                  bool _out534;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out535;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out532, out _out533, out _out534, out _out535);
-                  _952_recursiveGen = _out532;
-                  _953_recOwned = _out533;
-                  _954_recErased = _out534;
-                  _955_recIdents = _out535;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _952_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _953_recOwned;
-                  isErased = _954_recErased;
-                  readIdents = _955_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _991_recursiveGen;
+                  bool _992_recOwned;
+                  bool _993_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _994_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out554;
+                  bool _out555;
+                  bool _out556;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out557;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out554, out _out555, out _out556, out _out557);
+                  _991_recursiveGen = _out554;
+                  _992_recOwned = _out555;
+                  _993_recErased = _out556;
+                  _994_recIdents = _out557;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _991_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _992_recOwned;
+                  isErased = _993_recErased;
+                  readIdents = _994_recIdents;
                 }
               } else {
-                Dafny.ISequence<Dafny.Rune> _956___mcc_h386 = _source38.dtor_TypeArg_a0;
+                Dafny.ISequence<Dafny.Rune> _995___mcc_h541 = _source38.dtor_TypeArg_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _957_recursiveGen;
-                  bool _958_recOwned;
-                  bool _959_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _960_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out536;
-                  bool _out537;
-                  bool _out538;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out539;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out536, out _out537, out _out538, out _out539);
-                  _957_recursiveGen = _out536;
-                  _958_recOwned = _out537;
-                  _959_recErased = _out538;
-                  _960_recIdents = _out539;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _957_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _958_recOwned;
-                  isErased = _959_recErased;
-                  readIdents = _960_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _996_recursiveGen;
+                  bool _997_recOwned;
+                  bool _998_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _999_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out558;
+                  bool _out559;
+                  bool _out560;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out561;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out558, out _out559, out _out560, out _out561);
+                  _996_recursiveGen = _out558;
+                  _997_recOwned = _out559;
+                  _998_recErased = _out560;
+                  _999_recIdents = _out561;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _996_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _997_recOwned;
+                  isErased = _998_recErased;
+                  readIdents = _999_recIdents;
                 }
               }
-            } else if (_source26.is_Set) {
-              DAST._IType _961___mcc_h388 = _source26.dtor_element;
-              DAST._IType _source40 = _489___mcc_h124;
+            } else if (_source26.is_Seq) {
+              DAST._IType _1000___mcc_h543 = _source26.dtor_element;
+              DAST._IType _source40 = _501___mcc_h238;
               if (_source40.is_Path) {
-                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _962___mcc_h391 = _source40.dtor_Path_a0;
-                Dafny.ISequence<DAST._IType> _963___mcc_h392 = _source40.dtor_typeArgs;
-                DAST._IResolvedType _964___mcc_h393 = _source40.dtor_resolved;
-                DAST._IResolvedType _source41 = _964___mcc_h393;
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1001___mcc_h547 = _source40.dtor_Path_a0;
+                Dafny.ISequence<DAST._IType> _1002___mcc_h548 = _source40.dtor_typeArgs;
+                DAST._IResolvedType _1003___mcc_h549 = _source40.dtor_resolved;
+                DAST._IResolvedType _source41 = _1003___mcc_h549;
                 if (_source41.is_Datatype) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _965___mcc_h397 = _source41.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1004___mcc_h553 = _source41.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _966_recursiveGen;
-                    bool _967_recOwned;
-                    bool _968_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _969_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out540;
-                    bool _out541;
-                    bool _out542;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out543;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out540, out _out541, out _out542, out _out543);
-                    _966_recursiveGen = _out540;
-                    _967_recOwned = _out541;
-                    _968_recErased = _out542;
-                    _969_recIdents = _out543;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _966_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _967_recOwned;
-                    isErased = _968_recErased;
-                    readIdents = _969_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1005_recursiveGen;
+                    bool _1006_recOwned;
+                    bool _1007_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1008_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out562;
+                    bool _out563;
+                    bool _out564;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out565;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out562, out _out563, out _out564, out _out565);
+                    _1005_recursiveGen = _out562;
+                    _1006_recOwned = _out563;
+                    _1007_recErased = _out564;
+                    _1008_recIdents = _out565;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1005_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1006_recOwned;
+                    isErased = _1007_recErased;
+                    readIdents = _1008_recIdents;
                   }
                 } else if (_source41.is_Trait) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _970___mcc_h399 = _source41.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1009___mcc_h555 = _source41.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _971_recursiveGen;
-                    bool _972_recOwned;
-                    bool _973_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _974_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out544;
-                    bool _out545;
-                    bool _out546;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out547;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out544, out _out545, out _out546, out _out547);
-                    _971_recursiveGen = _out544;
-                    _972_recOwned = _out545;
-                    _973_recErased = _out546;
-                    _974_recIdents = _out547;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _971_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _972_recOwned;
-                    isErased = _973_recErased;
-                    readIdents = _974_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1010_recursiveGen;
+                    bool _1011_recOwned;
+                    bool _1012_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1013_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out566;
+                    bool _out567;
+                    bool _out568;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out569;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out566, out _out567, out _out568, out _out569);
+                    _1010_recursiveGen = _out566;
+                    _1011_recOwned = _out567;
+                    _1012_recErased = _out568;
+                    _1013_recIdents = _out569;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1010_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1011_recOwned;
+                    isErased = _1012_recErased;
+                    readIdents = _1013_recIdents;
                   }
                 } else {
-                  DAST._IType _975___mcc_h401 = _source41.dtor_Newtype_a0;
-                  DAST._IType _976_b = _975___mcc_h401;
+                  DAST._IType _1014___mcc_h557 = _source41.dtor_Newtype_a0;
+                  DAST._IType _1015_b = _1014___mcc_h557;
                   {
-                    if (object.Equals(_482_fromTpe, _976_b)) {
-                      Dafny.ISequence<Dafny.Rune> _977_recursiveGen;
-                      bool _978_recOwned;
-                      bool _979_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _980_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out548;
-                      bool _out549;
-                      bool _out550;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out551;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out548, out _out549, out _out550, out _out551);
-                      _977_recursiveGen = _out548;
-                      _978_recOwned = _out549;
-                      _979_recErased = _out550;
-                      _980_recIdents = _out551;
-                      Dafny.ISequence<Dafny.Rune> _981_rhsType;
-                      Dafny.ISequence<Dafny.Rune> _out552;
-                      _out552 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                      _981_rhsType = _out552;
-                      Dafny.ISequence<Dafny.Rune> _982_uneraseFn;
-                      _982_uneraseFn = ((_978_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _981_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _982_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _977_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _978_recOwned;
+                    if (object.Equals(_494_fromTpe, _1015_b)) {
+                      Dafny.ISequence<Dafny.Rune> _1016_recursiveGen;
+                      bool _1017_recOwned;
+                      bool _1018_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1019_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out570;
+                      bool _out571;
+                      bool _out572;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out573;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out570, out _out571, out _out572, out _out573);
+                      _1016_recursiveGen = _out570;
+                      _1017_recOwned = _out571;
+                      _1018_recErased = _out572;
+                      _1019_recIdents = _out573;
+                      Dafny.ISequence<Dafny.Rune> _1020_rhsType;
+                      Dafny.ISequence<Dafny.Rune> _out574;
+                      _out574 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                      _1020_rhsType = _out574;
+                      Dafny.ISequence<Dafny.Rune> _1021_uneraseFn;
+                      _1021_uneraseFn = ((_1017_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1020_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1021_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1016_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _1017_recOwned;
                       isErased = false;
-                      readIdents = _980_recIdents;
+                      readIdents = _1019_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out553;
-                      bool _out554;
-                      bool _out555;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out556;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _976_b), _976_b, _481_toTpe), @params, mustOwn, out _out553, out _out554, out _out555, out _out556);
-                      s = _out553;
-                      isOwned = _out554;
-                      isErased = _out555;
-                      readIdents = _out556;
+                      Dafny.ISequence<Dafny.Rune> _out575;
+                      bool _out576;
+                      bool _out577;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out578;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1015_b), _1015_b, _493_toTpe), selfIdent, @params, mustOwn, out _out575, out _out576, out _out577, out _out578);
+                      s = _out575;
+                      isOwned = _out576;
+                      isErased = _out577;
+                      readIdents = _out578;
                     }
                   }
                 }
+              } else if (_source40.is_Nullable) {
+                DAST._IType _1022___mcc_h559 = _source40.dtor_Nullable_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1023_recursiveGen;
+                  bool _1024_recOwned;
+                  bool _1025_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1026_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out579;
+                  bool _out580;
+                  bool _out581;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out582;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out579, out _out580, out _out581, out _out582);
+                  _1023_recursiveGen = _out579;
+                  _1024_recOwned = _out580;
+                  _1025_recErased = _out581;
+                  _1026_recIdents = _out582;
+                  if (!(_1024_recOwned)) {
+                    _1023_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1023_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1023_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                  isOwned = true;
+                  isErased = _1025_recErased;
+                  readIdents = _1026_recIdents;
+                }
               } else if (_source40.is_Tuple) {
-                Dafny.ISequence<DAST._IType> _983___mcc_h403 = _source40.dtor_Tuple_a0;
+                Dafny.ISequence<DAST._IType> _1027___mcc_h561 = _source40.dtor_Tuple_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _984_recursiveGen;
-                  bool _985_recOwned;
-                  bool _986_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _987_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out557;
-                  bool _out558;
-                  bool _out559;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out560;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out557, out _out558, out _out559, out _out560);
-                  _984_recursiveGen = _out557;
-                  _985_recOwned = _out558;
-                  _986_recErased = _out559;
-                  _987_recIdents = _out560;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _984_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _985_recOwned;
-                  isErased = _986_recErased;
-                  readIdents = _987_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1028_recursiveGen;
+                  bool _1029_recOwned;
+                  bool _1030_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1031_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out583;
+                  bool _out584;
+                  bool _out585;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out586;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out583, out _out584, out _out585, out _out586);
+                  _1028_recursiveGen = _out583;
+                  _1029_recOwned = _out584;
+                  _1030_recErased = _out585;
+                  _1031_recIdents = _out586;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1028_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1029_recOwned;
+                  isErased = _1030_recErased;
+                  readIdents = _1031_recIdents;
                 }
               } else if (_source40.is_Array) {
-                DAST._IType _988___mcc_h405 = _source40.dtor_element;
+                DAST._IType _1032___mcc_h563 = _source40.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _989_recursiveGen;
-                  bool _990_recOwned;
-                  bool _991_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _992_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out561;
-                  bool _out562;
-                  bool _out563;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out564;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out561, out _out562, out _out563, out _out564);
-                  _989_recursiveGen = _out561;
-                  _990_recOwned = _out562;
-                  _991_recErased = _out563;
-                  _992_recIdents = _out564;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _989_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _990_recOwned;
-                  isErased = _991_recErased;
-                  readIdents = _992_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1033_recursiveGen;
+                  bool _1034_recOwned;
+                  bool _1035_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1036_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out587;
+                  bool _out588;
+                  bool _out589;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out590;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out587, out _out588, out _out589, out _out590);
+                  _1033_recursiveGen = _out587;
+                  _1034_recOwned = _out588;
+                  _1035_recErased = _out589;
+                  _1036_recIdents = _out590;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1033_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1034_recOwned;
+                  isErased = _1035_recErased;
+                  readIdents = _1036_recIdents;
                 }
               } else if (_source40.is_Seq) {
-                DAST._IType _993___mcc_h407 = _source40.dtor_element;
+                DAST._IType _1037___mcc_h565 = _source40.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _994_recursiveGen;
-                  bool _995_recOwned;
-                  bool _996_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _997_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out565;
-                  bool _out566;
-                  bool _out567;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out568;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out565, out _out566, out _out567, out _out568);
-                  _994_recursiveGen = _out565;
-                  _995_recOwned = _out566;
-                  _996_recErased = _out567;
-                  _997_recIdents = _out568;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _994_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _995_recOwned;
-                  isErased = _996_recErased;
-                  readIdents = _997_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1038_recursiveGen;
+                  bool _1039_recOwned;
+                  bool _1040_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1041_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out591;
+                  bool _out592;
+                  bool _out593;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out594;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out591, out _out592, out _out593, out _out594);
+                  _1038_recursiveGen = _out591;
+                  _1039_recOwned = _out592;
+                  _1040_recErased = _out593;
+                  _1041_recIdents = _out594;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1038_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1039_recOwned;
+                  isErased = _1040_recErased;
+                  readIdents = _1041_recIdents;
                 }
               } else if (_source40.is_Set) {
-                DAST._IType _998___mcc_h409 = _source40.dtor_element;
+                DAST._IType _1042___mcc_h567 = _source40.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _999_recursiveGen;
-                  bool _1000_recOwned;
-                  bool _1001_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1002_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out569;
-                  bool _out570;
-                  bool _out571;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out572;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out569, out _out570, out _out571, out _out572);
-                  _999_recursiveGen = _out569;
-                  _1000_recOwned = _out570;
-                  _1001_recErased = _out571;
-                  _1002_recIdents = _out572;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _999_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1000_recOwned;
-                  isErased = _1001_recErased;
-                  readIdents = _1002_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1043_recursiveGen;
+                  bool _1044_recOwned;
+                  bool _1045_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1046_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out595;
+                  bool _out596;
+                  bool _out597;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out598;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out595, out _out596, out _out597, out _out598);
+                  _1043_recursiveGen = _out595;
+                  _1044_recOwned = _out596;
+                  _1045_recErased = _out597;
+                  _1046_recIdents = _out598;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1043_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1044_recOwned;
+                  isErased = _1045_recErased;
+                  readIdents = _1046_recIdents;
                 }
               } else if (_source40.is_Multiset) {
-                DAST._IType _1003___mcc_h411 = _source40.dtor_element;
+                DAST._IType _1047___mcc_h569 = _source40.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1004_recursiveGen;
-                  bool _1005_recOwned;
-                  bool _1006_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1007_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out573;
-                  bool _out574;
-                  bool _out575;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out576;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out573, out _out574, out _out575, out _out576);
-                  _1004_recursiveGen = _out573;
-                  _1005_recOwned = _out574;
-                  _1006_recErased = _out575;
-                  _1007_recIdents = _out576;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1004_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1005_recOwned;
-                  isErased = _1006_recErased;
-                  readIdents = _1007_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1048_recursiveGen;
+                  bool _1049_recOwned;
+                  bool _1050_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1051_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out599;
+                  bool _out600;
+                  bool _out601;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out602;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out599, out _out600, out _out601, out _out602);
+                  _1048_recursiveGen = _out599;
+                  _1049_recOwned = _out600;
+                  _1050_recErased = _out601;
+                  _1051_recIdents = _out602;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1048_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1049_recOwned;
+                  isErased = _1050_recErased;
+                  readIdents = _1051_recIdents;
                 }
               } else if (_source40.is_Map) {
-                DAST._IType _1008___mcc_h413 = _source40.dtor_key;
-                DAST._IType _1009___mcc_h414 = _source40.dtor_value;
+                DAST._IType _1052___mcc_h571 = _source40.dtor_key;
+                DAST._IType _1053___mcc_h572 = _source40.dtor_value;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1010_recursiveGen;
-                  bool _1011_recOwned;
-                  bool _1012_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1013_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out577;
-                  bool _out578;
-                  bool _out579;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out580;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out577, out _out578, out _out579, out _out580);
-                  _1010_recursiveGen = _out577;
-                  _1011_recOwned = _out578;
-                  _1012_recErased = _out579;
-                  _1013_recIdents = _out580;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1010_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1011_recOwned;
-                  isErased = _1012_recErased;
-                  readIdents = _1013_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1054_recursiveGen;
+                  bool _1055_recOwned;
+                  bool _1056_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1057_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out603;
+                  bool _out604;
+                  bool _out605;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out606;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out603, out _out604, out _out605, out _out606);
+                  _1054_recursiveGen = _out603;
+                  _1055_recOwned = _out604;
+                  _1056_recErased = _out605;
+                  _1057_recIdents = _out606;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1054_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1055_recOwned;
+                  isErased = _1056_recErased;
+                  readIdents = _1057_recIdents;
                 }
               } else if (_source40.is_Arrow) {
-                Dafny.ISequence<DAST._IType> _1014___mcc_h417 = _source40.dtor_args;
-                DAST._IType _1015___mcc_h418 = _source40.dtor_result;
+                Dafny.ISequence<DAST._IType> _1058___mcc_h575 = _source40.dtor_args;
+                DAST._IType _1059___mcc_h576 = _source40.dtor_result;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1016_recursiveGen;
-                  bool _1017_recOwned;
-                  bool _1018_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1019_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out581;
-                  bool _out582;
-                  bool _out583;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out584;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out581, out _out582, out _out583, out _out584);
-                  _1016_recursiveGen = _out581;
-                  _1017_recOwned = _out582;
-                  _1018_recErased = _out583;
-                  _1019_recIdents = _out584;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1016_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1017_recOwned;
-                  isErased = _1018_recErased;
-                  readIdents = _1019_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1060_recursiveGen;
+                  bool _1061_recOwned;
+                  bool _1062_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1063_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out607;
+                  bool _out608;
+                  bool _out609;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out610;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out607, out _out608, out _out609, out _out610);
+                  _1060_recursiveGen = _out607;
+                  _1061_recOwned = _out608;
+                  _1062_recErased = _out609;
+                  _1063_recIdents = _out610;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1060_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1061_recOwned;
+                  isErased = _1062_recErased;
+                  readIdents = _1063_recIdents;
                 }
               } else if (_source40.is_Primitive) {
-                DAST._IPrimitive _1020___mcc_h421 = _source40.dtor_Primitive_a0;
+                DAST._IPrimitive _1064___mcc_h579 = _source40.dtor_Primitive_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1021_recursiveGen;
-                  bool _1022_recOwned;
-                  bool _1023_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1024_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out585;
-                  bool _out586;
-                  bool _out587;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out588;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out585, out _out586, out _out587, out _out588);
-                  _1021_recursiveGen = _out585;
-                  _1022_recOwned = _out586;
-                  _1023_recErased = _out587;
-                  _1024_recIdents = _out588;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1021_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1022_recOwned;
-                  isErased = _1023_recErased;
-                  readIdents = _1024_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1065_recursiveGen;
+                  bool _1066_recOwned;
+                  bool _1067_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1068_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out611;
+                  bool _out612;
+                  bool _out613;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out614;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out611, out _out612, out _out613, out _out614);
+                  _1065_recursiveGen = _out611;
+                  _1066_recOwned = _out612;
+                  _1067_recErased = _out613;
+                  _1068_recIdents = _out614;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1065_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1066_recOwned;
+                  isErased = _1067_recErased;
+                  readIdents = _1068_recIdents;
                 }
               } else if (_source40.is_Passthrough) {
-                Dafny.ISequence<Dafny.Rune> _1025___mcc_h423 = _source40.dtor_Passthrough_a0;
+                Dafny.ISequence<Dafny.Rune> _1069___mcc_h581 = _source40.dtor_Passthrough_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1026_recursiveGen;
-                  bool _1027_recOwned;
-                  bool _1028_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1029_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out589;
-                  bool _out590;
-                  bool _out591;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out592;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out589, out _out590, out _out591, out _out592);
-                  _1026_recursiveGen = _out589;
-                  _1027_recOwned = _out590;
-                  _1028_recErased = _out591;
-                  _1029_recIdents = _out592;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1026_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1027_recOwned;
-                  isErased = _1028_recErased;
-                  readIdents = _1029_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1070_recursiveGen;
+                  bool _1071_recOwned;
+                  bool _1072_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1073_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out615;
+                  bool _out616;
+                  bool _out617;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out618;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out615, out _out616, out _out617, out _out618);
+                  _1070_recursiveGen = _out615;
+                  _1071_recOwned = _out616;
+                  _1072_recErased = _out617;
+                  _1073_recIdents = _out618;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1070_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1071_recOwned;
+                  isErased = _1072_recErased;
+                  readIdents = _1073_recIdents;
                 }
               } else {
-                Dafny.ISequence<Dafny.Rune> _1030___mcc_h425 = _source40.dtor_TypeArg_a0;
+                Dafny.ISequence<Dafny.Rune> _1074___mcc_h583 = _source40.dtor_TypeArg_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1031_recursiveGen;
-                  bool _1032_recOwned;
-                  bool _1033_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1034_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out593;
-                  bool _out594;
-                  bool _out595;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out596;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out593, out _out594, out _out595, out _out596);
-                  _1031_recursiveGen = _out593;
-                  _1032_recOwned = _out594;
-                  _1033_recErased = _out595;
-                  _1034_recIdents = _out596;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1031_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1032_recOwned;
-                  isErased = _1033_recErased;
-                  readIdents = _1034_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1075_recursiveGen;
+                  bool _1076_recOwned;
+                  bool _1077_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1078_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out619;
+                  bool _out620;
+                  bool _out621;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out622;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out619, out _out620, out _out621, out _out622);
+                  _1075_recursiveGen = _out619;
+                  _1076_recOwned = _out620;
+                  _1077_recErased = _out621;
+                  _1078_recIdents = _out622;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1075_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1076_recOwned;
+                  isErased = _1077_recErased;
+                  readIdents = _1078_recIdents;
                 }
               }
-            } else if (_source26.is_Multiset) {
-              DAST._IType _1035___mcc_h427 = _source26.dtor_element;
-              DAST._IType _source42 = _489___mcc_h124;
+            } else if (_source26.is_Set) {
+              DAST._IType _1079___mcc_h585 = _source26.dtor_element;
+              DAST._IType _source42 = _501___mcc_h238;
               if (_source42.is_Path) {
-                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1036___mcc_h430 = _source42.dtor_Path_a0;
-                Dafny.ISequence<DAST._IType> _1037___mcc_h431 = _source42.dtor_typeArgs;
-                DAST._IResolvedType _1038___mcc_h432 = _source42.dtor_resolved;
-                DAST._IResolvedType _source43 = _1038___mcc_h432;
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1080___mcc_h589 = _source42.dtor_Path_a0;
+                Dafny.ISequence<DAST._IType> _1081___mcc_h590 = _source42.dtor_typeArgs;
+                DAST._IResolvedType _1082___mcc_h591 = _source42.dtor_resolved;
+                DAST._IResolvedType _source43 = _1082___mcc_h591;
                 if (_source43.is_Datatype) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1039___mcc_h436 = _source43.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1083___mcc_h595 = _source43.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1040_recursiveGen;
-                    bool _1041_recOwned;
-                    bool _1042_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1043_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out597;
-                    bool _out598;
-                    bool _out599;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out600;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out597, out _out598, out _out599, out _out600);
-                    _1040_recursiveGen = _out597;
-                    _1041_recOwned = _out598;
-                    _1042_recErased = _out599;
-                    _1043_recIdents = _out600;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1040_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1041_recOwned;
-                    isErased = _1042_recErased;
-                    readIdents = _1043_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1084_recursiveGen;
+                    bool _1085_recOwned;
+                    bool _1086_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1087_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out623;
+                    bool _out624;
+                    bool _out625;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out626;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out623, out _out624, out _out625, out _out626);
+                    _1084_recursiveGen = _out623;
+                    _1085_recOwned = _out624;
+                    _1086_recErased = _out625;
+                    _1087_recIdents = _out626;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1084_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1085_recOwned;
+                    isErased = _1086_recErased;
+                    readIdents = _1087_recIdents;
                   }
                 } else if (_source43.is_Trait) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1044___mcc_h438 = _source43.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1088___mcc_h597 = _source43.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1045_recursiveGen;
-                    bool _1046_recOwned;
-                    bool _1047_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1048_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out601;
-                    bool _out602;
-                    bool _out603;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out604;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out601, out _out602, out _out603, out _out604);
-                    _1045_recursiveGen = _out601;
-                    _1046_recOwned = _out602;
-                    _1047_recErased = _out603;
-                    _1048_recIdents = _out604;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1045_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1046_recOwned;
-                    isErased = _1047_recErased;
-                    readIdents = _1048_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1089_recursiveGen;
+                    bool _1090_recOwned;
+                    bool _1091_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1092_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out627;
+                    bool _out628;
+                    bool _out629;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out630;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out627, out _out628, out _out629, out _out630);
+                    _1089_recursiveGen = _out627;
+                    _1090_recOwned = _out628;
+                    _1091_recErased = _out629;
+                    _1092_recIdents = _out630;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1089_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1090_recOwned;
+                    isErased = _1091_recErased;
+                    readIdents = _1092_recIdents;
                   }
                 } else {
-                  DAST._IType _1049___mcc_h440 = _source43.dtor_Newtype_a0;
-                  DAST._IType _1050_b = _1049___mcc_h440;
+                  DAST._IType _1093___mcc_h599 = _source43.dtor_Newtype_a0;
+                  DAST._IType _1094_b = _1093___mcc_h599;
                   {
-                    if (object.Equals(_482_fromTpe, _1050_b)) {
-                      Dafny.ISequence<Dafny.Rune> _1051_recursiveGen;
-                      bool _1052_recOwned;
-                      bool _1053_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1054_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out605;
-                      bool _out606;
-                      bool _out607;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out608;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out605, out _out606, out _out607, out _out608);
-                      _1051_recursiveGen = _out605;
-                      _1052_recOwned = _out606;
-                      _1053_recErased = _out607;
-                      _1054_recIdents = _out608;
-                      Dafny.ISequence<Dafny.Rune> _1055_rhsType;
-                      Dafny.ISequence<Dafny.Rune> _out609;
-                      _out609 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                      _1055_rhsType = _out609;
-                      Dafny.ISequence<Dafny.Rune> _1056_uneraseFn;
-                      _1056_uneraseFn = ((_1052_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1055_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1056_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1051_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _1052_recOwned;
+                    if (object.Equals(_494_fromTpe, _1094_b)) {
+                      Dafny.ISequence<Dafny.Rune> _1095_recursiveGen;
+                      bool _1096_recOwned;
+                      bool _1097_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1098_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out631;
+                      bool _out632;
+                      bool _out633;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out634;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out631, out _out632, out _out633, out _out634);
+                      _1095_recursiveGen = _out631;
+                      _1096_recOwned = _out632;
+                      _1097_recErased = _out633;
+                      _1098_recIdents = _out634;
+                      Dafny.ISequence<Dafny.Rune> _1099_rhsType;
+                      Dafny.ISequence<Dafny.Rune> _out635;
+                      _out635 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                      _1099_rhsType = _out635;
+                      Dafny.ISequence<Dafny.Rune> _1100_uneraseFn;
+                      _1100_uneraseFn = ((_1096_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1099_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1100_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1095_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _1096_recOwned;
                       isErased = false;
-                      readIdents = _1054_recIdents;
+                      readIdents = _1098_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out610;
-                      bool _out611;
-                      bool _out612;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out613;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _1050_b), _1050_b, _481_toTpe), @params, mustOwn, out _out610, out _out611, out _out612, out _out613);
-                      s = _out610;
-                      isOwned = _out611;
-                      isErased = _out612;
-                      readIdents = _out613;
+                      Dafny.ISequence<Dafny.Rune> _out636;
+                      bool _out637;
+                      bool _out638;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out639;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1094_b), _1094_b, _493_toTpe), selfIdent, @params, mustOwn, out _out636, out _out637, out _out638, out _out639);
+                      s = _out636;
+                      isOwned = _out637;
+                      isErased = _out638;
+                      readIdents = _out639;
                     }
                   }
                 }
+              } else if (_source42.is_Nullable) {
+                DAST._IType _1101___mcc_h601 = _source42.dtor_Nullable_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1102_recursiveGen;
+                  bool _1103_recOwned;
+                  bool _1104_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1105_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out640;
+                  bool _out641;
+                  bool _out642;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out643;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out640, out _out641, out _out642, out _out643);
+                  _1102_recursiveGen = _out640;
+                  _1103_recOwned = _out641;
+                  _1104_recErased = _out642;
+                  _1105_recIdents = _out643;
+                  if (!(_1103_recOwned)) {
+                    _1102_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1102_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1102_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                  isOwned = true;
+                  isErased = _1104_recErased;
+                  readIdents = _1105_recIdents;
+                }
               } else if (_source42.is_Tuple) {
-                Dafny.ISequence<DAST._IType> _1057___mcc_h442 = _source42.dtor_Tuple_a0;
+                Dafny.ISequence<DAST._IType> _1106___mcc_h603 = _source42.dtor_Tuple_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1058_recursiveGen;
-                  bool _1059_recOwned;
-                  bool _1060_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1061_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out614;
-                  bool _out615;
-                  bool _out616;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out617;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out614, out _out615, out _out616, out _out617);
-                  _1058_recursiveGen = _out614;
-                  _1059_recOwned = _out615;
-                  _1060_recErased = _out616;
-                  _1061_recIdents = _out617;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1058_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1059_recOwned;
-                  isErased = _1060_recErased;
-                  readIdents = _1061_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1107_recursiveGen;
+                  bool _1108_recOwned;
+                  bool _1109_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1110_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out644;
+                  bool _out645;
+                  bool _out646;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out647;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out644, out _out645, out _out646, out _out647);
+                  _1107_recursiveGen = _out644;
+                  _1108_recOwned = _out645;
+                  _1109_recErased = _out646;
+                  _1110_recIdents = _out647;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1107_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1108_recOwned;
+                  isErased = _1109_recErased;
+                  readIdents = _1110_recIdents;
                 }
               } else if (_source42.is_Array) {
-                DAST._IType _1062___mcc_h444 = _source42.dtor_element;
+                DAST._IType _1111___mcc_h605 = _source42.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1063_recursiveGen;
-                  bool _1064_recOwned;
-                  bool _1065_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1066_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out618;
-                  bool _out619;
-                  bool _out620;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out621;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out618, out _out619, out _out620, out _out621);
-                  _1063_recursiveGen = _out618;
-                  _1064_recOwned = _out619;
-                  _1065_recErased = _out620;
-                  _1066_recIdents = _out621;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1063_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1064_recOwned;
-                  isErased = _1065_recErased;
-                  readIdents = _1066_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1112_recursiveGen;
+                  bool _1113_recOwned;
+                  bool _1114_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1115_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out648;
+                  bool _out649;
+                  bool _out650;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out651;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out648, out _out649, out _out650, out _out651);
+                  _1112_recursiveGen = _out648;
+                  _1113_recOwned = _out649;
+                  _1114_recErased = _out650;
+                  _1115_recIdents = _out651;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1112_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1113_recOwned;
+                  isErased = _1114_recErased;
+                  readIdents = _1115_recIdents;
                 }
               } else if (_source42.is_Seq) {
-                DAST._IType _1067___mcc_h446 = _source42.dtor_element;
+                DAST._IType _1116___mcc_h607 = _source42.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1068_recursiveGen;
-                  bool _1069_recOwned;
-                  bool _1070_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1071_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out622;
-                  bool _out623;
-                  bool _out624;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out625;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out622, out _out623, out _out624, out _out625);
-                  _1068_recursiveGen = _out622;
-                  _1069_recOwned = _out623;
-                  _1070_recErased = _out624;
-                  _1071_recIdents = _out625;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1068_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1069_recOwned;
-                  isErased = _1070_recErased;
-                  readIdents = _1071_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1117_recursiveGen;
+                  bool _1118_recOwned;
+                  bool _1119_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1120_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out652;
+                  bool _out653;
+                  bool _out654;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out655;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out652, out _out653, out _out654, out _out655);
+                  _1117_recursiveGen = _out652;
+                  _1118_recOwned = _out653;
+                  _1119_recErased = _out654;
+                  _1120_recIdents = _out655;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1117_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1118_recOwned;
+                  isErased = _1119_recErased;
+                  readIdents = _1120_recIdents;
                 }
               } else if (_source42.is_Set) {
-                DAST._IType _1072___mcc_h448 = _source42.dtor_element;
+                DAST._IType _1121___mcc_h609 = _source42.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1073_recursiveGen;
-                  bool _1074_recOwned;
-                  bool _1075_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1076_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out626;
-                  bool _out627;
-                  bool _out628;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out629;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out626, out _out627, out _out628, out _out629);
-                  _1073_recursiveGen = _out626;
-                  _1074_recOwned = _out627;
-                  _1075_recErased = _out628;
-                  _1076_recIdents = _out629;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1073_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1074_recOwned;
-                  isErased = _1075_recErased;
-                  readIdents = _1076_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1122_recursiveGen;
+                  bool _1123_recOwned;
+                  bool _1124_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1125_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out656;
+                  bool _out657;
+                  bool _out658;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out659;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out656, out _out657, out _out658, out _out659);
+                  _1122_recursiveGen = _out656;
+                  _1123_recOwned = _out657;
+                  _1124_recErased = _out658;
+                  _1125_recIdents = _out659;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1122_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1123_recOwned;
+                  isErased = _1124_recErased;
+                  readIdents = _1125_recIdents;
                 }
               } else if (_source42.is_Multiset) {
-                DAST._IType _1077___mcc_h450 = _source42.dtor_element;
+                DAST._IType _1126___mcc_h611 = _source42.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1078_recursiveGen;
-                  bool _1079_recOwned;
-                  bool _1080_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1081_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out630;
-                  bool _out631;
-                  bool _out632;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out633;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out630, out _out631, out _out632, out _out633);
-                  _1078_recursiveGen = _out630;
-                  _1079_recOwned = _out631;
-                  _1080_recErased = _out632;
-                  _1081_recIdents = _out633;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1078_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1079_recOwned;
-                  isErased = _1080_recErased;
-                  readIdents = _1081_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1127_recursiveGen;
+                  bool _1128_recOwned;
+                  bool _1129_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1130_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out660;
+                  bool _out661;
+                  bool _out662;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out663;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out660, out _out661, out _out662, out _out663);
+                  _1127_recursiveGen = _out660;
+                  _1128_recOwned = _out661;
+                  _1129_recErased = _out662;
+                  _1130_recIdents = _out663;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1127_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1128_recOwned;
+                  isErased = _1129_recErased;
+                  readIdents = _1130_recIdents;
                 }
               } else if (_source42.is_Map) {
-                DAST._IType _1082___mcc_h452 = _source42.dtor_key;
-                DAST._IType _1083___mcc_h453 = _source42.dtor_value;
+                DAST._IType _1131___mcc_h613 = _source42.dtor_key;
+                DAST._IType _1132___mcc_h614 = _source42.dtor_value;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1084_recursiveGen;
-                  bool _1085_recOwned;
-                  bool _1086_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1087_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out634;
-                  bool _out635;
-                  bool _out636;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out637;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out634, out _out635, out _out636, out _out637);
-                  _1084_recursiveGen = _out634;
-                  _1085_recOwned = _out635;
-                  _1086_recErased = _out636;
-                  _1087_recIdents = _out637;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1084_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1085_recOwned;
-                  isErased = _1086_recErased;
-                  readIdents = _1087_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1133_recursiveGen;
+                  bool _1134_recOwned;
+                  bool _1135_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1136_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out664;
+                  bool _out665;
+                  bool _out666;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out667;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out664, out _out665, out _out666, out _out667);
+                  _1133_recursiveGen = _out664;
+                  _1134_recOwned = _out665;
+                  _1135_recErased = _out666;
+                  _1136_recIdents = _out667;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1133_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1134_recOwned;
+                  isErased = _1135_recErased;
+                  readIdents = _1136_recIdents;
                 }
               } else if (_source42.is_Arrow) {
-                Dafny.ISequence<DAST._IType> _1088___mcc_h456 = _source42.dtor_args;
-                DAST._IType _1089___mcc_h457 = _source42.dtor_result;
+                Dafny.ISequence<DAST._IType> _1137___mcc_h617 = _source42.dtor_args;
+                DAST._IType _1138___mcc_h618 = _source42.dtor_result;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1090_recursiveGen;
-                  bool _1091_recOwned;
-                  bool _1092_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1093_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out638;
-                  bool _out639;
-                  bool _out640;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out641;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out638, out _out639, out _out640, out _out641);
-                  _1090_recursiveGen = _out638;
-                  _1091_recOwned = _out639;
-                  _1092_recErased = _out640;
-                  _1093_recIdents = _out641;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1090_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1091_recOwned;
-                  isErased = _1092_recErased;
-                  readIdents = _1093_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1139_recursiveGen;
+                  bool _1140_recOwned;
+                  bool _1141_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1142_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out668;
+                  bool _out669;
+                  bool _out670;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out671;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out668, out _out669, out _out670, out _out671);
+                  _1139_recursiveGen = _out668;
+                  _1140_recOwned = _out669;
+                  _1141_recErased = _out670;
+                  _1142_recIdents = _out671;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1139_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1140_recOwned;
+                  isErased = _1141_recErased;
+                  readIdents = _1142_recIdents;
                 }
               } else if (_source42.is_Primitive) {
-                DAST._IPrimitive _1094___mcc_h460 = _source42.dtor_Primitive_a0;
+                DAST._IPrimitive _1143___mcc_h621 = _source42.dtor_Primitive_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1095_recursiveGen;
-                  bool _1096_recOwned;
-                  bool _1097_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1098_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out642;
-                  bool _out643;
-                  bool _out644;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out645;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out642, out _out643, out _out644, out _out645);
-                  _1095_recursiveGen = _out642;
-                  _1096_recOwned = _out643;
-                  _1097_recErased = _out644;
-                  _1098_recIdents = _out645;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1095_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1096_recOwned;
-                  isErased = _1097_recErased;
-                  readIdents = _1098_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1144_recursiveGen;
+                  bool _1145_recOwned;
+                  bool _1146_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1147_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out672;
+                  bool _out673;
+                  bool _out674;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out675;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out672, out _out673, out _out674, out _out675);
+                  _1144_recursiveGen = _out672;
+                  _1145_recOwned = _out673;
+                  _1146_recErased = _out674;
+                  _1147_recIdents = _out675;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1144_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1145_recOwned;
+                  isErased = _1146_recErased;
+                  readIdents = _1147_recIdents;
                 }
               } else if (_source42.is_Passthrough) {
-                Dafny.ISequence<Dafny.Rune> _1099___mcc_h462 = _source42.dtor_Passthrough_a0;
+                Dafny.ISequence<Dafny.Rune> _1148___mcc_h623 = _source42.dtor_Passthrough_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1100_recursiveGen;
-                  bool _1101_recOwned;
-                  bool _1102_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1103_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out646;
-                  bool _out647;
-                  bool _out648;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out649;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out646, out _out647, out _out648, out _out649);
-                  _1100_recursiveGen = _out646;
-                  _1101_recOwned = _out647;
-                  _1102_recErased = _out648;
-                  _1103_recIdents = _out649;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1100_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1101_recOwned;
-                  isErased = _1102_recErased;
-                  readIdents = _1103_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1149_recursiveGen;
+                  bool _1150_recOwned;
+                  bool _1151_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1152_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out676;
+                  bool _out677;
+                  bool _out678;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out679;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out676, out _out677, out _out678, out _out679);
+                  _1149_recursiveGen = _out676;
+                  _1150_recOwned = _out677;
+                  _1151_recErased = _out678;
+                  _1152_recIdents = _out679;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1149_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1150_recOwned;
+                  isErased = _1151_recErased;
+                  readIdents = _1152_recIdents;
                 }
               } else {
-                Dafny.ISequence<Dafny.Rune> _1104___mcc_h464 = _source42.dtor_TypeArg_a0;
+                Dafny.ISequence<Dafny.Rune> _1153___mcc_h625 = _source42.dtor_TypeArg_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1105_recursiveGen;
-                  bool _1106_recOwned;
-                  bool _1107_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1108_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out650;
-                  bool _out651;
-                  bool _out652;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out653;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out650, out _out651, out _out652, out _out653);
-                  _1105_recursiveGen = _out650;
-                  _1106_recOwned = _out651;
-                  _1107_recErased = _out652;
-                  _1108_recIdents = _out653;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1105_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1106_recOwned;
-                  isErased = _1107_recErased;
-                  readIdents = _1108_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1154_recursiveGen;
+                  bool _1155_recOwned;
+                  bool _1156_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1157_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out680;
+                  bool _out681;
+                  bool _out682;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out683;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out680, out _out681, out _out682, out _out683);
+                  _1154_recursiveGen = _out680;
+                  _1155_recOwned = _out681;
+                  _1156_recErased = _out682;
+                  _1157_recIdents = _out683;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1154_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1155_recOwned;
+                  isErased = _1156_recErased;
+                  readIdents = _1157_recIdents;
                 }
               }
-            } else if (_source26.is_Map) {
-              DAST._IType _1109___mcc_h466 = _source26.dtor_key;
-              DAST._IType _1110___mcc_h467 = _source26.dtor_value;
-              DAST._IType _source44 = _489___mcc_h124;
+            } else if (_source26.is_Multiset) {
+              DAST._IType _1158___mcc_h627 = _source26.dtor_element;
+              DAST._IType _source44 = _501___mcc_h238;
               if (_source44.is_Path) {
-                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1111___mcc_h472 = _source44.dtor_Path_a0;
-                Dafny.ISequence<DAST._IType> _1112___mcc_h473 = _source44.dtor_typeArgs;
-                DAST._IResolvedType _1113___mcc_h474 = _source44.dtor_resolved;
-                DAST._IResolvedType _source45 = _1113___mcc_h474;
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1159___mcc_h631 = _source44.dtor_Path_a0;
+                Dafny.ISequence<DAST._IType> _1160___mcc_h632 = _source44.dtor_typeArgs;
+                DAST._IResolvedType _1161___mcc_h633 = _source44.dtor_resolved;
+                DAST._IResolvedType _source45 = _1161___mcc_h633;
                 if (_source45.is_Datatype) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1114___mcc_h478 = _source45.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1162___mcc_h637 = _source45.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1115_recursiveGen;
-                    bool _1116_recOwned;
-                    bool _1117_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1118_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out654;
-                    bool _out655;
-                    bool _out656;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out657;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out654, out _out655, out _out656, out _out657);
-                    _1115_recursiveGen = _out654;
-                    _1116_recOwned = _out655;
-                    _1117_recErased = _out656;
-                    _1118_recIdents = _out657;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1115_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1116_recOwned;
-                    isErased = _1117_recErased;
-                    readIdents = _1118_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1163_recursiveGen;
+                    bool _1164_recOwned;
+                    bool _1165_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1166_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out684;
+                    bool _out685;
+                    bool _out686;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out687;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out684, out _out685, out _out686, out _out687);
+                    _1163_recursiveGen = _out684;
+                    _1164_recOwned = _out685;
+                    _1165_recErased = _out686;
+                    _1166_recIdents = _out687;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1163_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1164_recOwned;
+                    isErased = _1165_recErased;
+                    readIdents = _1166_recIdents;
                   }
                 } else if (_source45.is_Trait) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1119___mcc_h480 = _source45.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1167___mcc_h639 = _source45.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1120_recursiveGen;
-                    bool _1121_recOwned;
-                    bool _1122_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1123_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out658;
-                    bool _out659;
-                    bool _out660;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out661;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out658, out _out659, out _out660, out _out661);
-                    _1120_recursiveGen = _out658;
-                    _1121_recOwned = _out659;
-                    _1122_recErased = _out660;
-                    _1123_recIdents = _out661;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1120_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1121_recOwned;
-                    isErased = _1122_recErased;
-                    readIdents = _1123_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1168_recursiveGen;
+                    bool _1169_recOwned;
+                    bool _1170_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1171_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out688;
+                    bool _out689;
+                    bool _out690;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out691;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out688, out _out689, out _out690, out _out691);
+                    _1168_recursiveGen = _out688;
+                    _1169_recOwned = _out689;
+                    _1170_recErased = _out690;
+                    _1171_recIdents = _out691;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1168_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1169_recOwned;
+                    isErased = _1170_recErased;
+                    readIdents = _1171_recIdents;
                   }
                 } else {
-                  DAST._IType _1124___mcc_h482 = _source45.dtor_Newtype_a0;
-                  DAST._IType _1125_b = _1124___mcc_h482;
+                  DAST._IType _1172___mcc_h641 = _source45.dtor_Newtype_a0;
+                  DAST._IType _1173_b = _1172___mcc_h641;
                   {
-                    if (object.Equals(_482_fromTpe, _1125_b)) {
-                      Dafny.ISequence<Dafny.Rune> _1126_recursiveGen;
-                      bool _1127_recOwned;
-                      bool _1128_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1129_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out662;
-                      bool _out663;
-                      bool _out664;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out665;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out662, out _out663, out _out664, out _out665);
-                      _1126_recursiveGen = _out662;
-                      _1127_recOwned = _out663;
-                      _1128_recErased = _out664;
-                      _1129_recIdents = _out665;
-                      Dafny.ISequence<Dafny.Rune> _1130_rhsType;
-                      Dafny.ISequence<Dafny.Rune> _out666;
-                      _out666 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                      _1130_rhsType = _out666;
-                      Dafny.ISequence<Dafny.Rune> _1131_uneraseFn;
-                      _1131_uneraseFn = ((_1127_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1130_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1131_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1126_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _1127_recOwned;
+                    if (object.Equals(_494_fromTpe, _1173_b)) {
+                      Dafny.ISequence<Dafny.Rune> _1174_recursiveGen;
+                      bool _1175_recOwned;
+                      bool _1176_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1177_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out692;
+                      bool _out693;
+                      bool _out694;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out695;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out692, out _out693, out _out694, out _out695);
+                      _1174_recursiveGen = _out692;
+                      _1175_recOwned = _out693;
+                      _1176_recErased = _out694;
+                      _1177_recIdents = _out695;
+                      Dafny.ISequence<Dafny.Rune> _1178_rhsType;
+                      Dafny.ISequence<Dafny.Rune> _out696;
+                      _out696 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                      _1178_rhsType = _out696;
+                      Dafny.ISequence<Dafny.Rune> _1179_uneraseFn;
+                      _1179_uneraseFn = ((_1175_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1178_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1179_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1174_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _1175_recOwned;
                       isErased = false;
-                      readIdents = _1129_recIdents;
+                      readIdents = _1177_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out667;
-                      bool _out668;
-                      bool _out669;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out670;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _1125_b), _1125_b, _481_toTpe), @params, mustOwn, out _out667, out _out668, out _out669, out _out670);
-                      s = _out667;
-                      isOwned = _out668;
-                      isErased = _out669;
-                      readIdents = _out670;
+                      Dafny.ISequence<Dafny.Rune> _out697;
+                      bool _out698;
+                      bool _out699;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out700;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1173_b), _1173_b, _493_toTpe), selfIdent, @params, mustOwn, out _out697, out _out698, out _out699, out _out700);
+                      s = _out697;
+                      isOwned = _out698;
+                      isErased = _out699;
+                      readIdents = _out700;
                     }
                   }
                 }
+              } else if (_source44.is_Nullable) {
+                DAST._IType _1180___mcc_h643 = _source44.dtor_Nullable_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1181_recursiveGen;
+                  bool _1182_recOwned;
+                  bool _1183_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1184_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out701;
+                  bool _out702;
+                  bool _out703;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out704;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out701, out _out702, out _out703, out _out704);
+                  _1181_recursiveGen = _out701;
+                  _1182_recOwned = _out702;
+                  _1183_recErased = _out703;
+                  _1184_recIdents = _out704;
+                  if (!(_1182_recOwned)) {
+                    _1181_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1181_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1181_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                  isOwned = true;
+                  isErased = _1183_recErased;
+                  readIdents = _1184_recIdents;
+                }
               } else if (_source44.is_Tuple) {
-                Dafny.ISequence<DAST._IType> _1132___mcc_h484 = _source44.dtor_Tuple_a0;
+                Dafny.ISequence<DAST._IType> _1185___mcc_h645 = _source44.dtor_Tuple_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1133_recursiveGen;
-                  bool _1134_recOwned;
-                  bool _1135_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1136_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out671;
-                  bool _out672;
-                  bool _out673;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out674;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out671, out _out672, out _out673, out _out674);
-                  _1133_recursiveGen = _out671;
-                  _1134_recOwned = _out672;
-                  _1135_recErased = _out673;
-                  _1136_recIdents = _out674;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1133_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1134_recOwned;
-                  isErased = _1135_recErased;
-                  readIdents = _1136_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1186_recursiveGen;
+                  bool _1187_recOwned;
+                  bool _1188_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1189_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out705;
+                  bool _out706;
+                  bool _out707;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out708;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out705, out _out706, out _out707, out _out708);
+                  _1186_recursiveGen = _out705;
+                  _1187_recOwned = _out706;
+                  _1188_recErased = _out707;
+                  _1189_recIdents = _out708;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1186_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1187_recOwned;
+                  isErased = _1188_recErased;
+                  readIdents = _1189_recIdents;
                 }
               } else if (_source44.is_Array) {
-                DAST._IType _1137___mcc_h486 = _source44.dtor_element;
+                DAST._IType _1190___mcc_h647 = _source44.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1138_recursiveGen;
-                  bool _1139_recOwned;
-                  bool _1140_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1141_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out675;
-                  bool _out676;
-                  bool _out677;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out678;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out675, out _out676, out _out677, out _out678);
-                  _1138_recursiveGen = _out675;
-                  _1139_recOwned = _out676;
-                  _1140_recErased = _out677;
-                  _1141_recIdents = _out678;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1138_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1139_recOwned;
-                  isErased = _1140_recErased;
-                  readIdents = _1141_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1191_recursiveGen;
+                  bool _1192_recOwned;
+                  bool _1193_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1194_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out709;
+                  bool _out710;
+                  bool _out711;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out712;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out709, out _out710, out _out711, out _out712);
+                  _1191_recursiveGen = _out709;
+                  _1192_recOwned = _out710;
+                  _1193_recErased = _out711;
+                  _1194_recIdents = _out712;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1191_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1192_recOwned;
+                  isErased = _1193_recErased;
+                  readIdents = _1194_recIdents;
                 }
               } else if (_source44.is_Seq) {
-                DAST._IType _1142___mcc_h488 = _source44.dtor_element;
+                DAST._IType _1195___mcc_h649 = _source44.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1143_recursiveGen;
-                  bool _1144_recOwned;
-                  bool _1145_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1146_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out679;
-                  bool _out680;
-                  bool _out681;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out682;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out679, out _out680, out _out681, out _out682);
-                  _1143_recursiveGen = _out679;
-                  _1144_recOwned = _out680;
-                  _1145_recErased = _out681;
-                  _1146_recIdents = _out682;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1143_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1144_recOwned;
-                  isErased = _1145_recErased;
-                  readIdents = _1146_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1196_recursiveGen;
+                  bool _1197_recOwned;
+                  bool _1198_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1199_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out713;
+                  bool _out714;
+                  bool _out715;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out716;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out713, out _out714, out _out715, out _out716);
+                  _1196_recursiveGen = _out713;
+                  _1197_recOwned = _out714;
+                  _1198_recErased = _out715;
+                  _1199_recIdents = _out716;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1196_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1197_recOwned;
+                  isErased = _1198_recErased;
+                  readIdents = _1199_recIdents;
                 }
               } else if (_source44.is_Set) {
-                DAST._IType _1147___mcc_h490 = _source44.dtor_element;
+                DAST._IType _1200___mcc_h651 = _source44.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1148_recursiveGen;
-                  bool _1149_recOwned;
-                  bool _1150_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1151_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out683;
-                  bool _out684;
-                  bool _out685;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out686;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out683, out _out684, out _out685, out _out686);
-                  _1148_recursiveGen = _out683;
-                  _1149_recOwned = _out684;
-                  _1150_recErased = _out685;
-                  _1151_recIdents = _out686;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1148_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1149_recOwned;
-                  isErased = _1150_recErased;
-                  readIdents = _1151_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1201_recursiveGen;
+                  bool _1202_recOwned;
+                  bool _1203_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1204_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out717;
+                  bool _out718;
+                  bool _out719;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out720;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out717, out _out718, out _out719, out _out720);
+                  _1201_recursiveGen = _out717;
+                  _1202_recOwned = _out718;
+                  _1203_recErased = _out719;
+                  _1204_recIdents = _out720;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1201_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1202_recOwned;
+                  isErased = _1203_recErased;
+                  readIdents = _1204_recIdents;
                 }
               } else if (_source44.is_Multiset) {
-                DAST._IType _1152___mcc_h492 = _source44.dtor_element;
+                DAST._IType _1205___mcc_h653 = _source44.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1153_recursiveGen;
-                  bool _1154_recOwned;
-                  bool _1155_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1156_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out687;
-                  bool _out688;
-                  bool _out689;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out690;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out687, out _out688, out _out689, out _out690);
-                  _1153_recursiveGen = _out687;
-                  _1154_recOwned = _out688;
-                  _1155_recErased = _out689;
-                  _1156_recIdents = _out690;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1153_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1154_recOwned;
-                  isErased = _1155_recErased;
-                  readIdents = _1156_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1206_recursiveGen;
+                  bool _1207_recOwned;
+                  bool _1208_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1209_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out721;
+                  bool _out722;
+                  bool _out723;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out724;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out721, out _out722, out _out723, out _out724);
+                  _1206_recursiveGen = _out721;
+                  _1207_recOwned = _out722;
+                  _1208_recErased = _out723;
+                  _1209_recIdents = _out724;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1206_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1207_recOwned;
+                  isErased = _1208_recErased;
+                  readIdents = _1209_recIdents;
                 }
               } else if (_source44.is_Map) {
-                DAST._IType _1157___mcc_h494 = _source44.dtor_key;
-                DAST._IType _1158___mcc_h495 = _source44.dtor_value;
+                DAST._IType _1210___mcc_h655 = _source44.dtor_key;
+                DAST._IType _1211___mcc_h656 = _source44.dtor_value;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1159_recursiveGen;
-                  bool _1160_recOwned;
-                  bool _1161_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1162_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out691;
-                  bool _out692;
-                  bool _out693;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out694;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out691, out _out692, out _out693, out _out694);
-                  _1159_recursiveGen = _out691;
-                  _1160_recOwned = _out692;
-                  _1161_recErased = _out693;
-                  _1162_recIdents = _out694;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1159_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1160_recOwned;
-                  isErased = _1161_recErased;
-                  readIdents = _1162_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1212_recursiveGen;
+                  bool _1213_recOwned;
+                  bool _1214_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1215_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out725;
+                  bool _out726;
+                  bool _out727;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out728;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out725, out _out726, out _out727, out _out728);
+                  _1212_recursiveGen = _out725;
+                  _1213_recOwned = _out726;
+                  _1214_recErased = _out727;
+                  _1215_recIdents = _out728;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1212_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1213_recOwned;
+                  isErased = _1214_recErased;
+                  readIdents = _1215_recIdents;
                 }
               } else if (_source44.is_Arrow) {
-                Dafny.ISequence<DAST._IType> _1163___mcc_h498 = _source44.dtor_args;
-                DAST._IType _1164___mcc_h499 = _source44.dtor_result;
+                Dafny.ISequence<DAST._IType> _1216___mcc_h659 = _source44.dtor_args;
+                DAST._IType _1217___mcc_h660 = _source44.dtor_result;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1165_recursiveGen;
-                  bool _1166_recOwned;
-                  bool _1167_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1168_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out695;
-                  bool _out696;
-                  bool _out697;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out698;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out695, out _out696, out _out697, out _out698);
-                  _1165_recursiveGen = _out695;
-                  _1166_recOwned = _out696;
-                  _1167_recErased = _out697;
-                  _1168_recIdents = _out698;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1165_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1166_recOwned;
-                  isErased = _1167_recErased;
-                  readIdents = _1168_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1218_recursiveGen;
+                  bool _1219_recOwned;
+                  bool _1220_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1221_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out729;
+                  bool _out730;
+                  bool _out731;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out732;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out729, out _out730, out _out731, out _out732);
+                  _1218_recursiveGen = _out729;
+                  _1219_recOwned = _out730;
+                  _1220_recErased = _out731;
+                  _1221_recIdents = _out732;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1218_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1219_recOwned;
+                  isErased = _1220_recErased;
+                  readIdents = _1221_recIdents;
                 }
               } else if (_source44.is_Primitive) {
-                DAST._IPrimitive _1169___mcc_h502 = _source44.dtor_Primitive_a0;
+                DAST._IPrimitive _1222___mcc_h663 = _source44.dtor_Primitive_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1170_recursiveGen;
-                  bool _1171_recOwned;
-                  bool _1172_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1173_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out699;
-                  bool _out700;
-                  bool _out701;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out702;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out699, out _out700, out _out701, out _out702);
-                  _1170_recursiveGen = _out699;
-                  _1171_recOwned = _out700;
-                  _1172_recErased = _out701;
-                  _1173_recIdents = _out702;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1170_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1171_recOwned;
-                  isErased = _1172_recErased;
-                  readIdents = _1173_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1223_recursiveGen;
+                  bool _1224_recOwned;
+                  bool _1225_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1226_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out733;
+                  bool _out734;
+                  bool _out735;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out736;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out733, out _out734, out _out735, out _out736);
+                  _1223_recursiveGen = _out733;
+                  _1224_recOwned = _out734;
+                  _1225_recErased = _out735;
+                  _1226_recIdents = _out736;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1223_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1224_recOwned;
+                  isErased = _1225_recErased;
+                  readIdents = _1226_recIdents;
                 }
               } else if (_source44.is_Passthrough) {
-                Dafny.ISequence<Dafny.Rune> _1174___mcc_h504 = _source44.dtor_Passthrough_a0;
+                Dafny.ISequence<Dafny.Rune> _1227___mcc_h665 = _source44.dtor_Passthrough_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1175_recursiveGen;
-                  bool _1176_recOwned;
-                  bool _1177_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1178_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out703;
-                  bool _out704;
-                  bool _out705;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out706;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out703, out _out704, out _out705, out _out706);
-                  _1175_recursiveGen = _out703;
-                  _1176_recOwned = _out704;
-                  _1177_recErased = _out705;
-                  _1178_recIdents = _out706;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1175_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1176_recOwned;
-                  isErased = _1177_recErased;
-                  readIdents = _1178_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1228_recursiveGen;
+                  bool _1229_recOwned;
+                  bool _1230_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1231_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out737;
+                  bool _out738;
+                  bool _out739;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out740;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out737, out _out738, out _out739, out _out740);
+                  _1228_recursiveGen = _out737;
+                  _1229_recOwned = _out738;
+                  _1230_recErased = _out739;
+                  _1231_recIdents = _out740;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1228_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1229_recOwned;
+                  isErased = _1230_recErased;
+                  readIdents = _1231_recIdents;
                 }
               } else {
-                Dafny.ISequence<Dafny.Rune> _1179___mcc_h506 = _source44.dtor_TypeArg_a0;
+                Dafny.ISequence<Dafny.Rune> _1232___mcc_h667 = _source44.dtor_TypeArg_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1180_recursiveGen;
-                  bool _1181_recOwned;
-                  bool _1182_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1183_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out707;
-                  bool _out708;
-                  bool _out709;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out710;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out707, out _out708, out _out709, out _out710);
-                  _1180_recursiveGen = _out707;
-                  _1181_recOwned = _out708;
-                  _1182_recErased = _out709;
-                  _1183_recIdents = _out710;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1180_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1181_recOwned;
-                  isErased = _1182_recErased;
-                  readIdents = _1183_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1233_recursiveGen;
+                  bool _1234_recOwned;
+                  bool _1235_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1236_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out741;
+                  bool _out742;
+                  bool _out743;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out744;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out741, out _out742, out _out743, out _out744);
+                  _1233_recursiveGen = _out741;
+                  _1234_recOwned = _out742;
+                  _1235_recErased = _out743;
+                  _1236_recIdents = _out744;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1233_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1234_recOwned;
+                  isErased = _1235_recErased;
+                  readIdents = _1236_recIdents;
                 }
               }
-            } else if (_source26.is_Arrow) {
-              Dafny.ISequence<DAST._IType> _1184___mcc_h508 = _source26.dtor_args;
-              DAST._IType _1185___mcc_h509 = _source26.dtor_result;
-              DAST._IType _source46 = _489___mcc_h124;
+            } else if (_source26.is_Map) {
+              DAST._IType _1237___mcc_h669 = _source26.dtor_key;
+              DAST._IType _1238___mcc_h670 = _source26.dtor_value;
+              DAST._IType _source46 = _501___mcc_h238;
               if (_source46.is_Path) {
-                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1186___mcc_h514 = _source46.dtor_Path_a0;
-                Dafny.ISequence<DAST._IType> _1187___mcc_h515 = _source46.dtor_typeArgs;
-                DAST._IResolvedType _1188___mcc_h516 = _source46.dtor_resolved;
-                DAST._IResolvedType _source47 = _1188___mcc_h516;
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1239___mcc_h677 = _source46.dtor_Path_a0;
+                Dafny.ISequence<DAST._IType> _1240___mcc_h678 = _source46.dtor_typeArgs;
+                DAST._IResolvedType _1241___mcc_h679 = _source46.dtor_resolved;
+                DAST._IResolvedType _source47 = _1241___mcc_h679;
                 if (_source47.is_Datatype) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1189___mcc_h520 = _source47.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1242___mcc_h683 = _source47.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1190_recursiveGen;
-                    bool _1191_recOwned;
-                    bool _1192_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1193_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out711;
-                    bool _out712;
-                    bool _out713;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out714;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out711, out _out712, out _out713, out _out714);
-                    _1190_recursiveGen = _out711;
-                    _1191_recOwned = _out712;
-                    _1192_recErased = _out713;
-                    _1193_recIdents = _out714;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1190_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1191_recOwned;
-                    isErased = _1192_recErased;
-                    readIdents = _1193_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1243_recursiveGen;
+                    bool _1244_recOwned;
+                    bool _1245_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1246_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out745;
+                    bool _out746;
+                    bool _out747;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out748;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out745, out _out746, out _out747, out _out748);
+                    _1243_recursiveGen = _out745;
+                    _1244_recOwned = _out746;
+                    _1245_recErased = _out747;
+                    _1246_recIdents = _out748;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1243_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1244_recOwned;
+                    isErased = _1245_recErased;
+                    readIdents = _1246_recIdents;
                   }
                 } else if (_source47.is_Trait) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1194___mcc_h522 = _source47.dtor_path;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1247___mcc_h685 = _source47.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1195_recursiveGen;
-                    bool _1196_recOwned;
-                    bool _1197_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1198_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out715;
-                    bool _out716;
-                    bool _out717;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out718;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out715, out _out716, out _out717, out _out718);
-                    _1195_recursiveGen = _out715;
-                    _1196_recOwned = _out716;
-                    _1197_recErased = _out717;
-                    _1198_recIdents = _out718;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1195_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1196_recOwned;
-                    isErased = _1197_recErased;
-                    readIdents = _1198_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1248_recursiveGen;
+                    bool _1249_recOwned;
+                    bool _1250_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1251_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out749;
+                    bool _out750;
+                    bool _out751;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out752;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out749, out _out750, out _out751, out _out752);
+                    _1248_recursiveGen = _out749;
+                    _1249_recOwned = _out750;
+                    _1250_recErased = _out751;
+                    _1251_recIdents = _out752;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1248_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1249_recOwned;
+                    isErased = _1250_recErased;
+                    readIdents = _1251_recIdents;
                   }
                 } else {
-                  DAST._IType _1199___mcc_h524 = _source47.dtor_Newtype_a0;
-                  DAST._IType _1200_b = _1199___mcc_h524;
+                  DAST._IType _1252___mcc_h687 = _source47.dtor_Newtype_a0;
+                  DAST._IType _1253_b = _1252___mcc_h687;
                   {
-                    if (object.Equals(_482_fromTpe, _1200_b)) {
-                      Dafny.ISequence<Dafny.Rune> _1201_recursiveGen;
-                      bool _1202_recOwned;
-                      bool _1203_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1204_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out719;
-                      bool _out720;
-                      bool _out721;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out722;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out719, out _out720, out _out721, out _out722);
-                      _1201_recursiveGen = _out719;
-                      _1202_recOwned = _out720;
-                      _1203_recErased = _out721;
-                      _1204_recIdents = _out722;
-                      Dafny.ISequence<Dafny.Rune> _1205_rhsType;
-                      Dafny.ISequence<Dafny.Rune> _out723;
-                      _out723 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                      _1205_rhsType = _out723;
-                      Dafny.ISequence<Dafny.Rune> _1206_uneraseFn;
-                      _1206_uneraseFn = ((_1202_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1205_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1206_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1201_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _1202_recOwned;
+                    if (object.Equals(_494_fromTpe, _1253_b)) {
+                      Dafny.ISequence<Dafny.Rune> _1254_recursiveGen;
+                      bool _1255_recOwned;
+                      bool _1256_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1257_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out753;
+                      bool _out754;
+                      bool _out755;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out756;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out753, out _out754, out _out755, out _out756);
+                      _1254_recursiveGen = _out753;
+                      _1255_recOwned = _out754;
+                      _1256_recErased = _out755;
+                      _1257_recIdents = _out756;
+                      Dafny.ISequence<Dafny.Rune> _1258_rhsType;
+                      Dafny.ISequence<Dafny.Rune> _out757;
+                      _out757 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                      _1258_rhsType = _out757;
+                      Dafny.ISequence<Dafny.Rune> _1259_uneraseFn;
+                      _1259_uneraseFn = ((_1255_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1258_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1259_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1254_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _1255_recOwned;
                       isErased = false;
-                      readIdents = _1204_recIdents;
+                      readIdents = _1257_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out724;
-                      bool _out725;
-                      bool _out726;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out727;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _1200_b), _1200_b, _481_toTpe), @params, mustOwn, out _out724, out _out725, out _out726, out _out727);
-                      s = _out724;
-                      isOwned = _out725;
-                      isErased = _out726;
-                      readIdents = _out727;
+                      Dafny.ISequence<Dafny.Rune> _out758;
+                      bool _out759;
+                      bool _out760;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out761;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1253_b), _1253_b, _493_toTpe), selfIdent, @params, mustOwn, out _out758, out _out759, out _out760, out _out761);
+                      s = _out758;
+                      isOwned = _out759;
+                      isErased = _out760;
+                      readIdents = _out761;
                     }
                   }
                 }
+              } else if (_source46.is_Nullable) {
+                DAST._IType _1260___mcc_h689 = _source46.dtor_Nullable_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1261_recursiveGen;
+                  bool _1262_recOwned;
+                  bool _1263_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1264_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out762;
+                  bool _out763;
+                  bool _out764;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out765;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out762, out _out763, out _out764, out _out765);
+                  _1261_recursiveGen = _out762;
+                  _1262_recOwned = _out763;
+                  _1263_recErased = _out764;
+                  _1264_recIdents = _out765;
+                  if (!(_1262_recOwned)) {
+                    _1261_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1261_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1261_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                  isOwned = true;
+                  isErased = _1263_recErased;
+                  readIdents = _1264_recIdents;
+                }
               } else if (_source46.is_Tuple) {
-                Dafny.ISequence<DAST._IType> _1207___mcc_h526 = _source46.dtor_Tuple_a0;
+                Dafny.ISequence<DAST._IType> _1265___mcc_h691 = _source46.dtor_Tuple_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1208_recursiveGen;
-                  bool _1209_recOwned;
-                  bool _1210_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1211_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out728;
-                  bool _out729;
-                  bool _out730;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out731;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out728, out _out729, out _out730, out _out731);
-                  _1208_recursiveGen = _out728;
-                  _1209_recOwned = _out729;
-                  _1210_recErased = _out730;
-                  _1211_recIdents = _out731;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1208_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1209_recOwned;
-                  isErased = _1210_recErased;
-                  readIdents = _1211_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1266_recursiveGen;
+                  bool _1267_recOwned;
+                  bool _1268_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1269_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out766;
+                  bool _out767;
+                  bool _out768;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out769;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out766, out _out767, out _out768, out _out769);
+                  _1266_recursiveGen = _out766;
+                  _1267_recOwned = _out767;
+                  _1268_recErased = _out768;
+                  _1269_recIdents = _out769;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1266_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1267_recOwned;
+                  isErased = _1268_recErased;
+                  readIdents = _1269_recIdents;
                 }
               } else if (_source46.is_Array) {
-                DAST._IType _1212___mcc_h528 = _source46.dtor_element;
+                DAST._IType _1270___mcc_h693 = _source46.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1213_recursiveGen;
-                  bool _1214_recOwned;
-                  bool _1215_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1216_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out732;
-                  bool _out733;
-                  bool _out734;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out735;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out732, out _out733, out _out734, out _out735);
-                  _1213_recursiveGen = _out732;
-                  _1214_recOwned = _out733;
-                  _1215_recErased = _out734;
-                  _1216_recIdents = _out735;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1213_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1214_recOwned;
-                  isErased = _1215_recErased;
-                  readIdents = _1216_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1271_recursiveGen;
+                  bool _1272_recOwned;
+                  bool _1273_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1274_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out770;
+                  bool _out771;
+                  bool _out772;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out773;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out770, out _out771, out _out772, out _out773);
+                  _1271_recursiveGen = _out770;
+                  _1272_recOwned = _out771;
+                  _1273_recErased = _out772;
+                  _1274_recIdents = _out773;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1271_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1272_recOwned;
+                  isErased = _1273_recErased;
+                  readIdents = _1274_recIdents;
                 }
               } else if (_source46.is_Seq) {
-                DAST._IType _1217___mcc_h530 = _source46.dtor_element;
+                DAST._IType _1275___mcc_h695 = _source46.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1218_recursiveGen;
-                  bool _1219_recOwned;
-                  bool _1220_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1221_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out736;
-                  bool _out737;
-                  bool _out738;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out739;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out736, out _out737, out _out738, out _out739);
-                  _1218_recursiveGen = _out736;
-                  _1219_recOwned = _out737;
-                  _1220_recErased = _out738;
-                  _1221_recIdents = _out739;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1218_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1219_recOwned;
-                  isErased = _1220_recErased;
-                  readIdents = _1221_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1276_recursiveGen;
+                  bool _1277_recOwned;
+                  bool _1278_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1279_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out774;
+                  bool _out775;
+                  bool _out776;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out777;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out774, out _out775, out _out776, out _out777);
+                  _1276_recursiveGen = _out774;
+                  _1277_recOwned = _out775;
+                  _1278_recErased = _out776;
+                  _1279_recIdents = _out777;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1276_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1277_recOwned;
+                  isErased = _1278_recErased;
+                  readIdents = _1279_recIdents;
                 }
               } else if (_source46.is_Set) {
-                DAST._IType _1222___mcc_h532 = _source46.dtor_element;
+                DAST._IType _1280___mcc_h697 = _source46.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1223_recursiveGen;
-                  bool _1224_recOwned;
-                  bool _1225_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1226_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out740;
-                  bool _out741;
-                  bool _out742;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out743;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out740, out _out741, out _out742, out _out743);
-                  _1223_recursiveGen = _out740;
-                  _1224_recOwned = _out741;
-                  _1225_recErased = _out742;
-                  _1226_recIdents = _out743;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1223_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1224_recOwned;
-                  isErased = _1225_recErased;
-                  readIdents = _1226_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1281_recursiveGen;
+                  bool _1282_recOwned;
+                  bool _1283_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1284_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out778;
+                  bool _out779;
+                  bool _out780;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out781;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out778, out _out779, out _out780, out _out781);
+                  _1281_recursiveGen = _out778;
+                  _1282_recOwned = _out779;
+                  _1283_recErased = _out780;
+                  _1284_recIdents = _out781;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1281_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1282_recOwned;
+                  isErased = _1283_recErased;
+                  readIdents = _1284_recIdents;
                 }
               } else if (_source46.is_Multiset) {
-                DAST._IType _1227___mcc_h534 = _source46.dtor_element;
+                DAST._IType _1285___mcc_h699 = _source46.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1228_recursiveGen;
-                  bool _1229_recOwned;
-                  bool _1230_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1231_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out744;
-                  bool _out745;
-                  bool _out746;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out747;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out744, out _out745, out _out746, out _out747);
-                  _1228_recursiveGen = _out744;
-                  _1229_recOwned = _out745;
-                  _1230_recErased = _out746;
-                  _1231_recIdents = _out747;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1228_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1229_recOwned;
-                  isErased = _1230_recErased;
-                  readIdents = _1231_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1286_recursiveGen;
+                  bool _1287_recOwned;
+                  bool _1288_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1289_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out782;
+                  bool _out783;
+                  bool _out784;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out785;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out782, out _out783, out _out784, out _out785);
+                  _1286_recursiveGen = _out782;
+                  _1287_recOwned = _out783;
+                  _1288_recErased = _out784;
+                  _1289_recIdents = _out785;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1286_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1287_recOwned;
+                  isErased = _1288_recErased;
+                  readIdents = _1289_recIdents;
                 }
               } else if (_source46.is_Map) {
-                DAST._IType _1232___mcc_h536 = _source46.dtor_key;
-                DAST._IType _1233___mcc_h537 = _source46.dtor_value;
+                DAST._IType _1290___mcc_h701 = _source46.dtor_key;
+                DAST._IType _1291___mcc_h702 = _source46.dtor_value;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1234_recursiveGen;
-                  bool _1235_recOwned;
-                  bool _1236_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1237_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out748;
-                  bool _out749;
-                  bool _out750;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out751;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out748, out _out749, out _out750, out _out751);
-                  _1234_recursiveGen = _out748;
-                  _1235_recOwned = _out749;
-                  _1236_recErased = _out750;
-                  _1237_recIdents = _out751;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1234_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1235_recOwned;
-                  isErased = _1236_recErased;
-                  readIdents = _1237_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1292_recursiveGen;
+                  bool _1293_recOwned;
+                  bool _1294_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1295_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out786;
+                  bool _out787;
+                  bool _out788;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out789;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out786, out _out787, out _out788, out _out789);
+                  _1292_recursiveGen = _out786;
+                  _1293_recOwned = _out787;
+                  _1294_recErased = _out788;
+                  _1295_recIdents = _out789;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1292_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1293_recOwned;
+                  isErased = _1294_recErased;
+                  readIdents = _1295_recIdents;
                 }
               } else if (_source46.is_Arrow) {
-                Dafny.ISequence<DAST._IType> _1238___mcc_h540 = _source46.dtor_args;
-                DAST._IType _1239___mcc_h541 = _source46.dtor_result;
+                Dafny.ISequence<DAST._IType> _1296___mcc_h705 = _source46.dtor_args;
+                DAST._IType _1297___mcc_h706 = _source46.dtor_result;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1240_recursiveGen;
-                  bool _1241_recOwned;
-                  bool _1242_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1243_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out752;
-                  bool _out753;
-                  bool _out754;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out755;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out752, out _out753, out _out754, out _out755);
-                  _1240_recursiveGen = _out752;
-                  _1241_recOwned = _out753;
-                  _1242_recErased = _out754;
-                  _1243_recIdents = _out755;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1240_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1241_recOwned;
-                  isErased = _1242_recErased;
-                  readIdents = _1243_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1298_recursiveGen;
+                  bool _1299_recOwned;
+                  bool _1300_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1301_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out790;
+                  bool _out791;
+                  bool _out792;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out793;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out790, out _out791, out _out792, out _out793);
+                  _1298_recursiveGen = _out790;
+                  _1299_recOwned = _out791;
+                  _1300_recErased = _out792;
+                  _1301_recIdents = _out793;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1298_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1299_recOwned;
+                  isErased = _1300_recErased;
+                  readIdents = _1301_recIdents;
                 }
               } else if (_source46.is_Primitive) {
-                DAST._IPrimitive _1244___mcc_h544 = _source46.dtor_Primitive_a0;
+                DAST._IPrimitive _1302___mcc_h709 = _source46.dtor_Primitive_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1245_recursiveGen;
-                  bool _1246_recOwned;
-                  bool _1247_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1248_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out756;
-                  bool _out757;
-                  bool _out758;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out759;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out756, out _out757, out _out758, out _out759);
-                  _1245_recursiveGen = _out756;
-                  _1246_recOwned = _out757;
-                  _1247_recErased = _out758;
-                  _1248_recIdents = _out759;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1245_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1246_recOwned;
-                  isErased = _1247_recErased;
-                  readIdents = _1248_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1303_recursiveGen;
+                  bool _1304_recOwned;
+                  bool _1305_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1306_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out794;
+                  bool _out795;
+                  bool _out796;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out797;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out794, out _out795, out _out796, out _out797);
+                  _1303_recursiveGen = _out794;
+                  _1304_recOwned = _out795;
+                  _1305_recErased = _out796;
+                  _1306_recIdents = _out797;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1303_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1304_recOwned;
+                  isErased = _1305_recErased;
+                  readIdents = _1306_recIdents;
                 }
               } else if (_source46.is_Passthrough) {
-                Dafny.ISequence<Dafny.Rune> _1249___mcc_h546 = _source46.dtor_Passthrough_a0;
+                Dafny.ISequence<Dafny.Rune> _1307___mcc_h711 = _source46.dtor_Passthrough_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1308_recursiveGen;
+                  bool _1309_recOwned;
+                  bool _1310_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1311_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out798;
+                  bool _out799;
+                  bool _out800;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out801;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out798, out _out799, out _out800, out _out801);
+                  _1308_recursiveGen = _out798;
+                  _1309_recOwned = _out799;
+                  _1310_recErased = _out800;
+                  _1311_recIdents = _out801;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1308_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1309_recOwned;
+                  isErased = _1310_recErased;
+                  readIdents = _1311_recIdents;
+                }
+              } else {
+                Dafny.ISequence<Dafny.Rune> _1312___mcc_h713 = _source46.dtor_TypeArg_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1313_recursiveGen;
+                  bool _1314_recOwned;
+                  bool _1315_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1316_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out802;
+                  bool _out803;
+                  bool _out804;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out805;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out802, out _out803, out _out804, out _out805);
+                  _1313_recursiveGen = _out802;
+                  _1314_recOwned = _out803;
+                  _1315_recErased = _out804;
+                  _1316_recIdents = _out805;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1313_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1314_recOwned;
+                  isErased = _1315_recErased;
+                  readIdents = _1316_recIdents;
+                }
+              }
+            } else if (_source26.is_Arrow) {
+              Dafny.ISequence<DAST._IType> _1317___mcc_h715 = _source26.dtor_args;
+              DAST._IType _1318___mcc_h716 = _source26.dtor_result;
+              DAST._IType _source48 = _501___mcc_h238;
+              if (_source48.is_Path) {
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1319___mcc_h723 = _source48.dtor_Path_a0;
+                Dafny.ISequence<DAST._IType> _1320___mcc_h724 = _source48.dtor_typeArgs;
+                DAST._IResolvedType _1321___mcc_h725 = _source48.dtor_resolved;
+                DAST._IResolvedType _source49 = _1321___mcc_h725;
+                if (_source49.is_Datatype) {
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1322___mcc_h729 = _source49.dtor_path;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1323_recursiveGen;
+                    bool _1324_recOwned;
+                    bool _1325_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1326_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out806;
+                    bool _out807;
+                    bool _out808;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out809;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out806, out _out807, out _out808, out _out809);
+                    _1323_recursiveGen = _out806;
+                    _1324_recOwned = _out807;
+                    _1325_recErased = _out808;
+                    _1326_recIdents = _out809;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1323_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1324_recOwned;
+                    isErased = _1325_recErased;
+                    readIdents = _1326_recIdents;
+                  }
+                } else if (_source49.is_Trait) {
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1327___mcc_h731 = _source49.dtor_path;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1328_recursiveGen;
+                    bool _1329_recOwned;
+                    bool _1330_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1331_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out810;
+                    bool _out811;
+                    bool _out812;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out813;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out810, out _out811, out _out812, out _out813);
+                    _1328_recursiveGen = _out810;
+                    _1329_recOwned = _out811;
+                    _1330_recErased = _out812;
+                    _1331_recIdents = _out813;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1328_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1329_recOwned;
+                    isErased = _1330_recErased;
+                    readIdents = _1331_recIdents;
+                  }
+                } else {
+                  DAST._IType _1332___mcc_h733 = _source49.dtor_Newtype_a0;
+                  DAST._IType _1333_b = _1332___mcc_h733;
+                  {
+                    if (object.Equals(_494_fromTpe, _1333_b)) {
+                      Dafny.ISequence<Dafny.Rune> _1334_recursiveGen;
+                      bool _1335_recOwned;
+                      bool _1336_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1337_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out814;
+                      bool _out815;
+                      bool _out816;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out817;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out814, out _out815, out _out816, out _out817);
+                      _1334_recursiveGen = _out814;
+                      _1335_recOwned = _out815;
+                      _1336_recErased = _out816;
+                      _1337_recIdents = _out817;
+                      Dafny.ISequence<Dafny.Rune> _1338_rhsType;
+                      Dafny.ISequence<Dafny.Rune> _out818;
+                      _out818 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                      _1338_rhsType = _out818;
+                      Dafny.ISequence<Dafny.Rune> _1339_uneraseFn;
+                      _1339_uneraseFn = ((_1335_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1338_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1339_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1334_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _1335_recOwned;
+                      isErased = false;
+                      readIdents = _1337_recIdents;
+                    } else {
+                      Dafny.ISequence<Dafny.Rune> _out819;
+                      bool _out820;
+                      bool _out821;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out822;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1333_b), _1333_b, _493_toTpe), selfIdent, @params, mustOwn, out _out819, out _out820, out _out821, out _out822);
+                      s = _out819;
+                      isOwned = _out820;
+                      isErased = _out821;
+                      readIdents = _out822;
+                    }
+                  }
+                }
+              } else if (_source48.is_Nullable) {
+                DAST._IType _1340___mcc_h735 = _source48.dtor_Nullable_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1341_recursiveGen;
+                  bool _1342_recOwned;
+                  bool _1343_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1344_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out823;
+                  bool _out824;
+                  bool _out825;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out826;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out823, out _out824, out _out825, out _out826);
+                  _1341_recursiveGen = _out823;
+                  _1342_recOwned = _out824;
+                  _1343_recErased = _out825;
+                  _1344_recIdents = _out826;
+                  if (!(_1342_recOwned)) {
+                    _1341_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1341_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1341_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                  isOwned = true;
+                  isErased = _1343_recErased;
+                  readIdents = _1344_recIdents;
+                }
+              } else if (_source48.is_Tuple) {
+                Dafny.ISequence<DAST._IType> _1345___mcc_h737 = _source48.dtor_Tuple_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1346_recursiveGen;
+                  bool _1347_recOwned;
+                  bool _1348_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1349_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out827;
+                  bool _out828;
+                  bool _out829;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out830;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out827, out _out828, out _out829, out _out830);
+                  _1346_recursiveGen = _out827;
+                  _1347_recOwned = _out828;
+                  _1348_recErased = _out829;
+                  _1349_recIdents = _out830;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1346_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1347_recOwned;
+                  isErased = _1348_recErased;
+                  readIdents = _1349_recIdents;
+                }
+              } else if (_source48.is_Array) {
+                DAST._IType _1350___mcc_h739 = _source48.dtor_element;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1351_recursiveGen;
+                  bool _1352_recOwned;
+                  bool _1353_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1354_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out831;
+                  bool _out832;
+                  bool _out833;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out834;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out831, out _out832, out _out833, out _out834);
+                  _1351_recursiveGen = _out831;
+                  _1352_recOwned = _out832;
+                  _1353_recErased = _out833;
+                  _1354_recIdents = _out834;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1351_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1352_recOwned;
+                  isErased = _1353_recErased;
+                  readIdents = _1354_recIdents;
+                }
+              } else if (_source48.is_Seq) {
+                DAST._IType _1355___mcc_h741 = _source48.dtor_element;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1356_recursiveGen;
+                  bool _1357_recOwned;
+                  bool _1358_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1359_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out835;
+                  bool _out836;
+                  bool _out837;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out838;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out835, out _out836, out _out837, out _out838);
+                  _1356_recursiveGen = _out835;
+                  _1357_recOwned = _out836;
+                  _1358_recErased = _out837;
+                  _1359_recIdents = _out838;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1356_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1357_recOwned;
+                  isErased = _1358_recErased;
+                  readIdents = _1359_recIdents;
+                }
+              } else if (_source48.is_Set) {
+                DAST._IType _1360___mcc_h743 = _source48.dtor_element;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1361_recursiveGen;
+                  bool _1362_recOwned;
+                  bool _1363_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1364_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out839;
+                  bool _out840;
+                  bool _out841;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out842;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out839, out _out840, out _out841, out _out842);
+                  _1361_recursiveGen = _out839;
+                  _1362_recOwned = _out840;
+                  _1363_recErased = _out841;
+                  _1364_recIdents = _out842;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1361_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1362_recOwned;
+                  isErased = _1363_recErased;
+                  readIdents = _1364_recIdents;
+                }
+              } else if (_source48.is_Multiset) {
+                DAST._IType _1365___mcc_h745 = _source48.dtor_element;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1366_recursiveGen;
+                  bool _1367_recOwned;
+                  bool _1368_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1369_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out843;
+                  bool _out844;
+                  bool _out845;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out846;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out843, out _out844, out _out845, out _out846);
+                  _1366_recursiveGen = _out843;
+                  _1367_recOwned = _out844;
+                  _1368_recErased = _out845;
+                  _1369_recIdents = _out846;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1366_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1367_recOwned;
+                  isErased = _1368_recErased;
+                  readIdents = _1369_recIdents;
+                }
+              } else if (_source48.is_Map) {
+                DAST._IType _1370___mcc_h747 = _source48.dtor_key;
+                DAST._IType _1371___mcc_h748 = _source48.dtor_value;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1372_recursiveGen;
+                  bool _1373_recOwned;
+                  bool _1374_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1375_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out847;
+                  bool _out848;
+                  bool _out849;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out850;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out847, out _out848, out _out849, out _out850);
+                  _1372_recursiveGen = _out847;
+                  _1373_recOwned = _out848;
+                  _1374_recErased = _out849;
+                  _1375_recIdents = _out850;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1372_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1373_recOwned;
+                  isErased = _1374_recErased;
+                  readIdents = _1375_recIdents;
+                }
+              } else if (_source48.is_Arrow) {
+                Dafny.ISequence<DAST._IType> _1376___mcc_h751 = _source48.dtor_args;
+                DAST._IType _1377___mcc_h752 = _source48.dtor_result;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1250_recursiveGen;
-                  bool _1251_recOwned;
-                  bool _1252_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1253_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out760;
-                  bool _out761;
-                  bool _out762;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out763;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out760, out _out761, out _out762, out _out763);
-                  _1250_recursiveGen = _out760;
-                  _1251_recOwned = _out761;
-                  _1252_recErased = _out762;
-                  _1253_recIdents = _out763;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1250_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1251_recOwned;
-                  isErased = _1252_recErased;
-                  readIdents = _1253_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1378_recursiveGen;
+                  bool _1379_recOwned;
+                  bool _1380_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1381_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out851;
+                  bool _out852;
+                  bool _out853;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out854;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out851, out _out852, out _out853, out _out854);
+                  _1378_recursiveGen = _out851;
+                  _1379_recOwned = _out852;
+                  _1380_recErased = _out853;
+                  _1381_recIdents = _out854;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1378_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1379_recOwned;
+                  isErased = _1380_recErased;
+                  readIdents = _1381_recIdents;
+                }
+              } else if (_source48.is_Primitive) {
+                DAST._IPrimitive _1382___mcc_h755 = _source48.dtor_Primitive_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1383_recursiveGen;
+                  bool _1384_recOwned;
+                  bool _1385_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1386_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out855;
+                  bool _out856;
+                  bool _out857;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out858;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out855, out _out856, out _out857, out _out858);
+                  _1383_recursiveGen = _out855;
+                  _1384_recOwned = _out856;
+                  _1385_recErased = _out857;
+                  _1386_recIdents = _out858;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1383_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1384_recOwned;
+                  isErased = _1385_recErased;
+                  readIdents = _1386_recIdents;
+                }
+              } else if (_source48.is_Passthrough) {
+                Dafny.ISequence<Dafny.Rune> _1387___mcc_h757 = _source48.dtor_Passthrough_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1388_recursiveGen;
+                  bool _1389_recOwned;
+                  bool _1390_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1391_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out859;
+                  bool _out860;
+                  bool _out861;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out862;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out859, out _out860, out _out861, out _out862);
+                  _1388_recursiveGen = _out859;
+                  _1389_recOwned = _out860;
+                  _1390_recErased = _out861;
+                  _1391_recIdents = _out862;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1388_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1389_recOwned;
+                  isErased = _1390_recErased;
+                  readIdents = _1391_recIdents;
                 }
               } else {
-                Dafny.ISequence<Dafny.Rune> _1254___mcc_h548 = _source46.dtor_TypeArg_a0;
+                Dafny.ISequence<Dafny.Rune> _1392___mcc_h759 = _source48.dtor_TypeArg_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1255_recursiveGen;
-                  bool _1256_recOwned;
-                  bool _1257_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1258_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out764;
-                  bool _out765;
-                  bool _out766;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out767;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out764, out _out765, out _out766, out _out767);
-                  _1255_recursiveGen = _out764;
-                  _1256_recOwned = _out765;
-                  _1257_recErased = _out766;
-                  _1258_recIdents = _out767;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1255_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1256_recOwned;
-                  isErased = _1257_recErased;
-                  readIdents = _1258_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1393_recursiveGen;
+                  bool _1394_recOwned;
+                  bool _1395_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1396_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out863;
+                  bool _out864;
+                  bool _out865;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out866;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out863, out _out864, out _out865, out _out866);
+                  _1393_recursiveGen = _out863;
+                  _1394_recOwned = _out864;
+                  _1395_recErased = _out865;
+                  _1396_recIdents = _out866;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1393_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1394_recOwned;
+                  isErased = _1395_recErased;
+                  readIdents = _1396_recIdents;
                 }
               }
             } else if (_source26.is_Primitive) {
-              DAST._IPrimitive _1259___mcc_h550 = _source26.dtor_Primitive_a0;
-              DAST._IPrimitive _source48 = _1259___mcc_h550;
-              if (_source48.is_Int) {
-                DAST._IType _source49 = _489___mcc_h124;
-                if (_source49.is_Path) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1260___mcc_h553 = _source49.dtor_Path_a0;
-                  Dafny.ISequence<DAST._IType> _1261___mcc_h554 = _source49.dtor_typeArgs;
-                  DAST._IResolvedType _1262___mcc_h555 = _source49.dtor_resolved;
-                  DAST._IResolvedType _source50 = _1262___mcc_h555;
-                  if (_source50.is_Datatype) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1263___mcc_h559 = _source50.dtor_path;
+              DAST._IPrimitive _1397___mcc_h761 = _source26.dtor_Primitive_a0;
+              DAST._IPrimitive _source50 = _1397___mcc_h761;
+              if (_source50.is_Int) {
+                DAST._IType _source51 = _501___mcc_h238;
+                if (_source51.is_Path) {
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1398___mcc_h765 = _source51.dtor_Path_a0;
+                  Dafny.ISequence<DAST._IType> _1399___mcc_h766 = _source51.dtor_typeArgs;
+                  DAST._IResolvedType _1400___mcc_h767 = _source51.dtor_resolved;
+                  DAST._IResolvedType _source52 = _1400___mcc_h767;
+                  if (_source52.is_Datatype) {
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1401___mcc_h771 = _source52.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _1264_recursiveGen;
-                      bool _1265_recOwned;
-                      bool _1266_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1267_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out768;
-                      bool _out769;
-                      bool _out770;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out771;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out768, out _out769, out _out770, out _out771);
-                      _1264_recursiveGen = _out768;
-                      _1265_recOwned = _out769;
-                      _1266_recErased = _out770;
-                      _1267_recIdents = _out771;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1264_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1265_recOwned;
-                      isErased = _1266_recErased;
-                      readIdents = _1267_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1402_recursiveGen;
+                      bool _1403_recOwned;
+                      bool _1404_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1405_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out867;
+                      bool _out868;
+                      bool _out869;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out870;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out867, out _out868, out _out869, out _out870);
+                      _1402_recursiveGen = _out867;
+                      _1403_recOwned = _out868;
+                      _1404_recErased = _out869;
+                      _1405_recIdents = _out870;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1402_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1403_recOwned;
+                      isErased = _1404_recErased;
+                      readIdents = _1405_recIdents;
                     }
-                  } else if (_source50.is_Trait) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1268___mcc_h561 = _source50.dtor_path;
+                  } else if (_source52.is_Trait) {
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1406___mcc_h773 = _source52.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _1269_recursiveGen;
-                      bool _1270_recOwned;
-                      bool _1271_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1272_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out772;
-                      bool _out773;
-                      bool _out774;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out775;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out772, out _out773, out _out774, out _out775);
-                      _1269_recursiveGen = _out772;
-                      _1270_recOwned = _out773;
-                      _1271_recErased = _out774;
-                      _1272_recIdents = _out775;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1269_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1270_recOwned;
-                      isErased = _1271_recErased;
-                      readIdents = _1272_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1407_recursiveGen;
+                      bool _1408_recOwned;
+                      bool _1409_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1410_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out871;
+                      bool _out872;
+                      bool _out873;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out874;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out871, out _out872, out _out873, out _out874);
+                      _1407_recursiveGen = _out871;
+                      _1408_recOwned = _out872;
+                      _1409_recErased = _out873;
+                      _1410_recIdents = _out874;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1407_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1408_recOwned;
+                      isErased = _1409_recErased;
+                      readIdents = _1410_recIdents;
                     }
                   } else {
-                    DAST._IType _1273___mcc_h563 = _source50.dtor_Newtype_a0;
-                    DAST._IType _1274_b = _1273___mcc_h563;
+                    DAST._IType _1411___mcc_h775 = _source52.dtor_Newtype_a0;
+                    DAST._IType _1412_b = _1411___mcc_h775;
                     {
-                      if (object.Equals(_482_fromTpe, _1274_b)) {
-                        Dafny.ISequence<Dafny.Rune> _1275_recursiveGen;
-                        bool _1276_recOwned;
-                        bool _1277_recErased;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1278_recIdents;
-                        Dafny.ISequence<Dafny.Rune> _out776;
-                        bool _out777;
-                        bool _out778;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out779;
-                        DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out776, out _out777, out _out778, out _out779);
-                        _1275_recursiveGen = _out776;
-                        _1276_recOwned = _out777;
-                        _1277_recErased = _out778;
-                        _1278_recIdents = _out779;
-                        Dafny.ISequence<Dafny.Rune> _1279_rhsType;
-                        Dafny.ISequence<Dafny.Rune> _out780;
-                        _out780 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                        _1279_rhsType = _out780;
-                        Dafny.ISequence<Dafny.Rune> _1280_uneraseFn;
-                        _1280_uneraseFn = ((_1276_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1279_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1280_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1275_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                        isOwned = _1276_recOwned;
+                      if (object.Equals(_494_fromTpe, _1412_b)) {
+                        Dafny.ISequence<Dafny.Rune> _1413_recursiveGen;
+                        bool _1414_recOwned;
+                        bool _1415_recErased;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1416_recIdents;
+                        Dafny.ISequence<Dafny.Rune> _out875;
+                        bool _out876;
+                        bool _out877;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out878;
+                        DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out875, out _out876, out _out877, out _out878);
+                        _1413_recursiveGen = _out875;
+                        _1414_recOwned = _out876;
+                        _1415_recErased = _out877;
+                        _1416_recIdents = _out878;
+                        Dafny.ISequence<Dafny.Rune> _1417_rhsType;
+                        Dafny.ISequence<Dafny.Rune> _out879;
+                        _out879 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                        _1417_rhsType = _out879;
+                        Dafny.ISequence<Dafny.Rune> _1418_uneraseFn;
+                        _1418_uneraseFn = ((_1414_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1417_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1418_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1413_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                        isOwned = _1414_recOwned;
                         isErased = false;
-                        readIdents = _1278_recIdents;
+                        readIdents = _1416_recIdents;
                       } else {
-                        Dafny.ISequence<Dafny.Rune> _out781;
-                        bool _out782;
-                        bool _out783;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out784;
-                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _1274_b), _1274_b, _481_toTpe), @params, mustOwn, out _out781, out _out782, out _out783, out _out784);
-                        s = _out781;
-                        isOwned = _out782;
-                        isErased = _out783;
-                        readIdents = _out784;
+                        Dafny.ISequence<Dafny.Rune> _out880;
+                        bool _out881;
+                        bool _out882;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out883;
+                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1412_b), _1412_b, _493_toTpe), selfIdent, @params, mustOwn, out _out880, out _out881, out _out882, out _out883);
+                        s = _out880;
+                        isOwned = _out881;
+                        isErased = _out882;
+                        readIdents = _out883;
                       }
                     }
                   }
-                } else if (_source49.is_Tuple) {
-                  Dafny.ISequence<DAST._IType> _1281___mcc_h565 = _source49.dtor_Tuple_a0;
+                } else if (_source51.is_Nullable) {
+                  DAST._IType _1419___mcc_h777 = _source51.dtor_Nullable_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1282_recursiveGen;
-                    bool _1283_recOwned;
-                    bool _1284_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1285_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out785;
-                    bool _out786;
-                    bool _out787;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out788;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out785, out _out786, out _out787, out _out788);
-                    _1282_recursiveGen = _out785;
-                    _1283_recOwned = _out786;
-                    _1284_recErased = _out787;
-                    _1285_recIdents = _out788;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1282_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1283_recOwned;
-                    isErased = _1284_recErased;
-                    readIdents = _1285_recIdents;
-                  }
-                } else if (_source49.is_Array) {
-                  DAST._IType _1286___mcc_h567 = _source49.dtor_element;
+                    Dafny.ISequence<Dafny.Rune> _1420_recursiveGen;
+                    bool _1421_recOwned;
+                    bool _1422_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1423_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out884;
+                    bool _out885;
+                    bool _out886;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out887;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out884, out _out885, out _out886, out _out887);
+                    _1420_recursiveGen = _out884;
+                    _1421_recOwned = _out885;
+                    _1422_recErased = _out886;
+                    _1423_recIdents = _out887;
+                    if (!(_1421_recOwned)) {
+                      _1420_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1420_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                    }
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1420_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                    isOwned = true;
+                    isErased = _1422_recErased;
+                    readIdents = _1423_recIdents;
+                  }
+                } else if (_source51.is_Tuple) {
+                  Dafny.ISequence<DAST._IType> _1424___mcc_h779 = _source51.dtor_Tuple_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1287_recursiveGen;
-                    bool _1288_recOwned;
-                    bool _1289_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1290_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out789;
-                    bool _out790;
-                    bool _out791;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out792;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out789, out _out790, out _out791, out _out792);
-                    _1287_recursiveGen = _out789;
-                    _1288_recOwned = _out790;
-                    _1289_recErased = _out791;
-                    _1290_recIdents = _out792;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1287_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1288_recOwned;
-                    isErased = _1289_recErased;
-                    readIdents = _1290_recIdents;
-                  }
-                } else if (_source49.is_Seq) {
-                  DAST._IType _1291___mcc_h569 = _source49.dtor_element;
+                    Dafny.ISequence<Dafny.Rune> _1425_recursiveGen;
+                    bool _1426_recOwned;
+                    bool _1427_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1428_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out888;
+                    bool _out889;
+                    bool _out890;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out891;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out888, out _out889, out _out890, out _out891);
+                    _1425_recursiveGen = _out888;
+                    _1426_recOwned = _out889;
+                    _1427_recErased = _out890;
+                    _1428_recIdents = _out891;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1425_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1426_recOwned;
+                    isErased = _1427_recErased;
+                    readIdents = _1428_recIdents;
+                  }
+                } else if (_source51.is_Array) {
+                  DAST._IType _1429___mcc_h781 = _source51.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1292_recursiveGen;
-                    bool _1293_recOwned;
-                    bool _1294_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1295_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out793;
-                    bool _out794;
-                    bool _out795;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out796;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out793, out _out794, out _out795, out _out796);
-                    _1292_recursiveGen = _out793;
-                    _1293_recOwned = _out794;
-                    _1294_recErased = _out795;
-                    _1295_recIdents = _out796;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1292_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1293_recOwned;
-                    isErased = _1294_recErased;
-                    readIdents = _1295_recIdents;
-                  }
-                } else if (_source49.is_Set) {
-                  DAST._IType _1296___mcc_h571 = _source49.dtor_element;
+                    Dafny.ISequence<Dafny.Rune> _1430_recursiveGen;
+                    bool _1431_recOwned;
+                    bool _1432_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1433_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out892;
+                    bool _out893;
+                    bool _out894;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out895;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out892, out _out893, out _out894, out _out895);
+                    _1430_recursiveGen = _out892;
+                    _1431_recOwned = _out893;
+                    _1432_recErased = _out894;
+                    _1433_recIdents = _out895;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1430_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1431_recOwned;
+                    isErased = _1432_recErased;
+                    readIdents = _1433_recIdents;
+                  }
+                } else if (_source51.is_Seq) {
+                  DAST._IType _1434___mcc_h783 = _source51.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1297_recursiveGen;
-                    bool _1298_recOwned;
-                    bool _1299_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1300_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out797;
-                    bool _out798;
-                    bool _out799;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out800;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out797, out _out798, out _out799, out _out800);
-                    _1297_recursiveGen = _out797;
-                    _1298_recOwned = _out798;
-                    _1299_recErased = _out799;
-                    _1300_recIdents = _out800;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1297_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1298_recOwned;
-                    isErased = _1299_recErased;
-                    readIdents = _1300_recIdents;
-                  }
-                } else if (_source49.is_Multiset) {
-                  DAST._IType _1301___mcc_h573 = _source49.dtor_element;
+                    Dafny.ISequence<Dafny.Rune> _1435_recursiveGen;
+                    bool _1436_recOwned;
+                    bool _1437_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1438_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out896;
+                    bool _out897;
+                    bool _out898;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out899;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out896, out _out897, out _out898, out _out899);
+                    _1435_recursiveGen = _out896;
+                    _1436_recOwned = _out897;
+                    _1437_recErased = _out898;
+                    _1438_recIdents = _out899;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1435_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1436_recOwned;
+                    isErased = _1437_recErased;
+                    readIdents = _1438_recIdents;
+                  }
+                } else if (_source51.is_Set) {
+                  DAST._IType _1439___mcc_h785 = _source51.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1302_recursiveGen;
-                    bool _1303_recOwned;
-                    bool _1304_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1305_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out801;
-                    bool _out802;
-                    bool _out803;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out804;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out801, out _out802, out _out803, out _out804);
-                    _1302_recursiveGen = _out801;
-                    _1303_recOwned = _out802;
-                    _1304_recErased = _out803;
-                    _1305_recIdents = _out804;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1302_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1303_recOwned;
-                    isErased = _1304_recErased;
-                    readIdents = _1305_recIdents;
-                  }
-                } else if (_source49.is_Map) {
-                  DAST._IType _1306___mcc_h575 = _source49.dtor_key;
-                  DAST._IType _1307___mcc_h576 = _source49.dtor_value;
+                    Dafny.ISequence<Dafny.Rune> _1440_recursiveGen;
+                    bool _1441_recOwned;
+                    bool _1442_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1443_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out900;
+                    bool _out901;
+                    bool _out902;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out903;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out900, out _out901, out _out902, out _out903);
+                    _1440_recursiveGen = _out900;
+                    _1441_recOwned = _out901;
+                    _1442_recErased = _out902;
+                    _1443_recIdents = _out903;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1440_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1441_recOwned;
+                    isErased = _1442_recErased;
+                    readIdents = _1443_recIdents;
+                  }
+                } else if (_source51.is_Multiset) {
+                  DAST._IType _1444___mcc_h787 = _source51.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1308_recursiveGen;
-                    bool _1309_recOwned;
-                    bool _1310_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1311_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out805;
-                    bool _out806;
-                    bool _out807;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out808;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out805, out _out806, out _out807, out _out808);
-                    _1308_recursiveGen = _out805;
-                    _1309_recOwned = _out806;
-                    _1310_recErased = _out807;
-                    _1311_recIdents = _out808;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1308_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1309_recOwned;
-                    isErased = _1310_recErased;
-                    readIdents = _1311_recIdents;
-                  }
-                } else if (_source49.is_Arrow) {
-                  Dafny.ISequence<DAST._IType> _1312___mcc_h579 = _source49.dtor_args;
-                  DAST._IType _1313___mcc_h580 = _source49.dtor_result;
+                    Dafny.ISequence<Dafny.Rune> _1445_recursiveGen;
+                    bool _1446_recOwned;
+                    bool _1447_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1448_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out904;
+                    bool _out905;
+                    bool _out906;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out907;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out904, out _out905, out _out906, out _out907);
+                    _1445_recursiveGen = _out904;
+                    _1446_recOwned = _out905;
+                    _1447_recErased = _out906;
+                    _1448_recIdents = _out907;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1445_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1446_recOwned;
+                    isErased = _1447_recErased;
+                    readIdents = _1448_recIdents;
+                  }
+                } else if (_source51.is_Map) {
+                  DAST._IType _1449___mcc_h789 = _source51.dtor_key;
+                  DAST._IType _1450___mcc_h790 = _source51.dtor_value;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1314_recursiveGen;
-                    bool _1315_recOwned;
-                    bool _1316_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1317_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out809;
-                    bool _out810;
-                    bool _out811;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out812;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out809, out _out810, out _out811, out _out812);
-                    _1314_recursiveGen = _out809;
-                    _1315_recOwned = _out810;
-                    _1316_recErased = _out811;
-                    _1317_recIdents = _out812;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1314_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1315_recOwned;
-                    isErased = _1316_recErased;
-                    readIdents = _1317_recIdents;
-                  }
-                } else if (_source49.is_Primitive) {
-                  DAST._IPrimitive _1318___mcc_h583 = _source49.dtor_Primitive_a0;
-                  DAST._IPrimitive _source51 = _1318___mcc_h583;
-                  if (_source51.is_Int) {
+                    Dafny.ISequence<Dafny.Rune> _1451_recursiveGen;
+                    bool _1452_recOwned;
+                    bool _1453_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1454_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out908;
+                    bool _out909;
+                    bool _out910;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out911;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out908, out _out909, out _out910, out _out911);
+                    _1451_recursiveGen = _out908;
+                    _1452_recOwned = _out909;
+                    _1453_recErased = _out910;
+                    _1454_recIdents = _out911;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1451_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1452_recOwned;
+                    isErased = _1453_recErased;
+                    readIdents = _1454_recIdents;
+                  }
+                } else if (_source51.is_Arrow) {
+                  Dafny.ISequence<DAST._IType> _1455___mcc_h793 = _source51.dtor_args;
+                  DAST._IType _1456___mcc_h794 = _source51.dtor_result;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1457_recursiveGen;
+                    bool _1458_recOwned;
+                    bool _1459_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1460_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out912;
+                    bool _out913;
+                    bool _out914;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out915;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out912, out _out913, out _out914, out _out915);
+                    _1457_recursiveGen = _out912;
+                    _1458_recOwned = _out913;
+                    _1459_recErased = _out914;
+                    _1460_recIdents = _out915;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1457_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1458_recOwned;
+                    isErased = _1459_recErased;
+                    readIdents = _1460_recIdents;
+                  }
+                } else if (_source51.is_Primitive) {
+                  DAST._IPrimitive _1461___mcc_h797 = _source51.dtor_Primitive_a0;
+                  DAST._IPrimitive _source53 = _1461___mcc_h797;
+                  if (_source53.is_Int) {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1319_recursiveGen;
-                      bool _1320_recOwned;
-                      bool _1321_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1322_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out813;
-                      bool _out814;
-                      bool _out815;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out816;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out813, out _out814, out _out815, out _out816);
-                      _1319_recursiveGen = _out813;
-                      _1320_recOwned = _out814;
-                      _1321_recErased = _out815;
-                      _1322_recIdents = _out816;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1319_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1320_recOwned;
-                      isErased = _1321_recErased;
-                      readIdents = _1322_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1462_recursiveGen;
+                      bool _1463_recOwned;
+                      bool _1464_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1465_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out916;
+                      bool _out917;
+                      bool _out918;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out919;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out916, out _out917, out _out918, out _out919);
+                      _1462_recursiveGen = _out916;
+                      _1463_recOwned = _out917;
+                      _1464_recErased = _out918;
+                      _1465_recIdents = _out919;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1462_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1463_recOwned;
+                      isErased = _1464_recErased;
+                      readIdents = _1465_recIdents;
                     }
-                  } else if (_source51.is_Real) {
+                  } else if (_source53.is_Real) {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1323_recursiveGen;
-                      bool _1324___v40;
-                      bool _1325___v41;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1326_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out817;
-                      bool _out818;
-                      bool _out819;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out820;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, true, out _out817, out _out818, out _out819, out _out820);
-                      _1323_recursiveGen = _out817;
-                      _1324___v40 = _out818;
-                      _1325___v41 = _out819;
-                      _1326_recIdents = _out820;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigRational::from_integer("), _1323_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      Dafny.ISequence<Dafny.Rune> _1466_recursiveGen;
+                      bool _1467___v44;
+                      bool _1468___v45;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1469_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out920;
+                      bool _out921;
+                      bool _out922;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out923;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, true, out _out920, out _out921, out _out922, out _out923);
+                      _1466_recursiveGen = _out920;
+                      _1467___v44 = _out921;
+                      _1468___v45 = _out922;
+                      _1469_recIdents = _out923;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigRational::from_integer("), _1466_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
                       isOwned = true;
                       isErased = true;
-                      readIdents = _1326_recIdents;
+                      readIdents = _1469_recIdents;
                     }
-                  } else if (_source51.is_String) {
+                  } else if (_source53.is_String) {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1327_recursiveGen;
-                      bool _1328_recOwned;
-                      bool _1329_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1330_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out821;
-                      bool _out822;
-                      bool _out823;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out824;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out821, out _out822, out _out823, out _out824);
-                      _1327_recursiveGen = _out821;
-                      _1328_recOwned = _out822;
-                      _1329_recErased = _out823;
-                      _1330_recIdents = _out824;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1327_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1328_recOwned;
-                      isErased = _1329_recErased;
-                      readIdents = _1330_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1470_recursiveGen;
+                      bool _1471_recOwned;
+                      bool _1472_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1473_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out924;
+                      bool _out925;
+                      bool _out926;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out927;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out924, out _out925, out _out926, out _out927);
+                      _1470_recursiveGen = _out924;
+                      _1471_recOwned = _out925;
+                      _1472_recErased = _out926;
+                      _1473_recIdents = _out927;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1470_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1471_recOwned;
+                      isErased = _1472_recErased;
+                      readIdents = _1473_recIdents;
                     }
-                  } else if (_source51.is_Bool) {
+                  } else if (_source53.is_Bool) {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1331_recursiveGen;
-                      bool _1332_recOwned;
-                      bool _1333_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1334_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out825;
-                      bool _out826;
-                      bool _out827;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out828;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out825, out _out826, out _out827, out _out828);
-                      _1331_recursiveGen = _out825;
-                      _1332_recOwned = _out826;
-                      _1333_recErased = _out827;
-                      _1334_recIdents = _out828;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1331_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1332_recOwned;
-                      isErased = _1333_recErased;
-                      readIdents = _1334_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1474_recursiveGen;
+                      bool _1475_recOwned;
+                      bool _1476_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1477_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out928;
+                      bool _out929;
+                      bool _out930;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out931;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out928, out _out929, out _out930, out _out931);
+                      _1474_recursiveGen = _out928;
+                      _1475_recOwned = _out929;
+                      _1476_recErased = _out930;
+                      _1477_recIdents = _out931;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1474_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1475_recOwned;
+                      isErased = _1476_recErased;
+                      readIdents = _1477_recIdents;
                     }
                   } else {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1335_rhsType;
-                      Dafny.ISequence<Dafny.Rune> _out829;
-                      _out829 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                      _1335_rhsType = _out829;
-                      Dafny.ISequence<Dafny.Rune> _1336_recursiveGen;
-                      bool _1337___v50;
-                      bool _1338___v51;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1339_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out830;
-                      bool _out831;
-                      bool _out832;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out833;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, true, out _out830, out _out831, out _out832, out _out833);
-                      _1336_recursiveGen = _out830;
-                      _1337___v50 = _out831;
-                      _1338___v51 = _out832;
-                      _1339_recIdents = _out833;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("char::from_u32(<u32 as ::dafny_runtime::NumCast>::from("), _1336_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap()).unwrap()"));
+                      Dafny.ISequence<Dafny.Rune> _1478_rhsType;
+                      Dafny.ISequence<Dafny.Rune> _out932;
+                      _out932 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                      _1478_rhsType = _out932;
+                      Dafny.ISequence<Dafny.Rune> _1479_recursiveGen;
+                      bool _1480___v54;
+                      bool _1481___v55;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1482_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out933;
+                      bool _out934;
+                      bool _out935;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out936;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, true, out _out933, out _out934, out _out935, out _out936);
+                      _1479_recursiveGen = _out933;
+                      _1480___v54 = _out934;
+                      _1481___v55 = _out935;
+                      _1482_recIdents = _out936;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("char::from_u32(<u32 as ::dafny_runtime::NumCast>::from("), _1479_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap()).unwrap()"));
                       isOwned = true;
                       isErased = true;
-                      readIdents = _1339_recIdents;
+                      readIdents = _1482_recIdents;
                     }
                   }
-                } else if (_source49.is_Passthrough) {
-                  Dafny.ISequence<Dafny.Rune> _1340___mcc_h585 = _source49.dtor_Passthrough_a0;
+                } else if (_source51.is_Passthrough) {
+                  Dafny.ISequence<Dafny.Rune> _1483___mcc_h799 = _source51.dtor_Passthrough_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1341_rhsType;
-                    Dafny.ISequence<Dafny.Rune> _out834;
-                    _out834 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                    _1341_rhsType = _out834;
-                    Dafny.ISequence<Dafny.Rune> _1342_recursiveGen;
-                    bool _1343___v45;
-                    bool _1344___v46;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1345_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out835;
-                    bool _out836;
-                    bool _out837;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out838;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, true, out _out835, out _out836, out _out837, out _out838);
-                    _1342_recursiveGen = _out835;
-                    _1343___v45 = _out836;
-                    _1344___v46 = _out837;
-                    _1345_recIdents = _out838;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1341_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::NumCast>::from(")), _1342_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap()"));
+                    Dafny.ISequence<Dafny.Rune> _1484_rhsType;
+                    Dafny.ISequence<Dafny.Rune> _out937;
+                    _out937 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                    _1484_rhsType = _out937;
+                    Dafny.ISequence<Dafny.Rune> _1485_recursiveGen;
+                    bool _1486___v49;
+                    bool _1487___v50;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1488_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out938;
+                    bool _out939;
+                    bool _out940;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out941;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, true, out _out938, out _out939, out _out940, out _out941);
+                    _1485_recursiveGen = _out938;
+                    _1486___v49 = _out939;
+                    _1487___v50 = _out940;
+                    _1488_recIdents = _out941;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1484_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::NumCast>::from(")), _1485_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap()"));
                     isOwned = true;
                     isErased = true;
-                    readIdents = _1345_recIdents;
+                    readIdents = _1488_recIdents;
                   }
                 } else {
-                  Dafny.ISequence<Dafny.Rune> _1346___mcc_h587 = _source49.dtor_TypeArg_a0;
+                  Dafny.ISequence<Dafny.Rune> _1489___mcc_h801 = _source51.dtor_TypeArg_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1347_recursiveGen;
-                    bool _1348_recOwned;
-                    bool _1349_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1350_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out839;
-                    bool _out840;
-                    bool _out841;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out842;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out839, out _out840, out _out841, out _out842);
-                    _1347_recursiveGen = _out839;
-                    _1348_recOwned = _out840;
-                    _1349_recErased = _out841;
-                    _1350_recIdents = _out842;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1347_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1348_recOwned;
-                    isErased = _1349_recErased;
-                    readIdents = _1350_recIdents;
-                  }
-                }
-              } else if (_source48.is_Real) {
-                DAST._IType _source52 = _489___mcc_h124;
-                if (_source52.is_Path) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1351___mcc_h589 = _source52.dtor_Path_a0;
-                  Dafny.ISequence<DAST._IType> _1352___mcc_h590 = _source52.dtor_typeArgs;
-                  DAST._IResolvedType _1353___mcc_h591 = _source52.dtor_resolved;
-                  DAST._IResolvedType _source53 = _1353___mcc_h591;
-                  if (_source53.is_Datatype) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1354___mcc_h595 = _source53.dtor_path;
+                    Dafny.ISequence<Dafny.Rune> _1490_recursiveGen;
+                    bool _1491_recOwned;
+                    bool _1492_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1493_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out942;
+                    bool _out943;
+                    bool _out944;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out945;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out942, out _out943, out _out944, out _out945);
+                    _1490_recursiveGen = _out942;
+                    _1491_recOwned = _out943;
+                    _1492_recErased = _out944;
+                    _1493_recIdents = _out945;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1490_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1491_recOwned;
+                    isErased = _1492_recErased;
+                    readIdents = _1493_recIdents;
+                  }
+                }
+              } else if (_source50.is_Real) {
+                DAST._IType _source54 = _501___mcc_h238;
+                if (_source54.is_Path) {
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1494___mcc_h803 = _source54.dtor_Path_a0;
+                  Dafny.ISequence<DAST._IType> _1495___mcc_h804 = _source54.dtor_typeArgs;
+                  DAST._IResolvedType _1496___mcc_h805 = _source54.dtor_resolved;
+                  DAST._IResolvedType _source55 = _1496___mcc_h805;
+                  if (_source55.is_Datatype) {
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1497___mcc_h809 = _source55.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _1355_recursiveGen;
-                      bool _1356_recOwned;
-                      bool _1357_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1358_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out843;
-                      bool _out844;
-                      bool _out845;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out846;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out843, out _out844, out _out845, out _out846);
-                      _1355_recursiveGen = _out843;
-                      _1356_recOwned = _out844;
-                      _1357_recErased = _out845;
-                      _1358_recIdents = _out846;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1355_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1356_recOwned;
-                      isErased = _1357_recErased;
-                      readIdents = _1358_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1498_recursiveGen;
+                      bool _1499_recOwned;
+                      bool _1500_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1501_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out946;
+                      bool _out947;
+                      bool _out948;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out949;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out946, out _out947, out _out948, out _out949);
+                      _1498_recursiveGen = _out946;
+                      _1499_recOwned = _out947;
+                      _1500_recErased = _out948;
+                      _1501_recIdents = _out949;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1498_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1499_recOwned;
+                      isErased = _1500_recErased;
+                      readIdents = _1501_recIdents;
                     }
-                  } else if (_source53.is_Trait) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1359___mcc_h597 = _source53.dtor_path;
+                  } else if (_source55.is_Trait) {
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1502___mcc_h811 = _source55.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _1360_recursiveGen;
-                      bool _1361_recOwned;
-                      bool _1362_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1363_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out847;
-                      bool _out848;
-                      bool _out849;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out850;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out847, out _out848, out _out849, out _out850);
-                      _1360_recursiveGen = _out847;
-                      _1361_recOwned = _out848;
-                      _1362_recErased = _out849;
-                      _1363_recIdents = _out850;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1360_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1361_recOwned;
-                      isErased = _1362_recErased;
-                      readIdents = _1363_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1503_recursiveGen;
+                      bool _1504_recOwned;
+                      bool _1505_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1506_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out950;
+                      bool _out951;
+                      bool _out952;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out953;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out950, out _out951, out _out952, out _out953);
+                      _1503_recursiveGen = _out950;
+                      _1504_recOwned = _out951;
+                      _1505_recErased = _out952;
+                      _1506_recIdents = _out953;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1503_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1504_recOwned;
+                      isErased = _1505_recErased;
+                      readIdents = _1506_recIdents;
                     }
                   } else {
-                    DAST._IType _1364___mcc_h599 = _source53.dtor_Newtype_a0;
-                    DAST._IType _1365_b = _1364___mcc_h599;
+                    DAST._IType _1507___mcc_h813 = _source55.dtor_Newtype_a0;
+                    DAST._IType _1508_b = _1507___mcc_h813;
                     {
-                      if (object.Equals(_482_fromTpe, _1365_b)) {
-                        Dafny.ISequence<Dafny.Rune> _1366_recursiveGen;
-                        bool _1367_recOwned;
-                        bool _1368_recErased;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1369_recIdents;
-                        Dafny.ISequence<Dafny.Rune> _out851;
-                        bool _out852;
-                        bool _out853;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out854;
-                        DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out851, out _out852, out _out853, out _out854);
-                        _1366_recursiveGen = _out851;
-                        _1367_recOwned = _out852;
-                        _1368_recErased = _out853;
-                        _1369_recIdents = _out854;
-                        Dafny.ISequence<Dafny.Rune> _1370_rhsType;
-                        Dafny.ISequence<Dafny.Rune> _out855;
-                        _out855 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                        _1370_rhsType = _out855;
-                        Dafny.ISequence<Dafny.Rune> _1371_uneraseFn;
-                        _1371_uneraseFn = ((_1367_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1370_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1371_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1366_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                        isOwned = _1367_recOwned;
+                      if (object.Equals(_494_fromTpe, _1508_b)) {
+                        Dafny.ISequence<Dafny.Rune> _1509_recursiveGen;
+                        bool _1510_recOwned;
+                        bool _1511_recErased;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1512_recIdents;
+                        Dafny.ISequence<Dafny.Rune> _out954;
+                        bool _out955;
+                        bool _out956;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out957;
+                        DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out954, out _out955, out _out956, out _out957);
+                        _1509_recursiveGen = _out954;
+                        _1510_recOwned = _out955;
+                        _1511_recErased = _out956;
+                        _1512_recIdents = _out957;
+                        Dafny.ISequence<Dafny.Rune> _1513_rhsType;
+                        Dafny.ISequence<Dafny.Rune> _out958;
+                        _out958 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                        _1513_rhsType = _out958;
+                        Dafny.ISequence<Dafny.Rune> _1514_uneraseFn;
+                        _1514_uneraseFn = ((_1510_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1513_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1514_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1509_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                        isOwned = _1510_recOwned;
                         isErased = false;
-                        readIdents = _1369_recIdents;
+                        readIdents = _1512_recIdents;
                       } else {
-                        Dafny.ISequence<Dafny.Rune> _out856;
-                        bool _out857;
-                        bool _out858;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out859;
-                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _1365_b), _1365_b, _481_toTpe), @params, mustOwn, out _out856, out _out857, out _out858, out _out859);
-                        s = _out856;
-                        isOwned = _out857;
-                        isErased = _out858;
-                        readIdents = _out859;
+                        Dafny.ISequence<Dafny.Rune> _out959;
+                        bool _out960;
+                        bool _out961;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out962;
+                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1508_b), _1508_b, _493_toTpe), selfIdent, @params, mustOwn, out _out959, out _out960, out _out961, out _out962);
+                        s = _out959;
+                        isOwned = _out960;
+                        isErased = _out961;
+                        readIdents = _out962;
                       }
                     }
                   }
-                } else if (_source52.is_Tuple) {
-                  Dafny.ISequence<DAST._IType> _1372___mcc_h601 = _source52.dtor_Tuple_a0;
+                } else if (_source54.is_Nullable) {
+                  DAST._IType _1515___mcc_h815 = _source54.dtor_Nullable_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1516_recursiveGen;
+                    bool _1517_recOwned;
+                    bool _1518_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1519_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out963;
+                    bool _out964;
+                    bool _out965;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out966;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out963, out _out964, out _out965, out _out966);
+                    _1516_recursiveGen = _out963;
+                    _1517_recOwned = _out964;
+                    _1518_recErased = _out965;
+                    _1519_recIdents = _out966;
+                    if (!(_1517_recOwned)) {
+                      _1516_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1516_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                    }
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1516_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                    isOwned = true;
+                    isErased = _1518_recErased;
+                    readIdents = _1519_recIdents;
+                  }
+                } else if (_source54.is_Tuple) {
+                  Dafny.ISequence<DAST._IType> _1520___mcc_h817 = _source54.dtor_Tuple_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1373_recursiveGen;
-                    bool _1374_recOwned;
-                    bool _1375_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1376_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out860;
-                    bool _out861;
-                    bool _out862;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out863;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out860, out _out861, out _out862, out _out863);
-                    _1373_recursiveGen = _out860;
-                    _1374_recOwned = _out861;
-                    _1375_recErased = _out862;
-                    _1376_recIdents = _out863;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1373_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1374_recOwned;
-                    isErased = _1375_recErased;
-                    readIdents = _1376_recIdents;
-                  }
-                } else if (_source52.is_Array) {
-                  DAST._IType _1377___mcc_h603 = _source52.dtor_element;
+                    Dafny.ISequence<Dafny.Rune> _1521_recursiveGen;
+                    bool _1522_recOwned;
+                    bool _1523_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1524_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out967;
+                    bool _out968;
+                    bool _out969;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out970;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out967, out _out968, out _out969, out _out970);
+                    _1521_recursiveGen = _out967;
+                    _1522_recOwned = _out968;
+                    _1523_recErased = _out969;
+                    _1524_recIdents = _out970;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1521_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1522_recOwned;
+                    isErased = _1523_recErased;
+                    readIdents = _1524_recIdents;
+                  }
+                } else if (_source54.is_Array) {
+                  DAST._IType _1525___mcc_h819 = _source54.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1378_recursiveGen;
-                    bool _1379_recOwned;
-                    bool _1380_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1381_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out864;
-                    bool _out865;
-                    bool _out866;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out867;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out864, out _out865, out _out866, out _out867);
-                    _1378_recursiveGen = _out864;
-                    _1379_recOwned = _out865;
-                    _1380_recErased = _out866;
-                    _1381_recIdents = _out867;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1378_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1379_recOwned;
-                    isErased = _1380_recErased;
-                    readIdents = _1381_recIdents;
-                  }
-                } else if (_source52.is_Seq) {
-                  DAST._IType _1382___mcc_h605 = _source52.dtor_element;
+                    Dafny.ISequence<Dafny.Rune> _1526_recursiveGen;
+                    bool _1527_recOwned;
+                    bool _1528_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1529_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out971;
+                    bool _out972;
+                    bool _out973;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out974;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out971, out _out972, out _out973, out _out974);
+                    _1526_recursiveGen = _out971;
+                    _1527_recOwned = _out972;
+                    _1528_recErased = _out973;
+                    _1529_recIdents = _out974;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1526_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1527_recOwned;
+                    isErased = _1528_recErased;
+                    readIdents = _1529_recIdents;
+                  }
+                } else if (_source54.is_Seq) {
+                  DAST._IType _1530___mcc_h821 = _source54.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1383_recursiveGen;
-                    bool _1384_recOwned;
-                    bool _1385_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1386_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out868;
-                    bool _out869;
-                    bool _out870;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out871;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out868, out _out869, out _out870, out _out871);
-                    _1383_recursiveGen = _out868;
-                    _1384_recOwned = _out869;
-                    _1385_recErased = _out870;
-                    _1386_recIdents = _out871;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1383_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1384_recOwned;
-                    isErased = _1385_recErased;
-                    readIdents = _1386_recIdents;
-                  }
-                } else if (_source52.is_Set) {
-                  DAST._IType _1387___mcc_h607 = _source52.dtor_element;
+                    Dafny.ISequence<Dafny.Rune> _1531_recursiveGen;
+                    bool _1532_recOwned;
+                    bool _1533_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1534_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out975;
+                    bool _out976;
+                    bool _out977;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out978;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out975, out _out976, out _out977, out _out978);
+                    _1531_recursiveGen = _out975;
+                    _1532_recOwned = _out976;
+                    _1533_recErased = _out977;
+                    _1534_recIdents = _out978;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1531_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1532_recOwned;
+                    isErased = _1533_recErased;
+                    readIdents = _1534_recIdents;
+                  }
+                } else if (_source54.is_Set) {
+                  DAST._IType _1535___mcc_h823 = _source54.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1388_recursiveGen;
-                    bool _1389_recOwned;
-                    bool _1390_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1391_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out872;
-                    bool _out873;
-                    bool _out874;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out875;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out872, out _out873, out _out874, out _out875);
-                    _1388_recursiveGen = _out872;
-                    _1389_recOwned = _out873;
-                    _1390_recErased = _out874;
-                    _1391_recIdents = _out875;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1388_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1389_recOwned;
-                    isErased = _1390_recErased;
-                    readIdents = _1391_recIdents;
-                  }
-                } else if (_source52.is_Multiset) {
-                  DAST._IType _1392___mcc_h609 = _source52.dtor_element;
+                    Dafny.ISequence<Dafny.Rune> _1536_recursiveGen;
+                    bool _1537_recOwned;
+                    bool _1538_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1539_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out979;
+                    bool _out980;
+                    bool _out981;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out982;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out979, out _out980, out _out981, out _out982);
+                    _1536_recursiveGen = _out979;
+                    _1537_recOwned = _out980;
+                    _1538_recErased = _out981;
+                    _1539_recIdents = _out982;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1536_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1537_recOwned;
+                    isErased = _1538_recErased;
+                    readIdents = _1539_recIdents;
+                  }
+                } else if (_source54.is_Multiset) {
+                  DAST._IType _1540___mcc_h825 = _source54.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1393_recursiveGen;
-                    bool _1394_recOwned;
-                    bool _1395_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1396_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out876;
-                    bool _out877;
-                    bool _out878;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out879;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out876, out _out877, out _out878, out _out879);
-                    _1393_recursiveGen = _out876;
-                    _1394_recOwned = _out877;
-                    _1395_recErased = _out878;
-                    _1396_recIdents = _out879;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1393_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1394_recOwned;
-                    isErased = _1395_recErased;
-                    readIdents = _1396_recIdents;
-                  }
-                } else if (_source52.is_Map) {
-                  DAST._IType _1397___mcc_h611 = _source52.dtor_key;
-                  DAST._IType _1398___mcc_h612 = _source52.dtor_value;
+                    Dafny.ISequence<Dafny.Rune> _1541_recursiveGen;
+                    bool _1542_recOwned;
+                    bool _1543_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1544_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out983;
+                    bool _out984;
+                    bool _out985;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out986;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out983, out _out984, out _out985, out _out986);
+                    _1541_recursiveGen = _out983;
+                    _1542_recOwned = _out984;
+                    _1543_recErased = _out985;
+                    _1544_recIdents = _out986;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1541_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1542_recOwned;
+                    isErased = _1543_recErased;
+                    readIdents = _1544_recIdents;
+                  }
+                } else if (_source54.is_Map) {
+                  DAST._IType _1545___mcc_h827 = _source54.dtor_key;
+                  DAST._IType _1546___mcc_h828 = _source54.dtor_value;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1399_recursiveGen;
-                    bool _1400_recOwned;
-                    bool _1401_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1402_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out880;
-                    bool _out881;
-                    bool _out882;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out883;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out880, out _out881, out _out882, out _out883);
-                    _1399_recursiveGen = _out880;
-                    _1400_recOwned = _out881;
-                    _1401_recErased = _out882;
-                    _1402_recIdents = _out883;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1399_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1400_recOwned;
-                    isErased = _1401_recErased;
-                    readIdents = _1402_recIdents;
-                  }
-                } else if (_source52.is_Arrow) {
-                  Dafny.ISequence<DAST._IType> _1403___mcc_h615 = _source52.dtor_args;
-                  DAST._IType _1404___mcc_h616 = _source52.dtor_result;
+                    Dafny.ISequence<Dafny.Rune> _1547_recursiveGen;
+                    bool _1548_recOwned;
+                    bool _1549_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1550_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out987;
+                    bool _out988;
+                    bool _out989;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out990;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out987, out _out988, out _out989, out _out990);
+                    _1547_recursiveGen = _out987;
+                    _1548_recOwned = _out988;
+                    _1549_recErased = _out989;
+                    _1550_recIdents = _out990;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1547_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1548_recOwned;
+                    isErased = _1549_recErased;
+                    readIdents = _1550_recIdents;
+                  }
+                } else if (_source54.is_Arrow) {
+                  Dafny.ISequence<DAST._IType> _1551___mcc_h831 = _source54.dtor_args;
+                  DAST._IType _1552___mcc_h832 = _source54.dtor_result;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1405_recursiveGen;
-                    bool _1406_recOwned;
-                    bool _1407_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1408_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out884;
-                    bool _out885;
-                    bool _out886;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out887;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out884, out _out885, out _out886, out _out887);
-                    _1405_recursiveGen = _out884;
-                    _1406_recOwned = _out885;
-                    _1407_recErased = _out886;
-                    _1408_recIdents = _out887;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1405_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1406_recOwned;
-                    isErased = _1407_recErased;
-                    readIdents = _1408_recIdents;
-                  }
-                } else if (_source52.is_Primitive) {
-                  DAST._IPrimitive _1409___mcc_h619 = _source52.dtor_Primitive_a0;
-                  DAST._IPrimitive _source54 = _1409___mcc_h619;
-                  if (_source54.is_Int) {
+                    Dafny.ISequence<Dafny.Rune> _1553_recursiveGen;
+                    bool _1554_recOwned;
+                    bool _1555_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1556_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out991;
+                    bool _out992;
+                    bool _out993;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out994;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out991, out _out992, out _out993, out _out994);
+                    _1553_recursiveGen = _out991;
+                    _1554_recOwned = _out992;
+                    _1555_recErased = _out993;
+                    _1556_recIdents = _out994;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1553_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1554_recOwned;
+                    isErased = _1555_recErased;
+                    readIdents = _1556_recIdents;
+                  }
+                } else if (_source54.is_Primitive) {
+                  DAST._IPrimitive _1557___mcc_h835 = _source54.dtor_Primitive_a0;
+                  DAST._IPrimitive _source56 = _1557___mcc_h835;
+                  if (_source56.is_Int) {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1410_recursiveGen;
-                      bool _1411___v42;
-                      bool _1412___v43;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1413_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out888;
-                      bool _out889;
-                      bool _out890;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out891;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, false, out _out888, out _out889, out _out890, out _out891);
-                      _1410_recursiveGen = _out888;
-                      _1411___v42 = _out889;
-                      _1412___v43 = _out890;
-                      _1413_recIdents = _out891;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::dafny_rational_to_int("), _1410_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      Dafny.ISequence<Dafny.Rune> _1558_recursiveGen;
+                      bool _1559___v46;
+                      bool _1560___v47;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1561_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out995;
+                      bool _out996;
+                      bool _out997;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out998;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, false, out _out995, out _out996, out _out997, out _out998);
+                      _1558_recursiveGen = _out995;
+                      _1559___v46 = _out996;
+                      _1560___v47 = _out997;
+                      _1561_recIdents = _out998;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::dafny_rational_to_int("), _1558_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
                       isOwned = true;
                       isErased = true;
-                      readIdents = _1413_recIdents;
+                      readIdents = _1561_recIdents;
                     }
-                  } else if (_source54.is_Real) {
+                  } else if (_source56.is_Real) {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1414_recursiveGen;
-                      bool _1415_recOwned;
-                      bool _1416_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1417_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out892;
-                      bool _out893;
-                      bool _out894;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out895;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out892, out _out893, out _out894, out _out895);
-                      _1414_recursiveGen = _out892;
-                      _1415_recOwned = _out893;
-                      _1416_recErased = _out894;
-                      _1417_recIdents = _out895;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1414_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1415_recOwned;
-                      isErased = _1416_recErased;
-                      readIdents = _1417_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1562_recursiveGen;
+                      bool _1563_recOwned;
+                      bool _1564_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1565_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out999;
+                      bool _out1000;
+                      bool _out1001;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1002;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out999, out _out1000, out _out1001, out _out1002);
+                      _1562_recursiveGen = _out999;
+                      _1563_recOwned = _out1000;
+                      _1564_recErased = _out1001;
+                      _1565_recIdents = _out1002;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1562_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1563_recOwned;
+                      isErased = _1564_recErased;
+                      readIdents = _1565_recIdents;
                     }
-                  } else if (_source54.is_String) {
+                  } else if (_source56.is_String) {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1418_recursiveGen;
-                      bool _1419_recOwned;
-                      bool _1420_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1421_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out896;
-                      bool _out897;
-                      bool _out898;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out899;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out896, out _out897, out _out898, out _out899);
-                      _1418_recursiveGen = _out896;
-                      _1419_recOwned = _out897;
-                      _1420_recErased = _out898;
-                      _1421_recIdents = _out899;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1418_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1419_recOwned;
-                      isErased = _1420_recErased;
-                      readIdents = _1421_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1566_recursiveGen;
+                      bool _1567_recOwned;
+                      bool _1568_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1569_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1003;
+                      bool _out1004;
+                      bool _out1005;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1006;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1003, out _out1004, out _out1005, out _out1006);
+                      _1566_recursiveGen = _out1003;
+                      _1567_recOwned = _out1004;
+                      _1568_recErased = _out1005;
+                      _1569_recIdents = _out1006;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1566_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1567_recOwned;
+                      isErased = _1568_recErased;
+                      readIdents = _1569_recIdents;
                     }
-                  } else if (_source54.is_Bool) {
+                  } else if (_source56.is_Bool) {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1422_recursiveGen;
-                      bool _1423_recOwned;
-                      bool _1424_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1425_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out900;
-                      bool _out901;
-                      bool _out902;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out903;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out900, out _out901, out _out902, out _out903);
-                      _1422_recursiveGen = _out900;
-                      _1423_recOwned = _out901;
-                      _1424_recErased = _out902;
-                      _1425_recIdents = _out903;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1422_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1423_recOwned;
-                      isErased = _1424_recErased;
-                      readIdents = _1425_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1570_recursiveGen;
+                      bool _1571_recOwned;
+                      bool _1572_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1573_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1007;
+                      bool _out1008;
+                      bool _out1009;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1010;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1007, out _out1008, out _out1009, out _out1010);
+                      _1570_recursiveGen = _out1007;
+                      _1571_recOwned = _out1008;
+                      _1572_recErased = _out1009;
+                      _1573_recIdents = _out1010;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1570_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1571_recOwned;
+                      isErased = _1572_recErased;
+                      readIdents = _1573_recIdents;
                     }
                   } else {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1426_recursiveGen;
-                      bool _1427_recOwned;
-                      bool _1428_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1429_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out904;
-                      bool _out905;
-                      bool _out906;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out907;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out904, out _out905, out _out906, out _out907);
-                      _1426_recursiveGen = _out904;
-                      _1427_recOwned = _out905;
-                      _1428_recErased = _out906;
-                      _1429_recIdents = _out907;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1426_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1427_recOwned;
-                      isErased = _1428_recErased;
-                      readIdents = _1429_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1574_recursiveGen;
+                      bool _1575_recOwned;
+                      bool _1576_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1577_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1011;
+                      bool _out1012;
+                      bool _out1013;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1014;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1011, out _out1012, out _out1013, out _out1014);
+                      _1574_recursiveGen = _out1011;
+                      _1575_recOwned = _out1012;
+                      _1576_recErased = _out1013;
+                      _1577_recIdents = _out1014;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1574_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1575_recOwned;
+                      isErased = _1576_recErased;
+                      readIdents = _1577_recIdents;
                     }
                   }
-                } else if (_source52.is_Passthrough) {
-                  Dafny.ISequence<Dafny.Rune> _1430___mcc_h621 = _source52.dtor_Passthrough_a0;
+                } else if (_source54.is_Passthrough) {
+                  Dafny.ISequence<Dafny.Rune> _1578___mcc_h837 = _source54.dtor_Passthrough_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1431_recursiveGen;
-                    bool _1432_recOwned;
-                    bool _1433_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1434_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out908;
-                    bool _out909;
-                    bool _out910;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out911;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out908, out _out909, out _out910, out _out911);
-                    _1431_recursiveGen = _out908;
-                    _1432_recOwned = _out909;
-                    _1433_recErased = _out910;
-                    _1434_recIdents = _out911;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1431_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1432_recOwned;
-                    isErased = _1433_recErased;
-                    readIdents = _1434_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1579_recursiveGen;
+                    bool _1580_recOwned;
+                    bool _1581_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1582_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1015;
+                    bool _out1016;
+                    bool _out1017;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1018;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1015, out _out1016, out _out1017, out _out1018);
+                    _1579_recursiveGen = _out1015;
+                    _1580_recOwned = _out1016;
+                    _1581_recErased = _out1017;
+                    _1582_recIdents = _out1018;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1579_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1580_recOwned;
+                    isErased = _1581_recErased;
+                    readIdents = _1582_recIdents;
                   }
                 } else {
-                  Dafny.ISequence<Dafny.Rune> _1435___mcc_h623 = _source52.dtor_TypeArg_a0;
+                  Dafny.ISequence<Dafny.Rune> _1583___mcc_h839 = _source54.dtor_TypeArg_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1436_recursiveGen;
-                    bool _1437_recOwned;
-                    bool _1438_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1439_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out912;
-                    bool _out913;
-                    bool _out914;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out915;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out912, out _out913, out _out914, out _out915);
-                    _1436_recursiveGen = _out912;
-                    _1437_recOwned = _out913;
-                    _1438_recErased = _out914;
-                    _1439_recIdents = _out915;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1436_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1437_recOwned;
-                    isErased = _1438_recErased;
-                    readIdents = _1439_recIdents;
-                  }
-                }
-              } else if (_source48.is_String) {
-                DAST._IType _source55 = _489___mcc_h124;
-                if (_source55.is_Path) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1440___mcc_h625 = _source55.dtor_Path_a0;
-                  Dafny.ISequence<DAST._IType> _1441___mcc_h626 = _source55.dtor_typeArgs;
-                  DAST._IResolvedType _1442___mcc_h627 = _source55.dtor_resolved;
-                  DAST._IResolvedType _source56 = _1442___mcc_h627;
-                  if (_source56.is_Datatype) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1443___mcc_h631 = _source56.dtor_path;
-                    {
-                      Dafny.ISequence<Dafny.Rune> _1444_recursiveGen;
-                      bool _1445_recOwned;
-                      bool _1446_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1447_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out916;
-                      bool _out917;
-                      bool _out918;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out919;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out916, out _out917, out _out918, out _out919);
-                      _1444_recursiveGen = _out916;
-                      _1445_recOwned = _out917;
-                      _1446_recErased = _out918;
-                      _1447_recIdents = _out919;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1444_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1445_recOwned;
-                      isErased = _1446_recErased;
-                      readIdents = _1447_recIdents;
-                    }
-                  } else if (_source56.is_Trait) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1448___mcc_h633 = _source56.dtor_path;
-                    {
-                      Dafny.ISequence<Dafny.Rune> _1449_recursiveGen;
-                      bool _1450_recOwned;
-                      bool _1451_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1452_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out920;
-                      bool _out921;
-                      bool _out922;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out923;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out920, out _out921, out _out922, out _out923);
-                      _1449_recursiveGen = _out920;
-                      _1450_recOwned = _out921;
-                      _1451_recErased = _out922;
-                      _1452_recIdents = _out923;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1449_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1450_recOwned;
-                      isErased = _1451_recErased;
-                      readIdents = _1452_recIdents;
-                    }
-                  } else {
-                    DAST._IType _1453___mcc_h635 = _source56.dtor_Newtype_a0;
-                    DAST._IType _1454_b = _1453___mcc_h635;
-                    {
-                      if (object.Equals(_482_fromTpe, _1454_b)) {
-                        Dafny.ISequence<Dafny.Rune> _1455_recursiveGen;
-                        bool _1456_recOwned;
-                        bool _1457_recErased;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1458_recIdents;
-                        Dafny.ISequence<Dafny.Rune> _out924;
-                        bool _out925;
-                        bool _out926;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out927;
-                        DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out924, out _out925, out _out926, out _out927);
-                        _1455_recursiveGen = _out924;
-                        _1456_recOwned = _out925;
-                        _1457_recErased = _out926;
-                        _1458_recIdents = _out927;
-                        Dafny.ISequence<Dafny.Rune> _1459_rhsType;
-                        Dafny.ISequence<Dafny.Rune> _out928;
-                        _out928 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                        _1459_rhsType = _out928;
-                        Dafny.ISequence<Dafny.Rune> _1460_uneraseFn;
-                        _1460_uneraseFn = ((_1456_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1459_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1460_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1455_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                        isOwned = _1456_recOwned;
-                        isErased = false;
-                        readIdents = _1458_recIdents;
-                      } else {
-                        Dafny.ISequence<Dafny.Rune> _out929;
-                        bool _out930;
-                        bool _out931;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out932;
-                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _1454_b), _1454_b, _481_toTpe), @params, mustOwn, out _out929, out _out930, out _out931, out _out932);
-                        s = _out929;
-                        isOwned = _out930;
-                        isErased = _out931;
-                        readIdents = _out932;
-                      }
-                    }
-                  }
-                } else if (_source55.is_Tuple) {
-                  Dafny.ISequence<DAST._IType> _1461___mcc_h637 = _source55.dtor_Tuple_a0;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _1462_recursiveGen;
-                    bool _1463_recOwned;
-                    bool _1464_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1465_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out933;
-                    bool _out934;
-                    bool _out935;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out936;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out933, out _out934, out _out935, out _out936);
-                    _1462_recursiveGen = _out933;
-                    _1463_recOwned = _out934;
-                    _1464_recErased = _out935;
-                    _1465_recIdents = _out936;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1462_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1463_recOwned;
-                    isErased = _1464_recErased;
-                    readIdents = _1465_recIdents;
-                  }
-                } else if (_source55.is_Array) {
-                  DAST._IType _1466___mcc_h639 = _source55.dtor_element;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _1467_recursiveGen;
-                    bool _1468_recOwned;
-                    bool _1469_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1470_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out937;
-                    bool _out938;
-                    bool _out939;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out940;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out937, out _out938, out _out939, out _out940);
-                    _1467_recursiveGen = _out937;
-                    _1468_recOwned = _out938;
-                    _1469_recErased = _out939;
-                    _1470_recIdents = _out940;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1467_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1468_recOwned;
-                    isErased = _1469_recErased;
-                    readIdents = _1470_recIdents;
-                  }
-                } else if (_source55.is_Seq) {
-                  DAST._IType _1471___mcc_h641 = _source55.dtor_element;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _1472_recursiveGen;
-                    bool _1473_recOwned;
-                    bool _1474_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1475_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out941;
-                    bool _out942;
-                    bool _out943;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out944;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out941, out _out942, out _out943, out _out944);
-                    _1472_recursiveGen = _out941;
-                    _1473_recOwned = _out942;
-                    _1474_recErased = _out943;
-                    _1475_recIdents = _out944;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1472_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1473_recOwned;
-                    isErased = _1474_recErased;
-                    readIdents = _1475_recIdents;
-                  }
-                } else if (_source55.is_Set) {
-                  DAST._IType _1476___mcc_h643 = _source55.dtor_element;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _1477_recursiveGen;
-                    bool _1478_recOwned;
-                    bool _1479_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1480_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out945;
-                    bool _out946;
-                    bool _out947;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out948;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out945, out _out946, out _out947, out _out948);
-                    _1477_recursiveGen = _out945;
-                    _1478_recOwned = _out946;
-                    _1479_recErased = _out947;
-                    _1480_recIdents = _out948;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1477_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1478_recOwned;
-                    isErased = _1479_recErased;
-                    readIdents = _1480_recIdents;
-                  }
-                } else if (_source55.is_Multiset) {
-                  DAST._IType _1481___mcc_h645 = _source55.dtor_element;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _1482_recursiveGen;
-                    bool _1483_recOwned;
-                    bool _1484_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1485_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out949;
-                    bool _out950;
-                    bool _out951;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out952;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out949, out _out950, out _out951, out _out952);
-                    _1482_recursiveGen = _out949;
-                    _1483_recOwned = _out950;
-                    _1484_recErased = _out951;
-                    _1485_recIdents = _out952;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1482_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1483_recOwned;
-                    isErased = _1484_recErased;
-                    readIdents = _1485_recIdents;
-                  }
-                } else if (_source55.is_Map) {
-                  DAST._IType _1486___mcc_h647 = _source55.dtor_key;
-                  DAST._IType _1487___mcc_h648 = _source55.dtor_value;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _1488_recursiveGen;
-                    bool _1489_recOwned;
-                    bool _1490_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1491_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out953;
-                    bool _out954;
-                    bool _out955;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out956;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out953, out _out954, out _out955, out _out956);
-                    _1488_recursiveGen = _out953;
-                    _1489_recOwned = _out954;
-                    _1490_recErased = _out955;
-                    _1491_recIdents = _out956;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1488_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1489_recOwned;
-                    isErased = _1490_recErased;
-                    readIdents = _1491_recIdents;
-                  }
-                } else if (_source55.is_Arrow) {
-                  Dafny.ISequence<DAST._IType> _1492___mcc_h651 = _source55.dtor_args;
-                  DAST._IType _1493___mcc_h652 = _source55.dtor_result;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _1494_recursiveGen;
-                    bool _1495_recOwned;
-                    bool _1496_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1497_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out957;
-                    bool _out958;
-                    bool _out959;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out960;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out957, out _out958, out _out959, out _out960);
-                    _1494_recursiveGen = _out957;
-                    _1495_recOwned = _out958;
-                    _1496_recErased = _out959;
-                    _1497_recIdents = _out960;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1494_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1495_recOwned;
-                    isErased = _1496_recErased;
-                    readIdents = _1497_recIdents;
-                  }
-                } else if (_source55.is_Primitive) {
-                  DAST._IPrimitive _1498___mcc_h655 = _source55.dtor_Primitive_a0;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _1499_recursiveGen;
-                    bool _1500_recOwned;
-                    bool _1501_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1502_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out961;
-                    bool _out962;
-                    bool _out963;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out964;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out961, out _out962, out _out963, out _out964);
-                    _1499_recursiveGen = _out961;
-                    _1500_recOwned = _out962;
-                    _1501_recErased = _out963;
-                    _1502_recIdents = _out964;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1499_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1500_recOwned;
-                    isErased = _1501_recErased;
-                    readIdents = _1502_recIdents;
-                  }
-                } else if (_source55.is_Passthrough) {
-                  Dafny.ISequence<Dafny.Rune> _1503___mcc_h657 = _source55.dtor_Passthrough_a0;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _1504_recursiveGen;
-                    bool _1505_recOwned;
-                    bool _1506_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1507_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out965;
-                    bool _out966;
-                    bool _out967;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out968;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out965, out _out966, out _out967, out _out968);
-                    _1504_recursiveGen = _out965;
-                    _1505_recOwned = _out966;
-                    _1506_recErased = _out967;
-                    _1507_recIdents = _out968;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1504_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1505_recOwned;
-                    isErased = _1506_recErased;
-                    readIdents = _1507_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1584_recursiveGen;
+                    bool _1585_recOwned;
+                    bool _1586_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1587_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1019;
+                    bool _out1020;
+                    bool _out1021;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1022;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1019, out _out1020, out _out1021, out _out1022);
+                    _1584_recursiveGen = _out1019;
+                    _1585_recOwned = _out1020;
+                    _1586_recErased = _out1021;
+                    _1587_recIdents = _out1022;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1584_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1585_recOwned;
+                    isErased = _1586_recErased;
+                    readIdents = _1587_recIdents;
                   }
-                } else {
-                  Dafny.ISequence<Dafny.Rune> _1508___mcc_h659 = _source55.dtor_TypeArg_a0;
-                  {
-                    Dafny.ISequence<Dafny.Rune> _1509_recursiveGen;
-                    bool _1510_recOwned;
-                    bool _1511_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1512_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out969;
-                    bool _out970;
-                    bool _out971;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out972;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out969, out _out970, out _out971, out _out972);
-                    _1509_recursiveGen = _out969;
-                    _1510_recOwned = _out970;
-                    _1511_recErased = _out971;
-                    _1512_recIdents = _out972;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1509_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1510_recOwned;
-                    isErased = _1511_recErased;
-                    readIdents = _1512_recIdents;
-                  }
-                }
-              } else if (_source48.is_Bool) {
-                DAST._IType _source57 = _489___mcc_h124;
+                }
+              } else if (_source50.is_String) {
+                DAST._IType _source57 = _501___mcc_h238;
                 if (_source57.is_Path) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1513___mcc_h661 = _source57.dtor_Path_a0;
-                  Dafny.ISequence<DAST._IType> _1514___mcc_h662 = _source57.dtor_typeArgs;
-                  DAST._IResolvedType _1515___mcc_h663 = _source57.dtor_resolved;
-                  DAST._IResolvedType _source58 = _1515___mcc_h663;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1588___mcc_h841 = _source57.dtor_Path_a0;
+                  Dafny.ISequence<DAST._IType> _1589___mcc_h842 = _source57.dtor_typeArgs;
+                  DAST._IResolvedType _1590___mcc_h843 = _source57.dtor_resolved;
+                  DAST._IResolvedType _source58 = _1590___mcc_h843;
                   if (_source58.is_Datatype) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1516___mcc_h667 = _source58.dtor_path;
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1591___mcc_h847 = _source58.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _1517_recursiveGen;
-                      bool _1518_recOwned;
-                      bool _1519_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1520_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out973;
-                      bool _out974;
-                      bool _out975;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out976;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out973, out _out974, out _out975, out _out976);
-                      _1517_recursiveGen = _out973;
-                      _1518_recOwned = _out974;
-                      _1519_recErased = _out975;
-                      _1520_recIdents = _out976;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1517_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1518_recOwned;
-                      isErased = _1519_recErased;
-                      readIdents = _1520_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1592_recursiveGen;
+                      bool _1593_recOwned;
+                      bool _1594_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1595_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1023;
+                      bool _out1024;
+                      bool _out1025;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1026;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1023, out _out1024, out _out1025, out _out1026);
+                      _1592_recursiveGen = _out1023;
+                      _1593_recOwned = _out1024;
+                      _1594_recErased = _out1025;
+                      _1595_recIdents = _out1026;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1592_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1593_recOwned;
+                      isErased = _1594_recErased;
+                      readIdents = _1595_recIdents;
                     }
                   } else if (_source58.is_Trait) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1521___mcc_h669 = _source58.dtor_path;
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1596___mcc_h849 = _source58.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _1522_recursiveGen;
-                      bool _1523_recOwned;
-                      bool _1524_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1525_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out977;
-                      bool _out978;
-                      bool _out979;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out980;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out977, out _out978, out _out979, out _out980);
-                      _1522_recursiveGen = _out977;
-                      _1523_recOwned = _out978;
-                      _1524_recErased = _out979;
-                      _1525_recIdents = _out980;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1522_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1523_recOwned;
-                      isErased = _1524_recErased;
-                      readIdents = _1525_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1597_recursiveGen;
+                      bool _1598_recOwned;
+                      bool _1599_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1600_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1027;
+                      bool _out1028;
+                      bool _out1029;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1030;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1027, out _out1028, out _out1029, out _out1030);
+                      _1597_recursiveGen = _out1027;
+                      _1598_recOwned = _out1028;
+                      _1599_recErased = _out1029;
+                      _1600_recIdents = _out1030;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1597_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1598_recOwned;
+                      isErased = _1599_recErased;
+                      readIdents = _1600_recIdents;
                     }
                   } else {
-                    DAST._IType _1526___mcc_h671 = _source58.dtor_Newtype_a0;
-                    DAST._IType _1527_b = _1526___mcc_h671;
+                    DAST._IType _1601___mcc_h851 = _source58.dtor_Newtype_a0;
+                    DAST._IType _1602_b = _1601___mcc_h851;
                     {
-                      if (object.Equals(_482_fromTpe, _1527_b)) {
-                        Dafny.ISequence<Dafny.Rune> _1528_recursiveGen;
-                        bool _1529_recOwned;
-                        bool _1530_recErased;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1531_recIdents;
-                        Dafny.ISequence<Dafny.Rune> _out981;
-                        bool _out982;
-                        bool _out983;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out984;
-                        DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out981, out _out982, out _out983, out _out984);
-                        _1528_recursiveGen = _out981;
-                        _1529_recOwned = _out982;
-                        _1530_recErased = _out983;
-                        _1531_recIdents = _out984;
-                        Dafny.ISequence<Dafny.Rune> _1532_rhsType;
-                        Dafny.ISequence<Dafny.Rune> _out985;
-                        _out985 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                        _1532_rhsType = _out985;
-                        Dafny.ISequence<Dafny.Rune> _1533_uneraseFn;
-                        _1533_uneraseFn = ((_1529_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1532_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1533_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1528_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                        isOwned = _1529_recOwned;
+                      if (object.Equals(_494_fromTpe, _1602_b)) {
+                        Dafny.ISequence<Dafny.Rune> _1603_recursiveGen;
+                        bool _1604_recOwned;
+                        bool _1605_recErased;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1606_recIdents;
+                        Dafny.ISequence<Dafny.Rune> _out1031;
+                        bool _out1032;
+                        bool _out1033;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1034;
+                        DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1031, out _out1032, out _out1033, out _out1034);
+                        _1603_recursiveGen = _out1031;
+                        _1604_recOwned = _out1032;
+                        _1605_recErased = _out1033;
+                        _1606_recIdents = _out1034;
+                        Dafny.ISequence<Dafny.Rune> _1607_rhsType;
+                        Dafny.ISequence<Dafny.Rune> _out1035;
+                        _out1035 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                        _1607_rhsType = _out1035;
+                        Dafny.ISequence<Dafny.Rune> _1608_uneraseFn;
+                        _1608_uneraseFn = ((_1604_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1607_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1608_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1603_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                        isOwned = _1604_recOwned;
                         isErased = false;
-                        readIdents = _1531_recIdents;
+                        readIdents = _1606_recIdents;
                       } else {
-                        Dafny.ISequence<Dafny.Rune> _out986;
-                        bool _out987;
-                        bool _out988;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out989;
-                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _1527_b), _1527_b, _481_toTpe), @params, mustOwn, out _out986, out _out987, out _out988, out _out989);
-                        s = _out986;
-                        isOwned = _out987;
-                        isErased = _out988;
-                        readIdents = _out989;
+                        Dafny.ISequence<Dafny.Rune> _out1036;
+                        bool _out1037;
+                        bool _out1038;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1039;
+                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1602_b), _1602_b, _493_toTpe), selfIdent, @params, mustOwn, out _out1036, out _out1037, out _out1038, out _out1039);
+                        s = _out1036;
+                        isOwned = _out1037;
+                        isErased = _out1038;
+                        readIdents = _out1039;
                       }
                     }
                   }
+                } else if (_source57.is_Nullable) {
+                  DAST._IType _1609___mcc_h853 = _source57.dtor_Nullable_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1610_recursiveGen;
+                    bool _1611_recOwned;
+                    bool _1612_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1613_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1040;
+                    bool _out1041;
+                    bool _out1042;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1043;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1040, out _out1041, out _out1042, out _out1043);
+                    _1610_recursiveGen = _out1040;
+                    _1611_recOwned = _out1041;
+                    _1612_recErased = _out1042;
+                    _1613_recIdents = _out1043;
+                    if (!(_1611_recOwned)) {
+                      _1610_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1610_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                    }
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1610_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                    isOwned = true;
+                    isErased = _1612_recErased;
+                    readIdents = _1613_recIdents;
+                  }
                 } else if (_source57.is_Tuple) {
-                  Dafny.ISequence<DAST._IType> _1534___mcc_h673 = _source57.dtor_Tuple_a0;
+                  Dafny.ISequence<DAST._IType> _1614___mcc_h855 = _source57.dtor_Tuple_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1535_recursiveGen;
-                    bool _1536_recOwned;
-                    bool _1537_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1538_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out990;
-                    bool _out991;
-                    bool _out992;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out993;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out990, out _out991, out _out992, out _out993);
-                    _1535_recursiveGen = _out990;
-                    _1536_recOwned = _out991;
-                    _1537_recErased = _out992;
-                    _1538_recIdents = _out993;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1535_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1536_recOwned;
-                    isErased = _1537_recErased;
-                    readIdents = _1538_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1615_recursiveGen;
+                    bool _1616_recOwned;
+                    bool _1617_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1618_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1044;
+                    bool _out1045;
+                    bool _out1046;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1047;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1044, out _out1045, out _out1046, out _out1047);
+                    _1615_recursiveGen = _out1044;
+                    _1616_recOwned = _out1045;
+                    _1617_recErased = _out1046;
+                    _1618_recIdents = _out1047;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1615_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1616_recOwned;
+                    isErased = _1617_recErased;
+                    readIdents = _1618_recIdents;
                   }
                 } else if (_source57.is_Array) {
-                  DAST._IType _1539___mcc_h675 = _source57.dtor_element;
+                  DAST._IType _1619___mcc_h857 = _source57.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1540_recursiveGen;
-                    bool _1541_recOwned;
-                    bool _1542_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1543_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out994;
-                    bool _out995;
-                    bool _out996;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out997;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out994, out _out995, out _out996, out _out997);
-                    _1540_recursiveGen = _out994;
-                    _1541_recOwned = _out995;
-                    _1542_recErased = _out996;
-                    _1543_recIdents = _out997;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1540_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1541_recOwned;
-                    isErased = _1542_recErased;
-                    readIdents = _1543_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1620_recursiveGen;
+                    bool _1621_recOwned;
+                    bool _1622_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1623_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1048;
+                    bool _out1049;
+                    bool _out1050;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1051;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1048, out _out1049, out _out1050, out _out1051);
+                    _1620_recursiveGen = _out1048;
+                    _1621_recOwned = _out1049;
+                    _1622_recErased = _out1050;
+                    _1623_recIdents = _out1051;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1620_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1621_recOwned;
+                    isErased = _1622_recErased;
+                    readIdents = _1623_recIdents;
                   }
                 } else if (_source57.is_Seq) {
-                  DAST._IType _1544___mcc_h677 = _source57.dtor_element;
+                  DAST._IType _1624___mcc_h859 = _source57.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1545_recursiveGen;
-                    bool _1546_recOwned;
-                    bool _1547_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1548_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out998;
-                    bool _out999;
-                    bool _out1000;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1001;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out998, out _out999, out _out1000, out _out1001);
-                    _1545_recursiveGen = _out998;
-                    _1546_recOwned = _out999;
-                    _1547_recErased = _out1000;
-                    _1548_recIdents = _out1001;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1545_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1546_recOwned;
-                    isErased = _1547_recErased;
-                    readIdents = _1548_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1625_recursiveGen;
+                    bool _1626_recOwned;
+                    bool _1627_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1628_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1052;
+                    bool _out1053;
+                    bool _out1054;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1055;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1052, out _out1053, out _out1054, out _out1055);
+                    _1625_recursiveGen = _out1052;
+                    _1626_recOwned = _out1053;
+                    _1627_recErased = _out1054;
+                    _1628_recIdents = _out1055;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1625_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1626_recOwned;
+                    isErased = _1627_recErased;
+                    readIdents = _1628_recIdents;
                   }
                 } else if (_source57.is_Set) {
-                  DAST._IType _1549___mcc_h679 = _source57.dtor_element;
+                  DAST._IType _1629___mcc_h861 = _source57.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1550_recursiveGen;
-                    bool _1551_recOwned;
-                    bool _1552_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1553_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1002;
-                    bool _out1003;
-                    bool _out1004;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1005;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1002, out _out1003, out _out1004, out _out1005);
-                    _1550_recursiveGen = _out1002;
-                    _1551_recOwned = _out1003;
-                    _1552_recErased = _out1004;
-                    _1553_recIdents = _out1005;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1550_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1551_recOwned;
-                    isErased = _1552_recErased;
-                    readIdents = _1553_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1630_recursiveGen;
+                    bool _1631_recOwned;
+                    bool _1632_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1633_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1056;
+                    bool _out1057;
+                    bool _out1058;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1059;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1056, out _out1057, out _out1058, out _out1059);
+                    _1630_recursiveGen = _out1056;
+                    _1631_recOwned = _out1057;
+                    _1632_recErased = _out1058;
+                    _1633_recIdents = _out1059;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1630_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1631_recOwned;
+                    isErased = _1632_recErased;
+                    readIdents = _1633_recIdents;
                   }
                 } else if (_source57.is_Multiset) {
-                  DAST._IType _1554___mcc_h681 = _source57.dtor_element;
+                  DAST._IType _1634___mcc_h863 = _source57.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1555_recursiveGen;
-                    bool _1556_recOwned;
-                    bool _1557_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1558_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1006;
-                    bool _out1007;
-                    bool _out1008;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1009;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1006, out _out1007, out _out1008, out _out1009);
-                    _1555_recursiveGen = _out1006;
-                    _1556_recOwned = _out1007;
-                    _1557_recErased = _out1008;
-                    _1558_recIdents = _out1009;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1555_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1556_recOwned;
-                    isErased = _1557_recErased;
-                    readIdents = _1558_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1635_recursiveGen;
+                    bool _1636_recOwned;
+                    bool _1637_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1638_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1060;
+                    bool _out1061;
+                    bool _out1062;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1063;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1060, out _out1061, out _out1062, out _out1063);
+                    _1635_recursiveGen = _out1060;
+                    _1636_recOwned = _out1061;
+                    _1637_recErased = _out1062;
+                    _1638_recIdents = _out1063;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1635_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1636_recOwned;
+                    isErased = _1637_recErased;
+                    readIdents = _1638_recIdents;
                   }
                 } else if (_source57.is_Map) {
-                  DAST._IType _1559___mcc_h683 = _source57.dtor_key;
-                  DAST._IType _1560___mcc_h684 = _source57.dtor_value;
+                  DAST._IType _1639___mcc_h865 = _source57.dtor_key;
+                  DAST._IType _1640___mcc_h866 = _source57.dtor_value;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1561_recursiveGen;
-                    bool _1562_recOwned;
-                    bool _1563_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1564_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1010;
-                    bool _out1011;
-                    bool _out1012;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1013;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1010, out _out1011, out _out1012, out _out1013);
-                    _1561_recursiveGen = _out1010;
-                    _1562_recOwned = _out1011;
-                    _1563_recErased = _out1012;
-                    _1564_recIdents = _out1013;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1561_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1562_recOwned;
-                    isErased = _1563_recErased;
-                    readIdents = _1564_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1641_recursiveGen;
+                    bool _1642_recOwned;
+                    bool _1643_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1644_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1064;
+                    bool _out1065;
+                    bool _out1066;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1067;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1064, out _out1065, out _out1066, out _out1067);
+                    _1641_recursiveGen = _out1064;
+                    _1642_recOwned = _out1065;
+                    _1643_recErased = _out1066;
+                    _1644_recIdents = _out1067;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1641_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1642_recOwned;
+                    isErased = _1643_recErased;
+                    readIdents = _1644_recIdents;
                   }
                 } else if (_source57.is_Arrow) {
-                  Dafny.ISequence<DAST._IType> _1565___mcc_h687 = _source57.dtor_args;
-                  DAST._IType _1566___mcc_h688 = _source57.dtor_result;
+                  Dafny.ISequence<DAST._IType> _1645___mcc_h869 = _source57.dtor_args;
+                  DAST._IType _1646___mcc_h870 = _source57.dtor_result;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1567_recursiveGen;
-                    bool _1568_recOwned;
-                    bool _1569_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1570_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1014;
-                    bool _out1015;
-                    bool _out1016;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1017;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1014, out _out1015, out _out1016, out _out1017);
-                    _1567_recursiveGen = _out1014;
-                    _1568_recOwned = _out1015;
-                    _1569_recErased = _out1016;
-                    _1570_recIdents = _out1017;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1567_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1568_recOwned;
-                    isErased = _1569_recErased;
-                    readIdents = _1570_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1647_recursiveGen;
+                    bool _1648_recOwned;
+                    bool _1649_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1650_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1068;
+                    bool _out1069;
+                    bool _out1070;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1071;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1068, out _out1069, out _out1070, out _out1071);
+                    _1647_recursiveGen = _out1068;
+                    _1648_recOwned = _out1069;
+                    _1649_recErased = _out1070;
+                    _1650_recIdents = _out1071;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1647_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1648_recOwned;
+                    isErased = _1649_recErased;
+                    readIdents = _1650_recIdents;
                   }
                 } else if (_source57.is_Primitive) {
-                  DAST._IPrimitive _1571___mcc_h691 = _source57.dtor_Primitive_a0;
+                  DAST._IPrimitive _1651___mcc_h873 = _source57.dtor_Primitive_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1572_recursiveGen;
-                    bool _1573_recOwned;
-                    bool _1574_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1575_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1018;
-                    bool _out1019;
-                    bool _out1020;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1021;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1018, out _out1019, out _out1020, out _out1021);
-                    _1572_recursiveGen = _out1018;
-                    _1573_recOwned = _out1019;
-                    _1574_recErased = _out1020;
-                    _1575_recIdents = _out1021;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1572_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1573_recOwned;
-                    isErased = _1574_recErased;
-                    readIdents = _1575_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1652_recursiveGen;
+                    bool _1653_recOwned;
+                    bool _1654_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1655_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1072;
+                    bool _out1073;
+                    bool _out1074;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1075;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1072, out _out1073, out _out1074, out _out1075);
+                    _1652_recursiveGen = _out1072;
+                    _1653_recOwned = _out1073;
+                    _1654_recErased = _out1074;
+                    _1655_recIdents = _out1075;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1652_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1653_recOwned;
+                    isErased = _1654_recErased;
+                    readIdents = _1655_recIdents;
                   }
                 } else if (_source57.is_Passthrough) {
-                  Dafny.ISequence<Dafny.Rune> _1576___mcc_h693 = _source57.dtor_Passthrough_a0;
+                  Dafny.ISequence<Dafny.Rune> _1656___mcc_h875 = _source57.dtor_Passthrough_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1577_recursiveGen;
-                    bool _1578_recOwned;
-                    bool _1579_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1580_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1022;
-                    bool _out1023;
-                    bool _out1024;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1025;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1022, out _out1023, out _out1024, out _out1025);
-                    _1577_recursiveGen = _out1022;
-                    _1578_recOwned = _out1023;
-                    _1579_recErased = _out1024;
-                    _1580_recIdents = _out1025;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1577_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1578_recOwned;
-                    isErased = _1579_recErased;
-                    readIdents = _1580_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1657_recursiveGen;
+                    bool _1658_recOwned;
+                    bool _1659_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1660_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1076;
+                    bool _out1077;
+                    bool _out1078;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1079;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1076, out _out1077, out _out1078, out _out1079);
+                    _1657_recursiveGen = _out1076;
+                    _1658_recOwned = _out1077;
+                    _1659_recErased = _out1078;
+                    _1660_recIdents = _out1079;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1657_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1658_recOwned;
+                    isErased = _1659_recErased;
+                    readIdents = _1660_recIdents;
                   }
                 } else {
-                  Dafny.ISequence<Dafny.Rune> _1581___mcc_h695 = _source57.dtor_TypeArg_a0;
+                  Dafny.ISequence<Dafny.Rune> _1661___mcc_h877 = _source57.dtor_TypeArg_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1582_recursiveGen;
-                    bool _1583_recOwned;
-                    bool _1584_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1585_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1026;
-                    bool _out1027;
-                    bool _out1028;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1029;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1026, out _out1027, out _out1028, out _out1029);
-                    _1582_recursiveGen = _out1026;
-                    _1583_recOwned = _out1027;
-                    _1584_recErased = _out1028;
-                    _1585_recIdents = _out1029;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1582_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1583_recOwned;
-                    isErased = _1584_recErased;
-                    readIdents = _1585_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1662_recursiveGen;
+                    bool _1663_recOwned;
+                    bool _1664_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1665_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1080;
+                    bool _out1081;
+                    bool _out1082;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1083;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1080, out _out1081, out _out1082, out _out1083);
+                    _1662_recursiveGen = _out1080;
+                    _1663_recOwned = _out1081;
+                    _1664_recErased = _out1082;
+                    _1665_recIdents = _out1083;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1662_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1663_recOwned;
+                    isErased = _1664_recErased;
+                    readIdents = _1665_recIdents;
                   }
                 }
-              } else {
-                DAST._IType _source59 = _489___mcc_h124;
+              } else if (_source50.is_Bool) {
+                DAST._IType _source59 = _501___mcc_h238;
                 if (_source59.is_Path) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1586___mcc_h697 = _source59.dtor_Path_a0;
-                  Dafny.ISequence<DAST._IType> _1587___mcc_h698 = _source59.dtor_typeArgs;
-                  DAST._IResolvedType _1588___mcc_h699 = _source59.dtor_resolved;
-                  DAST._IResolvedType _source60 = _1588___mcc_h699;
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1666___mcc_h879 = _source59.dtor_Path_a0;
+                  Dafny.ISequence<DAST._IType> _1667___mcc_h880 = _source59.dtor_typeArgs;
+                  DAST._IResolvedType _1668___mcc_h881 = _source59.dtor_resolved;
+                  DAST._IResolvedType _source60 = _1668___mcc_h881;
                   if (_source60.is_Datatype) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1589___mcc_h703 = _source60.dtor_path;
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1669___mcc_h885 = _source60.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _1590_recursiveGen;
-                      bool _1591_recOwned;
-                      bool _1592_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1593_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out1030;
-                      bool _out1031;
-                      bool _out1032;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1033;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1030, out _out1031, out _out1032, out _out1033);
-                      _1590_recursiveGen = _out1030;
-                      _1591_recOwned = _out1031;
-                      _1592_recErased = _out1032;
-                      _1593_recIdents = _out1033;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1590_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1591_recOwned;
-                      isErased = _1592_recErased;
-                      readIdents = _1593_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1670_recursiveGen;
+                      bool _1671_recOwned;
+                      bool _1672_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1673_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1084;
+                      bool _out1085;
+                      bool _out1086;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1087;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1084, out _out1085, out _out1086, out _out1087);
+                      _1670_recursiveGen = _out1084;
+                      _1671_recOwned = _out1085;
+                      _1672_recErased = _out1086;
+                      _1673_recIdents = _out1087;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1670_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1671_recOwned;
+                      isErased = _1672_recErased;
+                      readIdents = _1673_recIdents;
                     }
                   } else if (_source60.is_Trait) {
-                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1594___mcc_h705 = _source60.dtor_path;
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1674___mcc_h887 = _source60.dtor_path;
                     {
-                      Dafny.ISequence<Dafny.Rune> _1595_recursiveGen;
-                      bool _1596_recOwned;
-                      bool _1597_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1598_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out1034;
-                      bool _out1035;
-                      bool _out1036;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1037;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1034, out _out1035, out _out1036, out _out1037);
-                      _1595_recursiveGen = _out1034;
-                      _1596_recOwned = _out1035;
-                      _1597_recErased = _out1036;
-                      _1598_recIdents = _out1037;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1595_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1596_recOwned;
-                      isErased = _1597_recErased;
-                      readIdents = _1598_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1675_recursiveGen;
+                      bool _1676_recOwned;
+                      bool _1677_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1678_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1088;
+                      bool _out1089;
+                      bool _out1090;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1091;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1088, out _out1089, out _out1090, out _out1091);
+                      _1675_recursiveGen = _out1088;
+                      _1676_recOwned = _out1089;
+                      _1677_recErased = _out1090;
+                      _1678_recIdents = _out1091;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1675_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1676_recOwned;
+                      isErased = _1677_recErased;
+                      readIdents = _1678_recIdents;
                     }
                   } else {
-                    DAST._IType _1599___mcc_h707 = _source60.dtor_Newtype_a0;
-                    DAST._IType _1600_b = _1599___mcc_h707;
+                    DAST._IType _1679___mcc_h889 = _source60.dtor_Newtype_a0;
+                    DAST._IType _1680_b = _1679___mcc_h889;
                     {
-                      if (object.Equals(_482_fromTpe, _1600_b)) {
-                        Dafny.ISequence<Dafny.Rune> _1601_recursiveGen;
-                        bool _1602_recOwned;
-                        bool _1603_recErased;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1604_recIdents;
-                        Dafny.ISequence<Dafny.Rune> _out1038;
-                        bool _out1039;
-                        bool _out1040;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1041;
-                        DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1038, out _out1039, out _out1040, out _out1041);
-                        _1601_recursiveGen = _out1038;
-                        _1602_recOwned = _out1039;
-                        _1603_recErased = _out1040;
-                        _1604_recIdents = _out1041;
-                        Dafny.ISequence<Dafny.Rune> _1605_rhsType;
-                        Dafny.ISequence<Dafny.Rune> _out1042;
-                        _out1042 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                        _1605_rhsType = _out1042;
-                        Dafny.ISequence<Dafny.Rune> _1606_uneraseFn;
-                        _1606_uneraseFn = ((_1602_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1605_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1606_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1601_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                        isOwned = _1602_recOwned;
+                      if (object.Equals(_494_fromTpe, _1680_b)) {
+                        Dafny.ISequence<Dafny.Rune> _1681_recursiveGen;
+                        bool _1682_recOwned;
+                        bool _1683_recErased;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1684_recIdents;
+                        Dafny.ISequence<Dafny.Rune> _out1092;
+                        bool _out1093;
+                        bool _out1094;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1095;
+                        DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1092, out _out1093, out _out1094, out _out1095);
+                        _1681_recursiveGen = _out1092;
+                        _1682_recOwned = _out1093;
+                        _1683_recErased = _out1094;
+                        _1684_recIdents = _out1095;
+                        Dafny.ISequence<Dafny.Rune> _1685_rhsType;
+                        Dafny.ISequence<Dafny.Rune> _out1096;
+                        _out1096 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                        _1685_rhsType = _out1096;
+                        Dafny.ISequence<Dafny.Rune> _1686_uneraseFn;
+                        _1686_uneraseFn = ((_1682_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1685_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1686_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1681_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                        isOwned = _1682_recOwned;
                         isErased = false;
-                        readIdents = _1604_recIdents;
+                        readIdents = _1684_recIdents;
                       } else {
-                        Dafny.ISequence<Dafny.Rune> _out1043;
-                        bool _out1044;
-                        bool _out1045;
-                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1046;
-                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _1600_b), _1600_b, _481_toTpe), @params, mustOwn, out _out1043, out _out1044, out _out1045, out _out1046);
-                        s = _out1043;
-                        isOwned = _out1044;
-                        isErased = _out1045;
-                        readIdents = _out1046;
+                        Dafny.ISequence<Dafny.Rune> _out1097;
+                        bool _out1098;
+                        bool _out1099;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1100;
+                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1680_b), _1680_b, _493_toTpe), selfIdent, @params, mustOwn, out _out1097, out _out1098, out _out1099, out _out1100);
+                        s = _out1097;
+                        isOwned = _out1098;
+                        isErased = _out1099;
+                        readIdents = _out1100;
                       }
                     }
                   }
+                } else if (_source59.is_Nullable) {
+                  DAST._IType _1687___mcc_h891 = _source59.dtor_Nullable_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1688_recursiveGen;
+                    bool _1689_recOwned;
+                    bool _1690_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1691_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1101;
+                    bool _out1102;
+                    bool _out1103;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1104;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1101, out _out1102, out _out1103, out _out1104);
+                    _1688_recursiveGen = _out1101;
+                    _1689_recOwned = _out1102;
+                    _1690_recErased = _out1103;
+                    _1691_recIdents = _out1104;
+                    if (!(_1689_recOwned)) {
+                      _1688_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1688_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                    }
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1688_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                    isOwned = true;
+                    isErased = _1690_recErased;
+                    readIdents = _1691_recIdents;
+                  }
                 } else if (_source59.is_Tuple) {
-                  Dafny.ISequence<DAST._IType> _1607___mcc_h709 = _source59.dtor_Tuple_a0;
+                  Dafny.ISequence<DAST._IType> _1692___mcc_h893 = _source59.dtor_Tuple_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1608_recursiveGen;
-                    bool _1609_recOwned;
-                    bool _1610_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1611_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1047;
-                    bool _out1048;
-                    bool _out1049;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1050;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1047, out _out1048, out _out1049, out _out1050);
-                    _1608_recursiveGen = _out1047;
-                    _1609_recOwned = _out1048;
-                    _1610_recErased = _out1049;
-                    _1611_recIdents = _out1050;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1608_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1609_recOwned;
-                    isErased = _1610_recErased;
-                    readIdents = _1611_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1693_recursiveGen;
+                    bool _1694_recOwned;
+                    bool _1695_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1696_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1105;
+                    bool _out1106;
+                    bool _out1107;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1108;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1105, out _out1106, out _out1107, out _out1108);
+                    _1693_recursiveGen = _out1105;
+                    _1694_recOwned = _out1106;
+                    _1695_recErased = _out1107;
+                    _1696_recIdents = _out1108;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1693_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1694_recOwned;
+                    isErased = _1695_recErased;
+                    readIdents = _1696_recIdents;
                   }
                 } else if (_source59.is_Array) {
-                  DAST._IType _1612___mcc_h711 = _source59.dtor_element;
+                  DAST._IType _1697___mcc_h895 = _source59.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1613_recursiveGen;
-                    bool _1614_recOwned;
-                    bool _1615_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1616_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1051;
-                    bool _out1052;
-                    bool _out1053;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1054;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1051, out _out1052, out _out1053, out _out1054);
-                    _1613_recursiveGen = _out1051;
-                    _1614_recOwned = _out1052;
-                    _1615_recErased = _out1053;
-                    _1616_recIdents = _out1054;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1613_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1614_recOwned;
-                    isErased = _1615_recErased;
-                    readIdents = _1616_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1698_recursiveGen;
+                    bool _1699_recOwned;
+                    bool _1700_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1701_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1109;
+                    bool _out1110;
+                    bool _out1111;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1112;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1109, out _out1110, out _out1111, out _out1112);
+                    _1698_recursiveGen = _out1109;
+                    _1699_recOwned = _out1110;
+                    _1700_recErased = _out1111;
+                    _1701_recIdents = _out1112;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1698_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1699_recOwned;
+                    isErased = _1700_recErased;
+                    readIdents = _1701_recIdents;
                   }
                 } else if (_source59.is_Seq) {
-                  DAST._IType _1617___mcc_h713 = _source59.dtor_element;
+                  DAST._IType _1702___mcc_h897 = _source59.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1618_recursiveGen;
-                    bool _1619_recOwned;
-                    bool _1620_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1621_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1055;
-                    bool _out1056;
-                    bool _out1057;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1058;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1055, out _out1056, out _out1057, out _out1058);
-                    _1618_recursiveGen = _out1055;
-                    _1619_recOwned = _out1056;
-                    _1620_recErased = _out1057;
-                    _1621_recIdents = _out1058;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1618_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1619_recOwned;
-                    isErased = _1620_recErased;
-                    readIdents = _1621_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1703_recursiveGen;
+                    bool _1704_recOwned;
+                    bool _1705_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1706_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1113;
+                    bool _out1114;
+                    bool _out1115;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1116;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1113, out _out1114, out _out1115, out _out1116);
+                    _1703_recursiveGen = _out1113;
+                    _1704_recOwned = _out1114;
+                    _1705_recErased = _out1115;
+                    _1706_recIdents = _out1116;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1703_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1704_recOwned;
+                    isErased = _1705_recErased;
+                    readIdents = _1706_recIdents;
                   }
                 } else if (_source59.is_Set) {
-                  DAST._IType _1622___mcc_h715 = _source59.dtor_element;
+                  DAST._IType _1707___mcc_h899 = _source59.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1623_recursiveGen;
-                    bool _1624_recOwned;
-                    bool _1625_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1626_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1059;
-                    bool _out1060;
-                    bool _out1061;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1062;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1059, out _out1060, out _out1061, out _out1062);
-                    _1623_recursiveGen = _out1059;
-                    _1624_recOwned = _out1060;
-                    _1625_recErased = _out1061;
-                    _1626_recIdents = _out1062;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1623_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1624_recOwned;
-                    isErased = _1625_recErased;
-                    readIdents = _1626_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1708_recursiveGen;
+                    bool _1709_recOwned;
+                    bool _1710_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1711_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1117;
+                    bool _out1118;
+                    bool _out1119;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1120;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1117, out _out1118, out _out1119, out _out1120);
+                    _1708_recursiveGen = _out1117;
+                    _1709_recOwned = _out1118;
+                    _1710_recErased = _out1119;
+                    _1711_recIdents = _out1120;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1708_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1709_recOwned;
+                    isErased = _1710_recErased;
+                    readIdents = _1711_recIdents;
                   }
                 } else if (_source59.is_Multiset) {
-                  DAST._IType _1627___mcc_h717 = _source59.dtor_element;
+                  DAST._IType _1712___mcc_h901 = _source59.dtor_element;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1628_recursiveGen;
-                    bool _1629_recOwned;
-                    bool _1630_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1631_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1063;
-                    bool _out1064;
-                    bool _out1065;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1066;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1063, out _out1064, out _out1065, out _out1066);
-                    _1628_recursiveGen = _out1063;
-                    _1629_recOwned = _out1064;
-                    _1630_recErased = _out1065;
-                    _1631_recIdents = _out1066;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1628_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1629_recOwned;
-                    isErased = _1630_recErased;
-                    readIdents = _1631_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1713_recursiveGen;
+                    bool _1714_recOwned;
+                    bool _1715_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1716_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1121;
+                    bool _out1122;
+                    bool _out1123;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1124;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1121, out _out1122, out _out1123, out _out1124);
+                    _1713_recursiveGen = _out1121;
+                    _1714_recOwned = _out1122;
+                    _1715_recErased = _out1123;
+                    _1716_recIdents = _out1124;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1713_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1714_recOwned;
+                    isErased = _1715_recErased;
+                    readIdents = _1716_recIdents;
                   }
                 } else if (_source59.is_Map) {
-                  DAST._IType _1632___mcc_h719 = _source59.dtor_key;
-                  DAST._IType _1633___mcc_h720 = _source59.dtor_value;
+                  DAST._IType _1717___mcc_h903 = _source59.dtor_key;
+                  DAST._IType _1718___mcc_h904 = _source59.dtor_value;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1634_recursiveGen;
-                    bool _1635_recOwned;
-                    bool _1636_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1637_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1067;
-                    bool _out1068;
-                    bool _out1069;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1070;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1067, out _out1068, out _out1069, out _out1070);
-                    _1634_recursiveGen = _out1067;
-                    _1635_recOwned = _out1068;
-                    _1636_recErased = _out1069;
-                    _1637_recIdents = _out1070;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1634_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1635_recOwned;
-                    isErased = _1636_recErased;
-                    readIdents = _1637_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1719_recursiveGen;
+                    bool _1720_recOwned;
+                    bool _1721_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1722_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1125;
+                    bool _out1126;
+                    bool _out1127;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1128;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1125, out _out1126, out _out1127, out _out1128);
+                    _1719_recursiveGen = _out1125;
+                    _1720_recOwned = _out1126;
+                    _1721_recErased = _out1127;
+                    _1722_recIdents = _out1128;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1719_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1720_recOwned;
+                    isErased = _1721_recErased;
+                    readIdents = _1722_recIdents;
                   }
                 } else if (_source59.is_Arrow) {
-                  Dafny.ISequence<DAST._IType> _1638___mcc_h723 = _source59.dtor_args;
-                  DAST._IType _1639___mcc_h724 = _source59.dtor_result;
+                  Dafny.ISequence<DAST._IType> _1723___mcc_h907 = _source59.dtor_args;
+                  DAST._IType _1724___mcc_h908 = _source59.dtor_result;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1640_recursiveGen;
-                    bool _1641_recOwned;
-                    bool _1642_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1643_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1071;
-                    bool _out1072;
-                    bool _out1073;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1074;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1071, out _out1072, out _out1073, out _out1074);
-                    _1640_recursiveGen = _out1071;
-                    _1641_recOwned = _out1072;
-                    _1642_recErased = _out1073;
-                    _1643_recIdents = _out1074;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1640_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1641_recOwned;
-                    isErased = _1642_recErased;
-                    readIdents = _1643_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1725_recursiveGen;
+                    bool _1726_recOwned;
+                    bool _1727_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1728_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1129;
+                    bool _out1130;
+                    bool _out1131;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1132;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1129, out _out1130, out _out1131, out _out1132);
+                    _1725_recursiveGen = _out1129;
+                    _1726_recOwned = _out1130;
+                    _1727_recErased = _out1131;
+                    _1728_recIdents = _out1132;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1725_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1726_recOwned;
+                    isErased = _1727_recErased;
+                    readIdents = _1728_recIdents;
                   }
                 } else if (_source59.is_Primitive) {
-                  DAST._IPrimitive _1644___mcc_h727 = _source59.dtor_Primitive_a0;
-                  DAST._IPrimitive _source61 = _1644___mcc_h727;
-                  if (_source61.is_Int) {
+                  DAST._IPrimitive _1729___mcc_h911 = _source59.dtor_Primitive_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1730_recursiveGen;
+                    bool _1731_recOwned;
+                    bool _1732_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1733_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1133;
+                    bool _out1134;
+                    bool _out1135;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1136;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1133, out _out1134, out _out1135, out _out1136);
+                    _1730_recursiveGen = _out1133;
+                    _1731_recOwned = _out1134;
+                    _1732_recErased = _out1135;
+                    _1733_recIdents = _out1136;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1730_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1731_recOwned;
+                    isErased = _1732_recErased;
+                    readIdents = _1733_recIdents;
+                  }
+                } else if (_source59.is_Passthrough) {
+                  Dafny.ISequence<Dafny.Rune> _1734___mcc_h913 = _source59.dtor_Passthrough_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1735_recursiveGen;
+                    bool _1736_recOwned;
+                    bool _1737_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1738_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1137;
+                    bool _out1138;
+                    bool _out1139;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1140;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1137, out _out1138, out _out1139, out _out1140);
+                    _1735_recursiveGen = _out1137;
+                    _1736_recOwned = _out1138;
+                    _1737_recErased = _out1139;
+                    _1738_recIdents = _out1140;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1735_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1736_recOwned;
+                    isErased = _1737_recErased;
+                    readIdents = _1738_recIdents;
+                  }
+                } else {
+                  Dafny.ISequence<Dafny.Rune> _1739___mcc_h915 = _source59.dtor_TypeArg_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1740_recursiveGen;
+                    bool _1741_recOwned;
+                    bool _1742_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1743_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1141;
+                    bool _out1142;
+                    bool _out1143;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1144;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1141, out _out1142, out _out1143, out _out1144);
+                    _1740_recursiveGen = _out1141;
+                    _1741_recOwned = _out1142;
+                    _1742_recErased = _out1143;
+                    _1743_recIdents = _out1144;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1740_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1741_recOwned;
+                    isErased = _1742_recErased;
+                    readIdents = _1743_recIdents;
+                  }
+                }
+              } else {
+                DAST._IType _source61 = _501___mcc_h238;
+                if (_source61.is_Path) {
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1744___mcc_h917 = _source61.dtor_Path_a0;
+                  Dafny.ISequence<DAST._IType> _1745___mcc_h918 = _source61.dtor_typeArgs;
+                  DAST._IResolvedType _1746___mcc_h919 = _source61.dtor_resolved;
+                  DAST._IResolvedType _source62 = _1746___mcc_h919;
+                  if (_source62.is_Datatype) {
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1747___mcc_h923 = _source62.dtor_path;
+                    {
+                      Dafny.ISequence<Dafny.Rune> _1748_recursiveGen;
+                      bool _1749_recOwned;
+                      bool _1750_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1751_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1145;
+                      bool _out1146;
+                      bool _out1147;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1148;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1145, out _out1146, out _out1147, out _out1148);
+                      _1748_recursiveGen = _out1145;
+                      _1749_recOwned = _out1146;
+                      _1750_recErased = _out1147;
+                      _1751_recIdents = _out1148;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1748_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1749_recOwned;
+                      isErased = _1750_recErased;
+                      readIdents = _1751_recIdents;
+                    }
+                  } else if (_source62.is_Trait) {
+                    Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1752___mcc_h925 = _source62.dtor_path;
+                    {
+                      Dafny.ISequence<Dafny.Rune> _1753_recursiveGen;
+                      bool _1754_recOwned;
+                      bool _1755_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1756_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1149;
+                      bool _out1150;
+                      bool _out1151;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1152;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1149, out _out1150, out _out1151, out _out1152);
+                      _1753_recursiveGen = _out1149;
+                      _1754_recOwned = _out1150;
+                      _1755_recErased = _out1151;
+                      _1756_recIdents = _out1152;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1753_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1754_recOwned;
+                      isErased = _1755_recErased;
+                      readIdents = _1756_recIdents;
+                    }
+                  } else {
+                    DAST._IType _1757___mcc_h927 = _source62.dtor_Newtype_a0;
+                    DAST._IType _1758_b = _1757___mcc_h927;
                     {
-                      Dafny.ISequence<Dafny.Rune> _1645_rhsType;
-                      Dafny.ISequence<Dafny.Rune> _out1075;
-                      _out1075 = DCOMP.COMP.GenType(_482_fromTpe, true, false);
-                      _1645_rhsType = _out1075;
-                      Dafny.ISequence<Dafny.Rune> _1646_recursiveGen;
-                      bool _1647___v52;
-                      bool _1648___v53;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1649_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out1076;
-                      bool _out1077;
-                      bool _out1078;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1079;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, true, out _out1076, out _out1077, out _out1078, out _out1079);
-                      _1646_recursiveGen = _out1076;
-                      _1647___v52 = _out1077;
-                      _1648___v53 = _out1078;
-                      _1649_recIdents = _out1079;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigInt::from("), _1646_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as u32)"));
+                      if (object.Equals(_494_fromTpe, _1758_b)) {
+                        Dafny.ISequence<Dafny.Rune> _1759_recursiveGen;
+                        bool _1760_recOwned;
+                        bool _1761_recErased;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1762_recIdents;
+                        Dafny.ISequence<Dafny.Rune> _out1153;
+                        bool _out1154;
+                        bool _out1155;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1156;
+                        DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1153, out _out1154, out _out1155, out _out1156);
+                        _1759_recursiveGen = _out1153;
+                        _1760_recOwned = _out1154;
+                        _1761_recErased = _out1155;
+                        _1762_recIdents = _out1156;
+                        Dafny.ISequence<Dafny.Rune> _1763_rhsType;
+                        Dafny.ISequence<Dafny.Rune> _out1157;
+                        _out1157 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                        _1763_rhsType = _out1157;
+                        Dafny.ISequence<Dafny.Rune> _1764_uneraseFn;
+                        _1764_uneraseFn = ((_1760_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                        s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1763_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1764_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1759_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                        isOwned = _1760_recOwned;
+                        isErased = false;
+                        readIdents = _1762_recIdents;
+                      } else {
+                        Dafny.ISequence<Dafny.Rune> _out1158;
+                        bool _out1159;
+                        bool _out1160;
+                        Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1161;
+                        DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1758_b), _1758_b, _493_toTpe), selfIdent, @params, mustOwn, out _out1158, out _out1159, out _out1160, out _out1161);
+                        s = _out1158;
+                        isOwned = _out1159;
+                        isErased = _out1160;
+                        readIdents = _out1161;
+                      }
+                    }
+                  }
+                } else if (_source61.is_Nullable) {
+                  DAST._IType _1765___mcc_h929 = _source61.dtor_Nullable_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1766_recursiveGen;
+                    bool _1767_recOwned;
+                    bool _1768_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1769_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1162;
+                    bool _out1163;
+                    bool _out1164;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1165;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1162, out _out1163, out _out1164, out _out1165);
+                    _1766_recursiveGen = _out1162;
+                    _1767_recOwned = _out1163;
+                    _1768_recErased = _out1164;
+                    _1769_recIdents = _out1165;
+                    if (!(_1767_recOwned)) {
+                      _1766_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1766_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                    }
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1766_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                    isOwned = true;
+                    isErased = _1768_recErased;
+                    readIdents = _1769_recIdents;
+                  }
+                } else if (_source61.is_Tuple) {
+                  Dafny.ISequence<DAST._IType> _1770___mcc_h931 = _source61.dtor_Tuple_a0;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1771_recursiveGen;
+                    bool _1772_recOwned;
+                    bool _1773_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1774_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1166;
+                    bool _out1167;
+                    bool _out1168;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1169;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1166, out _out1167, out _out1168, out _out1169);
+                    _1771_recursiveGen = _out1166;
+                    _1772_recOwned = _out1167;
+                    _1773_recErased = _out1168;
+                    _1774_recIdents = _out1169;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1771_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1772_recOwned;
+                    isErased = _1773_recErased;
+                    readIdents = _1774_recIdents;
+                  }
+                } else if (_source61.is_Array) {
+                  DAST._IType _1775___mcc_h933 = _source61.dtor_element;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1776_recursiveGen;
+                    bool _1777_recOwned;
+                    bool _1778_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1779_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1170;
+                    bool _out1171;
+                    bool _out1172;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1173;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1170, out _out1171, out _out1172, out _out1173);
+                    _1776_recursiveGen = _out1170;
+                    _1777_recOwned = _out1171;
+                    _1778_recErased = _out1172;
+                    _1779_recIdents = _out1173;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1776_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1777_recOwned;
+                    isErased = _1778_recErased;
+                    readIdents = _1779_recIdents;
+                  }
+                } else if (_source61.is_Seq) {
+                  DAST._IType _1780___mcc_h935 = _source61.dtor_element;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1781_recursiveGen;
+                    bool _1782_recOwned;
+                    bool _1783_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1784_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1174;
+                    bool _out1175;
+                    bool _out1176;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1177;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1174, out _out1175, out _out1176, out _out1177);
+                    _1781_recursiveGen = _out1174;
+                    _1782_recOwned = _out1175;
+                    _1783_recErased = _out1176;
+                    _1784_recIdents = _out1177;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1781_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1782_recOwned;
+                    isErased = _1783_recErased;
+                    readIdents = _1784_recIdents;
+                  }
+                } else if (_source61.is_Set) {
+                  DAST._IType _1785___mcc_h937 = _source61.dtor_element;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1786_recursiveGen;
+                    bool _1787_recOwned;
+                    bool _1788_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1789_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1178;
+                    bool _out1179;
+                    bool _out1180;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1181;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1178, out _out1179, out _out1180, out _out1181);
+                    _1786_recursiveGen = _out1178;
+                    _1787_recOwned = _out1179;
+                    _1788_recErased = _out1180;
+                    _1789_recIdents = _out1181;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1786_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1787_recOwned;
+                    isErased = _1788_recErased;
+                    readIdents = _1789_recIdents;
+                  }
+                } else if (_source61.is_Multiset) {
+                  DAST._IType _1790___mcc_h939 = _source61.dtor_element;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1791_recursiveGen;
+                    bool _1792_recOwned;
+                    bool _1793_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1794_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1182;
+                    bool _out1183;
+                    bool _out1184;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1185;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1182, out _out1183, out _out1184, out _out1185);
+                    _1791_recursiveGen = _out1182;
+                    _1792_recOwned = _out1183;
+                    _1793_recErased = _out1184;
+                    _1794_recIdents = _out1185;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1791_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1792_recOwned;
+                    isErased = _1793_recErased;
+                    readIdents = _1794_recIdents;
+                  }
+                } else if (_source61.is_Map) {
+                  DAST._IType _1795___mcc_h941 = _source61.dtor_key;
+                  DAST._IType _1796___mcc_h942 = _source61.dtor_value;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1797_recursiveGen;
+                    bool _1798_recOwned;
+                    bool _1799_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1800_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1186;
+                    bool _out1187;
+                    bool _out1188;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1189;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1186, out _out1187, out _out1188, out _out1189);
+                    _1797_recursiveGen = _out1186;
+                    _1798_recOwned = _out1187;
+                    _1799_recErased = _out1188;
+                    _1800_recIdents = _out1189;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1797_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1798_recOwned;
+                    isErased = _1799_recErased;
+                    readIdents = _1800_recIdents;
+                  }
+                } else if (_source61.is_Arrow) {
+                  Dafny.ISequence<DAST._IType> _1801___mcc_h945 = _source61.dtor_args;
+                  DAST._IType _1802___mcc_h946 = _source61.dtor_result;
+                  {
+                    Dafny.ISequence<Dafny.Rune> _1803_recursiveGen;
+                    bool _1804_recOwned;
+                    bool _1805_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1806_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1190;
+                    bool _out1191;
+                    bool _out1192;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1193;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1190, out _out1191, out _out1192, out _out1193);
+                    _1803_recursiveGen = _out1190;
+                    _1804_recOwned = _out1191;
+                    _1805_recErased = _out1192;
+                    _1806_recIdents = _out1193;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1803_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1804_recOwned;
+                    isErased = _1805_recErased;
+                    readIdents = _1806_recIdents;
+                  }
+                } else if (_source61.is_Primitive) {
+                  DAST._IPrimitive _1807___mcc_h949 = _source61.dtor_Primitive_a0;
+                  DAST._IPrimitive _source63 = _1807___mcc_h949;
+                  if (_source63.is_Int) {
+                    {
+                      Dafny.ISequence<Dafny.Rune> _1808_rhsType;
+                      Dafny.ISequence<Dafny.Rune> _out1194;
+                      _out1194 = DCOMP.COMP.GenType(_494_fromTpe, true, false);
+                      _1808_rhsType = _out1194;
+                      Dafny.ISequence<Dafny.Rune> _1809_recursiveGen;
+                      bool _1810___v56;
+                      bool _1811___v57;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1812_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1195;
+                      bool _out1196;
+                      bool _out1197;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1198;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, true, out _out1195, out _out1196, out _out1197, out _out1198);
+                      _1809_recursiveGen = _out1195;
+                      _1810___v56 = _out1196;
+                      _1811___v57 = _out1197;
+                      _1812_recIdents = _out1198;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigInt::from("), _1809_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as u32)"));
                       isOwned = true;
                       isErased = true;
-                      readIdents = _1649_recIdents;
+                      readIdents = _1812_recIdents;
                     }
-                  } else if (_source61.is_Real) {
+                  } else if (_source63.is_Real) {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1650_recursiveGen;
-                      bool _1651_recOwned;
-                      bool _1652_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1653_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out1080;
-                      bool _out1081;
-                      bool _out1082;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1083;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1080, out _out1081, out _out1082, out _out1083);
-                      _1650_recursiveGen = _out1080;
-                      _1651_recOwned = _out1081;
-                      _1652_recErased = _out1082;
-                      _1653_recIdents = _out1083;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1650_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1651_recOwned;
-                      isErased = _1652_recErased;
-                      readIdents = _1653_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1813_recursiveGen;
+                      bool _1814_recOwned;
+                      bool _1815_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1816_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1199;
+                      bool _out1200;
+                      bool _out1201;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1202;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1199, out _out1200, out _out1201, out _out1202);
+                      _1813_recursiveGen = _out1199;
+                      _1814_recOwned = _out1200;
+                      _1815_recErased = _out1201;
+                      _1816_recIdents = _out1202;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1813_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1814_recOwned;
+                      isErased = _1815_recErased;
+                      readIdents = _1816_recIdents;
                     }
-                  } else if (_source61.is_String) {
+                  } else if (_source63.is_String) {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1654_recursiveGen;
-                      bool _1655_recOwned;
-                      bool _1656_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1657_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out1084;
-                      bool _out1085;
-                      bool _out1086;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1087;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1084, out _out1085, out _out1086, out _out1087);
-                      _1654_recursiveGen = _out1084;
-                      _1655_recOwned = _out1085;
-                      _1656_recErased = _out1086;
-                      _1657_recIdents = _out1087;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1654_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1655_recOwned;
-                      isErased = _1656_recErased;
-                      readIdents = _1657_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1817_recursiveGen;
+                      bool _1818_recOwned;
+                      bool _1819_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1820_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1203;
+                      bool _out1204;
+                      bool _out1205;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1206;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1203, out _out1204, out _out1205, out _out1206);
+                      _1817_recursiveGen = _out1203;
+                      _1818_recOwned = _out1204;
+                      _1819_recErased = _out1205;
+                      _1820_recIdents = _out1206;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1817_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1818_recOwned;
+                      isErased = _1819_recErased;
+                      readIdents = _1820_recIdents;
                     }
-                  } else if (_source61.is_Bool) {
+                  } else if (_source63.is_Bool) {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1658_recursiveGen;
-                      bool _1659_recOwned;
-                      bool _1660_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1661_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out1088;
-                      bool _out1089;
-                      bool _out1090;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1091;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1088, out _out1089, out _out1090, out _out1091);
-                      _1658_recursiveGen = _out1088;
-                      _1659_recOwned = _out1089;
-                      _1660_recErased = _out1090;
-                      _1661_recIdents = _out1091;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1658_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1659_recOwned;
-                      isErased = _1660_recErased;
-                      readIdents = _1661_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1821_recursiveGen;
+                      bool _1822_recOwned;
+                      bool _1823_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1824_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1207;
+                      bool _out1208;
+                      bool _out1209;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1210;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1207, out _out1208, out _out1209, out _out1210);
+                      _1821_recursiveGen = _out1207;
+                      _1822_recOwned = _out1208;
+                      _1823_recErased = _out1209;
+                      _1824_recIdents = _out1210;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1821_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1822_recOwned;
+                      isErased = _1823_recErased;
+                      readIdents = _1824_recIdents;
                     }
                   } else {
                     {
-                      Dafny.ISequence<Dafny.Rune> _1662_recursiveGen;
-                      bool _1663_recOwned;
-                      bool _1664_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1665_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out1092;
-                      bool _out1093;
-                      bool _out1094;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1095;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1092, out _out1093, out _out1094, out _out1095);
-                      _1662_recursiveGen = _out1092;
-                      _1663_recOwned = _out1093;
-                      _1664_recErased = _out1094;
-                      _1665_recIdents = _out1095;
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1662_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                      isOwned = _1663_recOwned;
-                      isErased = _1664_recErased;
-                      readIdents = _1665_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _1825_recursiveGen;
+                      bool _1826_recOwned;
+                      bool _1827_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1828_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1211;
+                      bool _out1212;
+                      bool _out1213;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1214;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1211, out _out1212, out _out1213, out _out1214);
+                      _1825_recursiveGen = _out1211;
+                      _1826_recOwned = _out1212;
+                      _1827_recErased = _out1213;
+                      _1828_recIdents = _out1214;
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1825_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                      isOwned = _1826_recOwned;
+                      isErased = _1827_recErased;
+                      readIdents = _1828_recIdents;
                     }
                   }
-                } else if (_source59.is_Passthrough) {
-                  Dafny.ISequence<Dafny.Rune> _1666___mcc_h729 = _source59.dtor_Passthrough_a0;
+                } else if (_source61.is_Passthrough) {
+                  Dafny.ISequence<Dafny.Rune> _1829___mcc_h951 = _source61.dtor_Passthrough_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1667_recursiveGen;
-                    bool _1668_recOwned;
-                    bool _1669_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1670_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1096;
-                    bool _out1097;
-                    bool _out1098;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1099;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1096, out _out1097, out _out1098, out _out1099);
-                    _1667_recursiveGen = _out1096;
-                    _1668_recOwned = _out1097;
-                    _1669_recErased = _out1098;
-                    _1670_recIdents = _out1099;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1667_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1668_recOwned;
-                    isErased = _1669_recErased;
-                    readIdents = _1670_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1830_recursiveGen;
+                    bool _1831_recOwned;
+                    bool _1832_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1833_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1215;
+                    bool _out1216;
+                    bool _out1217;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1218;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1215, out _out1216, out _out1217, out _out1218);
+                    _1830_recursiveGen = _out1215;
+                    _1831_recOwned = _out1216;
+                    _1832_recErased = _out1217;
+                    _1833_recIdents = _out1218;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1830_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1831_recOwned;
+                    isErased = _1832_recErased;
+                    readIdents = _1833_recIdents;
                   }
                 } else {
-                  Dafny.ISequence<Dafny.Rune> _1671___mcc_h731 = _source59.dtor_TypeArg_a0;
+                  Dafny.ISequence<Dafny.Rune> _1834___mcc_h953 = _source61.dtor_TypeArg_a0;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1672_recursiveGen;
-                    bool _1673_recOwned;
-                    bool _1674_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1675_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1100;
-                    bool _out1101;
-                    bool _out1102;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1103;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1100, out _out1101, out _out1102, out _out1103);
-                    _1672_recursiveGen = _out1100;
-                    _1673_recOwned = _out1101;
-                    _1674_recErased = _out1102;
-                    _1675_recIdents = _out1103;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1672_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1673_recOwned;
-                    isErased = _1674_recErased;
-                    readIdents = _1675_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1835_recursiveGen;
+                    bool _1836_recOwned;
+                    bool _1837_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1838_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1219;
+                    bool _out1220;
+                    bool _out1221;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1222;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1219, out _out1220, out _out1221, out _out1222);
+                    _1835_recursiveGen = _out1219;
+                    _1836_recOwned = _out1220;
+                    _1837_recErased = _out1221;
+                    _1838_recIdents = _out1222;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1835_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1836_recOwned;
+                    isErased = _1837_recErased;
+                    readIdents = _1838_recIdents;
                   }
                 }
               }
             } else if (_source26.is_Passthrough) {
-              Dafny.ISequence<Dafny.Rune> _1676___mcc_h733 = _source26.dtor_Passthrough_a0;
-              DAST._IType _source62 = _489___mcc_h124;
-              if (_source62.is_Path) {
-                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1677___mcc_h736 = _source62.dtor_Path_a0;
-                Dafny.ISequence<DAST._IType> _1678___mcc_h737 = _source62.dtor_typeArgs;
-                DAST._IResolvedType _1679___mcc_h738 = _source62.dtor_resolved;
-                DAST._IResolvedType _source63 = _1679___mcc_h738;
-                if (_source63.is_Datatype) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1680___mcc_h742 = _source63.dtor_path;
+              Dafny.ISequence<Dafny.Rune> _1839___mcc_h955 = _source26.dtor_Passthrough_a0;
+              DAST._IType _source64 = _501___mcc_h238;
+              if (_source64.is_Path) {
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1840___mcc_h959 = _source64.dtor_Path_a0;
+                Dafny.ISequence<DAST._IType> _1841___mcc_h960 = _source64.dtor_typeArgs;
+                DAST._IResolvedType _1842___mcc_h961 = _source64.dtor_resolved;
+                DAST._IResolvedType _source65 = _1842___mcc_h961;
+                if (_source65.is_Datatype) {
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1843___mcc_h965 = _source65.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1681_recursiveGen;
-                    bool _1682_recOwned;
-                    bool _1683_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1684_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1104;
-                    bool _out1105;
-                    bool _out1106;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1107;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1104, out _out1105, out _out1106, out _out1107);
-                    _1681_recursiveGen = _out1104;
-                    _1682_recOwned = _out1105;
-                    _1683_recErased = _out1106;
-                    _1684_recIdents = _out1107;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1681_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1682_recOwned;
-                    isErased = _1683_recErased;
-                    readIdents = _1684_recIdents;
-                  }
-                } else if (_source63.is_Trait) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1685___mcc_h744 = _source63.dtor_path;
+                    Dafny.ISequence<Dafny.Rune> _1844_recursiveGen;
+                    bool _1845_recOwned;
+                    bool _1846_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1847_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1223;
+                    bool _out1224;
+                    bool _out1225;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1226;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1223, out _out1224, out _out1225, out _out1226);
+                    _1844_recursiveGen = _out1223;
+                    _1845_recOwned = _out1224;
+                    _1846_recErased = _out1225;
+                    _1847_recIdents = _out1226;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1844_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1845_recOwned;
+                    isErased = _1846_recErased;
+                    readIdents = _1847_recIdents;
+                  }
+                } else if (_source65.is_Trait) {
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1848___mcc_h967 = _source65.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1686_recursiveGen;
-                    bool _1687_recOwned;
-                    bool _1688_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1689_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1108;
-                    bool _out1109;
-                    bool _out1110;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1111;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1108, out _out1109, out _out1110, out _out1111);
-                    _1686_recursiveGen = _out1108;
-                    _1687_recOwned = _out1109;
-                    _1688_recErased = _out1110;
-                    _1689_recIdents = _out1111;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1686_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1687_recOwned;
-                    isErased = _1688_recErased;
-                    readIdents = _1689_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1849_recursiveGen;
+                    bool _1850_recOwned;
+                    bool _1851_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1852_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1227;
+                    bool _out1228;
+                    bool _out1229;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1230;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1227, out _out1228, out _out1229, out _out1230);
+                    _1849_recursiveGen = _out1227;
+                    _1850_recOwned = _out1228;
+                    _1851_recErased = _out1229;
+                    _1852_recIdents = _out1230;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1849_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1850_recOwned;
+                    isErased = _1851_recErased;
+                    readIdents = _1852_recIdents;
                   }
                 } else {
-                  DAST._IType _1690___mcc_h746 = _source63.dtor_Newtype_a0;
-                  DAST._IType _1691_b = _1690___mcc_h746;
+                  DAST._IType _1853___mcc_h969 = _source65.dtor_Newtype_a0;
+                  DAST._IType _1854_b = _1853___mcc_h969;
                   {
-                    if (object.Equals(_482_fromTpe, _1691_b)) {
-                      Dafny.ISequence<Dafny.Rune> _1692_recursiveGen;
-                      bool _1693_recOwned;
-                      bool _1694_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1695_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out1112;
-                      bool _out1113;
-                      bool _out1114;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1115;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1112, out _out1113, out _out1114, out _out1115);
-                      _1692_recursiveGen = _out1112;
-                      _1693_recOwned = _out1113;
-                      _1694_recErased = _out1114;
-                      _1695_recIdents = _out1115;
-                      Dafny.ISequence<Dafny.Rune> _1696_rhsType;
-                      Dafny.ISequence<Dafny.Rune> _out1116;
-                      _out1116 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                      _1696_rhsType = _out1116;
-                      Dafny.ISequence<Dafny.Rune> _1697_uneraseFn;
-                      _1697_uneraseFn = ((_1693_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1696_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1697_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1692_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _1693_recOwned;
+                    if (object.Equals(_494_fromTpe, _1854_b)) {
+                      Dafny.ISequence<Dafny.Rune> _1855_recursiveGen;
+                      bool _1856_recOwned;
+                      bool _1857_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1858_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1231;
+                      bool _out1232;
+                      bool _out1233;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1234;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1231, out _out1232, out _out1233, out _out1234);
+                      _1855_recursiveGen = _out1231;
+                      _1856_recOwned = _out1232;
+                      _1857_recErased = _out1233;
+                      _1858_recIdents = _out1234;
+                      Dafny.ISequence<Dafny.Rune> _1859_rhsType;
+                      Dafny.ISequence<Dafny.Rune> _out1235;
+                      _out1235 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                      _1859_rhsType = _out1235;
+                      Dafny.ISequence<Dafny.Rune> _1860_uneraseFn;
+                      _1860_uneraseFn = ((_1856_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1859_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1860_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1855_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _1856_recOwned;
                       isErased = false;
-                      readIdents = _1695_recIdents;
+                      readIdents = _1858_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out1117;
-                      bool _out1118;
-                      bool _out1119;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1120;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _1691_b), _1691_b, _481_toTpe), @params, mustOwn, out _out1117, out _out1118, out _out1119, out _out1120);
-                      s = _out1117;
-                      isOwned = _out1118;
-                      isErased = _out1119;
-                      readIdents = _out1120;
+                      Dafny.ISequence<Dafny.Rune> _out1236;
+                      bool _out1237;
+                      bool _out1238;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1239;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1854_b), _1854_b, _493_toTpe), selfIdent, @params, mustOwn, out _out1236, out _out1237, out _out1238, out _out1239);
+                      s = _out1236;
+                      isOwned = _out1237;
+                      isErased = _out1238;
+                      readIdents = _out1239;
                     }
                   }
                 }
-              } else if (_source62.is_Tuple) {
-                Dafny.ISequence<DAST._IType> _1698___mcc_h748 = _source62.dtor_Tuple_a0;
+              } else if (_source64.is_Nullable) {
+                DAST._IType _1861___mcc_h971 = _source64.dtor_Nullable_a0;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1862_recursiveGen;
+                  bool _1863_recOwned;
+                  bool _1864_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1865_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1240;
+                  bool _out1241;
+                  bool _out1242;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1243;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1240, out _out1241, out _out1242, out _out1243);
+                  _1862_recursiveGen = _out1240;
+                  _1863_recOwned = _out1241;
+                  _1864_recErased = _out1242;
+                  _1865_recIdents = _out1243;
+                  if (!(_1863_recOwned)) {
+                    _1862_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1862_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1862_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                  isOwned = true;
+                  isErased = _1864_recErased;
+                  readIdents = _1865_recIdents;
+                }
+              } else if (_source64.is_Tuple) {
+                Dafny.ISequence<DAST._IType> _1866___mcc_h973 = _source64.dtor_Tuple_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1699_recursiveGen;
-                  bool _1700_recOwned;
-                  bool _1701_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1702_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1121;
-                  bool _out1122;
-                  bool _out1123;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1124;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1121, out _out1122, out _out1123, out _out1124);
-                  _1699_recursiveGen = _out1121;
-                  _1700_recOwned = _out1122;
-                  _1701_recErased = _out1123;
-                  _1702_recIdents = _out1124;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1699_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1700_recOwned;
-                  isErased = _1701_recErased;
-                  readIdents = _1702_recIdents;
-                }
-              } else if (_source62.is_Array) {
-                DAST._IType _1703___mcc_h750 = _source62.dtor_element;
+                  Dafny.ISequence<Dafny.Rune> _1867_recursiveGen;
+                  bool _1868_recOwned;
+                  bool _1869_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1870_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1244;
+                  bool _out1245;
+                  bool _out1246;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1247;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1244, out _out1245, out _out1246, out _out1247);
+                  _1867_recursiveGen = _out1244;
+                  _1868_recOwned = _out1245;
+                  _1869_recErased = _out1246;
+                  _1870_recIdents = _out1247;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1867_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1868_recOwned;
+                  isErased = _1869_recErased;
+                  readIdents = _1870_recIdents;
+                }
+              } else if (_source64.is_Array) {
+                DAST._IType _1871___mcc_h975 = _source64.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1704_recursiveGen;
-                  bool _1705_recOwned;
-                  bool _1706_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1707_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1125;
-                  bool _out1126;
-                  bool _out1127;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1128;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1125, out _out1126, out _out1127, out _out1128);
-                  _1704_recursiveGen = _out1125;
-                  _1705_recOwned = _out1126;
-                  _1706_recErased = _out1127;
-                  _1707_recIdents = _out1128;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1704_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1705_recOwned;
-                  isErased = _1706_recErased;
-                  readIdents = _1707_recIdents;
-                }
-              } else if (_source62.is_Seq) {
-                DAST._IType _1708___mcc_h752 = _source62.dtor_element;
+                  Dafny.ISequence<Dafny.Rune> _1872_recursiveGen;
+                  bool _1873_recOwned;
+                  bool _1874_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1875_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1248;
+                  bool _out1249;
+                  bool _out1250;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1251;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1248, out _out1249, out _out1250, out _out1251);
+                  _1872_recursiveGen = _out1248;
+                  _1873_recOwned = _out1249;
+                  _1874_recErased = _out1250;
+                  _1875_recIdents = _out1251;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1872_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1873_recOwned;
+                  isErased = _1874_recErased;
+                  readIdents = _1875_recIdents;
+                }
+              } else if (_source64.is_Seq) {
+                DAST._IType _1876___mcc_h977 = _source64.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1709_recursiveGen;
-                  bool _1710_recOwned;
-                  bool _1711_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1712_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1129;
-                  bool _out1130;
-                  bool _out1131;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1132;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1129, out _out1130, out _out1131, out _out1132);
-                  _1709_recursiveGen = _out1129;
-                  _1710_recOwned = _out1130;
-                  _1711_recErased = _out1131;
-                  _1712_recIdents = _out1132;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1709_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1710_recOwned;
-                  isErased = _1711_recErased;
-                  readIdents = _1712_recIdents;
-                }
-              } else if (_source62.is_Set) {
-                DAST._IType _1713___mcc_h754 = _source62.dtor_element;
+                  Dafny.ISequence<Dafny.Rune> _1877_recursiveGen;
+                  bool _1878_recOwned;
+                  bool _1879_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1880_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1252;
+                  bool _out1253;
+                  bool _out1254;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1255;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1252, out _out1253, out _out1254, out _out1255);
+                  _1877_recursiveGen = _out1252;
+                  _1878_recOwned = _out1253;
+                  _1879_recErased = _out1254;
+                  _1880_recIdents = _out1255;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1877_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1878_recOwned;
+                  isErased = _1879_recErased;
+                  readIdents = _1880_recIdents;
+                }
+              } else if (_source64.is_Set) {
+                DAST._IType _1881___mcc_h979 = _source64.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1714_recursiveGen;
-                  bool _1715_recOwned;
-                  bool _1716_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1717_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1133;
-                  bool _out1134;
-                  bool _out1135;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1136;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1133, out _out1134, out _out1135, out _out1136);
-                  _1714_recursiveGen = _out1133;
-                  _1715_recOwned = _out1134;
-                  _1716_recErased = _out1135;
-                  _1717_recIdents = _out1136;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1714_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1715_recOwned;
-                  isErased = _1716_recErased;
-                  readIdents = _1717_recIdents;
-                }
-              } else if (_source62.is_Multiset) {
-                DAST._IType _1718___mcc_h756 = _source62.dtor_element;
+                  Dafny.ISequence<Dafny.Rune> _1882_recursiveGen;
+                  bool _1883_recOwned;
+                  bool _1884_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1885_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1256;
+                  bool _out1257;
+                  bool _out1258;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1259;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1256, out _out1257, out _out1258, out _out1259);
+                  _1882_recursiveGen = _out1256;
+                  _1883_recOwned = _out1257;
+                  _1884_recErased = _out1258;
+                  _1885_recIdents = _out1259;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1882_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1883_recOwned;
+                  isErased = _1884_recErased;
+                  readIdents = _1885_recIdents;
+                }
+              } else if (_source64.is_Multiset) {
+                DAST._IType _1886___mcc_h981 = _source64.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1719_recursiveGen;
-                  bool _1720_recOwned;
-                  bool _1721_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1722_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1137;
-                  bool _out1138;
-                  bool _out1139;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1140;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1137, out _out1138, out _out1139, out _out1140);
-                  _1719_recursiveGen = _out1137;
-                  _1720_recOwned = _out1138;
-                  _1721_recErased = _out1139;
-                  _1722_recIdents = _out1140;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1719_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1720_recOwned;
-                  isErased = _1721_recErased;
-                  readIdents = _1722_recIdents;
-                }
-              } else if (_source62.is_Map) {
-                DAST._IType _1723___mcc_h758 = _source62.dtor_key;
-                DAST._IType _1724___mcc_h759 = _source62.dtor_value;
+                  Dafny.ISequence<Dafny.Rune> _1887_recursiveGen;
+                  bool _1888_recOwned;
+                  bool _1889_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1890_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1260;
+                  bool _out1261;
+                  bool _out1262;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1263;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1260, out _out1261, out _out1262, out _out1263);
+                  _1887_recursiveGen = _out1260;
+                  _1888_recOwned = _out1261;
+                  _1889_recErased = _out1262;
+                  _1890_recIdents = _out1263;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1887_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1888_recOwned;
+                  isErased = _1889_recErased;
+                  readIdents = _1890_recIdents;
+                }
+              } else if (_source64.is_Map) {
+                DAST._IType _1891___mcc_h983 = _source64.dtor_key;
+                DAST._IType _1892___mcc_h984 = _source64.dtor_value;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1725_recursiveGen;
-                  bool _1726_recOwned;
-                  bool _1727_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1728_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1141;
-                  bool _out1142;
-                  bool _out1143;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1144;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1141, out _out1142, out _out1143, out _out1144);
-                  _1725_recursiveGen = _out1141;
-                  _1726_recOwned = _out1142;
-                  _1727_recErased = _out1143;
-                  _1728_recIdents = _out1144;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1725_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1726_recOwned;
-                  isErased = _1727_recErased;
-                  readIdents = _1728_recIdents;
-                }
-              } else if (_source62.is_Arrow) {
-                Dafny.ISequence<DAST._IType> _1729___mcc_h762 = _source62.dtor_args;
-                DAST._IType _1730___mcc_h763 = _source62.dtor_result;
+                  Dafny.ISequence<Dafny.Rune> _1893_recursiveGen;
+                  bool _1894_recOwned;
+                  bool _1895_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1896_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1264;
+                  bool _out1265;
+                  bool _out1266;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1267;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1264, out _out1265, out _out1266, out _out1267);
+                  _1893_recursiveGen = _out1264;
+                  _1894_recOwned = _out1265;
+                  _1895_recErased = _out1266;
+                  _1896_recIdents = _out1267;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1893_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1894_recOwned;
+                  isErased = _1895_recErased;
+                  readIdents = _1896_recIdents;
+                }
+              } else if (_source64.is_Arrow) {
+                Dafny.ISequence<DAST._IType> _1897___mcc_h987 = _source64.dtor_args;
+                DAST._IType _1898___mcc_h988 = _source64.dtor_result;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1731_recursiveGen;
-                  bool _1732_recOwned;
-                  bool _1733_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1734_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1145;
-                  bool _out1146;
-                  bool _out1147;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1148;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1145, out _out1146, out _out1147, out _out1148);
-                  _1731_recursiveGen = _out1145;
-                  _1732_recOwned = _out1146;
-                  _1733_recErased = _out1147;
-                  _1734_recIdents = _out1148;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1731_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1732_recOwned;
-                  isErased = _1733_recErased;
-                  readIdents = _1734_recIdents;
-                }
-              } else if (_source62.is_Primitive) {
-                DAST._IPrimitive _1735___mcc_h766 = _source62.dtor_Primitive_a0;
-                DAST._IPrimitive _source64 = _1735___mcc_h766;
-                if (_source64.is_Int) {
+                  Dafny.ISequence<Dafny.Rune> _1899_recursiveGen;
+                  bool _1900_recOwned;
+                  bool _1901_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1902_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1268;
+                  bool _out1269;
+                  bool _out1270;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1271;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1268, out _out1269, out _out1270, out _out1271);
+                  _1899_recursiveGen = _out1268;
+                  _1900_recOwned = _out1269;
+                  _1901_recErased = _out1270;
+                  _1902_recIdents = _out1271;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1899_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1900_recOwned;
+                  isErased = _1901_recErased;
+                  readIdents = _1902_recIdents;
+                }
+              } else if (_source64.is_Primitive) {
+                DAST._IPrimitive _1903___mcc_h991 = _source64.dtor_Primitive_a0;
+                DAST._IPrimitive _source66 = _1903___mcc_h991;
+                if (_source66.is_Int) {
                   {
-                    Dafny.ISequence<Dafny.Rune> _1736_rhsType;
-                    Dafny.ISequence<Dafny.Rune> _out1149;
-                    _out1149 = DCOMP.COMP.GenType(_482_fromTpe, true, false);
-                    _1736_rhsType = _out1149;
-                    Dafny.ISequence<Dafny.Rune> _1737_recursiveGen;
-                    bool _1738___v48;
-                    bool _1739___v49;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1740_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1150;
-                    bool _out1151;
-                    bool _out1152;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1153;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, true, out _out1150, out _out1151, out _out1152, out _out1153);
-                    _1737_recursiveGen = _out1150;
-                    _1738___v48 = _out1151;
-                    _1739___v49 = _out1152;
-                    _1740_recIdents = _out1153;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigInt::from("), _1737_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                    Dafny.ISequence<Dafny.Rune> _1904_rhsType;
+                    Dafny.ISequence<Dafny.Rune> _out1272;
+                    _out1272 = DCOMP.COMP.GenType(_494_fromTpe, true, false);
+                    _1904_rhsType = _out1272;
+                    Dafny.ISequence<Dafny.Rune> _1905_recursiveGen;
+                    bool _1906___v52;
+                    bool _1907___v53;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1908_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1273;
+                    bool _out1274;
+                    bool _out1275;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1276;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, true, out _out1273, out _out1274, out _out1275, out _out1276);
+                    _1905_recursiveGen = _out1273;
+                    _1906___v52 = _out1274;
+                    _1907___v53 = _out1275;
+                    _1908_recIdents = _out1276;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigInt::from("), _1905_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
                     isOwned = true;
                     isErased = true;
-                    readIdents = _1740_recIdents;
+                    readIdents = _1908_recIdents;
                   }
-                } else if (_source64.is_Real) {
+                } else if (_source66.is_Real) {
                   {
-                    Dafny.ISequence<Dafny.Rune> _1741_recursiveGen;
-                    bool _1742_recOwned;
-                    bool _1743_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1744_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1154;
-                    bool _out1155;
-                    bool _out1156;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1157;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1154, out _out1155, out _out1156, out _out1157);
-                    _1741_recursiveGen = _out1154;
-                    _1742_recOwned = _out1155;
-                    _1743_recErased = _out1156;
-                    _1744_recIdents = _out1157;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1741_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1742_recOwned;
-                    isErased = _1743_recErased;
-                    readIdents = _1744_recIdents;
-                  }
-                } else if (_source64.is_String) {
+                    Dafny.ISequence<Dafny.Rune> _1909_recursiveGen;
+                    bool _1910_recOwned;
+                    bool _1911_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1912_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1277;
+                    bool _out1278;
+                    bool _out1279;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1280;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1277, out _out1278, out _out1279, out _out1280);
+                    _1909_recursiveGen = _out1277;
+                    _1910_recOwned = _out1278;
+                    _1911_recErased = _out1279;
+                    _1912_recIdents = _out1280;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1909_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1910_recOwned;
+                    isErased = _1911_recErased;
+                    readIdents = _1912_recIdents;
+                  }
+                } else if (_source66.is_String) {
                   {
-                    Dafny.ISequence<Dafny.Rune> _1745_recursiveGen;
-                    bool _1746_recOwned;
-                    bool _1747_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1748_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1158;
-                    bool _out1159;
-                    bool _out1160;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1161;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1158, out _out1159, out _out1160, out _out1161);
-                    _1745_recursiveGen = _out1158;
-                    _1746_recOwned = _out1159;
-                    _1747_recErased = _out1160;
-                    _1748_recIdents = _out1161;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1745_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1746_recOwned;
-                    isErased = _1747_recErased;
-                    readIdents = _1748_recIdents;
-                  }
-                } else if (_source64.is_Bool) {
+                    Dafny.ISequence<Dafny.Rune> _1913_recursiveGen;
+                    bool _1914_recOwned;
+                    bool _1915_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1916_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1281;
+                    bool _out1282;
+                    bool _out1283;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1284;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1281, out _out1282, out _out1283, out _out1284);
+                    _1913_recursiveGen = _out1281;
+                    _1914_recOwned = _out1282;
+                    _1915_recErased = _out1283;
+                    _1916_recIdents = _out1284;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1913_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1914_recOwned;
+                    isErased = _1915_recErased;
+                    readIdents = _1916_recIdents;
+                  }
+                } else if (_source66.is_Bool) {
                   {
-                    Dafny.ISequence<Dafny.Rune> _1749_recursiveGen;
-                    bool _1750_recOwned;
-                    bool _1751_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1752_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1162;
-                    bool _out1163;
-                    bool _out1164;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1165;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1162, out _out1163, out _out1164, out _out1165);
-                    _1749_recursiveGen = _out1162;
-                    _1750_recOwned = _out1163;
-                    _1751_recErased = _out1164;
-                    _1752_recIdents = _out1165;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1749_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1750_recOwned;
-                    isErased = _1751_recErased;
-                    readIdents = _1752_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1917_recursiveGen;
+                    bool _1918_recOwned;
+                    bool _1919_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1920_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1285;
+                    bool _out1286;
+                    bool _out1287;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1288;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1285, out _out1286, out _out1287, out _out1288);
+                    _1917_recursiveGen = _out1285;
+                    _1918_recOwned = _out1286;
+                    _1919_recErased = _out1287;
+                    _1920_recIdents = _out1288;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1917_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1918_recOwned;
+                    isErased = _1919_recErased;
+                    readIdents = _1920_recIdents;
                   }
                 } else {
                   {
-                    Dafny.ISequence<Dafny.Rune> _1753_recursiveGen;
-                    bool _1754_recOwned;
-                    bool _1755_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1756_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1166;
-                    bool _out1167;
-                    bool _out1168;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1169;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1166, out _out1167, out _out1168, out _out1169);
-                    _1753_recursiveGen = _out1166;
-                    _1754_recOwned = _out1167;
-                    _1755_recErased = _out1168;
-                    _1756_recIdents = _out1169;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1753_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1754_recOwned;
-                    isErased = _1755_recErased;
-                    readIdents = _1756_recIdents;
-                  }
-                }
-              } else if (_source62.is_Passthrough) {
-                Dafny.ISequence<Dafny.Rune> _1757___mcc_h768 = _source62.dtor_Passthrough_a0;
+                    Dafny.ISequence<Dafny.Rune> _1921_recursiveGen;
+                    bool _1922_recOwned;
+                    bool _1923_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1924_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1289;
+                    bool _out1290;
+                    bool _out1291;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1292;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1289, out _out1290, out _out1291, out _out1292);
+                    _1921_recursiveGen = _out1289;
+                    _1922_recOwned = _out1290;
+                    _1923_recErased = _out1291;
+                    _1924_recIdents = _out1292;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1921_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1922_recOwned;
+                    isErased = _1923_recErased;
+                    readIdents = _1924_recIdents;
+                  }
+                }
+              } else if (_source64.is_Passthrough) {
+                Dafny.ISequence<Dafny.Rune> _1925___mcc_h993 = _source64.dtor_Passthrough_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1758_recursiveGen;
-                  bool _1759___v56;
-                  bool _1760___v57;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1761_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1170;
-                  bool _out1171;
-                  bool _out1172;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1173;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, true, out _out1170, out _out1171, out _out1172, out _out1173);
-                  _1758_recursiveGen = _out1170;
-                  _1759___v56 = _out1171;
-                  _1760___v57 = _out1172;
-                  _1761_recIdents = _out1173;
-                  Dafny.ISequence<Dafny.Rune> _1762_toTpeGen;
-                  Dafny.ISequence<Dafny.Rune> _out1174;
-                  _out1174 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                  _1762_toTpeGen = _out1174;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(("), _1758_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") as ")), _1762_toTpeGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                  Dafny.ISequence<Dafny.Rune> _1926_recursiveGen;
+                  bool _1927___v60;
+                  bool _1928___v61;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1929_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1293;
+                  bool _out1294;
+                  bool _out1295;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1296;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, true, out _out1293, out _out1294, out _out1295, out _out1296);
+                  _1926_recursiveGen = _out1293;
+                  _1927___v60 = _out1294;
+                  _1928___v61 = _out1295;
+                  _1929_recIdents = _out1296;
+                  Dafny.ISequence<Dafny.Rune> _1930_toTpeGen;
+                  Dafny.ISequence<Dafny.Rune> _out1297;
+                  _out1297 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                  _1930_toTpeGen = _out1297;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(("), _1926_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(") as ")), _1930_toTpeGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
                   isOwned = true;
                   isErased = true;
-                  readIdents = _1761_recIdents;
+                  readIdents = _1929_recIdents;
                 }
               } else {
-                Dafny.ISequence<Dafny.Rune> _1763___mcc_h770 = _source62.dtor_TypeArg_a0;
+                Dafny.ISequence<Dafny.Rune> _1931___mcc_h995 = _source64.dtor_TypeArg_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1764_recursiveGen;
-                  bool _1765_recOwned;
-                  bool _1766_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1767_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1175;
-                  bool _out1176;
-                  bool _out1177;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1178;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1175, out _out1176, out _out1177, out _out1178);
-                  _1764_recursiveGen = _out1175;
-                  _1765_recOwned = _out1176;
-                  _1766_recErased = _out1177;
-                  _1767_recIdents = _out1178;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1764_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1765_recOwned;
-                  isErased = _1766_recErased;
-                  readIdents = _1767_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _1932_recursiveGen;
+                  bool _1933_recOwned;
+                  bool _1934_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1935_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1298;
+                  bool _out1299;
+                  bool _out1300;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1301;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1298, out _out1299, out _out1300, out _out1301);
+                  _1932_recursiveGen = _out1298;
+                  _1933_recOwned = _out1299;
+                  _1934_recErased = _out1300;
+                  _1935_recIdents = _out1301;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1932_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1933_recOwned;
+                  isErased = _1934_recErased;
+                  readIdents = _1935_recIdents;
                 }
               }
             } else {
-              Dafny.ISequence<Dafny.Rune> _1768___mcc_h772 = _source26.dtor_TypeArg_a0;
-              DAST._IType _source65 = _489___mcc_h124;
-              if (_source65.is_Path) {
-                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1769___mcc_h775 = _source65.dtor_Path_a0;
-                Dafny.ISequence<DAST._IType> _1770___mcc_h776 = _source65.dtor_typeArgs;
-                DAST._IResolvedType _1771___mcc_h777 = _source65.dtor_resolved;
-                DAST._IResolvedType _source66 = _1771___mcc_h777;
-                if (_source66.is_Datatype) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1772___mcc_h781 = _source66.dtor_path;
+              Dafny.ISequence<Dafny.Rune> _1936___mcc_h997 = _source26.dtor_TypeArg_a0;
+              DAST._IType _source67 = _501___mcc_h238;
+              if (_source67.is_Path) {
+                Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1937___mcc_h1001 = _source67.dtor_Path_a0;
+                Dafny.ISequence<DAST._IType> _1938___mcc_h1002 = _source67.dtor_typeArgs;
+                DAST._IResolvedType _1939___mcc_h1003 = _source67.dtor_resolved;
+                DAST._IResolvedType _source68 = _1939___mcc_h1003;
+                if (_source68.is_Datatype) {
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1940___mcc_h1007 = _source68.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1773_recursiveGen;
-                    bool _1774_recOwned;
-                    bool _1775_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1776_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1179;
-                    bool _out1180;
-                    bool _out1181;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1182;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1179, out _out1180, out _out1181, out _out1182);
-                    _1773_recursiveGen = _out1179;
-                    _1774_recOwned = _out1180;
-                    _1775_recErased = _out1181;
-                    _1776_recIdents = _out1182;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1773_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1774_recOwned;
-                    isErased = _1775_recErased;
-                    readIdents = _1776_recIdents;
-                  }
-                } else if (_source66.is_Trait) {
-                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1777___mcc_h783 = _source66.dtor_path;
+                    Dafny.ISequence<Dafny.Rune> _1941_recursiveGen;
+                    bool _1942_recOwned;
+                    bool _1943_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1944_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1302;
+                    bool _out1303;
+                    bool _out1304;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1305;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1302, out _out1303, out _out1304, out _out1305);
+                    _1941_recursiveGen = _out1302;
+                    _1942_recOwned = _out1303;
+                    _1943_recErased = _out1304;
+                    _1944_recIdents = _out1305;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1941_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1942_recOwned;
+                    isErased = _1943_recErased;
+                    readIdents = _1944_recIdents;
+                  }
+                } else if (_source68.is_Trait) {
+                  Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1945___mcc_h1009 = _source68.dtor_path;
                   {
-                    Dafny.ISequence<Dafny.Rune> _1778_recursiveGen;
-                    bool _1779_recOwned;
-                    bool _1780_recErased;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1781_recIdents;
-                    Dafny.ISequence<Dafny.Rune> _out1183;
-                    bool _out1184;
-                    bool _out1185;
-                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1186;
-                    DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1183, out _out1184, out _out1185, out _out1186);
-                    _1778_recursiveGen = _out1183;
-                    _1779_recOwned = _out1184;
-                    _1780_recErased = _out1185;
-                    _1781_recIdents = _out1186;
-                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1778_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                    isOwned = _1779_recOwned;
-                    isErased = _1780_recErased;
-                    readIdents = _1781_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _1946_recursiveGen;
+                    bool _1947_recOwned;
+                    bool _1948_recErased;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1949_recIdents;
+                    Dafny.ISequence<Dafny.Rune> _out1306;
+                    bool _out1307;
+                    bool _out1308;
+                    Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1309;
+                    DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1306, out _out1307, out _out1308, out _out1309);
+                    _1946_recursiveGen = _out1306;
+                    _1947_recOwned = _out1307;
+                    _1948_recErased = _out1308;
+                    _1949_recIdents = _out1309;
+                    s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1946_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                    isOwned = _1947_recOwned;
+                    isErased = _1948_recErased;
+                    readIdents = _1949_recIdents;
                   }
                 } else {
-                  DAST._IType _1782___mcc_h785 = _source66.dtor_Newtype_a0;
-                  DAST._IType _1783_b = _1782___mcc_h785;
+                  DAST._IType _1950___mcc_h1011 = _source68.dtor_Newtype_a0;
+                  DAST._IType _1951_b = _1950___mcc_h1011;
                   {
-                    if (object.Equals(_482_fromTpe, _1783_b)) {
-                      Dafny.ISequence<Dafny.Rune> _1784_recursiveGen;
-                      bool _1785_recOwned;
-                      bool _1786_recErased;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1787_recIdents;
-                      Dafny.ISequence<Dafny.Rune> _out1187;
-                      bool _out1188;
-                      bool _out1189;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1190;
-                      DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1187, out _out1188, out _out1189, out _out1190);
-                      _1784_recursiveGen = _out1187;
-                      _1785_recOwned = _out1188;
-                      _1786_recErased = _out1189;
-                      _1787_recIdents = _out1190;
-                      Dafny.ISequence<Dafny.Rune> _1788_rhsType;
-                      Dafny.ISequence<Dafny.Rune> _out1191;
-                      _out1191 = DCOMP.COMP.GenType(_481_toTpe, true, false);
-                      _1788_rhsType = _out1191;
-                      Dafny.ISequence<Dafny.Rune> _1789_uneraseFn;
-                      _1789_uneraseFn = ((_1785_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1788_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1789_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1784_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-                      isOwned = _1785_recOwned;
+                    if (object.Equals(_494_fromTpe, _1951_b)) {
+                      Dafny.ISequence<Dafny.Rune> _1952_recursiveGen;
+                      bool _1953_recOwned;
+                      bool _1954_recErased;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1955_recIdents;
+                      Dafny.ISequence<Dafny.Rune> _out1310;
+                      bool _out1311;
+                      bool _out1312;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1313;
+                      DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1310, out _out1311, out _out1312, out _out1313);
+                      _1952_recursiveGen = _out1310;
+                      _1953_recOwned = _out1311;
+                      _1954_recErased = _out1312;
+                      _1955_recIdents = _out1313;
+                      Dafny.ISequence<Dafny.Rune> _1956_rhsType;
+                      Dafny.ISequence<Dafny.Rune> _out1314;
+                      _out1314 = DCOMP.COMP.GenType(_493_toTpe, true, false);
+                      _1956_rhsType = _out1314;
+                      Dafny.ISequence<Dafny.Rune> _1957_uneraseFn;
+                      _1957_uneraseFn = ((_1953_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+                      s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _1956_rhsType), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as ::dafny_runtime::DafnyUnerasable<_>>::")), _1957_uneraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1952_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                      isOwned = _1953_recOwned;
                       isErased = false;
-                      readIdents = _1787_recIdents;
+                      readIdents = _1955_recIdents;
                     } else {
-                      Dafny.ISequence<Dafny.Rune> _out1192;
-                      bool _out1193;
-                      bool _out1194;
-                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1195;
-                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_483_expr, _482_fromTpe, _1783_b), _1783_b, _481_toTpe), @params, mustOwn, out _out1192, out _out1193, out _out1194, out _out1195);
-                      s = _out1192;
-                      isOwned = _out1193;
-                      isErased = _out1194;
-                      readIdents = _out1195;
+                      Dafny.ISequence<Dafny.Rune> _out1315;
+                      bool _out1316;
+                      bool _out1317;
+                      Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1318;
+                      DCOMP.COMP.GenExpr(DAST.Expression.create_Convert(DAST.Expression.create_Convert(_495_expr, _494_fromTpe, _1951_b), _1951_b, _493_toTpe), selfIdent, @params, mustOwn, out _out1315, out _out1316, out _out1317, out _out1318);
+                      s = _out1315;
+                      isOwned = _out1316;
+                      isErased = _out1317;
+                      readIdents = _out1318;
                     }
                   }
                 }
-              } else if (_source65.is_Tuple) {
-                Dafny.ISequence<DAST._IType> _1790___mcc_h787 = _source65.dtor_Tuple_a0;
+              } else if (_source67.is_Nullable) {
+                DAST._IType _1958___mcc_h1013 = _source67.dtor_Nullable_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1791_recursiveGen;
-                  bool _1792_recOwned;
-                  bool _1793_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1794_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1196;
-                  bool _out1197;
-                  bool _out1198;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1199;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1196, out _out1197, out _out1198, out _out1199);
-                  _1791_recursiveGen = _out1196;
-                  _1792_recOwned = _out1197;
-                  _1793_recErased = _out1198;
-                  _1794_recIdents = _out1199;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1791_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1792_recOwned;
-                  isErased = _1793_recErased;
-                  readIdents = _1794_recIdents;
-                }
-              } else if (_source65.is_Array) {
-                DAST._IType _1795___mcc_h789 = _source65.dtor_element;
+                  Dafny.ISequence<Dafny.Rune> _1959_recursiveGen;
+                  bool _1960_recOwned;
+                  bool _1961_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1962_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1319;
+                  bool _out1320;
+                  bool _out1321;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1322;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1319, out _out1320, out _out1321, out _out1322);
+                  _1959_recursiveGen = _out1319;
+                  _1960_recOwned = _out1320;
+                  _1961_recErased = _out1321;
+                  _1962_recIdents = _out1322;
+                  if (!(_1960_recOwned)) {
+                    _1959_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(_1959_recursiveGen, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                  }
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("Some("), _1959_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+                  isOwned = true;
+                  isErased = _1961_recErased;
+                  readIdents = _1962_recIdents;
+                }
+              } else if (_source67.is_Tuple) {
+                Dafny.ISequence<DAST._IType> _1963___mcc_h1015 = _source67.dtor_Tuple_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1796_recursiveGen;
-                  bool _1797_recOwned;
-                  bool _1798_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1799_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1200;
-                  bool _out1201;
-                  bool _out1202;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1203;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1200, out _out1201, out _out1202, out _out1203);
-                  _1796_recursiveGen = _out1200;
-                  _1797_recOwned = _out1201;
-                  _1798_recErased = _out1202;
-                  _1799_recIdents = _out1203;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1796_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1797_recOwned;
-                  isErased = _1798_recErased;
-                  readIdents = _1799_recIdents;
-                }
-              } else if (_source65.is_Seq) {
-                DAST._IType _1800___mcc_h791 = _source65.dtor_element;
+                  Dafny.ISequence<Dafny.Rune> _1964_recursiveGen;
+                  bool _1965_recOwned;
+                  bool _1966_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1967_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1323;
+                  bool _out1324;
+                  bool _out1325;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1326;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1323, out _out1324, out _out1325, out _out1326);
+                  _1964_recursiveGen = _out1323;
+                  _1965_recOwned = _out1324;
+                  _1966_recErased = _out1325;
+                  _1967_recIdents = _out1326;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1964_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1965_recOwned;
+                  isErased = _1966_recErased;
+                  readIdents = _1967_recIdents;
+                }
+              } else if (_source67.is_Array) {
+                DAST._IType _1968___mcc_h1017 = _source67.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1801_recursiveGen;
-                  bool _1802_recOwned;
-                  bool _1803_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1804_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1204;
-                  bool _out1205;
-                  bool _out1206;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1207;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1204, out _out1205, out _out1206, out _out1207);
-                  _1801_recursiveGen = _out1204;
-                  _1802_recOwned = _out1205;
-                  _1803_recErased = _out1206;
-                  _1804_recIdents = _out1207;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1801_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1802_recOwned;
-                  isErased = _1803_recErased;
-                  readIdents = _1804_recIdents;
-                }
-              } else if (_source65.is_Set) {
-                DAST._IType _1805___mcc_h793 = _source65.dtor_element;
+                  Dafny.ISequence<Dafny.Rune> _1969_recursiveGen;
+                  bool _1970_recOwned;
+                  bool _1971_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1972_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1327;
+                  bool _out1328;
+                  bool _out1329;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1330;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1327, out _out1328, out _out1329, out _out1330);
+                  _1969_recursiveGen = _out1327;
+                  _1970_recOwned = _out1328;
+                  _1971_recErased = _out1329;
+                  _1972_recIdents = _out1330;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1969_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1970_recOwned;
+                  isErased = _1971_recErased;
+                  readIdents = _1972_recIdents;
+                }
+              } else if (_source67.is_Seq) {
+                DAST._IType _1973___mcc_h1019 = _source67.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1806_recursiveGen;
-                  bool _1807_recOwned;
-                  bool _1808_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1809_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1208;
-                  bool _out1209;
-                  bool _out1210;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1211;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1208, out _out1209, out _out1210, out _out1211);
-                  _1806_recursiveGen = _out1208;
-                  _1807_recOwned = _out1209;
-                  _1808_recErased = _out1210;
-                  _1809_recIdents = _out1211;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1806_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1807_recOwned;
-                  isErased = _1808_recErased;
-                  readIdents = _1809_recIdents;
-                }
-              } else if (_source65.is_Multiset) {
-                DAST._IType _1810___mcc_h795 = _source65.dtor_element;
+                  Dafny.ISequence<Dafny.Rune> _1974_recursiveGen;
+                  bool _1975_recOwned;
+                  bool _1976_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1977_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1331;
+                  bool _out1332;
+                  bool _out1333;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1334;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1331, out _out1332, out _out1333, out _out1334);
+                  _1974_recursiveGen = _out1331;
+                  _1975_recOwned = _out1332;
+                  _1976_recErased = _out1333;
+                  _1977_recIdents = _out1334;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1974_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1975_recOwned;
+                  isErased = _1976_recErased;
+                  readIdents = _1977_recIdents;
+                }
+              } else if (_source67.is_Set) {
+                DAST._IType _1978___mcc_h1021 = _source67.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1811_recursiveGen;
-                  bool _1812_recOwned;
-                  bool _1813_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1814_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1212;
-                  bool _out1213;
-                  bool _out1214;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1215;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1212, out _out1213, out _out1214, out _out1215);
-                  _1811_recursiveGen = _out1212;
-                  _1812_recOwned = _out1213;
-                  _1813_recErased = _out1214;
-                  _1814_recIdents = _out1215;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1811_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1812_recOwned;
-                  isErased = _1813_recErased;
-                  readIdents = _1814_recIdents;
-                }
-              } else if (_source65.is_Map) {
-                DAST._IType _1815___mcc_h797 = _source65.dtor_key;
-                DAST._IType _1816___mcc_h798 = _source65.dtor_value;
+                  Dafny.ISequence<Dafny.Rune> _1979_recursiveGen;
+                  bool _1980_recOwned;
+                  bool _1981_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1982_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1335;
+                  bool _out1336;
+                  bool _out1337;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1338;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1335, out _out1336, out _out1337, out _out1338);
+                  _1979_recursiveGen = _out1335;
+                  _1980_recOwned = _out1336;
+                  _1981_recErased = _out1337;
+                  _1982_recIdents = _out1338;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1979_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1980_recOwned;
+                  isErased = _1981_recErased;
+                  readIdents = _1982_recIdents;
+                }
+              } else if (_source67.is_Multiset) {
+                DAST._IType _1983___mcc_h1023 = _source67.dtor_element;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1817_recursiveGen;
-                  bool _1818_recOwned;
-                  bool _1819_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1820_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1216;
-                  bool _out1217;
-                  bool _out1218;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1219;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1216, out _out1217, out _out1218, out _out1219);
-                  _1817_recursiveGen = _out1216;
-                  _1818_recOwned = _out1217;
-                  _1819_recErased = _out1218;
-                  _1820_recIdents = _out1219;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1817_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1818_recOwned;
-                  isErased = _1819_recErased;
-                  readIdents = _1820_recIdents;
-                }
-              } else if (_source65.is_Arrow) {
-                Dafny.ISequence<DAST._IType> _1821___mcc_h801 = _source65.dtor_args;
-                DAST._IType _1822___mcc_h802 = _source65.dtor_result;
+                  Dafny.ISequence<Dafny.Rune> _1984_recursiveGen;
+                  bool _1985_recOwned;
+                  bool _1986_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1987_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1339;
+                  bool _out1340;
+                  bool _out1341;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1342;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1339, out _out1340, out _out1341, out _out1342);
+                  _1984_recursiveGen = _out1339;
+                  _1985_recOwned = _out1340;
+                  _1986_recErased = _out1341;
+                  _1987_recIdents = _out1342;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1984_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1985_recOwned;
+                  isErased = _1986_recErased;
+                  readIdents = _1987_recIdents;
+                }
+              } else if (_source67.is_Map) {
+                DAST._IType _1988___mcc_h1025 = _source67.dtor_key;
+                DAST._IType _1989___mcc_h1026 = _source67.dtor_value;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1823_recursiveGen;
-                  bool _1824_recOwned;
-                  bool _1825_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1826_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1220;
-                  bool _out1221;
-                  bool _out1222;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1223;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1220, out _out1221, out _out1222, out _out1223);
-                  _1823_recursiveGen = _out1220;
-                  _1824_recOwned = _out1221;
-                  _1825_recErased = _out1222;
-                  _1826_recIdents = _out1223;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1823_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1824_recOwned;
-                  isErased = _1825_recErased;
-                  readIdents = _1826_recIdents;
-                }
-              } else if (_source65.is_Primitive) {
-                DAST._IPrimitive _1827___mcc_h805 = _source65.dtor_Primitive_a0;
+                  Dafny.ISequence<Dafny.Rune> _1990_recursiveGen;
+                  bool _1991_recOwned;
+                  bool _1992_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1993_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1343;
+                  bool _out1344;
+                  bool _out1345;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1346;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1343, out _out1344, out _out1345, out _out1346);
+                  _1990_recursiveGen = _out1343;
+                  _1991_recOwned = _out1344;
+                  _1992_recErased = _out1345;
+                  _1993_recIdents = _out1346;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1990_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1991_recOwned;
+                  isErased = _1992_recErased;
+                  readIdents = _1993_recIdents;
+                }
+              } else if (_source67.is_Arrow) {
+                Dafny.ISequence<DAST._IType> _1994___mcc_h1029 = _source67.dtor_args;
+                DAST._IType _1995___mcc_h1030 = _source67.dtor_result;
+                {
+                  Dafny.ISequence<Dafny.Rune> _1996_recursiveGen;
+                  bool _1997_recOwned;
+                  bool _1998_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1999_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1347;
+                  bool _out1348;
+                  bool _out1349;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1350;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1347, out _out1348, out _out1349, out _out1350);
+                  _1996_recursiveGen = _out1347;
+                  _1997_recOwned = _out1348;
+                  _1998_recErased = _out1349;
+                  _1999_recIdents = _out1350;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1996_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _1997_recOwned;
+                  isErased = _1998_recErased;
+                  readIdents = _1999_recIdents;
+                }
+              } else if (_source67.is_Primitive) {
+                DAST._IPrimitive _2000___mcc_h1033 = _source67.dtor_Primitive_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1828_recursiveGen;
-                  bool _1829_recOwned;
-                  bool _1830_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1831_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1224;
-                  bool _out1225;
-                  bool _out1226;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1227;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1224, out _out1225, out _out1226, out _out1227);
-                  _1828_recursiveGen = _out1224;
-                  _1829_recOwned = _out1225;
-                  _1830_recErased = _out1226;
-                  _1831_recIdents = _out1227;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1828_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1829_recOwned;
-                  isErased = _1830_recErased;
-                  readIdents = _1831_recIdents;
-                }
-              } else if (_source65.is_Passthrough) {
-                Dafny.ISequence<Dafny.Rune> _1832___mcc_h807 = _source65.dtor_Passthrough_a0;
+                  Dafny.ISequence<Dafny.Rune> _2001_recursiveGen;
+                  bool _2002_recOwned;
+                  bool _2003_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2004_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1351;
+                  bool _out1352;
+                  bool _out1353;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1354;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1351, out _out1352, out _out1353, out _out1354);
+                  _2001_recursiveGen = _out1351;
+                  _2002_recOwned = _out1352;
+                  _2003_recErased = _out1353;
+                  _2004_recIdents = _out1354;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2001_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _2002_recOwned;
+                  isErased = _2003_recErased;
+                  readIdents = _2004_recIdents;
+                }
+              } else if (_source67.is_Passthrough) {
+                Dafny.ISequence<Dafny.Rune> _2005___mcc_h1035 = _source67.dtor_Passthrough_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1833_recursiveGen;
-                  bool _1834_recOwned;
-                  bool _1835_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1836_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1228;
-                  bool _out1229;
-                  bool _out1230;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1231;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1228, out _out1229, out _out1230, out _out1231);
-                  _1833_recursiveGen = _out1228;
-                  _1834_recOwned = _out1229;
-                  _1835_recErased = _out1230;
-                  _1836_recIdents = _out1231;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1833_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1834_recOwned;
-                  isErased = _1835_recErased;
-                  readIdents = _1836_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _2006_recursiveGen;
+                  bool _2007_recOwned;
+                  bool _2008_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2009_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1355;
+                  bool _out1356;
+                  bool _out1357;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1358;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1355, out _out1356, out _out1357, out _out1358);
+                  _2006_recursiveGen = _out1355;
+                  _2007_recOwned = _out1356;
+                  _2008_recErased = _out1357;
+                  _2009_recIdents = _out1358;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2006_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _2007_recOwned;
+                  isErased = _2008_recErased;
+                  readIdents = _2009_recIdents;
                 }
               } else {
-                Dafny.ISequence<Dafny.Rune> _1837___mcc_h809 = _source65.dtor_TypeArg_a0;
+                Dafny.ISequence<Dafny.Rune> _2010___mcc_h1037 = _source67.dtor_TypeArg_a0;
                 {
-                  Dafny.ISequence<Dafny.Rune> _1838_recursiveGen;
-                  bool _1839_recOwned;
-                  bool _1840_recErased;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1841_recIdents;
-                  Dafny.ISequence<Dafny.Rune> _out1232;
-                  bool _out1233;
-                  bool _out1234;
-                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1235;
-                  DCOMP.COMP.GenExpr(_483_expr, @params, mustOwn, out _out1232, out _out1233, out _out1234, out _out1235);
-                  _1838_recursiveGen = _out1232;
-                  _1839_recOwned = _out1233;
-                  _1840_recErased = _out1234;
-                  _1841_recIdents = _out1235;
-                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1838_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
-                  isOwned = _1839_recOwned;
-                  isErased = _1840_recErased;
-                  readIdents = _1841_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _2011_recursiveGen;
+                  bool _2012_recOwned;
+                  bool _2013_recErased;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2014_recIdents;
+                  Dafny.ISequence<Dafny.Rune> _out1359;
+                  bool _out1360;
+                  bool _out1361;
+                  Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1362;
+                  DCOMP.COMP.GenExpr(_495_expr, selfIdent, @params, mustOwn, out _out1359, out _out1360, out _out1361, out _out1362);
+                  _2011_recursiveGen = _out1359;
+                  _2012_recOwned = _out1360;
+                  _2013_recErased = _out1361;
+                  _2014_recIdents = _out1362;
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2011_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/* conversion not yet implemented */)"));
+                  isOwned = _2012_recOwned;
+                  isErased = _2013_recErased;
+                  readIdents = _2014_recIdents;
                 }
               }
             }
           }
         }
       } else if (_source19.is_SeqValue) {
-        Dafny.ISequence<DAST._IExpression> _1842___mcc_h22 = _source19.dtor_elements;
-        Dafny.ISequence<DAST._IExpression> _1843_exprs = _1842___mcc_h22;
+        Dafny.ISequence<DAST._IExpression> _2015___mcc_h22 = _source19.dtor_elements;
+        Dafny.ISequence<DAST._IExpression> _2016_exprs = _2015___mcc_h22;
         {
-          Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>> _1844_generatedValues;
-          _1844_generatedValues = Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.FromElements();
+          Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>> _2017_generatedValues;
+          _2017_generatedValues = Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.FromElements();
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
-          BigInteger _1845_i;
-          _1845_i = BigInteger.Zero;
-          bool _1846_allErased;
-          _1846_allErased = true;
-          while ((_1845_i) < (new BigInteger((_1843_exprs).Count))) {
-            Dafny.ISequence<Dafny.Rune> _1847_recursiveGen;
-            bool _1848___v59;
-            bool _1849_isErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1850_recIdents;
-            Dafny.ISequence<Dafny.Rune> _out1236;
-            bool _out1237;
-            bool _out1238;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1239;
-            DCOMP.COMP.GenExpr((_1843_exprs).Select(_1845_i), @params, true, out _out1236, out _out1237, out _out1238, out _out1239);
-            _1847_recursiveGen = _out1236;
-            _1848___v59 = _out1237;
-            _1849_isErased = _out1238;
-            _1850_recIdents = _out1239;
-            _1846_allErased = (_1846_allErased) && (_1849_isErased);
-            _1844_generatedValues = Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.Concat(_1844_generatedValues, Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.FromElements(_System.Tuple2<Dafny.ISequence<Dafny.Rune>, bool>.create(_1847_recursiveGen, _1849_isErased)));
-            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _1850_recIdents);
-            _1845_i = (_1845_i) + (BigInteger.One);
+          BigInteger _2018_i;
+          _2018_i = BigInteger.Zero;
+          bool _2019_allErased;
+          _2019_allErased = true;
+          while ((_2018_i) < (new BigInteger((_2016_exprs).Count))) {
+            Dafny.ISequence<Dafny.Rune> _2020_recursiveGen;
+            bool _2021___v63;
+            bool _2022_isErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2023_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1363;
+            bool _out1364;
+            bool _out1365;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1366;
+            DCOMP.COMP.GenExpr((_2016_exprs).Select(_2018_i), selfIdent, @params, true, out _out1363, out _out1364, out _out1365, out _out1366);
+            _2020_recursiveGen = _out1363;
+            _2021___v63 = _out1364;
+            _2022_isErased = _out1365;
+            _2023_recIdents = _out1366;
+            _2019_allErased = (_2019_allErased) && (_2022_isErased);
+            _2017_generatedValues = Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.Concat(_2017_generatedValues, Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.FromElements(_System.Tuple2<Dafny.ISequence<Dafny.Rune>, bool>.create(_2020_recursiveGen, _2022_isErased)));
+            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _2023_recIdents);
+            _2018_i = (_2018_i) + (BigInteger.One);
           }
           s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("vec![");
-          _1845_i = BigInteger.Zero;
-          while ((_1845_i) < (new BigInteger((_1844_generatedValues).Count))) {
-            if ((_1845_i).Sign == 1) {
+          _2018_i = BigInteger.Zero;
+          while ((_2018_i) < (new BigInteger((_2017_generatedValues).Count))) {
+            if ((_2018_i).Sign == 1) {
               s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
             }
-            Dafny.ISequence<Dafny.Rune> _1851_gen;
-            _1851_gen = ((_1844_generatedValues).Select(_1845_i)).dtor__0;
-            if ((((_1844_generatedValues).Select(_1845_i)).dtor__1) && (!(_1846_allErased))) {
-              _1851_gen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _1851_gen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            Dafny.ISequence<Dafny.Rune> _2024_gen;
+            _2024_gen = ((_2017_generatedValues).Select(_2018_i)).dtor__0;
+            if ((((_2017_generatedValues).Select(_2018_i)).dtor__1) && (!(_2019_allErased))) {
+              _2024_gen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _2024_gen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
             }
-            s = Dafny.Sequence<Dafny.Rune>.Concat(s, _1851_gen);
-            _1845_i = (_1845_i) + (BigInteger.One);
+            s = Dafny.Sequence<Dafny.Rune>.Concat(s, _2024_gen);
+            _2018_i = (_2018_i) + (BigInteger.One);
           }
           s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("]"));
           isOwned = true;
-          isErased = _1846_allErased;
+          isErased = _2019_allErased;
         }
       } else if (_source19.is_SetValue) {
-        Dafny.ISequence<DAST._IExpression> _1852___mcc_h23 = _source19.dtor_elements;
-        Dafny.ISequence<DAST._IExpression> _1853_exprs = _1852___mcc_h23;
+        Dafny.ISequence<DAST._IExpression> _2025___mcc_h23 = _source19.dtor_elements;
+        Dafny.ISequence<DAST._IExpression> _2026_exprs = _2025___mcc_h23;
         {
-          Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>> _1854_generatedValues;
-          _1854_generatedValues = Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.FromElements();
+          Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>> _2027_generatedValues;
+          _2027_generatedValues = Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.FromElements();
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
-          BigInteger _1855_i;
-          _1855_i = BigInteger.Zero;
-          bool _1856_allErased;
-          _1856_allErased = true;
-          while ((_1855_i) < (new BigInteger((_1853_exprs).Count))) {
-            Dafny.ISequence<Dafny.Rune> _1857_recursiveGen;
-            bool _1858___v60;
-            bool _1859_isErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1860_recIdents;
-            Dafny.ISequence<Dafny.Rune> _out1240;
-            bool _out1241;
-            bool _out1242;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1243;
-            DCOMP.COMP.GenExpr((_1853_exprs).Select(_1855_i), @params, true, out _out1240, out _out1241, out _out1242, out _out1243);
-            _1857_recursiveGen = _out1240;
-            _1858___v60 = _out1241;
-            _1859_isErased = _out1242;
-            _1860_recIdents = _out1243;
-            _1856_allErased = (_1856_allErased) && (_1859_isErased);
-            _1854_generatedValues = Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.Concat(_1854_generatedValues, Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.FromElements(_System.Tuple2<Dafny.ISequence<Dafny.Rune>, bool>.create(_1857_recursiveGen, _1859_isErased)));
-            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _1860_recIdents);
-            _1855_i = (_1855_i) + (BigInteger.One);
+          BigInteger _2028_i;
+          _2028_i = BigInteger.Zero;
+          bool _2029_allErased;
+          _2029_allErased = true;
+          while ((_2028_i) < (new BigInteger((_2026_exprs).Count))) {
+            Dafny.ISequence<Dafny.Rune> _2030_recursiveGen;
+            bool _2031___v64;
+            bool _2032_isErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2033_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1367;
+            bool _out1368;
+            bool _out1369;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1370;
+            DCOMP.COMP.GenExpr((_2026_exprs).Select(_2028_i), selfIdent, @params, true, out _out1367, out _out1368, out _out1369, out _out1370);
+            _2030_recursiveGen = _out1367;
+            _2031___v64 = _out1368;
+            _2032_isErased = _out1369;
+            _2033_recIdents = _out1370;
+            _2029_allErased = (_2029_allErased) && (_2032_isErased);
+            _2027_generatedValues = Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.Concat(_2027_generatedValues, Dafny.Sequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, bool>>.FromElements(_System.Tuple2<Dafny.ISequence<Dafny.Rune>, bool>.create(_2030_recursiveGen, _2032_isErased)));
+            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _2033_recIdents);
+            _2028_i = (_2028_i) + (BigInteger.One);
           }
           s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("vec![");
-          _1855_i = BigInteger.Zero;
-          while ((_1855_i) < (new BigInteger((_1854_generatedValues).Count))) {
-            if ((_1855_i).Sign == 1) {
+          _2028_i = BigInteger.Zero;
+          while ((_2028_i) < (new BigInteger((_2027_generatedValues).Count))) {
+            if ((_2028_i).Sign == 1) {
               s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
             }
-            Dafny.ISequence<Dafny.Rune> _1861_gen;
-            _1861_gen = ((_1854_generatedValues).Select(_1855_i)).dtor__0;
-            if ((((_1854_generatedValues).Select(_1855_i)).dtor__1) && (!(_1856_allErased))) {
-              _1861_gen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _1861_gen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            Dafny.ISequence<Dafny.Rune> _2034_gen;
+            _2034_gen = ((_2027_generatedValues).Select(_2028_i)).dtor__0;
+            if ((((_2027_generatedValues).Select(_2028_i)).dtor__1) && (!(_2029_allErased))) {
+              _2034_gen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::unerase_owned("), _2034_gen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
             }
-            s = Dafny.Sequence<Dafny.Rune>.Concat(s, _1861_gen);
-            _1855_i = (_1855_i) + (BigInteger.One);
+            s = Dafny.Sequence<Dafny.Rune>.Concat(s, _2034_gen);
+            _2028_i = (_2028_i) + (BigInteger.One);
           }
           s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("].into_iter().collect::<std::collections::HashSet<_>>()"));
           isOwned = true;
@@ -12117,415 +13024,1505 @@ public partial class COMP {
         }
       } else if (_source19.is_This) {
         {
-          if (mustOwn) {
-            s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("self.clone()");
-            isOwned = true;
+          DAST._IOptional<Dafny.ISequence<Dafny.Rune>> _source69 = selfIdent;
+          if (_source69.is_Some) {
+            Dafny.ISequence<Dafny.Rune> _2035___mcc_h1039 = _source69.dtor_Some_a0;
+            Dafny.ISequence<Dafny.Rune> _2036_id = _2035___mcc_h1039;
+            {
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(_2036_id, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
+                isOwned = true;
+              } else {
+                if ((_2036_id).Equals(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("self"))) {
+                  s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("self");
+                } else {
+                  s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), _2036_id);
+                }
+                isOwned = false;
+              }
+              readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(_2036_id);
+              isErased = false;
+            }
           } else {
-            s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("self");
-            isOwned = false;
+            {
+              s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("panic!(\"this outside of a method\")");
+              isOwned = true;
+              readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
+              isErased = true;
+            }
           }
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("self"));
-          isErased = false;
         }
       } else if (_source19.is_Ite) {
-        DAST._IExpression _1862___mcc_h24 = _source19.dtor_cond;
-        DAST._IExpression _1863___mcc_h25 = _source19.dtor_thn;
-        DAST._IExpression _1864___mcc_h26 = _source19.dtor_els;
-        DAST._IExpression _1865_f = _1864___mcc_h26;
-        DAST._IExpression _1866_t = _1863___mcc_h25;
-        DAST._IExpression _1867_cond = _1862___mcc_h24;
+        DAST._IExpression _2037___mcc_h24 = _source19.dtor_cond;
+        DAST._IExpression _2038___mcc_h25 = _source19.dtor_thn;
+        DAST._IExpression _2039___mcc_h26 = _source19.dtor_els;
+        DAST._IExpression _2040_f = _2039___mcc_h26;
+        DAST._IExpression _2041_t = _2038___mcc_h25;
+        DAST._IExpression _2042_cond = _2037___mcc_h24;
         {
-          Dafny.ISequence<Dafny.Rune> _1868_condString;
-          bool _1869___v61;
-          bool _1870_condErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1871_recIdentsCond;
-          Dafny.ISequence<Dafny.Rune> _out1244;
-          bool _out1245;
-          bool _out1246;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1247;
-          DCOMP.COMP.GenExpr(_1867_cond, @params, true, out _out1244, out _out1245, out _out1246, out _out1247);
-          _1868_condString = _out1244;
-          _1869___v61 = _out1245;
-          _1870_condErased = _out1246;
-          _1871_recIdentsCond = _out1247;
-          if (!(_1870_condErased)) {
-            _1868_condString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _1868_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          Dafny.ISequence<Dafny.Rune> _2043_condString;
+          bool _2044___v65;
+          bool _2045_condErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2046_recIdentsCond;
+          Dafny.ISequence<Dafny.Rune> _out1371;
+          bool _out1372;
+          bool _out1373;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1374;
+          DCOMP.COMP.GenExpr(_2042_cond, selfIdent, @params, true, out _out1371, out _out1372, out _out1373, out _out1374);
+          _2043_condString = _out1371;
+          _2044___v65 = _out1372;
+          _2045_condErased = _out1373;
+          _2046_recIdentsCond = _out1374;
+          if (!(_2045_condErased)) {
+            _2043_condString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _2043_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          Dafny.ISequence<Dafny.Rune> _1872___v62;
-          bool _1873_tHasToBeOwned;
-          bool _1874___v63;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1875___v64;
-          Dafny.ISequence<Dafny.Rune> _out1248;
-          bool _out1249;
-          bool _out1250;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1251;
-          DCOMP.COMP.GenExpr(_1866_t, @params, mustOwn, out _out1248, out _out1249, out _out1250, out _out1251);
-          _1872___v62 = _out1248;
-          _1873_tHasToBeOwned = _out1249;
-          _1874___v63 = _out1250;
-          _1875___v64 = _out1251;
-          Dafny.ISequence<Dafny.Rune> _1876_fString;
-          bool _1877_fOwned;
-          bool _1878_fErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1879_recIdentsF;
-          Dafny.ISequence<Dafny.Rune> _out1252;
-          bool _out1253;
-          bool _out1254;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1255;
-          DCOMP.COMP.GenExpr(_1865_f, @params, _1873_tHasToBeOwned, out _out1252, out _out1253, out _out1254, out _out1255);
-          _1876_fString = _out1252;
-          _1877_fOwned = _out1253;
-          _1878_fErased = _out1254;
-          _1879_recIdentsF = _out1255;
-          Dafny.ISequence<Dafny.Rune> _1880_tString;
-          bool _1881___v65;
-          bool _1882_tErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1883_recIdentsT;
-          Dafny.ISequence<Dafny.Rune> _out1256;
-          bool _out1257;
-          bool _out1258;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1259;
-          DCOMP.COMP.GenExpr(_1866_t, @params, _1877_fOwned, out _out1256, out _out1257, out _out1258, out _out1259);
-          _1880_tString = _out1256;
-          _1881___v65 = _out1257;
-          _1882_tErased = _out1258;
-          _1883_recIdentsT = _out1259;
-          if ((!(_1878_fErased)) || (!(_1882_tErased))) {
-            if (_1878_fErased) {
-              _1876_fString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _1876_fString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-            }
-            if (_1882_tErased) {
-              _1880_tString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _1880_tString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          Dafny.ISequence<Dafny.Rune> _2047___v66;
+          bool _2048_tHasToBeOwned;
+          bool _2049___v67;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2050___v68;
+          Dafny.ISequence<Dafny.Rune> _out1375;
+          bool _out1376;
+          bool _out1377;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1378;
+          DCOMP.COMP.GenExpr(_2041_t, selfIdent, @params, mustOwn, out _out1375, out _out1376, out _out1377, out _out1378);
+          _2047___v66 = _out1375;
+          _2048_tHasToBeOwned = _out1376;
+          _2049___v67 = _out1377;
+          _2050___v68 = _out1378;
+          Dafny.ISequence<Dafny.Rune> _2051_fString;
+          bool _2052_fOwned;
+          bool _2053_fErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2054_recIdentsF;
+          Dafny.ISequence<Dafny.Rune> _out1379;
+          bool _out1380;
+          bool _out1381;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1382;
+          DCOMP.COMP.GenExpr(_2040_f, selfIdent, @params, _2048_tHasToBeOwned, out _out1379, out _out1380, out _out1381, out _out1382);
+          _2051_fString = _out1379;
+          _2052_fOwned = _out1380;
+          _2053_fErased = _out1381;
+          _2054_recIdentsF = _out1382;
+          Dafny.ISequence<Dafny.Rune> _2055_tString;
+          bool _2056___v69;
+          bool _2057_tErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2058_recIdentsT;
+          Dafny.ISequence<Dafny.Rune> _out1383;
+          bool _out1384;
+          bool _out1385;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1386;
+          DCOMP.COMP.GenExpr(_2041_t, selfIdent, @params, _2052_fOwned, out _out1383, out _out1384, out _out1385, out _out1386);
+          _2055_tString = _out1383;
+          _2056___v69 = _out1384;
+          _2057_tErased = _out1385;
+          _2058_recIdentsT = _out1386;
+          if ((!(_2053_fErased)) || (!(_2057_tErased))) {
+            if (_2053_fErased) {
+              _2051_fString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _2051_fString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if (_2057_tErased) {
+              _2055_tString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _2055_tString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
             }
           }
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(if "), _1868_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _1880_tString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n} else {\n")), _1876_fString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n})"));
-          isOwned = _1877_fOwned;
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_1871_recIdentsCond, _1883_recIdentsT), _1879_recIdentsF);
-          isErased = (_1878_fErased) || (_1882_tErased);
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(if "), _2043_condString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _2055_tString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n} else {\n")), _2051_fString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n})"));
+          isOwned = _2052_fOwned;
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_2046_recIdentsCond, _2058_recIdentsT), _2054_recIdentsF);
+          isErased = (_2053_fErased) || (_2057_tErased);
         }
       } else if (_source19.is_UnOp) {
-        DAST._IUnaryOp _1884___mcc_h27 = _source19.dtor_unOp;
-        DAST._IExpression _1885___mcc_h28 = _source19.dtor_expr;
-        DAST._IUnaryOp _source67 = _1884___mcc_h27;
-        if (_source67.is_Not) {
-          DAST._IExpression _1886_e = _1885___mcc_h28;
+        DAST._IUnaryOp _2059___mcc_h27 = _source19.dtor_unOp;
+        DAST._IExpression _2060___mcc_h28 = _source19.dtor_expr;
+        DAST._IUnaryOp _source70 = _2059___mcc_h27;
+        if (_source70.is_Not) {
+          DAST._IExpression _2061_e = _2060___mcc_h28;
           {
-            Dafny.ISequence<Dafny.Rune> _1887_recursiveGen;
-            bool _1888___v66;
-            bool _1889_recErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1890_recIdents;
-            Dafny.ISequence<Dafny.Rune> _out1260;
-            bool _out1261;
-            bool _out1262;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1263;
-            DCOMP.COMP.GenExpr(_1886_e, @params, true, out _out1260, out _out1261, out _out1262, out _out1263);
-            _1887_recursiveGen = _out1260;
-            _1888___v66 = _out1261;
-            _1889_recErased = _out1262;
-            _1890_recIdents = _out1263;
-            if (!(_1889_recErased)) {
-              _1887_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _1887_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-            }
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("!("), _1887_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            Dafny.ISequence<Dafny.Rune> _2062_recursiveGen;
+            bool _2063___v70;
+            bool _2064_recErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2065_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1387;
+            bool _out1388;
+            bool _out1389;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1390;
+            DCOMP.COMP.GenExpr(_2061_e, selfIdent, @params, true, out _out1387, out _out1388, out _out1389, out _out1390);
+            _2062_recursiveGen = _out1387;
+            _2063___v70 = _out1388;
+            _2064_recErased = _out1389;
+            _2065_recIdents = _out1390;
+            if (!(_2064_recErased)) {
+              _2062_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _2062_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("!("), _2062_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
             isOwned = true;
-            readIdents = _1890_recIdents;
+            readIdents = _2065_recIdents;
             isErased = true;
           }
-        } else if (_source67.is_BitwiseNot) {
-          DAST._IExpression _1891_e = _1885___mcc_h28;
+        } else if (_source70.is_BitwiseNot) {
+          DAST._IExpression _2066_e = _2060___mcc_h28;
           {
-            Dafny.ISequence<Dafny.Rune> _1892_recursiveGen;
-            bool _1893___v67;
-            bool _1894_recErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1895_recIdents;
-            Dafny.ISequence<Dafny.Rune> _out1264;
-            bool _out1265;
-            bool _out1266;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1267;
-            DCOMP.COMP.GenExpr(_1891_e, @params, true, out _out1264, out _out1265, out _out1266, out _out1267);
-            _1892_recursiveGen = _out1264;
-            _1893___v67 = _out1265;
-            _1894_recErased = _out1266;
-            _1895_recIdents = _out1267;
-            if (!(_1894_recErased)) {
-              _1892_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _1892_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-            }
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("~("), _1892_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            Dafny.ISequence<Dafny.Rune> _2067_recursiveGen;
+            bool _2068___v71;
+            bool _2069_recErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2070_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1391;
+            bool _out1392;
+            bool _out1393;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1394;
+            DCOMP.COMP.GenExpr(_2066_e, selfIdent, @params, true, out _out1391, out _out1392, out _out1393, out _out1394);
+            _2067_recursiveGen = _out1391;
+            _2068___v71 = _out1392;
+            _2069_recErased = _out1393;
+            _2070_recIdents = _out1394;
+            if (!(_2069_recErased)) {
+              _2067_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _2067_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("~("), _2067_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
             isOwned = true;
-            readIdents = _1895_recIdents;
+            readIdents = _2070_recIdents;
             isErased = true;
           }
         } else {
-          DAST._IExpression _1896_e = _1885___mcc_h28;
+          DAST._IExpression _2071_e = _2060___mcc_h28;
           {
-            Dafny.ISequence<Dafny.Rune> _1897_recursiveGen;
-            bool _1898_recOwned;
-            bool _1899_recErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1900_recIdents;
-            Dafny.ISequence<Dafny.Rune> _out1268;
-            bool _out1269;
-            bool _out1270;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1271;
-            DCOMP.COMP.GenExpr(_1896_e, @params, false, out _out1268, out _out1269, out _out1270, out _out1271);
-            _1897_recursiveGen = _out1268;
-            _1898_recOwned = _out1269;
-            _1899_recErased = _out1270;
-            _1900_recIdents = _out1271;
-            if (!(_1899_recErased)) {
-              Dafny.ISequence<Dafny.Rune> _1901_eraseFn;
-              _1901_eraseFn = ((_1898_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-              _1897_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _1901_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1897_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-            }
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigInt::from(("), _1897_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").len())"));
+            Dafny.ISequence<Dafny.Rune> _2072_recursiveGen;
+            bool _2073_recOwned;
+            bool _2074_recErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2075_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1395;
+            bool _out1396;
+            bool _out1397;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1398;
+            DCOMP.COMP.GenExpr(_2071_e, selfIdent, @params, false, out _out1395, out _out1396, out _out1397, out _out1398);
+            _2072_recursiveGen = _out1395;
+            _2073_recOwned = _out1396;
+            _2074_recErased = _out1397;
+            _2075_recIdents = _out1398;
+            if (!(_2074_recErased)) {
+              Dafny.ISequence<Dafny.Rune> _2076_eraseFn;
+              _2076_eraseFn = ((_2073_recOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2072_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2076_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2072_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigInt::from(("), _2072_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").len())"));
             isOwned = true;
-            readIdents = _1900_recIdents;
+            readIdents = _2075_recIdents;
             isErased = true;
           }
         }
       } else if (_source19.is_BinOp) {
-        Dafny.ISequence<Dafny.Rune> _1902___mcc_h29 = _source19.dtor_op;
-        DAST._IExpression _1903___mcc_h30 = _source19.dtor_left;
-        DAST._IExpression _1904___mcc_h31 = _source19.dtor_right;
-        DAST._IExpression _1905_r = _1904___mcc_h31;
-        DAST._IExpression _1906_l = _1903___mcc_h30;
-        Dafny.ISequence<Dafny.Rune> _1907_op = _1902___mcc_h29;
+        Dafny.ISequence<Dafny.Rune> _2077___mcc_h29 = _source19.dtor_op;
+        DAST._IExpression _2078___mcc_h30 = _source19.dtor_left;
+        DAST._IExpression _2079___mcc_h31 = _source19.dtor_right;
+        DAST._IExpression _2080_r = _2079___mcc_h31;
+        DAST._IExpression _2081_l = _2078___mcc_h30;
+        Dafny.ISequence<Dafny.Rune> _2082_op = _2077___mcc_h29;
         {
-          Dafny.ISequence<Dafny.Rune> _1908_left;
-          bool _1909___v68;
-          bool _1910_leftErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1911_recIdentsL;
-          Dafny.ISequence<Dafny.Rune> _out1272;
-          bool _out1273;
-          bool _out1274;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1275;
-          DCOMP.COMP.GenExpr(_1906_l, @params, true, out _out1272, out _out1273, out _out1274, out _out1275);
-          _1908_left = _out1272;
-          _1909___v68 = _out1273;
-          _1910_leftErased = _out1274;
-          _1911_recIdentsL = _out1275;
-          Dafny.ISequence<Dafny.Rune> _1912_right;
-          bool _1913___v69;
-          bool _1914_rightErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1915_recIdentsR;
-          Dafny.ISequence<Dafny.Rune> _out1276;
-          bool _out1277;
-          bool _out1278;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1279;
-          DCOMP.COMP.GenExpr(_1905_r, @params, true, out _out1276, out _out1277, out _out1278, out _out1279);
-          _1912_right = _out1276;
-          _1913___v69 = _out1277;
-          _1914_rightErased = _out1278;
-          _1915_recIdentsR = _out1279;
-          if (!(_1910_leftErased)) {
-            _1908_left = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _1908_left), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          Dafny.ISequence<Dafny.Rune> _2083_left;
+          bool _2084___v72;
+          bool _2085_leftErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2086_recIdentsL;
+          Dafny.ISequence<Dafny.Rune> _out1399;
+          bool _out1400;
+          bool _out1401;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1402;
+          DCOMP.COMP.GenExpr(_2081_l, selfIdent, @params, true, out _out1399, out _out1400, out _out1401, out _out1402);
+          _2083_left = _out1399;
+          _2084___v72 = _out1400;
+          _2085_leftErased = _out1401;
+          _2086_recIdentsL = _out1402;
+          Dafny.ISequence<Dafny.Rune> _2087_right;
+          bool _2088___v73;
+          bool _2089_rightErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2090_recIdentsR;
+          Dafny.ISequence<Dafny.Rune> _out1403;
+          bool _out1404;
+          bool _out1405;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1406;
+          DCOMP.COMP.GenExpr(_2080_r, selfIdent, @params, true, out _out1403, out _out1404, out _out1405, out _out1406);
+          _2087_right = _out1403;
+          _2088___v73 = _out1404;
+          _2089_rightErased = _out1405;
+          _2090_recIdentsR = _out1406;
+          if (!(_2085_leftErased)) {
+            _2083_left = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _2083_left), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          if (!(_1914_rightErased)) {
-            _1912_right = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _1912_right), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          if (!(_2089_rightErased)) {
+            _2087_right = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _2087_right), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          if ((_1907_op).Equals(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/"))) {
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::euclidian_division("), _1908_left), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", ")), _1912_right), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-          } else if ((_1907_op).Equals(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("%"))) {
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::euclidian_modulo("), _1908_left), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", ")), _1912_right), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          if ((_2082_op).Equals(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("/"))) {
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::euclidian_division("), _2083_left), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", ")), _2087_right), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          } else if ((_2082_op).Equals(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("%"))) {
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::euclidian_modulo("), _2083_left), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", ")), _2087_right), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           } else {
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1908_left), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ")), _1907_op), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ")), _1912_right), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2083_left), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ")), _2082_op), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" ")), _2087_right), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
           isOwned = true;
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_1911_recIdentsL, _1915_recIdentsR);
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_2086_recIdentsL, _2090_recIdentsR);
           isErased = true;
         }
       } else if (_source19.is_ArrayLen) {
-        DAST._IExpression _1916___mcc_h32 = _source19.dtor_expr;
-        DAST._IExpression _1917_expr = _1916___mcc_h32;
+        DAST._IExpression _2091___mcc_h32 = _source19.dtor_expr;
+        DAST._IExpression _2092_expr = _2091___mcc_h32;
         {
-          Dafny.ISequence<Dafny.Rune> _1918_recursiveGen;
-          bool _1919___v70;
-          bool _1920_recErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1921_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out1280;
-          bool _out1281;
-          bool _out1282;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1283;
-          DCOMP.COMP.GenExpr(_1917_expr, @params, true, out _out1280, out _out1281, out _out1282, out _out1283);
-          _1918_recursiveGen = _out1280;
-          _1919___v70 = _out1281;
-          _1920_recErased = _out1282;
-          _1921_recIdents = _out1283;
-          if (!(_1920_recErased)) {
-            _1918_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _1918_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          Dafny.ISequence<Dafny.Rune> _2093_recursiveGen;
+          bool _2094___v74;
+          bool _2095_recErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2096_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out1407;
+          bool _out1408;
+          bool _out1409;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1410;
+          DCOMP.COMP.GenExpr(_2092_expr, selfIdent, @params, true, out _out1407, out _out1408, out _out1409, out _out1410);
+          _2093_recursiveGen = _out1407;
+          _2094___v74 = _out1408;
+          _2095_recErased = _out1409;
+          _2096_recIdents = _out1410;
+          if (!(_2095_recErased)) {
+            _2093_recursiveGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _2093_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigInt::from(("), _1918_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").borrow().len())"));
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::BigInt::from(("), _2093_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").borrow().len())"));
           isOwned = true;
-          readIdents = _1921_recIdents;
+          readIdents = _2096_recIdents;
           isErased = true;
         }
       } else if (_source19.is_Select) {
-        DAST._IExpression _1922___mcc_h33 = _source19.dtor_expr;
-        Dafny.ISequence<Dafny.Rune> _1923___mcc_h34 = _source19.dtor_field;
-        bool _1924___mcc_h35 = _source19.dtor_isConstant;
-        bool _1925___mcc_h36 = _source19.dtor_onDatatype;
-        bool _1926_isDatatype = _1925___mcc_h36;
-        bool _1927_isConstant = _1924___mcc_h35;
-        Dafny.ISequence<Dafny.Rune> _1928_field = _1923___mcc_h34;
-        DAST._IExpression _1929_on = _1922___mcc_h33;
-        {
-          Dafny.ISequence<Dafny.Rune> _1930_onString;
-          bool _1931_onOwned;
-          bool _1932_onErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1933_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out1284;
-          bool _out1285;
-          bool _out1286;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1287;
-          DCOMP.COMP.GenExpr(_1929_on, @params, false, out _out1284, out _out1285, out _out1286, out _out1287);
-          _1930_onString = _out1284;
-          _1931_onOwned = _out1285;
-          _1932_onErased = _out1286;
-          _1933_recIdents = _out1287;
-          if (!(_1932_onErased)) {
-            Dafny.ISequence<Dafny.Rune> _1934_eraseFn;
-            _1934_eraseFn = ((_1931_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-            _1930_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _1934_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1930_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
-          }
-          if ((_1926_isDatatype) || (_1927_isConstant)) {
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1930_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _1928_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
-            if (_1927_isConstant) {
-              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+        DAST._IExpression _2097___mcc_h33 = _source19.dtor_expr;
+        Dafny.ISequence<Dafny.Rune> _2098___mcc_h34 = _source19.dtor_field;
+        bool _2099___mcc_h35 = _source19.dtor_isConstant;
+        bool _2100___mcc_h36 = _source19.dtor_onDatatype;
+        DAST._IExpression _source71 = _2097___mcc_h33;
+        if (_source71.is_Literal) {
+          DAST._ILiteral _2101___mcc_h37 = _source71.dtor_Literal_a0;
+          bool _2102_isDatatype = _2100___mcc_h36;
+          bool _2103_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2104_field = _2098___mcc_h34;
+          DAST._IExpression _2105_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2106_onString;
+            bool _2107_onOwned;
+            bool _2108_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2109_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1411;
+            bool _out1412;
+            bool _out1413;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1414;
+            DCOMP.COMP.GenExpr(_2105_on, selfIdent, @params, false, out _out1411, out _out1412, out _out1413, out _out1414);
+            _2106_onString = _out1411;
+            _2107_onOwned = _out1412;
+            _2108_onErased = _out1413;
+            _2109_recIdents = _out1414;
+            if (!(_2108_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2110_eraseFn;
+              _2110_eraseFn = ((_2107_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2106_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2110_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2106_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
             }
-            if (mustOwn) {
+            if ((_2102_isDatatype) || (_2103_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2106_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2104_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2103_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2106_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2104_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
               s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
               isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2109_recIdents;
+          }
+        } else if (_source71.is_Ident) {
+          Dafny.ISequence<Dafny.Rune> _2111___mcc_h39 = _source71.dtor_Ident_a0;
+          bool _2112_isDatatype = _2100___mcc_h36;
+          bool _2113_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2114_field = _2098___mcc_h34;
+          DAST._IExpression _2115_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2116_onString;
+            bool _2117_onOwned;
+            bool _2118_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2119_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1415;
+            bool _out1416;
+            bool _out1417;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1418;
+            DCOMP.COMP.GenExpr(_2115_on, selfIdent, @params, false, out _out1415, out _out1416, out _out1417, out _out1418);
+            _2116_onString = _out1415;
+            _2117_onOwned = _out1416;
+            _2118_onErased = _out1417;
+            _2119_recIdents = _out1418;
+            if (!(_2118_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2120_eraseFn;
+              _2120_eraseFn = ((_2117_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2116_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2120_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2116_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2112_isDatatype) || (_2113_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2116_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2114_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2113_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
             } else {
-              isOwned = false;
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2116_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2114_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
             }
-          } else {
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _1930_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _1928_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+            isErased = false;
+            readIdents = _2119_recIdents;
+          }
+        } else if (_source71.is_Companion) {
+          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2121___mcc_h41 = _source71.dtor_Companion_a0;
+          bool _2122_isDatatype = _2100___mcc_h36;
+          bool _2123_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2124_field = _2098___mcc_h34;
+          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2125_c = _2121___mcc_h41;
+          {
+            Dafny.ISequence<Dafny.Rune> _2126_onString;
+            bool _2127_onOwned;
+            bool _2128_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2129_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1419;
+            bool _out1420;
+            bool _out1421;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1422;
+            DCOMP.COMP.GenExpr(DAST.Expression.create_Companion(_2125_c), selfIdent, @params, false, out _out1419, out _out1420, out _out1421, out _out1422);
+            _2126_onString = _out1419;
+            _2127_onOwned = _out1420;
+            _2128_onErased = _out1421;
+            _2129_recIdents = _out1422;
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_2126_onString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::r#")), _2124_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
             isOwned = true;
+            isErased = false;
+            readIdents = _2129_recIdents;
+          }
+        } else if (_source71.is_Tuple) {
+          Dafny.ISequence<DAST._IExpression> _2130___mcc_h43 = _source71.dtor_Tuple_a0;
+          bool _2131_isDatatype = _2100___mcc_h36;
+          bool _2132_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2133_field = _2098___mcc_h34;
+          DAST._IExpression _2134_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2135_onString;
+            bool _2136_onOwned;
+            bool _2137_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2138_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1423;
+            bool _out1424;
+            bool _out1425;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1426;
+            DCOMP.COMP.GenExpr(_2134_on, selfIdent, @params, false, out _out1423, out _out1424, out _out1425, out _out1426);
+            _2135_onString = _out1423;
+            _2136_onOwned = _out1424;
+            _2137_onErased = _out1425;
+            _2138_recIdents = _out1426;
+            if (!(_2137_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2139_eraseFn;
+              _2139_eraseFn = ((_2136_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2135_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2139_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2135_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2131_isDatatype) || (_2132_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2135_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2133_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2132_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2135_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2133_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2138_recIdents;
+          }
+        } else if (_source71.is_New) {
+          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2140___mcc_h45 = _source71.dtor_path;
+          Dafny.ISequence<DAST._IExpression> _2141___mcc_h46 = _source71.dtor_args;
+          bool _2142_isDatatype = _2100___mcc_h36;
+          bool _2143_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2144_field = _2098___mcc_h34;
+          DAST._IExpression _2145_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2146_onString;
+            bool _2147_onOwned;
+            bool _2148_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2149_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1427;
+            bool _out1428;
+            bool _out1429;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1430;
+            DCOMP.COMP.GenExpr(_2145_on, selfIdent, @params, false, out _out1427, out _out1428, out _out1429, out _out1430);
+            _2146_onString = _out1427;
+            _2147_onOwned = _out1428;
+            _2148_onErased = _out1429;
+            _2149_recIdents = _out1430;
+            if (!(_2148_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2150_eraseFn;
+              _2150_eraseFn = ((_2147_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2146_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2150_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2146_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2142_isDatatype) || (_2143_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2146_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2144_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2143_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2146_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2144_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2149_recIdents;
+          }
+        } else if (_source71.is_NewArray) {
+          Dafny.ISequence<DAST._IExpression> _2151___mcc_h49 = _source71.dtor_dims;
+          bool _2152_isDatatype = _2100___mcc_h36;
+          bool _2153_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2154_field = _2098___mcc_h34;
+          DAST._IExpression _2155_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2156_onString;
+            bool _2157_onOwned;
+            bool _2158_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2159_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1431;
+            bool _out1432;
+            bool _out1433;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1434;
+            DCOMP.COMP.GenExpr(_2155_on, selfIdent, @params, false, out _out1431, out _out1432, out _out1433, out _out1434);
+            _2156_onString = _out1431;
+            _2157_onOwned = _out1432;
+            _2158_onErased = _out1433;
+            _2159_recIdents = _out1434;
+            if (!(_2158_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2160_eraseFn;
+              _2160_eraseFn = ((_2157_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2156_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2160_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2156_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2152_isDatatype) || (_2153_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2156_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2154_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2153_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2156_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2154_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2159_recIdents;
+          }
+        } else if (_source71.is_DatatypeValue) {
+          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2161___mcc_h51 = _source71.dtor_path;
+          Dafny.ISequence<Dafny.Rune> _2162___mcc_h52 = _source71.dtor_variant;
+          bool _2163___mcc_h53 = _source71.dtor_isCo;
+          Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, DAST._IExpression>> _2164___mcc_h54 = _source71.dtor_contents;
+          bool _2165_isDatatype = _2100___mcc_h36;
+          bool _2166_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2167_field = _2098___mcc_h34;
+          DAST._IExpression _2168_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2169_onString;
+            bool _2170_onOwned;
+            bool _2171_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2172_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1435;
+            bool _out1436;
+            bool _out1437;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1438;
+            DCOMP.COMP.GenExpr(_2168_on, selfIdent, @params, false, out _out1435, out _out1436, out _out1437, out _out1438);
+            _2169_onString = _out1435;
+            _2170_onOwned = _out1436;
+            _2171_onErased = _out1437;
+            _2172_recIdents = _out1438;
+            if (!(_2171_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2173_eraseFn;
+              _2173_eraseFn = ((_2170_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2169_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2173_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2169_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2165_isDatatype) || (_2166_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2169_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2167_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2166_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2169_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2167_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2172_recIdents;
+          }
+        } else if (_source71.is_Convert) {
+          DAST._IExpression _2174___mcc_h59 = _source71.dtor_value;
+          DAST._IType _2175___mcc_h60 = _source71.dtor_from;
+          DAST._IType _2176___mcc_h61 = _source71.dtor_typ;
+          bool _2177_isDatatype = _2100___mcc_h36;
+          bool _2178_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2179_field = _2098___mcc_h34;
+          DAST._IExpression _2180_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2181_onString;
+            bool _2182_onOwned;
+            bool _2183_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2184_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1439;
+            bool _out1440;
+            bool _out1441;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1442;
+            DCOMP.COMP.GenExpr(_2180_on, selfIdent, @params, false, out _out1439, out _out1440, out _out1441, out _out1442);
+            _2181_onString = _out1439;
+            _2182_onOwned = _out1440;
+            _2183_onErased = _out1441;
+            _2184_recIdents = _out1442;
+            if (!(_2183_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2185_eraseFn;
+              _2185_eraseFn = ((_2182_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2181_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2185_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2181_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2177_isDatatype) || (_2178_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2181_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2179_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2178_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2181_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2179_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2184_recIdents;
+          }
+        } else if (_source71.is_SeqValue) {
+          Dafny.ISequence<DAST._IExpression> _2186___mcc_h65 = _source71.dtor_elements;
+          bool _2187_isDatatype = _2100___mcc_h36;
+          bool _2188_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2189_field = _2098___mcc_h34;
+          DAST._IExpression _2190_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2191_onString;
+            bool _2192_onOwned;
+            bool _2193_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2194_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1443;
+            bool _out1444;
+            bool _out1445;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1446;
+            DCOMP.COMP.GenExpr(_2190_on, selfIdent, @params, false, out _out1443, out _out1444, out _out1445, out _out1446);
+            _2191_onString = _out1443;
+            _2192_onOwned = _out1444;
+            _2193_onErased = _out1445;
+            _2194_recIdents = _out1446;
+            if (!(_2193_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2195_eraseFn;
+              _2195_eraseFn = ((_2192_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2191_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2195_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2191_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2187_isDatatype) || (_2188_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2191_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2189_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2188_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2191_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2189_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2194_recIdents;
+          }
+        } else if (_source71.is_SetValue) {
+          Dafny.ISequence<DAST._IExpression> _2196___mcc_h67 = _source71.dtor_elements;
+          bool _2197_isDatatype = _2100___mcc_h36;
+          bool _2198_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2199_field = _2098___mcc_h34;
+          DAST._IExpression _2200_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2201_onString;
+            bool _2202_onOwned;
+            bool _2203_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2204_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1447;
+            bool _out1448;
+            bool _out1449;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1450;
+            DCOMP.COMP.GenExpr(_2200_on, selfIdent, @params, false, out _out1447, out _out1448, out _out1449, out _out1450);
+            _2201_onString = _out1447;
+            _2202_onOwned = _out1448;
+            _2203_onErased = _out1449;
+            _2204_recIdents = _out1450;
+            if (!(_2203_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2205_eraseFn;
+              _2205_eraseFn = ((_2202_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2201_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2205_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2201_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2197_isDatatype) || (_2198_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2201_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2199_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2198_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2201_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2199_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2204_recIdents;
+          }
+        } else if (_source71.is_This) {
+          bool _2206_isDatatype = _2100___mcc_h36;
+          bool _2207_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2208_field = _2098___mcc_h34;
+          DAST._IExpression _2209_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2210_onString;
+            bool _2211_onOwned;
+            bool _2212_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2213_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1451;
+            bool _out1452;
+            bool _out1453;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1454;
+            DCOMP.COMP.GenExpr(_2209_on, selfIdent, @params, false, out _out1451, out _out1452, out _out1453, out _out1454);
+            _2210_onString = _out1451;
+            _2211_onOwned = _out1452;
+            _2212_onErased = _out1453;
+            _2213_recIdents = _out1454;
+            if (!(_2212_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2214_eraseFn;
+              _2214_eraseFn = ((_2211_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2210_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2214_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2210_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2206_isDatatype) || (_2207_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2210_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2208_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2207_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2210_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2208_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2213_recIdents;
+          }
+        } else if (_source71.is_Ite) {
+          DAST._IExpression _2215___mcc_h69 = _source71.dtor_cond;
+          DAST._IExpression _2216___mcc_h70 = _source71.dtor_thn;
+          DAST._IExpression _2217___mcc_h71 = _source71.dtor_els;
+          bool _2218_isDatatype = _2100___mcc_h36;
+          bool _2219_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2220_field = _2098___mcc_h34;
+          DAST._IExpression _2221_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2222_onString;
+            bool _2223_onOwned;
+            bool _2224_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2225_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1455;
+            bool _out1456;
+            bool _out1457;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1458;
+            DCOMP.COMP.GenExpr(_2221_on, selfIdent, @params, false, out _out1455, out _out1456, out _out1457, out _out1458);
+            _2222_onString = _out1455;
+            _2223_onOwned = _out1456;
+            _2224_onErased = _out1457;
+            _2225_recIdents = _out1458;
+            if (!(_2224_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2226_eraseFn;
+              _2226_eraseFn = ((_2223_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2222_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2226_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2222_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2218_isDatatype) || (_2219_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2222_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2220_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2219_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2222_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2220_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2225_recIdents;
+          }
+        } else if (_source71.is_UnOp) {
+          DAST._IUnaryOp _2227___mcc_h75 = _source71.dtor_unOp;
+          DAST._IExpression _2228___mcc_h76 = _source71.dtor_expr;
+          bool _2229_isDatatype = _2100___mcc_h36;
+          bool _2230_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2231_field = _2098___mcc_h34;
+          DAST._IExpression _2232_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2233_onString;
+            bool _2234_onOwned;
+            bool _2235_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2236_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1459;
+            bool _out1460;
+            bool _out1461;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1462;
+            DCOMP.COMP.GenExpr(_2232_on, selfIdent, @params, false, out _out1459, out _out1460, out _out1461, out _out1462);
+            _2233_onString = _out1459;
+            _2234_onOwned = _out1460;
+            _2235_onErased = _out1461;
+            _2236_recIdents = _out1462;
+            if (!(_2235_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2237_eraseFn;
+              _2237_eraseFn = ((_2234_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2233_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2237_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2233_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2229_isDatatype) || (_2230_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2233_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2231_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2230_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2233_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2231_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2236_recIdents;
+          }
+        } else if (_source71.is_BinOp) {
+          Dafny.ISequence<Dafny.Rune> _2238___mcc_h79 = _source71.dtor_op;
+          DAST._IExpression _2239___mcc_h80 = _source71.dtor_left;
+          DAST._IExpression _2240___mcc_h81 = _source71.dtor_right;
+          bool _2241_isDatatype = _2100___mcc_h36;
+          bool _2242_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2243_field = _2098___mcc_h34;
+          DAST._IExpression _2244_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2245_onString;
+            bool _2246_onOwned;
+            bool _2247_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2248_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1463;
+            bool _out1464;
+            bool _out1465;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1466;
+            DCOMP.COMP.GenExpr(_2244_on, selfIdent, @params, false, out _out1463, out _out1464, out _out1465, out _out1466);
+            _2245_onString = _out1463;
+            _2246_onOwned = _out1464;
+            _2247_onErased = _out1465;
+            _2248_recIdents = _out1466;
+            if (!(_2247_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2249_eraseFn;
+              _2249_eraseFn = ((_2246_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2245_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2249_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2245_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2241_isDatatype) || (_2242_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2245_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2243_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2242_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2245_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2243_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2248_recIdents;
+          }
+        } else if (_source71.is_ArrayLen) {
+          DAST._IExpression _2250___mcc_h85 = _source71.dtor_expr;
+          bool _2251_isDatatype = _2100___mcc_h36;
+          bool _2252_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2253_field = _2098___mcc_h34;
+          DAST._IExpression _2254_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2255_onString;
+            bool _2256_onOwned;
+            bool _2257_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2258_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1467;
+            bool _out1468;
+            bool _out1469;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1470;
+            DCOMP.COMP.GenExpr(_2254_on, selfIdent, @params, false, out _out1467, out _out1468, out _out1469, out _out1470);
+            _2255_onString = _out1467;
+            _2256_onOwned = _out1468;
+            _2257_onErased = _out1469;
+            _2258_recIdents = _out1470;
+            if (!(_2257_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2259_eraseFn;
+              _2259_eraseFn = ((_2256_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2255_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2259_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2255_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2251_isDatatype) || (_2252_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2255_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2253_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2252_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2255_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2253_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2258_recIdents;
+          }
+        } else if (_source71.is_Select) {
+          DAST._IExpression _2260___mcc_h87 = _source71.dtor_expr;
+          Dafny.ISequence<Dafny.Rune> _2261___mcc_h88 = _source71.dtor_field;
+          bool _2262___mcc_h89 = _source71.dtor_isConstant;
+          bool _2263___mcc_h90 = _source71.dtor_onDatatype;
+          bool _2264_isDatatype = _2100___mcc_h36;
+          bool _2265_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2266_field = _2098___mcc_h34;
+          DAST._IExpression _2267_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2268_onString;
+            bool _2269_onOwned;
+            bool _2270_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2271_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1471;
+            bool _out1472;
+            bool _out1473;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1474;
+            DCOMP.COMP.GenExpr(_2267_on, selfIdent, @params, false, out _out1471, out _out1472, out _out1473, out _out1474);
+            _2268_onString = _out1471;
+            _2269_onOwned = _out1472;
+            _2270_onErased = _out1473;
+            _2271_recIdents = _out1474;
+            if (!(_2270_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2272_eraseFn;
+              _2272_eraseFn = ((_2269_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2268_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2272_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2268_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2264_isDatatype) || (_2265_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2268_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2266_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2265_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2268_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2266_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2271_recIdents;
+          }
+        } else if (_source71.is_SelectFn) {
+          DAST._IExpression _2273___mcc_h95 = _source71.dtor_expr;
+          Dafny.ISequence<Dafny.Rune> _2274___mcc_h96 = _source71.dtor_field;
+          bool _2275___mcc_h97 = _source71.dtor_onDatatype;
+          bool _2276___mcc_h98 = _source71.dtor_isStatic;
+          BigInteger _2277___mcc_h99 = _source71.dtor_arity;
+          bool _2278_isDatatype = _2100___mcc_h36;
+          bool _2279_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2280_field = _2098___mcc_h34;
+          DAST._IExpression _2281_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2282_onString;
+            bool _2283_onOwned;
+            bool _2284_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2285_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1475;
+            bool _out1476;
+            bool _out1477;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1478;
+            DCOMP.COMP.GenExpr(_2281_on, selfIdent, @params, false, out _out1475, out _out1476, out _out1477, out _out1478);
+            _2282_onString = _out1475;
+            _2283_onOwned = _out1476;
+            _2284_onErased = _out1477;
+            _2285_recIdents = _out1478;
+            if (!(_2284_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2286_eraseFn;
+              _2286_eraseFn = ((_2283_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2282_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2286_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2282_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2278_isDatatype) || (_2279_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2282_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2280_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2279_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2282_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2280_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2285_recIdents;
+          }
+        } else if (_source71.is_Index) {
+          DAST._IExpression _2287___mcc_h105 = _source71.dtor_expr;
+          DAST._IExpression _2288___mcc_h106 = _source71.dtor_idx;
+          bool _2289_isDatatype = _2100___mcc_h36;
+          bool _2290_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2291_field = _2098___mcc_h34;
+          DAST._IExpression _2292_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2293_onString;
+            bool _2294_onOwned;
+            bool _2295_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2296_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1479;
+            bool _out1480;
+            bool _out1481;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1482;
+            DCOMP.COMP.GenExpr(_2292_on, selfIdent, @params, false, out _out1479, out _out1480, out _out1481, out _out1482);
+            _2293_onString = _out1479;
+            _2294_onOwned = _out1480;
+            _2295_onErased = _out1481;
+            _2296_recIdents = _out1482;
+            if (!(_2295_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2297_eraseFn;
+              _2297_eraseFn = ((_2294_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2293_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2297_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2293_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2289_isDatatype) || (_2290_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2293_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2291_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2290_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2293_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2291_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2296_recIdents;
+          }
+        } else if (_source71.is_TupleSelect) {
+          DAST._IExpression _2298___mcc_h109 = _source71.dtor_expr;
+          BigInteger _2299___mcc_h110 = _source71.dtor_index;
+          bool _2300_isDatatype = _2100___mcc_h36;
+          bool _2301_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2302_field = _2098___mcc_h34;
+          DAST._IExpression _2303_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2304_onString;
+            bool _2305_onOwned;
+            bool _2306_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2307_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1483;
+            bool _out1484;
+            bool _out1485;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1486;
+            DCOMP.COMP.GenExpr(_2303_on, selfIdent, @params, false, out _out1483, out _out1484, out _out1485, out _out1486);
+            _2304_onString = _out1483;
+            _2305_onOwned = _out1484;
+            _2306_onErased = _out1485;
+            _2307_recIdents = _out1486;
+            if (!(_2306_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2308_eraseFn;
+              _2308_eraseFn = ((_2305_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2304_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2308_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2304_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2300_isDatatype) || (_2301_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2304_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2302_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2301_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2304_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2302_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2307_recIdents;
+          }
+        } else if (_source71.is_Call) {
+          DAST._IExpression _2309___mcc_h113 = _source71.dtor_on;
+          Dafny.ISequence<Dafny.Rune> _2310___mcc_h114 = _source71.dtor_name;
+          Dafny.ISequence<DAST._IType> _2311___mcc_h115 = _source71.dtor_typeArgs;
+          Dafny.ISequence<DAST._IExpression> _2312___mcc_h116 = _source71.dtor_args;
+          bool _2313_isDatatype = _2100___mcc_h36;
+          bool _2314_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2315_field = _2098___mcc_h34;
+          DAST._IExpression _2316_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2317_onString;
+            bool _2318_onOwned;
+            bool _2319_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2320_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1487;
+            bool _out1488;
+            bool _out1489;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1490;
+            DCOMP.COMP.GenExpr(_2316_on, selfIdent, @params, false, out _out1487, out _out1488, out _out1489, out _out1490);
+            _2317_onString = _out1487;
+            _2318_onOwned = _out1488;
+            _2319_onErased = _out1489;
+            _2320_recIdents = _out1490;
+            if (!(_2319_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2321_eraseFn;
+              _2321_eraseFn = ((_2318_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2317_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2321_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2317_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2313_isDatatype) || (_2314_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2317_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2315_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2314_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2317_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2315_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2320_recIdents;
+          }
+        } else if (_source71.is_Lambda) {
+          Dafny.ISequence<DAST._IFormal> _2322___mcc_h121 = _source71.dtor_params;
+          DAST._IType _2323___mcc_h122 = _source71.dtor_retType;
+          Dafny.ISequence<DAST._IStatement> _2324___mcc_h123 = _source71.dtor_body;
+          bool _2325_isDatatype = _2100___mcc_h36;
+          bool _2326_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2327_field = _2098___mcc_h34;
+          DAST._IExpression _2328_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2329_onString;
+            bool _2330_onOwned;
+            bool _2331_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2332_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1491;
+            bool _out1492;
+            bool _out1493;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1494;
+            DCOMP.COMP.GenExpr(_2328_on, selfIdent, @params, false, out _out1491, out _out1492, out _out1493, out _out1494);
+            _2329_onString = _out1491;
+            _2330_onOwned = _out1492;
+            _2331_onErased = _out1493;
+            _2332_recIdents = _out1494;
+            if (!(_2331_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2333_eraseFn;
+              _2333_eraseFn = ((_2330_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2329_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2333_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2329_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2325_isDatatype) || (_2326_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2329_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2327_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2326_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2329_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2327_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2332_recIdents;
+          }
+        } else if (_source71.is_IIFE) {
+          Dafny.ISequence<Dafny.Rune> _2334___mcc_h127 = _source71.dtor_name;
+          DAST._IType _2335___mcc_h128 = _source71.dtor_typ;
+          DAST._IExpression _2336___mcc_h129 = _source71.dtor_value;
+          DAST._IExpression _2337___mcc_h130 = _source71.dtor_iifeBody;
+          bool _2338_isDatatype = _2100___mcc_h36;
+          bool _2339_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2340_field = _2098___mcc_h34;
+          DAST._IExpression _2341_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2342_onString;
+            bool _2343_onOwned;
+            bool _2344_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2345_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1495;
+            bool _out1496;
+            bool _out1497;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1498;
+            DCOMP.COMP.GenExpr(_2341_on, selfIdent, @params, false, out _out1495, out _out1496, out _out1497, out _out1498);
+            _2342_onString = _out1495;
+            _2343_onOwned = _out1496;
+            _2344_onErased = _out1497;
+            _2345_recIdents = _out1498;
+            if (!(_2344_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2346_eraseFn;
+              _2346_eraseFn = ((_2343_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2342_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2346_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2342_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2338_isDatatype) || (_2339_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2342_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2340_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2339_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2342_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2340_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2345_recIdents;
+          }
+        } else if (_source71.is_Apply) {
+          DAST._IExpression _2347___mcc_h135 = _source71.dtor_expr;
+          Dafny.ISequence<DAST._IExpression> _2348___mcc_h136 = _source71.dtor_args;
+          bool _2349_isDatatype = _2100___mcc_h36;
+          bool _2350_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2351_field = _2098___mcc_h34;
+          DAST._IExpression _2352_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2353_onString;
+            bool _2354_onOwned;
+            bool _2355_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2356_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1499;
+            bool _out1500;
+            bool _out1501;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1502;
+            DCOMP.COMP.GenExpr(_2352_on, selfIdent, @params, false, out _out1499, out _out1500, out _out1501, out _out1502);
+            _2353_onString = _out1499;
+            _2354_onOwned = _out1500;
+            _2355_onErased = _out1501;
+            _2356_recIdents = _out1502;
+            if (!(_2355_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2357_eraseFn;
+              _2357_eraseFn = ((_2354_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2353_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2357_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2353_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2349_isDatatype) || (_2350_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2353_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2351_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2350_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2353_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2351_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2356_recIdents;
+          }
+        } else if (_source71.is_TypeTest) {
+          DAST._IExpression _2358___mcc_h139 = _source71.dtor_on;
+          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2359___mcc_h140 = _source71.dtor_dType;
+          Dafny.ISequence<Dafny.Rune> _2360___mcc_h141 = _source71.dtor_variant;
+          bool _2361_isDatatype = _2100___mcc_h36;
+          bool _2362_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2363_field = _2098___mcc_h34;
+          DAST._IExpression _2364_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2365_onString;
+            bool _2366_onOwned;
+            bool _2367_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2368_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1503;
+            bool _out1504;
+            bool _out1505;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1506;
+            DCOMP.COMP.GenExpr(_2364_on, selfIdent, @params, false, out _out1503, out _out1504, out _out1505, out _out1506);
+            _2365_onString = _out1503;
+            _2366_onOwned = _out1504;
+            _2367_onErased = _out1505;
+            _2368_recIdents = _out1506;
+            if (!(_2367_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2369_eraseFn;
+              _2369_eraseFn = ((_2366_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2365_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2369_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2365_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2361_isDatatype) || (_2362_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2365_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2363_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2362_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2365_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2363_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2368_recIdents;
+          }
+        } else {
+          DAST._IType _2370___mcc_h145 = _source71.dtor_typ;
+          bool _2371_isDatatype = _2100___mcc_h36;
+          bool _2372_isConstant = _2099___mcc_h35;
+          Dafny.ISequence<Dafny.Rune> _2373_field = _2098___mcc_h34;
+          DAST._IExpression _2374_on = _2097___mcc_h33;
+          {
+            Dafny.ISequence<Dafny.Rune> _2375_onString;
+            bool _2376_onOwned;
+            bool _2377_onErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2378_recIdents;
+            Dafny.ISequence<Dafny.Rune> _out1507;
+            bool _out1508;
+            bool _out1509;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1510;
+            DCOMP.COMP.GenExpr(_2374_on, selfIdent, @params, false, out _out1507, out _out1508, out _out1509, out _out1510);
+            _2375_onString = _out1507;
+            _2376_onOwned = _out1508;
+            _2377_onErased = _out1509;
+            _2378_recIdents = _out1510;
+            if (!(_2377_onErased)) {
+              Dafny.ISequence<Dafny.Rune> _2379_eraseFn;
+              _2379_eraseFn = ((_2376_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+              _2375_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2379_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2375_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+            }
+            if ((_2371_isDatatype) || (_2372_isConstant)) {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2375_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2373_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("()"));
+              if (_2372_isConstant) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
+              }
+              if (mustOwn) {
+                s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+                isOwned = true;
+              } else {
+                isOwned = false;
+              }
+            } else {
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::ops::Deref::deref(&(("), _2375_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".r#")), _2373_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".borrow()))"));
+              s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
+              isOwned = true;
+            }
+            isErased = false;
+            readIdents = _2378_recIdents;
           }
-          isErased = false;
-          readIdents = _1933_recIdents;
         }
       } else if (_source19.is_SelectFn) {
-        DAST._IExpression _1935___mcc_h37 = _source19.dtor_expr;
-        Dafny.ISequence<Dafny.Rune> _1936___mcc_h38 = _source19.dtor_field;
-        bool _1937___mcc_h39 = _source19.dtor_onDatatype;
-        bool _1938___mcc_h40 = _source19.dtor_isStatic;
-        BigInteger _1939___mcc_h41 = _source19.dtor_arity;
-        BigInteger _1940_arity = _1939___mcc_h41;
-        bool _1941_isStatic = _1938___mcc_h40;
-        bool _1942_isDatatype = _1937___mcc_h39;
-        Dafny.ISequence<Dafny.Rune> _1943_field = _1936___mcc_h38;
-        DAST._IExpression _1944_on = _1935___mcc_h37;
+        DAST._IExpression _2380___mcc_h147 = _source19.dtor_expr;
+        Dafny.ISequence<Dafny.Rune> _2381___mcc_h148 = _source19.dtor_field;
+        bool _2382___mcc_h149 = _source19.dtor_onDatatype;
+        bool _2383___mcc_h150 = _source19.dtor_isStatic;
+        BigInteger _2384___mcc_h151 = _source19.dtor_arity;
+        BigInteger _2385_arity = _2384___mcc_h151;
+        bool _2386_isStatic = _2383___mcc_h150;
+        bool _2387_isDatatype = _2382___mcc_h149;
+        Dafny.ISequence<Dafny.Rune> _2388_field = _2381___mcc_h148;
+        DAST._IExpression _2389_on = _2380___mcc_h147;
         {
-          Dafny.ISequence<Dafny.Rune> _1945_onString;
-          bool _1946_onOwned;
-          bool _1947___v71;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1948_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out1288;
-          bool _out1289;
-          bool _out1290;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1291;
-          DCOMP.COMP.GenExpr(_1944_on, @params, false, out _out1288, out _out1289, out _out1290, out _out1291);
-          _1945_onString = _out1288;
-          _1946_onOwned = _out1289;
-          _1947___v71 = _out1290;
-          _1948_recIdents = _out1291;
-          if (_1941_isStatic) {
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_1945_onString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::")), _1943_field);
+          Dafny.ISequence<Dafny.Rune> _2390_onString;
+          bool _2391_onOwned;
+          bool _2392___v75;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2393_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out1511;
+          bool _out1512;
+          bool _out1513;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1514;
+          DCOMP.COMP.GenExpr(_2389_on, selfIdent, @params, false, out _out1511, out _out1512, out _out1513, out _out1514);
+          _2390_onString = _out1511;
+          _2391_onOwned = _out1512;
+          _2392___v75 = _out1513;
+          _2393_recIdents = _out1514;
+          if (_2386_isStatic) {
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_2390_onString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::")), _2388_field);
           } else {
             s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("{\n");
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let callTarget = (")), _1945_onString), ((_1946_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()")))), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";\n"));
-            Dafny.ISequence<Dafny.Rune> _1949_args;
-            _1949_args = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-            BigInteger _1950_i;
-            _1950_i = BigInteger.Zero;
-            while ((_1950_i) < (_1940_arity)) {
-              if ((_1950_i).Sign == 1) {
-                _1949_args = Dafny.Sequence<Dafny.Rune>.Concat(_1949_args, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let callTarget = (")), _2390_onString), ((_2391_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()")))), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";\n"));
+            Dafny.ISequence<Dafny.Rune> _2394_args;
+            _2394_args = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+            BigInteger _2395_i;
+            _2395_i = BigInteger.Zero;
+            while ((_2395_i) < (_2385_arity)) {
+              if ((_2395_i).Sign == 1) {
+                _2394_args = Dafny.Sequence<Dafny.Rune>.Concat(_2394_args, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
               }
-              _1949_args = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_1949_args, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("arg")), DCOMP.__default.natToString(_1950_i));
-              _1950_i = (_1950_i) + (BigInteger.One);
+              _2394_args = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_2394_args, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("arg")), DCOMP.__default.natToString(_2395_i));
+              _2395_i = (_2395_i) + (BigInteger.One);
             }
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("move |")), _1949_args), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("| {\n"));
-            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("callTarget.")), _1943_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1949_args), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")\n"));
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("move |")), _2394_args), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("| {\n"));
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("callTarget.")), _2388_field), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2394_args), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")\n"));
             s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}\n"));
             s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("}"));
           }
           s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::FunctionWrapper("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           isOwned = true;
           isErased = true;
-          readIdents = _1948_recIdents;
+          readIdents = _2393_recIdents;
         }
       } else if (_source19.is_Index) {
-        DAST._IExpression _1951___mcc_h42 = _source19.dtor_expr;
-        DAST._IExpression _1952___mcc_h43 = _source19.dtor_idx;
-        DAST._IExpression _1953_idx = _1952___mcc_h43;
-        DAST._IExpression _1954_on = _1951___mcc_h42;
+        DAST._IExpression _2396___mcc_h152 = _source19.dtor_expr;
+        DAST._IExpression _2397___mcc_h153 = _source19.dtor_idx;
+        DAST._IExpression _2398_idx = _2397___mcc_h153;
+        DAST._IExpression _2399_on = _2396___mcc_h152;
         {
-          Dafny.ISequence<Dafny.Rune> _1955_onString;
-          bool _1956_onOwned;
-          bool _1957_onErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1958_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out1292;
-          bool _out1293;
-          bool _out1294;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1295;
-          DCOMP.COMP.GenExpr(_1954_on, @params, false, out _out1292, out _out1293, out _out1294, out _out1295);
-          _1955_onString = _out1292;
-          _1956_onOwned = _out1293;
-          _1957_onErased = _out1294;
-          _1958_recIdents = _out1295;
-          if (!(_1957_onErased)) {
-            Dafny.ISequence<Dafny.Rune> _1959_eraseFn;
-            _1959_eraseFn = ((_1956_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
-            _1955_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _1959_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1955_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          Dafny.ISequence<Dafny.Rune> _2400_onString;
+          bool _2401_onOwned;
+          bool _2402_onErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2403_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out1515;
+          bool _out1516;
+          bool _out1517;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1518;
+          DCOMP.COMP.GenExpr(_2399_on, selfIdent, @params, false, out _out1515, out _out1516, out _out1517, out _out1518);
+          _2400_onString = _out1515;
+          _2401_onOwned = _out1516;
+          _2402_onErased = _out1517;
+          _2403_recIdents = _out1518;
+          if (!(_2402_onErased)) {
+            Dafny.ISequence<Dafny.Rune> _2404_eraseFn;
+            _2404_eraseFn = ((_2401_onOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("erase")));
+            _2400_onString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::"), _2404_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2400_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          Dafny.ISequence<Dafny.Rune> _1960_idxString;
-          bool _1961___v72;
-          bool _1962_idxErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1963_recIdentsIdx;
-          Dafny.ISequence<Dafny.Rune> _out1296;
-          bool _out1297;
-          bool _out1298;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1299;
-          DCOMP.COMP.GenExpr(_1953_idx, @params, true, out _out1296, out _out1297, out _out1298, out _out1299);
-          _1960_idxString = _out1296;
-          _1961___v72 = _out1297;
-          _1962_idxErased = _out1298;
-          _1963_recIdentsIdx = _out1299;
-          if (!(_1962_idxErased)) {
-            _1960_idxString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _1960_idxString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          Dafny.ISequence<Dafny.Rune> _2405_idxString;
+          bool _2406___v76;
+          bool _2407_idxErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2408_recIdentsIdx;
+          Dafny.ISequence<Dafny.Rune> _out1519;
+          bool _out1520;
+          bool _out1521;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1522;
+          DCOMP.COMP.GenExpr(_2398_idx, selfIdent, @params, true, out _out1519, out _out1520, out _out1521, out _out1522);
+          _2405_idxString = _out1519;
+          _2406___v76 = _out1520;
+          _2407_idxErased = _out1521;
+          _2408_recIdentsIdx = _out1522;
+          if (!(_2407_idxErased)) {
+            _2405_idxString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyErasable::erase_owned("), _2405_idxString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1955_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("[<usize as ::dafny_runtime::NumCast>::from(")), _1960_idxString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap()]"));
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2400_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("[<usize as ::dafny_runtime::NumCast>::from(")), _2405_idxString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").unwrap()]"));
           if (mustOwn) {
             s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").clone()"));
             isOwned = true;
           } else {
+            s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(&"), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
             isOwned = false;
           }
           isErased = true;
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_1958_recIdents, _1963_recIdentsIdx);
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(_2403_recIdents, _2408_recIdentsIdx);
         }
       } else if (_source19.is_TupleSelect) {
-        DAST._IExpression _1964___mcc_h44 = _source19.dtor_expr;
-        BigInteger _1965___mcc_h45 = _source19.dtor_index;
-        BigInteger _1966_idx = _1965___mcc_h45;
-        DAST._IExpression _1967_on = _1964___mcc_h44;
+        DAST._IExpression _2409___mcc_h154 = _source19.dtor_expr;
+        BigInteger _2410___mcc_h155 = _source19.dtor_index;
+        BigInteger _2411_idx = _2410___mcc_h155;
+        DAST._IExpression _2412_on = _2409___mcc_h154;
         {
-          Dafny.ISequence<Dafny.Rune> _1968_onString;
-          bool _1969___v73;
-          bool _1970_tupErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1971_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out1300;
-          bool _out1301;
-          bool _out1302;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1303;
-          DCOMP.COMP.GenExpr(_1967_on, @params, false, out _out1300, out _out1301, out _out1302, out _out1303);
-          _1968_onString = _out1300;
-          _1969___v73 = _out1301;
-          _1970_tupErased = _out1302;
-          _1971_recIdents = _out1303;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1968_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").")), DCOMP.__default.natToString(_1966_idx));
+          Dafny.ISequence<Dafny.Rune> _2413_onString;
+          bool _2414___v77;
+          bool _2415_tupErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2416_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out1523;
+          bool _out1524;
+          bool _out1525;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1526;
+          DCOMP.COMP.GenExpr(_2412_on, selfIdent, @params, false, out _out1523, out _out1524, out _out1525, out _out1526);
+          _2413_onString = _out1523;
+          _2414___v77 = _out1524;
+          _2415_tupErased = _out1525;
+          _2416_recIdents = _out1526;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2413_onString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").")), DCOMP.__default.natToString(_2411_idx));
           if (mustOwn) {
             s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), s), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone()"));
             isOwned = true;
@@ -12533,450 +14530,450 @@ public partial class COMP {
             s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), s);
             isOwned = false;
           }
-          isErased = _1970_tupErased;
-          readIdents = _1971_recIdents;
+          isErased = _2415_tupErased;
+          readIdents = _2416_recIdents;
         }
       } else if (_source19.is_Call) {
-        DAST._IExpression _1972___mcc_h46 = _source19.dtor_on;
-        Dafny.ISequence<Dafny.Rune> _1973___mcc_h47 = _source19.dtor_name;
-        Dafny.ISequence<DAST._IType> _1974___mcc_h48 = _source19.dtor_typeArgs;
-        Dafny.ISequence<DAST._IExpression> _1975___mcc_h49 = _source19.dtor_args;
-        Dafny.ISequence<DAST._IExpression> _1976_args = _1975___mcc_h49;
-        Dafny.ISequence<DAST._IType> _1977_typeArgs = _1974___mcc_h48;
-        Dafny.ISequence<Dafny.Rune> _1978_name = _1973___mcc_h47;
-        DAST._IExpression _1979_on = _1972___mcc_h46;
+        DAST._IExpression _2417___mcc_h156 = _source19.dtor_on;
+        Dafny.ISequence<Dafny.Rune> _2418___mcc_h157 = _source19.dtor_name;
+        Dafny.ISequence<DAST._IType> _2419___mcc_h158 = _source19.dtor_typeArgs;
+        Dafny.ISequence<DAST._IExpression> _2420___mcc_h159 = _source19.dtor_args;
+        Dafny.ISequence<DAST._IExpression> _2421_args = _2420___mcc_h159;
+        Dafny.ISequence<DAST._IType> _2422_typeArgs = _2419___mcc_h158;
+        Dafny.ISequence<Dafny.Rune> _2423_name = _2418___mcc_h157;
+        DAST._IExpression _2424_on = _2417___mcc_h156;
         {
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
-          Dafny.ISequence<Dafny.Rune> _1980_typeArgString;
-          _1980_typeArgString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-          if ((new BigInteger((_1977_typeArgs).Count)) >= (BigInteger.One)) {
-            BigInteger _1981_typeI;
-            _1981_typeI = BigInteger.Zero;
-            _1980_typeArgString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::<");
-            while ((_1981_typeI) < (new BigInteger((_1977_typeArgs).Count))) {
-              if ((_1981_typeI).Sign == 1) {
-                _1980_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_1980_typeArgString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+          Dafny.ISequence<Dafny.Rune> _2425_typeArgString;
+          _2425_typeArgString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+          if ((new BigInteger((_2422_typeArgs).Count)) >= (BigInteger.One)) {
+            BigInteger _2426_typeI;
+            _2426_typeI = BigInteger.Zero;
+            _2425_typeArgString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::<");
+            while ((_2426_typeI) < (new BigInteger((_2422_typeArgs).Count))) {
+              if ((_2426_typeI).Sign == 1) {
+                _2425_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_2425_typeArgString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
               }
-              Dafny.ISequence<Dafny.Rune> _1982_typeString;
-              Dafny.ISequence<Dafny.Rune> _out1304;
-              _out1304 = DCOMP.COMP.GenType((_1977_typeArgs).Select(_1981_typeI), false, false);
-              _1982_typeString = _out1304;
-              _1980_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_1980_typeArgString, _1982_typeString);
-              _1981_typeI = (_1981_typeI) + (BigInteger.One);
-            }
-            _1980_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_1980_typeArgString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
+              Dafny.ISequence<Dafny.Rune> _2427_typeString;
+              Dafny.ISequence<Dafny.Rune> _out1527;
+              _out1527 = DCOMP.COMP.GenType((_2422_typeArgs).Select(_2426_typeI), false, false);
+              _2427_typeString = _out1527;
+              _2425_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_2425_typeArgString, _2427_typeString);
+              _2426_typeI = (_2426_typeI) + (BigInteger.One);
+            }
+            _2425_typeArgString = Dafny.Sequence<Dafny.Rune>.Concat(_2425_typeArgString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(">"));
           }
-          Dafny.ISequence<Dafny.Rune> _1983_argString;
-          _1983_argString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-          BigInteger _1984_i;
-          _1984_i = BigInteger.Zero;
-          while ((_1984_i) < (new BigInteger((_1976_args).Count))) {
-            if ((_1984_i).Sign == 1) {
-              _1983_argString = Dafny.Sequence<Dafny.Rune>.Concat(_1983_argString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
-            }
-            Dafny.ISequence<Dafny.Rune> _1985_argExpr;
-            bool _1986_isOwned;
-            bool _1987_argErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1988_argIdents;
-            Dafny.ISequence<Dafny.Rune> _out1305;
-            bool _out1306;
-            bool _out1307;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1308;
-            DCOMP.COMP.GenExpr((_1976_args).Select(_1984_i), @params, false, out _out1305, out _out1306, out _out1307, out _out1308);
-            _1985_argExpr = _out1305;
-            _1986_isOwned = _out1306;
-            _1987_argErased = _out1307;
-            _1988_argIdents = _out1308;
-            if (_1986_isOwned) {
-              _1985_argExpr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), _1985_argExpr);
-            }
-            _1983_argString = Dafny.Sequence<Dafny.Rune>.Concat(_1983_argString, _1985_argExpr);
-            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _1988_argIdents);
-            _1984_i = (_1984_i) + (BigInteger.One);
+          Dafny.ISequence<Dafny.Rune> _2428_argString;
+          _2428_argString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+          BigInteger _2429_i;
+          _2429_i = BigInteger.Zero;
+          while ((_2429_i) < (new BigInteger((_2421_args).Count))) {
+            if ((_2429_i).Sign == 1) {
+              _2428_argString = Dafny.Sequence<Dafny.Rune>.Concat(_2428_argString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+            }
+            Dafny.ISequence<Dafny.Rune> _2430_argExpr;
+            bool _2431_isOwned;
+            bool _2432_argErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2433_argIdents;
+            Dafny.ISequence<Dafny.Rune> _out1528;
+            bool _out1529;
+            bool _out1530;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1531;
+            DCOMP.COMP.GenExpr((_2421_args).Select(_2429_i), selfIdent, @params, false, out _out1528, out _out1529, out _out1530, out _out1531);
+            _2430_argExpr = _out1528;
+            _2431_isOwned = _out1529;
+            _2432_argErased = _out1530;
+            _2433_argIdents = _out1531;
+            if (_2431_isOwned) {
+              _2430_argExpr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), _2430_argExpr);
+            }
+            _2428_argString = Dafny.Sequence<Dafny.Rune>.Concat(_2428_argString, _2430_argExpr);
+            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _2433_argIdents);
+            _2429_i = (_2429_i) + (BigInteger.One);
           }
-          Dafny.ISequence<Dafny.Rune> _1989_enclosingString;
-          bool _1990___v74;
-          bool _1991___v75;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _1992_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out1309;
-          bool _out1310;
-          bool _out1311;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1312;
-          DCOMP.COMP.GenExpr(_1979_on, @params, false, out _out1309, out _out1310, out _out1311, out _out1312);
-          _1989_enclosingString = _out1309;
-          _1990___v74 = _out1310;
-          _1991___v75 = _out1311;
-          _1992_recIdents = _out1312;
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _1992_recIdents);
-          DAST._IExpression _source68 = _1979_on;
-          if (_source68.is_Literal) {
-            DAST._ILiteral _1993___mcc_h811 = _source68.dtor_Literal_a0;
+          Dafny.ISequence<Dafny.Rune> _2434_enclosingString;
+          bool _2435___v78;
+          bool _2436___v79;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2437_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out1532;
+          bool _out1533;
+          bool _out1534;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1535;
+          DCOMP.COMP.GenExpr(_2424_on, selfIdent, @params, false, out _out1532, out _out1533, out _out1534, out _out1535);
+          _2434_enclosingString = _out1532;
+          _2435___v78 = _out1533;
+          _2436___v79 = _out1534;
+          _2437_recIdents = _out1535;
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _2437_recIdents);
+          DAST._IExpression _source72 = _2424_on;
+          if (_source72.is_Literal) {
+            DAST._ILiteral _2438___mcc_h1040 = _source72.dtor_Literal_a0;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_Ident) {
-            Dafny.ISequence<Dafny.Rune> _1994___mcc_h813 = _source68.dtor_Ident_a0;
+          } else if (_source72.is_Ident) {
+            Dafny.ISequence<Dafny.Rune> _2439___mcc_h1042 = _source72.dtor_Ident_a0;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_Companion) {
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1995___mcc_h815 = _source68.dtor_Companion_a0;
+          } else if (_source72.is_Companion) {
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2440___mcc_h1044 = _source72.dtor_Companion_a0;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(_1989_enclosingString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::"));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(_2434_enclosingString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::"));
             }
-          } else if (_source68.is_Tuple) {
-            Dafny.ISequence<DAST._IExpression> _1996___mcc_h817 = _source68.dtor_Tuple_a0;
+          } else if (_source72.is_Tuple) {
+            Dafny.ISequence<DAST._IExpression> _2441___mcc_h1046 = _source72.dtor_Tuple_a0;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_New) {
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _1997___mcc_h819 = _source68.dtor_path;
-            Dafny.ISequence<DAST._IExpression> _1998___mcc_h820 = _source68.dtor_args;
+          } else if (_source72.is_New) {
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2442___mcc_h1048 = _source72.dtor_path;
+            Dafny.ISequence<DAST._IExpression> _2443___mcc_h1049 = _source72.dtor_args;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_NewArray) {
-            Dafny.ISequence<DAST._IExpression> _1999___mcc_h823 = _source68.dtor_dims;
+          } else if (_source72.is_NewArray) {
+            Dafny.ISequence<DAST._IExpression> _2444___mcc_h1052 = _source72.dtor_dims;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_DatatypeValue) {
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2000___mcc_h825 = _source68.dtor_path;
-            Dafny.ISequence<Dafny.Rune> _2001___mcc_h826 = _source68.dtor_variant;
-            bool _2002___mcc_h827 = _source68.dtor_isCo;
-            Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, DAST._IExpression>> _2003___mcc_h828 = _source68.dtor_contents;
+          } else if (_source72.is_DatatypeValue) {
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2445___mcc_h1054 = _source72.dtor_path;
+            Dafny.ISequence<Dafny.Rune> _2446___mcc_h1055 = _source72.dtor_variant;
+            bool _2447___mcc_h1056 = _source72.dtor_isCo;
+            Dafny.ISequence<_System._ITuple2<Dafny.ISequence<Dafny.Rune>, DAST._IExpression>> _2448___mcc_h1057 = _source72.dtor_contents;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_Convert) {
-            DAST._IExpression _2004___mcc_h833 = _source68.dtor_value;
-            DAST._IType _2005___mcc_h834 = _source68.dtor_from;
-            DAST._IType _2006___mcc_h835 = _source68.dtor_typ;
+          } else if (_source72.is_Convert) {
+            DAST._IExpression _2449___mcc_h1062 = _source72.dtor_value;
+            DAST._IType _2450___mcc_h1063 = _source72.dtor_from;
+            DAST._IType _2451___mcc_h1064 = _source72.dtor_typ;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_SeqValue) {
-            Dafny.ISequence<DAST._IExpression> _2007___mcc_h839 = _source68.dtor_elements;
+          } else if (_source72.is_SeqValue) {
+            Dafny.ISequence<DAST._IExpression> _2452___mcc_h1068 = _source72.dtor_elements;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_SetValue) {
-            Dafny.ISequence<DAST._IExpression> _2008___mcc_h841 = _source68.dtor_elements;
+          } else if (_source72.is_SetValue) {
+            Dafny.ISequence<DAST._IExpression> _2453___mcc_h1070 = _source72.dtor_elements;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_This) {
+          } else if (_source72.is_This) {
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_Ite) {
-            DAST._IExpression _2009___mcc_h843 = _source68.dtor_cond;
-            DAST._IExpression _2010___mcc_h844 = _source68.dtor_thn;
-            DAST._IExpression _2011___mcc_h845 = _source68.dtor_els;
+          } else if (_source72.is_Ite) {
+            DAST._IExpression _2454___mcc_h1072 = _source72.dtor_cond;
+            DAST._IExpression _2455___mcc_h1073 = _source72.dtor_thn;
+            DAST._IExpression _2456___mcc_h1074 = _source72.dtor_els;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_UnOp) {
-            DAST._IUnaryOp _2012___mcc_h849 = _source68.dtor_unOp;
-            DAST._IExpression _2013___mcc_h850 = _source68.dtor_expr;
+          } else if (_source72.is_UnOp) {
+            DAST._IUnaryOp _2457___mcc_h1078 = _source72.dtor_unOp;
+            DAST._IExpression _2458___mcc_h1079 = _source72.dtor_expr;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_BinOp) {
-            Dafny.ISequence<Dafny.Rune> _2014___mcc_h853 = _source68.dtor_op;
-            DAST._IExpression _2015___mcc_h854 = _source68.dtor_left;
-            DAST._IExpression _2016___mcc_h855 = _source68.dtor_right;
+          } else if (_source72.is_BinOp) {
+            Dafny.ISequence<Dafny.Rune> _2459___mcc_h1082 = _source72.dtor_op;
+            DAST._IExpression _2460___mcc_h1083 = _source72.dtor_left;
+            DAST._IExpression _2461___mcc_h1084 = _source72.dtor_right;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_ArrayLen) {
-            DAST._IExpression _2017___mcc_h859 = _source68.dtor_expr;
+          } else if (_source72.is_ArrayLen) {
+            DAST._IExpression _2462___mcc_h1088 = _source72.dtor_expr;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_Select) {
-            DAST._IExpression _2018___mcc_h861 = _source68.dtor_expr;
-            Dafny.ISequence<Dafny.Rune> _2019___mcc_h862 = _source68.dtor_field;
-            bool _2020___mcc_h863 = _source68.dtor_isConstant;
-            bool _2021___mcc_h864 = _source68.dtor_onDatatype;
+          } else if (_source72.is_Select) {
+            DAST._IExpression _2463___mcc_h1090 = _source72.dtor_expr;
+            Dafny.ISequence<Dafny.Rune> _2464___mcc_h1091 = _source72.dtor_field;
+            bool _2465___mcc_h1092 = _source72.dtor_isConstant;
+            bool _2466___mcc_h1093 = _source72.dtor_onDatatype;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
-            }
-          } else if (_source68.is_SelectFn) {
-            DAST._IExpression _2022___mcc_h869 = _source68.dtor_expr;
-            Dafny.ISequence<Dafny.Rune> _2023___mcc_h870 = _source68.dtor_field;
-            bool _2024___mcc_h871 = _source68.dtor_onDatatype;
-            bool _2025___mcc_h872 = _source68.dtor_isStatic;
-            BigInteger _2026___mcc_h873 = _source68.dtor_arity;
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+            }
+          } else if (_source72.is_SelectFn) {
+            DAST._IExpression _2467___mcc_h1098 = _source72.dtor_expr;
+            Dafny.ISequence<Dafny.Rune> _2468___mcc_h1099 = _source72.dtor_field;
+            bool _2469___mcc_h1100 = _source72.dtor_onDatatype;
+            bool _2470___mcc_h1101 = _source72.dtor_isStatic;
+            BigInteger _2471___mcc_h1102 = _source72.dtor_arity;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_Index) {
-            DAST._IExpression _2027___mcc_h879 = _source68.dtor_expr;
-            DAST._IExpression _2028___mcc_h880 = _source68.dtor_idx;
+          } else if (_source72.is_Index) {
+            DAST._IExpression _2472___mcc_h1108 = _source72.dtor_expr;
+            DAST._IExpression _2473___mcc_h1109 = _source72.dtor_idx;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_TupleSelect) {
-            DAST._IExpression _2029___mcc_h883 = _source68.dtor_expr;
-            BigInteger _2030___mcc_h884 = _source68.dtor_index;
+          } else if (_source72.is_TupleSelect) {
+            DAST._IExpression _2474___mcc_h1112 = _source72.dtor_expr;
+            BigInteger _2475___mcc_h1113 = _source72.dtor_index;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_Call) {
-            DAST._IExpression _2031___mcc_h887 = _source68.dtor_on;
-            Dafny.ISequence<Dafny.Rune> _2032___mcc_h888 = _source68.dtor_name;
-            Dafny.ISequence<DAST._IType> _2033___mcc_h889 = _source68.dtor_typeArgs;
-            Dafny.ISequence<DAST._IExpression> _2034___mcc_h890 = _source68.dtor_args;
+          } else if (_source72.is_Call) {
+            DAST._IExpression _2476___mcc_h1116 = _source72.dtor_on;
+            Dafny.ISequence<Dafny.Rune> _2477___mcc_h1117 = _source72.dtor_name;
+            Dafny.ISequence<DAST._IType> _2478___mcc_h1118 = _source72.dtor_typeArgs;
+            Dafny.ISequence<DAST._IExpression> _2479___mcc_h1119 = _source72.dtor_args;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_Lambda) {
-            Dafny.ISequence<DAST._IFormal> _2035___mcc_h895 = _source68.dtor_params;
-            DAST._IType _2036___mcc_h896 = _source68.dtor_retType;
-            Dafny.ISequence<DAST._IStatement> _2037___mcc_h897 = _source68.dtor_body;
+          } else if (_source72.is_Lambda) {
+            Dafny.ISequence<DAST._IFormal> _2480___mcc_h1124 = _source72.dtor_params;
+            DAST._IType _2481___mcc_h1125 = _source72.dtor_retType;
+            Dafny.ISequence<DAST._IStatement> _2482___mcc_h1126 = _source72.dtor_body;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_IIFE) {
-            Dafny.ISequence<Dafny.Rune> _2038___mcc_h901 = _source68.dtor_name;
-            DAST._IType _2039___mcc_h902 = _source68.dtor_typ;
-            DAST._IExpression _2040___mcc_h903 = _source68.dtor_value;
-            DAST._IExpression _2041___mcc_h904 = _source68.dtor_iifeBody;
+          } else if (_source72.is_IIFE) {
+            Dafny.ISequence<Dafny.Rune> _2483___mcc_h1130 = _source72.dtor_name;
+            DAST._IType _2484___mcc_h1131 = _source72.dtor_typ;
+            DAST._IExpression _2485___mcc_h1132 = _source72.dtor_value;
+            DAST._IExpression _2486___mcc_h1133 = _source72.dtor_iifeBody;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_Apply) {
-            DAST._IExpression _2042___mcc_h909 = _source68.dtor_expr;
-            Dafny.ISequence<DAST._IExpression> _2043___mcc_h910 = _source68.dtor_args;
+          } else if (_source72.is_Apply) {
+            DAST._IExpression _2487___mcc_h1138 = _source72.dtor_expr;
+            Dafny.ISequence<DAST._IExpression> _2488___mcc_h1139 = _source72.dtor_args;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
-          } else if (_source68.is_TypeTest) {
-            DAST._IExpression _2044___mcc_h913 = _source68.dtor_on;
-            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2045___mcc_h914 = _source68.dtor_dType;
-            Dafny.ISequence<Dafny.Rune> _2046___mcc_h915 = _source68.dtor_variant;
+          } else if (_source72.is_TypeTest) {
+            DAST._IExpression _2489___mcc_h1142 = _source72.dtor_on;
+            Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2490___mcc_h1143 = _source72.dtor_dType;
+            Dafny.ISequence<Dafny.Rune> _2491___mcc_h1144 = _source72.dtor_variant;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           } else {
-            DAST._IType _2047___mcc_h919 = _source68.dtor_typ;
+            DAST._IType _2492___mcc_h1148 = _source72.dtor_typ;
             {
-              _1989_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _1989_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
+              _2434_enclosingString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("("), _2434_enclosingString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")."));
             }
           }
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_1989_enclosingString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_1978_name)), _1980_typeArgString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _1983_argString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_2434_enclosingString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("r#")), (_2423_name)), _2425_typeArgString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2428_argString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           isOwned = true;
           isErased = false;
         }
       } else if (_source19.is_Lambda) {
-        Dafny.ISequence<DAST._IFormal> _2048___mcc_h50 = _source19.dtor_params;
-        DAST._IType _2049___mcc_h51 = _source19.dtor_retType;
-        Dafny.ISequence<DAST._IStatement> _2050___mcc_h52 = _source19.dtor_body;
-        Dafny.ISequence<DAST._IStatement> _2051_body = _2050___mcc_h52;
-        DAST._IType _2052_retType = _2049___mcc_h51;
-        Dafny.ISequence<DAST._IFormal> _2053_params = _2048___mcc_h50;
+        Dafny.ISequence<DAST._IFormal> _2493___mcc_h160 = _source19.dtor_params;
+        DAST._IType _2494___mcc_h161 = _source19.dtor_retType;
+        Dafny.ISequence<DAST._IStatement> _2495___mcc_h162 = _source19.dtor_body;
+        Dafny.ISequence<DAST._IStatement> _2496_body = _2495___mcc_h162;
+        DAST._IType _2497_retType = _2494___mcc_h161;
+        Dafny.ISequence<DAST._IFormal> _2498_params = _2493___mcc_h160;
         {
-          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2054_paramNames;
-          _2054_paramNames = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements();
-          BigInteger _2055_i;
-          _2055_i = BigInteger.Zero;
-          while ((_2055_i) < (new BigInteger((_2053_params).Count))) {
-            _2054_paramNames = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.Concat(_2054_paramNames, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements(((_2053_params).Select(_2055_i)).dtor_name));
-            _2055_i = (_2055_i) + (BigInteger.One);
+          Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2499_paramNames;
+          _2499_paramNames = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements();
+          BigInteger _2500_i;
+          _2500_i = BigInteger.Zero;
+          while ((_2500_i) < (new BigInteger((_2498_params).Count))) {
+            _2499_paramNames = Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.Concat(_2499_paramNames, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements(((_2498_params).Select(_2500_i)).dtor_name));
+            _2500_i = (_2500_i) + (BigInteger.One);
           }
-          Dafny.ISequence<Dafny.Rune> _2056_recursiveGen;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2057_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out1313;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1314;
-          DCOMP.COMP.GenStmts(_2051_body, _2054_paramNames, true, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(""), out _out1313, out _out1314);
-          _2056_recursiveGen = _out1313;
-          _2057_recIdents = _out1314;
+          Dafny.ISequence<Dafny.Rune> _2501_recursiveGen;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2502_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out1536;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1537;
+          DCOMP.COMP.GenStmts(_2496_body, DAST.Optional<Dafny.ISequence<Dafny.Rune>>.create_None(), _2499_paramNames, true, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(""), out _out1536, out _out1537);
+          _2501_recursiveGen = _out1536;
+          _2502_recIdents = _out1537;
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
-          Dafny.ISequence<Dafny.Rune> _2058_allReadCloned;
-          _2058_allReadCloned = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-          while (!(_2057_recIdents).Equals(Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements())) {
-            Dafny.ISequence<Dafny.Rune> _2059_next;
-            foreach (Dafny.ISequence<Dafny.Rune> _assign_such_that_1 in (_2057_recIdents).Elements) {
-              _2059_next = (Dafny.ISequence<Dafny.Rune>)_assign_such_that_1;
-              if ((_2057_recIdents).Contains(_2059_next)) {
+          Dafny.ISequence<Dafny.Rune> _2503_allReadCloned;
+          _2503_allReadCloned = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+          while (!(_2502_recIdents).Equals(Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements())) {
+            Dafny.ISequence<Dafny.Rune> _2504_next;
+            foreach (Dafny.ISequence<Dafny.Rune> _assign_such_that_1 in (_2502_recIdents).Elements) {
+              _2504_next = (Dafny.ISequence<Dafny.Rune>)_assign_such_that_1;
+              if ((_2502_recIdents).Contains(_2504_next)) {
                 goto after__ASSIGN_SUCH_THAT_1;
               }
             }
-            throw new System.Exception("assign-such-that search produced no value (line 1570)");
+            throw new System.Exception("assign-such-that search produced no value (line 1643)");
           after__ASSIGN_SUCH_THAT_1:;
-            if (!((_2054_paramNames).Contains(_2059_next))) {
-              _2058_allReadCloned = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_2058_allReadCloned, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let r#")), _2059_next), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = r#")), _2059_next), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone();\n"));
-              readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(_2059_next));
+            if (!((_2499_paramNames).Contains(_2504_next))) {
+              _2503_allReadCloned = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_2503_allReadCloned, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("let r#")), _2504_next), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = r#")), _2504_next), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".clone();\n"));
+              readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(_2504_next));
             }
-            _2057_recIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Difference(_2057_recIdents, Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(_2059_next));
+            _2502_recIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Difference(_2502_recIdents, Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements(_2504_next));
           }
-          Dafny.ISequence<Dafny.Rune> _2060_paramsString;
-          _2060_paramsString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-          _2055_i = BigInteger.Zero;
-          while ((_2055_i) < (new BigInteger((_2053_params).Count))) {
-            if ((_2055_i).Sign == 1) {
-              _2060_paramsString = Dafny.Sequence<Dafny.Rune>.Concat(_2060_paramsString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
-            }
-            Dafny.ISequence<Dafny.Rune> _2061_typStr;
-            Dafny.ISequence<Dafny.Rune> _out1315;
-            _out1315 = DCOMP.COMP.GenType(((_2053_params).Select(_2055_i)).dtor_typ, false, true);
-            _2061_typStr = _out1315;
-            _2060_paramsString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_2060_paramsString, ((_2053_params).Select(_2055_i)).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": &")), _2061_typStr);
-            _2055_i = (_2055_i) + (BigInteger.One);
+          Dafny.ISequence<Dafny.Rune> _2505_paramsString;
+          _2505_paramsString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+          _2500_i = BigInteger.Zero;
+          while ((_2500_i) < (new BigInteger((_2498_params).Count))) {
+            if ((_2500_i).Sign == 1) {
+              _2505_paramsString = Dafny.Sequence<Dafny.Rune>.Concat(_2505_paramsString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+            }
+            Dafny.ISequence<Dafny.Rune> _2506_typStr;
+            Dafny.ISequence<Dafny.Rune> _out1538;
+            _out1538 = DCOMP.COMP.GenType(((_2498_params).Select(_2500_i)).dtor_typ, false, true);
+            _2506_typStr = _out1538;
+            _2505_paramsString = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(_2505_paramsString, ((_2498_params).Select(_2500_i)).dtor_name), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": &")), _2506_typStr);
+            _2500_i = (_2500_i) + (BigInteger.One);
           }
-          Dafny.ISequence<Dafny.Rune> _2062_retTypeGen;
-          Dafny.ISequence<Dafny.Rune> _out1316;
-          _out1316 = DCOMP.COMP.GenType(_2052_retType, false, true);
-          _2062_retTypeGen = _out1316;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::FunctionWrapper({\n"), _2058_allReadCloned), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::boxed::Box::new(move |")), _2060_paramsString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("| -> ")), _2062_retTypeGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _2056_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n})})"));
+          Dafny.ISequence<Dafny.Rune> _2507_retTypeGen;
+          Dafny.ISequence<Dafny.Rune> _out1539;
+          _out1539 = DCOMP.COMP.GenType(_2497_retType, false, true);
+          _2507_retTypeGen = _out1539;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::FunctionWrapper({\n"), _2503_allReadCloned), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::std::boxed::Box::new(move |")), _2505_paramsString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("| -> ")), _2507_retTypeGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" {\n")), _2501_recursiveGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n})})"));
           isOwned = true;
           isErased = true;
         }
       } else if (_source19.is_IIFE) {
-        Dafny.ISequence<Dafny.Rune> _2063___mcc_h53 = _source19.dtor_name;
-        DAST._IType _2064___mcc_h54 = _source19.dtor_typ;
-        DAST._IExpression _2065___mcc_h55 = _source19.dtor_value;
-        DAST._IExpression _2066___mcc_h56 = _source19.dtor_iifeBody;
-        DAST._IExpression _2067_iifeBody = _2066___mcc_h56;
-        DAST._IExpression _2068_value = _2065___mcc_h55;
-        DAST._IType _2069_tpe = _2064___mcc_h54;
-        Dafny.ISequence<Dafny.Rune> _2070_name = _2063___mcc_h53;
+        Dafny.ISequence<Dafny.Rune> _2508___mcc_h163 = _source19.dtor_name;
+        DAST._IType _2509___mcc_h164 = _source19.dtor_typ;
+        DAST._IExpression _2510___mcc_h165 = _source19.dtor_value;
+        DAST._IExpression _2511___mcc_h166 = _source19.dtor_iifeBody;
+        DAST._IExpression _2512_iifeBody = _2511___mcc_h166;
+        DAST._IExpression _2513_value = _2510___mcc_h165;
+        DAST._IType _2514_tpe = _2509___mcc_h164;
+        Dafny.ISequence<Dafny.Rune> _2515_name = _2508___mcc_h163;
         {
-          Dafny.ISequence<Dafny.Rune> _2071_valueGen;
-          bool _2072_valueOwned;
-          bool _2073_valueErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2074_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out1317;
-          bool _out1318;
-          bool _out1319;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1320;
-          DCOMP.COMP.GenExpr(_2068_value, @params, false, out _out1317, out _out1318, out _out1319, out _out1320);
-          _2071_valueGen = _out1317;
-          _2072_valueOwned = _out1318;
-          _2073_valueErased = _out1319;
-          _2074_recIdents = _out1320;
-          if (_2073_valueErased) {
-            Dafny.ISequence<Dafny.Rune> _2075_eraseFn;
-            _2075_eraseFn = ((_2072_valueOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-            _2071_valueGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::"), _2075_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2071_valueGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
+          Dafny.ISequence<Dafny.Rune> _2516_valueGen;
+          bool _2517_valueOwned;
+          bool _2518_valueErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2519_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out1540;
+          bool _out1541;
+          bool _out1542;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1543;
+          DCOMP.COMP.GenExpr(_2513_value, selfIdent, @params, false, out _out1540, out _out1541, out _out1542, out _out1543);
+          _2516_valueGen = _out1540;
+          _2517_valueOwned = _out1541;
+          _2518_valueErased = _out1542;
+          _2519_recIdents = _out1543;
+          if (_2518_valueErased) {
+            Dafny.ISequence<Dafny.Rune> _2520_eraseFn;
+            _2520_eraseFn = ((_2517_valueOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+            _2516_valueGen = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::dafny_runtime::DafnyUnerasable::<_>::"), _2520_eraseFn), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2516_valueGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(")"));
           }
-          readIdents = _2074_recIdents;
-          Dafny.ISequence<Dafny.Rune> _2076_valueTypeGen;
-          Dafny.ISequence<Dafny.Rune> _out1321;
-          _out1321 = DCOMP.COMP.GenType(_2069_tpe, false, true);
-          _2076_valueTypeGen = _out1321;
-          Dafny.ISequence<Dafny.Rune> _2077_bodyGen;
-          bool _2078_bodyOwned;
-          bool _2079_bodyErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2080_bodyIdents;
-          Dafny.ISequence<Dafny.Rune> _out1322;
-          bool _out1323;
-          bool _out1324;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1325;
-          DCOMP.COMP.GenExpr(_2067_iifeBody, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.Concat(@params, ((_2072_valueOwned) ? (Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements()) : (Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements((_2070_name))))), mustOwn, out _out1322, out _out1323, out _out1324, out _out1325);
-          _2077_bodyGen = _out1322;
-          _2078_bodyOwned = _out1323;
-          _2079_bodyErased = _out1324;
-          _2080_bodyIdents = _out1325;
-          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _2080_bodyIdents);
-          Dafny.ISequence<Dafny.Rune> _2081_eraseFn;
-          _2081_eraseFn = ((_2072_valueOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("{\nlet r#"), (_2070_name)), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ")), ((_2072_valueOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&")))), _2076_valueTypeGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = ")), _2071_valueGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";\n")), _2077_bodyGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
-          isOwned = _2078_bodyOwned;
-          isErased = _2079_bodyErased;
+          readIdents = _2519_recIdents;
+          Dafny.ISequence<Dafny.Rune> _2521_valueTypeGen;
+          Dafny.ISequence<Dafny.Rune> _out1544;
+          _out1544 = DCOMP.COMP.GenType(_2514_tpe, false, true);
+          _2521_valueTypeGen = _out1544;
+          Dafny.ISequence<Dafny.Rune> _2522_bodyGen;
+          bool _2523_bodyOwned;
+          bool _2524_bodyErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2525_bodyIdents;
+          Dafny.ISequence<Dafny.Rune> _out1545;
+          bool _out1546;
+          bool _out1547;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1548;
+          DCOMP.COMP.GenExpr(_2512_iifeBody, selfIdent, Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.Concat(@params, ((_2517_valueOwned) ? (Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements()) : (Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements((_2515_name))))), mustOwn, out _out1545, out _out1546, out _out1547, out _out1548);
+          _2522_bodyGen = _out1545;
+          _2523_bodyOwned = _out1546;
+          _2524_bodyErased = _out1547;
+          _2525_bodyIdents = _out1548;
+          readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _2525_bodyIdents);
+          Dafny.ISequence<Dafny.Rune> _2526_eraseFn;
+          _2526_eraseFn = ((_2517_valueOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase_owned")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("unerase")));
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("{\nlet r#"), (_2515_name)), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(": ")), ((_2517_valueOwned) ? (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("")) : (Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&")))), _2521_valueTypeGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" = ")), _2516_valueGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(";\n")), _2522_bodyGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n}"));
+          isOwned = _2523_bodyOwned;
+          isErased = _2524_bodyErased;
         }
       } else if (_source19.is_Apply) {
-        DAST._IExpression _2082___mcc_h57 = _source19.dtor_expr;
-        Dafny.ISequence<DAST._IExpression> _2083___mcc_h58 = _source19.dtor_args;
-        Dafny.ISequence<DAST._IExpression> _2084_args = _2083___mcc_h58;
-        DAST._IExpression _2085_func = _2082___mcc_h57;
+        DAST._IExpression _2527___mcc_h167 = _source19.dtor_expr;
+        Dafny.ISequence<DAST._IExpression> _2528___mcc_h168 = _source19.dtor_args;
+        Dafny.ISequence<DAST._IExpression> _2529_args = _2528___mcc_h168;
+        DAST._IExpression _2530_func = _2527___mcc_h167;
         {
-          Dafny.ISequence<Dafny.Rune> _2086_funcString;
-          bool _2087___v78;
-          bool _2088_funcErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2089_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out1326;
-          bool _out1327;
-          bool _out1328;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1329;
-          DCOMP.COMP.GenExpr(_2085_func, @params, false, out _out1326, out _out1327, out _out1328, out _out1329);
-          _2086_funcString = _out1326;
-          _2087___v78 = _out1327;
-          _2088_funcErased = _out1328;
-          _2089_recIdents = _out1329;
-          readIdents = _2089_recIdents;
-          Dafny.ISequence<Dafny.Rune> _2090_argString;
-          _2090_argString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
-          BigInteger _2091_i;
-          _2091_i = BigInteger.Zero;
-          while ((_2091_i) < (new BigInteger((_2084_args).Count))) {
-            if ((_2091_i).Sign == 1) {
-              _2090_argString = Dafny.Sequence<Dafny.Rune>.Concat(_2090_argString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
-            }
-            Dafny.ISequence<Dafny.Rune> _2092_argExpr;
-            bool _2093_isOwned;
-            bool _2094_argErased;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2095_argIdents;
-            Dafny.ISequence<Dafny.Rune> _out1330;
-            bool _out1331;
-            bool _out1332;
-            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1333;
-            DCOMP.COMP.GenExpr((_2084_args).Select(_2091_i), @params, false, out _out1330, out _out1331, out _out1332, out _out1333);
-            _2092_argExpr = _out1330;
-            _2093_isOwned = _out1331;
-            _2094_argErased = _out1332;
-            _2095_argIdents = _out1333;
-            if (_2093_isOwned) {
-              _2092_argExpr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), _2092_argExpr);
-            }
-            _2090_argString = Dafny.Sequence<Dafny.Rune>.Concat(_2090_argString, _2092_argExpr);
-            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _2095_argIdents);
-            _2091_i = (_2091_i) + (BigInteger.One);
+          Dafny.ISequence<Dafny.Rune> _2531_funcString;
+          bool _2532___v82;
+          bool _2533_funcErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2534_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out1549;
+          bool _out1550;
+          bool _out1551;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1552;
+          DCOMP.COMP.GenExpr(_2530_func, selfIdent, @params, false, out _out1549, out _out1550, out _out1551, out _out1552);
+          _2531_funcString = _out1549;
+          _2532___v82 = _out1550;
+          _2533_funcErased = _out1551;
+          _2534_recIdents = _out1552;
+          readIdents = _2534_recIdents;
+          Dafny.ISequence<Dafny.Rune> _2535_argString;
+          _2535_argString = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("");
+          BigInteger _2536_i;
+          _2536_i = BigInteger.Zero;
+          while ((_2536_i) < (new BigInteger((_2529_args).Count))) {
+            if ((_2536_i).Sign == 1) {
+              _2535_argString = Dafny.Sequence<Dafny.Rune>.Concat(_2535_argString, Dafny.Sequence<Dafny.Rune>.UnicodeFromString(", "));
+            }
+            Dafny.ISequence<Dafny.Rune> _2537_argExpr;
+            bool _2538_isOwned;
+            bool _2539_argErased;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2540_argIdents;
+            Dafny.ISequence<Dafny.Rune> _out1553;
+            bool _out1554;
+            bool _out1555;
+            Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1556;
+            DCOMP.COMP.GenExpr((_2529_args).Select(_2536_i), selfIdent, @params, false, out _out1553, out _out1554, out _out1555, out _out1556);
+            _2537_argExpr = _out1553;
+            _2538_isOwned = _out1554;
+            _2539_argErased = _out1555;
+            _2540_argIdents = _out1556;
+            if (_2538_isOwned) {
+              _2537_argExpr = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("&"), _2537_argExpr);
+            }
+            _2535_argString = Dafny.Sequence<Dafny.Rune>.Concat(_2535_argString, _2537_argExpr);
+            readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.Union(readIdents, _2540_argIdents);
+            _2536_i = (_2536_i) + (BigInteger.One);
           }
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(("), _2086_funcString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").0")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2090_argString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("))"));
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(("), _2531_funcString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(").0")), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("(")), _2535_argString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("))"));
           isOwned = true;
           isErased = false;
         }
       } else if (_source19.is_TypeTest) {
-        DAST._IExpression _2096___mcc_h59 = _source19.dtor_on;
-        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2097___mcc_h60 = _source19.dtor_dType;
-        Dafny.ISequence<Dafny.Rune> _2098___mcc_h61 = _source19.dtor_variant;
-        Dafny.ISequence<Dafny.Rune> _2099_variant = _2098___mcc_h61;
-        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2100_dType = _2097___mcc_h60;
-        DAST._IExpression _2101_on = _2096___mcc_h59;
+        DAST._IExpression _2541___mcc_h169 = _source19.dtor_on;
+        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2542___mcc_h170 = _source19.dtor_dType;
+        Dafny.ISequence<Dafny.Rune> _2543___mcc_h171 = _source19.dtor_variant;
+        Dafny.ISequence<Dafny.Rune> _2544_variant = _2543___mcc_h171;
+        Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> _2545_dType = _2542___mcc_h170;
+        DAST._IExpression _2546_on = _2541___mcc_h169;
         {
-          Dafny.ISequence<Dafny.Rune> _2102_exprGen;
-          bool _2103___v79;
-          bool _2104_exprErased;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2105_recIdents;
-          Dafny.ISequence<Dafny.Rune> _out1334;
-          bool _out1335;
-          bool _out1336;
-          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1337;
-          DCOMP.COMP.GenExpr(_2101_on, @params, false, out _out1334, out _out1335, out _out1336, out _out1337);
-          _2102_exprGen = _out1334;
-          _2103___v79 = _out1335;
-          _2104_exprErased = _out1336;
-          _2105_recIdents = _out1337;
-          Dafny.ISequence<Dafny.Rune> _2106_dTypePath;
-          Dafny.ISequence<Dafny.Rune> _out1338;
-          _out1338 = DCOMP.COMP.GenPath(_2100_dType);
-          _2106_dTypePath = _out1338;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("matches!("), _2102_exprGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref(), ")), _2106_dTypePath), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::r#")), _2099_variant), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("{ .. })"));
+          Dafny.ISequence<Dafny.Rune> _2547_exprGen;
+          bool _2548___v83;
+          bool _2549_exprErased;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _2550_recIdents;
+          Dafny.ISequence<Dafny.Rune> _out1557;
+          bool _out1558;
+          bool _out1559;
+          Dafny.ISet<Dafny.ISequence<Dafny.Rune>> _out1560;
+          DCOMP.COMP.GenExpr(_2546_on, selfIdent, @params, false, out _out1557, out _out1558, out _out1559, out _out1560);
+          _2547_exprGen = _out1557;
+          _2548___v83 = _out1558;
+          _2549_exprErased = _out1559;
+          _2550_recIdents = _out1560;
+          Dafny.ISequence<Dafny.Rune> _2551_dTypePath;
+          Dafny.ISequence<Dafny.Rune> _out1561;
+          _out1561 = DCOMP.COMP.GenPath(_2545_dType);
+          _2551_dTypePath = _out1561;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("matches!("), _2547_exprGen), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(".as_ref(), ")), _2551_dTypePath), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::r#")), _2544_variant), Dafny.Sequence<Dafny.Rune>.UnicodeFromString("{ .. })"));
           isOwned = true;
           isErased = true;
-          readIdents = _2105_recIdents;
+          readIdents = _2550_recIdents;
         }
       } else {
-        DAST._IType _2107___mcc_h62 = _source19.dtor_typ;
-        DAST._IType _2108_typ = _2107___mcc_h62;
+        DAST._IType _2552___mcc_h172 = _source19.dtor_typ;
+        DAST._IType _2553_typ = _2552___mcc_h172;
         {
-          Dafny.ISequence<Dafny.Rune> _2109_typString;
-          Dafny.ISequence<Dafny.Rune> _out1339;
-          _out1339 = DCOMP.COMP.GenType(_2108_typ, false, false);
-          _2109_typString = _out1339;
-          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _2109_typString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as std::default::Default>::default()"));
+          Dafny.ISequence<Dafny.Rune> _2554_typString;
+          Dafny.ISequence<Dafny.Rune> _out1562;
+          _out1562 = DCOMP.COMP.GenType(_2553_typ, false, false);
+          _2554_typString = _out1562;
+          s = Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.Concat(Dafny.Sequence<Dafny.Rune>.UnicodeFromString("<"), _2554_typString), Dafny.Sequence<Dafny.Rune>.UnicodeFromString(" as std::default::Default>::default()"));
           isOwned = true;
           isErased = false;
           readIdents = Dafny.Set<Dafny.ISequence<Dafny.Rune>>.FromElements();
@@ -12987,32 +14984,32 @@ public partial class COMP {
       Dafny.ISequence<Dafny.Rune> s = Dafny.Sequence<Dafny.Rune>.Empty;
       s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("#![allow(warnings, unconditional_panic)]\n");
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("extern crate dafny_runtime;\n"));
-      BigInteger _2110_i;
-      _2110_i = BigInteger.Zero;
-      while ((_2110_i) < (new BigInteger((p).Count))) {
-        Dafny.ISequence<Dafny.Rune> _2111_generated = Dafny.Sequence<Dafny.Rune>.Empty;
-        Dafny.ISequence<Dafny.Rune> _out1340;
-        _out1340 = DCOMP.COMP.GenModule((p).Select(_2110_i), Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements());
-        _2111_generated = _out1340;
-        if ((_2110_i).Sign == 1) {
+      BigInteger _2555_i;
+      _2555_i = BigInteger.Zero;
+      while ((_2555_i) < (new BigInteger((p).Count))) {
+        Dafny.ISequence<Dafny.Rune> _2556_generated = Dafny.Sequence<Dafny.Rune>.Empty;
+        Dafny.ISequence<Dafny.Rune> _out1563;
+        _out1563 = DCOMP.COMP.GenModule((p).Select(_2555_i), Dafny.Sequence<Dafny.ISequence<Dafny.Rune>>.FromElements());
+        _2556_generated = _out1563;
+        if ((_2555_i).Sign == 1) {
           s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\n"));
         }
-        s = Dafny.Sequence<Dafny.Rune>.Concat(s, _2111_generated);
-        _2110_i = (_2110_i) + (BigInteger.One);
+        s = Dafny.Sequence<Dafny.Rune>.Concat(s, _2556_generated);
+        _2555_i = (_2555_i) + (BigInteger.One);
       }
       return s;
     }
     public static Dafny.ISequence<Dafny.Rune> EmitCallToMain(Dafny.ISequence<Dafny.ISequence<Dafny.Rune>> fullName) {
       Dafny.ISequence<Dafny.Rune> s = Dafny.Sequence<Dafny.Rune>.Empty;
       s = Dafny.Sequence<Dafny.Rune>.UnicodeFromString("\nfn main() {\n");
-      BigInteger _2112_i;
-      _2112_i = BigInteger.Zero;
-      while ((_2112_i) < (new BigInteger((fullName).Count))) {
-        if ((_2112_i).Sign == 1) {
+      BigInteger _2557_i;
+      _2557_i = BigInteger.Zero;
+      while ((_2557_i) < (new BigInteger((fullName).Count))) {
+        if ((_2557_i).Sign == 1) {
           s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("::"));
         }
-        s = Dafny.Sequence<Dafny.Rune>.Concat(s, (fullName).Select(_2112_i));
-        _2112_i = (_2112_i) + (BigInteger.One);
+        s = Dafny.Sequence<Dafny.Rune>.Concat(s, (fullName).Select(_2557_i));
+        _2557_i = (_2557_i) + (BigInteger.One);
       }
       s = Dafny.Sequence<Dafny.Rune>.Concat(s, Dafny.Sequence<Dafny.Rune>.UnicodeFromString("();\n}"));
       return s;
diff --git a/Source/DafnyCore/Verifier/Translator.ExpressionWellformed.cs b/Source/DafnyCore/Verifier/Translator.ExpressionWellformed.cs
index 10404e9c2a4..8513544479c 100644
--- a/Source/DafnyCore/Verifier/Translator.ExpressionWellformed.cs
+++ b/Source/DafnyCore/Verifier/Translator.ExpressionWellformed.cs
@@ -711,34 +711,54 @@ private record ReadsCheckDelayer(ExpressionTranslator etran, Function selfCallsA
                 }
               }
               // check that the preconditions for the call hold
-              foreach (AttributedExpression p in e.Function.Req) {
-                Expression precond = Substitute(p.E, e.Receiver, substMap, e.GetTypeArgumentSubstitutions());
-                var (errorMessage, successMessage) = CustomErrorMessage(p.Attributes);
-                foreach (var ss in TrSplitExpr(precond, etran, true, out var splitHappened)) {
-                  if (ss.IsChecked) {
-                    var tok = new NestedToken(GetToken(expr), ss.Tok);
-                    var desc = new PODesc.PreconditionSatisfied(errorMessage, successMessage);
-                    if (wfOptions.AssertKv != null) {
-                      // use the given assert attribute only
-                      builder.Add(Assert(tok, ss.E, new PODesc.PreconditionSatisfied(errorMessage, successMessage), wfOptions.AssertKv));
-                    } else {
-                      builder.Add(AssertNS(tok, ss.E, new PODesc.PreconditionSatisfied(errorMessage, successMessage)));
+              // the check for .reads function must be translated explicitly: their declaration lacks
+              // an explicit precondition, which is added as an axiom in Translator.cs
+              if (e.Function.Name == "reads" && !e.Receiver.Type.IsArrowTypeWithoutReadEffects) {
+                var arguments = etran.FunctionInvocationArguments(e, null, null);
+                var precondition = FunctionCall(e.tok, Requires(e.Args.Count), Bpl.Type.Bool, arguments);
+                builder.Add(Assert(GetToken(expr), precondition, new PODesc.PreconditionSatisfied(null, null)));
+
+                if (wfOptions.DoReadsChecks) {
+                  // check that the callee reads only what the caller is already allowed to read
+                  Type objset = new SetType(true, program.SystemModuleManager.ObjectQ());
+                  Expression wrap = new BoogieWrapper(
+                    FunctionCall(expr.tok, Reads(e.Args.Count()), TrType(objset), arguments),
+                    objset);
+                  var reads = new FrameExpression(expr.tok, wrap, null);
+                  CheckFrameSubset(expr.tok, new List<FrameExpression> { reads }, null, null,
+                    etran, etran.ReadsFrame(expr.tok), wfOptions.AssertSink(this, builder), new PODesc.FrameSubset("invoke function", false), wfOptions.AssertKv);
+                }
+
+              } else {
+
+                foreach (AttributedExpression p in e.Function.Req) {
+                  Expression precond = Substitute(p.E, e.Receiver, substMap, e.GetTypeArgumentSubstitutions());
+                  var (errorMessage, successMessage) = CustomErrorMessage(p.Attributes);
+                  foreach (var ss in TrSplitExpr(precond, etran, true, out var splitHappened)) {
+                    if (ss.IsChecked) {
+                      var tok = new NestedToken(GetToken(expr), ss.Tok);
+                      var desc = new PODesc.PreconditionSatisfied(errorMessage, successMessage);
+                      if (wfOptions.AssertKv != null) {
+                        // use the given assert attribute only
+                        builder.Add(Assert(tok, ss.E, new PODesc.PreconditionSatisfied(errorMessage, successMessage), wfOptions.AssertKv));
+                      } else {
+                        builder.Add(AssertNS(tok, ss.E, new PODesc.PreconditionSatisfied(errorMessage, successMessage)));
+                      }
                     }
                   }
+                  if (wfOptions.AssertKv == null) {
+                    // assume only if no given assert attribute is given
+                    builder.Add(TrAssumeCmd(callExpr.tok, etran.TrExpr(precond)));
+                  }
                 }
-                if (wfOptions.AssertKv == null) {
-                  // assume only if no given assert attribute is given
-                  builder.Add(TrAssumeCmd(callExpr.tok, etran.TrExpr(precond)));
+                if (wfOptions.DoReadsChecks) {
+                  // check that the callee reads only what the caller is already allowed to read
+                  var s = new Substituter(null, new Dictionary<IVariable, Expression>(), e.GetTypeArgumentSubstitutions());
+                  CheckFrameSubset(callExpr.tok,
+                    e.Function.Reads.ConvertAll(s.SubstFrameExpr),
+                    e.Receiver, substMap, etran, etran.ReadsFrame(callExpr.tok), wfOptions.AssertSink(this, builder), new PODesc.FrameSubset("invoke function", false), wfOptions.AssertKv);
                 }
               }
-              if (wfOptions.DoReadsChecks) {
-                // check that the callee reads only what the caller is already allowed to read
-                var s = new Substituter(null, new Dictionary<IVariable, Expression>(), e.GetTypeArgumentSubstitutions());
-                CheckFrameSubset(callExpr.tok,
-                  e.Function.Reads.ConvertAll(s.SubstFrameExpr),
-                  e.Receiver, substMap, etran, etran.ReadsFrame(callExpr.tok), wfOptions.AssertSink(this, builder), new PODesc.FrameSubset("invoke function", false), wfOptions.AssertKv);
-              }
-
               Bpl.Expr allowance = null;
               if (codeContext != null && e.CoCall != FunctionCallExpr.CoCallResolution.Yes && !(e.Function is ExtremePredicate)) {
                 // check that the decreases measure goes down
diff --git a/Source/DafnyLanguageServer.Test/ProjectFiles/ProjectFilesTest.cs b/Source/DafnyLanguageServer.Test/ProjectFiles/ProjectFilesTest.cs
index 27c5de71dd1..481a72a5bcc 100644
--- a/Source/DafnyLanguageServer.Test/ProjectFiles/ProjectFilesTest.cs
+++ b/Source/DafnyLanguageServer.Test/ProjectFiles/ProjectFilesTest.cs
@@ -12,6 +12,38 @@ namespace Microsoft.Dafny.LanguageServer.IntegrationTest;
 
 public class ProjectFilesTest : ClientBasedLanguageServerTest {
 
+  /// <summary>
+  /// Previously this could cause two project managers for the same project to be created.
+  /// </summary>
+  [Fact]
+  public async Task OpenTwoFilesThenIntroduceProjectFile() {
+    var tempDirectory = Path.GetRandomFileName();
+    var producerMarkup = @"
+module [>Producer<]Oops {
+  const x := 3
+}".TrimStart();
+    MarkupTestFile.GetPositionsAndRanges(producerMarkup, out var producerSource, out _, out var ranges);
+    var producer = await CreateAndOpenTestDocument(producerSource, Path.Combine(tempDirectory, "producer.dfy"));
+    var consumerSourceMarkup = @"
+include ""producer.dfy""
+module Consumer {
+  import opened Pro><ducer
+  const y := x + 2
+}".TrimStart();
+    MarkupTestFile.GetPositionAndRanges(consumerSourceMarkup, out var consumerSource, out var gotoPosition, out _);
+    var consumer = await CreateAndOpenTestDocument(consumerSource, Path.Combine(tempDirectory, "consumer.dfy"));
+    await CreateAndOpenTestDocument("", Path.Combine(tempDirectory, DafnyProject.FileName));
+    await Task.Delay(ProjectManagerDatabase.ProjectFileCacheExpiryTime);
+    // Let consumer.dfy realize it has a new project file 
+    var definition1 = await RequestDefinition(consumer, gotoPosition);
+    Assert.Empty(definition1);
+    ApplyChange(ref producer, new Range(0, 15, 0, 19), ""); // Delete oops
+    // Check that the project manager of consumer.dfy has incorporated the update in producer.dfy
+    var definition2 = await RequestDefinition(consumer, gotoPosition);
+    Assert.Single(definition2);
+    Assert.Equal(ranges[0], definition2.First().Location!.Range);
+  }
+
   [Fact]
   public async Task ProjectFileByItselfHasNoDiagnostics() {
     var tempDirectory = Path.GetRandomFileName();
diff --git a/Source/DafnyLanguageServer/Workspace/CompilationManager.cs b/Source/DafnyLanguageServer/Workspace/CompilationManager.cs
index 3be2eba8945..b1a843ebdff 100644
--- a/Source/DafnyLanguageServer/Workspace/CompilationManager.cs
+++ b/Source/DafnyLanguageServer/Workspace/CompilationManager.cs
@@ -50,7 +50,7 @@ public class CompilationManager {
 
   private TaskCompletionSource verificationCompleted = new();
   private readonly DafnyOptions options;
-  private readonly Compilation startingCompilation;
+  public Compilation StartingCompilation { get; }
   private readonly ExecutionEngine boogieEngine;
 
   private readonly Subject<Compilation> compilationUpdates = new();
@@ -70,7 +70,7 @@ public class CompilationManager {
     IReadOnlyDictionary<Uri, DocumentVerificationTree> migratedVerificationTrees
     ) {
     this.options = options;
-    startingCompilation = compilation;
+    StartingCompilation = compilation;
     this.boogieEngine = boogieEngine;
     this.migratedVerificationTrees = migratedVerificationTrees;
 
@@ -95,7 +95,7 @@ public class CompilationManager {
   private async Task<CompilationAfterParsing> ParseAsync() {
     try {
       await started.Task;
-      var parsedCompilation = await documentLoader.ParseAsync(options, startingCompilation, migratedVerificationTrees,
+      var parsedCompilation = await documentLoader.ParseAsync(options, StartingCompilation, migratedVerificationTrees,
         cancellationSource.Token);
       verificationProgressReporter.RecomputeVerificationTrees(parsedCompilation);
       foreach (var root in parsedCompilation.RootUris) {
@@ -297,7 +297,7 @@ public class CompilationManager {
             var remainingJobs = Interlocked.Decrement(ref runningVerificationJobs);
             logger.LogDebug(
               $"StatusUpdateHandlerFinally called, remaining jobs {remainingJobs}, {compilation.Uri} version {compilation.Version}, " +
-              $"startingCompilation.version {startingCompilation.Version}.");
+              $"startingCompilation.version {StartingCompilation.Version}.");
             if (remainingJobs == 0) {
               FinishedNotifications(compilation, verifiable);
             }
@@ -330,14 +330,14 @@ public class CompilationManager {
   public void IncrementJobs() {
     MarkVerificationStarted();
     var verifyTaskIncrementedJobs = Interlocked.Increment(ref runningVerificationJobs);
-    logger.LogDebug($"Incremented jobs for verifyTask, remaining jobs {verifyTaskIncrementedJobs}, {startingCompilation.Uri} version {startingCompilation.Version}");
+    logger.LogDebug($"Incremented jobs for verifyTask, remaining jobs {verifyTaskIncrementedJobs}, {StartingCompilation.Uri} version {StartingCompilation.Version}");
   }
 
   public void DecrementJobs() {
     var remainingJobs = Interlocked.Decrement(ref runningVerificationJobs);
-    logger.LogDebug($"Decremented jobs, remaining jobs {remainingJobs}, {startingCompilation.Uri} version {startingCompilation.Version}");
+    logger.LogDebug($"Decremented jobs, remaining jobs {remainingJobs}, {StartingCompilation.Uri} version {StartingCompilation.Version}");
     if (remainingJobs == 0) {
-      logger.LogDebug($"Calling MarkVerificationFinished because there are no remaining verification jobs for {startingCompilation.Uri}, version {startingCompilation.Version}.");
+      logger.LogDebug($"Calling MarkVerificationFinished because there are no remaining verification jobs for {StartingCompilation.Uri}, version {StartingCompilation.Version}.");
       MarkVerificationFinished();
     }
   }
@@ -465,20 +465,20 @@ public class CompilationManager {
   }
 
   private void MarkVerificationStarted() {
-    logger.LogDebug($"MarkVerificationStarted called for {startingCompilation.Uri} version {startingCompilation.Version}");
+    logger.LogDebug($"MarkVerificationStarted called for {StartingCompilation.Uri} version {StartingCompilation.Version}");
     if (verificationCompleted.Task.IsCompleted) {
       verificationCompleted = new TaskCompletionSource();
     }
   }
 
   private void MarkVerificationFinished() {
-    logger.LogDebug($"MarkVerificationFinished called for {startingCompilation.Uri} version {startingCompilation.Version}");
+    logger.LogDebug($"MarkVerificationFinished called for {StartingCompilation.Uri} version {StartingCompilation.Version}");
     verificationCompleted.TrySetResult();
   }
 
   public Task<CompilationAfterParsing> LastDocument {
     get {
-      logger.LogDebug($"LastDocument {startingCompilation.Uri} will return document version {startingCompilation.Version}");
+      logger.LogDebug($"LastDocument {StartingCompilation.Uri} will return document version {StartingCompilation.Version}");
       return ResolvedCompilation.ContinueWith(
         t => {
           if (t.IsCompletedSuccessfully) {
@@ -486,7 +486,7 @@ public class CompilationManager {
             return verificationCompleted.Task.ContinueWith(
               verificationCompletedTask => {
                 logger.LogDebug(
-                  $"LastDocument returning translated compilation {startingCompilation.Uri} with status {verificationCompletedTask.Status}");
+                  $"LastDocument returning translated compilation {StartingCompilation.Uri} with status {verificationCompletedTask.Status}");
                 return Task.FromResult<CompilationAfterParsing>(t.Result);
               }, TaskScheduler.Current).Unwrap();
 #pragma warning restore VSTHRD103
diff --git a/Source/DafnyLanguageServer/Workspace/FileVerificationStatus.cs b/Source/DafnyLanguageServer/Workspace/FileVerificationStatus.cs
index c8ef9321223..047c2cd4928 100644
--- a/Source/DafnyLanguageServer/Workspace/FileVerificationStatus.cs
+++ b/Source/DafnyLanguageServer/Workspace/FileVerificationStatus.cs
@@ -9,7 +9,7 @@ namespace Microsoft.Dafny.LanguageServer.Workspace;
 
 public record FileVerificationStatus(
   DocumentUri Uri,
-  int Version,
+  int? Version,
   IReadOnlyList<NamedVerifiableStatus> NamedVerifiables) : IRequest {
   public override string ToString() {
     return $"{nameof(NamedVerifiables)}: {string.Join(", ", NamedVerifiables)}";
diff --git a/Source/DafnyLanguageServer/Workspace/LanguageServerFilesystem.cs b/Source/DafnyLanguageServer/Workspace/LanguageServerFilesystem.cs
index 366a810f823..03fdcab5152 100644
--- a/Source/DafnyLanguageServer/Workspace/LanguageServerFilesystem.cs
+++ b/Source/DafnyLanguageServer/Workspace/LanguageServerFilesystem.cs
@@ -18,9 +18,9 @@ public class LanguageServerFilesystem : IFileSystem {
 
   private class Entry {
     public TextBuffer Buffer { get; set; }
-    public int Version { get; set; }
+    public int? Version { get; set; }
 
-    public Entry(TextBuffer buffer, int version) {
+    public Entry(TextBuffer buffer, int? version) {
       Buffer = buffer;
       Version = version;
     }
@@ -44,7 +44,7 @@ private class Entry {
       // If we don't manage to detect whether this document already existed ond disc,
       // that only triggers a performance penalty
     }
-    openFiles[uri] = new Entry(new TextBuffer(document.Text), document.Version!.Value);
+    openFiles[uri] = new Entry(new TextBuffer(document.Text), document.Version);
     return existingText != document.Text;
   }
 
diff --git a/Source/DafnyLanguageServer/Workspace/NotificationPublisher.cs b/Source/DafnyLanguageServer/Workspace/NotificationPublisher.cs
index 6ecc3740232..11683946034 100644
--- a/Source/DafnyLanguageServer/Workspace/NotificationPublisher.cs
+++ b/Source/DafnyLanguageServer/Workspace/NotificationPublisher.cs
@@ -97,7 +97,7 @@ private sealed record ResolutionProgressStatus(CompilationStatus CompilationStat
 
     private FileVerificationStatus GetFileVerificationStatus(IdeState state, Uri uri) {
       var verificationResults = state.GetVerificationResults(uri);
-      return new FileVerificationStatus(uri, filesystem.GetVersion(uri) ?? 0,
+      return new FileVerificationStatus(uri, filesystem.GetVersion(uri),
         verificationResults.Select(kv => GetNamedVerifiableStatuses(kv.Key, kv.Value)).
             OrderBy(s => s.NameRange.Start).ToList());
     }
@@ -163,7 +163,7 @@ private sealed record ResolutionProgressStatus(CompilationStatus CompilationStat
 
           languageServer.TextDocument.PublishDiagnostics(new PublishDiagnosticsParams {
             Uri = publishUri,
-            Version = filesystem.GetVersion(publishUri) ?? 0,
+            Version = filesystem.GetVersion(publishUri),
             Diagnostics = diagnostics,
           });
         }
@@ -182,7 +182,7 @@ private sealed record ResolutionProgressStatus(CompilationStatus CompilationStat
       var tree = state.VerificationTrees[uri];
 
       var linesCount = tree.Range.End.Line + 1;
-      var fileVersion = filesystem.GetVersion(uri) ?? 0;
+      var fileVersion = filesystem.GetVersion(uri);
       var verificationStatusGutter = VerificationStatusGutter.ComputeFrom(
         DocumentUri.From(uri),
         fileVersion,
diff --git a/Source/DafnyLanguageServer/Workspace/Notifications/VerificationDiagnosticsParams.cs b/Source/DafnyLanguageServer/Workspace/Notifications/VerificationDiagnosticsParams.cs
index b1cece67695..b8b093f427a 100644
--- a/Source/DafnyLanguageServer/Workspace/Notifications/VerificationDiagnosticsParams.cs
+++ b/Source/DafnyLanguageServer/Workspace/Notifications/VerificationDiagnosticsParams.cs
@@ -28,7 +28,7 @@ LineVerificationStatus[] PerLineStatus
 
     public static VerificationStatusGutter ComputeFrom(
         DocumentUri uri,
-        int version,
+        int? version,
         ICollection<VerificationTree> verificationTrees,
         Container<Diagnostic> resolutionErrors,
         int linesCount,
diff --git a/Source/DafnyLanguageServer/Workspace/ProjectManager.cs b/Source/DafnyLanguageServer/Workspace/ProjectManager.cs
index 9f98cf7d11c..682ad068aa8 100644
--- a/Source/DafnyLanguageServer/Workspace/ProjectManager.cs
+++ b/Source/DafnyLanguageServer/Workspace/ProjectManager.cs
@@ -221,7 +221,7 @@ public class ProjectManager : IDisposable {
     return await CompilationManager.LastDocument;
   }
 
-  public async Task<IdeState> GetSnapshotAfterParsingAsync() {
+  public async Task<IdeState> GetStateAfterParsingAsync() {
     try {
       var parsedCompilation = await CompilationManager.ParsedCompilation;
       logger.LogDebug($"GetSnapshotAfterParsingAsync returns compilation version {parsedCompilation.Version}");
@@ -237,13 +237,13 @@ public class ProjectManager : IDisposable {
     try {
       var resolvedCompilation = await CompilationManager.ResolvedCompilation;
       logger.LogDebug($"GetStateAfterResolutionAsync returns compilation version {resolvedCompilation.Version}");
+      logger.LogDebug($"GetStateAfterResolutionAsync returns state version {latestIdeState.Value.Version}");
+      return latestIdeState.Value;
     } catch (OperationCanceledException) {
       logger.LogDebug($"GetSnapshotAfterResolutionAsync caught OperationCanceledException for resolved compilation {Project.Uri}");
-      return await GetSnapshotAfterParsingAsync();
+      return await GetStateAfterParsingAsync();
     }
 
-    logger.LogDebug($"GetStateAfterResolutionAsync returns state version {latestIdeState.Value.Version}");
-    return latestIdeState.Value;
   }
 
   public async Task<IdeState> GetIdeStateAfterVerificationAsync() {
diff --git a/Source/DafnyLanguageServer/Workspace/ProjectManagerDatabase.cs b/Source/DafnyLanguageServer/Workspace/ProjectManagerDatabase.cs
index 97f0f060b23..8e1d3d9223f 100644
--- a/Source/DafnyLanguageServer/Workspace/ProjectManagerDatabase.cs
+++ b/Source/DafnyLanguageServer/Workspace/ProjectManagerDatabase.cs
@@ -134,14 +134,21 @@ public class ProjectManagerDatabase : IProjectDatabase {
         if (projectManagerForFile != null) {
           var filesProjectHasChanged = !projectManagerForFile.Project.Equals(project);
           if (filesProjectHasChanged) {
-            var projectFileHasChanged = projectManagerForFile.Project.Uri == project.Uri;
-            if (projectFileHasChanged) {
+            var projectFileContentHasChanged = projectManagerForFile.Project.Uri == project.Uri;
+            if (projectFileContentHasChanged) {
+              // Scrap the project manager.
               var _ = projectManagerForFile.CloseAsync();
+              managersByProject.Remove(project.Uri);
             } else {
-              projectManagerForFile.CloseDocument(out _);
+              var previousProjectHasNoDocuments = projectManagerForFile.CloseDocument(out _);
+              if (previousProjectHasNoDocuments) {
+                // Enable garbage collection
+                managersByProject.Remove(projectManagerForFile.Project.Uri);
+              }
             }
 
-            projectManagerForFile = createProjectManager(boogieEngine, project);
+            projectManagerForFile = managersByProject.GetValueOrDefault(project.Uri) ??
+                                    createProjectManager(boogieEngine, project);
             projectManagerForFile.OpenDocument(documentId.Uri.ToUri(), true);
           }
         } else {
@@ -173,6 +180,9 @@ public class ProjectManagerDatabase : IProjectDatabase {
     }
 
     public async Task<DafnyProject> GetProject(Uri uri) {
+      if (uri.LocalPath.EndsWith(DafnyProject.FileName)) {
+        return await DafnyProject.Open(fileSystem, uri, TextWriter.Null, TextWriter.Null);
+      }
       return (await FindProjectFile(uri)) ?? ImplicitProject(uri);
     }
 
diff --git a/Source/DafnyRuntime/DafnyRuntime.js b/Source/DafnyRuntime/DafnyRuntime.js
index 44bff912f28..15eded4abb6 100644
--- a/Source/DafnyRuntime/DafnyRuntime.js
+++ b/Source/DafnyRuntime/DafnyRuntime.js
@@ -636,6 +636,13 @@ let _dafny = (function() {
     }
     update(k, v) {
       let m = this.slice();
+      m.updateUnsafe(k, v);
+      return m;
+    }
+    // Similar to update, but make the modification in-place.
+    // Meant to be used in the map constructor.
+    updateUnsafe(k, v) {
+      let m = this;
       let i = m.findIndex(k);
       m[i] = [k, v];
       return m;
diff --git a/Source/DafnyRuntime/DafnyRuntime.py b/Source/DafnyRuntime/DafnyRuntime.py
index 3ebf903903c..3a35989ee67 100644
--- a/Source/DafnyRuntime/DafnyRuntime.py
+++ b/Source/DafnyRuntime/DafnyRuntime.py
@@ -3,7 +3,7 @@
 from dataclasses import dataclass
 from contextlib import contextmanager
 from fractions import Fraction
-from collections import Counter
+from collections import Counter, deque
 from collections.abc import Iterable
 from functools import reduce
 from types import GeneratorType, FunctionType
@@ -95,8 +95,29 @@ def __add__(self, other):
     def __sub__(self, other):
         return CodePoint(minus_char(self, other))
 
-class Seq(tuple):
-    def __init__(self, __iterable = None, isStr = False):
+class Concat:
+    def __init__(self, l, r):
+        self.l = l
+        self.r = r
+        self.len = len(l) + len(r)
+
+    def __len__(self):
+        return self.len
+
+    def flatten(self):
+        l = []
+        q = deque([self])
+        while q:
+            e = q.pop()
+            if isinstance(e, list):
+                l += e
+            elif isinstance(e, Concat):
+                q.append(e.r)
+                q.append(e.l)
+        return l
+
+class Seq:
+    def __init__(self, iterable = None, isStr = False):
         '''
         isStr defines whether this value should be tracked at runtime as a string (a.k.a. seq<char>)
         It accepts three different values:
@@ -109,55 +130,65 @@ def __init__(self, __iterable = None, isStr = False):
         See docs/Compilation/StringsAndChars.md.
         '''
 
-        if __iterable is None:
-            __iterable = []
+        self.elems = iterable if isinstance(iterable, Concat) else (list(iterable) if iterable is not None else [])
+        self.len = len(self.elems)
         if isStr is None:
             self.isStr = None
         else:
             self.isStr = isStr \
-                        or isinstance(__iterable, str) \
-                        or (isinstance(__iterable, Seq) and __iterable.isStr) \
-                        or (not isinstance(__iterable, GeneratorType)
-                            and all(isinstance(e, str) and len(e) == 1 for e in __iterable)
-                            and len(__iterable) > 0)
+                        or isinstance(iterable, str) \
+                        or (isinstance(iterable, Seq) and iterable.isStr)
+            # delay expensive computation
+            if not self.isStr and isinstance(iterable, Concat):
+                self.isStr = 0
 
     @property
     def Elements(self):
-        return self
+        if isinstance(self.elems, Concat):
+            self.elems = self.elems.flatten()
+        return self.elems
 
     @property
     def UniqueElements(self):
-        return frozenset(self)
+        return frozenset(self.Elements)
 
     def VerbatimString(self, asliteral):
         if asliteral:
-            return f"\"{''.join(map(lambda c: c.__escaped__(), self))}\""
+            return f"\"{''.join(map(lambda c: c.__escaped__(), self.Elements))}\""
         else:
             return ''.join(self)
 
     def __dafnystr__(self) -> str:
+        if self.isStr == 0:
+            self.isStr = len(self) > 0 and all(isinstance(e, str) and len(e) == 1 for e in self.Elements)
         if self.isStr:
             # This should never be true when using --unicode-char,
             # so it is safe to assume we are a sequence of UTF-16 code units.
-            return string_from_utf_16(self)
-        return '[' + ', '.join(map(string_of, self)) + ']'
+            return string_from_utf_16(self.Elements)
+        return '[' + ', '.join(map(string_of, self.Elements)) + ']'
 
     def __add__(self, other):
-        return Seq(super().__add__(other), isStr=self.isStr and other.isStr)
+        return Seq(Concat(self.elems, other.elems), isStr=self.isStr and other.isStr)
 
     def __getitem__(self, key):
         if isinstance(key, slice):
             indices = range(*key.indices(len(self)))
-            return Seq((self[i] for i in indices), isStr=self.isStr)
-        return super().__getitem__(key)
+            return Seq((self.Elements[i] for i in indices), isStr=self.isStr)
+        return self.Elements.__getitem__(key)
 
     def set(self, key, value):
-        l = list(self)
+        l = list(self.Elements)
         l[key] = value
         return Seq(l, isStr=self.isStr)
 
+    def __len__(self):
+        return self.len
+
     def __hash__(self) -> int:
-        return hash(tuple(self))
+        return hash(tuple(self.Elements))
+
+    def __eq__(self, other: object) -> bool:
+        return self.Elements == other.Elements
 
     def __lt__(self, other):
         return len(self) < len(other) and self == other[:len(self)]
diff --git a/Source/DafnyRuntime/DafnyRuntimeGo/DafnyRuntime.go b/Source/DafnyRuntime/DafnyRuntimeGo/DafnyRuntime.go
index f5288328cda..6cb755e1f8b 100644
--- a/Source/DafnyRuntime/DafnyRuntimeGo/DafnyRuntime.go
+++ b/Source/DafnyRuntime/DafnyRuntimeGo/DafnyRuntime.go
@@ -1926,7 +1926,7 @@ func NewMapBuilder() *MapBuilder {
   return new(MapBuilder)
 }
 
-// Add adds a key and value to the map being built.
+// Add adds a key and value to the map being built, used by map comprehension
 func (mb *MapBuilder) Add(k, v interface{}) *MapBuilder {
   *mb = append(*mb, mapElt{k, v})
   return mb
@@ -1999,6 +1999,19 @@ func (m Map) Update(key, value interface{}) Map {
   return ans
 }
 
+// Similar to Update, but make the modification in-place.
+// Meant to be used in the map constructor.
+func (m Map) UpdateUnsafe(key, value interface{}) Map {
+  ans := m
+  i, found := ans.findIndex(key)
+  if found {
+    ans.elts[i] = mapElt{key, value}
+  } else {
+    ans.elts = append(ans.elts, mapElt{key, value})
+  }
+  return ans
+}
+
 func (a Map) Merge(b Map) Map {
   if a.CardinalityInt() == 0 {
     return b
diff --git a/Source/DafnyRuntime/DafnyRuntimeRust/src/lib.rs b/Source/DafnyRuntime/DafnyRuntimeRust/src/lib.rs
index c574f24d1c6..f66ca7850db 100644
--- a/Source/DafnyRuntime/DafnyRuntimeRust/src/lib.rs
+++ b/Source/DafnyRuntime/DafnyRuntimeRust/src/lib.rs
@@ -119,6 +119,32 @@ pub trait DafnyUnerasable<T: ?Sized> {
     fn unerase_owned(v: T) -> Self;
 }
 
+impl <T: DafnyErasable> DafnyErasable for Option<T> {
+    type Erased = Option<T::Erased>;
+
+    #[inline]
+    fn erase(&self) -> &Self::Erased {
+        unsafe { &*(self as *const Self as *const Self::Erased) }
+    }
+
+    #[inline]
+    fn erase_owned(self) -> Self::Erased {
+        unsafe { transmute_unchecked(self) }
+    }
+}
+
+impl <T: DafnyUnerasable<U>, U> DafnyUnerasable<Option<U>> for Option<T> {
+    #[inline]
+    fn unerase(v: &Option<U>) -> &Self {
+        unsafe { &*(v as *const Option<U> as *const Self) }
+    }
+
+    #[inline]
+    fn unerase_owned(v: Option<U>) -> Self {
+        unsafe { transmute_unchecked(v) }
+    }
+}
+
 impl <T> DafnyErasable for Rc<T> {
     type Erased = Rc<T>;
 
@@ -402,6 +428,15 @@ impl DafnyPrint for char {
     }
 }
 
+impl <T: DafnyPrint> DafnyPrint for Option<T> {
+    fn fmt_print(&self, f: &mut Formatter<'_>, _in_seq: bool) -> std::fmt::Result {
+        match self {
+            Some(x) => x.fmt_print(f, false),
+            None => write!(f, "null")
+        }
+    }
+}
+
 impl DafnyPrint for BigInt {
     fn fmt_print(&self, f: &mut Formatter<'_>, _in_seq: bool) -> std::fmt::Result {
         write!(f, "{}", self)
diff --git a/Test/HigherOrderIntrinsicSpecification/ReadPreconditionBypass1.dfy b/Test/HigherOrderIntrinsicSpecification/ReadPreconditionBypass1.dfy
new file mode 100644
index 00000000000..1d5ee2ccd14
--- /dev/null
+++ b/Test/HigherOrderIntrinsicSpecification/ReadPreconditionBypass1.dfy
@@ -0,0 +1,30 @@
+// RUN: %exits-with 4 %dafny /compile:0 "%s" > "%t"
+// RUN: %diff "%s.expect" "%t"
+
+class Ref {
+  var inner: Ref
+  constructor()
+}
+
+function myf(o: Ref): ()
+  requires false
+  reads o.inner
+{
+  ()
+}
+
+method Main()
+  ensures false
+{
+  var outer := new Ref();
+
+  var inner1 := new Ref();
+  outer.inner := inner1;
+  var reads1 := myf.reads(outer);  // Error: function precondition could not be proved
+  assert reads1 == {inner1};
+
+  var inner2 := new Ref();
+  outer.inner := inner2;
+  var reads2 := myf.reads(outer);
+  assert reads2 == {inner2};
+}
\ No newline at end of file
diff --git a/Test/HigherOrderIntrinsicSpecification/ReadPreconditionBypass1.dfy.expect b/Test/HigherOrderIntrinsicSpecification/ReadPreconditionBypass1.dfy.expect
new file mode 100644
index 00000000000..4a61ec10c3e
--- /dev/null
+++ b/Test/HigherOrderIntrinsicSpecification/ReadPreconditionBypass1.dfy.expect
@@ -0,0 +1,3 @@
+ReadPreconditionBypass1.dfy(23,20): Error: function precondition could not be proved
+
+Dafny program verifier finished with 1 verified, 1 error
diff --git a/Test/autoRevealDependencies/tree-map-simple.dfy b/Test/autoRevealDependencies/tree-map-simple.dfy
index 0773bb5a7cc..bd280bfd99b 100644
--- a/Test/autoRevealDependencies/tree-map-simple.dfy
+++ b/Test/autoRevealDependencies/tree-map-simple.dfy
@@ -3,7 +3,6 @@
 
 method Main() {
   TestY();
-  TestZ();
 }
 
 datatype List<A> = Nil | Cons(head: A, tail: List<A>)
@@ -54,41 +53,3 @@ method TestY() {
   assert t == Branch(100, Cons(Branch(50, Nil), Nil));  // proved via Lit axioms
   print t, "\n";
 }
-
-// ---------- Read-effect functions ----------
-
-ghost predicate PreZ<A,B>(f: A ~> B, s: set<A>)
-  reads set x, y | x in s && y in f.reads(x) :: y
-{
-  forall x :: x in s ==> f.requires(x)
-}
-
-function MapZ<A,B>(xs: List<A>, f: A ~> B): List<B>
-  requires PreZ(f, ListData(xs))
-  reads PreZ.reads(f, ListData(xs))
-  decreases xs
-{
-  match xs
-  case Nil => Nil
-  case Cons(x, xs) => Cons(f(x), MapZ(xs, f))
-}
-
-function TreeMapZ<A,B>(t0: Tree<A>, f: A ~> B): Tree<B>
-  requires PreZ(f, TreeData(t0))
-  reads PreZ.reads(f, TreeData(t0))
-  decreases t0
-{
-  var Branch(x, ts) := t0;
-  var g := t requires t in ListData(ts) && PreZ(f, TreeData(t))
-            reads set x, y | x in TreeData(t) && y in f.reads(x) :: y
-           => TreeMapZ(t, f);
-  Branch(f(x), MapZ(ts, g))
-}
-
-method TestZ() {
-  var f := x requires x != 0 => 100 / x;
-  var t := TreeMapZ(Branch(1, Cons(Branch(2, Nil), Nil)), f);
-  // Functions with reads clauses don't get Lit axioms, so we can't prove the same
-  // assertion as we did in TestY.
-  print t, "\n";
-}
diff --git a/Test/autoRevealDependencies/tree-map-simple.dfy.expect b/Test/autoRevealDependencies/tree-map-simple.dfy.expect
index ccc01c35f48..851aaf58286 100644
--- a/Test/autoRevealDependencies/tree-map-simple.dfy.expect
+++ b/Test/autoRevealDependencies/tree-map-simple.dfy.expect
@@ -1,2 +1,2 @@
 
-Dafny program verifier finished with 11 verified, 0 errors
+Dafny program verifier finished with 7 verified, 0 errors
diff --git a/Test/comp/Collections.dfy b/Test/comp/Collections.dfy
index 9457e44b170..1d62fce8580 100644
--- a/Test/comp/Collections.dfy
+++ b/Test/comp/Collections.dfy
@@ -359,6 +359,7 @@ method Maps() {
   print "items: ", items, "\n";
 
   TestMapMergeSubtraction();
+  TestMapMultiOccurrences();
 }
 
 method TestMapMergeSubtraction() {
@@ -479,6 +480,17 @@ method TestNullsAmongValues() {
   print r[0].name, " ", r[198].name, " ", 20 in r, "\n";  // ronald ronald false
 }
 
+method TestMapMultiOccurrences() {
+  var a := map[1 := 1, 1 := 2];
+  assert |a| == 1;
+  // The semantics are the last value wins
+  assert a[1] == 2;
+  print "Map multiple occurrences test", "\n";
+  print "  length: ", |a|, "\n";
+  print "  self-equal: ", a == a, "\n";
+  print "  select: ", a[1], "\n";
+}
+
 // -------------------------------------------------------------------------------------------
 
 method MultiSetForming() {
diff --git a/Test/comp/Collections.dfy.expect b/Test/comp/Collections.dfy.expect
index e705d887a7d..7c0fbb1b828 100644
--- a/Test/comp/Collections.dfy.expect
+++ b/Test/comp/Collections.dfy.expect
@@ -100,6 +100,10 @@ true true true false
 jack wendy null
 jack null null
 ronald ronald false
+Map multiple occurrences test
+  length: 1
+  self-equal: true
+  select: 2
 2: 0 1 1
 3: 0 1 2
 There are 0 occurrences of 58 in the multiset
diff --git a/Test/comp/Collections.dfy.go.expect b/Test/comp/Collections.dfy.go.expect
index 309d0c550c4..19be6351e0d 100644
--- a/Test/comp/Collections.dfy.go.expect
+++ b/Test/comp/Collections.dfy.go.expect
@@ -100,6 +100,10 @@ true true true false
 jack wendy null
 jack null null
 ronald ronald false
+Map multiple occurrences test
+  length: 1
+  self-equal: true
+  select: 2
 2: 0 1 1
 3: 0 1 2
 There are 0 occurrences of 58 in the multiset
diff --git a/Test/comp/Collections.dfy.java.expect b/Test/comp/Collections.dfy.java.expect
index ed929a4d34c..60f096fe133 100644
--- a/Test/comp/Collections.dfy.java.expect
+++ b/Test/comp/Collections.dfy.java.expect
@@ -100,6 +100,10 @@ true true true false
 jack wendy null
 jack null null
 ronald ronald false
+Map multiple occurrences test
+  length: 1
+  self-equal: true
+  select: 2
 2: 0 1 1
 3: 0 1 2
 There are 0 occurrences of 58 in the multiset
diff --git a/Test/comp/Collections.dfy.js.expect b/Test/comp/Collections.dfy.js.expect
index 309d0c550c4..19be6351e0d 100644
--- a/Test/comp/Collections.dfy.js.expect
+++ b/Test/comp/Collections.dfy.js.expect
@@ -100,6 +100,10 @@ true true true false
 jack wendy null
 jack null null
 ronald ronald false
+Map multiple occurrences test
+  length: 1
+  self-equal: true
+  select: 2
 2: 0 1 1
 3: 0 1 2
 There are 0 occurrences of 58 in the multiset
diff --git a/Test/comp/Collections.dfy.py.expect b/Test/comp/Collections.dfy.py.expect
index 61b4217bbaf..a8cb6f4eb53 100644
--- a/Test/comp/Collections.dfy.py.expect
+++ b/Test/comp/Collections.dfy.py.expect
@@ -100,6 +100,10 @@ true true true false
 jack wendy null
 jack null null
 ronald ronald false
+Map multiple occurrences test
+  length: 1
+  self-equal: true
+  select: 2
 2: 0 1 1
 3: 0 1 2
 There are 0 occurrences of 58 in the multiset
diff --git a/Test/comp/SequenceConcatOptimization.dfy b/Test/comp/SequenceConcatOptimization.dfy
index f3034af606e..24ed6530f5c 100644
--- a/Test/comp/SequenceConcatOptimization.dfy
+++ b/Test/comp/SequenceConcatOptimization.dfy
@@ -2,6 +2,7 @@
 // RUN: %baredafny test --no-verify --target=cs %args   "%s" >> "%t"
 // RUN: %baredafny test --no-verify --target=java %args "%s" >> "%t"
 // RUN: %baredafny test --no-verify --target=go %args   "%s" >> "%t"
+// RUN: %baredafny test --no-verify --target=py %args   "%s" >> "%t"
 
 module SequenceConcatOptimization {
 
diff --git a/Test/dafny0/ModuleInsertionErrors.dfy.expect b/Test/dafny0/ModuleInsertionErrors.dfy.expect
index f4359d670a9..6a290d76296 100644
--- a/Test/dafny0/ModuleInsertionErrors.dfy.expect
+++ b/Test/dafny0/ModuleInsertionErrors.dfy.expect
@@ -1,4 +1,4 @@
-ModuleInsertionErrors.dfy(23,11): Error: Duplicate module name: B
-ModuleInsertionErrors.dfy(24,11): Error: Duplicate module name: N
-ModuleInsertionErrors.dfy(30,17): Error: Duplicate module name: O
+ModuleInsertionErrors.dfy(23,11): Error: Duplicate module name: B [Related location] ModuleInsertionErrors.dfy(21,11)
+ModuleInsertionErrors.dfy(24,11): Error: Duplicate module name: N [Related location] ModuleInsertionErrors.dfy(26,11)
+ModuleInsertionErrors.dfy(30,17): Error: Duplicate module name: O [Related location] ModuleInsertionErrors.dfy(29,17)
 3 resolution/type errors detected in ModuleInsertionErrors.dfy
diff --git a/Test/dafny0/Reads.dfy b/Test/dafny0/Reads.dfy
index e6ce5541096..4c802a348cb 100644
--- a/Test/dafny0/Reads.dfy
+++ b/Test/dafny0/Reads.dfy
@@ -100,7 +100,7 @@ class Cell { var data: int }
 // Test the benefits of the new reads checking for function checking
 
 ghost function ApplyToSet<X>(S: set<X>, f: X ~> X): set<X>
-  requires forall x :: x in S ==> f.reads(x) == {} && f.requires(x)
+  requires forall x :: x in S ==> f.requires(x) && f.reads(x) == {}
 {
   if S == {} then {} else
     var x :| x in S;
@@ -111,11 +111,11 @@ ghost function ApplyToSet_AltSignature0<X>(S: set<X>, f: X ~> X): set<X>
   requires forall x :: x in S ==> f.requires(x) && f.reads(x) == {}
 
 ghost function ApplyToSet_AltSignature1<X>(S: set<X>, f: X ~> X): set<X>
-  requires forall x :: x in S ==> f.reads(x) == {}
   requires forall x :: x in S ==> f.requires(x)
+  requires forall x :: x in S ==> f.reads(x) == {}
 
 ghost function ApplyToSet_AltSignature2<X>(S: set<X>, f: X ~> X): set<X>
-  requires (forall x :: x in S ==> f.reads(x) == {}) ==> forall x :: x in S ==> f.requires(x)
+  requires (forall x :: x in S ==> f.requires(x)) ==> forall x :: x in S ==> f.reads(x) == {}
   // (this precondition would not be good enough to check the body above)
 
 ghost function FunctionInQuantifier0(): int
@@ -125,10 +125,10 @@ ghost function FunctionInQuantifier1(): int
   requires exists f: int ~> int :: f.requires(10) && f(10) == 100  // error: insufficient reads
 
 ghost function FunctionInQuantifier2(): int
-  requires exists f: int ~> int :: f.reads(10) == {} && f.requires(10) && f(10) == 100
+  requires exists f: int ~> int :: f.requires(10) && f.reads(10) == {} && f(10) == 100
   ensures FunctionInQuantifier2() == 100
 {
-  var f: int ~> int :| f.reads(10) == {} && f.requires(10) && f(10) == 100;  // fine :) :)
+  var f: int ~> int :| f.requires(10) && f.reads(10) == {} && f(10) == 100;  // fine :) :)
   f(10)
 }
 
diff --git a/Test/dafny0/ReadsOnMethods.dfy b/Test/dafny0/ReadsOnMethods.dfy
index 4382fe44c48..c96c4d7c12d 100644
--- a/Test/dafny0/ReadsOnMethods.dfy
+++ b/Test/dafny0/ReadsOnMethods.dfy
@@ -117,7 +117,7 @@ class Cell { var data: int }
 // Test the benefits of the new reads checking for function checking
 
 ghost method ApplyToSet<X>(S: set<X>, f: X ~> X) returns (r: set<X>)
-  requires forall x :: x in S ==> f.reads(x) == {} && f.requires(x)
+  requires forall x :: x in S ==> f.requires(x) && f.reads(x) == {}
   reads {}
 {
   if S == {} {
@@ -134,12 +134,12 @@ ghost method ApplyToSet_AltSignature0<X>(S: set<X>, f: X ~> X) returns (r: set<X
   reads {}
 
 ghost method ApplyToSet_AltSignature1<X>(S: set<X>, f: X ~> X) returns (r: set<X>)
-  requires forall x :: x in S ==> f.reads(x) == {}
   requires forall x :: x in S ==> f.requires(x)
+  requires forall x :: x in S ==> f.reads(x) == {}
   reads {}
 
 ghost method ApplyToSet_AltSignature2<X>(S: set<X>, f: X ~> X) returns (r: set<X>)
-  requires (forall x :: x in S ==> f.reads(x) == {}) ==> forall x :: x in S ==> f.requires(x)
+  requires (forall x :: x in S ==> f.requires(x) && f.reads(x) == {}) ==> forall x :: x in S ==> f.requires(x)
   // (this precondition would not be good enough to check the body above)
   reads {}
 
@@ -152,14 +152,14 @@ ghost method FunctionInQuantifier1() returns (r: int)
   reads {}
 
 ghost method FunctionInQuantifier2() returns (r: int)
-  requires exists f: int ~> int :: f.reads(10) == {} && f.requires(10) && f(10) == 100
+  requires exists f: int ~> int :: f.requires(10) && f.reads(10) == {} && f(10) == 100
   reads {}
   ensures r == 100
 {
   // Unlike the ghost function version, f.reads(10) is flagged because we aren't delaying reads checks on method bodies.
   // It's still an open question whether we should be though: https://github.com/dafny-lang/dafny/issues/4489.
   // For now this is at least only a completeness issue.
-  var f: int ~> int :| f.reads(10) == {} && f.requires(10) && f(10) == 100;  // error: insufficient reads
+  var f: int ~> int :| f.requires(10) && f.reads(10) == {} && f(10) == 100;  // error: insufficient reads
   return f(10);
 }
 
diff --git a/Test/dafny0/ReadsOnMethods.dfy.expect b/Test/dafny0/ReadsOnMethods.dfy.expect
index 589f533c82f..1fb19a5f17e 100644
--- a/Test/dafny0/ReadsOnMethods.dfy.expect
+++ b/Test/dafny0/ReadsOnMethods.dfy.expect
@@ -9,6 +9,7 @@ ReadsOnMethods.dfy(147,35): Error: function precondition could not be proved
 ReadsOnMethods.dfy(147,35): Error: insufficient reads clause to invoke function
 ReadsOnMethods.dfy(151,37): Error: insufficient reads clause to invoke function
 ReadsOnMethods.dfy(162,25): Error: insufficient reads clause to invoke function
+ReadsOnMethods.dfy(162,43): Error: insufficient reads clause to invoke function
 ReadsOnMethods.dfy(245,9): Error: insufficient reads clause to read field
 ReadsOnMethods.dfy(304,33): Error: insufficient reads clause to read field
 ReadsOnMethods.dfy(308,22): Error: insufficient reads clause to invoke function
@@ -33,4 +34,4 @@ ReadsOnMethods.dfy(172,19): Error: insufficient reads clause to read field
 ReadsOnMethods.dfy(183,25): Error: insufficient reads clause to read field
 ReadsOnMethods.dfy(469,9): Error: method might read an object not in the parent trait context's reads clause
 
-Dafny program verifier finished with 64 verified, 31 errors
+Dafny program verifier finished with 64 verified, 32 errors
diff --git a/Test/dafny4/ExpandedGuardedness.dfy b/Test/dafny4/ExpandedGuardedness.dfy
index b0b244d9ce9..7f160b25425 100644
--- a/Test/dafny4/ExpandedGuardedness.dfy
+++ b/Test/dafny4/ExpandedGuardedness.dfy
@@ -141,7 +141,7 @@ function OnlyDs(): Lang<char>
 greatest predicate TotalLang<S(!new)>(l: Lang<S>)
   reads *
 {
-  forall s: S :: l.deriv.reads(s) == {} && l.deriv.requires(s) && TotalLang(l.deriv(s))
+  forall s: S :: l.deriv.requires(s) && l.deriv.reads(s) == {} && TotalLang(l.deriv(s))
 }
 
 greatest lemma NothingTotal<S>()
@@ -159,7 +159,7 @@ greatest lemma OnlyDsTotal()
 greatest predicate TotalLang_Nat<S(!new)>[nat](l: Lang<S>)
   reads *
 {
-  forall s: S :: l.deriv.reads(s) == {} && l.deriv.requires(s) && TotalLang_Nat(l.deriv(s))
+  forall s: S :: l.deriv.requires(s) && l.deriv.reads(s) == {} && TotalLang_Nat(l.deriv(s))
 }
 
 greatest lemma NothingTotal_Nat<S>[nat]()
diff --git a/Test/git-issues/git-issue-478-errors.dfy.expect b/Test/git-issues/git-issue-478-errors.dfy.expect
index c529c695867..94969c68de1 100644
--- a/Test/git-issues/git-issue-478-errors.dfy.expect
+++ b/Test/git-issues/git-issue-478-errors.dfy.expect
@@ -1,6 +1,6 @@
 git-issue-478-errors.dfy(22,9): Error: Import declaration uses same name as a module in the same scope: LibW
 git-issue-478-errors.dfy(26,9): Error: Import declaration uses same name as a module in the same scope: LibX
-git-issue-478-errors.dfy(36,7): Error: Duplicate module name: M
+git-issue-478-errors.dfy(36,7): Error: Duplicate module name: M [Related location] git-issue-478-errors.dfy(35,7)
 git-issue-478-errors.dfy(7,7): Error: Import declaration uses same name as a module in the same scope: LibA
 git-issue-478-errors.dfy(11,7): Error: Import declaration uses same name as a module in the same scope: LibB
 git-issue-478-errors.dfy(37,7): Error: Import declaration uses same name as a module in the same scope: M
diff --git a/Test/hofs/Classes.dfy.expect b/Test/hofs/Classes.dfy.expect
index dcc2131f017..4a5288babd8 100644
--- a/Test/hofs/Classes.dfy.expect
+++ b/Test/hofs/Classes.dfy.expect
@@ -1,4 +1,4 @@
-Classes.dfy(38,5): Error: function precondition could not be proved
+Classes.dfy(33,12): Error: function precondition could not be proved
 Classes.dfy(60,11): Error: assertion might not hold
 
 Dafny program verifier finished with 4 verified, 2 errors
diff --git a/Test/hofs/Examples.dfy b/Test/hofs/Examples.dfy
deleted file mode 100644
index 4f55a0ac231..00000000000
--- a/Test/hofs/Examples.dfy
+++ /dev/null
@@ -1,57 +0,0 @@
-// RUN: %testDafnyForEachCompiler "%s" --refresh-exit-code=0 -- --relax-definite-assignment
-
-function Apply<A,B>(f: A ~> B, x: A): B
-  reads f.reads(x)
-  requires f.requires(x)
-{
-  f(x)
-}
-
-function Apply'<A,B>(f: A ~> B) : A ~> B
-{
-  x reads f.reads(x)
-    requires f.requires(x)
-    => f(x)
-}
-
-
-function Compose<A,B,C>(f: B ~> C, g:A ~> B): A ~> C
-{
-  x reads g.reads(x)
-    reads if g.requires(x) then f.reads(g(x)) else {}
-    requires g.requires(x)
-    requires f.requires(g(x))
-    => f(g(x))
-}
-
-function W<A>(f : (A,A) ~> A): A ~> A
-{
-  x requires f.requires(x,x)
-    reads f.reads(x,x)
-    => f(x,x)
-}
-
-function Curry<A,B,C>(f : (A,B) ~> C) : A ~> B ~> C
-{
-  x => y requires f.requires(x,y)
-         reads f.reads(x,y)
-         => f(x,y)
-}
-
-function Uncurry<A,B,C>(f : A ~> B ~> C) : (A,B) ~> C
-{
-  (x,y) requires f.requires(x)
-        requires f(x).requires(y)
-        reads f.reads(x)
-        reads if f.requires(x) then f(x).reads(y) else {}
-        => f(x)(y)
-}
-
-function S<A,B,C>(f : (A,B) ~> C, g : A ~> B): A ~> C
-{
-  x requires g.requires(x)
-    requires f.requires(x,g(x))
-    reads g.reads(x)
-    reads if g.requires(x) then f.reads(x,g(x)) else {}
-    => f(x,g(x))
-}
diff --git a/Test/hofs/Examples.dfy.expect b/Test/hofs/Examples.dfy.expect
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/Test/hofs/Frame.dfy.expect b/Test/hofs/Frame.dfy.expect
index 587a3d970a8..b39a812b6bf 100644
--- a/Test/hofs/Frame.dfy.expect
+++ b/Test/hofs/Frame.dfy.expect
@@ -3,7 +3,7 @@ Frame.dfy(37,13): Error: assertion might not hold
 Frame.dfy(63,22): Error: assertion might not hold
 Frame.dfy(66,18): Error: insufficient reads clause to read array element
 Frame.dfy(68,27): Error: insufficient reads clause to read array element
-Frame.dfy(123,13): Error: function precondition could not be proved
+Frame.dfy(120,17): Error: function precondition could not be proved
 Frame.dfy(123,18): Error: assertion might not hold
 
-Dafny program verifier finished with 5 verified, 7 errors
+Dafny program verifier finished with 6 verified, 7 errors
diff --git a/Test/hofs/ReadsReads.dfy.expect b/Test/hofs/ReadsReads.dfy.expect
index ddb24b86757..f693ae18112 100644
--- a/Test/hofs/ReadsReads.dfy.expect
+++ b/Test/hofs/ReadsReads.dfy.expect
@@ -1,6 +1,8 @@
+ReadsReads.dfy(35,6): Error: function precondition could not be proved
 ReadsReads.dfy(35,6): Error: insufficient reads clause to invoke function
 ReadsReads.dfy(40,4): Error: function precondition could not be proved
 ReadsReads.dfy(40,4): Error: insufficient reads clause to invoke function
+ReadsReads.dfy(52,11): Error: function precondition could not be proved
 ReadsReads.dfy(52,11): Error: insufficient reads clause to invoke function
 ReadsReads.dfy(64,6): Error: insufficient reads clause to invoke function
 ReadsReads.dfy(93,49): Error: assertion might not hold
@@ -16,4 +18,4 @@ ReadsReads.dfy(252,13): Error: assertion might not hold
 ReadsReads.dfy(262,13): Error: assertion might not hold
 ReadsReads.dfy(272,13): Error: assertion might not hold
 
-Dafny program verifier finished with 16 verified, 17 errors
+Dafny program verifier finished with 16 verified, 19 errors
diff --git a/Test/hofs/ReadsReadsOnMethods.dfy b/Test/hofs/ReadsReadsOnMethods.dfy
index b0733b1206e..9fdad7482e8 100644
--- a/Test/hofs/ReadsReadsOnMethods.dfy
+++ b/Test/hofs/ReadsReadsOnMethods.dfy
@@ -5,7 +5,7 @@
 
 module ReadsRequiresReads {
   ghost method MyReadsOk<A,B>(f : A ~> B, a : A) returns (r: set<object?>)
-    reads f.reads(a)
+    requires f.requires(a) reads f.reads(a)
   {
     r := f.reads(a);
   }
@@ -44,7 +44,7 @@ module ReadsRequiresReads {
   }
 
   ghost method MyReadsOk'<A,B>(f : A ~> B, a : A, o : object) returns (r: bool)
-    reads f.reads(a)
+    requires f.requires(a) reads f.reads(a)
   {
     r := o in f.reads(a);
   }
@@ -56,7 +56,7 @@ module ReadsRequiresReads {
   }
 
   ghost method MyRequiresOk<A,B>(f : A ~> B, a : A) returns (r: bool)
-    reads f.reads(a)
+    requires f.requires(a) reads f.reads(a)
   {
     r := f.requires(a);
   }
diff --git a/Test/hofs/ReadsReadsOnMethods.dfy.expect b/Test/hofs/ReadsReadsOnMethods.dfy.expect
index 9bd29e8dc46..3fc0c239b47 100644
--- a/Test/hofs/ReadsReadsOnMethods.dfy.expect
+++ b/Test/hofs/ReadsReadsOnMethods.dfy.expect
@@ -1,7 +1,9 @@
+ReadsReadsOnMethods.dfy(37,11): Error: function precondition could not be proved
 ReadsReadsOnMethods.dfy(37,11): Error: insufficient reads clause to invoke function
 ReadsReadsOnMethods.dfy(43,9): Error: function precondition could not be proved
 ReadsReadsOnMethods.dfy(43,9): Error: insufficient reads clause to invoke function
+ReadsReadsOnMethods.dfy(55,16): Error: function precondition could not be proved
 ReadsReadsOnMethods.dfy(55,16): Error: insufficient reads clause to invoke function
 ReadsReadsOnMethods.dfy(67,11): Error: insufficient reads clause to invoke function
 
-Dafny program verifier finished with 20 verified, 5 errors
+Dafny program verifier finished with 20 verified, 7 errors
diff --git a/Test/hofs/TreeMapSimple.dfy b/Test/hofs/TreeMapSimple.dfy
index b7baf6eb8d7..a7f6538e948 100644
--- a/Test/hofs/TreeMapSimple.dfy
+++ b/Test/hofs/TreeMapSimple.dfy
@@ -2,7 +2,6 @@
 
 method Main() {
   TestY();
-  TestZ();
 }
 
 datatype List<A> = Nil | Cons(head: A, tail: List<A>)
@@ -53,41 +52,3 @@ method TestY() {
   assert t == Branch(100, Cons(Branch(50, Nil), Nil));  // proved via Lit axioms
   print t, "\n";
 }
-
-// ---------- Read-effect functions ----------
-
-ghost predicate PreZ<A,B>(f: A ~> B, s: set<A>)
-  reads set x, y | x in s && y in f.reads(x) :: y
-{
-  forall x :: x in s ==> f.requires(x)
-}
-
-function MapZ<A,B>(xs: List<A>, f: A ~> B): List<B>
-  requires PreZ(f, ListData(xs))
-  reads PreZ.reads(f, ListData(xs))
-  decreases xs
-{
-  match xs
-  case Nil => Nil
-  case Cons(x, xs) => Cons(f(x), MapZ(xs, f))
-}
-
-function TreeMapZ<A,B>(t0: Tree<A>, f: A ~> B): Tree<B>
-  requires PreZ(f, TreeData(t0))
-  reads PreZ.reads(f, TreeData(t0))
-  decreases t0
-{
-  var Branch(x, ts) := t0;
-  var g := t requires t in ListData(ts) && PreZ(f, TreeData(t))
-            reads set x, y | x in TreeData(t) && y in f.reads(x) :: y
-           => TreeMapZ(t, f);
-  Branch(f(x), MapZ(ts, g))
-}
-
-method TestZ() {
-  var f := x requires x != 0 => 100 / x;
-  var t := TreeMapZ(Branch(1, Cons(Branch(2, Nil), Nil)), f);
-  // Functions with reads clauses don't get Lit axioms, so we can't prove the same
-  // assertion as we did in TestY.
-  print t, "\n";
-}
diff --git a/Test/hofs/TreeMapSimple.dfy.expect b/Test/hofs/TreeMapSimple.dfy.expect
index be0317f1016..facb9253f07 100644
--- a/Test/hofs/TreeMapSimple.dfy.expect
+++ b/Test/hofs/TreeMapSimple.dfy.expect
@@ -1,2 +1 @@
 Tree.Branch(100, List.Cons(Tree.Branch(50, List.Nil), List.Nil))
-Tree.Branch(100, List.Cons(Tree.Branch(50, List.Nil), List.Nil))
diff --git a/Test/hofs/Twice.dfy b/Test/hofs/Twice.dfy
deleted file mode 100644
index 75e095eb371..00000000000
--- a/Test/hofs/Twice.dfy
+++ /dev/null
@@ -1,37 +0,0 @@
-// RUN: %exits-with 4 %dafny /print:"%t.print" "%s" > "%t"
-// RUN: %diff "%s.expect" "%t"
-
-function Twice<A>(f : A ~> A): A ~> A
-{
-  x requires f.requires(x) && f.requires(f(x))
-    reads f.reads(x), if f.requires(x) then f.reads(f(x)) else {}
-  => f(f(x))
-}
-
-method Simple() {
-  assert Twice(x => x + 1)(0) == 2;
-  assert Twice(Twice(x => x + 1))(0) == 4;
-
-  assert Twice(Twice)(x => x + 1)(0) == 4;
-  assert Twice(Twice)(Twice)(x => x + 1)(0) == 16;
-}
-
-method WithReads() {
-  var a : array<int> := new int[1];
-  a[0] := 1;
-  var f := x reads a => x + a[0];
-  assert Twice(f)(0) == 2;
-  a[0] := 2;
-  assert Twice(f)(0) == 4;
-  assert Twice(f)(0) == 2; // should fail
-  assert false;            // should fail
-}
-
-
-function Twice_bad<A>(f : A ~> A): A ~> A
-{
-  x requires f.requires(x) && f.requires(f(x))
-    reads f.reads(x) + f.reads(f(x))
-  => f(f(x))
-}
-
diff --git a/Test/hofs/Twice.dfy.expect b/Test/hofs/Twice.dfy.expect
deleted file mode 100644
index 1e3250c6dd0..00000000000
--- a/Test/hofs/Twice.dfy.expect
+++ /dev/null
@@ -1,4 +0,0 @@
-Twice.dfy(26,21): Error: assertion might not hold
-Twice.dfy(34,31): Error: function precondition could not be proved
-
-Dafny program verifier finished with 2 verified, 2 errors
diff --git a/Test/hofs/VectorUpdate.dfy b/Test/hofs/VectorUpdate.dfy
index ab906838312..071b9eb9df1 100644
--- a/Test/hofs/VectorUpdate.dfy
+++ b/Test/hofs/VectorUpdate.dfy
@@ -24,7 +24,7 @@ method VectorUpdate<A>(N: int, a : array<A>, f : (int,A) ~> A)
 
 // here's a shorter version of the method above
 method VectorUpdate'<A>(a : array<A>, f : (int,A) ~> A)
-  requires forall j :: 0 <= j < a.Length ==> a !in f.reads(j,a[j]) && f.requires(j,a[j])
+  requires forall j :: 0 <= j < a.Length ==> f.requires(j,a[j]) && a !in f.reads(j,a[j])
   modifies a
   ensures forall j :: 0 <= j < a.Length ==> a[j] == f(j,old(a[j]))
 {
@@ -41,7 +41,7 @@ method VectorUpdate'<A>(a : array<A>, f : (int,A) ~> A)
 
 // here's yet another version
 method VectorUpdate''<A>(a : array<A>, f : (int,A) ~> A)
-  requires forall j :: 0 <= j < a.Length ==> a !in f.reads(j,a[j]) && f.requires(j,a[j])
+  requires forall j :: 0 <= j < a.Length ==> f.requires(j,a[j]) && a !in f.reads(j,a[j])
   modifies a
   ensures forall j :: 0 <= j < a.Length ==> a[j] == f(j,old(a[j]))
 {
diff --git a/Test/unicodechars/comp/Collections.dfy.expect b/Test/unicodechars/comp/Collections.dfy.expect
index 89f08b08d75..a896b0d701f 100644
--- a/Test/unicodechars/comp/Collections.dfy.expect
+++ b/Test/unicodechars/comp/Collections.dfy.expect
@@ -100,6 +100,10 @@ true true true false
 jack wendy null
 jack null null
 ronald ronald false
+Map multiple occurrences test
+  length: 1
+  self-equal: true
+  select: 2
 2: 0 1 1
 3: 0 1 2
 There are 0 occurrences of 58 in the multiset
diff --git a/Test/unicodechars/comp/Collections.dfy.go.expect b/Test/unicodechars/comp/Collections.dfy.go.expect
index 2fc0f3b7093..7c5ae68b60f 100644
--- a/Test/unicodechars/comp/Collections.dfy.go.expect
+++ b/Test/unicodechars/comp/Collections.dfy.go.expect
@@ -100,6 +100,10 @@ true true true false
 jack wendy null
 jack null null
 ronald ronald false
+Map multiple occurrences test
+  length: 1
+  self-equal: true
+  select: 2
 2: 0 1 1
 3: 0 1 2
 There are 0 occurrences of 58 in the multiset
diff --git a/Test/unicodechars/comp/Collections.dfy.java.expect b/Test/unicodechars/comp/Collections.dfy.java.expect
index 39975cadfc4..7b9a3bf1e51 100644
--- a/Test/unicodechars/comp/Collections.dfy.java.expect
+++ b/Test/unicodechars/comp/Collections.dfy.java.expect
@@ -100,6 +100,10 @@ true true true false
 jack wendy null
 jack null null
 ronald ronald false
+Map multiple occurrences test
+  length: 1
+  self-equal: true
+  select: 2
 2: 0 1 1
 3: 0 1 2
 There are 0 occurrences of 58 in the multiset
diff --git a/Test/unicodechars/comp/Collections.dfy.js.expect b/Test/unicodechars/comp/Collections.dfy.js.expect
index 2fc0f3b7093..7c5ae68b60f 100644
--- a/Test/unicodechars/comp/Collections.dfy.js.expect
+++ b/Test/unicodechars/comp/Collections.dfy.js.expect
@@ -100,6 +100,10 @@ true true true false
 jack wendy null
 jack null null
 ronald ronald false
+Map multiple occurrences test
+  length: 1
+  self-equal: true
+  select: 2
 2: 0 1 1
 3: 0 1 2
 There are 0 occurrences of 58 in the multiset
diff --git a/Test/unicodechars/comp/Collections.dfy.py.expect b/Test/unicodechars/comp/Collections.dfy.py.expect
index e4e346dede0..b68ff60874b 100644
--- a/Test/unicodechars/comp/Collections.dfy.py.expect
+++ b/Test/unicodechars/comp/Collections.dfy.py.expect
@@ -100,6 +100,10 @@ true true true false
 jack wendy null
 jack null null
 ronald ronald false
+Map multiple occurrences test
+  length: 1
+  self-equal: true
+  select: 2
 2: 0 1 1
 3: 0 1 2
 There are 0 occurrences of 58 in the multiset
diff --git a/docs/DafnyRef/Attributes.md b/docs/DafnyRef/Attributes.md
index 15ea2351031..e3ba35efdc9 100644
--- a/docs/DafnyRef/Attributes.md
+++ b/docs/DafnyRef/Attributes.md
@@ -243,7 +243,7 @@ without proof. In that case also the body of the function or
 method may be omitted.
 
 The `{:axiom}` attribute only prevents Dafny from verifying that the body matches the post-condition.
-Dafny still verifies the well-formedness of pre-conditions, of post-conditions, and of the body if provided.
+Dafny still verifies the [well-formedness](#sec-assertion-batches) of pre-conditions, of post-conditions, and of the body if provided.
 To prevent Dafny from running all these checks, one would use [`{:verify false}`](#sec-verify), which is not recommended.
 
 The compiler will still emit code for an [`{:axiom}`](#sec-axiom), if it is a [`function`, a `method` or a `function by method`](#sec-function-declarations) with a body.
@@ -515,7 +515,7 @@ By default, the body of a function is transparent to its users. This can be over
 ### 11.2.21. `{:verify false}` {#sec-verify}
      
 Skip verification of a function or a method altogether,
-not even trying to verify the well-formedness of postconditions and preconditions.
+not even trying to verify the [well-formedness](#sec-assertion-batches) of postconditions and preconditions.
 We discourage using this attribute and prefer [`{:axiom}`](#sec-axiom),
 which performs these minimal checks while not checking that the body satisfies the postconditions.
 
diff --git a/docs/DafnyRef/Expressions.md b/docs/DafnyRef/Expressions.md
index 2c99df21b7a..35827e5ac70 100644
--- a/docs/DafnyRef/Expressions.md
+++ b/docs/DafnyRef/Expressions.md
@@ -459,7 +459,7 @@ The _specification_ is a list of clauses `requires E` or
 expression.
 
 _body_ is an expression that defines the function's return
-value.  The body must be well-formed for all possible values of the
+value.  The body must be [well-formed](#sec-assertion-batches) for all possible values of the
 parameters that satisfy the precondition (just like the bodies of
 named functions and methods).  In some cases, this means it is
 necessary to write explicit `requires` and `reads` clauses.  For
@@ -468,7 +468,7 @@ example, the lambda expression
 ```dafny
 x requires x != 0 => 100 / x
 ```
-would not be well-formed if the `requires` clause were omitted,
+would not be [well-formed](#sec-assertion-batches) if the `requires` clause were omitted,
 because of the possibility of division-by-zero.
 
 In settings where functions cannot be partial and there are no
diff --git a/docs/DafnyRef/Grammar.md b/docs/DafnyRef/Grammar.md
index 5c086ddae13..826110a5362 100644
--- a/docs/DafnyRef/Grammar.md
+++ b/docs/DafnyRef/Grammar.md
@@ -511,7 +511,7 @@ may also include any of three optional elements:
 
 Note that a variable's domain expression may reference any variable declared before it,
 and a variable's range expression may reference the attached variable (and usually does) and any variable declared before it.
-For example, in the quantifier domain `i | 0 <= i < |s|, y <- s[i] | i < y`, the expression `s[i]` is well-formed
+For example, in the quantifier domain `i | 0 <= i < |s|, y <- s[i] | i < y`, the expression `s[i]` is always [well-formed](#sec-assertion-batches)
 because the range attached to `i` ensures `i` is a valid index in the sequence `s`.
 
 Allowing per-variable ranges is not fully backwards compatible, and so it is not yet allowed by default;
diff --git a/docs/DafnyRef/Specifications.md b/docs/DafnyRef/Specifications.md
index 3e07a9096e0..39cafc0c5b7 100644
--- a/docs/DafnyRef/Specifications.md
+++ b/docs/DafnyRef/Specifications.md
@@ -886,3 +886,70 @@ add:
    requires Valid()
    reads Repr
 ```
+
+## 7.8. Well-formedness of specifications {#sec-well-formedness-specifications}
+
+Dafny ensures that the [`requires` clauses](#sec-requires-clause)
+and [`ensures` clauses](#sec-ensures-clause), which are expressions,
+are [well-formed](#sec-assertion-batches) independent of the body
+they belong to.
+Examples of conditions this rules out are null pointer dereferencing,
+out-of-bounds array access, and division by zero.
+Hence, when declaring the following method:
+
+<!-- %check-verify -->
+```dafny
+method Test(a: array<int>) returns (j: int)
+  requires a.Length >= 1
+  ensures a.Length % 2 == 0 ==> j >= 10 / a.Length
+{
+  j := 20;
+  var divisor := a.Length;
+  if divisor % 2 == 0 {
+    j := j / divisor;
+  }
+}
+```
+
+Dafny will split the verification in two [assertion batches](#sec-assertion-batches)
+that will roughly look like the following lemmas:
+
+<!-- %check-verify -->
+```dafny
+lemma Test_WellFormed(a: array?<int>)
+{
+  assume a != null;       // From the definition of a
+  assert a != null;       // for the `requires a.Length >= 1`
+  assume a.Length >= 1;   // After well-formedness, we assume the requires
+  assert a != null;       // Again for the `a.Length % 2`
+  if a.Length % 2 == 0 {
+    assert a != null;     // Again for the final `a.Length`
+    assert a.Length != 0; // Because of the 10 / a.Length
+  }
+}
+
+method Test_Correctness(a: array?<int>)
+{ // Here we assume the well-formedness of the condition
+  assume a != null;       // for the `requires a.Length >= 1`
+  assume a != null;       // Again for the `a.Length % 2`
+  if a.Length % 2 == 0 {
+    assume a != null;     // Again for the final `a.Length`
+    assume a.Length != 0; // Because of the 10 / a.Length
+  }
+
+  // Now the body is translated
+  var j := 20;
+  assert a != null;          // For `var divisor := a.Length;`
+  var divisor := a.Length;
+  if * {
+    assume divisor % 2 == 0;
+    assert divisor != 0;
+    j := j / divisor;
+  }
+  assume divisor % 2 == 0 ==> divisor != 0;
+  assert a.Length % 2 == 0 ==> j >= 10 / a.Length;
+}
+```
+
+For this reason the IDE typically reports at least two [assertion batches](#sec-assertion-batches)
+when hovering a method.
diff --git a/docs/DafnyRef/Statements.md b/docs/DafnyRef/Statements.md
index 3f363c2ec37..667c02372d8 100644
--- a/docs/DafnyRef/Statements.md
+++ b/docs/DafnyRef/Statements.md
@@ -1643,7 +1643,7 @@ the loop needs to be declared either with `invariant c.data == 100` or with
 When a loop has an explicit `modifies` clause, there is, at the top of
 every iteration, a proof obligation that
 
-* the expressions given in the `modifies` clause are well-formed, and
+* the expressions given in the `modifies` clause are [well-formed](#sec-assertion-batches), and
 * everything indicated in the loop `modifies` clause is allowed to be modified by the
   (effective `modifies` clause of the) enclosing loop or method.
 
diff --git a/docs/DafnyRef/Types.md b/docs/DafnyRef/Types.md
index 09e6a537bd2..f11d16f9c90 100644
--- a/docs/DafnyRef/Types.md
+++ b/docs/DafnyRef/Types.md
@@ -181,7 +181,7 @@ C <== B <== A
 To illustrate the short-circuiting rules, note that the expression
 `a.Length` is defined for an array `a` only if `a` is not `null` (see
 [Section 5.1.2](#sec-reference-types)), which means the following two
-expressions are well-formed:
+expressions are [well-formed](#sec-assertion-batches):
 <!-- %no-check -->
 ```dafny
 a != null ==> 0 <= a.Length
@@ -193,9 +193,9 @@ The contrapositives of these two expressions would be:
 a.Length < 0 ==> a == null  // not well-formed
 a == null <== a.Length < 0  // not well-formed
 ```
-but these expressions are not well-formed, since well-formedness
+but these expressions might not necessarily be [well-formed](#sec-assertion-batches), since well-formedness
 requires the left (and right, respectively) operand, `a.Length < 0`,
-to be well-formed by itself.
+to be [well-formed](#sec-assertion-batches) in their context.
 
 Implication `A ==> B` is equivalent to the disjunction `!A || B`, but
 is sometimes (especially in specifications) clearer to read.  Since,
@@ -204,12 +204,12 @@ is sometimes (especially in specifications) clearer to read.  Since,
 ```dafny
 a == null || 0 <= a.Length
 ```
-is well-formed, whereas
+is [well-formed](#sec-assertion-batches) by itself, whereas
 <!-- %no-check -->
 ```dafny
 0 <= a.Length || a == null  // not well-formed
 ```
-is not.
+is not if the context cannot prove that `a != null`.
 
 In addition, booleans support _logical quantifiers_ (forall and
 exists), described in [Section 9.31.4](#sec-quantifier-expression).
@@ -2495,7 +2495,7 @@ matrix.Length0 == m && matrix.Length1 == n
 Higher-dimensional arrays are similar (`Length0`, `Length1`,
 `Length2`, ...).  The array selection expression and array update
 statement require that the indices are in bounds.  For example, the
-swap statement above is well-formed only if:
+swap statement above is [well-formed](#sec-assertion-batches) only if:
 <!-- %no-check -->
 ```dafny
 0 <= i < matrix.Length0 && 0 <= j < matrix.Length1 &&
@@ -3018,7 +3018,7 @@ Note that the expression
 ```dafny
 Cons(5, Nil).tail.head
 ```
-is not well-formed, since `Cons(5, Nil).tail` does not necessarily satisfy
+is not [well-formed](#sec-assertion-batches) by itself, since `Cons(5, Nil).tail` does not necessarily satisfy
 `Cons?`.
 
 A constructor can have the same name as
@@ -3596,7 +3596,7 @@ _TODO: Say more about the effect of this attribute and when it should be applied
 (and likely, correct the paragraph above)._
 
 
-# 6. Member declarations
+# 6. Member declarations {#sec-member-declaration}
 
 Members are the various kinds of methods, the various kinds of functions, mutable fields,
 and constant fields. These are usually associated with classes, but they also may be
@@ -4631,7 +4631,7 @@ both preceding and subsequent parameters, but there may not be any
 dependent cycle between the parameters and their default-value
 expressions.
 
-The well-formedness of default-value expressions is checked independent
+The [well-formedness](#sec-assertion-batches) of default-value expressions is checked independent
 of the precondition of the enclosing declaration. For a function, the
 parameter default-value expressions may only read what the function's
 `reads` clause allows. For a datatype constructor, parameter default-value
diff --git a/docs/DafnyRef/UserGuide.md b/docs/DafnyRef/UserGuide.md
index 4bdb665f58c..de1577504e4 100644
--- a/docs/DafnyRef/UserGuide.md
+++ b/docs/DafnyRef/UserGuide.md
@@ -1316,12 +1316,61 @@ method innerLoop()
 
 In the next section, when everything can be proven in a timely manner, we explain another strategy to decrease proof time by parallelizing it if needed, and making the verifier focus on certain parts.
 
-### 13.6.3. Assertion batches {#sec-assertion-batches}
+### 13.6.3. Assertion batches, well-formedness, correctness {#sec-assertion-batches}
 
 To understand how to control verification,
 it is first useful to understand how `dafny` verifies functions and methods.
 
-For every method (or function, constructor, etc.), `dafny` extracts _assertions_. Here is a non-exhaustive list of such extracted assertions:
+For every method (or function, constructor, etc.), `dafny` extracts _assertions_.
+Assertions can roughly be sorted into two kinds: Well-formedness and correctness.
+
+- _Well-formedness_ assertions: All the implicit requirements
+  of native operation calls (such as indexing and asserting that divisiors are nonzero),
+  [`requires` clauses](#sec-requires-clause) of function calls, explicit
+  [assertion expressions](#sec-statement-in-an-expression) and
+  [`decreases` clauses](#sec-decreases-clause) at function call sites
+  generate well-formedness assertions.  
+  An expression is said to be _well-formed_ in a context if
+  all well-formedness assertions can be proven in that context.
+
+- _Correctness_ assertions: All remaining assertions and clauses
+
+For example, given the following statements:
+
+<!-- %no-check -->
+```dafny
+if b {
+  assert a*a != 0;
+}
+c := (assert b ==> a != 0; if b then 3/a else f(a));
+assert c != 5/a;
+```
+
+Dafny performs the following checks:
+
+<!-- %no-check -->
+```dafny
+var c: int;
+if b {
+  assert a*a != 0;   // Correctness
+}
+assert b ==> a != 0; // Well-formedness
+if b {
+  assert a != 0;     // Well-formedness
+} else {
+  assert f.requires(a); // Well-formedness
+}
+c := if b then 3/a else f(a);
+assert a != 0;       // Well-formedness
+assert c != 5/a;     // Correctness
+```
+
+Well-formedness is proved at the same time as correctness, except for
+[well-formedness of requires and ensures clauses](#sec-well-formedness-specifications)
+which is proved separatedly from the well-formedness and correctness of the rest of the method/function.
+For the rest of this section, we don't diifferentiate between well-formedness assertions and correctness assertions.
+
+We can also classify the assertions extracted by Dafny in a few categories:
 
 **Integer assertions:**
 
@@ -1334,26 +1383,26 @@ For every method (or function, constructor, etc.), `dafny` extracts _assertions_
 
 * Every [object property access](#sec-class-types) yields an _assertion_ that the object is not null.
 * Every assignment `o.f := E;` yields an _assertion_ that `o` is among the set of objects of the `modifies` clause of the enclosing [loop](#sec-loop-framing) or [method](#sec-modifies-clause).
-* Every read `o.f` yields an _assertion_ that `o` is among the set of objects of the [`reads`](#sec-reads-clause) clause of the enclosing function or predicate; or the [`modifies`](#sec-modifies-clause) clause of the enclosing method.
+* Every read `o.f` yields an _assertion_ that `o` is among the set of objects of the [`reads`](#sec-reads-clause) clause of the enclosing function or predicate.
 * Every [array access](#sec-array-type) `a[x]` yields the assertion that `0 <= x < a.Length`.
 * Every [sequence access](#sec-sequences) `a[x]` yields an _assertion_, that `0 <= x < |a|`, because sequences are never null.
 * Every [datatype update expression](#sec-datatype-update-suffix) and [datatype destruction](#sec-algebraic-datatype) yields an _assertion_ that the object has the given property.
 * Every method overriding a [`trait`](#sec-trait-types) yields an _assertion_ that any postcondition it provides implies the postcondition of its parent trait, and an _assertion_ that any precondition it provides is implied by the precondition of its parent trait.
 
-**Other implicit assertions:**
+**Other assertions:**
 
 * Every value whose type is assigned to a [subset type](#sec-subset-types) yields an _assertion_ that it satisfies the subset type constraint.
 * Every non-empty [subset type](#sec-subset-types) yields an _assertion_ that its witness satisfies the constraint.
 * Every [Assign-such-that operator](#sec-update-and-call-statement) `x :| P(x)` yields an _assertion_ that `exists x :: P(x)`.
 * Every recursive function yields an _assertion_ that [it terminates](#sec-loop-termination).
 * Every [match expression](#sec-match-expression) or [alternative if statement](#sec-if-statement) yields an _assertion_ that all cases are covered.
+* Every call to a function or method with a [`requires`](#sec-requires-clause) clause yields _one assertion per requires clause_[^precision-requires-clause]
+  (special cases such as sequence indexing come with a special `requires` clause that the index is within bounds).
 
-**Explicit assertions:**
+**Specification assertions:**
 
 * Any explicit [`assert`](#sec-assert-statement) statement is _an assertion_[^precision-requires-clause].
 * A consecutive pair of lines in a [`calc`](#sec-calc-statement) statement forms _an assertion_ that the expressions are related according to the common operator.
-* Every call to a function or method with a [`requires`](#sec-requires-clause) clause yields _one assertion per requires clause_[^precision-requires-clause]
-  (special cases such as sequence indexing come with a special `requires` clause that the index is within bounds).
 * Every [`ensures`](#sec-ensures-clause) clause yields an _assertion_ at the end of the method and on every return, and on [`forall`](#sec-forall-statement) statements.
 * Every [`invariant`](#sec-invariant-clause) clause yields an _assertion_ that it holds before the loop and an _assertion_ that it holds at the end of the loop.
 * Every [`decreases`](#sec-decreases-clause) clause yields an _assertion_ at either a call site or at the end of a while loop.