15 files changed, 12420 insertions, 12404 deletions
diff --git a/Source/VCExpr/BigLiteralAbstracter.cs b/Source/VCExpr/BigLiteralAbstracter.cs
index 879ab6d6..39064fb7 100644
--- a/Source/VCExpr/BigLiteralAbstracter.cs
+++ b/Source/VCExpr/BigLiteralAbstracter.cs
@@ -1,232 +1,232 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-
-// Code for replacing large integer literals in VCExpr with
-// constants. This is necessary for Simplify, which cannot deal with
-// literals larger than 32 bits
-
-namespace Microsoft.Boogie.VCExprAST {
-
-  public class BigLiteralAbstracter : MutatingVCExprVisitor<bool>, ICloneable {
-
-    public BigLiteralAbstracter(VCExpressionGenerator gen)
-      : base(gen) {
-      Contract.Requires(gen != null);
-      DummyVar = gen.Variable("x", Type.Int);
-      IncAxioms = new List<VCExpr>();
-      Literals = new List<KeyValuePair<BigNum, VCExprVar>>();
-    }
-
-    private BigLiteralAbstracter(BigLiteralAbstracter abstracter)
-      : base(abstracter.Gen) {
-      Contract.Requires(abstracter != null);
-      DummyVar = abstracter.DummyVar;
-      IncAxioms = new List<VCExpr>(abstracter.IncAxioms);
-      Literals = new List<KeyValuePair<BigNum, VCExprVar>>(abstracter.Literals);
-    }
-
-    public Object Clone() {
-      Contract.Ensures(Contract.Result<Object>() != null);
-
-      return new BigLiteralAbstracter(this);
-    }
-
-    private static readonly BigNum ConstantDistance = BigNum.FromLong(100000);
-    private static readonly BigNum NegConstantDistance = BigNum.FromLong(-100000);
-    // distance twice plus one
-    private static readonly BigNum ConstantDistanceTPO = BigNum.FromLong(200001);
-    private static readonly BigNum ConstantDistancePO = BigNum.FromLong(100001);
-
-    public VCExpr Abstract(VCExpr expr) {
-      Contract.Requires(expr != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      return Mutate(expr, true);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    // list in which axioms are incrementally collected
-    private readonly List<VCExpr/*!*/>/*!*/ IncAxioms;
-
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(cce.NonNullElements(IncAxioms));
-    }
-
-    private void AddAxiom(VCExpr/*!*/ axiom) {
-      Contract.Requires(axiom != null);
-      IncAxioms.Add(axiom);
-    }
-
-    // Return all axioms that were added since the last time NewAxioms
-    // was called
-    public VCExpr GetNewAxioms() {
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExpr res = Gen.NAry(VCExpressionGenerator.AndOp, IncAxioms);
-      IncAxioms.Clear();
-      return res;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    // All named integer literals known to the visitor, in ascending
-    // order. Such literals are always positive, and the distance
-    // between two literals is always more than ConstantDistance.
-    private readonly List<KeyValuePair<BigNum, VCExprVar/*!*/>>/*!*/ Literals;
-
-    [ContractInvariantMethod]
-    void ObjectInvariat() {
-      Contract.Invariant(Literals != null);
-      Contract.Invariant(Contract.ForAll(Literals, i => i.Value != null));
-    }
-
-
-    private class EntryComparerC : IComparer<KeyValuePair<BigNum, VCExprVar/*!*/>> {
-      public int Compare(KeyValuePair<BigNum, VCExprVar/*!*/> a,
-                         KeyValuePair<BigNum, VCExprVar/*!*/> b) {
-        //Contract.Requires(a.Value!=null);
-        //Contract.Requires(b.Value!=null);
-        return a.Key.CompareTo(b.Key);
-      }
-    }
-
-    private static readonly EntryComparerC EntryComparer = new EntryComparerC();
-
-    // variable used when searching for entries in the literal list
-    private readonly VCExprVar/*!*/ DummyVar;
-    [ContractInvariantMethod]
-    void ObjectInvarint() {
-      Contract.Invariant(DummyVar != null);
-    }
-
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    // Construct an expression to represent the given (large) integer
-    // literal. Constants are defined and axiomatised if necessary
-    private VCExpr Represent(BigNum lit) {
-      Contract.Requires((NegConstantDistance > lit || lit > ConstantDistance));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      if (lit.IsNegative)
-        return Gen.Function(VCExpressionGenerator.SubIOp,
-                            Gen.Integer(BigNum.ZERO), RepresentPos(lit.Neg));
-      else
-        return RepresentPos(lit);
-    }
-
-    private VCExpr RepresentPos(BigNum lit) {
-      Contract.Requires((lit > ConstantDistance));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      int index = GetIndexFor(lit);
-      if (index >= 0)
-        // precise match
-        return Literals[index].Value;
-
-      // check whether a constant is defined that is at most
-      // ConstantDistance away from lit
-      index = ~index;
-      VCExpr res = null;
-      BigNum resDistance = ConstantDistancePO;
-
-      if (index > 0) {
-        BigNum dist = lit - Literals[index - 1].Key;
-        if (dist < resDistance) {
-          resDistance = dist;
-          res = Gen.Function(VCExpressionGenerator.AddIOp,
-                             Literals[index - 1].Value, Gen.Integer(dist));
-        }
-      }
-
-      if (index < Literals.Count) {
-        BigNum dist = Literals[index].Key - lit;
-        if (dist < resDistance) {
-          resDistance = dist;
-          res = Gen.Function(VCExpressionGenerator.SubIOp,
-                             Literals[index].Value, Gen.Integer(dist));
-        }
-      }
-
-      if (res != null)
-        return res;
-
-      // otherwise, define a new constant to represent this literal
-      return AddConstantFor(lit);
-    }
-
-    private VCExpr AddConstantFor(BigNum lit) {
-      Contract.Requires((lit > ConstantDistance));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      VCExprVar res = Gen.Variable("int#" + lit, Type.Int);
-      int index = GetIndexFor(lit);
-      Contract.Assert(index < 0);
-      index = ~index;
-
-      Literals.Insert(index, new KeyValuePair<BigNum, VCExprVar>(lit, res));
-
-      // relate the new constant to the predecessor and successor
-      if (index > 0)
-        DefineRelationship(Literals[index - 1].Value, Literals[index - 1].Key,
-                           res, lit);
-      else
-        DefineRelationship(Gen.Integer(BigNum.ZERO), BigNum.ZERO, res, lit);
-
-      if (index < Literals.Count - 1)
-        DefineRelationship(res, lit,
-                           Literals[index + 1].Value, Literals[index + 1].Key);
-
-      return res;
-    }
-
-    private void DefineRelationship(VCExpr/*!*/ aExpr, BigNum aValue,
-                                    VCExpr/*!*/ bExpr, BigNum bValue) {
-      Contract.Requires(aValue < bValue);
-      Contract.Requires(aExpr != null);
-      Contract.Requires(bExpr != null);
-
-      BigNum dist = bValue - aValue;
-      VCExpr distExpr = Gen.Function(VCExpressionGenerator.SubIOp, bExpr, aExpr);
-      if (dist <= ConstantDistanceTPO)
-        // constants that are sufficiently close to each other are put
-        // into a precise relationship
-        AddAxiom(Gen.Eq(distExpr, Gen.Integer(dist)));
-      else
-        AddAxiom(Gen.Function(VCExpressionGenerator.GtOp,
-                              distExpr, Gen.Integer(ConstantDistanceTPO)));
-    }
-
-    private int GetIndexFor(BigNum lit) {
-      return Literals.BinarySearch(new KeyValuePair<BigNum, VCExprVar>
-                                                   (lit, DummyVar),
-                                   EntryComparer);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public override VCExpr Visit(VCExprLiteral node, bool arg) {
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExprIntLit intLit = node as VCExprIntLit;
-      if (intLit != null) {
-        if (NegConstantDistance > intLit.Val || intLit.Val > ConstantDistance)
-          return Represent(intLit.Val);
-      }
-      return node;
-    }
-
-  }
-
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+
+// Code for replacing large integer literals in VCExpr with
+// constants. This is necessary for Simplify, which cannot deal with
+// literals larger than 32 bits
+
+namespace Microsoft.Boogie.VCExprAST {
+
+  public class BigLiteralAbstracter : MutatingVCExprVisitor<bool>, ICloneable {
+
+    public BigLiteralAbstracter(VCExpressionGenerator gen)
+      : base(gen) {
+      Contract.Requires(gen != null);
+      DummyVar = gen.Variable("x", Type.Int);
+      IncAxioms = new List<VCExpr>();
+      Literals = new List<KeyValuePair<BigNum, VCExprVar>>();
+    }
+
+    private BigLiteralAbstracter(BigLiteralAbstracter abstracter)
+      : base(abstracter.Gen) {
+      Contract.Requires(abstracter != null);
+      DummyVar = abstracter.DummyVar;
+      IncAxioms = new List<VCExpr>(abstracter.IncAxioms);
+      Literals = new List<KeyValuePair<BigNum, VCExprVar>>(abstracter.Literals);
+    }
+
+    public Object Clone() {
+      Contract.Ensures(Contract.Result<Object>() != null);
+
+      return new BigLiteralAbstracter(this);
+    }
+
+    private static readonly BigNum ConstantDistance = BigNum.FromLong(100000);
+    private static readonly BigNum NegConstantDistance = BigNum.FromLong(-100000);
+    // distance twice plus one
+    private static readonly BigNum ConstantDistanceTPO = BigNum.FromLong(200001);
+    private static readonly BigNum ConstantDistancePO = BigNum.FromLong(100001);
+
+    public VCExpr Abstract(VCExpr expr) {
+      Contract.Requires(expr != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      return Mutate(expr, true);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    // list in which axioms are incrementally collected
+    private readonly List<VCExpr/*!*/>/*!*/ IncAxioms;
+
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(cce.NonNullElements(IncAxioms));
+    }
+
+    private void AddAxiom(VCExpr/*!*/ axiom) {
+      Contract.Requires(axiom != null);
+      IncAxioms.Add(axiom);
+    }
+
+    // Return all axioms that were added since the last time NewAxioms
+    // was called
+    public VCExpr GetNewAxioms() {
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExpr res = Gen.NAry(VCExpressionGenerator.AndOp, IncAxioms);
+      IncAxioms.Clear();
+      return res;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    // All named integer literals known to the visitor, in ascending
+    // order. Such literals are always positive, and the distance
+    // between two literals is always more than ConstantDistance.
+    private readonly List<KeyValuePair<BigNum, VCExprVar/*!*/>>/*!*/ Literals;
+
+    [ContractInvariantMethod]
+    void ObjectInvariat() {
+      Contract.Invariant(Literals != null);
+      Contract.Invariant(Contract.ForAll(Literals, i => i.Value != null));
+    }
+
+
+    private class EntryComparerC : IComparer<KeyValuePair<BigNum, VCExprVar/*!*/>> {
+      public int Compare(KeyValuePair<BigNum, VCExprVar/*!*/> a,
+                         KeyValuePair<BigNum, VCExprVar/*!*/> b) {
+        //Contract.Requires(a.Value!=null);
+        //Contract.Requires(b.Value!=null);
+        return a.Key.CompareTo(b.Key);
+      }
+    }
+
+    private static readonly EntryComparerC EntryComparer = new EntryComparerC();
+
+    // variable used when searching for entries in the literal list
+    private readonly VCExprVar/*!*/ DummyVar;
+    [ContractInvariantMethod]
+    void ObjectInvarint() {
+      Contract.Invariant(DummyVar != null);
+    }
+
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    // Construct an expression to represent the given (large) integer
+    // literal. Constants are defined and axiomatised if necessary
+    private VCExpr Represent(BigNum lit) {
+      Contract.Requires((NegConstantDistance > lit || lit > ConstantDistance));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      if (lit.IsNegative)
+        return Gen.Function(VCExpressionGenerator.SubIOp,
+                            Gen.Integer(BigNum.ZERO), RepresentPos(lit.Neg));
+      else
+        return RepresentPos(lit);
+    }
+
+    private VCExpr RepresentPos(BigNum lit) {
+      Contract.Requires((lit > ConstantDistance));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      int index = GetIndexFor(lit);
+      if (index >= 0)
+        // precise match
+        return Literals[index].Value;
+
+      // check whether a constant is defined that is at most
+      // ConstantDistance away from lit
+      index = ~index;
+      VCExpr res = null;
+      BigNum resDistance = ConstantDistancePO;
+
+      if (index > 0) {
+        BigNum dist = lit - Literals[index - 1].Key;
+        if (dist < resDistance) {
+          resDistance = dist;
+          res = Gen.Function(VCExpressionGenerator.AddIOp,
+                             Literals[index - 1].Value, Gen.Integer(dist));
+        }
+      }
+
+      if (index < Literals.Count) {
+        BigNum dist = Literals[index].Key - lit;
+        if (dist < resDistance) {
+          resDistance = dist;
+          res = Gen.Function(VCExpressionGenerator.SubIOp,
+                             Literals[index].Value, Gen.Integer(dist));
+        }
+      }
+
+      if (res != null)
+        return res;
+
+      // otherwise, define a new constant to represent this literal
+      return AddConstantFor(lit);
+    }
+
+    private VCExpr AddConstantFor(BigNum lit) {
+      Contract.Requires((lit > ConstantDistance));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      VCExprVar res = Gen.Variable("int#" + lit, Type.Int);
+      int index = GetIndexFor(lit);
+      Contract.Assert(index < 0);
+      index = ~index;
+
+      Literals.Insert(index, new KeyValuePair<BigNum, VCExprVar>(lit, res));
+
+      // relate the new constant to the predecessor and successor
+      if (index > 0)
+        DefineRelationship(Literals[index - 1].Value, Literals[index - 1].Key,
+                           res, lit);
+      else
+        DefineRelationship(Gen.Integer(BigNum.ZERO), BigNum.ZERO, res, lit);
+
+      if (index < Literals.Count - 1)
+        DefineRelationship(res, lit,
+                           Literals[index + 1].Value, Literals[index + 1].Key);
+
+      return res;
+    }
+
+    private void DefineRelationship(VCExpr/*!*/ aExpr, BigNum aValue,
+                                    VCExpr/*!*/ bExpr, BigNum bValue) {
+      Contract.Requires(aValue < bValue);
+      Contract.Requires(aExpr != null);
+      Contract.Requires(bExpr != null);
+
+      BigNum dist = bValue - aValue;
+      VCExpr distExpr = Gen.Function(VCExpressionGenerator.SubIOp, bExpr, aExpr);
+      if (dist <= ConstantDistanceTPO)
+        // constants that are sufficiently close to each other are put
+        // into a precise relationship
+        AddAxiom(Gen.Eq(distExpr, Gen.Integer(dist)));
+      else
+        AddAxiom(Gen.Function(VCExpressionGenerator.GtOp,
+                              distExpr, Gen.Integer(ConstantDistanceTPO)));
+    }
+
+    private int GetIndexFor(BigNum lit) {
+      return Literals.BinarySearch(new KeyValuePair<BigNum, VCExprVar>
+                                                   (lit, DummyVar),
+                                   EntryComparer);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public override VCExpr Visit(VCExprLiteral node, bool arg) {
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExprIntLit intLit = node as VCExprIntLit;
+      if (intLit != null) {
+        if (NegConstantDistance > intLit.Val || intLit.Val > ConstantDistance)
+          return Represent(intLit.Val);
+      }
+      return node;
+    }
+
+  }
+
 }
 \ No newline at end of file
diff --git a/Source/VCExpr/Boogie2VCExpr.cs b/Source/VCExpr/Boogie2VCExpr.cs
index ad319c0e..a3364ad8 100644
--- a/Source/VCExpr/Boogie2VCExpr.cs
+++ b/Source/VCExpr/Boogie2VCExpr.cs
@@ -1,1239 +1,1239 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Linq;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-
-// A translator from the Boogie AST to the VCExpr AST.
-// This was previously realised in the methods AbsyExpr.VCView
-
-namespace Microsoft.Boogie.VCExprAST {
-  using Microsoft.Boogie;
-
-  // TODO: in future we might use that for defining symbols for Boogie's conditional compilation 
-  public class VCGenerationOptions {
-    private readonly List<string/*!*/>/*!*/ SupportedProverCommands;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(cce.NonNullElements(SupportedProverCommands));
-    }
-
-
-    public bool IsProverCommandSupported(string kind) {
-      Contract.Requires(kind != null);
-      return SupportedProverCommands.Contains(kind);
-    }
-
-    public bool IsAnyProverCommandSupported(string kinds) {
-      Contract.Requires(kinds != null);
-      if (kinds.IndexOf(',') < 0) {
-        return IsProverCommandSupported(kinds);
-      } else {
-        return kinds.Split(',', ' ').Any(k => IsProverCommandSupported(k));
-      }
-    }
-
-    public VCGenerationOptions(List<string/*!*/>/*!*/ supportedProverCommands) {
-      Contract.Requires(cce.NonNullElements(supportedProverCommands));
-      this.SupportedProverCommands = supportedProverCommands;
-    }
-  }
-
-  public delegate VCExpr/*!*/ CodeExprConverter(CodeExpr/*!*/ codeExpr, Hashtable/*<Block, VCExprVar!>*//*!*/ blockVariables, List<VCExprLetBinding> bindings, bool isPositiveContext);
-
-  public class Boogie2VCExprTranslator : ReadOnlyVisitor, ICloneable {
-    // Stack on which the various Visit-methods put the result of the translation
-    private readonly Stack<VCExpr/*!*/>/*!*/ SubExpressions = new Stack<VCExpr>();
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(cce.NonNullElements(SubExpressions));
-      Contract.Invariant(Gen != null);
-    }
-
-
-    private void Push(VCExpr expr) {
-      Contract.Requires(expr != null);
-      SubExpressions.Push(expr);
-    }
-
-    private VCExpr Pop() {
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return SubExpressions.Pop();
-    }
-
-    public VCExpr Translate(Expr expr) {
-      Contract.Requires(expr != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      this.Visit(expr);
-      return Pop();
-    }
-
-    public List<VCExpr/*!*/>/*!*/ Translate(IList<Expr> exprs) {
-      Contract.Requires(exprs != null);
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
-      List<VCExpr/*!*/>/*!*/ res = new List<VCExpr/*!*/>();
-      foreach (Expr e in exprs)
-        res.Add(Translate(cce.NonNull(e)));
-      return res;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-
-    internal readonly VCExpressionGenerator/*!*/ Gen;
-
-    public Boogie2VCExprTranslator(VCExpressionGenerator gen,
-                                   VCGenerationOptions genOptions) {
-      Contract.Requires(gen != null);
-      Contract.Requires(genOptions != null);
-      this.Gen = gen;
-      this.GenerationOptions = genOptions;
-      UnboundVariables = new VariableMapping<Variable>();
-      BoundVariables = new VariableMapping<BoundVariable>();
-      Formals = new VariableMapping<Formal>();
-    }
-
-    private Boogie2VCExprTranslator(Boogie2VCExprTranslator tl) {
-      Contract.Requires(tl != null);
-      this.Gen = tl.Gen;
-      this.GenerationOptions = tl.GenerationOptions;
-      UnboundVariables =
-        (VariableMapping<Variable>)tl.UnboundVariables.Clone();
-      BoundVariables = new VariableMapping<BoundVariable>();
-      Formals = new VariableMapping<Formal>();
-    }
-
-    public object Clone() {
-      Contract.Ensures(Contract.Result<object>() != null);
-      return new Boogie2VCExprTranslator(this);
-    }
-
-    private IAppliableTranslator IAppTranslatorAttr = null;
-    private IAppliableTranslator IAppTranslator {
-      get {
-        Contract.Ensures(Contract.Result<IAppliableTranslator>() != null);
-
-        if (IAppTranslatorAttr == null)
-          IAppTranslatorAttr = new IAppliableTranslator(this);
-        return IAppTranslatorAttr;
-      }
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // Class for handling occurring variables
-
-    private class VariableMapping<VarKind> : ICloneable {
-      private readonly List<Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/>/*!*/ Mapping;
-      [ContractInvariantMethod]
-      void ObjectInvariant() {
-        Contract.Invariant(Mapping != null && Contract.ForAll(Mapping, i => cce.NonNullDictionaryAndValues(i)));
-      }
-
-
-      public VariableMapping() {
-        List<Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/>/*!*/ mapping =
-          new List<Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/>();
-        mapping.Add(new Dictionary<VarKind/*!*/, VCExprVar/*!*/>());
-        this.Mapping = mapping;
-      }
-
-      private VariableMapping(VariableMapping<VarKind> vm) {
-        Contract.Requires(vm != null);
-        List<Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/>/*!*/ mapping =
-          new List<Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/>();
-        foreach (Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/ d in vm.Mapping) {
-          Contract.Assert(cce.NonNullDictionaryAndValues(d));
-          mapping.Add(new Dictionary<VarKind/*!*/, VCExprVar/*!*/>(d));
-        }
-        this.Mapping = mapping;
-      }
-
-      public object Clone() {
-        Contract.Ensures(Contract.Result<object>() != null);
-        return new VariableMapping<VarKind>(this);
-      }
-
-      public void PushScope() {
-        Mapping.Add(new Dictionary<VarKind/*!*/, VCExprVar/*!*/>());
-      }
-
-      public void PopScope() {
-        Contract.Assume(Mapping.Count > 0);
-        Mapping.RemoveAt(Mapping.Count - 1);
-      }
-
-      public void Bind(VarKind boogieVar, VCExprVar/*!*/ vcExprVar) {
-        Contract.Requires(vcExprVar != null);
-        Contract.Requires(boogieVar != null);
-        Contract.Requires(!Contains(boogieVar));
-        Mapping[Mapping.Count - 1].Add(boogieVar, vcExprVar);
-      }
-
-      public VCExprVar Lookup(VarKind boogieVar) {
-        Contract.Requires(boogieVar != null);
-        Contract.Ensures(Contract.Result<VCExprVar>() != null);
-        VCExprVar res = LookupHelp(boogieVar);
-        Contract.Assume(res != null);
-        return res;
-      }
-
-      [Pure]
-      public bool Contains(VarKind boogieVar) {
-        Contract.Requires(boogieVar != null);
-        return LookupHelp(boogieVar) != null;
-      }
-
-      public bool TryGetValue(VarKind boogieVar, out VCExprVar res) {
-        Contract.Requires(boogieVar != null);
-        res = LookupHelp(boogieVar);
-        return res != null;
-      }
-
-      [Pure]
-      private VCExprVar LookupHelp(VarKind boogieVar) {
-        Contract.Requires(boogieVar != null);
-        VCExprVar res;
-        foreach (Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/ d in Mapping) {
-          //Contract.Assert(cce.NonNullElements(d));
-          if (d.TryGetValue(boogieVar, out res)) {
-            Contract.Assert(res != null);
-            return res;
-          }
-        }
-        return null;
-      }
-    }
-
-    //////////////////////////////////////////////////////////////////////////////////
-
-    private readonly VariableMapping<Variable>/*!*/ UnboundVariables;
-    private readonly VariableMapping<BoundVariable>/*!*/ BoundVariables;
-    // used when translating the bodies of function expansions
-    private readonly VariableMapping<Formal>/*!*/ Formals;
-    [ContractInvariantMethod]
-    void ObjectInvairant() {
-      Contract.Invariant(UnboundVariables != null);
-      Contract.Invariant(BoundVariables != null);
-      Contract.Invariant(Formals != null);
-    }
-
-
-    internal void PushBoundVariableScope() {
-      BoundVariables.PushScope();
-    }
-    internal void PopBoundVariableScope() {
-      BoundVariables.PopScope();
-    }
-
-    internal void PushFormalsScope() {
-      Formals.PushScope();
-    }
-    internal void PopFormalsScope() {
-      Formals.PopScope();
-    }
-
-    public VCExprVar BindVariable(Variable boogieVar) {
-      Contract.Requires(boogieVar != null);
-      Contract.Ensures(Contract.Result<VCExprVar>() != null);
-      if (boogieVar is BoundVariable) {
-        VCExprVar/*!*/ newVar = Gen.Variable(boogieVar.Name, boogieVar.TypedIdent.Type);
-        BoundVariables.Bind((BoundVariable)boogieVar, newVar);
-        return newVar;
-      } else if (boogieVar is Formal) {
-        VCExprVar/*!*/ newVar = Gen.Variable(boogieVar.Name, boogieVar.TypedIdent.Type);
-        Formals.Bind((Formal)boogieVar, newVar);
-        return newVar;
-      } else {
-        // only bound variables and formals are declared explicitly
-        Contract.Assert(false);
-        throw new cce.UnreachableException();
-      }
-    }
-
-    public VCExprVar LookupVariable(Variable boogieVar) {
-      Contract.Requires(boogieVar != null);
-      Contract.Ensures(Contract.Result<VCExprVar>() != null);
-
-      BoundVariable bv = boogieVar as BoundVariable;
-      if (bv != null) {
-        return BoundVariables.Lookup(bv);
-      }
-      VCExprVar res;
-      Formal fml = boogieVar as Formal;
-      if (fml != null && Formals.TryGetValue(fml, out res))
-        return cce.NonNull(res);
-
-      // global variables, local variables, incarnations, etc. are
-      // bound the first time they occur
-      if (!UnboundVariables.TryGetValue(boogieVar, out res)) {
-        if (boogieVar is Constant)
-          res = new VCExprConstant(boogieVar.Name, boogieVar.TypedIdent.Type);
-        else 
-          res = new VCExprVar(boogieVar.Name, boogieVar.TypedIdent.Type);
-        UnboundVariables.Bind(boogieVar, res);
-      }
-      return cce.NonNull(res);
-    }
-
-    /// <summary>
-    /// Unlike LookupVariable, this method does not create a new variable mapping if none is
-    /// found.  Instead, this method returns null in such cases.  Also, this method does not
-    /// look for bound variables.
-    /// </summary>
-    /// <param name="boogieVar"></param>
-    /// <returns></returns>
-    public VCExprVar TryLookupVariable(Variable boogieVar) {
-      Contract.Requires(boogieVar != null);
-
-      VCExprVar res;
-      Formal fml = boogieVar as Formal;
-      if (fml != null && Formals.TryGetValue(fml, out res))
-        return cce.NonNull(res);
-
-      if (UnboundVariables.TryGetValue(boogieVar, out res)) {
-        return cce.NonNull(res);
-      }
-
-      return null;  // not present
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////////
-
-    internal readonly VCGenerationOptions/*!*/ GenerationOptions;
-    [ContractInvariantMethod]
-    void ObjectInvarian() {
-      Contract.Invariant(GenerationOptions != null);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////////
-
-    public override Expr VisitLiteralExpr(LiteralExpr node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Expr>() != null);
-      Push(TranslateLiteralExpr(node));
-      return node;
-    }
-    private VCExpr TranslateLiteralExpr(LiteralExpr node) {
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (node.Val is bool) {
-        bool b = (bool)node.Val;
-        if (b) {
-          return VCExpressionGenerator.True;
-        } else {
-          return VCExpressionGenerator.False;
-        }
-      } else if (node.Val is BigNum) {
-        return Gen.Integer(node.asBigNum);
-      } else if (node.Val is BigDec) {
-        return Gen.Real(node.asBigDec);
-      } else if (node.Val is BigFloat) {
-        return Gen.Float(node.asBigFloat);
-      }
-      else if (node.Val is BvConst) {
-        return Gen.Bitvector((BvConst)node.Val);
-      } else {
-        System.Diagnostics.Debug.Assert(false, "unknown kind of literal " + node.tok.ToString());
-        Contract.Assert(false);
-        throw new cce.UnreachableException();
-      }
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////////
-
-    public override Expr VisitIdentifierExpr(IdentifierExpr node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Expr>() != null);
-      Contract.Assume(node.Decl != null);   // the expression has to be resolved
-      Push(LookupVariable(node.Decl));
-      return node;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////////
-
-    // Because of our scheme for numbering incarnations of variables, the pre-state
-    // value of a variable x is always just "x". (The first update to it in a method
-    // causes it to become "x0". So we just remove old expressions with a visitor
-    // before transforming it into a VCExpr.
-    public override Expr VisitOldExpr(OldExpr node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Expr>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////////
-
-    public override Expr VisitNAryExpr(NAryExpr node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Expr>() != null);
-      Push(TranslateNAryExpr(node));
-      return node;
-    }
-
-    public bool isPositiveContext = true;
-    private VCExpr TranslateNAryExpr(NAryExpr node) {
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-     
-      bool flipContextForArg0 = false;
-      if (node.Fun is UnaryOperator)
-      {
-          UnaryOperator oper = (UnaryOperator)node.Fun;
-          if (oper.Op == UnaryOperator.Opcode.Not)
-              flipContextForArg0 = true;
-      }
-      else if (node.Fun is BinaryOperator)
-      {
-          BinaryOperator oper = (BinaryOperator)node.Fun;
-          if (oper.Op == BinaryOperator.Opcode.Imp)
-              flipContextForArg0 = true;
-          else if (oper.Op == BinaryOperator.Opcode.Iff) {
-              Expr one = new NAryExpr(node.tok, new BinaryOperator(node.tok, BinaryOperator.Opcode.Imp), new List<Expr> { node.Args[0], node.Args[1] });
-              Expr two = new NAryExpr(node.tok, new BinaryOperator(node.tok, BinaryOperator.Opcode.Imp), new List<Expr> { node.Args[1], node.Args[0] });
-              NAryExpr cmpd = new NAryExpr(node.tok, new BinaryOperator(node.tok, BinaryOperator.Opcode.And), new List<Expr> { one, two });
-              TypecheckingContext tc = new TypecheckingContext(null);
-              cmpd.Typecheck(tc);
-              return TranslateNAryExpr(cmpd);
-          }
-      }
-
-      int n = node.Args.Count;
-      List<VCExpr/*!*/>/*!*/ vcs = new List<VCExpr/*!*/>(n);
-        
-      for (int i = 0; i < n; i++) {
-        if (i == 0 && flipContextForArg0)
-            isPositiveContext = !isPositiveContext;
-        vcs.Add(Translate(cce.NonNull(node.Args)[i]));
-        if (i == 0 && flipContextForArg0)
-            isPositiveContext = !isPositiveContext;
-      }
-
-      if (node.Type == null) {
-        System.Console.WriteLine("*** type is null for {0}", node);
-        Contract.Assert(false);
-        throw new cce.UnreachableException();
-      }
-
-      return IAppTranslator.Translate(node.Fun, node.Type, vcs,
-                                      ToList(cce.NonNull(node.TypeParameters)));
-    }
-
-
-    private static List<Type/*!*/>/*!*/ EMPTY_TYPE_LIST = new List<Type/*!*/>();
-    [ContractInvariantMethod]
-    void ObjectInvirant() {
-      Contract.Invariant(EMPTY_TYPE_LIST != null);
-    }
-
-
-    private List<Type/*!*/>/*!*/ ToList(TypeParamInstantiation insts) {
-      Contract.Requires(insts != null);
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
-      if (insts.FormalTypeParams.Count == 0)
-        return EMPTY_TYPE_LIST;
-
-      List<Type/*!*/>/*!*/ typeArgs = new List<Type/*!*/>();
-      foreach (TypeVariable/*!*/ var in insts.FormalTypeParams) {
-        Contract.Assert(var != null);
-        typeArgs.Add(insts[var]);
-      }
-      return typeArgs;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////////
-
-    public override QuantifierExpr VisitQuantifierExpr(QuantifierExpr node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<QuantifierExpr>() != null);
-      Push(TranslateQuantifierExpr(node));
-      return node;
-    }
-
-    public override Expr VisitExistsExpr(ExistsExpr node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Expr>() != null);
-      node = (ExistsExpr)this.VisitQuantifierExpr(node);
-      return node;
-    }
-
-    public override Expr VisitForallExpr(ForallExpr node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Expr>() != null);
-      node = (ForallExpr)this.VisitQuantifierExpr(node);
-      return node;
-    }
-
-    private VCExpr TranslateQuantifierExpr(QuantifierExpr node) {
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<TypeVariable/*!*/>/*!*/ typeParams = new List<TypeVariable/*!*/>();
-      foreach (TypeVariable/*!*/ v in node.TypeParameters) {
-        Contract.Assert(v != null);
-        typeParams.Add(v);
-      }
-
-      PushBoundVariableScope();
-
-      List<VCExprVar/*!*/>/*!*/ boundVars = new List<VCExprVar/*!*/>();
-      foreach (Variable/*!*/ v in node.Dummies)
-        boundVars.Add(BindVariable(v));
-
-      try {
-        List<VCTrigger/*!*/>/*!*/ triggers = TranslateTriggers(node.Triggers);
-        VCExpr/*!*/ body = Translate(node.Body);
-        VCQuantifierInfos/*!*/ infos = GenerateQuantifierInfos(node);
-
-        Quantifier quan;
-        if (node is ForallExpr)
-          quan = Quantifier.ALL;
-        else if (node is ExistsExpr)
-          quan = Quantifier.EX;
-        else {
-          Contract.Assert(false);
-          throw new cce.UnreachableException();
-        }
-
-        return Gen.Quantify(quan, typeParams, boundVars, triggers, infos, body);
-      } finally {
-        PopBoundVariableScope();
-      }
-    }
-
-    private List<VCTrigger/*!*/>/*!*/ TranslateTriggers(Trigger node) {
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCTrigger>>()));
-      List<VCTrigger/*!*/>/*!*/ res = new List<VCTrigger/*!*/>();
-      Trigger curTrigger = node;
-      while (curTrigger != null) {
-        res.Add(Gen.Trigger(curTrigger.Pos, Translate(curTrigger.Tr)));
-        curTrigger = curTrigger.Next;
-      }
-      return res;
-    }
-
-    private VCQuantifierInfos GenerateQuantifierInfos(QuantifierExpr node) {
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCQuantifierInfos>() != null);
-      string qid = getQidNameFromQKeyValue(node.Dummies, node.Attributes);
-      return new VCQuantifierInfos(qid, node.SkolemId, false, node.Attributes);
-    }
-
-    private string getQidNameFromQKeyValue(List<Variable> vars, QKeyValue attributes) {
-      Contract.Requires(vars != null);
-      // Check for a 'qid, name' pair in keyvalues
-      string qid = QKeyValue.FindStringAttribute(attributes, "qid");
-      if (qid == null && vars.Count != 0) {
-        // generate default name (line:column position in .bpl file)
-        Variable v = vars[0];
-        Contract.Assert(v != null); // Rustan's claim!
-        // Include the first 8 characters of the filename in QID (helpful in case we use /concat)
-        // We limit it to 8, so the SX file doesn't grow too big, and who on earth would need
-        // more than 8 characters in a filename anyways.
-        int max = 8;
-        StringBuilder buf = new StringBuilder(max + 20);
-        string filename = v.tok.filename;
-        if (filename == null)
-          filename = "unknown";
-        for (int i = 0; i < filename.Length; ++i) {
-          if (filename[i] == '/' || filename[i] == '\\')
-            buf.Length = 0;
-          if (buf.Length < max && char.IsLetterOrDigit(filename[i])) {
-            if (buf.Length == 0 && char.IsDigit(filename[i])) {
-              // Z3 does not like QID's to start with a digit, so we prepend another character
-              buf.Append('_');
-            }
-            buf.Append(filename[i]);
-          }
-        }
-        buf.Append('.').Append(v.Line).Append(':').Append(v.Col);
-        qid = buf.ToString();
-      }
-      return qid;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////////
-
-    public override Expr VisitBvExtractExpr(BvExtractExpr node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Expr>() != null);
-      Push(TranslateBvExtractExpr(node));
-      return node;
-    }
-
-    private VCExpr TranslateBvExtractExpr(BvExtractExpr node) {
-      Contract.Requires(node != null);
-      Contract.Requires((node.Start <= node.End));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExpr/*!*/ bv = Translate(node.Bitvector);
-      return Gen.BvExtract(bv, cce.NonNull(node.Bitvector.Type).BvBits, node.Start, node.End);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////////
-
-    public override Expr VisitBvConcatExpr(BvConcatExpr node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Expr>() != null);
-      Push(TranslateBvConcatExpr(node));
-      return node;
-    }
-
-    private VCExpr TranslateBvConcatExpr(BvConcatExpr node) {
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExpr/*!*/ bv0 = Translate(node.E0);
-      VCExpr/*!*/ bv1 = Translate(node.E1);
-      return Gen.BvConcat(bv0, bv1);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////////
-    // all the other cases should never happen
-
-    public override Cmd VisitAssertCmd(AssertCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Cmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Cmd VisitAssignCmd(AssignCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Cmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Cmd VisitAssumeCmd(AssumeCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Cmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override AtomicRE VisitAtomicRE(AtomicRE node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<AtomicRE>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Axiom VisitAxiom(Axiom node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Axiom>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Type VisitBasicType(BasicType node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Type>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Type VisitBvType(BvType node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Type>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Block VisitBlock(Block node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Block>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public CodeExprConverter codeExprConverter = null;
-    public void SetCodeExprConverter(CodeExprConverter f) {
-      this.codeExprConverter = f;
-    }
-    public override Expr/*!*/ VisitCodeExpr(CodeExpr/*!*/ codeExpr) {
-      //Contract.Requires(codeExpr != null);
-      Contract.Ensures(Contract.Result<Expr>() != null);
-      Contract.Assume(codeExprConverter != null);
-
-      Hashtable/*<Block, LetVariable!>*/ blockVariables = new Hashtable/*<Block, LetVariable!!>*/();
-      List<VCExprLetBinding/*!*/> bindings = new List<VCExprLetBinding/*!*/>();
-      VCExpr e = codeExprConverter(codeExpr, blockVariables, bindings, isPositiveContext);
-      Push(e);
-      return codeExpr;
-    }
-    public override List<Block> VisitBlockSeq(List<Block> blockSeq) {
-      //Contract.Requires(blockSeq != null);
-      Contract.Ensures(Contract.Result<List<Block>>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override List<Block/*!*/>/*!*/ VisitBlockList(List<Block/*!*/>/*!*/ blocks) {
-      //Contract.Requires(cce.NonNullElements(blocks));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<Block>>()));
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override BoundVariable VisitBoundVariable(BoundVariable node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<BoundVariable>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Cmd VisitCallCmd(CallCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Cmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Cmd VisitParCallCmd(ParCallCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Cmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override List<Cmd> VisitCmdSeq(List<Cmd> cmdSeq) {
-      //Contract.Requires(cmdSeq != null);
-      Contract.Ensures(Contract.Result<List<Cmd>>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Choice VisitChoice(Choice node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Choice>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Cmd VisitCommentCmd(CommentCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Cmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Constant VisitConstant(Constant node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Constant>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override CtorType VisitCtorType(CtorType node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<CtorType>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Declaration VisitDeclaration(Declaration node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Declaration>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override List<Declaration/*!*/>/*!*/ VisitDeclarationList(List<Declaration/*!*/>/*!*/ declarationList) {
-      //Contract.Requires(cce.NonNullElements(declarationList));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<Declaration>>()));
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override DeclWithFormals VisitDeclWithFormals(DeclWithFormals node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<DeclWithFormals>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Requires VisitRequires(Requires @requires) {
-      //Contract.Requires(@requires != null);
-      Contract.Ensures(Contract.Result<Requires>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override List<Requires> VisitRequiresSeq(List<Requires> requiresSeq) {
-      //Contract.Requires(requiresSeq != null);
-      Contract.Ensures(Contract.Result<List<Requires>>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Ensures VisitEnsures(Ensures @ensures) {
-      //Contract.Requires(@ensures != null);
-      Contract.Ensures(Contract.Result<Ensures>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override List<Ensures> VisitEnsuresSeq(List<Ensures> ensuresSeq) {
-      //Contract.Requires(ensuresSeq != null);
-      Contract.Ensures(Contract.Result<List<Ensures>>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Formal VisitFormal(Formal node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Formal>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Function VisitFunction(Function node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Function>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override GlobalVariable VisitGlobalVariable(GlobalVariable node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<GlobalVariable>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override GotoCmd VisitGotoCmd(GotoCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<GotoCmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Cmd VisitHavocCmd(HavocCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Cmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Implementation VisitImplementation(Implementation node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Implementation>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override LocalVariable VisitLocalVariable(LocalVariable node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<LocalVariable>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override AssignLhs VisitMapAssignLhs(MapAssignLhs node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<AssignLhs>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override MapType VisitMapType(MapType node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<MapType>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Procedure VisitProcedure(Procedure node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Procedure>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Program VisitProgram(Program node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Program>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Cmd VisitRE(RE node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Cmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override List<RE> VisitRESeq(List<RE> reSeq) {
-      //Contract.Requires(reSeq != null);
-      Contract.Ensures(Contract.Result<List<RE>>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override ReturnCmd VisitReturnCmd(ReturnCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<ReturnCmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override ReturnExprCmd VisitReturnExprCmd(ReturnExprCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<ReturnExprCmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Sequential VisitSequential(Sequential node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Sequential>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override AssignLhs VisitSimpleAssignLhs(SimpleAssignLhs node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<AssignLhs>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Cmd VisitStateCmd(StateCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Cmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override TransferCmd VisitTransferCmd(TransferCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<TransferCmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Trigger VisitTrigger(Trigger node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Trigger>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Type VisitType(Type node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Type>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override TypedIdent VisitTypedIdent(TypedIdent node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<TypedIdent>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Type VisitTypeSynonymAnnotation(TypeSynonymAnnotation node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Type>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Type VisitTypeVariable(TypeVariable node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Type>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Variable VisitVariable(Variable node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Variable>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override List<Variable> VisitVariableSeq(List<Variable> variableSeq) {
-      //Contract.Requires(variableSeq != null);
-      Contract.Ensures(Contract.Result<List<Variable>>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Cmd VisitAssertEnsuresCmd(AssertEnsuresCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Cmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public override Cmd VisitAssertRequiresCmd(AssertRequiresCmd node) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Cmd>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-
-  }
-
-
-  /////////////////////////////////////////////////////////////////////////////////
-
-  public class IAppliableTranslator : IAppliableVisitor<VCExpr/*!*/> {
-
-    private readonly Boogie2VCExprTranslator/*!*/ BaseTranslator;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(BaseTranslator != null);
-    }
-
-
-    private VCExpressionGenerator/*!*/ Gen {
-      get {
-        Contract.Ensures(Contract.Result<VCExpressionGenerator>() != null);
-
-        return BaseTranslator.Gen;
-      }
-    }
-    private VCGenerationOptions GenerationOptions {
-      get {
-        Contract.Ensures(Contract.Result<VCGenerationOptions>() != null);
-
-        return BaseTranslator.GenerationOptions;
-      }
-    }
-
-    public IAppliableTranslator(Boogie2VCExprTranslator baseTranslator) {
-      Contract.Requires(baseTranslator != null);
-      this.BaseTranslator = baseTranslator;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-
-    private List<VCExpr/*!*/>/*!*/ args = new List<VCExpr/*!*/>();
-    private List<Type/*!*/>/*!*/ typeArgs = new List<Type/*!*/>();
-    [ContractInvariantMethod]
-    void ObjectInvarianet() {
-      Contract.Invariant(args != null);
-      Contract.Invariant(typeArgs != null);
-    }
-
-
-    public VCExpr Translate(IAppliable app, Type ty, List<VCExpr/*!*/>/*!*/ args, List<Type/*!*/>/*!*/ typeArgs) {
-      Contract.Requires(ty != null);
-      Contract.Requires(app != null);
-      Contract.Requires(cce.NonNullElements(typeArgs));
-      Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      List<VCExpr/*!*/>/*!*/ oldArgs = this.args;
-      List<Type/*!*/>/*!*/ oldTypeArgs = this.typeArgs;
-      this.args = args;
-      this.typeArgs = typeArgs;
-      VCExpr/*!*/ result = app.Dispatch<VCExpr/*!*/>(this);
-      this.args = oldArgs;
-      this.typeArgs = oldTypeArgs;
-      return result;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-
-
-
-    public VCExpr Visit(UnaryOperator unaryOperator) {
-      //Contract.Requires(unaryOperator != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      Contract.Assert(unaryOperator.Op == UnaryOperator.Opcode.Neg || unaryOperator.Op == UnaryOperator.Opcode.Not);
-      Contract.Assert(this.args.Count == 1);
-      if (unaryOperator.Op == UnaryOperator.Opcode.Neg) {
-        VCExpr e = cce.NonNull(this.args[0]);
-        if (cce.NonNull(e.Type).IsInt) {
-          return Gen.Function(VCExpressionGenerator.SubIOp, Gen.Integer(BigNum.ZERO), e);
-        }
-        else {// if (cce.NonNull(e.Type).IsReal) {
-          return Gen.Function(VCExpressionGenerator.SubROp, Gen.Real(BigDec.ZERO), e);
-        }
-        //else  {//is float
-          //return Gen.Function(VCExpressionGenerator.SubFOp, Gen.Float(BigFloat.ZERO(8, 23)), e);
-        //} 
-      }
-      else {
-        return Gen.Not(this.args);
-      }
-    }
-
-    public VCExpr Visit(BinaryOperator binaryOperator) {
-      //Contract.Requires(binaryOperator != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return TranslateBinaryOperator(binaryOperator, this.args);
-    }
-
-    public VCExpr Visit(FunctionCall functionCall) {
-      //Contract.Requires(functionCall != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return TranslateFunctionCall(functionCall, this.args, this.typeArgs);
-    }
-
-    public VCExpr Visit(MapSelect mapSelect) {
-      //Contract.Requires(mapSelect != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Gen.Select(this.args, this.typeArgs);
-    }
-
-    public VCExpr Visit(MapStore mapStore) {
-      //Contract.Requires(mapStore != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Gen.Store(this.args, this.typeArgs);
-    }
-
-    public VCExpr Visit(TypeCoercion typeCoercion) {
-      //Contract.Requires(typeCoercion != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      Contract.Assert(this.args.Count == 1);
-      return this.args[0];
-    }
-
-    public VCExpr Visit(ArithmeticCoercion arithCoercion) {
-      //Contract.Requires(arithCoercion != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      Contract.Assert(this.args.Count == 1);
-      switch (arithCoercion.Coercion) {
-        case ArithmeticCoercion.CoercionType.ToInt:
-          return Gen.Function(VCExpressionGenerator.ToIntOp, this.args);
-        case ArithmeticCoercion.CoercionType.ToReal:
-          return Gen.Function(VCExpressionGenerator.ToRealOp, this.args);
-        default:
-          Contract.Assert(false);
-          return null;
-      }
-    }
-
-    public VCExpr Visit(IfThenElse ite) {
-      //Contract.Requires(ite != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Gen.Function(VCExpressionGenerator.IfThenElseOp, this.args);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-
-    private VCExpr TranslateBinaryOperator(BinaryOperator app, List<VCExpr/*!*/>/*!*/ args) {
-      Contract.Requires(app != null);
-      Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      Contract.Assert(args.Count == 2);
-      Type t = cce.NonNull(cce.NonNull(args[0]).Type);
-
-      switch (app.Op) {
-        case BinaryOperator.Opcode.Add:
-          if (t.IsInt) {
-            return Gen.Function(VCExpressionGenerator.AddIOp, args);
-          }
-          else if (t.IsReal) {
-            return Gen.Function(VCExpressionGenerator.AddROp, args);
-          }
-          else { //t is float
-            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "+"), args);
-          }
-        case BinaryOperator.Opcode.Sub:
-          if (t.IsInt) {
-            return Gen.Function(VCExpressionGenerator.SubIOp, args);
-          }
-          else if (t.IsReal) {
-            return Gen.Function(VCExpressionGenerator.SubROp, args);
-          }
-          else { //t is float
-            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "-"), args);
-          }
-        case BinaryOperator.Opcode.Mul:
-          if (t.IsInt) {
-            return Gen.Function(VCExpressionGenerator.MulIOp, args);
-          }
-          else if (t.IsReal) {
-            return Gen.Function(VCExpressionGenerator.MulROp, args);
-          }
-          else
-          { //t is float
-            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "*"), args);
-          }
-        case BinaryOperator.Opcode.Div:
-          return Gen.Function(VCExpressionGenerator.DivIOp, args);
-        case BinaryOperator.Opcode.Mod:
-          return Gen.Function(VCExpressionGenerator.ModOp, args);
-        case BinaryOperator.Opcode.RealDiv:
-          if (t.IsFloat) {
-            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "/"), args);
-          }
-          VCExpr arg0 = cce.NonNull(args[0]);
-          VCExpr arg1 = cce.NonNull(args[1]);
-          if (cce.NonNull(arg0.Type).IsInt) {
-            arg0 = Gen.Function(VCExpressionGenerator.ToRealOp, arg0);
-          }
-          if (cce.NonNull(arg1.Type).IsInt) {
-            arg1 = Gen.Function(VCExpressionGenerator.ToRealOp, arg1);
-          }
-          return Gen.Function(VCExpressionGenerator.DivROp, arg0, arg1);
-        case BinaryOperator.Opcode.Pow:
-          return Gen.Function(VCExpressionGenerator.PowOp, args);
-        case BinaryOperator.Opcode.Eq:
-        case BinaryOperator.Opcode.Iff:
-          // we don't distinguish between equality and equivalence at this point
-          if (t.IsFloat)
-            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "=="), args);
-          return Gen.Function(VCExpressionGenerator.EqOp, args);
-        case BinaryOperator.Opcode.Neq:
-          return Gen.Function(VCExpressionGenerator.NeqOp, args);
-        case BinaryOperator.Opcode.Lt:
-          if (t.IsFloat)
-            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "<"), args);
-          return Gen.Function(VCExpressionGenerator.LtOp, args);
-        case BinaryOperator.Opcode.Le:
-          if (t.IsFloat)
-            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "<="), args);
-          return Gen.Function(VCExpressionGenerator.LeOp, args);
-        case BinaryOperator.Opcode.Ge:
-          if (t.IsFloat)
-            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, ">="), args);
-          return Gen.Function(VCExpressionGenerator.GeOp, args);
-        case BinaryOperator.Opcode.Gt:
-          if (t.IsFloat)
-            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, ">"), args);
-          return Gen.Function(VCExpressionGenerator.GtOp, args);
-        case BinaryOperator.Opcode.Imp:
-          return Gen.Function(VCExpressionGenerator.ImpliesOp, args);
-        case BinaryOperator.Opcode.And:
-          return Gen.Function(VCExpressionGenerator.AndOp, args);
-        case BinaryOperator.Opcode.Or:
-          return Gen.Function(VCExpressionGenerator.OrOp, args);
-        case BinaryOperator.Opcode.Subtype:
-          return Gen.Function(VCExpressionGenerator.SubtypeOp, args);
-        default:
-          Contract.Assert(false);
-          throw new cce.UnreachableException();  // unexpected binary operator
-      }
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////
-
-    private VCExpr/*!*/ TranslateFunctionCall(FunctionCall app, List<VCExpr/*!*/>/*!*/ args, List<Type/*!*/>/*!*/ typeArgs) {
-      Contract.Requires(cce.NonNullElements(args));
-      Contract.Requires(cce.NonNullElements(typeArgs));
-      Contract.Requires(app != null);
-      Contract.Requires((app.Func != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);    // resolution must have happened
-
-      VCExpr res = ApplyExpansion(app, args, typeArgs);
-      if (res != null)
-        return res;
-
-      VCExprOp/*!*/ functionOp = Gen.BoogieFunctionOp(app.Func);
-      return Gen.Function(functionOp, args, typeArgs);
-    }
-
-    private VCExpr ApplyExpansion(FunctionCall app, List<VCExpr/*!*/>/*!*/ args, List<Type/*!*/>/*!*/ typeArgs) {
-      Contract.Requires(app != null);
-      Contract.Requires(cce.NonNullElements(args));
-      Contract.Requires(cce.NonNullElements(typeArgs));
-      Contract.Assert(app.Func != null);    // resolution must have happened
-
-      lock (app.Func)
-      {
-        if (app.Func.doingExpansion)
-        {
-          System.Console.WriteLine("*** detected expansion loop on {0}", app.Func);
-          return null;
-        }
-
-        var exp = app.Func.Body;
-        if (exp == null)
-          return null;
-
-        VCExpr/*!*/ translatedBody;
-        VCExprSubstitution/*!*/ subst = new VCExprSubstitution();
-        try
-        {
-          BaseTranslator.PushFormalsScope();
-          BaseTranslator.PushBoundVariableScope();
-          app.Func.doingExpansion = true;
-
-          // first bind the formals to VCExpr variables, which are later
-          // substituted with the actual parameters
-          var inParams = app.Func.InParams;
-          for (int i = 0; i < inParams.Count; ++i)
-            subst[BaseTranslator.BindVariable(inParams[i])] = args[i];
-
-          // recursively translate the body of the expansion
-          translatedBody = BaseTranslator.Translate(exp);
-        }
-        finally
-        {
-          BaseTranslator.PopFormalsScope();
-          BaseTranslator.PopBoundVariableScope();
-          app.Func.doingExpansion = false;
-        }
-
-        // substitute the formals with the actual parameters in the body
-        var tparms = app.Func.TypeParameters;
-        Contract.Assert(typeArgs.Count == tparms.Count);
-        for (int i = 0; i < typeArgs.Count; ++i)
-          subst[tparms[i]] = typeArgs[i];
-        SubstitutingVCExprVisitor/*!*/ substituter = new SubstitutingVCExprVisitor(Gen);
-        return substituter.Mutate(translatedBody, subst);
-      }
-    }
-  }
-}
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+
+// A translator from the Boogie AST to the VCExpr AST.
+// This was previously realised in the methods AbsyExpr.VCView
+
+namespace Microsoft.Boogie.VCExprAST {
+  using Microsoft.Boogie;
+
+  // TODO: in future we might use that for defining symbols for Boogie's conditional compilation 
+  public class VCGenerationOptions {
+    private readonly List<string/*!*/>/*!*/ SupportedProverCommands;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(cce.NonNullElements(SupportedProverCommands));
+    }
+
+
+    public bool IsProverCommandSupported(string kind) {
+      Contract.Requires(kind != null);
+      return SupportedProverCommands.Contains(kind);
+    }
+
+    public bool IsAnyProverCommandSupported(string kinds) {
+      Contract.Requires(kinds != null);
+      if (kinds.IndexOf(',') < 0) {
+        return IsProverCommandSupported(kinds);
+      } else {
+        return kinds.Split(',', ' ').Any(k => IsProverCommandSupported(k));
+      }
+    }
+
+    public VCGenerationOptions(List<string/*!*/>/*!*/ supportedProverCommands) {
+      Contract.Requires(cce.NonNullElements(supportedProverCommands));
+      this.SupportedProverCommands = supportedProverCommands;
+    }
+  }
+
+  public delegate VCExpr/*!*/ CodeExprConverter(CodeExpr/*!*/ codeExpr, Hashtable/*<Block, VCExprVar!>*//*!*/ blockVariables, List<VCExprLetBinding> bindings, bool isPositiveContext);
+
+  public class Boogie2VCExprTranslator : ReadOnlyVisitor, ICloneable {
+    // Stack on which the various Visit-methods put the result of the translation
+    private readonly Stack<VCExpr/*!*/>/*!*/ SubExpressions = new Stack<VCExpr>();
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(cce.NonNullElements(SubExpressions));
+      Contract.Invariant(Gen != null);
+    }
+
+
+    private void Push(VCExpr expr) {
+      Contract.Requires(expr != null);
+      SubExpressions.Push(expr);
+    }
+
+    private VCExpr Pop() {
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return SubExpressions.Pop();
+    }
+
+    public VCExpr Translate(Expr expr) {
+      Contract.Requires(expr != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      this.Visit(expr);
+      return Pop();
+    }
+
+    public List<VCExpr/*!*/>/*!*/ Translate(IList<Expr> exprs) {
+      Contract.Requires(exprs != null);
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
+      List<VCExpr/*!*/>/*!*/ res = new List<VCExpr/*!*/>();
+      foreach (Expr e in exprs)
+        res.Add(Translate(cce.NonNull(e)));
+      return res;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+
+    internal readonly VCExpressionGenerator/*!*/ Gen;
+
+    public Boogie2VCExprTranslator(VCExpressionGenerator gen,
+                                   VCGenerationOptions genOptions) {
+      Contract.Requires(gen != null);
+      Contract.Requires(genOptions != null);
+      this.Gen = gen;
+      this.GenerationOptions = genOptions;
+      UnboundVariables = new VariableMapping<Variable>();
+      BoundVariables = new VariableMapping<BoundVariable>();
+      Formals = new VariableMapping<Formal>();
+    }
+
+    private Boogie2VCExprTranslator(Boogie2VCExprTranslator tl) {
+      Contract.Requires(tl != null);
+      this.Gen = tl.Gen;
+      this.GenerationOptions = tl.GenerationOptions;
+      UnboundVariables =
+        (VariableMapping<Variable>)tl.UnboundVariables.Clone();
+      BoundVariables = new VariableMapping<BoundVariable>();
+      Formals = new VariableMapping<Formal>();
+    }
+
+    public object Clone() {
+      Contract.Ensures(Contract.Result<object>() != null);
+      return new Boogie2VCExprTranslator(this);
+    }
+
+    private IAppliableTranslator IAppTranslatorAttr = null;
+    private IAppliableTranslator IAppTranslator {
+      get {
+        Contract.Ensures(Contract.Result<IAppliableTranslator>() != null);
+
+        if (IAppTranslatorAttr == null)
+          IAppTranslatorAttr = new IAppliableTranslator(this);
+        return IAppTranslatorAttr;
+      }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // Class for handling occurring variables
+
+    private class VariableMapping<VarKind> : ICloneable {
+      private readonly List<Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/>/*!*/ Mapping;
+      [ContractInvariantMethod]
+      void ObjectInvariant() {
+        Contract.Invariant(Mapping != null && Contract.ForAll(Mapping, i => cce.NonNullDictionaryAndValues(i)));
+      }
+
+
+      public VariableMapping() {
+        List<Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/>/*!*/ mapping =
+          new List<Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/>();
+        mapping.Add(new Dictionary<VarKind/*!*/, VCExprVar/*!*/>());
+        this.Mapping = mapping;
+      }
+
+      private VariableMapping(VariableMapping<VarKind> vm) {
+        Contract.Requires(vm != null);
+        List<Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/>/*!*/ mapping =
+          new List<Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/>();
+        foreach (Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/ d in vm.Mapping) {
+          Contract.Assert(cce.NonNullDictionaryAndValues(d));
+          mapping.Add(new Dictionary<VarKind/*!*/, VCExprVar/*!*/>(d));
+        }
+        this.Mapping = mapping;
+      }
+
+      public object Clone() {
+        Contract.Ensures(Contract.Result<object>() != null);
+        return new VariableMapping<VarKind>(this);
+      }
+
+      public void PushScope() {
+        Mapping.Add(new Dictionary<VarKind/*!*/, VCExprVar/*!*/>());
+      }
+
+      public void PopScope() {
+        Contract.Assume(Mapping.Count > 0);
+        Mapping.RemoveAt(Mapping.Count - 1);
+      }
+
+      public void Bind(VarKind boogieVar, VCExprVar/*!*/ vcExprVar) {
+        Contract.Requires(vcExprVar != null);
+        Contract.Requires(boogieVar != null);
+        Contract.Requires(!Contains(boogieVar));
+        Mapping[Mapping.Count - 1].Add(boogieVar, vcExprVar);
+      }
+
+      public VCExprVar Lookup(VarKind boogieVar) {
+        Contract.Requires(boogieVar != null);
+        Contract.Ensures(Contract.Result<VCExprVar>() != null);
+        VCExprVar res = LookupHelp(boogieVar);
+        Contract.Assume(res != null);
+        return res;
+      }
+
+      [Pure]
+      public bool Contains(VarKind boogieVar) {
+        Contract.Requires(boogieVar != null);
+        return LookupHelp(boogieVar) != null;
+      }
+
+      public bool TryGetValue(VarKind boogieVar, out VCExprVar res) {
+        Contract.Requires(boogieVar != null);
+        res = LookupHelp(boogieVar);
+        return res != null;
+      }
+
+      [Pure]
+      private VCExprVar LookupHelp(VarKind boogieVar) {
+        Contract.Requires(boogieVar != null);
+        VCExprVar res;
+        foreach (Dictionary<VarKind/*!*/, VCExprVar/*!*/>/*!*/ d in Mapping) {
+          //Contract.Assert(cce.NonNullElements(d));
+          if (d.TryGetValue(boogieVar, out res)) {
+            Contract.Assert(res != null);
+            return res;
+          }
+        }
+        return null;
+      }
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+
+    private readonly VariableMapping<Variable>/*!*/ UnboundVariables;
+    private readonly VariableMapping<BoundVariable>/*!*/ BoundVariables;
+    // used when translating the bodies of function expansions
+    private readonly VariableMapping<Formal>/*!*/ Formals;
+    [ContractInvariantMethod]
+    void ObjectInvairant() {
+      Contract.Invariant(UnboundVariables != null);
+      Contract.Invariant(BoundVariables != null);
+      Contract.Invariant(Formals != null);
+    }
+
+
+    internal void PushBoundVariableScope() {
+      BoundVariables.PushScope();
+    }
+    internal void PopBoundVariableScope() {
+      BoundVariables.PopScope();
+    }
+
+    internal void PushFormalsScope() {
+      Formals.PushScope();
+    }
+    internal void PopFormalsScope() {
+      Formals.PopScope();
+    }
+
+    public VCExprVar BindVariable(Variable boogieVar) {
+      Contract.Requires(boogieVar != null);
+      Contract.Ensures(Contract.Result<VCExprVar>() != null);
+      if (boogieVar is BoundVariable) {
+        VCExprVar/*!*/ newVar = Gen.Variable(boogieVar.Name, boogieVar.TypedIdent.Type);
+        BoundVariables.Bind((BoundVariable)boogieVar, newVar);
+        return newVar;
+      } else if (boogieVar is Formal) {
+        VCExprVar/*!*/ newVar = Gen.Variable(boogieVar.Name, boogieVar.TypedIdent.Type);
+        Formals.Bind((Formal)boogieVar, newVar);
+        return newVar;
+      } else {
+        // only bound variables and formals are declared explicitly
+        Contract.Assert(false);
+        throw new cce.UnreachableException();
+      }
+    }
+
+    public VCExprVar LookupVariable(Variable boogieVar) {
+      Contract.Requires(boogieVar != null);
+      Contract.Ensures(Contract.Result<VCExprVar>() != null);
+
+      BoundVariable bv = boogieVar as BoundVariable;
+      if (bv != null) {
+        return BoundVariables.Lookup(bv);
+      }
+      VCExprVar res;
+      Formal fml = boogieVar as Formal;
+      if (fml != null && Formals.TryGetValue(fml, out res))
+        return cce.NonNull(res);
+
+      // global variables, local variables, incarnations, etc. are
+      // bound the first time they occur
+      if (!UnboundVariables.TryGetValue(boogieVar, out res)) {
+        if (boogieVar is Constant)
+          res = new VCExprConstant(boogieVar.Name, boogieVar.TypedIdent.Type);
+        else 
+          res = new VCExprVar(boogieVar.Name, boogieVar.TypedIdent.Type);
+        UnboundVariables.Bind(boogieVar, res);
+      }
+      return cce.NonNull(res);
+    }
+
+    /// <summary>
+    /// Unlike LookupVariable, this method does not create a new variable mapping if none is
+    /// found.  Instead, this method returns null in such cases.  Also, this method does not
+    /// look for bound variables.
+    /// </summary>
+    /// <param name="boogieVar"></param>
+    /// <returns></returns>
+    public VCExprVar TryLookupVariable(Variable boogieVar) {
+      Contract.Requires(boogieVar != null);
+
+      VCExprVar res;
+      Formal fml = boogieVar as Formal;
+      if (fml != null && Formals.TryGetValue(fml, out res))
+        return cce.NonNull(res);
+
+      if (UnboundVariables.TryGetValue(boogieVar, out res)) {
+        return cce.NonNull(res);
+      }
+
+      return null;  // not present
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////
+
+    internal readonly VCGenerationOptions/*!*/ GenerationOptions;
+    [ContractInvariantMethod]
+    void ObjectInvarian() {
+      Contract.Invariant(GenerationOptions != null);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////
+
+    public override Expr VisitLiteralExpr(LiteralExpr node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Expr>() != null);
+      Push(TranslateLiteralExpr(node));
+      return node;
+    }
+    private VCExpr TranslateLiteralExpr(LiteralExpr node) {
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (node.Val is bool) {
+        bool b = (bool)node.Val;
+        if (b) {
+          return VCExpressionGenerator.True;
+        } else {
+          return VCExpressionGenerator.False;
+        }
+      } else if (node.Val is BigNum) {
+        return Gen.Integer(node.asBigNum);
+      } else if (node.Val is BigDec) {
+        return Gen.Real(node.asBigDec);
+      } else if (node.Val is BigFloat) {
+        return Gen.Float(node.asBigFloat);
+      }
+      else if (node.Val is BvConst) {
+        return Gen.Bitvector((BvConst)node.Val);
+      } else {
+        System.Diagnostics.Debug.Assert(false, "unknown kind of literal " + node.tok.ToString());
+        Contract.Assert(false);
+        throw new cce.UnreachableException();
+      }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////
+
+    public override Expr VisitIdentifierExpr(IdentifierExpr node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Expr>() != null);
+      Contract.Assume(node.Decl != null);   // the expression has to be resolved
+      Push(LookupVariable(node.Decl));
+      return node;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////
+
+    // Because of our scheme for numbering incarnations of variables, the pre-state
+    // value of a variable x is always just "x". (The first update to it in a method
+    // causes it to become "x0". So we just remove old expressions with a visitor
+    // before transforming it into a VCExpr.
+    public override Expr VisitOldExpr(OldExpr node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Expr>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////
+
+    public override Expr VisitNAryExpr(NAryExpr node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Expr>() != null);
+      Push(TranslateNAryExpr(node));
+      return node;
+    }
+
+    public bool isPositiveContext = true;
+    private VCExpr TranslateNAryExpr(NAryExpr node) {
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+     
+      bool flipContextForArg0 = false;
+      if (node.Fun is UnaryOperator)
+      {
+          UnaryOperator oper = (UnaryOperator)node.Fun;
+          if (oper.Op == UnaryOperator.Opcode.Not)
+              flipContextForArg0 = true;
+      }
+      else if (node.Fun is BinaryOperator)
+      {
+          BinaryOperator oper = (BinaryOperator)node.Fun;
+          if (oper.Op == BinaryOperator.Opcode.Imp)
+              flipContextForArg0 = true;
+          else if (oper.Op == BinaryOperator.Opcode.Iff) {
+              Expr one = new NAryExpr(node.tok, new BinaryOperator(node.tok, BinaryOperator.Opcode.Imp), new List<Expr> { node.Args[0], node.Args[1] });
+              Expr two = new NAryExpr(node.tok, new BinaryOperator(node.tok, BinaryOperator.Opcode.Imp), new List<Expr> { node.Args[1], node.Args[0] });
+              NAryExpr cmpd = new NAryExpr(node.tok, new BinaryOperator(node.tok, BinaryOperator.Opcode.And), new List<Expr> { one, two });
+              TypecheckingContext tc = new TypecheckingContext(null);
+              cmpd.Typecheck(tc);
+              return TranslateNAryExpr(cmpd);
+          }
+      }
+
+      int n = node.Args.Count;
+      List<VCExpr/*!*/>/*!*/ vcs = new List<VCExpr/*!*/>(n);
+        
+      for (int i = 0; i < n; i++) {
+        if (i == 0 && flipContextForArg0)
+            isPositiveContext = !isPositiveContext;
+        vcs.Add(Translate(cce.NonNull(node.Args)[i]));
+        if (i == 0 && flipContextForArg0)
+            isPositiveContext = !isPositiveContext;
+      }
+
+      if (node.Type == null) {
+        System.Console.WriteLine("*** type is null for {0}", node);
+        Contract.Assert(false);
+        throw new cce.UnreachableException();
+      }
+
+      return IAppTranslator.Translate(node.Fun, node.Type, vcs,
+                                      ToList(cce.NonNull(node.TypeParameters)));
+    }
+
+
+    private static List<Type/*!*/>/*!*/ EMPTY_TYPE_LIST = new List<Type/*!*/>();
+    [ContractInvariantMethod]
+    void ObjectInvirant() {
+      Contract.Invariant(EMPTY_TYPE_LIST != null);
+    }
+
+
+    private List<Type/*!*/>/*!*/ ToList(TypeParamInstantiation insts) {
+      Contract.Requires(insts != null);
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
+      if (insts.FormalTypeParams.Count == 0)
+        return EMPTY_TYPE_LIST;
+
+      List<Type/*!*/>/*!*/ typeArgs = new List<Type/*!*/>();
+      foreach (TypeVariable/*!*/ var in insts.FormalTypeParams) {
+        Contract.Assert(var != null);
+        typeArgs.Add(insts[var]);
+      }
+      return typeArgs;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////
+
+    public override QuantifierExpr VisitQuantifierExpr(QuantifierExpr node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<QuantifierExpr>() != null);
+      Push(TranslateQuantifierExpr(node));
+      return node;
+    }
+
+    public override Expr VisitExistsExpr(ExistsExpr node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Expr>() != null);
+      node = (ExistsExpr)this.VisitQuantifierExpr(node);
+      return node;
+    }
+
+    public override Expr VisitForallExpr(ForallExpr node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Expr>() != null);
+      node = (ForallExpr)this.VisitQuantifierExpr(node);
+      return node;
+    }
+
+    private VCExpr TranslateQuantifierExpr(QuantifierExpr node) {
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<TypeVariable/*!*/>/*!*/ typeParams = new List<TypeVariable/*!*/>();
+      foreach (TypeVariable/*!*/ v in node.TypeParameters) {
+        Contract.Assert(v != null);
+        typeParams.Add(v);
+      }
+
+      PushBoundVariableScope();
+
+      List<VCExprVar/*!*/>/*!*/ boundVars = new List<VCExprVar/*!*/>();
+      foreach (Variable/*!*/ v in node.Dummies)
+        boundVars.Add(BindVariable(v));
+
+      try {
+        List<VCTrigger/*!*/>/*!*/ triggers = TranslateTriggers(node.Triggers);
+        VCExpr/*!*/ body = Translate(node.Body);
+        VCQuantifierInfos/*!*/ infos = GenerateQuantifierInfos(node);
+
+        Quantifier quan;
+        if (node is ForallExpr)
+          quan = Quantifier.ALL;
+        else if (node is ExistsExpr)
+          quan = Quantifier.EX;
+        else {
+          Contract.Assert(false);
+          throw new cce.UnreachableException();
+        }
+
+        return Gen.Quantify(quan, typeParams, boundVars, triggers, infos, body);
+      } finally {
+        PopBoundVariableScope();
+      }
+    }
+
+    private List<VCTrigger/*!*/>/*!*/ TranslateTriggers(Trigger node) {
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCTrigger>>()));
+      List<VCTrigger/*!*/>/*!*/ res = new List<VCTrigger/*!*/>();
+      Trigger curTrigger = node;
+      while (curTrigger != null) {
+        res.Add(Gen.Trigger(curTrigger.Pos, Translate(curTrigger.Tr)));
+        curTrigger = curTrigger.Next;
+      }
+      return res;
+    }
+
+    private VCQuantifierInfos GenerateQuantifierInfos(QuantifierExpr node) {
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCQuantifierInfos>() != null);
+      string qid = getQidNameFromQKeyValue(node.Dummies, node.Attributes);
+      return new VCQuantifierInfos(qid, node.SkolemId, false, node.Attributes);
+    }
+
+    private string getQidNameFromQKeyValue(List<Variable> vars, QKeyValue attributes) {
+      Contract.Requires(vars != null);
+      // Check for a 'qid, name' pair in keyvalues
+      string qid = QKeyValue.FindStringAttribute(attributes, "qid");
+      if (qid == null && vars.Count != 0) {
+        // generate default name (line:column position in .bpl file)
+        Variable v = vars[0];
+        Contract.Assert(v != null); // Rustan's claim!
+        // Include the first 8 characters of the filename in QID (helpful in case we use /concat)
+        // We limit it to 8, so the SX file doesn't grow too big, and who on earth would need
+        // more than 8 characters in a filename anyways.
+        int max = 8;
+        StringBuilder buf = new StringBuilder(max + 20);
+        string filename = v.tok.filename;
+        if (filename == null)
+          filename = "unknown";
+        for (int i = 0; i < filename.Length; ++i) {
+          if (filename[i] == '/' || filename[i] == '\\')
+            buf.Length = 0;
+          if (buf.Length < max && char.IsLetterOrDigit(filename[i])) {
+            if (buf.Length == 0 && char.IsDigit(filename[i])) {
+              // Z3 does not like QID's to start with a digit, so we prepend another character
+              buf.Append('_');
+            }
+            buf.Append(filename[i]);
+          }
+        }
+        buf.Append('.').Append(v.Line).Append(':').Append(v.Col);
+        qid = buf.ToString();
+      }
+      return qid;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////
+
+    public override Expr VisitBvExtractExpr(BvExtractExpr node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Expr>() != null);
+      Push(TranslateBvExtractExpr(node));
+      return node;
+    }
+
+    private VCExpr TranslateBvExtractExpr(BvExtractExpr node) {
+      Contract.Requires(node != null);
+      Contract.Requires((node.Start <= node.End));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExpr/*!*/ bv = Translate(node.Bitvector);
+      return Gen.BvExtract(bv, cce.NonNull(node.Bitvector.Type).BvBits, node.Start, node.End);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////
+
+    public override Expr VisitBvConcatExpr(BvConcatExpr node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Expr>() != null);
+      Push(TranslateBvConcatExpr(node));
+      return node;
+    }
+
+    private VCExpr TranslateBvConcatExpr(BvConcatExpr node) {
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExpr/*!*/ bv0 = Translate(node.E0);
+      VCExpr/*!*/ bv1 = Translate(node.E1);
+      return Gen.BvConcat(bv0, bv1);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////
+    // all the other cases should never happen
+
+    public override Cmd VisitAssertCmd(AssertCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Cmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Cmd VisitAssignCmd(AssignCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Cmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Cmd VisitAssumeCmd(AssumeCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Cmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override AtomicRE VisitAtomicRE(AtomicRE node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<AtomicRE>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Axiom VisitAxiom(Axiom node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Axiom>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Type VisitBasicType(BasicType node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Type>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Type VisitBvType(BvType node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Type>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Block VisitBlock(Block node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Block>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public CodeExprConverter codeExprConverter = null;
+    public void SetCodeExprConverter(CodeExprConverter f) {
+      this.codeExprConverter = f;
+    }
+    public override Expr/*!*/ VisitCodeExpr(CodeExpr/*!*/ codeExpr) {
+      //Contract.Requires(codeExpr != null);
+      Contract.Ensures(Contract.Result<Expr>() != null);
+      Contract.Assume(codeExprConverter != null);
+
+      Hashtable/*<Block, LetVariable!>*/ blockVariables = new Hashtable/*<Block, LetVariable!!>*/();
+      List<VCExprLetBinding/*!*/> bindings = new List<VCExprLetBinding/*!*/>();
+      VCExpr e = codeExprConverter(codeExpr, blockVariables, bindings, isPositiveContext);
+      Push(e);
+      return codeExpr;
+    }
+    public override List<Block> VisitBlockSeq(List<Block> blockSeq) {
+      //Contract.Requires(blockSeq != null);
+      Contract.Ensures(Contract.Result<List<Block>>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override List<Block/*!*/>/*!*/ VisitBlockList(List<Block/*!*/>/*!*/ blocks) {
+      //Contract.Requires(cce.NonNullElements(blocks));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<Block>>()));
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override BoundVariable VisitBoundVariable(BoundVariable node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<BoundVariable>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Cmd VisitCallCmd(CallCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Cmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Cmd VisitParCallCmd(ParCallCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Cmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override List<Cmd> VisitCmdSeq(List<Cmd> cmdSeq) {
+      //Contract.Requires(cmdSeq != null);
+      Contract.Ensures(Contract.Result<List<Cmd>>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Choice VisitChoice(Choice node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Choice>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Cmd VisitCommentCmd(CommentCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Cmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Constant VisitConstant(Constant node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Constant>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override CtorType VisitCtorType(CtorType node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<CtorType>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Declaration VisitDeclaration(Declaration node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Declaration>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override List<Declaration/*!*/>/*!*/ VisitDeclarationList(List<Declaration/*!*/>/*!*/ declarationList) {
+      //Contract.Requires(cce.NonNullElements(declarationList));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<Declaration>>()));
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override DeclWithFormals VisitDeclWithFormals(DeclWithFormals node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<DeclWithFormals>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Requires VisitRequires(Requires @requires) {
+      //Contract.Requires(@requires != null);
+      Contract.Ensures(Contract.Result<Requires>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override List<Requires> VisitRequiresSeq(List<Requires> requiresSeq) {
+      //Contract.Requires(requiresSeq != null);
+      Contract.Ensures(Contract.Result<List<Requires>>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Ensures VisitEnsures(Ensures @ensures) {
+      //Contract.Requires(@ensures != null);
+      Contract.Ensures(Contract.Result<Ensures>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override List<Ensures> VisitEnsuresSeq(List<Ensures> ensuresSeq) {
+      //Contract.Requires(ensuresSeq != null);
+      Contract.Ensures(Contract.Result<List<Ensures>>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Formal VisitFormal(Formal node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Formal>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Function VisitFunction(Function node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Function>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override GlobalVariable VisitGlobalVariable(GlobalVariable node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<GlobalVariable>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override GotoCmd VisitGotoCmd(GotoCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<GotoCmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Cmd VisitHavocCmd(HavocCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Cmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Implementation VisitImplementation(Implementation node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Implementation>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override LocalVariable VisitLocalVariable(LocalVariable node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<LocalVariable>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override AssignLhs VisitMapAssignLhs(MapAssignLhs node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<AssignLhs>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override MapType VisitMapType(MapType node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<MapType>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Procedure VisitProcedure(Procedure node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Procedure>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Program VisitProgram(Program node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Program>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Cmd VisitRE(RE node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Cmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override List<RE> VisitRESeq(List<RE> reSeq) {
+      //Contract.Requires(reSeq != null);
+      Contract.Ensures(Contract.Result<List<RE>>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override ReturnCmd VisitReturnCmd(ReturnCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<ReturnCmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override ReturnExprCmd VisitReturnExprCmd(ReturnExprCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<ReturnExprCmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Sequential VisitSequential(Sequential node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Sequential>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override AssignLhs VisitSimpleAssignLhs(SimpleAssignLhs node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<AssignLhs>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Cmd VisitStateCmd(StateCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Cmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override TransferCmd VisitTransferCmd(TransferCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<TransferCmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Trigger VisitTrigger(Trigger node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Trigger>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Type VisitType(Type node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Type>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override TypedIdent VisitTypedIdent(TypedIdent node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<TypedIdent>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Type VisitTypeSynonymAnnotation(TypeSynonymAnnotation node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Type>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Type VisitTypeVariable(TypeVariable node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Type>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Variable VisitVariable(Variable node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Variable>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override List<Variable> VisitVariableSeq(List<Variable> variableSeq) {
+      //Contract.Requires(variableSeq != null);
+      Contract.Ensures(Contract.Result<List<Variable>>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Cmd VisitAssertEnsuresCmd(AssertEnsuresCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Cmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public override Cmd VisitAssertRequiresCmd(AssertRequiresCmd node) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Cmd>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+
+  }
+
+
+  /////////////////////////////////////////////////////////////////////////////////
+
+  public class IAppliableTranslator : IAppliableVisitor<VCExpr/*!*/> {
+
+    private readonly Boogie2VCExprTranslator/*!*/ BaseTranslator;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(BaseTranslator != null);
+    }
+
+
+    private VCExpressionGenerator/*!*/ Gen {
+      get {
+        Contract.Ensures(Contract.Result<VCExpressionGenerator>() != null);
+
+        return BaseTranslator.Gen;
+      }
+    }
+    private VCGenerationOptions GenerationOptions {
+      get {
+        Contract.Ensures(Contract.Result<VCGenerationOptions>() != null);
+
+        return BaseTranslator.GenerationOptions;
+      }
+    }
+
+    public IAppliableTranslator(Boogie2VCExprTranslator baseTranslator) {
+      Contract.Requires(baseTranslator != null);
+      this.BaseTranslator = baseTranslator;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+
+    private List<VCExpr/*!*/>/*!*/ args = new List<VCExpr/*!*/>();
+    private List<Type/*!*/>/*!*/ typeArgs = new List<Type/*!*/>();
+    [ContractInvariantMethod]
+    void ObjectInvarianet() {
+      Contract.Invariant(args != null);
+      Contract.Invariant(typeArgs != null);
+    }
+
+
+    public VCExpr Translate(IAppliable app, Type ty, List<VCExpr/*!*/>/*!*/ args, List<Type/*!*/>/*!*/ typeArgs) {
+      Contract.Requires(ty != null);
+      Contract.Requires(app != null);
+      Contract.Requires(cce.NonNullElements(typeArgs));
+      Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      List<VCExpr/*!*/>/*!*/ oldArgs = this.args;
+      List<Type/*!*/>/*!*/ oldTypeArgs = this.typeArgs;
+      this.args = args;
+      this.typeArgs = typeArgs;
+      VCExpr/*!*/ result = app.Dispatch<VCExpr/*!*/>(this);
+      this.args = oldArgs;
+      this.typeArgs = oldTypeArgs;
+      return result;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+
+
+
+    public VCExpr Visit(UnaryOperator unaryOperator) {
+      //Contract.Requires(unaryOperator != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      Contract.Assert(unaryOperator.Op == UnaryOperator.Opcode.Neg || unaryOperator.Op == UnaryOperator.Opcode.Not);
+      Contract.Assert(this.args.Count == 1);
+      if (unaryOperator.Op == UnaryOperator.Opcode.Neg) {
+        VCExpr e = cce.NonNull(this.args[0]);
+        if (cce.NonNull(e.Type).IsInt) {
+          return Gen.Function(VCExpressionGenerator.SubIOp, Gen.Integer(BigNum.ZERO), e);
+        }
+        else {// if (cce.NonNull(e.Type).IsReal) {
+          return Gen.Function(VCExpressionGenerator.SubROp, Gen.Real(BigDec.ZERO), e);
+        }
+        //else  {//is float
+          //return Gen.Function(VCExpressionGenerator.SubFOp, Gen.Float(BigFloat.ZERO(8, 23)), e);
+        //} 
+      }
+      else {
+        return Gen.Not(this.args);
+      }
+    }
+
+    public VCExpr Visit(BinaryOperator binaryOperator) {
+      //Contract.Requires(binaryOperator != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return TranslateBinaryOperator(binaryOperator, this.args);
+    }
+
+    public VCExpr Visit(FunctionCall functionCall) {
+      //Contract.Requires(functionCall != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return TranslateFunctionCall(functionCall, this.args, this.typeArgs);
+    }
+
+    public VCExpr Visit(MapSelect mapSelect) {
+      //Contract.Requires(mapSelect != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Gen.Select(this.args, this.typeArgs);
+    }
+
+    public VCExpr Visit(MapStore mapStore) {
+      //Contract.Requires(mapStore != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Gen.Store(this.args, this.typeArgs);
+    }
+
+    public VCExpr Visit(TypeCoercion typeCoercion) {
+      //Contract.Requires(typeCoercion != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      Contract.Assert(this.args.Count == 1);
+      return this.args[0];
+    }
+
+    public VCExpr Visit(ArithmeticCoercion arithCoercion) {
+      //Contract.Requires(arithCoercion != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      Contract.Assert(this.args.Count == 1);
+      switch (arithCoercion.Coercion) {
+        case ArithmeticCoercion.CoercionType.ToInt:
+          return Gen.Function(VCExpressionGenerator.ToIntOp, this.args);
+        case ArithmeticCoercion.CoercionType.ToReal:
+          return Gen.Function(VCExpressionGenerator.ToRealOp, this.args);
+        default:
+          Contract.Assert(false);
+          return null;
+      }
+    }
+
+    public VCExpr Visit(IfThenElse ite) {
+      //Contract.Requires(ite != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Gen.Function(VCExpressionGenerator.IfThenElseOp, this.args);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+
+    private VCExpr TranslateBinaryOperator(BinaryOperator app, List<VCExpr/*!*/>/*!*/ args) {
+      Contract.Requires(app != null);
+      Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      Contract.Assert(args.Count == 2);
+      Type t = cce.NonNull(cce.NonNull(args[0]).Type);
+
+      switch (app.Op) {
+        case BinaryOperator.Opcode.Add:
+          if (t.IsInt) {
+            return Gen.Function(VCExpressionGenerator.AddIOp, args);
+          }
+          else if (t.IsReal) {
+            return Gen.Function(VCExpressionGenerator.AddROp, args);
+          }
+          else { //t is float
+            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "+"), args);
+          }
+        case BinaryOperator.Opcode.Sub:
+          if (t.IsInt) {
+            return Gen.Function(VCExpressionGenerator.SubIOp, args);
+          }
+          else if (t.IsReal) {
+            return Gen.Function(VCExpressionGenerator.SubROp, args);
+          }
+          else { //t is float
+            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "-"), args);
+          }
+        case BinaryOperator.Opcode.Mul:
+          if (t.IsInt) {
+            return Gen.Function(VCExpressionGenerator.MulIOp, args);
+          }
+          else if (t.IsReal) {
+            return Gen.Function(VCExpressionGenerator.MulROp, args);
+          }
+          else
+          { //t is float
+            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "*"), args);
+          }
+        case BinaryOperator.Opcode.Div:
+          return Gen.Function(VCExpressionGenerator.DivIOp, args);
+        case BinaryOperator.Opcode.Mod:
+          return Gen.Function(VCExpressionGenerator.ModOp, args);
+        case BinaryOperator.Opcode.RealDiv:
+          if (t.IsFloat) {
+            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "/"), args);
+          }
+          VCExpr arg0 = cce.NonNull(args[0]);
+          VCExpr arg1 = cce.NonNull(args[1]);
+          if (cce.NonNull(arg0.Type).IsInt) {
+            arg0 = Gen.Function(VCExpressionGenerator.ToRealOp, arg0);
+          }
+          if (cce.NonNull(arg1.Type).IsInt) {
+            arg1 = Gen.Function(VCExpressionGenerator.ToRealOp, arg1);
+          }
+          return Gen.Function(VCExpressionGenerator.DivROp, arg0, arg1);
+        case BinaryOperator.Opcode.Pow:
+          return Gen.Function(VCExpressionGenerator.PowOp, args);
+        case BinaryOperator.Opcode.Eq:
+        case BinaryOperator.Opcode.Iff:
+          // we don't distinguish between equality and equivalence at this point
+          if (t.IsFloat)
+            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "=="), args);
+          return Gen.Function(VCExpressionGenerator.EqOp, args);
+        case BinaryOperator.Opcode.Neq:
+          return Gen.Function(VCExpressionGenerator.NeqOp, args);
+        case BinaryOperator.Opcode.Lt:
+          if (t.IsFloat)
+            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "<"), args);
+          return Gen.Function(VCExpressionGenerator.LtOp, args);
+        case BinaryOperator.Opcode.Le:
+          if (t.IsFloat)
+            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, "<="), args);
+          return Gen.Function(VCExpressionGenerator.LeOp, args);
+        case BinaryOperator.Opcode.Ge:
+          if (t.IsFloat)
+            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, ">="), args);
+          return Gen.Function(VCExpressionGenerator.GeOp, args);
+        case BinaryOperator.Opcode.Gt:
+          if (t.IsFloat)
+            return Gen.Function(Gen.BinaryFloatOp(t.FloatExponent, t.FloatMantissa, ">"), args);
+          return Gen.Function(VCExpressionGenerator.GtOp, args);
+        case BinaryOperator.Opcode.Imp:
+          return Gen.Function(VCExpressionGenerator.ImpliesOp, args);
+        case BinaryOperator.Opcode.And:
+          return Gen.Function(VCExpressionGenerator.AndOp, args);
+        case BinaryOperator.Opcode.Or:
+          return Gen.Function(VCExpressionGenerator.OrOp, args);
+        case BinaryOperator.Opcode.Subtype:
+          return Gen.Function(VCExpressionGenerator.SubtypeOp, args);
+        default:
+          Contract.Assert(false);
+          throw new cce.UnreachableException();  // unexpected binary operator
+      }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+
+    private VCExpr/*!*/ TranslateFunctionCall(FunctionCall app, List<VCExpr/*!*/>/*!*/ args, List<Type/*!*/>/*!*/ typeArgs) {
+      Contract.Requires(cce.NonNullElements(args));
+      Contract.Requires(cce.NonNullElements(typeArgs));
+      Contract.Requires(app != null);
+      Contract.Requires((app.Func != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);    // resolution must have happened
+
+      VCExpr res = ApplyExpansion(app, args, typeArgs);
+      if (res != null)
+        return res;
+
+      VCExprOp/*!*/ functionOp = Gen.BoogieFunctionOp(app.Func);
+      return Gen.Function(functionOp, args, typeArgs);
+    }
+
+    private VCExpr ApplyExpansion(FunctionCall app, List<VCExpr/*!*/>/*!*/ args, List<Type/*!*/>/*!*/ typeArgs) {
+      Contract.Requires(app != null);
+      Contract.Requires(cce.NonNullElements(args));
+      Contract.Requires(cce.NonNullElements(typeArgs));
+      Contract.Assert(app.Func != null);    // resolution must have happened
+
+      lock (app.Func)
+      {
+        if (app.Func.doingExpansion)
+        {
+          System.Console.WriteLine("*** detected expansion loop on {0}", app.Func);
+          return null;
+        }
+
+        var exp = app.Func.Body;
+        if (exp == null)
+          return null;
+
+        VCExpr/*!*/ translatedBody;
+        VCExprSubstitution/*!*/ subst = new VCExprSubstitution();
+        try
+        {
+          BaseTranslator.PushFormalsScope();
+          BaseTranslator.PushBoundVariableScope();
+          app.Func.doingExpansion = true;
+
+          // first bind the formals to VCExpr variables, which are later
+          // substituted with the actual parameters
+          var inParams = app.Func.InParams;
+          for (int i = 0; i < inParams.Count; ++i)
+            subst[BaseTranslator.BindVariable(inParams[i])] = args[i];
+
+          // recursively translate the body of the expansion
+          translatedBody = BaseTranslator.Translate(exp);
+        }
+        finally
+        {
+          BaseTranslator.PopFormalsScope();
+          BaseTranslator.PopBoundVariableScope();
+          app.Func.doingExpansion = false;
+        }
+
+        // substitute the formals with the actual parameters in the body
+        var tparms = app.Func.TypeParameters;
+        Contract.Assert(typeArgs.Count == tparms.Count);
+        for (int i = 0; i < typeArgs.Count; ++i)
+          subst[tparms[i]] = typeArgs[i];
+        SubstitutingVCExprVisitor/*!*/ substituter = new SubstitutingVCExprVisitor(Gen);
+        return substituter.Mutate(translatedBody, subst);
+      }
+    }
+  }
+}
diff --git a/Source/VCExpr/Clustering.cs b/Source/VCExpr/Clustering.cs
index 1ab10107..a799aaae 100644
--- a/Source/VCExpr/Clustering.cs
+++ b/Source/VCExpr/Clustering.cs
@@ -1,522 +1,522 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Linq;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-using Microsoft.Boogie.VCExprAST;
-
-// Code for managing and clusterings sets of terms; this is used to
-// compress the input given to the theorem prover
-
-namespace Microsoft.Boogie.Clustering {
-  using Microsoft.Boogie.VCExprAST;
-
-
-  public class SubtermCollector : BoundVarTraversingVCExprVisitor<bool, bool> {
-
-    private readonly VCExpressionGenerator/*!*/ Gen;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Gen != null);
-      Contract.Invariant(cce.NonNullDictionaryAndValues(GlobalVariables));
-      Contract.Invariant(cce.NonNullDictionaryAndValues(SubtermClusters));
-    }
-
-
-    public SubtermCollector(VCExpressionGenerator gen) {
-      Contract.Requires(gen != null);
-      Gen = gen;
-    }
-
-    // variables that are global and treated like constants
-    private readonly IDictionary<VCExprVar/*!*/, VCExprVar/*!*/> GlobalVariables = new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/>();
-
-    private readonly IDictionary<VCExprOp/*!*/, TermClustersSameHead/*!*/> SubtermClusters =
-      new Dictionary<VCExprOp/*!*/, TermClustersSameHead/*!*/>();
-
-    public void UnifyClusters() {
-      foreach (KeyValuePair<VCExprOp/*!*/, TermClustersSameHead/*!*/> pair
-                 in SubtermClusters) {
-        Contract.Assert(cce.NonNullElements(pair));
-        pair.Value.UnifyClusters();
-      }
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    protected override bool StandardResult(VCExpr node, bool arg) {
-      //Contract.Requires(node != null);
-      return false;   // by default, do not collect terms containing node
-    }
-
-    public override bool Visit(VCExprLiteral node, bool arg) {
-      Contract.Requires(node != null);
-      return true;
-    }
-
-    public override bool Visit(VCExprNAry node, bool arg) {
-      Contract.Requires(node != null);
-      VCExprBoogieFunctionOp op = node.Op as VCExprBoogieFunctionOp;
-      if (op == null) {
-        base.Visit(node, arg);
-        return false;
-      }
-
-      bool res = true;
-      foreach (VCExpr subexpr in node) {
-        Contract.Assert(subexpr != null);
-        res &= this.Traverse(subexpr, arg);
-      }
-
-      if (res) {
-        TermClustersSameHead clusters;
-        if (!SubtermClusters.TryGetValue(op, out clusters)) {
-          clusters = new TermClustersSameHead(op, GlobalVariables, Gen);
-          SubtermClusters.Add(op, clusters);
-        }
-        cce.NonNull(clusters).AddExpr(node);
-      }
-
-      return res;
-    }
-
-    public override bool Visit(VCExprVar node, bool arg) {
-      Contract.Requires(node != null);
-      if (!BoundTermVars.Contains(node))
-        GlobalVariables[node] = node;
-      return true;
-    }
-
-    [Pure]
-    public override string ToString() {
-      Contract.Ensures(Contract.Result<string>() != null);
-      string/*!*/ res = "";
-      foreach (KeyValuePair<VCExprOp/*!*/, TermClustersSameHead/*!*/> pair
-                 in SubtermClusters) {
-        Contract.Assert(cce.NonNullElements(pair));
-        res = res + pair.Value + "\n";
-      }
-      return res;
-    }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  // Class for managing and clustering a set of terms that all start
-  // with the same function symbol
-  internal class TermClustersSameHead {
-
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Op != null);
-      Contract.Invariant(Gen != null);
-      Contract.Invariant(cce.NonNullDictionaryAndValues(GlobalVariables));
-    }
-    // variables that are global and treated like constants
-    private readonly IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ GlobalVariables;
-    public readonly VCExprOp/*!*/ Op;
-    private readonly VCExpressionGenerator/*!*/ Gen;
-
-    public TermClustersSameHead(VCExprOp op, IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars, VCExpressionGenerator/*!*/ gen) {
-      Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
-      Contract.Requires(gen != null);
-      Contract.Requires(op != null);
-      Op = op;
-      GlobalVariables = globalVars;
-      Gen = gen;
-    }
-
-    private readonly List<Cluster>/*!*/ Clusters = new List<Cluster>();
-
-    private struct Cluster {
-      public readonly VCExprNAry/*!*/ Generator;
-      public readonly int Size;
-      [ContractInvariantMethod]
-      void ObjectInvariant() {
-        Contract.Invariant(Generator != null);
-      }
-
-      public Cluster(VCExprNAry generator, int size) {
-        Contract.Requires(generator != null);
-        Generator = generator;
-        Size = size;
-      }
-    }
-
-    private int Distance(Cluster a, Cluster b) {
-      AntiUnificationVisitor/*!*/ visitor = new AntiUnificationVisitor(Gen);
-      visitor.AntiUnify(a.Generator, b.Generator);
-
-      int reprSizeA, reprSizeB;
-      visitor.RepresentationSize(GlobalVariables, out reprSizeA, out reprSizeB);
-      return (a.Size - 1) * reprSizeA + (b.Size - 1) * reprSizeB;
-    }
-
-    private bool EqualUpToRenaming(Cluster a, Cluster b) {
-      AntiUnificationVisitor/*!*/ visitor = new AntiUnificationVisitor(Gen);
-      visitor.AntiUnify(a.Generator, b.Generator);
-      return visitor.RepresentationIsRenaming(GlobalVariables);
-    }
-
-    private Cluster Merge(Cluster a, Cluster b) {
-      AntiUnificationVisitor/*!*/ visitor = new AntiUnificationVisitor(Gen);
-      VCExpr/*!*/ generator = visitor.AntiUnify(a.Generator, b.Generator);
-      Contract.Assert(generator != null);
-      VCExprNAry generatorNAry = generator as VCExprNAry;
-      Contract.Assert(generatorNAry != null && Op.Equals(generatorNAry.Op));
-      return new Cluster(generatorNAry, a.Size + b.Size);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public void AddExpr(VCExprNAry expr) {
-      Contract.Requires(expr != null);
-      Contract.Requires(Op.Equals(expr.Op));
-
-      Cluster c = new Cluster(expr, 1);
-      for (int i = 0; i < Clusters.Count; ++i) {
-        Cluster d = Clusters[i];
-        if (EqualUpToRenaming(c, d)) {
-          Clusters[i] = new Cluster(d.Generator, d.Size + 1);
-          return;
-        }
-      }
-
-      Clusters.Add(c);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    private struct ClusteringMatrix {
-
-      private readonly VCExpressionGenerator/*!*/ Gen;
-      private readonly IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ GlobalVariables;
-
-      public readonly List<Cluster>/*!*/ Clusters;
-      public readonly bool[]/*!*/ RemainingClusters;
-
-      public readonly Distance[,]/*!*/ Distances;
-
-      [ContractInvariantMethod]
-      void ObjectInvariant() {
-        Contract.Invariant(Gen != null);
-        Contract.Invariant(cce.NonNullDictionaryAndValues(GlobalVariables));
-        Contract.Invariant(Clusters != null);
-        Contract.Invariant(RemainingClusters != null);
-        Contract.Invariant(Distances != null);
-      }
-
-
-      public struct Distance {
-        public readonly int Dist;
-        public readonly VCExprNAry/*!*/ Generator;
-
-        public Distance(Cluster a, Cluster b, IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars, VCExpressionGenerator gen) {
-          Contract.Requires(gen != null);
-          Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
-          AntiUnificationVisitor/*!*/ visitor = new AntiUnificationVisitor(gen);
-          Generator = (VCExprNAry)visitor.AntiUnify(a.Generator, b.Generator);
-
-          int reprSizeA, reprSizeB;
-          visitor.RepresentationSize(globalVars, out reprSizeA, out reprSizeB);
-          Dist = (a.Size - 1) * reprSizeA + (b.Size - 1) * reprSizeB;
-        }
-      }
-
-      public ClusteringMatrix(List<Cluster> clusters, IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars, VCExpressionGenerator gen) {
-        Contract.Requires(gen != null);
-        Contract.Requires(clusters != null);
-        Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
-        List<Cluster> c = new List<Cluster>();
-        c.AddRange(clusters);
-        Clusters = c;
-
-        GlobalVariables = globalVars;
-        Gen = gen;
-
-        bool[] remaining = new bool[clusters.Count];
-        RemainingClusters = remaining;
-        for (int i = 0; i < remaining.Length; ++i)
-          remaining[i] = true;
-
-        Distance[,]/*!*/ distances = new Distance[clusters.Count, clusters.Count];
-        Distances = distances;
-        for (int i = 1; i < clusters.Count; ++i)
-          for (int j = 0; j < i; ++j)
-            distances[i, j] =
-              new Distance(clusters[i], clusters[j], GlobalVariables, Gen);
-      }
-
-      public void UnifyClusters(int maxDist) {
-        while (true) {
-          int i, j;
-          int minDist = FindMinDistance(out i, out j);
-
-          if (minDist > maxDist)
-            return;
-
-          MergeClusters(i, j);
-        }
-      }
-
-      public void ResultingClusters(List<Cluster> clusters) {
-        Contract.Requires(clusters != null);
-        clusters.Clear();
-        for (int i = 0; i < Clusters.Count; ++i)
-          if (RemainingClusters[i])
-            clusters.Add(Clusters[i]);
-      }
-
-      //////////////////////////////////////////////////////////////////////////
-
-      private void Update(int i) {
-        for (int j = 0; j < i; ++j) {
-          if (RemainingClusters[j])
-            Distances[i, j] =
-              new Distance(Clusters[i], Clusters[j], GlobalVariables, Gen);
-        }
-        for (int j = i + 1; j < Clusters.Count; ++j) {
-          if (RemainingClusters[j])
-            Distances[j, i] =
-              new Distance(Clusters[j], Clusters[i], GlobalVariables, Gen);
-        }
-      }
-
-      private int FindMinDistance(out int c0, out int c1) {
-        int minDist = int.MaxValue;
-        c0 = -1;
-        c1 = -1;
-
-        for (int i = 0; i < Clusters.Count; ++i)
-          if (RemainingClusters[i]) {
-            for (int j = 0; j < i; ++j)
-              if (RemainingClusters[j]) {
-                if (Distances[i, j].Dist < minDist) {
-                  minDist = Distances[i, j].Dist;
-                  c0 = i;
-                  c1 = j;
-                }
-              }
-          }
-
-        Contract.Assert(c0 == -1 && c1 == -1 || c0 > c1 && c1 >= 0);
-        return minDist;
-      }
-
-      private void MergeClusters(int i, int j) {
-        Contract.Requires(j >= 0 && i > j && RemainingClusters[i] && RemainingClusters[j]);
-        Clusters[i] = new Cluster(Distances[i, j].Generator,
-                                   Clusters[i].Size + Clusters[j].Size);
-        RemainingClusters[j] = false;
-        Update(i);
-      }
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public void UnifyClusters() {
-      ClusteringMatrix matrix =
-        new ClusteringMatrix(Clusters, GlobalVariables, Gen);
-      matrix.UnifyClusters(50);
-      matrix.ResultingClusters(Clusters);
-    }
-
-    [Pure]
-    public override string ToString() {
-      Contract.Ensures(Contract.Result<string>() != null);
-      string/*!*/ res = "";
-      foreach (Cluster c in Clusters)
-        res = res + c.Generator + "\t" + c.Size + "\n";
-      return res;
-    }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  internal class AntiUnificationVisitor : TraversingVCExprVisitor<VCExpr/*!*/, VCExpr/*!*/> {
-
-    private readonly VCExpressionGenerator/*!*/ Gen;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Gen != null);
-      Contract.Invariant(cce.NonNullDictionaryAndValues(Representation));
-    }
-
-
-    public AntiUnificationVisitor(VCExpressionGenerator gen) {
-      Contract.Requires(gen != null);
-      Gen = gen;
-    }
-
-    // Sub-expressions in the first and second expression to be
-    // anti-unified that are replaced with variables
-    private readonly IDictionary<ExprPair, VCExprVar/*!*/>/*!*/ Representation =
-      new Dictionary<ExprPair, VCExprVar/*!*/>();
-
-
-
-    private struct ExprPair {
-      public readonly VCExpr/*!*/ Expr0, Expr1;
-      [ContractInvariantMethod]
-      void ObjectInvariant() {
-        Contract.Invariant(Expr0 != null);
-        Contract.Invariant(Expr1 != null);
-      }
-
-      public ExprPair(VCExpr expr0, VCExpr expr1) {
-        Contract.Requires(expr1 != null);
-        Contract.Requires(expr0 != null);
-        Expr0 = expr0;
-        Expr1 = expr1;
-      }
-      [Pure]
-      [Reads(ReadsAttribute.Reads.Nothing)]
-      public override bool Equals(object that) {
-        if (that is ExprPair) {
-          ExprPair thatPair = (ExprPair)that;
-          return this.Expr0.Equals(thatPair.Expr0) &&
-                 this.Expr1.Equals(thatPair.Expr1);
-        }
-        return false;
-      }
-      [Pure]
-      public override int GetHashCode() {
-        return Expr0.GetHashCode() + Expr1.GetHashCode() * 13;
-      }
-    }
-
-    public void Reset() {
-      Representation.Clear();
-    }
-
-    public bool RepresentationIsRenaming(IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars) {
-      Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
-      if (!Representation.Any(pair => pair.Key.Expr0 is VCExprVar && pair.Key.Expr1 is VCExprVar && !globalVars.ContainsKey(cce.NonNull((VCExprVar)pair.Key.Expr0)) && !globalVars.ContainsKey(cce.NonNull((VCExprVar/*!*/)pair.Key.Expr1))))
-        return false;
-      // check that all substituted variables are distinct
-      // TODO: optimise
-      return
-        Representation.All(pair1 => Representation.All(pair2 => pair1.Value.Equals(pair2.Value) || !pair1.Key.Expr0.Equals(pair2.Key.Expr0) && !pair1.Key.Expr1.Equals(pair2.Key.Expr1)));
-    }
-
-    public void RepresentationSize(IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars, out int expr0Size, out int expr1Size) {
-      Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
-      ReprSizeComputingVisitor/*!*/ size0Visitor = new ReprSizeComputingVisitor();
-      ReprSizeComputingVisitor/*!*/ size1Visitor = new ReprSizeComputingVisitor();
-
-      foreach (KeyValuePair<ExprPair, VCExprVar/*!*/> pair in Representation) {
-        Contract.Assert(pair.Value != null);
-        size0Visitor.ComputeSize(pair.Key.Expr0, globalVars);
-        size1Visitor.ComputeSize(pair.Key.Expr1, globalVars);
-      }
-
-      expr0Size = size0Visitor.Size;
-      expr1Size = size1Visitor.Size;
-    }
-
-    public VCExpr AntiUnify(VCExpr s, VCExpr t) {
-      Contract.Requires(t != null);
-      Contract.Requires(s != null);
-      Contract.Requires((s.Type.Equals(t.Type)));
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Traverse(s, t);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    private VCExprVar AbstractWithVariable(VCExpr s, VCExpr t) {
-      Contract.Requires(t != null);
-      Contract.Requires(s != null);
-      Contract.Requires((s.Type.Equals(t.Type)));
-Contract.Ensures(Contract.Result<VCExprVar>() != null);
-
-      ExprPair pair = new ExprPair(s, t);
-      VCExprVar repr;
-      if (!Representation.TryGetValue(pair, out repr)) {
-        repr = Gen.Variable("abs" + Representation.Count, s.Type);
-        Representation.Add(pair, repr);
-      }
-      return cce.NonNull(repr);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public override VCExpr Visit(VCExprLiteral node, VCExpr that) {
-      Contract.Requires(that != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (node.Equals(that))
-        return node;
-      return AbstractWithVariable(node, that);
-    }
-
-    public override VCExpr Visit(VCExprNAry node, VCExpr that) {
-      Contract.Requires(that != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExprNAry thatNAry = that as VCExprNAry;
-      if (thatNAry != null && node.Op.Equals(thatNAry.Op)) {
-        // type parameters should already have been eliminated at this
-        // stage
-        Contract.Assert(node.TypeParamArity == 0 && thatNAry.TypeParamArity == 0 && node.Arity == thatNAry.Arity);
-
-        List<VCExpr/*!*/>/*!*/ unifiedArgs = new List<VCExpr/*!*/>();
-        for (int i = 0; i < node.Arity; ++i)
-          unifiedArgs.Add(Traverse(node[i], thatNAry[i]));
-
-        return Gen.Function(node.Op, unifiedArgs);
-      }
-      return AbstractWithVariable(node, that);
-    }
-
-    public override VCExpr Visit(VCExprVar node, VCExpr that) {
-      Contract.Requires(that != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (node.Equals(that))
-        return node;
-      return AbstractWithVariable(node, that);
-    }
-
-    protected override VCExpr StandardResult(VCExpr node, VCExpr that) {
-      //Contract.Requires(that != null);
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException(); // not handled here      
-    }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  internal class ReprSizeComputingVisitor
-                 : TraversingVCExprVisitor<bool,
-    // variables considered as global constants
-                                           IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/> {
-
-    public int Size = 0;
-
-    public void ComputeSize(VCExpr expr, IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars) {
-      Contract.Requires(expr != null);
-      Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
-      Traverse(expr, globalVars);
-    }
-
-    protected override bool StandardResult(VCExpr node, IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars) {
-      //Contract.Requires(node != null);
-      //Contract.Requires(cce.NonNullElements(globalVars));
-      VCExprVar nodeAsVar = node as VCExprVar;
-      if (nodeAsVar == null || globalVars.ContainsKey(nodeAsVar))
-        Size = Size + 1;
-      return true;
-    }
-  }
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+using Microsoft.Boogie.VCExprAST;
+
+// Code for managing and clusterings sets of terms; this is used to
+// compress the input given to the theorem prover
+
+namespace Microsoft.Boogie.Clustering {
+  using Microsoft.Boogie.VCExprAST;
+
+
+  public class SubtermCollector : BoundVarTraversingVCExprVisitor<bool, bool> {
+
+    private readonly VCExpressionGenerator/*!*/ Gen;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Gen != null);
+      Contract.Invariant(cce.NonNullDictionaryAndValues(GlobalVariables));
+      Contract.Invariant(cce.NonNullDictionaryAndValues(SubtermClusters));
+    }
+
+
+    public SubtermCollector(VCExpressionGenerator gen) {
+      Contract.Requires(gen != null);
+      Gen = gen;
+    }
+
+    // variables that are global and treated like constants
+    private readonly IDictionary<VCExprVar/*!*/, VCExprVar/*!*/> GlobalVariables = new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/>();
+
+    private readonly IDictionary<VCExprOp/*!*/, TermClustersSameHead/*!*/> SubtermClusters =
+      new Dictionary<VCExprOp/*!*/, TermClustersSameHead/*!*/>();
+
+    public void UnifyClusters() {
+      foreach (KeyValuePair<VCExprOp/*!*/, TermClustersSameHead/*!*/> pair
+                 in SubtermClusters) {
+        Contract.Assert(cce.NonNullElements(pair));
+        pair.Value.UnifyClusters();
+      }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    protected override bool StandardResult(VCExpr node, bool arg) {
+      //Contract.Requires(node != null);
+      return false;   // by default, do not collect terms containing node
+    }
+
+    public override bool Visit(VCExprLiteral node, bool arg) {
+      Contract.Requires(node != null);
+      return true;
+    }
+
+    public override bool Visit(VCExprNAry node, bool arg) {
+      Contract.Requires(node != null);
+      VCExprBoogieFunctionOp op = node.Op as VCExprBoogieFunctionOp;
+      if (op == null) {
+        base.Visit(node, arg);
+        return false;
+      }
+
+      bool res = true;
+      foreach (VCExpr subexpr in node) {
+        Contract.Assert(subexpr != null);
+        res &= this.Traverse(subexpr, arg);
+      }
+
+      if (res) {
+        TermClustersSameHead clusters;
+        if (!SubtermClusters.TryGetValue(op, out clusters)) {
+          clusters = new TermClustersSameHead(op, GlobalVariables, Gen);
+          SubtermClusters.Add(op, clusters);
+        }
+        cce.NonNull(clusters).AddExpr(node);
+      }
+
+      return res;
+    }
+
+    public override bool Visit(VCExprVar node, bool arg) {
+      Contract.Requires(node != null);
+      if (!BoundTermVars.Contains(node))
+        GlobalVariables[node] = node;
+      return true;
+    }
+
+    [Pure]
+    public override string ToString() {
+      Contract.Ensures(Contract.Result<string>() != null);
+      string/*!*/ res = "";
+      foreach (KeyValuePair<VCExprOp/*!*/, TermClustersSameHead/*!*/> pair
+                 in SubtermClusters) {
+        Contract.Assert(cce.NonNullElements(pair));
+        res = res + pair.Value + "\n";
+      }
+      return res;
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  // Class for managing and clustering a set of terms that all start
+  // with the same function symbol
+  internal class TermClustersSameHead {
+
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Op != null);
+      Contract.Invariant(Gen != null);
+      Contract.Invariant(cce.NonNullDictionaryAndValues(GlobalVariables));
+    }
+    // variables that are global and treated like constants
+    private readonly IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ GlobalVariables;
+    public readonly VCExprOp/*!*/ Op;
+    private readonly VCExpressionGenerator/*!*/ Gen;
+
+    public TermClustersSameHead(VCExprOp op, IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars, VCExpressionGenerator/*!*/ gen) {
+      Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
+      Contract.Requires(gen != null);
+      Contract.Requires(op != null);
+      Op = op;
+      GlobalVariables = globalVars;
+      Gen = gen;
+    }
+
+    private readonly List<Cluster>/*!*/ Clusters = new List<Cluster>();
+
+    private struct Cluster {
+      public readonly VCExprNAry/*!*/ Generator;
+      public readonly int Size;
+      [ContractInvariantMethod]
+      void ObjectInvariant() {
+        Contract.Invariant(Generator != null);
+      }
+
+      public Cluster(VCExprNAry generator, int size) {
+        Contract.Requires(generator != null);
+        Generator = generator;
+        Size = size;
+      }
+    }
+
+    private int Distance(Cluster a, Cluster b) {
+      AntiUnificationVisitor/*!*/ visitor = new AntiUnificationVisitor(Gen);
+      visitor.AntiUnify(a.Generator, b.Generator);
+
+      int reprSizeA, reprSizeB;
+      visitor.RepresentationSize(GlobalVariables, out reprSizeA, out reprSizeB);
+      return (a.Size - 1) * reprSizeA + (b.Size - 1) * reprSizeB;
+    }
+
+    private bool EqualUpToRenaming(Cluster a, Cluster b) {
+      AntiUnificationVisitor/*!*/ visitor = new AntiUnificationVisitor(Gen);
+      visitor.AntiUnify(a.Generator, b.Generator);
+      return visitor.RepresentationIsRenaming(GlobalVariables);
+    }
+
+    private Cluster Merge(Cluster a, Cluster b) {
+      AntiUnificationVisitor/*!*/ visitor = new AntiUnificationVisitor(Gen);
+      VCExpr/*!*/ generator = visitor.AntiUnify(a.Generator, b.Generator);
+      Contract.Assert(generator != null);
+      VCExprNAry generatorNAry = generator as VCExprNAry;
+      Contract.Assert(generatorNAry != null && Op.Equals(generatorNAry.Op));
+      return new Cluster(generatorNAry, a.Size + b.Size);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public void AddExpr(VCExprNAry expr) {
+      Contract.Requires(expr != null);
+      Contract.Requires(Op.Equals(expr.Op));
+
+      Cluster c = new Cluster(expr, 1);
+      for (int i = 0; i < Clusters.Count; ++i) {
+        Cluster d = Clusters[i];
+        if (EqualUpToRenaming(c, d)) {
+          Clusters[i] = new Cluster(d.Generator, d.Size + 1);
+          return;
+        }
+      }
+
+      Clusters.Add(c);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    private struct ClusteringMatrix {
+
+      private readonly VCExpressionGenerator/*!*/ Gen;
+      private readonly IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ GlobalVariables;
+
+      public readonly List<Cluster>/*!*/ Clusters;
+      public readonly bool[]/*!*/ RemainingClusters;
+
+      public readonly Distance[,]/*!*/ Distances;
+
+      [ContractInvariantMethod]
+      void ObjectInvariant() {
+        Contract.Invariant(Gen != null);
+        Contract.Invariant(cce.NonNullDictionaryAndValues(GlobalVariables));
+        Contract.Invariant(Clusters != null);
+        Contract.Invariant(RemainingClusters != null);
+        Contract.Invariant(Distances != null);
+      }
+
+
+      public struct Distance {
+        public readonly int Dist;
+        public readonly VCExprNAry/*!*/ Generator;
+
+        public Distance(Cluster a, Cluster b, IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars, VCExpressionGenerator gen) {
+          Contract.Requires(gen != null);
+          Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
+          AntiUnificationVisitor/*!*/ visitor = new AntiUnificationVisitor(gen);
+          Generator = (VCExprNAry)visitor.AntiUnify(a.Generator, b.Generator);
+
+          int reprSizeA, reprSizeB;
+          visitor.RepresentationSize(globalVars, out reprSizeA, out reprSizeB);
+          Dist = (a.Size - 1) * reprSizeA + (b.Size - 1) * reprSizeB;
+        }
+      }
+
+      public ClusteringMatrix(List<Cluster> clusters, IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars, VCExpressionGenerator gen) {
+        Contract.Requires(gen != null);
+        Contract.Requires(clusters != null);
+        Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
+        List<Cluster> c = new List<Cluster>();
+        c.AddRange(clusters);
+        Clusters = c;
+
+        GlobalVariables = globalVars;
+        Gen = gen;
+
+        bool[] remaining = new bool[clusters.Count];
+        RemainingClusters = remaining;
+        for (int i = 0; i < remaining.Length; ++i)
+          remaining[i] = true;
+
+        Distance[,]/*!*/ distances = new Distance[clusters.Count, clusters.Count];
+        Distances = distances;
+        for (int i = 1; i < clusters.Count; ++i)
+          for (int j = 0; j < i; ++j)
+            distances[i, j] =
+              new Distance(clusters[i], clusters[j], GlobalVariables, Gen);
+      }
+
+      public void UnifyClusters(int maxDist) {
+        while (true) {
+          int i, j;
+          int minDist = FindMinDistance(out i, out j);
+
+          if (minDist > maxDist)
+            return;
+
+          MergeClusters(i, j);
+        }
+      }
+
+      public void ResultingClusters(List<Cluster> clusters) {
+        Contract.Requires(clusters != null);
+        clusters.Clear();
+        for (int i = 0; i < Clusters.Count; ++i)
+          if (RemainingClusters[i])
+            clusters.Add(Clusters[i]);
+      }
+
+      //////////////////////////////////////////////////////////////////////////
+
+      private void Update(int i) {
+        for (int j = 0; j < i; ++j) {
+          if (RemainingClusters[j])
+            Distances[i, j] =
+              new Distance(Clusters[i], Clusters[j], GlobalVariables, Gen);
+        }
+        for (int j = i + 1; j < Clusters.Count; ++j) {
+          if (RemainingClusters[j])
+            Distances[j, i] =
+              new Distance(Clusters[j], Clusters[i], GlobalVariables, Gen);
+        }
+      }
+
+      private int FindMinDistance(out int c0, out int c1) {
+        int minDist = int.MaxValue;
+        c0 = -1;
+        c1 = -1;
+
+        for (int i = 0; i < Clusters.Count; ++i)
+          if (RemainingClusters[i]) {
+            for (int j = 0; j < i; ++j)
+              if (RemainingClusters[j]) {
+                if (Distances[i, j].Dist < minDist) {
+                  minDist = Distances[i, j].Dist;
+                  c0 = i;
+                  c1 = j;
+                }
+              }
+          }
+
+        Contract.Assert(c0 == -1 && c1 == -1 || c0 > c1 && c1 >= 0);
+        return minDist;
+      }
+
+      private void MergeClusters(int i, int j) {
+        Contract.Requires(j >= 0 && i > j && RemainingClusters[i] && RemainingClusters[j]);
+        Clusters[i] = new Cluster(Distances[i, j].Generator,
+                                   Clusters[i].Size + Clusters[j].Size);
+        RemainingClusters[j] = false;
+        Update(i);
+      }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public void UnifyClusters() {
+      ClusteringMatrix matrix =
+        new ClusteringMatrix(Clusters, GlobalVariables, Gen);
+      matrix.UnifyClusters(50);
+      matrix.ResultingClusters(Clusters);
+    }
+
+    [Pure]
+    public override string ToString() {
+      Contract.Ensures(Contract.Result<string>() != null);
+      string/*!*/ res = "";
+      foreach (Cluster c in Clusters)
+        res = res + c.Generator + "\t" + c.Size + "\n";
+      return res;
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  internal class AntiUnificationVisitor : TraversingVCExprVisitor<VCExpr/*!*/, VCExpr/*!*/> {
+
+    private readonly VCExpressionGenerator/*!*/ Gen;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Gen != null);
+      Contract.Invariant(cce.NonNullDictionaryAndValues(Representation));
+    }
+
+
+    public AntiUnificationVisitor(VCExpressionGenerator gen) {
+      Contract.Requires(gen != null);
+      Gen = gen;
+    }
+
+    // Sub-expressions in the first and second expression to be
+    // anti-unified that are replaced with variables
+    private readonly IDictionary<ExprPair, VCExprVar/*!*/>/*!*/ Representation =
+      new Dictionary<ExprPair, VCExprVar/*!*/>();
+
+
+
+    private struct ExprPair {
+      public readonly VCExpr/*!*/ Expr0, Expr1;
+      [ContractInvariantMethod]
+      void ObjectInvariant() {
+        Contract.Invariant(Expr0 != null);
+        Contract.Invariant(Expr1 != null);
+      }
+
+      public ExprPair(VCExpr expr0, VCExpr expr1) {
+        Contract.Requires(expr1 != null);
+        Contract.Requires(expr0 != null);
+        Expr0 = expr0;
+        Expr1 = expr1;
+      }
+      [Pure]
+      [Reads(ReadsAttribute.Reads.Nothing)]
+      public override bool Equals(object that) {
+        if (that is ExprPair) {
+          ExprPair thatPair = (ExprPair)that;
+          return this.Expr0.Equals(thatPair.Expr0) &&
+                 this.Expr1.Equals(thatPair.Expr1);
+        }
+        return false;
+      }
+      [Pure]
+      public override int GetHashCode() {
+        return Expr0.GetHashCode() + Expr1.GetHashCode() * 13;
+      }
+    }
+
+    public void Reset() {
+      Representation.Clear();
+    }
+
+    public bool RepresentationIsRenaming(IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars) {
+      Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
+      if (!Representation.Any(pair => pair.Key.Expr0 is VCExprVar && pair.Key.Expr1 is VCExprVar && !globalVars.ContainsKey(cce.NonNull((VCExprVar)pair.Key.Expr0)) && !globalVars.ContainsKey(cce.NonNull((VCExprVar/*!*/)pair.Key.Expr1))))
+        return false;
+      // check that all substituted variables are distinct
+      // TODO: optimise
+      return
+        Representation.All(pair1 => Representation.All(pair2 => pair1.Value.Equals(pair2.Value) || !pair1.Key.Expr0.Equals(pair2.Key.Expr0) && !pair1.Key.Expr1.Equals(pair2.Key.Expr1)));
+    }
+
+    public void RepresentationSize(IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars, out int expr0Size, out int expr1Size) {
+      Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
+      ReprSizeComputingVisitor/*!*/ size0Visitor = new ReprSizeComputingVisitor();
+      ReprSizeComputingVisitor/*!*/ size1Visitor = new ReprSizeComputingVisitor();
+
+      foreach (KeyValuePair<ExprPair, VCExprVar/*!*/> pair in Representation) {
+        Contract.Assert(pair.Value != null);
+        size0Visitor.ComputeSize(pair.Key.Expr0, globalVars);
+        size1Visitor.ComputeSize(pair.Key.Expr1, globalVars);
+      }
+
+      expr0Size = size0Visitor.Size;
+      expr1Size = size1Visitor.Size;
+    }
+
+    public VCExpr AntiUnify(VCExpr s, VCExpr t) {
+      Contract.Requires(t != null);
+      Contract.Requires(s != null);
+      Contract.Requires((s.Type.Equals(t.Type)));
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Traverse(s, t);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    private VCExprVar AbstractWithVariable(VCExpr s, VCExpr t) {
+      Contract.Requires(t != null);
+      Contract.Requires(s != null);
+      Contract.Requires((s.Type.Equals(t.Type)));
+Contract.Ensures(Contract.Result<VCExprVar>() != null);
+
+      ExprPair pair = new ExprPair(s, t);
+      VCExprVar repr;
+      if (!Representation.TryGetValue(pair, out repr)) {
+        repr = Gen.Variable("abs" + Representation.Count, s.Type);
+        Representation.Add(pair, repr);
+      }
+      return cce.NonNull(repr);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public override VCExpr Visit(VCExprLiteral node, VCExpr that) {
+      Contract.Requires(that != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (node.Equals(that))
+        return node;
+      return AbstractWithVariable(node, that);
+    }
+
+    public override VCExpr Visit(VCExprNAry node, VCExpr that) {
+      Contract.Requires(that != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExprNAry thatNAry = that as VCExprNAry;
+      if (thatNAry != null && node.Op.Equals(thatNAry.Op)) {
+        // type parameters should already have been eliminated at this
+        // stage
+        Contract.Assert(node.TypeParamArity == 0 && thatNAry.TypeParamArity == 0 && node.Arity == thatNAry.Arity);
+
+        List<VCExpr/*!*/>/*!*/ unifiedArgs = new List<VCExpr/*!*/>();
+        for (int i = 0; i < node.Arity; ++i)
+          unifiedArgs.Add(Traverse(node[i], thatNAry[i]));
+
+        return Gen.Function(node.Op, unifiedArgs);
+      }
+      return AbstractWithVariable(node, that);
+    }
+
+    public override VCExpr Visit(VCExprVar node, VCExpr that) {
+      Contract.Requires(that != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (node.Equals(that))
+        return node;
+      return AbstractWithVariable(node, that);
+    }
+
+    protected override VCExpr StandardResult(VCExpr node, VCExpr that) {
+      //Contract.Requires(that != null);
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException(); // not handled here      
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  internal class ReprSizeComputingVisitor
+                 : TraversingVCExprVisitor<bool,
+    // variables considered as global constants
+                                           IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/> {
+
+    public int Size = 0;
+
+    public void ComputeSize(VCExpr expr, IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars) {
+      Contract.Requires(expr != null);
+      Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
+      Traverse(expr, globalVars);
+    }
+
+    protected override bool StandardResult(VCExpr node, IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ globalVars) {
+      //Contract.Requires(node != null);
+      //Contract.Requires(cce.NonNullElements(globalVars));
+      VCExprVar nodeAsVar = node as VCExprVar;
+      if (nodeAsVar == null || globalVars.ContainsKey(nodeAsVar))
+        Size = Size + 1;
+      return true;
+    }
+  }
 }
 \ No newline at end of file
diff --git a/Source/VCExpr/LetBindingSorter.cs b/Source/VCExpr/LetBindingSorter.cs
index 474770d0..2bf28fbb 100644
--- a/Source/VCExpr/LetBindingSorter.cs
+++ b/Source/VCExpr/LetBindingSorter.cs
@@ -1,161 +1,161 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Linq;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-
-// Sort the bindings in a let-expression so that terms bound earlier do
-// not contain variables bound later
-
-namespace Microsoft.Boogie.VCExprAST {
-
-  // (argument is not used)
-  public class LetBindingSorter : MutatingVCExprVisitor<bool> {
-
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(FreeVarCollector != null);
-    }
-
-    private readonly FreeVariableCollector/*!*/ FreeVarCollector =
-      new FreeVariableCollector();
-
-    private List<VCExprVar/*!*/>/*!*/ FreeVarsIn(VCExpr expr) {
-      Contract.Requires(expr != null);
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
-      FreeVarCollector.Collect(expr);
-      List<VCExprVar/*!*/>/*!*/ freeVars = new List<VCExprVar/*!*/>(FreeVarCollector.FreeTermVars.Keys);
-      FreeVarCollector.Reset();
-      return freeVars;
-    }
-
-    public LetBindingSorter(VCExpressionGenerator gen):base(gen) {
-      Contract.Requires(gen != null);
-
-    }
-
-    public override VCExpr Visit(VCExprLet node, bool arg){
-Contract.Requires(node != null);
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      IDictionary<VCExprVar/*!*/, Binding/*!*/> boundVars =
-        new Dictionary<VCExprVar/*!*/, Binding/*!*/> ();
-
-      // recurse and collect the free variables in bound terms and formulae
-      foreach (VCExprLetBinding/*!*/ binding in node) {Contract.Assert(binding != null);
-        VCExpr/*!*/ newE = Mutate(binding.E, arg);
-        Binding/*!*/ b = new Binding (binding.V, newE, FreeVarsIn(newE));
-        boundVars.Add(b.V, b);
-      }
-
-      // generate the occurrence edges
-      foreach (KeyValuePair<VCExprVar/*!*/, Binding/*!*/> pair in boundVars) {Contract.Assert(cce.NonNullElements(pair));
-        Binding/*!*/ b = pair.Value;
-        Contract.Assert(b != null);
-        foreach (VCExprVar/*!*/ v in b.FreeVars) {Contract.Assert(v != null);
-          Binding b2;
-          if (boundVars.TryGetValue(v, out b2)) {
-            cce.NonNull(b2).Occurrences.Add(b);
-            b.InvOccurrencesNum = b.InvOccurrencesNum + 1;
-          }
-        }
-      }
-
-      // topological sort
-      Stack<Binding/*!*/> rootBindings = new Stack<Binding/*!*/> ();
-      foreach (KeyValuePair<VCExprVar/*!*/, Binding/*!*/> pair in boundVars)
-      {Contract.Assert(cce.NonNullElements(pair));
-        if (pair.Value.InvOccurrencesNum == 0)
-          rootBindings.Push(pair.Value);}
-
-      List<Binding/*!*/>/*!*/ sortedBindings = new List<Binding/*!*/> ();
-      while (rootBindings.Count > 0) {
-        Binding/*!*/ b = rootBindings.Pop();
-        Contract.Assert(b != null);
-        sortedBindings.Add(b);
-        foreach (Binding/*!*/ b2 in b.Occurrences) {
-          Contract.Assert(b2 != null);
-          b2.InvOccurrencesNum = b2.InvOccurrencesNum - 1;
-          if (b2.InvOccurrencesNum == 0)
-            rootBindings.Push(b2);
-        }
-      }
-
-      if (boundVars.Any(pair=> pair.Value.InvOccurrencesNum > 0))
-        System.Diagnostics.Debug.Fail("Cyclic let-bindings");
-
-      Contract.Assert(node.Length == sortedBindings.Count);
-
-      // check which of the bindings can be dropped
-      VCExpr newBody = Mutate(node.Body, arg);
-      Contract.Assert(newBody != null);
-
-      IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ usedVars =
-        new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/> ();
-      foreach (VCExprVar/*!*/ v in FreeVarsIn(newBody)){Contract.Assert(v != null);
-        if (!usedVars.ContainsKey(v))
-          usedVars.Add(v, v);}
-
-      for (int i = sortedBindings.Count - 1; i >= 0; --i) {
-        if (usedVars.ContainsKey(sortedBindings[i].V)) {
-          foreach (VCExprVar/*!*/ v in sortedBindings[i].FreeVars){
-            Contract.Assert(v != null);
-            if (!usedVars.ContainsKey(v))
-              usedVars.Add(v, v);}
-        } else {
-          sortedBindings.RemoveAt(i);
-        }
-      }
-
-      // assemble the resulting let-expression
-      List<VCExprLetBinding/*!*/>/*!*/ newBindings = new List<VCExprLetBinding/*!*/>();
-      foreach (Binding b in sortedBindings)
-        newBindings.Add(Gen.LetBinding(b.V, b.E));
-
-      return Gen.Let(newBindings, newBody);
-    }
-
-    private class Binding {
-      public readonly VCExprVar/*!*/ V;
-      public readonly VCExpr/*!*/ E;
-      public readonly List<VCExprVar/*!*/>/*!*/ FreeVars;
-      [ContractInvariantMethod]
-      void ObjectInvariant() {
-        Contract.Invariant(V != null);
-        Contract.Invariant(E != null);
-        Contract.Invariant(cce.NonNullElements(FreeVars));
-        Contract.Invariant(Occurrences != null);
-      }
-
-
-      // list of all bound expression in which the variable V occurs
-      // (outgoing edges)
-      public readonly List<Binding>/*!*/ Occurrences;
-
-      // number of variables that are bound in this let-expression
-      // and that occur in FreeVars
-      // (incoming edges)
-      public int InvOccurrencesNum;
-
-      public Binding(VCExprVar v, VCExpr e, List<VCExprVar/*!*/>/*!*/ freeVars) {
-        Contract.Requires(e != null);
-        Contract.Requires(v != null);
-        Contract.Requires(cce.NonNullElements(freeVars));
-        this.V = v;
-        this.E = e;
-        this.FreeVars = freeVars;
-        this.Occurrences = new List<Binding>();
-        this.InvOccurrencesNum = 0;
-      }
-    }
-
-  }
-
-}
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+
+// Sort the bindings in a let-expression so that terms bound earlier do
+// not contain variables bound later
+
+namespace Microsoft.Boogie.VCExprAST {
+
+  // (argument is not used)
+  public class LetBindingSorter : MutatingVCExprVisitor<bool> {
+
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(FreeVarCollector != null);
+    }
+
+    private readonly FreeVariableCollector/*!*/ FreeVarCollector =
+      new FreeVariableCollector();
+
+    private List<VCExprVar/*!*/>/*!*/ FreeVarsIn(VCExpr expr) {
+      Contract.Requires(expr != null);
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
+      FreeVarCollector.Collect(expr);
+      List<VCExprVar/*!*/>/*!*/ freeVars = new List<VCExprVar/*!*/>(FreeVarCollector.FreeTermVars.Keys);
+      FreeVarCollector.Reset();
+      return freeVars;
+    }
+
+    public LetBindingSorter(VCExpressionGenerator gen):base(gen) {
+      Contract.Requires(gen != null);
+
+    }
+
+    public override VCExpr Visit(VCExprLet node, bool arg){
+Contract.Requires(node != null);
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      IDictionary<VCExprVar/*!*/, Binding/*!*/> boundVars =
+        new Dictionary<VCExprVar/*!*/, Binding/*!*/> ();
+
+      // recurse and collect the free variables in bound terms and formulae
+      foreach (VCExprLetBinding/*!*/ binding in node) {Contract.Assert(binding != null);
+        VCExpr/*!*/ newE = Mutate(binding.E, arg);
+        Binding/*!*/ b = new Binding (binding.V, newE, FreeVarsIn(newE));
+        boundVars.Add(b.V, b);
+      }
+
+      // generate the occurrence edges
+      foreach (KeyValuePair<VCExprVar/*!*/, Binding/*!*/> pair in boundVars) {Contract.Assert(cce.NonNullElements(pair));
+        Binding/*!*/ b = pair.Value;
+        Contract.Assert(b != null);
+        foreach (VCExprVar/*!*/ v in b.FreeVars) {Contract.Assert(v != null);
+          Binding b2;
+          if (boundVars.TryGetValue(v, out b2)) {
+            cce.NonNull(b2).Occurrences.Add(b);
+            b.InvOccurrencesNum = b.InvOccurrencesNum + 1;
+          }
+        }
+      }
+
+      // topological sort
+      Stack<Binding/*!*/> rootBindings = new Stack<Binding/*!*/> ();
+      foreach (KeyValuePair<VCExprVar/*!*/, Binding/*!*/> pair in boundVars)
+      {Contract.Assert(cce.NonNullElements(pair));
+        if (pair.Value.InvOccurrencesNum == 0)
+          rootBindings.Push(pair.Value);}
+
+      List<Binding/*!*/>/*!*/ sortedBindings = new List<Binding/*!*/> ();
+      while (rootBindings.Count > 0) {
+        Binding/*!*/ b = rootBindings.Pop();
+        Contract.Assert(b != null);
+        sortedBindings.Add(b);
+        foreach (Binding/*!*/ b2 in b.Occurrences) {
+          Contract.Assert(b2 != null);
+          b2.InvOccurrencesNum = b2.InvOccurrencesNum - 1;
+          if (b2.InvOccurrencesNum == 0)
+            rootBindings.Push(b2);
+        }
+      }
+
+      if (boundVars.Any(pair=> pair.Value.InvOccurrencesNum > 0))
+        System.Diagnostics.Debug.Fail("Cyclic let-bindings");
+
+      Contract.Assert(node.Length == sortedBindings.Count);
+
+      // check which of the bindings can be dropped
+      VCExpr newBody = Mutate(node.Body, arg);
+      Contract.Assert(newBody != null);
+
+      IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ usedVars =
+        new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/> ();
+      foreach (VCExprVar/*!*/ v in FreeVarsIn(newBody)){Contract.Assert(v != null);
+        if (!usedVars.ContainsKey(v))
+          usedVars.Add(v, v);}
+
+      for (int i = sortedBindings.Count - 1; i >= 0; --i) {
+        if (usedVars.ContainsKey(sortedBindings[i].V)) {
+          foreach (VCExprVar/*!*/ v in sortedBindings[i].FreeVars){
+            Contract.Assert(v != null);
+            if (!usedVars.ContainsKey(v))
+              usedVars.Add(v, v);}
+        } else {
+          sortedBindings.RemoveAt(i);
+        }
+      }
+
+      // assemble the resulting let-expression
+      List<VCExprLetBinding/*!*/>/*!*/ newBindings = new List<VCExprLetBinding/*!*/>();
+      foreach (Binding b in sortedBindings)
+        newBindings.Add(Gen.LetBinding(b.V, b.E));
+
+      return Gen.Let(newBindings, newBody);
+    }
+
+    private class Binding {
+      public readonly VCExprVar/*!*/ V;
+      public readonly VCExpr/*!*/ E;
+      public readonly List<VCExprVar/*!*/>/*!*/ FreeVars;
+      [ContractInvariantMethod]
+      void ObjectInvariant() {
+        Contract.Invariant(V != null);
+        Contract.Invariant(E != null);
+        Contract.Invariant(cce.NonNullElements(FreeVars));
+        Contract.Invariant(Occurrences != null);
+      }
+
+
+      // list of all bound expression in which the variable V occurs
+      // (outgoing edges)
+      public readonly List<Binding>/*!*/ Occurrences;
+
+      // number of variables that are bound in this let-expression
+      // and that occur in FreeVars
+      // (incoming edges)
+      public int InvOccurrencesNum;
+
+      public Binding(VCExprVar v, VCExpr e, List<VCExprVar/*!*/>/*!*/ freeVars) {
+        Contract.Requires(e != null);
+        Contract.Requires(v != null);
+        Contract.Requires(cce.NonNullElements(freeVars));
+        this.V = v;
+        this.E = e;
+        this.FreeVars = freeVars;
+        this.Occurrences = new List<Binding>();
+        this.InvOccurrencesNum = 0;
+      }
+    }
+
+  }
+
+}
diff --git a/Source/VCExpr/NameClashResolver.cs b/Source/VCExpr/NameClashResolver.cs
index a46105f8..0effb386 100644
--- a/Source/VCExpr/NameClashResolver.cs
+++ b/Source/VCExpr/NameClashResolver.cs
@@ -1,196 +1,196 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-
-// Visitor that establishes unique variable (or constant) names in a VCExpr.
-// This is done by adding a counter as suffix if name clashes occur
-
-// TODO: also handle type variables here
-
-namespace Microsoft.Boogie.VCExprAST {
-  using TEHelperFuns = Microsoft.Boogie.TypeErasure.HelperFuns;
-
-  public class UniqueNamer : ICloneable {
-    public string Spacer = "@@";
-
-    public UniqueNamer() {
-      GlobalNames = new Dictionary<Object, string>();
-      LocalNames = TEHelperFuns.ToList(new Dictionary<Object/*!*/, string/*!*/>()
-                                         as IDictionary<Object/*!*/, string/*!*/>);
-      UsedNames = new HashSet<string>();
-      CurrentCounters = new Dictionary<string, int>();
-      GlobalPlusLocalNames = new Dictionary<Object, string>();
-    }
-
-    private UniqueNamer(UniqueNamer namer) {
-      Contract.Requires(namer != null);
-
-      Spacer = namer.Spacer;
-      GlobalNames = new Dictionary<Object, string>(namer.GlobalNames);
-      LocalNames = new List<IDictionary<Object, string>>();
-
-      foreach (IDictionary<Object/*!*/, string/*!*/>/*!*/ d in namer.LocalNames)
-        LocalNames.Add(new Dictionary<Object/*!*/, string/*!*/>(d));
-
-      UsedNames = new HashSet<string>(namer.UsedNames);
-      CurrentCounters = new Dictionary<string, int>(namer.CurrentCounters);
-      GlobalPlusLocalNames = new Dictionary<Object, string>(namer.GlobalPlusLocalNames);
-    }
-
-    public Object Clone() {
-      Contract.Ensures(Contract.Result<Object>() != null);
-      return new UniqueNamer(this);
-    }
-
-    public void Reset()
-    {
-      GlobalNames.Clear();
-      LocalNames.Clear();
-      LocalNames.Add(new Dictionary<Object/*!*/, string/*!*/>());
-      UsedNames.Clear();
-      CurrentCounters.Clear();
-      GlobalPlusLocalNames.Clear();
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    private readonly IDictionary<Object/*!*/, string/*!*/>/*!*/ GlobalNames;
-    [ContractInvariantMethod]
-    void GlobalNamesInvariantMethod() {
-      Contract.Invariant(cce.NonNullDictionaryAndValues(GlobalNames));
-    }
-    private readonly List<IDictionary<Object/*!*/, string/*!*/>/*!*/>/*!*/ LocalNames;
-    [ContractInvariantMethod]
-    void LocalNamesInvariantMethod() {
-      Contract.Invariant(Contract.ForAll(LocalNames, i => i != null && cce.NonNullDictionaryAndValues(i)));
-    }
-
-    // dictionary of all names that have already been used
-    // (locally or globally)
-    private readonly HashSet<string/*!*/>/*!*/ UsedNames;
-    [ContractInvariantMethod]
-    void UsedNamesInvariantMethod() {
-      Contract.Invariant(cce.NonNull(UsedNames));
-    }
-    private readonly IDictionary<string/*!*/, int/*!*/>/*!*/ CurrentCounters;
-    [ContractInvariantMethod]
-    void CurrentCountersInvariantMethod() {
-      Contract.Invariant(CurrentCounters != null);
-    }
-    private readonly IDictionary<Object/*!*/, string/*!*/>/*!*/ GlobalPlusLocalNames;
-    [ContractInvariantMethod]
-    void GlobalPlusLocalNamesInvariantMethod() {
-      Contract.Invariant(cce.NonNullDictionaryAndValues(GlobalPlusLocalNames));
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public void PushScope() {
-      LocalNames.Add(new Dictionary<Object/*!*/, string/*!*/>());
-    }
-
-    public void PopScope() {
-      LocalNames.RemoveAt(LocalNames.Count - 1);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    private string NextFreeName(Object thingie, string baseName) {
-      Contract.Requires(baseName != null);
-      Contract.Requires(thingie != null);
-      Contract.Ensures(Contract.Result<string>() != null);
-      string/*!*/ candidate;
-      int counter;
-
-      if (CurrentCounters.TryGetValue(baseName, out counter)) {
-        candidate = baseName + Spacer + counter;
-        counter = counter + 1;
-      } else {
-        candidate = baseName;
-        counter = 0;
-      }
-
-      while (UsedNames.Contains(candidate)) {
-        candidate = baseName + Spacer + counter;
-        counter = counter + 1;
-      }
-
-      UsedNames.Add(candidate);
-      CurrentCounters[baseName] = counter;
-      GlobalPlusLocalNames[thingie] = candidate;
-      return candidate;
-    }
-
-    // retrieve the name of a thingie; if it does not have a name yet,
-    // generate a unique name for it (as close as possible to its inherent
-    // name) and register it globally
-    public string GetName(Object thingie, string inherentName) {
-      Contract.Requires(inherentName != null);
-      Contract.Requires(thingie != null);
-      Contract.Ensures(Contract.Result<string>() != null);
-      string res = this[thingie];
-
-      if (res != null)
-        return res;
-
-      // if the object is not yet registered, create a name for it
-      res = NextFreeName(thingie, inherentName);
-      GlobalNames.Add(thingie, res);
-
-      return res;
-    }
-
-    [Pure]
-    public string this[Object/*!*/ thingie] {
-      get {
-        Contract.Requires(thingie != null);
-
-        string res;
-        for (int i = LocalNames.Count - 1; i >= 0; --i) {
-          if (LocalNames[i].TryGetValue(thingie, out res))
-            return res;
-        }
-
-        GlobalNames.TryGetValue(thingie, out res);
-        return res;
-      }
-    }
-
-    public string GetLocalName(Object thingie, string inherentName) {
-      Contract.Requires(inherentName != null);
-      Contract.Requires(thingie != null);
-      Contract.Ensures(Contract.Result<string>() != null);
-      string res = NextFreeName(thingie, inherentName);
-      LocalNames[LocalNames.Count - 1][thingie] = res;
-      return res;
-    }
-
-    public virtual string GetQuotedName(Object thingie, string inherentName)
-    {
-      return GetName(thingie, inherentName);
-    }
-
-    public virtual string GetQuotedLocalName(Object thingie, string inherentName)
-    {
-      return GetLocalName(thingie, inherentName);
-    }
-
-    public string Lookup(Object thingie) {
-      Contract.Requires(thingie != null);
-      Contract.Ensures(Contract.Result<string>() != null);
-      string name;
-      if (GlobalPlusLocalNames.TryGetValue(thingie, out name))
-        return name;
-      return Spacer + "undefined" + Spacer + thingie.GetHashCode() + Spacer;
-    }
-  }
-}
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+
+// Visitor that establishes unique variable (or constant) names in a VCExpr.
+// This is done by adding a counter as suffix if name clashes occur
+
+// TODO: also handle type variables here
+
+namespace Microsoft.Boogie.VCExprAST {
+  using TEHelperFuns = Microsoft.Boogie.TypeErasure.HelperFuns;
+
+  public class UniqueNamer : ICloneable {
+    public string Spacer = "@@";
+
+    public UniqueNamer() {
+      GlobalNames = new Dictionary<Object, string>();
+      LocalNames = TEHelperFuns.ToList(new Dictionary<Object/*!*/, string/*!*/>()
+                                         as IDictionary<Object/*!*/, string/*!*/>);
+      UsedNames = new HashSet<string>();
+      CurrentCounters = new Dictionary<string, int>();
+      GlobalPlusLocalNames = new Dictionary<Object, string>();
+    }
+
+    private UniqueNamer(UniqueNamer namer) {
+      Contract.Requires(namer != null);
+
+      Spacer = namer.Spacer;
+      GlobalNames = new Dictionary<Object, string>(namer.GlobalNames);
+      LocalNames = new List<IDictionary<Object, string>>();
+
+      foreach (IDictionary<Object/*!*/, string/*!*/>/*!*/ d in namer.LocalNames)
+        LocalNames.Add(new Dictionary<Object/*!*/, string/*!*/>(d));
+
+      UsedNames = new HashSet<string>(namer.UsedNames);
+      CurrentCounters = new Dictionary<string, int>(namer.CurrentCounters);
+      GlobalPlusLocalNames = new Dictionary<Object, string>(namer.GlobalPlusLocalNames);
+    }
+
+    public Object Clone() {
+      Contract.Ensures(Contract.Result<Object>() != null);
+      return new UniqueNamer(this);
+    }
+
+    public void Reset()
+    {
+      GlobalNames.Clear();
+      LocalNames.Clear();
+      LocalNames.Add(new Dictionary<Object/*!*/, string/*!*/>());
+      UsedNames.Clear();
+      CurrentCounters.Clear();
+      GlobalPlusLocalNames.Clear();
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    private readonly IDictionary<Object/*!*/, string/*!*/>/*!*/ GlobalNames;
+    [ContractInvariantMethod]
+    void GlobalNamesInvariantMethod() {
+      Contract.Invariant(cce.NonNullDictionaryAndValues(GlobalNames));
+    }
+    private readonly List<IDictionary<Object/*!*/, string/*!*/>/*!*/>/*!*/ LocalNames;
+    [ContractInvariantMethod]
+    void LocalNamesInvariantMethod() {
+      Contract.Invariant(Contract.ForAll(LocalNames, i => i != null && cce.NonNullDictionaryAndValues(i)));
+    }
+
+    // dictionary of all names that have already been used
+    // (locally or globally)
+    private readonly HashSet<string/*!*/>/*!*/ UsedNames;
+    [ContractInvariantMethod]
+    void UsedNamesInvariantMethod() {
+      Contract.Invariant(cce.NonNull(UsedNames));
+    }
+    private readonly IDictionary<string/*!*/, int/*!*/>/*!*/ CurrentCounters;
+    [ContractInvariantMethod]
+    void CurrentCountersInvariantMethod() {
+      Contract.Invariant(CurrentCounters != null);
+    }
+    private readonly IDictionary<Object/*!*/, string/*!*/>/*!*/ GlobalPlusLocalNames;
+    [ContractInvariantMethod]
+    void GlobalPlusLocalNamesInvariantMethod() {
+      Contract.Invariant(cce.NonNullDictionaryAndValues(GlobalPlusLocalNames));
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public void PushScope() {
+      LocalNames.Add(new Dictionary<Object/*!*/, string/*!*/>());
+    }
+
+    public void PopScope() {
+      LocalNames.RemoveAt(LocalNames.Count - 1);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    private string NextFreeName(Object thingie, string baseName) {
+      Contract.Requires(baseName != null);
+      Contract.Requires(thingie != null);
+      Contract.Ensures(Contract.Result<string>() != null);
+      string/*!*/ candidate;
+      int counter;
+
+      if (CurrentCounters.TryGetValue(baseName, out counter)) {
+        candidate = baseName + Spacer + counter;
+        counter = counter + 1;
+      } else {
+        candidate = baseName;
+        counter = 0;
+      }
+
+      while (UsedNames.Contains(candidate)) {
+        candidate = baseName + Spacer + counter;
+        counter = counter + 1;
+      }
+
+      UsedNames.Add(candidate);
+      CurrentCounters[baseName] = counter;
+      GlobalPlusLocalNames[thingie] = candidate;
+      return candidate;
+    }
+
+    // retrieve the name of a thingie; if it does not have a name yet,
+    // generate a unique name for it (as close as possible to its inherent
+    // name) and register it globally
+    public string GetName(Object thingie, string inherentName) {
+      Contract.Requires(inherentName != null);
+      Contract.Requires(thingie != null);
+      Contract.Ensures(Contract.Result<string>() != null);
+      string res = this[thingie];
+
+      if (res != null)
+        return res;
+
+      // if the object is not yet registered, create a name for it
+      res = NextFreeName(thingie, inherentName);
+      GlobalNames.Add(thingie, res);
+
+      return res;
+    }
+
+    [Pure]
+    public string this[Object/*!*/ thingie] {
+      get {
+        Contract.Requires(thingie != null);
+
+        string res;
+        for (int i = LocalNames.Count - 1; i >= 0; --i) {
+          if (LocalNames[i].TryGetValue(thingie, out res))
+            return res;
+        }
+
+        GlobalNames.TryGetValue(thingie, out res);
+        return res;
+      }
+    }
+
+    public string GetLocalName(Object thingie, string inherentName) {
+      Contract.Requires(inherentName != null);
+      Contract.Requires(thingie != null);
+      Contract.Ensures(Contract.Result<string>() != null);
+      string res = NextFreeName(thingie, inherentName);
+      LocalNames[LocalNames.Count - 1][thingie] = res;
+      return res;
+    }
+
+    public virtual string GetQuotedName(Object thingie, string inherentName)
+    {
+      return GetName(thingie, inherentName);
+    }
+
+    public virtual string GetQuotedLocalName(Object thingie, string inherentName)
+    {
+      return GetLocalName(thingie, inherentName);
+    }
+
+    public string Lookup(Object thingie) {
+      Contract.Requires(thingie != null);
+      Contract.Ensures(Contract.Result<string>() != null);
+      string name;
+      if (GlobalPlusLocalNames.TryGetValue(thingie, out name))
+        return name;
+      return Spacer + "undefined" + Spacer + thingie.GetHashCode() + Spacer;
+    }
+  }
+}
diff --git a/Source/VCExpr/SimplifyLikeLineariser.cs b/Source/VCExpr/SimplifyLikeLineariser.cs
index 6f74fe08..1a4374f8 100644
--- a/Source/VCExpr/SimplifyLikeLineariser.cs
+++ b/Source/VCExpr/SimplifyLikeLineariser.cs
@@ -1,1222 +1,1222 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-using Microsoft.Boogie.VCExprAST;
-
-// a naive method to turn VCExprs into strings that can be fed into Simplify
-
-namespace Microsoft.Boogie.VCExprAST {
-  [ContractClassFor(typeof(LineariserOptions))]
-  public abstract class LinOptContracts : LineariserOptions {
-    public LinOptContracts()
-      : base(true) {
-    }
-    public override LineariserOptions SetAsTerm(bool newVal) {
-      Contract.Ensures(Contract.Result<LineariserOptions>() != null);
-      throw new NotImplementedException();
-    }
-
-  }
-
-  // Options for the linearisation. Here one can choose, for instance,
-  // whether Simplify or Z3 output is to be produced
-  [ContractClass(typeof(LinOptContracts))]
-  public abstract class LineariserOptions {
-
-    public readonly bool AsTerm;
-    public abstract LineariserOptions/*!*/ SetAsTerm(bool newVal);
-
-    public abstract bool QuantifierIds {
-      get;
-    }
-
-    public virtual bool UseWeights {
-      get {
-        return false;
-      }
-    }
-
-    public virtual bool InverseImplies {
-      get {
-        return false;
-      }
-    }
-
-    // whether to include type specifications in quantifiers
-    public abstract bool UseTypes {
-      get;
-    }
-
-    // variables representing formulas in let-bindings have to be
-    // printed in a different way than other variables
-    public virtual List<VCExprVar/*!*/>/*!*/ LetVariables {
-      get {
-        Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
-        return EmptyList;
-      }
-    }
-
-    public virtual LineariserOptions AddLetVariable(VCExprVar furtherVar) {
-      Contract.Requires(furtherVar != null);
-      Contract.Ensures(Contract.Result<LineariserOptions>() != null);
-      return this;
-    }
-
-    public virtual LineariserOptions AddLetVariables(List<VCExprVar/*!*/>/*!*/ furtherVars) {
-      Contract.Requires(cce.NonNullElements(furtherVars));
-      Contract.Ensures(Contract.Result<LineariserOptions>() != null);
-      return this;
-    }
-
-    private static readonly List<VCExprVar/*!*/>/*!*/ EmptyList = new List<VCExprVar/*!*/>();
-    [ContractInvariantMethod]
-    void ObjectInvarinat() {
-      Contract.Invariant(EmptyList != null);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////////////////
-
-    protected LineariserOptions(bool asTerm) {
-      this.AsTerm = asTerm;
-    }
-
-    public static readonly LineariserOptions SimplifyDefault = new SimplifyOptions(false);
-    internal static readonly LineariserOptions SimplifyDefaultTerm = new SimplifyOptions(true);
-
-    ////////////////////////////////////////////////////////////////////////////////////////
-
-    private class SimplifyOptions : LineariserOptions {
-      internal SimplifyOptions(bool asTerm)
-        : base(asTerm) {
-
-      }
-      public override bool QuantifierIds {
-        get {
-          return false;
-        }
-      }
-      public override bool UseTypes {
-        get {
-          return false;
-        }
-      }
-      public override LineariserOptions SetAsTerm(bool newVal) {
-        Contract.Ensures(Contract.Result<LineariserOptions>() != null);
-        if (newVal)
-          return SimplifyDefaultTerm;
-        else
-          return SimplifyDefault;
-      }
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////////////////////////
-
-  // Lineariser for expressions. The result (bool) is currently not used for anything
-  public class SimplifyLikeExprLineariser : IVCExprVisitor<bool, LineariserOptions/*!*/> {
-
-    public static string ToSimplifyString(VCExpr e, UniqueNamer namer) {
-      Contract.Requires(namer != null);
-      Contract.Requires(e != null);
-      Contract.Ensures(Contract.Result<string>() != null);
-      return ToString(e, LineariserOptions.SimplifyDefault, namer);
-    }
-
-    public static string ToString(VCExpr/*!*/ e, LineariserOptions/*!*/ options, UniqueNamer/*!*/ namer) {
-      Contract.Requires(e != null);
-      Contract.Requires(options != null);
-      Contract.Requires(namer != null);
-      Contract.Ensures(Contract.Result<string>() != null);
-
-      StringWriter sw = new StringWriter();
-      SimplifyLikeExprLineariser lin = new SimplifyLikeExprLineariser(sw, namer);
-      lin.Linearise(e, options);
-      return sw.ToString();
-    }
-
-    ////////////////////////////////////////////////////////////////////////////////////////
-
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(wr != null);
-      Contract.Invariant(Namer != null);
-    }
-
-    private readonly TextWriter/*!*/ wr;
-    private SimplifyLikeOpLineariser OpLinObject = null;
-    private IVCExprOpVisitor<bool, LineariserOptions/*!*/>/*!*/ OpLineariser {
-      get {
-        Contract.Ensures(Contract.Result<IVCExprOpVisitor<bool, LineariserOptions>>() != null);
-        if (OpLinObject == null)
-          OpLinObject = new SimplifyLikeOpLineariser(this, wr);
-        return OpLinObject;
-      }
-    }
-
-    internal readonly UniqueNamer Namer;
-
-    public SimplifyLikeExprLineariser(TextWriter wr, UniqueNamer namer) {
-      Contract.Requires(namer != null);
-      Contract.Requires(wr != null);
-      this.wr = wr;
-      this.Namer = namer;
-    }
-
-    public void Linearise(VCExpr expr, LineariserOptions options) {
-      Contract.Requires(options != null);
-      Contract.Requires(expr != null);
-      expr.Accept<bool, LineariserOptions>(this, options);
-    }
-
-    public void LineariseAsTerm(VCExpr expr, LineariserOptions options) {
-      Contract.Requires(options != null);
-      Contract.Requires(expr != null);
-      Linearise(expr, options.SetAsTerm(true));
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////
-
-    public static string MakeIdPrintable(string s) {
-      Contract.Requires(s != null);
-      Contract.Requires(s != "");
-      Contract.Ensures(Contract.Result<string>() != null);
-      // make sure that no keywords are used as identifiers
-      switch (s) {
-        case andName:
-        case orName:
-        case notName:
-        case impliesName:
-        case iffName:
-        case eqName:
-        case neqName:
-        case distinctName:
-        case TRUEName:
-        case FALSEName:
-          s = "nonkeyword_" + s;
-          break;
-      }
-
-      if (CommandLineOptions.Clo.BracketIdsInVC == 0) {
-        // In this form, we go with any identifier, so we don't ever bother about brackets.
-        // Except: @true and @false are always written with brackets
-        return s;
-      }
-      bool looksLikeOperator = true;
-      bool looksLikeSimpleId = true;
-      bool useBrackets = false;
-      foreach (char ch in s) {
-        switch (ch) {
-          case '=':
-          case '<':
-          case '>':
-          case '+':
-          case '-':
-          case '*':
-          case '/':
-          case '%':
-          case ':':
-            // looks like operator, not simple id
-            looksLikeSimpleId = false;
-            break;
-          default:
-            if (Char.IsLetterOrDigit(ch)) {
-              // looks like simple id, not operator
-              looksLikeOperator = false;
-            } else {
-              // looks like neither operator nor simple id
-              looksLikeOperator = false;
-              looksLikeSimpleId = false;
-            }
-            break;
-        }
-        if (!looksLikeOperator && !looksLikeSimpleId) {
-          useBrackets = true;
-          break;
-        }
-      }
-      if (useBrackets) {
-        return "|" + s + "|";
-      } else {
-        return s;
-      }
-    }
-
-    private static void TypeToStringHelper(Type t, StringBuilder sb) {
-      Contract.Requires(t != null);
-
-      TypeSynonymAnnotation syn = t as TypeSynonymAnnotation;
-      if (syn != null) {
-        TypeToStringHelper(syn.ExpandedType, sb);
-      } else {
-        if (t.IsMap) {
-          MapType m = t.AsMap;
-          sb.Append('[');
-          for (int i = 0; i < m.MapArity; ++i) {
-            if (i != 0)
-              sb.Append(',');
-            TypeToStringHelper(m.Arguments[i], sb);
-          }
-          sb.Append(']');
-          TypeToStringHelper(m.Result, sb);
-        } else if (t.IsBool || t.IsInt || t.IsBv) {
-          sb.Append(TypeToString(t));
-        } else {
-          System.IO.StringWriter buffer = new System.IO.StringWriter();
-          using (TokenTextWriter stream = new TokenTextWriter("<buffer>", buffer, /*setTokens=*/ false, /*pretty=*/ false)) {
-            t.Emit(stream);
-          }
-          sb.Append(buffer.ToString());
-        }
-      }
-
-    }
-
-
-    public static string TypeToString(Type t) {
-      Contract.Requires(t != null);
-      Contract.Ensures(Contract.Result<string>() != null);
-
-      if (t.IsBool)
-        return "$bool";
-      else if (t.IsInt)
-        return "$int";
-      else if (t.IsBv)
-        return "$bv" + t.BvBits;
-      else {
-        StringBuilder sb = new StringBuilder();
-        TypeToStringHelper(t, sb);
-        return sb.ToString();
-      }
-    }
-
-    public static string BvConcatOpName(VCExprNAry node) {
-      Contract.Requires(node != null);
-      Contract.Requires((node.Op is VCExprBvConcatOp));
-      Contract.Ensures(Contract.Result<string>() != null);
-      int bits1 = node[0].Type.BvBits;
-      int bits2 = node[1].Type.BvBits;
-      return "$bv" + (bits1 + bits2) + "_concat[" + bits1 + "." + bits2 + "]";
-    }
-
-    public static string BvExtractOpName(VCExprNAry node) {
-      Contract.Requires(node != null);
-      Contract.Requires(node.Op is VCExprBvExtractOp);
-      Contract.Ensures(Contract.Result<string>() != null);
-      VCExprBvExtractOp op = (VCExprBvExtractOp)node.Op;
-      return "$bv" + node.Type.BvBits + "_extract" + op.Total + "[" + op.Start + ":" + op.End + "]";
-    }
-
-    public static string StoreOpName(VCExprNAry node) {
-      Contract.Requires(node != null);
-      Contract.Requires((node.Op is VCExprSelectOp) || (node.Op is VCExprStoreOp));
-      Contract.Ensures(Contract.Result<string>() != null);
-      return "Store_" + TypeToString(node[0].Type);
-    }
-
-    public static string SelectOpName(VCExprNAry node) {
-      Contract.Requires(node != null);
-      Contract.Requires((node.Op is VCExprSelectOp) || (node.Op is VCExprStoreOp));
-      Contract.Ensures(Contract.Result<string>() != null);
-      return "Select_" + TypeToString(node[0].Type);
-    }
-
-    internal void WriteId(string s) {
-      Contract.Requires(s != null);
-      wr.Write(MakeIdPrintable(s));
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////
-
-    /// <summary>
-    /// The name for logical conjunction in Simplify
-    /// </summary>
-    internal const string andName = "AND"; // conjunction
-    internal const string orName = "OR"; // disjunction
-    internal const string notName = "NOT"; // negation
-    internal const string impliesName = "IMPLIES"; // implication
-    internal const string iffName = "IFF"; // logical equivalence
-    internal const string eqName = "EQ"; // equality
-    internal const string neqName = "NEQ"; // inequality
-    internal const string lessName = "<";
-    internal const string greaterName = ">";
-    internal const string atmostName = "<=";
-    internal const string atleastName = ">=";
-    internal const string TRUEName = "TRUE"; // nullary predicate that is always true
-    internal const string FALSEName = "FALSE"; // nullary predicate that is always false
-    internal const string subtypeName = "<:";
-    internal const string subtypeArgsName = "<::";
-
-    internal const string distinctName = "DISTINCT";
-    /// <summary>
-    /// name of the main inclusion relation
-    /// </summary>
-    internal const string boolTrueName = "|@true|";
-    internal const string boolFalseName = "|@false|";
-    internal const string boolAndName = "boolAnd";
-    internal const string boolOrName = "boolOr";
-    internal const string boolNotName = "boolNot";
-    internal const string termEqName = "anyEqual";
-    internal const string termNeqName = "anyNeq";
-    internal const string termLessName = "intLess";
-    internal const string termGreaterName = "intGreater";
-    internal const string termAtmostName = "intAtMost";
-    internal const string termAtleastName = "intAtLeast";
-    internal const string intAddName = "+";
-    internal const string intAddNameReflect = "Reflect$Add";
-    internal const string intSubName = "-";
-    internal const string intMulName = "*";
-    internal const string intDivName = "/";
-    internal const string intModName = "%";
-    internal const string realAddName = "realAdd";
-    internal const string realSubName = "realSub";
-    internal const string realMulName = "realMul";
-    internal const string realDivName = "realDiv";
-    internal const string floatAddName = "floatAdd";
-    internal const string floatSubName = "floatSub";
-    internal const string floatMulName = "floatMul";
-    internal const string floatDivName = "floatDiv";
-    internal const string floatRemName = "floatRem";
-    internal const string floatMinName = "floatMin";
-    internal const string floatMaxName = "floatMax";
-    internal const string floatLeqName = "floatLeq";
-    internal const string floatLtName = "floatLt";
-    internal const string floatGeqName = "floatGeq";
-    internal const string floatGtName = "floatGt";
-    internal const string floatEqName = "floatEq";
-    internal const string realPowName = "realPow";
-    internal const string toIntName = "toIntCoercion";
-    internal const string toRealName = "toRealCoercion";
-    internal const string toFloatName = "toFloatCoercion";
-
-    internal void AssertAsTerm(string x, LineariserOptions options) {
-      Contract.Requires(options != null);
-      Contract.Requires(x != null);
-      if (!options.AsTerm)
-        System.Diagnostics.Debug.Fail("One should never write " + x + " as a formula!");
-    }
-
-    internal void AssertAsFormula(string x, LineariserOptions options) {
-      Contract.Requires(options != null);
-      Contract.Requires(x != null);
-      if (options.AsTerm)
-        System.Diagnostics.Debug.Fail("One should never write " + x + " as a term!");
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////
-
-    public bool Visit(VCExprLiteral node, LineariserOptions options) {
-      //Contract.Requires(options != null);
-      //Contract.Requires(node != null);
-      if (options.AsTerm) {
-
-        if (node == VCExpressionGenerator.True)
-          wr.Write(options.UseTypes ? TRUEName : boolTrueName);
-        else if (node == VCExpressionGenerator.False)
-          wr.Write(options.UseTypes ? FALSEName : boolFalseName);
-        else if (node is VCExprIntLit) {
-          wr.Write(((VCExprIntLit)node).Val);
-        } else {
-          Contract.Assert(false);
-          throw new cce.UnreachableException();
-        }
-
-      } else {
-
-        if (node == VCExpressionGenerator.True)
-          wr.Write(TRUEName);
-        else if (node == VCExpressionGenerator.False)
-          wr.Write(FALSEName);
-        else if (node is VCExprIntLit) {
-          System.Diagnostics.Debug.Fail("One should never write IntLit as a predicate!");
-        } else {
-          Contract.Assert(false);
-          throw new cce.UnreachableException();
-        }
-
-      }
-
-      return true;
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////
-
-    public bool Visit(VCExprNAry node, LineariserOptions options) {
-      //Contract.Requires(options != null);
-      //Contract.Requires(node != null);
-      VCExprOp op = node.Op;
-      Contract.Assert(op != null);
-
-      if (!options.AsTerm &&
-          (op.Equals(VCExpressionGenerator.AndOp) ||
-           op.Equals(VCExpressionGenerator.OrOp))) {
-        // handle these operators without recursion
-
-        wr.Write("({0}",
-                 op.Equals(VCExpressionGenerator.AndOp) ? andName : orName);
-        IEnumerator enumerator = new VCExprNAryUniformOpEnumerator(node);
-        Contract.Assert(enumerator != null);
-        while (enumerator.MoveNext()) {
-          VCExprNAry naryExpr = enumerator.Current as VCExprNAry;
-          if (naryExpr == null || !naryExpr.Op.Equals(op)) {
-            wr.Write(" ");
-            Linearise(cce.NonNull((VCExpr)enumerator.Current), options);
-          }
-        }
-
-        wr.Write(")");
-
-        return true;
-      }
-
-      return node.Accept<bool, LineariserOptions>(OpLineariser, options);
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////
-
-    public bool Visit(VCExprVar node, LineariserOptions options) {
-      //Contract.Requires(options != null);
-      //Contract.Requires(node != null);
-      string printedName = Namer.GetName(node, node.Name);
-      Contract.Assert(printedName != null);
-
-      if (options.AsTerm ||
-        // variables for formulas bound in a let-binding are never
-        // written as an equation
-          options.LetVariables.Contains(node) ||
-        // if variables are properly typed, they cannot be written as
-        // equation either
-          options.UseTypes) {
-        WriteId(printedName);
-      } else {
-        wr.Write("({0} ", eqName);
-        WriteId(printedName);
-        wr.Write(" {0})", boolTrueName);
-      }
-
-      return true;
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////
-
-    public bool Visit(VCExprQuantifier node, LineariserOptions options) {
-      //Contract.Requires(options != null);
-      //Contract.Requires(node != null);
-      AssertAsFormula(node.Quan.ToString(), options);
-      Contract.Assert(node.TypeParameters.Count == 0);
-
-      Namer.PushScope();
-      try {
-
-        string kind = node.Quan == Quantifier.ALL ? "FORALL" : "EXISTS";
-        wr.Write("({0} (", kind);
-
-        for (int i = 0; i < node.BoundVars.Count; i++) {
-          VCExprVar var = node.BoundVars[i];
-          Contract.Assert(var != null);
-          string printedName = Namer.GetLocalName(var, var.Name);
-          Contract.Assert(printedName != null);
-          if (i != 0)
-            wr.Write(" ");
-          WriteId(printedName);
-          if (options.UseTypes)
-            wr.Write(" :TYPE {0}", TypeToString(var.Type));
-        }
-        wr.Write(") ");
-
-        WriteTriggers(node.Triggers, options);
-
-        if (options.QuantifierIds) {
-          // only needed for Z3
-          VCQuantifierInfos infos = node.Infos;
-          Contract.Assert(infos != null);
-          if (infos.qid != null) {
-            wr.Write("(QID ");
-            wr.Write(infos.qid);
-            wr.Write(") ");
-          }
-          if (0 <= infos.uniqueId) {
-            wr.Write("(SKOLEMID ");
-            wr.Write(infos.uniqueId);
-            wr.Write(") ");
-          }
-        }
-
-        if (options.UseWeights) {
-          int weight = QKeyValue.FindIntAttribute(node.Infos.attributes, "weight", 1);
-          if (weight != 1) {
-            wr.Write("(WEIGHT ");
-            wr.Write(weight);
-            wr.Write(") ");
-          }
-        }
-
-        Linearise(node.Body, options);
-        wr.Write(")");
-
-        return true;
-
-      } finally {
-        Namer.PopScope();
-      }
-    }
-
-    private void WriteTriggers(List<VCTrigger/*!*/>/*!*/ triggers, LineariserOptions options) {
-      Contract.Requires(options != null);
-      Contract.Requires(cce.NonNullElements(triggers));
-      // first, count how many neg/pos triggers there are
-      int negTriggers = 0;
-      int posTriggers = 0;
-      foreach (VCTrigger vcTrig in triggers) {
-        Contract.Assert(vcTrig != null);
-        if (vcTrig.Pos) {
-          posTriggers++;
-        } else {
-          negTriggers++;
-        }
-      }
-
-      if (posTriggers > 0) {
-        wr.Write("(PATS");
-        foreach (VCTrigger vcTrig in triggers) {
-          Contract.Assert(vcTrig != null);
-          if (vcTrig.Pos) {
-            if (vcTrig.Exprs.Count > 1) {
-              wr.Write(" (MPAT");
-            }
-            foreach (VCExpr e in vcTrig.Exprs) {
-              Contract.Assert(e != null);
-              wr.Write(" ");
-              LineariseAsTerm(e, options);
-            }
-            if (vcTrig.Exprs.Count > 1) {
-              wr.Write(")");
-            }
-          }
-        }
-        wr.Write(") ");
-      } else if (negTriggers > 0) {
-        // if also positive triggers are given, the SMT solver (at least Z3)
-        // will ignore the negative patterns and output a warning. Therefore
-        // we never specify both negative and positive triggers
-        wr.Write("(NOPATS");
-        foreach (VCTrigger vcTrig in triggers) {
-          Contract.Assert(vcTrig != null);
-          if (!vcTrig.Pos) {
-            wr.Write(" ");
-            Contract.Assert(vcTrig.Exprs.Count == 1);
-            LineariseAsTerm(vcTrig.Exprs[0], options);
-          }
-        }
-        wr.Write(") ");
-      }
-
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////
-
-    public bool Visit(VCExprLet node, LineariserOptions options) {
-      //Contract.Requires(options != null);
-      //Contract.Requires(node != null);
-      Namer.PushScope();
-      try {
-
-        wr.Write("(LET (");
-
-        LineariserOptions optionsWithVars = options.AddLetVariables(node.BoundVars);
-        Contract.Assert(optionsWithVars != null);
-
-        string s = "(";
-        foreach (VCExprLetBinding b in node) {
-          Contract.Assert(b != null);
-          wr.Write(s);
-          string printedName = Namer.GetLocalName(b.V, b.V.Name);
-
-          bool formula = b.V.Type.IsBool;
-          if (formula)
-            wr.Write("FORMULA ");
-          else
-            wr.Write("TERM ");
-          WriteId(printedName);
-          wr.Write(" ");
-          Linearise(b.E, optionsWithVars.SetAsTerm(!formula));
-          wr.Write(")");
-          s = " (";
-        }
-        wr.Write(") ");
-        Linearise(node.Body, optionsWithVars);
-        wr.Write(")");
-
-        return true;
-
-      } finally {
-        Namer.PopScope();
-      }
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////////
-
-    // Lineariser for operator terms. The result (bool) is currently not used for anything
-    internal class SimplifyLikeOpLineariser : IVCExprOpVisitor<bool, LineariserOptions/*!*/> {
-      [ContractInvariantMethod]
-      void ObjectInvariant() {
-        Contract.Invariant(ExprLineariser != null);
-        Contract.Invariant(wr != null);
-      }
-
-      private readonly SimplifyLikeExprLineariser/*!*/ ExprLineariser;
-      private readonly TextWriter/*!*/ wr;
-
-      public SimplifyLikeOpLineariser(SimplifyLikeExprLineariser ExprLineariser, TextWriter wr) {
-        Contract.Requires(wr != null);
-        Contract.Requires(ExprLineariser != null);
-        this.ExprLineariser = ExprLineariser;
-        this.wr = wr;
-      }
-
-      ///////////////////////////////////////////////////////////////////////////////////
-
-      private void WriteApplication(string op, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options, bool argsAsTerms) {
-        Contract.Requires(options != null);
-        Contract.Requires(op != null);
-        Contract.Requires(cce.NonNullElements(args));
-        WriteApplication(op, op, args, options, argsAsTerms);
-      }
-
-      private void WriteApplication(string op, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options) {
-        Contract.Requires(options != null);
-        Contract.Requires(op != null);
-        Contract.Requires(cce.NonNullElements(args));
-        WriteApplication(op, op, args, options, options.AsTerm);
-      }
-
-      private void WriteTermApplication(string op, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options) {
-        Contract.Requires(options != null);
-        Contract.Requires(op != null);
-        Contract.Requires(cce.NonNullElements(args));
-        ExprLineariser.AssertAsTerm(op, options);
-        WriteApplication(op, op, args, options, options.AsTerm);
-      }
-
-      private void WriteApplication(string termOp, string predOp, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options) {
-        Contract.Requires(options != null);
-        Contract.Requires(predOp != null);
-        Contract.Requires(termOp != null);
-        Contract.Requires(cce.NonNullElements(args));
-        WriteApplication(termOp, predOp, args, options, options.AsTerm);
-      }
-
-      private void WriteApplication(string termOp, string predOp, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options, bool argsAsTerms) {
-        Contract.Requires(options != null);
-        Contract.Requires(predOp != null);
-        Contract.Requires(termOp != null);
-        Contract.Requires(cce.NonNullElements(args));// change the AsTerm option for the arguments?
-        wr.Write("({0}", options.AsTerm ? termOp : predOp);
-
-        LineariserOptions newOptions = options.SetAsTerm(argsAsTerms);
-
-        foreach (VCExpr e in args) {
-          Contract.Assert(e != null);
-          wr.Write(" ");
-          ExprLineariser.Linearise(e, newOptions);
-        }
-
-        wr.Write(")");
-      }
-
-      // write an application that can only be a term.
-      // if the expression is supposed to be printed as a formula,
-      // it is turned into an equation (EQ (f args) |@true|)
-      private void WriteApplicationTermOnly(string termOp, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options) {
-        Contract.Requires(options != null);
-        Contract.Requires(termOp != null);
-        Contract.Requires(cce.NonNullElements(args));
-        if (!options.AsTerm)
-          // Write: (EQ (f args) |@true|)
-          // where "args" are written as terms
-          wr.Write("({0} ", eqName);
-
-        WriteApplication(termOp, args, options, true);
-
-        if (!options.AsTerm)
-          wr.Write(" {0})", boolTrueName);
-      }
-
-      ///////////////////////////////////////////////////////////////////////////////////
-
-      public bool VisitNotOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteApplication(boolNotName, notName, node, options);      // arguments can be both terms and formulas
-        return true;
-      }
-
-      public bool VisitEqOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        if (options.AsTerm) {
-          // use equality on terms, also if the arguments have type bool
-          WriteApplication(termEqName, node, options);
-        } else {
-          if (node[0].Type.IsBool) {
-            Contract.Assert(node[1].Type.IsBool);
-            // use equivalence
-            WriteApplication(iffName, node, options);
-          } else {
-            Contract.Assert(!node[1].Type.IsBool);
-            // use equality and write the arguments as terms
-            WriteApplication(eqName, node, options, true);
-          }
-        }
-
-        return true;
-      }
-
-      public bool VisitNeqOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        if (options.AsTerm) {
-          // use equality on terms, also if the arguments have type bool
-          WriteApplication(termNeqName, node, options);
-        } else {
-          if (node[0].Type.IsBool) {
-            Contract.Assert(node[1].Type.IsBool);
-            // use equivalence and negate the whole thing
-            wr.Write("({0} ", notName);
-            WriteApplication(iffName, node, options);
-            wr.Write(")");
-          } else {
-            // use equality and write the arguments as terms
-            WriteApplication(neqName, node, options, true);
-          }
-        }
-
-        return true;
-      }
-
-      public bool VisitAndOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        Contract.Assert(options.AsTerm);
-        WriteApplication(boolAndName, andName, node, options);        // arguments can be both terms and formulas
-        return true;
-      }
-
-      public bool VisitOrOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        Contract.Assert(options.AsTerm);
-        WriteApplication(boolOrName, orName, node, options);        // arguments can be both terms and formulas
-        return true;
-      }
-
-      public bool VisitImpliesOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        if (options.AsTerm) {
-          wr.Write("({0} ({1} ", boolOrName, boolNotName);
-          ExprLineariser.Linearise(node[0], options);
-          wr.Write(") ");
-          ExprLineariser.Linearise(node[1], options);
-          wr.Write(")");
-        } else if (options.InverseImplies) {
-          wr.Write("({0} ", orName);
-          ExprLineariser.Linearise(node[1], options);
-          wr.Write(" ({0} ", notName);
-          ExprLineariser.Linearise(node[0], options);
-          wr.Write("))");
-        } else {
-          WriteApplication(impliesName, node, options);
-        }
-        return true;
-      }
-
-      public bool VisitDistinctOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        ExprLineariser.AssertAsFormula(distinctName, options);
-
-        if (node.Length < 2) {
-          ExprLineariser.Linearise(VCExpressionGenerator.True, options);
-        } else {
-          wr.Write("({0}", distinctName);
-          foreach (VCExpr e in node) {
-            Contract.Assert(e != null);
-            wr.Write(" ");
-            ExprLineariser.LineariseAsTerm(e, options);
-          }
-          wr.Write(")");
-        }
-
-        return true;
-      }
-
-      public bool VisitLabelOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        VCExprLabelOp op = (VCExprLabelOp)node.Op;
-        Contract.Assert(op != null);
-        wr.Write(String.Format("({0} |{1}| ", op.pos ? "LBLPOS" : "LBLNEG", op.label));
-        ExprLineariser.Linearise(node[0], options);
-        wr.Write(")");
-        return true;
-      }
-
-      public bool VisitSelectOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        wr.Write("(" + SelectOpName(node));
-        foreach (VCExpr/*!*/ e in node) {
-          Contract.Assert(e != null);
-          wr.Write(" ");
-          ExprLineariser.Linearise(e, options.SetAsTerm(!e.Type.IsBool));
-        }
-        wr.Write(")");
-        return true;
-      }
-
-      public bool VisitStoreOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        wr.Write("(" + StoreOpName(node));
-        foreach (VCExpr e in node) {
-          Contract.Assert(e != null);
-          wr.Write(" ");
-          ExprLineariser.Linearise(e, options.SetAsTerm(!e.Type.IsBool));
-        }
-        wr.Write(")");
-        return true;
-      }
-
-      public bool VisitFloatAddOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatAddName, node, options);
-        return true;
-      }
-
-      public bool VisitFloatSubOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatSubName, node, options);
-        return true;
-      }
-
-      public bool VisitFloatMulOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatMulName, node, options);
-        return true;
-      }
-
-      public bool VisitFloatDivOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatDivName, node, options);
-        return true;
-      }
-
-      public bool VisitFloatRemOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatRemName, node, options);
-        return true;
-      }
-
-      public bool VisitFloatMinOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatMinName, node, options);
-        return true;
-      }
-
-      public bool VisitFloatMaxOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatMaxName, node, options);
-        return true;
-      }
-
-      public bool VisitFloatLeqOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatLeqName, node, options);
-        return true;
-      }
-
-      public bool VisitFloatLtOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatLtName, node, options);
-        return true;
-      }
-
-      public bool VisitFloatGeqOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatGeqName, node, options);
-        return true;
-      }
-
-      public bool VisitFloatGtOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatGtName, node, options);
-        return true;
-      }
-
-      public bool VisitFloatEqOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(floatEqName, node, options);
-        return true;
-      }
-
-      public bool VisitBvOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication("$make_bv" + node.Type.BvBits, node, options);
-        return true;
-      }
-
-      public bool VisitBvExtractOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(BvExtractOpName(node), node, options);
-        return true;
-      }
-
-      public bool VisitBvConcatOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(BvConcatOpName(node), node, options);
-        return true;
-      }
-
-      public bool VisitIfThenElseOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-
-        wr.Write("(ITE ");
-        ExprLineariser.Linearise(node[0], options.SetAsTerm(false));
-        wr.Write(" ");
-        ExprLineariser.Linearise(node[1], options);
-        wr.Write(" ");
-        ExprLineariser.Linearise(node[2], options);
-        wr.Write(")");
-
-        return true;
-      }
-
-      public bool VisitCustomOp(VCExprNAry/*!*/ node, LineariserOptions/*!*/ options) {
-        //Contract.Requires(node != null);
-        //Contract.Requires(options != null);
-        VCExprCustomOp op = (VCExprCustomOp)node.Op;
-        wr.Write("({0}", op.Name);
-        foreach (VCExpr arg in node) {
-          wr.Write(" ");
-          ExprLineariser.Linearise(arg, options);
-        }
-        wr.Write(")");
-        return true;
-      }
-
-      public bool VisitAddOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        if (node.Type.IsInt) {
-          if (CommandLineOptions.Clo.ReflectAdd) {
-            WriteTermApplication(intAddNameReflect, node, options);
-          }
-          else {
-            WriteTermApplication(intAddName, node, options);
-          }
-        }
-        else {
-          WriteTermApplication(realAddName, node, options);
-        }
-        return true;
-      }
-
-      public bool VisitSubOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        if (node.Type.IsInt) {
-          WriteTermApplication(intSubName, node, options);
-        }
-        else if (node.Type.IsReal) {
-          WriteTermApplication(realSubName, node, options);
-        }
-        else {
-          WriteTermApplication(floatSubName, node, options);
-        }
-        return true;
-      }
-
-      public bool VisitMulOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        if (node.Type.IsInt) {
-          WriteTermApplication(intMulName, node, options);
-        }
-        else if (node.Type.IsReal) {
-          WriteTermApplication(realMulName, node, options);
-        }
-        else {
-          WriteTermApplication(floatMulName, node, options);
-        }
-        return true;
-      }
-
-      public bool VisitDivOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(intDivName, node, options);
-        return true;
-      }
-
-      public bool VisitModOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(intModName, node, options);
-        return true;
-      }
-
-      public bool VisitRealDivOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(realDivName, node, options);
-        return true;
-      }
-
-      public bool VisitPowOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteTermApplication(realPowName, node, options);
-        return true;
-      }
-
-      public bool VisitLtOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteApplication(termLessName, lessName, node, options, true);  // arguments are always terms
-        return true;
-      }
-
-      public bool VisitLeOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteApplication(termAtmostName, atmostName, node, options, true);  // arguments are always terms
-        return true;
-      }
-
-      public bool VisitGtOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteApplication(termGreaterName, greaterName, node, options, true);  // arguments are always terms
-        return true;
-      }
-
-      public bool VisitGeOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteApplication(termAtleastName, atleastName, node, options, true);  // arguments are always terms
-        return true;
-      }
-
-      public bool VisitSubtypeOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteApplication(subtypeName, node, options, true);               // arguments are always terms
-        return true;
-      }
-
-      public bool VisitSubtype3Op(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteApplication(subtypeArgsName, node, options, true);               // arguments are always terms
-        return true;
-      }
-
-      public bool VisitToIntOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteApplication(toIntName, node, options);
-        return true;
-      }
-
-      public bool VisitToRealOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteApplication(toRealName, node, options);
-        return true;
-      }
-
-      public bool VisitToFloatOp(VCExprNAry node, LineariserOptions options)
-      {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        WriteApplication(toFloatName, node, options);
-        return true;
-      }
-
-      public bool VisitBoogieFunctionOp(VCExprNAry node, LineariserOptions options) {
-        //Contract.Requires(options != null);
-        //Contract.Requires(node != null);
-        VCExprBoogieFunctionOp op = (VCExprBoogieFunctionOp)node.Op;
-        Contract.Assert(op != null);
-        string funcName = op.Func.Name;
-        Contract.Assert(funcName != null);
-        string bvzName = op.Func.FindStringAttribute("external");
-        string printedName = ExprLineariser.Namer.GetName(op.Func, funcName);
-        Contract.Assert(printedName != null);
-        if (bvzName != null)
-          printedName = bvzName;
-
-        if (options.UseTypes) {
-          // we use term notation for arguments whose type is not bool, and
-          // formula notation for boolean arguments
-
-          wr.Write("(");
-          ExprLineariser.WriteId(printedName);
-
-          foreach (VCExpr e in node) {
-            Contract.Assert(e != null);
-            wr.Write(" ");
-            ExprLineariser.Linearise(e, options.SetAsTerm(!e.Type.IsBool));
-          }
-
-          wr.Write(")");
-        } else {
-          // arguments are always terms
-          WriteApplicationTermOnly(SimplifyLikeExprLineariser.MakeIdPrintable(printedName),
-                                   node, options);
-        }
-        return true;
-      }
-
-    }
-  }
-
-}
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+using Microsoft.Boogie.VCExprAST;
+
+// a naive method to turn VCExprs into strings that can be fed into Simplify
+
+namespace Microsoft.Boogie.VCExprAST {
+  [ContractClassFor(typeof(LineariserOptions))]
+  public abstract class LinOptContracts : LineariserOptions {
+    public LinOptContracts()
+      : base(true) {
+    }
+    public override LineariserOptions SetAsTerm(bool newVal) {
+      Contract.Ensures(Contract.Result<LineariserOptions>() != null);
+      throw new NotImplementedException();
+    }
+
+  }
+
+  // Options for the linearisation. Here one can choose, for instance,
+  // whether Simplify or Z3 output is to be produced
+  [ContractClass(typeof(LinOptContracts))]
+  public abstract class LineariserOptions {
+
+    public readonly bool AsTerm;
+    public abstract LineariserOptions/*!*/ SetAsTerm(bool newVal);
+
+    public abstract bool QuantifierIds {
+      get;
+    }
+
+    public virtual bool UseWeights {
+      get {
+        return false;
+      }
+    }
+
+    public virtual bool InverseImplies {
+      get {
+        return false;
+      }
+    }
+
+    // whether to include type specifications in quantifiers
+    public abstract bool UseTypes {
+      get;
+    }
+
+    // variables representing formulas in let-bindings have to be
+    // printed in a different way than other variables
+    public virtual List<VCExprVar/*!*/>/*!*/ LetVariables {
+      get {
+        Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
+        return EmptyList;
+      }
+    }
+
+    public virtual LineariserOptions AddLetVariable(VCExprVar furtherVar) {
+      Contract.Requires(furtherVar != null);
+      Contract.Ensures(Contract.Result<LineariserOptions>() != null);
+      return this;
+    }
+
+    public virtual LineariserOptions AddLetVariables(List<VCExprVar/*!*/>/*!*/ furtherVars) {
+      Contract.Requires(cce.NonNullElements(furtherVars));
+      Contract.Ensures(Contract.Result<LineariserOptions>() != null);
+      return this;
+    }
+
+    private static readonly List<VCExprVar/*!*/>/*!*/ EmptyList = new List<VCExprVar/*!*/>();
+    [ContractInvariantMethod]
+    void ObjectInvarinat() {
+      Contract.Invariant(EmptyList != null);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////
+
+    protected LineariserOptions(bool asTerm) {
+      this.AsTerm = asTerm;
+    }
+
+    public static readonly LineariserOptions SimplifyDefault = new SimplifyOptions(false);
+    internal static readonly LineariserOptions SimplifyDefaultTerm = new SimplifyOptions(true);
+
+    ////////////////////////////////////////////////////////////////////////////////////////
+
+    private class SimplifyOptions : LineariserOptions {
+      internal SimplifyOptions(bool asTerm)
+        : base(asTerm) {
+
+      }
+      public override bool QuantifierIds {
+        get {
+          return false;
+        }
+      }
+      public override bool UseTypes {
+        get {
+          return false;
+        }
+      }
+      public override LineariserOptions SetAsTerm(bool newVal) {
+        Contract.Ensures(Contract.Result<LineariserOptions>() != null);
+        if (newVal)
+          return SimplifyDefaultTerm;
+        else
+          return SimplifyDefault;
+      }
+    }
+  }
+
+  ////////////////////////////////////////////////////////////////////////////////////////
+
+  // Lineariser for expressions. The result (bool) is currently not used for anything
+  public class SimplifyLikeExprLineariser : IVCExprVisitor<bool, LineariserOptions/*!*/> {
+
+    public static string ToSimplifyString(VCExpr e, UniqueNamer namer) {
+      Contract.Requires(namer != null);
+      Contract.Requires(e != null);
+      Contract.Ensures(Contract.Result<string>() != null);
+      return ToString(e, LineariserOptions.SimplifyDefault, namer);
+    }
+
+    public static string ToString(VCExpr/*!*/ e, LineariserOptions/*!*/ options, UniqueNamer/*!*/ namer) {
+      Contract.Requires(e != null);
+      Contract.Requires(options != null);
+      Contract.Requires(namer != null);
+      Contract.Ensures(Contract.Result<string>() != null);
+
+      StringWriter sw = new StringWriter();
+      SimplifyLikeExprLineariser lin = new SimplifyLikeExprLineariser(sw, namer);
+      lin.Linearise(e, options);
+      return sw.ToString();
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////////////
+
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(wr != null);
+      Contract.Invariant(Namer != null);
+    }
+
+    private readonly TextWriter/*!*/ wr;
+    private SimplifyLikeOpLineariser OpLinObject = null;
+    private IVCExprOpVisitor<bool, LineariserOptions/*!*/>/*!*/ OpLineariser {
+      get {
+        Contract.Ensures(Contract.Result<IVCExprOpVisitor<bool, LineariserOptions>>() != null);
+        if (OpLinObject == null)
+          OpLinObject = new SimplifyLikeOpLineariser(this, wr);
+        return OpLinObject;
+      }
+    }
+
+    internal readonly UniqueNamer Namer;
+
+    public SimplifyLikeExprLineariser(TextWriter wr, UniqueNamer namer) {
+      Contract.Requires(namer != null);
+      Contract.Requires(wr != null);
+      this.wr = wr;
+      this.Namer = namer;
+    }
+
+    public void Linearise(VCExpr expr, LineariserOptions options) {
+      Contract.Requires(options != null);
+      Contract.Requires(expr != null);
+      expr.Accept<bool, LineariserOptions>(this, options);
+    }
+
+    public void LineariseAsTerm(VCExpr expr, LineariserOptions options) {
+      Contract.Requires(options != null);
+      Contract.Requires(expr != null);
+      Linearise(expr, options.SetAsTerm(true));
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////
+
+    public static string MakeIdPrintable(string s) {
+      Contract.Requires(s != null);
+      Contract.Requires(s != "");
+      Contract.Ensures(Contract.Result<string>() != null);
+      // make sure that no keywords are used as identifiers
+      switch (s) {
+        case andName:
+        case orName:
+        case notName:
+        case impliesName:
+        case iffName:
+        case eqName:
+        case neqName:
+        case distinctName:
+        case TRUEName:
+        case FALSEName:
+          s = "nonkeyword_" + s;
+          break;
+      }
+
+      if (CommandLineOptions.Clo.BracketIdsInVC == 0) {
+        // In this form, we go with any identifier, so we don't ever bother about brackets.
+        // Except: @true and @false are always written with brackets
+        return s;
+      }
+      bool looksLikeOperator = true;
+      bool looksLikeSimpleId = true;
+      bool useBrackets = false;
+      foreach (char ch in s) {
+        switch (ch) {
+          case '=':
+          case '<':
+          case '>':
+          case '+':
+          case '-':
+          case '*':
+          case '/':
+          case '%':
+          case ':':
+            // looks like operator, not simple id
+            looksLikeSimpleId = false;
+            break;
+          default:
+            if (Char.IsLetterOrDigit(ch)) {
+              // looks like simple id, not operator
+              looksLikeOperator = false;
+            } else {
+              // looks like neither operator nor simple id
+              looksLikeOperator = false;
+              looksLikeSimpleId = false;
+            }
+            break;
+        }
+        if (!looksLikeOperator && !looksLikeSimpleId) {
+          useBrackets = true;
+          break;
+        }
+      }
+      if (useBrackets) {
+        return "|" + s + "|";
+      } else {
+        return s;
+      }
+    }
+
+    private static void TypeToStringHelper(Type t, StringBuilder sb) {
+      Contract.Requires(t != null);
+
+      TypeSynonymAnnotation syn = t as TypeSynonymAnnotation;
+      if (syn != null) {
+        TypeToStringHelper(syn.ExpandedType, sb);
+      } else {
+        if (t.IsMap) {
+          MapType m = t.AsMap;
+          sb.Append('[');
+          for (int i = 0; i < m.MapArity; ++i) {
+            if (i != 0)
+              sb.Append(',');
+            TypeToStringHelper(m.Arguments[i], sb);
+          }
+          sb.Append(']');
+          TypeToStringHelper(m.Result, sb);
+        } else if (t.IsBool || t.IsInt || t.IsBv) {
+          sb.Append(TypeToString(t));
+        } else {
+          System.IO.StringWriter buffer = new System.IO.StringWriter();
+          using (TokenTextWriter stream = new TokenTextWriter("<buffer>", buffer, /*setTokens=*/ false, /*pretty=*/ false)) {
+            t.Emit(stream);
+          }
+          sb.Append(buffer.ToString());
+        }
+      }
+
+    }
+
+
+    public static string TypeToString(Type t) {
+      Contract.Requires(t != null);
+      Contract.Ensures(Contract.Result<string>() != null);
+
+      if (t.IsBool)
+        return "$bool";
+      else if (t.IsInt)
+        return "$int";
+      else if (t.IsBv)
+        return "$bv" + t.BvBits;
+      else {
+        StringBuilder sb = new StringBuilder();
+        TypeToStringHelper(t, sb);
+        return sb.ToString();
+      }
+    }
+
+    public static string BvConcatOpName(VCExprNAry node) {
+      Contract.Requires(node != null);
+      Contract.Requires((node.Op is VCExprBvConcatOp));
+      Contract.Ensures(Contract.Result<string>() != null);
+      int bits1 = node[0].Type.BvBits;
+      int bits2 = node[1].Type.BvBits;
+      return "$bv" + (bits1 + bits2) + "_concat[" + bits1 + "." + bits2 + "]";
+    }
+
+    public static string BvExtractOpName(VCExprNAry node) {
+      Contract.Requires(node != null);
+      Contract.Requires(node.Op is VCExprBvExtractOp);
+      Contract.Ensures(Contract.Result<string>() != null);
+      VCExprBvExtractOp op = (VCExprBvExtractOp)node.Op;
+      return "$bv" + node.Type.BvBits + "_extract" + op.Total + "[" + op.Start + ":" + op.End + "]";
+    }
+
+    public static string StoreOpName(VCExprNAry node) {
+      Contract.Requires(node != null);
+      Contract.Requires((node.Op is VCExprSelectOp) || (node.Op is VCExprStoreOp));
+      Contract.Ensures(Contract.Result<string>() != null);
+      return "Store_" + TypeToString(node[0].Type);
+    }
+
+    public static string SelectOpName(VCExprNAry node) {
+      Contract.Requires(node != null);
+      Contract.Requires((node.Op is VCExprSelectOp) || (node.Op is VCExprStoreOp));
+      Contract.Ensures(Contract.Result<string>() != null);
+      return "Select_" + TypeToString(node[0].Type);
+    }
+
+    internal void WriteId(string s) {
+      Contract.Requires(s != null);
+      wr.Write(MakeIdPrintable(s));
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////
+
+    /// <summary>
+    /// The name for logical conjunction in Simplify
+    /// </summary>
+    internal const string andName = "AND"; // conjunction
+    internal const string orName = "OR"; // disjunction
+    internal const string notName = "NOT"; // negation
+    internal const string impliesName = "IMPLIES"; // implication
+    internal const string iffName = "IFF"; // logical equivalence
+    internal const string eqName = "EQ"; // equality
+    internal const string neqName = "NEQ"; // inequality
+    internal const string lessName = "<";
+    internal const string greaterName = ">";
+    internal const string atmostName = "<=";
+    internal const string atleastName = ">=";
+    internal const string TRUEName = "TRUE"; // nullary predicate that is always true
+    internal const string FALSEName = "FALSE"; // nullary predicate that is always false
+    internal const string subtypeName = "<:";
+    internal const string subtypeArgsName = "<::";
+
+    internal const string distinctName = "DISTINCT";
+    /// <summary>
+    /// name of the main inclusion relation
+    /// </summary>
+    internal const string boolTrueName = "|@true|";
+    internal const string boolFalseName = "|@false|";
+    internal const string boolAndName = "boolAnd";
+    internal const string boolOrName = "boolOr";
+    internal const string boolNotName = "boolNot";
+    internal const string termEqName = "anyEqual";
+    internal const string termNeqName = "anyNeq";
+    internal const string termLessName = "intLess";
+    internal const string termGreaterName = "intGreater";
+    internal const string termAtmostName = "intAtMost";
+    internal const string termAtleastName = "intAtLeast";
+    internal const string intAddName = "+";
+    internal const string intAddNameReflect = "Reflect$Add";
+    internal const string intSubName = "-";
+    internal const string intMulName = "*";
+    internal const string intDivName = "/";
+    internal const string intModName = "%";
+    internal const string realAddName = "realAdd";
+    internal const string realSubName = "realSub";
+    internal const string realMulName = "realMul";
+    internal const string realDivName = "realDiv";
+    internal const string floatAddName = "floatAdd";
+    internal const string floatSubName = "floatSub";
+    internal const string floatMulName = "floatMul";
+    internal const string floatDivName = "floatDiv";
+    internal const string floatRemName = "floatRem";
+    internal const string floatMinName = "floatMin";
+    internal const string floatMaxName = "floatMax";
+    internal const string floatLeqName = "floatLeq";
+    internal const string floatLtName = "floatLt";
+    internal const string floatGeqName = "floatGeq";
+    internal const string floatGtName = "floatGt";
+    internal const string floatEqName = "floatEq";
+    internal const string realPowName = "realPow";
+    internal const string toIntName = "toIntCoercion";
+    internal const string toRealName = "toRealCoercion";
+    internal const string toFloatName = "toFloatCoercion";
+
+    internal void AssertAsTerm(string x, LineariserOptions options) {
+      Contract.Requires(options != null);
+      Contract.Requires(x != null);
+      if (!options.AsTerm)
+        System.Diagnostics.Debug.Fail("One should never write " + x + " as a formula!");
+    }
+
+    internal void AssertAsFormula(string x, LineariserOptions options) {
+      Contract.Requires(options != null);
+      Contract.Requires(x != null);
+      if (options.AsTerm)
+        System.Diagnostics.Debug.Fail("One should never write " + x + " as a term!");
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////
+
+    public bool Visit(VCExprLiteral node, LineariserOptions options) {
+      //Contract.Requires(options != null);
+      //Contract.Requires(node != null);
+      if (options.AsTerm) {
+
+        if (node == VCExpressionGenerator.True)
+          wr.Write(options.UseTypes ? TRUEName : boolTrueName);
+        else if (node == VCExpressionGenerator.False)
+          wr.Write(options.UseTypes ? FALSEName : boolFalseName);
+        else if (node is VCExprIntLit) {
+          wr.Write(((VCExprIntLit)node).Val);
+        } else {
+          Contract.Assert(false);
+          throw new cce.UnreachableException();
+        }
+
+      } else {
+
+        if (node == VCExpressionGenerator.True)
+          wr.Write(TRUEName);
+        else if (node == VCExpressionGenerator.False)
+          wr.Write(FALSEName);
+        else if (node is VCExprIntLit) {
+          System.Diagnostics.Debug.Fail("One should never write IntLit as a predicate!");
+        } else {
+          Contract.Assert(false);
+          throw new cce.UnreachableException();
+        }
+
+      }
+
+      return true;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////
+
+    public bool Visit(VCExprNAry node, LineariserOptions options) {
+      //Contract.Requires(options != null);
+      //Contract.Requires(node != null);
+      VCExprOp op = node.Op;
+      Contract.Assert(op != null);
+
+      if (!options.AsTerm &&
+          (op.Equals(VCExpressionGenerator.AndOp) ||
+           op.Equals(VCExpressionGenerator.OrOp))) {
+        // handle these operators without recursion
+
+        wr.Write("({0}",
+                 op.Equals(VCExpressionGenerator.AndOp) ? andName : orName);
+        IEnumerator enumerator = new VCExprNAryUniformOpEnumerator(node);
+        Contract.Assert(enumerator != null);
+        while (enumerator.MoveNext()) {
+          VCExprNAry naryExpr = enumerator.Current as VCExprNAry;
+          if (naryExpr == null || !naryExpr.Op.Equals(op)) {
+            wr.Write(" ");
+            Linearise(cce.NonNull((VCExpr)enumerator.Current), options);
+          }
+        }
+
+        wr.Write(")");
+
+        return true;
+      }
+
+      return node.Accept<bool, LineariserOptions>(OpLineariser, options);
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////
+
+    public bool Visit(VCExprVar node, LineariserOptions options) {
+      //Contract.Requires(options != null);
+      //Contract.Requires(node != null);
+      string printedName = Namer.GetName(node, node.Name);
+      Contract.Assert(printedName != null);
+
+      if (options.AsTerm ||
+        // variables for formulas bound in a let-binding are never
+        // written as an equation
+          options.LetVariables.Contains(node) ||
+        // if variables are properly typed, they cannot be written as
+        // equation either
+          options.UseTypes) {
+        WriteId(printedName);
+      } else {
+        wr.Write("({0} ", eqName);
+        WriteId(printedName);
+        wr.Write(" {0})", boolTrueName);
+      }
+
+      return true;
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////
+
+    public bool Visit(VCExprQuantifier node, LineariserOptions options) {
+      //Contract.Requires(options != null);
+      //Contract.Requires(node != null);
+      AssertAsFormula(node.Quan.ToString(), options);
+      Contract.Assert(node.TypeParameters.Count == 0);
+
+      Namer.PushScope();
+      try {
+
+        string kind = node.Quan == Quantifier.ALL ? "FORALL" : "EXISTS";
+        wr.Write("({0} (", kind);
+
+        for (int i = 0; i < node.BoundVars.Count; i++) {
+          VCExprVar var = node.BoundVars[i];
+          Contract.Assert(var != null);
+          string printedName = Namer.GetLocalName(var, var.Name);
+          Contract.Assert(printedName != null);
+          if (i != 0)
+            wr.Write(" ");
+          WriteId(printedName);
+          if (options.UseTypes)
+            wr.Write(" :TYPE {0}", TypeToString(var.Type));
+        }
+        wr.Write(") ");
+
+        WriteTriggers(node.Triggers, options);
+
+        if (options.QuantifierIds) {
+          // only needed for Z3
+          VCQuantifierInfos infos = node.Infos;
+          Contract.Assert(infos != null);
+          if (infos.qid != null) {
+            wr.Write("(QID ");
+            wr.Write(infos.qid);
+            wr.Write(") ");
+          }
+          if (0 <= infos.uniqueId) {
+            wr.Write("(SKOLEMID ");
+            wr.Write(infos.uniqueId);
+            wr.Write(") ");
+          }
+        }
+
+        if (options.UseWeights) {
+          int weight = QKeyValue.FindIntAttribute(node.Infos.attributes, "weight", 1);
+          if (weight != 1) {
+            wr.Write("(WEIGHT ");
+            wr.Write(weight);
+            wr.Write(") ");
+          }
+        }
+
+        Linearise(node.Body, options);
+        wr.Write(")");
+
+        return true;
+
+      } finally {
+        Namer.PopScope();
+      }
+    }
+
+    private void WriteTriggers(List<VCTrigger/*!*/>/*!*/ triggers, LineariserOptions options) {
+      Contract.Requires(options != null);
+      Contract.Requires(cce.NonNullElements(triggers));
+      // first, count how many neg/pos triggers there are
+      int negTriggers = 0;
+      int posTriggers = 0;
+      foreach (VCTrigger vcTrig in triggers) {
+        Contract.Assert(vcTrig != null);
+        if (vcTrig.Pos) {
+          posTriggers++;
+        } else {
+          negTriggers++;
+        }
+      }
+
+      if (posTriggers > 0) {
+        wr.Write("(PATS");
+        foreach (VCTrigger vcTrig in triggers) {
+          Contract.Assert(vcTrig != null);
+          if (vcTrig.Pos) {
+            if (vcTrig.Exprs.Count > 1) {
+              wr.Write(" (MPAT");
+            }
+            foreach (VCExpr e in vcTrig.Exprs) {
+              Contract.Assert(e != null);
+              wr.Write(" ");
+              LineariseAsTerm(e, options);
+            }
+            if (vcTrig.Exprs.Count > 1) {
+              wr.Write(")");
+            }
+          }
+        }
+        wr.Write(") ");
+      } else if (negTriggers > 0) {
+        // if also positive triggers are given, the SMT solver (at least Z3)
+        // will ignore the negative patterns and output a warning. Therefore
+        // we never specify both negative and positive triggers
+        wr.Write("(NOPATS");
+        foreach (VCTrigger vcTrig in triggers) {
+          Contract.Assert(vcTrig != null);
+          if (!vcTrig.Pos) {
+            wr.Write(" ");
+            Contract.Assert(vcTrig.Exprs.Count == 1);
+            LineariseAsTerm(vcTrig.Exprs[0], options);
+          }
+        }
+        wr.Write(") ");
+      }
+
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////
+
+    public bool Visit(VCExprLet node, LineariserOptions options) {
+      //Contract.Requires(options != null);
+      //Contract.Requires(node != null);
+      Namer.PushScope();
+      try {
+
+        wr.Write("(LET (");
+
+        LineariserOptions optionsWithVars = options.AddLetVariables(node.BoundVars);
+        Contract.Assert(optionsWithVars != null);
+
+        string s = "(";
+        foreach (VCExprLetBinding b in node) {
+          Contract.Assert(b != null);
+          wr.Write(s);
+          string printedName = Namer.GetLocalName(b.V, b.V.Name);
+
+          bool formula = b.V.Type.IsBool;
+          if (formula)
+            wr.Write("FORMULA ");
+          else
+            wr.Write("TERM ");
+          WriteId(printedName);
+          wr.Write(" ");
+          Linearise(b.E, optionsWithVars.SetAsTerm(!formula));
+          wr.Write(")");
+          s = " (";
+        }
+        wr.Write(") ");
+        Linearise(node.Body, optionsWithVars);
+        wr.Write(")");
+
+        return true;
+
+      } finally {
+        Namer.PopScope();
+      }
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////
+
+    // Lineariser for operator terms. The result (bool) is currently not used for anything
+    internal class SimplifyLikeOpLineariser : IVCExprOpVisitor<bool, LineariserOptions/*!*/> {
+      [ContractInvariantMethod]
+      void ObjectInvariant() {
+        Contract.Invariant(ExprLineariser != null);
+        Contract.Invariant(wr != null);
+      }
+
+      private readonly SimplifyLikeExprLineariser/*!*/ ExprLineariser;
+      private readonly TextWriter/*!*/ wr;
+
+      public SimplifyLikeOpLineariser(SimplifyLikeExprLineariser ExprLineariser, TextWriter wr) {
+        Contract.Requires(wr != null);
+        Contract.Requires(ExprLineariser != null);
+        this.ExprLineariser = ExprLineariser;
+        this.wr = wr;
+      }
+
+      ///////////////////////////////////////////////////////////////////////////////////
+
+      private void WriteApplication(string op, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options, bool argsAsTerms) {
+        Contract.Requires(options != null);
+        Contract.Requires(op != null);
+        Contract.Requires(cce.NonNullElements(args));
+        WriteApplication(op, op, args, options, argsAsTerms);
+      }
+
+      private void WriteApplication(string op, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options) {
+        Contract.Requires(options != null);
+        Contract.Requires(op != null);
+        Contract.Requires(cce.NonNullElements(args));
+        WriteApplication(op, op, args, options, options.AsTerm);
+      }
+
+      private void WriteTermApplication(string op, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options) {
+        Contract.Requires(options != null);
+        Contract.Requires(op != null);
+        Contract.Requires(cce.NonNullElements(args));
+        ExprLineariser.AssertAsTerm(op, options);
+        WriteApplication(op, op, args, options, options.AsTerm);
+      }
+
+      private void WriteApplication(string termOp, string predOp, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options) {
+        Contract.Requires(options != null);
+        Contract.Requires(predOp != null);
+        Contract.Requires(termOp != null);
+        Contract.Requires(cce.NonNullElements(args));
+        WriteApplication(termOp, predOp, args, options, options.AsTerm);
+      }
+
+      private void WriteApplication(string termOp, string predOp, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options, bool argsAsTerms) {
+        Contract.Requires(options != null);
+        Contract.Requires(predOp != null);
+        Contract.Requires(termOp != null);
+        Contract.Requires(cce.NonNullElements(args));// change the AsTerm option for the arguments?
+        wr.Write("({0}", options.AsTerm ? termOp : predOp);
+
+        LineariserOptions newOptions = options.SetAsTerm(argsAsTerms);
+
+        foreach (VCExpr e in args) {
+          Contract.Assert(e != null);
+          wr.Write(" ");
+          ExprLineariser.Linearise(e, newOptions);
+        }
+
+        wr.Write(")");
+      }
+
+      // write an application that can only be a term.
+      // if the expression is supposed to be printed as a formula,
+      // it is turned into an equation (EQ (f args) |@true|)
+      private void WriteApplicationTermOnly(string termOp, IEnumerable<VCExpr/*!*/>/*!*/ args, LineariserOptions options) {
+        Contract.Requires(options != null);
+        Contract.Requires(termOp != null);
+        Contract.Requires(cce.NonNullElements(args));
+        if (!options.AsTerm)
+          // Write: (EQ (f args) |@true|)
+          // where "args" are written as terms
+          wr.Write("({0} ", eqName);
+
+        WriteApplication(termOp, args, options, true);
+
+        if (!options.AsTerm)
+          wr.Write(" {0})", boolTrueName);
+      }
+
+      ///////////////////////////////////////////////////////////////////////////////////
+
+      public bool VisitNotOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteApplication(boolNotName, notName, node, options);      // arguments can be both terms and formulas
+        return true;
+      }
+
+      public bool VisitEqOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        if (options.AsTerm) {
+          // use equality on terms, also if the arguments have type bool
+          WriteApplication(termEqName, node, options);
+        } else {
+          if (node[0].Type.IsBool) {
+            Contract.Assert(node[1].Type.IsBool);
+            // use equivalence
+            WriteApplication(iffName, node, options);
+          } else {
+            Contract.Assert(!node[1].Type.IsBool);
+            // use equality and write the arguments as terms
+            WriteApplication(eqName, node, options, true);
+          }
+        }
+
+        return true;
+      }
+
+      public bool VisitNeqOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        if (options.AsTerm) {
+          // use equality on terms, also if the arguments have type bool
+          WriteApplication(termNeqName, node, options);
+        } else {
+          if (node[0].Type.IsBool) {
+            Contract.Assert(node[1].Type.IsBool);
+            // use equivalence and negate the whole thing
+            wr.Write("({0} ", notName);
+            WriteApplication(iffName, node, options);
+            wr.Write(")");
+          } else {
+            // use equality and write the arguments as terms
+            WriteApplication(neqName, node, options, true);
+          }
+        }
+
+        return true;
+      }
+
+      public bool VisitAndOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        Contract.Assert(options.AsTerm);
+        WriteApplication(boolAndName, andName, node, options);        // arguments can be both terms and formulas
+        return true;
+      }
+
+      public bool VisitOrOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        Contract.Assert(options.AsTerm);
+        WriteApplication(boolOrName, orName, node, options);        // arguments can be both terms and formulas
+        return true;
+      }
+
+      public bool VisitImpliesOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        if (options.AsTerm) {
+          wr.Write("({0} ({1} ", boolOrName, boolNotName);
+          ExprLineariser.Linearise(node[0], options);
+          wr.Write(") ");
+          ExprLineariser.Linearise(node[1], options);
+          wr.Write(")");
+        } else if (options.InverseImplies) {
+          wr.Write("({0} ", orName);
+          ExprLineariser.Linearise(node[1], options);
+          wr.Write(" ({0} ", notName);
+          ExprLineariser.Linearise(node[0], options);
+          wr.Write("))");
+        } else {
+          WriteApplication(impliesName, node, options);
+        }
+        return true;
+      }
+
+      public bool VisitDistinctOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        ExprLineariser.AssertAsFormula(distinctName, options);
+
+        if (node.Length < 2) {
+          ExprLineariser.Linearise(VCExpressionGenerator.True, options);
+        } else {
+          wr.Write("({0}", distinctName);
+          foreach (VCExpr e in node) {
+            Contract.Assert(e != null);
+            wr.Write(" ");
+            ExprLineariser.LineariseAsTerm(e, options);
+          }
+          wr.Write(")");
+        }
+
+        return true;
+      }
+
+      public bool VisitLabelOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        VCExprLabelOp op = (VCExprLabelOp)node.Op;
+        Contract.Assert(op != null);
+        wr.Write(String.Format("({0} |{1}| ", op.pos ? "LBLPOS" : "LBLNEG", op.label));
+        ExprLineariser.Linearise(node[0], options);
+        wr.Write(")");
+        return true;
+      }
+
+      public bool VisitSelectOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        wr.Write("(" + SelectOpName(node));
+        foreach (VCExpr/*!*/ e in node) {
+          Contract.Assert(e != null);
+          wr.Write(" ");
+          ExprLineariser.Linearise(e, options.SetAsTerm(!e.Type.IsBool));
+        }
+        wr.Write(")");
+        return true;
+      }
+
+      public bool VisitStoreOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        wr.Write("(" + StoreOpName(node));
+        foreach (VCExpr e in node) {
+          Contract.Assert(e != null);
+          wr.Write(" ");
+          ExprLineariser.Linearise(e, options.SetAsTerm(!e.Type.IsBool));
+        }
+        wr.Write(")");
+        return true;
+      }
+
+      public bool VisitFloatAddOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatAddName, node, options);
+        return true;
+      }
+
+      public bool VisitFloatSubOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatSubName, node, options);
+        return true;
+      }
+
+      public bool VisitFloatMulOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatMulName, node, options);
+        return true;
+      }
+
+      public bool VisitFloatDivOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatDivName, node, options);
+        return true;
+      }
+
+      public bool VisitFloatRemOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatRemName, node, options);
+        return true;
+      }
+
+      public bool VisitFloatMinOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatMinName, node, options);
+        return true;
+      }
+
+      public bool VisitFloatMaxOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatMaxName, node, options);
+        return true;
+      }
+
+      public bool VisitFloatLeqOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatLeqName, node, options);
+        return true;
+      }
+
+      public bool VisitFloatLtOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatLtName, node, options);
+        return true;
+      }
+
+      public bool VisitFloatGeqOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatGeqName, node, options);
+        return true;
+      }
+
+      public bool VisitFloatGtOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatGtName, node, options);
+        return true;
+      }
+
+      public bool VisitFloatEqOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(floatEqName, node, options);
+        return true;
+      }
+
+      public bool VisitBvOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication("$make_bv" + node.Type.BvBits, node, options);
+        return true;
+      }
+
+      public bool VisitBvExtractOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(BvExtractOpName(node), node, options);
+        return true;
+      }
+
+      public bool VisitBvConcatOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(BvConcatOpName(node), node, options);
+        return true;
+      }
+
+      public bool VisitIfThenElseOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+
+        wr.Write("(ITE ");
+        ExprLineariser.Linearise(node[0], options.SetAsTerm(false));
+        wr.Write(" ");
+        ExprLineariser.Linearise(node[1], options);
+        wr.Write(" ");
+        ExprLineariser.Linearise(node[2], options);
+        wr.Write(")");
+
+        return true;
+      }
+
+      public bool VisitCustomOp(VCExprNAry/*!*/ node, LineariserOptions/*!*/ options) {
+        //Contract.Requires(node != null);
+        //Contract.Requires(options != null);
+        VCExprCustomOp op = (VCExprCustomOp)node.Op;
+        wr.Write("({0}", op.Name);
+        foreach (VCExpr arg in node) {
+          wr.Write(" ");
+          ExprLineariser.Linearise(arg, options);
+        }
+        wr.Write(")");
+        return true;
+      }
+
+      public bool VisitAddOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        if (node.Type.IsInt) {
+          if (CommandLineOptions.Clo.ReflectAdd) {
+            WriteTermApplication(intAddNameReflect, node, options);
+          }
+          else {
+            WriteTermApplication(intAddName, node, options);
+          }
+        }
+        else {
+          WriteTermApplication(realAddName, node, options);
+        }
+        return true;
+      }
+
+      public bool VisitSubOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        if (node.Type.IsInt) {
+          WriteTermApplication(intSubName, node, options);
+        }
+        else if (node.Type.IsReal) {
+          WriteTermApplication(realSubName, node, options);
+        }
+        else {
+          WriteTermApplication(floatSubName, node, options);
+        }
+        return true;
+      }
+
+      public bool VisitMulOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        if (node.Type.IsInt) {
+          WriteTermApplication(intMulName, node, options);
+        }
+        else if (node.Type.IsReal) {
+          WriteTermApplication(realMulName, node, options);
+        }
+        else {
+          WriteTermApplication(floatMulName, node, options);
+        }
+        return true;
+      }
+
+      public bool VisitDivOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(intDivName, node, options);
+        return true;
+      }
+
+      public bool VisitModOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(intModName, node, options);
+        return true;
+      }
+
+      public bool VisitRealDivOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(realDivName, node, options);
+        return true;
+      }
+
+      public bool VisitPowOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteTermApplication(realPowName, node, options);
+        return true;
+      }
+
+      public bool VisitLtOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteApplication(termLessName, lessName, node, options, true);  // arguments are always terms
+        return true;
+      }
+
+      public bool VisitLeOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteApplication(termAtmostName, atmostName, node, options, true);  // arguments are always terms
+        return true;
+      }
+
+      public bool VisitGtOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteApplication(termGreaterName, greaterName, node, options, true);  // arguments are always terms
+        return true;
+      }
+
+      public bool VisitGeOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteApplication(termAtleastName, atleastName, node, options, true);  // arguments are always terms
+        return true;
+      }
+
+      public bool VisitSubtypeOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteApplication(subtypeName, node, options, true);               // arguments are always terms
+        return true;
+      }
+
+      public bool VisitSubtype3Op(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteApplication(subtypeArgsName, node, options, true);               // arguments are always terms
+        return true;
+      }
+
+      public bool VisitToIntOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteApplication(toIntName, node, options);
+        return true;
+      }
+
+      public bool VisitToRealOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteApplication(toRealName, node, options);
+        return true;
+      }
+
+      public bool VisitToFloatOp(VCExprNAry node, LineariserOptions options)
+      {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        WriteApplication(toFloatName, node, options);
+        return true;
+      }
+
+      public bool VisitBoogieFunctionOp(VCExprNAry node, LineariserOptions options) {
+        //Contract.Requires(options != null);
+        //Contract.Requires(node != null);
+        VCExprBoogieFunctionOp op = (VCExprBoogieFunctionOp)node.Op;
+        Contract.Assert(op != null);
+        string funcName = op.Func.Name;
+        Contract.Assert(funcName != null);
+        string bvzName = op.Func.FindStringAttribute("external");
+        string printedName = ExprLineariser.Namer.GetName(op.Func, funcName);
+        Contract.Assert(printedName != null);
+        if (bvzName != null)
+          printedName = bvzName;
+
+        if (options.UseTypes) {
+          // we use term notation for arguments whose type is not bool, and
+          // formula notation for boolean arguments
+
+          wr.Write("(");
+          ExprLineariser.WriteId(printedName);
+
+          foreach (VCExpr e in node) {
+            Contract.Assert(e != null);
+            wr.Write(" ");
+            ExprLineariser.Linearise(e, options.SetAsTerm(!e.Type.IsBool));
+          }
+
+          wr.Write(")");
+        } else {
+          // arguments are always terms
+          WriteApplicationTermOnly(SimplifyLikeExprLineariser.MakeIdPrintable(printedName),
+                                   node, options);
+        }
+        return true;
+      }
+
+    }
+  }
+
+}
diff --git a/Source/VCExpr/TermFormulaFlattening.cs b/Source/VCExpr/TermFormulaFlattening.cs
index 7815413f..c4150024 100644
--- a/Source/VCExpr/TermFormulaFlattening.cs
+++ b/Source/VCExpr/TermFormulaFlattening.cs
@@ -1,248 +1,248 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Linq;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-using Microsoft.Boogie.VCExprAST;
-
-// Ensure that no formulas (expressions of type boolean that are not
-// just a variable) occur with terms (expressions of some other
-// type). This is done by introducing let-binders for boolean
-// variables.
-
-namespace Microsoft.Boogie.VCExprAST
-{
-
-  public struct FlattenerState {
-    public readonly int Polarity;
-    public readonly bool InTerm;
-
-    public static FlattenerState INITIAL = new FlattenerState(1, false);
-
-    public FlattenerState(int polarity, bool inTerm) {
-      Polarity = polarity;
-      InTerm = inTerm;
-    }
-
-    public FlattenerState TogglePolarity { get {
-      return new FlattenerState(-Polarity, InTerm);
-    } }
-
-    public FlattenerState ZeroPolarity { get {
-      return new FlattenerState(0, InTerm);
-    } }
-
-    public FlattenerState EnterTerm { get {
-      return new FlattenerState(Polarity, true);
-    } }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  public class TermFormulaFlattener : MutatingVCExprVisitor<FlattenerState> {
-
-    public TermFormulaFlattener(VCExpressionGenerator gen):base(gen){
-Contract.Requires(gen != null);
-      
-    }
-
-    private readonly IDictionary<VCExpr/*!*/, VCExprVar/*!*/>/*!*/ Bindings =
-      new Dictionary<VCExpr/*!*/, VCExprVar/*!*/> ();
-    
-    private int varNameCounter = 0;
-
-    public VCExpr Flatten(VCExpr expr){
-Contract.Requires(expr != null);
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExpr/*!*/ res = Mutate(expr, FlattenerState.INITIAL);
-      Contract.Assert(res != null);
-      while (Bindings.Count > 0) {
-        List<VCExprLetBinding/*!*/>/*!*/ letBindings = new List<VCExprLetBinding/*!*/> ();
-        foreach (KeyValuePair<VCExpr/*!*/, VCExprVar/*!*/> pair in Bindings){Contract.Assert(cce.NonNullElements(pair));
-          letBindings.Add(Gen.LetBinding(pair.Value, pair.Key));}
-        Bindings.Clear();
-        res = AddBindings(letBindings, res, FlattenerState.INITIAL);
-      }
-      return res;
-    }
-
-    private VCExprVar GetVarFor(VCExpr expr){
-Contract.Requires(expr != null);
-Contract.Requires((expr.Type.IsBool));
-Contract.Ensures(Contract.Result<VCExprVar>() != null);
-      VCExprVar res;
-      if (!Bindings.TryGetValue(expr, out res)) {
-        string name = "flt" + varNameCounter;
-        varNameCounter = varNameCounter + 1;
-        res = Gen.Variable(name, Type.Bool);
-        Bindings.Add(expr, res);
-      }
-      return cce.NonNull(res);
-    }
-
-    // Remove all let-bindings from the field bindings whose rhs
-    // contains any of the specified variables
-    private List<VCExprLetBinding/*!*/>/*!*/ RemoveBindingsWithVars(List<VCExprVar/*!*/>/*!*/ boundVars, List<TypeVariable/*!*/>/*!*/ boundTypeVars){
-Contract.Requires(cce.NonNullElements(boundTypeVars));
-Contract.Requires(cce.NonNullElements(boundVars));
-Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprLetBinding>>()));      
-      List<VCExprLetBinding/*!*/>/*!*/ res = new List<VCExprLetBinding/*!*/> ();
-      FreeVariableCollector/*!*/ coll = new FreeVariableCollector ();
-
-      foreach (KeyValuePair<VCExpr, VCExprVar> pair in Bindings) {
-        Contract.Assert(cce.NonNullElements(pair));
-        coll.Collect(pair.Key);
-        if (boundVars.Any(var => coll.FreeTermVars.ContainsKey(var)) ||
-            boundTypeVars.Any(var => coll.FreeTypeVars.Contains(var)))
-          res.Add(Gen.LetBinding(pair.Value, pair.Key));
-        coll.Reset();
-      }
-
-      foreach (VCExprLetBinding b in res){Contract.Assert(b != null);
-        Bindings.Remove(b.E);}
-
-      return res;
-    }
-    
-    // Add bindings to a formula using an implication or
-    // conjunction. The bindings themselves will be flattened as well,
-    // which might introduce further bindings
-    private VCExpr AddBindings(List<VCExprLetBinding/*!*/>/*!*/ bindings, VCExpr body, FlattenerState state){
-Contract.Requires(body != null);
-Contract.Requires(cce.NonNullElements(bindings));
-Contract.Requires((body.Type.IsBool));
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      List<VCExprLetBinding/*!*/>/*!*/ mutatedBindings = FlattenBindings(bindings, state);
-      Contract.Assert(mutatedBindings != null);
-      VCExpr/*!*/ bindingEquations = Gen.AsEquations(mutatedBindings);
-      Contract.Assert(bindingEquations != null);
-      switch(state.Polarity) {
-      case 1:
-        return Gen.Implies(bindingEquations, body);
-      case -1:
-        return Gen.And(bindingEquations, body);
-      case 0:
-        // also add explicit quantifiers for the bound variables
-        List<VCExprVar/*!*/>/*!*/ vars = new List<VCExprVar/*!*/> ();
-        foreach (VCExprLetBinding/*!*/ binding in mutatedBindings){Contract.Assert(binding != null);
-          vars.Add(binding.V);}
-        return Gen.Forall(vars, new List<VCTrigger/*!*/>(),
-                          Gen.Implies(bindingEquations, body));
-      }
-      Contract.Assert(false); throw new cce.UnreachableException();
-    }
-
-    private List<VCExprLetBinding/*!*/>/*!*/ FlattenBindings(List<VCExprLetBinding/*!*/>/*!*/ bindings, FlattenerState state){
-Contract.Requires(cce.NonNullElements(bindings));
-Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprLetBinding>>()));
-      FlattenerState stateInBindings = state.ZeroPolarity;
-      List<VCExprLetBinding/*!*/>/*!*/ mutatedBindings = new List<VCExprLetBinding/*!*/> ();
-      foreach (VCExprLetBinding/*!*/ b in bindings) {
-        Contract.Assert(b != null);
-        mutatedBindings.Add(Gen.LetBinding(b.V, Mutate(b.E, stateInBindings)));
-      }
-      return mutatedBindings;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public override bool AvoidVisit(VCExprNAry node, FlattenerState arg)
-    {
-        return node.Op.Equals(VCExpressionGenerator.AndOp) ||
-               node.Op.Equals(VCExpressionGenerator.OrOp);
-    }
-
-    public override VCExpr Visit(VCExprNAry node, FlattenerState state){
-Contract.Requires(node != null);
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      // track the polarity to know whether implications or conjunctions
-      // are to be introduced
-
-      if (node.Op.Equals(VCExpressionGenerator.NotOp))
-        return Gen.Not(Mutate(node[0], state.TogglePolarity));
-
-      if (node.Op.Equals(VCExpressionGenerator.ImpliesOp)) {
-        VCExpr newArg0 = Mutate(node[0], state.TogglePolarity);
-        VCExpr newArg1 = Mutate(node[1], state);
-        return Gen.Implies(newArg0, newArg1);
-      }
-
-      if (!node.Type.IsBool)
-        state = state.EnterTerm;
-
-      if (!node.Op.Equals(VCExpressionGenerator.AndOp) &&
-          !node.Op.Equals(VCExpressionGenerator.OrOp) &&
-          !(node.Op is VCExprLabelOp))
-        // standard is to set the polarity to 0 (fits most operators)
-        return base.Visit(node, state.ZeroPolarity);
-
-      return base.Visit(node, state);
-    }
-
-    public override VCExpr Visit(VCExprQuantifier node, FlattenerState state){
-Contract.Requires(node != null);
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (state.InTerm)
-        return GetVarFor(node);
-
-      // we only flatten within the matrix of the quantified formula,
-      // not within the triggers (since SMT-solvers do not seem to
-      // appreciate triggers with let-binders)
-      VCExpr newBody = Mutate(node.Body, state);
-
-      // Check whether any of the extracted terms contain variables
-      // bound by this quantifier. In this case, we have to add
-      // let-binders and remove the extracted terms
-      bool cont = true;
-      while (cont) {
-        List<VCExprLetBinding/*!*/>/*!*/ localBindings =
-          RemoveBindingsWithVars(node.BoundVars, node.TypeParameters);
-        Contract.Assert(cce.NonNullElements(localBindings));
-        if (localBindings.Count > 0)
-          newBody = AddBindings(localBindings, newBody, state);
-        else
-          cont = false;
-      }
-
-      return Gen.Quantify(node.Quan, node.TypeParameters, node.BoundVars, node.Triggers, node.Infos, newBody);
-    }
-
-    public override VCExpr Visit(VCExprLet node, FlattenerState state){
-Contract.Requires(node != null);
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (state.InTerm)
-        return GetVarFor(node);
-
-      VCExprLet prelimRes = (VCExprLet)cce.NonNull(base.Visit(node, state));
-
-      List<VCExprLetBinding/*!*/>/*!*/ allBindings = new List<VCExprLetBinding/*!*/> ();
-      allBindings.AddRange(prelimRes);
-
-      // Check whether any of the extracted terms contain variables
-      // bound by this binder. In this case, we have to add
-      // let-binders and remove the extracted terms
-      bool cont = true;
-      while (cont) {
-        List<VCExprLetBinding/*!*/>/*!*/ localBindings =
-          RemoveBindingsWithVars(prelimRes.BoundVars, new List<TypeVariable/*!*/>());
-        if (localBindings.Count > 0)
-          allBindings.AddRange(FlattenBindings(localBindings, state));
-        else
-          cont = false;
-      }
-      
-      return Gen.Let(allBindings, prelimRes.Body);
-    }
-
-  }
-
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+using Microsoft.Boogie.VCExprAST;
+
+// Ensure that no formulas (expressions of type boolean that are not
+// just a variable) occur with terms (expressions of some other
+// type). This is done by introducing let-binders for boolean
+// variables.
+
+namespace Microsoft.Boogie.VCExprAST
+{
+
+  public struct FlattenerState {
+    public readonly int Polarity;
+    public readonly bool InTerm;
+
+    public static FlattenerState INITIAL = new FlattenerState(1, false);
+
+    public FlattenerState(int polarity, bool inTerm) {
+      Polarity = polarity;
+      InTerm = inTerm;
+    }
+
+    public FlattenerState TogglePolarity { get {
+      return new FlattenerState(-Polarity, InTerm);
+    } }
+
+    public FlattenerState ZeroPolarity { get {
+      return new FlattenerState(0, InTerm);
+    } }
+
+    public FlattenerState EnterTerm { get {
+      return new FlattenerState(Polarity, true);
+    } }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  public class TermFormulaFlattener : MutatingVCExprVisitor<FlattenerState> {
+
+    public TermFormulaFlattener(VCExpressionGenerator gen):base(gen){
+Contract.Requires(gen != null);
+      
+    }
+
+    private readonly IDictionary<VCExpr/*!*/, VCExprVar/*!*/>/*!*/ Bindings =
+      new Dictionary<VCExpr/*!*/, VCExprVar/*!*/> ();
+    
+    private int varNameCounter = 0;
+
+    public VCExpr Flatten(VCExpr expr){
+Contract.Requires(expr != null);
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExpr/*!*/ res = Mutate(expr, FlattenerState.INITIAL);
+      Contract.Assert(res != null);
+      while (Bindings.Count > 0) {
+        List<VCExprLetBinding/*!*/>/*!*/ letBindings = new List<VCExprLetBinding/*!*/> ();
+        foreach (KeyValuePair<VCExpr/*!*/, VCExprVar/*!*/> pair in Bindings){Contract.Assert(cce.NonNullElements(pair));
+          letBindings.Add(Gen.LetBinding(pair.Value, pair.Key));}
+        Bindings.Clear();
+        res = AddBindings(letBindings, res, FlattenerState.INITIAL);
+      }
+      return res;
+    }
+
+    private VCExprVar GetVarFor(VCExpr expr){
+Contract.Requires(expr != null);
+Contract.Requires((expr.Type.IsBool));
+Contract.Ensures(Contract.Result<VCExprVar>() != null);
+      VCExprVar res;
+      if (!Bindings.TryGetValue(expr, out res)) {
+        string name = "flt" + varNameCounter;
+        varNameCounter = varNameCounter + 1;
+        res = Gen.Variable(name, Type.Bool);
+        Bindings.Add(expr, res);
+      }
+      return cce.NonNull(res);
+    }
+
+    // Remove all let-bindings from the field bindings whose rhs
+    // contains any of the specified variables
+    private List<VCExprLetBinding/*!*/>/*!*/ RemoveBindingsWithVars(List<VCExprVar/*!*/>/*!*/ boundVars, List<TypeVariable/*!*/>/*!*/ boundTypeVars){
+Contract.Requires(cce.NonNullElements(boundTypeVars));
+Contract.Requires(cce.NonNullElements(boundVars));
+Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprLetBinding>>()));      
+      List<VCExprLetBinding/*!*/>/*!*/ res = new List<VCExprLetBinding/*!*/> ();
+      FreeVariableCollector/*!*/ coll = new FreeVariableCollector ();
+
+      foreach (KeyValuePair<VCExpr, VCExprVar> pair in Bindings) {
+        Contract.Assert(cce.NonNullElements(pair));
+        coll.Collect(pair.Key);
+        if (boundVars.Any(var => coll.FreeTermVars.ContainsKey(var)) ||
+            boundTypeVars.Any(var => coll.FreeTypeVars.Contains(var)))
+          res.Add(Gen.LetBinding(pair.Value, pair.Key));
+        coll.Reset();
+      }
+
+      foreach (VCExprLetBinding b in res){Contract.Assert(b != null);
+        Bindings.Remove(b.E);}
+
+      return res;
+    }
+    
+    // Add bindings to a formula using an implication or
+    // conjunction. The bindings themselves will be flattened as well,
+    // which might introduce further bindings
+    private VCExpr AddBindings(List<VCExprLetBinding/*!*/>/*!*/ bindings, VCExpr body, FlattenerState state){
+Contract.Requires(body != null);
+Contract.Requires(cce.NonNullElements(bindings));
+Contract.Requires((body.Type.IsBool));
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      List<VCExprLetBinding/*!*/>/*!*/ mutatedBindings = FlattenBindings(bindings, state);
+      Contract.Assert(mutatedBindings != null);
+      VCExpr/*!*/ bindingEquations = Gen.AsEquations(mutatedBindings);
+      Contract.Assert(bindingEquations != null);
+      switch(state.Polarity) {
+      case 1:
+        return Gen.Implies(bindingEquations, body);
+      case -1:
+        return Gen.And(bindingEquations, body);
+      case 0:
+        // also add explicit quantifiers for the bound variables
+        List<VCExprVar/*!*/>/*!*/ vars = new List<VCExprVar/*!*/> ();
+        foreach (VCExprLetBinding/*!*/ binding in mutatedBindings){Contract.Assert(binding != null);
+          vars.Add(binding.V);}
+        return Gen.Forall(vars, new List<VCTrigger/*!*/>(),
+                          Gen.Implies(bindingEquations, body));
+      }
+      Contract.Assert(false); throw new cce.UnreachableException();
+    }
+
+    private List<VCExprLetBinding/*!*/>/*!*/ FlattenBindings(List<VCExprLetBinding/*!*/>/*!*/ bindings, FlattenerState state){
+Contract.Requires(cce.NonNullElements(bindings));
+Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprLetBinding>>()));
+      FlattenerState stateInBindings = state.ZeroPolarity;
+      List<VCExprLetBinding/*!*/>/*!*/ mutatedBindings = new List<VCExprLetBinding/*!*/> ();
+      foreach (VCExprLetBinding/*!*/ b in bindings) {
+        Contract.Assert(b != null);
+        mutatedBindings.Add(Gen.LetBinding(b.V, Mutate(b.E, stateInBindings)));
+      }
+      return mutatedBindings;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public override bool AvoidVisit(VCExprNAry node, FlattenerState arg)
+    {
+        return node.Op.Equals(VCExpressionGenerator.AndOp) ||
+               node.Op.Equals(VCExpressionGenerator.OrOp);
+    }
+
+    public override VCExpr Visit(VCExprNAry node, FlattenerState state){
+Contract.Requires(node != null);
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      // track the polarity to know whether implications or conjunctions
+      // are to be introduced
+
+      if (node.Op.Equals(VCExpressionGenerator.NotOp))
+        return Gen.Not(Mutate(node[0], state.TogglePolarity));
+
+      if (node.Op.Equals(VCExpressionGenerator.ImpliesOp)) {
+        VCExpr newArg0 = Mutate(node[0], state.TogglePolarity);
+        VCExpr newArg1 = Mutate(node[1], state);
+        return Gen.Implies(newArg0, newArg1);
+      }
+
+      if (!node.Type.IsBool)
+        state = state.EnterTerm;
+
+      if (!node.Op.Equals(VCExpressionGenerator.AndOp) &&
+          !node.Op.Equals(VCExpressionGenerator.OrOp) &&
+          !(node.Op is VCExprLabelOp))
+        // standard is to set the polarity to 0 (fits most operators)
+        return base.Visit(node, state.ZeroPolarity);
+
+      return base.Visit(node, state);
+    }
+
+    public override VCExpr Visit(VCExprQuantifier node, FlattenerState state){
+Contract.Requires(node != null);
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (state.InTerm)
+        return GetVarFor(node);
+
+      // we only flatten within the matrix of the quantified formula,
+      // not within the triggers (since SMT-solvers do not seem to
+      // appreciate triggers with let-binders)
+      VCExpr newBody = Mutate(node.Body, state);
+
+      // Check whether any of the extracted terms contain variables
+      // bound by this quantifier. In this case, we have to add
+      // let-binders and remove the extracted terms
+      bool cont = true;
+      while (cont) {
+        List<VCExprLetBinding/*!*/>/*!*/ localBindings =
+          RemoveBindingsWithVars(node.BoundVars, node.TypeParameters);
+        Contract.Assert(cce.NonNullElements(localBindings));
+        if (localBindings.Count > 0)
+          newBody = AddBindings(localBindings, newBody, state);
+        else
+          cont = false;
+      }
+
+      return Gen.Quantify(node.Quan, node.TypeParameters, node.BoundVars, node.Triggers, node.Infos, newBody);
+    }
+
+    public override VCExpr Visit(VCExprLet node, FlattenerState state){
+Contract.Requires(node != null);
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (state.InTerm)
+        return GetVarFor(node);
+
+      VCExprLet prelimRes = (VCExprLet)cce.NonNull(base.Visit(node, state));
+
+      List<VCExprLetBinding/*!*/>/*!*/ allBindings = new List<VCExprLetBinding/*!*/> ();
+      allBindings.AddRange(prelimRes);
+
+      // Check whether any of the extracted terms contain variables
+      // bound by this binder. In this case, we have to add
+      // let-binders and remove the extracted terms
+      bool cont = true;
+      while (cont) {
+        List<VCExprLetBinding/*!*/>/*!*/ localBindings =
+          RemoveBindingsWithVars(prelimRes.BoundVars, new List<TypeVariable/*!*/>());
+        if (localBindings.Count > 0)
+          allBindings.AddRange(FlattenBindings(localBindings, state));
+        else
+          cont = false;
+      }
+      
+      return Gen.Let(allBindings, prelimRes.Body);
+    }
+
+  }
+
 }
 \ No newline at end of file
diff --git a/Source/VCExpr/TypeErasure.cs b/Source/VCExpr/TypeErasure.cs
index 6fb38c27..c2d99d77 100644
--- a/Source/VCExpr/TypeErasure.cs
+++ b/Source/VCExpr/TypeErasure.cs
@@ -1,1710 +1,1710 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Linq;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-using Microsoft.Boogie.VCExprAST;
-
-// different classes for erasing complex types in VCExprs, replacing them
-// with axioms that can be handled by theorem provers and SMT solvers
-
-namespace Microsoft.Boogie.TypeErasure {
-  using Microsoft.Boogie.VCExprAST;
-
-  // some functionality that is needed in many places (and that should
-  // really be provided by the Spec# container classes; maybe one
-  // could integrate the functions in a nicer way?)
-  public class HelperFuns {
-
-    public static Function BoogieFunction(string name, List<TypeVariable/*!*/>/*!*/ typeParams, params Type[] types) {
-      Contract.Requires(types != null);
-      Contract.Requires(name != null);
-      Contract.Requires(cce.NonNullElements(typeParams));
-      Contract.Requires(types.Length > 0);
-      Contract.Requires(Contract.ForAll(0, types.Length, i => types[i] != null));
-      Contract.Ensures(Contract.Result<Function>() != null);
-
-      List<Variable> args = new List<Variable>();
-      for (int i = 0; i < types.Length - 1; ++i)
-        args.Add(new Formal(Token.NoToken,
-                             new TypedIdent(Token.NoToken, "arg" + i, cce.NonNull(types[i])),
-                             true));
-      Formal result = new Formal(Token.NoToken,
-                                   new TypedIdent(Token.NoToken, "res",
-                                                   cce.NonNull(types)[types.Length - 1]),
-                                   false);
-      return new Function(Token.NoToken, name, new List<TypeVariable>(typeParams), args, result);
-    }
-
-    public static Function BoogieFunction(string name, params Type[] types) {
-      Contract.Requires(types != null);
-      Contract.Requires(name != null);
-      Contract.Ensures(Contract.Result<Function>() != null);
-      return BoogieFunction(name, new List<TypeVariable/*!*/>(), types);
-    }
-
-    // boogie function where all arguments and the result have the same type U
-    public static Function UniformBoogieFunction(string name, int arity, Type U) {
-      Contract.Requires(U != null);
-      Contract.Requires(name != null);
-      Contract.Ensures(Contract.Result<Function>() != null);
-      Type[]/*!*/ types = new Type[arity + 1];
-      for (int i = 0; i < arity + 1; ++i)
-        types[i] = U;
-      return BoogieFunction(name, types);
-    }
-
-    public static List<VCExprVar/*!*/>/*!*/ GenVarsForInParams(Function fun, VCExpressionGenerator gen) {
-      Contract.Requires(gen != null);
-      Contract.Requires(fun != null);
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
-      List<VCExprVar/*!*/>/*!*/ arguments = new List<VCExprVar/*!*/>(fun.InParams.Count);
-      foreach (Formal/*!*/ f in fun.InParams) {
-        Contract.Assert(f != null);
-        VCExprVar/*!*/ var = gen.Variable(f.Name, f.TypedIdent.Type);
-        arguments.Add(var);
-      }
-      return arguments;
-    }
-
-    public static List<T/*!*/>/*!*/ ToList<T>(params T[] args) where T : class{
-      Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<T>>()));
-      return new List<T>(args);
-    }
-
-    public static List<VCExpr/*!*/>/*!*/ ToVCExprList(List<VCExprVar/*!*/>/*!*/ list) {
-      Contract.Requires(cce.NonNullElements(list));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
-      return new List<VCExpr>(list);
-    }
-
-    public static List<VCExprVar/*!*/>/*!*/ VarVector(string baseName, int num, Type type, VCExpressionGenerator gen) {
-      Contract.Requires(gen != null);
-      Contract.Requires(type != null);
-      Contract.Requires(baseName != null);
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
-      List<VCExprVar/*!*/>/*!*/ res = new List<VCExprVar/*!*/>(num);
-      for (int i = 0; i < num; ++i)
-        res.Add(gen.Variable(baseName + i, type));
-      return res;
-    }
-
-    public static List<VCExprVar/*!*/>/*!*/ VarVector(string baseName, List<Type/*!*/>/*!*/ types, VCExpressionGenerator gen) {
-      Contract.Requires(gen != null);
-      Contract.Requires(baseName != null);
-      Contract.Requires(cce.NonNullElements(types));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
-      List<VCExprVar/*!*/>/*!*/ res = new List<VCExprVar/*!*/>(types.Count);
-      for (int i = 0; i < types.Count; ++i)
-        res.Add(gen.Variable(baseName + i, types[i]));
-      return res;
-    }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  internal struct TypeCtorRepr {
-    // function that represents the application of the type constructor
-    // to smaller types
-    public readonly Function/*!*/ Ctor;
-    // left-inverse functions that extract the subtypes of a compound type
-    public readonly List<Function/*!*/>/*!*/ Dtors;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Ctor != null);
-      Contract.Invariant(cce.NonNullElements(Dtors));
-    }
-
-
-    public TypeCtorRepr(Function ctor, List<Function/*!*/>/*!*/ dtors) {
-      Contract.Requires(ctor != null);
-      Contract.Requires(cce.NonNullElements(dtors));
-      Contract.Requires(ctor.InParams.Count == dtors.Count);
-      this.Ctor = ctor;
-      this.Dtors = dtors;
-    }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  // The class responsible for creating and keeping track of all
-  // axioms related to the type system. This abstract class is made
-  // concrete in two subclasses, one for type erasure with type
-  // premisses in quantifiers (the semantic approach), and one for
-  // type erasure with explicit type arguments of polymorphic
-  // functions (the syntacted approach).
-  [ContractClass(typeof(TypeAxiomBuilderContracts))]
-  public abstract class TypeAxiomBuilder : ICloneable {
-
-    protected readonly VCExpressionGenerator/*!*/ Gen;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Gen != null);
-      Contract.Invariant(Ctor != null);
-
-    }
-
-
-    internal abstract MapTypeAbstractionBuilder/*!*/ MapTypeAbstracter {
-      get;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // Type Axioms
-
-    // list in which all typed axioms are collected
-    private readonly List<VCExpr/*!*/>/*!*/ AllTypeAxioms;
-    [ContractInvariantMethod]
-    void AllTypeAxiomsInvariantMethod() {
-      Contract.Invariant(cce.NonNullElements(AllTypeAxioms));
-    }
-
-    // list in which type axioms are incrementally collected
-    private readonly List<VCExpr/*!*/>/*!*/ IncTypeAxioms;
-    [ContractInvariantMethod]
-    void IncTypeAxiomsInvariantMethod() {
-      Contract.Invariant(cce.NonNullElements(IncTypeAxioms));
-    }
-
-    internal void AddTypeAxiom(VCExpr axiom) {
-      Contract.Requires(axiom != null);
-      AllTypeAxioms.Add(axiom);
-      IncTypeAxioms.Add(axiom);
-    }
-
-    // Return all axioms that were added since the last time NewAxioms
-    // was called
-    public VCExpr GetNewAxioms() {
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExpr/*!*/ res = Gen.NAry(VCExpressionGenerator.AndOp, IncTypeAxioms);
-      IncTypeAxioms.Clear();
-      return res;
-    }
-
-    // mapping from a type to its constructor number/index
-    private readonly Function/*!*/ Ctor;
-    private BigNum CurrentCtorNum;
-
-    private VCExpr GenCtorAssignment(VCExpr typeRepr) {
-      Contract.Requires(typeRepr != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (CommandLineOptions.Clo.TypeEncodingMethod
-                == CommandLineOptions.TypeEncoding.None)
-        return VCExpressionGenerator.True;
-
-      VCExpr res = Gen.Eq(Gen.Function(Ctor, typeRepr),
-                           Gen.Integer(CurrentCtorNum));
-      CurrentCtorNum = CurrentCtorNum + BigNum.ONE;
-      return res;
-    }
-
-    private VCExpr GenCtorAssignment(Function typeRepr) {
-      Contract.Requires(typeRepr != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (CommandLineOptions.Clo.TypeEncodingMethod
-                == CommandLineOptions.TypeEncoding.None)
-        return VCExpressionGenerator.True;
-
-      List<VCExprVar/*!*/>/*!*/ quantifiedVars = HelperFuns.GenVarsForInParams(typeRepr, Gen);
-      VCExpr/*!*/ eq =
-        GenCtorAssignment(Gen.Function(typeRepr,
-                                       HelperFuns.ToVCExprList(quantifiedVars)));
-
-      if (typeRepr.InParams.Count == 0)
-        return eq;
-
-      return Gen.Forall(quantifiedVars, new List<VCTrigger/*!*/>(),
-                        "ctor:" + typeRepr.Name, -1, eq);
-    }
-
-    // generate an axiom (forall x0, x1, ... :: invFun(fun(x0, x1, ...) == xi)
-    protected VCExpr GenLeftInverseAxiom(Function fun, Function invFun, int dtorNum) {
-      Contract.Requires(invFun != null);
-      Contract.Requires(fun != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<VCExprVar/*!*/>/*!*/ quantifiedVars = HelperFuns.GenVarsForInParams(fun, Gen);
-      Contract.Assert(cce.NonNullElements(quantifiedVars));
-
-      VCExpr/*!*/ funApp = Gen.Function(fun, HelperFuns.ToVCExprList(quantifiedVars));
-      VCExpr/*!*/ lhs = Gen.Function(invFun, funApp);
-      VCExpr/*!*/ rhs = quantifiedVars[dtorNum];
-      VCExpr/*!*/ eq = Gen.Eq(lhs, rhs);
-
-      List<VCTrigger/*!*/>/*!*/ triggers = HelperFuns.ToList(Gen.Trigger(true, HelperFuns.ToList(funApp)));
-      Contract.Assert(cce.NonNullElements(triggers));
-      return Gen.Forall(quantifiedVars, triggers, "typeInv:" + invFun.Name, -1, eq);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    // the type of everything that is not int, bool, or a type
-    [ContractInvariantMethod]
-    void ObjectInvariant2() {
-      Contract.Invariant(UDecl != null);
-      Contract.Invariant(TDecl != null);
-      Contract.Invariant(U != null);
-      Contract.Invariant(T != null);
-    }
-
-    private readonly TypeCtorDecl/*!*/ UDecl;
-    public readonly Type/*!*/ U;
-
-    // the type of types
-    private readonly TypeCtorDecl/*!*/ TDecl;
-    public readonly Type/*!*/ T;
-
-    public abstract Type/*!*/ TypeAfterErasure(Type/*!*/ type);
-    [Pure]
-    public abstract bool UnchangedType(Type/*!*/ type);
-
-    ///////////////////////////////////////////////////////////////////////////
-    // Symbols for representing types
-
-    private readonly IDictionary<Type/*!*/, VCExpr/*!*/>/*!*/ BasicTypeReprs;
-    [ContractInvariantMethod]
-    void BasicTypeReprsInvariantMethod() {
-      Contract.Invariant(cce.NonNullDictionaryAndValues(BasicTypeReprs));
-    }
-
-    private VCExpr GetBasicTypeRepr(Type type) {
-      Contract.Requires(type != null);
-      Contract.Requires(type.IsBasic || type.IsBv);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExpr res;
-      if (!BasicTypeReprs.TryGetValue(type, out res)) {
-        res = Gen.Function(HelperFuns.BoogieFunction(type.ToString() + "Type", T));
-        AddTypeAxiom(GenCtorAssignment(res));
-        BasicTypeReprs.Add(type, res);
-      }
-      return cce.NonNull(res);
-    }
-
-    private readonly IDictionary<TypeCtorDecl/*!*/, TypeCtorRepr/*!*/>/*!*/ TypeCtorReprs;
-    [ContractInvariantMethod]
-    void TypeCtorReprsInvariantMethod() {
-      Contract.Invariant(TypeCtorReprs != null);
-    }
-
-    internal TypeCtorRepr GetTypeCtorReprStruct(TypeCtorDecl decl) {
-      Contract.Requires(decl != null);
-      TypeCtorRepr reprSet;
-      if (!TypeCtorReprs.TryGetValue(decl, out reprSet)) {
-        Function/*!*/ ctor = HelperFuns.UniformBoogieFunction(decl.Name + "Type", decl.Arity, T);
-        Contract.Assert(ctor != null);
-        AddTypeAxiom(GenCtorAssignment(ctor));
-
-        List<Function/*!*/>/*!*/ dtors = new List<Function/*!*/>(decl.Arity);
-        for (int i = 0; i < decl.Arity; ++i) {
-          Function/*!*/ dtor = HelperFuns.UniformBoogieFunction(decl.Name + "TypeInv" + i, 1, T);
-          dtors.Add(dtor);
-          AddTypeAxiom(GenLeftInverseAxiom(ctor, dtor, i));
-        }
-
-        reprSet = new TypeCtorRepr(ctor, dtors);
-        TypeCtorReprs.Add(decl, reprSet);
-      }
-
-      return reprSet;
-    }
-
-    public Function GetTypeCtorRepr(TypeCtorDecl decl) {
-      Contract.Requires(decl != null);
-      Contract.Ensures(Contract.Result<Function>() != null);
-      return GetTypeCtorReprStruct(decl).Ctor;
-    }
-
-    public Function GetTypeDtor(TypeCtorDecl decl, int num) {
-      Contract.Requires(decl != null);
-      Contract.Ensures(Contract.Result<Function>() != null);
-      return GetTypeCtorReprStruct(decl).Dtors[num];
-    }
-
-    // mapping from free type variables to VCExpr variables
-    private readonly IDictionary<TypeVariable/*!*/, VCExprVar/*!*/>/*!*/ TypeVariableMapping;
-    [ContractInvariantMethod]
-    void TypeVariableMappingInvariantMethod() {
-      Contract.Invariant(cce.NonNullDictionaryAndValues(TypeVariableMapping));
-    }
-
-    public VCExprVar Typed2Untyped(TypeVariable var) {
-      Contract.Requires(var != null);
-      Contract.Ensures(Contract.Result<VCExprVar>() != null);
-      VCExprVar res;
-      if (!TypeVariableMapping.TryGetValue(var, out res)) {
-        res = new VCExprVar(var.Name, T);
-        TypeVariableMapping.Add(var, res);
-      }
-      return cce.NonNull(res);
-    }
-
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Symbols for representing variables and constants
-
-    // Globally defined variables
-    private readonly IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ Typed2UntypedVariables;
-    [ContractInvariantMethod]
-    void Typed2UntypedVariablesInvariantMethod() {
-      Contract.Invariant(cce.NonNullDictionaryAndValues(Typed2UntypedVariables));
-    }
-
-    // This method must only be used for free (unbound) variables
-    public VCExprVar Typed2Untyped(VCExprVar var) {
-      Contract.Requires(var != null);
-      Contract.Ensures(Contract.Result<VCExprVar>() != null);
-      VCExprVar res = TryTyped2Untyped(var);
-      if (res == null) {
-        res = Gen.Variable(var.Name, TypeAfterErasure(var.Type));
-        Typed2UntypedVariables.Add(var, res);
-        AddVarTypeAxiom(res, var.Type);
-      }
-      return cce.NonNull(res);
-    }
-
-    /// <summary>
-    ///  This method is like Typed2Untyped, except in the case where the given variables
-    ///  doesn't exist in the mapping.  For that case, this method returns null whereas
-    ///  Typed2Untyped creates a new variable that it adds to the mapping.
-    /// </summary>
-    /// <param name="var"></param>
-    /// <returns></returns>
-    public VCExprVar TryTyped2Untyped(VCExprVar var) {
-      Contract.Requires(var != null);
-      VCExprVar res;
-      if (Typed2UntypedVariables.TryGetValue(var, out res)) {
-        return res;
-      } else {
-        return null;
-      }
-    }
-
-    protected abstract void AddVarTypeAxiom(VCExprVar/*!*/ var, Type/*!*/ originalType);
-
-    ///////////////////////////////////////////////////////////////////////////
-    // Translation function from types to their term representation
-
-    public VCExpr Type2Term(Type type, IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/ varMapping) {
-      Contract.Requires(type != null);
-      Contract.Requires(cce.NonNullDictionaryAndValues(varMapping));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      //
-      if (type.IsBasic || type.IsBv) {
-        //
-        return GetBasicTypeRepr(type);
-        //
-      } else if (type.IsCtor) {
-        //
-        CtorType ctype = type.AsCtor;
-        Function/*!*/ repr = GetTypeCtorRepr(ctype.Decl);
-        List<VCExpr/*!*/>/*!*/ args = new List<VCExpr/*!*/>(ctype.Arguments.Count);
-        foreach (Type/*!*/ t in ctype.Arguments.ToArray()) {
-          Contract.Assert(t != null);
-          args.Add(Type2Term(t, varMapping));
-        }
-        return Gen.Function(repr, args);
-        //
-      } else if (type.IsVariable) {
-        //
-        VCExpr res;
-        if (!varMapping.TryGetValue(type.AsVariable, out res))
-          // then the variable is free and we bind it at this point to a term
-          // variable
-          res = Typed2Untyped(type.AsVariable);
-        return cce.NonNull(res);
-        //
-      } else if (type.IsMap) {
-        //
-        return Type2Term(MapTypeAbstracter.AbstractMapType(type.AsMap), varMapping);
-        //
-      } else {
-        System.Diagnostics.Debug.Fail("Don't know how to handle this type: " + type);
-        Contract.Assert(false);
-        throw new cce.UnreachableException();  // please the compiler
-      }
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public TypeAxiomBuilder(VCExpressionGenerator gen) {
-      Contract.Requires(gen != null);
-      this.Gen = gen;
-      AllTypeAxioms = new List<VCExpr/*!*/>();
-      IncTypeAxioms = new List<VCExpr/*!*/>();
-      BasicTypeReprs = new Dictionary<Type/*!*/, VCExpr/*!*/>();
-      CurrentCtorNum = BigNum.ZERO;
-      TypeCtorReprs = new Dictionary<TypeCtorDecl/*!*/, TypeCtorRepr>();
-      TypeVariableMapping = new Dictionary<TypeVariable/*!*/, VCExprVar/*!*/>();
-      Typed2UntypedVariables = new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/>();
-
-      TypeCtorDecl/*!*/ uDecl = new TypeCtorDecl(Token.NoToken, "U", 0);
-      UDecl = uDecl;
-      Type/*!*/ u = new CtorType(Token.NoToken, uDecl, new List<Type>());
-      U = u;
-
-      TypeCtorDecl/*!*/ tDecl = new TypeCtorDecl(Token.NoToken, "T", 0);
-      TDecl = tDecl;
-      Type/*!*/ t = new CtorType(Token.NoToken, tDecl, new List<Type>());
-      T = t;
-
-      Ctor = HelperFuns.BoogieFunction("Ctor", t, Type.Int);
-    }
-
-    public virtual void Setup() {
-      GetBasicTypeRepr(Type.Int);
-      GetBasicTypeRepr(Type.Real);
-      GetBasicTypeRepr(Type.Bool);
-    }
-
-    // constructor to allow cloning
-    internal TypeAxiomBuilder(TypeAxiomBuilder builder) {
-      Contract.Requires(builder != null);
-      Gen = builder.Gen;
-      AllTypeAxioms = new List<VCExpr/*!*/>(builder.AllTypeAxioms);
-      IncTypeAxioms = new List<VCExpr/*!*/>(builder.IncTypeAxioms);
-
-      UDecl = builder.UDecl;
-      U = builder.U;
-
-      TDecl = builder.TDecl;
-      T = builder.T;
-
-      Ctor = builder.Ctor;
-      CurrentCtorNum = builder.CurrentCtorNum;
-
-      BasicTypeReprs = new Dictionary<Type/*!*/, VCExpr/*!*/>(builder.BasicTypeReprs);
-      TypeCtorReprs = new Dictionary<TypeCtorDecl/*!*/, TypeCtorRepr>(builder.TypeCtorReprs);
-
-      TypeVariableMapping =
-        new Dictionary<TypeVariable/*!*/, VCExprVar/*!*/>(builder.TypeVariableMapping);
-      Typed2UntypedVariables =
-        new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/>(builder.Typed2UntypedVariables);
-    }
-
-    public abstract Object/*!*/ Clone();
-  }
-
-  [ContractClassFor(typeof(TypeAxiomBuilder))]
-  public abstract class TypeAxiomBuilderContracts : TypeAxiomBuilder {
-    public TypeAxiomBuilderContracts()
-      : base((VCExpressionGenerator)null) {
-    }
-    internal override MapTypeAbstractionBuilder MapTypeAbstracter {
-      get {
-        Contract.Ensures(Contract.Result<MapTypeAbstractionBuilder>() != null);
-        throw new NotImplementedException();
-      }
-    }
-
-    public override Type TypeAfterErasure(Type type) {
-      Contract.Requires(type != null);
-      Contract.Ensures(Contract.Result<Type>() != null);
-
-      throw new NotImplementedException();
-    }
-
-    public override bool UnchangedType(Type type) {
-      Contract.Requires(type != null);
-      throw new NotImplementedException();
-    }
-
-    protected override void AddVarTypeAxiom(VCExprVar var, Type originalType) {
-      Contract.Requires(var != null);
-      Contract.Requires(originalType != null);
-      throw new NotImplementedException();
-    }
-
-    public override object Clone() {
-      Contract.Ensures(Contract.Result<object>() != null);
-
-      throw new NotImplementedException();
-    }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  // Subclass of the TypeAxiomBuilder that provides all functionality
-  // to deal with native sorts of a theorem prover (that are the only
-  // types left after erasing all other types). Currently, these are:
-  //
-  //  U ... sort of all individuals/objects/values
-  //  T ... sort of all types
-  //  int ... integers
-  //  bool ... booleans
-
-  [ContractClass(typeof(TypeAxiomBuilderIntBoolUContracts))]
-  public abstract class TypeAxiomBuilderIntBoolU : TypeAxiomBuilder {
-
-    public TypeAxiomBuilderIntBoolU(VCExpressionGenerator gen)
-      : base(gen) {
-      Contract.Requires(gen != null);
-
-      TypeCasts = new Dictionary<Type/*!*/, TypeCastSet>();
-    }
-
-    // constructor to allow cloning
-    internal TypeAxiomBuilderIntBoolU(TypeAxiomBuilderIntBoolU builder)
-      : base(builder) {
-      Contract.Requires(builder != null);
-
-      TypeCasts = new Dictionary<Type/*!*/, TypeCastSet>(builder.TypeCasts);
-    }
-
-    public override void Setup() {
-      base.Setup();
-
-      GetTypeCasts(Type.Int);
-      GetTypeCasts(Type.Real);
-      GetTypeCasts(Type.Bool);
-    }
-
-    // generate inverse axioms for casts (castToU(castFromU(x)) = x, under certain premisses)
-    protected abstract VCExpr/*!*/ GenReverseCastAxiom(Function/*!*/ castToU, Function/*!*/ castFromU);
-
-    protected VCExpr GenReverseCastEq(Function castToU, Function castFromU, out VCExprVar var, out List<VCTrigger/*!*/>/*!*/ triggers) {
-      Contract.Requires((castFromU != null));
-      Contract.Requires((castToU != null));
-      Contract.Ensures((cce.NonNullElements(Contract.ValueAtReturn(out triggers))));
-      Contract.Ensures(Contract.ValueAtReturn(out var) != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      var = Gen.Variable("x", U);
-
-      VCExpr inner = Gen.Function(castFromU, var);
-      VCExpr lhs = Gen.Function(castToU, inner);
-      triggers = HelperFuns.ToList(Gen.Trigger(true, HelperFuns.ToList(inner)));
-
-      return Gen.Eq(lhs, var);
-    }
-
-    protected abstract VCExpr/*!*/ GenCastTypeAxioms(Function/*!*/ castToU, Function/*!*/ castFromU);
-
-    ///////////////////////////////////////////////////////////////////////////
-    // storage of type casts for types that are supposed to be left over in the
-    // VCs (like int, bool, bitvectors)
-
-    private readonly IDictionary<Type/*!*/, TypeCastSet/*!*/>/*!*/ TypeCasts;
-    [ContractInvariantMethod]
-    void TypeCastsInvariantMethod() {
-      Contract.Invariant(TypeCasts != null);
-    }
-
-    private TypeCastSet GetTypeCasts(Type type) {
-      Contract.Requires(type != null);
-      TypeCastSet res;
-      if (!TypeCasts.TryGetValue(type, out res)) {
-        Function/*!*/ castToU = HelperFuns.BoogieFunction(type.ToString() + "_2_U", type, U);
-        Function/*!*/ castFromU = HelperFuns.BoogieFunction("U_2_" + type.ToString(), U, type);
-
-        AddTypeAxiom(GenLeftInverseAxiom(castToU, castFromU, 0));
-        AddTypeAxiom(GenReverseCastAxiom(castToU, castFromU));
-        AddTypeAxiom(GenCastTypeAxioms(castToU, castFromU));
-
-        res = new TypeCastSet(castToU, castFromU);
-        TypeCasts.Add(type, res);
-      }
-      return res;
-    }
-    [Pure]
-    public Function CastTo(Type type) {
-      Contract.Requires(type != null);
-      Contract.Requires(UnchangedType(type));
-      Contract.Ensures(Contract.Result<Function>() != null);
-      return GetTypeCasts(type).CastFromU;
-    }
-
-    public Function CastFrom(Type type) {
-      Contract.Requires(type != null);
-      Contract.Requires((UnchangedType(type)));
-      Contract.Ensures(Contract.Result<Function>() != null);
-      return GetTypeCasts(type).CastToU;
-    }
-
-    private struct TypeCastSet {
-      public readonly Function/*!*/ CastToU;
-      public readonly Function/*!*/ CastFromU;
-      [ContractInvariantMethod]
-      void ObjectInvariant() {
-        Contract.Invariant(CastToU != null);
-        Contract.Invariant(CastFromU != null);
-      }
-
-
-      public TypeCastSet(Function castToU, Function castFromU) {
-        Contract.Requires(castFromU != null);
-        Contract.Requires(castToU != null);
-        CastToU = castToU;
-        CastFromU = castFromU;
-      }
-    }
-
-    public bool IsCast(Function fun) {
-      Contract.Requires(fun != null);
-      if (fun.InParams.Count != 1)
-        return false;
-      Type/*!*/ inType = cce.NonNull(fun.InParams[0]).TypedIdent.Type;
-      if (inType.Equals(U)) {
-        Type/*!*/ outType = cce.NonNull(fun.OutParams[0]).TypedIdent.Type;
-        if (!TypeCasts.ContainsKey(outType))
-          return false;
-        return fun.Equals(CastTo(outType));
-      } else {
-        if (!TypeCasts.ContainsKey(inType))
-          return false;
-        Type/*!*/ outType = cce.NonNull(fun.OutParams[0]).TypedIdent.Type;
-        if (!outType.Equals(U))
-          return false;
-        return fun.Equals(CastFrom(inType));
-      }
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    // the only types that we allow in "untyped" expressions are U,
-    // Type.Int, Type.Real, and Type.Bool
-
-    public override Type TypeAfterErasure(Type type) {
-      //Contract.Requires(type != null);
-      Contract.Ensures(Contract.Result<Type>() != null);
-      if (UnchangedType(type))
-        // these types are kept
-        return type;
-      else
-        // all other types are replaced by U
-        return U;
-    }
-
-    [Pure]
-    public override bool UnchangedType(Type type) {
-      //Contract.Requires(type != null);
-      return type.IsInt || type.IsReal || type.IsBool || type.IsBv || (type.IsMap && CommandLineOptions.Clo.MonomorphicArrays);
-    }
-
-    public VCExpr Cast(VCExpr expr, Type toType) {
-      Contract.Requires(toType != null);
-      Contract.Requires(expr != null);
-      Contract.Requires((expr.Type.Equals(U) || UnchangedType(expr.Type)));
-      Contract.Requires((toType.Equals(U) || UnchangedType(toType)));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (expr.Type.Equals(toType))
-        return expr;
-
-      if (toType.Equals(U)) {
-        return Gen.Function(CastFrom(expr.Type), expr);
-      } else {
-        Contract.Assert(expr.Type.Equals(U));
-        return Gen.Function(CastTo(toType), expr);
-      }
-    }
-
-    public List<VCExpr/*!*/>/*!*/ CastSeq(List<VCExpr/*!*/>/*!*/ exprs, Type toType) {
-      Contract.Requires(toType != null);
-      Contract.Requires(cce.NonNullElements(exprs));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
-      List<VCExpr/*!*/>/*!*/ res = new List<VCExpr/*!*/>(exprs.Count);
-      foreach (VCExpr/*!*/ expr in exprs) {
-        Contract.Assert(expr != null);
-        res.Add(Cast(expr, toType));
-      }
-      return res;
-    }
-
-
-  }
-
-  [ContractClassFor(typeof(TypeAxiomBuilderIntBoolU))]
-  public abstract class TypeAxiomBuilderIntBoolUContracts : TypeAxiomBuilderIntBoolU {
-    public TypeAxiomBuilderIntBoolUContracts()
-      : base((TypeAxiomBuilderIntBoolU)null) {
-    }
-    protected override VCExpr GenReverseCastAxiom(Function castToU, Function castFromU) {
-      Contract.Requires(castToU != null);
-      Contract.Requires(castFromU != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      throw new NotImplementedException();
-    }
-
-    protected override VCExpr GenCastTypeAxioms(Function castToU, Function castFromU) {
-      Contract.Requires(castFromU != null);
-      Contract.Requires(castToU != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      throw new NotImplementedException();
-    }
-
-    internal override MapTypeAbstractionBuilder MapTypeAbstracter {
-      get {
-        throw new NotImplementedException();
-      }
-    }
-
-    protected override void AddVarTypeAxiom(VCExprVar var, Type originalType) {
-      throw new NotImplementedException();
-    }
-
-    public override object Clone() {
-      throw new NotImplementedException();
-    }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-  // Class for computing most general abstractions of map types. An abstraction
-  // of a map type t is a maptype t' in which closed proper subtypes have been replaced
-  // with type variables. E.g., an abstraction of <a>[C a, int]a would be <a>[C a, b]a.
-  // We subsequently consider most general abstractions as ordinary parametrised types,
-  // i.e., "<a>[C a, b]a" would be considered as a type "M b" with polymorphically typed
-  // access functions
-  //
-  //            select<a,b>(M b, C a, b) returns (a)
-  //            store<a,b>(M b, C a, b, a) returns (M b)
-  [ContractClass(typeof(MapTypeAbstractionBuilderContracts))]
-  internal abstract class MapTypeAbstractionBuilder {
-
-    protected readonly TypeAxiomBuilder/*!*/ AxBuilder;
-    protected readonly VCExpressionGenerator/*!*/ Gen;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(AxBuilder != null);
-      Contract.Invariant(Gen != null);
-    }
-
-
-    internal MapTypeAbstractionBuilder(TypeAxiomBuilder axBuilder, VCExpressionGenerator gen) {
-      Contract.Requires(gen != null);
-      Contract.Requires(axBuilder != null);
-      this.AxBuilder = axBuilder;
-      this.Gen = gen;
-      AbstractionVariables = new List<TypeVariable/*!*/>();
-      ClassRepresentations = new Dictionary<MapType/*!*/, MapTypeClassRepresentation>();
-    }
-
-    // constructor for cloning
-    internal MapTypeAbstractionBuilder(TypeAxiomBuilder axBuilder, VCExpressionGenerator gen, MapTypeAbstractionBuilder builder) {
-      Contract.Requires(builder != null);
-      Contract.Requires(gen != null);
-      Contract.Requires(axBuilder != null);
-      this.AxBuilder = axBuilder;
-      this.Gen = gen;
-      AbstractionVariables =
-        new List<TypeVariable/*!*/>(builder.AbstractionVariables);
-      ClassRepresentations =
-        new Dictionary<MapType/*!*/, MapTypeClassRepresentation>(builder.ClassRepresentations);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // Type variables used in the abstractions. We use the same variables in the
-    // same order in all abstractions in order to obtain comparable abstractions
-    // (equals, hashcode)
-
-    private readonly List<TypeVariable/*!*/>/*!*/ AbstractionVariables;
-    [ContractInvariantMethod]
-    void AbstractionVariablesInvariantMethod() {
-      Contract.Invariant(cce.NonNullElements(AbstractionVariables));
-    }
-
-    private TypeVariable AbstractionVariable(int num) {
-      Contract.Requires((num >= 0));
-      Contract.Ensures(Contract.Result<TypeVariable>() != null);
-      while (AbstractionVariables.Count <= num)
-        AbstractionVariables.Add(new TypeVariable(Token.NoToken,
-                                                   "aVar" + AbstractionVariables.Count));
-      return AbstractionVariables[num];
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // The untyped representation of a class of map types, i.e., of a map type
-    // <a0, a1, ...>[A0, A1, ...] R, where the argument types and the result type
-    // possibly contain free type variables. For each such class, a separate type
-    // constructor and separate select/store functions are introduced.
-
-    protected struct MapTypeClassRepresentation {
-      public readonly TypeCtorDecl/*!*/ RepresentingType;
-      public readonly Function/*!*/ Select;
-      public readonly Function/*!*/ Store;
-      [ContractInvariantMethod]
-      void ObjectInvariant() {
-        Contract.Invariant(RepresentingType != null);
-        Contract.Invariant(Select != null);
-        Contract.Invariant(Store != null);
-      }
-
-
-      public MapTypeClassRepresentation(TypeCtorDecl representingType, Function select, Function store) {
-        Contract.Requires(store != null);
-        Contract.Requires(select != null);
-        Contract.Requires(representingType != null);
-        this.RepresentingType = representingType;
-        this.Select = select;
-        this.Store = store;
-      }
-    }
-
-    private readonly IDictionary<MapType/*!*/, MapTypeClassRepresentation/*!*/>/*!*/ ClassRepresentations;
-    [ContractInvariantMethod]
-    void ClassRepresentationsInvariantMethod() {
-      Contract.Invariant(ClassRepresentations != null);
-    }
-
-    protected MapTypeClassRepresentation GetClassRepresentation(MapType abstractedType) {
-      Contract.Requires(abstractedType != null);
-      MapTypeClassRepresentation res;
-      if (!ClassRepresentations.TryGetValue(abstractedType, out res)) {
-        int num = ClassRepresentations.Count;
-        TypeCtorDecl/*!*/ synonym =
-          new TypeCtorDecl(Token.NoToken, "MapType" + num, abstractedType.FreeVariables.Count);
-
-        Function/*!*/ select, store;
-        GenSelectStoreFunctions(abstractedType, synonym, out select, out store);
-
-        res = new MapTypeClassRepresentation(synonym, select, store);
-        ClassRepresentations.Add(abstractedType, res);
-      }
-      return res;
-    }
-
-    // the actual select and store functions are generated by the
-    // concrete subclasses of this class
-    protected abstract void GenSelectStoreFunctions(MapType/*!*/ abstractedType, TypeCtorDecl/*!*/ synonymDecl, out Function/*!*/ select, out Function/*!*/ store);
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    public Function Select(MapType rawType, out List<Type> instantiations) {
-      Contract.Requires((rawType != null));
-      Contract.Ensures(Contract.ValueAtReturn(out instantiations) != null);
-      Contract.Ensures(Contract.Result<Function>() != null);
-      return AbstractAndGetRepresentation(rawType, out instantiations).Select;
-    }
-
-    public Function Store(MapType rawType, out List<Type> instantiations) {
-      Contract.Requires((rawType != null));
-      Contract.Ensures(Contract.ValueAtReturn(out instantiations) != null);
-      Contract.Ensures(Contract.Result<Function>() != null);
-      return AbstractAndGetRepresentation(rawType, out instantiations).Store;
-    }
-
-    private MapTypeClassRepresentation
-            AbstractAndGetRepresentation(MapType rawType, out List<Type> instantiations) {
-      Contract.Requires((rawType != null));
-      Contract.Ensures(Contract.ValueAtReturn(out instantiations) != null);
-      instantiations = new List<Type>();
-      MapType/*!*/ abstraction = ThinOutMapType(rawType, instantiations);
-      return GetClassRepresentation(abstraction);
-    }
-
-    public CtorType AbstractMapType(MapType rawType) {
-      Contract.Requires(rawType != null);
-      Contract.Ensures(Contract.Result<CtorType>() != null);
-      List<Type>/*!*/ instantiations = new List<Type>();
-      MapType/*!*/ abstraction = ThinOutMapType(rawType, instantiations);
-
-      MapTypeClassRepresentation repr = GetClassRepresentation(abstraction);
-      Contract.Assume(repr.RepresentingType.Arity == instantiations.Count);
-      return new CtorType(Token.NoToken, repr.RepresentingType, instantiations);
-    }
-
-    // TODO: cache the result of this operation
-    protected MapType ThinOutMapType(MapType rawType, List<Type> instantiations) {
-      Contract.Requires(instantiations != null);
-      Contract.Requires(rawType != null);
-      Contract.Ensures(Contract.Result<MapType>() != null);
-      List<Type>/*!*/ newArguments = new List<Type>();
-      foreach (Type/*!*/ subtype in rawType.Arguments.ToList()) {
-        Contract.Assert(subtype != null);
-        newArguments.Add(ThinOutType(subtype, rawType.TypeParameters,
-                                     instantiations));
-      }
-      Type/*!*/ newResult = ThinOutType(rawType.Result, rawType.TypeParameters,
-                                    instantiations);
-      return new MapType(Token.NoToken, rawType.TypeParameters, newArguments, newResult);
-    }
-
-    // the instantiations of inserted type variables, the order corresponds to the order in which "AbstractionVariable(int)" delivers variables
-    private Type/*!*/ ThinOutType(Type rawType, List<TypeVariable> boundTypeParams, List<Type> instantiations) {
-      Contract.Requires(instantiations != null);
-      Contract.Requires(boundTypeParams != null);
-      Contract.Requires(rawType != null);
-      Contract.Ensures(Contract.Result<Type>() != null);
-
-      if (CommandLineOptions.Clo.Monomorphize && AxBuilder.UnchangedType(rawType))
-        return rawType;
-
-      if (rawType.FreeVariables.All(var => !boundTypeParams.Contains(var))) {
-        // Bingo!
-        // if the type does not contain any bound variables, we can simply
-        // replace it with a type variable
-        TypeVariable/*!*/ abstractionVar = AbstractionVariable(instantiations.Count);
-        Contract.Assume(!boundTypeParams.Contains(abstractionVar));
-        instantiations.Add(rawType);
-        return abstractionVar;
-      }
-
-      if (rawType.IsVariable) {
-        //
-        // then the variable has to be bound, we cannot do anything
-        TypeVariable/*!*/ rawVar = rawType.AsVariable;
-        Contract.Assume(boundTypeParams.Contains(rawVar));
-        return rawVar;
-        //
-      } else if (rawType.IsMap) {
-        //
-        // recursively abstract this map type and continue abstracting
-        CtorType/*!*/ abstraction = AbstractMapType(rawType.AsMap);
-        return ThinOutType(abstraction, boundTypeParams, instantiations);
-        //
-      } else if (rawType.IsCtor) {
-        //
-        // traverse the subtypes
-        CtorType/*!*/ rawCtorType = rawType.AsCtor;
-        List<Type>/*!*/ newArguments = new List<Type>();
-        foreach (Type/*!*/ subtype in rawCtorType.Arguments.ToList()) {
-          Contract.Assert(subtype != null);
-          newArguments.Add(ThinOutType(subtype, boundTypeParams,
-                                       instantiations));
-        }
-        return new CtorType(Token.NoToken, rawCtorType.Decl, newArguments);
-        //
-      } else {
-        System.Diagnostics.Debug.Fail("Don't know how to handle this type: " + rawType);
-        return rawType;   // compiler appeasement policy
-      }
-    }
-
-  }
-  [ContractClassFor(typeof(MapTypeAbstractionBuilder))]
-  internal abstract class MapTypeAbstractionBuilderContracts : MapTypeAbstractionBuilder {
-    public MapTypeAbstractionBuilderContracts()
-      : base(null, null) {
-    }
-    protected override void GenSelectStoreFunctions(MapType abstractedType, TypeCtorDecl synonymDecl, out Function select, out Function store) {
-      Contract.Requires(abstractedType != null);
-      Contract.Requires(synonymDecl != null);
-      Contract.Ensures(Contract.ValueAtReturn(out select) != null);
-      Contract.Ensures(Contract.ValueAtReturn(out store) != null);
-
-      throw new NotImplementedException();
-    }
-  }
-
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  public class VariableBindings {
-    public readonly IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ VCExprVarBindings;
-    public readonly IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/ TypeVariableBindings;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(cce.NonNullDictionaryAndValues(VCExprVarBindings));
-      Contract.Invariant(cce.NonNullDictionaryAndValues(TypeVariableBindings));
-    }
-
-
-    public VariableBindings(IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ vcExprVarBindings,
-                            IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/ typeVariableBindings) {
-      Contract.Requires(cce.NonNullDictionaryAndValues(vcExprVarBindings));
-      Contract.Requires(cce.NonNullDictionaryAndValues(typeVariableBindings));
-      this.VCExprVarBindings = vcExprVarBindings;
-      this.TypeVariableBindings = typeVariableBindings;
-    }
-
-    public VariableBindings() :
-      this(new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/>(),
-            new Dictionary<TypeVariable/*!*/, VCExpr/*!*/>()) {
-    }
-
-    public VariableBindings Clone() {
-      Contract.Ensures(Contract.Result<VariableBindings>() != null);
-      IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ newVCExprVarBindings =
-        new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/>();
-      foreach (KeyValuePair<VCExprVar/*!*/, VCExprVar/*!*/> pair in VCExprVarBindings) {
-        Contract.Assert(cce.NonNullElements(pair));
-        newVCExprVarBindings.Add(pair);
-      }
-      IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/ newTypeVariableBindings =
-        new Dictionary<TypeVariable/*!*/, VCExpr/*!*/>();
-      foreach (KeyValuePair<TypeVariable/*!*/, VCExpr/*!*/> pair in TypeVariableBindings) {
-        Contract.Assert(cce.NonNullElements(pair));
-        newTypeVariableBindings.Add(pair);
-      }
-      return new VariableBindings(newVCExprVarBindings, newTypeVariableBindings);
-    }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  // The central class for turning types VCExprs into untyped
-  // VCExprs. This class makes use of the type axiom builder to manage
-  // the available types and symbols.
-  [ContractClass(typeof(TypeEraserContracts))]
-  public abstract class TypeEraser : MutatingVCExprVisitor<VariableBindings/*!*/> {
-
-    protected readonly TypeAxiomBuilderIntBoolU/*!*/ AxBuilder;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(AxBuilder != null);
-    }
-
-
-    protected abstract OpTypeEraser/*!*/ OpEraser {
-      get;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public TypeEraser(TypeAxiomBuilderIntBoolU axBuilder, VCExpressionGenerator gen)
-      : base(gen) {
-      Contract.Requires(gen != null);
-      Contract.Requires(axBuilder != null);
-      AxBuilder = axBuilder;
-    }
-
-    public VCExpr Erase(VCExpr expr, int polarity) {
-      Contract.Requires(expr != null);
-      Contract.Requires((polarity >= -1 && polarity <= 1));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      this.Polarity = polarity;
-      return Mutate(expr, new VariableBindings());
-    }
-
-    internal int Polarity = 1;  // 1 for positive, -1 for negative, 0 for both
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public override VCExpr Visit(VCExprLiteral node, VariableBindings bindings) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      Contract.Assume(node.Type == Type.Bool || node.Type == Type.Int || node.Type == Type.Real);
-      return node;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public override bool AvoidVisit(VCExprNAry node, VariableBindings arg)
-    {
-        return node.Op.Equals(VCExpressionGenerator.AndOp) ||
-               node.Op.Equals(VCExpressionGenerator.OrOp);
-    }
-
-    public override VCExpr Visit(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExprOp/*!*/ op = node.Op;
-      if (op == VCExpressionGenerator.AndOp || op == VCExpressionGenerator.OrOp)
-        // more efficient on large conjunctions/disjunctions
-        return base.Visit(node, bindings);
-
-      // the visitor that handles all other operators
-      return node.Accept<VCExpr/*!*/, VariableBindings/*!*/>(OpEraser, bindings);
-    }
-
-    // this method is called by MutatingVCExprVisitor.Visit(VCExprNAry, ...)
-    protected override VCExpr/*!*/ UpdateModifiedNode(VCExprNAry/*!*/ originalNode, List<VCExpr/*!*/>/*!*/ newSubExprs, bool changed, VariableBindings/*!*/ bindings) {
-      //Contract.Requires(originalNode != null);
-      //Contract.Requires(cce.NonNullElements(newSubExprs));
-      //Contract.Requires(bindings != null);
-      Contract.Assume(originalNode.Op == VCExpressionGenerator.AndOp ||
-             originalNode.Op == VCExpressionGenerator.OrOp);
-      return Gen.Function(originalNode.Op,
-                          AxBuilder.Cast(newSubExprs[0], Type.Bool),
-                          AxBuilder.Cast(newSubExprs[1], Type.Bool));
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public override VCExpr Visit(VCExprVar node, VariableBindings bindings) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExprVar res;
-      if (!bindings.VCExprVarBindings.TryGetValue(node, out res))
-        return AxBuilder.Typed2Untyped(node);
-      return cce.NonNull(res);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    protected bool IsUniversalQuantifier(VCExprQuantifier node) {
-      Contract.Requires(node != null);
-      return Polarity == 1 && node.Quan == Quantifier.EX ||
-             Polarity == -1 && node.Quan == Quantifier.ALL;
-    }
-
-    protected List<VCExprVar/*!*/>/*!*/ BoundVarsAfterErasure(List<VCExprVar/*!*/>/*!*/ oldBoundVars,
-      // the mapping between old and new variables
-      // is added to this bindings-object
-                                                      VariableBindings/*!*/ bindings) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(cce.NonNullElements(oldBoundVars));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
-
-      List<VCExprVar/*!*/>/*!*/ newBoundVars = new List<VCExprVar/*!*/>(oldBoundVars.Count);
-      foreach (VCExprVar/*!*/ var in oldBoundVars) {
-        Type/*!*/ newType = AxBuilder.TypeAfterErasure(var.Type);
-        VCExprVar/*!*/ newVar = Gen.Variable(var.Name, newType);
-        newBoundVars.Add(newVar);
-        bindings.VCExprVarBindings.Add(var, newVar);
-      }
-      return newBoundVars;
-    }
-
-    // We check whether casts Int2U or Bool2U on the bound variables
-    // occur in triggers. In case a trigger like f(Int2U(x)) occurs,
-    // it may be better to give variable x the type U and remove the
-    // cast. The following method returns true if the quantifier
-    // should be translated again with a different typing
-    protected bool RedoQuantifier(VCExprQuantifier/*!*/ node,
-                                  VCExprQuantifier/*!*/ newNode,
-      // the bound vars that actually occur in the body or
-      // in any of the triggers
-                                  List<VCExprVar/*!*/>/*!*/ occurringVars,
-                                  VariableBindings/*!*/ oldBindings,
-                                  out VariableBindings/*!*/ newBindings,
-                                  out List<VCExprVar/*!*/>/*!*/ newBoundVars) {
-      Contract.Requires(node != null);
-      Contract.Requires(newNode != null);
-      Contract.Requires(cce.NonNullElements(occurringVars));
-      Contract.Requires(oldBindings != null);
-      Contract.Ensures(Contract.ValueAtReturn(out newBindings) != null);
-      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out newBoundVars)));
-      List<VCExprVar/*!*/> castVariables =
-        VariableCastCollector.FindCastVariables(node, newNode, AxBuilder);
-      if (castVariables.Count == 0) {
-        newBindings = oldBindings;         // to make the compiler happy
-        newBoundVars = newNode.BoundVars;  // to make the compiler happy
-        return false;
-      }
-
-      // redo everything with a different typing ...
-
-      newBindings = oldBindings.Clone();
-      newBoundVars = new List<VCExprVar/*!*/>(node.BoundVars.Count);
-      foreach (VCExprVar/*!*/ var in node.BoundVars) {
-        Contract.Assert(var != null);
-        Type/*!*/ newType =
-          castVariables.Contains(var) ? AxBuilder.U
-                                      : AxBuilder.TypeAfterErasure(var.Type);
-        Contract.Assert(newType != null);
-        VCExprVar/*!*/ newVar = Gen.Variable(var.Name, newType);
-        Contract.Assert(newVar != null);
-        newBoundVars.Add(newVar);
-        newBindings.VCExprVarBindings.Add(var, newVar);
-      }
-
-      return true;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public override VCExpr Visit(VCExprLet node, VariableBindings bindings) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VariableBindings/*!*/ newVarBindings = bindings.Clone();
-
-      List<VCExprVar/*!*/>/*!*/ newBoundVars = new List<VCExprVar/*!*/>(node.BoundVars.Count);
-      foreach (VCExprVar/*!*/ var in node.BoundVars) {
-        Type/*!*/ newType = AxBuilder.TypeAfterErasure(var.Type);
-        VCExprVar/*!*/ newVar = Gen.Variable(var.Name, newType);
-        newBoundVars.Add(newVar);
-        newVarBindings.VCExprVarBindings.Add(var, newVar);
-      }
-
-      List<VCExprLetBinding/*!*/>/*!*/ newbindings = new List<VCExprLetBinding/*!*/>(node.Length);
-      for (int i = 0; i < node.Length; ++i) {
-        VCExprLetBinding/*!*/ binding = node[i];
-        Contract.Assert(binding != null);
-        VCExprVar/*!*/ newVar = newBoundVars[i];
-        Type/*!*/ newType = newVar.Type;
-
-        VCExpr/*!*/ newE = AxBuilder.Cast(Mutate(binding.E, newVarBindings), newType);
-        newbindings.Add(Gen.LetBinding(newVar, newE));
-      }
-
-      VCExpr/*!*/ newbody = Mutate(node.Body, newVarBindings);
-      return Gen.Let(newbindings, newbody);
-    }
-  }
-
-  [ContractClassFor(typeof(TypeEraser))]
-  public abstract class TypeEraserContracts : TypeEraser {
-    public TypeEraserContracts()
-      : base(null, null) {
-    }
-    protected override OpTypeEraser OpEraser {
-      get {
-        Contract.Ensures(Contract.Result<OpTypeEraser>() != null);
-        throw new NotImplementedException();
-      }
-    }
-  }
-
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  public abstract class OpTypeEraser : StandardVCExprOpVisitor<VCExpr/*!*/, VariableBindings/*!*/> {
-
-    protected readonly TypeAxiomBuilderIntBoolU/*!*/ AxBuilder;
-
-    protected readonly TypeEraser/*!*/ Eraser;
-    protected readonly VCExpressionGenerator/*!*/ Gen;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(AxBuilder != null);
-      Contract.Invariant(Eraser != null);
-      Contract.Invariant(Gen != null);
-    }
-
-
-    public OpTypeEraser(TypeEraser/*!*/ eraser, TypeAxiomBuilderIntBoolU/*!*/ axBuilder, VCExpressionGenerator/*!*/ gen) {
-      Contract.Requires(eraser != null);
-      Contract.Requires(axBuilder != null);
-      Contract.Requires(gen != null);
-      this.AxBuilder = axBuilder;
-      this.Eraser = eraser;
-      this.Gen = gen;
-    }
-
-    protected override VCExpr StandardResult(VCExprNAry node, VariableBindings bindings) {
-      //Contract.Requires(bindings != null);
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      System.Diagnostics.Debug.Fail("Don't know how to erase types in this expression: " + node);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();  // to please the compiler
-    }
-
-    private List<VCExpr/*!*/>/*!*/ MutateSeq(VCExprNAry node, VariableBindings bindings, int newPolarity) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
-      int oldPolarity = Eraser.Polarity;
-      Eraser.Polarity = newPolarity;
-      List<VCExpr/*!*/>/*!*/ newArgs = Eraser.MutateSeq(node, bindings);
-      Eraser.Polarity = oldPolarity;
-      return newArgs;
-    }
-
-    private VCExpr CastArguments(VCExprNAry node, Type argType, VariableBindings bindings, int newPolarity) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(argType != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Gen.Function(node.Op,
-                          AxBuilder.CastSeq(MutateSeq(node, bindings, newPolarity),
-                          argType));
-    }
-
-    // Cast the arguments of the node to their old type if necessary and possible; otherwise use
-    // their new type (int, real, bool, or U)
-    private VCExpr CastArgumentsToOldType(VCExprNAry node, VariableBindings bindings, int newPolarity) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(node != null);
-      Contract.Requires((node.Arity > 0));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      List<VCExpr/*!*/>/*!*/ newArgs = MutateSeq(node, bindings, newPolarity);
-      Type/*!*/ oldType = node[0].Type;
-      if (AxBuilder.UnchangedType(oldType) &&
-          node.Skip(1).All(e => e.Type.Equals(oldType)))
-        return Gen.Function(node.Op, AxBuilder.CastSeq(newArgs, oldType));
-      else
-        return Gen.Function(node.Op, AxBuilder.CastSeq(newArgs, AxBuilder.U));
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    public override VCExpr VisitNotOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArguments(node, Type.Bool, bindings, -Eraser.Polarity);
-    }
-    public override VCExpr VisitEqOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitNeqOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitImpliesOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      // UGLY: the code for tracking polarities should be factored out
-      List<VCExpr/*!*/>/*!*/ newArgs = new List<VCExpr/*!*/>(2);
-      Eraser.Polarity = -Eraser.Polarity;
-      newArgs.Add(Eraser.Mutate(node[0], bindings));
-      Eraser.Polarity = -Eraser.Polarity;
-      newArgs.Add(Eraser.Mutate(node[1], bindings));
-      return Gen.Function(node.Op, AxBuilder.CastSeq(newArgs, Type.Bool));
-    }
-    public override VCExpr VisitDistinctOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitLabelOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      // argument of the label operator should always be a formula
-      // (at least for Simplify ... should this be ensured at a later point?)
-      return CastArguments(node, Type.Bool, bindings, Eraser.Polarity);
-    }
-    public override VCExpr VisitIfThenElseOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<VCExpr/*!*/>/*!*/ newArgs = MutateSeq(node, bindings, 0);
-      newArgs[0] = AxBuilder.Cast(newArgs[0], Type.Bool);
-      Type t = node.Type;
-      if (!AxBuilder.UnchangedType(t)) {
-        t = AxBuilder.U;
-      }
-      newArgs[1] = AxBuilder.Cast(newArgs[1], t);
-      newArgs[2] = AxBuilder.Cast(newArgs[2], t);
-      return Gen.Function(node.Op, newArgs);
-    }
-    public override VCExpr/*!*/ VisitCustomOp(VCExprNAry/*!*/ node, VariableBindings/*!*/ bindings) {
-      Contract.Requires(node != null);
-      Contract.Requires(bindings != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      List<VCExpr/*!*/>/*!*/ newArgs = MutateSeq(node, bindings, 0);
-      return Gen.Function(node.Op, newArgs);
-    }
-    public override VCExpr VisitAddOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArguments(node, node.Type, bindings, 0);
-    }
-    public override VCExpr VisitSubOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArguments(node, node.Type, bindings, 0);
-    }
-    public override VCExpr VisitMulOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArguments(node, node.Type, bindings, 0);
-    }
-    public override VCExpr VisitDivOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArguments(node, Type.Int, bindings, 0);
-    }
-    public override VCExpr VisitModOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArguments(node, Type.Int, bindings, 0);
-    }
-    public override VCExpr VisitRealDivOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArguments(node, Type.Real, bindings, 0);
-    }
-    /*public override VCExpr VisitFloatDivOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArguments(node, Type.Float, bindings, 0);
-    }*/
-    public override VCExpr VisitPowOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArguments(node, Type.Real, bindings, 0);
-    }
-    public override VCExpr VisitLtOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitLeOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitGtOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitGeOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitSubtypeOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArguments(node, AxBuilder.U, bindings, 0);
-    }
-    public override VCExpr VisitToIntOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitToRealOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatAddOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatSubOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatMulOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatDivOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatRemOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatMinOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatMaxOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatLeqOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatLtOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatGeqOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatGtOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitFloatEqOp(VCExprNAry node, VariableBindings bindings)
-    {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitBvOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitBvExtractOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return CastArgumentsToOldType(node, bindings, 0);
-    }
-    public override VCExpr VisitBvConcatOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-      Contract.Requires((node != null));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<VCExpr/*!*/>/*!*/ newArgs = MutateSeq(node, bindings, 0);
-
-      // each argument is cast to its old type
-      Contract.Assert(newArgs.Count == node.Arity && newArgs.Count == 2);
-      VCExpr/*!*/ arg0 = AxBuilder.Cast(newArgs[0], node[0].Type);
-      Contract.Assert(arg0 != null);
-      VCExpr/*!*/ arg1 = AxBuilder.Cast(newArgs[1], node[1].Type);
-      Contract.Assert(arg1 != null);
-      return Gen.Function(node.Op, arg0, arg1);
-    }
-
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  /// <summary>
-  /// Collect all variables x occurring in expressions of the form Int2U(x) or Bool2U(x), and
-  /// collect all variables x occurring outside such forms.
-  /// </summary>
-  internal class VariableCastCollector : TraversingVCExprVisitor<bool, bool> {
-    /// <summary>
-    /// Determine those bound variables in "oldNode" <em>all</em> of whose relevant uses
-    /// have to be cast in potential triggers in "newNode".  It is assume that
-    /// the bound variables of "oldNode" correspond to the first bound
-    /// variables of "newNode".
-    /// </summary>
-    public static List<VCExprVar/*!*/>/*!*/ FindCastVariables(VCExprQuantifier oldNode, VCExprQuantifier newNode, TypeAxiomBuilderIntBoolU axBuilder) {
-      Contract.Requires((axBuilder != null));
-      Contract.Requires((newNode != null));
-      Contract.Requires((oldNode != null));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
-      VariableCastCollector/*!*/ collector = new VariableCastCollector(axBuilder);
-      Contract.Assert(collector != null);
-      if (newNode.Triggers.Any(trigger => trigger.Pos)) {
-        // look in the given triggers
-        foreach (VCTrigger/*!*/ trigger in newNode.Triggers) {
-          Contract.Assert(trigger != null);
-          if (trigger.Pos) {
-            foreach (VCExpr/*!*/ expr in trigger.Exprs) {
-              Contract.Assert(expr != null);
-              collector.Traverse(expr, true);
-            }
-          }
-        }
-      } else {
-        // look in the body of the quantifier
-        collector.Traverse(newNode.Body, true);
-      }
-
-      List<VCExprVar/*!*/>/*!*/ castVariables = new List<VCExprVar/*!*/>(collector.varsInCasts.Count);
-      foreach (VCExprVar/*!*/ castVar in collector.varsInCasts) {
-        Contract.Assert(castVar != null);
-        int i = newNode.BoundVars.IndexOf(castVar);
-        if (0 <= i && i < oldNode.BoundVars.Count && !collector.varsOutsideCasts.ContainsKey(castVar))
-          castVariables.Add(oldNode.BoundVars[i]);
-      }
-      return castVariables;
-    }
-
-    public VariableCastCollector(TypeAxiomBuilderIntBoolU axBuilder) {
-      Contract.Requires(axBuilder != null);
-      this.AxBuilder = axBuilder;
-    }
-
-    readonly List<VCExprVar/*!*/>/*!*/ varsInCasts = new List<VCExprVar/*!*/>();
-    readonly Dictionary<VCExprVar/*!*/, object>/*!*/ varsOutsideCasts = new Dictionary<VCExprVar/*!*/, object>();
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(cce.NonNullElements(varsInCasts));
-      Contract.Invariant(varsOutsideCasts != null && Contract.ForAll(varsOutsideCasts, voc => voc.Key != null));
-      Contract.Invariant(AxBuilder != null);
-
-    }
-
-
-    readonly TypeAxiomBuilderIntBoolU/*!*/ AxBuilder;
-
-    protected override bool StandardResult(VCExpr node, bool arg) {
-      //Contract.Requires(node != null);
-      return true; // not used
-    }
-
-    public override bool Visit(VCExprNAry node, bool arg) {
-      Contract.Requires(node != null);
-      if (node.Op is VCExprBoogieFunctionOp) {
-        Function func = ((VCExprBoogieFunctionOp)node.Op).Func;
-        Contract.Assert(func != null);
-        if ((AxBuilder.IsCast(func)) && node[0] is VCExprVar) {
-          VCExprVar castVar = (VCExprVar)node[0];
-          if (!varsInCasts.Contains(castVar))
-            varsInCasts.Add(castVar);
-          return true;
-        }
-      } else if (node.Op is VCExprNAryOp) {
-        VCExpressionGenerator.SingletonOp op = VCExpressionGenerator.SingletonOpDict[node.Op];
-        switch (op) {
-          // the following operators cannot be used in triggers, so disregard any uses of variables as direct arguments
-          case VCExpressionGenerator.SingletonOp.NotOp:
-          case VCExpressionGenerator.SingletonOp.EqOp:
-          case VCExpressionGenerator.SingletonOp.NeqOp:
-          case VCExpressionGenerator.SingletonOp.AndOp:
-          case VCExpressionGenerator.SingletonOp.OrOp:
-          case VCExpressionGenerator.SingletonOp.ImpliesOp:
-          case VCExpressionGenerator.SingletonOp.LtOp:
-          case VCExpressionGenerator.SingletonOp.LeOp:
-          case VCExpressionGenerator.SingletonOp.GtOp:
-          case VCExpressionGenerator.SingletonOp.GeOp:
-            foreach (VCExpr n in node) {
-              if (!(n is VCExprVar)) {  // don't recurse on VCExprVar argument
-                n.Accept<bool, bool>(this, arg);
-              }
-            }
-            return true;
-          default:
-            break;
-        }
-      }
-      return base.Visit(node, arg);
-    }
-
-    public override bool Visit(VCExprVar node, bool arg) {
-      Contract.Requires(node != null);
-      if (!varsOutsideCasts.ContainsKey(node))
-        varsOutsideCasts.Add(node, null);
-      return true;
-    }
-  }
-
-}
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+using Microsoft.Boogie.VCExprAST;
+
+// different classes for erasing complex types in VCExprs, replacing them
+// with axioms that can be handled by theorem provers and SMT solvers
+
+namespace Microsoft.Boogie.TypeErasure {
+  using Microsoft.Boogie.VCExprAST;
+
+  // some functionality that is needed in many places (and that should
+  // really be provided by the Spec# container classes; maybe one
+  // could integrate the functions in a nicer way?)
+  public class HelperFuns {
+
+    public static Function BoogieFunction(string name, List<TypeVariable/*!*/>/*!*/ typeParams, params Type[] types) {
+      Contract.Requires(types != null);
+      Contract.Requires(name != null);
+      Contract.Requires(cce.NonNullElements(typeParams));
+      Contract.Requires(types.Length > 0);
+      Contract.Requires(Contract.ForAll(0, types.Length, i => types[i] != null));
+      Contract.Ensures(Contract.Result<Function>() != null);
+
+      List<Variable> args = new List<Variable>();
+      for (int i = 0; i < types.Length - 1; ++i)
+        args.Add(new Formal(Token.NoToken,
+                             new TypedIdent(Token.NoToken, "arg" + i, cce.NonNull(types[i])),
+                             true));
+      Formal result = new Formal(Token.NoToken,
+                                   new TypedIdent(Token.NoToken, "res",
+                                                   cce.NonNull(types)[types.Length - 1]),
+                                   false);
+      return new Function(Token.NoToken, name, new List<TypeVariable>(typeParams), args, result);
+    }
+
+    public static Function BoogieFunction(string name, params Type[] types) {
+      Contract.Requires(types != null);
+      Contract.Requires(name != null);
+      Contract.Ensures(Contract.Result<Function>() != null);
+      return BoogieFunction(name, new List<TypeVariable/*!*/>(), types);
+    }
+
+    // boogie function where all arguments and the result have the same type U
+    public static Function UniformBoogieFunction(string name, int arity, Type U) {
+      Contract.Requires(U != null);
+      Contract.Requires(name != null);
+      Contract.Ensures(Contract.Result<Function>() != null);
+      Type[]/*!*/ types = new Type[arity + 1];
+      for (int i = 0; i < arity + 1; ++i)
+        types[i] = U;
+      return BoogieFunction(name, types);
+    }
+
+    public static List<VCExprVar/*!*/>/*!*/ GenVarsForInParams(Function fun, VCExpressionGenerator gen) {
+      Contract.Requires(gen != null);
+      Contract.Requires(fun != null);
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
+      List<VCExprVar/*!*/>/*!*/ arguments = new List<VCExprVar/*!*/>(fun.InParams.Count);
+      foreach (Formal/*!*/ f in fun.InParams) {
+        Contract.Assert(f != null);
+        VCExprVar/*!*/ var = gen.Variable(f.Name, f.TypedIdent.Type);
+        arguments.Add(var);
+      }
+      return arguments;
+    }
+
+    public static List<T/*!*/>/*!*/ ToList<T>(params T[] args) where T : class{
+      Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<T>>()));
+      return new List<T>(args);
+    }
+
+    public static List<VCExpr/*!*/>/*!*/ ToVCExprList(List<VCExprVar/*!*/>/*!*/ list) {
+      Contract.Requires(cce.NonNullElements(list));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
+      return new List<VCExpr>(list);
+    }
+
+    public static List<VCExprVar/*!*/>/*!*/ VarVector(string baseName, int num, Type type, VCExpressionGenerator gen) {
+      Contract.Requires(gen != null);
+      Contract.Requires(type != null);
+      Contract.Requires(baseName != null);
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
+      List<VCExprVar/*!*/>/*!*/ res = new List<VCExprVar/*!*/>(num);
+      for (int i = 0; i < num; ++i)
+        res.Add(gen.Variable(baseName + i, type));
+      return res;
+    }
+
+    public static List<VCExprVar/*!*/>/*!*/ VarVector(string baseName, List<Type/*!*/>/*!*/ types, VCExpressionGenerator gen) {
+      Contract.Requires(gen != null);
+      Contract.Requires(baseName != null);
+      Contract.Requires(cce.NonNullElements(types));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
+      List<VCExprVar/*!*/>/*!*/ res = new List<VCExprVar/*!*/>(types.Count);
+      for (int i = 0; i < types.Count; ++i)
+        res.Add(gen.Variable(baseName + i, types[i]));
+      return res;
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  internal struct TypeCtorRepr {
+    // function that represents the application of the type constructor
+    // to smaller types
+    public readonly Function/*!*/ Ctor;
+    // left-inverse functions that extract the subtypes of a compound type
+    public readonly List<Function/*!*/>/*!*/ Dtors;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Ctor != null);
+      Contract.Invariant(cce.NonNullElements(Dtors));
+    }
+
+
+    public TypeCtorRepr(Function ctor, List<Function/*!*/>/*!*/ dtors) {
+      Contract.Requires(ctor != null);
+      Contract.Requires(cce.NonNullElements(dtors));
+      Contract.Requires(ctor.InParams.Count == dtors.Count);
+      this.Ctor = ctor;
+      this.Dtors = dtors;
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  // The class responsible for creating and keeping track of all
+  // axioms related to the type system. This abstract class is made
+  // concrete in two subclasses, one for type erasure with type
+  // premisses in quantifiers (the semantic approach), and one for
+  // type erasure with explicit type arguments of polymorphic
+  // functions (the syntacted approach).
+  [ContractClass(typeof(TypeAxiomBuilderContracts))]
+  public abstract class TypeAxiomBuilder : ICloneable {
+
+    protected readonly VCExpressionGenerator/*!*/ Gen;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Gen != null);
+      Contract.Invariant(Ctor != null);
+
+    }
+
+
+    internal abstract MapTypeAbstractionBuilder/*!*/ MapTypeAbstracter {
+      get;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Type Axioms
+
+    // list in which all typed axioms are collected
+    private readonly List<VCExpr/*!*/>/*!*/ AllTypeAxioms;
+    [ContractInvariantMethod]
+    void AllTypeAxiomsInvariantMethod() {
+      Contract.Invariant(cce.NonNullElements(AllTypeAxioms));
+    }
+
+    // list in which type axioms are incrementally collected
+    private readonly List<VCExpr/*!*/>/*!*/ IncTypeAxioms;
+    [ContractInvariantMethod]
+    void IncTypeAxiomsInvariantMethod() {
+      Contract.Invariant(cce.NonNullElements(IncTypeAxioms));
+    }
+
+    internal void AddTypeAxiom(VCExpr axiom) {
+      Contract.Requires(axiom != null);
+      AllTypeAxioms.Add(axiom);
+      IncTypeAxioms.Add(axiom);
+    }
+
+    // Return all axioms that were added since the last time NewAxioms
+    // was called
+    public VCExpr GetNewAxioms() {
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExpr/*!*/ res = Gen.NAry(VCExpressionGenerator.AndOp, IncTypeAxioms);
+      IncTypeAxioms.Clear();
+      return res;
+    }
+
+    // mapping from a type to its constructor number/index
+    private readonly Function/*!*/ Ctor;
+    private BigNum CurrentCtorNum;
+
+    private VCExpr GenCtorAssignment(VCExpr typeRepr) {
+      Contract.Requires(typeRepr != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (CommandLineOptions.Clo.TypeEncodingMethod
+                == CommandLineOptions.TypeEncoding.None)
+        return VCExpressionGenerator.True;
+
+      VCExpr res = Gen.Eq(Gen.Function(Ctor, typeRepr),
+                           Gen.Integer(CurrentCtorNum));
+      CurrentCtorNum = CurrentCtorNum + BigNum.ONE;
+      return res;
+    }
+
+    private VCExpr GenCtorAssignment(Function typeRepr) {
+      Contract.Requires(typeRepr != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (CommandLineOptions.Clo.TypeEncodingMethod
+                == CommandLineOptions.TypeEncoding.None)
+        return VCExpressionGenerator.True;
+
+      List<VCExprVar/*!*/>/*!*/ quantifiedVars = HelperFuns.GenVarsForInParams(typeRepr, Gen);
+      VCExpr/*!*/ eq =
+        GenCtorAssignment(Gen.Function(typeRepr,
+                                       HelperFuns.ToVCExprList(quantifiedVars)));
+
+      if (typeRepr.InParams.Count == 0)
+        return eq;
+
+      return Gen.Forall(quantifiedVars, new List<VCTrigger/*!*/>(),
+                        "ctor:" + typeRepr.Name, -1, eq);
+    }
+
+    // generate an axiom (forall x0, x1, ... :: invFun(fun(x0, x1, ...) == xi)
+    protected VCExpr GenLeftInverseAxiom(Function fun, Function invFun, int dtorNum) {
+      Contract.Requires(invFun != null);
+      Contract.Requires(fun != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<VCExprVar/*!*/>/*!*/ quantifiedVars = HelperFuns.GenVarsForInParams(fun, Gen);
+      Contract.Assert(cce.NonNullElements(quantifiedVars));
+
+      VCExpr/*!*/ funApp = Gen.Function(fun, HelperFuns.ToVCExprList(quantifiedVars));
+      VCExpr/*!*/ lhs = Gen.Function(invFun, funApp);
+      VCExpr/*!*/ rhs = quantifiedVars[dtorNum];
+      VCExpr/*!*/ eq = Gen.Eq(lhs, rhs);
+
+      List<VCTrigger/*!*/>/*!*/ triggers = HelperFuns.ToList(Gen.Trigger(true, HelperFuns.ToList(funApp)));
+      Contract.Assert(cce.NonNullElements(triggers));
+      return Gen.Forall(quantifiedVars, triggers, "typeInv:" + invFun.Name, -1, eq);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // the type of everything that is not int, bool, or a type
+    [ContractInvariantMethod]
+    void ObjectInvariant2() {
+      Contract.Invariant(UDecl != null);
+      Contract.Invariant(TDecl != null);
+      Contract.Invariant(U != null);
+      Contract.Invariant(T != null);
+    }
+
+    private readonly TypeCtorDecl/*!*/ UDecl;
+    public readonly Type/*!*/ U;
+
+    // the type of types
+    private readonly TypeCtorDecl/*!*/ TDecl;
+    public readonly Type/*!*/ T;
+
+    public abstract Type/*!*/ TypeAfterErasure(Type/*!*/ type);
+    [Pure]
+    public abstract bool UnchangedType(Type/*!*/ type);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Symbols for representing types
+
+    private readonly IDictionary<Type/*!*/, VCExpr/*!*/>/*!*/ BasicTypeReprs;
+    [ContractInvariantMethod]
+    void BasicTypeReprsInvariantMethod() {
+      Contract.Invariant(cce.NonNullDictionaryAndValues(BasicTypeReprs));
+    }
+
+    private VCExpr GetBasicTypeRepr(Type type) {
+      Contract.Requires(type != null);
+      Contract.Requires(type.IsBasic || type.IsBv);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExpr res;
+      if (!BasicTypeReprs.TryGetValue(type, out res)) {
+        res = Gen.Function(HelperFuns.BoogieFunction(type.ToString() + "Type", T));
+        AddTypeAxiom(GenCtorAssignment(res));
+        BasicTypeReprs.Add(type, res);
+      }
+      return cce.NonNull(res);
+    }
+
+    private readonly IDictionary<TypeCtorDecl/*!*/, TypeCtorRepr/*!*/>/*!*/ TypeCtorReprs;
+    [ContractInvariantMethod]
+    void TypeCtorReprsInvariantMethod() {
+      Contract.Invariant(TypeCtorReprs != null);
+    }
+
+    internal TypeCtorRepr GetTypeCtorReprStruct(TypeCtorDecl decl) {
+      Contract.Requires(decl != null);
+      TypeCtorRepr reprSet;
+      if (!TypeCtorReprs.TryGetValue(decl, out reprSet)) {
+        Function/*!*/ ctor = HelperFuns.UniformBoogieFunction(decl.Name + "Type", decl.Arity, T);
+        Contract.Assert(ctor != null);
+        AddTypeAxiom(GenCtorAssignment(ctor));
+
+        List<Function/*!*/>/*!*/ dtors = new List<Function/*!*/>(decl.Arity);
+        for (int i = 0; i < decl.Arity; ++i) {
+          Function/*!*/ dtor = HelperFuns.UniformBoogieFunction(decl.Name + "TypeInv" + i, 1, T);
+          dtors.Add(dtor);
+          AddTypeAxiom(GenLeftInverseAxiom(ctor, dtor, i));
+        }
+
+        reprSet = new TypeCtorRepr(ctor, dtors);
+        TypeCtorReprs.Add(decl, reprSet);
+      }
+
+      return reprSet;
+    }
+
+    public Function GetTypeCtorRepr(TypeCtorDecl decl) {
+      Contract.Requires(decl != null);
+      Contract.Ensures(Contract.Result<Function>() != null);
+      return GetTypeCtorReprStruct(decl).Ctor;
+    }
+
+    public Function GetTypeDtor(TypeCtorDecl decl, int num) {
+      Contract.Requires(decl != null);
+      Contract.Ensures(Contract.Result<Function>() != null);
+      return GetTypeCtorReprStruct(decl).Dtors[num];
+    }
+
+    // mapping from free type variables to VCExpr variables
+    private readonly IDictionary<TypeVariable/*!*/, VCExprVar/*!*/>/*!*/ TypeVariableMapping;
+    [ContractInvariantMethod]
+    void TypeVariableMappingInvariantMethod() {
+      Contract.Invariant(cce.NonNullDictionaryAndValues(TypeVariableMapping));
+    }
+
+    public VCExprVar Typed2Untyped(TypeVariable var) {
+      Contract.Requires(var != null);
+      Contract.Ensures(Contract.Result<VCExprVar>() != null);
+      VCExprVar res;
+      if (!TypeVariableMapping.TryGetValue(var, out res)) {
+        res = new VCExprVar(var.Name, T);
+        TypeVariableMapping.Add(var, res);
+      }
+      return cce.NonNull(res);
+    }
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Symbols for representing variables and constants
+
+    // Globally defined variables
+    private readonly IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ Typed2UntypedVariables;
+    [ContractInvariantMethod]
+    void Typed2UntypedVariablesInvariantMethod() {
+      Contract.Invariant(cce.NonNullDictionaryAndValues(Typed2UntypedVariables));
+    }
+
+    // This method must only be used for free (unbound) variables
+    public VCExprVar Typed2Untyped(VCExprVar var) {
+      Contract.Requires(var != null);
+      Contract.Ensures(Contract.Result<VCExprVar>() != null);
+      VCExprVar res = TryTyped2Untyped(var);
+      if (res == null) {
+        res = Gen.Variable(var.Name, TypeAfterErasure(var.Type));
+        Typed2UntypedVariables.Add(var, res);
+        AddVarTypeAxiom(res, var.Type);
+      }
+      return cce.NonNull(res);
+    }
+
+    /// <summary>
+    ///  This method is like Typed2Untyped, except in the case where the given variables
+    ///  doesn't exist in the mapping.  For that case, this method returns null whereas
+    ///  Typed2Untyped creates a new variable that it adds to the mapping.
+    /// </summary>
+    /// <param name="var"></param>
+    /// <returns></returns>
+    public VCExprVar TryTyped2Untyped(VCExprVar var) {
+      Contract.Requires(var != null);
+      VCExprVar res;
+      if (Typed2UntypedVariables.TryGetValue(var, out res)) {
+        return res;
+      } else {
+        return null;
+      }
+    }
+
+    protected abstract void AddVarTypeAxiom(VCExprVar/*!*/ var, Type/*!*/ originalType);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Translation function from types to their term representation
+
+    public VCExpr Type2Term(Type type, IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/ varMapping) {
+      Contract.Requires(type != null);
+      Contract.Requires(cce.NonNullDictionaryAndValues(varMapping));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      //
+      if (type.IsBasic || type.IsBv) {
+        //
+        return GetBasicTypeRepr(type);
+        //
+      } else if (type.IsCtor) {
+        //
+        CtorType ctype = type.AsCtor;
+        Function/*!*/ repr = GetTypeCtorRepr(ctype.Decl);
+        List<VCExpr/*!*/>/*!*/ args = new List<VCExpr/*!*/>(ctype.Arguments.Count);
+        foreach (Type/*!*/ t in ctype.Arguments.ToArray()) {
+          Contract.Assert(t != null);
+          args.Add(Type2Term(t, varMapping));
+        }
+        return Gen.Function(repr, args);
+        //
+      } else if (type.IsVariable) {
+        //
+        VCExpr res;
+        if (!varMapping.TryGetValue(type.AsVariable, out res))
+          // then the variable is free and we bind it at this point to a term
+          // variable
+          res = Typed2Untyped(type.AsVariable);
+        return cce.NonNull(res);
+        //
+      } else if (type.IsMap) {
+        //
+        return Type2Term(MapTypeAbstracter.AbstractMapType(type.AsMap), varMapping);
+        //
+      } else {
+        System.Diagnostics.Debug.Fail("Don't know how to handle this type: " + type);
+        Contract.Assert(false);
+        throw new cce.UnreachableException();  // please the compiler
+      }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public TypeAxiomBuilder(VCExpressionGenerator gen) {
+      Contract.Requires(gen != null);
+      this.Gen = gen;
+      AllTypeAxioms = new List<VCExpr/*!*/>();
+      IncTypeAxioms = new List<VCExpr/*!*/>();
+      BasicTypeReprs = new Dictionary<Type/*!*/, VCExpr/*!*/>();
+      CurrentCtorNum = BigNum.ZERO;
+      TypeCtorReprs = new Dictionary<TypeCtorDecl/*!*/, TypeCtorRepr>();
+      TypeVariableMapping = new Dictionary<TypeVariable/*!*/, VCExprVar/*!*/>();
+      Typed2UntypedVariables = new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/>();
+
+      TypeCtorDecl/*!*/ uDecl = new TypeCtorDecl(Token.NoToken, "U", 0);
+      UDecl = uDecl;
+      Type/*!*/ u = new CtorType(Token.NoToken, uDecl, new List<Type>());
+      U = u;
+
+      TypeCtorDecl/*!*/ tDecl = new TypeCtorDecl(Token.NoToken, "T", 0);
+      TDecl = tDecl;
+      Type/*!*/ t = new CtorType(Token.NoToken, tDecl, new List<Type>());
+      T = t;
+
+      Ctor = HelperFuns.BoogieFunction("Ctor", t, Type.Int);
+    }
+
+    public virtual void Setup() {
+      GetBasicTypeRepr(Type.Int);
+      GetBasicTypeRepr(Type.Real);
+      GetBasicTypeRepr(Type.Bool);
+    }
+
+    // constructor to allow cloning
+    internal TypeAxiomBuilder(TypeAxiomBuilder builder) {
+      Contract.Requires(builder != null);
+      Gen = builder.Gen;
+      AllTypeAxioms = new List<VCExpr/*!*/>(builder.AllTypeAxioms);
+      IncTypeAxioms = new List<VCExpr/*!*/>(builder.IncTypeAxioms);
+
+      UDecl = builder.UDecl;
+      U = builder.U;
+
+      TDecl = builder.TDecl;
+      T = builder.T;
+
+      Ctor = builder.Ctor;
+      CurrentCtorNum = builder.CurrentCtorNum;
+
+      BasicTypeReprs = new Dictionary<Type/*!*/, VCExpr/*!*/>(builder.BasicTypeReprs);
+      TypeCtorReprs = new Dictionary<TypeCtorDecl/*!*/, TypeCtorRepr>(builder.TypeCtorReprs);
+
+      TypeVariableMapping =
+        new Dictionary<TypeVariable/*!*/, VCExprVar/*!*/>(builder.TypeVariableMapping);
+      Typed2UntypedVariables =
+        new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/>(builder.Typed2UntypedVariables);
+    }
+
+    public abstract Object/*!*/ Clone();
+  }
+
+  [ContractClassFor(typeof(TypeAxiomBuilder))]
+  public abstract class TypeAxiomBuilderContracts : TypeAxiomBuilder {
+    public TypeAxiomBuilderContracts()
+      : base((VCExpressionGenerator)null) {
+    }
+    internal override MapTypeAbstractionBuilder MapTypeAbstracter {
+      get {
+        Contract.Ensures(Contract.Result<MapTypeAbstractionBuilder>() != null);
+        throw new NotImplementedException();
+      }
+    }
+
+    public override Type TypeAfterErasure(Type type) {
+      Contract.Requires(type != null);
+      Contract.Ensures(Contract.Result<Type>() != null);
+
+      throw new NotImplementedException();
+    }
+
+    public override bool UnchangedType(Type type) {
+      Contract.Requires(type != null);
+      throw new NotImplementedException();
+    }
+
+    protected override void AddVarTypeAxiom(VCExprVar var, Type originalType) {
+      Contract.Requires(var != null);
+      Contract.Requires(originalType != null);
+      throw new NotImplementedException();
+    }
+
+    public override object Clone() {
+      Contract.Ensures(Contract.Result<object>() != null);
+
+      throw new NotImplementedException();
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  // Subclass of the TypeAxiomBuilder that provides all functionality
+  // to deal with native sorts of a theorem prover (that are the only
+  // types left after erasing all other types). Currently, these are:
+  //
+  //  U ... sort of all individuals/objects/values
+  //  T ... sort of all types
+  //  int ... integers
+  //  bool ... booleans
+
+  [ContractClass(typeof(TypeAxiomBuilderIntBoolUContracts))]
+  public abstract class TypeAxiomBuilderIntBoolU : TypeAxiomBuilder {
+
+    public TypeAxiomBuilderIntBoolU(VCExpressionGenerator gen)
+      : base(gen) {
+      Contract.Requires(gen != null);
+
+      TypeCasts = new Dictionary<Type/*!*/, TypeCastSet>();
+    }
+
+    // constructor to allow cloning
+    internal TypeAxiomBuilderIntBoolU(TypeAxiomBuilderIntBoolU builder)
+      : base(builder) {
+      Contract.Requires(builder != null);
+
+      TypeCasts = new Dictionary<Type/*!*/, TypeCastSet>(builder.TypeCasts);
+    }
+
+    public override void Setup() {
+      base.Setup();
+
+      GetTypeCasts(Type.Int);
+      GetTypeCasts(Type.Real);
+      GetTypeCasts(Type.Bool);
+    }
+
+    // generate inverse axioms for casts (castToU(castFromU(x)) = x, under certain premisses)
+    protected abstract VCExpr/*!*/ GenReverseCastAxiom(Function/*!*/ castToU, Function/*!*/ castFromU);
+
+    protected VCExpr GenReverseCastEq(Function castToU, Function castFromU, out VCExprVar var, out List<VCTrigger/*!*/>/*!*/ triggers) {
+      Contract.Requires((castFromU != null));
+      Contract.Requires((castToU != null));
+      Contract.Ensures((cce.NonNullElements(Contract.ValueAtReturn(out triggers))));
+      Contract.Ensures(Contract.ValueAtReturn(out var) != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      var = Gen.Variable("x", U);
+
+      VCExpr inner = Gen.Function(castFromU, var);
+      VCExpr lhs = Gen.Function(castToU, inner);
+      triggers = HelperFuns.ToList(Gen.Trigger(true, HelperFuns.ToList(inner)));
+
+      return Gen.Eq(lhs, var);
+    }
+
+    protected abstract VCExpr/*!*/ GenCastTypeAxioms(Function/*!*/ castToU, Function/*!*/ castFromU);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // storage of type casts for types that are supposed to be left over in the
+    // VCs (like int, bool, bitvectors)
+
+    private readonly IDictionary<Type/*!*/, TypeCastSet/*!*/>/*!*/ TypeCasts;
+    [ContractInvariantMethod]
+    void TypeCastsInvariantMethod() {
+      Contract.Invariant(TypeCasts != null);
+    }
+
+    private TypeCastSet GetTypeCasts(Type type) {
+      Contract.Requires(type != null);
+      TypeCastSet res;
+      if (!TypeCasts.TryGetValue(type, out res)) {
+        Function/*!*/ castToU = HelperFuns.BoogieFunction(type.ToString() + "_2_U", type, U);
+        Function/*!*/ castFromU = HelperFuns.BoogieFunction("U_2_" + type.ToString(), U, type);
+
+        AddTypeAxiom(GenLeftInverseAxiom(castToU, castFromU, 0));
+        AddTypeAxiom(GenReverseCastAxiom(castToU, castFromU));
+        AddTypeAxiom(GenCastTypeAxioms(castToU, castFromU));
+
+        res = new TypeCastSet(castToU, castFromU);
+        TypeCasts.Add(type, res);
+      }
+      return res;
+    }
+    [Pure]
+    public Function CastTo(Type type) {
+      Contract.Requires(type != null);
+      Contract.Requires(UnchangedType(type));
+      Contract.Ensures(Contract.Result<Function>() != null);
+      return GetTypeCasts(type).CastFromU;
+    }
+
+    public Function CastFrom(Type type) {
+      Contract.Requires(type != null);
+      Contract.Requires((UnchangedType(type)));
+      Contract.Ensures(Contract.Result<Function>() != null);
+      return GetTypeCasts(type).CastToU;
+    }
+
+    private struct TypeCastSet {
+      public readonly Function/*!*/ CastToU;
+      public readonly Function/*!*/ CastFromU;
+      [ContractInvariantMethod]
+      void ObjectInvariant() {
+        Contract.Invariant(CastToU != null);
+        Contract.Invariant(CastFromU != null);
+      }
+
+
+      public TypeCastSet(Function castToU, Function castFromU) {
+        Contract.Requires(castFromU != null);
+        Contract.Requires(castToU != null);
+        CastToU = castToU;
+        CastFromU = castFromU;
+      }
+    }
+
+    public bool IsCast(Function fun) {
+      Contract.Requires(fun != null);
+      if (fun.InParams.Count != 1)
+        return false;
+      Type/*!*/ inType = cce.NonNull(fun.InParams[0]).TypedIdent.Type;
+      if (inType.Equals(U)) {
+        Type/*!*/ outType = cce.NonNull(fun.OutParams[0]).TypedIdent.Type;
+        if (!TypeCasts.ContainsKey(outType))
+          return false;
+        return fun.Equals(CastTo(outType));
+      } else {
+        if (!TypeCasts.ContainsKey(inType))
+          return false;
+        Type/*!*/ outType = cce.NonNull(fun.OutParams[0]).TypedIdent.Type;
+        if (!outType.Equals(U))
+          return false;
+        return fun.Equals(CastFrom(inType));
+      }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    // the only types that we allow in "untyped" expressions are U,
+    // Type.Int, Type.Real, and Type.Bool
+
+    public override Type TypeAfterErasure(Type type) {
+      //Contract.Requires(type != null);
+      Contract.Ensures(Contract.Result<Type>() != null);
+      if (UnchangedType(type))
+        // these types are kept
+        return type;
+      else
+        // all other types are replaced by U
+        return U;
+    }
+
+    [Pure]
+    public override bool UnchangedType(Type type) {
+      //Contract.Requires(type != null);
+      return type.IsInt || type.IsReal || type.IsBool || type.IsBv || (type.IsMap && CommandLineOptions.Clo.MonomorphicArrays);
+    }
+
+    public VCExpr Cast(VCExpr expr, Type toType) {
+      Contract.Requires(toType != null);
+      Contract.Requires(expr != null);
+      Contract.Requires((expr.Type.Equals(U) || UnchangedType(expr.Type)));
+      Contract.Requires((toType.Equals(U) || UnchangedType(toType)));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (expr.Type.Equals(toType))
+        return expr;
+
+      if (toType.Equals(U)) {
+        return Gen.Function(CastFrom(expr.Type), expr);
+      } else {
+        Contract.Assert(expr.Type.Equals(U));
+        return Gen.Function(CastTo(toType), expr);
+      }
+    }
+
+    public List<VCExpr/*!*/>/*!*/ CastSeq(List<VCExpr/*!*/>/*!*/ exprs, Type toType) {
+      Contract.Requires(toType != null);
+      Contract.Requires(cce.NonNullElements(exprs));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
+      List<VCExpr/*!*/>/*!*/ res = new List<VCExpr/*!*/>(exprs.Count);
+      foreach (VCExpr/*!*/ expr in exprs) {
+        Contract.Assert(expr != null);
+        res.Add(Cast(expr, toType));
+      }
+      return res;
+    }
+
+
+  }
+
+  [ContractClassFor(typeof(TypeAxiomBuilderIntBoolU))]
+  public abstract class TypeAxiomBuilderIntBoolUContracts : TypeAxiomBuilderIntBoolU {
+    public TypeAxiomBuilderIntBoolUContracts()
+      : base((TypeAxiomBuilderIntBoolU)null) {
+    }
+    protected override VCExpr GenReverseCastAxiom(Function castToU, Function castFromU) {
+      Contract.Requires(castToU != null);
+      Contract.Requires(castFromU != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      throw new NotImplementedException();
+    }
+
+    protected override VCExpr GenCastTypeAxioms(Function castToU, Function castFromU) {
+      Contract.Requires(castFromU != null);
+      Contract.Requires(castToU != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      throw new NotImplementedException();
+    }
+
+    internal override MapTypeAbstractionBuilder MapTypeAbstracter {
+      get {
+        throw new NotImplementedException();
+      }
+    }
+
+    protected override void AddVarTypeAxiom(VCExprVar var, Type originalType) {
+      throw new NotImplementedException();
+    }
+
+    public override object Clone() {
+      throw new NotImplementedException();
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Class for computing most general abstractions of map types. An abstraction
+  // of a map type t is a maptype t' in which closed proper subtypes have been replaced
+  // with type variables. E.g., an abstraction of <a>[C a, int]a would be <a>[C a, b]a.
+  // We subsequently consider most general abstractions as ordinary parametrised types,
+  // i.e., "<a>[C a, b]a" would be considered as a type "M b" with polymorphically typed
+  // access functions
+  //
+  //            select<a,b>(M b, C a, b) returns (a)
+  //            store<a,b>(M b, C a, b, a) returns (M b)
+  [ContractClass(typeof(MapTypeAbstractionBuilderContracts))]
+  internal abstract class MapTypeAbstractionBuilder {
+
+    protected readonly TypeAxiomBuilder/*!*/ AxBuilder;
+    protected readonly VCExpressionGenerator/*!*/ Gen;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(AxBuilder != null);
+      Contract.Invariant(Gen != null);
+    }
+
+
+    internal MapTypeAbstractionBuilder(TypeAxiomBuilder axBuilder, VCExpressionGenerator gen) {
+      Contract.Requires(gen != null);
+      Contract.Requires(axBuilder != null);
+      this.AxBuilder = axBuilder;
+      this.Gen = gen;
+      AbstractionVariables = new List<TypeVariable/*!*/>();
+      ClassRepresentations = new Dictionary<MapType/*!*/, MapTypeClassRepresentation>();
+    }
+
+    // constructor for cloning
+    internal MapTypeAbstractionBuilder(TypeAxiomBuilder axBuilder, VCExpressionGenerator gen, MapTypeAbstractionBuilder builder) {
+      Contract.Requires(builder != null);
+      Contract.Requires(gen != null);
+      Contract.Requires(axBuilder != null);
+      this.AxBuilder = axBuilder;
+      this.Gen = gen;
+      AbstractionVariables =
+        new List<TypeVariable/*!*/>(builder.AbstractionVariables);
+      ClassRepresentations =
+        new Dictionary<MapType/*!*/, MapTypeClassRepresentation>(builder.ClassRepresentations);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Type variables used in the abstractions. We use the same variables in the
+    // same order in all abstractions in order to obtain comparable abstractions
+    // (equals, hashcode)
+
+    private readonly List<TypeVariable/*!*/>/*!*/ AbstractionVariables;
+    [ContractInvariantMethod]
+    void AbstractionVariablesInvariantMethod() {
+      Contract.Invariant(cce.NonNullElements(AbstractionVariables));
+    }
+
+    private TypeVariable AbstractionVariable(int num) {
+      Contract.Requires((num >= 0));
+      Contract.Ensures(Contract.Result<TypeVariable>() != null);
+      while (AbstractionVariables.Count <= num)
+        AbstractionVariables.Add(new TypeVariable(Token.NoToken,
+                                                   "aVar" + AbstractionVariables.Count));
+      return AbstractionVariables[num];
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // The untyped representation of a class of map types, i.e., of a map type
+    // <a0, a1, ...>[A0, A1, ...] R, where the argument types and the result type
+    // possibly contain free type variables. For each such class, a separate type
+    // constructor and separate select/store functions are introduced.
+
+    protected struct MapTypeClassRepresentation {
+      public readonly TypeCtorDecl/*!*/ RepresentingType;
+      public readonly Function/*!*/ Select;
+      public readonly Function/*!*/ Store;
+      [ContractInvariantMethod]
+      void ObjectInvariant() {
+        Contract.Invariant(RepresentingType != null);
+        Contract.Invariant(Select != null);
+        Contract.Invariant(Store != null);
+      }
+
+
+      public MapTypeClassRepresentation(TypeCtorDecl representingType, Function select, Function store) {
+        Contract.Requires(store != null);
+        Contract.Requires(select != null);
+        Contract.Requires(representingType != null);
+        this.RepresentingType = representingType;
+        this.Select = select;
+        this.Store = store;
+      }
+    }
+
+    private readonly IDictionary<MapType/*!*/, MapTypeClassRepresentation/*!*/>/*!*/ ClassRepresentations;
+    [ContractInvariantMethod]
+    void ClassRepresentationsInvariantMethod() {
+      Contract.Invariant(ClassRepresentations != null);
+    }
+
+    protected MapTypeClassRepresentation GetClassRepresentation(MapType abstractedType) {
+      Contract.Requires(abstractedType != null);
+      MapTypeClassRepresentation res;
+      if (!ClassRepresentations.TryGetValue(abstractedType, out res)) {
+        int num = ClassRepresentations.Count;
+        TypeCtorDecl/*!*/ synonym =
+          new TypeCtorDecl(Token.NoToken, "MapType" + num, abstractedType.FreeVariables.Count);
+
+        Function/*!*/ select, store;
+        GenSelectStoreFunctions(abstractedType, synonym, out select, out store);
+
+        res = new MapTypeClassRepresentation(synonym, select, store);
+        ClassRepresentations.Add(abstractedType, res);
+      }
+      return res;
+    }
+
+    // the actual select and store functions are generated by the
+    // concrete subclasses of this class
+    protected abstract void GenSelectStoreFunctions(MapType/*!*/ abstractedType, TypeCtorDecl/*!*/ synonymDecl, out Function/*!*/ select, out Function/*!*/ store);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    public Function Select(MapType rawType, out List<Type> instantiations) {
+      Contract.Requires((rawType != null));
+      Contract.Ensures(Contract.ValueAtReturn(out instantiations) != null);
+      Contract.Ensures(Contract.Result<Function>() != null);
+      return AbstractAndGetRepresentation(rawType, out instantiations).Select;
+    }
+
+    public Function Store(MapType rawType, out List<Type> instantiations) {
+      Contract.Requires((rawType != null));
+      Contract.Ensures(Contract.ValueAtReturn(out instantiations) != null);
+      Contract.Ensures(Contract.Result<Function>() != null);
+      return AbstractAndGetRepresentation(rawType, out instantiations).Store;
+    }
+
+    private MapTypeClassRepresentation
+            AbstractAndGetRepresentation(MapType rawType, out List<Type> instantiations) {
+      Contract.Requires((rawType != null));
+      Contract.Ensures(Contract.ValueAtReturn(out instantiations) != null);
+      instantiations = new List<Type>();
+      MapType/*!*/ abstraction = ThinOutMapType(rawType, instantiations);
+      return GetClassRepresentation(abstraction);
+    }
+
+    public CtorType AbstractMapType(MapType rawType) {
+      Contract.Requires(rawType != null);
+      Contract.Ensures(Contract.Result<CtorType>() != null);
+      List<Type>/*!*/ instantiations = new List<Type>();
+      MapType/*!*/ abstraction = ThinOutMapType(rawType, instantiations);
+
+      MapTypeClassRepresentation repr = GetClassRepresentation(abstraction);
+      Contract.Assume(repr.RepresentingType.Arity == instantiations.Count);
+      return new CtorType(Token.NoToken, repr.RepresentingType, instantiations);
+    }
+
+    // TODO: cache the result of this operation
+    protected MapType ThinOutMapType(MapType rawType, List<Type> instantiations) {
+      Contract.Requires(instantiations != null);
+      Contract.Requires(rawType != null);
+      Contract.Ensures(Contract.Result<MapType>() != null);
+      List<Type>/*!*/ newArguments = new List<Type>();
+      foreach (Type/*!*/ subtype in rawType.Arguments.ToList()) {
+        Contract.Assert(subtype != null);
+        newArguments.Add(ThinOutType(subtype, rawType.TypeParameters,
+                                     instantiations));
+      }
+      Type/*!*/ newResult = ThinOutType(rawType.Result, rawType.TypeParameters,
+                                    instantiations);
+      return new MapType(Token.NoToken, rawType.TypeParameters, newArguments, newResult);
+    }
+
+    // the instantiations of inserted type variables, the order corresponds to the order in which "AbstractionVariable(int)" delivers variables
+    private Type/*!*/ ThinOutType(Type rawType, List<TypeVariable> boundTypeParams, List<Type> instantiations) {
+      Contract.Requires(instantiations != null);
+      Contract.Requires(boundTypeParams != null);
+      Contract.Requires(rawType != null);
+      Contract.Ensures(Contract.Result<Type>() != null);
+
+      if (CommandLineOptions.Clo.Monomorphize && AxBuilder.UnchangedType(rawType))
+        return rawType;
+
+      if (rawType.FreeVariables.All(var => !boundTypeParams.Contains(var))) {
+        // Bingo!
+        // if the type does not contain any bound variables, we can simply
+        // replace it with a type variable
+        TypeVariable/*!*/ abstractionVar = AbstractionVariable(instantiations.Count);
+        Contract.Assume(!boundTypeParams.Contains(abstractionVar));
+        instantiations.Add(rawType);
+        return abstractionVar;
+      }
+
+      if (rawType.IsVariable) {
+        //
+        // then the variable has to be bound, we cannot do anything
+        TypeVariable/*!*/ rawVar = rawType.AsVariable;
+        Contract.Assume(boundTypeParams.Contains(rawVar));
+        return rawVar;
+        //
+      } else if (rawType.IsMap) {
+        //
+        // recursively abstract this map type and continue abstracting
+        CtorType/*!*/ abstraction = AbstractMapType(rawType.AsMap);
+        return ThinOutType(abstraction, boundTypeParams, instantiations);
+        //
+      } else if (rawType.IsCtor) {
+        //
+        // traverse the subtypes
+        CtorType/*!*/ rawCtorType = rawType.AsCtor;
+        List<Type>/*!*/ newArguments = new List<Type>();
+        foreach (Type/*!*/ subtype in rawCtorType.Arguments.ToList()) {
+          Contract.Assert(subtype != null);
+          newArguments.Add(ThinOutType(subtype, boundTypeParams,
+                                       instantiations));
+        }
+        return new CtorType(Token.NoToken, rawCtorType.Decl, newArguments);
+        //
+      } else {
+        System.Diagnostics.Debug.Fail("Don't know how to handle this type: " + rawType);
+        return rawType;   // compiler appeasement policy
+      }
+    }
+
+  }
+  [ContractClassFor(typeof(MapTypeAbstractionBuilder))]
+  internal abstract class MapTypeAbstractionBuilderContracts : MapTypeAbstractionBuilder {
+    public MapTypeAbstractionBuilderContracts()
+      : base(null, null) {
+    }
+    protected override void GenSelectStoreFunctions(MapType abstractedType, TypeCtorDecl synonymDecl, out Function select, out Function store) {
+      Contract.Requires(abstractedType != null);
+      Contract.Requires(synonymDecl != null);
+      Contract.Ensures(Contract.ValueAtReturn(out select) != null);
+      Contract.Ensures(Contract.ValueAtReturn(out store) != null);
+
+      throw new NotImplementedException();
+    }
+  }
+
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  public class VariableBindings {
+    public readonly IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ VCExprVarBindings;
+    public readonly IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/ TypeVariableBindings;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(cce.NonNullDictionaryAndValues(VCExprVarBindings));
+      Contract.Invariant(cce.NonNullDictionaryAndValues(TypeVariableBindings));
+    }
+
+
+    public VariableBindings(IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ vcExprVarBindings,
+                            IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/ typeVariableBindings) {
+      Contract.Requires(cce.NonNullDictionaryAndValues(vcExprVarBindings));
+      Contract.Requires(cce.NonNullDictionaryAndValues(typeVariableBindings));
+      this.VCExprVarBindings = vcExprVarBindings;
+      this.TypeVariableBindings = typeVariableBindings;
+    }
+
+    public VariableBindings() :
+      this(new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/>(),
+            new Dictionary<TypeVariable/*!*/, VCExpr/*!*/>()) {
+    }
+
+    public VariableBindings Clone() {
+      Contract.Ensures(Contract.Result<VariableBindings>() != null);
+      IDictionary<VCExprVar/*!*/, VCExprVar/*!*/>/*!*/ newVCExprVarBindings =
+        new Dictionary<VCExprVar/*!*/, VCExprVar/*!*/>();
+      foreach (KeyValuePair<VCExprVar/*!*/, VCExprVar/*!*/> pair in VCExprVarBindings) {
+        Contract.Assert(cce.NonNullElements(pair));
+        newVCExprVarBindings.Add(pair);
+      }
+      IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/ newTypeVariableBindings =
+        new Dictionary<TypeVariable/*!*/, VCExpr/*!*/>();
+      foreach (KeyValuePair<TypeVariable/*!*/, VCExpr/*!*/> pair in TypeVariableBindings) {
+        Contract.Assert(cce.NonNullElements(pair));
+        newTypeVariableBindings.Add(pair);
+      }
+      return new VariableBindings(newVCExprVarBindings, newTypeVariableBindings);
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  // The central class for turning types VCExprs into untyped
+  // VCExprs. This class makes use of the type axiom builder to manage
+  // the available types and symbols.
+  [ContractClass(typeof(TypeEraserContracts))]
+  public abstract class TypeEraser : MutatingVCExprVisitor<VariableBindings/*!*/> {
+
+    protected readonly TypeAxiomBuilderIntBoolU/*!*/ AxBuilder;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(AxBuilder != null);
+    }
+
+
+    protected abstract OpTypeEraser/*!*/ OpEraser {
+      get;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public TypeEraser(TypeAxiomBuilderIntBoolU axBuilder, VCExpressionGenerator gen)
+      : base(gen) {
+      Contract.Requires(gen != null);
+      Contract.Requires(axBuilder != null);
+      AxBuilder = axBuilder;
+    }
+
+    public VCExpr Erase(VCExpr expr, int polarity) {
+      Contract.Requires(expr != null);
+      Contract.Requires((polarity >= -1 && polarity <= 1));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      this.Polarity = polarity;
+      return Mutate(expr, new VariableBindings());
+    }
+
+    internal int Polarity = 1;  // 1 for positive, -1 for negative, 0 for both
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public override VCExpr Visit(VCExprLiteral node, VariableBindings bindings) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      Contract.Assume(node.Type == Type.Bool || node.Type == Type.Int || node.Type == Type.Real);
+      return node;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public override bool AvoidVisit(VCExprNAry node, VariableBindings arg)
+    {
+        return node.Op.Equals(VCExpressionGenerator.AndOp) ||
+               node.Op.Equals(VCExpressionGenerator.OrOp);
+    }
+
+    public override VCExpr Visit(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExprOp/*!*/ op = node.Op;
+      if (op == VCExpressionGenerator.AndOp || op == VCExpressionGenerator.OrOp)
+        // more efficient on large conjunctions/disjunctions
+        return base.Visit(node, bindings);
+
+      // the visitor that handles all other operators
+      return node.Accept<VCExpr/*!*/, VariableBindings/*!*/>(OpEraser, bindings);
+    }
+
+    // this method is called by MutatingVCExprVisitor.Visit(VCExprNAry, ...)
+    protected override VCExpr/*!*/ UpdateModifiedNode(VCExprNAry/*!*/ originalNode, List<VCExpr/*!*/>/*!*/ newSubExprs, bool changed, VariableBindings/*!*/ bindings) {
+      //Contract.Requires(originalNode != null);
+      //Contract.Requires(cce.NonNullElements(newSubExprs));
+      //Contract.Requires(bindings != null);
+      Contract.Assume(originalNode.Op == VCExpressionGenerator.AndOp ||
+             originalNode.Op == VCExpressionGenerator.OrOp);
+      return Gen.Function(originalNode.Op,
+                          AxBuilder.Cast(newSubExprs[0], Type.Bool),
+                          AxBuilder.Cast(newSubExprs[1], Type.Bool));
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public override VCExpr Visit(VCExprVar node, VariableBindings bindings) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExprVar res;
+      if (!bindings.VCExprVarBindings.TryGetValue(node, out res))
+        return AxBuilder.Typed2Untyped(node);
+      return cce.NonNull(res);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    protected bool IsUniversalQuantifier(VCExprQuantifier node) {
+      Contract.Requires(node != null);
+      return Polarity == 1 && node.Quan == Quantifier.EX ||
+             Polarity == -1 && node.Quan == Quantifier.ALL;
+    }
+
+    protected List<VCExprVar/*!*/>/*!*/ BoundVarsAfterErasure(List<VCExprVar/*!*/>/*!*/ oldBoundVars,
+      // the mapping between old and new variables
+      // is added to this bindings-object
+                                                      VariableBindings/*!*/ bindings) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(cce.NonNullElements(oldBoundVars));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
+
+      List<VCExprVar/*!*/>/*!*/ newBoundVars = new List<VCExprVar/*!*/>(oldBoundVars.Count);
+      foreach (VCExprVar/*!*/ var in oldBoundVars) {
+        Type/*!*/ newType = AxBuilder.TypeAfterErasure(var.Type);
+        VCExprVar/*!*/ newVar = Gen.Variable(var.Name, newType);
+        newBoundVars.Add(newVar);
+        bindings.VCExprVarBindings.Add(var, newVar);
+      }
+      return newBoundVars;
+    }
+
+    // We check whether casts Int2U or Bool2U on the bound variables
+    // occur in triggers. In case a trigger like f(Int2U(x)) occurs,
+    // it may be better to give variable x the type U and remove the
+    // cast. The following method returns true if the quantifier
+    // should be translated again with a different typing
+    protected bool RedoQuantifier(VCExprQuantifier/*!*/ node,
+                                  VCExprQuantifier/*!*/ newNode,
+      // the bound vars that actually occur in the body or
+      // in any of the triggers
+                                  List<VCExprVar/*!*/>/*!*/ occurringVars,
+                                  VariableBindings/*!*/ oldBindings,
+                                  out VariableBindings/*!*/ newBindings,
+                                  out List<VCExprVar/*!*/>/*!*/ newBoundVars) {
+      Contract.Requires(node != null);
+      Contract.Requires(newNode != null);
+      Contract.Requires(cce.NonNullElements(occurringVars));
+      Contract.Requires(oldBindings != null);
+      Contract.Ensures(Contract.ValueAtReturn(out newBindings) != null);
+      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out newBoundVars)));
+      List<VCExprVar/*!*/> castVariables =
+        VariableCastCollector.FindCastVariables(node, newNode, AxBuilder);
+      if (castVariables.Count == 0) {
+        newBindings = oldBindings;         // to make the compiler happy
+        newBoundVars = newNode.BoundVars;  // to make the compiler happy
+        return false;
+      }
+
+      // redo everything with a different typing ...
+
+      newBindings = oldBindings.Clone();
+      newBoundVars = new List<VCExprVar/*!*/>(node.BoundVars.Count);
+      foreach (VCExprVar/*!*/ var in node.BoundVars) {
+        Contract.Assert(var != null);
+        Type/*!*/ newType =
+          castVariables.Contains(var) ? AxBuilder.U
+                                      : AxBuilder.TypeAfterErasure(var.Type);
+        Contract.Assert(newType != null);
+        VCExprVar/*!*/ newVar = Gen.Variable(var.Name, newType);
+        Contract.Assert(newVar != null);
+        newBoundVars.Add(newVar);
+        newBindings.VCExprVarBindings.Add(var, newVar);
+      }
+
+      return true;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public override VCExpr Visit(VCExprLet node, VariableBindings bindings) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VariableBindings/*!*/ newVarBindings = bindings.Clone();
+
+      List<VCExprVar/*!*/>/*!*/ newBoundVars = new List<VCExprVar/*!*/>(node.BoundVars.Count);
+      foreach (VCExprVar/*!*/ var in node.BoundVars) {
+        Type/*!*/ newType = AxBuilder.TypeAfterErasure(var.Type);
+        VCExprVar/*!*/ newVar = Gen.Variable(var.Name, newType);
+        newBoundVars.Add(newVar);
+        newVarBindings.VCExprVarBindings.Add(var, newVar);
+      }
+
+      List<VCExprLetBinding/*!*/>/*!*/ newbindings = new List<VCExprLetBinding/*!*/>(node.Length);
+      for (int i = 0; i < node.Length; ++i) {
+        VCExprLetBinding/*!*/ binding = node[i];
+        Contract.Assert(binding != null);
+        VCExprVar/*!*/ newVar = newBoundVars[i];
+        Type/*!*/ newType = newVar.Type;
+
+        VCExpr/*!*/ newE = AxBuilder.Cast(Mutate(binding.E, newVarBindings), newType);
+        newbindings.Add(Gen.LetBinding(newVar, newE));
+      }
+
+      VCExpr/*!*/ newbody = Mutate(node.Body, newVarBindings);
+      return Gen.Let(newbindings, newbody);
+    }
+  }
+
+  [ContractClassFor(typeof(TypeEraser))]
+  public abstract class TypeEraserContracts : TypeEraser {
+    public TypeEraserContracts()
+      : base(null, null) {
+    }
+    protected override OpTypeEraser OpEraser {
+      get {
+        Contract.Ensures(Contract.Result<OpTypeEraser>() != null);
+        throw new NotImplementedException();
+      }
+    }
+  }
+
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  public abstract class OpTypeEraser : StandardVCExprOpVisitor<VCExpr/*!*/, VariableBindings/*!*/> {
+
+    protected readonly TypeAxiomBuilderIntBoolU/*!*/ AxBuilder;
+
+    protected readonly TypeEraser/*!*/ Eraser;
+    protected readonly VCExpressionGenerator/*!*/ Gen;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(AxBuilder != null);
+      Contract.Invariant(Eraser != null);
+      Contract.Invariant(Gen != null);
+    }
+
+
+    public OpTypeEraser(TypeEraser/*!*/ eraser, TypeAxiomBuilderIntBoolU/*!*/ axBuilder, VCExpressionGenerator/*!*/ gen) {
+      Contract.Requires(eraser != null);
+      Contract.Requires(axBuilder != null);
+      Contract.Requires(gen != null);
+      this.AxBuilder = axBuilder;
+      this.Eraser = eraser;
+      this.Gen = gen;
+    }
+
+    protected override VCExpr StandardResult(VCExprNAry node, VariableBindings bindings) {
+      //Contract.Requires(bindings != null);
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      System.Diagnostics.Debug.Fail("Don't know how to erase types in this expression: " + node);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();  // to please the compiler
+    }
+
+    private List<VCExpr/*!*/>/*!*/ MutateSeq(VCExprNAry node, VariableBindings bindings, int newPolarity) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
+      int oldPolarity = Eraser.Polarity;
+      Eraser.Polarity = newPolarity;
+      List<VCExpr/*!*/>/*!*/ newArgs = Eraser.MutateSeq(node, bindings);
+      Eraser.Polarity = oldPolarity;
+      return newArgs;
+    }
+
+    private VCExpr CastArguments(VCExprNAry node, Type argType, VariableBindings bindings, int newPolarity) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(argType != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Gen.Function(node.Op,
+                          AxBuilder.CastSeq(MutateSeq(node, bindings, newPolarity),
+                          argType));
+    }
+
+    // Cast the arguments of the node to their old type if necessary and possible; otherwise use
+    // their new type (int, real, bool, or U)
+    private VCExpr CastArgumentsToOldType(VCExprNAry node, VariableBindings bindings, int newPolarity) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(node != null);
+      Contract.Requires((node.Arity > 0));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      List<VCExpr/*!*/>/*!*/ newArgs = MutateSeq(node, bindings, newPolarity);
+      Type/*!*/ oldType = node[0].Type;
+      if (AxBuilder.UnchangedType(oldType) &&
+          node.Skip(1).All(e => e.Type.Equals(oldType)))
+        return Gen.Function(node.Op, AxBuilder.CastSeq(newArgs, oldType));
+      else
+        return Gen.Function(node.Op, AxBuilder.CastSeq(newArgs, AxBuilder.U));
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    public override VCExpr VisitNotOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArguments(node, Type.Bool, bindings, -Eraser.Polarity);
+    }
+    public override VCExpr VisitEqOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitNeqOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitImpliesOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      // UGLY: the code for tracking polarities should be factored out
+      List<VCExpr/*!*/>/*!*/ newArgs = new List<VCExpr/*!*/>(2);
+      Eraser.Polarity = -Eraser.Polarity;
+      newArgs.Add(Eraser.Mutate(node[0], bindings));
+      Eraser.Polarity = -Eraser.Polarity;
+      newArgs.Add(Eraser.Mutate(node[1], bindings));
+      return Gen.Function(node.Op, AxBuilder.CastSeq(newArgs, Type.Bool));
+    }
+    public override VCExpr VisitDistinctOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitLabelOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      // argument of the label operator should always be a formula
+      // (at least for Simplify ... should this be ensured at a later point?)
+      return CastArguments(node, Type.Bool, bindings, Eraser.Polarity);
+    }
+    public override VCExpr VisitIfThenElseOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<VCExpr/*!*/>/*!*/ newArgs = MutateSeq(node, bindings, 0);
+      newArgs[0] = AxBuilder.Cast(newArgs[0], Type.Bool);
+      Type t = node.Type;
+      if (!AxBuilder.UnchangedType(t)) {
+        t = AxBuilder.U;
+      }
+      newArgs[1] = AxBuilder.Cast(newArgs[1], t);
+      newArgs[2] = AxBuilder.Cast(newArgs[2], t);
+      return Gen.Function(node.Op, newArgs);
+    }
+    public override VCExpr/*!*/ VisitCustomOp(VCExprNAry/*!*/ node, VariableBindings/*!*/ bindings) {
+      Contract.Requires(node != null);
+      Contract.Requires(bindings != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      List<VCExpr/*!*/>/*!*/ newArgs = MutateSeq(node, bindings, 0);
+      return Gen.Function(node.Op, newArgs);
+    }
+    public override VCExpr VisitAddOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArguments(node, node.Type, bindings, 0);
+    }
+    public override VCExpr VisitSubOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArguments(node, node.Type, bindings, 0);
+    }
+    public override VCExpr VisitMulOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArguments(node, node.Type, bindings, 0);
+    }
+    public override VCExpr VisitDivOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArguments(node, Type.Int, bindings, 0);
+    }
+    public override VCExpr VisitModOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArguments(node, Type.Int, bindings, 0);
+    }
+    public override VCExpr VisitRealDivOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArguments(node, Type.Real, bindings, 0);
+    }
+    /*public override VCExpr VisitFloatDivOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArguments(node, Type.Float, bindings, 0);
+    }*/
+    public override VCExpr VisitPowOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArguments(node, Type.Real, bindings, 0);
+    }
+    public override VCExpr VisitLtOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitLeOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitGtOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitGeOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitSubtypeOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArguments(node, AxBuilder.U, bindings, 0);
+    }
+    public override VCExpr VisitToIntOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitToRealOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatAddOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatSubOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatMulOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatDivOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatRemOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatMinOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatMaxOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatLeqOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatLtOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatGeqOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatGtOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitFloatEqOp(VCExprNAry node, VariableBindings bindings)
+    {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitBvOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitBvExtractOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return CastArgumentsToOldType(node, bindings, 0);
+    }
+    public override VCExpr VisitBvConcatOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+      Contract.Requires((node != null));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<VCExpr/*!*/>/*!*/ newArgs = MutateSeq(node, bindings, 0);
+
+      // each argument is cast to its old type
+      Contract.Assert(newArgs.Count == node.Arity && newArgs.Count == 2);
+      VCExpr/*!*/ arg0 = AxBuilder.Cast(newArgs[0], node[0].Type);
+      Contract.Assert(arg0 != null);
+      VCExpr/*!*/ arg1 = AxBuilder.Cast(newArgs[1], node[1].Type);
+      Contract.Assert(arg1 != null);
+      return Gen.Function(node.Op, arg0, arg1);
+    }
+
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  /// <summary>
+  /// Collect all variables x occurring in expressions of the form Int2U(x) or Bool2U(x), and
+  /// collect all variables x occurring outside such forms.
+  /// </summary>
+  internal class VariableCastCollector : TraversingVCExprVisitor<bool, bool> {
+    /// <summary>
+    /// Determine those bound variables in "oldNode" <em>all</em> of whose relevant uses
+    /// have to be cast in potential triggers in "newNode".  It is assume that
+    /// the bound variables of "oldNode" correspond to the first bound
+    /// variables of "newNode".
+    /// </summary>
+    public static List<VCExprVar/*!*/>/*!*/ FindCastVariables(VCExprQuantifier oldNode, VCExprQuantifier newNode, TypeAxiomBuilderIntBoolU axBuilder) {
+      Contract.Requires((axBuilder != null));
+      Contract.Requires((newNode != null));
+      Contract.Requires((oldNode != null));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
+      VariableCastCollector/*!*/ collector = new VariableCastCollector(axBuilder);
+      Contract.Assert(collector != null);
+      if (newNode.Triggers.Any(trigger => trigger.Pos)) {
+        // look in the given triggers
+        foreach (VCTrigger/*!*/ trigger in newNode.Triggers) {
+          Contract.Assert(trigger != null);
+          if (trigger.Pos) {
+            foreach (VCExpr/*!*/ expr in trigger.Exprs) {
+              Contract.Assert(expr != null);
+              collector.Traverse(expr, true);
+            }
+          }
+        }
+      } else {
+        // look in the body of the quantifier
+        collector.Traverse(newNode.Body, true);
+      }
+
+      List<VCExprVar/*!*/>/*!*/ castVariables = new List<VCExprVar/*!*/>(collector.varsInCasts.Count);
+      foreach (VCExprVar/*!*/ castVar in collector.varsInCasts) {
+        Contract.Assert(castVar != null);
+        int i = newNode.BoundVars.IndexOf(castVar);
+        if (0 <= i && i < oldNode.BoundVars.Count && !collector.varsOutsideCasts.ContainsKey(castVar))
+          castVariables.Add(oldNode.BoundVars[i]);
+      }
+      return castVariables;
+    }
+
+    public VariableCastCollector(TypeAxiomBuilderIntBoolU axBuilder) {
+      Contract.Requires(axBuilder != null);
+      this.AxBuilder = axBuilder;
+    }
+
+    readonly List<VCExprVar/*!*/>/*!*/ varsInCasts = new List<VCExprVar/*!*/>();
+    readonly Dictionary<VCExprVar/*!*/, object>/*!*/ varsOutsideCasts = new Dictionary<VCExprVar/*!*/, object>();
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(cce.NonNullElements(varsInCasts));
+      Contract.Invariant(varsOutsideCasts != null && Contract.ForAll(varsOutsideCasts, voc => voc.Key != null));
+      Contract.Invariant(AxBuilder != null);
+
+    }
+
+
+    readonly TypeAxiomBuilderIntBoolU/*!*/ AxBuilder;
+
+    protected override bool StandardResult(VCExpr node, bool arg) {
+      //Contract.Requires(node != null);
+      return true; // not used
+    }
+
+    public override bool Visit(VCExprNAry node, bool arg) {
+      Contract.Requires(node != null);
+      if (node.Op is VCExprBoogieFunctionOp) {
+        Function func = ((VCExprBoogieFunctionOp)node.Op).Func;
+        Contract.Assert(func != null);
+        if ((AxBuilder.IsCast(func)) && node[0] is VCExprVar) {
+          VCExprVar castVar = (VCExprVar)node[0];
+          if (!varsInCasts.Contains(castVar))
+            varsInCasts.Add(castVar);
+          return true;
+        }
+      } else if (node.Op is VCExprNAryOp) {
+        VCExpressionGenerator.SingletonOp op = VCExpressionGenerator.SingletonOpDict[node.Op];
+        switch (op) {
+          // the following operators cannot be used in triggers, so disregard any uses of variables as direct arguments
+          case VCExpressionGenerator.SingletonOp.NotOp:
+          case VCExpressionGenerator.SingletonOp.EqOp:
+          case VCExpressionGenerator.SingletonOp.NeqOp:
+          case VCExpressionGenerator.SingletonOp.AndOp:
+          case VCExpressionGenerator.SingletonOp.OrOp:
+          case VCExpressionGenerator.SingletonOp.ImpliesOp:
+          case VCExpressionGenerator.SingletonOp.LtOp:
+          case VCExpressionGenerator.SingletonOp.LeOp:
+          case VCExpressionGenerator.SingletonOp.GtOp:
+          case VCExpressionGenerator.SingletonOp.GeOp:
+            foreach (VCExpr n in node) {
+              if (!(n is VCExprVar)) {  // don't recurse on VCExprVar argument
+                n.Accept<bool, bool>(this, arg);
+              }
+            }
+            return true;
+          default:
+            break;
+        }
+      }
+      return base.Visit(node, arg);
+    }
+
+    public override bool Visit(VCExprVar node, bool arg) {
+      Contract.Requires(node != null);
+      if (!varsOutsideCasts.ContainsKey(node))
+        varsOutsideCasts.Add(node, null);
+      return true;
+    }
+  }
+
+}
diff --git a/Source/VCExpr/TypeErasureArguments.cs b/Source/VCExpr/TypeErasureArguments.cs
index 8885cbc7..1ee79c17 100644
--- a/Source/VCExpr/TypeErasureArguments.cs
+++ b/Source/VCExpr/TypeErasureArguments.cs
@@ -1,754 +1,754 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Linq;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-using Microsoft.Boogie.VCExprAST;
-
-// Erasure of types using explicit type parameters for functions
-
-namespace Microsoft.Boogie.TypeErasure {
-  using Microsoft.Boogie.VCExprAST;
-  using HFNS = Microsoft.Boogie.VCExprAST.HelperFuns;
-
-  public class TypeAxiomBuilderArguments : TypeAxiomBuilderIntBoolU {
-
-    public TypeAxiomBuilderArguments(VCExpressionGenerator gen)
-      : base(gen) {
-      Contract.Requires(gen != null);
-
-      Typed2UntypedFunctions = new Dictionary<Function/*!*/, Function/*!*/>();
-    }
-
-    // constructor to allow cloning
-    [NotDelayed]
-    internal TypeAxiomBuilderArguments(TypeAxiomBuilderArguments builder)
-      : base(builder) {
-      Contract.Requires(builder != null);
-      Typed2UntypedFunctions =
-        new Dictionary<Function/*!*/, Function/*!*/>(builder.Typed2UntypedFunctions);
-
-
-      MapTypeAbstracterAttr =
-        builder.MapTypeAbstracterAttr == null ?
-        null : new MapTypeAbstractionBuilderArguments(this, builder.Gen,
-                                                      builder.MapTypeAbstracterAttr);
-    }
-
-    public override Object Clone() {
-      Contract.Ensures(Contract.Result<Object>() != null);
-      return new TypeAxiomBuilderArguments(this);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////////    
-
-    // generate axioms of the kind "forall x:U. {Int2U(U2Int(x))} Int2U(U2Int(x))==x"
-    // (this makes use of the assumption that only well-typed terms are generated
-    // by the SMT-solver, i.e., that U2Int is only applied to terms that actually
-    // are of type int)
-    protected override VCExpr GenReverseCastAxiom(Function castToU, Function castFromU) {
-      //Contract.Requires(castFromU != null);
-      //Contract.Requires(castToU != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<VCTrigger/*!*/>/*!*/ triggers;
-      VCExprVar/*!*/ var;
-      VCExpr/*!*/ eq = GenReverseCastEq(castToU, castFromU, out var, out triggers);
-      return Gen.Forall(HelperFuns.ToList(var), triggers, "cast:" + castFromU.Name, -1, eq);
-    }
-
-    protected override VCExpr GenCastTypeAxioms(Function castToU, Function castFromU) {
-      //Contract.Requires(castFromU != null);
-      //Contract.Requires(castToU != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      // nothing
-      return VCExpressionGenerator.True;
-    }
-
-    private MapTypeAbstractionBuilderArguments MapTypeAbstracterAttr = null;
-
-    internal override MapTypeAbstractionBuilder/*!*/ MapTypeAbstracter {
-      get {
-        Contract.Ensures(Contract.Result<MapTypeAbstractionBuilder>() != null);
-
-        if (MapTypeAbstracterAttr == null)
-          MapTypeAbstracterAttr = new MapTypeAbstractionBuilderArguments(this, Gen);
-        return MapTypeAbstracterAttr;
-      }
-    }
-
-    protected override void AddVarTypeAxiom(VCExprVar var, Type originalType) {
-      //Contract.Requires(originalType != null);
-      //Contract.Requires(var != null);
-      // no axioms are needed for variable or function types
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Symbols for representing functions
-
-    // Globally defined functions
-    private readonly IDictionary<Function/*!*/, Function/*!*/>/*!*/ Typed2UntypedFunctions;
-    [ContractInvariantMethod]
-    void Typed2UntypedFunctionsInvariantMethod() {
-      Contract.Invariant(cce.NonNullDictionaryAndValues(Typed2UntypedFunctions));
-    }
-
-    public Function Typed2Untyped(Function fun) {
-      Contract.Requires(fun != null);
-      Contract.Ensures(Contract.Result<Function>() != null);
-      Function res;
-      if (!Typed2UntypedFunctions.TryGetValue(fun, out res)) {
-        Contract.Assert(fun.OutParams.Count == 1);
-
-        // if all of the parameters are int or bool, the function does
-        // not have to be changed
-        if (fun.InParams.All(param => UnchangedType(cce.NonNull(param).TypedIdent.Type)) &&
-            UnchangedType(cce.NonNull(fun.OutParams[0]).TypedIdent.Type)) {
-          res = fun;
-        } else {
-          Type[]/*!*/ types = new Type[fun.TypeParameters.Count + fun.InParams.Count + 1];
-
-          int i = 0;
-          // the first arguments are the explicit type parameters
-          for (int j = 0; j < fun.TypeParameters.Count; ++j) {
-            types[i] = T;
-            i = i + 1;
-          }
-          // followed by the actual parameters
-          foreach (Variable/*!*/ x in fun.InParams) {
-            Contract.Assert(x != null);
-            types[i] = TypeAfterErasure(x.TypedIdent.Type);
-            i = i + 1;
-          }
-
-          types[types.Length - 1] = TypeAfterErasure(cce.NonNull(fun.OutParams[0]).TypedIdent.Type);
-
-          res = HelperFuns.BoogieFunction(fun.Name, types);
-          res.Attributes = fun.Attributes;
-        }
-
-        Typed2UntypedFunctions.Add(fun, res);
-      }
-      return cce.NonNull(res);
-    }
-
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  internal class MapTypeAbstractionBuilderArguments : MapTypeAbstractionBuilder {
-
-    private readonly TypeAxiomBuilderArguments/*!*/ AxBuilderArguments;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(AxBuilderArguments != null);
-    }
-
-
-    internal MapTypeAbstractionBuilderArguments(TypeAxiomBuilderArguments axBuilder, VCExpressionGenerator gen)
-      : base(axBuilder, gen) {
-      Contract.Requires(gen != null);
-      Contract.Requires(axBuilder != null);
-
-      this.AxBuilderArguments = axBuilder;
-    }
-
-    // constructor for cloning
-    internal MapTypeAbstractionBuilderArguments(TypeAxiomBuilderArguments axBuilder, VCExpressionGenerator gen, MapTypeAbstractionBuilderArguments builder)
-      : base(axBuilder, gen, builder) {
-      Contract.Requires(builder != null);
-      Contract.Requires(gen != null);
-      Contract.Requires(axBuilder != null);
-      this.AxBuilderArguments = axBuilder;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    protected override void GenSelectStoreFunctions(MapType abstractedType, TypeCtorDecl synonym, out Function/*!*/ select, out Function/*!*/ store) {
-      //Contract.Requires(synonym != null);
-//Contract.Requires(abstractedType != null);
-Contract.Ensures(Contract.ValueAtReturn(out select) != null);
-Contract.Ensures(Contract.ValueAtReturn(out store) != null);
-      Contract.Assert(synonym.Name != null);
-      string/*!*/ baseName = synonym.Name;
-      int typeParamNum = abstractedType.FreeVariables.Count +
-                         abstractedType.TypeParameters.Count;
-
-      int arity = typeParamNum + abstractedType.Arguments.Count;
-
-      Type/*!*/[]/*!*/ selectTypes = new Type/*!*/ [arity + 2];
-      Type/*!*/[]/*!*/ storeTypes = new Type/*!*/ [arity + 3];
-
-      int i = 0;
-      // Fill in the free variables and type parameters
-      for (; i < typeParamNum; i++) {
-        selectTypes[i] = AxBuilder.T;
-        storeTypes[i] = AxBuilder.T;
-      }
-      // Fill in the map type
-      if (CommandLineOptions.Clo.MonomorphicArrays) {
-        selectTypes[i] = abstractedType;
-        storeTypes[i] = abstractedType;
-      } else {
-        selectTypes[i] = AxBuilder.U;
-        storeTypes[i] = AxBuilder.U;
-      }
-      i++;
-      // Fill in the index types
-      foreach (Type/*!*/ type in abstractedType.Arguments) {
-        Contract.Assert(type != null);
-        if (CommandLineOptions.Clo.Monomorphize && AxBuilder.UnchangedType(type)) {
-          selectTypes[i] = type;
-          storeTypes[i] = type;
-        } else {
-          selectTypes[i] = AxBuilder.U;
-          storeTypes[i] = AxBuilder.U;
-        }
-        i++;
-      }
-      // Fill in the output type for select function which also happens 
-      // to be the type of the last argument to the store function
-      if (CommandLineOptions.Clo.Monomorphize && AxBuilder.UnchangedType(abstractedType.Result)) {
-        selectTypes[i] = abstractedType.Result;
-        storeTypes[i] = abstractedType.Result;
-      } else {
-        selectTypes[i] = AxBuilder.U;
-        storeTypes[i] = AxBuilder.U;
-      }
-      i++;
-      // Fill in the map type which is the output of the store function
-      if (CommandLineOptions.Clo.MonomorphicArrays)
-        storeTypes[i] = abstractedType;
-      else
-        storeTypes[i] = AxBuilder.U;
-      Contract.Assert(cce.NonNullElements<Type>(selectTypes));
-      Contract.Assert(cce.NonNullElements<Type>(storeTypes));
-
-      select = HelperFuns.BoogieFunction(baseName + "Select", selectTypes);
-      store = HelperFuns.BoogieFunction(baseName + "Store", storeTypes);
-
-      if (CommandLineOptions.Clo.UseArrayTheory) {
-        select.AddAttribute("builtin", "select");
-        store.AddAttribute("builtin", "store");
-      } else {
-        AxBuilder.AddTypeAxiom(GenMapAxiom0(select, store,
-                 abstractedType.TypeParameters.Count, abstractedType.FreeVariables.Count));
-        AxBuilder.AddTypeAxiom(GenMapAxiom1(select, store,
-                 abstractedType.TypeParameters.Count, abstractedType.FreeVariables.Count));
-      }
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // The normal axioms of the theory of arrays (right now without extensionality)
-
-    private VCExpr Select(Function select, List<VCExprVar/*!*/>/*!*/ types, VCExpr map, List<VCExprVar/*!*/>/*!*/ indexes) {
-      Contract.Requires(map != null);
-      Contract.Requires(select != null);
-      Contract.Requires(cce.NonNullElements(indexes));
-      Contract.Requires(cce.NonNullElements(types));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<VCExpr/*!*/>/*!*/ selectArgs = new List<VCExpr/*!*/>();
-      selectArgs.AddRange(HelperFuns.ToVCExprList(types));
-      selectArgs.Add(map);
-      selectArgs.AddRange(HelperFuns.ToVCExprList(indexes));
-      return Gen.Function(select, selectArgs);
-    }
-
-    private VCExpr Store(Function store, List<VCExprVar/*!*/>/*!*/ types, VCExpr map, List<VCExprVar/*!*/>/*!*/ indexes, VCExpr val) {
-      Contract.Requires(val != null);
-      Contract.Requires(map != null);
-      Contract.Requires(store != null);
-      Contract.Requires(cce.NonNullElements(indexes));
-      Contract.Requires(cce.NonNullElements(types));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<VCExpr/*!*/>/*!*/ storeArgs = new List<VCExpr/*!*/>();
-      storeArgs.AddRange(HelperFuns.ToVCExprList(types));
-      storeArgs.Add(map);
-      storeArgs.AddRange(HelperFuns.ToVCExprList(indexes));
-      storeArgs.Add(val);
-      return Gen.Function(store, storeArgs);
-    }
-
-    private VCExpr/*!*/ GenMapAxiom0(Function/*!*/ select, Function/*!*/ store,
-      // bound type variables in the map type
-                                 int mapTypeParamNum,
-      // free type variables in the map
-      // type (abstraction)
-                                 int mapAbstractionVarNum) {
-      Contract.Requires(select != null);
-      Contract.Requires(store != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      int arity = select.InParams.Count - 1 - mapTypeParamNum - mapAbstractionVarNum;
-      List<VCExprVar/*!*/>/*!*/ types =
-        HelperFuns.VarVector("t", mapTypeParamNum + mapAbstractionVarNum,
-                             AxBuilder.T, Gen);
-
-      List<Type/*!*/> indexTypes = new List<Type/*!*/>();
-      for (int i = mapTypeParamNum + mapAbstractionVarNum + 1; i < select.InParams.Count; i++) {
-        indexTypes.Add(cce.NonNull(select.InParams[i]).TypedIdent.Type);
-      }
-      Contract.Assert(arity == indexTypes.Count);
-
-      List<VCExprVar/*!*/>/*!*/ indexes = HelperFuns.VarVector("x", indexTypes, Gen);
-
-      VCExprVar/*!*/ m = Gen.Variable("m", AxBuilder.U);
-      Contract.Assert(m != null);
-      VCExprVar/*!*/ val = Gen.Variable("val", cce.NonNull(select.OutParams[0]).TypedIdent.Type);
-      Contract.Assert(val != null);
-
-      VCExpr/*!*/ storeExpr = Store(store, types, m, indexes, val);
-      Contract.Assert(storeExpr != null);
-      VCExpr/*!*/ selectExpr = Select(select, types, storeExpr, indexes);
-      Contract.Assert(selectExpr != null);
-
-      List<VCExprVar/*!*/>/*!*/ quantifiedVars = new List<VCExprVar/*!*/>();
-      quantifiedVars.AddRange(types);
-      quantifiedVars.Add(val);
-      quantifiedVars.Add(m);
-      quantifiedVars.AddRange(indexes);
-
-      VCExpr/*!*/ eq = Gen.Eq(selectExpr, val);
-      Contract.Assert(eq != null);
-      return Gen.Forall(quantifiedVars, new List<VCTrigger/*!*/>(), "mapAx0:" + select.Name, 0, eq);
-    }
-
-    private VCExpr/*!*/ GenMapAxiom1(Function/*!*/ select, Function/*!*/ store,
-      // bound type variables in the map
-      // type
-                                 int mapTypeParamNum,
-      // free type variables in the map
-      // type (abstraction)
-                                 int mapAbstractionVarNum) {
-      Contract.Requires(select != null);
-      Contract.Requires(store != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      int arity = select.InParams.Count - 1 - mapTypeParamNum - mapAbstractionVarNum;
-
-      List<VCExprVar/*!*/>/*!*/ freeTypeVars =
-        HelperFuns.VarVector("u", mapAbstractionVarNum, AxBuilder.T, Gen);
-      List<VCExprVar/*!*/>/*!*/ boundTypeVars0 =
-        HelperFuns.VarVector("s", mapTypeParamNum, AxBuilder.T, Gen);
-      List<VCExprVar/*!*/>/*!*/ boundTypeVars1 =
-        HelperFuns.VarVector("t", mapTypeParamNum, AxBuilder.T, Gen);
-
-      List<VCExprVar/*!*/>/*!*/ types0 = new List<VCExprVar/*!*/>(boundTypeVars0);
-      types0.AddRange(freeTypeVars);
-
-      List<VCExprVar/*!*/>/*!*/ types1 = new List<VCExprVar/*!*/>(boundTypeVars1);
-      types1.AddRange(freeTypeVars);
-
-      List<Type/*!*/> indexTypes = new List<Type/*!*/>();
-      for (int i = mapTypeParamNum + mapAbstractionVarNum + 1; i < select.InParams.Count; i++) {
-        indexTypes.Add(cce.NonNull(select.InParams[i]).TypedIdent.Type);
-      }
-      Contract.Assert(arity == indexTypes.Count);
-
-      List<VCExprVar/*!*/>/*!*/ indexes0 = HelperFuns.VarVector("x", indexTypes, Gen);
-      List<VCExprVar/*!*/>/*!*/ indexes1 = HelperFuns.VarVector("y", indexTypes, Gen);
-
-      VCExprVar/*!*/ m = Gen.Variable("m", AxBuilder.U);
-      Contract.Assert(m != null);
-      VCExprVar/*!*/ val = Gen.Variable("val", cce.NonNull(select.OutParams[0]).TypedIdent.Type);
-      Contract.Assert(val != null);
-
-      VCExpr/*!*/ storeExpr = Store(store, types0, m, indexes0, val);
-      Contract.Assert(storeExpr != null);
-      VCExpr/*!*/ selectWithoutStoreExpr = Select(select, types1, m, indexes1);
-      Contract.Assert(selectWithoutStoreExpr != null);
-      VCExpr/*!*/ selectExpr = Select(select, types1, storeExpr, indexes1);
-      Contract.Assert(selectExpr != null);
-
-      VCExpr/*!*/ selectEq = Gen.Eq(selectExpr, selectWithoutStoreExpr);
-      Contract.Assert(selectEq != null);
-
-      List<VCExprVar/*!*/>/*!*/ quantifiedVars = new List<VCExprVar/*!*/>();
-      quantifiedVars.AddRange(freeTypeVars);
-      quantifiedVars.AddRange(boundTypeVars0);
-      quantifiedVars.AddRange(boundTypeVars1);
-      quantifiedVars.Add(val);
-      quantifiedVars.Add(m);
-      quantifiedVars.AddRange(indexes0);
-      quantifiedVars.AddRange(indexes1);
-
-      List<VCTrigger/*!*/>/*!*/ triggers = new List<VCTrigger/*!*/>();
-
-      // different value arguments or different type arguments are sufficient
-      // to conclude that that value of the map at some point (after an update)
-      // has not changed
-
-      List<VCExpr/*!*/>/*!*/ indexEqs = new List<VCExpr/*!*/>();
-      for (int i = 0; i < mapTypeParamNum; ++i)
-        indexEqs.Add(Gen.Eq(boundTypeVars0[i], boundTypeVars1[i]));
-      for (int i = 0; i < arity; ++i)
-        indexEqs.Add(Gen.Eq(indexes0[i], indexes1[i]));
-
-      VCExpr/*!*/ axiom = VCExpressionGenerator.True;
-      int n = 0;
-      foreach (VCExpr/*!*/ indexesEq in indexEqs) {
-        Contract.Assert(indexesEq != null);
-        VCExpr/*!*/ matrix = Gen.Or(indexesEq, selectEq);
-        Contract.Assert(matrix != null);
-        VCExpr/*!*/ conjunct = Gen.Forall(quantifiedVars, triggers, "mapAx1:" + select.Name + ":" + n, 0, matrix);
-        Contract.Assert(conjunct != null);
-        axiom = Gen.AndSimp(axiom, conjunct);
-        n = n + 1;
-      }
-
-      return axiom;
-    }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  public class TypeEraserArguments : TypeEraser {
-
-    private readonly TypeAxiomBuilderArguments/*!*/ AxBuilderArguments;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(AxBuilderArguments != null);
-    }
-
-
-    private OpTypeEraser OpEraserAttr = null;
-    protected override OpTypeEraser/*!*/ OpEraser {
-      get {
-        Contract.Ensures(Contract.Result<OpTypeEraser>() != null);
-
-        if (OpEraserAttr == null)
-          OpEraserAttr = new OpTypeEraserArguments(this, AxBuilderArguments, Gen);
-        return OpEraserAttr;
-      }
-    }
-
-    public TypeEraserArguments(TypeAxiomBuilderArguments axBuilder, VCExpressionGenerator gen) :base(axBuilder, gen){
-      Contract.Requires(gen != null);
-      Contract.Requires(axBuilder != null);
-      
-      this.AxBuilderArguments = axBuilder;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public override VCExpr Visit(VCExprQuantifier node, VariableBindings oldBindings) {
-      Contract.Requires(oldBindings != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VariableBindings/*!*/ bindings = oldBindings.Clone();
-
-      // bound term variables are replaced with bound term variables
-      // typed in a simpler way
-      List<VCExprVar/*!*/>/*!*/ newBoundVars =
-        BoundVarsAfterErasure(node.BoundVars, bindings);
-
-      // type variables are replaced with ordinary quantified variables
-      GenBoundVarsForTypeParams(node.TypeParameters, newBoundVars, bindings);
-      VCExpr/*!*/ newNode = HandleQuantifier(node, newBoundVars, bindings);
-      Contract.Assert(newNode != null);
-
-      if (!(newNode is VCExprQuantifier) || !IsUniversalQuantifier(node))
-        return newNode;
-
-      VariableBindings/*!*/ bindings2;
-      if (!RedoQuantifier(node, (VCExprQuantifier)newNode, node.BoundVars, oldBindings,
-                          out bindings2, out newBoundVars))
-        return newNode;
-
-      GenBoundVarsForTypeParams(node.TypeParameters, newBoundVars, bindings2);
-      return HandleQuantifier(node, newBoundVars, bindings2);
-    }
-
-    private void GenBoundVarsForTypeParams(List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ newBoundVars, VariableBindings bindings) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(cce.NonNullElements(typeParams));
-      Contract.Requires(cce.NonNullElements(newBoundVars));
-      foreach (TypeVariable/*!*/ tvar in typeParams) {
-        Contract.Assert(tvar != null);
-        VCExprVar/*!*/ var = Gen.Variable(tvar.Name, AxBuilder.T);
-        Contract.Assert(var != null);
-        newBoundVars.Add(var);
-        bindings.TypeVariableBindings.Add(tvar, var);
-      }
-    }
-
-    private VCExpr HandleQuantifier(VCExprQuantifier node, List<VCExprVar/*!*/>/*!*/ newBoundVars, VariableBindings bindings){
-Contract.Requires(bindings != null);
-Contract.Requires(node != null);
-Contract.Requires(cce.NonNullElements(newBoundVars));
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<VCTrigger/*!*/>/*!*/ newTriggers = MutateTriggers(node.Triggers, bindings);
-      Contract.Assert(cce.NonNullElements(newTriggers));
-      VCExpr/*!*/ newBody = Mutate(node.Body, bindings);
-      Contract.Assert(newBody != null);
-      newBody = AxBuilder.Cast(newBody, Type.Bool);
-
-      if (newBoundVars.Count == 0)  // might happen that no bound variables are left
-        return newBody;
-      return Gen.Quantify(node.Quan, new List<TypeVariable/*!*/>(), newBoundVars,
-                          newTriggers, node.Infos, newBody);
-    }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  public class OpTypeEraserArguments : OpTypeEraser {
-
-    protected readonly TypeAxiomBuilderArguments/*!*/ AxBuilderArguments;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(AxBuilderArguments != null);
-    }
-
-
-    public OpTypeEraserArguments(TypeEraserArguments eraser, TypeAxiomBuilderArguments axBuilder, VCExpressionGenerator gen) :base(eraser, axBuilder, gen){
-      Contract.Requires(gen != null);
-      Contract.Requires(axBuilder != null);
-      Contract.Requires(eraser != null);
-      this.AxBuilderArguments = axBuilder;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    private VCExpr AssembleOpExpression(OpTypesPair opTypes, IEnumerable<VCExpr/*!*/>/*!*/ oldArgs, VariableBindings bindings){
-Contract.Requires(bindings != null);
-Contract.Requires(cce.NonNullElements(oldArgs));
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      // UGLY: the code for tracking polarities should be factored out
-      int oldPolarity = Eraser.Polarity;
-      Eraser.Polarity = 0;
-
-      List<VCExpr/*!*/>/*!*/ newArgs = new List<VCExpr/*!*/> ();
-      // explicit type parameters
-      foreach (Type/*!*/ t in opTypes.Types){
-        Contract.Assert(newArgs != null);
-        newArgs.Add(AxBuilder.Type2Term(t, bindings.TypeVariableBindings));}
-      
-      // and the actual value parameters
-      Function/*!*/ newFun = ((VCExprBoogieFunctionOp)opTypes.Op).Func;
-                              // ^ we only allow this operator at this point
-      int i = opTypes.Types.Count;
-      foreach (VCExpr/*!*/ arg in oldArgs) {
-        Contract.Assert(arg != null);
-        newArgs.Add(AxBuilder.Cast(Eraser.Mutate(arg, bindings),
-                                   cce.NonNull(newFun.InParams[i]).TypedIdent.Type));
-        i = i + 1;
-      }
-
-      Eraser.Polarity = oldPolarity;
-      return Gen.Function(opTypes.Op, newArgs);
-    }
-
-    // for the time being, we store both the types of the arguments and the explicit
-    // type parameters (for most operators, this is more than actually necessary)
-    private OpTypesPair OriginalOpTypes(VCExprNAry node){
-Contract.Requires(node != null);
-      List<Type/*!*/>/*!*/ originalTypes = new List<Type/*!*/> ();
-      foreach (VCExpr/*!*/ expr in node) {
-        Contract.Assert(expr != null);
-        originalTypes.Add(expr.Type);
-      }
-      originalTypes.AddRange(node.TypeArguments);
-      return new OpTypesPair (node.Op, originalTypes);
-    }
-
-    private VCExpr EqualTypes(Type t0, Type t1, VariableBindings bindings){
-Contract.Requires(bindings != null);
-Contract.Requires(t1 != null);
-Contract.Requires(t0 != null);
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (t0.Equals(t1))
-        return VCExpressionGenerator.True;
-      VCExpr/*!*/ t0Expr = AxBuilder.Type2Term(t0, bindings.TypeVariableBindings);
-      Contract.Assert(t0Expr != null);
-      VCExpr/*!*/ t1Expr = AxBuilder.Type2Term(t1, bindings.TypeVariableBindings);
-      Contract.Assert(t1Expr != null);
-      return Gen.Eq(t0Expr, t1Expr);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    public override VCExpr VisitEqOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-Contract.Requires((node != null));
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      // we also have to state that the types are equal, because the
-      // translation does not contain any information about the
-      // relationship between values and types
-      return Gen.AndSimp(base.VisitEqOp(node, bindings),
-                         EqualTypes(node[0].Type, node[1].Type, bindings));
-    }
-
-    public override VCExpr VisitNeqOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires((bindings != null));
-Contract.Requires((node != null));
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      // we also have to state that the types are (un)equal, because the
-      // translation does not contain any information about the
-      // relationship between values and types
-      return Gen.OrSimp(base.VisitNeqOp(node, bindings),
-                        Gen.Not(EqualTypes(node[0].Type, node[1].Type, bindings)));
-    }
-
-    public override VCExpr VisitSubtypeOp(VCExprNAry node, VariableBindings bindings) {
-Contract.Requires((bindings != null));
-Contract.Requires((node != null));
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      // UGLY: the code for tracking polarities should be factored out
-      int oldPolarity = Eraser.Polarity;
-      Eraser.Polarity = 0;
-
-      VCExpr/*!*/ res =
-        Gen.Function(VCExpressionGenerator.Subtype3Op,
-                     AxBuilder.Type2Term(node[0].Type,
-                                         bindings.TypeVariableBindings),
-                     AxBuilder.Cast(Eraser.Mutate(node[0], bindings),
-                                    AxBuilder.U),
-                     AxBuilder.Cast(Eraser.Mutate(node[1], bindings),
-                                    AxBuilder.U));
-
-      Eraser.Polarity = oldPolarity;
-      return res;
-    }
-
-    public override VCExpr VisitSelectOp(VCExprNAry node, VariableBindings bindings) {
-Contract.Requires((bindings != null));
-Contract.Requires((node != null));
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      OpTypesPair originalOpTypes = OriginalOpTypes(node);
-      OpTypesPair newOpTypes;
-
-      if (!NewOpCache.TryGetValue(originalOpTypes, out newOpTypes)) {
-        MapType/*!*/ rawType = node[0].Type.AsMap;
-        Contract.Assert(rawType != null);
-        List<Type>/*!*/ abstractionInstantiation;
-        Function/*!*/ select =
-          AxBuilder.MapTypeAbstracter.Select(rawType, out abstractionInstantiation);
-        Contract.Assert(abstractionInstantiation != null);
-        newOpTypes = TypesPairForSelectStore(node, select, abstractionInstantiation);
-        NewOpCache.Add(originalOpTypes, newOpTypes);
-      }
-
-      return AssembleOpExpression(newOpTypes, node, bindings);
-    }
-
-    public override VCExpr VisitStoreOp(VCExprNAry node, VariableBindings bindings) {
-Contract.Requires((bindings != null));
-Contract.Requires((node != null));
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      OpTypesPair originalOpTypes = OriginalOpTypes(node);
-      OpTypesPair newOpTypes;
-
-      if (!NewOpCache.TryGetValue(originalOpTypes, out newOpTypes)) {
-        MapType/*!*/ rawType = node[0].Type.AsMap;
-        List<Type>/*!*/ abstractionInstantiation;
-        Function/*!*/ store =
-          AxBuilder.MapTypeAbstracter.Store(rawType, out abstractionInstantiation);
-
-        newOpTypes = TypesPairForSelectStore(node, store, abstractionInstantiation);
-        NewOpCache.Add(originalOpTypes, newOpTypes);
-      }
-
-      return AssembleOpExpression(newOpTypes, node, bindings);
-    }
-
-    private OpTypesPair TypesPairForSelectStore(VCExprNAry/*!*/ node, Function/*!*/ untypedOp,
-      // instantiation of the abstract map type parameters
-                                                List<Type>/*!*/ abstractionInstantiation) {
-      Contract.Requires(node != null);
-      Contract.Requires(untypedOp != null);
-      Contract.Requires(abstractionInstantiation != null);
-
-      List<Type/*!*/>/*!*/ inferredTypeArgs = new List<Type/*!*/> ();
-      foreach (Type/*!*/ t in node.TypeArguments){Contract.Assert(t != null);
-//        inferredTypeArgs.Add(AxBuilder.MapTypeAbstracter.AbstractMapTypeRecursively(t));
-        inferredTypeArgs.Add(t);}
-      foreach (Type/*!*/ t in abstractionInstantiation) {
-        Contract.Assert(t != null);
-        inferredTypeArgs.Add(t);}
-
-      Contract.Assert(untypedOp.InParams.Count == inferredTypeArgs.Count + node.Arity);
-      return new OpTypesPair (Gen.BoogieFunctionOp(untypedOp), inferredTypeArgs);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    public override VCExpr VisitBoogieFunctionOp(VCExprNAry node, VariableBindings bindings) {
-Contract.Requires((bindings != null));
-Contract.Requires((node != null));
-Contract.Ensures(Contract.Result<VCExpr>() != null);
-      OpTypesPair originalOpTypes = OriginalOpTypes(node);
-      OpTypesPair newOpTypes;
-
-      if (!NewOpCache.TryGetValue(originalOpTypes, out newOpTypes)) {
-        Function/*!*/ oriFun = ((VCExprBoogieFunctionOp)node.Op).Func;
-        Contract.Assert(oriFun != null);
-        List<Type/*!*/>/*!*/ inferredTypeArgs = new List<Type/*!*/> ();
-        foreach (Type/*!*/ t in node.TypeArguments){Contract.Assert(t != null);
-//          inferredTypeArgs.Add(AxBuilder.MapTypeAbstracter.AbstractMapTypeRecursively(t));
-          inferredTypeArgs.Add(t);}
-
-        VCExprOp/*!*/ newOp = Gen.BoogieFunctionOp(AxBuilderArguments.Typed2Untyped(oriFun));
-        newOpTypes = new OpTypesPair (newOp, inferredTypeArgs);
-
-        NewOpCache.Add(originalOpTypes, newOpTypes);
-      }
-
-      return AssembleOpExpression(newOpTypes, node, bindings);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    // cache from the typed operators to the untyped operators with
-    // explicit type arguments. the keys are pairs of the typed
-    // operator and the actual types of the argument expressions, the
-    // values are pairs of the new operators and the types that have
-    // to be given as explicit type arguments
-    private readonly IDictionary<OpTypesPair, OpTypesPair>/*!*/ NewOpCache =
-      new Dictionary<OpTypesPair, OpTypesPair>();
-
-    private struct OpTypesPair {
-      public readonly VCExprOp/*!*/ Op;
-      public readonly List<Type/*!*/>/*!*/ Types;
-      [ContractInvariantMethod]
-      void ObjectInvariant() {
-        Contract.Invariant(Op != null);
-        Contract.Invariant(cce.NonNullElements(Types));
-      }
-
-
-      public OpTypesPair(VCExprOp op, List<Type/*!*/>/*!*/ types) {
-        Contract.Requires(op != null);
-        Contract.Requires(cce.NonNullElements(types));
-        this.Op = op;
-        this.Types = types;
-        this.HashCode = HFNS.PolyHash(op.GetHashCode(), 17, types);
-      }
-
-      [Pure]
-      [Reads(ReadsAttribute.Reads.Nothing)]
-      public override bool Equals(object that) {
-        if (that is OpTypesPair) {
-          OpTypesPair thatPair = (OpTypesPair)that;
-          return this.Op.Equals(thatPair.Op) &&
-            HFNS.SameElements(this.Types, thatPair.Types);
-        }
-        return false;
-      }
-
-      private readonly int HashCode;
-
-      [Pure]
-      public override int GetHashCode() {
-        return HashCode;
-      }
-    }
-  }
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+using Microsoft.Boogie.VCExprAST;
+
+// Erasure of types using explicit type parameters for functions
+
+namespace Microsoft.Boogie.TypeErasure {
+  using Microsoft.Boogie.VCExprAST;
+  using HFNS = Microsoft.Boogie.VCExprAST.HelperFuns;
+
+  public class TypeAxiomBuilderArguments : TypeAxiomBuilderIntBoolU {
+
+    public TypeAxiomBuilderArguments(VCExpressionGenerator gen)
+      : base(gen) {
+      Contract.Requires(gen != null);
+
+      Typed2UntypedFunctions = new Dictionary<Function/*!*/, Function/*!*/>();
+    }
+
+    // constructor to allow cloning
+    [NotDelayed]
+    internal TypeAxiomBuilderArguments(TypeAxiomBuilderArguments builder)
+      : base(builder) {
+      Contract.Requires(builder != null);
+      Typed2UntypedFunctions =
+        new Dictionary<Function/*!*/, Function/*!*/>(builder.Typed2UntypedFunctions);
+
+
+      MapTypeAbstracterAttr =
+        builder.MapTypeAbstracterAttr == null ?
+        null : new MapTypeAbstractionBuilderArguments(this, builder.Gen,
+                                                      builder.MapTypeAbstracterAttr);
+    }
+
+    public override Object Clone() {
+      Contract.Ensures(Contract.Result<Object>() != null);
+      return new TypeAxiomBuilderArguments(this);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////    
+
+    // generate axioms of the kind "forall x:U. {Int2U(U2Int(x))} Int2U(U2Int(x))==x"
+    // (this makes use of the assumption that only well-typed terms are generated
+    // by the SMT-solver, i.e., that U2Int is only applied to terms that actually
+    // are of type int)
+    protected override VCExpr GenReverseCastAxiom(Function castToU, Function castFromU) {
+      //Contract.Requires(castFromU != null);
+      //Contract.Requires(castToU != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<VCTrigger/*!*/>/*!*/ triggers;
+      VCExprVar/*!*/ var;
+      VCExpr/*!*/ eq = GenReverseCastEq(castToU, castFromU, out var, out triggers);
+      return Gen.Forall(HelperFuns.ToList(var), triggers, "cast:" + castFromU.Name, -1, eq);
+    }
+
+    protected override VCExpr GenCastTypeAxioms(Function castToU, Function castFromU) {
+      //Contract.Requires(castFromU != null);
+      //Contract.Requires(castToU != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      // nothing
+      return VCExpressionGenerator.True;
+    }
+
+    private MapTypeAbstractionBuilderArguments MapTypeAbstracterAttr = null;
+
+    internal override MapTypeAbstractionBuilder/*!*/ MapTypeAbstracter {
+      get {
+        Contract.Ensures(Contract.Result<MapTypeAbstractionBuilder>() != null);
+
+        if (MapTypeAbstracterAttr == null)
+          MapTypeAbstracterAttr = new MapTypeAbstractionBuilderArguments(this, Gen);
+        return MapTypeAbstracterAttr;
+      }
+    }
+
+    protected override void AddVarTypeAxiom(VCExprVar var, Type originalType) {
+      //Contract.Requires(originalType != null);
+      //Contract.Requires(var != null);
+      // no axioms are needed for variable or function types
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Symbols for representing functions
+
+    // Globally defined functions
+    private readonly IDictionary<Function/*!*/, Function/*!*/>/*!*/ Typed2UntypedFunctions;
+    [ContractInvariantMethod]
+    void Typed2UntypedFunctionsInvariantMethod() {
+      Contract.Invariant(cce.NonNullDictionaryAndValues(Typed2UntypedFunctions));
+    }
+
+    public Function Typed2Untyped(Function fun) {
+      Contract.Requires(fun != null);
+      Contract.Ensures(Contract.Result<Function>() != null);
+      Function res;
+      if (!Typed2UntypedFunctions.TryGetValue(fun, out res)) {
+        Contract.Assert(fun.OutParams.Count == 1);
+
+        // if all of the parameters are int or bool, the function does
+        // not have to be changed
+        if (fun.InParams.All(param => UnchangedType(cce.NonNull(param).TypedIdent.Type)) &&
+            UnchangedType(cce.NonNull(fun.OutParams[0]).TypedIdent.Type)) {
+          res = fun;
+        } else {
+          Type[]/*!*/ types = new Type[fun.TypeParameters.Count + fun.InParams.Count + 1];
+
+          int i = 0;
+          // the first arguments are the explicit type parameters
+          for (int j = 0; j < fun.TypeParameters.Count; ++j) {
+            types[i] = T;
+            i = i + 1;
+          }
+          // followed by the actual parameters
+          foreach (Variable/*!*/ x in fun.InParams) {
+            Contract.Assert(x != null);
+            types[i] = TypeAfterErasure(x.TypedIdent.Type);
+            i = i + 1;
+          }
+
+          types[types.Length - 1] = TypeAfterErasure(cce.NonNull(fun.OutParams[0]).TypedIdent.Type);
+
+          res = HelperFuns.BoogieFunction(fun.Name, types);
+          res.Attributes = fun.Attributes;
+        }
+
+        Typed2UntypedFunctions.Add(fun, res);
+      }
+      return cce.NonNull(res);
+    }
+
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  internal class MapTypeAbstractionBuilderArguments : MapTypeAbstractionBuilder {
+
+    private readonly TypeAxiomBuilderArguments/*!*/ AxBuilderArguments;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(AxBuilderArguments != null);
+    }
+
+
+    internal MapTypeAbstractionBuilderArguments(TypeAxiomBuilderArguments axBuilder, VCExpressionGenerator gen)
+      : base(axBuilder, gen) {
+      Contract.Requires(gen != null);
+      Contract.Requires(axBuilder != null);
+
+      this.AxBuilderArguments = axBuilder;
+    }
+
+    // constructor for cloning
+    internal MapTypeAbstractionBuilderArguments(TypeAxiomBuilderArguments axBuilder, VCExpressionGenerator gen, MapTypeAbstractionBuilderArguments builder)
+      : base(axBuilder, gen, builder) {
+      Contract.Requires(builder != null);
+      Contract.Requires(gen != null);
+      Contract.Requires(axBuilder != null);
+      this.AxBuilderArguments = axBuilder;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    protected override void GenSelectStoreFunctions(MapType abstractedType, TypeCtorDecl synonym, out Function/*!*/ select, out Function/*!*/ store) {
+      //Contract.Requires(synonym != null);
+//Contract.Requires(abstractedType != null);
+Contract.Ensures(Contract.ValueAtReturn(out select) != null);
+Contract.Ensures(Contract.ValueAtReturn(out store) != null);
+      Contract.Assert(synonym.Name != null);
+      string/*!*/ baseName = synonym.Name;
+      int typeParamNum = abstractedType.FreeVariables.Count +
+                         abstractedType.TypeParameters.Count;
+
+      int arity = typeParamNum + abstractedType.Arguments.Count;
+
+      Type/*!*/[]/*!*/ selectTypes = new Type/*!*/ [arity + 2];
+      Type/*!*/[]/*!*/ storeTypes = new Type/*!*/ [arity + 3];
+
+      int i = 0;
+      // Fill in the free variables and type parameters
+      for (; i < typeParamNum; i++) {
+        selectTypes[i] = AxBuilder.T;
+        storeTypes[i] = AxBuilder.T;
+      }
+      // Fill in the map type
+      if (CommandLineOptions.Clo.MonomorphicArrays) {
+        selectTypes[i] = abstractedType;
+        storeTypes[i] = abstractedType;
+      } else {
+        selectTypes[i] = AxBuilder.U;
+        storeTypes[i] = AxBuilder.U;
+      }
+      i++;
+      // Fill in the index types
+      foreach (Type/*!*/ type in abstractedType.Arguments) {
+        Contract.Assert(type != null);
+        if (CommandLineOptions.Clo.Monomorphize && AxBuilder.UnchangedType(type)) {
+          selectTypes[i] = type;
+          storeTypes[i] = type;
+        } else {
+          selectTypes[i] = AxBuilder.U;
+          storeTypes[i] = AxBuilder.U;
+        }
+        i++;
+      }
+      // Fill in the output type for select function which also happens 
+      // to be the type of the last argument to the store function
+      if (CommandLineOptions.Clo.Monomorphize && AxBuilder.UnchangedType(abstractedType.Result)) {
+        selectTypes[i] = abstractedType.Result;
+        storeTypes[i] = abstractedType.Result;
+      } else {
+        selectTypes[i] = AxBuilder.U;
+        storeTypes[i] = AxBuilder.U;
+      }
+      i++;
+      // Fill in the map type which is the output of the store function
+      if (CommandLineOptions.Clo.MonomorphicArrays)
+        storeTypes[i] = abstractedType;
+      else
+        storeTypes[i] = AxBuilder.U;
+      Contract.Assert(cce.NonNullElements<Type>(selectTypes));
+      Contract.Assert(cce.NonNullElements<Type>(storeTypes));
+
+      select = HelperFuns.BoogieFunction(baseName + "Select", selectTypes);
+      store = HelperFuns.BoogieFunction(baseName + "Store", storeTypes);
+
+      if (CommandLineOptions.Clo.UseArrayTheory) {
+        select.AddAttribute("builtin", "select");
+        store.AddAttribute("builtin", "store");
+      } else {
+        AxBuilder.AddTypeAxiom(GenMapAxiom0(select, store,
+                 abstractedType.TypeParameters.Count, abstractedType.FreeVariables.Count));
+        AxBuilder.AddTypeAxiom(GenMapAxiom1(select, store,
+                 abstractedType.TypeParameters.Count, abstractedType.FreeVariables.Count));
+      }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // The normal axioms of the theory of arrays (right now without extensionality)
+
+    private VCExpr Select(Function select, List<VCExprVar/*!*/>/*!*/ types, VCExpr map, List<VCExprVar/*!*/>/*!*/ indexes) {
+      Contract.Requires(map != null);
+      Contract.Requires(select != null);
+      Contract.Requires(cce.NonNullElements(indexes));
+      Contract.Requires(cce.NonNullElements(types));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<VCExpr/*!*/>/*!*/ selectArgs = new List<VCExpr/*!*/>();
+      selectArgs.AddRange(HelperFuns.ToVCExprList(types));
+      selectArgs.Add(map);
+      selectArgs.AddRange(HelperFuns.ToVCExprList(indexes));
+      return Gen.Function(select, selectArgs);
+    }
+
+    private VCExpr Store(Function store, List<VCExprVar/*!*/>/*!*/ types, VCExpr map, List<VCExprVar/*!*/>/*!*/ indexes, VCExpr val) {
+      Contract.Requires(val != null);
+      Contract.Requires(map != null);
+      Contract.Requires(store != null);
+      Contract.Requires(cce.NonNullElements(indexes));
+      Contract.Requires(cce.NonNullElements(types));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<VCExpr/*!*/>/*!*/ storeArgs = new List<VCExpr/*!*/>();
+      storeArgs.AddRange(HelperFuns.ToVCExprList(types));
+      storeArgs.Add(map);
+      storeArgs.AddRange(HelperFuns.ToVCExprList(indexes));
+      storeArgs.Add(val);
+      return Gen.Function(store, storeArgs);
+    }
+
+    private VCExpr/*!*/ GenMapAxiom0(Function/*!*/ select, Function/*!*/ store,
+      // bound type variables in the map type
+                                 int mapTypeParamNum,
+      // free type variables in the map
+      // type (abstraction)
+                                 int mapAbstractionVarNum) {
+      Contract.Requires(select != null);
+      Contract.Requires(store != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      int arity = select.InParams.Count - 1 - mapTypeParamNum - mapAbstractionVarNum;
+      List<VCExprVar/*!*/>/*!*/ types =
+        HelperFuns.VarVector("t", mapTypeParamNum + mapAbstractionVarNum,
+                             AxBuilder.T, Gen);
+
+      List<Type/*!*/> indexTypes = new List<Type/*!*/>();
+      for (int i = mapTypeParamNum + mapAbstractionVarNum + 1; i < select.InParams.Count; i++) {
+        indexTypes.Add(cce.NonNull(select.InParams[i]).TypedIdent.Type);
+      }
+      Contract.Assert(arity == indexTypes.Count);
+
+      List<VCExprVar/*!*/>/*!*/ indexes = HelperFuns.VarVector("x", indexTypes, Gen);
+
+      VCExprVar/*!*/ m = Gen.Variable("m", AxBuilder.U);
+      Contract.Assert(m != null);
+      VCExprVar/*!*/ val = Gen.Variable("val", cce.NonNull(select.OutParams[0]).TypedIdent.Type);
+      Contract.Assert(val != null);
+
+      VCExpr/*!*/ storeExpr = Store(store, types, m, indexes, val);
+      Contract.Assert(storeExpr != null);
+      VCExpr/*!*/ selectExpr = Select(select, types, storeExpr, indexes);
+      Contract.Assert(selectExpr != null);
+
+      List<VCExprVar/*!*/>/*!*/ quantifiedVars = new List<VCExprVar/*!*/>();
+      quantifiedVars.AddRange(types);
+      quantifiedVars.Add(val);
+      quantifiedVars.Add(m);
+      quantifiedVars.AddRange(indexes);
+
+      VCExpr/*!*/ eq = Gen.Eq(selectExpr, val);
+      Contract.Assert(eq != null);
+      return Gen.Forall(quantifiedVars, new List<VCTrigger/*!*/>(), "mapAx0:" + select.Name, 0, eq);
+    }
+
+    private VCExpr/*!*/ GenMapAxiom1(Function/*!*/ select, Function/*!*/ store,
+      // bound type variables in the map
+      // type
+                                 int mapTypeParamNum,
+      // free type variables in the map
+      // type (abstraction)
+                                 int mapAbstractionVarNum) {
+      Contract.Requires(select != null);
+      Contract.Requires(store != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      int arity = select.InParams.Count - 1 - mapTypeParamNum - mapAbstractionVarNum;
+
+      List<VCExprVar/*!*/>/*!*/ freeTypeVars =
+        HelperFuns.VarVector("u", mapAbstractionVarNum, AxBuilder.T, Gen);
+      List<VCExprVar/*!*/>/*!*/ boundTypeVars0 =
+        HelperFuns.VarVector("s", mapTypeParamNum, AxBuilder.T, Gen);
+      List<VCExprVar/*!*/>/*!*/ boundTypeVars1 =
+        HelperFuns.VarVector("t", mapTypeParamNum, AxBuilder.T, Gen);
+
+      List<VCExprVar/*!*/>/*!*/ types0 = new List<VCExprVar/*!*/>(boundTypeVars0);
+      types0.AddRange(freeTypeVars);
+
+      List<VCExprVar/*!*/>/*!*/ types1 = new List<VCExprVar/*!*/>(boundTypeVars1);
+      types1.AddRange(freeTypeVars);
+
+      List<Type/*!*/> indexTypes = new List<Type/*!*/>();
+      for (int i = mapTypeParamNum + mapAbstractionVarNum + 1; i < select.InParams.Count; i++) {
+        indexTypes.Add(cce.NonNull(select.InParams[i]).TypedIdent.Type);
+      }
+      Contract.Assert(arity == indexTypes.Count);
+
+      List<VCExprVar/*!*/>/*!*/ indexes0 = HelperFuns.VarVector("x", indexTypes, Gen);
+      List<VCExprVar/*!*/>/*!*/ indexes1 = HelperFuns.VarVector("y", indexTypes, Gen);
+
+      VCExprVar/*!*/ m = Gen.Variable("m", AxBuilder.U);
+      Contract.Assert(m != null);
+      VCExprVar/*!*/ val = Gen.Variable("val", cce.NonNull(select.OutParams[0]).TypedIdent.Type);
+      Contract.Assert(val != null);
+
+      VCExpr/*!*/ storeExpr = Store(store, types0, m, indexes0, val);
+      Contract.Assert(storeExpr != null);
+      VCExpr/*!*/ selectWithoutStoreExpr = Select(select, types1, m, indexes1);
+      Contract.Assert(selectWithoutStoreExpr != null);
+      VCExpr/*!*/ selectExpr = Select(select, types1, storeExpr, indexes1);
+      Contract.Assert(selectExpr != null);
+
+      VCExpr/*!*/ selectEq = Gen.Eq(selectExpr, selectWithoutStoreExpr);
+      Contract.Assert(selectEq != null);
+
+      List<VCExprVar/*!*/>/*!*/ quantifiedVars = new List<VCExprVar/*!*/>();
+      quantifiedVars.AddRange(freeTypeVars);
+      quantifiedVars.AddRange(boundTypeVars0);
+      quantifiedVars.AddRange(boundTypeVars1);
+      quantifiedVars.Add(val);
+      quantifiedVars.Add(m);
+      quantifiedVars.AddRange(indexes0);
+      quantifiedVars.AddRange(indexes1);
+
+      List<VCTrigger/*!*/>/*!*/ triggers = new List<VCTrigger/*!*/>();
+
+      // different value arguments or different type arguments are sufficient
+      // to conclude that that value of the map at some point (after an update)
+      // has not changed
+
+      List<VCExpr/*!*/>/*!*/ indexEqs = new List<VCExpr/*!*/>();
+      for (int i = 0; i < mapTypeParamNum; ++i)
+        indexEqs.Add(Gen.Eq(boundTypeVars0[i], boundTypeVars1[i]));
+      for (int i = 0; i < arity; ++i)
+        indexEqs.Add(Gen.Eq(indexes0[i], indexes1[i]));
+
+      VCExpr/*!*/ axiom = VCExpressionGenerator.True;
+      int n = 0;
+      foreach (VCExpr/*!*/ indexesEq in indexEqs) {
+        Contract.Assert(indexesEq != null);
+        VCExpr/*!*/ matrix = Gen.Or(indexesEq, selectEq);
+        Contract.Assert(matrix != null);
+        VCExpr/*!*/ conjunct = Gen.Forall(quantifiedVars, triggers, "mapAx1:" + select.Name + ":" + n, 0, matrix);
+        Contract.Assert(conjunct != null);
+        axiom = Gen.AndSimp(axiom, conjunct);
+        n = n + 1;
+      }
+
+      return axiom;
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  public class TypeEraserArguments : TypeEraser {
+
+    private readonly TypeAxiomBuilderArguments/*!*/ AxBuilderArguments;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(AxBuilderArguments != null);
+    }
+
+
+    private OpTypeEraser OpEraserAttr = null;
+    protected override OpTypeEraser/*!*/ OpEraser {
+      get {
+        Contract.Ensures(Contract.Result<OpTypeEraser>() != null);
+
+        if (OpEraserAttr == null)
+          OpEraserAttr = new OpTypeEraserArguments(this, AxBuilderArguments, Gen);
+        return OpEraserAttr;
+      }
+    }
+
+    public TypeEraserArguments(TypeAxiomBuilderArguments axBuilder, VCExpressionGenerator gen) :base(axBuilder, gen){
+      Contract.Requires(gen != null);
+      Contract.Requires(axBuilder != null);
+      
+      this.AxBuilderArguments = axBuilder;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public override VCExpr Visit(VCExprQuantifier node, VariableBindings oldBindings) {
+      Contract.Requires(oldBindings != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VariableBindings/*!*/ bindings = oldBindings.Clone();
+
+      // bound term variables are replaced with bound term variables
+      // typed in a simpler way
+      List<VCExprVar/*!*/>/*!*/ newBoundVars =
+        BoundVarsAfterErasure(node.BoundVars, bindings);
+
+      // type variables are replaced with ordinary quantified variables
+      GenBoundVarsForTypeParams(node.TypeParameters, newBoundVars, bindings);
+      VCExpr/*!*/ newNode = HandleQuantifier(node, newBoundVars, bindings);
+      Contract.Assert(newNode != null);
+
+      if (!(newNode is VCExprQuantifier) || !IsUniversalQuantifier(node))
+        return newNode;
+
+      VariableBindings/*!*/ bindings2;
+      if (!RedoQuantifier(node, (VCExprQuantifier)newNode, node.BoundVars, oldBindings,
+                          out bindings2, out newBoundVars))
+        return newNode;
+
+      GenBoundVarsForTypeParams(node.TypeParameters, newBoundVars, bindings2);
+      return HandleQuantifier(node, newBoundVars, bindings2);
+    }
+
+    private void GenBoundVarsForTypeParams(List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ newBoundVars, VariableBindings bindings) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(cce.NonNullElements(typeParams));
+      Contract.Requires(cce.NonNullElements(newBoundVars));
+      foreach (TypeVariable/*!*/ tvar in typeParams) {
+        Contract.Assert(tvar != null);
+        VCExprVar/*!*/ var = Gen.Variable(tvar.Name, AxBuilder.T);
+        Contract.Assert(var != null);
+        newBoundVars.Add(var);
+        bindings.TypeVariableBindings.Add(tvar, var);
+      }
+    }
+
+    private VCExpr HandleQuantifier(VCExprQuantifier node, List<VCExprVar/*!*/>/*!*/ newBoundVars, VariableBindings bindings){
+Contract.Requires(bindings != null);
+Contract.Requires(node != null);
+Contract.Requires(cce.NonNullElements(newBoundVars));
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<VCTrigger/*!*/>/*!*/ newTriggers = MutateTriggers(node.Triggers, bindings);
+      Contract.Assert(cce.NonNullElements(newTriggers));
+      VCExpr/*!*/ newBody = Mutate(node.Body, bindings);
+      Contract.Assert(newBody != null);
+      newBody = AxBuilder.Cast(newBody, Type.Bool);
+
+      if (newBoundVars.Count == 0)  // might happen that no bound variables are left
+        return newBody;
+      return Gen.Quantify(node.Quan, new List<TypeVariable/*!*/>(), newBoundVars,
+                          newTriggers, node.Infos, newBody);
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  public class OpTypeEraserArguments : OpTypeEraser {
+
+    protected readonly TypeAxiomBuilderArguments/*!*/ AxBuilderArguments;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(AxBuilderArguments != null);
+    }
+
+
+    public OpTypeEraserArguments(TypeEraserArguments eraser, TypeAxiomBuilderArguments axBuilder, VCExpressionGenerator gen) :base(eraser, axBuilder, gen){
+      Contract.Requires(gen != null);
+      Contract.Requires(axBuilder != null);
+      Contract.Requires(eraser != null);
+      this.AxBuilderArguments = axBuilder;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    private VCExpr AssembleOpExpression(OpTypesPair opTypes, IEnumerable<VCExpr/*!*/>/*!*/ oldArgs, VariableBindings bindings){
+Contract.Requires(bindings != null);
+Contract.Requires(cce.NonNullElements(oldArgs));
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      // UGLY: the code for tracking polarities should be factored out
+      int oldPolarity = Eraser.Polarity;
+      Eraser.Polarity = 0;
+
+      List<VCExpr/*!*/>/*!*/ newArgs = new List<VCExpr/*!*/> ();
+      // explicit type parameters
+      foreach (Type/*!*/ t in opTypes.Types){
+        Contract.Assert(newArgs != null);
+        newArgs.Add(AxBuilder.Type2Term(t, bindings.TypeVariableBindings));}
+      
+      // and the actual value parameters
+      Function/*!*/ newFun = ((VCExprBoogieFunctionOp)opTypes.Op).Func;
+                              // ^ we only allow this operator at this point
+      int i = opTypes.Types.Count;
+      foreach (VCExpr/*!*/ arg in oldArgs) {
+        Contract.Assert(arg != null);
+        newArgs.Add(AxBuilder.Cast(Eraser.Mutate(arg, bindings),
+                                   cce.NonNull(newFun.InParams[i]).TypedIdent.Type));
+        i = i + 1;
+      }
+
+      Eraser.Polarity = oldPolarity;
+      return Gen.Function(opTypes.Op, newArgs);
+    }
+
+    // for the time being, we store both the types of the arguments and the explicit
+    // type parameters (for most operators, this is more than actually necessary)
+    private OpTypesPair OriginalOpTypes(VCExprNAry node){
+Contract.Requires(node != null);
+      List<Type/*!*/>/*!*/ originalTypes = new List<Type/*!*/> ();
+      foreach (VCExpr/*!*/ expr in node) {
+        Contract.Assert(expr != null);
+        originalTypes.Add(expr.Type);
+      }
+      originalTypes.AddRange(node.TypeArguments);
+      return new OpTypesPair (node.Op, originalTypes);
+    }
+
+    private VCExpr EqualTypes(Type t0, Type t1, VariableBindings bindings){
+Contract.Requires(bindings != null);
+Contract.Requires(t1 != null);
+Contract.Requires(t0 != null);
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (t0.Equals(t1))
+        return VCExpressionGenerator.True;
+      VCExpr/*!*/ t0Expr = AxBuilder.Type2Term(t0, bindings.TypeVariableBindings);
+      Contract.Assert(t0Expr != null);
+      VCExpr/*!*/ t1Expr = AxBuilder.Type2Term(t1, bindings.TypeVariableBindings);
+      Contract.Assert(t1Expr != null);
+      return Gen.Eq(t0Expr, t1Expr);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    public override VCExpr VisitEqOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+Contract.Requires((node != null));
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      // we also have to state that the types are equal, because the
+      // translation does not contain any information about the
+      // relationship between values and types
+      return Gen.AndSimp(base.VisitEqOp(node, bindings),
+                         EqualTypes(node[0].Type, node[1].Type, bindings));
+    }
+
+    public override VCExpr VisitNeqOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires((bindings != null));
+Contract.Requires((node != null));
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      // we also have to state that the types are (un)equal, because the
+      // translation does not contain any information about the
+      // relationship between values and types
+      return Gen.OrSimp(base.VisitNeqOp(node, bindings),
+                        Gen.Not(EqualTypes(node[0].Type, node[1].Type, bindings)));
+    }
+
+    public override VCExpr VisitSubtypeOp(VCExprNAry node, VariableBindings bindings) {
+Contract.Requires((bindings != null));
+Contract.Requires((node != null));
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      // UGLY: the code for tracking polarities should be factored out
+      int oldPolarity = Eraser.Polarity;
+      Eraser.Polarity = 0;
+
+      VCExpr/*!*/ res =
+        Gen.Function(VCExpressionGenerator.Subtype3Op,
+                     AxBuilder.Type2Term(node[0].Type,
+                                         bindings.TypeVariableBindings),
+                     AxBuilder.Cast(Eraser.Mutate(node[0], bindings),
+                                    AxBuilder.U),
+                     AxBuilder.Cast(Eraser.Mutate(node[1], bindings),
+                                    AxBuilder.U));
+
+      Eraser.Polarity = oldPolarity;
+      return res;
+    }
+
+    public override VCExpr VisitSelectOp(VCExprNAry node, VariableBindings bindings) {
+Contract.Requires((bindings != null));
+Contract.Requires((node != null));
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      OpTypesPair originalOpTypes = OriginalOpTypes(node);
+      OpTypesPair newOpTypes;
+
+      if (!NewOpCache.TryGetValue(originalOpTypes, out newOpTypes)) {
+        MapType/*!*/ rawType = node[0].Type.AsMap;
+        Contract.Assert(rawType != null);
+        List<Type>/*!*/ abstractionInstantiation;
+        Function/*!*/ select =
+          AxBuilder.MapTypeAbstracter.Select(rawType, out abstractionInstantiation);
+        Contract.Assert(abstractionInstantiation != null);
+        newOpTypes = TypesPairForSelectStore(node, select, abstractionInstantiation);
+        NewOpCache.Add(originalOpTypes, newOpTypes);
+      }
+
+      return AssembleOpExpression(newOpTypes, node, bindings);
+    }
+
+    public override VCExpr VisitStoreOp(VCExprNAry node, VariableBindings bindings) {
+Contract.Requires((bindings != null));
+Contract.Requires((node != null));
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      OpTypesPair originalOpTypes = OriginalOpTypes(node);
+      OpTypesPair newOpTypes;
+
+      if (!NewOpCache.TryGetValue(originalOpTypes, out newOpTypes)) {
+        MapType/*!*/ rawType = node[0].Type.AsMap;
+        List<Type>/*!*/ abstractionInstantiation;
+        Function/*!*/ store =
+          AxBuilder.MapTypeAbstracter.Store(rawType, out abstractionInstantiation);
+
+        newOpTypes = TypesPairForSelectStore(node, store, abstractionInstantiation);
+        NewOpCache.Add(originalOpTypes, newOpTypes);
+      }
+
+      return AssembleOpExpression(newOpTypes, node, bindings);
+    }
+
+    private OpTypesPair TypesPairForSelectStore(VCExprNAry/*!*/ node, Function/*!*/ untypedOp,
+      // instantiation of the abstract map type parameters
+                                                List<Type>/*!*/ abstractionInstantiation) {
+      Contract.Requires(node != null);
+      Contract.Requires(untypedOp != null);
+      Contract.Requires(abstractionInstantiation != null);
+
+      List<Type/*!*/>/*!*/ inferredTypeArgs = new List<Type/*!*/> ();
+      foreach (Type/*!*/ t in node.TypeArguments){Contract.Assert(t != null);
+//        inferredTypeArgs.Add(AxBuilder.MapTypeAbstracter.AbstractMapTypeRecursively(t));
+        inferredTypeArgs.Add(t);}
+      foreach (Type/*!*/ t in abstractionInstantiation) {
+        Contract.Assert(t != null);
+        inferredTypeArgs.Add(t);}
+
+      Contract.Assert(untypedOp.InParams.Count == inferredTypeArgs.Count + node.Arity);
+      return new OpTypesPair (Gen.BoogieFunctionOp(untypedOp), inferredTypeArgs);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    public override VCExpr VisitBoogieFunctionOp(VCExprNAry node, VariableBindings bindings) {
+Contract.Requires((bindings != null));
+Contract.Requires((node != null));
+Contract.Ensures(Contract.Result<VCExpr>() != null);
+      OpTypesPair originalOpTypes = OriginalOpTypes(node);
+      OpTypesPair newOpTypes;
+
+      if (!NewOpCache.TryGetValue(originalOpTypes, out newOpTypes)) {
+        Function/*!*/ oriFun = ((VCExprBoogieFunctionOp)node.Op).Func;
+        Contract.Assert(oriFun != null);
+        List<Type/*!*/>/*!*/ inferredTypeArgs = new List<Type/*!*/> ();
+        foreach (Type/*!*/ t in node.TypeArguments){Contract.Assert(t != null);
+//          inferredTypeArgs.Add(AxBuilder.MapTypeAbstracter.AbstractMapTypeRecursively(t));
+          inferredTypeArgs.Add(t);}
+
+        VCExprOp/*!*/ newOp = Gen.BoogieFunctionOp(AxBuilderArguments.Typed2Untyped(oriFun));
+        newOpTypes = new OpTypesPair (newOp, inferredTypeArgs);
+
+        NewOpCache.Add(originalOpTypes, newOpTypes);
+      }
+
+      return AssembleOpExpression(newOpTypes, node, bindings);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    // cache from the typed operators to the untyped operators with
+    // explicit type arguments. the keys are pairs of the typed
+    // operator and the actual types of the argument expressions, the
+    // values are pairs of the new operators and the types that have
+    // to be given as explicit type arguments
+    private readonly IDictionary<OpTypesPair, OpTypesPair>/*!*/ NewOpCache =
+      new Dictionary<OpTypesPair, OpTypesPair>();
+
+    private struct OpTypesPair {
+      public readonly VCExprOp/*!*/ Op;
+      public readonly List<Type/*!*/>/*!*/ Types;
+      [ContractInvariantMethod]
+      void ObjectInvariant() {
+        Contract.Invariant(Op != null);
+        Contract.Invariant(cce.NonNullElements(Types));
+      }
+
+
+      public OpTypesPair(VCExprOp op, List<Type/*!*/>/*!*/ types) {
+        Contract.Requires(op != null);
+        Contract.Requires(cce.NonNullElements(types));
+        this.Op = op;
+        this.Types = types;
+        this.HashCode = HFNS.PolyHash(op.GetHashCode(), 17, types);
+      }
+
+      [Pure]
+      [Reads(ReadsAttribute.Reads.Nothing)]
+      public override bool Equals(object that) {
+        if (that is OpTypesPair) {
+          OpTypesPair thatPair = (OpTypesPair)that;
+          return this.Op.Equals(thatPair.Op) &&
+            HFNS.SameElements(this.Types, thatPair.Types);
+        }
+        return false;
+      }
+
+      private readonly int HashCode;
+
+      [Pure]
+      public override int GetHashCode() {
+        return HashCode;
+      }
+    }
+  }
 }
 \ No newline at end of file
diff --git a/Source/VCExpr/TypeErasurePremisses.cs b/Source/VCExpr/TypeErasurePremisses.cs
index d4b36b68..dc9ad10f 100644
--- a/Source/VCExpr/TypeErasurePremisses.cs
+++ b/Source/VCExpr/TypeErasurePremisses.cs
@@ -1,1337 +1,1337 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-using Microsoft.Boogie.VCExprAST;
-
-// Erasure of types using premisses   (forall x :: type(x)=T ==> p(x))
-
-namespace Microsoft.Boogie.TypeErasure
-{
-  using Microsoft.Boogie.VCExprAST;
-
-  // When using type premisses, we can distinguish two kinds of type
-  // parameters of a function or map: parameters that occur in the
-  // formal argument types of the function are "implicit" because they
-  // can be inferred from the actual argument types; parameters that
-  // only occur in the result type of the function are "explicit"
-  // because they are not inferrable and have to be given to the
-  // function as additional arguments.
-  //
-  // The following structure is used to store the untyped version of a
-  // typed function, together with the lists of implicit and explicit
-  // type parameters (in the same order as they occur in the signature
-  // of the original function).
-
-  internal struct UntypedFunction
-  {
-    public readonly Function/*!*/ Fun;
-    // type parameters that can be extracted from the value parameters
-    public readonly List<TypeVariable/*!*/>/*!*/ ImplicitTypeParams;
-    // type parameters that have to be given explicitly
-    public readonly List<TypeVariable/*!*/>/*!*/ ExplicitTypeParams;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Fun != null);
-      Contract.Invariant(cce.NonNullElements(ImplicitTypeParams));
-      Contract.Invariant(cce.NonNullElements(ExplicitTypeParams));
-    }
-
-
-    public UntypedFunction(Function/*!*/ fun,
-                           List<TypeVariable/*!*/>/*!*/ implicitTypeParams,
-                           List<TypeVariable/*!*/>/*!*/ explicitTypeParams) {
-      Contract.Requires(fun != null);
-      Contract.Requires(cce.NonNullElements(implicitTypeParams));
-      Contract.Requires(cce.NonNullElements(explicitTypeParams));
-      Fun = fun;
-      ImplicitTypeParams = implicitTypeParams;
-      ExplicitTypeParams = explicitTypeParams;
-    }
-  }
-
-  public class TypeAxiomBuilderPremisses : TypeAxiomBuilderIntBoolU
-  {
-
-    public TypeAxiomBuilderPremisses(VCExpressionGenerator gen)
-      : base(gen) {
-      Contract.Requires(gen != null);
-
-      TypeFunction = HelperFuns.BoogieFunction("dummy", Type.Int);
-      Typed2UntypedFunctions = new Dictionary<Function/*!*/, UntypedFunction>();
-      MapTypeAbstracterAttr = null;
-    }
-
-    // constructor to allow cloning
-    [NotDelayed]
-    internal TypeAxiomBuilderPremisses(TypeAxiomBuilderPremisses builder)
-      : base(builder) {
-      Contract.Requires(builder != null);
-      TypeFunction = builder.TypeFunction;
-      Typed2UntypedFunctions =
-        new Dictionary<Function/*!*/, UntypedFunction>(builder.Typed2UntypedFunctions);
-
-      MapTypeAbstracterAttr =
-        builder.MapTypeAbstracterAttr == null ?
-        null : new MapTypeAbstractionBuilderPremisses(this, builder.Gen,
-                                                      builder.MapTypeAbstracterAttr);
-    }
-
-    public override Object Clone() {
-      Contract.Ensures(Contract.Result<Object>() != null);
-      return new TypeAxiomBuilderPremisses(this);
-    }
-
-    public override void Setup() {
-      TypeFunction = HelperFuns.BoogieFunction("type", U, T);
-      base.Setup();
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    // generate axioms of the kind "forall x:U. {Int2U(U2Int(x))}
-    //                                          type(x)=int ==> Int2U(U2Int(x))==x"
-    protected override VCExpr GenReverseCastAxiom(Function castToU, Function castFromU) {
-      //Contract.Requires(castFromU != null);
-      //Contract.Requires(castToU != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<VCTrigger/*!*/>/*!*/ triggers;
-      VCExprVar/*!*/ var;
-      VCExpr/*!*/ eq = GenReverseCastEq(castToU, castFromU, out var, out triggers);
-      Contract.Assert(cce.NonNullElements(triggers));
-      Contract.Assert(var != null);
-      Contract.Assert(eq != null);
-      VCExpr/*!*/ premiss;
-      if (CommandLineOptions.Clo.TypeEncodingMethod
-              == CommandLineOptions.TypeEncoding.None)
-        premiss = VCExpressionGenerator.True;
-      else
-        premiss = GenVarTypeAxiom(var, cce.NonNull(castFromU.OutParams[0]).TypedIdent.Type,
-          // we don't have any bindings available
-                                  new Dictionary<TypeVariable/*!*/, VCExpr/*!*/>());
-      VCExpr/*!*/ matrix = Gen.ImpliesSimp(premiss, eq);
-      Contract.Assert(matrix != null);
-      return Gen.Forall(HelperFuns.ToList(var), triggers, "cast:" + castFromU.Name, -1, matrix);
-    }
-
-    protected override VCExpr GenCastTypeAxioms(Function castToU, Function castFromU) {
-      //Contract.Requires(castFromU != null);
-      //Contract.Requires(castToU != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      Type/*!*/ fromType = cce.NonNull(castToU.InParams[0]).TypedIdent.Type;
-      return GenFunctionAxiom(castToU, new List<TypeVariable/*!*/>(), new List<TypeVariable/*!*/>(),
-                              HelperFuns.ToList(fromType), fromType);
-    }
-
-    private MapTypeAbstractionBuilderPremisses MapTypeAbstracterAttr;
-
-    internal override MapTypeAbstractionBuilder/*!*/ MapTypeAbstracter {
-      get {
-        Contract.Ensures(Contract.Result<MapTypeAbstractionBuilder>() != null);
-
-        if (MapTypeAbstracterAttr == null)
-          MapTypeAbstracterAttr = new MapTypeAbstractionBuilderPremisses(this, Gen);
-        return MapTypeAbstracterAttr;
-      }
-    }
-
-    internal MapTypeAbstractionBuilderPremisses/*!*/ MapTypeAbstracterPremisses {
-      get {
-        Contract.Ensures(Contract.Result<MapTypeAbstractionBuilderPremisses>() != null);
-
-        return (MapTypeAbstractionBuilderPremisses)MapTypeAbstracter;
-      }
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    // function that maps individuals to their type
-    // the field is overwritten with its actual value in "Setup"
-    private Function/*!*/ TypeFunction;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(TypeFunction != null);
-    }
-
-
-    public VCExpr TypeOf(VCExpr expr) {
-      Contract.Requires(expr != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Gen.Function(TypeFunction, expr);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // Generate type premisses and type parameter bindings for quantifiers, functions, procedures
-
-    // let-bindings to extract the instantiations of type parameters
-    public List<VCExprLetBinding/*!*/>/*!*/
-           GenTypeParamBindings(// the original bound variables and (implicit) type parameters
-                                List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ oldBoundVars,
-      // VariableBindings to which the translation
-      // TypeVariable -> VCExprVar is added
-                                VariableBindings/*!*/ bindings,
-                                bool addTypeVarsToBindings) {
-      Contract.Requires(typeParams != null);
-      Contract.Requires(cce.NonNullElements(oldBoundVars));
-      Contract.Requires(bindings != null);
-
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprLetBinding>>()));
-
-      // type variables are replaced with ordinary variables that are bound using a
-      // let-expression
-      if (addTypeVarsToBindings) {
-        foreach (TypeVariable/*!*/ tvar in typeParams) {
-          Contract.Assert(tvar != null);
-          bindings.TypeVariableBindings.Add(tvar, Gen.Variable(tvar.Name, T));
-        }
-      }
-
-      // extract the values of type variables from the term variables
-      List<VCExprVar/*!*/>/*!*/ UtypedVars = new List<VCExprVar/*!*/>(oldBoundVars.Count);
-      List<Type/*!*/>/*!*/ originalTypes = new List<Type/*!*/>(oldBoundVars.Count);
-      foreach (VCExprVar var in oldBoundVars) {
-        VCExprVar/*!*/ newVar = bindings.VCExprVarBindings[var];
-        if (newVar.Type.Equals(U)) {
-          UtypedVars.Add(newVar);
-          originalTypes.Add(var.Type);
-        }
-      }
-
-      UtypedVars.TrimExcess();
-      originalTypes.TrimExcess();
-
-      return BestTypeVarExtractors(typeParams, originalTypes, UtypedVars, bindings);
-    }
-
-
-    public VCExpr/*!*/ AddTypePremisses(List<VCExprLetBinding/*!*/>/*!*/ typeVarBindings,
-                                    VCExpr/*!*/ typePremisses, bool universal,
-                                    VCExpr/*!*/ body) {
-      Contract.Requires(cce.NonNullElements(typeVarBindings));
-      Contract.Requires(typePremisses != null);
-      Contract.Requires(body != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      VCExpr/*!*/ bodyWithPremisses;
-      if (universal)
-        bodyWithPremisses = Gen.ImpliesSimp(typePremisses, body);
-      else
-        bodyWithPremisses = Gen.AndSimp(typePremisses, body);
-
-      return Gen.Let(typeVarBindings, bodyWithPremisses);
-    }
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    // Extract the instantiations of type variables from the concrete types of
-    // term variables. E.g., for a function  f<a>(x : C a), we would extract the
-    // instantiation of "a" by looking at the concrete type of "x".
-
-    public List<VCExprLetBinding/*!*/>/*!*/
-           BestTypeVarExtractors(List<TypeVariable/*!*/>/*!*/ vars, List<Type/*!*/>/*!*/ types,
-                                 List<VCExprVar/*!*/>/*!*/ concreteTypeSources,
-                                 VariableBindings/*!*/ bindings) {
-      Contract.Requires(cce.NonNullElements(vars));
-      Contract.Requires(cce.NonNullElements(types));
-      Contract.Requires(cce.NonNullElements(concreteTypeSources));
-      Contract.Requires(bindings != null);
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprLetBinding>>()));
-
-      List<VCExprLetBinding/*!*/>/*!*/ typeParamBindings = new List<VCExprLetBinding/*!*/>();
-      foreach (TypeVariable/*!*/ var in vars) {
-        Contract.Assert(var != null);
-        VCExpr extractor = BestTypeVarExtractor(var, types, concreteTypeSources);
-        if (extractor != null)
-          typeParamBindings.Add(
-            Gen.LetBinding((VCExprVar)bindings.TypeVariableBindings[var],
-                           extractor));
-      }
-      return typeParamBindings;
-    }
-
-    private VCExpr BestTypeVarExtractor(TypeVariable/*!*/ var, List<Type/*!*/>/*!*/ types,
-                                        List<VCExprVar/*!*/>/*!*/ concreteTypeSources) {
-      Contract.Requires(var != null);
-      Contract.Requires(cce.NonNullElements(types));
-      Contract.Requires(cce.NonNullElements(concreteTypeSources));
-      List<VCExpr/*!*/> allExtractors = TypeVarExtractors(var, types, concreteTypeSources);
-      Contract.Assert(cce.NonNullElements(allExtractors));
-      if (allExtractors.Count == 0)
-        return null;
-
-      VCExpr bestExtractor = allExtractors[0];
-      int bestExtractorSize = SizeComputingVisitor.ComputeSize(bestExtractor);
-      for (int i = 1; i < allExtractors.Count; ++i) {
-        int newSize = SizeComputingVisitor.ComputeSize(allExtractors[i]);
-        if (newSize < bestExtractorSize) {
-          bestExtractor = allExtractors[i];
-          bestExtractorSize = newSize;
-        }
-      }
-
-      return bestExtractor;
-    }
-
-    private List<VCExpr/*!*/>/*!*/ TypeVarExtractors(TypeVariable/*!*/ var, List<Type/*!*/>/*!*/ types,
-                                             List<VCExprVar/*!*/>/*!*/ concreteTypeSources) {
-      Contract.Requires(var != null);
-      Contract.Requires(cce.NonNullElements(types));
-      Contract.Requires(cce.NonNullElements(concreteTypeSources));
-      Contract.Requires((types.Count == concreteTypeSources.Count));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
-      List<VCExpr/*!*/>/*!*/ res = new List<VCExpr/*!*/>();
-      for (int i = 0; i < types.Count; ++i)
-        TypeVarExtractors(var, types[i], TypeOf(concreteTypeSources[i]), res);
-
-      return res;
-    }
-
-    private void TypeVarExtractors(TypeVariable var, Type completeType, VCExpr innerTerm, List<VCExpr/*!*/>/*!*/ extractors) {
-      Contract.Requires(innerTerm != null);
-      Contract.Requires(completeType != null);
-      Contract.Requires(var != null);
-      Contract.Requires(cce.NonNullElements(extractors));
-      if (completeType.IsVariable) {
-        if (var.Equals(completeType)) {
-          extractors.Add(innerTerm);
-        }  // else nothing
-      } else if (completeType.IsBasic) {
-        // nothing
-      } else if (completeType.IsCtor) {
-        CtorType/*!*/ ctorType = completeType.AsCtor;
-        if (ctorType.Arguments.Count > 0) {
-          // otherwise there are no chances of extracting any
-          // instantiations from this type
-          TypeCtorRepr repr = GetTypeCtorReprStruct(ctorType.Decl);
-          for (int i = 0; i < ctorType.Arguments.Count; ++i) {
-            VCExpr/*!*/ newInnerTerm = Gen.Function(repr.Dtors[i], innerTerm);
-            Contract.Assert(newInnerTerm != null);
-            TypeVarExtractors(var, ctorType.Arguments[i], newInnerTerm, extractors);
-          }
-        }
-      } else if (completeType.IsMap) {
-        TypeVarExtractors(var, MapTypeAbstracter.AbstractMapType(completeType.AsMap),
-                          innerTerm, extractors);
-      } else {
-        System.Diagnostics.Debug.Fail("Don't know how to handle this type: " + completeType);
-      }
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Symbols for representing functions
-
-    // Globally defined functions
-    private readonly IDictionary<Function/*!*/, UntypedFunction/*!*/>/*!*/ Typed2UntypedFunctions;
-    [ContractInvariantMethod]
-    void Typed2UntypedFunctionsInvariantMethod() {
-      Contract.Invariant(Typed2UntypedFunctions != null);
-    }
-
-    // distinguish between implicit and explicit type parameters
-    internal static void SeparateTypeParams(List<Type/*!*/>/*!*/ valueArgumentTypes,
-                                            List<TypeVariable>/*!*/ allTypeParams,
-                                            out List<TypeVariable/*!*/>/*!*/ implicitParams,
-                                            out List<TypeVariable/*!*/>/*!*/ explicitParams) {
-      Contract.Requires(cce.NonNullElements(valueArgumentTypes));
-      Contract.Requires(allTypeParams != null);
-      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out implicitParams)));
-      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out explicitParams)));
-      List<TypeVariable>/*!*/ varsInInParamTypes = new List<TypeVariable>();
-      foreach (Type/*!*/ t in valueArgumentTypes) {
-        Contract.Assert(t != null);
-        varsInInParamTypes.AppendWithoutDups(t.FreeVariables);
-      }
-
-      implicitParams = new List<TypeVariable/*!*/>(allTypeParams.Count);
-      explicitParams = new List<TypeVariable/*!*/>(allTypeParams.Count);
-
-      foreach (TypeVariable/*!*/ var in allTypeParams) {
-        Contract.Assert(var != null);
-        if (varsInInParamTypes.Contains(var))
-          implicitParams.Add(var);
-        else
-          explicitParams.Add(var);
-      }
-
-      implicitParams.TrimExcess();
-      explicitParams.TrimExcess();
-    }
-
-    internal UntypedFunction Typed2Untyped(Function fun) {
-      Contract.Requires(fun != null);
-      UntypedFunction res;
-      if (!Typed2UntypedFunctions.TryGetValue(fun, out res)) {
-        Contract.Assert(fun.OutParams.Count == 1);
-
-        // if all of the parameters are int or bool, the function does
-        // not have to be changed
-        if (fun.InParams.All(param => UnchangedType(cce.NonNull(param).TypedIdent.Type)) &&
-            UnchangedType(cce.NonNull(fun.OutParams[0]).TypedIdent.Type) &&
-            fun.TypeParameters.Count == 0) {
-          res = new UntypedFunction(fun, new List<TypeVariable/*!*/>(), new List<TypeVariable/*!*/>());
-        } else {
-          List<Type/*!*/>/*!*/ argTypes = new List<Type/*!*/>();
-          foreach (Variable/*!*/ v in fun.InParams) {
-            Contract.Assert(v != null);
-            argTypes.Add(v.TypedIdent.Type);
-          }
-
-          List<TypeVariable/*!*/>/*!*/ implicitParams, explicitParams;
-          SeparateTypeParams(argTypes, fun.TypeParameters, out implicitParams, out explicitParams);
-
-          Type[]/*!*/ types = new Type[explicitParams.Count + fun.InParams.Count + 1];
-          int i = 0;
-          for (int j = 0; j < explicitParams.Count; ++j) {
-            types[i] = T;
-            i = i + 1;
-          }
-          for (int j = 0; j < fun.InParams.Count; ++i, ++j)
-            types[i] = TypeAfterErasure(cce.NonNull(fun.InParams[j]).TypedIdent.Type);
-          types[types.Length - 1] = TypeAfterErasure(cce.NonNull(fun.OutParams[0]).TypedIdent.Type);
-
-          Function/*!*/ untypedFun = HelperFuns.BoogieFunction(fun.Name, types);
-          Contract.Assert(untypedFun != null);
-          untypedFun.Attributes = fun.Attributes;
-          res = new UntypedFunction(untypedFun, implicitParams, explicitParams);
-          if (U.Equals(types[types.Length - 1]))
-            AddTypeAxiom(GenFunctionAxiom(res, fun));
-        }
-
-        Typed2UntypedFunctions.Add(fun, res);
-      }
-      return res;
-    }
-
-    private VCExpr GenFunctionAxiom(UntypedFunction fun, Function originalFun) {
-      Contract.Requires(originalFun != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<Type/*!*/>/*!*/ originalInTypes = new List<Type/*!*/>(originalFun.InParams.Count);
-      foreach (Formal/*!*/ f in originalFun.InParams)
-        originalInTypes.Add(f.TypedIdent.Type);
-
-      return GenFunctionAxiom(fun.Fun, fun.ImplicitTypeParams, fun.ExplicitTypeParams,
-                              originalInTypes,
-                              cce.NonNull(originalFun.OutParams[0]).TypedIdent.Type);
-    }
-
-    internal VCExpr/*!*/ GenFunctionAxiom(Function/*!*/ fun,
-                                      List<TypeVariable/*!*/>/*!*/ implicitTypeParams,
-                                      List<TypeVariable/*!*/>/*!*/ explicitTypeParams,
-                                      List<Type/*!*/>/*!*/ originalInTypes,
-                                      Type/*!*/ originalResultType) {
-      Contract.Requires(cce.NonNullElements(implicitTypeParams));
-      Contract.Requires(fun != null);
-      Contract.Requires(cce.NonNullElements(explicitTypeParams));
-      Contract.Requires(cce.NonNullElements(originalInTypes));
-      Contract.Requires(originalResultType != null);
-      Contract.Requires(originalInTypes.Count + explicitTypeParams.Count == fun.InParams.Count);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      if (CommandLineOptions.Clo.TypeEncodingMethod == CommandLineOptions.TypeEncoding.None) {
-        return VCExpressionGenerator.True;
-      }
-
-      List<VCExprVar/*!*/>/*!*/ typedInputVars = new List<VCExprVar/*!*/>(originalInTypes.Count);
-      int i = 0;
-      foreach (Type/*!*/ t in originalInTypes) {
-        Contract.Assert(t != null);
-        typedInputVars.Add(Gen.Variable("arg" + i, t));
-        i = i + 1;
-      }
-
-      VariableBindings/*!*/ bindings = new VariableBindings();
-
-      // type parameters that have to be given explicitly are replaced
-      // with universally quantified type variables
-      List<VCExprVar/*!*/>/*!*/ boundVars = new List<VCExprVar/*!*/>(explicitTypeParams.Count + typedInputVars.Count);
-      foreach (TypeVariable/*!*/ var in explicitTypeParams) {
-        Contract.Assert(var != null);
-        VCExprVar/*!*/ newVar = Gen.Variable(var.Name, T);
-        boundVars.Add(newVar);
-        bindings.TypeVariableBindings.Add(var, newVar);
-      }
-
-      // bound term variables are replaced with bound term variables typed in
-      // a simpler way
-      foreach (VCExprVar/*!*/ var in typedInputVars) {
-        Contract.Assert(var != null);
-        Type/*!*/ newType = TypeAfterErasure(var.Type);
-        Contract.Assert(newType != null);
-        VCExprVar/*!*/ newVar = Gen.Variable(var.Name, newType);
-        Contract.Assert(newVar != null);
-        boundVars.Add(newVar);
-        bindings.VCExprVarBindings.Add(var, newVar);
-      }
-
-      List<VCExprLetBinding/*!*/> typeVarBindings =
-        GenTypeParamBindings(implicitTypeParams, typedInputVars, bindings, true);
-      Contract.Assert(cce.NonNullElements(typeVarBindings));
-
-      VCExpr/*!*/ funApp = Gen.Function(fun, HelperFuns.ToVCExprList(boundVars));
-      Contract.Assert(funApp != null);
-      VCExpr/*!*/ conclusion = Gen.Eq(TypeOf(funApp),
-                                  Type2Term(originalResultType, bindings.TypeVariableBindings));
-      Contract.Assert(conclusion != null);
-      VCExpr conclusionWithPremisses =
-        // leave out antecedents of function type axioms ... they don't appear necessary,
-        // because a function can always be extended to all U-values (right?)
-        //        AddTypePremisses(typeVarBindings, typePremisses, true, conclusion);
-        Gen.Let(typeVarBindings, conclusion);
-
-      if (boundVars.Count > 0) {
-        List<VCTrigger/*!*/> triggers = HelperFuns.ToList(Gen.Trigger(true, HelperFuns.ToList(funApp)));
-        Contract.Assert(cce.NonNullElements(triggers));
-        return Gen.Forall(boundVars, triggers, "funType:" + fun.Name, -1, conclusionWithPremisses);
-      } else {
-        return conclusionWithPremisses;
-      }
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    protected override void AddVarTypeAxiom(VCExprVar var, Type originalType) {
-      //Contract.Requires(originalType != null);
-      //Contract.Requires(var != null);
-      if (CommandLineOptions.Clo.TypeEncodingMethod == CommandLineOptions.TypeEncoding.None) return;
-      AddTypeAxiom(GenVarTypeAxiom(var, originalType,
-        // we don't have any bindings available
-                                   new Dictionary<TypeVariable/*!*/, VCExpr/*!*/>()));
-    }
-
-    public VCExpr GenVarTypeAxiom(VCExprVar var, Type originalType, IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/ varMapping) {
-      Contract.Requires(var != null);
-      Contract.Requires(originalType != null);
-      Contract.Requires(cce.NonNullDictionaryAndValues(varMapping));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      if (!var.Type.Equals(originalType)) {
-        VCExpr/*!*/ typeRepr = Type2Term(originalType, varMapping);
-        return Gen.Eq(TypeOf(var), typeRepr);
-      }
-      return VCExpressionGenerator.True;
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-
-  internal class MapTypeAbstractionBuilderPremisses : MapTypeAbstractionBuilder
-  {
-
-    private readonly TypeAxiomBuilderPremisses/*!*/ AxBuilderPremisses;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(AxBuilderPremisses != null);
-    }
-
-
-    internal MapTypeAbstractionBuilderPremisses(TypeAxiomBuilderPremisses axBuilder, VCExpressionGenerator gen)
-      : base(axBuilder, gen) {
-      Contract.Requires(gen != null);
-      Contract.Requires(axBuilder != null);
-
-      this.AxBuilderPremisses = axBuilder;
-    }
-
-    // constructor for cloning
-    internal MapTypeAbstractionBuilderPremisses(TypeAxiomBuilderPremisses axBuilder, VCExpressionGenerator gen, MapTypeAbstractionBuilderPremisses builder)
-      : base(axBuilder, gen, builder) {
-      Contract.Requires(builder != null);
-      Contract.Requires(gen != null);
-      Contract.Requires(axBuilder != null);
-
-      this.AxBuilderPremisses = axBuilder;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    // Determine the type parameters of a map type that have to be
-    // given explicitly when applying the select function (the
-    // parameters that only occur in the result type of the
-    // map). These parameters are given as a list of indexes sorted in
-    // ascending order; the index i refers to the i'th bound variable
-    // in a type    <a0, a1, ..., an>[...]...
-    public List<int>/*!*/ ExplicitSelectTypeParams(MapType type) {
-      Contract.Requires(type != null);
-      Contract.Ensures(Contract.Result<List<int>>() != null);
-
-      List<int> res;
-      if (!explicitSelectTypeParamsCache.TryGetValue(type, out res)) {
-        List<TypeVariable/*!*/>/*!*/ explicitParams, implicitParams;
-        TypeAxiomBuilderPremisses.SeparateTypeParams(type.Arguments.ToList(),
-                                                     type.TypeParameters,
-                                                     out implicitParams,
-                                                     out explicitParams);
-        res = new List<int>(explicitParams.Count);
-        foreach (TypeVariable/*!*/ var in explicitParams) {
-          Contract.Assert(var != null);
-          res.Add(type.TypeParameters.IndexOf(var));
-        }
-        explicitSelectTypeParamsCache.Add(type, res);
-      }
-      return cce.NonNull(res);
-    }
-
-    private IDictionary<MapType/*!*/, List<int>/*!*/>/*!*/ explicitSelectTypeParamsCache =
-      new Dictionary<MapType/*!*/, List<int>/*!*/>();
-    [ContractInvariantMethod]
-    void ObjectInvarant() {
-      Contract.Invariant(cce.NonNullDictionaryAndValues(explicitSelectTypeParamsCache));
-    }
-
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    protected override void GenSelectStoreFunctions(MapType abstractedType, TypeCtorDecl synonym, out Function/*!*/ select, out Function/*!*/ store) {
-      //Contract.Requires(synonym != null);
-      //Contract.Requires(abstractedType != null);
-      Contract.Ensures(Contract.ValueAtReturn(out select) != null);
-      Contract.Ensures(Contract.ValueAtReturn(out store) != null);
-      Type/*!*/ mapTypeSynonym;
-      List<TypeVariable/*!*/>/*!*/ typeParams;
-      List<Type/*!*/>/*!*/ originalInTypes;
-      GenTypeAxiomParams(abstractedType, synonym, out mapTypeSynonym,
-                         out typeParams, out originalInTypes);
-
-      // select
-      List<TypeVariable/*!*/>/*!*/ explicitSelectParams, implicitSelectParams;
-      select = CreateAccessFun(typeParams, originalInTypes,
-                               abstractedType.Result, synonym.Name + "Select",
-                               out implicitSelectParams, out explicitSelectParams);
-
-      // store, which gets one further argument: the assigned rhs
-      originalInTypes.Add(abstractedType.Result);
-
-      List<TypeVariable/*!*/>/*!*/ explicitStoreParams, implicitStoreParams;
-      store = CreateAccessFun(typeParams, originalInTypes,
-                              mapTypeSynonym, synonym.Name + "Store",
-                              out implicitStoreParams, out explicitStoreParams);
-
-      // the store function does not have any explicit type parameters
-      Contract.Assert(explicitStoreParams.Count == 0);
-
-      if (CommandLineOptions.Clo.UseArrayTheory) {
-        select.AddAttribute("builtin", "select");
-        store.AddAttribute("builtin", "store");
-      } else {
-        AxBuilder.AddTypeAxiom(GenMapAxiom0(select, store,
-                                            abstractedType.Result,
-                                            implicitSelectParams, explicitSelectParams,
-                                            originalInTypes));
-        AxBuilder.AddTypeAxiom(GenMapAxiom1(select, store,
-                                            abstractedType.Result,
-                                            explicitSelectParams));
-      }
-    }
-
-    protected void GenTypeAxiomParams(MapType/*!*/ abstractedType, TypeCtorDecl/*!*/ synonymDecl,
-                                      out Type/*!*/ mapTypeSynonym,
-                                      out List<TypeVariable/*!*/>/*!*/ typeParams,
-                                      out List<Type/*!*/>/*!*/ originalIndexTypes) {
-      Contract.Requires(abstractedType != null);
-      Contract.Requires(synonymDecl != null);
-      Contract.Ensures(Contract.ValueAtReturn(out mapTypeSynonym) != null);
-      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out typeParams)));
-      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out originalIndexTypes)));
-      typeParams = new List<TypeVariable/*!*/>();
-      typeParams.AddRange(abstractedType.TypeParameters);
-      typeParams.AddRange(abstractedType.FreeVariables);
-
-      originalIndexTypes = new List<Type/*!*/>(abstractedType.Arguments.Count + 1);
-      List<Type>/*!*/ mapTypeParams = new List<Type>();
-      foreach (TypeVariable/*!*/ var in abstractedType.FreeVariables) {
-        Contract.Assert(var != null);
-        mapTypeParams.Add(var);
-      }
-
-      if (CommandLineOptions.Clo.MonomorphicArrays)
-        mapTypeSynonym = abstractedType;
-      else
-        mapTypeSynonym = new CtorType(Token.NoToken, synonymDecl, mapTypeParams);
-
-      originalIndexTypes.Add(mapTypeSynonym);
-      originalIndexTypes.AddRange(abstractedType.Arguments.ToList());
-    }
-
-    // method to actually create the select or store function
-    private Function/*!*/ CreateAccessFun(List<TypeVariable/*!*/>/*!*/ originalTypeParams,
-                                      List<Type/*!*/>/*!*/ originalInTypes,
-                                      Type/*!*/ originalResult,
-                                      string/*!*/ name,
-                                      out List<TypeVariable/*!*/>/*!*/ implicitTypeParams, out List<TypeVariable/*!*/>/*!*/ explicitTypeParams) {
-      Contract.Requires(cce.NonNullElements(originalTypeParams));
-      Contract.Requires(cce.NonNullElements(originalInTypes));
-      Contract.Requires(originalResult != null);
-      Contract.Requires(name != null);
-      Contract.Ensures(Contract.Result<Function>() != null);
-      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out implicitTypeParams)));
-      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out explicitTypeParams)));
-
-      // select and store are basically handled like normal functions: the type
-      // parameters are split into the implicit parameters, and into the parameters
-      // that have to be given explicitly
-      TypeAxiomBuilderPremisses.SeparateTypeParams(originalInTypes,
-                                                   new List<TypeVariable>(originalTypeParams),
-                                                   out implicitTypeParams,
-                                                   out explicitTypeParams);
-
-      Type[]/*!*/ ioTypes = new Type[explicitTypeParams.Count + originalInTypes.Count + 1];
-      int i = 0;
-      for (; i < explicitTypeParams.Count; ++i)
-        ioTypes[i] = AxBuilder.T;
-      foreach (Type/*!*/ type in originalInTypes) {
-        Contract.Assert(type != null);
-        if (CommandLineOptions.Clo.Monomorphize && AxBuilder.UnchangedType(type))
-          ioTypes[i] = type;
-        else
-          ioTypes[i] = AxBuilder.U;
-        i++;
-      }
-      if (CommandLineOptions.Clo.Monomorphize && AxBuilder.UnchangedType(originalResult))
-        ioTypes[i] = originalResult;
-      else
-        ioTypes[i] = AxBuilder.U;
-
-      Function/*!*/ res = HelperFuns.BoogieFunction(name, ioTypes);
-      Contract.Assert(res != null);
-
-      if (AxBuilder.U.Equals(ioTypes[i])) {
-        AxBuilder.AddTypeAxiom(
-            AxBuilderPremisses.GenFunctionAxiom(res,
-                                            implicitTypeParams, explicitTypeParams,
-                                            originalInTypes, originalResult));
-      }
-      return res;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // The normal axioms of the theory of arrays (without extensionality)
-
-    private VCExpr/*!*/ Select(Function/*!*/ select,
-      // in general, the select function has to
-      // receive explicit type parameters (which
-      // are here already represented as VCExpr
-      // of type T)
-                           List<VCExpr/*!*/>/*!*/ typeParams,
-                           VCExpr/*!*/ map,
-                           List<VCExprVar/*!*/>/*!*/ indexes) {
-      Contract.Requires(select != null);
-      Contract.Requires(cce.NonNullElements(typeParams));
-      Contract.Requires(map != null);
-      Contract.Requires(cce.NonNullElements(indexes));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      List<VCExpr/*!*/>/*!*/ selectArgs = new List<VCExpr/*!*/>(typeParams.Count + indexes.Count + 1);
-      selectArgs.AddRange(typeParams);
-      selectArgs.Add(map);
-      selectArgs.AddRange(HelperFuns.ToVCExprList(indexes));
-      return Gen.Function(select, selectArgs);
-    }
-
-    private VCExpr Store(Function store, VCExpr map, List<VCExprVar/*!*/>/*!*/ indexes, VCExpr val) {
-      Contract.Requires(val != null);
-      Contract.Requires(map != null);
-      Contract.Requires(store != null);
-      Contract.Requires(cce.NonNullElements(indexes));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<VCExpr/*!*/>/*!*/ storeArgs = new List<VCExpr/*!*/>(indexes.Count + 2);
-      storeArgs.Add(map);
-      storeArgs.AddRange(HelperFuns.ToVCExprList(indexes));
-      storeArgs.Add(val);
-      return Gen.Function(store, storeArgs);
-    }
-
-    /// <summary>
-    /// Generate:
-    ///   (forall m, indexes, val ::
-    ///     type(val) == T ==>
-    ///     select(store(m, indexes, val), indexes) == val)
-    /// where the quantifier body is also enclosed in a let that defines portions of T, if needed.
-    /// </summary>
-    private VCExpr GenMapAxiom0(Function select, Function store, Type mapResult, List<TypeVariable/*!*/>/*!*/ implicitTypeParamsSelect, List<TypeVariable/*!*/>/*!*/ explicitTypeParamsSelect, List<Type/*!*/>/*!*/ originalInTypes) {
-      Contract.Requires(mapResult != null);
-      Contract.Requires(store != null);
-      Contract.Requires(select != null);
-      Contract.Requires(cce.NonNullElements(implicitTypeParamsSelect));
-      Contract.Requires(cce.NonNullElements(originalInTypes));
-      Contract.Requires(cce.NonNullElements(explicitTypeParamsSelect));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      int arity = store.InParams.Count - 2;
-      List<VCExprVar/*!*/> inParams = new List<VCExprVar/*!*/>();
-      List<VCExprVar/*!*/> quantifiedVars = new List<VCExprVar/*!*/>(store.InParams.Count);
-      VariableBindings bindings = new VariableBindings();
-
-      // bound variable:  m
-      VCExprVar typedM = Gen.Variable("m", originalInTypes[0]);
-      VCExprVar m = Gen.Variable("m", AxBuilder.U);
-      inParams.Add(typedM);
-      quantifiedVars.Add(m);
-      bindings.VCExprVarBindings.Add(typedM, m);
-
-      // bound variables:  indexes
-      List<Type/*!*/> origIndexTypes = new List<Type/*!*/>(arity);
-      List<Type/*!*/> indexTypes = new List<Type/*!*/>(arity);
-      for (int i = 1; i < store.InParams.Count - 1; i++) {
-        origIndexTypes.Add(originalInTypes[i]);
-        indexTypes.Add(cce.NonNull(store.InParams[i]).TypedIdent.Type);
-      }
-      Contract.Assert(arity == indexTypes.Count);
-      List<VCExprVar/*!*/> typedArgs = HelperFuns.VarVector("arg", origIndexTypes, Gen);
-      Contract.Assert(cce.NonNullElements(typedArgs));
-      List<VCExprVar/*!*/> indexes = HelperFuns.VarVector("x", indexTypes, Gen);
-      Contract.Assert(cce.NonNullElements(indexes));
-      Contract.Assert(typedArgs.Count == indexes.Count);
-      inParams.AddRange(typedArgs);
-      quantifiedVars.AddRange(indexes);
-      for (int i = 0; i < arity; i++) {
-        bindings.VCExprVarBindings.Add(typedArgs[i], indexes[i]);
-      }
-
-      // bound variable:  val
-      VCExprVar typedVal = Gen.Variable("val", mapResult);
-      VCExprVar val = Gen.Variable("val", cce.NonNull(select.OutParams[0]).TypedIdent.Type);
-      quantifiedVars.Add(val);
-      bindings.VCExprVarBindings.Add(typedVal, val);
-
-      // add all type parameters into bindings
-      foreach (TypeVariable tp in implicitTypeParamsSelect) {
-        VCExprVar tVar = Gen.Variable(tp.Name, AxBuilderPremisses.T);
-        bindings.TypeVariableBindings.Add(tp, tVar);
-      }
-      List<VCExpr/*!*/> typeParams = new List<VCExpr/*!*/>(explicitTypeParamsSelect.Count);
-      foreach (TypeVariable tp in explicitTypeParamsSelect) {
-        VCExprVar tVar = Gen.Variable(tp.Name, AxBuilderPremisses.T);
-        bindings.TypeVariableBindings.Add(tp, tVar);
-        // ... and record these explicit type-parameter arguments in typeParams
-        typeParams.Add(tVar);
-      }
-
-      VCExpr/*!*/ storeExpr = Store(store, m, indexes, val);
-      Contract.Assert(storeExpr != null);
-      VCExpr/*!*/ selectExpr = Select(select, typeParams, storeExpr, indexes);
-      Contract.Assert(selectExpr != null);
-
-      // Create let-binding definitions for all type parameters.
-      // The implicit ones can be phrased in terms of the types of the ordinary in-parameters, and
-      // we want to make sure that they don't get phrased in terms of the out-parameter, so we pass
-      // in inParams here.
-      List<VCExprLetBinding/*!*/> letBindings_Implicit =
-        AxBuilderPremisses.GenTypeParamBindings(implicitTypeParamsSelect, inParams, bindings, false);
-      Contract.Assert(cce.NonNullElements(letBindings_Implicit));
-      // The explicit ones, by definition, can only be phrased in terms of the result, so we pass
-      // in List(typedVal) here.
-      List<VCExprLetBinding/*!*/> letBindings_Explicit =
-        AxBuilderPremisses.GenTypeParamBindings(explicitTypeParamsSelect, HelperFuns.ToList(typedVal), bindings, false);
-      Contract.Assert(cce.NonNullElements(letBindings_Explicit));
-
-      // generate:  select(store(m, indices, val)) == val
-      VCExpr/*!*/ eq = Gen.Eq(selectExpr, val);
-      Contract.Assert(eq != null);
-      // generate:  type(val) == T, where T is the type of val
-      VCExpr/*!*/ ante = Gen.Eq(
-        AxBuilderPremisses.TypeOf(val),
-        AxBuilderPremisses.Type2Term(mapResult, bindings.TypeVariableBindings));
-      Contract.Assert(ante != null);
-      VCExpr body;
-      if (CommandLineOptions.Clo.TypeEncodingMethod == CommandLineOptions.TypeEncoding.None ||
-          !AxBuilder.U.Equals(cce.NonNull(select.OutParams[0]).TypedIdent.Type)) {
-        body = Gen.Let(letBindings_Explicit, eq);
-      } else {
-        body = Gen.Let(letBindings_Implicit, Gen.Let(letBindings_Explicit, Gen.ImpliesSimp(ante, eq)));
-      }
-      return Gen.Forall(quantifiedVars, new List<VCTrigger/*!*/>(), "mapAx0:" + select.Name, 0, body);
-    }
-
-    private VCExpr GenMapAxiom1(Function select, Function store, Type mapResult, List<TypeVariable/*!*/>/*!*/ explicitSelectParams) {
-      Contract.Requires(mapResult != null);
-      Contract.Requires(store != null);
-      Contract.Requires(select != null);
-      Contract.Requires(cce.NonNullElements(explicitSelectParams));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      int arity = store.InParams.Count - 2;
-
-      List<Type/*!*/> indexTypes = new List<Type/*!*/>();
-      for (int i = 1; i < store.InParams.Count - 1; i++) {
-        indexTypes.Add(cce.NonNull(store.InParams[i]).TypedIdent.Type);
-      }
-      Contract.Assert(indexTypes.Count == arity);
-
-      List<VCExprVar/*!*/>/*!*/ indexes0 = HelperFuns.VarVector("x", indexTypes, Gen);
-      Contract.Assert(cce.NonNullElements(indexes0));
-      List<VCExprVar/*!*/>/*!*/ indexes1 = HelperFuns.VarVector("y", indexTypes, Gen);
-      Contract.Assert(cce.NonNullElements(indexes1));
-      VCExprVar/*!*/ m = Gen.Variable("m", AxBuilder.U);
-      Contract.Assert(m != null);
-      VCExprVar/*!*/ val = Gen.Variable("val", cce.NonNull(select.OutParams[0]).TypedIdent.Type);
-      Contract.Assert(val != null);
-
-      // extract the explicit type parameters from the actual result type ...
-      VCExprVar/*!*/ typedVal = Gen.Variable("val", mapResult);
-      Contract.Assert(typedVal != null);
-      VariableBindings/*!*/ bindings = new VariableBindings();
-      bindings.VCExprVarBindings.Add(typedVal, val);
-
-      List<VCExprLetBinding/*!*/>/*!*/ letBindings =
-        AxBuilderPremisses.GenTypeParamBindings(explicitSelectParams,
-                                                HelperFuns.ToList(typedVal),
-                                                bindings, true);
-      Contract.Assert(cce.NonNullElements(letBindings));
-
-      // ... and quantify the introduced term variables for type
-      // parameters universally
-      List<VCExprVar/*!*/>/*!*/ typeParams = new List<VCExprVar/*!*/>(explicitSelectParams.Count);
-      List<VCExpr/*!*/>/*!*/ typeParamsExpr = new List<VCExpr/*!*/>(explicitSelectParams.Count);
-      foreach (TypeVariable/*!*/ var in explicitSelectParams) {
-        Contract.Assert(var != null);
-        VCExprVar/*!*/ newVar = (VCExprVar)bindings.TypeVariableBindings[var];
-        Contract.Assert(newVar != null);
-        typeParams.Add(newVar);
-        typeParamsExpr.Add(newVar);
-      }
-
-      VCExpr/*!*/ storeExpr = Store(store, m, indexes0, val);
-      Contract.Assert(storeExpr != null);
-      VCExpr/*!*/ selectWithoutStoreExpr = Select(select, typeParamsExpr, m, indexes1);
-      Contract.Assert(selectWithoutStoreExpr != null);
-      VCExpr/*!*/ selectExpr = Select(select, typeParamsExpr, storeExpr, indexes1);
-      Contract.Assert(selectExpr != null);
-
-      VCExpr/*!*/ selectEq = Gen.Eq(selectExpr, selectWithoutStoreExpr);
-      Contract.Assert(selectEq != null);
-
-      List<VCExprVar/*!*/>/*!*/ quantifiedVars = new List<VCExprVar/*!*/>(indexes0.Count + indexes1.Count + 2);
-      quantifiedVars.Add(val);
-      quantifiedVars.Add(m);
-      quantifiedVars.AddRange(indexes0);
-      quantifiedVars.AddRange(indexes1);
-      quantifiedVars.AddRange(typeParams);
-
-      List<VCTrigger/*!*/>/*!*/ triggers = new List<VCTrigger/*!*/>();
-      Contract.Assert(cce.NonNullElements(triggers));
-
-      VCExpr/*!*/ axiom = VCExpressionGenerator.True;
-      Contract.Assert(axiom != null);
-
-      // first non-interference criterium: the queried location is
-      // different from the assigned location
-      for (int i = 0; i < arity; ++i) {
-        VCExpr/*!*/ indexesEq = Gen.Eq(indexes0[i], indexes1[i]);
-        VCExpr/*!*/ matrix = Gen.Or(indexesEq, selectEq);
-        VCExpr/*!*/ conjunct = Gen.Forall(quantifiedVars, triggers, "mapAx1:" + select.Name + ":" + i, 0, matrix);
-        Contract.Assert(indexesEq != null);
-        Contract.Assert(matrix != null);
-        Contract.Assert(conjunct != null);
-        axiom = Gen.AndSimp(axiom, conjunct);
-      }
-
-      // second non-interference criterion: the queried type is
-      // different from the assigned type
-      VCExpr/*!*/ typesEq = VCExpressionGenerator.True;
-      foreach (VCExprLetBinding/*!*/ b in letBindings) {
-        Contract.Assert(b != null);
-        typesEq = Gen.AndSimp(typesEq, Gen.Eq(b.V, b.E));
-      }
-      VCExpr/*!*/ matrix2 = Gen.Or(typesEq, selectEq);
-      VCExpr/*!*/ conjunct2 = Gen.Forall(quantifiedVars, triggers, "mapAx2:" + select.Name, 0, matrix2);
-      axiom = Gen.AndSimp(axiom, conjunct2);
-
-      return axiom;
-    }
-
-  }
-
-  /////////////////////////////////////////////////////////////////////////////
-
-  public class TypeEraserPremisses : TypeEraser
-  {
-
-    private readonly TypeAxiomBuilderPremisses/*!*/ AxBuilderPremisses;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(AxBuilderPremisses != null);
-    }
-
-
-    private OpTypeEraser OpEraserAttr = null;
-    protected override OpTypeEraser/*!*/ OpEraser {
-      get {
-        Contract.Ensures(Contract.Result<OpTypeEraser>() != null);
-
-        if (OpEraserAttr == null)
-          OpEraserAttr = new OpTypeEraserPremisses(this, AxBuilderPremisses, Gen);
-        return OpEraserAttr;
-      }
-    }
-
-    public TypeEraserPremisses(TypeAxiomBuilderPremisses axBuilder, VCExpressionGenerator gen)
-      : base(axBuilder, gen) {
-      Contract.Requires(gen != null);
-      Contract.Requires(axBuilder != null);
-
-      this.AxBuilderPremisses = axBuilder;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public override VCExpr Visit(VCExprQuantifier node, VariableBindings oldBindings) {
-      Contract.Requires(oldBindings != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VariableBindings bindings = oldBindings.Clone();
-
-      // determine the bound vars that actually occur in the body or
-      // in any of the triggers (if some variables do not occur, we
-      // need to take special care of type parameters that only occur
-      // in the types of such variables)
-      FreeVariableCollector coll = new FreeVariableCollector();
-      coll.Collect(node.Body);
-      foreach (VCTrigger trigger in node.Triggers) {
-        if (trigger.Pos)
-          foreach (VCExpr/*!*/ e in trigger.Exprs) {
-            Contract.Assert(e != null);
-
-            coll.Collect(e);
-          }
-      }
-
-      List<VCExprVar/*!*/> occurringVars = new List<VCExprVar/*!*/>(node.BoundVars.Count);
-      foreach (VCExprVar var in node.BoundVars)
-        if (coll.FreeTermVars.ContainsKey(var))
-          occurringVars.Add(var);
-
-      occurringVars.TrimExcess();
-
-      // bound term variables are replaced with bound term variables typed in
-      // a simpler way
-      List<VCExprVar/*!*/>/*!*/ newBoundVars =
-        BoundVarsAfterErasure(occurringVars, bindings);
-      Contract.Assert(cce.NonNullElements(newBoundVars));
-      VCExpr/*!*/ newNode = HandleQuantifier(node, occurringVars,
-                                         newBoundVars, bindings);
-      Contract.Assert(newNode != null);
-
-      if (!(newNode is VCExprQuantifier) || !IsUniversalQuantifier(node))
-        return newNode;
-
-      VariableBindings bindings2;
-      if (!RedoQuantifier(node, (VCExprQuantifier)newNode, occurringVars, oldBindings,
-                          out bindings2, out newBoundVars))
-        return newNode;
-
-      return HandleQuantifier(node, occurringVars,
-                              newBoundVars, bindings2);
-    }
-
-    private VCExpr/*!*/ GenTypePremisses(List<VCExprVar/*!*/>/*!*/ oldBoundVars,
-                                     List<VCExprVar/*!*/>/*!*/ newBoundVars,
-                                     IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/
-                                                             typeVarTranslation,
-                                     List<VCExprLetBinding/*!*/>/*!*/ typeVarBindings,
-                                     out List<VCTrigger/*!*/>/*!*/ triggers) {
-      Contract.Requires(cce.NonNullElements(oldBoundVars));
-      Contract.Requires(cce.NonNullElements(newBoundVars));
-      Contract.Requires(cce.NonNullDictionaryAndValues(typeVarTranslation));
-      Contract.Requires(cce.NonNullElements(typeVarBindings));
-      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out triggers)));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      // build a substitution of the type variables that it can be checked
-      // whether type premisses are trivial
-      VCExprSubstitution/*!*/ typeParamSubstitution = new VCExprSubstitution();
-      foreach (VCExprLetBinding/*!*/ binding in typeVarBindings) {
-        Contract.Assert(binding != null);
-        typeParamSubstitution[binding.V] = binding.E;
-      }
-      SubstitutingVCExprVisitor/*!*/ substituter = new SubstitutingVCExprVisitor(Gen);
-      Contract.Assert(substituter != null);
-
-      List<VCExpr/*!*/>/*!*/ typePremisses = new List<VCExpr/*!*/>(newBoundVars.Count);
-      triggers = new List<VCTrigger/*!*/>(newBoundVars.Count);
-
-      for (int i = 0; i < newBoundVars.Count; ++i) {
-        VCExprVar/*!*/ oldVar = oldBoundVars[i];
-        Contract.Assert(oldVar != null);
-        VCExprVar/*!*/ newVar = newBoundVars[i];
-        Contract.Assert(newVar != null);
-
-        VCExpr/*!*/ typePremiss =
-          AxBuilderPremisses.GenVarTypeAxiom(newVar, oldVar.Type,
-                                             typeVarTranslation);
-        Contract.Assert(typePremiss != null);
-        if (!IsTriviallyTrue(substituter.Mutate(typePremiss,
-                                                typeParamSubstitution))) {
-          typePremisses.Add(typePremiss);
-          // generate a negative trigger for the variable occurrence
-          // in the type premiss
-          triggers.Add(Gen.Trigger(false,
-                         HelperFuns.ToList(AxBuilderPremisses.TypeOf(newVar))));
-        }
-      }
-
-      typePremisses.TrimExcess();
-      triggers.TrimExcess();
-
-      return Gen.NAry(VCExpressionGenerator.AndOp, typePremisses);
-    }
-
-    // these optimisations should maybe be moved into a separate
-    // visitor (peep-hole optimisations)
-    private bool IsTriviallyTrue(VCExpr expr) {
-      Contract.Requires(expr != null);
-      if (expr.Equals(VCExpressionGenerator.True))
-        return true;
-
-      if (expr is VCExprNAry) {
-        VCExprNAry/*!*/ naryExpr = (VCExprNAry)expr;
-        Contract.Assert(naryExpr != null);
-        if (naryExpr.Op.Equals(VCExpressionGenerator.EqOp) &&
-            naryExpr[0].Equals(naryExpr[1]))
-          return true;
-      }
-
-      return false;
-    }
-
-    private VCExpr HandleQuantifier(VCExprQuantifier node, List<VCExprVar/*!*/>/*!*/ occurringVars/*!*/, List<VCExprVar/*!*/>/*!*/ newBoundVars, VariableBindings bindings) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(node != null);
-      Contract.Requires(cce.NonNullElements(occurringVars/*!*/));
-      Contract.Requires(cce.NonNullElements(newBoundVars));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<VCExprLetBinding/*!*/>/*!*/ typeVarBindings =
-        AxBuilderPremisses.GenTypeParamBindings(node.TypeParameters, occurringVars, bindings, true);
-      Contract.Assert(typeVarBindings != null);
-      // Check whether some of the type parameters could not be
-      // determined from the bound variable types. In this case, we
-      // quantify explicitly over these variables
-      if (typeVarBindings.Count < node.TypeParameters.Count) {
-        foreach (TypeVariable/*!*/ var in node.TypeParameters) {
-          Contract.Assert(var != null);
-          if (typeVarBindings.All(b => !b.V.Equals(var)))
-            newBoundVars.Add((VCExprVar)bindings.TypeVariableBindings[var]);
-        }
-      }
-
-      // the lists of old and new bound variables for which type
-      // antecedents are to be generated
-      List<VCExprVar/*!*/>/*!*/ varsWithTypeSpecs = new List<VCExprVar/*!*/>();
-      List<VCExprVar/*!*/>/*!*/ newVarsWithTypeSpecs = new List<VCExprVar/*!*/>();
-      if (!IsUniversalQuantifier(node) ||
-          CommandLineOptions.Clo.TypeEncodingMethod
-                == CommandLineOptions.TypeEncoding.Predicates) {
-        foreach (VCExprVar/*!*/ oldVar in occurringVars) {
-          Contract.Assert(oldVar != null);
-          varsWithTypeSpecs.Add(oldVar);
-          newVarsWithTypeSpecs.Add(bindings.VCExprVarBindings[oldVar]);
-        }
-      } // else, no type antecedents are created for any variables
-
-      List<VCTrigger/*!*/>/*!*/ furtherTriggers;
-      VCExpr/*!*/ typePremisses =
-        GenTypePremisses(varsWithTypeSpecs, newVarsWithTypeSpecs,
-                         bindings.TypeVariableBindings,
-                         typeVarBindings, out furtherTriggers);
-
-      Contract.Assert(cce.NonNullElements(furtherTriggers));
-      Contract.Assert(typePremisses != null);
-      List<VCTrigger/*!*/>/*!*/ newTriggers = MutateTriggers(node.Triggers, bindings);
-      Contract.Assert(cce.NonNullElements(newTriggers));
-      newTriggers.AddRange(furtherTriggers);
-      newTriggers = AddLets2Triggers(newTriggers, typeVarBindings);
-
-      VCExpr/*!*/ newBody = Mutate(node.Body, bindings);
-      Contract.Assert(newBody != null);
-
-      // assemble the new quantified formula
-
-      if (CommandLineOptions.Clo.TypeEncodingMethod
-                == CommandLineOptions.TypeEncoding.None) {
-        typePremisses = VCExpressionGenerator.True;
-      }
-
-      VCExpr/*!*/ bodyWithPremisses =
-        AxBuilderPremisses.AddTypePremisses(typeVarBindings, typePremisses,
-                                            node.Quan == Quantifier.ALL,
-                                            AxBuilder.Cast(newBody, Type.Bool));
-      Contract.Assert(bodyWithPremisses != null);
-      if (newBoundVars.Count == 0)  // might happen that no bound variables are left
-        return bodyWithPremisses;
-
-      foreach (VCExprVar/*!*/ v in newBoundVars) {
-        Contract.Assert(v != null);
-        if (v.Type == AxBuilderPremisses.U) {
-          newTriggers.Add(Gen.Trigger(false, AxBuilderPremisses.Cast(v, Type.Int)));
-          newTriggers.Add(Gen.Trigger(false, AxBuilderPremisses.Cast(v, Type.Bool)));
-        }
-      }
-
-      return Gen.Quantify(node.Quan, new List<TypeVariable/*!*/>(), newBoundVars,
-                          newTriggers, node.Infos, bodyWithPremisses);
-    }
-
-    // check whether we need to add let-binders for any of the type
-    // parameters to the triggers (otherwise, the triggers will
-    // contain unbound/dangling variables for such parameters)
-    private List<VCTrigger/*!*/>/*!*/ AddLets2Triggers(List<VCTrigger/*!*/>/*!*/ triggers/*!*/, List<VCExprLetBinding/*!*/>/*!*/ typeVarBindings) {
-      Contract.Requires(cce.NonNullElements(triggers/*!*/));
-      Contract.Requires(cce.NonNullElements(typeVarBindings));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCTrigger>>()));
-      List<VCTrigger/*!*/>/*!*/ triggersWithLets = new List<VCTrigger/*!*/>(triggers.Count);
-
-      foreach (VCTrigger/*!*/ t in triggers) {
-        Contract.Assert(t != null);
-        List<VCExpr/*!*/>/*!*/ exprsWithLets = new List<VCExpr/*!*/>(t.Exprs.Count);
-
-        bool changed = false;
-        foreach (VCExpr/*!*/ e in t.Exprs) {
-          Contract.Assert(e != null);
-          Dictionary<VCExprVar/*!*/, object>/*!*/ freeVars =
-                      FreeVariableCollector.FreeTermVariables(e);
-          Contract.Assert(freeVars != null && cce.NonNullElements(freeVars.Keys));
-          if (typeVarBindings.Any(b => freeVars.ContainsKey(b.V))) {
-            exprsWithLets.Add(Gen.Let(typeVarBindings, e));
-            changed = true;
-          } else {
-            exprsWithLets.Add(e);
-          }
-        }
-
-        if (changed)
-          triggersWithLets.Add(Gen.Trigger(t.Pos, exprsWithLets));
-        else
-          triggersWithLets.Add(t);
-      }
-
-      return triggersWithLets;
-    }
-
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  public class OpTypeEraserPremisses : OpTypeEraser
-  {
-
-    private TypeAxiomBuilderPremisses/*!*/ AxBuilderPremisses;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(AxBuilderPremisses != null);
-    }
-
-
-    public OpTypeEraserPremisses(TypeEraserPremisses eraser, TypeAxiomBuilderPremisses axBuilder, VCExpressionGenerator gen)
-      : base(eraser, axBuilder, gen) {
-      Contract.Requires(gen != null);
-      Contract.Requires(axBuilder != null);
-      Contract.Requires(eraser != null);
-      this.AxBuilderPremisses = axBuilder;
-    }
-
-    private VCExpr HandleFunctionOp(Function newFun, List<Type/*!*/>/*!*/ typeArgs/*!*/, IEnumerable<VCExpr/*!*/>/*!*/ oldArgs, VariableBindings bindings) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(newFun != null);
-      Contract.Requires(cce.NonNullElements(typeArgs/*!*/));
-      Contract.Requires(cce.NonNullElements(oldArgs));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      // UGLY: the code for tracking polarities should be factored out
-      int oldPolarity = Eraser.Polarity;
-      Eraser.Polarity = 0;
-
-      List<VCExpr/*!*/>/*!*/ newArgs = new List<VCExpr/*!*/>(typeArgs.Count);
-
-      // translate the explicit type arguments
-      foreach (Type/*!*/ t in typeArgs) {
-        Contract.Assert(t != null);
-        newArgs.Add(AxBuilder.Type2Term(t, bindings.TypeVariableBindings));
-      }
-
-      // recursively translate the value arguments
-      foreach (VCExpr/*!*/ arg in oldArgs) {
-        Contract.Assert(arg != null);
-        Type/*!*/ newType = cce.NonNull(newFun.InParams[newArgs.Count]).TypedIdent.Type;
-        newArgs.Add(AxBuilder.Cast(Eraser.Mutate(arg, bindings), newType));
-      }
-
-      Eraser.Polarity = oldPolarity;
-      return Gen.Function(newFun, newArgs);
-    }
-
-    public override VCExpr/*!*/ VisitSelectOp(VCExprNAry/*!*/ node,
-                                             VariableBindings/*!*/ bindings) {
-      Contract.Requires(node != null); Contract.Requires(bindings != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      MapType/*!*/ mapType = node[0].Type.AsMap;
-      Contract.Assert(mapType != null);
-      List<Type>/*!*/ instantiations; // not used
-      Function/*!*/ select =
-        AxBuilder.MapTypeAbstracter.Select(mapType, out instantiations);
-      Contract.Assert(select != null);
-
-      List<int>/*!*/ explicitTypeParams =
-        AxBuilderPremisses.MapTypeAbstracterPremisses
-                          .ExplicitSelectTypeParams(mapType);
-      Contract.Assert(select.InParams.Count == explicitTypeParams.Count + node.Arity);
-
-      List<Type/*!*/>/*!*/ typeArgs = new List<Type/*!*/>(explicitTypeParams.Count);
-      foreach (int i in explicitTypeParams)
-        typeArgs.Add(node.TypeArguments[i]);
-      return HandleFunctionOp(select, typeArgs, node, bindings);
-    }
-
-    public override VCExpr VisitStoreOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      List<Type>/*!*/ instantiations; // not used
-      Function/*!*/ store =
-        AxBuilder.MapTypeAbstracter.Store(node[0].Type.AsMap, out instantiations);
-      Contract.Assert(store != null);
-      return HandleFunctionOp(store,
-        // the store function never has explicit
-        // type parameters
-                              new List<Type/*!*/>(),
-                              node, bindings);
-    }
-
-    public override VCExpr VisitBoogieFunctionOp(VCExprNAry node, VariableBindings bindings) {
-      Contract.Requires(bindings != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      Function/*!*/ oriFun = ((VCExprBoogieFunctionOp)node.Op).Func;
-      Contract.Assert(oriFun != null);
-      UntypedFunction untypedFun = AxBuilderPremisses.Typed2Untyped(oriFun);
-      Contract.Assert(untypedFun.Fun.InParams.Count ==
-             untypedFun.ExplicitTypeParams.Count + node.Arity);
-
-      List<Type/*!*/>/*!*/ typeArgs =
-        ExtractTypeArgs(node,
-                        oriFun.TypeParameters, untypedFun.ExplicitTypeParams);
-      return HandleFunctionOp(untypedFun.Fun, typeArgs, node, bindings);
-    }
-
-    private List<Type/*!*/>/*!*/ ExtractTypeArgs(VCExprNAry node, List<TypeVariable> allTypeParams, List<TypeVariable/*!*/>/*!*/ explicitTypeParams) {
-      Contract.Requires(allTypeParams != null);
-      Contract.Requires(node != null);
-      Contract.Requires(cce.NonNullElements(explicitTypeParams));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
-      List<Type/*!*/>/*!*/ res = new List<Type/*!*/>(explicitTypeParams.Count);
-      foreach (TypeVariable/*!*/ var in explicitTypeParams) {
-        Contract.Assert(var != null);
-        // this lookup could be optimised
-        res.Add(node.TypeArguments[allTypeParams.IndexOf(var)]);
-      }
-      return res;
-    }
-  }
-
-
-}
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+using Microsoft.Boogie.VCExprAST;
+
+// Erasure of types using premisses   (forall x :: type(x)=T ==> p(x))
+
+namespace Microsoft.Boogie.TypeErasure
+{
+  using Microsoft.Boogie.VCExprAST;
+
+  // When using type premisses, we can distinguish two kinds of type
+  // parameters of a function or map: parameters that occur in the
+  // formal argument types of the function are "implicit" because they
+  // can be inferred from the actual argument types; parameters that
+  // only occur in the result type of the function are "explicit"
+  // because they are not inferrable and have to be given to the
+  // function as additional arguments.
+  //
+  // The following structure is used to store the untyped version of a
+  // typed function, together with the lists of implicit and explicit
+  // type parameters (in the same order as they occur in the signature
+  // of the original function).
+
+  internal struct UntypedFunction
+  {
+    public readonly Function/*!*/ Fun;
+    // type parameters that can be extracted from the value parameters
+    public readonly List<TypeVariable/*!*/>/*!*/ ImplicitTypeParams;
+    // type parameters that have to be given explicitly
+    public readonly List<TypeVariable/*!*/>/*!*/ ExplicitTypeParams;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Fun != null);
+      Contract.Invariant(cce.NonNullElements(ImplicitTypeParams));
+      Contract.Invariant(cce.NonNullElements(ExplicitTypeParams));
+    }
+
+
+    public UntypedFunction(Function/*!*/ fun,
+                           List<TypeVariable/*!*/>/*!*/ implicitTypeParams,
+                           List<TypeVariable/*!*/>/*!*/ explicitTypeParams) {
+      Contract.Requires(fun != null);
+      Contract.Requires(cce.NonNullElements(implicitTypeParams));
+      Contract.Requires(cce.NonNullElements(explicitTypeParams));
+      Fun = fun;
+      ImplicitTypeParams = implicitTypeParams;
+      ExplicitTypeParams = explicitTypeParams;
+    }
+  }
+
+  public class TypeAxiomBuilderPremisses : TypeAxiomBuilderIntBoolU
+  {
+
+    public TypeAxiomBuilderPremisses(VCExpressionGenerator gen)
+      : base(gen) {
+      Contract.Requires(gen != null);
+
+      TypeFunction = HelperFuns.BoogieFunction("dummy", Type.Int);
+      Typed2UntypedFunctions = new Dictionary<Function/*!*/, UntypedFunction>();
+      MapTypeAbstracterAttr = null;
+    }
+
+    // constructor to allow cloning
+    [NotDelayed]
+    internal TypeAxiomBuilderPremisses(TypeAxiomBuilderPremisses builder)
+      : base(builder) {
+      Contract.Requires(builder != null);
+      TypeFunction = builder.TypeFunction;
+      Typed2UntypedFunctions =
+        new Dictionary<Function/*!*/, UntypedFunction>(builder.Typed2UntypedFunctions);
+
+      MapTypeAbstracterAttr =
+        builder.MapTypeAbstracterAttr == null ?
+        null : new MapTypeAbstractionBuilderPremisses(this, builder.Gen,
+                                                      builder.MapTypeAbstracterAttr);
+    }
+
+    public override Object Clone() {
+      Contract.Ensures(Contract.Result<Object>() != null);
+      return new TypeAxiomBuilderPremisses(this);
+    }
+
+    public override void Setup() {
+      TypeFunction = HelperFuns.BoogieFunction("type", U, T);
+      base.Setup();
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    // generate axioms of the kind "forall x:U. {Int2U(U2Int(x))}
+    //                                          type(x)=int ==> Int2U(U2Int(x))==x"
+    protected override VCExpr GenReverseCastAxiom(Function castToU, Function castFromU) {
+      //Contract.Requires(castFromU != null);
+      //Contract.Requires(castToU != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<VCTrigger/*!*/>/*!*/ triggers;
+      VCExprVar/*!*/ var;
+      VCExpr/*!*/ eq = GenReverseCastEq(castToU, castFromU, out var, out triggers);
+      Contract.Assert(cce.NonNullElements(triggers));
+      Contract.Assert(var != null);
+      Contract.Assert(eq != null);
+      VCExpr/*!*/ premiss;
+      if (CommandLineOptions.Clo.TypeEncodingMethod
+              == CommandLineOptions.TypeEncoding.None)
+        premiss = VCExpressionGenerator.True;
+      else
+        premiss = GenVarTypeAxiom(var, cce.NonNull(castFromU.OutParams[0]).TypedIdent.Type,
+          // we don't have any bindings available
+                                  new Dictionary<TypeVariable/*!*/, VCExpr/*!*/>());
+      VCExpr/*!*/ matrix = Gen.ImpliesSimp(premiss, eq);
+      Contract.Assert(matrix != null);
+      return Gen.Forall(HelperFuns.ToList(var), triggers, "cast:" + castFromU.Name, -1, matrix);
+    }
+
+    protected override VCExpr GenCastTypeAxioms(Function castToU, Function castFromU) {
+      //Contract.Requires(castFromU != null);
+      //Contract.Requires(castToU != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      Type/*!*/ fromType = cce.NonNull(castToU.InParams[0]).TypedIdent.Type;
+      return GenFunctionAxiom(castToU, new List<TypeVariable/*!*/>(), new List<TypeVariable/*!*/>(),
+                              HelperFuns.ToList(fromType), fromType);
+    }
+
+    private MapTypeAbstractionBuilderPremisses MapTypeAbstracterAttr;
+
+    internal override MapTypeAbstractionBuilder/*!*/ MapTypeAbstracter {
+      get {
+        Contract.Ensures(Contract.Result<MapTypeAbstractionBuilder>() != null);
+
+        if (MapTypeAbstracterAttr == null)
+          MapTypeAbstracterAttr = new MapTypeAbstractionBuilderPremisses(this, Gen);
+        return MapTypeAbstracterAttr;
+      }
+    }
+
+    internal MapTypeAbstractionBuilderPremisses/*!*/ MapTypeAbstracterPremisses {
+      get {
+        Contract.Ensures(Contract.Result<MapTypeAbstractionBuilderPremisses>() != null);
+
+        return (MapTypeAbstractionBuilderPremisses)MapTypeAbstracter;
+      }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    // function that maps individuals to their type
+    // the field is overwritten with its actual value in "Setup"
+    private Function/*!*/ TypeFunction;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(TypeFunction != null);
+    }
+
+
+    public VCExpr TypeOf(VCExpr expr) {
+      Contract.Requires(expr != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Gen.Function(TypeFunction, expr);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Generate type premisses and type parameter bindings for quantifiers, functions, procedures
+
+    // let-bindings to extract the instantiations of type parameters
+    public List<VCExprLetBinding/*!*/>/*!*/
+           GenTypeParamBindings(// the original bound variables and (implicit) type parameters
+                                List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ oldBoundVars,
+      // VariableBindings to which the translation
+      // TypeVariable -> VCExprVar is added
+                                VariableBindings/*!*/ bindings,
+                                bool addTypeVarsToBindings) {
+      Contract.Requires(typeParams != null);
+      Contract.Requires(cce.NonNullElements(oldBoundVars));
+      Contract.Requires(bindings != null);
+
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprLetBinding>>()));
+
+      // type variables are replaced with ordinary variables that are bound using a
+      // let-expression
+      if (addTypeVarsToBindings) {
+        foreach (TypeVariable/*!*/ tvar in typeParams) {
+          Contract.Assert(tvar != null);
+          bindings.TypeVariableBindings.Add(tvar, Gen.Variable(tvar.Name, T));
+        }
+      }
+
+      // extract the values of type variables from the term variables
+      List<VCExprVar/*!*/>/*!*/ UtypedVars = new List<VCExprVar/*!*/>(oldBoundVars.Count);
+      List<Type/*!*/>/*!*/ originalTypes = new List<Type/*!*/>(oldBoundVars.Count);
+      foreach (VCExprVar var in oldBoundVars) {
+        VCExprVar/*!*/ newVar = bindings.VCExprVarBindings[var];
+        if (newVar.Type.Equals(U)) {
+          UtypedVars.Add(newVar);
+          originalTypes.Add(var.Type);
+        }
+      }
+
+      UtypedVars.TrimExcess();
+      originalTypes.TrimExcess();
+
+      return BestTypeVarExtractors(typeParams, originalTypes, UtypedVars, bindings);
+    }
+
+
+    public VCExpr/*!*/ AddTypePremisses(List<VCExprLetBinding/*!*/>/*!*/ typeVarBindings,
+                                    VCExpr/*!*/ typePremisses, bool universal,
+                                    VCExpr/*!*/ body) {
+      Contract.Requires(cce.NonNullElements(typeVarBindings));
+      Contract.Requires(typePremisses != null);
+      Contract.Requires(body != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      VCExpr/*!*/ bodyWithPremisses;
+      if (universal)
+        bodyWithPremisses = Gen.ImpliesSimp(typePremisses, body);
+      else
+        bodyWithPremisses = Gen.AndSimp(typePremisses, body);
+
+      return Gen.Let(typeVarBindings, bodyWithPremisses);
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Extract the instantiations of type variables from the concrete types of
+    // term variables. E.g., for a function  f<a>(x : C a), we would extract the
+    // instantiation of "a" by looking at the concrete type of "x".
+
+    public List<VCExprLetBinding/*!*/>/*!*/
+           BestTypeVarExtractors(List<TypeVariable/*!*/>/*!*/ vars, List<Type/*!*/>/*!*/ types,
+                                 List<VCExprVar/*!*/>/*!*/ concreteTypeSources,
+                                 VariableBindings/*!*/ bindings) {
+      Contract.Requires(cce.NonNullElements(vars));
+      Contract.Requires(cce.NonNullElements(types));
+      Contract.Requires(cce.NonNullElements(concreteTypeSources));
+      Contract.Requires(bindings != null);
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprLetBinding>>()));
+
+      List<VCExprLetBinding/*!*/>/*!*/ typeParamBindings = new List<VCExprLetBinding/*!*/>();
+      foreach (TypeVariable/*!*/ var in vars) {
+        Contract.Assert(var != null);
+        VCExpr extractor = BestTypeVarExtractor(var, types, concreteTypeSources);
+        if (extractor != null)
+          typeParamBindings.Add(
+            Gen.LetBinding((VCExprVar)bindings.TypeVariableBindings[var],
+                           extractor));
+      }
+      return typeParamBindings;
+    }
+
+    private VCExpr BestTypeVarExtractor(TypeVariable/*!*/ var, List<Type/*!*/>/*!*/ types,
+                                        List<VCExprVar/*!*/>/*!*/ concreteTypeSources) {
+      Contract.Requires(var != null);
+      Contract.Requires(cce.NonNullElements(types));
+      Contract.Requires(cce.NonNullElements(concreteTypeSources));
+      List<VCExpr/*!*/> allExtractors = TypeVarExtractors(var, types, concreteTypeSources);
+      Contract.Assert(cce.NonNullElements(allExtractors));
+      if (allExtractors.Count == 0)
+        return null;
+
+      VCExpr bestExtractor = allExtractors[0];
+      int bestExtractorSize = SizeComputingVisitor.ComputeSize(bestExtractor);
+      for (int i = 1; i < allExtractors.Count; ++i) {
+        int newSize = SizeComputingVisitor.ComputeSize(allExtractors[i]);
+        if (newSize < bestExtractorSize) {
+          bestExtractor = allExtractors[i];
+          bestExtractorSize = newSize;
+        }
+      }
+
+      return bestExtractor;
+    }
+
+    private List<VCExpr/*!*/>/*!*/ TypeVarExtractors(TypeVariable/*!*/ var, List<Type/*!*/>/*!*/ types,
+                                             List<VCExprVar/*!*/>/*!*/ concreteTypeSources) {
+      Contract.Requires(var != null);
+      Contract.Requires(cce.NonNullElements(types));
+      Contract.Requires(cce.NonNullElements(concreteTypeSources));
+      Contract.Requires((types.Count == concreteTypeSources.Count));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
+      List<VCExpr/*!*/>/*!*/ res = new List<VCExpr/*!*/>();
+      for (int i = 0; i < types.Count; ++i)
+        TypeVarExtractors(var, types[i], TypeOf(concreteTypeSources[i]), res);
+
+      return res;
+    }
+
+    private void TypeVarExtractors(TypeVariable var, Type completeType, VCExpr innerTerm, List<VCExpr/*!*/>/*!*/ extractors) {
+      Contract.Requires(innerTerm != null);
+      Contract.Requires(completeType != null);
+      Contract.Requires(var != null);
+      Contract.Requires(cce.NonNullElements(extractors));
+      if (completeType.IsVariable) {
+        if (var.Equals(completeType)) {
+          extractors.Add(innerTerm);
+        }  // else nothing
+      } else if (completeType.IsBasic) {
+        // nothing
+      } else if (completeType.IsCtor) {
+        CtorType/*!*/ ctorType = completeType.AsCtor;
+        if (ctorType.Arguments.Count > 0) {
+          // otherwise there are no chances of extracting any
+          // instantiations from this type
+          TypeCtorRepr repr = GetTypeCtorReprStruct(ctorType.Decl);
+          for (int i = 0; i < ctorType.Arguments.Count; ++i) {
+            VCExpr/*!*/ newInnerTerm = Gen.Function(repr.Dtors[i], innerTerm);
+            Contract.Assert(newInnerTerm != null);
+            TypeVarExtractors(var, ctorType.Arguments[i], newInnerTerm, extractors);
+          }
+        }
+      } else if (completeType.IsMap) {
+        TypeVarExtractors(var, MapTypeAbstracter.AbstractMapType(completeType.AsMap),
+                          innerTerm, extractors);
+      } else {
+        System.Diagnostics.Debug.Fail("Don't know how to handle this type: " + completeType);
+      }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Symbols for representing functions
+
+    // Globally defined functions
+    private readonly IDictionary<Function/*!*/, UntypedFunction/*!*/>/*!*/ Typed2UntypedFunctions;
+    [ContractInvariantMethod]
+    void Typed2UntypedFunctionsInvariantMethod() {
+      Contract.Invariant(Typed2UntypedFunctions != null);
+    }
+
+    // distinguish between implicit and explicit type parameters
+    internal static void SeparateTypeParams(List<Type/*!*/>/*!*/ valueArgumentTypes,
+                                            List<TypeVariable>/*!*/ allTypeParams,
+                                            out List<TypeVariable/*!*/>/*!*/ implicitParams,
+                                            out List<TypeVariable/*!*/>/*!*/ explicitParams) {
+      Contract.Requires(cce.NonNullElements(valueArgumentTypes));
+      Contract.Requires(allTypeParams != null);
+      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out implicitParams)));
+      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out explicitParams)));
+      List<TypeVariable>/*!*/ varsInInParamTypes = new List<TypeVariable>();
+      foreach (Type/*!*/ t in valueArgumentTypes) {
+        Contract.Assert(t != null);
+        varsInInParamTypes.AppendWithoutDups(t.FreeVariables);
+      }
+
+      implicitParams = new List<TypeVariable/*!*/>(allTypeParams.Count);
+      explicitParams = new List<TypeVariable/*!*/>(allTypeParams.Count);
+
+      foreach (TypeVariable/*!*/ var in allTypeParams) {
+        Contract.Assert(var != null);
+        if (varsInInParamTypes.Contains(var))
+          implicitParams.Add(var);
+        else
+          explicitParams.Add(var);
+      }
+
+      implicitParams.TrimExcess();
+      explicitParams.TrimExcess();
+    }
+
+    internal UntypedFunction Typed2Untyped(Function fun) {
+      Contract.Requires(fun != null);
+      UntypedFunction res;
+      if (!Typed2UntypedFunctions.TryGetValue(fun, out res)) {
+        Contract.Assert(fun.OutParams.Count == 1);
+
+        // if all of the parameters are int or bool, the function does
+        // not have to be changed
+        if (fun.InParams.All(param => UnchangedType(cce.NonNull(param).TypedIdent.Type)) &&
+            UnchangedType(cce.NonNull(fun.OutParams[0]).TypedIdent.Type) &&
+            fun.TypeParameters.Count == 0) {
+          res = new UntypedFunction(fun, new List<TypeVariable/*!*/>(), new List<TypeVariable/*!*/>());
+        } else {
+          List<Type/*!*/>/*!*/ argTypes = new List<Type/*!*/>();
+          foreach (Variable/*!*/ v in fun.InParams) {
+            Contract.Assert(v != null);
+            argTypes.Add(v.TypedIdent.Type);
+          }
+
+          List<TypeVariable/*!*/>/*!*/ implicitParams, explicitParams;
+          SeparateTypeParams(argTypes, fun.TypeParameters, out implicitParams, out explicitParams);
+
+          Type[]/*!*/ types = new Type[explicitParams.Count + fun.InParams.Count + 1];
+          int i = 0;
+          for (int j = 0; j < explicitParams.Count; ++j) {
+            types[i] = T;
+            i = i + 1;
+          }
+          for (int j = 0; j < fun.InParams.Count; ++i, ++j)
+            types[i] = TypeAfterErasure(cce.NonNull(fun.InParams[j]).TypedIdent.Type);
+          types[types.Length - 1] = TypeAfterErasure(cce.NonNull(fun.OutParams[0]).TypedIdent.Type);
+
+          Function/*!*/ untypedFun = HelperFuns.BoogieFunction(fun.Name, types);
+          Contract.Assert(untypedFun != null);
+          untypedFun.Attributes = fun.Attributes;
+          res = new UntypedFunction(untypedFun, implicitParams, explicitParams);
+          if (U.Equals(types[types.Length - 1]))
+            AddTypeAxiom(GenFunctionAxiom(res, fun));
+        }
+
+        Typed2UntypedFunctions.Add(fun, res);
+      }
+      return res;
+    }
+
+    private VCExpr GenFunctionAxiom(UntypedFunction fun, Function originalFun) {
+      Contract.Requires(originalFun != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<Type/*!*/>/*!*/ originalInTypes = new List<Type/*!*/>(originalFun.InParams.Count);
+      foreach (Formal/*!*/ f in originalFun.InParams)
+        originalInTypes.Add(f.TypedIdent.Type);
+
+      return GenFunctionAxiom(fun.Fun, fun.ImplicitTypeParams, fun.ExplicitTypeParams,
+                              originalInTypes,
+                              cce.NonNull(originalFun.OutParams[0]).TypedIdent.Type);
+    }
+
+    internal VCExpr/*!*/ GenFunctionAxiom(Function/*!*/ fun,
+                                      List<TypeVariable/*!*/>/*!*/ implicitTypeParams,
+                                      List<TypeVariable/*!*/>/*!*/ explicitTypeParams,
+                                      List<Type/*!*/>/*!*/ originalInTypes,
+                                      Type/*!*/ originalResultType) {
+      Contract.Requires(cce.NonNullElements(implicitTypeParams));
+      Contract.Requires(fun != null);
+      Contract.Requires(cce.NonNullElements(explicitTypeParams));
+      Contract.Requires(cce.NonNullElements(originalInTypes));
+      Contract.Requires(originalResultType != null);
+      Contract.Requires(originalInTypes.Count + explicitTypeParams.Count == fun.InParams.Count);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      if (CommandLineOptions.Clo.TypeEncodingMethod == CommandLineOptions.TypeEncoding.None) {
+        return VCExpressionGenerator.True;
+      }
+
+      List<VCExprVar/*!*/>/*!*/ typedInputVars = new List<VCExprVar/*!*/>(originalInTypes.Count);
+      int i = 0;
+      foreach (Type/*!*/ t in originalInTypes) {
+        Contract.Assert(t != null);
+        typedInputVars.Add(Gen.Variable("arg" + i, t));
+        i = i + 1;
+      }
+
+      VariableBindings/*!*/ bindings = new VariableBindings();
+
+      // type parameters that have to be given explicitly are replaced
+      // with universally quantified type variables
+      List<VCExprVar/*!*/>/*!*/ boundVars = new List<VCExprVar/*!*/>(explicitTypeParams.Count + typedInputVars.Count);
+      foreach (TypeVariable/*!*/ var in explicitTypeParams) {
+        Contract.Assert(var != null);
+        VCExprVar/*!*/ newVar = Gen.Variable(var.Name, T);
+        boundVars.Add(newVar);
+        bindings.TypeVariableBindings.Add(var, newVar);
+      }
+
+      // bound term variables are replaced with bound term variables typed in
+      // a simpler way
+      foreach (VCExprVar/*!*/ var in typedInputVars) {
+        Contract.Assert(var != null);
+        Type/*!*/ newType = TypeAfterErasure(var.Type);
+        Contract.Assert(newType != null);
+        VCExprVar/*!*/ newVar = Gen.Variable(var.Name, newType);
+        Contract.Assert(newVar != null);
+        boundVars.Add(newVar);
+        bindings.VCExprVarBindings.Add(var, newVar);
+      }
+
+      List<VCExprLetBinding/*!*/> typeVarBindings =
+        GenTypeParamBindings(implicitTypeParams, typedInputVars, bindings, true);
+      Contract.Assert(cce.NonNullElements(typeVarBindings));
+
+      VCExpr/*!*/ funApp = Gen.Function(fun, HelperFuns.ToVCExprList(boundVars));
+      Contract.Assert(funApp != null);
+      VCExpr/*!*/ conclusion = Gen.Eq(TypeOf(funApp),
+                                  Type2Term(originalResultType, bindings.TypeVariableBindings));
+      Contract.Assert(conclusion != null);
+      VCExpr conclusionWithPremisses =
+        // leave out antecedents of function type axioms ... they don't appear necessary,
+        // because a function can always be extended to all U-values (right?)
+        //        AddTypePremisses(typeVarBindings, typePremisses, true, conclusion);
+        Gen.Let(typeVarBindings, conclusion);
+
+      if (boundVars.Count > 0) {
+        List<VCTrigger/*!*/> triggers = HelperFuns.ToList(Gen.Trigger(true, HelperFuns.ToList(funApp)));
+        Contract.Assert(cce.NonNullElements(triggers));
+        return Gen.Forall(boundVars, triggers, "funType:" + fun.Name, -1, conclusionWithPremisses);
+      } else {
+        return conclusionWithPremisses;
+      }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    protected override void AddVarTypeAxiom(VCExprVar var, Type originalType) {
+      //Contract.Requires(originalType != null);
+      //Contract.Requires(var != null);
+      if (CommandLineOptions.Clo.TypeEncodingMethod == CommandLineOptions.TypeEncoding.None) return;
+      AddTypeAxiom(GenVarTypeAxiom(var, originalType,
+        // we don't have any bindings available
+                                   new Dictionary<TypeVariable/*!*/, VCExpr/*!*/>()));
+    }
+
+    public VCExpr GenVarTypeAxiom(VCExprVar var, Type originalType, IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/ varMapping) {
+      Contract.Requires(var != null);
+      Contract.Requires(originalType != null);
+      Contract.Requires(cce.NonNullDictionaryAndValues(varMapping));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      if (!var.Type.Equals(originalType)) {
+        VCExpr/*!*/ typeRepr = Type2Term(originalType, varMapping);
+        return Gen.Eq(TypeOf(var), typeRepr);
+      }
+      return VCExpressionGenerator.True;
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  internal class MapTypeAbstractionBuilderPremisses : MapTypeAbstractionBuilder
+  {
+
+    private readonly TypeAxiomBuilderPremisses/*!*/ AxBuilderPremisses;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(AxBuilderPremisses != null);
+    }
+
+
+    internal MapTypeAbstractionBuilderPremisses(TypeAxiomBuilderPremisses axBuilder, VCExpressionGenerator gen)
+      : base(axBuilder, gen) {
+      Contract.Requires(gen != null);
+      Contract.Requires(axBuilder != null);
+
+      this.AxBuilderPremisses = axBuilder;
+    }
+
+    // constructor for cloning
+    internal MapTypeAbstractionBuilderPremisses(TypeAxiomBuilderPremisses axBuilder, VCExpressionGenerator gen, MapTypeAbstractionBuilderPremisses builder)
+      : base(axBuilder, gen, builder) {
+      Contract.Requires(builder != null);
+      Contract.Requires(gen != null);
+      Contract.Requires(axBuilder != null);
+
+      this.AxBuilderPremisses = axBuilder;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    // Determine the type parameters of a map type that have to be
+    // given explicitly when applying the select function (the
+    // parameters that only occur in the result type of the
+    // map). These parameters are given as a list of indexes sorted in
+    // ascending order; the index i refers to the i'th bound variable
+    // in a type    <a0, a1, ..., an>[...]...
+    public List<int>/*!*/ ExplicitSelectTypeParams(MapType type) {
+      Contract.Requires(type != null);
+      Contract.Ensures(Contract.Result<List<int>>() != null);
+
+      List<int> res;
+      if (!explicitSelectTypeParamsCache.TryGetValue(type, out res)) {
+        List<TypeVariable/*!*/>/*!*/ explicitParams, implicitParams;
+        TypeAxiomBuilderPremisses.SeparateTypeParams(type.Arguments.ToList(),
+                                                     type.TypeParameters,
+                                                     out implicitParams,
+                                                     out explicitParams);
+        res = new List<int>(explicitParams.Count);
+        foreach (TypeVariable/*!*/ var in explicitParams) {
+          Contract.Assert(var != null);
+          res.Add(type.TypeParameters.IndexOf(var));
+        }
+        explicitSelectTypeParamsCache.Add(type, res);
+      }
+      return cce.NonNull(res);
+    }
+
+    private IDictionary<MapType/*!*/, List<int>/*!*/>/*!*/ explicitSelectTypeParamsCache =
+      new Dictionary<MapType/*!*/, List<int>/*!*/>();
+    [ContractInvariantMethod]
+    void ObjectInvarant() {
+      Contract.Invariant(cce.NonNullDictionaryAndValues(explicitSelectTypeParamsCache));
+    }
+
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    protected override void GenSelectStoreFunctions(MapType abstractedType, TypeCtorDecl synonym, out Function/*!*/ select, out Function/*!*/ store) {
+      //Contract.Requires(synonym != null);
+      //Contract.Requires(abstractedType != null);
+      Contract.Ensures(Contract.ValueAtReturn(out select) != null);
+      Contract.Ensures(Contract.ValueAtReturn(out store) != null);
+      Type/*!*/ mapTypeSynonym;
+      List<TypeVariable/*!*/>/*!*/ typeParams;
+      List<Type/*!*/>/*!*/ originalInTypes;
+      GenTypeAxiomParams(abstractedType, synonym, out mapTypeSynonym,
+                         out typeParams, out originalInTypes);
+
+      // select
+      List<TypeVariable/*!*/>/*!*/ explicitSelectParams, implicitSelectParams;
+      select = CreateAccessFun(typeParams, originalInTypes,
+                               abstractedType.Result, synonym.Name + "Select",
+                               out implicitSelectParams, out explicitSelectParams);
+
+      // store, which gets one further argument: the assigned rhs
+      originalInTypes.Add(abstractedType.Result);
+
+      List<TypeVariable/*!*/>/*!*/ explicitStoreParams, implicitStoreParams;
+      store = CreateAccessFun(typeParams, originalInTypes,
+                              mapTypeSynonym, synonym.Name + "Store",
+                              out implicitStoreParams, out explicitStoreParams);
+
+      // the store function does not have any explicit type parameters
+      Contract.Assert(explicitStoreParams.Count == 0);
+
+      if (CommandLineOptions.Clo.UseArrayTheory) {
+        select.AddAttribute("builtin", "select");
+        store.AddAttribute("builtin", "store");
+      } else {
+        AxBuilder.AddTypeAxiom(GenMapAxiom0(select, store,
+                                            abstractedType.Result,
+                                            implicitSelectParams, explicitSelectParams,
+                                            originalInTypes));
+        AxBuilder.AddTypeAxiom(GenMapAxiom1(select, store,
+                                            abstractedType.Result,
+                                            explicitSelectParams));
+      }
+    }
+
+    protected void GenTypeAxiomParams(MapType/*!*/ abstractedType, TypeCtorDecl/*!*/ synonymDecl,
+                                      out Type/*!*/ mapTypeSynonym,
+                                      out List<TypeVariable/*!*/>/*!*/ typeParams,
+                                      out List<Type/*!*/>/*!*/ originalIndexTypes) {
+      Contract.Requires(abstractedType != null);
+      Contract.Requires(synonymDecl != null);
+      Contract.Ensures(Contract.ValueAtReturn(out mapTypeSynonym) != null);
+      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out typeParams)));
+      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out originalIndexTypes)));
+      typeParams = new List<TypeVariable/*!*/>();
+      typeParams.AddRange(abstractedType.TypeParameters);
+      typeParams.AddRange(abstractedType.FreeVariables);
+
+      originalIndexTypes = new List<Type/*!*/>(abstractedType.Arguments.Count + 1);
+      List<Type>/*!*/ mapTypeParams = new List<Type>();
+      foreach (TypeVariable/*!*/ var in abstractedType.FreeVariables) {
+        Contract.Assert(var != null);
+        mapTypeParams.Add(var);
+      }
+
+      if (CommandLineOptions.Clo.MonomorphicArrays)
+        mapTypeSynonym = abstractedType;
+      else
+        mapTypeSynonym = new CtorType(Token.NoToken, synonymDecl, mapTypeParams);
+
+      originalIndexTypes.Add(mapTypeSynonym);
+      originalIndexTypes.AddRange(abstractedType.Arguments.ToList());
+    }
+
+    // method to actually create the select or store function
+    private Function/*!*/ CreateAccessFun(List<TypeVariable/*!*/>/*!*/ originalTypeParams,
+                                      List<Type/*!*/>/*!*/ originalInTypes,
+                                      Type/*!*/ originalResult,
+                                      string/*!*/ name,
+                                      out List<TypeVariable/*!*/>/*!*/ implicitTypeParams, out List<TypeVariable/*!*/>/*!*/ explicitTypeParams) {
+      Contract.Requires(cce.NonNullElements(originalTypeParams));
+      Contract.Requires(cce.NonNullElements(originalInTypes));
+      Contract.Requires(originalResult != null);
+      Contract.Requires(name != null);
+      Contract.Ensures(Contract.Result<Function>() != null);
+      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out implicitTypeParams)));
+      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out explicitTypeParams)));
+
+      // select and store are basically handled like normal functions: the type
+      // parameters are split into the implicit parameters, and into the parameters
+      // that have to be given explicitly
+      TypeAxiomBuilderPremisses.SeparateTypeParams(originalInTypes,
+                                                   new List<TypeVariable>(originalTypeParams),
+                                                   out implicitTypeParams,
+                                                   out explicitTypeParams);
+
+      Type[]/*!*/ ioTypes = new Type[explicitTypeParams.Count + originalInTypes.Count + 1];
+      int i = 0;
+      for (; i < explicitTypeParams.Count; ++i)
+        ioTypes[i] = AxBuilder.T;
+      foreach (Type/*!*/ type in originalInTypes) {
+        Contract.Assert(type != null);
+        if (CommandLineOptions.Clo.Monomorphize && AxBuilder.UnchangedType(type))
+          ioTypes[i] = type;
+        else
+          ioTypes[i] = AxBuilder.U;
+        i++;
+      }
+      if (CommandLineOptions.Clo.Monomorphize && AxBuilder.UnchangedType(originalResult))
+        ioTypes[i] = originalResult;
+      else
+        ioTypes[i] = AxBuilder.U;
+
+      Function/*!*/ res = HelperFuns.BoogieFunction(name, ioTypes);
+      Contract.Assert(res != null);
+
+      if (AxBuilder.U.Equals(ioTypes[i])) {
+        AxBuilder.AddTypeAxiom(
+            AxBuilderPremisses.GenFunctionAxiom(res,
+                                            implicitTypeParams, explicitTypeParams,
+                                            originalInTypes, originalResult));
+      }
+      return res;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // The normal axioms of the theory of arrays (without extensionality)
+
+    private VCExpr/*!*/ Select(Function/*!*/ select,
+      // in general, the select function has to
+      // receive explicit type parameters (which
+      // are here already represented as VCExpr
+      // of type T)
+                           List<VCExpr/*!*/>/*!*/ typeParams,
+                           VCExpr/*!*/ map,
+                           List<VCExprVar/*!*/>/*!*/ indexes) {
+      Contract.Requires(select != null);
+      Contract.Requires(cce.NonNullElements(typeParams));
+      Contract.Requires(map != null);
+      Contract.Requires(cce.NonNullElements(indexes));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      List<VCExpr/*!*/>/*!*/ selectArgs = new List<VCExpr/*!*/>(typeParams.Count + indexes.Count + 1);
+      selectArgs.AddRange(typeParams);
+      selectArgs.Add(map);
+      selectArgs.AddRange(HelperFuns.ToVCExprList(indexes));
+      return Gen.Function(select, selectArgs);
+    }
+
+    private VCExpr Store(Function store, VCExpr map, List<VCExprVar/*!*/>/*!*/ indexes, VCExpr val) {
+      Contract.Requires(val != null);
+      Contract.Requires(map != null);
+      Contract.Requires(store != null);
+      Contract.Requires(cce.NonNullElements(indexes));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<VCExpr/*!*/>/*!*/ storeArgs = new List<VCExpr/*!*/>(indexes.Count + 2);
+      storeArgs.Add(map);
+      storeArgs.AddRange(HelperFuns.ToVCExprList(indexes));
+      storeArgs.Add(val);
+      return Gen.Function(store, storeArgs);
+    }
+
+    /// <summary>
+    /// Generate:
+    ///   (forall m, indexes, val ::
+    ///     type(val) == T ==>
+    ///     select(store(m, indexes, val), indexes) == val)
+    /// where the quantifier body is also enclosed in a let that defines portions of T, if needed.
+    /// </summary>
+    private VCExpr GenMapAxiom0(Function select, Function store, Type mapResult, List<TypeVariable/*!*/>/*!*/ implicitTypeParamsSelect, List<TypeVariable/*!*/>/*!*/ explicitTypeParamsSelect, List<Type/*!*/>/*!*/ originalInTypes) {
+      Contract.Requires(mapResult != null);
+      Contract.Requires(store != null);
+      Contract.Requires(select != null);
+      Contract.Requires(cce.NonNullElements(implicitTypeParamsSelect));
+      Contract.Requires(cce.NonNullElements(originalInTypes));
+      Contract.Requires(cce.NonNullElements(explicitTypeParamsSelect));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      int arity = store.InParams.Count - 2;
+      List<VCExprVar/*!*/> inParams = new List<VCExprVar/*!*/>();
+      List<VCExprVar/*!*/> quantifiedVars = new List<VCExprVar/*!*/>(store.InParams.Count);
+      VariableBindings bindings = new VariableBindings();
+
+      // bound variable:  m
+      VCExprVar typedM = Gen.Variable("m", originalInTypes[0]);
+      VCExprVar m = Gen.Variable("m", AxBuilder.U);
+      inParams.Add(typedM);
+      quantifiedVars.Add(m);
+      bindings.VCExprVarBindings.Add(typedM, m);
+
+      // bound variables:  indexes
+      List<Type/*!*/> origIndexTypes = new List<Type/*!*/>(arity);
+      List<Type/*!*/> indexTypes = new List<Type/*!*/>(arity);
+      for (int i = 1; i < store.InParams.Count - 1; i++) {
+        origIndexTypes.Add(originalInTypes[i]);
+        indexTypes.Add(cce.NonNull(store.InParams[i]).TypedIdent.Type);
+      }
+      Contract.Assert(arity == indexTypes.Count);
+      List<VCExprVar/*!*/> typedArgs = HelperFuns.VarVector("arg", origIndexTypes, Gen);
+      Contract.Assert(cce.NonNullElements(typedArgs));
+      List<VCExprVar/*!*/> indexes = HelperFuns.VarVector("x", indexTypes, Gen);
+      Contract.Assert(cce.NonNullElements(indexes));
+      Contract.Assert(typedArgs.Count == indexes.Count);
+      inParams.AddRange(typedArgs);
+      quantifiedVars.AddRange(indexes);
+      for (int i = 0; i < arity; i++) {
+        bindings.VCExprVarBindings.Add(typedArgs[i], indexes[i]);
+      }
+
+      // bound variable:  val
+      VCExprVar typedVal = Gen.Variable("val", mapResult);
+      VCExprVar val = Gen.Variable("val", cce.NonNull(select.OutParams[0]).TypedIdent.Type);
+      quantifiedVars.Add(val);
+      bindings.VCExprVarBindings.Add(typedVal, val);
+
+      // add all type parameters into bindings
+      foreach (TypeVariable tp in implicitTypeParamsSelect) {
+        VCExprVar tVar = Gen.Variable(tp.Name, AxBuilderPremisses.T);
+        bindings.TypeVariableBindings.Add(tp, tVar);
+      }
+      List<VCExpr/*!*/> typeParams = new List<VCExpr/*!*/>(explicitTypeParamsSelect.Count);
+      foreach (TypeVariable tp in explicitTypeParamsSelect) {
+        VCExprVar tVar = Gen.Variable(tp.Name, AxBuilderPremisses.T);
+        bindings.TypeVariableBindings.Add(tp, tVar);
+        // ... and record these explicit type-parameter arguments in typeParams
+        typeParams.Add(tVar);
+      }
+
+      VCExpr/*!*/ storeExpr = Store(store, m, indexes, val);
+      Contract.Assert(storeExpr != null);
+      VCExpr/*!*/ selectExpr = Select(select, typeParams, storeExpr, indexes);
+      Contract.Assert(selectExpr != null);
+
+      // Create let-binding definitions for all type parameters.
+      // The implicit ones can be phrased in terms of the types of the ordinary in-parameters, and
+      // we want to make sure that they don't get phrased in terms of the out-parameter, so we pass
+      // in inParams here.
+      List<VCExprLetBinding/*!*/> letBindings_Implicit =
+        AxBuilderPremisses.GenTypeParamBindings(implicitTypeParamsSelect, inParams, bindings, false);
+      Contract.Assert(cce.NonNullElements(letBindings_Implicit));
+      // The explicit ones, by definition, can only be phrased in terms of the result, so we pass
+      // in List(typedVal) here.
+      List<VCExprLetBinding/*!*/> letBindings_Explicit =
+        AxBuilderPremisses.GenTypeParamBindings(explicitTypeParamsSelect, HelperFuns.ToList(typedVal), bindings, false);
+      Contract.Assert(cce.NonNullElements(letBindings_Explicit));
+
+      // generate:  select(store(m, indices, val)) == val
+      VCExpr/*!*/ eq = Gen.Eq(selectExpr, val);
+      Contract.Assert(eq != null);
+      // generate:  type(val) == T, where T is the type of val
+      VCExpr/*!*/ ante = Gen.Eq(
+        AxBuilderPremisses.TypeOf(val),
+        AxBuilderPremisses.Type2Term(mapResult, bindings.TypeVariableBindings));
+      Contract.Assert(ante != null);
+      VCExpr body;
+      if (CommandLineOptions.Clo.TypeEncodingMethod == CommandLineOptions.TypeEncoding.None ||
+          !AxBuilder.U.Equals(cce.NonNull(select.OutParams[0]).TypedIdent.Type)) {
+        body = Gen.Let(letBindings_Explicit, eq);
+      } else {
+        body = Gen.Let(letBindings_Implicit, Gen.Let(letBindings_Explicit, Gen.ImpliesSimp(ante, eq)));
+      }
+      return Gen.Forall(quantifiedVars, new List<VCTrigger/*!*/>(), "mapAx0:" + select.Name, 0, body);
+    }
+
+    private VCExpr GenMapAxiom1(Function select, Function store, Type mapResult, List<TypeVariable/*!*/>/*!*/ explicitSelectParams) {
+      Contract.Requires(mapResult != null);
+      Contract.Requires(store != null);
+      Contract.Requires(select != null);
+      Contract.Requires(cce.NonNullElements(explicitSelectParams));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      int arity = store.InParams.Count - 2;
+
+      List<Type/*!*/> indexTypes = new List<Type/*!*/>();
+      for (int i = 1; i < store.InParams.Count - 1; i++) {
+        indexTypes.Add(cce.NonNull(store.InParams[i]).TypedIdent.Type);
+      }
+      Contract.Assert(indexTypes.Count == arity);
+
+      List<VCExprVar/*!*/>/*!*/ indexes0 = HelperFuns.VarVector("x", indexTypes, Gen);
+      Contract.Assert(cce.NonNullElements(indexes0));
+      List<VCExprVar/*!*/>/*!*/ indexes1 = HelperFuns.VarVector("y", indexTypes, Gen);
+      Contract.Assert(cce.NonNullElements(indexes1));
+      VCExprVar/*!*/ m = Gen.Variable("m", AxBuilder.U);
+      Contract.Assert(m != null);
+      VCExprVar/*!*/ val = Gen.Variable("val", cce.NonNull(select.OutParams[0]).TypedIdent.Type);
+      Contract.Assert(val != null);
+
+      // extract the explicit type parameters from the actual result type ...
+      VCExprVar/*!*/ typedVal = Gen.Variable("val", mapResult);
+      Contract.Assert(typedVal != null);
+      VariableBindings/*!*/ bindings = new VariableBindings();
+      bindings.VCExprVarBindings.Add(typedVal, val);
+
+      List<VCExprLetBinding/*!*/>/*!*/ letBindings =
+        AxBuilderPremisses.GenTypeParamBindings(explicitSelectParams,
+                                                HelperFuns.ToList(typedVal),
+                                                bindings, true);
+      Contract.Assert(cce.NonNullElements(letBindings));
+
+      // ... and quantify the introduced term variables for type
+      // parameters universally
+      List<VCExprVar/*!*/>/*!*/ typeParams = new List<VCExprVar/*!*/>(explicitSelectParams.Count);
+      List<VCExpr/*!*/>/*!*/ typeParamsExpr = new List<VCExpr/*!*/>(explicitSelectParams.Count);
+      foreach (TypeVariable/*!*/ var in explicitSelectParams) {
+        Contract.Assert(var != null);
+        VCExprVar/*!*/ newVar = (VCExprVar)bindings.TypeVariableBindings[var];
+        Contract.Assert(newVar != null);
+        typeParams.Add(newVar);
+        typeParamsExpr.Add(newVar);
+      }
+
+      VCExpr/*!*/ storeExpr = Store(store, m, indexes0, val);
+      Contract.Assert(storeExpr != null);
+      VCExpr/*!*/ selectWithoutStoreExpr = Select(select, typeParamsExpr, m, indexes1);
+      Contract.Assert(selectWithoutStoreExpr != null);
+      VCExpr/*!*/ selectExpr = Select(select, typeParamsExpr, storeExpr, indexes1);
+      Contract.Assert(selectExpr != null);
+
+      VCExpr/*!*/ selectEq = Gen.Eq(selectExpr, selectWithoutStoreExpr);
+      Contract.Assert(selectEq != null);
+
+      List<VCExprVar/*!*/>/*!*/ quantifiedVars = new List<VCExprVar/*!*/>(indexes0.Count + indexes1.Count + 2);
+      quantifiedVars.Add(val);
+      quantifiedVars.Add(m);
+      quantifiedVars.AddRange(indexes0);
+      quantifiedVars.AddRange(indexes1);
+      quantifiedVars.AddRange(typeParams);
+
+      List<VCTrigger/*!*/>/*!*/ triggers = new List<VCTrigger/*!*/>();
+      Contract.Assert(cce.NonNullElements(triggers));
+
+      VCExpr/*!*/ axiom = VCExpressionGenerator.True;
+      Contract.Assert(axiom != null);
+
+      // first non-interference criterium: the queried location is
+      // different from the assigned location
+      for (int i = 0; i < arity; ++i) {
+        VCExpr/*!*/ indexesEq = Gen.Eq(indexes0[i], indexes1[i]);
+        VCExpr/*!*/ matrix = Gen.Or(indexesEq, selectEq);
+        VCExpr/*!*/ conjunct = Gen.Forall(quantifiedVars, triggers, "mapAx1:" + select.Name + ":" + i, 0, matrix);
+        Contract.Assert(indexesEq != null);
+        Contract.Assert(matrix != null);
+        Contract.Assert(conjunct != null);
+        axiom = Gen.AndSimp(axiom, conjunct);
+      }
+
+      // second non-interference criterion: the queried type is
+      // different from the assigned type
+      VCExpr/*!*/ typesEq = VCExpressionGenerator.True;
+      foreach (VCExprLetBinding/*!*/ b in letBindings) {
+        Contract.Assert(b != null);
+        typesEq = Gen.AndSimp(typesEq, Gen.Eq(b.V, b.E));
+      }
+      VCExpr/*!*/ matrix2 = Gen.Or(typesEq, selectEq);
+      VCExpr/*!*/ conjunct2 = Gen.Forall(quantifiedVars, triggers, "mapAx2:" + select.Name, 0, matrix2);
+      axiom = Gen.AndSimp(axiom, conjunct2);
+
+      return axiom;
+    }
+
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+
+  public class TypeEraserPremisses : TypeEraser
+  {
+
+    private readonly TypeAxiomBuilderPremisses/*!*/ AxBuilderPremisses;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(AxBuilderPremisses != null);
+    }
+
+
+    private OpTypeEraser OpEraserAttr = null;
+    protected override OpTypeEraser/*!*/ OpEraser {
+      get {
+        Contract.Ensures(Contract.Result<OpTypeEraser>() != null);
+
+        if (OpEraserAttr == null)
+          OpEraserAttr = new OpTypeEraserPremisses(this, AxBuilderPremisses, Gen);
+        return OpEraserAttr;
+      }
+    }
+
+    public TypeEraserPremisses(TypeAxiomBuilderPremisses axBuilder, VCExpressionGenerator gen)
+      : base(axBuilder, gen) {
+      Contract.Requires(gen != null);
+      Contract.Requires(axBuilder != null);
+
+      this.AxBuilderPremisses = axBuilder;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public override VCExpr Visit(VCExprQuantifier node, VariableBindings oldBindings) {
+      Contract.Requires(oldBindings != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VariableBindings bindings = oldBindings.Clone();
+
+      // determine the bound vars that actually occur in the body or
+      // in any of the triggers (if some variables do not occur, we
+      // need to take special care of type parameters that only occur
+      // in the types of such variables)
+      FreeVariableCollector coll = new FreeVariableCollector();
+      coll.Collect(node.Body);
+      foreach (VCTrigger trigger in node.Triggers) {
+        if (trigger.Pos)
+          foreach (VCExpr/*!*/ e in trigger.Exprs) {
+            Contract.Assert(e != null);
+
+            coll.Collect(e);
+          }
+      }
+
+      List<VCExprVar/*!*/> occurringVars = new List<VCExprVar/*!*/>(node.BoundVars.Count);
+      foreach (VCExprVar var in node.BoundVars)
+        if (coll.FreeTermVars.ContainsKey(var))
+          occurringVars.Add(var);
+
+      occurringVars.TrimExcess();
+
+      // bound term variables are replaced with bound term variables typed in
+      // a simpler way
+      List<VCExprVar/*!*/>/*!*/ newBoundVars =
+        BoundVarsAfterErasure(occurringVars, bindings);
+      Contract.Assert(cce.NonNullElements(newBoundVars));
+      VCExpr/*!*/ newNode = HandleQuantifier(node, occurringVars,
+                                         newBoundVars, bindings);
+      Contract.Assert(newNode != null);
+
+      if (!(newNode is VCExprQuantifier) || !IsUniversalQuantifier(node))
+        return newNode;
+
+      VariableBindings bindings2;
+      if (!RedoQuantifier(node, (VCExprQuantifier)newNode, occurringVars, oldBindings,
+                          out bindings2, out newBoundVars))
+        return newNode;
+
+      return HandleQuantifier(node, occurringVars,
+                              newBoundVars, bindings2);
+    }
+
+    private VCExpr/*!*/ GenTypePremisses(List<VCExprVar/*!*/>/*!*/ oldBoundVars,
+                                     List<VCExprVar/*!*/>/*!*/ newBoundVars,
+                                     IDictionary<TypeVariable/*!*/, VCExpr/*!*/>/*!*/
+                                                             typeVarTranslation,
+                                     List<VCExprLetBinding/*!*/>/*!*/ typeVarBindings,
+                                     out List<VCTrigger/*!*/>/*!*/ triggers) {
+      Contract.Requires(cce.NonNullElements(oldBoundVars));
+      Contract.Requires(cce.NonNullElements(newBoundVars));
+      Contract.Requires(cce.NonNullDictionaryAndValues(typeVarTranslation));
+      Contract.Requires(cce.NonNullElements(typeVarBindings));
+      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out triggers)));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      // build a substitution of the type variables that it can be checked
+      // whether type premisses are trivial
+      VCExprSubstitution/*!*/ typeParamSubstitution = new VCExprSubstitution();
+      foreach (VCExprLetBinding/*!*/ binding in typeVarBindings) {
+        Contract.Assert(binding != null);
+        typeParamSubstitution[binding.V] = binding.E;
+      }
+      SubstitutingVCExprVisitor/*!*/ substituter = new SubstitutingVCExprVisitor(Gen);
+      Contract.Assert(substituter != null);
+
+      List<VCExpr/*!*/>/*!*/ typePremisses = new List<VCExpr/*!*/>(newBoundVars.Count);
+      triggers = new List<VCTrigger/*!*/>(newBoundVars.Count);
+
+      for (int i = 0; i < newBoundVars.Count; ++i) {
+        VCExprVar/*!*/ oldVar = oldBoundVars[i];
+        Contract.Assert(oldVar != null);
+        VCExprVar/*!*/ newVar = newBoundVars[i];
+        Contract.Assert(newVar != null);
+
+        VCExpr/*!*/ typePremiss =
+          AxBuilderPremisses.GenVarTypeAxiom(newVar, oldVar.Type,
+                                             typeVarTranslation);
+        Contract.Assert(typePremiss != null);
+        if (!IsTriviallyTrue(substituter.Mutate(typePremiss,
+                                                typeParamSubstitution))) {
+          typePremisses.Add(typePremiss);
+          // generate a negative trigger for the variable occurrence
+          // in the type premiss
+          triggers.Add(Gen.Trigger(false,
+                         HelperFuns.ToList(AxBuilderPremisses.TypeOf(newVar))));
+        }
+      }
+
+      typePremisses.TrimExcess();
+      triggers.TrimExcess();
+
+      return Gen.NAry(VCExpressionGenerator.AndOp, typePremisses);
+    }
+
+    // these optimisations should maybe be moved into a separate
+    // visitor (peep-hole optimisations)
+    private bool IsTriviallyTrue(VCExpr expr) {
+      Contract.Requires(expr != null);
+      if (expr.Equals(VCExpressionGenerator.True))
+        return true;
+
+      if (expr is VCExprNAry) {
+        VCExprNAry/*!*/ naryExpr = (VCExprNAry)expr;
+        Contract.Assert(naryExpr != null);
+        if (naryExpr.Op.Equals(VCExpressionGenerator.EqOp) &&
+            naryExpr[0].Equals(naryExpr[1]))
+          return true;
+      }
+
+      return false;
+    }
+
+    private VCExpr HandleQuantifier(VCExprQuantifier node, List<VCExprVar/*!*/>/*!*/ occurringVars/*!*/, List<VCExprVar/*!*/>/*!*/ newBoundVars, VariableBindings bindings) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(node != null);
+      Contract.Requires(cce.NonNullElements(occurringVars/*!*/));
+      Contract.Requires(cce.NonNullElements(newBoundVars));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<VCExprLetBinding/*!*/>/*!*/ typeVarBindings =
+        AxBuilderPremisses.GenTypeParamBindings(node.TypeParameters, occurringVars, bindings, true);
+      Contract.Assert(typeVarBindings != null);
+      // Check whether some of the type parameters could not be
+      // determined from the bound variable types. In this case, we
+      // quantify explicitly over these variables
+      if (typeVarBindings.Count < node.TypeParameters.Count) {
+        foreach (TypeVariable/*!*/ var in node.TypeParameters) {
+          Contract.Assert(var != null);
+          if (typeVarBindings.All(b => !b.V.Equals(bindings.TypeVariableBindings[var])))
+            newBoundVars.Add((VCExprVar)bindings.TypeVariableBindings[var]);
+        }
+      }
+
+      // the lists of old and new bound variables for which type
+      // antecedents are to be generated
+      List<VCExprVar/*!*/>/*!*/ varsWithTypeSpecs = new List<VCExprVar/*!*/>();
+      List<VCExprVar/*!*/>/*!*/ newVarsWithTypeSpecs = new List<VCExprVar/*!*/>();
+      if (!IsUniversalQuantifier(node) ||
+          CommandLineOptions.Clo.TypeEncodingMethod
+                == CommandLineOptions.TypeEncoding.Predicates) {
+        foreach (VCExprVar/*!*/ oldVar in occurringVars) {
+          Contract.Assert(oldVar != null);
+          varsWithTypeSpecs.Add(oldVar);
+          newVarsWithTypeSpecs.Add(bindings.VCExprVarBindings[oldVar]);
+        }
+      } // else, no type antecedents are created for any variables
+
+      List<VCTrigger/*!*/>/*!*/ furtherTriggers;
+      VCExpr/*!*/ typePremisses =
+        GenTypePremisses(varsWithTypeSpecs, newVarsWithTypeSpecs,
+                         bindings.TypeVariableBindings,
+                         typeVarBindings, out furtherTriggers);
+
+      Contract.Assert(cce.NonNullElements(furtherTriggers));
+      Contract.Assert(typePremisses != null);
+      List<VCTrigger/*!*/>/*!*/ newTriggers = MutateTriggers(node.Triggers, bindings);
+      Contract.Assert(cce.NonNullElements(newTriggers));
+      newTriggers.AddRange(furtherTriggers);
+      newTriggers = AddLets2Triggers(newTriggers, typeVarBindings);
+
+      VCExpr/*!*/ newBody = Mutate(node.Body, bindings);
+      Contract.Assert(newBody != null);
+
+      // assemble the new quantified formula
+
+      if (CommandLineOptions.Clo.TypeEncodingMethod
+                == CommandLineOptions.TypeEncoding.None) {
+        typePremisses = VCExpressionGenerator.True;
+      }
+
+      VCExpr/*!*/ bodyWithPremisses =
+        AxBuilderPremisses.AddTypePremisses(typeVarBindings, typePremisses,
+                                            node.Quan == Quantifier.ALL,
+                                            AxBuilder.Cast(newBody, Type.Bool));
+      Contract.Assert(bodyWithPremisses != null);
+      if (newBoundVars.Count == 0)  // might happen that no bound variables are left
+        return bodyWithPremisses;
+
+      foreach (VCExprVar/*!*/ v in newBoundVars) {
+        Contract.Assert(v != null);
+        if (v.Type == AxBuilderPremisses.U) {
+          newTriggers.Add(Gen.Trigger(false, AxBuilderPremisses.Cast(v, Type.Int)));
+          newTriggers.Add(Gen.Trigger(false, AxBuilderPremisses.Cast(v, Type.Bool)));
+        }
+      }
+
+      return Gen.Quantify(node.Quan, new List<TypeVariable/*!*/>(), newBoundVars,
+                          newTriggers, node.Infos, bodyWithPremisses);
+    }
+
+    // check whether we need to add let-binders for any of the type
+    // parameters to the triggers (otherwise, the triggers will
+    // contain unbound/dangling variables for such parameters)
+    private List<VCTrigger/*!*/>/*!*/ AddLets2Triggers(List<VCTrigger/*!*/>/*!*/ triggers/*!*/, List<VCExprLetBinding/*!*/>/*!*/ typeVarBindings) {
+      Contract.Requires(cce.NonNullElements(triggers/*!*/));
+      Contract.Requires(cce.NonNullElements(typeVarBindings));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCTrigger>>()));
+      List<VCTrigger/*!*/>/*!*/ triggersWithLets = new List<VCTrigger/*!*/>(triggers.Count);
+
+      foreach (VCTrigger/*!*/ t in triggers) {
+        Contract.Assert(t != null);
+        List<VCExpr/*!*/>/*!*/ exprsWithLets = new List<VCExpr/*!*/>(t.Exprs.Count);
+
+        bool changed = false;
+        foreach (VCExpr/*!*/ e in t.Exprs) {
+          Contract.Assert(e != null);
+          Dictionary<VCExprVar/*!*/, object>/*!*/ freeVars =
+                      FreeVariableCollector.FreeTermVariables(e);
+          Contract.Assert(freeVars != null && cce.NonNullElements(freeVars.Keys));
+          if (typeVarBindings.Any(b => freeVars.ContainsKey(b.V))) {
+            exprsWithLets.Add(Gen.Let(typeVarBindings, e));
+            changed = true;
+          } else {
+            exprsWithLets.Add(e);
+          }
+        }
+
+        if (changed)
+          triggersWithLets.Add(Gen.Trigger(t.Pos, exprsWithLets));
+        else
+          triggersWithLets.Add(t);
+      }
+
+      return triggersWithLets;
+    }
+
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  public class OpTypeEraserPremisses : OpTypeEraser
+  {
+
+    private TypeAxiomBuilderPremisses/*!*/ AxBuilderPremisses;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(AxBuilderPremisses != null);
+    }
+
+
+    public OpTypeEraserPremisses(TypeEraserPremisses eraser, TypeAxiomBuilderPremisses axBuilder, VCExpressionGenerator gen)
+      : base(eraser, axBuilder, gen) {
+      Contract.Requires(gen != null);
+      Contract.Requires(axBuilder != null);
+      Contract.Requires(eraser != null);
+      this.AxBuilderPremisses = axBuilder;
+    }
+
+    private VCExpr HandleFunctionOp(Function newFun, List<Type/*!*/>/*!*/ typeArgs/*!*/, IEnumerable<VCExpr/*!*/>/*!*/ oldArgs, VariableBindings bindings) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(newFun != null);
+      Contract.Requires(cce.NonNullElements(typeArgs/*!*/));
+      Contract.Requires(cce.NonNullElements(oldArgs));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      // UGLY: the code for tracking polarities should be factored out
+      int oldPolarity = Eraser.Polarity;
+      Eraser.Polarity = 0;
+
+      List<VCExpr/*!*/>/*!*/ newArgs = new List<VCExpr/*!*/>(typeArgs.Count);
+
+      // translate the explicit type arguments
+      foreach (Type/*!*/ t in typeArgs) {
+        Contract.Assert(t != null);
+        newArgs.Add(AxBuilder.Type2Term(t, bindings.TypeVariableBindings));
+      }
+
+      // recursively translate the value arguments
+      foreach (VCExpr/*!*/ arg in oldArgs) {
+        Contract.Assert(arg != null);
+        Type/*!*/ newType = cce.NonNull(newFun.InParams[newArgs.Count]).TypedIdent.Type;
+        newArgs.Add(AxBuilder.Cast(Eraser.Mutate(arg, bindings), newType));
+      }
+
+      Eraser.Polarity = oldPolarity;
+      return Gen.Function(newFun, newArgs);
+    }
+
+    public override VCExpr/*!*/ VisitSelectOp(VCExprNAry/*!*/ node,
+                                             VariableBindings/*!*/ bindings) {
+      Contract.Requires(node != null); Contract.Requires(bindings != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      MapType/*!*/ mapType = node[0].Type.AsMap;
+      Contract.Assert(mapType != null);
+      List<Type>/*!*/ instantiations; // not used
+      Function/*!*/ select =
+        AxBuilder.MapTypeAbstracter.Select(mapType, out instantiations);
+      Contract.Assert(select != null);
+
+      List<int>/*!*/ explicitTypeParams =
+        AxBuilderPremisses.MapTypeAbstracterPremisses
+                          .ExplicitSelectTypeParams(mapType);
+      Contract.Assert(select.InParams.Count == explicitTypeParams.Count + node.Arity);
+
+      List<Type/*!*/>/*!*/ typeArgs = new List<Type/*!*/>(explicitTypeParams.Count);
+      foreach (int i in explicitTypeParams)
+        typeArgs.Add(node.TypeArguments[i]);
+      return HandleFunctionOp(select, typeArgs, node, bindings);
+    }
+
+    public override VCExpr VisitStoreOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      List<Type>/*!*/ instantiations; // not used
+      Function/*!*/ store =
+        AxBuilder.MapTypeAbstracter.Store(node[0].Type.AsMap, out instantiations);
+      Contract.Assert(store != null);
+      return HandleFunctionOp(store,
+        // the store function never has explicit
+        // type parameters
+                              new List<Type/*!*/>(),
+                              node, bindings);
+    }
+
+    public override VCExpr VisitBoogieFunctionOp(VCExprNAry node, VariableBindings bindings) {
+      Contract.Requires(bindings != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      Function/*!*/ oriFun = ((VCExprBoogieFunctionOp)node.Op).Func;
+      Contract.Assert(oriFun != null);
+      UntypedFunction untypedFun = AxBuilderPremisses.Typed2Untyped(oriFun);
+      Contract.Assert(untypedFun.Fun.InParams.Count ==
+             untypedFun.ExplicitTypeParams.Count + node.Arity);
+
+      List<Type/*!*/>/*!*/ typeArgs =
+        ExtractTypeArgs(node,
+                        oriFun.TypeParameters, untypedFun.ExplicitTypeParams);
+      return HandleFunctionOp(untypedFun.Fun, typeArgs, node, bindings);
+    }
+
+    private List<Type/*!*/>/*!*/ ExtractTypeArgs(VCExprNAry node, List<TypeVariable> allTypeParams, List<TypeVariable/*!*/>/*!*/ explicitTypeParams) {
+      Contract.Requires(allTypeParams != null);
+      Contract.Requires(node != null);
+      Contract.Requires(cce.NonNullElements(explicitTypeParams));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
+      List<Type/*!*/>/*!*/ res = new List<Type/*!*/>(explicitTypeParams.Count);
+      foreach (TypeVariable/*!*/ var in explicitTypeParams) {
+        Contract.Assert(var != null);
+        // this lookup could be optimised
+        res.Add(node.TypeArguments[allTypeParams.IndexOf(var)]);
+      }
+      return res;
+    }
+  }
+
+
+}
diff --git a/Source/VCExpr/VCExpr.csproj b/Source/VCExpr/VCExpr.csproj
index acacb4d1..efac274e 100644
--- a/Source/VCExpr/VCExpr.csproj
+++ b/Source/VCExpr/VCExpr.csproj
@@ -1,223 +1,223 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.21022</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{56FFDBCA-7D14-43B8-A6CA-22A20E417EE1}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>VCExpr</RootNamespace>
-    <AssemblyName>VCExpr</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <CodeContractsAssemblyMode>1</CodeContractsAssemblyMode>
-    <SignAssembly>true</SignAssembly>
-    <AssemblyOriginatorKeyFile>..\InterimKey.snk</AssemblyOriginatorKeyFile>
-    <FileUpgradeFlags>
-    </FileUpgradeFlags>
-    <OldToolsVersion>3.5</OldToolsVersion>
-    <UpgradeBackupLocation />
-    <PublishUrl>publish\</PublishUrl>
-    <Install>true</Install>
-    <InstallFrom>Disk</InstallFrom>
-    <UpdateEnabled>false</UpdateEnabled>
-    <UpdateMode>Foreground</UpdateMode>
-    <UpdateInterval>7</UpdateInterval>
-    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
-    <UpdatePeriodically>false</UpdatePeriodically>
-    <UpdateRequired>false</UpdateRequired>
-    <MapFileExtensions>true</MapFileExtensions>
-    <ApplicationRevision>0</ApplicationRevision>
-    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
-    <IsWebBootstrapper>false</IsWebBootstrapper>
-    <UseApplicationTrust>false</UseApplicationTrust>
-    <BootstrapperEnabled>true</BootstrapperEnabled>
-    <TargetFrameworkProfile Condition=" '$(OS)' == 'Windows_NT'" >Client</TargetFrameworkProfile>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <CodeContractsEnableRuntimeChecking>False</CodeContractsEnableRuntimeChecking>
-    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
-    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
-    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
-    <CodeContractsRunCodeAnalysis>False</CodeContractsRunCodeAnalysis>
-    <CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
-    <CodeContractsBoundsObligations>False</CodeContractsBoundsObligations>
-    <CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
-    <CodeContractsPointerObligations>False</CodeContractsPointerObligations>
-    <CodeContractsContainerAnalysis>False</CodeContractsContainerAnalysis>
-    <CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
-    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
-    <CodeContractsShowSquigglies>False</CodeContractsShowSquigglies>
-    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
-    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
-    <CodeContractsCustomRewriterAssembly>
-    </CodeContractsCustomRewriterAssembly>
-    <CodeContractsCustomRewriterClass>
-    </CodeContractsCustomRewriterClass>
-    <CodeContractsLibPaths>
-    </CodeContractsLibPaths>
-    <CodeContractsExtraRewriteOptions>
-    </CodeContractsExtraRewriteOptions>
-    <CodeContractsExtraAnalysisOptions>
-    </CodeContractsExtraAnalysisOptions>
-    <CodeContractsBaseLineFile>
-    </CodeContractsBaseLineFile>
-    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
-    <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'z3apidebug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\z3apidebug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <CodeAnalysisRuleAssemblies>
-    </CodeAnalysisRuleAssemblies>
-    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
-    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>Migrated rules for VCExpr.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
-    <WarningLevel>4</WarningLevel>
-    <Optimize>false</Optimize>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Checked|AnyCPU'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\Checked\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <CodeAnalysisLogFile>bin\Debug\VCExpr.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
-    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
-    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
-    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
-    <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
-    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
-    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
-    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
-    <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
-    <CodeContractsRunCodeAnalysis>False</CodeContractsRunCodeAnalysis>
-    <CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
-    <CodeContractsBoundsObligations>False</CodeContractsBoundsObligations>
-    <CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
-    <CodeContractsEnumObligations>False</CodeContractsEnumObligations>
-    <CodeContractsPointerObligations>False</CodeContractsPointerObligations>
-    <CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
-    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
-    <CodeContractsShowSquigglies>False</CodeContractsShowSquigglies>
-    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
-    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
-    <CodeContractsCustomRewriterAssembly />
-    <CodeContractsCustomRewriterClass />
-    <CodeContractsLibPaths />
-    <CodeContractsExtraRewriteOptions />
-    <CodeContractsExtraAnalysisOptions />
-    <CodeContractsBaseLineFile />
-    <CodeContractsCacheAnalysisResults>False</CodeContractsCacheAnalysisResults>
-    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
-    <CodeContractsReferenceAssembly>Build</CodeContractsReferenceAssembly>
-    <CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
-    <WarningLevel>4</WarningLevel>
-    <Optimize>false</Optimize>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'QED|AnyCPU'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\QED\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="..\version.cs">
-      <Link>version.cs</Link>
-    </Compile>
-    <Compile Include="BigLiteralAbstracter.cs" />
-    <Compile Include="Boogie2VCExpr.cs" />
-    <Compile Include="Clustering.cs" />
-    <Compile Include="LetBindingSorter.cs" />
-    <Compile Include="NameClashResolver.cs" />
-    <Compile Include="SimplifyLikeLineariser.cs" />
-    <Compile Include="TermFormulaFlattening.cs" />
-    <Compile Include="TypeErasure.cs" />
-    <Compile Include="TypeErasureArguments.cs" />
-    <Compile Include="TypeErasurePremisses.cs" />
-    <Compile Include="VCExprAST.cs" />
-    <Compile Include="VCExprASTPrinter.cs" />
-    <Compile Include="VCExprASTVisitors.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\Basetypes\Basetypes.csproj">
-      <Project>{43DFAD18-3E35-4558-9BE2-CAFF6B5BA8A0}</Project>
-      <Name>Basetypes</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\CodeContractsExtender\CodeContractsExtender.csproj">
-      <Project>{ACCC0156-0921-43ED-8F67-AD8BDC8CDE31}</Project>
-      <Name>CodeContractsExtender</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Core\Core.csproj">
-      <Project>{B230A69C-C466-4065-B9C1-84D80E76D802}</Project>
-      <Name>Core</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\ParserHelper\ParserHelper.csproj">
-      <Project>{FCD3AC7F-9DFD-46C8-AB1E-09F0B0F16DC5}</Project>
-      <Name>ParserHelper</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Properties\" />
-  </ItemGroup>
-  <ItemGroup>
-    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
-      <Visible>False</Visible>
-      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
-      <Install>false</Install>
-    </BootstrapperPackage>
-    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
-      <Visible>False</Visible>
-      <ProductName>.NET Framework 3.5 SP1</ProductName>
-      <Install>true</Install>
-    </BootstrapperPackage>
-    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
-      <Visible>False</Visible>
-      <ProductName>Windows Installer 3.1</ProductName>
-      <Install>true</Install>
-    </BootstrapperPackage>
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.21022</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{56FFDBCA-7D14-43B8-A6CA-22A20E417EE1}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>VCExpr</RootNamespace>
+    <AssemblyName>BoogieVCExpr</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <CodeContractsAssemblyMode>1</CodeContractsAssemblyMode>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>..\InterimKey.snk</AssemblyOriginatorKeyFile>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile Condition=" '$(OS)' == 'Windows_NT'">Client</TargetFrameworkProfile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeContractsEnableRuntimeChecking>False</CodeContractsEnableRuntimeChecking>
+    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
+    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
+    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
+    <CodeContractsRunCodeAnalysis>False</CodeContractsRunCodeAnalysis>
+    <CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
+    <CodeContractsBoundsObligations>False</CodeContractsBoundsObligations>
+    <CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
+    <CodeContractsPointerObligations>False</CodeContractsPointerObligations>
+    <CodeContractsContainerAnalysis>False</CodeContractsContainerAnalysis>
+    <CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
+    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
+    <CodeContractsShowSquigglies>False</CodeContractsShowSquigglies>
+    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
+    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
+    <CodeContractsCustomRewriterAssembly>
+    </CodeContractsCustomRewriterAssembly>
+    <CodeContractsCustomRewriterClass>
+    </CodeContractsCustomRewriterClass>
+    <CodeContractsLibPaths>
+    </CodeContractsLibPaths>
+    <CodeContractsExtraRewriteOptions>
+    </CodeContractsExtraRewriteOptions>
+    <CodeContractsExtraAnalysisOptions>
+    </CodeContractsExtraAnalysisOptions>
+    <CodeContractsBaseLineFile>
+    </CodeContractsBaseLineFile>
+    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
+    <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'z3apidebug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\z3apidebug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisRuleAssemblies>
+    </CodeAnalysisRuleAssemblies>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>Migrated rules for VCExpr.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <WarningLevel>4</WarningLevel>
+    <Optimize>false</Optimize>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Checked|AnyCPU'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\Checked\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisLogFile>bin\Debug\VCExpr.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
+    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
+    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
+    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
+    <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
+    <CodeContractsRunCodeAnalysis>False</CodeContractsRunCodeAnalysis>
+    <CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
+    <CodeContractsBoundsObligations>False</CodeContractsBoundsObligations>
+    <CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
+    <CodeContractsEnumObligations>False</CodeContractsEnumObligations>
+    <CodeContractsPointerObligations>False</CodeContractsPointerObligations>
+    <CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
+    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
+    <CodeContractsShowSquigglies>False</CodeContractsShowSquigglies>
+    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
+    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
+    <CodeContractsCustomRewriterAssembly />
+    <CodeContractsCustomRewriterClass />
+    <CodeContractsLibPaths />
+    <CodeContractsExtraRewriteOptions />
+    <CodeContractsExtraAnalysisOptions />
+    <CodeContractsBaseLineFile />
+    <CodeContractsCacheAnalysisResults>False</CodeContractsCacheAnalysisResults>
+    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
+    <CodeContractsReferenceAssembly>Build</CodeContractsReferenceAssembly>
+    <CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
+    <WarningLevel>4</WarningLevel>
+    <Optimize>false</Optimize>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'QED|AnyCPU'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\QED\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\version.cs">
+      <Link>version.cs</Link>
+    </Compile>
+    <Compile Include="BigLiteralAbstracter.cs" />
+    <Compile Include="Boogie2VCExpr.cs" />
+    <Compile Include="Clustering.cs" />
+    <Compile Include="LetBindingSorter.cs" />
+    <Compile Include="NameClashResolver.cs" />
+    <Compile Include="SimplifyLikeLineariser.cs" />
+    <Compile Include="TermFormulaFlattening.cs" />
+    <Compile Include="TypeErasure.cs" />
+    <Compile Include="TypeErasureArguments.cs" />
+    <Compile Include="TypeErasurePremisses.cs" />
+    <Compile Include="VCExprAST.cs" />
+    <Compile Include="VCExprASTPrinter.cs" />
+    <Compile Include="VCExprASTVisitors.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Basetypes\Basetypes.csproj">
+      <Project>{43DFAD18-3E35-4558-9BE2-CAFF6B5BA8A0}</Project>
+      <Name>Basetypes</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\CodeContractsExtender\CodeContractsExtender.csproj">
+      <Project>{ACCC0156-0921-43ED-8F67-AD8BDC8CDE31}</Project>
+      <Name>CodeContractsExtender</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Core\Core.csproj">
+      <Project>{B230A69C-C466-4065-B9C1-84D80E76D802}</Project>
+      <Name>Core</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\ParserHelper\ParserHelper.csproj">
+      <Project>{FCD3AC7F-9DFD-46C8-AB1E-09F0B0F16DC5}</Project>
+      <Name>ParserHelper</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Properties\" />
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
+\ No newline at end of file
diff --git a/Source/VCExpr/VCExprAST.cs b/Source/VCExpr/VCExprAST.cs
index b22853ce..b5d4dfb5 100644
--- a/Source/VCExpr/VCExprAST.cs
+++ b/Source/VCExpr/VCExprAST.cs
@@ -1,2260 +1,2276 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-
-// Prover-independent syntax trees for representing verification conditions
-// The language can be seen as a simple polymorphically typed first-order logic,
-// very similar to the expression language of Boogie
-
-namespace Microsoft.Boogie {
-  using Microsoft.Boogie.VCExprAST;
-
-  public class VCExpressionGenerator {
-    public static readonly VCExpr False = new VCExprLiteral(Type.Bool);
-    public static readonly VCExpr True = new VCExprLiteral(Type.Bool);
-
-    private Function ControlFlowFunction = null;
-    public VCExpr ControlFlowFunctionApplication(VCExpr e1, VCExpr e2) {
-      Contract.Requires(e1 != null);
-      Contract.Requires(e2 != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      if (ControlFlowFunction == null) {
-        Formal/*!*/ first = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Int), true);
-        Formal/*!*/ second = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Int), true);
-        List<Variable> inputs = new List<Variable>();
-        inputs.Add(first);
-        inputs.Add(second);
-        Formal/*!*/ returnVar = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Int), false);
-        ControlFlowFunction = new Function(Token.NoToken, "ControlFlow", inputs, returnVar);
-      }
-      List<VCExpr/*!*/> args = new List<VCExpr/*!*/>();
-      args.Add(e1);
-      args.Add(e2);
-      return Function(BoogieFunctionOp(ControlFlowFunction), args);
-    }
-
-    public VCExpr/*!*/ Integer(BigNum x) {
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      return new VCExprIntLit(x);
-    }
-
-    public VCExpr/*!*/ Real(BigDec x) {
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      return new VCExprRealLit(x);
-    }
-
-    public VCExpr/*!*/ Float(BigFloat x)
-    {
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      return new VCExprFloatLit(x);
-    }
-
-    public VCExpr/*!*/ Function(VCExprOp/*!*/ op,
-                            List<VCExpr/*!*/>/*!*/ arguments,
-                            List<Type/*!*/>/*!*/ typeArguments) {
-      Contract.Requires(op != null);
-      Contract.Requires(cce.NonNullElements(arguments));
-      Contract.Requires(cce.NonNullElements(typeArguments));
-      if (typeArguments.Count > 0)
-        return new VCExprMultiAry(op, arguments, typeArguments);
-
-      switch (arguments.Count) {
-        case 0:
-          return new VCExprNullary(op);
-        case 1:
-          return new VCExprUnary(op, arguments);
-        case 2:
-          return new VCExprBinary(op, arguments);
-        default:
-          return new VCExprMultiAry(op, arguments);
-      }
-    }
-
-    public VCExpr/*!*/ Function(VCExprOp/*!*/ op, List<VCExpr/*!*/>/*!*/ arguments) {
-      Contract.Requires(op != null);
-      Contract.Requires(cce.NonNullElements(arguments));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      return Function(op, arguments, VCExprNAry.EMPTY_TYPE_LIST);
-    }
-
-    public VCExpr/*!*/ Function(VCExprOp/*!*/ op, params VCExpr[]/*!*/ arguments) {
-      Contract.Requires(op != null);
-      Contract.Requires(cce.NonNullElements(arguments));
-
-      return Function(op,
-                      HelperFuns.ToNonNullList(arguments),
-                      VCExprNAry.EMPTY_TYPE_LIST);
-    }
-
-    public VCExpr/*!*/ Function(VCExprOp/*!*/ op, VCExpr[]/*!*/ arguments, Type[]/*!*/ typeArguments) {
-      Contract.Requires(op != null);
-      Contract.Requires(cce.NonNullElements(arguments));
-      Contract.Requires(cce.NonNullElements(typeArguments));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-
-      return Function(op,
-                      HelperFuns.ToNonNullList(arguments),
-                      HelperFuns.ToNonNullList(typeArguments));
-    }
-
-    public VCExpr/*!*/ Function(Function/*!*/ op, List<VCExpr/*!*/>/*!*/ arguments) {
-      Contract.Requires(op != null);
-      Contract.Requires(cce.NonNullElements(arguments));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      return Function(BoogieFunctionOp(op), arguments, VCExprNAry.EMPTY_TYPE_LIST);
-    }
-
-    public VCExpr/*!*/ Function(Function/*!*/ op, params VCExpr[]/*!*/ arguments) {
-      Contract.Requires(cce.NonNullElements(arguments));
-      Contract.Requires(op != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      return Function(BoogieFunctionOp(op), arguments);
-    }
-
-
-    // The following method should really be called "ReduceLeft". It must
-    // only be used for the binary operators "and" and "or"
-    public VCExpr/*!*/ NAry(VCExprOp/*!*/ op, List<VCExpr/*!*/>/*!*/ args) {
-      Contract.Requires(op != null);
-      Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      return NAry(op, args.ToArray());
-    }
-
-    public VCExpr/*!*/ NAry(VCExprOp/*!*/ op, params VCExpr[]/*!*/ args) {
-      Contract.Requires(op != null);
-      Contract.Requires(cce.NonNullElements(args));
-      Contract.Requires(op == AndOp || op == OrOp);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      bool and = (op == AndOp);
-
-      VCExpr/*!*/ e = and ? True : False;
-      foreach (VCExpr a in args) {
-        e = and ? AndSimp(e, cce.NonNull(a)) : OrSimp(e, cce.NonNull(a));
-      }
-      return e;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////////
-
-    public static readonly VCExprOp NotOp = new VCExprNAryOp(1, Type.Bool);
-    public static readonly VCExprOp EqOp = new VCExprNAryOp(2, Type.Bool);
-    public static readonly VCExprOp NeqOp = new VCExprNAryOp(2, Type.Bool);
-    public static readonly VCExprOp AndOp = new VCExprNAryOp(2, Type.Bool);
-    public static readonly VCExprOp OrOp = new VCExprNAryOp(2, Type.Bool);
-    public static readonly VCExprOp ImpliesOp = new VCExprNAryOp(2, Type.Bool);
-
-    public VCExprDistinctOp DistinctOp(int arity) {
-      Contract.Ensures(Contract.Result<VCExprDistinctOp>() != null);
-
-      return new VCExprDistinctOp(arity);
-    }
-
-    public VCExpr/*!*/ Not(List<VCExpr/*!*/>/*!*/ args) {
-      Contract.Requires(args != null);
-      Contract.Requires(args.Count == 1);
-      Contract.Requires(args[0] != null);
-      return Function(NotOp, args);
-    }
-
-    public VCExpr/*!*/ Not(VCExpr/*!*/ e0) {
-      Contract.Requires(e0 != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      return Function(NotOp, e0);
-    }
-    public VCExpr/*!*/ Eq(VCExpr/*!*/ e0, VCExpr/*!*/ e1) {
-      return Function(EqOp, e0, e1);
-    }
-    public VCExpr/*!*/ Neq(VCExpr/*!*/ e0, VCExpr/*!*/ e1) {
-      Contract.Requires(e0 != null);
-      Contract.Requires(e1 != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      return Function(NeqOp, e0, e1);
-    }
-    public VCExpr/*!*/ And(VCExpr/*!*/ e0, VCExpr/*!*/ e1) {
-      Contract.Requires(e0 != null);
-      Contract.Requires(e1 != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(AndOp, e0, e1);
-    }
-    public VCExpr/*!*/ Gt(VCExpr/*!*/ e0, VCExpr/*!*/ e1)
-    {
-        Contract.Requires(e0 != null);
-        Contract.Requires(e1 != null);
-        Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-        return Function(GtOp, e0, e1);
-    }
-    public VCExpr/*!*/ Add(VCExpr/*!*/ e0, VCExpr/*!*/ e1)
-    {
-        Contract.Requires(e0 != null);
-        Contract.Requires(e1 != null);
-        Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-        VCExprOp op = cce.NonNull(cce.NonNull(e0).Type).IsInt ? AddIOp : AddROp;
-        return Function(op, e0, e1);
-    }
-    public VCExpr/*!*/ Or(VCExpr/*!*/ e0, VCExpr/*!*/ e1) {
-      Contract.Requires(e0 != null);
-      Contract.Requires(e1 != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(OrOp, e0, e1);
-    }
-    public VCExpr/*!*/ Implies(VCExpr/*!*/ e0, VCExpr/*!*/ e1) {
-      Contract.Requires(e0 != null);
-      Contract.Requires(e1 != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(ImpliesOp, e0, e1);
-    }
-    public VCExpr/*!*/ Distinct(List<VCExpr/*!*/>/*!*/ args) {
-      Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      if (args.Count <= 1)
-        // trivial case
-        return True;
-      return Function(DistinctOp(args.Count), args);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    // Versions of the propositional operators that automatically simplify in
-    // certain cases (for example, if one of the operators is True or False)
-
-    public VCExpr NotSimp(VCExpr e0) {
-      Contract.Requires(e0 != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (e0.Equals(True))
-        return False;
-      if (e0.Equals(False))
-        return True;
-      return Not(e0);
-    }
-    public VCExpr AndSimp(VCExpr e0, VCExpr e1) {
-      Contract.Requires(e1 != null);
-      Contract.Requires(e0 != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (e0.Equals(True))
-        return e1;
-      if (e1.Equals(True))
-        return e0;
-      if (e0.Equals(False) || e1.Equals(False))
-        return False;
-      return And(e0, e1);
-    }
-    public VCExpr OrSimp(VCExpr e0, VCExpr e1) {
-      Contract.Requires(e1 != null);
-      Contract.Requires(e0 != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (e0.Equals(False))
-        return e1;
-      if (e1.Equals(False))
-        return e0;
-      if (e0.Equals(True) || e1.Equals(True))
-        return True;
-      return Or(e0, e1);
-    }
-    public VCExpr ImpliesSimp(VCExpr e0, VCExpr e1, bool aggressive = true) {
-      Contract.Requires(e1 != null);
-      Contract.Requires(e0 != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (e0.Equals(True))
-        return e1;
-      if (e1.Equals(False))
-        return NotSimp(e0);
-      if (e0.Equals(False) || e1.Equals(True))
-        return True;
-      // attempt to save on the depth of expressions (to reduce chances of stack overflows)
-      while (aggressive && e1 is VCExprBinary) {
-        VCExprBinary n = (VCExprBinary)e1;
-        if (n.Op == ImpliesOp) {
-          if (AndSize(n[0]) <= AndSize(e0)) {
-            // combine the antecedents
-            e0 = And(e0, n[0]);
-            e1 = n[1];
-            continue;
-          }
-        }
-        break;
-      }
-      return Implies(e0, e1);
-    }
-
-    ///<summary>
-    /// Returns some measure of the number of conjuncts in e.  This could be the total number of conjuncts in all
-    /// top-most layers of the expression, or it can simply be the length of the left-prong of this and-tree.  The
-    /// important thing is that: AndSize(e0) >= AndSize(31) ==> AndSize(And(e0,e1)) > AndSize(e0).
-    ///</summary>
-    int AndSize(VCExpr e) {
-      Contract.Requires(e != null);
-      int n = 1;
-      while (true) {
-        VCExprNAry nary = e as VCExprNAry;
-        if (nary != null && nary.Op == AndOp && 2 <= nary.Arity) {
-          e = nary[0];
-          n++;
-        } else {
-          return n;
-        }
-      }
-    }
-
-    ////////////////////////////////////////////////////////////////////////////////
-    // Further operators
-
-    public static readonly VCExprOp AddIOp = new VCExprNAryOp(2, Type.Int);
-    public static readonly VCExprOp AddROp = new VCExprNAryOp(2, Type.Real);
-    public static readonly VCExprOp SubIOp = new VCExprNAryOp(2, Type.Int);
-    public static readonly VCExprOp SubROp = new VCExprNAryOp(2, Type.Real);
-   // public static readonly VCExprOp SubFOp = new VCExprNAryOp(2, Type.Float);
-    public static readonly VCExprOp MulIOp = new VCExprNAryOp(2, Type.Int);
-    public static readonly VCExprOp MulROp = new VCExprNAryOp(2, Type.Real);
-    //public static readonly VCExprOp MulFOp = new VCExprNAryOp(2, Type.Float);
-    public static readonly VCExprOp DivIOp = new VCExprNAryOp(2, Type.Int);
-    public static readonly VCExprOp DivROp = new VCExprNAryOp(2, Type.Real);
-    //public static readonly VCExprOp DivFOp = new VCExprNAryOp(2, Type.Float);
-    public static readonly VCExprOp ModOp = new VCExprNAryOp(2, Type.Int);
-    public static readonly VCExprOp PowOp = new VCExprNAryOp(2, Type.Real);
-    public static readonly VCExprOp LtOp = new VCExprNAryOp(2, Type.Bool);
-    public static readonly VCExprOp LeOp = new VCExprNAryOp(2, Type.Bool);
-    public static readonly VCExprOp GtOp = new VCExprNAryOp(2, Type.Bool);
-    public static readonly VCExprOp GeOp = new VCExprNAryOp(2, Type.Bool);
-    public static readonly VCExprOp SubtypeOp = new VCExprNAryOp(2, Type.Bool);
-    // ternary version of the subtype operator, the first argument of which gives
-    // the type of the compared terms
-    public static readonly VCExprOp Subtype3Op = new VCExprNAryOp(3, Type.Bool);
-    public static readonly VCExprOp IfThenElseOp = new VCExprIfThenElseOp();
-    public static readonly VCExprOp ToIntOp = new VCExprNAryOp(1, Type.Int);
-    public static readonly VCExprOp ToRealOp = new VCExprNAryOp(1, Type.Real);
-    //public static readonly VCExprOp ToFloatOp = new VCExprNAryOp(1, Type.Float);
-
-    public static readonly VCExprOp TickleBoolOp = new VCExprCustomOp("tickleBool", 1, Type.Bool);
-
-    public VCExprOp BoogieFunctionOp(Function func) {
-      Contract.Requires(func != null);
-      Contract.Ensures(Contract.Result<VCExprOp>() != null);
-      return new VCExprBoogieFunctionOp(func);
-    }
-
-    // Float nodes
-
-    public VCExprOp BinaryFloatOp(int exp, int man, string op)
-    {
-      Contract.Requires(exp > 0);
-      Contract.Requires(man > 0);
-      Contract.Requires(op != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return new VCExprBinaryFloatOp(exp, man, op);
-    }
-
-    // Bitvector nodes
-
-    public VCExpr Bitvector(BvConst bv) {
-      Contract.Requires(bv != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(new VCExprBvOp(bv.Bits), Integer(bv.Value));
-    }
-
-    public VCExpr BvExtract(VCExpr bv, int bits, int start, int end) {
-      Contract.Requires(bv != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(new VCExprBvExtractOp(start, end, bits), bv);
-    }
-
-    public VCExpr BvConcat(VCExpr bv1, VCExpr bv2) {
-      Contract.Requires(bv2 != null);
-      Contract.Requires(bv1 != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(new VCExprBvConcatOp(bv1.Type.BvBits, bv2.Type.BvBits), bv1, bv2);
-    }
-
-    public VCExpr AtMost(VCExpr smaller, VCExpr greater) {
-      Contract.Requires(greater != null);
-      Contract.Requires(smaller != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(SubtypeOp, smaller, greater);
-    }
-
-
-    ////////////////////////////////////////////////////////////////////////////////
-    // Dispatcher for the visitor
-
-    // the declared singleton operators
-    internal enum SingletonOp {
-      NotOp,
-      EqOp,
-      NeqOp,
-      AndOp,
-      OrOp,
-      ImpliesOp,
-      AddOp,
-      SubOp,
-      MulOp,
-      DivOp,
-      ModOp,
-      RealDivOp,
-      PowOp,
-      LtOp,
-      LeOp,
-      GtOp,
-      GeOp,
-      SubtypeOp,
-      Subtype3Op,
-      BvConcatOp,
-      ToIntOp,
-      ToRealOp,
-      ToFloatOp
-    };
-    internal static Dictionary<VCExprOp/*!*/, SingletonOp>/*!*/ SingletonOpDict;
-    [ContractInvariantMethod]
-    void MiscInvariant() {
-      Contract.Invariant(SingletonOpDict != null);
-    }
-
-
-    static VCExpressionGenerator() {
-      SingletonOpDict = new Dictionary<VCExprOp/*!*/, SingletonOp>();
-      SingletonOpDict.Add(NotOp, SingletonOp.NotOp);
-      SingletonOpDict.Add(EqOp, SingletonOp.EqOp);
-      SingletonOpDict.Add(NeqOp, SingletonOp.NeqOp);
-      SingletonOpDict.Add(AndOp, SingletonOp.AndOp);
-      SingletonOpDict.Add(OrOp, SingletonOp.OrOp);
-      SingletonOpDict.Add(ImpliesOp, SingletonOp.ImpliesOp);
-      SingletonOpDict.Add(AddIOp, SingletonOp.AddOp);
-      SingletonOpDict.Add(AddROp, SingletonOp.AddOp);
-      SingletonOpDict.Add(SubIOp, SingletonOp.SubOp);
-      SingletonOpDict.Add(SubROp, SingletonOp.SubOp);
-      //SingletonOpDict.Add(SubFOp, SingletonOp.SubOp);
-      SingletonOpDict.Add(MulIOp, SingletonOp.MulOp);
-      SingletonOpDict.Add(MulROp, SingletonOp.MulOp);
-      //SingletonOpDict.Add(MulFOp, SingletonOp.MulOp);
-      SingletonOpDict.Add(DivIOp, SingletonOp.DivOp);
-      SingletonOpDict.Add(DivROp, SingletonOp.RealDivOp);
-      //SingletonOpDict.Add(DivFOp, SingletonOp.FloatDivOp);
-      SingletonOpDict.Add(ModOp, SingletonOp.ModOp);
-      SingletonOpDict.Add(PowOp, SingletonOp.PowOp);
-      SingletonOpDict.Add(LtOp, SingletonOp.LtOp);
-      SingletonOpDict.Add(LeOp, SingletonOp.LeOp);
-      SingletonOpDict.Add(GtOp, SingletonOp.GtOp);
-      SingletonOpDict.Add(GeOp, SingletonOp.GeOp);
-      SingletonOpDict.Add(SubtypeOp, SingletonOp.SubtypeOp);
-      SingletonOpDict.Add(Subtype3Op, SingletonOp.Subtype3Op);
-      SingletonOpDict.Add(ToIntOp, SingletonOp.ToIntOp);
-      SingletonOpDict.Add(ToRealOp, SingletonOp.ToRealOp);
-      //SingletonOpDict.Add(ToFloatOp, SingletonOp.ToFloatOp);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////////
-
-
-    // Let-bindings
-
-    public VCExprLetBinding LetBinding(VCExprVar v, VCExpr e) {
-      Contract.Requires(e != null);
-      Contract.Requires(v != null);
-      Contract.Ensures(Contract.Result<VCExprLetBinding>() != null);
-      return new VCExprLetBinding(v, e);
-    }
-
-    // A "real" let expression. All let-bindings happen simultaneously, i.e.,
-    // at this level the order of the bindings does not matter. It is possible to
-    // create expressions like   "let x = y, y = 5 in ...". All bound variables are
-    // bound in all bound terms/formulas and can occur there, but the dependencies
-    // have to be acyclic
-    public VCExpr Let(List<VCExprLetBinding> bindings, VCExpr body) {
-      Contract.Requires(body != null);
-      Contract.Requires(cce.NonNullElements(bindings));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (bindings.Count == 0)
-        // no empty let-bindings
-        return body;
-      return new VCExprLet(bindings, body);
-    }
-
-    public VCExpr Let(VCExpr body, params VCExprLetBinding[] bindings) {
-      Contract.Requires(body != null);
-      Contract.Requires((cce.NonNullElements(bindings)));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Let(HelperFuns.ToNonNullList(bindings), body);
-    }
-
-
-    /// <summary>
-    /// In contrast to the previous method, the following methods are not a general LET.
-    ///  Instead, it
-    /// is a boolean "LET b = P in Q", where P and Q are predicates, that is allowed to be
-    /// encoded as "(b == P) ==> Q" or even as "(P ==> b) ==> Q"
-    /// (or "(P ==> b) and Q" in negative positions).
-    /// The method assumes that the variables in the bindings are unique in the entire formula
-    /// to be produced, which allows the implementation to ignore scope issues in the event that
-    /// it needs to generate an alternate expression for LET.
-    /// </summary>
-
-
-    // Turn let-bindings let v = E in ... into implications E ==> v
-    public VCExpr AsImplications(List<VCExprLetBinding> bindings) {
-      Contract.Requires(cce.NonNullElements(bindings));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExpr/*!*/ antecedents = True;
-      foreach (VCExprLetBinding b in bindings)
-        // turn "LET_binding v = E" into "v <== E"
-        antecedents = AndSimp(antecedents, Implies(b.E, b.V));
-      return antecedents;
-    }
-
-    // Turn let-bindings let v = E in ... into equations v == E
-    public VCExpr AsEquations(List<VCExprLetBinding> bindings) {
-      Contract.Requires(cce.NonNullElements(bindings));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExpr/*!*/ antecedents = True;
-      foreach (VCExprLetBinding b in bindings)
-        // turn "LET_binding v = E" into "v <== E"
-        antecedents = AndSimp(antecedents, Eq(b.E, b.V));
-      return antecedents;
-    }
-
-
-
-    // Maps
-
-    public VCExpr Select(params VCExpr[] allArgs) {
-      Contract.Requires(allArgs != null);
-      Contract.Requires((cce.NonNullElements(allArgs)));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(new VCExprSelectOp(allArgs.Length - 1, 0),
-                      HelperFuns.ToNonNullList(allArgs),
-                      VCExprNAry.EMPTY_TYPE_LIST);
-    }
-
-    public VCExpr Select(VCExpr[] allArgs, Type[] typeArgs) {
-      Contract.Requires(1 <= allArgs.Length);
-      Contract.Requires(cce.NonNullElements(allArgs));
-      Contract.Requires(cce.NonNullElements(typeArgs));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(new VCExprSelectOp(allArgs.Length - 1, typeArgs.Length),
-                      allArgs, typeArgs);
-    }
-
-    public VCExpr Select(List<VCExpr> allArgs, List<Type> typeArgs) {
-      Contract.Requires(cce.NonNullElements(typeArgs));
-      Contract.Requires(cce.NonNullElements(allArgs));
-      Contract.Requires((1 <= allArgs.Count));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(new VCExprSelectOp(allArgs.Count - 1, typeArgs.Count),
-                      allArgs, typeArgs);
-    }
-
-    public VCExpr Store(params VCExpr[] allArgs) {
-      Contract.Requires(allArgs != null);
-      Contract.Requires(cce.NonNullElements(allArgs));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(new VCExprStoreOp(allArgs.Length - 2, 0),
-                      HelperFuns.ToNonNullList(allArgs),
-                      VCExprNAry.EMPTY_TYPE_LIST);
-    }
-
-    public VCExpr Store(VCExpr[] allArgs, Type[] typeArgs) {
-      Contract.Requires(typeArgs != null);
-      Contract.Requires(allArgs != null);
-      Contract.Requires((2 <= allArgs.Length));
-      Contract.Requires(cce.NonNullElements(allArgs));
-      Contract.Requires(cce.NonNullElements(typeArgs));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(new VCExprStoreOp(allArgs.Length - 2, typeArgs.Length),
-                      allArgs, typeArgs);
-    }
-
-    public VCExpr Store(List<VCExpr> allArgs, List<Type/*!*/>/*!*/ typeArgs) {
-      Contract.Requires(cce.NonNullElements(typeArgs));
-      Contract.Requires(cce.NonNullElements(allArgs));
-      Contract.Requires((2 <= allArgs.Count));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(new VCExprStoreOp(allArgs.Count - 2, typeArgs.Count),
-                      allArgs, typeArgs);
-    }
-
-
-    // Labels
-
-    public VCExprLabelOp LabelOp(bool pos, string l) {
-      Contract.Requires(l != null);
-      Contract.Ensures(Contract.Result<VCExprLabelOp>() != null);
-      return new VCExprLabelOp(pos, l);
-    }
-
-    public VCExpr LabelNeg(string label, VCExpr e) {
-      Contract.Requires(e != null);
-      Contract.Requires(label != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      if (e.Equals(True)) {
-        return e;  // don't bother putting negative labels around True (which will expose the True to further peephole optimizations)
-      }
-      return Function(LabelOp(false, label), e);
-    }
-    public VCExpr LabelPos(string label, VCExpr e) {
-      Contract.Requires(e != null);
-      Contract.Requires(label != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Function(LabelOp(true, label), e);
-    }
-
-    // Quantifiers
-
-    public VCExpr Quantify(Quantifier quan, List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, VCQuantifierInfos infos, VCExpr body) {
-      Contract.Requires(body != null);
-      Contract.Requires(infos != null);
-      Contract.Requires(cce.NonNullElements(triggers));
-      Contract.Requires(cce.NonNullElements(vars));
-      Contract.Requires(cce.NonNullElements(typeParams));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return new VCExprQuantifier(quan, typeParams, vars, triggers, infos, body);
-    }
-
-    public VCExpr Forall(List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, VCQuantifierInfos infos, VCExpr body) {
-      Contract.Requires(body != null);
-      Contract.Requires(infos != null);
-      Contract.Requires(cce.NonNullElements(triggers));
-      Contract.Requires(cce.NonNullElements(vars));
-      Contract.Requires(cce.NonNullElements(typeParams));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Quantify(Quantifier.ALL, typeParams, vars, triggers, infos, body);
-    }
-    public VCExpr Forall(List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, string qid, int weight, VCExpr body) {
-      Contract.Requires(body != null);
-      Contract.Requires(qid != null);
-      Contract.Requires(cce.NonNullElements(triggers));
-      Contract.Requires(cce.NonNullElements(vars));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      QKeyValue kv = null;
-      if (0 <= weight) {
-        kv = new QKeyValue(Token.NoToken, "weight", new List<object>() { new LiteralExpr(Token.NoToken, BigNum.FromInt(0)) }, null);
-      }
-      return Quantify(Quantifier.ALL, new List<TypeVariable/*!*/>(), vars,
-                            triggers, new VCQuantifierInfos(qid, -1, false, kv), body);
-    }
-    public VCExpr Forall(List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, VCExpr body) {
-      Contract.Requires(body != null);
-      Contract.Requires(cce.NonNullElements(triggers));
-      Contract.Requires(cce.NonNullElements(vars));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Quantify(Quantifier.ALL, new List<TypeVariable/*!*/>(), vars,
-                            triggers, new VCQuantifierInfos(null, -1, false, null), body);
-    }
-    public VCExpr Forall(VCExprVar var, VCTrigger trigger, VCExpr body) {
-      Contract.Requires(body != null);
-      Contract.Requires(trigger != null);
-      Contract.Requires(var != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Forall(HelperFuns.ToNonNullList(var), HelperFuns.ToNonNullList(trigger), body);
-    }
-    public VCExpr Exists(List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, VCQuantifierInfos infos, VCExpr body) {
-      Contract.Requires(body != null);
-      Contract.Requires(infos != null);
-      Contract.Requires(cce.NonNullElements(triggers));
-      Contract.Requires(cce.NonNullElements(vars));
-      Contract.Requires(cce.NonNullElements(typeParams));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Quantify(Quantifier.EX, typeParams, vars, triggers, infos, body);
-    }
-    public VCExpr Exists(List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, VCExpr body) {
-      Contract.Requires(body != null);
-      Contract.Requires(cce.NonNullElements(triggers));
-      Contract.Requires(cce.NonNullElements(vars));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Quantify(Quantifier.EX, new List<TypeVariable/*!*/>(), vars,
-                      triggers, new VCQuantifierInfos(null, -1, false, null), body);
-    }
-    public VCExpr Exists(VCExprVar var, VCTrigger trigger, VCExpr body) {
-      Contract.Requires(body != null);
-      Contract.Requires(trigger != null);
-      Contract.Requires(var != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return Exists(HelperFuns.ToNonNullList(var), HelperFuns.ToNonNullList(trigger), body);
-    }
-
-    public VCTrigger Trigger(bool pos, List<VCExpr> exprs) {
-      Contract.Requires(cce.NonNullElements(exprs));
-      Contract.Ensures(Contract.Result<VCTrigger>() != null);
-      return new VCTrigger(pos, exprs);
-    }
-
-    public VCTrigger Trigger(bool pos, params VCExpr[] exprs) {
-      Contract.Requires(exprs != null);
-      Contract.Requires((Contract.ForAll(0, exprs.Length, i => exprs[i] != null)));
-      Contract.Ensures(Contract.Result<VCTrigger>() != null);
-      return Trigger(pos, HelperFuns.ToNonNullList(exprs));
-    }
-
-    // Reference to a bound or free variable
-
-    public VCExprVar Variable(string name, Type type) {
-      Contract.Requires(type != null);
-      Contract.Requires(name != null);
-      Contract.Ensures(Contract.Result<VCExprVar>() != null);
-      return new VCExprVar(name, type);
-    }
-  }
-}
-
-namespace Microsoft.Boogie.VCExprAST {
-
-  public class HelperFuns {
-    public static bool SameElements(IEnumerable a, IEnumerable b) {
-      Contract.Requires(b != null);
-      Contract.Requires(a != null);
-      IEnumerator ia = a.GetEnumerator();
-      IEnumerator ib = b.GetEnumerator();
-      while (true) {
-        if (ia.MoveNext()) {
-          if (ib.MoveNext()) {
-            if (!cce.NonNull(ia.Current).Equals(ib.Current))
-              return false;
-          } else {
-            return false;
-          }
-        } else {
-          return !ib.MoveNext();
-        }
-      }
-    }
-
-    public static int PolyHash(int init, int factor, IEnumerable a) {
-      Contract.Requires(a != null);
-      int res = init;
-      foreach (object x in a)
-        res = res * factor + (cce.NonNull(x)).GetHashCode();
-      return res;
-    }
-
-    public static List<T> ToList<T>(IEnumerable<T> l) {
-      Contract.Requires(l != null);
-      Contract.Ensures(Contract.Result<List<T>>() != null);
-      List<T>/*!*/ res = new List<T>();
-      foreach (T x in l)
-        res.Add(x);
-      return res;
-    }
-
-    public static List<Type> ToTypeSeq(VCExpr[] exprs, int startIndex) {
-      Contract.Requires(exprs != null);
-      Contract.Requires((Contract.ForAll(0, exprs.Length, i => exprs[i] != null)));
-      Contract.Ensures(Contract.Result<List<Type>>() != null);
-      List<Type>/*!*/ res = new List<Type>();
-      for (int i = startIndex; i < exprs.Length; ++i)
-        res.Add(cce.NonNull(exprs[i]).Type);
-      return res;
-    }
-
-    public static List<T/*!*/>/*!*/ ToNonNullList<T>(params T[] args) where T : class {
-      Contract.Requires(args != null);
-      List<T/*!*/>/*!*/ res = new List<T>(args.Length);
-      foreach (T t in args)
-        res.Add(cce.NonNull(t));
-      return res;
-    }
-
-    public static IDictionary<A, B> Clone<A, B>(IDictionary<A, B> dict) {
-      Contract.Requires(dict != null);
-      Contract.Ensures(Contract.Result<IDictionary<A, B>>() != null);
-      IDictionary<A, B> res = new Dictionary<A, B>(dict.Count);
-      foreach (KeyValuePair<A, B> pair in dict)
-        res.Add(pair);
-      return res;
-    }
-  }
-
-  [ContractClassFor(typeof(VCExpr))]
-  public abstract class VCExprContracts : VCExpr {
-    public override Type Type {
-      get {
-        Contract.Ensures(Contract.Result<Type>() != null);
-        throw new NotImplementedException();
-      }
-
-    }
-    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
-      Contract.Requires(visitor != null);
-      throw new NotImplementedException();
-    }
-  }
-
-  [ContractClass(typeof(VCExprContracts))]
-  public abstract class VCExpr {
-    public abstract Type Type {
-      get;
-    }
-
-    public abstract Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg);
-
-    [Pure]
-    public override string ToString() {
-      Contract.Ensures(Contract.Result<string>() != null);
-      StringWriter sw = new StringWriter();
-      VCExprPrinter printer = new VCExprPrinter();
-      printer.Print(this, sw);
-      return cce.NonNull(sw.ToString());
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////////////
-  // Literal expressions
-
-  public class VCExprLiteral : VCExpr {
-    private readonly Type LitType;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(LitType != null);
-    }
-
-    public override Type Type {
-      get {
-        return LitType;
-      }
-    }
-    internal VCExprLiteral(Type type) {
-      Contract.Requires(type != null);
-      this.LitType = type;
-    }
-    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      return visitor.Visit(this, arg);
-    }
-  }
-
-  public class VCExprIntLit : VCExprLiteral {
-    public readonly BigNum Val;
-    internal VCExprIntLit(BigNum val)
-      : base(Type.Int) {
-      this.Val = val;
-    }
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprIntLit)
-        return Val == ((VCExprIntLit)that).Val;
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return Val.GetHashCode() * 72321;
-    }
-  }
-
-  public class VCExprRealLit : VCExprLiteral {
-    public readonly BigDec Val;
-    internal VCExprRealLit(BigDec val)
-      : base(Type.Real) {
-      this.Val = val;
-    }
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprRealLit)
-        return Val == ((VCExprRealLit)that).Val;
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return Val.GetHashCode() * 72321;
-    }
-  }
-
-  public class VCExprFloatLit : VCExprLiteral
-  {
-    public readonly BigFloat Val;
-    internal VCExprFloatLit(BigFloat val)
-      : base(Type.GetFloatType(val.ExponentSize, val.SignificandSize))
-    {
-      this.Val = val;
-    }
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that)
-    {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprFloatLit)
-        return Val == ((VCExprFloatLit)that).Val;
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode()
-    {
-      return Val.GetHashCode() * 72321;
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////////////
-  // Operator expressions with fixed arity
-  [ContractClassFor(typeof(VCExprNAry))]
-  public abstract class VCExprNAryContracts : VCExprNAry {
-    public VCExprNAryContracts()
-      : base(null) {
-    }
-    public override VCExpr this[int index] {
-      get {
-        Contract.Ensures(Contract.Result<VCExpr>() != null);
-        throw new NotImplementedException();
-      }
-    }
-  }
-
-  [ContractClass(typeof(VCExprNAryContracts))]
-  public abstract class VCExprNAry : VCExpr, IEnumerable<VCExpr/*!*/> {
-    public readonly VCExprOp Op;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Op != null);
-      Contract.Invariant(cce.NonNullElements(EMPTY_TYPE_LIST));
-      Contract.Invariant(cce.NonNullElements(EMPTY_VCEXPR_LIST));
-    }
-
-    public int Arity {
-      get {
-        return Op.Arity;
-      }
-    }
-    public int TypeParamArity {
-      get {
-        return Op.TypeParamArity;
-      }
-    }
-    public int Length {
-      get {
-        return Arity;
-      }
-    }
-    // the sub-expressions of the expression
-    public abstract VCExpr/*!*/ this[int index] {
-      get;
-    }
-
-    // the type arguments
-    public abstract List<Type/*!*/>/*!*/ TypeArguments {
-      get;
-    }
-
-    [Pure]
-    [GlobalAccess(false)]
-    [Escapes(true, false)]
-    public IEnumerator<VCExpr/*!*/>/*!*/ GetEnumerator() {
-      Contract.Ensures(cce.NonNullElements(Contract.Result<IEnumerator<VCExpr>>()));
-      for (int i = 0; i < Arity; ++i)
-        yield return this[i];
-    }
-    [Pure]
-    [GlobalAccess(false)]
-    [Escapes(true, false)]
-    IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-      Contract.Ensures(Contract.Result<IEnumerator>() != null);
-      for (int i = 0; i < Arity; ++i)
-        yield return this[i];
-    }
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprNAry) {
-        // we compare the subterms iteratively (not recursively)
-        // to avoid stack overflows
-
-        VCExprNAryEnumerator enum0 = new VCExprNAryEnumerator(this);
-        VCExprNAryEnumerator enum1 = new VCExprNAryEnumerator((VCExprNAry)that);
-
-        while (true) {
-          bool next0 = enum0.MoveNext();
-          bool next1 = enum1.MoveNext();
-          if (next0 != next1)
-            return false;
-          if (!next0)
-            return true;
-
-          VCExprNAry nextExprNAry0 = enum0.Current as VCExprNAry;
-          VCExprNAry nextExprNAry1 = enum1.Current as VCExprNAry;
-
-          if ((nextExprNAry0 == null) != (nextExprNAry1 == null))
-            return false;
-          if (nextExprNAry0 != null && nextExprNAry1 != null) {
-            if (!nextExprNAry0.Op.Equals(nextExprNAry1.Op))
-              return false;
-          } else {
-            if (!cce.NonNull(enum0.Current).Equals(enum1.Current))
-              return false;
-          }
-        }
-      }
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return HelperFuns.PolyHash(Op.GetHashCode() * 123 + Arity * 61521,
-                                 3, this);
-    }
-
-    internal VCExprNAry(VCExprOp op) {
-      Contract.Requires(op != null);
-      this.Op = op;
-    }
-    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      return visitor.Visit(this, arg);
-    }
-    public Result Accept<Result, Arg>(IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      Contract.Requires(visitor != null);
-      return Op.Accept(this, visitor, arg);
-    }
-
-    internal static readonly List<Type/*!*/>/*!*/ EMPTY_TYPE_LIST = new List<Type/*!*/>();
-    internal static readonly List<VCExpr/*!*/>/*!*/ EMPTY_VCEXPR_LIST = new List<VCExpr/*!*/>();
-
-    public IEnumerable<VCExpr> UniformArguments
-    {
-      get
-      {
-        var enumerator = new VCExprNAryUniformOpEnumerator(this);
-        while (enumerator.MoveNext()) {
-          VCExprNAry naryExpr = enumerator.Current as VCExprNAry;
-          if (naryExpr == null || !naryExpr.Op.Equals(this.Op)) {
-            yield return (VCExpr)enumerator.Current;
-          }
-        }
-      }
-    }
-  }
-
-  // We give specialised implementations for nullary, unary and binary expressions
-
-  internal class VCExprNullary : VCExprNAry {
-    private readonly Type ExprType;
-    [ContractInvariantMethod]
-    void loneinvariant() {
-      Contract.Invariant(ExprType != null);
-    }
-
-    public override Type Type {
-      get {
-        Contract.Ensures(Contract.Result<Type>() != null);
-        return ExprType;
-      }
-    }
-    public override VCExpr this[int index] {
-      get {
-        Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-        Contract.Assert(false);
-        throw new cce.UnreachableException(); // no arguments
-      }
-    }
-
-    // the type arguments
-    public override List<Type/*!*/>/*!*/ TypeArguments {
-      get {
-        Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
-        return EMPTY_TYPE_LIST;
-      }
-    }
-
-    internal VCExprNullary(VCExprOp op)
-      : base(op) {
-      Contract.Requires(op != null);
-      Contract.Requires(op.Arity == 0 && op.TypeParamArity == 0);
-      this.ExprType = op.InferType(EMPTY_VCEXPR_LIST, EMPTY_TYPE_LIST);
-    }
-  }
-
-  internal class VCExprUnary : VCExprNAry {
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Argument != null);
-      Contract.Invariant(ExprType != null);
-
-    }
-
-    private readonly VCExpr/*!*/ Argument;
-    private readonly Type/*!*/ ExprType;
-    public override Type/*!*/ Type {
-      get {
-        Contract.Ensures(Contract.Result<Type>() != null);
-        return ExprType;
-      }
-    }
-    public override VCExpr/*!*/ this[int index] {
-      get {
-        Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-        Contract.Assume(index == 0);
-        return Argument;
-      }
-    }
-
-    // the type arguments
-    public override List<Type/*!*/>/*!*/ TypeArguments {
-      get {
-        Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
-        return EMPTY_TYPE_LIST;
-      }
-    }
-
-    internal VCExprUnary(VCExprOp op, List<VCExpr> arguments)
-      : base(op) {
-      Contract.Requires(op != null);
-      Contract.Requires(cce.NonNullElements(arguments));
-      Contract.Requires(op.Arity == 1 && op.TypeParamArity == 0 && arguments.Count == 1);
-
-      this.Argument = arguments[0];
-      this.ExprType =
-        op.InferType(arguments, EMPTY_TYPE_LIST);
-    }
-
-    internal VCExprUnary(VCExprOp op, VCExpr argument)
-      : base(op) {
-      Contract.Requires(argument != null);
-      Contract.Requires(op != null);
-      Contract.Requires(op.Arity == 1 && op.TypeParamArity == 0);
-
-      this.Argument = argument;
-      // PR: could be optimised so that the argument does
-      // not have to be boxed in an array each time
-      this.ExprType =
-        op.InferType(HelperFuns.ToNonNullList(argument), EMPTY_TYPE_LIST);
-    }
-  }
-
-  internal class VCExprBinary : VCExprNAry {
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Argument0 != null);
-      Contract.Invariant(Argument1 != null);
-      Contract.Invariant(ExprType != null);
-    }
-
-    private readonly VCExpr Argument0;
-    private readonly VCExpr Argument1;
-    private readonly Type ExprType;
-    public override Type Type {
-      get {
-        Contract.Ensures(Contract.Result<Type>() != null);
-        return ExprType;
-      }
-    }
-    public override VCExpr this[int index] {
-      get {
-        Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-        switch (index) {
-          case 0:
-            return Argument0;
-          case 1:
-            return Argument1;
-          default: {
-              Contract.Assert(false);
-              throw new cce.UnreachableException();
-            }
-        }
-      }
-    }
-
-    // the type arguments
-    public override List<Type/*!*/>/*!*/ TypeArguments {
-      get {
-        Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
-        return EMPTY_TYPE_LIST;
-      }
-    }
-
-    internal VCExprBinary(VCExprOp op, List<VCExpr> arguments)
-      : base(op) {
-      Contract.Requires(op != null);
-      Contract.Requires(cce.NonNullElements(arguments));
-      Contract.Requires(op.Arity == 2 && op.TypeParamArity == 0 && arguments.Count == 2);
-
-      this.Argument0 = arguments[0];
-      this.Argument1 = arguments[1];
-      this.ExprType = op.InferType(arguments, EMPTY_TYPE_LIST);
-    }
-
-    internal VCExprBinary(VCExprOp op, VCExpr argument0, VCExpr argument1)
-      : base(op) {
-      Contract.Requires(argument1 != null);
-      Contract.Requires(argument0 != null);
-      Contract.Requires(op != null);
-      Contract.Requires(op.Arity == 2 && op.TypeParamArity == 0);
-      this.Argument0 = argument0;
-      this.Argument1 = argument1;
-      // PR: could be optimised so that the arguments do
-      // not have to be boxed in an array each time
-      this.ExprType =
-        op.InferType(HelperFuns.ToNonNullList(argument0, argument1),
-                     EMPTY_TYPE_LIST);
-    }
-  }
-
-  internal class VCExprMultiAry : VCExprNAry {
-    private readonly List<VCExpr/*!*/>/*!*/ Arguments;
-    private readonly List<Type/*!*/>/*!*/ TypeArgumentsAttr;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(cce.NonNullElements(Arguments));
-      Contract.Invariant(cce.NonNullElements(TypeArgumentsAttr));
-      Contract.Invariant(ExprType != null);
-    }
-
-
-    private readonly Type/*!*/ ExprType;
-    public override Type/*!*/ Type {
-      get {
-        Contract.Ensures(Contract.Result<Type>() != null);
-        return ExprType;
-      }
-    }
-    public override VCExpr/*!*/ this[int index] {
-      get {
-        Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-        Contract.Assume(index >= 0 && index < Arity);
-        return cce.NonNull(Arguments)[index];
-      }
-    }
-
-    // the type arguments
-    public override List<Type/*!*/>/*!*/ TypeArguments {
-      get {
-        Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
-        return TypeArgumentsAttr;
-      }
-    }
-
-    internal VCExprMultiAry(VCExprOp op, List<VCExpr> arguments)
-      : base(op) {
-      Contract.Requires(op != null);
-      Contract.Requires(cce.NonNullElements(arguments));
-      this.Arguments = arguments;
-      this.TypeArgumentsAttr = EMPTY_TYPE_LIST;
-      this.ExprType = op.InferType(arguments, TypeArgumentsAttr);
-    }
-    internal VCExprMultiAry(VCExprOp op, List<VCExpr> arguments, List<Type/*!*/>/*!*/ typeArguments)
-      : base(op) {
-      Contract.Requires(op != null);
-      Contract.Requires(cce.NonNullElements(typeArguments));
-      Contract.Requires(cce.NonNullElements(arguments));
-      Contract.Requires(arguments.Count > 2 || typeArguments.Count > 0);
-      Contract.Requires(op.Arity == arguments.Count);
-      Contract.Requires(op.TypeParamArity == typeArguments.Count);
-      this.Arguments = arguments;
-      this.TypeArgumentsAttr = typeArguments;
-      this.ExprType = op.InferType(arguments, typeArguments);
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////////////
-  // The various operators available
-  [ContractClass(typeof(VCExprOpContracts))]
-  public abstract class VCExprOp {
-    // the number of value parameters
-    public abstract int Arity {
-      get;
-    }
-    // the number of type parameters
-    public abstract int TypeParamArity {
-      get;
-    }
-
-    public abstract Type/*!*/ InferType(List<VCExpr/*!*/>/*!*/ args, List<Type/*!*/>/*!*/ typeArgs);
-
-    public virtual Result Accept<Result, Arg>(VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      Contract.Requires(visitor != null);
-      Contract.Requires(expr != null);
-      VCExpressionGenerator.SingletonOp op;
-      if (VCExpressionGenerator.SingletonOpDict.TryGetValue(this, out op)) {
-        switch (op) {
-          case VCExpressionGenerator.SingletonOp.NotOp:
-            return visitor.VisitNotOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.EqOp:
-            return visitor.VisitEqOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.NeqOp:
-            return visitor.VisitNeqOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.AndOp:
-            return visitor.VisitAndOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.OrOp:
-            return visitor.VisitOrOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.ImpliesOp:
-            return visitor.VisitImpliesOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.AddOp:
-            return visitor.VisitAddOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.SubOp:
-            return visitor.VisitSubOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.MulOp:
-            return visitor.VisitMulOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.DivOp:
-            return visitor.VisitDivOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.ModOp:
-            return visitor.VisitModOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.RealDivOp:
-            return visitor.VisitRealDivOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.PowOp:
-            return visitor.VisitPowOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.LtOp:
-            return visitor.VisitLtOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.LeOp:
-            return visitor.VisitLeOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.GtOp:
-            return visitor.VisitGtOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.GeOp:
-            return visitor.VisitGeOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.SubtypeOp:
-            return visitor.VisitSubtypeOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.Subtype3Op:
-            return visitor.VisitSubtype3Op(expr, arg);
-          case VCExpressionGenerator.SingletonOp.BvConcatOp:
-            return visitor.VisitBvConcatOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.ToIntOp:
-            return visitor.VisitToIntOp(expr, arg);
-          case VCExpressionGenerator.SingletonOp.ToRealOp:
-            return visitor.VisitToRealOp(expr, arg);
-          default:
-            Contract.Assert(false);
-            throw new cce.UnreachableException();
-        }
-      } else {
-        Contract.Assert(false);
-        throw new cce.UnreachableException();
-      }
-    }
-  }
-  [ContractClassFor(typeof(VCExprOp))]
-  abstract class VCExprOpContracts : VCExprOp {
-    public override Type InferType(List<VCExpr> args, List<Type> typeArgs) {
-      Contract.Requires(cce.NonNullElements(args));
-      Contract.Requires(cce.NonNullElements(typeArgs));
-      Contract.Ensures(Contract.Result<Type>() != null);
-
-      throw new NotImplementedException();
-    }
-  }
-
-  public class VCExprNAryOp : VCExprOp {
-    private readonly Type OpType;
-    private readonly int OpArity;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(OpType != null);
-    }
-
-    public override int Arity {
-      get {
-        return OpArity;
-      }
-    }
-    public override int TypeParamArity {
-      get {
-        return 0;
-      }
-    }
-    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
-      //Contract.Requires(cce.NonNullElements(typeArgs));
-      //Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<Type>() != null);
-      return OpType;
-    }
-
-    internal VCExprNAryOp(int arity, Type type) {
-      Contract.Requires(type != null);
-      this.OpArity = arity;
-      this.OpType = type;
-    }
-  }
-
-  public class VCExprDistinctOp : VCExprNAryOp {
-    internal VCExprDistinctOp(int arity)
-      : base(arity, Type.Bool) {
-    }
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprDistinctOp)
-        return Arity == ((VCExprDistinctOp)that).Arity;
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return Arity * 917632481;
-    }
-    public override Result Accept<Result, Arg>
-           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      //Contract.Requires(expr != null);
-      return visitor.VisitDistinctOp(expr, arg);
-    }
-  }
-
-  public class VCExprLabelOp : VCExprOp {
-    public override int Arity {
-      get {
-        return 1;
-      }
-    }
-    public override int TypeParamArity {
-      get {
-        return 0;
-      }
-    }
-    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
-      //Contract.Requires(cce.NonNullElements(typeArgs));
-      //Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<Type>() != null);
-      return args[0].Type;
-    }
-
-    public readonly bool pos;
-    public readonly string label;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(label != null);
-    }
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprLabelOp) {
-        VCExprLabelOp/*!*/ thatOp = (VCExprLabelOp)that;
-        return this.pos == thatOp.pos && this.label.Equals(thatOp.label);
-      }
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return (pos ? 9817231 : 7198639) + label.GetHashCode();
-    }
-
-    internal VCExprLabelOp(bool pos, string l) {
-      Contract.Requires(l != null);
-      this.pos = pos;
-      this.label = pos ? "+" + l : "@" + l;
-    }
-    public override Result Accept<Result, Arg>
-           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      //Contract.Requires(expr != null);
-      return visitor.VisitLabelOp(expr, arg);
-    }
-  }
-
-  public class VCExprSelectOp : VCExprOp {
-    private readonly int MapArity;
-    private readonly int MapTypeParamArity;
-    public override int Arity {
-      get {
-        return MapArity + 1;
-      }
-    }
-    public override int TypeParamArity {
-      get {
-        return MapTypeParamArity;
-      }
-    }
-
-    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
-      //Contract.Requires(cce.NonNullElements(typeArgs));
-      //Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<Type>() != null);
-      MapType/*!*/ mapType = args[0].Type.AsMap;
-      Contract.Assert(TypeParamArity == mapType.TypeParameters.Count);
-      IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ subst = new Dictionary<TypeVariable/*!*/, Type/*!*/>();
-      for (int i = 0; i < TypeParamArity; ++i)
-        subst.Add(mapType.TypeParameters[i], typeArgs[i]);
-      return mapType.Result.Substitute(subst);
-    }
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprSelectOp)
-        return Arity == ((VCExprSelectOp)that).Arity &&
-          TypeParamArity == ((VCExprSelectOp)that).TypeParamArity;
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return Arity * 1212481 + TypeParamArity * 298741;
-    }
-
-    internal VCExprSelectOp(int arity, int typeParamArity) {
-      Contract.Requires(0 <= arity && 0 <= typeParamArity);
-      this.MapArity = arity;
-      this.MapTypeParamArity = typeParamArity;
-    }
-    public override Result Accept<Result, Arg>
-           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      //Contract.Requires(expr != null);
-      return visitor.VisitSelectOp(expr, arg);
-    }
-  }
-
-  public class VCExprStoreOp : VCExprOp {
-    private readonly int MapArity;
-    private readonly int MapTypeParamArity;
-    public override int Arity {
-      get {
-        return MapArity + 2;
-      }
-    }
-    // stores never need explicit type parameters, because also the
-    // rhs is a value argument
-    public override int TypeParamArity {
-      get {
-        return MapTypeParamArity;
-      }
-    }
-
-    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
-      //Contract.Requires(cce.NonNullElements(typeArgs));
-      //Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<Type>() != null);
-      return args[0].Type;
-    }
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprStoreOp)
-        return Arity == ((VCExprStoreOp)that).Arity;
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return Arity * 91361821;
-    }
-
-    internal VCExprStoreOp(int arity, int typeParamArity) {
-      Contract.Requires(0 <= arity && 0 <= typeParamArity);
-      this.MapArity = arity;
-      this.MapTypeParamArity = typeParamArity;
-    }
-    public override Result Accept<Result, Arg>
-           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      //Contract.Requires(expr != null);
-      return visitor.VisitStoreOp(expr, arg);
-    }
-  }
-
-  public class VCExprIfThenElseOp : VCExprOp {
-    public override int Arity {
-      get {
-        return 3;
-      }
-    }
-    public override int TypeParamArity {
-      get {
-        return 0;
-      }
-    }
-    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
-      //Contract.Requires(cce.NonNullElements(typeArgs));
-      //Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<Type>() != null);
-      return args[1].Type;
-    }
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprIfThenElseOp)
-        return true;
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return 1;
-    }
-
-    internal VCExprIfThenElseOp() {
-    }
-    public override Result Accept<Result, Arg>
-           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      //Contract.Requires(expr != null);
-      return visitor.VisitIfThenElseOp(expr, arg);
-    }
-  }
-
-  public class VCExprCustomOp : VCExprOp {
-    public readonly string/*!*/ Name;
-    int arity;
-    public readonly Type/*!*/ Type;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Name != null);
-      Contract.Invariant(Type != null);
-    }
-
-    public VCExprCustomOp(string/*!*/ name, int arity, Type/*!*/ type) {
-      Contract.Requires(name != null);
-      Contract.Requires(type != null);
-      this.Name = name;
-      this.arity = arity;
-      this.Type = type;
-    }
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      VCExprCustomOp t = that as VCExprCustomOp;
-      if (t == null)
-        return false;
-      return this.Name == t.Name && this.arity == t.arity && this.Type == t.Type;
-    }
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override int GetHashCode() {
-      int h = Name.GetHashCode();
-      h = 7823 * h + arity;
-      h = 7823 * h + Type.GetHashCode();
-      return h;
-    }
-    public override int Arity {
-      get {
-        return arity;
-      }
-    }
-    public override int TypeParamArity {
-      get {
-        return 0;
-      }
-    }
-    public override Type/*!*/ InferType(List<VCExpr/*!*/>/*!*/ args, List<Type/*!*/>/*!*/ typeArgs) {
-      //Contract.Requires((cce.NonNullElements(args)));
-      //Contract.Requires((cce.NonNullElements(typeArgs)));
-      Contract.Ensures(Contract.Result<Type>() != null);
-      return Type;
-    }
-    public override Result Accept<Result, Arg>
-           (VCExprNAry/*!*/ expr, IVCExprOpVisitor<Result, Arg>/*!*/ visitor, Arg arg) {
-      //Contract.Requires(expr != null);
-      //Contract.Requires(visitor != null);
-      return visitor.VisitCustomOp(expr, arg);
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////////////
-  // Float operators
-
-  public class VCExprBinaryFloatOp : VCExprOp {
-    public readonly int Mantissa;
-    public readonly int Exponent;
-    private string op;
-
-    public override int Arity {
-      get {
-        return 2;
-      }
-    }
-    public override int TypeParamArity {
-      get {
-        return 2;
-      }
-    }
-    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
-      //Contract.Requires(cce.NonNullElements(typeArgs));
-      //Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<Type>() != null);
-      return Type.GetFloatType(Exponent, Mantissa);
-    }
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprBinaryFloatOp)
-        return this.Exponent == ((VCExprBinaryFloatOp)that).Exponent && this.Mantissa == ((VCExprBinaryFloatOp)that).Mantissa;
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return Exponent * 81748912 + Mantissa * 67867979;
-    }
-
-    internal VCExprBinaryFloatOp(int exp, int man, string op) {
-      this.Exponent = exp;
-      this.Mantissa = man;
-      this.op = op;
-    }
-    public override Result Accept<Result, Arg>
-           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      //Contract.Requires(expr != null);
-      switch (op) { 
-      case ("+"):
-        return visitor.VisitFloatAddOp(expr, arg);
-      case ("-"):
-        return visitor.VisitFloatSubOp(expr, arg);
-      case ("*"):
-        return visitor.VisitFloatMulOp(expr, arg);
-      case ("/"):
-        return visitor.VisitFloatDivOp(expr, arg);
-      case ("rem"):
-        return visitor.VisitFloatRemOp(expr, arg);
-      case ("min"):
-        return visitor.VisitFloatMinOp(expr, arg);
-      case ("max"):
-        return visitor.VisitFloatMaxOp(expr, arg);
-      case ("<="):
-        return visitor.VisitFloatLeqOp(expr, arg);
-      case ("<"):
-        return visitor.VisitFloatLtOp(expr, arg);
-      case (">="):
-        return visitor.VisitFloatGeqOp(expr, arg);
-      case (">"):
-        return visitor.VisitFloatGtOp(expr, arg);
-      case ("=="):
-        return visitor.VisitFloatEqOp(expr, arg);
-      default:
-        Contract.Assert(false);
-        throw new cce.UnreachableException();
-      }
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////////////
-  // Bitvector operators
-
-  public class VCExprBvOp : VCExprOp {
-    public readonly int Bits;
-
-    public override int Arity {
-      get {
-        return 1;
-      }
-    }
-    public override int TypeParamArity {
-      get {
-        return 0;
-      }
-    }
-    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
-      //Contract.Requires(cce.NonNullElements(typeArgs));
-      //Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<Type>() != null);
-      return Type.GetBvType(Bits);
-    }
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprBvOp)
-        return this.Bits == ((VCExprBvOp)that).Bits;
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return Bits * 81748912;
-    }
-
-    internal VCExprBvOp(int bits) {
-      this.Bits = bits;
-    }
-    public override Result Accept<Result, Arg>
-           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      //Contract.Requires(expr != null);
-      return visitor.VisitBvOp(expr, arg);
-    }
-  }
-
-  public class VCExprBvExtractOp : VCExprOp {
-    public readonly int Start;
-    public readonly int End;
-    public readonly int Total;  // the number of bits from which the End-Start bits are extracted
-
-    public override int Arity {
-      get {
-        return 1;
-      }
-    }
-    public override int TypeParamArity {
-      get {
-        return 0;
-      }
-    }
-    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
-      //Contract.Requires(cce.NonNullElements(typeArgs));
-      //Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<Type>() != null);
-      return Type.GetBvType(End - Start);
-    }
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprBvExtractOp) {
-        VCExprBvExtractOp/*!*/ thatExtract = (VCExprBvExtractOp)that;
-        return this.Start == thatExtract.Start && this.End == thatExtract.End && this.Total == thatExtract.Total;
-      }
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return Start * 81912 + End * 978132 + Total * 571289;
-    }
-
-    internal VCExprBvExtractOp(int start, int end, int total) {
-      Contract.Requires(0 <= start && start <= end && end <= total);
-      this.Start = start;
-      this.End = end;
-      this.Total = total;
-    }
-    public override Result Accept<Result, Arg>
-           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      //Contract.Requires(expr != null);
-      return visitor.VisitBvExtractOp(expr, arg);
-    }
-  }
-
-  public class VCExprBvConcatOp : VCExprOp {
-    public readonly int LeftSize;
-    public readonly int RightSize;
-
-    public override int Arity {
-      get {
-        return 2;
-      }
-    }
-    public override int TypeParamArity {
-      get {
-        return 0;
-      }
-    }
-    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
-      //Contract.Requires(cce.NonNullElements(typeArgs));
-      //Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<Type>() != null);
-      return Type.GetBvType(args[0].Type.BvBits + args[1].Type.BvBits);
-    }
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprBvConcatOp) {
-        VCExprBvConcatOp thatConcat = (VCExprBvConcatOp)that;
-        return this.LeftSize == thatConcat.LeftSize && this.RightSize == thatConcat.RightSize;
-      }
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return LeftSize * 81912 + RightSize * 978132;
-    }
-
-    internal VCExprBvConcatOp(int leftSize, int rightSize) {
-      Contract.Requires(0 <= leftSize && 0 <= rightSize);
-      this.LeftSize = leftSize;
-      this.RightSize = rightSize;
-    }
-    public override Result Accept<Result, Arg>
-           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      //Contract.Requires(expr != null);
-      return visitor.VisitBvConcatOp(expr, arg);
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////////////
-  // References to user-defined Boogie functions
-
-  public class VCExprBoogieFunctionOp : VCExprOp {
-    public readonly Function Func;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Func != null);
-    }
-
-
-    public override int Arity {
-      get {
-        return Func.InParams.Count;
-      }
-    }
-    public override int TypeParamArity {
-      get {
-        return Func.TypeParameters.Count;
-      }
-    }
-    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
-      //Contract.Requires(cce.NonNullElements(typeArgs));
-      //Contract.Requires(cce.NonNullElements(args));
-      Contract.Ensures(Contract.Result<Type>() != null);
-      Contract.Assert(TypeParamArity == Func.TypeParameters.Count);
-      if (TypeParamArity == 0)
-        return cce.NonNull(Func.OutParams[0]).TypedIdent.Type;
-      IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ subst = new Dictionary<TypeVariable/*!*/, Type/*!*/>(TypeParamArity);
-      for (int i = 0; i < TypeParamArity; ++i)
-        subst.Add(Func.TypeParameters[i], typeArgs[i]);
-      return cce.NonNull(Func.OutParams[0]).TypedIdent.Type.Substitute(subst);
-    }
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprBoogieFunctionOp)
-        return this.Func.Equals(((VCExprBoogieFunctionOp)that).Func);
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return Func.GetHashCode() + 18731;
-    }
-
-    // we require that the result type of the expression is specified, because we
-    // do not want to perform full type inference at this point
-    internal VCExprBoogieFunctionOp(Function func) {
-      Contract.Requires(func != null);
-      this.Func = func;
-    }
-    public override Result Accept<Result, Arg>
-           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      //Contract.Requires(expr != null);
-      return visitor.VisitBoogieFunctionOp(expr, arg);
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////////////
-  // Binders (quantifiers and let-expressions). We introduce our own class for
-  // term variables, but use the Boogie-AST class for type variables
-
-  public class VCExprVar : VCExpr {
-    // the name of the variable. Note that the name is not used for comparison,
-    // i.e., there can be two distinct variables with the same name
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Name != null);
-      Contract.Invariant(VarType != null);
-    }
-
-    public readonly string/*!*/ Name;
-    private readonly Type/*!*/ VarType;
-    public override Type/*!*/ Type {
-      get {
-        Contract.Ensures(Contract.Result<Type>() != null);
-        return VarType;
-      }
-    }
-
-    internal VCExprVar(string name, Type type) {
-      Contract.Requires(type != null);
-      Contract.Requires(name != null);
-      this.Name = name;
-      this.VarType = type;
-    }
-    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      return visitor.Visit(this, arg);
-    }
-  }
-
-  public class VCExprConstant : VCExprVar
-  {
-      internal VCExprConstant(string name, Type type) : base(name,type) {
-      Contract.Requires(type != null);
-      Contract.Requires(name != null);
-    }
-  }
-
-  public abstract class VCExprBinder : VCExpr {
-    public readonly VCExpr/*!*/ Body;
-    public readonly List<TypeVariable/*!*/>/*!*/ TypeParameters;
-    public readonly List<VCExprVar/*!*/>/*!*/ BoundVars;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Body != null);
-      Contract.Invariant(cce.NonNullElements(TypeParameters));
-      Contract.Invariant(cce.NonNullElements(BoundVars));
-    }
-
-
-    public override Type/*!*/ Type {
-      get {
-        Contract.Ensures(Contract.Result<Type>() != null);
-
-        return Body.Type;
-      }
-    }
-
-    internal VCExprBinder(List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ boundVars, VCExpr body) {
-      Contract.Requires(body != null);
-      Contract.Requires(cce.NonNullElements(boundVars));
-      Contract.Requires(cce.NonNullElements(typeParams));
-      Contract.Requires(boundVars.Count + typeParams.Count > 0);     // only nontrivial binders ...
-      this.TypeParameters = typeParams;
-      this.BoundVars = boundVars;
-      this.Body = body;
-    }
-  }
-
-  public class VCTrigger {
-    public readonly bool Pos;
-    public readonly List<VCExpr/*!*/>/*!*/ Exprs;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Exprs != null);
-    }
-
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCTrigger) {
-        VCTrigger/*!*/ thatTrigger = (VCTrigger)that;
-        return this.Pos == thatTrigger.Pos &&
-          HelperFuns.SameElements(this.Exprs, thatTrigger.Exprs);
-      }
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return (Pos ? 913821 : 871334) +
-             HelperFuns.PolyHash(123, 7, this.Exprs);
-    }
-
-    public VCTrigger(bool pos, List<VCExpr> exprs) {
-      Contract.Requires(cce.NonNullElements(exprs));
-      this.Pos = pos;
-      this.Exprs = exprs;
-    }
-  }
-
-  public class VCQuantifierInfos {
-    public readonly string qid;
-    public readonly int uniqueId;
-    public readonly bool bvZ3Native;
-    public QKeyValue attributes;
-
-    public VCQuantifierInfos(string qid, int uniqueId, bool bvZ3Native, QKeyValue attributes) {
-      this.qid = qid;
-      this.uniqueId = uniqueId;
-      this.bvZ3Native = bvZ3Native;
-      this.attributes = attributes;
-    }
-  }
-
-  public enum Quantifier {
-    ALL,
-    EX
-  };
-
-  public class VCExprQuantifier : VCExprBinder {
-    public readonly Quantifier Quan;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Infos != null);
-      Contract.Invariant(cce.NonNullElements(Triggers));
-    }
-
-
-    public readonly List<VCTrigger/*!*/>/*!*/ Triggers;
-    public readonly VCQuantifierInfos Infos;
-
-    // Equality is /not/ modulo bound renaming at this point
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprQuantifier) {
-        VCExprQuantifier/*!*/ thatQuan = (VCExprQuantifier)that;
-        return this.Quan == thatQuan.Quan &&
-               HelperFuns.SameElements(this.Triggers, thatQuan.Triggers) &&
-               HelperFuns.SameElements(this.TypeParameters, thatQuan.TypeParameters) &&
-               HelperFuns.SameElements(this.BoundVars, thatQuan.BoundVars) &&
-               this.Body.Equals(thatQuan.Body);
-      }
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return Quan.GetHashCode() +
-        HelperFuns.PolyHash(973219, 7, TypeParameters) +
-        HelperFuns.PolyHash(998431, 9, BoundVars) +
-        HelperFuns.PolyHash(123, 11, Triggers);
-    }
-
-    internal VCExprQuantifier(Quantifier kind, List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ boundVars, List<VCTrigger/*!*/>/*!*/ triggers, VCQuantifierInfos infos, VCExpr body)
-      : base(typeParams, boundVars, body) {
-      Contract.Requires(body != null);
-      Contract.Requires(infos != null);
-      Contract.Requires(cce.NonNullElements(triggers));
-      Contract.Requires(cce.NonNullElements(boundVars));
-      Contract.Requires(cce.NonNullElements(typeParams));
-
-      this.Quan = kind;
-      this.Triggers = triggers;
-      this.Infos = infos;
-    }
-    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      return visitor.Visit(this, arg);
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////////////
-  // Let-Bindings
-
-  public class VCExprLetBinding {
-    public readonly VCExprVar V;
-    public readonly VCExpr E;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(V != null);
-      Contract.Invariant(E != null);
-    }
-
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprLetBinding) {
-        VCExprLetBinding/*!*/ thatB = (VCExprLetBinding)that;
-        return this.V.Equals(thatB.V) && this.E.Equals(thatB.E);
-      }
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return V.GetHashCode() * 71261 + E.GetHashCode();
-    }
-
-    internal VCExprLetBinding(VCExprVar v, VCExpr e) {
-      Contract.Requires(e != null);
-      Contract.Requires(v != null);
-      this.V = v;
-      this.E = e;
-      Contract.Assert(v.Type.Equals(e.Type));
-    }
-  }
-
-  public class VCExprLet : VCExprBinder, IEnumerable<VCExprLetBinding/*!*/> {
-    private readonly List<VCExprLetBinding/*!*/>/*!*/ Bindings;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(cce.NonNullElements(Bindings));
-
-    }
-
-
-    public int Length {
-      get {
-        return Bindings.Count;
-      }
-    }
-    public VCExprLetBinding this[int index] {
-      get {
-        Contract.Ensures(Contract.Result<VCExprLetBinding>() != null);
-        return Bindings[index];
-      }
-    }
-
-    [Pure]
-    [Reads(ReadsAttribute.Reads.Nothing)]
-    public override bool Equals(object that) {
-      if (Object.ReferenceEquals(this, that))
-        return true;
-      if (that is VCExprLet) {
-        VCExprLet/*!*/ thatLet = (VCExprLet)that;
-        return this.Body.Equals(thatLet.Body) &&
-               HelperFuns.SameElements(this, (VCExprLet)that);
-      }
-      return false;
-    }
-    [Pure]
-    public override int GetHashCode() {
-      return HelperFuns.PolyHash(Body.GetHashCode(), 9, Bindings);
-    }
-
-    [Pure]
-    [GlobalAccess(false)]
-    [Escapes(true, false)]
-    public IEnumerator<VCExprLetBinding/*!*/>/*!*/ GetEnumerator() {
-      Contract.Ensures(cce.NonNullElements(Contract.Result<IEnumerator<VCExprLetBinding>>()));
-      return Bindings.GetEnumerator();
-    }
-    [Pure]
-    [GlobalAccess(false)]
-    [Escapes(true, false)]
-    IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-      Contract.Ensures(Contract.Result<IEnumerator>() != null);
-      return Bindings.GetEnumerator();
-    }
-
-    private static List<VCExprVar/*!*/>/*!*/ toSeq(List<VCExprLetBinding/*!*/>/*!*/ bindings) {
-      Contract.Requires(cce.NonNullElements(bindings));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
-      List<VCExprVar> res = new List<VCExprVar>();
-      foreach (VCExprLetBinding/*!*/ b in bindings)
-        res.Add(b.V);
-      return res;
-    }
-
-    internal VCExprLet(List<VCExprLetBinding/*!*/>/*!*/ bindings, VCExpr/*!*/ body)
-      : base(new List<TypeVariable/*!*/>(), toSeq(bindings), body) {
-      Contract.Requires(cce.NonNullElements(bindings));
-      Contract.Requires(body != null);
-      this.Bindings = bindings;
-    }
-    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
-      //Contract.Requires(visitor != null);
-      return visitor.Visit(this, arg);
-    }
-  }
-}
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+
+// Prover-independent syntax trees for representing verification conditions
+// The language can be seen as a simple polymorphically typed first-order logic,
+// very similar to the expression language of Boogie
+
+namespace Microsoft.Boogie {
+  using Microsoft.Boogie.VCExprAST;
+
+  public class VCExpressionGenerator {
+    public static readonly VCExpr False = new VCExprLiteral(Type.Bool);
+    public static readonly VCExpr True = new VCExprLiteral(Type.Bool);
+
+    private Function ControlFlowFunction = null;
+    public VCExpr ControlFlowFunctionApplication(VCExpr e1, VCExpr e2) {
+      Contract.Requires(e1 != null);
+      Contract.Requires(e2 != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      if (ControlFlowFunction == null) {
+        Formal/*!*/ first = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Int), true);
+        Formal/*!*/ second = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Int), true);
+        List<Variable> inputs = new List<Variable>();
+        inputs.Add(first);
+        inputs.Add(second);
+        Formal/*!*/ returnVar = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Int), false);
+        ControlFlowFunction = new Function(Token.NoToken, "ControlFlow", inputs, returnVar);
+      }
+      List<VCExpr/*!*/> args = new List<VCExpr/*!*/>();
+      args.Add(e1);
+      args.Add(e2);
+      return Function(BoogieFunctionOp(ControlFlowFunction), args);
+    }
+
+    public VCExpr/*!*/ Integer(BigNum x) {
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      return new VCExprIntLit(x);
+    }
+
+    public VCExpr/*!*/ Real(BigDec x) {
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      return new VCExprRealLit(x);
+    }
+
+    public VCExpr/*!*/ Float(BigFloat x)
+    {
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      return new VCExprFloatLit(x);
+    }
+
+    public VCExpr/*!*/ Function(VCExprOp/*!*/ op,
+                            List<VCExpr/*!*/>/*!*/ arguments,
+                            List<Type/*!*/>/*!*/ typeArguments) {
+      Contract.Requires(op != null);
+      Contract.Requires(cce.NonNullElements(arguments));
+      Contract.Requires(cce.NonNullElements(typeArguments));
+      if (typeArguments.Count > 0)
+        return new VCExprMultiAry(op, arguments, typeArguments);
+
+      switch (arguments.Count) {
+        case 0:
+          return new VCExprNullary(op);
+        case 1:
+          return new VCExprUnary(op, arguments);
+        case 2:
+          return new VCExprBinary(op, arguments);
+        default:
+          return new VCExprMultiAry(op, arguments);
+      }
+    }
+
+    public VCExpr/*!*/ Function(VCExprOp/*!*/ op, List<VCExpr/*!*/>/*!*/ arguments) {
+      Contract.Requires(op != null);
+      Contract.Requires(cce.NonNullElements(arguments));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      return Function(op, arguments, VCExprNAry.EMPTY_TYPE_LIST);
+    }
+
+    public VCExpr/*!*/ Function(VCExprOp/*!*/ op, params VCExpr[]/*!*/ arguments) {
+      Contract.Requires(op != null);
+      Contract.Requires(cce.NonNullElements(arguments));
+
+      return Function(op,
+                      HelperFuns.ToNonNullList(arguments),
+                      VCExprNAry.EMPTY_TYPE_LIST);
+    }
+
+    public VCExpr/*!*/ Function(VCExprOp/*!*/ op, VCExpr[]/*!*/ arguments, Type[]/*!*/ typeArguments) {
+      Contract.Requires(op != null);
+      Contract.Requires(cce.NonNullElements(arguments));
+      Contract.Requires(cce.NonNullElements(typeArguments));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+
+      return Function(op,
+                      HelperFuns.ToNonNullList(arguments),
+                      HelperFuns.ToNonNullList(typeArguments));
+    }
+
+    public VCExpr/*!*/ Function(Function/*!*/ op, List<VCExpr/*!*/>/*!*/ arguments) {
+      Contract.Requires(op != null);
+      Contract.Requires(cce.NonNullElements(arguments));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      return Function(BoogieFunctionOp(op), arguments, VCExprNAry.EMPTY_TYPE_LIST);
+    }
+
+    public VCExpr/*!*/ Function(Function/*!*/ op, params VCExpr[]/*!*/ arguments) {
+      Contract.Requires(cce.NonNullElements(arguments));
+      Contract.Requires(op != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      return Function(BoogieFunctionOp(op), arguments);
+    }
+
+
+    // The following method should really be called "ReduceLeft". It must
+    // only be used for the binary operators "and" and "or"
+    public VCExpr/*!*/ NAry(VCExprOp/*!*/ op, List<VCExpr/*!*/>/*!*/ args) {
+      Contract.Requires(op != null);
+      Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      return NAry(op, args.ToArray());
+    }
+
+    public VCExpr/*!*/ NAry(VCExprOp/*!*/ op, params VCExpr[]/*!*/ args) {
+      Contract.Requires(op != null);
+      Contract.Requires(cce.NonNullElements(args));
+      Contract.Requires(op == AndOp || op == OrOp);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      bool and = (op == AndOp);
+
+      VCExpr/*!*/ e = and ? True : False;
+      foreach (VCExpr a in args) {
+        e = and ? AndSimp(e, cce.NonNull(a)) : OrSimp(e, cce.NonNull(a));
+      }
+      return e;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////
+
+    public static readonly VCExprOp NotOp = new VCExprNAryOp(1, Type.Bool);
+    public static readonly VCExprOp EqOp = new VCExprNAryOp(2, Type.Bool);
+    public static readonly VCExprOp NeqOp = new VCExprNAryOp(2, Type.Bool);
+    public static readonly VCExprOp AndOp = new VCExprNAryOp(2, Type.Bool);
+    public static readonly VCExprOp OrOp = new VCExprNAryOp(2, Type.Bool);
+    public static readonly VCExprOp ImpliesOp = new VCExprNAryOp(2, Type.Bool);
+
+    public VCExprDistinctOp DistinctOp(int arity) {
+      Contract.Ensures(Contract.Result<VCExprDistinctOp>() != null);
+
+      return new VCExprDistinctOp(arity);
+    }
+
+    public VCExpr/*!*/ Not(List<VCExpr/*!*/>/*!*/ args) {
+      Contract.Requires(args != null);
+      Contract.Requires(args.Count == 1);
+      Contract.Requires(args[0] != null);
+      return Function(NotOp, args);
+    }
+
+    public VCExpr/*!*/ Not(VCExpr/*!*/ e0) {
+      Contract.Requires(e0 != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      return Function(NotOp, e0);
+    }
+    public VCExpr/*!*/ Eq(VCExpr/*!*/ e0, VCExpr/*!*/ e1) {
+      return Function(EqOp, e0, e1);
+    }
+    public VCExpr/*!*/ Neq(VCExpr/*!*/ e0, VCExpr/*!*/ e1) {
+      Contract.Requires(e0 != null);
+      Contract.Requires(e1 != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      return Function(NeqOp, e0, e1);
+    }
+    public VCExpr/*!*/ And(VCExpr/*!*/ e0, VCExpr/*!*/ e1) {
+      Contract.Requires(e0 != null);
+      Contract.Requires(e1 != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(AndOp, e0, e1);
+    }
+    public VCExpr/*!*/ Gt(VCExpr/*!*/ e0, VCExpr/*!*/ e1)
+    {
+        Contract.Requires(e0 != null);
+        Contract.Requires(e1 != null);
+        Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+        return Function(GtOp, e0, e1);
+    }
+    public VCExpr/*!*/ Add(VCExpr/*!*/ e0, VCExpr/*!*/ e1)
+    {
+        Contract.Requires(e0 != null);
+        Contract.Requires(e1 != null);
+        Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+        VCExprOp op = cce.NonNull(cce.NonNull(e0).Type).IsInt ? AddIOp : AddROp;
+        return Function(op, e0, e1);
+    }
+    public VCExpr/*!*/ Or(VCExpr/*!*/ e0, VCExpr/*!*/ e1) {
+      Contract.Requires(e0 != null);
+      Contract.Requires(e1 != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(OrOp, e0, e1);
+    }
+    public VCExpr/*!*/ Implies(VCExpr/*!*/ e0, VCExpr/*!*/ e1) {
+      Contract.Requires(e0 != null);
+      Contract.Requires(e1 != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(ImpliesOp, e0, e1);
+    }
+    public VCExpr/*!*/ Distinct(List<VCExpr/*!*/>/*!*/ args) {
+      Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      if (args.Count <= 1)
+        // trivial case
+        return True;
+      return Function(DistinctOp(args.Count), args);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Versions of the propositional operators that automatically simplify in
+    // certain cases (for example, if one of the operators is True or False)
+
+    public VCExpr NotSimp(VCExpr e0) {
+      Contract.Requires(e0 != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (e0.Equals(True))
+        return False;
+      if (e0.Equals(False))
+        return True;
+      return Not(e0);
+    }
+    public VCExpr AndSimp(VCExpr e0, VCExpr e1) {
+      Contract.Requires(e1 != null);
+      Contract.Requires(e0 != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (e0.Equals(True))
+        return e1;
+      if (e1.Equals(True))
+        return e0;
+      if (e0.Equals(False) || e1.Equals(False))
+        return False;
+      return And(e0, e1);
+    }
+    public VCExpr OrSimp(VCExpr e0, VCExpr e1) {
+      Contract.Requires(e1 != null);
+      Contract.Requires(e0 != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (e0.Equals(False))
+        return e1;
+      if (e1.Equals(False))
+        return e0;
+      if (e0.Equals(True) || e1.Equals(True))
+        return True;
+      return Or(e0, e1);
+    }
+    public VCExpr ImpliesSimp(VCExpr e0, VCExpr e1, bool aggressive = true) {
+      Contract.Requires(e1 != null);
+      Contract.Requires(e0 != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (e0.Equals(True))
+        return e1;
+      if (e1.Equals(False))
+        return NotSimp(e0);
+      if (e0.Equals(False) || e1.Equals(True))
+        return True;
+      // attempt to save on the depth of expressions (to reduce chances of stack overflows)
+      while (aggressive && e1 is VCExprBinary) {
+        VCExprBinary n = (VCExprBinary)e1;
+        if (n.Op == ImpliesOp) {
+          if (AndSize(n[0]) <= AndSize(e0)) {
+            // combine the antecedents
+            e0 = And(e0, n[0]);
+            e1 = n[1];
+            continue;
+          }
+        }
+        break;
+      }
+      return Implies(e0, e1);
+    }
+
+    ///<summary>
+    /// Returns some measure of the number of conjuncts in e.  This could be the total number of conjuncts in all
+    /// top-most layers of the expression, or it can simply be the length of the left-prong of this and-tree.  The
+    /// important thing is that: AndSize(e0) >= AndSize(31) ==> AndSize(And(e0,e1)) > AndSize(e0).
+    ///</summary>
+    int AndSize(VCExpr e) {
+      Contract.Requires(e != null);
+      int n = 1;
+      while (true) {
+        VCExprNAry nary = e as VCExprNAry;
+        if (nary != null && nary.Op == AndOp && 2 <= nary.Arity) {
+          e = nary[0];
+          n++;
+        } else {
+          return n;
+        }
+      }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Further operators
+
+    public static readonly VCExprOp AddIOp = new VCExprNAryOp(2, Type.Int);
+    public static readonly VCExprOp AddROp = new VCExprNAryOp(2, Type.Real);
+    public static readonly VCExprOp SubIOp = new VCExprNAryOp(2, Type.Int);
+    public static readonly VCExprOp SubROp = new VCExprNAryOp(2, Type.Real);
+   // public static readonly VCExprOp SubFOp = new VCExprNAryOp(2, Type.Float);
+    public static readonly VCExprOp MulIOp = new VCExprNAryOp(2, Type.Int);
+    public static readonly VCExprOp MulROp = new VCExprNAryOp(2, Type.Real);
+    //public static readonly VCExprOp MulFOp = new VCExprNAryOp(2, Type.Float);
+    public static readonly VCExprOp DivIOp = new VCExprNAryOp(2, Type.Int);
+    public static readonly VCExprOp DivROp = new VCExprNAryOp(2, Type.Real);
+    //public static readonly VCExprOp DivFOp = new VCExprNAryOp(2, Type.Float);
+    public static readonly VCExprOp ModOp = new VCExprNAryOp(2, Type.Int);
+    public static readonly VCExprOp PowOp = new VCExprNAryOp(2, Type.Real);
+    public static readonly VCExprOp LtOp = new VCExprNAryOp(2, Type.Bool);
+    public static readonly VCExprOp LeOp = new VCExprNAryOp(2, Type.Bool);
+    public static readonly VCExprOp GtOp = new VCExprNAryOp(2, Type.Bool);
+    public static readonly VCExprOp GeOp = new VCExprNAryOp(2, Type.Bool);
+    public static readonly VCExprOp SubtypeOp = new VCExprNAryOp(2, Type.Bool);
+    // ternary version of the subtype operator, the first argument of which gives
+    // the type of the compared terms
+    public static readonly VCExprOp Subtype3Op = new VCExprNAryOp(3, Type.Bool);
+    public static readonly VCExprOp IfThenElseOp = new VCExprIfThenElseOp();
+    public static readonly VCExprOp ToIntOp = new VCExprNAryOp(1, Type.Int);
+    public static readonly VCExprOp ToRealOp = new VCExprNAryOp(1, Type.Real);
+    //public static readonly VCExprOp ToFloatOp = new VCExprNAryOp(1, Type.Float);
+
+    public static readonly VCExprOp TickleBoolOp = new VCExprCustomOp("tickleBool", 1, Type.Bool);
+
+    public static readonly VCExprOp TimeoutDiagnosticsOp = new VCExprCustomOp("timeoutDiagnostics", 1, Type.Bool);
+
+    public static readonly VCExprOp MinimizeOp = new VCExprCustomOp("minimize##dummy", 2, Type.Bool);
+    public static readonly VCExprOp MaximizeOp = new VCExprCustomOp("maximize##dummy", 2, Type.Bool);
+    public static readonly VCExprOp NamedAssumeOp = new VCExprCustomOp("named_assume##dummy", 2, Type.Bool);
+
+    public VCExprOp BoogieFunctionOp(Function func) {
+      Contract.Requires(func != null);
+      Contract.Ensures(Contract.Result<VCExprOp>() != null);
+      return new VCExprBoogieFunctionOp(func);
+    }
+
+    // Float nodes
+
+    public VCExprOp BinaryFloatOp(int exp, int man, string op)
+    {
+      Contract.Requires(exp > 0);
+      Contract.Requires(man > 0);
+      Contract.Requires(op != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return new VCExprBinaryFloatOp(exp, man, op);
+    }
+
+    // Bitvector nodes
+
+    public VCExpr Bitvector(BvConst bv) {
+      Contract.Requires(bv != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(new VCExprBvOp(bv.Bits), Integer(bv.Value));
+    }
+
+    public VCExpr BvExtract(VCExpr bv, int bits, int start, int end) {
+      Contract.Requires(bv != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(new VCExprBvExtractOp(start, end, bits), bv);
+    }
+
+    public VCExpr BvConcat(VCExpr bv1, VCExpr bv2) {
+      Contract.Requires(bv2 != null);
+      Contract.Requires(bv1 != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(new VCExprBvConcatOp(bv1.Type.BvBits, bv2.Type.BvBits), bv1, bv2);
+    }
+
+    public VCExpr AtMost(VCExpr smaller, VCExpr greater) {
+      Contract.Requires(greater != null);
+      Contract.Requires(smaller != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(SubtypeOp, smaller, greater);
+    }
+
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Dispatcher for the visitor
+
+    // the declared singleton operators
+    internal enum SingletonOp {
+      NotOp,
+      EqOp,
+      NeqOp,
+      AndOp,
+      OrOp,
+      ImpliesOp,
+      AddOp,
+      SubOp,
+      MulOp,
+      DivOp,
+      ModOp,
+      RealDivOp,
+      PowOp,
+      LtOp,
+      LeOp,
+      GtOp,
+      GeOp,
+      SubtypeOp,
+      Subtype3Op,
+      BvConcatOp,
+      ToIntOp,
+      ToRealOp,
+      ToFloatOp
+    };
+    internal static Dictionary<VCExprOp/*!*/, SingletonOp>/*!*/ SingletonOpDict;
+    [ContractInvariantMethod]
+    void MiscInvariant() {
+      Contract.Invariant(SingletonOpDict != null);
+    }
+
+
+    static VCExpressionGenerator() {
+      SingletonOpDict = new Dictionary<VCExprOp/*!*/, SingletonOp>();
+      SingletonOpDict.Add(NotOp, SingletonOp.NotOp);
+      SingletonOpDict.Add(EqOp, SingletonOp.EqOp);
+      SingletonOpDict.Add(NeqOp, SingletonOp.NeqOp);
+      SingletonOpDict.Add(AndOp, SingletonOp.AndOp);
+      SingletonOpDict.Add(OrOp, SingletonOp.OrOp);
+      SingletonOpDict.Add(ImpliesOp, SingletonOp.ImpliesOp);
+      SingletonOpDict.Add(AddIOp, SingletonOp.AddOp);
+      SingletonOpDict.Add(AddROp, SingletonOp.AddOp);
+      SingletonOpDict.Add(SubIOp, SingletonOp.SubOp);
+      SingletonOpDict.Add(SubROp, SingletonOp.SubOp);
+      //SingletonOpDict.Add(SubFOp, SingletonOp.SubOp);
+      SingletonOpDict.Add(MulIOp, SingletonOp.MulOp);
+      SingletonOpDict.Add(MulROp, SingletonOp.MulOp);
+      //SingletonOpDict.Add(MulFOp, SingletonOp.MulOp);
+      SingletonOpDict.Add(DivIOp, SingletonOp.DivOp);
+      SingletonOpDict.Add(DivROp, SingletonOp.RealDivOp);
+      //SingletonOpDict.Add(DivFOp, SingletonOp.FloatDivOp);
+      SingletonOpDict.Add(ModOp, SingletonOp.ModOp);
+      SingletonOpDict.Add(PowOp, SingletonOp.PowOp);
+      SingletonOpDict.Add(LtOp, SingletonOp.LtOp);
+      SingletonOpDict.Add(LeOp, SingletonOp.LeOp);
+      SingletonOpDict.Add(GtOp, SingletonOp.GtOp);
+      SingletonOpDict.Add(GeOp, SingletonOp.GeOp);
+      SingletonOpDict.Add(SubtypeOp, SingletonOp.SubtypeOp);
+      SingletonOpDict.Add(Subtype3Op, SingletonOp.Subtype3Op);
+      SingletonOpDict.Add(ToIntOp, SingletonOp.ToIntOp);
+      SingletonOpDict.Add(ToRealOp, SingletonOp.ToRealOp);
+      //SingletonOpDict.Add(ToFloatOp, SingletonOp.ToFloatOp);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////
+
+
+    // Let-bindings
+
+    public VCExprLetBinding LetBinding(VCExprVar v, VCExpr e) {
+      Contract.Requires(e != null);
+      Contract.Requires(v != null);
+      Contract.Ensures(Contract.Result<VCExprLetBinding>() != null);
+      return new VCExprLetBinding(v, e);
+    }
+
+    // A "real" let expression. All let-bindings happen simultaneously, i.e.,
+    // at this level the order of the bindings does not matter. It is possible to
+    // create expressions like   "let x = y, y = 5 in ...". All bound variables are
+    // bound in all bound terms/formulas and can occur there, but the dependencies
+    // have to be acyclic
+    public VCExpr Let(List<VCExprLetBinding> bindings, VCExpr body) {
+      Contract.Requires(body != null);
+      Contract.Requires(cce.NonNullElements(bindings));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (bindings.Count == 0)
+        // no empty let-bindings
+        return body;
+      return new VCExprLet(bindings, body);
+    }
+
+    public VCExpr Let(VCExpr body, params VCExprLetBinding[] bindings) {
+      Contract.Requires(body != null);
+      Contract.Requires((cce.NonNullElements(bindings)));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Let(HelperFuns.ToNonNullList(bindings), body);
+    }
+
+
+    /// <summary>
+    /// In contrast to the previous method, the following methods are not a general LET.
+    ///  Instead, it
+    /// is a boolean "LET b = P in Q", where P and Q are predicates, that is allowed to be
+    /// encoded as "(b == P) ==> Q" or even as "(P ==> b) ==> Q"
+    /// (or "(P ==> b) and Q" in negative positions).
+    /// The method assumes that the variables in the bindings are unique in the entire formula
+    /// to be produced, which allows the implementation to ignore scope issues in the event that
+    /// it needs to generate an alternate expression for LET.
+    /// </summary>
+
+
+    // Turn let-bindings let v = E in ... into implications E ==> v
+    public VCExpr AsImplications(List<VCExprLetBinding> bindings) {
+      Contract.Requires(cce.NonNullElements(bindings));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExpr/*!*/ antecedents = True;
+      foreach (VCExprLetBinding b in bindings)
+        // turn "LET_binding v = E" into "v <== E"
+        antecedents = AndSimp(antecedents, Implies(b.E, b.V));
+      return antecedents;
+    }
+
+    // Turn let-bindings let v = E in ... into equations v == E
+    public VCExpr AsEquations(List<VCExprLetBinding> bindings) {
+      Contract.Requires(cce.NonNullElements(bindings));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExpr/*!*/ antecedents = True;
+      foreach (VCExprLetBinding b in bindings)
+        // turn "LET_binding v = E" into "v <== E"
+        antecedents = AndSimp(antecedents, Eq(b.E, b.V));
+      return antecedents;
+    }
+
+
+
+    // Maps
+
+    public VCExpr Select(params VCExpr[] allArgs) {
+      Contract.Requires(allArgs != null);
+      Contract.Requires((cce.NonNullElements(allArgs)));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(new VCExprSelectOp(allArgs.Length - 1, 0),
+                      HelperFuns.ToNonNullList(allArgs),
+                      VCExprNAry.EMPTY_TYPE_LIST);
+    }
+
+    public VCExpr Select(VCExpr[] allArgs, Type[] typeArgs) {
+      Contract.Requires(1 <= allArgs.Length);
+      Contract.Requires(cce.NonNullElements(allArgs));
+      Contract.Requires(cce.NonNullElements(typeArgs));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(new VCExprSelectOp(allArgs.Length - 1, typeArgs.Length),
+                      allArgs, typeArgs);
+    }
+
+    public VCExpr Select(List<VCExpr> allArgs, List<Type> typeArgs) {
+      Contract.Requires(cce.NonNullElements(typeArgs));
+      Contract.Requires(cce.NonNullElements(allArgs));
+      Contract.Requires((1 <= allArgs.Count));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(new VCExprSelectOp(allArgs.Count - 1, typeArgs.Count),
+                      allArgs, typeArgs);
+    }
+
+    public VCExpr Store(params VCExpr[] allArgs) {
+      Contract.Requires(allArgs != null);
+      Contract.Requires(cce.NonNullElements(allArgs));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(new VCExprStoreOp(allArgs.Length - 2, 0),
+                      HelperFuns.ToNonNullList(allArgs),
+                      VCExprNAry.EMPTY_TYPE_LIST);
+    }
+
+    public VCExpr Store(VCExpr[] allArgs, Type[] typeArgs) {
+      Contract.Requires(typeArgs != null);
+      Contract.Requires(allArgs != null);
+      Contract.Requires((2 <= allArgs.Length));
+      Contract.Requires(cce.NonNullElements(allArgs));
+      Contract.Requires(cce.NonNullElements(typeArgs));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(new VCExprStoreOp(allArgs.Length - 2, typeArgs.Length),
+                      allArgs, typeArgs);
+    }
+
+    public VCExpr Store(List<VCExpr> allArgs, List<Type/*!*/>/*!*/ typeArgs) {
+      Contract.Requires(cce.NonNullElements(typeArgs));
+      Contract.Requires(cce.NonNullElements(allArgs));
+      Contract.Requires((2 <= allArgs.Count));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(new VCExprStoreOp(allArgs.Count - 2, typeArgs.Count),
+                      allArgs, typeArgs);
+    }
+
+
+    // Labels
+
+    public VCExprLabelOp LabelOp(bool pos, string l) {
+      Contract.Requires(l != null);
+      Contract.Ensures(Contract.Result<VCExprLabelOp>() != null);
+      return new VCExprLabelOp(pos, l);
+    }
+
+    public VCExpr LabelNeg(string label, VCExpr e) {
+      Contract.Requires(e != null);
+      Contract.Requires(label != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      if (e.Equals(True)) {
+        return e;  // don't bother putting negative labels around True (which will expose the True to further peephole optimizations)
+      }
+      return Function(LabelOp(false, label), e);
+    }
+    public VCExpr LabelPos(string label, VCExpr e) {
+      Contract.Requires(e != null);
+      Contract.Requires(label != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Function(LabelOp(true, label), e);
+    }
+
+    // Quantifiers
+
+    public VCExpr Quantify(Quantifier quan, List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, VCQuantifierInfos infos, VCExpr body) {
+      Contract.Requires(body != null);
+      Contract.Requires(infos != null);
+      Contract.Requires(cce.NonNullElements(triggers));
+      Contract.Requires(cce.NonNullElements(vars));
+      Contract.Requires(cce.NonNullElements(typeParams));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return new VCExprQuantifier(quan, typeParams, vars, triggers, infos, body);
+    }
+
+    public VCExpr Forall(List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, VCQuantifierInfos infos, VCExpr body) {
+      Contract.Requires(body != null);
+      Contract.Requires(infos != null);
+      Contract.Requires(cce.NonNullElements(triggers));
+      Contract.Requires(cce.NonNullElements(vars));
+      Contract.Requires(cce.NonNullElements(typeParams));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Quantify(Quantifier.ALL, typeParams, vars, triggers, infos, body);
+    }
+    public VCExpr Forall(List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, string qid, int weight, VCExpr body) {
+      Contract.Requires(body != null);
+      Contract.Requires(qid != null);
+      Contract.Requires(cce.NonNullElements(triggers));
+      Contract.Requires(cce.NonNullElements(vars));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      QKeyValue kv = null;
+      if (0 <= weight) {
+        kv = new QKeyValue(Token.NoToken, "weight", new List<object>() { new LiteralExpr(Token.NoToken, BigNum.FromInt(0)) }, null);
+      }
+      return Quantify(Quantifier.ALL, new List<TypeVariable/*!*/>(), vars,
+                            triggers, new VCQuantifierInfos(qid, -1, false, kv), body);
+    }
+    public VCExpr Forall(List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, VCExpr body) {
+      Contract.Requires(body != null);
+      Contract.Requires(cce.NonNullElements(triggers));
+      Contract.Requires(cce.NonNullElements(vars));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Quantify(Quantifier.ALL, new List<TypeVariable/*!*/>(), vars,
+                            triggers, new VCQuantifierInfos(null, -1, false, null), body);
+    }
+    public VCExpr Forall(VCExprVar var, VCTrigger trigger, VCExpr body) {
+      Contract.Requires(body != null);
+      Contract.Requires(trigger != null);
+      Contract.Requires(var != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Forall(HelperFuns.ToNonNullList(var), HelperFuns.ToNonNullList(trigger), body);
+    }
+    public VCExpr Exists(List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, VCQuantifierInfos infos, VCExpr body) {
+      Contract.Requires(body != null);
+      Contract.Requires(infos != null);
+      Contract.Requires(cce.NonNullElements(triggers));
+      Contract.Requires(cce.NonNullElements(vars));
+      Contract.Requires(cce.NonNullElements(typeParams));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Quantify(Quantifier.EX, typeParams, vars, triggers, infos, body);
+    }
+    public VCExpr Exists(List<VCExprVar/*!*/>/*!*/ vars, List<VCTrigger/*!*/>/*!*/ triggers, VCExpr body) {
+      Contract.Requires(body != null);
+      Contract.Requires(cce.NonNullElements(triggers));
+      Contract.Requires(cce.NonNullElements(vars));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Quantify(Quantifier.EX, new List<TypeVariable/*!*/>(), vars,
+                      triggers, new VCQuantifierInfos(null, -1, false, null), body);
+    }
+    public VCExpr Exists(VCExprVar var, VCTrigger trigger, VCExpr body) {
+      Contract.Requires(body != null);
+      Contract.Requires(trigger != null);
+      Contract.Requires(var != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return Exists(HelperFuns.ToNonNullList(var), HelperFuns.ToNonNullList(trigger), body);
+    }
+
+    public VCTrigger Trigger(bool pos, List<VCExpr> exprs) {
+      Contract.Requires(cce.NonNullElements(exprs));
+      Contract.Ensures(Contract.Result<VCTrigger>() != null);
+      return new VCTrigger(pos, exprs);
+    }
+
+    public VCTrigger Trigger(bool pos, params VCExpr[] exprs) {
+      Contract.Requires(exprs != null);
+      Contract.Requires((Contract.ForAll(0, exprs.Length, i => exprs[i] != null)));
+      Contract.Ensures(Contract.Result<VCTrigger>() != null);
+      return Trigger(pos, HelperFuns.ToNonNullList(exprs));
+    }
+
+    // Reference to a bound or free variable
+
+    public VCExprVar Variable(string name, Type type) {
+      Contract.Requires(type != null);
+      Contract.Requires(name != null);
+      Contract.Ensures(Contract.Result<VCExprVar>() != null);
+      return new VCExprVar(name, type);
+    }
+  }
+}
+
+namespace Microsoft.Boogie.VCExprAST {
+
+  public class HelperFuns {
+    public static bool SameElements(IEnumerable a, IEnumerable b) {
+      Contract.Requires(b != null);
+      Contract.Requires(a != null);
+      IEnumerator ia = a.GetEnumerator();
+      IEnumerator ib = b.GetEnumerator();
+      while (true) {
+        if (ia.MoveNext()) {
+          if (ib.MoveNext()) {
+            if (!cce.NonNull(ia.Current).Equals(ib.Current))
+              return false;
+          } else {
+            return false;
+          }
+        } else {
+          return !ib.MoveNext();
+        }
+      }
+    }
+
+    public static int PolyHash(int init, int factor, IEnumerable a) {
+      Contract.Requires(a != null);
+      int res = init;
+      foreach (object x in a)
+        res = res * factor + (cce.NonNull(x)).GetHashCode();
+      return res;
+    }
+
+    public static List<T> ToList<T>(IEnumerable<T> l) {
+      Contract.Requires(l != null);
+      Contract.Ensures(Contract.Result<List<T>>() != null);
+      List<T>/*!*/ res = new List<T>();
+      foreach (T x in l)
+        res.Add(x);
+      return res;
+    }
+
+    public static List<Type> ToTypeSeq(VCExpr[] exprs, int startIndex) {
+      Contract.Requires(exprs != null);
+      Contract.Requires((Contract.ForAll(0, exprs.Length, i => exprs[i] != null)));
+      Contract.Ensures(Contract.Result<List<Type>>() != null);
+      List<Type>/*!*/ res = new List<Type>();
+      for (int i = startIndex; i < exprs.Length; ++i)
+        res.Add(cce.NonNull(exprs[i]).Type);
+      return res;
+    }
+
+    public static List<T/*!*/>/*!*/ ToNonNullList<T>(params T[] args) where T : class {
+      Contract.Requires(args != null);
+      List<T/*!*/>/*!*/ res = new List<T>(args.Length);
+      foreach (T t in args)
+        res.Add(cce.NonNull(t));
+      return res;
+    }
+
+    public static IDictionary<A, B> Clone<A, B>(IDictionary<A, B> dict) {
+      Contract.Requires(dict != null);
+      Contract.Ensures(Contract.Result<IDictionary<A, B>>() != null);
+      IDictionary<A, B> res = new Dictionary<A, B>(dict.Count);
+      foreach (KeyValuePair<A, B> pair in dict)
+        res.Add(pair);
+      return res;
+    }
+  }
+
+  [ContractClassFor(typeof(VCExpr))]
+  public abstract class VCExprContracts : VCExpr {
+    public override Type Type {
+      get {
+        Contract.Ensures(Contract.Result<Type>() != null);
+        throw new NotImplementedException();
+      }
+
+    }
+    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
+      Contract.Requires(visitor != null);
+      throw new NotImplementedException();
+    }
+  }
+
+  [ContractClass(typeof(VCExprContracts))]
+  public abstract class VCExpr {
+    public abstract Type Type {
+      get;
+    }
+
+    public abstract Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg);
+
+    [Pure]
+    public override string ToString() {
+      Contract.Ensures(Contract.Result<string>() != null);
+      StringWriter sw = new StringWriter();
+      VCExprPrinter printer = new VCExprPrinter();
+      printer.Print(this, sw);
+      return cce.NonNull(sw.ToString());
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////////
+  // Literal expressions
+
+  public class VCExprLiteral : VCExpr {
+    private readonly Type LitType;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(LitType != null);
+    }
+
+    public override Type Type {
+      get {
+        return LitType;
+      }
+    }
+    internal VCExprLiteral(Type type) {
+      Contract.Requires(type != null);
+      this.LitType = type;
+    }
+    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      return visitor.Visit(this, arg);
+    }
+  }
+
+  public class VCExprIntLit : VCExprLiteral {
+    public readonly BigNum Val;
+    internal VCExprIntLit(BigNum val)
+      : base(Type.Int) {
+      this.Val = val;
+    }
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprIntLit)
+        return Val == ((VCExprIntLit)that).Val;
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return Val.GetHashCode() * 72321;
+    }
+  }
+
+  public class VCExprRealLit : VCExprLiteral {
+    public readonly BigDec Val;
+    internal VCExprRealLit(BigDec val)
+      : base(Type.Real) {
+      this.Val = val;
+    }
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprRealLit)
+        return Val == ((VCExprRealLit)that).Val;
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return Val.GetHashCode() * 72321;
+    }
+  }
+
+  public class VCExprFloatLit : VCExprLiteral
+  {
+    public readonly BigFloat Val;
+    internal VCExprFloatLit(BigFloat val)
+      : base(Type.GetFloatType(val.ExponentSize, val.SignificandSize))
+    {
+      this.Val = val;
+    }
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that)
+    {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprFloatLit)
+        return Val == ((VCExprFloatLit)that).Val;
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode()
+    {
+      return Val.GetHashCode() * 72321;
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////////
+  // Operator expressions with fixed arity
+  [ContractClassFor(typeof(VCExprNAry))]
+  public abstract class VCExprNAryContracts : VCExprNAry {
+    public VCExprNAryContracts()
+      : base(null) {
+    }
+    public override VCExpr this[int index] {
+      get {
+        Contract.Ensures(Contract.Result<VCExpr>() != null);
+        throw new NotImplementedException();
+      }
+    }
+  }
+
+  [ContractClass(typeof(VCExprNAryContracts))]
+  public abstract class VCExprNAry : VCExpr, IEnumerable<VCExpr/*!*/> {
+    public readonly VCExprOp Op;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Op != null);
+      Contract.Invariant(cce.NonNullElements(EMPTY_TYPE_LIST));
+      Contract.Invariant(cce.NonNullElements(EMPTY_VCEXPR_LIST));
+    }
+
+    public int Arity {
+      get {
+        return Op.Arity;
+      }
+    }
+    public int TypeParamArity {
+      get {
+        return Op.TypeParamArity;
+      }
+    }
+    public int Length {
+      get {
+        return Arity;
+      }
+    }
+    // the sub-expressions of the expression
+    public abstract VCExpr/*!*/ this[int index] {
+      get;
+    }
+
+    // the type arguments
+    public abstract List<Type/*!*/>/*!*/ TypeArguments {
+      get;
+    }
+
+    [Pure]
+    [GlobalAccess(false)]
+    [Escapes(true, false)]
+    public IEnumerator<VCExpr/*!*/>/*!*/ GetEnumerator() {
+      Contract.Ensures(cce.NonNullElements(Contract.Result<IEnumerator<VCExpr>>()));
+      for (int i = 0; i < Arity; ++i)
+        yield return this[i];
+    }
+    [Pure]
+    [GlobalAccess(false)]
+    [Escapes(true, false)]
+    IEnumerator System.Collections.IEnumerable.GetEnumerator() {
+      Contract.Ensures(Contract.Result<IEnumerator>() != null);
+      for (int i = 0; i < Arity; ++i)
+        yield return this[i];
+    }
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprNAry) {
+        // we compare the subterms iteratively (not recursively)
+        // to avoid stack overflows
+
+        VCExprNAryEnumerator enum0 = new VCExprNAryEnumerator(this);
+        VCExprNAryEnumerator enum1 = new VCExprNAryEnumerator((VCExprNAry)that);
+
+        while (true) {
+          bool next0 = enum0.MoveNext();
+          bool next1 = enum1.MoveNext();
+          if (next0 != next1)
+            return false;
+          if (!next0)
+            return true;
+
+          VCExprNAry nextExprNAry0 = enum0.Current as VCExprNAry;
+          VCExprNAry nextExprNAry1 = enum1.Current as VCExprNAry;
+
+          if ((nextExprNAry0 == null) != (nextExprNAry1 == null))
+            return false;
+          if (nextExprNAry0 != null && nextExprNAry1 != null) {
+            if (!nextExprNAry0.Op.Equals(nextExprNAry1.Op))
+              return false;
+          } else {
+            if (!cce.NonNull(enum0.Current).Equals(enum1.Current))
+              return false;
+          }
+        }
+      }
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return HelperFuns.PolyHash(Op.GetHashCode() * 123 + Arity * 61521,
+                                 3, this);
+    }
+
+    internal VCExprNAry(VCExprOp op) {
+      Contract.Requires(op != null);
+      this.Op = op;
+    }
+    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      return visitor.Visit(this, arg);
+    }
+    public Result Accept<Result, Arg>(IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      Contract.Requires(visitor != null);
+      return Op.Accept(this, visitor, arg);
+    }
+
+    internal static readonly List<Type/*!*/>/*!*/ EMPTY_TYPE_LIST = new List<Type/*!*/>();
+    internal static readonly List<VCExpr/*!*/>/*!*/ EMPTY_VCEXPR_LIST = new List<VCExpr/*!*/>();
+
+    public IEnumerable<VCExpr> UniformArguments
+    {
+      get
+      {
+        var enumerator = new VCExprNAryUniformOpEnumerator(this);
+        while (enumerator.MoveNext()) {
+          VCExprNAry naryExpr = enumerator.Current as VCExprNAry;
+          if (naryExpr == null || !naryExpr.Op.Equals(this.Op)) {
+            yield return (VCExpr)enumerator.Current;
+          }
+        }
+      }
+    }
+  }
+
+  // We give specialised implementations for nullary, unary and binary expressions
+
+  internal class VCExprNullary : VCExprNAry {
+    private readonly Type ExprType;
+    [ContractInvariantMethod]
+    void loneinvariant() {
+      Contract.Invariant(ExprType != null);
+    }
+
+    public override Type Type {
+      get {
+        Contract.Ensures(Contract.Result<Type>() != null);
+        return ExprType;
+      }
+    }
+    public override VCExpr this[int index] {
+      get {
+        Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+        Contract.Assert(false);
+        throw new cce.UnreachableException(); // no arguments
+      }
+    }
+
+    // the type arguments
+    public override List<Type/*!*/>/*!*/ TypeArguments {
+      get {
+        Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
+        return EMPTY_TYPE_LIST;
+      }
+    }
+
+    internal VCExprNullary(VCExprOp op)
+      : base(op) {
+      Contract.Requires(op != null);
+      Contract.Requires(op.Arity == 0 && op.TypeParamArity == 0);
+      this.ExprType = op.InferType(EMPTY_VCEXPR_LIST, EMPTY_TYPE_LIST);
+    }
+  }
+
+  internal class VCExprUnary : VCExprNAry {
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Argument != null);
+      Contract.Invariant(ExprType != null);
+
+    }
+
+    private readonly VCExpr/*!*/ Argument;
+    private readonly Type/*!*/ ExprType;
+    public override Type/*!*/ Type {
+      get {
+        Contract.Ensures(Contract.Result<Type>() != null);
+        return ExprType;
+      }
+    }
+    public override VCExpr/*!*/ this[int index] {
+      get {
+        Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+        Contract.Assume(index == 0);
+        return Argument;
+      }
+    }
+
+    // the type arguments
+    public override List<Type/*!*/>/*!*/ TypeArguments {
+      get {
+        Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
+        return EMPTY_TYPE_LIST;
+      }
+    }
+
+    internal VCExprUnary(VCExprOp op, List<VCExpr> arguments)
+      : base(op) {
+      Contract.Requires(op != null);
+      Contract.Requires(cce.NonNullElements(arguments));
+      Contract.Requires(op.Arity == 1 && op.TypeParamArity == 0 && arguments.Count == 1);
+
+      this.Argument = arguments[0];
+      this.ExprType =
+        op.InferType(arguments, EMPTY_TYPE_LIST);
+    }
+
+    internal VCExprUnary(VCExprOp op, VCExpr argument)
+      : base(op) {
+      Contract.Requires(argument != null);
+      Contract.Requires(op != null);
+      Contract.Requires(op.Arity == 1 && op.TypeParamArity == 0);
+
+      this.Argument = argument;
+      // PR: could be optimised so that the argument does
+      // not have to be boxed in an array each time
+      this.ExprType =
+        op.InferType(HelperFuns.ToNonNullList(argument), EMPTY_TYPE_LIST);
+    }
+  }
+
+  internal class VCExprBinary : VCExprNAry {
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Argument0 != null);
+      Contract.Invariant(Argument1 != null);
+      Contract.Invariant(ExprType != null);
+    }
+
+    private readonly VCExpr Argument0;
+    private readonly VCExpr Argument1;
+    private readonly Type ExprType;
+    public override Type Type {
+      get {
+        Contract.Ensures(Contract.Result<Type>() != null);
+        return ExprType;
+      }
+    }
+    public override VCExpr this[int index] {
+      get {
+        Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+        switch (index) {
+          case 0:
+            return Argument0;
+          case 1:
+            return Argument1;
+          default: {
+              Contract.Assert(false);
+              throw new cce.UnreachableException();
+            }
+        }
+      }
+    }
+
+    // the type arguments
+    public override List<Type/*!*/>/*!*/ TypeArguments {
+      get {
+        Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
+        return EMPTY_TYPE_LIST;
+      }
+    }
+
+    internal VCExprBinary(VCExprOp op, List<VCExpr> arguments)
+      : base(op) {
+      Contract.Requires(op != null);
+      Contract.Requires(cce.NonNullElements(arguments));
+      Contract.Requires(op.Arity == 2 && op.TypeParamArity == 0 && arguments.Count == 2);
+
+      this.Argument0 = arguments[0];
+      this.Argument1 = arguments[1];
+      this.ExprType = op.InferType(arguments, EMPTY_TYPE_LIST);
+    }
+
+    internal VCExprBinary(VCExprOp op, VCExpr argument0, VCExpr argument1)
+      : base(op) {
+      Contract.Requires(argument1 != null);
+      Contract.Requires(argument0 != null);
+      Contract.Requires(op != null);
+      Contract.Requires(op.Arity == 2 && op.TypeParamArity == 0);
+      this.Argument0 = argument0;
+      this.Argument1 = argument1;
+      // PR: could be optimised so that the arguments do
+      // not have to be boxed in an array each time
+      this.ExprType =
+        op.InferType(HelperFuns.ToNonNullList(argument0, argument1),
+                     EMPTY_TYPE_LIST);
+    }
+  }
+
+  internal class VCExprMultiAry : VCExprNAry {
+    private readonly List<VCExpr/*!*/>/*!*/ Arguments;
+    private readonly List<Type/*!*/>/*!*/ TypeArgumentsAttr;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(cce.NonNullElements(Arguments));
+      Contract.Invariant(cce.NonNullElements(TypeArgumentsAttr));
+      Contract.Invariant(ExprType != null);
+    }
+
+
+    private readonly Type/*!*/ ExprType;
+    public override Type/*!*/ Type {
+      get {
+        Contract.Ensures(Contract.Result<Type>() != null);
+        return ExprType;
+      }
+    }
+    public override VCExpr/*!*/ this[int index] {
+      get {
+        Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+        Contract.Assume(index >= 0 && index < Arity);
+        return cce.NonNull(Arguments)[index];
+      }
+    }
+
+    // the type arguments
+    public override List<Type/*!*/>/*!*/ TypeArguments {
+      get {
+        Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
+        return TypeArgumentsAttr;
+      }
+    }
+
+    internal VCExprMultiAry(VCExprOp op, List<VCExpr> arguments)
+      : base(op) {
+      Contract.Requires(op != null);
+      Contract.Requires(cce.NonNullElements(arguments));
+      this.Arguments = arguments;
+      this.TypeArgumentsAttr = EMPTY_TYPE_LIST;
+      this.ExprType = op.InferType(arguments, TypeArgumentsAttr);
+    }
+    internal VCExprMultiAry(VCExprOp op, List<VCExpr> arguments, List<Type/*!*/>/*!*/ typeArguments)
+      : base(op) {
+      Contract.Requires(op != null);
+      Contract.Requires(cce.NonNullElements(typeArguments));
+      Contract.Requires(cce.NonNullElements(arguments));
+      Contract.Requires(arguments.Count > 2 || typeArguments.Count > 0);
+      Contract.Requires(op.Arity == arguments.Count);
+      Contract.Requires(op.TypeParamArity == typeArguments.Count);
+      this.Arguments = arguments;
+      this.TypeArgumentsAttr = typeArguments;
+      this.ExprType = op.InferType(arguments, typeArguments);
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////////
+  // The various operators available
+  [ContractClass(typeof(VCExprOpContracts))]
+  public abstract class VCExprOp {
+    // the number of value parameters
+    public abstract int Arity {
+      get;
+    }
+    // the number of type parameters
+    public abstract int TypeParamArity {
+      get;
+    }
+
+    public abstract Type/*!*/ InferType(List<VCExpr/*!*/>/*!*/ args, List<Type/*!*/>/*!*/ typeArgs);
+
+    public virtual Result Accept<Result, Arg>(VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      Contract.Requires(visitor != null);
+      Contract.Requires(expr != null);
+      VCExpressionGenerator.SingletonOp op;
+      if (VCExpressionGenerator.SingletonOpDict.TryGetValue(this, out op)) {
+        switch (op) {
+          case VCExpressionGenerator.SingletonOp.NotOp:
+            return visitor.VisitNotOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.EqOp:
+            return visitor.VisitEqOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.NeqOp:
+            return visitor.VisitNeqOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.AndOp:
+            return visitor.VisitAndOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.OrOp:
+            return visitor.VisitOrOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.ImpliesOp:
+            return visitor.VisitImpliesOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.AddOp:
+            return visitor.VisitAddOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.SubOp:
+            return visitor.VisitSubOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.MulOp:
+            return visitor.VisitMulOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.DivOp:
+            return visitor.VisitDivOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.ModOp:
+            return visitor.VisitModOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.RealDivOp:
+            return visitor.VisitRealDivOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.PowOp:
+            return visitor.VisitPowOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.LtOp:
+            return visitor.VisitLtOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.LeOp:
+            return visitor.VisitLeOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.GtOp:
+            return visitor.VisitGtOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.GeOp:
+            return visitor.VisitGeOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.SubtypeOp:
+            return visitor.VisitSubtypeOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.Subtype3Op:
+            return visitor.VisitSubtype3Op(expr, arg);
+          case VCExpressionGenerator.SingletonOp.BvConcatOp:
+            return visitor.VisitBvConcatOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.ToIntOp:
+            return visitor.VisitToIntOp(expr, arg);
+          case VCExpressionGenerator.SingletonOp.ToRealOp:
+            return visitor.VisitToRealOp(expr, arg);
+          default:
+            Contract.Assert(false);
+            throw new cce.UnreachableException();
+        }
+      } else {
+        Contract.Assert(false);
+        throw new cce.UnreachableException();
+      }
+    }
+  }
+  [ContractClassFor(typeof(VCExprOp))]
+  abstract class VCExprOpContracts : VCExprOp {
+    public override Type InferType(List<VCExpr> args, List<Type> typeArgs) {
+      Contract.Requires(cce.NonNullElements(args));
+      Contract.Requires(cce.NonNullElements(typeArgs));
+      Contract.Ensures(Contract.Result<Type>() != null);
+
+      throw new NotImplementedException();
+    }
+  }
+
+  public class VCExprNAryOp : VCExprOp {
+    private readonly Type OpType;
+    private readonly int OpArity;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(OpType != null);
+    }
+
+    public override int Arity {
+      get {
+        return OpArity;
+      }
+    }
+    public override int TypeParamArity {
+      get {
+        return 0;
+      }
+    }
+    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
+      //Contract.Requires(cce.NonNullElements(typeArgs));
+      //Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<Type>() != null);
+      return OpType;
+    }
+
+    internal VCExprNAryOp(int arity, Type type) {
+      Contract.Requires(type != null);
+      this.OpArity = arity;
+      this.OpType = type;
+    }
+  }
+
+  public class VCExprDistinctOp : VCExprNAryOp {
+    internal VCExprDistinctOp(int arity)
+      : base(arity, Type.Bool) {
+    }
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprDistinctOp)
+        return Arity == ((VCExprDistinctOp)that).Arity;
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return Arity * 917632481;
+    }
+    public override Result Accept<Result, Arg>
+           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      //Contract.Requires(expr != null);
+      return visitor.VisitDistinctOp(expr, arg);
+    }
+  }
+
+  public class VCExprLabelOp : VCExprOp {
+    public override int Arity {
+      get {
+        return 1;
+      }
+    }
+    public override int TypeParamArity {
+      get {
+        return 0;
+      }
+    }
+    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
+      //Contract.Requires(cce.NonNullElements(typeArgs));
+      //Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<Type>() != null);
+      return args[0].Type;
+    }
+
+    public readonly bool pos;
+    public readonly string label;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(label != null);
+    }
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprLabelOp) {
+        VCExprLabelOp/*!*/ thatOp = (VCExprLabelOp)that;
+        return this.pos == thatOp.pos && this.label.Equals(thatOp.label);
+      }
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return (pos ? 9817231 : 7198639) + label.GetHashCode();
+    }
+
+    internal VCExprLabelOp(bool pos, string l) {
+      Contract.Requires(l != null);
+      this.pos = pos;
+      this.label = pos ? "+" + l : "@" + l;
+    }
+    public override Result Accept<Result, Arg>
+           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      //Contract.Requires(expr != null);
+      return visitor.VisitLabelOp(expr, arg);
+    }
+  }
+
+  public class VCExprSelectOp : VCExprOp {
+    private readonly int MapArity;
+    private readonly int MapTypeParamArity;
+    public override int Arity {
+      get {
+        return MapArity + 1;
+      }
+    }
+    public override int TypeParamArity {
+      get {
+        return MapTypeParamArity;
+      }
+    }
+
+    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
+      //Contract.Requires(cce.NonNullElements(typeArgs));
+      //Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<Type>() != null);
+      MapType/*!*/ mapType = args[0].Type.AsMap;
+      Contract.Assert(TypeParamArity == mapType.TypeParameters.Count);
+      IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ subst = new Dictionary<TypeVariable/*!*/, Type/*!*/>();
+      for (int i = 0; i < TypeParamArity; ++i)
+        subst.Add(mapType.TypeParameters[i], typeArgs[i]);
+      return mapType.Result.Substitute(subst);
+    }
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprSelectOp)
+        return Arity == ((VCExprSelectOp)that).Arity &&
+          TypeParamArity == ((VCExprSelectOp)that).TypeParamArity;
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return Arity * 1212481 + TypeParamArity * 298741;
+    }
+
+    internal VCExprSelectOp(int arity, int typeParamArity) {
+      Contract.Requires(0 <= arity && 0 <= typeParamArity);
+      this.MapArity = arity;
+      this.MapTypeParamArity = typeParamArity;
+    }
+    public override Result Accept<Result, Arg>
+           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      //Contract.Requires(expr != null);
+      return visitor.VisitSelectOp(expr, arg);
+    }
+  }
+
+  public class VCExprStoreOp : VCExprOp {
+    private readonly int MapArity;
+    private readonly int MapTypeParamArity;
+    public override int Arity {
+      get {
+        return MapArity + 2;
+      }
+    }
+    // stores never need explicit type parameters, because also the
+    // rhs is a value argument
+    public override int TypeParamArity {
+      get {
+        return MapTypeParamArity;
+      }
+    }
+
+    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
+      //Contract.Requires(cce.NonNullElements(typeArgs));
+      //Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<Type>() != null);
+      return args[0].Type;
+    }
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprStoreOp)
+        return Arity == ((VCExprStoreOp)that).Arity;
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return Arity * 91361821;
+    }
+
+    internal VCExprStoreOp(int arity, int typeParamArity) {
+      Contract.Requires(0 <= arity && 0 <= typeParamArity);
+      this.MapArity = arity;
+      this.MapTypeParamArity = typeParamArity;
+    }
+    public override Result Accept<Result, Arg>
+           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      //Contract.Requires(expr != null);
+      return visitor.VisitStoreOp(expr, arg);
+    }
+  }
+
+  public class VCExprIfThenElseOp : VCExprOp {
+    public override int Arity {
+      get {
+        return 3;
+      }
+    }
+    public override int TypeParamArity {
+      get {
+        return 0;
+      }
+    }
+    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
+      //Contract.Requires(cce.NonNullElements(typeArgs));
+      //Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<Type>() != null);
+      return args[1].Type;
+    }
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprIfThenElseOp)
+        return true;
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return 1;
+    }
+
+    internal VCExprIfThenElseOp() {
+    }
+    public override Result Accept<Result, Arg>
+           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      //Contract.Requires(expr != null);
+      return visitor.VisitIfThenElseOp(expr, arg);
+    }
+  }
+
+  public class VCExprSoftOp : VCExprCustomOp
+  {
+    public readonly int Weight;
+
+    public VCExprSoftOp(int weight) : base("soft##dummy", 2, Microsoft.Boogie.Type.Bool)
+    {
+      Weight = weight;
+    }
+  }
+
+  public class VCExprCustomOp : VCExprOp {
+    public readonly string/*!*/ Name;
+    int arity;
+    public readonly Type/*!*/ Type;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Name != null);
+      Contract.Invariant(Type != null);
+    }
+
+    public VCExprCustomOp(string/*!*/ name, int arity, Type/*!*/ type) {
+      Contract.Requires(name != null);
+      Contract.Requires(type != null);
+      this.Name = name;
+      this.arity = arity;
+      this.Type = type;
+    }
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      VCExprCustomOp t = that as VCExprCustomOp;
+      if (t == null)
+        return false;
+      return this.Name == t.Name && this.arity == t.arity && this.Type == t.Type;
+    }
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override int GetHashCode() {
+      int h = Name.GetHashCode();
+      h = 7823 * h + arity;
+      h = 7823 * h + Type.GetHashCode();
+      return h;
+    }
+    public override int Arity {
+      get {
+        return arity;
+      }
+    }
+    public override int TypeParamArity {
+      get {
+        return 0;
+      }
+    }
+    public override Type/*!*/ InferType(List<VCExpr/*!*/>/*!*/ args, List<Type/*!*/>/*!*/ typeArgs) {
+      //Contract.Requires((cce.NonNullElements(args)));
+      //Contract.Requires((cce.NonNullElements(typeArgs)));
+      Contract.Ensures(Contract.Result<Type>() != null);
+      return Type;
+    }
+    public override Result Accept<Result, Arg>
+           (VCExprNAry/*!*/ expr, IVCExprOpVisitor<Result, Arg>/*!*/ visitor, Arg arg) {
+      //Contract.Requires(expr != null);
+      //Contract.Requires(visitor != null);
+      return visitor.VisitCustomOp(expr, arg);
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////////
+  // Float operators
+
+  public class VCExprBinaryFloatOp : VCExprOp {
+    public readonly int Mantissa;
+    public readonly int Exponent;
+    private string op;
+
+    public override int Arity {
+      get {
+        return 2;
+      }
+    }
+    public override int TypeParamArity {
+      get {
+        return 2;
+      }
+    }
+    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
+      //Contract.Requires(cce.NonNullElements(typeArgs));
+      //Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<Type>() != null);
+      return Type.GetFloatType(Exponent, Mantissa);
+    }
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprBinaryFloatOp)
+        return this.Exponent == ((VCExprBinaryFloatOp)that).Exponent && this.Mantissa == ((VCExprBinaryFloatOp)that).Mantissa;
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return Exponent * 81748912 + Mantissa * 67867979;
+    }
+
+    internal VCExprBinaryFloatOp(int exp, int man, string op) {
+      this.Exponent = exp;
+      this.Mantissa = man;
+      this.op = op;
+    }
+    public override Result Accept<Result, Arg>
+           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      //Contract.Requires(expr != null);
+      switch (op) { 
+      case ("+"):
+        return visitor.VisitFloatAddOp(expr, arg);
+      case ("-"):
+        return visitor.VisitFloatSubOp(expr, arg);
+      case ("*"):
+        return visitor.VisitFloatMulOp(expr, arg);
+      case ("/"):
+        return visitor.VisitFloatDivOp(expr, arg);
+      case ("rem"):
+        return visitor.VisitFloatRemOp(expr, arg);
+      case ("min"):
+        return visitor.VisitFloatMinOp(expr, arg);
+      case ("max"):
+        return visitor.VisitFloatMaxOp(expr, arg);
+      case ("<="):
+        return visitor.VisitFloatLeqOp(expr, arg);
+      case ("<"):
+        return visitor.VisitFloatLtOp(expr, arg);
+      case (">="):
+        return visitor.VisitFloatGeqOp(expr, arg);
+      case (">"):
+        return visitor.VisitFloatGtOp(expr, arg);
+      case ("=="):
+        return visitor.VisitFloatEqOp(expr, arg);
+      default:
+        Contract.Assert(false);
+        throw new cce.UnreachableException();
+      }
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////////
+  // Bitvector operators
+
+  public class VCExprBvOp : VCExprOp {
+    public readonly int Bits;
+
+    public override int Arity {
+      get {
+        return 1;
+      }
+    }
+    public override int TypeParamArity {
+      get {
+        return 0;
+      }
+    }
+    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
+      //Contract.Requires(cce.NonNullElements(typeArgs));
+      //Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<Type>() != null);
+      return Type.GetBvType(Bits);
+    }
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprBvOp)
+        return this.Bits == ((VCExprBvOp)that).Bits;
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return Bits * 81748912;
+    }
+
+    internal VCExprBvOp(int bits) {
+      this.Bits = bits;
+    }
+    public override Result Accept<Result, Arg>
+           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      //Contract.Requires(expr != null);
+      return visitor.VisitBvOp(expr, arg);
+    }
+  }
+
+  public class VCExprBvExtractOp : VCExprOp {
+    public readonly int Start;
+    public readonly int End;
+    public readonly int Total;  // the number of bits from which the End-Start bits are extracted
+
+    public override int Arity {
+      get {
+        return 1;
+      }
+    }
+    public override int TypeParamArity {
+      get {
+        return 0;
+      }
+    }
+    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
+      //Contract.Requires(cce.NonNullElements(typeArgs));
+      //Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<Type>() != null);
+      return Type.GetBvType(End - Start);
+    }
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprBvExtractOp) {
+        VCExprBvExtractOp/*!*/ thatExtract = (VCExprBvExtractOp)that;
+        return this.Start == thatExtract.Start && this.End == thatExtract.End && this.Total == thatExtract.Total;
+      }
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return Start * 81912 + End * 978132 + Total * 571289;
+    }
+
+    internal VCExprBvExtractOp(int start, int end, int total) {
+      Contract.Requires(0 <= start && start <= end && end <= total);
+      this.Start = start;
+      this.End = end;
+      this.Total = total;
+    }
+    public override Result Accept<Result, Arg>
+           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      //Contract.Requires(expr != null);
+      return visitor.VisitBvExtractOp(expr, arg);
+    }
+  }
+
+  public class VCExprBvConcatOp : VCExprOp {
+    public readonly int LeftSize;
+    public readonly int RightSize;
+
+    public override int Arity {
+      get {
+        return 2;
+      }
+    }
+    public override int TypeParamArity {
+      get {
+        return 0;
+      }
+    }
+    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
+      //Contract.Requires(cce.NonNullElements(typeArgs));
+      //Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<Type>() != null);
+      return Type.GetBvType(args[0].Type.BvBits + args[1].Type.BvBits);
+    }
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprBvConcatOp) {
+        VCExprBvConcatOp thatConcat = (VCExprBvConcatOp)that;
+        return this.LeftSize == thatConcat.LeftSize && this.RightSize == thatConcat.RightSize;
+      }
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return LeftSize * 81912 + RightSize * 978132;
+    }
+
+    internal VCExprBvConcatOp(int leftSize, int rightSize) {
+      Contract.Requires(0 <= leftSize && 0 <= rightSize);
+      this.LeftSize = leftSize;
+      this.RightSize = rightSize;
+    }
+    public override Result Accept<Result, Arg>
+           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      //Contract.Requires(expr != null);
+      return visitor.VisitBvConcatOp(expr, arg);
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////////
+  // References to user-defined Boogie functions
+
+  public class VCExprBoogieFunctionOp : VCExprOp {
+    public readonly Function Func;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Func != null);
+    }
+
+
+    public override int Arity {
+      get {
+        return Func.InParams.Count;
+      }
+    }
+    public override int TypeParamArity {
+      get {
+        return Func.TypeParameters.Count;
+      }
+    }
+    public override Type InferType(List<VCExpr> args, List<Type/*!*/>/*!*/ typeArgs) {
+      //Contract.Requires(cce.NonNullElements(typeArgs));
+      //Contract.Requires(cce.NonNullElements(args));
+      Contract.Ensures(Contract.Result<Type>() != null);
+      Contract.Assert(TypeParamArity == Func.TypeParameters.Count);
+      if (TypeParamArity == 0)
+        return cce.NonNull(Func.OutParams[0]).TypedIdent.Type;
+      IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ subst = new Dictionary<TypeVariable/*!*/, Type/*!*/>(TypeParamArity);
+      for (int i = 0; i < TypeParamArity; ++i)
+        subst.Add(Func.TypeParameters[i], typeArgs[i]);
+      return cce.NonNull(Func.OutParams[0]).TypedIdent.Type.Substitute(subst);
+    }
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprBoogieFunctionOp)
+        return this.Func.Equals(((VCExprBoogieFunctionOp)that).Func);
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return Func.GetHashCode() + 18731;
+    }
+
+    // we require that the result type of the expression is specified, because we
+    // do not want to perform full type inference at this point
+    internal VCExprBoogieFunctionOp(Function func) {
+      Contract.Requires(func != null);
+      this.Func = func;
+    }
+    public override Result Accept<Result, Arg>
+           (VCExprNAry expr, IVCExprOpVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      //Contract.Requires(expr != null);
+      return visitor.VisitBoogieFunctionOp(expr, arg);
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////////
+  // Binders (quantifiers and let-expressions). We introduce our own class for
+  // term variables, but use the Boogie-AST class for type variables
+
+  public class VCExprVar : VCExpr {
+    // the name of the variable. Note that the name is not used for comparison,
+    // i.e., there can be two distinct variables with the same name
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Name != null);
+      Contract.Invariant(VarType != null);
+    }
+
+    public readonly string/*!*/ Name;
+    private readonly Type/*!*/ VarType;
+    public override Type/*!*/ Type {
+      get {
+        Contract.Ensures(Contract.Result<Type>() != null);
+        return VarType;
+      }
+    }
+
+    internal VCExprVar(string name, Type type) {
+      Contract.Requires(type != null);
+      Contract.Requires(name != null);
+      this.Name = name;
+      this.VarType = type;
+    }
+    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      return visitor.Visit(this, arg);
+    }
+  }
+
+  public class VCExprConstant : VCExprVar
+  {
+      internal VCExprConstant(string name, Type type) : base(name,type) {
+      Contract.Requires(type != null);
+      Contract.Requires(name != null);
+    }
+  }
+
+  public abstract class VCExprBinder : VCExpr {
+    public readonly VCExpr/*!*/ Body;
+    public readonly List<TypeVariable/*!*/>/*!*/ TypeParameters;
+    public readonly List<VCExprVar/*!*/>/*!*/ BoundVars;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Body != null);
+      Contract.Invariant(cce.NonNullElements(TypeParameters));
+      Contract.Invariant(cce.NonNullElements(BoundVars));
+    }
+
+
+    public override Type/*!*/ Type {
+      get {
+        Contract.Ensures(Contract.Result<Type>() != null);
+
+        return Body.Type;
+      }
+    }
+
+    internal VCExprBinder(List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ boundVars, VCExpr body) {
+      Contract.Requires(body != null);
+      Contract.Requires(cce.NonNullElements(boundVars));
+      Contract.Requires(cce.NonNullElements(typeParams));
+      Contract.Requires(boundVars.Count + typeParams.Count > 0);     // only nontrivial binders ...
+      this.TypeParameters = typeParams;
+      this.BoundVars = boundVars;
+      this.Body = body;
+    }
+  }
+
+  public class VCTrigger {
+    public readonly bool Pos;
+    public readonly List<VCExpr/*!*/>/*!*/ Exprs;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Exprs != null);
+    }
+
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCTrigger) {
+        VCTrigger/*!*/ thatTrigger = (VCTrigger)that;
+        return this.Pos == thatTrigger.Pos &&
+          HelperFuns.SameElements(this.Exprs, thatTrigger.Exprs);
+      }
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return (Pos ? 913821 : 871334) +
+             HelperFuns.PolyHash(123, 7, this.Exprs);
+    }
+
+    public VCTrigger(bool pos, List<VCExpr> exprs) {
+      Contract.Requires(cce.NonNullElements(exprs));
+      this.Pos = pos;
+      this.Exprs = exprs;
+    }
+  }
+
+  public class VCQuantifierInfos {
+    public readonly string qid;
+    public readonly int uniqueId;
+    public readonly bool bvZ3Native;
+    public QKeyValue attributes;
+
+    public VCQuantifierInfos(string qid, int uniqueId, bool bvZ3Native, QKeyValue attributes) {
+      this.qid = qid;
+      this.uniqueId = uniqueId;
+      this.bvZ3Native = bvZ3Native;
+      this.attributes = attributes;
+    }
+  }
+
+  public enum Quantifier {
+    ALL,
+    EX
+  };
+
+  public class VCExprQuantifier : VCExprBinder {
+    public readonly Quantifier Quan;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Infos != null);
+      Contract.Invariant(cce.NonNullElements(Triggers));
+    }
+
+
+    public readonly List<VCTrigger/*!*/>/*!*/ Triggers;
+    public readonly VCQuantifierInfos Infos;
+
+    // Equality is /not/ modulo bound renaming at this point
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprQuantifier) {
+        VCExprQuantifier/*!*/ thatQuan = (VCExprQuantifier)that;
+        return this.Quan == thatQuan.Quan &&
+               HelperFuns.SameElements(this.Triggers, thatQuan.Triggers) &&
+               HelperFuns.SameElements(this.TypeParameters, thatQuan.TypeParameters) &&
+               HelperFuns.SameElements(this.BoundVars, thatQuan.BoundVars) &&
+               this.Body.Equals(thatQuan.Body);
+      }
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return Quan.GetHashCode() +
+        HelperFuns.PolyHash(973219, 7, TypeParameters) +
+        HelperFuns.PolyHash(998431, 9, BoundVars) +
+        HelperFuns.PolyHash(123, 11, Triggers);
+    }
+
+    internal VCExprQuantifier(Quantifier kind, List<TypeVariable/*!*/>/*!*/ typeParams, List<VCExprVar/*!*/>/*!*/ boundVars, List<VCTrigger/*!*/>/*!*/ triggers, VCQuantifierInfos infos, VCExpr body)
+      : base(typeParams, boundVars, body) {
+      Contract.Requires(body != null);
+      Contract.Requires(infos != null);
+      Contract.Requires(cce.NonNullElements(triggers));
+      Contract.Requires(cce.NonNullElements(boundVars));
+      Contract.Requires(cce.NonNullElements(typeParams));
+
+      this.Quan = kind;
+      this.Triggers = triggers;
+      this.Infos = infos;
+    }
+    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      return visitor.Visit(this, arg);
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////////
+  // Let-Bindings
+
+  public class VCExprLetBinding {
+    public readonly VCExprVar V;
+    public readonly VCExpr E;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(V != null);
+      Contract.Invariant(E != null);
+    }
+
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprLetBinding) {
+        VCExprLetBinding/*!*/ thatB = (VCExprLetBinding)that;
+        return this.V.Equals(thatB.V) && this.E.Equals(thatB.E);
+      }
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return V.GetHashCode() * 71261 + E.GetHashCode();
+    }
+
+    internal VCExprLetBinding(VCExprVar v, VCExpr e) {
+      Contract.Requires(e != null);
+      Contract.Requires(v != null);
+      this.V = v;
+      this.E = e;
+      Contract.Assert(v.Type.Equals(e.Type));
+    }
+  }
+
+  public class VCExprLet : VCExprBinder, IEnumerable<VCExprLetBinding/*!*/> {
+    private readonly List<VCExprLetBinding/*!*/>/*!*/ Bindings;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(cce.NonNullElements(Bindings));
+
+    }
+
+
+    public int Length {
+      get {
+        return Bindings.Count;
+      }
+    }
+    public VCExprLetBinding this[int index] {
+      get {
+        Contract.Ensures(Contract.Result<VCExprLetBinding>() != null);
+        return Bindings[index];
+      }
+    }
+
+    [Pure]
+    [Reads(ReadsAttribute.Reads.Nothing)]
+    public override bool Equals(object that) {
+      if (Object.ReferenceEquals(this, that))
+        return true;
+      if (that is VCExprLet) {
+        VCExprLet/*!*/ thatLet = (VCExprLet)that;
+        return this.Body.Equals(thatLet.Body) &&
+               HelperFuns.SameElements(this, (VCExprLet)that);
+      }
+      return false;
+    }
+    [Pure]
+    public override int GetHashCode() {
+      return HelperFuns.PolyHash(Body.GetHashCode(), 9, Bindings);
+    }
+
+    [Pure]
+    [GlobalAccess(false)]
+    [Escapes(true, false)]
+    public IEnumerator<VCExprLetBinding/*!*/>/*!*/ GetEnumerator() {
+      Contract.Ensures(cce.NonNullElements(Contract.Result<IEnumerator<VCExprLetBinding>>()));
+      return Bindings.GetEnumerator();
+    }
+    [Pure]
+    [GlobalAccess(false)]
+    [Escapes(true, false)]
+    IEnumerator System.Collections.IEnumerable.GetEnumerator() {
+      Contract.Ensures(Contract.Result<IEnumerator>() != null);
+      return Bindings.GetEnumerator();
+    }
+
+    private static List<VCExprVar/*!*/>/*!*/ toSeq(List<VCExprLetBinding/*!*/>/*!*/ bindings) {
+      Contract.Requires(cce.NonNullElements(bindings));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExprVar>>()));
+      List<VCExprVar> res = new List<VCExprVar>();
+      foreach (VCExprLetBinding/*!*/ b in bindings)
+        res.Add(b.V);
+      return res;
+    }
+
+    internal VCExprLet(List<VCExprLetBinding/*!*/>/*!*/ bindings, VCExpr/*!*/ body)
+      : base(new List<TypeVariable/*!*/>(), toSeq(bindings), body) {
+      Contract.Requires(cce.NonNullElements(bindings));
+      Contract.Requires(body != null);
+      this.Bindings = bindings;
+    }
+    public override Result Accept<Result, Arg>(IVCExprVisitor<Result, Arg> visitor, Arg arg) {
+      //Contract.Requires(visitor != null);
+      return visitor.Visit(this, arg);
+    }
+  }
+}
diff --git a/Source/VCExpr/VCExprASTPrinter.cs b/Source/VCExpr/VCExprASTPrinter.cs
index 8e2f5d12..dac9604c 100644
--- a/Source/VCExpr/VCExprASTPrinter.cs
+++ b/Source/VCExpr/VCExprASTPrinter.cs
@@ -1,432 +1,432 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using Microsoft.Basetypes;
-
-// A simple visitor for turning a VCExpr into a human-readable string
-// (S-expr syntax)
-
-namespace Microsoft.Boogie.VCExprAST {
-
-  public class VCExprPrinter : IVCExprVisitor<bool, TextWriter/*!*/> {
-    private VCExprOpPrinter OpPrinterVar = null;
-    private VCExprOpPrinter/*!*/ OpPrinter {
-      get {
-        Contract.Ensures(Contract.Result<VCExprOpPrinter>() != null);
-
-        if (OpPrinterVar == null)
-          OpPrinterVar = new VCExprOpPrinter(this);
-        return OpPrinterVar;
-      }
-    }
-
-    public void Print(VCExpr expr, TextWriter wr) {
-      Contract.Requires(wr != null);
-      Contract.Requires(expr != null);
-      expr.Accept<bool, TextWriter/*!*/>(this, wr);
-    }
-
-    public bool Visit(VCExprLiteral node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      if (node == VCExpressionGenerator.True) {
-        wr.Write("true");
-      } else if (node == VCExpressionGenerator.False) {
-        wr.Write("false");
-      } else if (node is VCExprIntLit) {
-        wr.Write(((VCExprIntLit)node).Val);
-      } else {
-        Contract.Assert(false);
-        throw new cce.UnreachableException();
-      }
-      return true;
-    }
-    public bool Visit(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      VCExprOp/*!*/ op = node.Op;
-      Contract.Assert(op != null);
-
-      if (op.Equals(VCExpressionGenerator.AndOp) ||
-          op.Equals(VCExpressionGenerator.OrOp)) {
-        // handle these operators without recursion
-
-        wr.Write("({0}",
-                 op.Equals(VCExpressionGenerator.AndOp) ? "And" : "Or");
-        IEnumerator/*!*/ enumerator = new VCExprNAryUniformOpEnumerator(node);
-        Contract.Assert(enumerator != null);
-        while (enumerator.MoveNext()) {
-          VCExprNAry naryExpr = enumerator.Current as VCExprNAry;
-          if (naryExpr == null || !naryExpr.Op.Equals(op)) {
-            wr.Write(" ");
-            Print(cce.NonNull((VCExpr/*!*/)enumerator.Current), wr);
-          }
-        }
-
-        wr.Write(")");
-
-        return true;
-      }
-
-      return node.Accept<bool, TextWriter/*!*/>(OpPrinter, wr);
-    }
-    public bool Visit(VCExprVar node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      wr.Write(node.Name);
-      return true;
-    }
-    public bool Visit(VCExprQuantifier node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      string/*!*/ quan = node.Quan == Quantifier.ALL ? "Forall" : "Exists";
-      Contract.Assert(quan != null);
-
-      wr.Write("({0} ", quan);
-
-      if (node.TypeParameters.Count > 0) {
-        wr.Write("<");
-        string/*!*/ sep = "";
-        foreach (TypeVariable/*!*/ v in node.TypeParameters) {
-          Contract.Assert(v != null);
-          wr.Write(sep);
-          sep = ", ";
-          wr.Write("{0}", v.Name);
-        }
-        wr.Write("> ");
-      }
-
-      if (node.BoundVars.Count > 0) {
-        string/*!*/ sep = "";
-        foreach (VCExprVar/*!*/ v in node.BoundVars) {
-          Contract.Assert(v != null);
-          wr.Write(sep);
-          sep = ", ";
-          Print(v, wr);
-        }
-        wr.Write(" ");
-      }
-
-      wr.Write(":: ");
-
-      if (node.Triggers.Count > 0) {
-        wr.Write("{0} ", "{");
-        string/*!*/ sep = "";
-        foreach (VCTrigger/*!*/ t in node.Triggers) {
-          Contract.Assert(t != null);
-          wr.Write(sep);
-          sep = ", ";
-          string/*!*/ sep2 = "";
-          foreach (VCExpr/*!*/ e in t.Exprs) {
-            Contract.Assert(e != null);
-            wr.Write(sep2);
-            sep2 = "+";
-            Print(e, wr);
-          }
-        }
-        wr.Write(" {0} ", "}");
-      }
-
-      Print(node.Body, wr);
-      wr.Write(")");
-      return true;
-    }
-    public bool Visit(VCExprLet node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      wr.Write("(Let ");
-
-      string/*!*/ sep = "";
-      foreach (VCExprLetBinding/*!*/ b in node) {
-        Contract.Assert(b != null);
-        wr.Write(sep);
-        sep = ", ";
-        Print(b.V, wr);
-        wr.Write(" = ");
-        Print(b.E, wr);
-      }
-      wr.Write(" ");
-
-      Print(node.Body, wr);
-      wr.Write(")");
-      return true;
-    }
-  }
-
-  public class VCExprOpPrinter : IVCExprOpVisitor<bool, TextWriter/*!*/> {
-    private VCExprPrinter/*!*/ ExprPrinter;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(ExprPrinter != null);
-    }
-
-
-    public VCExprOpPrinter(VCExprPrinter exprPrinter) {
-      Contract.Requires(exprPrinter != null);
-      this.ExprPrinter = exprPrinter;
-    }
-
-    private bool PrintNAry(string op, VCExprNAry node, TextWriter wr) {
-      Contract.Requires(wr != null);
-      Contract.Requires(node != null);
-      Contract.Requires(op != null);
-      wr.Write("({0}", op);
-      foreach (VCExpr/*!*/ arg in node) {
-        Contract.Assert(arg != null);
-        wr.Write(" ");
-        ExprPrinter.Print(arg, wr);
-      }
-      wr.Write(")");
-      return true;
-    }
-
-    public bool VisitNotOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("!", node, wr);
-    }
-    public bool VisitEqOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("==", node, wr);
-    }
-    public bool VisitNeqOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("!=", node, wr);
-    }
-    public bool VisitAndOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public bool VisitOrOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      Contract.Assert(false);
-      throw new cce.UnreachableException();
-    }
-    public bool VisitImpliesOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("Implies", node, wr);
-    }
-    public bool VisitDistinctOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("Distinct", node, wr);
-    }
-    public bool VisitLabelOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      VCExprLabelOp/*!*/ op = (VCExprLabelOp)node.Op;
-      Contract.Assert(op != null);
-      return PrintNAry("Label " + op.label, node, wr);
-    }
-    public bool VisitSelectOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("Select", node, wr);
-    }
-    public bool VisitStoreOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("Store", node, wr);
-    }
-    public bool VisitFloatAddOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.add", node, wr);
-    }
-    public bool VisitFloatSubOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.sub", node, wr);
-    }
-    public bool VisitFloatMulOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.mul", node, wr);
-    }
-    public bool VisitFloatDivOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.div", node, wr);
-    }
-    public bool VisitFloatRemOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.rem", node, wr);
-    }
-    public bool VisitFloatMinOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.min", node, wr);
-    }
-    public bool VisitFloatMaxOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.max", node, wr);
-    }
-    public bool VisitFloatLeqOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.leq", node, wr);
-    }
-    public bool VisitFloatLtOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.lt", node, wr);
-    }
-    public bool VisitFloatGeqOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.geq", node, wr);
-    }
-    public bool VisitFloatGtOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.gt", node, wr);
-    }
-    public bool VisitFloatEqOp(VCExprNAry node, TextWriter wr)
-    {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("fp.eq", node, wr);
-    }
-    public bool VisitBvOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("Bv", node, wr);
-    }
-    public bool VisitBvExtractOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("BvExtract", node, wr);
-    }
-    public bool VisitBvConcatOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("BvConcat", node, wr);
-    }
-    public bool VisitIfThenElseOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("if-then-else", node, wr);
-    }
-    public bool VisitCustomOp(VCExprNAry/*!*/ node, TextWriter/*!*/ wr) {
-      //Contract.Requires(node!=null);
-      //Contract.Requires(wr != null);
-      VCExprCustomOp op = (VCExprCustomOp)node.Op;
-      return PrintNAry(op.Name, node, wr);
-    }
-    public bool VisitAddOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      if (CommandLineOptions.Clo.ReflectAdd) {
-        return PrintNAry("Reflect$Add", node, wr);
-      } else {
-        return PrintNAry("+", node, wr);
-      }
-    }
-    public bool VisitSubOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("-", node, wr);
-    }
-    public bool VisitMulOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("*", node, wr);
-    }
-    public bool VisitDivOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("div", node, wr);
-    }
-    public bool VisitModOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("mod", node, wr);
-    }
-    public bool VisitRealDivOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("/", node, wr);
-    }
-    public bool VisitPowOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("**", node, wr);
-    }
-    public bool VisitLtOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("<", node, wr);
-    }
-    public bool VisitLeOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("<=", node, wr);
-    }
-    public bool VisitGtOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry(">", node, wr);
-    }
-    public bool VisitGeOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry(">=", node, wr);
-    }
-    public bool VisitSubtypeOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("<:", node, wr);
-    }
-    public bool VisitSubtype3Op(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("<::", node, wr);
-    }
-    public bool VisitToIntOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("int", node, wr);
-    }
-    public bool VisitToRealOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      return PrintNAry("real", node, wr);
-    }
-    public bool VisitBoogieFunctionOp(VCExprNAry node, TextWriter wr) {
-      //Contract.Requires(wr != null);
-      //Contract.Requires(node != null);
-      VCExprBoogieFunctionOp/*!*/ op = (VCExprBoogieFunctionOp)node.Op;
-      Contract.Assert(op != null);
-      return PrintNAry(op.Func.Name, node, wr);
-    }
-  }
-
-
-}
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using Microsoft.Basetypes;
+
+// A simple visitor for turning a VCExpr into a human-readable string
+// (S-expr syntax)
+
+namespace Microsoft.Boogie.VCExprAST {
+
+  public class VCExprPrinter : IVCExprVisitor<bool, TextWriter/*!*/> {
+    private VCExprOpPrinter OpPrinterVar = null;
+    private VCExprOpPrinter/*!*/ OpPrinter {
+      get {
+        Contract.Ensures(Contract.Result<VCExprOpPrinter>() != null);
+
+        if (OpPrinterVar == null)
+          OpPrinterVar = new VCExprOpPrinter(this);
+        return OpPrinterVar;
+      }
+    }
+
+    public void Print(VCExpr expr, TextWriter wr) {
+      Contract.Requires(wr != null);
+      Contract.Requires(expr != null);
+      expr.Accept<bool, TextWriter/*!*/>(this, wr);
+    }
+
+    public bool Visit(VCExprLiteral node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      if (node == VCExpressionGenerator.True) {
+        wr.Write("true");
+      } else if (node == VCExpressionGenerator.False) {
+        wr.Write("false");
+      } else if (node is VCExprIntLit) {
+        wr.Write(((VCExprIntLit)node).Val);
+      } else {
+        Contract.Assert(false);
+        throw new cce.UnreachableException();
+      }
+      return true;
+    }
+    public bool Visit(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      VCExprOp/*!*/ op = node.Op;
+      Contract.Assert(op != null);
+
+      if (op.Equals(VCExpressionGenerator.AndOp) ||
+          op.Equals(VCExpressionGenerator.OrOp)) {
+        // handle these operators without recursion
+
+        wr.Write("({0}",
+                 op.Equals(VCExpressionGenerator.AndOp) ? "And" : "Or");
+        IEnumerator/*!*/ enumerator = new VCExprNAryUniformOpEnumerator(node);
+        Contract.Assert(enumerator != null);
+        while (enumerator.MoveNext()) {
+          VCExprNAry naryExpr = enumerator.Current as VCExprNAry;
+          if (naryExpr == null || !naryExpr.Op.Equals(op)) {
+            wr.Write(" ");
+            Print(cce.NonNull((VCExpr/*!*/)enumerator.Current), wr);
+          }
+        }
+
+        wr.Write(")");
+
+        return true;
+      }
+
+      return node.Accept<bool, TextWriter/*!*/>(OpPrinter, wr);
+    }
+    public bool Visit(VCExprVar node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      wr.Write(node.Name);
+      return true;
+    }
+    public bool Visit(VCExprQuantifier node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      string/*!*/ quan = node.Quan == Quantifier.ALL ? "Forall" : "Exists";
+      Contract.Assert(quan != null);
+
+      wr.Write("({0} ", quan);
+
+      if (node.TypeParameters.Count > 0) {
+        wr.Write("<");
+        string/*!*/ sep = "";
+        foreach (TypeVariable/*!*/ v in node.TypeParameters) {
+          Contract.Assert(v != null);
+          wr.Write(sep);
+          sep = ", ";
+          wr.Write("{0}", v.Name);
+        }
+        wr.Write("> ");
+      }
+
+      if (node.BoundVars.Count > 0) {
+        string/*!*/ sep = "";
+        foreach (VCExprVar/*!*/ v in node.BoundVars) {
+          Contract.Assert(v != null);
+          wr.Write(sep);
+          sep = ", ";
+          Print(v, wr);
+        }
+        wr.Write(" ");
+      }
+
+      wr.Write(":: ");
+
+      if (node.Triggers.Count > 0) {
+        wr.Write("{0} ", "{");
+        string/*!*/ sep = "";
+        foreach (VCTrigger/*!*/ t in node.Triggers) {
+          Contract.Assert(t != null);
+          wr.Write(sep);
+          sep = ", ";
+          string/*!*/ sep2 = "";
+          foreach (VCExpr/*!*/ e in t.Exprs) {
+            Contract.Assert(e != null);
+            wr.Write(sep2);
+            sep2 = "+";
+            Print(e, wr);
+          }
+        }
+        wr.Write(" {0} ", "}");
+      }
+
+      Print(node.Body, wr);
+      wr.Write(")");
+      return true;
+    }
+    public bool Visit(VCExprLet node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      wr.Write("(Let ");
+
+      string/*!*/ sep = "";
+      foreach (VCExprLetBinding/*!*/ b in node) {
+        Contract.Assert(b != null);
+        wr.Write(sep);
+        sep = ", ";
+        Print(b.V, wr);
+        wr.Write(" = ");
+        Print(b.E, wr);
+      }
+      wr.Write(" ");
+
+      Print(node.Body, wr);
+      wr.Write(")");
+      return true;
+    }
+  }
+
+  public class VCExprOpPrinter : IVCExprOpVisitor<bool, TextWriter/*!*/> {
+    private VCExprPrinter/*!*/ ExprPrinter;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(ExprPrinter != null);
+    }
+
+
+    public VCExprOpPrinter(VCExprPrinter exprPrinter) {
+      Contract.Requires(exprPrinter != null);
+      this.ExprPrinter = exprPrinter;
+    }
+
+    private bool PrintNAry(string op, VCExprNAry node, TextWriter wr) {
+      Contract.Requires(wr != null);
+      Contract.Requires(node != null);
+      Contract.Requires(op != null);
+      wr.Write("({0}", op);
+      foreach (VCExpr/*!*/ arg in node) {
+        Contract.Assert(arg != null);
+        wr.Write(" ");
+        ExprPrinter.Print(arg, wr);
+      }
+      wr.Write(")");
+      return true;
+    }
+
+    public bool VisitNotOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("!", node, wr);
+    }
+    public bool VisitEqOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("==", node, wr);
+    }
+    public bool VisitNeqOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("!=", node, wr);
+    }
+    public bool VisitAndOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public bool VisitOrOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      Contract.Assert(false);
+      throw new cce.UnreachableException();
+    }
+    public bool VisitImpliesOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("Implies", node, wr);
+    }
+    public bool VisitDistinctOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("Distinct", node, wr);
+    }
+    public bool VisitLabelOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      VCExprLabelOp/*!*/ op = (VCExprLabelOp)node.Op;
+      Contract.Assert(op != null);
+      return PrintNAry("Label " + op.label, node, wr);
+    }
+    public bool VisitSelectOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("Select", node, wr);
+    }
+    public bool VisitStoreOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("Store", node, wr);
+    }
+    public bool VisitFloatAddOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.add", node, wr);
+    }
+    public bool VisitFloatSubOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.sub", node, wr);
+    }
+    public bool VisitFloatMulOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.mul", node, wr);
+    }
+    public bool VisitFloatDivOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.div", node, wr);
+    }
+    public bool VisitFloatRemOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.rem", node, wr);
+    }
+    public bool VisitFloatMinOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.min", node, wr);
+    }
+    public bool VisitFloatMaxOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.max", node, wr);
+    }
+    public bool VisitFloatLeqOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.leq", node, wr);
+    }
+    public bool VisitFloatLtOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.lt", node, wr);
+    }
+    public bool VisitFloatGeqOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.geq", node, wr);
+    }
+    public bool VisitFloatGtOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.gt", node, wr);
+    }
+    public bool VisitFloatEqOp(VCExprNAry node, TextWriter wr)
+    {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("fp.eq", node, wr);
+    }
+    public bool VisitBvOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("Bv", node, wr);
+    }
+    public bool VisitBvExtractOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("BvExtract", node, wr);
+    }
+    public bool VisitBvConcatOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("BvConcat", node, wr);
+    }
+    public bool VisitIfThenElseOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("if-then-else", node, wr);
+    }
+    public bool VisitCustomOp(VCExprNAry/*!*/ node, TextWriter/*!*/ wr) {
+      //Contract.Requires(node!=null);
+      //Contract.Requires(wr != null);
+      VCExprCustomOp op = (VCExprCustomOp)node.Op;
+      return PrintNAry(op.Name, node, wr);
+    }
+    public bool VisitAddOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      if (CommandLineOptions.Clo.ReflectAdd) {
+        return PrintNAry("Reflect$Add", node, wr);
+      } else {
+        return PrintNAry("+", node, wr);
+      }
+    }
+    public bool VisitSubOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("-", node, wr);
+    }
+    public bool VisitMulOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("*", node, wr);
+    }
+    public bool VisitDivOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("div", node, wr);
+    }
+    public bool VisitModOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("mod", node, wr);
+    }
+    public bool VisitRealDivOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("/", node, wr);
+    }
+    public bool VisitPowOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("**", node, wr);
+    }
+    public bool VisitLtOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("<", node, wr);
+    }
+    public bool VisitLeOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("<=", node, wr);
+    }
+    public bool VisitGtOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry(">", node, wr);
+    }
+    public bool VisitGeOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry(">=", node, wr);
+    }
+    public bool VisitSubtypeOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("<:", node, wr);
+    }
+    public bool VisitSubtype3Op(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("<::", node, wr);
+    }
+    public bool VisitToIntOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("int", node, wr);
+    }
+    public bool VisitToRealOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      return PrintNAry("real", node, wr);
+    }
+    public bool VisitBoogieFunctionOp(VCExprNAry node, TextWriter wr) {
+      //Contract.Requires(wr != null);
+      //Contract.Requires(node != null);
+      VCExprBoogieFunctionOp/*!*/ op = (VCExprBoogieFunctionOp)node.Op;
+      Contract.Assert(op != null);
+      return PrintNAry(op.Func.Name, node, wr);
+    }
+  }
+
+
+}
diff --git a/Source/VCExpr/VCExprASTVisitors.cs b/Source/VCExpr/VCExprASTVisitors.cs
index c81f69e5..a23aaf8a 100644
--- a/Source/VCExpr/VCExprASTVisitors.cs
+++ b/Source/VCExpr/VCExprASTVisitors.cs
@@ -1,1681 +1,1681 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation.  All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-using System;
-using System.Text;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using System.Linq;
-using Microsoft.Basetypes;
-
-// Some visitor skeletons for the VCExpression AST
-
-namespace Microsoft.Boogie.VCExprAST {
-  using Microsoft.Boogie;
-
-  [ContractClass(typeof(IVCExprVisitorContracts<,>))]
-  public interface IVCExprVisitor<Result, Arg> {
-    Result Visit(VCExprLiteral/*!*/ node, Arg arg);
-    Result Visit(VCExprNAry/*!*/ node, Arg arg);
-    Result Visit(VCExprVar/*!*/ node, Arg arg);
-    Result Visit(VCExprQuantifier/*!*/ node, Arg arg);
-    Result Visit(VCExprLet/*!*/ node, Arg arg);
-  }
-  [ContractClassFor(typeof(IVCExprVisitor<,>))]
-  public abstract class IVCExprVisitorContracts<Result, Arg> : IVCExprVisitor<Result, Arg> {
-    #region IVCExprVisitor Members
-
-    public Result Visit(VCExprLiteral node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result Visit(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result Visit(VCExprVar node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result Visit(VCExprQuantifier node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result Visit(VCExprLet node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    #endregion
-  }
-  [ContractClass(typeof(IVCExprOpVisitorContracts<,>))]
-  public interface IVCExprOpVisitor<Result, Arg> {
-    Result VisitNotOp(VCExprNAry node, Arg arg);
-    Result VisitEqOp(VCExprNAry node, Arg arg);
-    Result VisitNeqOp(VCExprNAry node, Arg arg);
-    Result VisitAndOp(VCExprNAry node, Arg arg);
-    Result VisitOrOp(VCExprNAry node, Arg arg);
-    Result VisitImpliesOp(VCExprNAry node, Arg arg);
-    Result VisitDistinctOp(VCExprNAry node, Arg arg);
-    Result VisitLabelOp(VCExprNAry node, Arg arg);
-    Result VisitSelectOp(VCExprNAry node, Arg arg);
-    Result VisitStoreOp(VCExprNAry node, Arg arg);
-    Result VisitFloatAddOp(VCExprNAry node, Arg arg);
-    Result VisitFloatSubOp(VCExprNAry node, Arg arg);
-    Result VisitFloatMulOp(VCExprNAry node, Arg arg);
-    Result VisitFloatDivOp(VCExprNAry node, Arg arg);
-    Result VisitFloatRemOp(VCExprNAry node, Arg arg);
-    Result VisitFloatMinOp(VCExprNAry node, Arg arg);
-    Result VisitFloatMaxOp(VCExprNAry node, Arg arg);
-    Result VisitFloatLeqOp(VCExprNAry node, Arg arg);
-    Result VisitFloatLtOp(VCExprNAry node, Arg arg);
-    Result VisitFloatGeqOp(VCExprNAry node, Arg arg);
-    Result VisitFloatGtOp(VCExprNAry node, Arg arg);
-    Result VisitFloatEqOp(VCExprNAry node, Arg arg);
-    Result VisitBvOp(VCExprNAry node, Arg arg);
-    Result VisitBvExtractOp(VCExprNAry node, Arg arg);
-    Result VisitBvConcatOp(VCExprNAry node, Arg arg);
-    Result VisitAddOp(VCExprNAry node, Arg arg);
-    Result VisitSubOp(VCExprNAry node, Arg arg);
-    Result VisitMulOp(VCExprNAry node, Arg arg);
-    Result VisitDivOp(VCExprNAry node, Arg arg);
-    Result VisitModOp(VCExprNAry node, Arg arg);
-    Result VisitRealDivOp(VCExprNAry node, Arg arg);
-    Result VisitPowOp(VCExprNAry node, Arg arg);
-    Result VisitLtOp(VCExprNAry node, Arg arg);
-    Result VisitLeOp(VCExprNAry node, Arg arg);
-    Result VisitGtOp(VCExprNAry node, Arg arg);
-    Result VisitGeOp(VCExprNAry node, Arg arg);
-    Result VisitSubtypeOp(VCExprNAry node, Arg arg);
-    Result VisitSubtype3Op(VCExprNAry node, Arg arg);
-    Result VisitToIntOp(VCExprNAry node, Arg arg);
-    Result VisitToRealOp(VCExprNAry node, Arg arg);
-    Result VisitBoogieFunctionOp(VCExprNAry node, Arg arg);
-    Result VisitIfThenElseOp(VCExprNAry node, Arg arg);
-    Result VisitCustomOp(VCExprNAry node, Arg arg);
-  }
-  [ContractClassFor(typeof(IVCExprOpVisitor<,>))]
-  public abstract class IVCExprOpVisitorContracts<Result, Arg> : IVCExprOpVisitor<Result, Arg> {
-    #region IVCExprOpVisitor<Result,Arg> Members
-
-    public Result VisitNotOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitEqOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitNeqOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitAndOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitOrOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitImpliesOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitDistinctOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitLabelOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitSelectOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitStoreOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatAddOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatSubOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatMulOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatDivOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatRemOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatMinOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatMaxOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatLeqOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatLtOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatGeqOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatGtOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitFloatEqOp(VCExprNAry node, Arg arg)
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitBvOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitBvExtractOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitBvConcatOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitAddOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitSubOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitMulOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitDivOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitModOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitRealDivOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitPowOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitLtOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitLeOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitGtOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitGeOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitSubtypeOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitSubtype3Op(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitToIntOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitToRealOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitToFloat(VCExprNAry node, Arg arg) //TODO: modify later
-    {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitBoogieFunctionOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitIfThenElseOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    public Result VisitCustomOp(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-
-    #endregion
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-  // Standard implementations that make it easier to create own visitors
-
-  // Simple traversal of VCExprs. The Visit implementations work
-  // recursively, apart from the implementation for VCExprNAry that
-  // uses a stack when applied to nested nodes with the same
-  // operator, e.g., (AND (AND (AND ...) ...) ...). This is necessary
-  // to avoid stack overflows
-
-
-  [ContractClass(typeof(TraversingVCExprVisitorContracts<,>))]
-  public abstract class TraversingVCExprVisitor<Result, Arg>
-                        : IVCExprVisitor<Result, Arg> {
-    protected abstract Result StandardResult(VCExpr/*!*/ node, Arg arg);
-
-    public Result Traverse(VCExpr node, Arg arg) {
-      Contract.Requires(node != null);
-      return node.Accept(this, arg);
-    }
-
-    public virtual Result Visit(VCExprLiteral node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-
-    public virtual Result Visit(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      Result res = StandardResult(node, arg);
-
-
-      if (node.TypeParamArity == 0 &&
-          (node.Op == VCExpressionGenerator.AndOp ||
-           node.Op == VCExpressionGenerator.OrOp ||
-           node.Op == VCExpressionGenerator.ImpliesOp)) {
-        Contract.Assert(node.Op != null);
-        VCExprOp op = node.Op;
-        HashSet<VCExprOp> ops = new HashSet<VCExprOp>();
-        ops.Add(VCExpressionGenerator.AndOp);
-        ops.Add(VCExpressionGenerator.OrOp);
-        ops.Add(VCExpressionGenerator.ImpliesOp);
-        IEnumerator enumerator = new VCExprNAryMultiUniformOpEnumerator(node, ops);
-        while (enumerator.MoveNext()) {
-          VCExpr expr = cce.NonNull((VCExpr)enumerator.Current);
-          VCExprNAry naryExpr = expr as VCExprNAry;
-          if (naryExpr == null || !ops.Contains(naryExpr.Op)) {
-            expr.Accept(this, arg);
-          } else {
-            StandardResult(expr, arg);
-          }
-        }
-      } else {
-        foreach (VCExpr e in node) {
-          Contract.Assert(e != null);
-          e.Accept(this, arg);
-        }
-      }
-
-      return res;
-    }
-
-    public virtual Result Visit(VCExprVar node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result Visit(VCExprQuantifier node, Arg arg) {
-      //Contract.Requires(node != null);
-      Result res = StandardResult(node, arg);
-      foreach (VCTrigger/*!*/ trigger in node.Triggers) {
-        Contract.Assert(trigger != null);
-        foreach (VCExpr/*!*/ expr in trigger.Exprs) {
-          Contract.Assert(expr != null);
-          expr.Accept(this, arg);
-        }
-      }
-      node.Body.Accept(this, arg);
-      return res;
-    }
-    public virtual Result Visit(VCExprLet node, Arg arg) {
-      //Contract.Requires(node != null);
-      Result res = StandardResult(node, arg);
-      // visit the bound expressions first
-      foreach (VCExprLetBinding/*!*/ binding in node) {
-        Contract.Assert(binding != null);
-        binding.E.Accept(this, arg);
-      }
-      node.Body.Accept(this, arg);
-      return res;
-    }
-  }
-  [ContractClassFor(typeof(TraversingVCExprVisitor<,>))]
-  public abstract class TraversingVCExprVisitorContracts<Result, Arg> : TraversingVCExprVisitor<Result, Arg> {
-    protected override Result StandardResult(VCExpr node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-  }
-  //////////////////////////////////////////////////////////////////////////////
-  // Class to iterate over the nodes of a tree of VCExprNAry. This is
-  // used to avoid handling such VCExpr recursively, which can easily
-  // lead to stack overflows
-
-  public class VCExprNAryEnumerator : IEnumerator {
-
-    private readonly VCExprNAry/*!*/ CompleteExpr;
-    private VCExpr CurrentExpr = null;
-    private readonly Stack<VCExpr/*!*/>/*!*/ ExprTodo = new Stack<VCExpr/*!*/>();
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(CompleteExpr != null);
-      Contract.Invariant(cce.NonNullElements(ExprTodo));
-    }
-
-    public VCExprNAryEnumerator(VCExprNAry completeExpr) {
-      Contract.Requires(completeExpr != null);
-      this.CompleteExpr = completeExpr;
-      Stack<VCExpr/*!*/>/*!*/ exprTodo = new Stack<VCExpr/*!*/>();
-      exprTodo.Push(completeExpr);
-      ExprTodo = exprTodo;
-    }
-
-    // Method using which a subclass can decide whether the
-    // subexpressions of an expression should be enumerated as well
-    // The default is to enumerate all nodes
-    protected virtual bool Descend(VCExprNAry expr) {
-      Contract.Requires(expr != null);
-      return true;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public bool MoveNext() {
-      if (ExprTodo.Count == 0)
-        return false;
-
-      CurrentExpr = ExprTodo.Pop();
-      VCExprNAry currentNAry = CurrentExpr as VCExprNAry;
-      if (currentNAry != null && Descend(currentNAry)) {
-        for (int i = currentNAry.Arity - 1; i >= 0; --i)
-          ExprTodo.Push(currentNAry[i]);
-      }
-
-      return true;
-    }
-
-    public object Current {
-      get {
-        return cce.NonNull(CurrentExpr);
-      }
-    }
-
-    public void Reset() {
-      ExprTodo.Clear();
-      CurrentExpr = null;
-      ExprTodo.Push(CompleteExpr);
-    }
-  }
-
-
-  //////////////////////////////////////////////////////////////////////////////
-
-  public class VCExprNAryUniformOpEnumerator : VCExprNAryEnumerator {
-    private readonly VCExprOp/*!*/ Op;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Op != null);
-    }
-
-    public VCExprNAryUniformOpEnumerator(VCExprNAry completeExpr)
-      : base(completeExpr) {
-      Contract.Requires(completeExpr != null);
-
-      this.Op = completeExpr.Op;
-    }
-    protected override bool Descend(VCExprNAry expr) {
-      //Contract.Requires(expr != null);
-      return expr.Op.Equals(Op) &&
-        // we never skip nodes with type parameters
-        // (those are too interesting ...)
-             expr.TypeParamArity == 0;
-    }
-  }
-
-  public class VCExprNAryMultiUniformOpEnumerator : VCExprNAryEnumerator
-  {
-      private readonly HashSet<VCExprOp> Ops;
-      [ContractInvariantMethod]
-      void ObjectInvariant()
-      {
-          Contract.Invariant(Ops != null);
-      }
-
-      public VCExprNAryMultiUniformOpEnumerator(VCExprNAry completeExpr, HashSet<VCExprOp> ops)
-          : base(completeExpr)
-      {
-          Contract.Requires(completeExpr != null);
-
-          this.Ops = ops;
-      }
-      protected override bool Descend(VCExprNAry expr)
-      {
-          return Ops.Contains(expr.Op) && expr.TypeParamArity == 0;
-      }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-  // Visitor that knows about the variables bound at each location in a VCExpr
-
-  public abstract class BoundVarTraversingVCExprVisitor<Result, Arg>
-                        : TraversingVCExprVisitor<Result, Arg> {
-    // Maps with all variables bound above a certain location in the VCExpression.
-    // The value of the map tells how often a particular symbol was bound
-    private readonly IDictionary<VCExprVar/*!*/, int>/*!*/ BoundTermVarsDict =
-      new Dictionary<VCExprVar/*!*/, int>();
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(BoundTermVarsDict != null);
-      Contract.Invariant(BoundTypeVarsDict != null);
-    }
-
-    private readonly IDictionary<TypeVariable/*!*/, int>/*!*/ BoundTypeVarsDict =
-      new Dictionary<TypeVariable/*!*/, int>();
-
-    protected ICollection<VCExprVar/*!*/>/*!*/ BoundTermVars {
-      get {
-        Contract.Ensures(cce.NonNullElements(Contract.Result<ICollection<VCExprVar>>()));
-        return BoundTermVarsDict.Keys;
-      }
-    }
-    protected ICollection<TypeVariable/*!*/>/*!*/ BoundTypeVars {
-      get {
-        Contract.Ensures(cce.NonNullElements(Contract.Result<ICollection<TypeVariable>>()));
-        return BoundTypeVarsDict.Keys;
-      }
-    }
-
-    private void AddBoundVar<T>(IDictionary<T, int> dict, T sym) {
-      Contract.Requires(sym != null);
-      Contract.Requires(dict != null);
-      int n;
-      if (dict.TryGetValue(sym, out n))
-        dict[sym] = n + 1;
-      else
-        dict[sym] = 1;
-    }
-
-    private void RemoveBoundVar<T>(IDictionary<T/*!*/, int/*!*/>/*!*/ dict, T sym) {
-      Contract.Requires(sym != null);
-      Contract.Requires(dict != null);
-      int n;
-      bool b = dict.TryGetValue(sym, out n);
-      Contract.Assert(b && n > 0);
-      if (n == 1)
-        dict.Remove(sym);
-      else
-        dict[sym] = n - 1;
-    }
-
-    public override Result Visit(VCExprQuantifier node, Arg arg) {
-      Contract.Requires(node != null);
-      // we temporarily add bound (term and type) variables to the
-      // corresponding lists
-      foreach (VCExprVar/*!*/ v in node.BoundVars) {
-        Contract.Assert(v != null);
-        AddBoundVar<VCExprVar>(BoundTermVarsDict, v);
-      }
-      foreach (TypeVariable/*!*/ v in node.TypeParameters) {
-        Contract.Assert(v != null);
-        AddBoundVar<TypeVariable>(BoundTypeVarsDict, v);
-      }
-
-      Result res;
-      try {
-        res = VisitAfterBinding(node, arg);
-      } finally {
-        foreach (VCExprVar/*!*/ v in node.BoundVars) {
-          Contract.Assert(v != null);
-          RemoveBoundVar<VCExprVar>(BoundTermVarsDict, v);
-        }
-        foreach (TypeVariable/*!*/ v in node.TypeParameters) {
-          Contract.Assert(v != null);
-          RemoveBoundVar<TypeVariable>(BoundTypeVarsDict, v);
-        }
-      }
-      return res;
-    }
-    public override Result Visit(VCExprLet node, Arg arg) {
-      Contract.Requires(node != null);
-      // we temporarily add bound term variables to the
-      // corresponding lists
-      foreach (VCExprVar/*!*/ v in node.BoundVars) {
-        Contract.Assert(v != null);
-        AddBoundVar<VCExprVar>(BoundTermVarsDict, v);
-      }
-
-      Result res;
-      try {
-        res = VisitAfterBinding(node, arg);
-      } finally {
-        foreach (VCExprVar/*!*/ v in node.BoundVars) {
-          Contract.Assert(v != null);
-          RemoveBoundVar<VCExprVar>(BoundTermVarsDict, v);
-        }
-      }
-      return res;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    // The possibility is provided to look at a (quantifier or let) node
-    // after its bound variables have been registered
-    // (when overriding the normal visit-methods, the node will be visited
-    // before the binding happens)
-
-    protected virtual Result VisitAfterBinding(VCExprQuantifier node, Arg arg) {
-      Contract.Requires(node != null);
-      return base.Visit(node, arg);
-    }
-
-    protected virtual Result VisitAfterBinding(VCExprLet node, Arg arg) {
-      Contract.Requires(node != null);
-      return base.Visit(node, arg);
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////////////
-  // General visitor for recursively collecting information in a VCExpr.
-  // As the visitor is not used anywhere for the time being, it maybe should
-  // be removed
-
-  [ContractClass(typeof(CollectingVCExprVisitorContracts<,>))]
-  public abstract class CollectingVCExprVisitor<Result, Arg>
-                        : IVCExprVisitor<Result, Arg> {
-    protected abstract Result CombineResults(List<Result>/*!*/ results, Arg arg);
-
-    public Result Collect(VCExpr node, Arg arg) {
-      Contract.Requires(node != null);
-      return node.Accept(this, arg);
-    }
-
-    public virtual Result Visit(VCExprLiteral node, Arg arg) {
-      //Contract.Requires(node != null);
-      return CombineResults(new List<Result>(), arg);
-    }
-    public virtual Result Visit(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      List<Result>/*!*/ results = new List<Result>();
-      foreach (VCExpr/*!*/ subnode in node) {
-        Contract.Assert(subnode != null);
-        results.Add(subnode.Accept(this, arg));
-      }
-      return CombineResults(results, arg);
-    }
-    public virtual Result Visit(VCExprVar node, Arg arg) {
-      //Contract.Requires(node != null);
-      return CombineResults(new List<Result>(), arg);
-    }
-    public virtual Result Visit(VCExprQuantifier node, Arg arg) {
-      //Contract.Requires(node != null);
-      List<Result>/*!*/ result = new List<Result>();
-      result.Add(node.Body.Accept(this, arg));
-      foreach (VCTrigger/*!*/ trigger in node.Triggers) {
-        Contract.Assert(trigger != null);
-        foreach (VCExpr/*!*/ expr in trigger.Exprs) {
-          Contract.Assert(expr != null);
-          result.Add(expr.Accept(this, arg));
-        }
-      }
-      return CombineResults(result, arg);
-    }
-    public virtual Result Visit(VCExprLet node, Arg arg) {
-      //Contract.Requires(node != null);
-      List<Result>/*!*/ results = new List<Result>();
-      // visit the bound expressions first
-      foreach (VCExprLetBinding/*!*/ binding in node) {
-        Contract.Assert(binding != null);
-        results.Add(binding.E.Accept(this, arg));
-      }
-      results.Add(node.Body.Accept(this, arg));
-      return CombineResults(results, arg);
-    }
-  }
-  [ContractClassFor(typeof(CollectingVCExprVisitor<,>))]
-  public abstract class CollectingVCExprVisitorContracts<Result, Arg> : CollectingVCExprVisitor<Result, Arg> {
-    protected override Result CombineResults(List<Result> results, Arg arg) {
-      Contract.Requires(results != null);
-      throw new NotImplementedException();
-    }
-  }
-  ////////////////////////////////////////////////////////////////////////////
-
-  public class SizeComputingVisitor : TraversingVCExprVisitor<bool, bool> {
-
-    private int Size = 0;
-
-    public static int ComputeSize(VCExpr expr) {
-      Contract.Requires(expr != null);
-      SizeComputingVisitor/*!*/ visitor = new SizeComputingVisitor();
-      visitor.Traverse(expr, true);
-      return visitor.Size;
-    }
-
-    protected override bool StandardResult(VCExpr node, bool arg) {
-      //Contract.Requires(node != null);
-      Size = Size + 1;
-      return true;
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////////////
-
-  // Collect all free term and type variables in a VCExpr. Type variables
-  // can occur free either in the types of bound variables, or in the type
-  // parameters of VCExprNAry.
-
-  // the result and argument (of type bool) are not used currently
-  public class FreeVariableCollector : BoundVarTraversingVCExprVisitor<bool, bool> {
-    public readonly Dictionary<VCExprVar/*!*/, object>/*!*/ FreeTermVars = new Dictionary<VCExprVar/*!*/, object>();
-    public readonly List<TypeVariable/*!*/>/*!*/ FreeTypeVars = new List<TypeVariable/*!*/>();
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(FreeTermVars != null && Contract.ForAll(FreeTermVars, entry => entry.Key != null));
-      Contract.Invariant(cce.NonNullElements(FreeTypeVars));
-    }
-
-
-    // not used
-    protected override bool StandardResult(VCExpr node, bool arg) {
-      //Contract.Requires(node != null);
-      return true;
-    }
-
-    public static Dictionary<VCExprVar/*!*/, object>/*!*/ FreeTermVariables(VCExpr node) {
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<Dictionary<VCExprVar, object>>() != null);
-      Contract.Ensures(Contract.ForAll(Contract.Result<Dictionary<VCExprVar, object>>(), ftv => ftv.Key != null));
-      FreeVariableCollector collector = new FreeVariableCollector();
-      collector.Traverse(node, true);
-      return collector.FreeTermVars;
-    }
-
-    public static List<TypeVariable/*!*/>/*!*/ FreeTypeVariables(VCExpr node) {
-      Contract.Requires(node != null);
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<TypeVariable>>()));
-      FreeVariableCollector collector = new FreeVariableCollector();
-      collector.Traverse(node, true);
-      return collector.FreeTypeVars;
-    }
-
-    public void Reset() {
-      FreeTermVars.Clear();
-      FreeTypeVars.Clear();
-    }
-
-    public void Collect(VCExpr node) {
-      Contract.Requires(node != null);
-      Traverse(node, true);
-    }
-
-    public void Collect(Type type) {
-      Contract.Requires(type != null);
-      AddTypeVariables(type.FreeVariables.ToList());
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-
-    private void CollectTypeVariables(IEnumerable<VCExprVar/*!*/>/*!*/ boundVars) {
-      Contract.Requires(cce.NonNullElements(boundVars));
-      foreach (VCExprVar/*!*/ var in boundVars) {
-        Contract.Assert(var != null);
-        Collect(var.Type);
-      }
-    }
-
-    private void AddTypeVariables(IEnumerable<TypeVariable/*!*/>/*!*/ typeVars) {
-      Contract.Requires(cce.NonNullElements(typeVars));
-      foreach (TypeVariable/*!*/ tvar in typeVars) {
-        Contract.Assert(tvar != null);
-        if (!BoundTypeVars.Contains(tvar) && !FreeTypeVars.Contains(tvar))
-          FreeTypeVars.Add(tvar);
-      }
-    }
-
-    public override bool Visit(VCExprVar node, bool arg) {
-      Contract.Requires(node != null);
-      if (!BoundTermVars.Contains(node) && !FreeTermVars.ContainsKey(node)) {
-        FreeTermVars.Add(node, null);
-        Collect(node.Type);
-      }
-      return true;
-    }
-
-    public override bool Visit(VCExprNAry node, bool arg) {
-      Contract.Requires(node != null);
-      foreach (Type/*!*/ t in node.TypeArguments) {
-        Contract.Assert(t != null);
-        Collect(t);
-      }
-      return base.Visit(node, arg);
-    }
-
-    protected override bool VisitAfterBinding(VCExprQuantifier node, bool arg) {
-      //Contract.Requires(node != null);
-      CollectTypeVariables(node.BoundVars);
-      return base.VisitAfterBinding(node, arg);
-    }
-
-    protected override bool VisitAfterBinding(VCExprLet node, bool arg) {
-      //Contract.Requires(node != null);
-      CollectTypeVariables(node.BoundVars);
-      return base.VisitAfterBinding(node, arg);
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////////////
-  // Framework for mutating VCExprs
-
-  // The Visit implementations in the following visitor work
-  // recursively, apart from the implementation for VCExprNAry that
-  // uses its own stack when applied to nested nodes with the same
-  // operator, e.g., (AND (AND (AND ...) ...) ...). This is necessary
-  // to avoid stack overflows (like in TraversingVCExprVisitor)
-
-  public abstract class MutatingVCExprVisitor<Arg>
-                        : IVCExprVisitor<VCExpr/*!*/, Arg> {
-    protected readonly VCExpressionGenerator/*!*/ Gen;
-    [ContractInvariantMethod]
-    void ObjectInvariant() {
-      Contract.Invariant(Gen != null);
-    }
-
-
-    public MutatingVCExprVisitor(VCExpressionGenerator gen) {
-      Contract.Requires(gen != null);
-      this.Gen = gen;
-    }
-
-    public VCExpr Mutate(VCExpr expr, Arg arg) {
-      Contract.Requires(expr != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return expr.Accept(this, arg);
-    }
-
-    public List<VCExpr/*!*/>/*!*/ MutateSeq(IEnumerable<VCExpr/*!*/>/*!*/ exprs, Arg arg) {
-      Contract.Requires(cce.NonNullElements(exprs));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
-      List<VCExpr/*!*/>/*!*/ res = new List<VCExpr/*!*/>();
-      foreach (VCExpr/*!*/ expr in exprs) {
-        Contract.Assert(expr != null);
-        res.Add(expr.Accept(this, arg));
-      }
-      return res;
-    }
-
-    private List<VCExpr/*!*/>/*!*/ MutateList(List<VCExpr/*!*/>/*!*/ exprs, Arg arg) {
-      Contract.Requires(cce.NonNullElements(exprs));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
-      bool changed = false;
-      List<VCExpr/*!*/>/*!*/ res = new List<VCExpr/*!*/>();
-      foreach (VCExpr/*!*/ expr in exprs) {
-        Contract.Assert(expr != null);
-        VCExpr/*!*/ newExpr = expr.Accept(this, arg);
-        if (!Object.ReferenceEquals(expr, newExpr))
-          changed = true;
-        res.Add(newExpr);
-      }
-      if (!changed)
-        return exprs;
-      return res;
-    }
-
-    public virtual VCExpr Visit(VCExprLiteral node, Arg arg) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return node;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    // Special element used to mark the positions in the todo-stack where
-    // results have to be popped from the result-stack.
-    private static readonly VCExpr/*!*/ CombineResultsMarker = new VCExprLiteral(Type.Bool);
-
-    // The todo-stack contains records of the shape
-    //
-    //     arg0
-    //     arg1
-    //     arg2
-    //     ...
-    //     CombineResultsMarker
-    //     f(arg0, arg1, arg2, ...)               (the original expression)
-
-    private readonly Stack<VCExpr/*!*/>/*!*/ NAryExprTodoStack = new Stack<VCExpr/*!*/>();
-    private readonly Stack<VCExpr/*!*/>/*!*/ NAryExprResultStack = new Stack<VCExpr/*!*/>();
-    [ContractInvariantMethod]
-    void ObjectInvarianta() {
-      Contract.Invariant(cce.NonNullElements(NAryExprResultStack));
-      Contract.Invariant(cce.NonNullElements(NAryExprTodoStack));
-    }
-
-
-    private void PushTodo(VCExprNAry exprTodo) {
-      Contract.Requires(exprTodo != null);
-      NAryExprTodoStack.Push(exprTodo);
-      NAryExprTodoStack.Push(CombineResultsMarker);
-      for (int i = exprTodo.Arity - 1; i >= 0; --i)
-        NAryExprTodoStack.Push(exprTodo[i]);
-    }
-
-    public virtual bool AvoidVisit(VCExprNAry node, Arg arg)
-    {
-        return true;
-    }
-
-    public virtual VCExpr Visit(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      int initialStackSize = NAryExprTodoStack.Count;
-      int initialResultStackSize = NAryExprResultStack.Count;
-
-      PushTodo(node);
-
-      while (NAryExprTodoStack.Count > initialStackSize) {
-        VCExpr/*!*/ subExpr = NAryExprTodoStack.Pop();
-        Contract.Assert(subExpr != null);
-
-        if (Object.ReferenceEquals(subExpr, CombineResultsMarker)) {
-          // assemble a result
-          VCExprNAry/*!*/ originalExpr = (VCExprNAry)NAryExprTodoStack.Pop();
-          Contract.Assert(originalExpr != null);
-          VCExprOp/*!*/ op = originalExpr.Op;
-          bool changed = false;
-          List<VCExpr/*!*/>/*!*/ newSubExprs = new List<VCExpr/*!*/>();
-
-          for (int i = op.Arity - 1; i >= 0; --i) {
-            VCExpr/*!*/ nextSubExpr = NAryExprResultStack.Pop();
-            Contract.Assert(nextSubExpr != null);
-            if (!Object.ReferenceEquals(nextSubExpr, originalExpr[i]))
-              changed = true;
-            newSubExprs.Insert(0, nextSubExpr);
-          }
-
-          NAryExprResultStack.Push(UpdateModifiedNode(originalExpr, newSubExprs, changed, arg));
-          //
-        } else {
-          //
-            VCExprNAry narySubExpr = subExpr as VCExprNAry;
-          if (narySubExpr != null && this.AvoidVisit(narySubExpr, arg) &&
-            // as in VCExprNAryUniformOpEnumerator, all expressions with
-            // type parameters are allowed to be inspected more closely
-              narySubExpr.TypeParamArity == 0) {
-            PushTodo(narySubExpr);
-          } else {
-            NAryExprResultStack.Push(subExpr.Accept(this, arg));
-          }
-          //
-        }
-      }
-
-      Contract.Assert(NAryExprTodoStack.Count == initialStackSize && NAryExprResultStack.Count == initialResultStackSize + 1);
-      return NAryExprResultStack.Pop();
-    }
-
-    protected virtual VCExpr/*!*/ UpdateModifiedNode(VCExprNAry/*!*/ originalNode, List<VCExpr/*!*/>/*!*/ newSubExprs, // has any of the subexpressions changed? 
-                                                 bool changed,
-                                                 Arg arg) {
-      Contract.Requires(cce.NonNullElements(newSubExprs));
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      if (changed)
-        return Gen.Function(originalNode.Op,
-                            newSubExprs, originalNode.TypeArguments);
-      else
-        return originalNode;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    public virtual VCExpr Visit(VCExprVar node, Arg arg) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      return node;
-    }
-
-    protected List<VCTrigger/*!*/>/*!*/ MutateTriggers(List<VCTrigger/*!*/>/*!*/ triggers, Arg arg) {
-      Contract.Requires(cce.NonNullElements(triggers));
-      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCTrigger>>()));
-      List<VCTrigger/*!*/>/*!*/ newTriggers = new List<VCTrigger/*!*/>();
-      bool changed = false;
-      foreach (VCTrigger/*!*/ trigger in triggers) {
-        Contract.Assert(trigger != null);
-        List<VCExpr/*!*/>/*!*/ exprs = trigger.Exprs;
-        List<VCExpr/*!*/>/*!*/ newExprs = MutateList(exprs, arg);
-
-        if (Object.ReferenceEquals(exprs, newExprs)) {
-          newTriggers.Add(trigger);
-        } else {
-          newTriggers.Add(Gen.Trigger(trigger.Pos, newExprs));
-          changed = true;
-        }
-      }
-      if (!changed)
-        return triggers;
-      return newTriggers;
-    }
-
-    public virtual VCExpr Visit(VCExprQuantifier node, Arg arg) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      bool changed = false;
-
-      VCExpr/*!*/ body = node.Body;
-      Contract.Assert(body != null);
-      VCExpr/*!*/ newbody = body.Accept(this, arg);
-      Contract.Assert(newbody != null);
-      if (!Object.ReferenceEquals(body, newbody))
-        changed = true;
-
-      // visit the trigger expressions as well
-      List<VCTrigger/*!*/>/*!*/ triggers = node.Triggers;
-      Contract.Assert(cce.NonNullElements(triggers));
-      List<VCTrigger/*!*/>/*!*/ newTriggers = MutateTriggers(triggers, arg);
-      Contract.Assert(cce.NonNullElements(newTriggers));
-      if (!Object.ReferenceEquals(triggers, newTriggers))
-        changed = true;
-
-      if (!changed)
-        return node;
-      return Gen.Quantify(node.Quan, node.TypeParameters, node.BoundVars,
-                          newTriggers, node.Infos, newbody);
-    }
-
-    public virtual VCExpr Visit(VCExprLet node, Arg arg) {
-      //Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      bool changed = false;
-
-      VCExpr/*!*/ body = node.Body;
-      VCExpr/*!*/ newbody = body.Accept(this, arg);
-      if (!Object.ReferenceEquals(body, newbody))
-        changed = true;
-
-      List<VCExprLetBinding/*!*/>/*!*/ newbindings = new List<VCExprLetBinding/*!*/>();
-      for (int i = 0; i < node.Length; ++i) {
-        VCExprLetBinding/*!*/ binding = node[i];
-        Contract.Assert(binding != null);
-        VCExpr/*!*/ e = binding.E;
-        VCExpr/*!*/ newE = e.Accept(this, arg);
-        if (Object.ReferenceEquals(e, newE)) {
-          newbindings.Add(binding);
-        } else {
-          changed = true;
-          newbindings.Add(Gen.LetBinding(binding.V, newE));
-        }
-      }
-
-      if (!changed)
-        return node;
-      return Gen.Let(newbindings, newbody);
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////////////
-  // Substitutions and a visitor for applying substitutions. A substitution can
-  // substitute both type variables and term variables
-
-  public class VCExprSubstitution {
-    private readonly List<IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/>/*!*/ TermSubsts;
-    [ContractInvariantMethod]
-    void TermSubstsInvariantMethod() {
-      Contract.Invariant(TermSubsts != null && Contract.ForAll(TermSubsts, i => cce.NonNullDictionaryAndValues(i)));
-    }
-    private readonly List<IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/>/*!*/ TypeSubsts;
-    [ContractInvariantMethod]
-    void TypeSubstsInvariantMethod() {
-      Contract.Invariant(TermSubsts != null && Contract.ForAll(TypeSubsts, i => cce.NonNullDictionaryAndValues(i)));
-    }
-
-    public VCExprSubstitution(IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/ termSubst, IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ typeSubst) {
-      Contract.Requires(cce.NonNullDictionaryAndValues(termSubst));
-      Contract.Requires(cce.NonNullDictionaryAndValues(typeSubst));
-      List<IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/>/*!*/ termSubsts =
-        new List<IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/>();
-      termSubsts.Add(termSubst);
-      List<IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/>/*!*/ typeSubsts =
-        new List<IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/>();
-      typeSubsts.Add(typeSubst);
-      this.TermSubsts = termSubsts;
-      this.TypeSubsts = typeSubsts;
-    }
-
-    public VCExprSubstitution()
-      : this(new Dictionary<VCExprVar/*!*/, VCExpr/*!*/>(), new Dictionary<TypeVariable/*!*/, Type/*!*/>()) {
-
-    }
-
-    public void PushScope() {
-      TermSubsts.Add(new Dictionary<VCExprVar/*!*/, VCExpr/*!*/>());
-      TypeSubsts.Add(new Dictionary<TypeVariable/*!*/, Type/*!*/>());
-    }
-
-    public void PopScope() {
-      TermSubsts.RemoveAt(TermSubsts.Count - 1);
-      TypeSubsts.RemoveAt(TypeSubsts.Count - 1);
-    }
-
-    public VCExpr this[VCExprVar/*!*/ var] {
-      get {
-        Contract.Requires(var != null);
-        VCExpr res;
-        for (int i = TermSubsts.Count - 1; i >= 0; --i) {
-          if (TermSubsts[i].TryGetValue(var, out res))
-            return res;
-        }
-        return null;
-      }
-      set {
-        TermSubsts[TermSubsts.Count - 1][var] = cce.NonNull(value);
-      }
-    }
-
-    public Type this[TypeVariable/*!*/ var] {
-      get {
-        Contract.Requires(var != null);
-        Type res;
-        for (int i = TypeSubsts.Count - 1; i >= 0; --i) {
-          if (TypeSubsts[i].TryGetValue(var, out res))
-            return res;
-        }
-        return null;
-      }
-      set {
-        TypeSubsts[TypeSubsts.Count - 1][var] = cce.NonNull(value);
-      }
-    }
-
-    public bool ContainsKey(VCExprVar var) {
-      Contract.Requires(var != null);
-      return this[var] != null;
-    }
-
-    public bool ContainsKey(TypeVariable var) {
-      Contract.Requires(var != null);
-      return this[var] != null;
-    }
-
-    public bool TermSubstIsEmpty {
-      get {
-        return TermSubsts.All(dict => !dict.Any());
-      }
-    }
-
-    public bool TypeSubstIsEmpty {
-      get {
-        return TypeSubsts.All(dict => !dict.Any());
-      }
-    }
-
-    public IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ ToTypeSubst {
-      get {
-        Contract.Ensures(cce.NonNullDictionaryAndValues(Contract.Result<IDictionary<TypeVariable, Type>>()));
-        IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ res = new Dictionary<TypeVariable/*!*/, Type/*!*/>();
-        foreach (IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ dict in TypeSubsts) {
-          foreach (KeyValuePair<TypeVariable/*!*/, Type/*!*/> pair in dict) {
-            Contract.Assert(cce.NonNullElements(pair));
-            // later ones overwrite earlier ones
-            res[pair.Key] = pair.Value;
-          }
-        }
-        return res;
-      }
-    }
-
-    // the variables that are not mapped to themselves
-    public IEnumerable<VCExprVar/*!*/>/*!*/ TermDomain {
-      get {
-        Contract.Ensures(cce.NonNullElements(Contract.Result<IEnumerable<VCExprVar>>()));
-        HashSet<VCExprVar/*!*/>/*!*/ domain = new HashSet<VCExprVar/*!*/>();
-        foreach (IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/ dict in TermSubsts) {
-          Contract.Assert(dict != null);
-          foreach (VCExprVar/*!*/ var in dict.Keys) {
-            Contract.Assert(var != null);
-            if (!var.Equals(this[var]))
-              domain.Add(var);
-          }
-        }
-        return domain;
-      }
-    }
-
-    // the variables that are not mapped to themselves
-    public IEnumerable<TypeVariable/*!*/>/*!*/ TypeDomain {
-      get {
-        Contract.Ensures(cce.NonNullElements(Contract.Result<IEnumerable<TypeVariable>>()));
-        HashSet<TypeVariable/*!*/>/*!*/ domain = new HashSet<TypeVariable/*!*/>();
-        foreach (IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ dict in TypeSubsts) {
-          Contract.Assert(dict != null);
-          foreach (TypeVariable/*!*/ var in dict.Keys) {
-            Contract.Assert(var != null);
-            if (!var.Equals(this[var]))
-              domain.Add(var);
-          }
-        }
-        return domain;
-      }
-    }
-
-    public FreeVariableCollector/*!*/ Codomains {
-      get {
-        Contract.Ensures(Contract.Result<FreeVariableCollector>() != null);
-
-        FreeVariableCollector/*!*/ coll = new FreeVariableCollector();
-        foreach (VCExprVar/*!*/ var in TermDomain)
-          coll.Collect(cce.NonNull(this)[var]);
-        foreach (TypeVariable/*!*/ var in TypeDomain)
-          coll.Collect(cce.NonNull(this)[var]);
-        return coll;
-      }
-    }
-
-    public VCExprSubstitution Clone() {
-      Contract.Ensures(Contract.Result<VCExprSubstitution>() != null);
-      VCExprSubstitution/*!*/ res = new VCExprSubstitution();
-      foreach (IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/ dict in TermSubsts)
-        res.TermSubsts.Add(HelperFuns.Clone(dict));
-      foreach (IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ dict in TypeSubsts)
-        res.TypeSubsts.Add(HelperFuns.Clone(dict));
-      return res;
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////////////
-
-  public class SubstitutingVCExprVisitor
-               : MutatingVCExprVisitor<VCExprSubstitution/*!*/> {
-    public SubstitutingVCExprVisitor(VCExpressionGenerator gen)
-      : base(gen) {
-      Contract.Requires(gen != null);
-
-    }
-
-    // when descending across a binder, we have to check that no collisions
-    // or variable capture can occur. if this might happen, we replace the
-    // term and type variables bound by the binder with fresh variables
-    private bool CollisionPossible(IEnumerable<TypeVariable/*!*/>/*!*/ typeParams, IEnumerable<VCExprVar/*!*/>/*!*/ boundVars, VCExprSubstitution/*!*/ substitution) {
-      Contract.Requires(cce.NonNullElements(typeParams));
-      Contract.Requires(cce.NonNullElements(boundVars));
-      Contract.Requires(substitution != null);
-      // variables can be shadowed by a binder
-      if (typeParams.Any(var => substitution.ContainsKey(var)) ||
-          boundVars.Any(var => substitution.ContainsKey(var)))
-        return true;
-      // compute the codomain of the substitution
-      FreeVariableCollector coll = substitution.Codomains;
-      Contract.Assert(coll != null);
-      // variables could be captured when applying the substitution
-      return typeParams.Any(var => coll.FreeTypeVars.Contains(var)) ||
-             boundVars.Any(var => coll.FreeTermVars.ContainsKey(var));
-    }
-
-    // can be overwritten if names of bound variables are to be changed
-    protected virtual string ChooseNewVariableName(string oldName) {
-      Contract.Requires(oldName != null);
-      Contract.Ensures(Contract.Result<string>() != null);
-      return oldName;
-    }
-
-    // handle type parameters in VCExprNAry
-    protected override VCExpr/*!*/ UpdateModifiedNode(VCExprNAry/*!*/ originalNode, List<VCExpr/*!*/>/*!*/ newSubExprs, bool changed, VCExprSubstitution/*!*/ substitution) {
-      //Contract.Requires(originalNode != null);
-      //Contract.Requires(cce.NonNullElements(newSubExprs));
-      //Contract.Requires(substitution != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      List<Type/*!*/>/*!*/ typeParams = new List<Type/*!*/>();
-      foreach (Type/*!*/ t in originalNode.TypeArguments) {
-        Contract.Assert(t != null);
-        Type/*!*/ newType = t.Substitute(substitution.ToTypeSubst);
-        Contract.Assert(newType != null);
-        if (!ReferenceEquals(t, newType))
-          changed = true;
-        typeParams.Add(newType);
-      }
-      if (changed)
-        return Gen.Function(originalNode.Op, newSubExprs, typeParams);
-      else
-        return originalNode;
-    }
-
-    public override VCExpr/*!*/ Visit(VCExprQuantifier/*!*/ node, VCExprSubstitution/*!*/ substitution) {
-      Contract.Requires(node != null);
-      Contract.Requires(substitution != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      // the default is to refresh bound variables only if necessary
-      // because of collisions
-      return Visit(node, substitution, false);
-    }
-
-    public VCExpr/*!*/ Visit(VCExprQuantifier/*!*/ node, VCExprSubstitution/*!*/ substitution, bool refreshBoundVariables) {
-      Contract.Requires(node != null);
-      Contract.Requires(substitution != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-
-      substitution.PushScope();
-      try {
-
-        List<TypeVariable/*!*/>/*!*/ typeParams = node.TypeParameters;
-        Contract.Assert(cce.NonNullElements(typeParams));
-        bool refreshAllVariables = refreshBoundVariables ||
-                                   CollisionPossible(node.TypeParameters, node.BoundVars, substitution);
-        if (refreshAllVariables) {
-          // we introduce fresh type variables to ensure that none gets captured
-          typeParams = new List<TypeVariable/*!*/>();
-          foreach (TypeVariable/*!*/ var in node.TypeParameters) {
-            Contract.Assert(var != null);
-            TypeVariable/*!*/ freshVar =
-              new TypeVariable(Token.NoToken, ChooseNewVariableName(var.Name));
-            Contract.Assert(freshVar != null);
-            typeParams.Add(freshVar);
-            substitution[var] = freshVar;
-            // this might overwrite other elements of the substitution, deliberately
-          }
-        }
-
-        List<VCExprVar/*!*/>/*!*/ boundVars = node.BoundVars;
-        Contract.Assert(cce.NonNullElements(boundVars));
-        if (refreshAllVariables || !substitution.TypeSubstIsEmpty) {
-          // collisions are possible, or we also substitute type variables. in this case
-          // the bound term variables have to be replaced with fresh variables with the
-          // right types
-          boundVars = new List<VCExprVar/*!*/>();
-          IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ typeSubst = substitution.ToTypeSubst;
-          Contract.Assert(cce.NonNullDictionaryAndValues(typeSubst));
-          foreach (VCExprVar/*!*/ var in node.BoundVars) {
-            Contract.Assert(var != null);
-            VCExprVar/*!*/ freshVar =
-              Gen.Variable(ChooseNewVariableName(var.Name),
-                           var.Type.Substitute(typeSubst));
-            Contract.Assert(freshVar != null);
-            boundVars.Add(freshVar);
-            substitution[var] = freshVar;
-            // this might overwrite other elements of the substitution, deliberately
-          }
-        }
-
-        List<VCTrigger/*!*/>/*!*/ newTriggers = new List<VCTrigger/*!*/>();
-        foreach (VCTrigger/*!*/ trigger in node.Triggers) {
-          Contract.Assert(trigger != null);
-          newTriggers.Add(Gen.Trigger(trigger.Pos, MutateSeq(trigger.Exprs, substitution)));
-        }
-
-        VCExpr/*!*/ newBody = Mutate(node.Body, substitution);
-        Contract.Assert(newBody != null);
-
-        return Gen.Quantify(node.Quan, typeParams, boundVars,
-                            newTriggers, node.Infos, newBody);
-
-      } finally {
-        substitution.PopScope();
-      }
-    }
-
-    public override VCExpr Visit(VCExprVar node, VCExprSubstitution substitution) {
-      Contract.Requires(substitution != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      VCExpr res = substitution[node];
-      if (res != null)
-        return res;
-      return node;
-    }
-
-    public override VCExpr Visit(VCExprLet node, VCExprSubstitution substitution) {
-      Contract.Requires(substitution != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      // the default is to refresh bound variables only if necessary
-      // because of collisions
-      return Visit(node, substitution, false);
-    }
-
-    public VCExpr Visit(VCExprLet node, VCExprSubstitution substitution, bool refreshBoundVariables) {
-      Contract.Requires(substitution != null);
-      Contract.Requires(node != null);
-      Contract.Ensures(Contract.Result<VCExpr>() != null);
-      // let-expressions do not have type parameters (fortunately ...)
-      substitution.PushScope();
-      try {
-
-        bool refreshAllVariables =
-          refreshBoundVariables ||
-          !substitution.TypeSubstIsEmpty ||
-          CollisionPossible(new List<TypeVariable/*!*/>(), node.BoundVars, substitution);
-
-        List<VCExprVar/*!*/>/*!*/ newBoundVars = node.BoundVars;
-        Contract.Assert(cce.NonNullElements(newBoundVars));
-        if (refreshAllVariables) {
-          // collisions are possible, or we also substitute type variables. in this case
-          // the bound term variables have to be replaced with fresh variables with the
-          // right types
-          newBoundVars = new List<VCExprVar/*!*/>();
-          IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ typeSubst = substitution.ToTypeSubst;
-          Contract.Assert(cce.NonNullDictionaryAndValues(typeSubst));
-          foreach (VCExprVar/*!*/ var in node.BoundVars) {
-            Contract.Assert(var != null);
-            VCExprVar/*!*/ freshVar =
-              Gen.Variable(ChooseNewVariableName(var.Name),
-                           var.Type.Substitute(typeSubst));
-            Contract.Assert(freshVar != null);
-            newBoundVars.Add(freshVar);
-            substitution[var] = freshVar;
-            // this might overwrite other elements of the substitution, deliberately
-          }
-        }
-
-        List<VCExprLetBinding/*!*/>/*!*/ newbindings = new List<VCExprLetBinding/*!*/>();
-        for (int i = 0; i < node.Length; ++i) {
-          VCExprLetBinding/*!*/ binding = node[i];
-          Contract.Assert(binding != null);
-          newbindings.Add(Gen.LetBinding(newBoundVars[i], Mutate(binding.E, substitution)));
-        }
-
-        VCExpr/*!*/ newBody = Mutate(node.Body, substitution);
-        Contract.Assert(newBody != null);
-        return Gen.Let(newbindings, newBody);
-
-      } finally {
-        substitution.PopScope();
-      }
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////////////
-  [ContractClassFor(typeof(StandardVCExprOpVisitor<,>))]
-  public abstract class StandardVCExprOpVisitorContracts<Result, Arg> : StandardVCExprOpVisitor<Result, Arg> {
-    protected override Result StandardResult(VCExprNAry node, Arg arg) {
-      Contract.Requires(node != null);
-      throw new NotImplementedException();
-    }
-  }
-
-
-  [ContractClass(typeof(StandardVCExprOpVisitorContracts<,>))]
-  public abstract class StandardVCExprOpVisitor<Result, Arg>
-                        : IVCExprOpVisitor<Result, Arg> {
-    protected abstract Result StandardResult(VCExprNAry/*!*/ node, Arg arg);
-
-    public virtual Result VisitNotOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitEqOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitNeqOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitAndOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitOrOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitImpliesOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitDistinctOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitLabelOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitSelectOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitStoreOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatAddOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatSubOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatMulOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatDivOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatRemOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatMinOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatMaxOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatLeqOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatLtOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatGeqOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatGtOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitFloatEqOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitBvOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitBvExtractOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitBvConcatOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitIfThenElseOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitCustomOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitAddOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitSubOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitMulOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitDivOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitModOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitRealDivOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitPowOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitLtOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitLeOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitGtOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitGeOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitSubtypeOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitSubtype3Op(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitToIntOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitToRealOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitToFloatOp(VCExprNAry node, Arg arg)
-    {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-    public virtual Result VisitBoogieFunctionOp(VCExprNAry node, Arg arg) {
-      //Contract.Requires(node != null);
-      return StandardResult(node, arg);
-    }
-  }
-
+//-----------------------------------------------------------------------------
+//
+// Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//-----------------------------------------------------------------------------
+using System;
+using System.Text;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.Linq;
+using Microsoft.Basetypes;
+
+// Some visitor skeletons for the VCExpression AST
+
+namespace Microsoft.Boogie.VCExprAST {
+  using Microsoft.Boogie;
+
+  [ContractClass(typeof(IVCExprVisitorContracts<,>))]
+  public interface IVCExprVisitor<Result, Arg> {
+    Result Visit(VCExprLiteral/*!*/ node, Arg arg);
+    Result Visit(VCExprNAry/*!*/ node, Arg arg);
+    Result Visit(VCExprVar/*!*/ node, Arg arg);
+    Result Visit(VCExprQuantifier/*!*/ node, Arg arg);
+    Result Visit(VCExprLet/*!*/ node, Arg arg);
+  }
+  [ContractClassFor(typeof(IVCExprVisitor<,>))]
+  public abstract class IVCExprVisitorContracts<Result, Arg> : IVCExprVisitor<Result, Arg> {
+    #region IVCExprVisitor Members
+
+    public Result Visit(VCExprLiteral node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result Visit(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result Visit(VCExprVar node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result Visit(VCExprQuantifier node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result Visit(VCExprLet node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    #endregion
+  }
+  [ContractClass(typeof(IVCExprOpVisitorContracts<,>))]
+  public interface IVCExprOpVisitor<Result, Arg> {
+    Result VisitNotOp(VCExprNAry node, Arg arg);
+    Result VisitEqOp(VCExprNAry node, Arg arg);
+    Result VisitNeqOp(VCExprNAry node, Arg arg);
+    Result VisitAndOp(VCExprNAry node, Arg arg);
+    Result VisitOrOp(VCExprNAry node, Arg arg);
+    Result VisitImpliesOp(VCExprNAry node, Arg arg);
+    Result VisitDistinctOp(VCExprNAry node, Arg arg);
+    Result VisitLabelOp(VCExprNAry node, Arg arg);
+    Result VisitSelectOp(VCExprNAry node, Arg arg);
+    Result VisitStoreOp(VCExprNAry node, Arg arg);
+    Result VisitFloatAddOp(VCExprNAry node, Arg arg);
+    Result VisitFloatSubOp(VCExprNAry node, Arg arg);
+    Result VisitFloatMulOp(VCExprNAry node, Arg arg);
+    Result VisitFloatDivOp(VCExprNAry node, Arg arg);
+    Result VisitFloatRemOp(VCExprNAry node, Arg arg);
+    Result VisitFloatMinOp(VCExprNAry node, Arg arg);
+    Result VisitFloatMaxOp(VCExprNAry node, Arg arg);
+    Result VisitFloatLeqOp(VCExprNAry node, Arg arg);
+    Result VisitFloatLtOp(VCExprNAry node, Arg arg);
+    Result VisitFloatGeqOp(VCExprNAry node, Arg arg);
+    Result VisitFloatGtOp(VCExprNAry node, Arg arg);
+    Result VisitFloatEqOp(VCExprNAry node, Arg arg);
+    Result VisitBvOp(VCExprNAry node, Arg arg);
+    Result VisitBvExtractOp(VCExprNAry node, Arg arg);
+    Result VisitBvConcatOp(VCExprNAry node, Arg arg);
+    Result VisitAddOp(VCExprNAry node, Arg arg);
+    Result VisitSubOp(VCExprNAry node, Arg arg);
+    Result VisitMulOp(VCExprNAry node, Arg arg);
+    Result VisitDivOp(VCExprNAry node, Arg arg);
+    Result VisitModOp(VCExprNAry node, Arg arg);
+    Result VisitRealDivOp(VCExprNAry node, Arg arg);
+    Result VisitPowOp(VCExprNAry node, Arg arg);
+    Result VisitLtOp(VCExprNAry node, Arg arg);
+    Result VisitLeOp(VCExprNAry node, Arg arg);
+    Result VisitGtOp(VCExprNAry node, Arg arg);
+    Result VisitGeOp(VCExprNAry node, Arg arg);
+    Result VisitSubtypeOp(VCExprNAry node, Arg arg);
+    Result VisitSubtype3Op(VCExprNAry node, Arg arg);
+    Result VisitToIntOp(VCExprNAry node, Arg arg);
+    Result VisitToRealOp(VCExprNAry node, Arg arg);
+    Result VisitBoogieFunctionOp(VCExprNAry node, Arg arg);
+    Result VisitIfThenElseOp(VCExprNAry node, Arg arg);
+    Result VisitCustomOp(VCExprNAry node, Arg arg);
+  }
+  [ContractClassFor(typeof(IVCExprOpVisitor<,>))]
+  public abstract class IVCExprOpVisitorContracts<Result, Arg> : IVCExprOpVisitor<Result, Arg> {
+    #region IVCExprOpVisitor<Result,Arg> Members
+
+    public Result VisitNotOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitEqOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitNeqOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitAndOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitOrOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitImpliesOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitDistinctOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitLabelOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitSelectOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitStoreOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatAddOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatSubOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatMulOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatDivOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatRemOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatMinOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatMaxOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatLeqOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatLtOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatGeqOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatGtOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitFloatEqOp(VCExprNAry node, Arg arg)
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitBvOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitBvExtractOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitBvConcatOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitAddOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitSubOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitMulOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitDivOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitModOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitRealDivOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitPowOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitLtOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitLeOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitGtOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitGeOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitSubtypeOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitSubtype3Op(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitToIntOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitToRealOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitToFloat(VCExprNAry node, Arg arg) //TODO: modify later
+    {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitBoogieFunctionOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitIfThenElseOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    public Result VisitCustomOp(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+
+    #endregion
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Standard implementations that make it easier to create own visitors
+
+  // Simple traversal of VCExprs. The Visit implementations work
+  // recursively, apart from the implementation for VCExprNAry that
+  // uses a stack when applied to nested nodes with the same
+  // operator, e.g., (AND (AND (AND ...) ...) ...). This is necessary
+  // to avoid stack overflows
+
+
+  [ContractClass(typeof(TraversingVCExprVisitorContracts<,>))]
+  public abstract class TraversingVCExprVisitor<Result, Arg>
+                        : IVCExprVisitor<Result, Arg> {
+    protected abstract Result StandardResult(VCExpr/*!*/ node, Arg arg);
+
+    public Result Traverse(VCExpr node, Arg arg) {
+      Contract.Requires(node != null);
+      return node.Accept(this, arg);
+    }
+
+    public virtual Result Visit(VCExprLiteral node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+
+    public virtual Result Visit(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      Result res = StandardResult(node, arg);
+
+
+      if (node.TypeParamArity == 0 &&
+          (node.Op == VCExpressionGenerator.AndOp ||
+           node.Op == VCExpressionGenerator.OrOp ||
+           node.Op == VCExpressionGenerator.ImpliesOp)) {
+        Contract.Assert(node.Op != null);
+        VCExprOp op = node.Op;
+        HashSet<VCExprOp> ops = new HashSet<VCExprOp>();
+        ops.Add(VCExpressionGenerator.AndOp);
+        ops.Add(VCExpressionGenerator.OrOp);
+        ops.Add(VCExpressionGenerator.ImpliesOp);
+        IEnumerator enumerator = new VCExprNAryMultiUniformOpEnumerator(node, ops);
+        while (enumerator.MoveNext()) {
+          VCExpr expr = cce.NonNull((VCExpr)enumerator.Current);
+          VCExprNAry naryExpr = expr as VCExprNAry;
+          if (naryExpr == null || !ops.Contains(naryExpr.Op)) {
+            expr.Accept(this, arg);
+          } else {
+            StandardResult(expr, arg);
+          }
+        }
+      } else {
+        foreach (VCExpr e in node) {
+          Contract.Assert(e != null);
+          e.Accept(this, arg);
+        }
+      }
+
+      return res;
+    }
+
+    public virtual Result Visit(VCExprVar node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result Visit(VCExprQuantifier node, Arg arg) {
+      //Contract.Requires(node != null);
+      Result res = StandardResult(node, arg);
+      foreach (VCTrigger/*!*/ trigger in node.Triggers) {
+        Contract.Assert(trigger != null);
+        foreach (VCExpr/*!*/ expr in trigger.Exprs) {
+          Contract.Assert(expr != null);
+          expr.Accept(this, arg);
+        }
+      }
+      node.Body.Accept(this, arg);
+      return res;
+    }
+    public virtual Result Visit(VCExprLet node, Arg arg) {
+      //Contract.Requires(node != null);
+      Result res = StandardResult(node, arg);
+      // visit the bound expressions first
+      foreach (VCExprLetBinding/*!*/ binding in node) {
+        Contract.Assert(binding != null);
+        binding.E.Accept(this, arg);
+      }
+      node.Body.Accept(this, arg);
+      return res;
+    }
+  }
+  [ContractClassFor(typeof(TraversingVCExprVisitor<,>))]
+  public abstract class TraversingVCExprVisitorContracts<Result, Arg> : TraversingVCExprVisitor<Result, Arg> {
+    protected override Result StandardResult(VCExpr node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+  }
+  //////////////////////////////////////////////////////////////////////////////
+  // Class to iterate over the nodes of a tree of VCExprNAry. This is
+  // used to avoid handling such VCExpr recursively, which can easily
+  // lead to stack overflows
+
+  public class VCExprNAryEnumerator : IEnumerator {
+
+    private readonly VCExprNAry/*!*/ CompleteExpr;
+    private VCExpr CurrentExpr = null;
+    private readonly Stack<VCExpr/*!*/>/*!*/ ExprTodo = new Stack<VCExpr/*!*/>();
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(CompleteExpr != null);
+      Contract.Invariant(cce.NonNullElements(ExprTodo));
+    }
+
+    public VCExprNAryEnumerator(VCExprNAry completeExpr) {
+      Contract.Requires(completeExpr != null);
+      this.CompleteExpr = completeExpr;
+      Stack<VCExpr/*!*/>/*!*/ exprTodo = new Stack<VCExpr/*!*/>();
+      exprTodo.Push(completeExpr);
+      ExprTodo = exprTodo;
+    }
+
+    // Method using which a subclass can decide whether the
+    // subexpressions of an expression should be enumerated as well
+    // The default is to enumerate all nodes
+    protected virtual bool Descend(VCExprNAry expr) {
+      Contract.Requires(expr != null);
+      return true;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public bool MoveNext() {
+      if (ExprTodo.Count == 0)
+        return false;
+
+      CurrentExpr = ExprTodo.Pop();
+      VCExprNAry currentNAry = CurrentExpr as VCExprNAry;
+      if (currentNAry != null && Descend(currentNAry)) {
+        for (int i = currentNAry.Arity - 1; i >= 0; --i)
+          ExprTodo.Push(currentNAry[i]);
+      }
+
+      return true;
+    }
+
+    public object Current {
+      get {
+        return cce.NonNull(CurrentExpr);
+      }
+    }
+
+    public void Reset() {
+      ExprTodo.Clear();
+      CurrentExpr = null;
+      ExprTodo.Push(CompleteExpr);
+    }
+  }
+
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  public class VCExprNAryUniformOpEnumerator : VCExprNAryEnumerator {
+    private readonly VCExprOp/*!*/ Op;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Op != null);
+    }
+
+    public VCExprNAryUniformOpEnumerator(VCExprNAry completeExpr)
+      : base(completeExpr) {
+      Contract.Requires(completeExpr != null);
+
+      this.Op = completeExpr.Op;
+    }
+    protected override bool Descend(VCExprNAry expr) {
+      //Contract.Requires(expr != null);
+      return expr.Op.Equals(Op) &&
+        // we never skip nodes with type parameters
+        // (those are too interesting ...)
+             expr.TypeParamArity == 0;
+    }
+  }
+
+  public class VCExprNAryMultiUniformOpEnumerator : VCExprNAryEnumerator
+  {
+      private readonly HashSet<VCExprOp> Ops;
+      [ContractInvariantMethod]
+      void ObjectInvariant()
+      {
+          Contract.Invariant(Ops != null);
+      }
+
+      public VCExprNAryMultiUniformOpEnumerator(VCExprNAry completeExpr, HashSet<VCExprOp> ops)
+          : base(completeExpr)
+      {
+          Contract.Requires(completeExpr != null);
+
+          this.Ops = ops;
+      }
+      protected override bool Descend(VCExprNAry expr)
+      {
+          return Ops.Contains(expr.Op) && expr.TypeParamArity == 0;
+      }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Visitor that knows about the variables bound at each location in a VCExpr
+
+  public abstract class BoundVarTraversingVCExprVisitor<Result, Arg>
+                        : TraversingVCExprVisitor<Result, Arg> {
+    // Maps with all variables bound above a certain location in the VCExpression.
+    // The value of the map tells how often a particular symbol was bound
+    private readonly IDictionary<VCExprVar/*!*/, int>/*!*/ BoundTermVarsDict =
+      new Dictionary<VCExprVar/*!*/, int>();
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(BoundTermVarsDict != null);
+      Contract.Invariant(BoundTypeVarsDict != null);
+    }
+
+    private readonly IDictionary<TypeVariable/*!*/, int>/*!*/ BoundTypeVarsDict =
+      new Dictionary<TypeVariable/*!*/, int>();
+
+    protected ICollection<VCExprVar/*!*/>/*!*/ BoundTermVars {
+      get {
+        Contract.Ensures(cce.NonNullElements(Contract.Result<ICollection<VCExprVar>>()));
+        return BoundTermVarsDict.Keys;
+      }
+    }
+    protected ICollection<TypeVariable/*!*/>/*!*/ BoundTypeVars {
+      get {
+        Contract.Ensures(cce.NonNullElements(Contract.Result<ICollection<TypeVariable>>()));
+        return BoundTypeVarsDict.Keys;
+      }
+    }
+
+    private void AddBoundVar<T>(IDictionary<T, int> dict, T sym) {
+      Contract.Requires(sym != null);
+      Contract.Requires(dict != null);
+      int n;
+      if (dict.TryGetValue(sym, out n))
+        dict[sym] = n + 1;
+      else
+        dict[sym] = 1;
+    }
+
+    private void RemoveBoundVar<T>(IDictionary<T/*!*/, int/*!*/>/*!*/ dict, T sym) {
+      Contract.Requires(sym != null);
+      Contract.Requires(dict != null);
+      int n;
+      bool b = dict.TryGetValue(sym, out n);
+      Contract.Assert(b && n > 0);
+      if (n == 1)
+        dict.Remove(sym);
+      else
+        dict[sym] = n - 1;
+    }
+
+    public override Result Visit(VCExprQuantifier node, Arg arg) {
+      Contract.Requires(node != null);
+      // we temporarily add bound (term and type) variables to the
+      // corresponding lists
+      foreach (VCExprVar/*!*/ v in node.BoundVars) {
+        Contract.Assert(v != null);
+        AddBoundVar<VCExprVar>(BoundTermVarsDict, v);
+      }
+      foreach (TypeVariable/*!*/ v in node.TypeParameters) {
+        Contract.Assert(v != null);
+        AddBoundVar<TypeVariable>(BoundTypeVarsDict, v);
+      }
+
+      Result res;
+      try {
+        res = VisitAfterBinding(node, arg);
+      } finally {
+        foreach (VCExprVar/*!*/ v in node.BoundVars) {
+          Contract.Assert(v != null);
+          RemoveBoundVar<VCExprVar>(BoundTermVarsDict, v);
+        }
+        foreach (TypeVariable/*!*/ v in node.TypeParameters) {
+          Contract.Assert(v != null);
+          RemoveBoundVar<TypeVariable>(BoundTypeVarsDict, v);
+        }
+      }
+      return res;
+    }
+    public override Result Visit(VCExprLet node, Arg arg) {
+      Contract.Requires(node != null);
+      // we temporarily add bound term variables to the
+      // corresponding lists
+      foreach (VCExprVar/*!*/ v in node.BoundVars) {
+        Contract.Assert(v != null);
+        AddBoundVar<VCExprVar>(BoundTermVarsDict, v);
+      }
+
+      Result res;
+      try {
+        res = VisitAfterBinding(node, arg);
+      } finally {
+        foreach (VCExprVar/*!*/ v in node.BoundVars) {
+          Contract.Assert(v != null);
+          RemoveBoundVar<VCExprVar>(BoundTermVarsDict, v);
+        }
+      }
+      return res;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // The possibility is provided to look at a (quantifier or let) node
+    // after its bound variables have been registered
+    // (when overriding the normal visit-methods, the node will be visited
+    // before the binding happens)
+
+    protected virtual Result VisitAfterBinding(VCExprQuantifier node, Arg arg) {
+      Contract.Requires(node != null);
+      return base.Visit(node, arg);
+    }
+
+    protected virtual Result VisitAfterBinding(VCExprLet node, Arg arg) {
+      Contract.Requires(node != null);
+      return base.Visit(node, arg);
+    }
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // General visitor for recursively collecting information in a VCExpr.
+  // As the visitor is not used anywhere for the time being, it maybe should
+  // be removed
+
+  [ContractClass(typeof(CollectingVCExprVisitorContracts<,>))]
+  public abstract class CollectingVCExprVisitor<Result, Arg>
+                        : IVCExprVisitor<Result, Arg> {
+    protected abstract Result CombineResults(List<Result>/*!*/ results, Arg arg);
+
+    public Result Collect(VCExpr node, Arg arg) {
+      Contract.Requires(node != null);
+      return node.Accept(this, arg);
+    }
+
+    public virtual Result Visit(VCExprLiteral node, Arg arg) {
+      //Contract.Requires(node != null);
+      return CombineResults(new List<Result>(), arg);
+    }
+    public virtual Result Visit(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      List<Result>/*!*/ results = new List<Result>();
+      foreach (VCExpr/*!*/ subnode in node) {
+        Contract.Assert(subnode != null);
+        results.Add(subnode.Accept(this, arg));
+      }
+      return CombineResults(results, arg);
+    }
+    public virtual Result Visit(VCExprVar node, Arg arg) {
+      //Contract.Requires(node != null);
+      return CombineResults(new List<Result>(), arg);
+    }
+    public virtual Result Visit(VCExprQuantifier node, Arg arg) {
+      //Contract.Requires(node != null);
+      List<Result>/*!*/ result = new List<Result>();
+      result.Add(node.Body.Accept(this, arg));
+      foreach (VCTrigger/*!*/ trigger in node.Triggers) {
+        Contract.Assert(trigger != null);
+        foreach (VCExpr/*!*/ expr in trigger.Exprs) {
+          Contract.Assert(expr != null);
+          result.Add(expr.Accept(this, arg));
+        }
+      }
+      return CombineResults(result, arg);
+    }
+    public virtual Result Visit(VCExprLet node, Arg arg) {
+      //Contract.Requires(node != null);
+      List<Result>/*!*/ results = new List<Result>();
+      // visit the bound expressions first
+      foreach (VCExprLetBinding/*!*/ binding in node) {
+        Contract.Assert(binding != null);
+        results.Add(binding.E.Accept(this, arg));
+      }
+      results.Add(node.Body.Accept(this, arg));
+      return CombineResults(results, arg);
+    }
+  }
+  [ContractClassFor(typeof(CollectingVCExprVisitor<,>))]
+  public abstract class CollectingVCExprVisitorContracts<Result, Arg> : CollectingVCExprVisitor<Result, Arg> {
+    protected override Result CombineResults(List<Result> results, Arg arg) {
+      Contract.Requires(results != null);
+      throw new NotImplementedException();
+    }
+  }
+  ////////////////////////////////////////////////////////////////////////////
+
+  public class SizeComputingVisitor : TraversingVCExprVisitor<bool, bool> {
+
+    private int Size = 0;
+
+    public static int ComputeSize(VCExpr expr) {
+      Contract.Requires(expr != null);
+      SizeComputingVisitor/*!*/ visitor = new SizeComputingVisitor();
+      visitor.Traverse(expr, true);
+      return visitor.Size;
+    }
+
+    protected override bool StandardResult(VCExpr node, bool arg) {
+      //Contract.Requires(node != null);
+      Size = Size + 1;
+      return true;
+    }
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+
+  // Collect all free term and type variables in a VCExpr. Type variables
+  // can occur free either in the types of bound variables, or in the type
+  // parameters of VCExprNAry.
+
+  // the result and argument (of type bool) are not used currently
+  public class FreeVariableCollector : BoundVarTraversingVCExprVisitor<bool, bool> {
+    public readonly Dictionary<VCExprVar/*!*/, object>/*!*/ FreeTermVars = new Dictionary<VCExprVar/*!*/, object>();
+    public readonly List<TypeVariable/*!*/>/*!*/ FreeTypeVars = new List<TypeVariable/*!*/>();
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(FreeTermVars != null && Contract.ForAll(FreeTermVars, entry => entry.Key != null));
+      Contract.Invariant(cce.NonNullElements(FreeTypeVars));
+    }
+
+
+    // not used
+    protected override bool StandardResult(VCExpr node, bool arg) {
+      //Contract.Requires(node != null);
+      return true;
+    }
+
+    public static Dictionary<VCExprVar/*!*/, object>/*!*/ FreeTermVariables(VCExpr node) {
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<Dictionary<VCExprVar, object>>() != null);
+      Contract.Ensures(Contract.ForAll(Contract.Result<Dictionary<VCExprVar, object>>(), ftv => ftv.Key != null));
+      FreeVariableCollector collector = new FreeVariableCollector();
+      collector.Traverse(node, true);
+      return collector.FreeTermVars;
+    }
+
+    public static List<TypeVariable/*!*/>/*!*/ FreeTypeVariables(VCExpr node) {
+      Contract.Requires(node != null);
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<TypeVariable>>()));
+      FreeVariableCollector collector = new FreeVariableCollector();
+      collector.Traverse(node, true);
+      return collector.FreeTypeVars;
+    }
+
+    public void Reset() {
+      FreeTermVars.Clear();
+      FreeTypeVars.Clear();
+    }
+
+    public void Collect(VCExpr node) {
+      Contract.Requires(node != null);
+      Traverse(node, true);
+    }
+
+    public void Collect(Type type) {
+      Contract.Requires(type != null);
+      AddTypeVariables(type.FreeVariables.ToList());
+    }
+
+    /////////////////////////////////////////////////////////////////////////
+
+    private void CollectTypeVariables(IEnumerable<VCExprVar/*!*/>/*!*/ boundVars) {
+      Contract.Requires(cce.NonNullElements(boundVars));
+      foreach (VCExprVar/*!*/ var in boundVars) {
+        Contract.Assert(var != null);
+        Collect(var.Type);
+      }
+    }
+
+    private void AddTypeVariables(IEnumerable<TypeVariable/*!*/>/*!*/ typeVars) {
+      Contract.Requires(cce.NonNullElements(typeVars));
+      foreach (TypeVariable/*!*/ tvar in typeVars) {
+        Contract.Assert(tvar != null);
+        if (!BoundTypeVars.Contains(tvar) && !FreeTypeVars.Contains(tvar))
+          FreeTypeVars.Add(tvar);
+      }
+    }
+
+    public override bool Visit(VCExprVar node, bool arg) {
+      Contract.Requires(node != null);
+      if (!BoundTermVars.Contains(node) && !FreeTermVars.ContainsKey(node)) {
+        FreeTermVars.Add(node, null);
+        Collect(node.Type);
+      }
+      return true;
+    }
+
+    public override bool Visit(VCExprNAry node, bool arg) {
+      Contract.Requires(node != null);
+      foreach (Type/*!*/ t in node.TypeArguments) {
+        Contract.Assert(t != null);
+        Collect(t);
+      }
+      return base.Visit(node, arg);
+    }
+
+    protected override bool VisitAfterBinding(VCExprQuantifier node, bool arg) {
+      //Contract.Requires(node != null);
+      CollectTypeVariables(node.BoundVars);
+      return base.VisitAfterBinding(node, arg);
+    }
+
+    protected override bool VisitAfterBinding(VCExprLet node, bool arg) {
+      //Contract.Requires(node != null);
+      CollectTypeVariables(node.BoundVars);
+      return base.VisitAfterBinding(node, arg);
+    }
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // Framework for mutating VCExprs
+
+  // The Visit implementations in the following visitor work
+  // recursively, apart from the implementation for VCExprNAry that
+  // uses its own stack when applied to nested nodes with the same
+  // operator, e.g., (AND (AND (AND ...) ...) ...). This is necessary
+  // to avoid stack overflows (like in TraversingVCExprVisitor)
+
+  public abstract class MutatingVCExprVisitor<Arg>
+                        : IVCExprVisitor<VCExpr/*!*/, Arg> {
+    protected readonly VCExpressionGenerator/*!*/ Gen;
+    [ContractInvariantMethod]
+    void ObjectInvariant() {
+      Contract.Invariant(Gen != null);
+    }
+
+
+    public MutatingVCExprVisitor(VCExpressionGenerator gen) {
+      Contract.Requires(gen != null);
+      this.Gen = gen;
+    }
+
+    public VCExpr Mutate(VCExpr expr, Arg arg) {
+      Contract.Requires(expr != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return expr.Accept(this, arg);
+    }
+
+    public List<VCExpr/*!*/>/*!*/ MutateSeq(IEnumerable<VCExpr/*!*/>/*!*/ exprs, Arg arg) {
+      Contract.Requires(cce.NonNullElements(exprs));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
+      List<VCExpr/*!*/>/*!*/ res = new List<VCExpr/*!*/>();
+      foreach (VCExpr/*!*/ expr in exprs) {
+        Contract.Assert(expr != null);
+        res.Add(expr.Accept(this, arg));
+      }
+      return res;
+    }
+
+    private List<VCExpr/*!*/>/*!*/ MutateList(List<VCExpr/*!*/>/*!*/ exprs, Arg arg) {
+      Contract.Requires(cce.NonNullElements(exprs));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCExpr>>()));
+      bool changed = false;
+      List<VCExpr/*!*/>/*!*/ res = new List<VCExpr/*!*/>();
+      foreach (VCExpr/*!*/ expr in exprs) {
+        Contract.Assert(expr != null);
+        VCExpr/*!*/ newExpr = expr.Accept(this, arg);
+        if (!Object.ReferenceEquals(expr, newExpr))
+          changed = true;
+        res.Add(newExpr);
+      }
+      if (!changed)
+        return exprs;
+      return res;
+    }
+
+    public virtual VCExpr Visit(VCExprLiteral node, Arg arg) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return node;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    // Special element used to mark the positions in the todo-stack where
+    // results have to be popped from the result-stack.
+    private static readonly VCExpr/*!*/ CombineResultsMarker = new VCExprLiteral(Type.Bool);
+
+    // The todo-stack contains records of the shape
+    //
+    //     arg0
+    //     arg1
+    //     arg2
+    //     ...
+    //     CombineResultsMarker
+    //     f(arg0, arg1, arg2, ...)               (the original expression)
+
+    private readonly Stack<VCExpr/*!*/>/*!*/ NAryExprTodoStack = new Stack<VCExpr/*!*/>();
+    private readonly Stack<VCExpr/*!*/>/*!*/ NAryExprResultStack = new Stack<VCExpr/*!*/>();
+    [ContractInvariantMethod]
+    void ObjectInvarianta() {
+      Contract.Invariant(cce.NonNullElements(NAryExprResultStack));
+      Contract.Invariant(cce.NonNullElements(NAryExprTodoStack));
+    }
+
+
+    private void PushTodo(VCExprNAry exprTodo) {
+      Contract.Requires(exprTodo != null);
+      NAryExprTodoStack.Push(exprTodo);
+      NAryExprTodoStack.Push(CombineResultsMarker);
+      for (int i = exprTodo.Arity - 1; i >= 0; --i)
+        NAryExprTodoStack.Push(exprTodo[i]);
+    }
+
+    public virtual bool AvoidVisit(VCExprNAry node, Arg arg)
+    {
+        return true;
+    }
+
+    public virtual VCExpr Visit(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      int initialStackSize = NAryExprTodoStack.Count;
+      int initialResultStackSize = NAryExprResultStack.Count;
+
+      PushTodo(node);
+
+      while (NAryExprTodoStack.Count > initialStackSize) {
+        VCExpr/*!*/ subExpr = NAryExprTodoStack.Pop();
+        Contract.Assert(subExpr != null);
+
+        if (Object.ReferenceEquals(subExpr, CombineResultsMarker)) {
+          // assemble a result
+          VCExprNAry/*!*/ originalExpr = (VCExprNAry)NAryExprTodoStack.Pop();
+          Contract.Assert(originalExpr != null);
+          VCExprOp/*!*/ op = originalExpr.Op;
+          bool changed = false;
+          List<VCExpr/*!*/>/*!*/ newSubExprs = new List<VCExpr/*!*/>();
+
+          for (int i = op.Arity - 1; i >= 0; --i) {
+            VCExpr/*!*/ nextSubExpr = NAryExprResultStack.Pop();
+            Contract.Assert(nextSubExpr != null);
+            if (!Object.ReferenceEquals(nextSubExpr, originalExpr[i]))
+              changed = true;
+            newSubExprs.Insert(0, nextSubExpr);
+          }
+
+          NAryExprResultStack.Push(UpdateModifiedNode(originalExpr, newSubExprs, changed, arg));
+          //
+        } else {
+          //
+            VCExprNAry narySubExpr = subExpr as VCExprNAry;
+          if (narySubExpr != null && this.AvoidVisit(narySubExpr, arg) &&
+            // as in VCExprNAryUniformOpEnumerator, all expressions with
+            // type parameters are allowed to be inspected more closely
+              narySubExpr.TypeParamArity == 0) {
+            PushTodo(narySubExpr);
+          } else {
+            NAryExprResultStack.Push(subExpr.Accept(this, arg));
+          }
+          //
+        }
+      }
+
+      Contract.Assert(NAryExprTodoStack.Count == initialStackSize && NAryExprResultStack.Count == initialResultStackSize + 1);
+      return NAryExprResultStack.Pop();
+    }
+
+    protected virtual VCExpr/*!*/ UpdateModifiedNode(VCExprNAry/*!*/ originalNode, List<VCExpr/*!*/>/*!*/ newSubExprs, // has any of the subexpressions changed? 
+                                                 bool changed,
+                                                 Arg arg) {
+      Contract.Requires(cce.NonNullElements(newSubExprs));
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      if (changed)
+        return Gen.Function(originalNode.Op,
+                            newSubExprs, originalNode.TypeArguments);
+      else
+        return originalNode;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    public virtual VCExpr Visit(VCExprVar node, Arg arg) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      return node;
+    }
+
+    protected List<VCTrigger/*!*/>/*!*/ MutateTriggers(List<VCTrigger/*!*/>/*!*/ triggers, Arg arg) {
+      Contract.Requires(cce.NonNullElements(triggers));
+      Contract.Ensures(cce.NonNullElements(Contract.Result<List<VCTrigger>>()));
+      List<VCTrigger/*!*/>/*!*/ newTriggers = new List<VCTrigger/*!*/>();
+      bool changed = false;
+      foreach (VCTrigger/*!*/ trigger in triggers) {
+        Contract.Assert(trigger != null);
+        List<VCExpr/*!*/>/*!*/ exprs = trigger.Exprs;
+        List<VCExpr/*!*/>/*!*/ newExprs = MutateList(exprs, arg);
+
+        if (Object.ReferenceEquals(exprs, newExprs)) {
+          newTriggers.Add(trigger);
+        } else {
+          newTriggers.Add(Gen.Trigger(trigger.Pos, newExprs));
+          changed = true;
+        }
+      }
+      if (!changed)
+        return triggers;
+      return newTriggers;
+    }
+
+    public virtual VCExpr Visit(VCExprQuantifier node, Arg arg) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      bool changed = false;
+
+      VCExpr/*!*/ body = node.Body;
+      Contract.Assert(body != null);
+      VCExpr/*!*/ newbody = body.Accept(this, arg);
+      Contract.Assert(newbody != null);
+      if (!Object.ReferenceEquals(body, newbody))
+        changed = true;
+
+      // visit the trigger expressions as well
+      List<VCTrigger/*!*/>/*!*/ triggers = node.Triggers;
+      Contract.Assert(cce.NonNullElements(triggers));
+      List<VCTrigger/*!*/>/*!*/ newTriggers = MutateTriggers(triggers, arg);
+      Contract.Assert(cce.NonNullElements(newTriggers));
+      if (!Object.ReferenceEquals(triggers, newTriggers))
+        changed = true;
+
+      if (!changed)
+        return node;
+      return Gen.Quantify(node.Quan, node.TypeParameters, node.BoundVars,
+                          newTriggers, node.Infos, newbody);
+    }
+
+    public virtual VCExpr Visit(VCExprLet node, Arg arg) {
+      //Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      bool changed = false;
+
+      VCExpr/*!*/ body = node.Body;
+      VCExpr/*!*/ newbody = body.Accept(this, arg);
+      if (!Object.ReferenceEquals(body, newbody))
+        changed = true;
+
+      List<VCExprLetBinding/*!*/>/*!*/ newbindings = new List<VCExprLetBinding/*!*/>();
+      for (int i = 0; i < node.Length; ++i) {
+        VCExprLetBinding/*!*/ binding = node[i];
+        Contract.Assert(binding != null);
+        VCExpr/*!*/ e = binding.E;
+        VCExpr/*!*/ newE = e.Accept(this, arg);
+        if (Object.ReferenceEquals(e, newE)) {
+          newbindings.Add(binding);
+        } else {
+          changed = true;
+          newbindings.Add(Gen.LetBinding(binding.V, newE));
+        }
+      }
+
+      if (!changed)
+        return node;
+      return Gen.Let(newbindings, newbody);
+    }
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  // Substitutions and a visitor for applying substitutions. A substitution can
+  // substitute both type variables and term variables
+
+  public class VCExprSubstitution {
+    private readonly List<IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/>/*!*/ TermSubsts;
+    [ContractInvariantMethod]
+    void TermSubstsInvariantMethod() {
+      Contract.Invariant(TermSubsts != null && Contract.ForAll(TermSubsts, i => cce.NonNullDictionaryAndValues(i)));
+    }
+    private readonly List<IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/>/*!*/ TypeSubsts;
+    [ContractInvariantMethod]
+    void TypeSubstsInvariantMethod() {
+      Contract.Invariant(TermSubsts != null && Contract.ForAll(TypeSubsts, i => cce.NonNullDictionaryAndValues(i)));
+    }
+
+    public VCExprSubstitution(IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/ termSubst, IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ typeSubst) {
+      Contract.Requires(cce.NonNullDictionaryAndValues(termSubst));
+      Contract.Requires(cce.NonNullDictionaryAndValues(typeSubst));
+      List<IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/>/*!*/ termSubsts =
+        new List<IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/>();
+      termSubsts.Add(termSubst);
+      List<IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/>/*!*/ typeSubsts =
+        new List<IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/>();
+      typeSubsts.Add(typeSubst);
+      this.TermSubsts = termSubsts;
+      this.TypeSubsts = typeSubsts;
+    }
+
+    public VCExprSubstitution()
+      : this(new Dictionary<VCExprVar/*!*/, VCExpr/*!*/>(), new Dictionary<TypeVariable/*!*/, Type/*!*/>()) {
+
+    }
+
+    public void PushScope() {
+      TermSubsts.Add(new Dictionary<VCExprVar/*!*/, VCExpr/*!*/>());
+      TypeSubsts.Add(new Dictionary<TypeVariable/*!*/, Type/*!*/>());
+    }
+
+    public void PopScope() {
+      TermSubsts.RemoveAt(TermSubsts.Count - 1);
+      TypeSubsts.RemoveAt(TypeSubsts.Count - 1);
+    }
+
+    public VCExpr this[VCExprVar/*!*/ var] {
+      get {
+        Contract.Requires(var != null);
+        VCExpr res;
+        for (int i = TermSubsts.Count - 1; i >= 0; --i) {
+          if (TermSubsts[i].TryGetValue(var, out res))
+            return res;
+        }
+        return null;
+      }
+      set {
+        TermSubsts[TermSubsts.Count - 1][var] = cce.NonNull(value);
+      }
+    }
+
+    public Type this[TypeVariable/*!*/ var] {
+      get {
+        Contract.Requires(var != null);
+        Type res;
+        for (int i = TypeSubsts.Count - 1; i >= 0; --i) {
+          if (TypeSubsts[i].TryGetValue(var, out res))
+            return res;
+        }
+        return null;
+      }
+      set {
+        TypeSubsts[TypeSubsts.Count - 1][var] = cce.NonNull(value);
+      }
+    }
+
+    public bool ContainsKey(VCExprVar var) {
+      Contract.Requires(var != null);
+      return this[var] != null;
+    }
+
+    public bool ContainsKey(TypeVariable var) {
+      Contract.Requires(var != null);
+      return this[var] != null;
+    }
+
+    public bool TermSubstIsEmpty {
+      get {
+        return TermSubsts.All(dict => !dict.Any());
+      }
+    }
+
+    public bool TypeSubstIsEmpty {
+      get {
+        return TypeSubsts.All(dict => !dict.Any());
+      }
+    }
+
+    public IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ ToTypeSubst {
+      get {
+        Contract.Ensures(cce.NonNullDictionaryAndValues(Contract.Result<IDictionary<TypeVariable, Type>>()));
+        IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ res = new Dictionary<TypeVariable/*!*/, Type/*!*/>();
+        foreach (IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ dict in TypeSubsts) {
+          foreach (KeyValuePair<TypeVariable/*!*/, Type/*!*/> pair in dict) {
+            Contract.Assert(cce.NonNullElements(pair));
+            // later ones overwrite earlier ones
+            res[pair.Key] = pair.Value;
+          }
+        }
+        return res;
+      }
+    }
+
+    // the variables that are not mapped to themselves
+    public IEnumerable<VCExprVar/*!*/>/*!*/ TermDomain {
+      get {
+        Contract.Ensures(cce.NonNullElements(Contract.Result<IEnumerable<VCExprVar>>()));
+        HashSet<VCExprVar/*!*/>/*!*/ domain = new HashSet<VCExprVar/*!*/>();
+        foreach (IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/ dict in TermSubsts) {
+          Contract.Assert(dict != null);
+          foreach (VCExprVar/*!*/ var in dict.Keys) {
+            Contract.Assert(var != null);
+            if (!var.Equals(this[var]))
+              domain.Add(var);
+          }
+        }
+        return domain;
+      }
+    }
+
+    // the variables that are not mapped to themselves
+    public IEnumerable<TypeVariable/*!*/>/*!*/ TypeDomain {
+      get {
+        Contract.Ensures(cce.NonNullElements(Contract.Result<IEnumerable<TypeVariable>>()));
+        HashSet<TypeVariable/*!*/>/*!*/ domain = new HashSet<TypeVariable/*!*/>();
+        foreach (IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ dict in TypeSubsts) {
+          Contract.Assert(dict != null);
+          foreach (TypeVariable/*!*/ var in dict.Keys) {
+            Contract.Assert(var != null);
+            if (!var.Equals(this[var]))
+              domain.Add(var);
+          }
+        }
+        return domain;
+      }
+    }
+
+    public FreeVariableCollector/*!*/ Codomains {
+      get {
+        Contract.Ensures(Contract.Result<FreeVariableCollector>() != null);
+
+        FreeVariableCollector/*!*/ coll = new FreeVariableCollector();
+        foreach (VCExprVar/*!*/ var in TermDomain)
+          coll.Collect(cce.NonNull(this)[var]);
+        foreach (TypeVariable/*!*/ var in TypeDomain)
+          coll.Collect(cce.NonNull(this)[var]);
+        return coll;
+      }
+    }
+
+    public VCExprSubstitution Clone() {
+      Contract.Ensures(Contract.Result<VCExprSubstitution>() != null);
+      VCExprSubstitution/*!*/ res = new VCExprSubstitution();
+      foreach (IDictionary<VCExprVar/*!*/, VCExpr/*!*/>/*!*/ dict in TermSubsts)
+        res.TermSubsts.Add(HelperFuns.Clone(dict));
+      foreach (IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ dict in TypeSubsts)
+        res.TypeSubsts.Add(HelperFuns.Clone(dict));
+      return res;
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////////
+
+  public class SubstitutingVCExprVisitor
+               : MutatingVCExprVisitor<VCExprSubstitution/*!*/> {
+    public SubstitutingVCExprVisitor(VCExpressionGenerator gen)
+      : base(gen) {
+      Contract.Requires(gen != null);
+
+    }
+
+    // when descending across a binder, we have to check that no collisions
+    // or variable capture can occur. if this might happen, we replace the
+    // term and type variables bound by the binder with fresh variables
+    private bool CollisionPossible(IEnumerable<TypeVariable/*!*/>/*!*/ typeParams, IEnumerable<VCExprVar/*!*/>/*!*/ boundVars, VCExprSubstitution/*!*/ substitution) {
+      Contract.Requires(cce.NonNullElements(typeParams));
+      Contract.Requires(cce.NonNullElements(boundVars));
+      Contract.Requires(substitution != null);
+      // variables can be shadowed by a binder
+      if (typeParams.Any(var => substitution.ContainsKey(var)) ||
+          boundVars.Any(var => substitution.ContainsKey(var)))
+        return true;
+      // compute the codomain of the substitution
+      FreeVariableCollector coll = substitution.Codomains;
+      Contract.Assert(coll != null);
+      // variables could be captured when applying the substitution
+      return typeParams.Any(var => coll.FreeTypeVars.Contains(var)) ||
+             boundVars.Any(var => coll.FreeTermVars.ContainsKey(var));
+    }
+
+    // can be overwritten if names of bound variables are to be changed
+    protected virtual string ChooseNewVariableName(string oldName) {
+      Contract.Requires(oldName != null);
+      Contract.Ensures(Contract.Result<string>() != null);
+      return oldName;
+    }
+
+    // handle type parameters in VCExprNAry
+    protected override VCExpr/*!*/ UpdateModifiedNode(VCExprNAry/*!*/ originalNode, List<VCExpr/*!*/>/*!*/ newSubExprs, bool changed, VCExprSubstitution/*!*/ substitution) {
+      //Contract.Requires(originalNode != null);
+      //Contract.Requires(cce.NonNullElements(newSubExprs));
+      //Contract.Requires(substitution != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      List<Type/*!*/>/*!*/ typeParams = new List<Type/*!*/>();
+      foreach (Type/*!*/ t in originalNode.TypeArguments) {
+        Contract.Assert(t != null);
+        Type/*!*/ newType = t.Substitute(substitution.ToTypeSubst);
+        Contract.Assert(newType != null);
+        if (!ReferenceEquals(t, newType))
+          changed = true;
+        typeParams.Add(newType);
+      }
+      if (changed)
+        return Gen.Function(originalNode.Op, newSubExprs, typeParams);
+      else
+        return originalNode;
+    }
+
+    public override VCExpr/*!*/ Visit(VCExprQuantifier/*!*/ node, VCExprSubstitution/*!*/ substitution) {
+      Contract.Requires(node != null);
+      Contract.Requires(substitution != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      // the default is to refresh bound variables only if necessary
+      // because of collisions
+      return Visit(node, substitution, false);
+    }
+
+    public VCExpr/*!*/ Visit(VCExprQuantifier/*!*/ node, VCExprSubstitution/*!*/ substitution, bool refreshBoundVariables) {
+      Contract.Requires(node != null);
+      Contract.Requires(substitution != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+
+      substitution.PushScope();
+      try {
+
+        List<TypeVariable/*!*/>/*!*/ typeParams = node.TypeParameters;
+        Contract.Assert(cce.NonNullElements(typeParams));
+        bool refreshAllVariables = refreshBoundVariables ||
+                                   CollisionPossible(node.TypeParameters, node.BoundVars, substitution);
+        if (refreshAllVariables) {
+          // we introduce fresh type variables to ensure that none gets captured
+          typeParams = new List<TypeVariable/*!*/>();
+          foreach (TypeVariable/*!*/ var in node.TypeParameters) {
+            Contract.Assert(var != null);
+            TypeVariable/*!*/ freshVar =
+              new TypeVariable(Token.NoToken, ChooseNewVariableName(var.Name));
+            Contract.Assert(freshVar != null);
+            typeParams.Add(freshVar);
+            substitution[var] = freshVar;
+            // this might overwrite other elements of the substitution, deliberately
+          }
+        }
+
+        List<VCExprVar/*!*/>/*!*/ boundVars = node.BoundVars;
+        Contract.Assert(cce.NonNullElements(boundVars));
+        if (refreshAllVariables || !substitution.TypeSubstIsEmpty) {
+          // collisions are possible, or we also substitute type variables. in this case
+          // the bound term variables have to be replaced with fresh variables with the
+          // right types
+          boundVars = new List<VCExprVar/*!*/>();
+          IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ typeSubst = substitution.ToTypeSubst;
+          Contract.Assert(cce.NonNullDictionaryAndValues(typeSubst));
+          foreach (VCExprVar/*!*/ var in node.BoundVars) {
+            Contract.Assert(var != null);
+            VCExprVar/*!*/ freshVar =
+              Gen.Variable(ChooseNewVariableName(var.Name),
+                           var.Type.Substitute(typeSubst));
+            Contract.Assert(freshVar != null);
+            boundVars.Add(freshVar);
+            substitution[var] = freshVar;
+            // this might overwrite other elements of the substitution, deliberately
+          }
+        }
+
+        List<VCTrigger/*!*/>/*!*/ newTriggers = new List<VCTrigger/*!*/>();
+        foreach (VCTrigger/*!*/ trigger in node.Triggers) {
+          Contract.Assert(trigger != null);
+          newTriggers.Add(Gen.Trigger(trigger.Pos, MutateSeq(trigger.Exprs, substitution)));
+        }
+
+        VCExpr/*!*/ newBody = Mutate(node.Body, substitution);
+        Contract.Assert(newBody != null);
+
+        return Gen.Quantify(node.Quan, typeParams, boundVars,
+                            newTriggers, node.Infos, newBody);
+
+      } finally {
+        substitution.PopScope();
+      }
+    }
+
+    public override VCExpr Visit(VCExprVar node, VCExprSubstitution substitution) {
+      Contract.Requires(substitution != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      VCExpr res = substitution[node];
+      if (res != null)
+        return res;
+      return node;
+    }
+
+    public override VCExpr Visit(VCExprLet node, VCExprSubstitution substitution) {
+      Contract.Requires(substitution != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      // the default is to refresh bound variables only if necessary
+      // because of collisions
+      return Visit(node, substitution, false);
+    }
+
+    public VCExpr Visit(VCExprLet node, VCExprSubstitution substitution, bool refreshBoundVariables) {
+      Contract.Requires(substitution != null);
+      Contract.Requires(node != null);
+      Contract.Ensures(Contract.Result<VCExpr>() != null);
+      // let-expressions do not have type parameters (fortunately ...)
+      substitution.PushScope();
+      try {
+
+        bool refreshAllVariables =
+          refreshBoundVariables ||
+          !substitution.TypeSubstIsEmpty ||
+          CollisionPossible(new List<TypeVariable/*!*/>(), node.BoundVars, substitution);
+
+        List<VCExprVar/*!*/>/*!*/ newBoundVars = node.BoundVars;
+        Contract.Assert(cce.NonNullElements(newBoundVars));
+        if (refreshAllVariables) {
+          // collisions are possible, or we also substitute type variables. in this case
+          // the bound term variables have to be replaced with fresh variables with the
+          // right types
+          newBoundVars = new List<VCExprVar/*!*/>();
+          IDictionary<TypeVariable/*!*/, Type/*!*/>/*!*/ typeSubst = substitution.ToTypeSubst;
+          Contract.Assert(cce.NonNullDictionaryAndValues(typeSubst));
+          foreach (VCExprVar/*!*/ var in node.BoundVars) {
+            Contract.Assert(var != null);
+            VCExprVar/*!*/ freshVar =
+              Gen.Variable(ChooseNewVariableName(var.Name),
+                           var.Type.Substitute(typeSubst));
+            Contract.Assert(freshVar != null);
+            newBoundVars.Add(freshVar);
+            substitution[var] = freshVar;
+            // this might overwrite other elements of the substitution, deliberately
+          }
+        }
+
+        List<VCExprLetBinding/*!*/>/*!*/ newbindings = new List<VCExprLetBinding/*!*/>();
+        for (int i = 0; i < node.Length; ++i) {
+          VCExprLetBinding/*!*/ binding = node[i];
+          Contract.Assert(binding != null);
+          newbindings.Add(Gen.LetBinding(newBoundVars[i], Mutate(binding.E, substitution)));
+        }
+
+        VCExpr/*!*/ newBody = Mutate(node.Body, substitution);
+        Contract.Assert(newBody != null);
+        return Gen.Let(newbindings, newBody);
+
+      } finally {
+        substitution.PopScope();
+      }
+    }
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+  [ContractClassFor(typeof(StandardVCExprOpVisitor<,>))]
+  public abstract class StandardVCExprOpVisitorContracts<Result, Arg> : StandardVCExprOpVisitor<Result, Arg> {
+    protected override Result StandardResult(VCExprNAry node, Arg arg) {
+      Contract.Requires(node != null);
+      throw new NotImplementedException();
+    }
+  }
+
+
+  [ContractClass(typeof(StandardVCExprOpVisitorContracts<,>))]
+  public abstract class StandardVCExprOpVisitor<Result, Arg>
+                        : IVCExprOpVisitor<Result, Arg> {
+    protected abstract Result StandardResult(VCExprNAry/*!*/ node, Arg arg);
+
+    public virtual Result VisitNotOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitEqOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitNeqOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitAndOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitOrOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitImpliesOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitDistinctOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitLabelOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitSelectOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitStoreOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatAddOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatSubOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatMulOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatDivOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatRemOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatMinOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatMaxOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatLeqOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatLtOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatGeqOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatGtOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitFloatEqOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitBvOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitBvExtractOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitBvConcatOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitIfThenElseOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitCustomOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitAddOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitSubOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitMulOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitDivOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitModOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitRealDivOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitPowOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitLtOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitLeOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitGtOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitGeOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitSubtypeOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitSubtype3Op(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitToIntOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitToRealOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitToFloatOp(VCExprNAry node, Arg arg)
+    {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+    public virtual Result VisitBoogieFunctionOp(VCExprNAry node, Arg arg) {
+      //Contract.Requires(node != null);
+      return StandardResult(node, arg);
+    }
+  }
+
 }
 \ No newline at end of file
diff --git a/Source/VCExpr/cce.cs b/Source/VCExpr/cce.cs
index ef594484..1e0b12a5 100644
--- a/Source/VCExpr/cce.cs
+++ b/Source/VCExpr/cce.cs
@@ -1,193 +1,193 @@
-using System;
-using SA=System.Attribute;
-using System.Collections.Generic;
-using System.Diagnostics.Contracts;
-using System.Text;
-//using Microsoft.Boogie;
-
-/// <summary>
-/// A class containing static methods to extend the functionality of Code Contracts
-/// </summary>
-
-public static class cce {
-  //[Pure]
-  //public static bool NonNullElements<T>(Microsoft.Dafny.Graph<T> collection) {
-  //  return collection != null && cce.NonNullElements(collection.TopologicallySortedComponents());
-  //}
-  [Pure]
-  public static T NonNull<T>(T t) {
-    Contract.Assert(t != null);
-    return t;
-  }
-  [Pure]
-  public static bool NonNullElements<T>(IEnumerable<T> collection) {
-    return collection != null && Contract.ForAll(collection, c => c != null);
-  }
-  [Pure]
-  public static bool NonNullElements<TKey, TValue>(IDictionary<TKey, TValue> collection) {
-    return collection != null && Contract.ForAll(collection, pair => NonNullElements(pair));
-  }
-  //[Pure]
-  //public static bool NonNullElements(VariableSeq collection) {
-  //  return collection != null && Contract.ForAll(0, collection.Length, i => collection[i] != null);
-  //}
-  /// <summary>
-  /// For possibly-null lists of non-null elements
-  /// </summary>
-  /// <typeparam name="T"></typeparam>
-  /// <param name="collection"></param>
-  /// <param name="nullability">If true, the collection is treated as an IEnumerable&lt;T!&gt;?, rather than an IEnumerable&lt;T!&gt;!</param>
-  /// <returns></returns>
-  [Pure]
-  public static bool NonNullElements<T>(IEnumerable<T> collection, bool nullability) {
-    return (nullability && collection == null) || cce.NonNullElements(collection);
-    //Should be the same as:
-    /*if(nullability&&collection==null)
-     * return true;
-     * return cce.NonNullElements(collection)
-     */
-
-  }
-  [Pure]
-  public static bool NonNullElements<TKey, TValue>(KeyValuePair<TKey, TValue> kvp) {
-    return kvp.Key != null && kvp.Value != null;
-  }
-  [Pure]
-  public static bool NonNullElements<T>(IEnumerator<T> iEnumerator) {
-    return iEnumerator != null;
-  }
-  //[Pure]
-  //public static bool NonNullElements<T>(Graphing.Graph<T> graph) {
-  //  return cce.NonNullElements(graph.TopologicalSort());
-  //}
-  [Pure]
-  public static void BeginExpose(object o) {
-  }
-  [Pure]
-  public static void EndExpose() {
-  }
-  [Pure]
-  public static bool IsPeerConsistent(object o) {
-    return true;
-  }
-  [Pure]
-  public static bool IsConsistent(object o) {
-    return true;
-  }
-  [Pure]
-  public static bool IsExposable(object o) {
-    return true;
-  }
-  [Pure]
-  public static bool IsExposed(object o) {
-    return true;
-  }
-  [Pure]
-  public static bool IsNew(object o) {
-    return true;
-  }
-  public static class Owner {
-    [Pure]
-    public static bool Same(object o, object p) {
-      return true;
-    }
-    [Pure]
-    public static void AssignSame(object o, object p) {
-    }
-    [Pure]
-    public static object ElementProxy(object o) {
-      return o;
-    }
-    [Pure]
-    public static bool None(object o) {
-      return true;
-    }
-    [Pure]
-    public static bool Different(object o, object p) {
-      return true;
-    }
-    [Pure]
-    public static bool New(object o) {
-      return true;
-    }
-  }
-  [Pure]
-  public static void LoopInvariant(bool p) {
-    Contract.Assert(p);
-  }
-  public class UnreachableException : Exception {
-    public UnreachableException() {
-    }
-  }
-  //[Pure]
-  //public static bool IsValid(Microsoft.Dafny.Expression expression) {
-  //  return true;
-  //}
-  //public static List<T> toList<T>(PureCollections.Sequence s) {
-  //  List<T> toRet = new List<T>();
-  //  foreach (T t in s.elems)
-  //    if(t!=null)
-  //    toRet.Add(t);
-  //  return toRet;
-  //}
-
-  //internal static bool NonNullElements(Set set) {
-  //  return set != null && Contract.ForAll(0,set.Count, i => set[i] != null);
-  //}
-}
-
-public class PeerAttribute : SA {
-}
-public class RepAttribute : SA {
-}
-public class CapturedAttribute : SA {
-}
-public class NotDelayedAttribute : SA {
-}
-public class NoDefaultContractAttribute : SA {
-}
-public class VerifyAttribute : SA {
-  public VerifyAttribute(bool b) {
-
-  }
-}
-public class StrictReadonlyAttribute : SA {
-}
-public class AdditiveAttribute : SA {
-}
-public class ReadsAttribute : SA {
-  public enum Reads {
-    Nothing,
-    Everything,
-  };
-  public ReadsAttribute(object o) {
-  }
-}
-public class GlobalAccessAttribute : SA {
-  public GlobalAccessAttribute(bool b) {
-  }
-}
-public class EscapesAttribute : SA {
-  public EscapesAttribute(bool b, bool b_2) {
-  }
-}
-public class NeedsContractsAttribute : SA {
-  public NeedsContractsAttribute() {
-  }
-  public NeedsContractsAttribute(bool ret, bool parameters) {
-  }
-  public NeedsContractsAttribute(bool ret, int[] parameters) {
-  }
-}
-public class ImmutableAttribute : SA {
-}
-public class InsideAttribute : SA {
-}
-public class SpecPublicAttribute : SA {
-}
-public class ElementsPeerAttribute : SA {
-}
-public class ResultNotNewlyAllocatedAttribute : SA {
-}
-public class OnceAttribute : SA {
+using System;
+using SA=System.Attribute;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.Text;
+//using Microsoft.Boogie;
+
+/// <summary>
+/// A class containing static methods to extend the functionality of Code Contracts
+/// </summary>
+
+public static class cce {
+  //[Pure]
+  //public static bool NonNullElements<T>(Microsoft.Dafny.Graph<T> collection) {
+  //  return collection != null && cce.NonNullElements(collection.TopologicallySortedComponents());
+  //}
+  [Pure]
+  public static T NonNull<T>(T t) {
+    Contract.Assert(t != null);
+    return t;
+  }
+  [Pure]
+  public static bool NonNullElements<T>(IEnumerable<T> collection) {
+    return collection != null && Contract.ForAll(collection, c => c != null);
+  }
+  [Pure]
+  public static bool NonNullElements<TKey, TValue>(IDictionary<TKey, TValue> collection) {
+    return collection != null && Contract.ForAll(collection, pair => NonNullElements(pair));
+  }
+  //[Pure]
+  //public static bool NonNullElements(VariableSeq collection) {
+  //  return collection != null && Contract.ForAll(0, collection.Length, i => collection[i] != null);
+  //}
+  /// <summary>
+  /// For possibly-null lists of non-null elements
+  /// </summary>
+  /// <typeparam name="T"></typeparam>
+  /// <param name="collection"></param>
+  /// <param name="nullability">If true, the collection is treated as an IEnumerable&lt;T!&gt;?, rather than an IEnumerable&lt;T!&gt;!</param>
+  /// <returns></returns>
+  [Pure]
+  public static bool NonNullElements<T>(IEnumerable<T> collection, bool nullability) {
+    return (nullability && collection == null) || cce.NonNullElements(collection);
+    //Should be the same as:
+    /*if(nullability&&collection==null)
+     * return true;
+     * return cce.NonNullElements(collection)
+     */
+
+  }
+  [Pure]
+  public static bool NonNullElements<TKey, TValue>(KeyValuePair<TKey, TValue> kvp) {
+    return kvp.Key != null && kvp.Value != null;
+  }
+  [Pure]
+  public static bool NonNullElements<T>(IEnumerator<T> iEnumerator) {
+    return iEnumerator != null;
+  }
+  //[Pure]
+  //public static bool NonNullElements<T>(Graphing.Graph<T> graph) {
+  //  return cce.NonNullElements(graph.TopologicalSort());
+  //}
+  [Pure]
+  public static void BeginExpose(object o) {
+  }
+  [Pure]
+  public static void EndExpose() {
+  }
+  [Pure]
+  public static bool IsPeerConsistent(object o) {
+    return true;
+  }
+  [Pure]
+  public static bool IsConsistent(object o) {
+    return true;
+  }
+  [Pure]
+  public static bool IsExposable(object o) {
+    return true;
+  }
+  [Pure]
+  public static bool IsExposed(object o) {
+    return true;
+  }
+  [Pure]
+  public static bool IsNew(object o) {
+    return true;
+  }
+  public static class Owner {
+    [Pure]
+    public static bool Same(object o, object p) {
+      return true;
+    }
+    [Pure]
+    public static void AssignSame(object o, object p) {
+    }
+    [Pure]
+    public static object ElementProxy(object o) {
+      return o;
+    }
+    [Pure]
+    public static bool None(object o) {
+      return true;
+    }
+    [Pure]
+    public static bool Different(object o, object p) {
+      return true;
+    }
+    [Pure]
+    public static bool New(object o) {
+      return true;
+    }
+  }
+  [Pure]
+  public static void LoopInvariant(bool p) {
+    Contract.Assert(p);
+  }
+  public class UnreachableException : Exception {
+    public UnreachableException() {
+    }
+  }
+  //[Pure]
+  //public static bool IsValid(Microsoft.Dafny.Expression expression) {
+  //  return true;
+  //}
+  //public static List<T> toList<T>(PureCollections.Sequence s) {
+  //  List<T> toRet = new List<T>();
+  //  foreach (T t in s.elems)
+  //    if(t!=null)
+  //    toRet.Add(t);
+  //  return toRet;
+  //}
+
+  //internal static bool NonNullElements(Set set) {
+  //  return set != null && Contract.ForAll(0,set.Count, i => set[i] != null);
+  //}
+}
+
+public class PeerAttribute : SA {
+}
+public class RepAttribute : SA {
+}
+public class CapturedAttribute : SA {
+}
+public class NotDelayedAttribute : SA {
+}
+public class NoDefaultContractAttribute : SA {
+}
+public class VerifyAttribute : SA {
+  public VerifyAttribute(bool b) {
+
+  }
+}
+public class StrictReadonlyAttribute : SA {
+}
+public class AdditiveAttribute : SA {
+}
+public class ReadsAttribute : SA {
+  public enum Reads {
+    Nothing,
+    Everything,
+  };
+  public ReadsAttribute(object o) {
+  }
+}
+public class GlobalAccessAttribute : SA {
+  public GlobalAccessAttribute(bool b) {
+  }
+}
+public class EscapesAttribute : SA {
+  public EscapesAttribute(bool b, bool b_2) {
+  }
+}
+public class NeedsContractsAttribute : SA {
+  public NeedsContractsAttribute() {
+  }
+  public NeedsContractsAttribute(bool ret, bool parameters) {
+  }
+  public NeedsContractsAttribute(bool ret, int[] parameters) {
+  }
+}
+public class ImmutableAttribute : SA {
+}
+public class InsideAttribute : SA {
+}
+public class SpecPublicAttribute : SA {
+}
+public class ElementsPeerAttribute : SA {
+}
+public class ResultNotNewlyAllocatedAttribute : SA {
+}
+public class OnceAttribute : SA {
 }
 \ No newline at end of file