From 10a8896ae40fd918abbb8caa616ac6ee0876ac1d Mon Sep 17 00:00:00 2001
From: qunyanm <unknown>
Date: Fri, 29 May 2015 16:29:15 -0700
Subject: Add an infinite set collection type.

---
 Source/Dafny/Scanner.cs | 300 +++++++++++++++++++++++++-----------------------
 1 file changed, 156 insertions(+), 144 deletions(-)

(limited to 'Source/Dafny/Scanner.cs')

diff --git a/Source/Dafny/Scanner.cs b/Source/Dafny/Scanner.cs
index 3427477b..4c5eedb4 100644
--- a/Source/Dafny/Scanner.cs
+++ b/Source/Dafny/Scanner.cs
@@ -211,13 +211,13 @@ public class UTF8Buffer: Buffer {
 public class Scanner {
 	const char EOL = '\n';
 	const int eofSym = 0; /* pdt */
-	const int maxT = 136;
-	const int noSym = 136;
+	const int maxT = 137;
+	const int noSym = 137;
 
 
 	[ContractInvariantMethod]
 	void objectInvariant(){
-		Contract.Invariant(buffer!=null);
+		Contract.Invariant(this._buffer != null);
 		Contract.Invariant(t != null);
 		Contract.Invariant(start != null);
 		Contract.Invariant(tokens != null);
@@ -227,7 +227,18 @@ public class Scanner {
 		Contract.Invariant(errorHandler != null);
 	}
 
-	public Buffer/*!*/ buffer; // scanner buffer
+	private Buffer/*!*/ _buffer; // scanner buffer
+
+	public Buffer/*!*/ buffer {
+		get {
+			Contract.Ensures(Contract.Result<Buffer>() != null);
+			return this._buffer;
+		}
+		set {
+			Contract.Requires(value != null);
+			this._buffer = value;
+		}
+	}
 
 	Token/*!*/ t;          // current token
 	int ch;           // current input character
@@ -307,7 +318,7 @@ public class Scanner {
 		t = new Token(); // dummy because t is a non-null field
 		try {
 			Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
-			buffer = new Buffer(stream, false);
+			this._buffer = new Buffer(stream, false);
 			Filename = useBaseName? GetBaseName(fileName): fileName;
 			Init();
 		} catch (IOException) {
@@ -322,7 +333,7 @@ public class Scanner {
 	  Contract.Requires(fileName != null);
 		pt = tokens = new Token();  // first token is a dummy
 		t = new Token(); // dummy because t is a non-null field
-		buffer = new Buffer(s, true);
+		this._buffer = new Buffer(s, true);
 		this.errorHandler = errorHandler;
 		this.Filename = useBaseName? GetBaseName(fileName) : fileName;
 		Init();
@@ -503,75 +514,76 @@ public class Scanner {
 			case "object": t.kind = 11; break;
 			case "string": t.kind = 12; break;
 			case "set": t.kind = 13; break;
-			case "multiset": t.kind = 14; break;
-			case "seq": t.kind = 15; break;
-			case "map": t.kind = 16; break;
-			case "imap": t.kind = 17; break;
-			case "assume": t.kind = 29; break;
-			case "calc": t.kind = 30; break;
-			case "case": t.kind = 31; break;
-			case "then": t.kind = 32; break;
-			case "else": t.kind = 33; break;
-			case "decreases": t.kind = 34; break;
-			case "invariant": t.kind = 35; break;
-			case "function": t.kind = 36; break;
-			case "predicate": t.kind = 37; break;
-			case "inductive": t.kind = 38; break;
-			case "lemma": t.kind = 39; break;
-			case "copredicate": t.kind = 40; break;
-			case "modifies": t.kind = 41; break;
-			case "reads": t.kind = 42; break;
-			case "requires": t.kind = 43; break;
-			case "include": t.kind = 58; break;
-			case "abstract": t.kind = 59; break;
-			case "module": t.kind = 60; break;
-			case "refines": t.kind = 61; break;
-			case "import": t.kind = 62; break;
-			case "opened": t.kind = 63; break;
-			case "as": t.kind = 65; break;
-			case "default": t.kind = 66; break;
-			case "class": t.kind = 67; break;
-			case "extends": t.kind = 68; break;
-			case "trait": t.kind = 69; break;
-			case "ghost": t.kind = 70; break;
-			case "static": t.kind = 71; break;
-			case "protected": t.kind = 72; break;
-			case "datatype": t.kind = 73; break;
-			case "codatatype": t.kind = 74; break;
-			case "var": t.kind = 75; break;
-			case "newtype": t.kind = 76; break;
-			case "type": t.kind = 77; break;
-			case "iterator": t.kind = 78; break;
-			case "yields": t.kind = 79; break;
-			case "returns": t.kind = 80; break;
-			case "method": t.kind = 81; break;
-			case "colemma": t.kind = 82; break;
-			case "comethod": t.kind = 83; break;
-			case "constructor": t.kind = 84; break;
-			case "free": t.kind = 85; break;
-			case "ensures": t.kind = 86; break;
-			case "yield": t.kind = 87; break;
-			case "label": t.kind = 89; break;
-			case "break": t.kind = 90; break;
-			case "where": t.kind = 91; break;
-			case "return": t.kind = 93; break;
-			case "new": t.kind = 95; break;
-			case "if": t.kind = 96; break;
-			case "while": t.kind = 97; break;
-			case "match": t.kind = 98; break;
-			case "assert": t.kind = 99; break;
-			case "print": t.kind = 100; break;
-			case "forall": t.kind = 101; break;
-			case "parallel": t.kind = 102; break;
-			case "modify": t.kind = 103; break;
-			case "exists": t.kind = 122; break;
-			case "in": t.kind = 124; break;
-			case "false": t.kind = 129; break;
-			case "true": t.kind = 130; break;
-			case "null": t.kind = 131; break;
-			case "this": t.kind = 132; break;
-			case "fresh": t.kind = 133; break;
-			case "old": t.kind = 134; break;
+			case "iset": t.kind = 14; break;
+			case "multiset": t.kind = 15; break;
+			case "seq": t.kind = 16; break;
+			case "map": t.kind = 17; break;
+			case "imap": t.kind = 18; break;
+			case "assume": t.kind = 30; break;
+			case "calc": t.kind = 31; break;
+			case "case": t.kind = 32; break;
+			case "then": t.kind = 33; break;
+			case "else": t.kind = 34; break;
+			case "decreases": t.kind = 35; break;
+			case "invariant": t.kind = 36; break;
+			case "function": t.kind = 37; break;
+			case "predicate": t.kind = 38; break;
+			case "inductive": t.kind = 39; break;
+			case "lemma": t.kind = 40; break;
+			case "copredicate": t.kind = 41; break;
+			case "modifies": t.kind = 42; break;
+			case "reads": t.kind = 43; break;
+			case "requires": t.kind = 44; break;
+			case "include": t.kind = 59; break;
+			case "abstract": t.kind = 60; break;
+			case "module": t.kind = 61; break;
+			case "refines": t.kind = 62; break;
+			case "import": t.kind = 63; break;
+			case "opened": t.kind = 64; break;
+			case "as": t.kind = 66; break;
+			case "default": t.kind = 67; break;
+			case "class": t.kind = 68; break;
+			case "extends": t.kind = 69; break;
+			case "trait": t.kind = 70; break;
+			case "ghost": t.kind = 71; break;
+			case "static": t.kind = 72; break;
+			case "protected": t.kind = 73; break;
+			case "datatype": t.kind = 74; break;
+			case "codatatype": t.kind = 75; break;
+			case "var": t.kind = 76; break;
+			case "newtype": t.kind = 77; break;
+			case "type": t.kind = 78; break;
+			case "iterator": t.kind = 79; break;
+			case "yields": t.kind = 80; break;
+			case "returns": t.kind = 81; break;
+			case "method": t.kind = 82; break;
+			case "colemma": t.kind = 83; break;
+			case "comethod": t.kind = 84; break;
+			case "constructor": t.kind = 85; break;
+			case "free": t.kind = 86; break;
+			case "ensures": t.kind = 87; break;
+			case "yield": t.kind = 88; break;
+			case "label": t.kind = 90; break;
+			case "break": t.kind = 91; break;
+			case "where": t.kind = 92; break;
+			case "return": t.kind = 94; break;
+			case "new": t.kind = 96; break;
+			case "if": t.kind = 97; break;
+			case "while": t.kind = 98; break;
+			case "match": t.kind = 99; break;
+			case "assert": t.kind = 100; break;
+			case "print": t.kind = 101; break;
+			case "forall": t.kind = 102; break;
+			case "parallel": t.kind = 103; break;
+			case "modify": t.kind = 104; break;
+			case "exists": t.kind = 123; break;
+			case "in": t.kind = 125; break;
+			case "false": t.kind = 130; break;
+			case "true": t.kind = 131; break;
+			case "null": t.kind = 132; break;
+			case "this": t.kind = 133; break;
+			case "fresh": t.kind = 134; break;
+			case "old": t.kind = 135; break;
 			default: break;
 		}
 	}
@@ -674,7 +686,7 @@ public class Scanner {
 				if (ch >= '0' && ch <= '9' || ch >= 'A' && ch <= 'F' || ch >= 'a' && ch <= 'f') {AddCh(); goto case 15;}
 				else {goto case 0;}
 			case 20:
-				{t.kind = 18; break;}
+				{t.kind = 19; break;}
 			case 21:
 				if (ch <= 9 || ch >= 11 && ch <= 12 || ch >= 14 && ch <= '!' || ch >= '#' && ch <= '[' || ch >= ']' && ch <= 65535) {AddCh(); goto case 21;}
 				else if (ch == '"') {AddCh(); goto case 28;}
@@ -700,37 +712,37 @@ public class Scanner {
 				else if (ch == '"') {AddCh(); goto case 55;}
 				else {goto case 0;}
 			case 28:
-				{t.kind = 19; break;}
+				{t.kind = 20; break;}
 			case 29:
-				{t.kind = 21; break;}
+				{t.kind = 22; break;}
 			case 30:
-				{t.kind = 23; break;}
-			case 31:
 				{t.kind = 24; break;}
+			case 31:
+				{t.kind = 25; break;}
 			case 32:
-				{t.kind = 26; break;}
-			case 33:
 				{t.kind = 27; break;}
-			case 34:
+			case 33:
 				{t.kind = 28; break;}
+			case 34:
+				{t.kind = 29; break;}
 			case 35:
-				{t.kind = 44; break;}
-			case 36:
 				{t.kind = 45; break;}
-			case 37:
+			case 36:
 				{t.kind = 46; break;}
-			case 38:
+			case 37:
 				{t.kind = 47; break;}
-			case 39:
+			case 38:
 				{t.kind = 48; break;}
-			case 40:
+			case 39:
 				{t.kind = 49; break;}
+			case 40:
+				{t.kind = 50; break;}
 			case 41:
-				{t.kind = 53; break;}
-			case 42:
 				{t.kind = 54; break;}
-			case 43:
+			case 42:
 				{t.kind = 55; break;}
+			case 43:
+				{t.kind = 56; break;}
 			case 44:
 				if (ch == 'n') {AddCh(); goto case 45;}
 				else {goto case 0;}
@@ -741,9 +753,9 @@ public class Scanner {
 				{
 					tlen -= apx;
 					SetScannerBehindT();
-					t.kind = 56; break;}
+					t.kind = 57; break;}
 			case 47:
-				{t.kind = 57; break;}
+				{t.kind = 58; break;}
 			case 48:
 				recEnd = pos; recKind = 2;
 				if (ch >= '0' && ch <= '9') {AddCh(); goto case 48;}
@@ -782,9 +794,9 @@ public class Scanner {
 				else if (ch == 'u') {AddCh(); goto case 22;}
 				else {goto case 0;}
 			case 55:
-				recEnd = pos; recKind = 19;
+				recEnd = pos; recKind = 20;
 				if (ch == '"') {AddCh(); goto case 27;}
-				else {t.kind = 19; break;}
+				else {t.kind = 20; break;}
 			case 56:
 				if (ch >= '0' && ch <= '9') {AddCh(); goto case 48;}
 				else {goto case 0;}
@@ -813,9 +825,9 @@ public class Scanner {
 				if (ch == 39 || ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 8;}
 				else {t.kind = 1; t.val = new String(tval, 0, tlen); CheckLiteral(); return t;}
 			case 62:
-				recEnd = pos; recKind = 18;
+				recEnd = pos; recKind = 19;
 				if (ch == 39 || ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 8;}
-				else {t.kind = 18; break;}
+				else {t.kind = 19; break;}
 			case 63:
 				recEnd = pos; recKind = 1;
 				if (ch == 39 || ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'x' || ch == 'z') {AddCh(); goto case 5;}
@@ -832,104 +844,104 @@ public class Scanner {
 				else if (ch >= '0' && ch <= '9') {AddCh(); goto case 65;}
 				else {t.kind = 5; break;}
 			case 66:
-				{t.kind = 88; break;}
+				{t.kind = 89; break;}
 			case 67:
-				{t.kind = 92; break;}
+				{t.kind = 93; break;}
 			case 68:
-				{t.kind = 94; break;}
+				{t.kind = 95; break;}
 			case 69:
-				{t.kind = 104; break;}
+				{t.kind = 105; break;}
 			case 70:
-				{t.kind = 106; break;}
-			case 71:
 				{t.kind = 107; break;}
-			case 72:
+			case 71:
 				{t.kind = 108; break;}
-			case 73:
+			case 72:
 				{t.kind = 109; break;}
-			case 74:
+			case 73:
 				{t.kind = 110; break;}
-			case 75:
+			case 74:
 				{t.kind = 111; break;}
-			case 76:
+			case 75:
 				{t.kind = 112; break;}
+			case 76:
+				{t.kind = 113; break;}
 			case 77:
-				{t.kind = 114; break;}
+				{t.kind = 115; break;}
 			case 78:
 				if (ch == '&') {AddCh(); goto case 79;}
 				else {goto case 0;}
 			case 79:
-				{t.kind = 115; break;}
-			case 80:
 				{t.kind = 116; break;}
-			case 81:
+			case 80:
 				{t.kind = 117; break;}
-			case 82:
+			case 81:
 				{t.kind = 118; break;}
+			case 82:
+				{t.kind = 119; break;}
 			case 83:
-				{t.kind = 120; break;}
-			case 84:
 				{t.kind = 121; break;}
+			case 84:
+				{t.kind = 122; break;}
 			case 85:
-				{t.kind = 123; break;}
+				{t.kind = 124; break;}
 			case 86:
-				{t.kind = 125; break;}
+				{t.kind = 126; break;}
 			case 87:
-				{t.kind = 127; break;}
-			case 88:
 				{t.kind = 128; break;}
+			case 88:
+				{t.kind = 129; break;}
 			case 89:
-				recEnd = pos; recKind = 20;
+				recEnd = pos; recKind = 21;
 				if (ch == ':') {AddCh(); goto case 30;}
 				else if (ch == '=') {AddCh(); goto case 67;}
 				else if (ch == '|') {AddCh(); goto case 68;}
-				else {t.kind = 20; break;}
+				else {t.kind = 21; break;}
 			case 90:
-				recEnd = pos; recKind = 22;
+				recEnd = pos; recKind = 23;
 				if (ch == '|') {AddCh(); goto case 81;}
-				else {t.kind = 22; break;}
+				else {t.kind = 23; break;}
 			case 91:
-				recEnd = pos; recKind = 25;
+				recEnd = pos; recKind = 26;
 				if (ch == '.') {AddCh(); goto case 97;}
-				else {t.kind = 25; break;}
+				else {t.kind = 26; break;}
 			case 92:
-				recEnd = pos; recKind = 64;
+				recEnd = pos; recKind = 65;
 				if (ch == '>') {AddCh(); goto case 33;}
 				else if (ch == '=') {AddCh(); goto case 98;}
-				else {t.kind = 64; break;}
+				else {t.kind = 65; break;}
 			case 93:
-				recEnd = pos; recKind = 126;
+				recEnd = pos; recKind = 127;
 				if (ch == '>') {AddCh(); goto case 34;}
-				else {t.kind = 126; break;}
+				else {t.kind = 127; break;}
 			case 94:
-				recEnd = pos; recKind = 50;
+				recEnd = pos; recKind = 51;
 				if (ch == '=') {AddCh(); goto case 99;}
-				else {t.kind = 50; break;}
+				else {t.kind = 51; break;}
 			case 95:
-				recEnd = pos; recKind = 51;
+				recEnd = pos; recKind = 52;
 				if (ch == '=') {AddCh(); goto case 70;}
-				else {t.kind = 51; break;}
+				else {t.kind = 52; break;}
 			case 96:
-				recEnd = pos; recKind = 119;
+				recEnd = pos; recKind = 120;
 				if (ch == '=') {AddCh(); goto case 41;}
 				else if (ch == 'i') {AddCh(); goto case 44;}
-				else {t.kind = 119; break;}
+				else {t.kind = 120; break;}
 			case 97:
-				recEnd = pos; recKind = 135;
+				recEnd = pos; recKind = 136;
 				if (ch == '.') {AddCh(); goto case 47;}
-				else {t.kind = 135; break;}
+				else {t.kind = 136; break;}
 			case 98:
-				recEnd = pos; recKind = 52;
+				recEnd = pos; recKind = 53;
 				if (ch == '>') {AddCh(); goto case 75;}
-				else {t.kind = 52; break;}
+				else {t.kind = 53; break;}
 			case 99:
-				recEnd = pos; recKind = 105;
+				recEnd = pos; recKind = 106;
 				if (ch == '=') {AddCh(); goto case 100;}
-				else {t.kind = 105; break;}
+				else {t.kind = 106; break;}
 			case 100:
-				recEnd = pos; recKind = 113;
+				recEnd = pos; recKind = 114;
 				if (ch == '>') {AddCh(); goto case 73;}
-				else {t.kind = 113; break;}
+				else {t.kind = 114; break;}
 
 		}
 		t.val = new String(tval, 0, tlen);
-- 
cgit v1.2.3


From 5b3dcd0c09a7ea8a34e7f5e4b8800015b3b07e96 Mon Sep 17 00:00:00 2001
From: Bryan Parno <parno@microsoft.com>
Date: Wed, 1 Jul 2015 12:37:54 -0700
Subject: Add the ability to specify how much "fuel" a function should have,
 i.e., how many times Z3 is permitted to unfold it's definition.  The new
 {:fuel} annotation can be added to the function itself, it which case it will
 apply to all uses of that function, or it can overridden within the scope of
 a module, function, method, iterator, calc, forall, while, assert, or assume.
  The general format is:

{:fuel functionName,lowFuel,highFuel}

When applied as an annotation to the function itself, omit functionName.
If highFuel is omitted, it defaults to lowFuel + 1.

The default fuel setting for recursive functions is 1,2.  Setting the fuel higher,
say, to 3,4, will give more unfoldings, which may make some proofs go through
with less programmer assistance (e.g., with fewer assert statements), but it may
also increase verification time, so use it with care.  Setting the fuel to 0,0 is
similar to making the definition opaque, except when used with all literal arguments.
---
 Source/Dafny/Cloner.cs      |   2 +-
 Source/Dafny/Dafny.atg      |   4 +-
 Source/Dafny/DafnyAst.cs    |  25 ++-
 Source/Dafny/Parser.cs      |  78 ++++----
 Source/Dafny/Resolver.cs    |  74 +++++++-
 Source/Dafny/Scanner.cs     |  31 +---
 Source/Dafny/Translator.cs  | 388 ++++++++++++++++++++++++++++++----------
 Test/dafny0/Fuel.dfy        | 423 ++++++++++++++++++++++++++++++++++++++++++++
 Test/dafny0/Fuel.dfy.expect |  95 ++++++++++
 Test/dafny4/Circ.dfy        |   2 +
 10 files changed, 967 insertions(+), 155 deletions(-)
 create mode 100644 Test/dafny0/Fuel.dfy
 create mode 100644 Test/dafny0/Fuel.dfy.expect

(limited to 'Source/Dafny/Scanner.cs')

diff --git a/Source/Dafny/Cloner.cs b/Source/Dafny/Cloner.cs
index f13aa2f4..e313ffac 100644
--- a/Source/Dafny/Cloner.cs
+++ b/Source/Dafny/Cloner.cs
@@ -545,7 +545,7 @@ namespace Microsoft.Dafny
 
       } else if (stmt is CalcStmt) {
           var s = (CalcStmt)stmt;
-          r = new CalcStmt(Tok(s.Tok), Tok(s.EndTok), CloneCalcOp(s.Op), s.Lines.ConvertAll(CloneExpr), s.Hints.ConvertAll(CloneBlockStmt), s.StepOps.ConvertAll(CloneCalcOp), CloneCalcOp(s.ResultOp));
+          r = new CalcStmt(Tok(s.Tok), Tok(s.EndTok), CloneCalcOp(s.Op), s.Lines.ConvertAll(CloneExpr), s.Hints.ConvertAll(CloneBlockStmt), s.StepOps.ConvertAll(CloneCalcOp), CloneCalcOp(s.ResultOp), CloneAttributes(s.Attributes));
 
       } else if (stmt is MatchStmt) {
         var s = (MatchStmt)stmt;
diff --git a/Source/Dafny/Dafny.atg b/Source/Dafny/Dafny.atg
index 6cc0af5a..5d4a4321 100644
--- a/Source/Dafny/Dafny.atg
+++ b/Source/Dafny/Dafny.atg
@@ -1965,6 +1965,7 @@ ModifyStmt<out Statement s>
 CalcStmt<out Statement s>
 = (. Contract.Ensures(Contract.ValueAtReturn(out s) != null);
      Token x;
+     Attributes attrs = null;
      CalcStmt.CalcOp op, calcOp = Microsoft.Dafny.CalcStmt.DefaultOp, resOp = Microsoft.Dafny.CalcStmt.DefaultOp;
      var lines = new List<Expression>();
      var hints = new List<BlockStmt>();
@@ -1976,6 +1977,7 @@ CalcStmt<out Statement s>
      IToken danglingOperator = null;
   .)
   "calc"                                                  (. x = t; .)
+  { IF(IsAttribute()) Attribute<ref attrs> }
   [ CalcOp<out opTok, out calcOp>                         (. maybeOp = calcOp.ResultOp(calcOp); // guard against non-transitive calcOp (like !=)
                                                              if (maybeOp == null) {
                                                                SemErr(opTok, "the main operator of a calculation must be transitive");
@@ -2024,7 +2026,7 @@ CalcStmt<out Statement s>
       // Repeat the last line to create a dummy line for the dangling hint
       lines.Add(lines[lines.Count - 1]);
     }
-    s = new CalcStmt(x, t, calcOp, lines, hints, stepOps, resOp);
+    s = new CalcStmt(x, t, calcOp, lines, hints, stepOps, resOp, attrs);
   .)
   .
 CalcOp<out IToken x, out CalcStmt.CalcOp/*!*/ op>
diff --git a/Source/Dafny/DafnyAst.cs b/Source/Dafny/DafnyAst.cs
index b8660f98..c9c9ccc8 100644
--- a/Source/Dafny/DafnyAst.cs
+++ b/Source/Dafny/DafnyAst.cs
@@ -314,6 +314,22 @@ namespace Microsoft.Dafny {
       return null;
     }
 
+
+    /// <summary>
+    /// Same as FindExpressions, but returns all matches
+    /// </summary>
+    public static List<List<Expression>> FindAllExpressions(Attributes attrs, string nm) {
+      Contract.Requires(nm != null);
+      List<List<Expression>> ret = null;
+      for (; attrs != null; attrs = attrs.Prev) {
+        if (attrs.Name == nm) {
+          ret = ret ?? new List<List<Expression>>();   // Avoid allocating the list in the common case where we don't find nm
+          ret.Add(attrs.Args);
+        }
+      }
+      return ret;
+    }
+
     /// <summary>
     /// Returns true if "nm" is a specified attribute whose arguments match the "allowed" parameter.
     /// - if "nm" is not found in attrs, return false and leave value unmodified.  Otherwise,
@@ -2874,6 +2890,7 @@ namespace Microsoft.Dafny {
     public override string WhatKind { get { return "function"; } }
     public readonly bool IsProtected;
     public bool IsRecursive;  // filled in during resolution
+    public bool IsFueled;  // filled in during resolution if anyone tries to adjust this function's fuel
     public readonly List<TypeParameter> TypeArgs;
     public readonly List<Formal> Formals;
     public readonly Type ResultType;
@@ -2899,7 +2916,7 @@ namespace Microsoft.Dafny {
         return Contract.Exists(Decreases.Expressions, e => e is WildcardExpr);
       }
     }
-
+    
     /// <summary>
     /// The "AllCalls" field is used for non-FixpointPredicate, non-PrefixPredicate functions only (so its value should not be relied upon for FixpointPredicate and PrefixPredicate functions).
     /// It records all function calls made by the Function, including calls made in the body as well as in the specification.
@@ -2944,6 +2961,7 @@ namespace Microsoft.Dafny {
       Contract.Requires(cce.NonNullElements(ens));
       Contract.Requires(decreases != null);
       this.IsProtected = isProtected;
+      this.IsFueled = false;  // Defaults to false.  Only set to true if someone mentions this function in a fuel annotation
       this.TypeArgs = typeArgs;
       this.Formals = formals;
       this.ResultType = resultType;
@@ -2968,6 +2986,8 @@ namespace Microsoft.Dafny {
     }
     ModuleDefinition ICodeContext.EnclosingModule { get { return this.EnclosingClass.Module; } }
     bool ICodeContext.MustReverify { get { return false; } }
+
+    public bool IsFuelAware() { return IsRecursive || IsFueled; }
   }
 
   public class Predicate : Function
@@ -4640,7 +4660,7 @@ namespace Microsoft.Dafny {
       Contract.Invariant(StepOps.Count == Hints.Count);
     }
 
-    public CalcStmt(IToken tok, IToken endTok, CalcOp op, List<Expression> lines, List<BlockStmt> hints, List<CalcOp> stepOps, CalcOp resultOp)
+    public CalcStmt(IToken tok, IToken endTok, CalcOp op, List<Expression> lines, List<BlockStmt> hints, List<CalcOp> stepOps, CalcOp resultOp, Attributes attrs)
       : base(tok, endTok)
     {
       Contract.Requires(tok != null);
@@ -4665,6 +4685,7 @@ namespace Microsoft.Dafny {
       }
       this.Steps = new List<Expression>();
       this.Result = null;
+      this.Attributes = attrs;
     }
 
     public override IEnumerable<Statement> SubStatements
diff --git a/Source/Dafny/Parser.cs b/Source/Dafny/Parser.cs
index b183fff1..c4047819 100644
--- a/Source/Dafny/Parser.cs
+++ b/Source/Dafny/Parser.cs
@@ -74,8 +74,8 @@ public class Parser {
 	public const int _ellipsis = 58;
 	public const int maxT = 137;
 
-	const bool _T = true;
-	const bool _x = false;
+	const bool T = true;
+	const bool x = false;
 	const int minErrDist = 2;
 
 	public Scanner/*!*/ scanner;
@@ -2565,6 +2565,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 	void CalcStmt(out Statement s) {
 		Contract.Ensures(Contract.ValueAtReturn(out s) != null);
 		Token x;
+		Attributes attrs = null;
 		CalcStmt.CalcOp op, calcOp = Microsoft.Dafny.CalcStmt.DefaultOp, resOp = Microsoft.Dafny.CalcStmt.DefaultOp;
 		var lines = new List<Expression>();
 		var hints = new List<BlockStmt>();
@@ -2577,6 +2578,9 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		
 		Expect(31);
 		x = t; 
+		while (IsAttribute()) {
+			Attribute(ref attrs);
+		}
 		if (StartOf(25)) {
 			CalcOp(out opTok, out calcOp);
 			maybeOp = calcOp.ResultOp(calcOp); // guard against non-transitive calcOp (like !=)
@@ -2631,7 +2635,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		 // Repeat the last line to create a dummy line for the dangling hint
 		 lines.Add(lines[lines.Count - 1]);
 		}
-		s = new CalcStmt(x, t, calcOp, lines, hints, stepOps, resOp);
+		s = new CalcStmt(x, t, calcOp, lines, hints, stepOps, resOp, attrs);
 		
 	}
 
@@ -3988,7 +3992,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 			S = Util.RemoveUnderscores(t.val);
 			try {
-             n = BigIntegerParser.Parse(S);
+			 n = BigIntegerParser.Parse(S);
 			} catch (System.FormatException) {
 			 SemErr("incorrectly formatted number");
 			 n = BigInteger.Zero;
@@ -3999,7 +4003,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			S = Util.RemoveUnderscores(t.val.Substring(2));
 			try {
 			 // note: leading 0 required when parsing positive hex numbers
-             n = BigIntegerParser.Parse("0" + S, System.Globalization.NumberStyles.HexNumber);
+			 n = BigIntegerParser.Parse("0" + S, System.Globalization.NumberStyles.HexNumber);
 			} catch (System.FormatException) {
 			 SemErr("incorrectly formatted number");
 			 n = BigInteger.Zero;
@@ -4364,38 +4368,38 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 	}
 
 	static readonly bool[,]/*!*/ set = {
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_T, _x,_x,_T,_T, _T,_x,_x,_T, _T,_x,_x,_T, _T,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_T,_T, _x,_x,_T,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_x,_T,_T, _x,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_T, _x,_x,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_x,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _T,_x,_x,_x, _x,_x,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_T,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_T, _x,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_x,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_x, _x,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_T, _x,_x,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_x,_T,_T, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_T,_T, _x,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_T,_T, _x,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_T,_T, _x,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_T,_T, _x,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _T,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_x,_x,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_T,_T, _x,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x}
+		{T,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,T, x,x,T,T, T,x,x,T, T,x,x,T, T,x,T,T, T,T,T,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, T,x,T,T, x,x,T,T, T,x,x,T, x,x,T,T, T,T,T,T, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
+		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,x,T, x,x,x,x, T,x,T,T, T,T,T,T, T,T,T,T, x,x,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,T,x,x, T,x,x,x, x,x,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,T,x,x, x,T,T,T, T,T,T,T, T,T,T,T, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,T,T,T, T,T,x,x, x,x,T,x, x,x,x,T, x,x,x,x, x,x,x,x, T,T,x,T, x,T,x,x, T,x,T,T, T,T,T,T, T,T,T,T, x,x,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,T,T,T, T,x,x,x, T,x,T,x, x,T,T,T, x,T,T,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,x,x,T, x,x,T,T, T,T,T,T, x,x,x},
+		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,T,T,T, T,T,x,T, T,T,T,x, x,T,x,T, x,x,x,x, x,x,x,x, T,T,x,T, x,x,x,x, T,x,T,T, T,T,T,T, T,T,T,T, x,x,T,T, T,T,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,T,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,T,T,x, x,T,T,T, T,T,T,T, T,T,T,T, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
+		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,T,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,T,T,T, T,x,x,x, T,x,T,x, x,T,T,T, x,T,T,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,x,x,T, x,x,T,T, T,T,T,T, x,x,x},
+		{T,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
+		{x,T,T,T, T,x,x,x, T,x,T,x, x,T,T,T, x,T,T,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,T,x,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,x,x,T, x,x,T,T, T,T,T,T, x,x,x},
+		{x,T,T,T, T,x,x,x, T,x,T,x, x,T,T,T, x,T,T,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,T,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,x,x,T, x,x,T,T, T,T,T,T, x,x,x},
+		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
+		{x,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,T,T, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
+		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,T,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, T,T,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{x,T,T,T, T,x,x,x, T,x,T,x, x,T,T,T, x,T,T,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,T,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, T,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,x,x,T, x,x,T,T, T,T,T,T, x,x,x},
+		{x,x,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
+		{T,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
+		{x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,T,T,x, x,x,x,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+		{T,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,x, T,T,x,T, x,x,x,x, T,x,T,T, T,T,T,T, T,T,T,T, x,x,T,T, T,T,T,T, T,T,T,T, x,T,T,T, x,T,T,T, T,T,T,T, T,x,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,x,x,x, x,T,T,T, T,T,T,T, T,T,T,T, T,x,x},
+		{T,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,T,T,T, T,T,x,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,x, T,T,T,T, T,T,T,T, T,T,T,x, T,T,x,T, x,x,x,x, T,x,T,T, T,T,T,T, T,T,T,T, x,x,T,T, T,T,T,T, T,T,T,T, x,T,T,x, x,T,T,T, T,T,T,T, T,x,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,x,x,x, x,T,T,T, T,T,T,T, T,T,T,T, T,x,x}
 
 	};
 } // end Parser
diff --git a/Source/Dafny/Resolver.cs b/Source/Dafny/Resolver.cs
index 835871d9..e48a7932 100644
--- a/Source/Dafny/Resolver.cs
+++ b/Source/Dafny/Resolver.cs
@@ -455,6 +455,25 @@ namespace Microsoft.Dafny
           }
         }
       }
+
+      // Determine, for each function, whether someone tries to adjust its fuel parameter
+      foreach (var module in prog.Modules) {
+        CheckForFuelAdjustments(module.tok, module.Attributes, module, this);
+        foreach (var clbl in ModuleDefinition.AllItersAndCallables(module.TopLevelDecls)) {
+          Statement body = null;
+          if (clbl is Method) {
+            body = ((Method)clbl).Body;
+            CheckForFuelAdjustments(clbl.Tok,((Method)clbl).Attributes, module, this);
+          } else if (clbl is IteratorDecl) {
+            body = ((IteratorDecl)clbl).Body;
+            CheckForFuelAdjustments(clbl.Tok, ((IteratorDecl)clbl).Attributes, module, this);
+          }
+          if (body != null) {
+            var c = new FuelAdjustment_Visitor(this);
+            c.Visit(body, new FuelAdjustment_Context(module, this));
+          }
+        }
+      }
     }
 
     void FillInDefaultDecreasesClauses(Program prog)
@@ -683,8 +702,8 @@ namespace Microsoft.Dafny
       var datatypeDependencies = new Graph<IndDatatypeDecl>();
       var codatatypeDependencies = new Graph<CoDatatypeDecl>();
       int prevErrorCount = ErrorCount;
-      ResolveAttributes(m.Attributes, new ResolveOpts(new NoContext(m.Module), false));
       ResolveTopLevelDecls_Signatures(m, m.TopLevelDecls, datatypeDependencies, codatatypeDependencies);
+      ResolveAttributes(m.Attributes, new ResolveOpts(new NoContext(m.Module), false)); // Must follow ResolveTopLevelDecls_Signatures, in case attributes refer to members
       if (ErrorCount == prevErrorCount) {
         ResolveTopLevelDecls_Meat(m.TopLevelDecls, datatypeDependencies, codatatypeDependencies);
       }
@@ -2335,6 +2354,59 @@ namespace Microsoft.Dafny
     }
     #endregion CheckTailRecursive
 
+    // ------------------------------------------------------------------------------------------------------
+    // ----- FuelAdjustmentChecks ---------------------------------------------------------------------------
+    // ------------------------------------------------------------------------------------------------------
+    #region FuelAdjustmentChecks
+
+    protected static void CheckForFuelAdjustments(IToken tok, Attributes attrs, ModuleDefinition currentModule, ResolutionErrorReporter reporter) {
+      List<List<Expression>> results = Attributes.FindAllExpressions(attrs, "fuel");
+
+      if (results != null) {
+        foreach (List<Expression> args in results) {
+          if (args != null && args.Count >= 2) {
+            // Try to extract the function from the first argument
+            MemberSelectExpr selectExpr = args[0].Resolved as MemberSelectExpr;
+            if (selectExpr != null) {
+              Function f = selectExpr.Member as Function;
+              if (f != null) {
+                f.IsFueled = true;
+                if (f.IsProtected && currentModule != f.EnclosingClass.Module) {
+                  reporter.Error(tok, "cannot adjust fuel for protected function {0} from another module", f.Name);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    public class FuelAdjustment_Context
+    {
+      public ModuleDefinition currentModule;
+      public ResolutionErrorReporter reporter;
+      public FuelAdjustment_Context(ModuleDefinition currentModule, ResolutionErrorReporter reporter) {
+        this.currentModule = currentModule;
+        this.reporter = reporter;
+      }
+    }
+
+    class FuelAdjustment_Visitor : ResolverTopDownVisitor<FuelAdjustment_Context>
+    {
+      public FuelAdjustment_Visitor(Resolver resolver)
+        : base(resolver) {
+        Contract.Requires(resolver != null);
+      }
+
+      protected override bool VisitOneStmt(Statement stmt, ref FuelAdjustment_Context st) {
+        Contract.Requires(stmt != null);
+        Resolver.CheckForFuelAdjustments(stmt.Tok, stmt.Attributes, st.currentModule, st.reporter);
+        return true;
+      }
+    }
+
+    #endregion FuelAdjustmentChecks
+
     // ------------------------------------------------------------------------------------------------------
     // ----- FixpointPredicateChecks ------------------------------------------------------------------------
     // ------------------------------------------------------------------------------------------------------
diff --git a/Source/Dafny/Scanner.cs b/Source/Dafny/Scanner.cs
index 4c5eedb4..d0d2e4dd 100644
--- a/Source/Dafny/Scanner.cs
+++ b/Source/Dafny/Scanner.cs
@@ -217,7 +217,7 @@ public class Scanner {
 
 	[ContractInvariantMethod]
 	void objectInvariant(){
-		Contract.Invariant(this._buffer != null);
+		Contract.Invariant(buffer!=null);
 		Contract.Invariant(t != null);
 		Contract.Invariant(start != null);
 		Contract.Invariant(tokens != null);
@@ -227,18 +227,7 @@ public class Scanner {
 		Contract.Invariant(errorHandler != null);
 	}
 
-	private Buffer/*!*/ _buffer; // scanner buffer
-
-	public Buffer/*!*/ buffer {
-		get {
-			Contract.Ensures(Contract.Result<Buffer>() != null);
-			return this._buffer;
-		}
-		set {
-			Contract.Requires(value != null);
-			this._buffer = value;
-		}
-	}
+	public Buffer/*!*/ buffer; // scanner buffer
 
 	Token/*!*/ t;          // current token
 	int ch;           // current input character
@@ -310,7 +299,7 @@ public class Scanner {
 	}
 
 //	[NotDelayed]
-	public Scanner (string/*!*/ fileName, Errors/*!*/ errorHandler, bool useBaseName = false) : base() {
+	public Scanner (string/*!*/ fileName, Errors/*!*/ errorHandler) : base() {
 	  Contract.Requires(fileName != null);
 	  Contract.Requires(errorHandler != null);
 		this.errorHandler = errorHandler;
@@ -318,8 +307,8 @@ public class Scanner {
 		t = new Token(); // dummy because t is a non-null field
 		try {
 			Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
-			this._buffer = new Buffer(stream, false);
-			Filename = useBaseName? GetBaseName(fileName): fileName;
+			buffer = new Buffer(stream, false);
+			Filename = fileName;
 			Init();
 		} catch (IOException) {
 			throw new FatalError("Cannot open file " + fileName);
@@ -327,22 +316,18 @@ public class Scanner {
 	}
 
 //	[NotDelayed]
-	public Scanner (Stream/*!*/ s, Errors/*!*/ errorHandler, string/*!*/ fileName, bool useBaseName = false) : base() {
+	public Scanner (Stream/*!*/ s, Errors/*!*/ errorHandler, string/*!*/ fileName) : base() {
 	  Contract.Requires(s != null);
 	  Contract.Requires(errorHandler != null);
 	  Contract.Requires(fileName != null);
 		pt = tokens = new Token();  // first token is a dummy
 		t = new Token(); // dummy because t is a non-null field
-		this._buffer = new Buffer(s, true);
+		buffer = new Buffer(s, true);
 		this.errorHandler = errorHandler;
-		this.Filename = useBaseName? GetBaseName(fileName) : fileName;
+		this.Filename = fileName;
 		Init();
 	}
 
-    string GetBaseName(string fileName) {
-        return System.IO.Path.GetFileName(fileName); // Return basename
-    }
-
 	void Init() {
 		pos = -1; line = 1; col = 0;
 		oldEols = 0;
diff --git a/Source/Dafny/Translator.cs b/Source/Dafny/Translator.cs
index 4324b2b8..9ba11e2f 100644
--- a/Source/Dafny/Translator.cs
+++ b/Source/Dafny/Translator.cs
@@ -114,6 +114,7 @@ namespace Microsoft.Dafny {
     readonly Dictionary<string, Bpl.Constant> fieldConstants = new Dictionary<string,Constant>();
     readonly ISet<string> abstractTypes = new HashSet<string>();
     readonly ISet<string> opaqueTypes = new HashSet<string>();
+    FuelContext fuelContext = null;
     Program program;
 
     [ContractInvariantMethod]
@@ -625,6 +626,11 @@ namespace Microsoft.Dafny {
     }
     void AddTypeDecl(NewtypeDecl dd) {
       Contract.Requires(dd != null);
+      Contract.Ensures(fuelContext == Contract.OldValue(fuelContext));      
+
+      FuelContext oldFuelContext = this.fuelContext;
+      this.fuelContext = FuelSetting.NewFuelContext(dd);
+
       AddTypeDecl_Aux(dd.tok, dd.FullName, new List<TypeParameter>());
       AddWellformednessCheck(dd);
       // Add $Is and $IsAlloc axioms for the newtype
@@ -667,6 +673,7 @@ namespace Microsoft.Dafny {
 
         sink.AddTopLevelDeclaration(new Bpl.Axiom(dd.tok, BplForall(vars, BplTrigger(is_o), body), name));
       });
+      this.fuelContext = oldFuelContext;
     }
     void AddTypeDecl_Aux(IToken tok, string nm, List<TypeParameter> typeArgs) {
       Contract.Requires(tok != null);
@@ -1181,7 +1188,7 @@ namespace Microsoft.Dafny {
       }
     }
 
-    Bpl.Expr LayerSucc(Bpl.Expr e, int amt = 1) {
+    public Bpl.Expr LayerSucc(Bpl.Expr e, int amt = 1) {
       if (amt == 0) {
         return e;
       } else if (amt > 0) {
@@ -1301,6 +1308,7 @@ namespace Microsoft.Dafny {
     {
       Contract.Requires(sink != null && predef != null);
       Contract.Requires(c != null);
+      Contract.Ensures(fuelContext == Contract.OldValue(fuelContext));
 
       sink.AddTopLevelDeclaration(GetClass(c));
       if (c is ArrayClassDecl) {
@@ -1387,6 +1395,9 @@ namespace Microsoft.Dafny {
 
         } else if (member is Function) {
           var f = (Function)member;
+          FuelContext oldFuelContext = this.fuelContext;
+          this.fuelContext = FuelSetting.NewFuelContext(f);
+
           AddClassMember_Function(f);
           if (!IsOpaqueFunction(f) && !f.IsBuiltin && !(f.tok is IncludeToken)) { // Opaque function's well-formedness is checked on the full version
             AddWellformednessCheck(f);
@@ -1399,9 +1410,11 @@ namespace Microsoft.Dafny {
             AddClassMember_Function(cop.PrefixPredicate);
             // skip the well-formedness check, because it has already been done for the fixpoint-predicate
           }
-
+          this.fuelContext = oldFuelContext;
         } else if (member is Method) {
           Method m = (Method)member;
+          FuelContext oldFuelContext = this.fuelContext;
+          this.fuelContext = FuelSetting.NewFuelContext(m);
 
           // wellformedness check for method specification
           if (m.EnclosingClass is IteratorDecl && m == ((IteratorDecl)m.EnclosingClass).Member_MoveNext) {
@@ -1434,7 +1447,7 @@ namespace Microsoft.Dafny {
             sink.AddTopLevelDeclaration(proc);
             AddMethodImpl(m, proc, false);
           }
-
+          this.fuelContext = oldFuelContext;
         } else {
           Contract.Assert(false); throw new cce.UnreachableException();  // unexpected member
         }
@@ -1467,7 +1480,7 @@ namespace Microsoft.Dafny {
       // declare function
       AddFunction(f);
       // add synonym axiom
-      if (f.IsRecursive) {
+      if (f.IsFuelAware()) {
         AddSynonymAxiom(f);
       }
       // add frame axiom
@@ -1494,6 +1507,10 @@ namespace Microsoft.Dafny {
 
     void AddIteratorSpecAndBody(IteratorDecl iter) {
       Contract.Requires(iter != null);
+      Contract.Ensures(fuelContext == Contract.OldValue(fuelContext));
+
+      FuelContext oldFuelContext = this.fuelContext;      
+      this.fuelContext = FuelSetting.NewFuelContext(iter);
 
       // wellformedness check for method specification
       Bpl.Procedure proc = AddIteratorProc(iter, MethodTranslationKind.SpecWellformedness);
@@ -1506,6 +1523,7 @@ namespace Microsoft.Dafny {
         // ...and its implementation
         AddIteratorImpl(iter, proc);
       }
+      this.fuelContext = oldFuelContext;
     }
 
     Bpl.Procedure AddIteratorProc(IteratorDecl iter, MethodTranslationKind kind) {
@@ -1950,7 +1968,7 @@ namespace Microsoft.Dafny {
       var formals = MkTyParamBinders(GetTypeParams(f), out tyargs);
       var args = new List<Bpl.Expr>();
       Bpl.BoundVariable layer;
-      if (f.IsRecursive) {
+      if (f.IsFuelAware()) {
         layer = new Bpl.BoundVariable(f.tok, new Bpl.TypedIdent(f.tok, "$ly", predef.LayerType));
         formals.Add(layer);
         // Note, "layer" is not added to "args" here; rather, that's done below, as needed
@@ -2121,7 +2139,7 @@ namespace Microsoft.Dafny {
       var formals = MkTyParamBinders(GetTypeParams(f), out tyargs);
 
       Bpl.BoundVariable layer;
-      if (f.IsRecursive) {
+      if (f.IsFuelAware()) {
         layer = new Bpl.BoundVariable(f.tok, new Bpl.TypedIdent(f.tok, "$ly", predef.LayerType));
         formals.Add(layer);
         // Note, "layer" is not added to "args" here; rather, that's done below, as needed
@@ -2317,7 +2335,7 @@ namespace Microsoft.Dafny {
 
     void AddSynonymAxiom(Function f) {
       Contract.Requires(f != null);
-      Contract.Requires(f.IsRecursive);
+      Contract.Requires(f.IsFuelAware());
       Contract.Requires(sink != null && predef != null);
       // axiom  // layer synonym axiom
       //   (forall s, $Heap, formals ::
@@ -2400,7 +2418,7 @@ namespace Microsoft.Dafny {
       var coArgs = new List<Bpl.Expr>(tyexprs);
       var prefixArgs = new List<Bpl.Expr>(tyexprs);
       var prefixArgsLimited = new List<Bpl.Expr>(tyexprs);
-      if (pp.IsRecursive) {
+      if (pp.IsFuelAware()) {
         var sV = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$ly", predef.LayerType));
         var s = new Bpl.IdentifierExpr(tok, sV);
         var succS = FunctionCall(tok, BuiltinFunction.LayerSucc, null, s);
@@ -3073,13 +3091,13 @@ namespace Microsoft.Dafny {
         Bpl.FunctionCall funcIdT = new Bpl.FunctionCall(new Bpl.IdentifierExpr(f.OverriddenFunction.tok, f.OverriddenFunction.FullSanitizedName, TrType(f.OverriddenFunction.ResultType)));
         List<Bpl.Expr> argsC = new List<Bpl.Expr>();
         List<Bpl.Expr> argsT = new List<Bpl.Expr>();
-        if (f.IsRecursive)
+        if (f.IsFuelAware())
         {
-            argsC.Add(etran.LayerN(1));
+            argsC.Add(etran.layerInterCluster.GetFunctionFuel(f));
         }
-        if (f.OverriddenFunction.IsRecursive)
+        if (f.OverriddenFunction.IsFuelAware())
         {
-            argsT.Add(etran.LayerN(1));
+          argsT.Add(etran.layerInterCluster.GetFunctionFuel(f));
         }
         argsC.Add(etran.HeapExpr);
         argsT.Add(etran.HeapExpr);
@@ -3726,7 +3744,7 @@ namespace Microsoft.Dafny {
         var typeParams = TrTypeParamDecls(f.TypeArgs);
         {
           var formals = new List<Variable>();
-          if (f.IsRecursive) {
+          if (f.IsFuelAware()) {
             formals.Add(new Bpl.Formal(f.tok, new Bpl.TypedIdent(f.tok, "$ly", predef.LayerType), true));
           }
           if (!f.IsStatic) {
@@ -3750,7 +3768,7 @@ namespace Microsoft.Dafny {
         List<Bpl.Expr> argsF = new List<Bpl.Expr>();
         List<Bpl.Expr> argsFFrame = new List<Bpl.Expr>();
         List<Bpl.Expr> argsCanCall = new List<Bpl.Expr>();
-        if (f.IsRecursive) {
+        if (f.IsFuelAware()) {
           var sV = new Bpl.BoundVariable(f.tok, new Bpl.TypedIdent(f.tok, "$ly", predef.LayerType));
           var s = new Bpl.IdentifierExpr(f.tok, sV);
           bvars.Add(sV);
@@ -3795,7 +3813,7 @@ namespace Microsoft.Dafny {
         sink.AddTopLevelDeclaration(new Bpl.Axiom(f.tok, ax));
       } else {
 #else
-        // This is the general case
+      // This is the general case
         Bpl.Expr h0; var h0Var = BplBoundVar("$h0", predef.HeapType, out h0);
         Bpl.Expr h1; var h1Var = BplBoundVar("$h1", predef.HeapType, out h1);
 
@@ -3825,7 +3843,7 @@ namespace Microsoft.Dafny {
         var f1args = new List<Bpl.Expr>(tyexprs);
         var f0argsCanCall = new List<Bpl.Expr>(tyexprs);
         var f1argsCanCall = new List<Bpl.Expr>(tyexprs);
-        if (f.IsRecursive) {
+        if (f.IsFuelAware()) {
           Bpl.Expr s; var sV = BplBoundVar("$ly", predef.LayerType, out s);
           bvars.Add(sV);
           f0args.Add(s); f1args.Add(s);  // but don't add to f0argsCanCall or f1argsCanCall
@@ -4066,8 +4084,8 @@ namespace Microsoft.Dafny {
         foreach (var p in GetTypeParams(f)) {
           args.Add(trTypeParam(p, null));
         }
-        if (f.IsRecursive) {
-          args.Add(etran.LayerN(1));
+        if (f.IsFuelAware()) {
+          args.Add(etran.layerInterCluster.GetFunctionFuel(f));
         }
         args.Add(etran.HeapExpr);
         if (!f.IsStatic) {
@@ -4100,8 +4118,8 @@ namespace Microsoft.Dafny {
         foreach (var p in GetTypeParams(f)) {
           args.Add(trTypeParam(p, null));
         }
-        if (f.IsRecursive) {
-          args.Add(etran.LayerN(1));
+        if (f.IsFuelAware()) {
+          args.Add(etran.layerInterCluster.GetFunctionFuel(f));
         }
         args.Add(etran.HeapExpr);
         foreach (Variable p in implInParams) {
@@ -5572,7 +5590,7 @@ namespace Microsoft.Dafny {
           tyargs.Add(TypeToTy(fm.Type));
         }
         tyargs.Add(TypeToTy(f.ResultType));
-        if (f.IsRecursive) {
+        if (f.IsFuelAware()) {
           Bpl.Expr ly; vars.Add(BplBoundVar("$ly", predef.LayerType, out ly)); args.Add(ly);
           formals.Add(BplFormalVar(null, predef.LayerType, true));
         }
@@ -6135,7 +6153,7 @@ namespace Microsoft.Dafny {
         var typeParams = TrTypeParamDecls(f.TypeArgs);
         var formals = new List<Variable>();
         formals.AddRange(MkTyParamFormals(GetTypeParams(f)));
-        if (f.IsRecursive) {
+        if (f.IsFuelAware()) {
           formals.Add(new Bpl.Formal(f.tok, new Bpl.TypedIdent(f.tok, "$ly", predef.LayerType), true));
         }
         formals.Add(new Bpl.Formal(f.tok, new Bpl.TypedIdent(f.tok, "$heap", predef.HeapType), true));
@@ -6212,7 +6230,7 @@ namespace Microsoft.Dafny {
       Contract.Requires(predef != null);
       Contract.Requires(currentModule == null && codeContext == null);
       Contract.Ensures(currentModule == null && codeContext == null);
-      Contract.Ensures(Contract.Result<Bpl.Procedure>() != null);
+      Contract.Ensures(Contract.Result<Bpl.Procedure>() != null);      
 
       currentModule = m.EnclosingClass.Module;
       codeContext = m;
@@ -6495,7 +6513,7 @@ namespace Microsoft.Dafny {
       // parameters of the procedure
       List<Variable> inParams = new List<Variable>();
       Bpl.Formal layer;
-      if (f.IsRecursive) {
+      if (f.IsFuelAware()) {
         layer = new Bpl.Formal(f.tok, new Bpl.TypedIdent(f.tok, "$ly", predef.LayerType), true);
         inParams.Add(layer);
       } else {
@@ -7018,9 +7036,11 @@ namespace Microsoft.Dafny {
       Contract.Requires(locals != null);
       Contract.Requires(etran != null);
       Contract.Requires(codeContext != null && predef != null);
+      Contract.Ensures(fuelContext == Contract.OldValue(fuelContext));
       if (stmt is PredicateStmt) {
+        this.fuelContext = FuelSetting.ExpandFuelContext(stmt.Attributes, this.fuelContext);
         if (stmt is AssertStmt || DafnyOptions.O.DisallowSoundnessCheating) {
-          AddComment(builder, stmt, "assert statement");
+          AddComment(builder, stmt, "assert statement");          
           PredicateStmt s = (PredicateStmt)stmt;
           TrStmt_CheckWellformed(s.Expr, builder, locals, etran, false);
           IToken enclosingToken = null;
@@ -7040,13 +7060,14 @@ namespace Microsoft.Dafny {
               }
             }
             builder.Add(new Bpl.AssumeCmd(stmt.Tok, etran.TrExpr(s.Expr)));
-          }
+          }          
         } else if (stmt is AssumeStmt) {
           AddComment(builder, stmt, "assume statement");
           AssumeStmt s = (AssumeStmt)stmt;
           TrStmt_CheckWellformed(s.Expr, builder, locals, etran, false);
           builder.Add(new Bpl.AssumeCmd(stmt.Tok, etran.TrExpr(s.Expr), etran.TrAttributes(stmt.Attributes, null)));
         }
+        this.fuelContext = FuelSetting.PopFuelContext();
       } else if (stmt is PrintStmt) {
         AddComment(builder, stmt, "print statement");
         PrintStmt s = (PrintStmt)stmt;
@@ -7279,6 +7300,7 @@ namespace Microsoft.Dafny {
 
       } else if (stmt is WhileStmt) {
         AddComment(builder, stmt, "while statement");
+        this.fuelContext = FuelSetting.ExpandFuelContext(stmt.Attributes, this.fuelContext);
         var s = (WhileStmt)stmt;
         BodyTranslator bodyTr = null;
         if (s.Body != null) {
@@ -7289,7 +7311,7 @@ namespace Microsoft.Dafny {
           };
         }
         TrLoop(s, s.Guard, bodyTr, builder, locals, etran);
-
+        this.fuelContext = FuelSetting.PopFuelContext();
       } else if (stmt is AlternativeLoopStmt) {
         AddComment(builder, stmt, "alternative loop statement");
         var s = (AlternativeLoopStmt)stmt;
@@ -7331,6 +7353,7 @@ namespace Microsoft.Dafny {
 
       } else if (stmt is ForallStmt) {
         var s = (ForallStmt)stmt;
+        this.fuelContext = FuelSetting.ExpandFuelContext(stmt.Attributes, this.fuelContext);
         if (s.Kind == ForallStmt.ParBodyKind.Assign) {
           AddComment(builder, stmt, "forall statement (assign)");
           Contract.Assert(s.Ens.Count == 0);
@@ -7374,7 +7397,7 @@ namespace Microsoft.Dafny {
         } else {
           Contract.Assert(false);  // unexpected kind
         }
-
+        this.fuelContext = FuelSetting.PopFuelContext();
       } else if (stmt is CalcStmt) {
         /* Translate into:
         if (*) {
@@ -7397,9 +7420,10 @@ namespace Microsoft.Dafny {
         }
         assume line<0> op line<n>;
         */
-        var s = (CalcStmt)stmt;
+        var s = (CalcStmt)stmt;        
         Contract.Assert(s.Steps.Count == s.Hints.Count); // established by the resolver
         AddComment(builder, stmt, "calc statement");
+        this.fuelContext = FuelSetting.ExpandFuelContext(stmt.Attributes, this.fuelContext);
         CurrentIdGenerator.Push();  // put the entire calc statement within its own sub-branch
         if (s.Lines.Count > 0) {
           Bpl.IfCmd ifCmd = null;
@@ -7464,7 +7488,7 @@ namespace Microsoft.Dafny {
           }
         }
         CurrentIdGenerator.Pop();
-
+        this.fuelContext = FuelSetting.PopFuelContext();
       } else if (stmt is MatchStmt) {
         var s = (MatchStmt)stmt;
         TrStmt_CheckWellformed(s.Source, builder, locals, etran, true);
@@ -10262,6 +10286,227 @@ namespace Microsoft.Dafny {
       }
     }
 
+    internal class FuelSettingPair 
+    {
+      public int low;
+      public int high;
+
+      public FuelSettingPair(int low = (int)FuelSetting.FuelAmount.LOW, int high = (int)FuelSetting.FuelAmount.HIGH) {
+        this.low = low;
+        this.high = high;
+      }
+    }
+
+    // C#'s version of a type alias
+    internal class FuelContext : Dictionary<Function, FuelSettingPair> { }
+
+    internal class FuelSetting
+    {
+      public enum FuelAmount { NONE, LOW, HIGH };
+      public static Stack<FuelContext> SavedContexts = new Stack<FuelContext>();
+
+      private static FuelSettingPair FuelAttrib(Function f) {
+        Contract.Requires(f != null);
+        Contract.Ensures(Contract.Result<FuelSettingPair>() != null);
+        FuelSettingPair setting = new FuelSettingPair();
+
+        if (f.Attributes != null) {
+          List<Expression> args = Attributes.FindExpressions(f.Attributes, "fuel");
+          if (args != null && args.Count >= 2) {
+            LiteralExpr literalLow = args[0] as LiteralExpr;
+            LiteralExpr literalHigh = args[1] as LiteralExpr;
+
+            if (literalLow != null && literalLow.Value is BigInteger && literalHigh != null && literalHigh.Value is BigInteger) {
+              setting.low = (int)((BigInteger)literalLow.Value);
+              setting.high = (int)((BigInteger)literalHigh.Value);
+            }
+          } else if (args != null && args.Count >= 1) {
+            LiteralExpr literal = args[0] as LiteralExpr;
+            if (literal != null && literal.Value is BigInteger) {
+              setting.low = (int)((BigInteger)literal.Value);
+              setting.high = setting.low + 1;
+            }
+          }
+        }
+
+        return setting;
+      }
+
+      public int amount;        // Amount of fuel above that represented by start
+      private Bpl.Expr start;   // Starting fuel argument (null indicates LZ)      
+      private Translator translator;
+
+      public FuelSetting(Translator translator, int amount, Bpl.Expr start = null) {
+        this.translator = translator;
+        this.amount = amount;
+        this.start = start;
+      }
+
+      public FuelSetting Offset(int offset) {
+        return new FuelSetting(translator, this.amount + offset, start);
+      }
+
+      public Bpl.Expr LayerZero() {
+        Contract.Ensures(Contract.Result<Bpl.Expr>() != null);
+        return new Bpl.IdentifierExpr(Token.NoToken, "$LZ", translator.predef.LayerType);
+      }
+
+      public Bpl.Expr LayerN(int n) {
+        Contract.Requires(0 <= n);
+        Contract.Ensures(Contract.Result<Bpl.Expr>() != null);
+        return translator.LayerSucc(LayerZero(), n);
+      }
+
+      private Bpl.Expr ToExpr(int amount) {
+        if (start == null) {
+          return LayerN(amount);
+        } else {
+          return translator.LayerSucc(start, amount);
+        }
+      }
+
+      public Bpl.Expr ToExpr() {
+        return this.ToExpr(this.amount);
+      }
+
+      /// <summary>
+      /// Get the fuel value for this function, given the ambient environment (represented by the fuel setting)
+      /// the function itself, and the function call's context (if any)
+      /// </summary>      
+      public Bpl.Expr GetFunctionFuel(Function f) {
+        Contract.Requires(f != null);
+        if (this.amount == (int)FuelAmount.NONE) {
+          return this.ToExpr();
+        } else {
+          FuelSettingPair setting = null;
+          var found = translator.fuelContext.TryGetValue(f, out setting);
+
+          if (!found) {  // If the context doesn't define fuel for this function, check for a fuel attribute (which supplies a default value if none is found)
+            setting = FuelAttrib(f);
+          }
+
+          if (this.amount == (int)FuelAmount.LOW) {
+            return ToExpr(setting.low);
+          } else if (this.amount == (int)FuelAmount.HIGH) {
+            return ToExpr(setting.high);
+          } else {
+            Contract.Assert(false); // Should not reach here
+            return null;
+          }
+        }
+      }
+
+
+      /// <summary>
+      /// Finds all fuel related attributes of the form {:fuel function low [high]}
+      /// Adds the setting to the context _if_ the context does not already have a setting for that function.
+      /// In other words, it should be called in order from most to least specific contenxt scope.
+      /// </summary>    
+      private static void FindFuelAttributes(Attributes attribs, FuelContext fuelContext) {
+        Function f = null;
+        FuelSettingPair setting = null;
+
+        if (attribs != null) {
+          List<List<Expression>> results = Attributes.FindAllExpressions(attribs, "fuel");
+
+          if (results != null) {
+            foreach (List<Expression> args in results) {
+              if (args != null && args.Count >= 2) {
+                // Try to extract the function from the first argument
+                MemberSelectExpr selectExpr = args[0].Resolved as MemberSelectExpr;
+                if (selectExpr != null) {
+                  f = selectExpr.Member as Function;
+                }
+
+                // Try to extract the lower fuel setting
+                LiteralExpr literalLow = args[1] as LiteralExpr;
+                if (literalLow != null && literalLow.Value is BigInteger) {
+                  setting = new FuelSettingPair();
+                  setting.low = (int)((BigInteger)literalLow.Value);
+                }
+
+                // The user may supply an additional high argument; if not, it defaults to low + 1
+                if (f != null && args.Count >= 3) {
+                  LiteralExpr literalHigh = args[2] as LiteralExpr;
+                  if (setting != null && literalHigh != null && literalHigh.Value is BigInteger) {
+                    setting.high = (int)((BigInteger)literalHigh.Value);
+                    if (!fuelContext.ContainsKey(f)) {
+                      fuelContext.Add(f, setting);
+                    }
+                  }
+                } else if (f != null && setting != null) {
+                  setting.high = setting.low + 1;
+                  if (!fuelContext.ContainsKey(f)) {
+                    fuelContext.Add(f, setting);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      /// <summary>
+      /// Extend the given context with fuel information from the declaration itself, and enclosing modules
+      /// </summary>
+      private static void AddFuelContext(FuelContext context, TopLevelDecl decl) {
+        FindFuelAttributes(decl.Attributes, context);
+
+        var module = decl.Module;
+        while (module != null) {
+          FindFuelAttributes(module.Attributes, context);
+          module = module.Module;
+        }
+      }
+
+      /// <summary>
+      /// Creates a summary of all fuel settings in scope, starting from the given class declaration
+      /// </summary>      
+      public static FuelContext NewFuelContext(TopLevelDecl decl) {
+        FuelContext context = new FuelContext();
+        AddFuelContext(context, decl);
+        return context;
+      }
+
+      /// <summary>
+      /// Creates a summary of all fuel settings in scope, starting from the given member declaration      
+      /// </summary>      
+      public static FuelContext NewFuelContext(MemberDecl decl) {
+        FuelContext context = new FuelContext();
+
+        FindFuelAttributes(decl.Attributes, context);
+        AddFuelContext(context, decl.EnclosingClass);
+        
+        return context;
+      }
+
+      /// <summary>
+      /// Extends the given fuel context with any new fuel settings found in attribs
+      /// </summary>    
+      public static FuelContext ExpandFuelContext(Attributes attribs, FuelContext oldFuelContext) {
+        Contract.Ensures(SavedContexts.Count == Contract.OldValue(SavedContexts.Count) + 1);
+        FuelContext newContext = new FuelContext();
+        FindFuelAttributes(attribs, newContext);
+        if (newContext.Count > 0) {
+          foreach (var pair in oldFuelContext) {
+            if (!newContext.ContainsKey(pair.Key)) {    // Local setting takes precedence over old context
+              newContext.Add(pair.Key, pair.Value);              
+            }
+          }          
+        } else {
+          newContext = oldFuelContext;
+        }
+        SavedContexts.Push(oldFuelContext);
+        return newContext;
+      }
+
+      public static FuelContext PopFuelContext() {
+        Contract.Requires(SavedContexts.Count > 0);
+        return SavedContexts.Pop();
+      }
+
+    }
+
     internal class ExpressionTranslator
     {
       public readonly Bpl.Expr HeapExpr;
@@ -10270,8 +10515,8 @@ namespace Microsoft.Dafny {
       public readonly string This;
       public readonly string modifiesFrame; // the name of the context's frame variable.
       readonly Function applyLimited_CurrentFunction;
-      public readonly Bpl.Expr layerInterCluster;
-      public readonly Bpl.Expr layerIntraCluster = null;  // a value of null says to do the same as for inter-cluster calls
+      public readonly FuelSetting layerInterCluster;
+      public readonly FuelSetting layerIntraCluster = null;  // a value of null says to do the same as for inter-cluster calls
       public int Statistics_CustomLayerFunctionCount = 0;
       public readonly bool ProducingCoCertificates = false;
       [ContractInvariantMethod]
@@ -10287,41 +10532,17 @@ namespace Microsoft.Dafny {
         Contract.Invariant(0 <= Statistics_CustomLayerFunctionCount);
       }
 
-      /// <summary>
-      /// This is a general constructor, but takes the layerInterCluster as an int.
-      /// </summary>
-      ExpressionTranslator(Translator translator, PredefinedDecls predef, Bpl.Expr heap, string thisVar,
-        Function applyLimited_CurrentFunction, int layerInterCluster, Bpl.Expr layerIntraCluster, string modifiesFrame) {
-
-        Contract.Requires(translator != null);
-        Contract.Requires(predef != null);
-        Contract.Requires(heap != null);
-        Contract.Requires(thisVar != null);
-        Contract.Requires(0 <= layerInterCluster);
-        Contract.Requires(modifiesFrame != null);
-
-        this.translator = translator;
-        this.predef = predef;
-        this.HeapExpr = heap;
-        this.This = thisVar;
-        this.applyLimited_CurrentFunction = applyLimited_CurrentFunction;
-        this.layerInterCluster = LayerN(layerInterCluster);
-        this.layerIntraCluster = layerIntraCluster;
-        this.modifiesFrame = modifiesFrame;
-      }
-
       /// <summary>
       /// This is the most general constructor.  It is private and takes all the parameters.  Whenever
       /// one ExpressionTranslator is constructed from another, unchanged parameters are just copied in.
       /// </summary>
       ExpressionTranslator(Translator translator, PredefinedDecls predef, Bpl.Expr heap, string thisVar,
-        Function applyLimited_CurrentFunction, Bpl.Expr layerInterCluster, Bpl.Expr layerIntraCluster, string modifiesFrame) {
+        Function applyLimited_CurrentFunction, FuelSetting layerInterCluster, FuelSetting layerIntraCluster, string modifiesFrame) {
 
         Contract.Requires(translator != null);
         Contract.Requires(predef != null);
         Contract.Requires(heap != null);
-        Contract.Requires(thisVar != null);
-        Contract.Requires(layerInterCluster != null);
+        Contract.Requires(thisVar != null);       
         Contract.Requires(modifiesFrame != null);
 
         this.translator = translator;
@@ -10329,7 +10550,7 @@ namespace Microsoft.Dafny {
         this.HeapExpr = heap;
         this.This = thisVar;
         this.applyLimited_CurrentFunction = applyLimited_CurrentFunction;
-        this.layerInterCluster = layerInterCluster;
+        this.layerInterCluster = layerInterCluster;        
         if (layerIntraCluster == null) {
           this.layerIntraCluster = layerInterCluster;
         } else {
@@ -10365,7 +10586,7 @@ namespace Microsoft.Dafny {
       }
 
       public ExpressionTranslator(Translator translator, PredefinedDecls predef, Bpl.Expr heap, string thisVar)
-        : this(translator, predef, heap, thisVar, null, 1, null, "$_Frame") {
+        : this(translator, predef, heap, thisVar, null, new FuelSetting(translator, 1), null, "$_Frame") {
         Contract.Requires(translator != null);
         Contract.Requires(predef != null);
         Contract.Requires(heap != null);
@@ -10409,7 +10630,7 @@ namespace Microsoft.Dafny {
         Contract.Requires(layerArgument != null);
         Contract.Ensures(Contract.Result<ExpressionTranslator>() != null);
 
-        return new ExpressionTranslator(translator, predef, HeapExpr, This, null, layerArgument, layerArgument, modifiesFrame);
+        return new ExpressionTranslator(translator, predef, HeapExpr, This, null, new FuelSetting(translator, 0, layerArgument), new FuelSetting(translator, 0, layerArgument), modifiesFrame);
       }
 
       public ExpressionTranslator LimitedFunctions(Function applyLimited_CurrentFunction, Bpl.Expr layerArgument) {
@@ -10417,16 +10638,16 @@ namespace Microsoft.Dafny {
         Contract.Requires(layerArgument != null);
         Contract.Ensures(Contract.Result<ExpressionTranslator>() != null);
 
-        return new ExpressionTranslator(translator, predef, HeapExpr, This, applyLimited_CurrentFunction, /* layerArgument */ layerInterCluster, layerArgument, modifiesFrame);
+        return new ExpressionTranslator(translator, predef, HeapExpr, This, applyLimited_CurrentFunction, /* layerArgument */ layerInterCluster, new FuelSetting(translator, 0, layerArgument), modifiesFrame);
       }
 
       public ExpressionTranslator LayerOffset(int offset) {
         Contract.Requires(0 <= offset);
         Contract.Ensures(Contract.Result<ExpressionTranslator>() != null);
 
-        var et = new ExpressionTranslator(translator, predef, HeapExpr, This, applyLimited_CurrentFunction, translator.LayerSucc(layerInterCluster, offset), layerIntraCluster, modifiesFrame);
+        var et = new ExpressionTranslator(translator, predef, HeapExpr, This, applyLimited_CurrentFunction, layerInterCluster.Offset(offset), layerIntraCluster, modifiesFrame);
         if (this.oldEtran != null) {
-          var etOld = new ExpressionTranslator(translator, predef, Old.HeapExpr, This, applyLimited_CurrentFunction, translator.LayerSucc(layerInterCluster, offset), layerIntraCluster, modifiesFrame);
+          var etOld = new ExpressionTranslator(translator, predef, Old.HeapExpr, This, applyLimited_CurrentFunction, layerInterCluster.Offset(offset), layerIntraCluster, modifiesFrame);
           etOld.oldEtran = etOld;
           et.oldEtran = etOld;
         }
@@ -10465,17 +10686,6 @@ namespace Microsoft.Dafny {
         }
       }
 
-      public Bpl.Expr LayerZero() {
-        Contract.Ensures(Contract.Result<Bpl.Expr>() != null);
-        return new Bpl.IdentifierExpr(Token.NoToken, "$LZ", predef.LayerType);
-      }
-
-      public Bpl.Expr LayerN(int n) {
-        Contract.Requires(0 <= n);
-        Contract.Ensures(Contract.Result<Bpl.Expr>() != null);
-        return translator.LayerSucc(LayerZero(), n);
-      }
-
       public Bpl.IdentifierExpr ModuleContextHeight() {
         Contract.Ensures(Contract.Result<Bpl.IdentifierExpr>().Type != null);
         return new Bpl.IdentifierExpr(Token.NoToken, "$ModuleContextHeight", Bpl.Type.Int);
@@ -10649,8 +10859,8 @@ namespace Microsoft.Dafny {
             },
             fn => {
               var args = e.TypeApplication.ConvertAll(translator.TypeToTy);
-              if (fn.IsRecursive) {
-                args.Add(layerInterCluster);
+              if (fn.IsFuelAware()) {
+                args.Add(this.layerInterCluster.GetFunctionFuel(fn));
               }
               if (!fn.IsStatic) {
                 args.Add(/* translator.BoxIfUnboxed */(TrExpr(e.Obj)/*, e.Type */));
@@ -10806,15 +11016,15 @@ namespace Microsoft.Dafny {
         } else if (expr is FunctionCallExpr) {
           FunctionCallExpr e = (FunctionCallExpr)expr;
           Bpl.Expr layerArgument;
-          if (e.Function.IsRecursive) {
+          if (e.Function.IsFuelAware()) {
             Statistics_CustomLayerFunctionCount++;
             ModuleDefinition module = e.Function.EnclosingClass.Module;
             if (this.applyLimited_CurrentFunction != null &&
               this.layerIntraCluster != null &&
               ModuleDefinition.InSameSCC(e.Function, applyLimited_CurrentFunction)) {
-              layerArgument = this.layerIntraCluster;
+              layerArgument = this.layerIntraCluster.GetFunctionFuel(e.Function);
             } else {
-              layerArgument = this.layerInterCluster;
+              layerArgument = this.layerInterCluster.GetFunctionFuel(e.Function);
             }
           } else {
             layerArgument = null;
@@ -10992,7 +11202,7 @@ namespace Microsoft.Dafny {
               if (cot != null) {
                 var e0args = e.E0.Type.NormalizeExpand().TypeArgs;
                 var e1args = e.E1.Type.NormalizeExpand().TypeArgs;
-                return translator.CoEqualCall(cot, e0args, e1args, null, LayerN(2), e0, e1, expr.tok);
+                return translator.CoEqualCall(cot, e0args, e1args, null, this.layerInterCluster.LayerN((int)FuelSetting.FuelAmount.HIGH), e0, e1, expr.tok);
               }
               typ = Bpl.Type.Bool;
               bOpcode = BinaryOperator.Opcode.Eq; break;
@@ -11001,7 +11211,7 @@ namespace Microsoft.Dafny {
               if (cotx != null) {
                 var e0args = e.E0.Type.NormalizeExpand().TypeArgs;
                 var e1args = e.E1.Type.NormalizeExpand().TypeArgs;
-                var x = translator.CoEqualCall(cotx, e0args, e1args, null, LayerN(2), e0, e1, expr.tok);
+                var x = translator.CoEqualCall(cotx, e0args, e1args, null, this.layerInterCluster.LayerN((int)FuelSetting.FuelAmount.HIGH), e0, e1, expr.tok);
                 return Bpl.Expr.Unary(expr.tok, UnaryOperator.Opcode.Not, x);
               }
               typ = Bpl.Type.Bool;
@@ -11282,7 +11492,7 @@ namespace Microsoft.Dafny {
               var e2type = e.E2.Type.NormalizeExpand();
               var cot = e1type.AsCoDatatype;
               Contract.Assert(cot != null);  // the argument types of prefix equality (and prefix disequality) are codatatypes
-              var r = translator.CoEqualCall(cot, e1type.TypeArgs, e2type.TypeArgs, e0, LayerN(2), e1, e2);
+              var r = translator.CoEqualCall(cot, e1type.TypeArgs, e2type.TypeArgs, e0, this.layerInterCluster.LayerN((int)FuelSetting.FuelAmount.HIGH), e1, e2);
               if (e.Op == TernaryExpr.Opcode.PrefixEqOp) {
                 return r;
               } else {
@@ -11315,8 +11525,7 @@ namespace Microsoft.Dafny {
           if (Attributes.ContainsBool(e.Attributes, "layerQuantifier", ref _scratch)) {
             // If this is a layer quantifier, quantify over layers here, and use $LS(ly) layers in the translation of the body
             var ly = BplBoundVar(e.Refresh("q$ly#", translator.CurrentIdGenerator), predef.LayerType, bvars);
-            Expr layer = translator.LayerSucc(ly);
-            bodyEtran = new ExpressionTranslator(translator, predef, HeapExpr, This, applyLimited_CurrentFunction, layer, layer, modifiesFrame);
+            bodyEtran = new ExpressionTranslator(translator, predef, HeapExpr, This, applyLimited_CurrentFunction, new FuelSetting(translator, 1, ly), new FuelSetting(translator, 1, ly), modifiesFrame);
           }
           if (Attributes.ContainsBool(e.Attributes, "heapQuantifier", ref _scratch)) {
             var h = BplBoundVar(e.Refresh("q$heap#", translator.CurrentIdGenerator), predef.HeapType, bvars);
@@ -11489,7 +11698,7 @@ namespace Microsoft.Dafny {
                 new Bpl.LambdaExpr(e.tok, new List<TypeVariable>(), bvars, null, ebody),
                 new Bpl.LambdaExpr(e.tok, new List<TypeVariable>(), bvars, null, reqbody),
                 new Bpl.LambdaExpr(e.tok, new List<TypeVariable>(), bvars, null, rdbody))),
-            layerIntraCluster ?? layerInterCluster),
+                layerIntraCluster != null ? layerIntraCluster.ToExpr() : layerInterCluster.ToExpr()),
           predef.HandleType);
       }
 
@@ -12582,15 +12791,14 @@ namespace Microsoft.Dafny {
           //   checked $PrefixEqual#Dt(k, A, B) || (0 < k ==> A.Cons? ==> B.Cons? && A.head == B.head && $PrefixEqual#2#Dt(k - 1, A.tail, B.tail))  // note the #2 in the recursive call, just like for user-defined predicates that are inlined by TrSplitExpr
           //   free $PrefixEqual#Dt(k, A, B);
           var kPos = Bpl.Expr.Lt(Bpl.Expr.Literal(0), k);
-          var prefixEqK = CoEqualCall(codecl, e1type.TypeArgs, e2type.TypeArgs, k, etran.LayerN(2), A, B); // FunctionCall(expr.tok, CoPrefixName(codecl, 1), Bpl.Type.Bool, k, A, B);
+          var prefixEqK = CoEqualCall(codecl, e1type.TypeArgs, e2type.TypeArgs, k, etran.layerInterCluster.LayerN((int)FuelSetting.FuelAmount.HIGH), A, B); // FunctionCall(expr.tok, CoPrefixName(codecl, 1), Bpl.Type.Bool, k, A, B);
           var kMinusOne = Bpl.Expr.Sub(k, Bpl.Expr.Literal(1));
           // for the inlining of the definition of prefix equality, translate the two main equality operands arguments with a higher offset (to obtain #2 functions)
           var etran2 = etran.LayerOffset(1);
           var A2 = etran2.TrExpr(e.E1);
           var B2 = etran2.TrExpr(e.E2);
           var needsTokenAdjust = TrSplitNeedsTokenAdjustment(expr);
-          // Dan: dafny4/Circ.dfy needs this one to be 2+, rather than 1+
-          Bpl.Expr layer = LayerSucc(etran.layerInterCluster, 2);
+          Bpl.Expr layer = etran.layerInterCluster.LayerN((int)FuelSetting.FuelAmount.HIGH);
           foreach (var c in CoPrefixEquality(needsTokenAdjust ? new ForceCheckToken(expr.tok) : expr.tok, codecl, e1type.TypeArgs, e2type.TypeArgs, kMinusOne, layer, A2, B2, true)) {
             var p = Bpl.Expr.Binary(c.tok, BinaryOperator.Opcode.Or, prefixEqK, Bpl.Expr.Imp(kPos, c));
             splits.Add(new SplitExprInfo(SplitExprInfo.K.Checked, p));
@@ -13944,7 +14152,7 @@ namespace Microsoft.Dafny {
           r = rr;
         } else if (stmt is CalcStmt) {
           var s = (CalcStmt)stmt;
-          var rr = new CalcStmt(s.Tok, s.EndTok, SubstCalcOp(s.Op), s.Lines.ConvertAll(Substitute), s.Hints.ConvertAll(SubstBlockStmt), s.StepOps.ConvertAll(SubstCalcOp), SubstCalcOp(s.ResultOp));
+          var rr = new CalcStmt(s.Tok, s.EndTok, SubstCalcOp(s.Op), s.Lines.ConvertAll(Substitute), s.Hints.ConvertAll(SubstBlockStmt), s.StepOps.ConvertAll(SubstCalcOp), SubstCalcOp(s.ResultOp), SubstAttributes(s.Attributes));
           rr.Steps.AddRange(s.Steps.ConvertAll(Substitute));
           rr.Result = Substitute(s.Result);
           r = rr;
diff --git a/Test/dafny0/Fuel.dfy b/Test/dafny0/Fuel.dfy
new file mode 100644
index 00000000..c8a1fc2f
--- /dev/null
+++ b/Test/dafny0/Fuel.dfy
@@ -0,0 +1,423 @@
+// RUN: %dafny /compile:0 /print:"%t.print" /dprint:"%t.dprint" "%s" > "%t"
+// RUN: %diff "%s.expect" "%t"
+
+module TestModule1 {
+    function pos(x:int) : int 
+    {
+        if x < 0 then 0
+        else 1 + pos(x - 1)
+    }
+
+    method test(y:int, z:int) 
+        requires y > 5;
+        requires z < 0;
+    {
+        assert pos(z) == 0;
+        assert pos(-1) == 0;
+        assert pos(y) == 3 + pos(y - 3);    // error: Should fail, due to lack of fuel
+        assert pos(y) == 4 + pos(y - 4);    // Succeeds, thanks to the assume from the preceding assert
+    }
+}
+
+// Test with function-level fuel boost
+module TestModule2 {
+    function {:fuel 3} pos1(x:int) : int 
+    {
+        if x < 0 then 0
+        else 1 + pos1(x - 1)
+    }
+
+    function {:fuel 3,5} pos2(x:int) : int 
+    {
+        if x < 0 then 0
+        else 1 + pos2(x - 1)
+    }
+
+    function {:fuel 3,5} pos3(x:int) : int 
+    {
+        if x < 0 then 0
+        else 1 + pos3(x - 1)
+    }
+
+    function {:opaque} {:fuel 3,5} pos4(x:int) : int 
+    {
+        if x < 0 then 0
+        else 1 + pos3(x - 1)
+    }
+
+    method test(y:int, z:int) 
+        requires y > 5;
+        requires z < 0;
+    {
+        assert pos1(z) == 0;
+        assert pos1(-1) == 0;
+        assert pos1(y) == 3 + pos1(y - 3);
+        assert pos1(y) == 4 + pos1(y - 4);
+
+        assert pos2(z) == 0;
+        assert pos2(-1) == 0;
+        assert pos2(y) == 3 + pos2(y - 3);
+        assert pos2(y) == 4 + pos2(y - 4);
+
+        if (*) {
+            assert pos3(y) == 5 + pos3(y - 5);  // Just enough fuel to get here
+        } else {
+            assert pos3(y) == 6 + pos3(y - 6);  // error: Should fail even with a boost, since boost is too small
+        }
+
+        if (*) {
+            assert pos4(z) == 0;    // error: Fuel shouldn't overcome opaque
+        } else {
+            reveal_pos4();
+            assert pos4(y) == 5 + pos4(y - 5);  // With reveal, everything should work as above
+        }
+
+
+    }
+}
+
+
+module TestModule3 {
+    // This fuel setting is equivalent to opaque, except for literals
+    function {:fuel 0,0} pos(x:int) : int 
+    {
+        if x < 0 then 0
+        else 1 + pos(x - 1)
+    }
+
+    method test(y:int, z:int) 
+        requires y > 5;
+        requires z < 0;
+    {
+        assert pos(z) == 0;             // error: Opaque setting hides body
+        assert pos(-1) == 0;            // Passes, since Dafny's computation mode for lits ignore fuel
+        assert pos(y) == 3 + pos(y - 3);// error: Opaque setting hides body
+    }
+}
+
+// Test fuel settings via different contexts
+module TestModule4 {
+    function pos(x:int) : int 
+    {
+        if x < 0 then 0
+        else 1 + pos(x - 1)
+    }
+
+    // Should pass
+    method {:fuel pos,3,5} test1(y:int, z:int) 
+        requires y > 5;
+        requires z < 0;
+    {
+        assert pos(z) == 0;
+        assert pos(-1) == 0;
+        assert pos(y) == 3 + pos(y - 3);
+    }
+
+    method {:fuel pos,0,0} test2(y:int, z:int) 
+        requires y > 5;
+        requires z < 0;
+    {
+        assert pos(z) == 0;               // error: Should fail due to "opaque" fuel setting
+        assert pos(-1) == 0;
+        assert pos(y) == 3 + pos(y - 3);  // error: Should fail due to "opaque" fuel setting
+    }
+
+    method test3(y:int, z:int) 
+        requires y > 5;
+        requires z < 0;
+    {
+        assert {:fuel pos,0,0} pos(z) == 0;               // error: Should fail due to "opaque" fuel setting
+        assert pos(-1) == 0;
+        if (*) {
+            assert pos(y) == 3 + pos(y - 3);  // error: Should fail without extra fuel setting
+            assert pos(y) == 6 + pos(y - 6);  // error: Should fail even with previous assert turned into assume
+        } else {
+            assert {:fuel pos,3,5} pos(y) == 3 + pos(y - 3);  // Should succeed with extra fuel setting
+            assert pos(y) == 6 + pos(y - 6);  // Should succeed thanks to previous assert turned into assume
+        } 
+    }
+
+    method test4(y:int, z:int) 
+        requires y > 5;
+        requires z < 0;
+    {
+        forall t:int {:fuel pos,3} | t > 0 
+            ensures true;
+        {
+            assert pos(y) == 3 + pos(y - 3);    // Expected to pass, due to local fuel boost
+        }
+
+        if (*) {
+            calc {:fuel pos,3} {
+                pos(y);
+                3 + pos(y - 3);
+            }
+        }
+
+        assert pos(y) == 3 + pos(y - 3);    // error: Should fail, due to lack of fuel outside the forall
+    }
+}
+
+// Test fuel settings via different module contexts
+module TestModule5 {
+    // Test module level fuel settings, with nested modules
+
+    module TestModule5a {
+        module {:fuel TestModule5aiA.pos,3} TestModule5ai {
+            module TestModule5aiA {
+                function pos(x:int) : int 
+                {
+                    if x < 0 then 0
+                    else 1 + pos(x - 1)
+                }
+
+                method test(y:int, z:int) 
+                    requires y > 5;
+                    requires z < 0;
+                {
+                    assert pos(z) == 0;
+                    assert pos(-1) == 0;
+                    assert pos(y) == 3 + pos(y - 3);    // Should pass due to intermediate module's fuel setting
+                }
+            }
+
+            method test(y:int, z:int) 
+                requires y > 5;
+                requires z < 0;
+            {
+                assert TestModule5aiA.pos(z) == 0;
+                assert TestModule5aiA.pos(-1) == 0;
+                assert TestModule5aiA.pos(y) == 3 + TestModule5aiA.pos(y - 3);    // Should pass due to module level fuel
+            }
+        }
+  
+        method test(y:int, z:int) 
+            requires y > 5;
+            requires z < 0;
+        {
+            assert TestModule5ai.TestModule5aiA.pos(z) == 0;
+            assert TestModule5ai.TestModule5aiA.pos(-1) == 0;
+            assert TestModule5ai.TestModule5aiA.pos(y) == 3 + TestModule5ai.TestModule5aiA.pos(y - 3);    // error: Should fail, due to lack of fuel
+        }
+    }
+
+    module {:fuel TestModule5bi.TestModule5biA.pos,3} TestModule5b {
+        module  TestModule5bi {
+            module TestModule5biA {
+                function pos(x:int) : int 
+                {
+                    if x < 0 then 0
+                    else 1 + pos(x - 1)
+                }
+
+                method test(y:int, z:int) 
+                    requires y > 5;
+                    requires z < 0;
+                {
+                    assert pos(z) == 0;
+                    assert pos(-1) == 0;
+                    assert pos(y) == 3 + pos(y - 3);    // Should succceed due to outer module fuel setting
+                }
+            }
+        }
+    }
+}
+
+// Test fuel setting for multiple functions
+module TestModule6 {
+    function pos(x:int) : int 
+    {
+        if x < 0 then 0
+        else 1 + pos(x - 1)
+    }
+
+    function neg(x:int) : int
+        decreases 1 - x;
+    {
+        if x > 0 then 0
+        else 1 + neg(x + 1)
+    }
+
+    method test1(y:int, z:int) 
+        requires y > 5;
+        requires z < 5;
+    {
+        assert pos(y) == 3 + pos(y - 3);    // error: Should fail, due to lack of fuel
+
+        assert neg(z) == 3 + neg(z + 3);    // error: Should fail, due to lack of fuel
+    }
+
+    method {:fuel pos,3} {:fuel neg,4} test2(y:int, z:int) 
+        requires y > 5;
+        requires z < -5;
+    {
+        assert pos(y) == 3 + pos(y - 3);    
+
+        assert neg(z) == 3 + neg(z + 3);    
+    }
+}
+
+// Test fuel settings with multiple overlapping contexts
+module TestModule7 {
+    function {:fuel 3} pos(x:int) : int 
+    {
+        if x < 0 then 0
+        else 1 + pos(x - 1)
+    }
+
+    function {:fuel 0,0} neg(x:int) : int
+        decreases 1 - x;
+    {
+        if x > 0 then 0
+        else 1 + neg(x + 1)
+    }
+
+    method {:fuel neg,4} {:fuel pos,0,0} test1(y:int, z:int) 
+        requires y > 5;
+        requires z < -5;
+    {
+        if (*) {
+            assert pos(y) == 3 + pos(y - 3);    // error: Method fuel should override function fuel, so this should fail
+            assert neg(z) == 3 + neg(z + 3);    // Method fuel should override function fuel, so this succeeds
+        }
+
+        forall t:int {:fuel pos,3} | t > 0 
+            ensures true;
+        {
+            assert pos(y) == 3 + pos(y - 3);    // Statement fuel should override method fuel, so this should succeed
+        }
+    }
+}
+
+// Test fuel in a slightly more complicated setting
+module TestModule8 {
+
+    newtype byte = i:int | 0 <= i < 0x100
+    newtype uint64 = i:int | 0 <= i < 0x10000000000000000
+
+    datatype G = GUint64
+               | GArray(elt:G)
+               | GTuple(t:seq<G>)
+               | GByteArray
+               | GTaggedUnion(cases:seq<G>)
+
+        datatype V = VUint64(u:uint64)
+                   | VTuple(t:seq<V>)
+                   | VCase(c:uint64, val:V)
+
+        predicate {:fuel 2} ValInGrammar(val:V, grammar:G)
+        {
+            match val
+                case VUint64(_) => grammar.GUint64?
+                case VTuple(t)  => grammar.GTuple? && |t| == |grammar.t|
+                                      && forall i :: 0 <= i < |t| ==> ValInGrammar(t[i], grammar.t[i])
+                case VCase(c, val) => grammar.GTaggedUnion? && int(c) < |grammar.cases| && ValInGrammar(val, grammar.cases[c])
+        }
+
+        datatype CRequest = CRequest(client:EndPoint, seqno:uint64, request:CAppMessage) | CRequestNoOp()
+
+        type EndPoint
+        function method EndPoint_grammar() : G { GUint64 }
+        function method CRequest_grammar() : G { GTaggedUnion([ GTuple([EndPoint_grammar(), GUint64, CAppMessage_grammar()]), GUint64]) }
+
+        function method parse_EndPoint(val:V) : EndPoint
+            requires ValInGrammar(val, EndPoint_grammar());
+
+        type CAppMessage
+        function method CAppMessage_grammar() : G { GTaggedUnion([GUint64, GUint64, GUint64]) }
+        function method parse_AppMessage(val:V) : CAppMessage
+            requires ValInGrammar(val, CAppMessage_grammar());
+
+        function method {:fuel ValInGrammar,1,2} parse_Request1(val:V) : CRequest
+            requires ValInGrammar(val, CRequest_grammar());
+        {
+            if val.c == 0 then
+                var ep := parse_EndPoint(val.val.t[0]); // With default fuel, error: function precondition, destructor, index
+                CRequest(ep, val.val.t[1].u, parse_AppMessage(val.val.t[2]))    // error: index out of range, destructor
+            else 
+                CRequestNoOp()
+        }
+
+        function method parse_Request2(val:V) : CRequest
+            requires ValInGrammar(val, CRequest_grammar());
+        {
+            if val.c == 0 then
+                var ep := parse_EndPoint(val.val.t[0]);                      // With fuel boosted to 2 this succeeds
+                CRequest(ep, val.val.t[1].u, parse_AppMessage(val.val.t[2])) // error: destructor
+            else 
+                CRequestNoOp()
+        }
+
+        function method {:fuel ValInGrammar,3} parse_Request3(val:V) : CRequest
+            requires ValInGrammar(val, CRequest_grammar());
+        {
+            if val.c == 0 then
+                var ep := parse_EndPoint(val.val.t[0]); 
+                CRequest(ep, val.val.t[1].u, parse_AppMessage(val.val.t[2]))    // With one more boost, everything succeeds
+            else 
+                CRequestNoOp()
+        }
+
+        // With the method, everything succeeds with one less fuel boost (i.e., 2, rather than 3, as in parse_Request3)
+        method parse_Request4(val:V) returns (req:CRequest)     
+            requires ValInGrammar(val, CRequest_grammar());
+        {
+            if val.c == 0 {
+                var ep := parse_EndPoint(val.val.t[0]);
+                req := CRequest(ep, val.val.t[1].u, parse_AppMessage(val.val.t[2]));
+            } else {
+                req := CRequestNoOp();
+            }
+        }
+}
+
+
+// Test fuel when it's applied to a non-recursive function
+module TestModule9 {
+    function abs(x:int) : int
+    {
+        if x < 0 then -1 * x else x
+    }
+
+    // All should pass.
+    method test1(y:int, z:int)
+        requires y > 5;
+        requires z < 0;
+    {
+        assert abs(z) == -1*z;
+        assert abs(y) == y;
+        assert abs(-1) == 1;
+    }
+
+    // Method-level fuel override
+    method {:fuel abs,0,0} test2(y:int, z:int)
+        requires y > 5;
+        requires z < 0;
+    {
+        assert abs(z) == -1*z;  // error: Cannot see the body of abs
+        assert abs(y) == y;     // error: Cannot see the body of abs
+        assert abs(-1) == 1;    // lit bypasses fuel, so this should succeed
+    }
+
+    // Statement-level fuel override
+    method test3(y:int, z:int)
+        requires y > 5;
+        requires z < 0;
+    {
+        assert {:fuel abs,0,0} abs(z) == -1*z;  // error: Cannot see the body of abs
+        assert abs(y) == y;     // Normal success
+        assert abs(-1) == 1;    // lit bypasses fuel, so this should succeed
+    }
+
+    // Giving more fuel to a non-recursive function won't help,
+    // but it shouldn't hurt either.
+    method {:fuel abs,5,7} test4(y:int, z:int)
+        requires y > 5;
+        requires z < 0;
+    {
+        assert abs(z) == -1*z;
+        assert abs(y) == y;
+        assert abs(-1) == 1;
+    }
+}
+
diff --git a/Test/dafny0/Fuel.dfy.expect b/Test/dafny0/Fuel.dfy.expect
new file mode 100644
index 00000000..4c180a9c
--- /dev/null
+++ b/Test/dafny0/Fuel.dfy.expect
@@ -0,0 +1,95 @@
+Fuel.dfy(17,23): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+Fuel.dfy(65,28): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+    (0,0): anon6_Else
+Fuel.dfy(69,28): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+    (0,0): anon6_Then
+    (0,0): anon7_Then
+Fuel.dfy(92,23): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+Fuel.dfy(94,23): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+Fuel.dfy(120,23): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+Fuel.dfy(122,23): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+Fuel.dfy(129,39): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+Fuel.dfy(132,27): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+    (0,0): anon3_Then
+Fuel.dfy(133,27): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+    (0,0): anon3_Then
+Fuel.dfy(157,23): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+    (0,0): anon10_Else
+    (0,0): anon9
+Fuel.dfy(200,56): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+Fuel.dfy(245,23): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+Fuel.dfy(247,23): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+Fuel.dfy(280,27): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+    (0,0): anon7_Then
+Fuel.dfy(335,27): Error: possible violation of function precondition
+Fuel.dfy(324,22): Related location
+Execution trace:
+    (0,0): anon0
+    (0,0): anon7_Else
+    (0,0): anon8_Then
+Fuel.dfy(335,50): Error: destructor 't' can only be applied to datatype values constructed by 'VTuple'
+Execution trace:
+    (0,0): anon0
+    (0,0): anon7_Else
+    (0,0): anon8_Then
+Fuel.dfy(335,51): Error: index out of range
+Execution trace:
+    (0,0): anon0
+    (0,0): anon7_Else
+    (0,0): anon8_Then
+Fuel.dfy(336,39): Error: index out of range
+Execution trace:
+    (0,0): anon0
+    (0,0): anon7_Else
+    (0,0): anon8_Then
+Fuel.dfy(336,43): Error: destructor 'u' can only be applied to datatype values constructed by 'VUint64'
+Execution trace:
+    (0,0): anon0
+    (0,0): anon7_Else
+    (0,0): anon8_Then
+Fuel.dfy(346,43): Error: destructor 'u' can only be applied to datatype values constructed by 'VUint64'
+Execution trace:
+    (0,0): anon0
+    (0,0): anon7_Else
+    (0,0): anon8_Then
+Fuel.dfy(397,23): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+Fuel.dfy(398,23): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+Fuel.dfy(407,39): Error: assertion violation
+Execution trace:
+    (0,0): anon0
+
+Dafny program verifier finished with 51 verified, 24 errors
diff --git a/Test/dafny4/Circ.dfy b/Test/dafny4/Circ.dfy
index e7609195..d110c05c 100644
--- a/Test/dafny4/Circ.dfy
+++ b/Test/dafny4/Circ.dfy
@@ -16,6 +16,7 @@ function zip(a: Stream, b: Stream): Stream { Cons(a.head, zip(b, a.tail)) }
 colemma BlinkZipProperty()
   ensures zip(zeros(), ones()) == blink();
 {
+    BlinkZipProperty();
 }
 
 // ----- Thue-Morse sequence -----
@@ -75,6 +76,7 @@ colemma FProperty(s: Stream<Bit>)
     // def. zip
     Cons(s.head, Cons(not(s).head, zip(s.tail, not(s).tail)));
   }
+  FProperty(s.tail);
 }
 
 // The fix-point theorem now follows easily.
-- 
cgit v1.2.3


From 85d4456ccf1e1d8c456dffa012d3f3d724f50a4a Mon Sep 17 00:00:00 2001
From: Michael Lowell Roberts <mirobert@microsoft.com>
Date: Thu, 2 Jul 2015 15:00:52 -0700
Subject: multiple changes... - fix for requirement inheritance in refinement.
 - minimimally viable implementation of exclusive refinement feature.

---
 Source/Dafny/Cloner.cs                |  11 +-
 Source/Dafny/Dafny.atg                |   5 +-
 Source/Dafny/DafnyAst.cs              | 119 ++++-
 Source/Dafny/Makefile                 |   4 +-
 Source/Dafny/Parser.cs                | 962 +++++++++++++++++-----------------
 Source/Dafny/RefinementTransformer.cs |   9 +
 Source/Dafny/Resolver.cs              |  71 ++-
 Source/Dafny/Scanner.cs               | 198 +++----
 Source/Dafny/Translator.cs            |   4 +-
 9 files changed, 768 insertions(+), 615 deletions(-)

(limited to 'Source/Dafny/Scanner.cs')

diff --git a/Source/Dafny/Cloner.cs b/Source/Dafny/Cloner.cs
index e313ffac..6e64c7ec 100644
--- a/Source/Dafny/Cloner.cs
+++ b/Source/Dafny/Cloner.cs
@@ -17,12 +17,15 @@ namespace Microsoft.Dafny
       if (m is DefaultModuleDecl) {
         nw = new DefaultModuleDecl();
       } else {
-        nw = new ModuleDefinition(Tok(m.tok), name, m.IsAbstract, m.IsFacade, m.RefinementBaseName, m.Module, CloneAttributes(m.Attributes), true);
+        nw = new ModuleDefinition(Tok(m.tok), name, m.IsAbstract, m.IsFacade, m.IsExclusiveRefinement, m.RefinementBaseName, m.Module, CloneAttributes(m.Attributes), true);
       }
       foreach (var d in m.TopLevelDecls) {
         nw.TopLevelDecls.Add(CloneDeclaration(d, nw));
       }
-      nw.RefinementBase = m.RefinementBase;
+      if (null != m.RefinementBase) {
+          nw.RefinementBase = m.RefinementBase;
+      }
+      nw.ClonedFrom = m;
       nw.Height = m.Height;
       return nw;
     }
@@ -33,7 +36,7 @@ namespace Microsoft.Dafny
 
       if (d is OpaqueTypeDecl) {
         var dd = (OpaqueTypeDecl)d;
-        return new OpaqueTypeDecl(Tok(dd.tok), dd.Name, m, dd.EqualitySupport, dd.TypeArgs.ConvertAll(CloneTypeParam), CloneAttributes(dd.Attributes));
+        return new OpaqueTypeDecl(Tok(dd.tok), dd.Name, m, dd.EqualitySupport, dd.TypeArgs.ConvertAll(CloneTypeParam), CloneAttributes(dd.Attributes), d);
       } else if (d is TypeSynonymDecl) {
         var dd = (TypeSynonymDecl)d;
         var tps = dd.TypeArgs.ConvertAll(CloneTypeParam);
@@ -138,7 +141,7 @@ namespace Microsoft.Dafny
     }
 
     public TypeParameter CloneTypeParam(TypeParameter tp) {
-      return new TypeParameter(Tok(tp.tok), tp.Name, tp.EqualitySupport);
+      return new TypeParameter(Tok(tp.tok), tp.Name, tp.EqualitySupport, tp);
     }
 
     public MemberDecl CloneMember(MemberDecl member) {
diff --git a/Source/Dafny/Dafny.atg b/Source/Dafny/Dafny.atg
index 5d4a4321..7b51fb5e 100644
--- a/Source/Dafny/Dafny.atg
+++ b/Source/Dafny/Dafny.atg
@@ -542,6 +542,7 @@ SubModuleDecl<ModuleDefinition parent, out ModuleDecl submodule>
      ModuleDecl sm;
      submodule = null; // appease compiler
      bool isAbstract = false;
+     bool isExclusively = false;
      bool opened = false;
   .)
   ( [ "abstract"  (. isAbstract = true; .) ]
@@ -549,7 +550,9 @@ SubModuleDecl<ModuleDefinition parent, out ModuleDecl submodule>
     { Attribute<ref attrs> }
     NoUSIdent<out id>
 
-      [ "refines" QualifiedModuleName<out idRefined> ] (. module = new ModuleDefinition(id, id.val, isAbstract, false, idRefined == null ? null : idRefined, parent, attrs, false); .)
+      [ "exclusively" "refines" QualifiedModuleName<out idRefined> (. isExclusively = true; .)  
+      | "refines" QualifiedModuleName<out idRefined> (. isExclusively = false; .) ] 
+            (. module = new ModuleDefinition(id, id.val, isAbstract, false, isExclusively, idRefined == null ? null : idRefined, parent, attrs, false, this); .)  
        "{"                                             (. module.BodyStartTok = t; .)
         { SubModuleDecl<module, out sm>                (. module.TopLevelDecls.Add(sm); .)
         | ClassDecl<module, out c>                     (. module.TopLevelDecls.Add(c); .)
diff --git a/Source/Dafny/DafnyAst.cs b/Source/Dafny/DafnyAst.cs
index 712cb00a..134fb4c1 100644
--- a/Source/Dafny/DafnyAst.cs
+++ b/Source/Dafny/DafnyAst.cs
@@ -86,7 +86,7 @@ namespace Microsoft.Dafny {
 
   public class BuiltIns
   {
-    public readonly ModuleDefinition SystemModule = new ModuleDefinition(Token.NoToken, "_System", false, false, null, null, null, true);
+    public readonly ModuleDefinition SystemModule = new ModuleDefinition(Token.NoToken, "_System", false, false, /*isExclusiveRefinement:*/ false, null, null, null, true);
     readonly Dictionary<int, ClassDecl> arrayTypeDecls = new Dictionary<int, ClassDecl>();
     readonly Dictionary<int, ArrowTypeDecl> arrowTypeDecls = new Dictionary<int, ArrowTypeDecl>();
     readonly Dictionary<int, TupleTypeDecl> tupleTypeDecls = new Dictionary<int, TupleTypeDecl>();
@@ -1486,6 +1486,8 @@ namespace Microsoft.Dafny {
     IToken INamedRegion.BodyEndTok { get { return BodyEndTok; } }
     string INamedRegion.Name { get { return Name; } }
     string compileName;
+    private readonly Declaration clonedFrom;
+
     public virtual string CompileName {
       get {
         if (compileName == null) {
@@ -1496,12 +1498,19 @@ namespace Microsoft.Dafny {
     }
     public Attributes Attributes;  // readonly, except during class merging in the refinement transformations
 
-    public Declaration(IToken tok, string name, Attributes attributes) {
+    public Declaration(IToken tok, string name, Attributes attributes, Declaration clonedFrom) {
       Contract.Requires(tok != null);
       Contract.Requires(name != null);
       this.tok = tok;
       this.Name = name;
       this.Attributes = attributes;
+      this.clonedFrom = clonedFrom;
+    }
+
+    public Declaration ClonedFrom { 
+      get {
+        return this.clonedFrom;
+      } 
     }
 
     [Pure]
@@ -1513,12 +1522,10 @@ namespace Microsoft.Dafny {
     internal FreshIdGenerator IdGenerator = new FreshIdGenerator();
   }
 
-  public class OpaqueType_AsParameter : TypeParameter
-  {
+  public class OpaqueType_AsParameter : TypeParameter {
     public readonly List<TypeParameter> TypeArgs;
     public OpaqueType_AsParameter(IToken tok, string name, EqualitySupportValue equalitySupport, List<TypeParameter> typeArgs)
-      : base(tok, name, equalitySupport)
-    {
+      : base(tok, name, equalitySupport) {
       Contract.Requires(tok != null);
       Contract.Requires(name != null);
       Contract.Requires(typeArgs != null);
@@ -1566,8 +1573,8 @@ namespace Microsoft.Dafny {
     }
     public int PositionalIndex; // which type parameter this is (ie. in C<S, T, U>, S is 0, T is 1 and U is 2).
 
-    public TypeParameter(IToken tok, string name, EqualitySupportValue equalitySupport = EqualitySupportValue.Unspecified)
-      : base(tok, name, null) {
+    public TypeParameter(IToken tok, string name, EqualitySupportValue equalitySupport = EqualitySupportValue.Unspecified, Declaration clonedFrom = null)
+      : base(tok, name, null, clonedFrom) {
       Contract.Requires(tok != null);
       Contract.Requires(name != null);
       EqualitySupport = equalitySupport;
@@ -1642,7 +1649,7 @@ namespace Microsoft.Dafny {
   }
 
   public class ModuleSignature {
-
+    private ModuleDefinition exclusiveRefinement = null;
     public readonly Dictionary<string, TopLevelDecl> TopLevels = new Dictionary<string, TopLevelDecl>();
     public readonly Dictionary<string, Tuple<DatatypeCtor, bool>> Ctors = new Dictionary<string, Tuple<DatatypeCtor, bool>>();
     public readonly Dictionary<string, MemberDecl> StaticMembers = new Dictionary<string, MemberDecl>();
@@ -1663,6 +1670,25 @@ namespace Microsoft.Dafny {
         return false;
       }
     }
+
+    public ModuleDefinition ExclusiveRefinement {
+      get {
+        if (null == exclusiveRefinement) {
+          return ModuleDef == null ? null : ModuleDef.ExclusiveRefinement;          
+        } else {
+          return exclusiveRefinement;
+        }
+      }
+
+      set {
+        if (null == ExclusiveRefinement) {
+          exclusiveRefinement = null;
+        } else {
+          throw new InvalidOperationException("An exclusive refinement relationship cannot be amended.");
+        }
+      }
+    }
+
   }
 
   public class ModuleDefinition : INamedRegion
@@ -1678,22 +1704,64 @@ namespace Microsoft.Dafny {
     public readonly Attributes Attributes;
     public readonly List<IToken> RefinementBaseName;  // null if no refinement base
     public ModuleDecl RefinementBaseRoot; // filled in early during resolution, corresponds to RefinementBaseName[0]
-    public ModuleDefinition RefinementBase;  // filled in during resolution (null if no refinement base)
+
     public List<Include> Includes;
 
     public readonly List<TopLevelDecl> TopLevelDecls = new List<TopLevelDecl>();  // filled in by the parser; readonly after that
     public readonly Graph<ICallable> CallGraph = new Graph<ICallable>();  // filled in during resolution
     public int Height;  // height in the topological sorting of modules; filled in during resolution
     public readonly bool IsAbstract;
+    public readonly bool IsExclusiveRefinement;
     public readonly bool IsFacade; // True iff this module represents a module facade (that is, an abstract interface)
     private readonly bool IsBuiltinName; // true if this is something like _System that shouldn't have it's name mangled.
+
+    private ModuleDefinition exclusiveRefinement;
+
+    public ModuleDefinition ExclusiveRefinement {
+      get { return exclusiveRefinement; }
+      set {
+        if (null == exclusiveRefinement) {
+          if (!value.IsExclusiveRefinement) {
+            throw new ArgumentException(
+              string.Format("Exclusive refinement of {0} with 'new' module {0} is disallowed.",
+              Name,
+              value.Name));
+          }
+          // todo: validate state of `value`.
+          exclusiveRefinement = value;
+        } else {
+          throw new InvalidOperationException(string.Format("Exclusive refinement of {0} has already been established {1}; cannot reestabilish as {2}.", Name, exclusiveRefinement.Name, value.Name));
+        }
+      }
+    }
+
+    public int ExclusiveRefinementCount { get; set; }
+
+    private ModuleDefinition refinementBase; // filled in during resolution via RefinementBase property (null if no refinement base yet or at all).
+
+    public ModuleDefinition RefinementBase {
+        get {
+           return refinementBase;
+        }
+
+        set {
+          // the refinementBase member may only be changed once.
+          if (null != refinementBase) {
+              throw new InvalidOperationException(string.Format("This module ({0}) already has a refinement base ({1}).", Name, refinementBase.Name));
+          }
+          refinementBase = value;
+        }
+    }
+
+    public ModuleDefinition ClonedFrom { get; set; }
+
     [ContractInvariantMethod]
     void ObjectInvariant() {
       Contract.Invariant(cce.NonNullElements(TopLevelDecls));
       Contract.Invariant(CallGraph != null);
     }
 
-    public ModuleDefinition(IToken tok, string name, bool isAbstract, bool isFacade, List<IToken> refinementBase, ModuleDefinition parent, Attributes attributes, bool isBuiltinName)
+    public ModuleDefinition(IToken tok, string name, bool isAbstract, bool isFacade, bool isExclusiveRefinement, List<IToken> refinementBase, ModuleDefinition parent, Attributes attributes, bool isBuiltinName, Parser parser = null)
     {
       Contract.Requires(tok != null);
       Contract.Requires(name != null);
@@ -1704,8 +1772,9 @@ namespace Microsoft.Dafny {
       RefinementBaseName = refinementBase;
       IsAbstract = isAbstract;
       IsFacade = isFacade;
+      IsExclusiveRefinement = isExclusiveRefinement;
       RefinementBaseRoot = null;
-      RefinementBase = null;
+      this.refinementBase = null;
       Includes = new List<Include>();
       IsBuiltinName = isBuiltinName;
     }
@@ -1844,7 +1913,9 @@ namespace Microsoft.Dafny {
   }
 
   public class DefaultModuleDecl : ModuleDefinition {
-    public DefaultModuleDecl() : base(Token.NoToken, "_module", false, false, null, null, null, true) {
+      public DefaultModuleDecl()
+          : base(Token.NoToken, "_module", false, false, /*isExclusiveRefinement:*/ false, null, null, null, true)
+      {
     }
     public override bool IsDefaultModule {
       get {
@@ -1862,8 +1933,8 @@ namespace Microsoft.Dafny {
       Contract.Invariant(cce.NonNullElements(TypeArgs));
     }
 
-    public TopLevelDecl(IToken tok, string name, ModuleDefinition module, List<TypeParameter> typeArgs, Attributes attributes)
-      : base(tok, name, attributes) {
+    public TopLevelDecl(IToken tok, string name, ModuleDefinition module, List<TypeParameter> typeArgs, Attributes attributes, Declaration clonedFrom = null)
+      : base(tok, name, attributes, clonedFrom) {
       Contract.Requires(tok != null);
       Contract.Requires(name != null);
       Contract.Requires(cce.NonNullElements(typeArgs));
@@ -2116,7 +2187,7 @@ namespace Microsoft.Dafny {
     public List<DatatypeDestructor> Destructors = new List<DatatypeDestructor>();  // contents filled in during resolution; includes both implicit (not mentionable in source) and explicit destructors
 
     public DatatypeCtor(IToken tok, string name, [Captured] List<Formal> formals, Attributes attributes)
-      : base(tok, name, attributes) {
+      : base(tok, name, attributes, null) {
       Contract.Requires(tok != null);
       Contract.Requires(name != null);
       Contract.Requires(cce.NonNullElements(formals));
@@ -2326,7 +2397,7 @@ namespace Microsoft.Dafny {
     public TopLevelDecl EnclosingClass;  // filled in during resolution
     public MemberDecl RefinementBase;  // filled in during the pre-resolution refinement transformation; null if the member is new here
     public MemberDecl(IToken tok, string name, bool hasStaticKeyword, bool isGhost, Attributes attributes)
-      : base(tok, name, attributes) {
+      : base(tok, name, attributes, null) {
       Contract.Requires(tok != null);
       Contract.Requires(name != null);
       HasStaticKeyword = hasStaticKeyword;
@@ -2463,8 +2534,8 @@ namespace Microsoft.Dafny {
       Contract.Invariant(TheType != null && Name == TheType.Name);
     }
 
-    public OpaqueTypeDecl(IToken tok, string name, ModuleDefinition module, TypeParameter.EqualitySupportValue equalitySupport, List<TypeParameter> typeArgs, Attributes attributes)
-      : base(tok, name, module, typeArgs, attributes) {
+    public OpaqueTypeDecl(IToken tok, string name, ModuleDefinition module, TypeParameter.EqualitySupportValue equalitySupport, List<TypeParameter> typeArgs, Attributes attributes, Declaration clonedFrom = null)
+      : base(tok, name, module, typeArgs, attributes, clonedFrom) {
       Contract.Requires(tok != null);
       Contract.Requires(name != null);
       Contract.Requires(module != null);
@@ -3063,7 +3134,7 @@ namespace Microsoft.Dafny {
       prefixPredCall.TypeArgumentSubstitutions = new Dictionary<TypeParameter, Type>();
       var old_to_new = new Dictionary<TypeParameter, TypeParameter>();
       for (int i = 0; i < this.TypeArgs.Count; i++) {
-	 old_to_new[this.TypeArgs[i]] = this.PrefixPredicate.TypeArgs[i];
+   old_to_new[this.TypeArgs[i]] = this.PrefixPredicate.TypeArgs[i];
       }
       foreach (var p in fexp.TypeArgumentSubstitutions) {
         prefixPredCall.TypeArgumentSubstitutions[old_to_new[p.Key]] = p.Value;
@@ -5578,8 +5649,8 @@ namespace Microsoft.Dafny {
       Contract.Invariant(cce.NonNullElements(Arguments));
       Contract.Invariant(cce.NonNullElements(InferredTypeArgs));
       Contract.Invariant(
-	Ctor == null ||
-	InferredTypeArgs.Count == Ctor.EnclosingDatatype.TypeArgs.Count);
+  Ctor == null ||
+  InferredTypeArgs.Count == Ctor.EnclosingDatatype.TypeArgs.Count);
     }
 
     public DatatypeValue(IToken tok, string datatypeName, string memberName, [Captured] List<Expression> arguments)
@@ -6009,10 +6080,10 @@ namespace Microsoft.Dafny {
         Function == null || TypeArgumentSubstitutions == null ||
         Contract.ForAll(
           Function.TypeArgs,
-        	  a => TypeArgumentSubstitutions.ContainsKey(a)) &&
+            a => TypeArgumentSubstitutions.ContainsKey(a)) &&
         Contract.ForAll(
           TypeArgumentSubstitutions.Keys,
-        	  a => Function.TypeArgs.Contains(a) || Function.EnclosingClass.TypeArgs.Contains(a)));
+            a => Function.TypeArgs.Contains(a) || Function.EnclosingClass.TypeArgs.Contains(a)));
     }
 
     public Function Function;  // filled in by resolution
diff --git a/Source/Dafny/Makefile b/Source/Dafny/Makefile
index 4c01c780..e8c0f5e0 100644
--- a/Source/Dafny/Makefile
+++ b/Source/Dafny/Makefile
@@ -4,8 +4,8 @@
 # from http://boogiepartners.codeplex.com/. Update the FRAME_DIR variable to
 # point to whatever directory you install that into.
 # ###############################################################################
-COCO_EXE_DIR = ..\..\..\boogiepartners\CocoRdownload
-FRAME_DIR = ..\..\..\boogiepartners\CocoR\Modified
+COCO_EXE_DIR = ..\..\..\boogie-partners\CocoRdownload
+FRAME_DIR = ..\..\..\boogie-partners\CocoR\Modified
 COCO = $(COCO_EXE_DIR)\Coco.exe
 
 # "all" depends on 2 files, really (Parser.cs and Scanner.cs), but they
diff --git a/Source/Dafny/Parser.cs b/Source/Dafny/Parser.cs
index c4047819..a90e650a 100644
--- a/Source/Dafny/Parser.cs
+++ b/Source/Dafny/Parser.cs
@@ -72,10 +72,10 @@ public class Parser {
 	public const int _star = 56;
 	public const int _notIn = 57;
 	public const int _ellipsis = 58;
-	public const int maxT = 137;
+	public const int maxT = 138;
 
-	const bool T = true;
-	const bool x = false;
+	const bool _T = true;
+	const bool _x = false;
 	const int minErrDist = 2;
 
 	public Scanner/*!*/ scanner;
@@ -540,42 +540,42 @@ bool IsType(ref IToken pt) {
 		}
 		while (StartOf(1)) {
 			switch (la.kind) {
-			case 60: case 61: case 63: {
+			case 60: case 61: case 64: {
 				SubModuleDecl(defaultModule, out submodule);
 				defaultModule.TopLevelDecls.Add(submodule); 
 				break;
 			}
-			case 68: {
+			case 69: {
 				ClassDecl(defaultModule, out c);
 				defaultModule.TopLevelDecls.Add(c); 
 				break;
 			}
-			case 74: case 75: {
+			case 75: case 76: {
 				DatatypeDecl(defaultModule, out dt);
 				defaultModule.TopLevelDecls.Add(dt); 
 				break;
 			}
-			case 77: {
+			case 78: {
 				NewtypeDecl(defaultModule, out td);
 				defaultModule.TopLevelDecls.Add(td); 
 				break;
 			}
-			case 78: {
+			case 79: {
 				OtherTypeDecl(defaultModule, out td);
 				defaultModule.TopLevelDecls.Add(td); 
 				break;
 			}
-			case 79: {
+			case 80: {
 				IteratorDecl(defaultModule, out iter);
 				defaultModule.TopLevelDecls.Add(iter); 
 				break;
 			}
-			case 70: {
+			case 71: {
 				TraitDecl(defaultModule, out trait);
 				defaultModule.TopLevelDecls.Add(trait); 
 				break;
 			}
-			case 37: case 38: case 39: case 40: case 41: case 71: case 72: case 73: case 76: case 82: case 83: case 84: case 85: {
+			case 37: case 38: case 39: case 40: case 41: case 72: case 73: case 74: case 77: case 83: case 84: case 85: case 86: {
 				ClassMemberDecl(membersDefaultClass, false, !DafnyOptions.O.AllowGlobals);
 				break;
 			}
@@ -606,6 +606,7 @@ bool IsType(ref IToken pt) {
 		ModuleDecl sm;
 		submodule = null; // appease compiler
 		bool isAbstract = false;
+		bool isExclusively = false;
 		bool opened = false;
 		
 		if (la.kind == 60 || la.kind == 61) {
@@ -618,51 +619,59 @@ bool IsType(ref IToken pt) {
 				Attribute(ref attrs);
 			}
 			NoUSIdent(out id);
-			if (la.kind == 62) {
-				Get();
-				QualifiedModuleName(out idRefined);
+			if (la.kind == 62 || la.kind == 63) {
+				if (la.kind == 62) {
+					Get();
+					Expect(63);
+					QualifiedModuleName(out idRefined);
+					isExclusively = true; 
+				} else {
+					Get();
+					QualifiedModuleName(out idRefined);
+					isExclusively = false; 
+				}
 			}
-			module = new ModuleDefinition(id, id.val, isAbstract, false, idRefined == null ? null : idRefined, parent, attrs, false); 
+			module = new ModuleDefinition(id, id.val, isAbstract, false, isExclusively, idRefined == null ? null : idRefined, parent, attrs, false, this); 
 			Expect(45);
 			module.BodyStartTok = t; 
 			while (StartOf(1)) {
 				switch (la.kind) {
-				case 60: case 61: case 63: {
+				case 60: case 61: case 64: {
 					SubModuleDecl(module, out sm);
 					module.TopLevelDecls.Add(sm); 
 					break;
 				}
-				case 68: {
+				case 69: {
 					ClassDecl(module, out c);
 					module.TopLevelDecls.Add(c); 
 					break;
 				}
-				case 70: {
+				case 71: {
 					TraitDecl(module, out trait);
 					module.TopLevelDecls.Add(trait); 
 					break;
 				}
-				case 74: case 75: {
+				case 75: case 76: {
 					DatatypeDecl(module, out dt);
 					module.TopLevelDecls.Add(dt); 
 					break;
 				}
-				case 77: {
+				case 78: {
 					NewtypeDecl(module, out td);
 					module.TopLevelDecls.Add(td); 
 					break;
 				}
-				case 78: {
+				case 79: {
 					OtherTypeDecl(module, out td);
 					module.TopLevelDecls.Add(td); 
 					break;
 				}
-				case 79: {
+				case 80: {
 					IteratorDecl(module, out iter);
 					module.TopLevelDecls.Add(iter); 
 					break;
 				}
-				case 37: case 38: case 39: case 40: case 41: case 71: case 72: case 73: case 76: case 82: case 83: case 84: case 85: {
+				case 37: case 38: case 39: case 40: case 41: case 72: case 73: case 74: case 77: case 83: case 84: case 85: case 86: {
 					ClassMemberDecl(namedModuleDefaultClassMembers, false, !DafnyOptions.O.AllowGlobals);
 					break;
 				}
@@ -672,22 +681,22 @@ bool IsType(ref IToken pt) {
 			module.BodyEndTok = t;
 			module.TopLevelDecls.Add(new DefaultClassDecl(module, namedModuleDefaultClassMembers));
 			submodule = new LiteralModuleDecl(module, parent); 
-		} else if (la.kind == 63) {
+		} else if (la.kind == 64) {
 			Get();
-			if (la.kind == 64) {
+			if (la.kind == 65) {
 				Get();
 				opened = true;
 			}
 			NoUSIdent(out id);
-			if (la.kind == 65 || la.kind == 66) {
-				if (la.kind == 65) {
+			if (la.kind == 66 || la.kind == 67) {
+				if (la.kind == 66) {
 					Get();
 					QualifiedModuleName(out idPath);
 					submodule = new AliasModuleDecl(idPath, id, parent, opened); 
 				} else {
 					Get();
 					QualifiedModuleName(out idPath);
-					if (la.kind == 67) {
+					if (la.kind == 68) {
 						Get();
 						QualifiedModuleName(out idAssignment);
 					}
@@ -695,7 +704,7 @@ bool IsType(ref IToken pt) {
 				}
 			}
 			if (la.kind == 27) {
-				while (!(la.kind == 0 || la.kind == 27)) {SynErr(138); Get();}
+				while (!(la.kind == 0 || la.kind == 27)) {SynErr(139); Get();}
 				Get();
 				errors.Warning(t, "the semi-colon that used to terminate a sub-module declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 			}
@@ -705,7 +714,7 @@ bool IsType(ref IToken pt) {
 			 submodule = new AliasModuleDecl(idPath, id, parent, opened);
 			}
 			
-		} else SynErr(139);
+		} else SynErr(140);
 	}
 
 	void ClassDecl(ModuleDefinition/*!*/ module, out ClassDecl/*!*/ c) {
@@ -719,8 +728,8 @@ bool IsType(ref IToken pt) {
 		List<MemberDecl/*!*/> members = new List<MemberDecl/*!*/>();
 		IToken bodyStart;
 		
-		while (!(la.kind == 0 || la.kind == 68)) {SynErr(140); Get();}
-		Expect(68);
+		while (!(la.kind == 0 || la.kind == 69)) {SynErr(141); Get();}
+		Expect(69);
 		while (la.kind == 45) {
 			Attribute(ref attrs);
 		}
@@ -728,7 +737,7 @@ bool IsType(ref IToken pt) {
 		if (la.kind == 51) {
 			GenericParameters(typeArgs);
 		}
-		if (la.kind == 69) {
+		if (la.kind == 70) {
 			Get();
 			Type(out trait);
 			traits.Add(trait); 
@@ -760,13 +769,13 @@ bool IsType(ref IToken pt) {
 		IToken bodyStart = Token.NoToken;  // dummy assignment
 		bool co = false;
 		
-		while (!(la.kind == 0 || la.kind == 74 || la.kind == 75)) {SynErr(141); Get();}
-		if (la.kind == 74) {
+		while (!(la.kind == 0 || la.kind == 75 || la.kind == 76)) {SynErr(142); Get();}
+		if (la.kind == 75) {
 			Get();
-		} else if (la.kind == 75) {
+		} else if (la.kind == 76) {
 			Get();
 			co = true; 
-		} else SynErr(142);
+		} else SynErr(143);
 		while (la.kind == 45) {
 			Attribute(ref attrs);
 		}
@@ -774,7 +783,7 @@ bool IsType(ref IToken pt) {
 		if (la.kind == 51) {
 			GenericParameters(typeArgs);
 		}
-		Expect(65);
+		Expect(66);
 		bodyStart = t; 
 		DatatypeMemberDecl(ctors);
 		while (la.kind == 23) {
@@ -782,7 +791,7 @@ bool IsType(ref IToken pt) {
 			DatatypeMemberDecl(ctors);
 		}
 		if (la.kind == 27) {
-			while (!(la.kind == 0 || la.kind == 27)) {SynErr(143); Get();}
+			while (!(la.kind == 0 || la.kind == 27)) {SynErr(144); Get();}
 			Get();
 			errors.Warning(t, "the semi-colon that used to terminate a (co)datatype declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 		}
@@ -803,12 +812,12 @@ bool IsType(ref IToken pt) {
 		Type baseType = null;
 		Expression wh;
 		
-		Expect(77);
+		Expect(78);
 		while (la.kind == 45) {
 			Attribute(ref attrs);
 		}
 		NoUSIdent(out id);
-		Expect(65);
+		Expect(66);
 		if (IsIdentColonOrBar()) {
 			NoUSIdent(out bvId);
 			if (la.kind == 21) {
@@ -822,7 +831,7 @@ bool IsType(ref IToken pt) {
 		} else if (StartOf(3)) {
 			Type(out baseType);
 			td = new NewtypeDecl(theVerifyThisFile ? id : new IncludeToken(id), id.val, module, baseType, attrs); 
-		} else SynErr(144);
+		} else SynErr(145);
 	}
 
 	void OtherTypeDecl(ModuleDefinition module, out TopLevelDecl td) {
@@ -833,7 +842,7 @@ bool IsType(ref IToken pt) {
 		td = null;
 		Type ty;
 		
-		Expect(78);
+		Expect(79);
 		while (la.kind == 45) {
 			Attribute(ref attrs);
 		}
@@ -850,18 +859,18 @@ bool IsType(ref IToken pt) {
 			if (la.kind == 51) {
 				GenericParameters(typeArgs);
 			}
-			if (la.kind == 65) {
+			if (la.kind == 66) {
 				Get();
 				Type(out ty);
 				td = new TypeSynonymDecl(id, id.val, typeArgs, module, ty, attrs); 
 			}
-		} else SynErr(145);
+		} else SynErr(146);
 		if (td == null) {
 		 td = new OpaqueTypeDecl(id, id.val, module, eqSupport, typeArgs, attrs);
 		}
 		
 		if (la.kind == 27) {
-			while (!(la.kind == 0 || la.kind == 27)) {SynErr(146); Get();}
+			while (!(la.kind == 0 || la.kind == 27)) {SynErr(147); Get();}
 			Get();
 			errors.Warning(t, "the semi-colon that used to terminate an opaque-type declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 		}
@@ -890,8 +899,8 @@ bool IsType(ref IToken pt) {
 		IToken bodyStart = Token.NoToken;
 		IToken bodyEnd = Token.NoToken;
 		
-		while (!(la.kind == 0 || la.kind == 79)) {SynErr(147); Get();}
-		Expect(79);
+		while (!(la.kind == 0 || la.kind == 80)) {SynErr(148); Get();}
+		Expect(80);
 		while (la.kind == 45) {
 			Attribute(ref attrs);
 		}
@@ -901,8 +910,8 @@ bool IsType(ref IToken pt) {
 				GenericParameters(typeArgs);
 			}
 			Formals(true, true, ins);
-			if (la.kind == 80 || la.kind == 81) {
-				if (la.kind == 80) {
+			if (la.kind == 81 || la.kind == 82) {
+				if (la.kind == 81) {
 					Get();
 				} else {
 					Get();
@@ -913,7 +922,7 @@ bool IsType(ref IToken pt) {
 		} else if (la.kind == 58) {
 			Get();
 			signatureEllipsis = t; 
-		} else SynErr(148);
+		} else SynErr(149);
 		while (StartOf(5)) {
 			IteratorSpec(reads, mod, decreases, req, ens, yieldReq, yieldEns, ref readsAttrs, ref modAttrs, ref decrAttrs);
 		}
@@ -940,8 +949,8 @@ bool IsType(ref IToken pt) {
 		List<MemberDecl/*!*/> members = new List<MemberDecl/*!*/>();
 		IToken bodyStart;
 		
-		while (!(la.kind == 0 || la.kind == 70)) {SynErr(149); Get();}
-		Expect(70);
+		while (!(la.kind == 0 || la.kind == 71)) {SynErr(150); Get();}
+		Expect(71);
 		while (la.kind == 45) {
 			Attribute(ref attrs);
 		}
@@ -968,11 +977,11 @@ bool IsType(ref IToken pt) {
 		MemberModifiers mmod = new MemberModifiers();
 		IToken staticToken = null, protectedToken = null;
 		
-		while (la.kind == 71 || la.kind == 72 || la.kind == 73) {
-			if (la.kind == 71) {
+		while (la.kind == 72 || la.kind == 73 || la.kind == 74) {
+			if (la.kind == 72) {
 				Get();
 				mmod.IsGhost = true; 
-			} else if (la.kind == 72) {
+			} else if (la.kind == 73) {
 				Get();
 				mmod.IsStatic = true; staticToken = t; 
 			} else {
@@ -980,7 +989,7 @@ bool IsType(ref IToken pt) {
 				mmod.IsProtected = true; protectedToken = t; 
 			}
 		}
-		if (la.kind == 76) {
+		if (la.kind == 77) {
 			if (moduleLevelDecl) {
 			 SemErr(la, "fields are not allowed to be declared at the module level; instead, wrap the field in a 'class' declaration");
 			 mmod.IsStatic = false;
@@ -1008,7 +1017,7 @@ bool IsType(ref IToken pt) {
 			
 			MethodDecl(mmod, allowConstructors, out m);
 			mm.Add(m); 
-		} else SynErr(150);
+		} else SynErr(151);
 	}
 
 	void Attribute(ref Attributes attrs) {
@@ -1093,8 +1102,8 @@ bool IsType(ref IToken pt) {
 		Attributes attrs = null;
 		IToken/*!*/ id;  Type/*!*/ ty;
 		
-		while (!(la.kind == 0 || la.kind == 76)) {SynErr(151); Get();}
-		Expect(76);
+		while (!(la.kind == 0 || la.kind == 77)) {SynErr(152); Get();}
+		Expect(77);
 		if (mmod.IsStatic) { SemErr(t, "fields cannot be declared 'static'"); }
 		
 		while (la.kind == 45) {
@@ -1131,7 +1140,7 @@ bool IsType(ref IToken pt) {
 		
 		if (la.kind == 37) {
 			Get();
-			if (la.kind == 82) {
+			if (la.kind == 83) {
 				Get();
 				isFunctionMethod = true; 
 			}
@@ -1151,11 +1160,11 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 58) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(152);
+			} else SynErr(153);
 		} else if (la.kind == 38) {
 			Get();
 			isPredicate = true; 
-			if (la.kind == 82) {
+			if (la.kind == 83) {
 				Get();
 				isFunctionMethod = true; 
 			}
@@ -1182,7 +1191,7 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 58) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(153);
+			} else SynErr(154);
 		} else if (la.kind == 39) {
 			Get();
 			Expect(38);
@@ -1205,7 +1214,7 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 58) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(154);
+			} else SynErr(155);
 		} else if (la.kind == 41) {
 			Get();
 			isCoPredicate = true; 
@@ -1227,8 +1236,8 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 58) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(155);
-		} else SynErr(156);
+			} else SynErr(156);
+		} else SynErr(157);
 		decreases = isIndPredicate || isCoPredicate ? null : new List<Expression/*!*/>(); 
 		while (StartOf(9)) {
 			FunctionSpec(reqs, reads, ens, decreases);
@@ -1287,9 +1296,9 @@ bool IsType(ref IToken pt) {
 		IToken bodyStart = Token.NoToken;
 		IToken bodyEnd = Token.NoToken;
 		
-		while (!(StartOf(10))) {SynErr(157); Get();}
+		while (!(StartOf(10))) {SynErr(158); Get();}
 		switch (la.kind) {
-		case 82: {
+		case 83: {
 			Get();
 			break;
 		}
@@ -1298,12 +1307,12 @@ bool IsType(ref IToken pt) {
 			isLemma = true; 
 			break;
 		}
-		case 83: {
+		case 84: {
 			Get();
 			isCoLemma = true; 
 			break;
 		}
-		case 84: {
+		case 85: {
 			Get();
 			isCoLemma = true;
 			errors.Warning(t, "the 'comethod' keyword has been deprecated; it has been renamed to 'colemma'");
@@ -1316,7 +1325,7 @@ bool IsType(ref IToken pt) {
 			isIndLemma = true; 
 			break;
 		}
-		case 85: {
+		case 86: {
 			Get();
 			if (allowConstructor) {
 			 isConstructor = true;
@@ -1326,7 +1335,7 @@ bool IsType(ref IToken pt) {
 			
 			break;
 		}
-		default: SynErr(158); break;
+		default: SynErr(159); break;
 		}
 		keywordToken = t; 
 		if (isLemma) {
@@ -1369,7 +1378,7 @@ bool IsType(ref IToken pt) {
 				GenericParameters(typeArgs);
 			}
 			Formals(true, !mmod.IsGhost, ins);
-			if (la.kind == 81) {
+			if (la.kind == 82) {
 				Get();
 				if (isConstructor) { SemErr(t, "constructors cannot have out-parameters"); } 
 				Formals(false, !mmod.IsGhost, outs);
@@ -1377,7 +1386,7 @@ bool IsType(ref IToken pt) {
 		} else if (la.kind == 58) {
 			Get();
 			signatureEllipsis = t; 
-		} else SynErr(159);
+		} else SynErr(160);
 		while (StartOf(11)) {
 			MethodSpec(req, mod, ens, dec, ref decAttrs, ref modAttrs);
 		}
@@ -1450,14 +1459,14 @@ bool IsType(ref IToken pt) {
 		} else if (la.kind == 2) {
 			Get();
 			id = t; 
-		} else SynErr(160);
+		} else SynErr(161);
 		Expect(21);
 		Type(out ty);
 	}
 
 	void OldSemi() {
 		if (la.kind == 27) {
-			while (!(la.kind == 0 || la.kind == 27)) {SynErr(161); Get();}
+			while (!(la.kind == 0 || la.kind == 27)) {SynErr(162); Get();}
 			Get();
 		}
 	}
@@ -1480,7 +1489,7 @@ bool IsType(ref IToken pt) {
 		Contract.Ensures(Contract.ValueAtReturn(out id)!=null);
 		Contract.Ensures(Contract.ValueAtReturn(out ty)!=null);
 		isGhost = false; 
-		if (la.kind == 71) {
+		if (la.kind == 72) {
 			Get();
 			if (allowGhostKeyword) { isGhost = true; } else { SemErr(t, "formal cannot be declared 'ghost' in this context"); } 
 		}
@@ -1532,7 +1541,7 @@ bool IsType(ref IToken pt) {
 		Contract.Ensures(Contract.ValueAtReturn(out ty)!=null);
 		Contract.Ensures(Contract.ValueAtReturn(out identName)!=null);
 		string name = null; id = Token.NoToken; ty = new BoolType()/*dummy*/; isGhost = false; 
-		if (la.kind == 71) {
+		if (la.kind == 72) {
 			Get();
 			isGhost = true; 
 		}
@@ -1554,7 +1563,7 @@ bool IsType(ref IToken pt) {
 			id = t; name = id.val;
 			Expect(21);
 			Type(out ty);
-		} else SynErr(162);
+		} else SynErr(163);
 		if (name != null) {
 		 identName = name;
 		} else {
@@ -1742,7 +1751,7 @@ bool IsType(ref IToken pt) {
 			ty = new UserDefinedType(e.tok, e); 
 			break;
 		}
-		default: SynErr(163); break;
+		default: SynErr(164); break;
 		}
 		if (la.kind == 29) {
 			Type t2; 
@@ -1763,7 +1772,7 @@ bool IsType(ref IToken pt) {
 	void Formals(bool incoming, bool allowGhostKeyword, List<Formal> formals) {
 		Contract.Requires(cce.NonNullElements(formals)); IToken id;  Type ty;  bool isGhost; 
 		Expect(49);
-		if (la.kind == 1 || la.kind == 71) {
+		if (la.kind == 1 || la.kind == 72) {
 			GIdentType(allowGhostKeyword, out id, out ty, out isGhost);
 			formals.Add(new Formal(id, id.val, ty, incoming, isGhost)); 
 			while (la.kind == 22) {
@@ -1781,7 +1790,7 @@ List<MaybeFreeExpression/*!*/>/*!*/ yieldReq, List<MaybeFreeExpression/*!*/>/*!*
 ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 		Expression/*!*/ e; FrameExpression/*!*/ fe; bool isFree = false; bool isYield = false; Attributes ensAttrs = null;
 		
-		while (!(StartOf(13))) {SynErr(164); Get();}
+		while (!(StartOf(13))) {SynErr(165); Get();}
 		if (la.kind == 43) {
 			Get();
 			while (IsAttribute()) {
@@ -1809,13 +1818,13 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 			}
 			OldSemi();
 		} else if (StartOf(14)) {
-			if (la.kind == 86) {
+			if (la.kind == 87) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
 				
 			}
-			if (la.kind == 88) {
+			if (la.kind == 89) {
 				Get();
 				isYield = true; 
 			}
@@ -1829,7 +1838,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 				 req.Add(new MaybeFreeExpression(e, isFree));
 				}
 				
-			} else if (la.kind == 87) {
+			} else if (la.kind == 88) {
 				Get();
 				while (IsAttribute()) {
 					Attribute(ref ensAttrs);
@@ -1842,7 +1851,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 				 ens.Add(new MaybeFreeExpression(e, isFree, ensAttrs));
 				}
 				
-			} else SynErr(165);
+			} else SynErr(166);
 		} else if (la.kind == 35) {
 			Get();
 			while (IsAttribute()) {
@@ -1850,7 +1859,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 			}
 			DecreasesList(decreases, false, false);
 			OldSemi();
-		} else SynErr(166);
+		} else SynErr(167);
 	}
 
 	void BlockStmt(out BlockStmt/*!*/ block, out IToken bodyStart, out IToken bodyEnd) {
@@ -1872,7 +1881,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Requires(cce.NonNullElements(req)); Contract.Requires(cce.NonNullElements(mod)); Contract.Requires(cce.NonNullElements(ens)); Contract.Requires(cce.NonNullElements(decreases));
 		Expression/*!*/ e;  FrameExpression/*!*/ fe;  bool isFree = false; Attributes ensAttrs = null;
 		
-		while (!(StartOf(16))) {SynErr(167); Get();}
+		while (!(StartOf(16))) {SynErr(168); Get();}
 		if (la.kind == 42) {
 			Get();
 			while (IsAttribute()) {
@@ -1886,8 +1895,8 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				mod.Add(fe); 
 			}
 			OldSemi();
-		} else if (la.kind == 44 || la.kind == 86 || la.kind == 87) {
-			if (la.kind == 86) {
+		} else if (la.kind == 44 || la.kind == 87 || la.kind == 88) {
+			if (la.kind == 87) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
@@ -1898,7 +1907,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Expression(out e, false, false);
 				OldSemi();
 				req.Add(new MaybeFreeExpression(e, isFree)); 
-			} else if (la.kind == 87) {
+			} else if (la.kind == 88) {
 				Get();
 				while (IsAttribute()) {
 					Attribute(ref ensAttrs);
@@ -1906,7 +1915,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Expression(out e, false, false);
 				OldSemi();
 				ens.Add(new MaybeFreeExpression(e, isFree, ensAttrs)); 
-			} else SynErr(168);
+			} else SynErr(169);
 		} else if (la.kind == 35) {
 			Get();
 			while (IsAttribute()) {
@@ -1914,7 +1923,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			DecreasesList(decreases, true, false);
 			OldSemi();
-		} else SynErr(169);
+		} else SynErr(170);
 	}
 
 	void FrameExpression(out FrameExpression fe, bool allowSemi, bool allowLambda) {
@@ -1927,18 +1936,18 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (StartOf(7)) {
 			Expression(out e, allowSemi, allowLambda);
 			feTok = e.tok; 
-			if (la.kind == 89) {
+			if (la.kind == 90) {
 				Get();
 				Ident(out id);
 				fieldName = id.val;  feTok = id; 
 			}
 			fe = new FrameExpression(feTok, e, fieldName); 
-		} else if (la.kind == 89) {
+		} else if (la.kind == 90) {
 			Get();
 			Ident(out id);
 			fieldName = id.val; 
 			fe = new FrameExpression(id, new ImplicitThisExpr(id), fieldName); 
-		} else SynErr(170);
+		} else SynErr(171);
 	}
 
 	void DecreasesList(List<Expression> decreases, bool allowWildcard, bool allowLambda) {
@@ -1993,7 +2002,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Requires(cce.NonNullElements(reads));
 		Contract.Requires(decreases == null || cce.NonNullElements(decreases));
 		Expression/*!*/ e;  FrameExpression/*!*/ fe; 
-		while (!(StartOf(17))) {SynErr(171); Get();}
+		while (!(StartOf(17))) {SynErr(172); Get();}
 		if (la.kind == 44) {
 			Get();
 			Expression(out e, false, false);
@@ -2009,7 +2018,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				reads.Add(fe); 
 			}
 			OldSemi();
-		} else if (la.kind == 87) {
+		} else if (la.kind == 88) {
 			Get();
 			Expression(out e, false, false);
 			OldSemi();
@@ -2023,7 +2032,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			
 			DecreasesList(decreases, false, false);
 			OldSemi();
-		} else SynErr(172);
+		} else SynErr(173);
 	}
 
 	void FunctionBody(out Expression/*!*/ e, out IToken bodyStart, out IToken bodyEnd) {
@@ -2042,7 +2051,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			fe = new FrameExpression(t, new WildcardExpr(t), null); 
 		} else if (StartOf(18)) {
 			FrameExpression(out fe, allowSemi, false);
-		} else SynErr(173);
+		} else SynErr(174);
 	}
 
 	void PossiblyWildExpression(out Expression e, bool allowLambda) {
@@ -2053,7 +2062,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			e = new WildcardExpr(t); 
 		} else if (StartOf(7)) {
 			Expression(out e, false, allowLambda);
-		} else SynErr(174);
+		} else SynErr(175);
 	}
 
 	void Stmt(List<Statement/*!*/>/*!*/ ss) {
@@ -2070,14 +2079,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken bodyStart, bodyEnd;
 		int breakCount;
 		
-		while (!(StartOf(19))) {SynErr(175); Get();}
+		while (!(StartOf(19))) {SynErr(176); Get();}
 		switch (la.kind) {
 		case 45: {
 			BlockStmt(out bs, out bodyStart, out bodyEnd);
 			s = bs; 
 			break;
 		}
-		case 100: {
+		case 101: {
 			AssertStmt(out s);
 			break;
 		}
@@ -2085,31 +2094,31 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			AssumeStmt(out s);
 			break;
 		}
-		case 101: {
+		case 102: {
 			PrintStmt(out s);
 			break;
 		}
-		case 1: case 2: case 3: case 4: case 8: case 10: case 19: case 20: case 23: case 49: case 130: case 131: case 132: case 133: case 134: case 135: {
+		case 1: case 2: case 3: case 4: case 8: case 10: case 19: case 20: case 23: case 49: case 131: case 132: case 133: case 134: case 135: case 136: {
 			UpdateStmt(out s);
 			break;
 		}
-		case 71: case 76: {
+		case 72: case 77: {
 			VarDeclStatement(out s);
 			break;
 		}
-		case 97: {
+		case 98: {
 			IfStmt(out s);
 			break;
 		}
-		case 98: {
+		case 99: {
 			WhileStmt(out s);
 			break;
 		}
-		case 99: {
+		case 100: {
 			MatchStmt(out s);
 			break;
 		}
-		case 102: case 103: {
+		case 103: case 104: {
 			ForallStmt(out s);
 			break;
 		}
@@ -2117,11 +2126,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			CalcStmt(out s);
 			break;
 		}
-		case 104: {
+		case 105: {
 			ModifyStmt(out s);
 			break;
 		}
-		case 90: {
+		case 91: {
 			Get();
 			x = t; 
 			NoUSIdent(out id);
@@ -2130,24 +2139,24 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			s.Labels = new LList<Label>(new Label(x, id.val), s.Labels); 
 			break;
 		}
-		case 91: {
+		case 92: {
 			Get();
 			x = t; breakCount = 1; label = null; 
 			if (la.kind == 1) {
 				NoUSIdent(out id);
 				label = id.val; 
-			} else if (la.kind == 27 || la.kind == 91) {
-				while (la.kind == 91) {
+			} else if (la.kind == 27 || la.kind == 92) {
+				while (la.kind == 92) {
 					Get();
 					breakCount++; 
 				}
-			} else SynErr(176);
-			while (!(la.kind == 0 || la.kind == 27)) {SynErr(177); Get();}
+			} else SynErr(177);
+			while (!(la.kind == 0 || la.kind == 27)) {SynErr(178); Get();}
 			Expect(27);
 			s = label != null ? new BreakStmt(x, t, label) : new BreakStmt(x, t, breakCount); 
 			break;
 		}
-		case 88: case 94: {
+		case 89: case 95: {
 			ReturnStmt(out s);
 			break;
 		}
@@ -2155,7 +2164,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			SkeletonStmt(out s);
 			break;
 		}
-		default: SynErr(178); break;
+		default: SynErr(179); break;
 		}
 	}
 
@@ -2164,7 +2173,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression e = dummyExpr; Attributes attrs = null;
 		IToken dotdotdot = null;
 		
-		Expect(100);
+		Expect(101);
 		x = t; 
 		while (IsAttribute()) {
 			Attribute(ref attrs);
@@ -2174,7 +2183,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 58) {
 			Get();
 			dotdotdot = t; 
-		} else SynErr(179);
+		} else SynErr(180);
 		Expect(27);
 		if (dotdotdot != null) {
 		 s = new SkeletonStatement(new AssertStmt(x, t, new LiteralExpr(x, true), attrs), dotdotdot, null);
@@ -2199,7 +2208,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 58) {
 			Get();
 			dotdotdot = t; 
-		} else SynErr(180);
+		} else SynErr(181);
 		Expect(27);
 		if (dotdotdot != null) {
 		 s = new SkeletonStatement(new AssumeStmt(x, t, new LiteralExpr(x, true), attrs), dotdotdot, null);
@@ -2214,7 +2223,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken x;  Expression e;
 		var args = new List<Expression>();
 		
-		Expect(101);
+		Expect(102);
 		x = t; 
 		Expression(out e, false, true);
 		args.Add(e); 
@@ -2244,14 +2253,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			Expect(27);
 			endTok = t; rhss.Add(new ExprRhs(e, attrs)); 
-		} else if (la.kind == 22 || la.kind == 93 || la.kind == 95) {
+		} else if (la.kind == 22 || la.kind == 94 || la.kind == 96) {
 			lhss.Add(e); 
 			while (la.kind == 22) {
 				Get();
 				Lhs(out e);
 				lhss.Add(e); 
 			}
-			if (la.kind == 93) {
+			if (la.kind == 94) {
 				Get();
 				x = t; 
 				Rhs(out r);
@@ -2261,7 +2270,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					Rhs(out r);
 					rhss.Add(r); 
 				}
-			} else if (la.kind == 95) {
+			} else if (la.kind == 96) {
 				Get();
 				x = t; 
 				if (la.kind == _assume) {
@@ -2269,13 +2278,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					suchThatAssume = t; 
 				}
 				Expression(out suchThat, false, true);
-			} else SynErr(181);
+			} else SynErr(182);
 			Expect(27);
 			endTok = t; 
 		} else if (la.kind == 21) {
 			Get();
 			SemErr(t, "invalid statement (did you forget the 'label' keyword?)"); 
-		} else SynErr(182);
+		} else SynErr(183);
 		if (suchThat != null) {
 		 s = new AssignSuchThatStmt(x, endTok, lhss, suchThat, suchThatAssume, null);
 		} else {
@@ -2299,11 +2308,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Attributes attrs = null;
 		IToken endTok;
 		
-		if (la.kind == 71) {
+		if (la.kind == 72) {
 			Get();
 			isGhost = true;  x = t; 
 		}
-		Expect(76);
+		Expect(77);
 		if (!isGhost) { x = t; } 
 		while (la.kind == 45) {
 			Attribute(ref attrs);
@@ -2318,8 +2327,8 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			LocalIdentTypeOptional(out d, isGhost);
 			lhss.Add(d); d.Attributes = attrs; attrs = null; 
 		}
-		if (la.kind == 45 || la.kind == 93 || la.kind == 95) {
-			if (la.kind == 93) {
+		if (la.kind == 45 || la.kind == 94 || la.kind == 96) {
+			if (la.kind == 94) {
 				Get();
 				assignTok = t; 
 				Rhs(out r);
@@ -2333,7 +2342,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				while (la.kind == 45) {
 					Attribute(ref attrs);
 				}
-				Expect(95);
+				Expect(96);
 				assignTok = t; 
 				if (la.kind == _assume) {
 					Expect(30);
@@ -2342,7 +2351,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Expression(out suchThat, false, true);
 			}
 		}
-		while (!(la.kind == 0 || la.kind == 27)) {SynErr(183); Get();}
+		while (!(la.kind == 0 || la.kind == 27)) {SynErr(184); Get();}
 		Expect(27);
 		endTok = t; 
 		ConcreteUpdateStatement update;
@@ -2376,7 +2385,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<GuardedAlternative> alternatives;
 		ifStmt = dummyStmt;  // to please the compiler
 		
-		Expect(97);
+		Expect(98);
 		x = t; 
 		if (IsAlternative()) {
 			AlternativeBlock(out alternatives, out endTok);
@@ -2392,13 +2401,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			endTok = thn.EndTok; 
 			if (la.kind == 34) {
 				Get();
-				if (la.kind == 97) {
+				if (la.kind == 98) {
 					IfStmt(out s);
 					els = s; endTok = s.EndTok; 
 				} else if (la.kind == 45) {
 					BlockStmt(out bs, out bodyStart, out bodyEnd);
 					els = bs; endTok = bs.EndTok; 
-				} else SynErr(184);
+				} else SynErr(185);
 			}
 			if (guardEllipsis != null) {
 			 ifStmt = new SkeletonStatement(new IfStmt(x, endTok, guard, thn, els), guardEllipsis, null);
@@ -2406,7 +2415,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 ifStmt = new IfStmt(x, endTok, guard, thn, els);
 			}
 			
-		} else SynErr(185);
+		} else SynErr(186);
 	}
 
 	void WhileStmt(out Statement stmt) {
@@ -2425,7 +2434,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		stmt = dummyStmt;  // to please the compiler
 		bool isDirtyLoop = true;
 		
-		Expect(98);
+		Expect(99);
 		x = t; 
 		if (IsLoopSpec() || IsAlternative()) {
 			while (StartOf(22)) {
@@ -2451,7 +2460,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Expect(58);
 				bodyEllipsis = t; endTok = t; isDirtyLoop = false; 
 			} else if (StartOf(23)) {
-			} else SynErr(186);
+			} else SynErr(187);
 			if (guardEllipsis != null || bodyEllipsis != null) {
 			 if (mod != null) {
 			   SemErr(mod[0].E.tok, "'modifies' clauses are not allowed on refining loops");
@@ -2469,7 +2478,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 stmt = new WhileStmt(x, endTok, guard, invariants, new Specification<Expression>(decreases, decAttrs), new Specification<FrameExpression>(mod, modAttrs), body);
 			}
 			
-		} else SynErr(187);
+		} else SynErr(188);
 	}
 
 	void MatchStmt(out Statement/*!*/ s) {
@@ -2478,7 +2487,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<MatchCaseStmt/*!*/> cases = new List<MatchCaseStmt/*!*/>();
 		bool usesOptionalBrace = false;
 		
-		Expect(99);
+		Expect(100);
 		x = t; 
 		Expression(out e, true, true);
 		if (la.kind == _lbrace) {
@@ -2494,7 +2503,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				CaseStatement(out c);
 				cases.Add(c); 
 			}
-		} else SynErr(188);
+		} else SynErr(189);
 		s = new MatchStmt(x, t, e, cases, usesOptionalBrace); 
 	}
 
@@ -2511,15 +2520,15 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken bodyStart, bodyEnd;
 		IToken tok = Token.NoToken;
 		
-		if (la.kind == 102) {
+		if (la.kind == 103) {
 			Get();
 			x = t; tok = x; 
-		} else if (la.kind == 103) {
+		} else if (la.kind == 104) {
 			Get();
 			x = t;
 			errors.Warning(t, "the 'parallel' keyword has been deprecated; the comprehension statement now uses the keyword 'forall' (and the parentheses around the bound variables are now optional)");
 			
-		} else SynErr(189);
+		} else SynErr(190);
 		if (la.kind == _openparen) {
 			Expect(49);
 			if (la.kind == 1) {
@@ -2530,19 +2539,19 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			if (la.kind == _ident) {
 				QuantifierDomain(out bvars, out attrs, out range);
 			}
-		} else SynErr(190);
+		} else SynErr(191);
 		if (bvars == null) { bvars = new List<BoundVar>(); }
 		if (range == null) { range = new LiteralExpr(x, true); }
 		
-		while (la.kind == 86 || la.kind == 87) {
+		while (la.kind == 87 || la.kind == 88) {
 			isFree = false; 
-			if (la.kind == 86) {
+			if (la.kind == 87) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
 				
 			}
-			Expect(87);
+			Expect(88);
 			Expression(out e, false, true);
 			ens.Add(new MaybeFreeExpression(e, isFree)); 
 			OldSemi();
@@ -2620,7 +2629,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				} else if (la.kind == 31) {
 					CalcStmt(out subCalc);
 					hintEnd = subCalc.EndTok; subhints.Add(subCalc); 
-				} else SynErr(191);
+				} else SynErr(192);
 			}
 			var h = new BlockStmt(hintStart, hintEnd, subhints); // if the hint is empty, hintStart is the first token of the next line, but it doesn't matter because the block statement is just used as a container
 			hints.Add(h);
@@ -2646,7 +2655,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		BlockStmt body = null;  IToken bodyStart;
 		IToken ellipsisToken = null;
 		
-		Expect(104);
+		Expect(105);
 		tok = t; 
 		while (IsAttribute()) {
 			Attribute(ref attrs);
@@ -2662,14 +2671,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 58) {
 			Get();
 			ellipsisToken = t; 
-		} else SynErr(192);
+		} else SynErr(193);
 		if (la.kind == 45) {
 			BlockStmt(out body, out bodyStart, out endTok);
 		} else if (la.kind == 27) {
-			while (!(la.kind == 0 || la.kind == 27)) {SynErr(193); Get();}
+			while (!(la.kind == 0 || la.kind == 27)) {SynErr(194); Get();}
 			Get();
 			endTok = t; 
-		} else SynErr(194);
+		} else SynErr(195);
 		s = new ModifyStmt(tok, endTok, mod, attrs, body);
 		if (ellipsisToken != null) {
 		 s = new SkeletonStatement(s, ellipsisToken, null);
@@ -2683,13 +2692,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		AssignmentRhs r;
 		bool isYield = false;
 		
-		if (la.kind == 94) {
+		if (la.kind == 95) {
 			Get();
 			returnTok = t; 
-		} else if (la.kind == 88) {
+		} else if (la.kind == 89) {
 			Get();
 			returnTok = t; isYield = true; 
-		} else SynErr(195);
+		} else SynErr(196);
 		if (StartOf(26)) {
 			Rhs(out r);
 			rhss = new List<AssignmentRhs>(); rhss.Add(r); 
@@ -2715,7 +2724,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression e; 
 		Expect(58);
 		dotdotdot = t; 
-		if (la.kind == 92) {
+		if (la.kind == 93) {
 			Get();
 			names = new List<IToken>(); exprs = new List<Expression>(); whereTok = t;
 			Ident(out tok);
@@ -2725,7 +2734,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Ident(out tok);
 				names.Add(tok); 
 			}
-			Expect(93);
+			Expect(94);
 			Expression(out e, false, true);
 			exprs.Add(e); 
 			while (la.kind == 22) {
@@ -2752,7 +2761,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		r = dummyRhs;  // to please compiler
 		Attributes attrs = null;
 		
-		if (la.kind == 96) {
+		if (la.kind == 97) {
 			Get();
 			newToken = t; 
 			TypeAndToken(out x, out ty);
@@ -2787,7 +2796,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (StartOf(7)) {
 			Expression(out e, false, true);
 			r = new ExprRhs(e); 
-		} else SynErr(196);
+		} else SynErr(197);
 		while (la.kind == 45) {
 			Attribute(ref attrs);
 		}
@@ -2808,7 +2817,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			while (la.kind == 26 || la.kind == 47 || la.kind == 49) {
 				Suffix(ref e);
 			}
-		} else SynErr(197);
+		} else SynErr(198);
 	}
 
 	void Expressions(List<Expression> args) {
@@ -2857,16 +2866,16 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (StartOf(7)) {
 			Expression(out ee, true, true);
 			e = ee; 
-		} else SynErr(198);
+		} else SynErr(199);
 	}
 
 	void LoopSpec(List<MaybeFreeExpression> invariants, List<Expression> decreases, ref List<FrameExpression> mod, ref Attributes decAttrs, ref Attributes modAttrs) {
 		Expression e; FrameExpression fe;
 		bool isFree = false; Attributes attrs = null;
 		
-		if (la.kind == 36 || la.kind == 86) {
-			while (!(la.kind == 0 || la.kind == 36 || la.kind == 86)) {SynErr(199); Get();}
-			if (la.kind == 86) {
+		if (la.kind == 36 || la.kind == 87) {
+			while (!(la.kind == 0 || la.kind == 36 || la.kind == 87)) {SynErr(200); Get();}
+			if (la.kind == 87) {
 				Get();
 				isFree = true; errors.Warning(t, "the 'free' keyword is soon to be deprecated"); 
 			}
@@ -2878,7 +2887,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			invariants.Add(new MaybeFreeExpression(e, isFree, attrs)); 
 			OldSemi();
 		} else if (la.kind == 35) {
-			while (!(la.kind == 0 || la.kind == 35)) {SynErr(200); Get();}
+			while (!(la.kind == 0 || la.kind == 35)) {SynErr(201); Get();}
 			Get();
 			while (IsAttribute()) {
 				Attribute(ref decAttrs);
@@ -2886,7 +2895,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			DecreasesList(decreases, true, true);
 			OldSemi();
 		} else if (la.kind == 42) {
-			while (!(la.kind == 0 || la.kind == 42)) {SynErr(201); Get();}
+			while (!(la.kind == 0 || la.kind == 42)) {SynErr(202); Get();}
 			Get();
 			mod = mod ?? new List<FrameExpression>(); 
 			while (IsAttribute()) {
@@ -2900,7 +2909,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				mod.Add(fe); 
 			}
 			OldSemi();
-		} else SynErr(202);
+		} else SynErr(203);
 	}
 
 	void CaseStatement(out MatchCaseStmt/*!*/ c) {
@@ -2937,12 +2946,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				arguments.Add(pat); 
 			}
 			Expect(50);
-		} else SynErr(203);
+		} else SynErr(204);
 		Expect(28);
-		while (!(StartOf(28))) {SynErr(204); Get();}
+		while (!(StartOf(28))) {SynErr(205); Get();}
 		while (IsNotEndOfCase()) {
 			Stmt(body);
-			while (!(StartOf(28))) {SynErr(205); Get();}
+			while (!(StartOf(28))) {SynErr(206); Get();}
 		}
 		c = new MatchCaseStmt(x, name, arguments, body); 
 	}
@@ -2990,7 +2999,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			IdentTypeOptional(out bv);
 			pat = new CasePattern(bv.tok, bv);
 			
-		} else SynErr(206);
+		} else SynErr(207);
 		if (pat == null) {
 		 pat = new CasePattern(t, "_ParseError", new List<CasePattern>());
 		}
@@ -3028,7 +3037,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		case 53: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Eq; 
-			if (la.kind == 105) {
+			if (la.kind == 106) {
 				Get();
 				Expect(47);
 				Expression(out k, true, true);
@@ -3046,12 +3055,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  binOp = BinaryExpr.Opcode.Gt; 
 			break;
 		}
-		case 106: {
+		case 107: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 107: {
+		case 108: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Ge; 
 			break;
@@ -3066,32 +3075,32 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  binOp = BinaryExpr.Opcode.Neq; 
 			break;
 		}
-		case 108: {
+		case 109: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 109: {
+		case 110: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Ge; 
 			break;
 		}
-		case 110: case 111: {
+		case 111: case 112: {
 			EquivOp();
 			x = t;  binOp = BinaryExpr.Opcode.Iff; 
 			break;
 		}
-		case 112: case 113: {
+		case 113: case 114: {
 			ImpliesOp();
 			x = t;  binOp = BinaryExpr.Opcode.Imp; 
 			break;
 		}
-		case 114: case 115: {
+		case 115: case 116: {
 			ExpliesOp();
 			x = t;  binOp = BinaryExpr.Opcode.Exp; 
 			break;
 		}
-		default: SynErr(207); break;
+		default: SynErr(208); break;
 		}
 		if (k == null) {
 		 op = new Microsoft.Dafny.CalcStmt.BinaryCalcOp(binOp);
@@ -3102,67 +3111,67 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 	}
 
 	void EquivOp() {
-		if (la.kind == 110) {
+		if (la.kind == 111) {
 			Get();
-		} else if (la.kind == 111) {
+		} else if (la.kind == 112) {
 			Get();
-		} else SynErr(208);
+		} else SynErr(209);
 	}
 
 	void ImpliesOp() {
-		if (la.kind == 112) {
+		if (la.kind == 113) {
 			Get();
-		} else if (la.kind == 113) {
+		} else if (la.kind == 114) {
 			Get();
-		} else SynErr(209);
+		} else SynErr(210);
 	}
 
 	void ExpliesOp() {
-		if (la.kind == 114) {
+		if (la.kind == 115) {
 			Get();
-		} else if (la.kind == 115) {
+		} else if (la.kind == 116) {
 			Get();
-		} else SynErr(210);
+		} else SynErr(211);
 	}
 
 	void AndOp() {
-		if (la.kind == 116) {
+		if (la.kind == 117) {
 			Get();
-		} else if (la.kind == 117) {
+		} else if (la.kind == 118) {
 			Get();
-		} else SynErr(211);
+		} else SynErr(212);
 	}
 
 	void OrOp() {
-		if (la.kind == 118) {
+		if (la.kind == 119) {
 			Get();
-		} else if (la.kind == 119) {
+		} else if (la.kind == 120) {
 			Get();
-		} else SynErr(212);
+		} else SynErr(213);
 	}
 
 	void NegOp() {
-		if (la.kind == 120) {
+		if (la.kind == 121) {
 			Get();
-		} else if (la.kind == 121) {
+		} else if (la.kind == 122) {
 			Get();
-		} else SynErr(213);
+		} else SynErr(214);
 	}
 
 	void Forall() {
-		if (la.kind == 102) {
+		if (la.kind == 103) {
 			Get();
-		} else if (la.kind == 122) {
+		} else if (la.kind == 123) {
 			Get();
-		} else SynErr(214);
+		} else SynErr(215);
 	}
 
 	void Exists() {
-		if (la.kind == 123) {
+		if (la.kind == 124) {
 			Get();
-		} else if (la.kind == 124) {
+		} else if (la.kind == 125) {
 			Get();
-		} else SynErr(215);
+		} else SynErr(216);
 	}
 
 	void QSep() {
@@ -3170,7 +3179,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 		} else if (la.kind == 25) {
 			Get();
-		} else SynErr(216);
+		} else SynErr(217);
 	}
 
 	void EquivExpression(out Expression e0, bool allowSemi, bool allowLambda) {
@@ -3188,12 +3197,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Ensures(Contract.ValueAtReturn(out e0) != null); IToken/*!*/ x;  Expression/*!*/ e1; 
 		LogicalExpression(out e0, allowSemi, allowLambda);
 		if (IsImpliesOp() || IsExpliesOp()) {
-			if (la.kind == 112 || la.kind == 113) {
+			if (la.kind == 113 || la.kind == 114) {
 				ImpliesOp();
 				x = t; 
 				ImpliesExpression(out e1, allowSemi, allowLambda);
 				e0 = new BinaryExpr(x, BinaryExpr.Opcode.Imp, e0, e1); 
-			} else if (la.kind == 114 || la.kind == 115) {
+			} else if (la.kind == 115 || la.kind == 116) {
 				ExpliesOp();
 				x = t; 
 				LogicalExpression(out e1, allowSemi, allowLambda);
@@ -3204,7 +3213,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					LogicalExpression(out e1, allowSemi, allowLambda);
 					e0 = new BinaryExpr(x, BinaryExpr.Opcode.Exp, e0, e1); 
 				}
-			} else SynErr(217);
+			} else SynErr(218);
 		}
 	}
 
@@ -3212,7 +3221,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Ensures(Contract.ValueAtReturn(out e0) != null); IToken/*!*/ x;  Expression/*!*/ e1; 
 		RelationalExpression(out e0, allowSemi, allowLambda);
 		if (IsAndOp() || IsOrOp()) {
-			if (la.kind == 116 || la.kind == 117) {
+			if (la.kind == 117 || la.kind == 118) {
 				AndOp();
 				x = t; 
 				RelationalExpression(out e1, allowSemi, allowLambda);
@@ -3223,7 +3232,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					RelationalExpression(out e1, allowSemi, allowLambda);
 					e0 = new BinaryExpr(x, BinaryExpr.Opcode.And, e0, e1); 
 				}
-			} else if (la.kind == 118 || la.kind == 119) {
+			} else if (la.kind == 119 || la.kind == 120) {
 				OrOp();
 				x = t; 
 				RelationalExpression(out e1, allowSemi, allowLambda);
@@ -3234,7 +3243,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					RelationalExpression(out e1, allowSemi, allowLambda);
 					e0 = new BinaryExpr(x, BinaryExpr.Opcode.Or, e0, e1); 
 				}
-			} else SynErr(218);
+			} else SynErr(219);
 		}
 	}
 
@@ -3370,7 +3379,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		case 53: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Eq; 
-			if (la.kind == 105) {
+			if (la.kind == 106) {
 				Get();
 				Expect(47);
 				Expression(out k, true, true);
@@ -3388,12 +3397,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.Gt; 
 			break;
 		}
-		case 106: {
+		case 107: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 107: {
+		case 108: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Ge; 
 			break;
@@ -3401,7 +3410,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		case 54: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Neq; 
-			if (la.kind == 105) {
+			if (la.kind == 106) {
 				Get();
 				Expect(47);
 				Expression(out k, true, true);
@@ -3409,7 +3418,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			break;
 		}
-		case 125: {
+		case 126: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.In; 
 			break;
@@ -3419,11 +3428,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.NotIn; 
 			break;
 		}
-		case 120: {
+		case 121: {
 			Get();
 			x = t;  y = Token.NoToken; 
 			if (la.val == "!") {
-				Expect(120);
+				Expect(121);
 				y = t; 
 			}
 			if (y == Token.NoToken) {
@@ -3442,17 +3451,17 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.Neq; 
 			break;
 		}
-		case 108: {
+		case 109: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 109: {
+		case 110: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Ge; 
 			break;
 		}
-		default: SynErr(219); break;
+		default: SynErr(220); break;
 		}
 	}
 
@@ -3468,23 +3477,23 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void AddOp(out IToken x, out BinaryExpr.Opcode op) {
 		Contract.Ensures(Contract.ValueAtReturn(out x) != null); x = Token.NoToken;  op=BinaryExpr.Opcode.Add/*(dummy)*/; 
-		if (la.kind == 126) {
+		if (la.kind == 127) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Add; 
-		} else if (la.kind == 127) {
+		} else if (la.kind == 128) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Sub; 
-		} else SynErr(220);
+		} else SynErr(221);
 	}
 
 	void UnaryExpression(out Expression e, bool allowSemi, bool allowLambda) {
 		Contract.Ensures(Contract.ValueAtReturn(out e) != null); IToken/*!*/ x;  e = dummyExpr; 
-		if (la.kind == 127) {
+		if (la.kind == 128) {
 			Get();
 			x = t; 
 			UnaryExpression(out e, allowSemi, allowLambda);
 			e = new NegationExpression(x, e); 
-		} else if (la.kind == 120 || la.kind == 121) {
+		} else if (la.kind == 121 || la.kind == 122) {
 			NegOp();
 			x = t; 
 			UnaryExpression(out e, allowSemi, allowLambda);
@@ -3534,7 +3543,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			while (IsSuffix()) {
 				Suffix(ref e);
 			}
-		} else SynErr(221);
+		} else SynErr(222);
 	}
 
 	void MulOp(out IToken x, out BinaryExpr.Opcode op) {
@@ -3542,13 +3551,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 56) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Mul; 
-		} else if (la.kind == 128) {
+		} else if (la.kind == 129) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Div; 
-		} else if (la.kind == 129) {
+		} else if (la.kind == 130) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Mod; 
-		} else SynErr(222);
+		} else SynErr(223);
 	}
 
 	void MapDisplayExpr(IToken/*!*/ mapToken, bool finite, out Expression e) {
@@ -3583,10 +3592,10 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			if (IsGenericInstantiation()) {
 				typeArgs = new List<Type>(); 
 				GenericInstantiation(typeArgs);
-			} else if (la.kind == 105) {
+			} else if (la.kind == 106) {
 				HashCall(id, out openParen, out typeArgs, out args);
 			} else if (StartOf(30)) {
-			} else SynErr(223);
+			} else SynErr(224);
 			e = new ExprDotName(id, e, id.val, typeArgs);
 			if (openParen != null) {
 			 e = new ApplySuffix(openParen, e, args);
@@ -3598,14 +3607,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			if (StartOf(7)) {
 				Expression(out ee, true, true);
 				e0 = ee; 
-				if (la.kind == 136) {
+				if (la.kind == 137) {
 					Get();
 					anyDots = true; 
 					if (StartOf(7)) {
 						Expression(out ee, true, true);
 						e1 = ee; 
 					}
-				} else if (la.kind == 93) {
+				} else if (la.kind == 94) {
 					Get();
 					Expression(out ee, true, true);
 					e1 = ee; 
@@ -3639,15 +3648,15 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 						multipleIndices.Add(ee);
 						
 					}
-				} else SynErr(224);
-			} else if (la.kind == 136) {
+				} else SynErr(225);
+			} else if (la.kind == 137) {
 				Get();
 				anyDots = true; 
 				if (StartOf(7)) {
 					Expression(out ee, true, true);
 					e1 = ee; 
 				}
-			} else SynErr(225);
+			} else SynErr(226);
 			if (multipleIndices != null) {
 			 e = new MultiSelectExpr(x, e, multipleIndices);
 			 // make sure an array class with this dimensionality exists
@@ -3691,7 +3700,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			Expect(50);
 			e = new ApplySuffix(openParen, e, args); 
-		} else SynErr(226);
+		} else SynErr(227);
 	}
 
 	void ISetDisplayExpr(IToken/*!*/ setToken, bool finite, out Expression e) {
@@ -3733,7 +3742,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				}
 			}
 			Expect(50);
-		} else SynErr(227);
+		} else SynErr(228);
 		while (la.kind == 43 || la.kind == 44) {
 			if (la.kind == 43) {
 				Get();
@@ -3759,7 +3768,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;
 		
 		switch (la.kind) {
-		case 97: {
+		case 98: {
 			Get();
 			x = t; 
 			Expression(out e, true, true);
@@ -3770,11 +3779,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			e = new ITEExpr(x, e, e0, e1); 
 			break;
 		}
-		case 99: {
+		case 100: {
 			MatchExpression(out e, allowSemi, allowLambda);
 			break;
 		}
-		case 102: case 122: case 123: case 124: {
+		case 103: case 123: case 124: case 125: {
 			QuantifierGuts(out e, allowSemi, allowLambda);
 			break;
 		}
@@ -3790,13 +3799,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			SetComprehensionExpr(x, false, out e, allowSemi, allowLambda);
 			break;
 		}
-		case 30: case 31: case 100: {
+		case 30: case 31: case 101: {
 			StmtInExpr(out s);
 			Expression(out e, allowSemi, allowLambda);
 			e = new StmtExpr(s.Tok, s, e); 
 			break;
 		}
-		case 71: case 76: {
+		case 72: case 77: {
 			LetExpr(out e, allowSemi, allowLambda);
 			break;
 		}
@@ -3812,11 +3821,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			MapComprehensionExpr(x, false, out e, allowSemi, allowLambda);
 			break;
 		}
-		case 90: {
+		case 91: {
 			NamedExpr(out e, allowSemi, allowLambda);
 			break;
 		}
-		default: SynErr(228); break;
+		default: SynErr(229); break;
 		}
 	}
 
@@ -3828,10 +3837,10 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (IsGenericInstantiation()) {
 			typeArgs = new List<Type>(); 
 			GenericInstantiation(typeArgs);
-		} else if (la.kind == 105) {
+		} else if (la.kind == 106) {
 			HashCall(id, out openParen, out typeArgs, out args);
 		} else if (StartOf(30)) {
-		} else SynErr(229);
+		} else SynErr(230);
 		e = new NameSegment(id, id.val, typeArgs);
 		if (openParen != null) {
 		 e = new ApplySuffix(openParen, e, args);
@@ -3860,7 +3869,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			e = new SeqDisplayExpr(x, elements); 
 			Expect(48);
-		} else SynErr(230);
+		} else SynErr(231);
 	}
 
 	void MultiSetExpr(out Expression e) {
@@ -3884,7 +3893,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Expression(out e, true, true);
 			e = new MultiSetFormingExpr(x, e); 
 			Expect(50);
-		} else SynErr(231);
+		} else SynErr(232);
 	}
 
 	void ConstAtomExpression(out Expression e, bool allowSemi, bool allowLambda) {
@@ -3893,17 +3902,17 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;  Type toType = null;
 		
 		switch (la.kind) {
-		case 130: {
+		case 131: {
 			Get();
 			e = new LiteralExpr(t, false); 
 			break;
 		}
-		case 131: {
+		case 132: {
 			Get();
 			e = new LiteralExpr(t, true); 
 			break;
 		}
-		case 132: {
+		case 133: {
 			Get();
 			e = new LiteralExpr(t); 
 			break;
@@ -3931,12 +3940,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			
 			break;
 		}
-		case 133: {
+		case 134: {
 			Get();
 			e = new ThisExpr(t); 
 			break;
 		}
-		case 134: {
+		case 135: {
 			Get();
 			x = t; 
 			Expect(49);
@@ -3945,7 +3954,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Fresh, e); 
 			break;
 		}
-		case 135: {
+		case 136: {
 			Get();
 			x = t; 
 			Expect(49);
@@ -3980,7 +3989,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			ParensExpression(out e, allowSemi, allowLambda);
 			break;
 		}
-		default: SynErr(232); break;
+		default: SynErr(233); break;
 		}
 	}
 
@@ -4009,7 +4018,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 n = BigInteger.Zero;
 			}
 			
-		} else SynErr(233);
+		} else SynErr(234);
 	}
 
 	void Dec(out Basetypes.BigDec d) {
@@ -4053,20 +4062,20 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 29) {
 			Get();
 			oneShot = true; 
-		} else SynErr(234);
+		} else SynErr(235);
 	}
 
 	void MapLiteralExpressions(out List<ExpressionPair> elements) {
 		Expression/*!*/ d, r;
 		elements = new List<ExpressionPair/*!*/>(); 
 		Expression(out d, true, true);
-		Expect(93);
+		Expect(94);
 		Expression(out r, true, true);
 		elements.Add(new ExpressionPair(d,r)); 
 		while (la.kind == 22) {
 			Get();
 			Expression(out d, true, true);
-			Expect(93);
+			Expect(94);
 			Expression(out r, true, true);
 			elements.Add(new ExpressionPair(d,r)); 
 		}
@@ -4100,7 +4109,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<MatchCaseExpr/*!*/> cases = new List<MatchCaseExpr/*!*/>();
 		bool usesOptionalBrace = false;
 		
-		Expect(99);
+		Expect(100);
 		x = t; 
 		Expression(out e, allowSemi, allowLambda);
 		if (la.kind == _lbrace) {
@@ -4116,7 +4125,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				CaseExpression(out c, allowSemi, allowLambda);
 				cases.Add(c); 
 			}
-		} else SynErr(235);
+		} else SynErr(236);
 		e = new MatchExpr(x, e, cases, usesOptionalBrace); 
 	}
 
@@ -4128,13 +4137,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression range;
 		Expression/*!*/ body;
 		
-		if (la.kind == 102 || la.kind == 122) {
+		if (la.kind == 103 || la.kind == 123) {
 			Forall();
 			x = t;  univ = true; 
-		} else if (la.kind == 123 || la.kind == 124) {
+		} else if (la.kind == 124 || la.kind == 125) {
 			Exists();
 			x = t; 
-		} else SynErr(236);
+		} else SynErr(237);
 		QuantifierDomain(out bvars, out attrs, out range);
 		QSep();
 		Expression(out body, allowSemi, allowLambda);
@@ -4177,13 +4186,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void StmtInExpr(out Statement s) {
 		s = dummyStmt; 
-		if (la.kind == 100) {
+		if (la.kind == 101) {
 			AssertStmt(out s);
 		} else if (la.kind == 30) {
 			AssumeStmt(out s);
 		} else if (la.kind == 31) {
 			CalcStmt(out s);
-		} else SynErr(237);
+		} else SynErr(238);
 	}
 
 	void LetExpr(out Expression e, bool allowSemi, bool allowLambda) {
@@ -4196,11 +4205,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Attributes attrs = null;
 		e = dummyExpr;
 		
-		if (la.kind == 71) {
+		if (la.kind == 72) {
 			Get();
 			isGhost = true;  x = t; 
 		}
-		Expect(76);
+		Expect(77);
 		if (!isGhost) { x = t; } 
 		CasePattern(out pat);
 		if (isGhost) { pat.Vars.Iter(bv => bv.IsGhost = true); }
@@ -4213,13 +4222,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			letLHSs.Add(pat);
 			
 		}
-		if (la.kind == 93) {
+		if (la.kind == 94) {
 			Get();
-		} else if (la.kind == 45 || la.kind == 95) {
+		} else if (la.kind == 45 || la.kind == 96) {
 			while (la.kind == 45) {
 				Attribute(ref attrs);
 			}
-			Expect(95);
+			Expect(96);
 			exact = false;
 			foreach (var lhs in letLHSs) {
 			 if (lhs.Arguments != null) {
@@ -4227,7 +4236,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 }
 			}
 			
-		} else SynErr(238);
+		} else SynErr(239);
 		Expression(out e, false, true);
 		letRHSs.Add(e); 
 		while (la.kind == 22) {
@@ -4245,7 +4254,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;
 		Expression expr;
 		
-		Expect(90);
+		Expect(91);
 		x = t; 
 		NoUSIdent(out d);
 		Expect(21);
@@ -4287,7 +4296,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				arguments.Add(pat); 
 			}
 			Expect(50);
-		} else SynErr(239);
+		} else SynErr(240);
 		Expect(28);
 		Expression(out body, allowSemi, allowLambda);
 		c = new MatchCaseExpr(x, name, arguments, body); 
@@ -4295,7 +4304,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void HashCall(IToken id, out IToken openParen, out List<Type> typeArgs, out List<Expression> args) {
 		Expression k; args = new List<Expression>(); typeArgs = null; 
-		Expect(105);
+		Expect(106);
 		id.val = id.val + "#"; 
 		if (la.kind == 51) {
 			typeArgs = new List<Type>(); 
@@ -4352,7 +4361,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 43) {
 			Get();
 			x = t; 
-		} else SynErr(240);
+		} else SynErr(241);
 	}
 
 
@@ -4368,38 +4377,38 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 	}
 
 	static readonly bool[,]/*!*/ set = {
-		{T,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,T, x,x,T,T, T,x,x,T, T,x,x,T, T,x,T,T, T,T,T,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, T,x,T,T, x,x,T,T, T,x,x,T, x,x,T,T, T,T,T,T, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
-		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,x,T, x,x,x,x, T,x,T,T, T,T,T,T, T,T,T,T, x,x,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,T,x,x, T,x,x,x, x,x,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,T,x,x, x,T,T,T, T,T,T,T, T,T,T,T, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,T,T,T, T,T,x,x, x,x,T,x, x,x,x,T, x,x,x,x, x,x,x,x, T,T,x,T, x,T,x,x, T,x,T,T, T,T,T,T, T,T,T,T, x,x,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,T,T,T, T,x,x,x, T,x,T,x, x,T,T,T, x,T,T,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,x,x,T, x,x,T,T, T,T,T,T, x,x,x},
-		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,T,T,T, T,T,x,T, T,T,T,x, x,T,x,T, x,x,x,x, x,x,x,x, T,T,x,T, x,x,x,x, T,x,T,T, T,T,T,T, T,T,T,T, x,x,T,T, T,T,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,T,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,T,T,x, x,T,T,T, T,T,T,T, T,T,T,T, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
-		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,T,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,T,T,T, T,x,x,x, T,x,T,x, x,T,T,T, x,T,T,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,x,x,T, x,x,T,T, T,T,T,T, x,x,x},
-		{T,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
-		{x,T,T,T, T,x,x,x, T,x,T,x, x,T,T,T, x,T,T,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,T,x,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,x,x,T, x,x,T,T, T,T,T,T, x,x,x},
-		{x,T,T,T, T,x,x,x, T,x,T,x, x,T,T,T, x,T,T,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,T,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,x,x,T, x,x,T,T, T,T,T,T, x,x,x},
-		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
-		{x,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,T,T, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
-		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,T,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, T,T,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,T,T,T, T,x,x,x, T,x,T,x, x,T,T,T, x,T,T,T, T,x,x,T, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,T,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, T,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,T,T, T,x,x,T, x,x,T,T, T,T,T,T, x,x,x},
-		{x,x,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
-		{T,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,T,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, x,x,T,x, x,T,T,T, T,T,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,T,T, x,x,x},
-		{x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,T,T,x, x,x,x,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,T,x,T, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{T,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,x, T,T,x,T, x,x,x,x, T,x,T,T, T,T,T,T, T,T,T,T, x,x,T,T, T,T,T,T, T,T,T,T, x,T,T,T, x,T,T,T, T,T,T,T, T,x,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,x,x,x, x,T,T,T, T,T,T,T, T,T,T,T, T,x,x},
-		{T,T,T,T, T,x,x,x, T,x,T,x, x,x,x,x, x,x,x,T, T,T,T,T, T,T,x,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,x, T,T,T,T, T,T,T,T, T,T,T,x, T,T,x,T, x,x,x,x, T,x,T,T, T,T,T,T, T,T,T,T, x,x,T,T, T,T,T,T, T,T,T,T, x,T,T,x, x,T,T,T, T,T,T,T, T,x,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,x,x,x, x,T,T,T, T,T,T,T, T,T,T,T, T,x,x}
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_T, _x,_x,_T,_T, _T,_x,_x,_T, _T,_x,_x,_T, _T,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _T,_x,_x,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _T,_x,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_x, _x,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _T,_x,_x,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_T,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_x,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_x, _T,_x,_x,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_T,_T, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_x, _T,_x,_x,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_T,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x}
 
 	};
 } // end Parser
@@ -4486,185 +4495,186 @@ public class Errors {
 			case 59: s = "\"include\" expected"; break;
 			case 60: s = "\"abstract\" expected"; break;
 			case 61: s = "\"module\" expected"; break;
-			case 62: s = "\"refines\" expected"; break;
-			case 63: s = "\"import\" expected"; break;
-			case 64: s = "\"opened\" expected"; break;
-			case 65: s = "\"=\" expected"; break;
-			case 66: s = "\"as\" expected"; break;
-			case 67: s = "\"default\" expected"; break;
-			case 68: s = "\"class\" expected"; break;
-			case 69: s = "\"extends\" expected"; break;
-			case 70: s = "\"trait\" expected"; break;
-			case 71: s = "\"ghost\" expected"; break;
-			case 72: s = "\"static\" expected"; break;
-			case 73: s = "\"protected\" expected"; break;
-			case 74: s = "\"datatype\" expected"; break;
-			case 75: s = "\"codatatype\" expected"; break;
-			case 76: s = "\"var\" expected"; break;
-			case 77: s = "\"newtype\" expected"; break;
-			case 78: s = "\"type\" expected"; break;
-			case 79: s = "\"iterator\" expected"; break;
-			case 80: s = "\"yields\" expected"; break;
-			case 81: s = "\"returns\" expected"; break;
-			case 82: s = "\"method\" expected"; break;
-			case 83: s = "\"colemma\" expected"; break;
-			case 84: s = "\"comethod\" expected"; break;
-			case 85: s = "\"constructor\" expected"; break;
-			case 86: s = "\"free\" expected"; break;
-			case 87: s = "\"ensures\" expected"; break;
-			case 88: s = "\"yield\" expected"; break;
-			case 89: s = "\"`\" expected"; break;
-			case 90: s = "\"label\" expected"; break;
-			case 91: s = "\"break\" expected"; break;
-			case 92: s = "\"where\" expected"; break;
-			case 93: s = "\":=\" expected"; break;
-			case 94: s = "\"return\" expected"; break;
-			case 95: s = "\":|\" expected"; break;
-			case 96: s = "\"new\" expected"; break;
-			case 97: s = "\"if\" expected"; break;
-			case 98: s = "\"while\" expected"; break;
-			case 99: s = "\"match\" expected"; break;
-			case 100: s = "\"assert\" expected"; break;
-			case 101: s = "\"print\" expected"; break;
-			case 102: s = "\"forall\" expected"; break;
-			case 103: s = "\"parallel\" expected"; break;
-			case 104: s = "\"modify\" expected"; break;
-			case 105: s = "\"#\" expected"; break;
-			case 106: s = "\"<=\" expected"; break;
-			case 107: s = "\">=\" expected"; break;
-			case 108: s = "\"\\u2264\" expected"; break;
-			case 109: s = "\"\\u2265\" expected"; break;
-			case 110: s = "\"<==>\" expected"; break;
-			case 111: s = "\"\\u21d4\" expected"; break;
-			case 112: s = "\"==>\" expected"; break;
-			case 113: s = "\"\\u21d2\" expected"; break;
-			case 114: s = "\"<==\" expected"; break;
-			case 115: s = "\"\\u21d0\" expected"; break;
-			case 116: s = "\"&&\" expected"; break;
-			case 117: s = "\"\\u2227\" expected"; break;
-			case 118: s = "\"||\" expected"; break;
-			case 119: s = "\"\\u2228\" expected"; break;
-			case 120: s = "\"!\" expected"; break;
-			case 121: s = "\"\\u00ac\" expected"; break;
-			case 122: s = "\"\\u2200\" expected"; break;
-			case 123: s = "\"exists\" expected"; break;
-			case 124: s = "\"\\u2203\" expected"; break;
-			case 125: s = "\"in\" expected"; break;
-			case 126: s = "\"+\" expected"; break;
-			case 127: s = "\"-\" expected"; break;
-			case 128: s = "\"/\" expected"; break;
-			case 129: s = "\"%\" expected"; break;
-			case 130: s = "\"false\" expected"; break;
-			case 131: s = "\"true\" expected"; break;
-			case 132: s = "\"null\" expected"; break;
-			case 133: s = "\"this\" expected"; break;
-			case 134: s = "\"fresh\" expected"; break;
-			case 135: s = "\"old\" expected"; break;
-			case 136: s = "\"..\" expected"; break;
-			case 137: s = "??? expected"; break;
-			case 138: s = "this symbol not expected in SubModuleDecl"; break;
-			case 139: s = "invalid SubModuleDecl"; break;
-			case 140: s = "this symbol not expected in ClassDecl"; break;
-			case 141: s = "this symbol not expected in DatatypeDecl"; break;
-			case 142: s = "invalid DatatypeDecl"; break;
-			case 143: s = "this symbol not expected in DatatypeDecl"; break;
-			case 144: s = "invalid NewtypeDecl"; break;
-			case 145: s = "invalid OtherTypeDecl"; break;
-			case 146: s = "this symbol not expected in OtherTypeDecl"; break;
-			case 147: s = "this symbol not expected in IteratorDecl"; break;
-			case 148: s = "invalid IteratorDecl"; break;
-			case 149: s = "this symbol not expected in TraitDecl"; break;
-			case 150: s = "invalid ClassMemberDecl"; break;
-			case 151: s = "this symbol not expected in FieldDecl"; break;
-			case 152: s = "invalid FunctionDecl"; break;
+			case 62: s = "\"exclusively\" expected"; break;
+			case 63: s = "\"refines\" expected"; break;
+			case 64: s = "\"import\" expected"; break;
+			case 65: s = "\"opened\" expected"; break;
+			case 66: s = "\"=\" expected"; break;
+			case 67: s = "\"as\" expected"; break;
+			case 68: s = "\"default\" expected"; break;
+			case 69: s = "\"class\" expected"; break;
+			case 70: s = "\"extends\" expected"; break;
+			case 71: s = "\"trait\" expected"; break;
+			case 72: s = "\"ghost\" expected"; break;
+			case 73: s = "\"static\" expected"; break;
+			case 74: s = "\"protected\" expected"; break;
+			case 75: s = "\"datatype\" expected"; break;
+			case 76: s = "\"codatatype\" expected"; break;
+			case 77: s = "\"var\" expected"; break;
+			case 78: s = "\"newtype\" expected"; break;
+			case 79: s = "\"type\" expected"; break;
+			case 80: s = "\"iterator\" expected"; break;
+			case 81: s = "\"yields\" expected"; break;
+			case 82: s = "\"returns\" expected"; break;
+			case 83: s = "\"method\" expected"; break;
+			case 84: s = "\"colemma\" expected"; break;
+			case 85: s = "\"comethod\" expected"; break;
+			case 86: s = "\"constructor\" expected"; break;
+			case 87: s = "\"free\" expected"; break;
+			case 88: s = "\"ensures\" expected"; break;
+			case 89: s = "\"yield\" expected"; break;
+			case 90: s = "\"`\" expected"; break;
+			case 91: s = "\"label\" expected"; break;
+			case 92: s = "\"break\" expected"; break;
+			case 93: s = "\"where\" expected"; break;
+			case 94: s = "\":=\" expected"; break;
+			case 95: s = "\"return\" expected"; break;
+			case 96: s = "\":|\" expected"; break;
+			case 97: s = "\"new\" expected"; break;
+			case 98: s = "\"if\" expected"; break;
+			case 99: s = "\"while\" expected"; break;
+			case 100: s = "\"match\" expected"; break;
+			case 101: s = "\"assert\" expected"; break;
+			case 102: s = "\"print\" expected"; break;
+			case 103: s = "\"forall\" expected"; break;
+			case 104: s = "\"parallel\" expected"; break;
+			case 105: s = "\"modify\" expected"; break;
+			case 106: s = "\"#\" expected"; break;
+			case 107: s = "\"<=\" expected"; break;
+			case 108: s = "\">=\" expected"; break;
+			case 109: s = "\"\\u2264\" expected"; break;
+			case 110: s = "\"\\u2265\" expected"; break;
+			case 111: s = "\"<==>\" expected"; break;
+			case 112: s = "\"\\u21d4\" expected"; break;
+			case 113: s = "\"==>\" expected"; break;
+			case 114: s = "\"\\u21d2\" expected"; break;
+			case 115: s = "\"<==\" expected"; break;
+			case 116: s = "\"\\u21d0\" expected"; break;
+			case 117: s = "\"&&\" expected"; break;
+			case 118: s = "\"\\u2227\" expected"; break;
+			case 119: s = "\"||\" expected"; break;
+			case 120: s = "\"\\u2228\" expected"; break;
+			case 121: s = "\"!\" expected"; break;
+			case 122: s = "\"\\u00ac\" expected"; break;
+			case 123: s = "\"\\u2200\" expected"; break;
+			case 124: s = "\"exists\" expected"; break;
+			case 125: s = "\"\\u2203\" expected"; break;
+			case 126: s = "\"in\" expected"; break;
+			case 127: s = "\"+\" expected"; break;
+			case 128: s = "\"-\" expected"; break;
+			case 129: s = "\"/\" expected"; break;
+			case 130: s = "\"%\" expected"; break;
+			case 131: s = "\"false\" expected"; break;
+			case 132: s = "\"true\" expected"; break;
+			case 133: s = "\"null\" expected"; break;
+			case 134: s = "\"this\" expected"; break;
+			case 135: s = "\"fresh\" expected"; break;
+			case 136: s = "\"old\" expected"; break;
+			case 137: s = "\"..\" expected"; break;
+			case 138: s = "??? expected"; break;
+			case 139: s = "this symbol not expected in SubModuleDecl"; break;
+			case 140: s = "invalid SubModuleDecl"; break;
+			case 141: s = "this symbol not expected in ClassDecl"; break;
+			case 142: s = "this symbol not expected in DatatypeDecl"; break;
+			case 143: s = "invalid DatatypeDecl"; break;
+			case 144: s = "this symbol not expected in DatatypeDecl"; break;
+			case 145: s = "invalid NewtypeDecl"; break;
+			case 146: s = "invalid OtherTypeDecl"; break;
+			case 147: s = "this symbol not expected in OtherTypeDecl"; break;
+			case 148: s = "this symbol not expected in IteratorDecl"; break;
+			case 149: s = "invalid IteratorDecl"; break;
+			case 150: s = "this symbol not expected in TraitDecl"; break;
+			case 151: s = "invalid ClassMemberDecl"; break;
+			case 152: s = "this symbol not expected in FieldDecl"; break;
 			case 153: s = "invalid FunctionDecl"; break;
 			case 154: s = "invalid FunctionDecl"; break;
 			case 155: s = "invalid FunctionDecl"; break;
 			case 156: s = "invalid FunctionDecl"; break;
-			case 157: s = "this symbol not expected in MethodDecl"; break;
-			case 158: s = "invalid MethodDecl"; break;
+			case 157: s = "invalid FunctionDecl"; break;
+			case 158: s = "this symbol not expected in MethodDecl"; break;
 			case 159: s = "invalid MethodDecl"; break;
-			case 160: s = "invalid FIdentType"; break;
-			case 161: s = "this symbol not expected in OldSemi"; break;
-			case 162: s = "invalid TypeIdentOptional"; break;
-			case 163: s = "invalid TypeAndToken"; break;
-			case 164: s = "this symbol not expected in IteratorSpec"; break;
-			case 165: s = "invalid IteratorSpec"; break;
+			case 160: s = "invalid MethodDecl"; break;
+			case 161: s = "invalid FIdentType"; break;
+			case 162: s = "this symbol not expected in OldSemi"; break;
+			case 163: s = "invalid TypeIdentOptional"; break;
+			case 164: s = "invalid TypeAndToken"; break;
+			case 165: s = "this symbol not expected in IteratorSpec"; break;
 			case 166: s = "invalid IteratorSpec"; break;
-			case 167: s = "this symbol not expected in MethodSpec"; break;
-			case 168: s = "invalid MethodSpec"; break;
+			case 167: s = "invalid IteratorSpec"; break;
+			case 168: s = "this symbol not expected in MethodSpec"; break;
 			case 169: s = "invalid MethodSpec"; break;
-			case 170: s = "invalid FrameExpression"; break;
-			case 171: s = "this symbol not expected in FunctionSpec"; break;
-			case 172: s = "invalid FunctionSpec"; break;
-			case 173: s = "invalid PossiblyWildFrameExpression"; break;
-			case 174: s = "invalid PossiblyWildExpression"; break;
-			case 175: s = "this symbol not expected in OneStmt"; break;
-			case 176: s = "invalid OneStmt"; break;
-			case 177: s = "this symbol not expected in OneStmt"; break;
-			case 178: s = "invalid OneStmt"; break;
-			case 179: s = "invalid AssertStmt"; break;
-			case 180: s = "invalid AssumeStmt"; break;
-			case 181: s = "invalid UpdateStmt"; break;
+			case 170: s = "invalid MethodSpec"; break;
+			case 171: s = "invalid FrameExpression"; break;
+			case 172: s = "this symbol not expected in FunctionSpec"; break;
+			case 173: s = "invalid FunctionSpec"; break;
+			case 174: s = "invalid PossiblyWildFrameExpression"; break;
+			case 175: s = "invalid PossiblyWildExpression"; break;
+			case 176: s = "this symbol not expected in OneStmt"; break;
+			case 177: s = "invalid OneStmt"; break;
+			case 178: s = "this symbol not expected in OneStmt"; break;
+			case 179: s = "invalid OneStmt"; break;
+			case 180: s = "invalid AssertStmt"; break;
+			case 181: s = "invalid AssumeStmt"; break;
 			case 182: s = "invalid UpdateStmt"; break;
-			case 183: s = "this symbol not expected in VarDeclStatement"; break;
-			case 184: s = "invalid IfStmt"; break;
+			case 183: s = "invalid UpdateStmt"; break;
+			case 184: s = "this symbol not expected in VarDeclStatement"; break;
 			case 185: s = "invalid IfStmt"; break;
-			case 186: s = "invalid WhileStmt"; break;
+			case 186: s = "invalid IfStmt"; break;
 			case 187: s = "invalid WhileStmt"; break;
-			case 188: s = "invalid MatchStmt"; break;
-			case 189: s = "invalid ForallStmt"; break;
+			case 188: s = "invalid WhileStmt"; break;
+			case 189: s = "invalid MatchStmt"; break;
 			case 190: s = "invalid ForallStmt"; break;
-			case 191: s = "invalid CalcStmt"; break;
-			case 192: s = "invalid ModifyStmt"; break;
-			case 193: s = "this symbol not expected in ModifyStmt"; break;
-			case 194: s = "invalid ModifyStmt"; break;
-			case 195: s = "invalid ReturnStmt"; break;
-			case 196: s = "invalid Rhs"; break;
-			case 197: s = "invalid Lhs"; break;
-			case 198: s = "invalid Guard"; break;
-			case 199: s = "this symbol not expected in LoopSpec"; break;
+			case 191: s = "invalid ForallStmt"; break;
+			case 192: s = "invalid CalcStmt"; break;
+			case 193: s = "invalid ModifyStmt"; break;
+			case 194: s = "this symbol not expected in ModifyStmt"; break;
+			case 195: s = "invalid ModifyStmt"; break;
+			case 196: s = "invalid ReturnStmt"; break;
+			case 197: s = "invalid Rhs"; break;
+			case 198: s = "invalid Lhs"; break;
+			case 199: s = "invalid Guard"; break;
 			case 200: s = "this symbol not expected in LoopSpec"; break;
 			case 201: s = "this symbol not expected in LoopSpec"; break;
-			case 202: s = "invalid LoopSpec"; break;
-			case 203: s = "invalid CaseStatement"; break;
-			case 204: s = "this symbol not expected in CaseStatement"; break;
+			case 202: s = "this symbol not expected in LoopSpec"; break;
+			case 203: s = "invalid LoopSpec"; break;
+			case 204: s = "invalid CaseStatement"; break;
 			case 205: s = "this symbol not expected in CaseStatement"; break;
-			case 206: s = "invalid CasePattern"; break;
-			case 207: s = "invalid CalcOp"; break;
-			case 208: s = "invalid EquivOp"; break;
-			case 209: s = "invalid ImpliesOp"; break;
-			case 210: s = "invalid ExpliesOp"; break;
-			case 211: s = "invalid AndOp"; break;
-			case 212: s = "invalid OrOp"; break;
-			case 213: s = "invalid NegOp"; break;
-			case 214: s = "invalid Forall"; break;
-			case 215: s = "invalid Exists"; break;
-			case 216: s = "invalid QSep"; break;
-			case 217: s = "invalid ImpliesExpliesExpression"; break;
-			case 218: s = "invalid LogicalExpression"; break;
-			case 219: s = "invalid RelOp"; break;
-			case 220: s = "invalid AddOp"; break;
-			case 221: s = "invalid UnaryExpression"; break;
-			case 222: s = "invalid MulOp"; break;
-			case 223: s = "invalid Suffix"; break;
+			case 206: s = "this symbol not expected in CaseStatement"; break;
+			case 207: s = "invalid CasePattern"; break;
+			case 208: s = "invalid CalcOp"; break;
+			case 209: s = "invalid EquivOp"; break;
+			case 210: s = "invalid ImpliesOp"; break;
+			case 211: s = "invalid ExpliesOp"; break;
+			case 212: s = "invalid AndOp"; break;
+			case 213: s = "invalid OrOp"; break;
+			case 214: s = "invalid NegOp"; break;
+			case 215: s = "invalid Forall"; break;
+			case 216: s = "invalid Exists"; break;
+			case 217: s = "invalid QSep"; break;
+			case 218: s = "invalid ImpliesExpliesExpression"; break;
+			case 219: s = "invalid LogicalExpression"; break;
+			case 220: s = "invalid RelOp"; break;
+			case 221: s = "invalid AddOp"; break;
+			case 222: s = "invalid UnaryExpression"; break;
+			case 223: s = "invalid MulOp"; break;
 			case 224: s = "invalid Suffix"; break;
 			case 225: s = "invalid Suffix"; break;
 			case 226: s = "invalid Suffix"; break;
-			case 227: s = "invalid LambdaExpression"; break;
-			case 228: s = "invalid EndlessExpression"; break;
-			case 229: s = "invalid NameSegment"; break;
-			case 230: s = "invalid DisplayExpr"; break;
-			case 231: s = "invalid MultiSetExpr"; break;
-			case 232: s = "invalid ConstAtomExpression"; break;
-			case 233: s = "invalid Nat"; break;
-			case 234: s = "invalid LambdaArrow"; break;
-			case 235: s = "invalid MatchExpression"; break;
-			case 236: s = "invalid QuantifierGuts"; break;
-			case 237: s = "invalid StmtInExpr"; break;
-			case 238: s = "invalid LetExpr"; break;
-			case 239: s = "invalid CaseExpression"; break;
-			case 240: s = "invalid DotSuffix"; break;
+			case 227: s = "invalid Suffix"; break;
+			case 228: s = "invalid LambdaExpression"; break;
+			case 229: s = "invalid EndlessExpression"; break;
+			case 230: s = "invalid NameSegment"; break;
+			case 231: s = "invalid DisplayExpr"; break;
+			case 232: s = "invalid MultiSetExpr"; break;
+			case 233: s = "invalid ConstAtomExpression"; break;
+			case 234: s = "invalid Nat"; break;
+			case 235: s = "invalid LambdaArrow"; break;
+			case 236: s = "invalid MatchExpression"; break;
+			case 237: s = "invalid QuantifierGuts"; break;
+			case 238: s = "invalid StmtInExpr"; break;
+			case 239: s = "invalid LetExpr"; break;
+			case 240: s = "invalid CaseExpression"; break;
+			case 241: s = "invalid DotSuffix"; break;
 
 			default: s = "error " + n; break;
 		}
diff --git a/Source/Dafny/RefinementTransformer.cs b/Source/Dafny/RefinementTransformer.cs
index 05146b7d..2d32f78a 100644
--- a/Source/Dafny/RefinementTransformer.cs
+++ b/Source/Dafny/RefinementTransformer.cs
@@ -86,6 +86,15 @@ namespace Microsoft.Dafny
         if (Resolver.ResolvePath(m.RefinementBaseRoot, m.RefinementBaseName, out RefinedSig, reporter)) {
           if (RefinedSig.ModuleDef != null) {
             m.RefinementBase = RefinedSig.ModuleDef;
+            if (m.IsExclusiveRefinement) {
+              if (null == m.RefinementBase.ExclusiveRefinement) {
+                m.RefinementBase.ExclusiveRefinement = m;
+              } else {
+                this.reporter.Error(
+                    m.tok,
+                    "no more than one exclusive refinement may exist for a given module.");
+              }
+            }
             PreResolveWorker(m);
           } else {
             reporter.Error(m.RefinementBaseName[0], "module ({0}) named as refinement base is not a literal module or simple reference to a literal module", Util.Comma(".", m.RefinementBaseName, x => x.val));
diff --git a/Source/Dafny/Resolver.cs b/Source/Dafny/Resolver.cs
index 29e36ccd..2d274ffe 100644
--- a/Source/Dafny/Resolver.cs
+++ b/Source/Dafny/Resolver.cs
@@ -305,6 +305,33 @@ namespace Microsoft.Dafny
 
       systemNameInfo = RegisterTopLevelDecls(prog.BuiltIns.SystemModule, false);
       prog.CompileModules.Add(prog.BuiltIns.SystemModule);
+
+      // first, we need to detect which top-level modules have exclusive refinement relationships.
+      foreach (ModuleDecl decl in sortedDecls) {
+        if (decl is LiteralModuleDecl) {
+          var literalDecl = (LiteralModuleDecl)decl;
+          var m = literalDecl.ModuleDef;
+          if (m.RefinementBaseRoot != null) {
+            if (m.IsExclusiveRefinement) {
+              foreach (var d in sortedDecls) {
+                // refinement dependencies won't be later in the sorted module list than the one we're looking at.
+                if (Object.ReferenceEquals(d, decl)) {
+                  break;
+                }
+                if (d is LiteralModuleDecl) {
+                  var ld = (LiteralModuleDecl)d;
+                  // currently, only exclusive refinements of top-level modules are supported.
+                  if (string.Equals(m.RefinementBaseName[0].val, m.RefinementBaseRoot.Name, StringComparison.InvariantCulture)
+                      && string.Equals(m.RefinementBaseName[0].val, ld.ModuleDef.Name, StringComparison.InvariantCulture)) {
+                    ld.ModuleDef.ExclusiveRefinementCount += 1;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
       foreach (var decl in sortedDecls) {
         if (decl is LiteralModuleDecl) {
           // The declaration is a literal module, so it has members and such that we need
@@ -360,20 +387,27 @@ namespace Microsoft.Dafny
           var abs = (ModuleFacadeDecl)decl;
           ModuleSignature p;
           if (ResolvePath(abs.Root, abs.Path, out p, this)) {
-            abs.Signature = MakeAbstractSignature(p, abs.FullCompileName, abs.Height, prog.Modules);
             abs.OriginalSignature = p;
-            ModuleSignature compileSig;
-            if (abs.CompilePath != null) {
-              if (ResolvePath(abs.CompileRoot, abs.CompilePath, out compileSig, this)) {
-                if (refinementTransformer.CheckIsRefinement(compileSig, p)) {
-                  abs.Signature.CompileSignature = compileSig;
-                } else {
-                  Error(abs.CompilePath[0],
-                  "module " + Util.Comma(".", abs.CompilePath, x => x.val) + " must be a refinement of " + Util.Comma(".", abs.Path, x => x.val));
+            // ModuleDefinition.ExclusiveRefinement may not be set at this point but ExclusiveRefinementCount will be.
+            if (0 == abs.Root.Signature.ModuleDef.ExclusiveRefinementCount) {
+              abs.Signature = MakeAbstractSignature(p, abs.FullCompileName, abs.Height, prog.Modules);
+              ModuleSignature compileSig;
+              if (abs.CompilePath != null) {
+                if (ResolvePath(abs.CompileRoot, abs.CompilePath, out compileSig, this)) {
+                  if (refinementTransformer.CheckIsRefinement(compileSig, p)) {
+                    abs.Signature.CompileSignature = compileSig;
+                  } else {
+                    Error(
+                      abs.CompilePath[0],
+                      "module " + Util.Comma(".", abs.CompilePath, x => x.val) + " must be a refinement of "
+                      + Util.Comma(".", abs.Path, x => x.val));
+                  }
+                  abs.Signature.IsGhost = compileSig.IsGhost;
+                  // always keep the ghost information, to supress a spurious error message when the compile module isn't actually a refinement
                 }
-                abs.Signature.IsGhost = compileSig.IsGhost;
-                // always keep the ghost information, to supress a spurious error message when the compile module isn't actually a refinement
               }
+            } else {
+              abs.Signature = p;
             }
           } else {
             abs.Signature = new ModuleSignature(); // there was an error, give it a valid but empty signature
@@ -1198,7 +1232,8 @@ namespace Microsoft.Dafny
     }
 
     private ModuleSignature MakeAbstractSignature(ModuleSignature p, string Name, int Height, List<ModuleDefinition> mods) {
-      var mod = new ModuleDefinition(Token.NoToken, Name + ".Abs", true, true, null, null, null, false);
+      var mod = new ModuleDefinition(Token.NoToken, Name + ".Abs", true, true, /*isExclusiveRefinement:*/ false, null, null, null, false);
+      mod.ClonedFrom = p.ModuleDef;
       mod.Height = Height;
       foreach (var kv in p.TopLevels) {
         mod.TopLevelDecls.Add(CloneDeclaration(kv.Value, mod, mods, Name));
@@ -1207,6 +1242,7 @@ namespace Microsoft.Dafny
       sig.Refines = p.Refines;
       sig.CompileSignature = p;
       sig.IsGhost = p.IsGhost;
+      sig.ExclusiveRefinement = p.ExclusiveRefinement;
       mods.Add(mod);
       ResolveModuleDefinition(mod, sig);
       return sig;
@@ -4200,8 +4236,15 @@ namespace Microsoft.Dafny
           } else if (r.Type is Resolver_IdentifierExpr.ResolverType_Type) {
             var d = r.Decl;
             if (d is OpaqueTypeDecl) {
-              t.ResolvedParam = ((OpaqueTypeDecl)d).TheType;  // resolve like a type parameter, and it may have type parameters if it's an opaque type              
-              t.ResolvedClass = d;  // Store the decl, so the compiler will generate the fully qualified name
+              var dd = (OpaqueTypeDecl)d;
+              if (dd.Module.ClonedFrom != null && dd.Module.ClonedFrom.ExclusiveRefinement != null) {
+                t.ResolvedParam = ((OpaqueTypeDecl)dd.ClonedFrom).TheType;
+                t.ResolvedClass = d;  // Store the decl, so the compiler will generate the fully qualified name
+              } else {
+                t.ResolvedParam = ((OpaqueTypeDecl)d).TheType;
+                // resolve like a type parameter, and it may have type parameters if it's an opaque type
+                t.ResolvedClass = d;  // Store the decl, so the compiler will generate the fully qualified name
+              }
             } else if (d is NewtypeDecl) {
               var dd = (NewtypeDecl)d;
               var caller = context as ICallable;
diff --git a/Source/Dafny/Scanner.cs b/Source/Dafny/Scanner.cs
index d0d2e4dd..325a2f2c 100644
--- a/Source/Dafny/Scanner.cs
+++ b/Source/Dafny/Scanner.cs
@@ -211,13 +211,13 @@ public class UTF8Buffer: Buffer {
 public class Scanner {
 	const char EOL = '\n';
 	const int eofSym = 0; /* pdt */
-	const int maxT = 137;
-	const int noSym = 137;
+	const int maxT = 138;
+	const int noSym = 138;
 
 
 	[ContractInvariantMethod]
 	void objectInvariant(){
-		Contract.Invariant(buffer!=null);
+		Contract.Invariant(this._buffer != null);
 		Contract.Invariant(t != null);
 		Contract.Invariant(start != null);
 		Contract.Invariant(tokens != null);
@@ -227,7 +227,18 @@ public class Scanner {
 		Contract.Invariant(errorHandler != null);
 	}
 
-	public Buffer/*!*/ buffer; // scanner buffer
+	private Buffer/*!*/ _buffer; // scanner buffer
+
+	public Buffer/*!*/ buffer {
+		get {
+			Contract.Ensures(Contract.Result<Buffer>() != null);
+			return this._buffer;
+		}
+		set {
+			Contract.Requires(value != null);
+			this._buffer = value;
+		}
+	}
 
 	Token/*!*/ t;          // current token
 	int ch;           // current input character
@@ -299,7 +310,7 @@ public class Scanner {
 	}
 
 //	[NotDelayed]
-	public Scanner (string/*!*/ fileName, Errors/*!*/ errorHandler) : base() {
+	public Scanner (string/*!*/ fileName, Errors/*!*/ errorHandler, bool useBaseName = false) : base() {
 	  Contract.Requires(fileName != null);
 	  Contract.Requires(errorHandler != null);
 		this.errorHandler = errorHandler;
@@ -307,8 +318,8 @@ public class Scanner {
 		t = new Token(); // dummy because t is a non-null field
 		try {
 			Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
-			buffer = new Buffer(stream, false);
-			Filename = fileName;
+			this._buffer = new Buffer(stream, false);
+			Filename = useBaseName? GetBaseName(fileName): fileName;
 			Init();
 		} catch (IOException) {
 			throw new FatalError("Cannot open file " + fileName);
@@ -316,18 +327,22 @@ public class Scanner {
 	}
 
 //	[NotDelayed]
-	public Scanner (Stream/*!*/ s, Errors/*!*/ errorHandler, string/*!*/ fileName) : base() {
+	public Scanner (Stream/*!*/ s, Errors/*!*/ errorHandler, string/*!*/ fileName, bool useBaseName = false) : base() {
 	  Contract.Requires(s != null);
 	  Contract.Requires(errorHandler != null);
 	  Contract.Requires(fileName != null);
 		pt = tokens = new Token();  // first token is a dummy
 		t = new Token(); // dummy because t is a non-null field
-		buffer = new Buffer(s, true);
+		this._buffer = new Buffer(s, true);
 		this.errorHandler = errorHandler;
-		this.Filename = fileName;
+		this.Filename = useBaseName? GetBaseName(fileName) : fileName;
 		Init();
 	}
 
+    string GetBaseName(string fileName) {
+        return System.IO.Path.GetFileName(fileName); // Return basename
+    }
+
 	void Init() {
 		pos = -1; line = 1; col = 0;
 		oldEols = 0;
@@ -522,53 +537,54 @@ public class Scanner {
 			case "include": t.kind = 59; break;
 			case "abstract": t.kind = 60; break;
 			case "module": t.kind = 61; break;
-			case "refines": t.kind = 62; break;
-			case "import": t.kind = 63; break;
-			case "opened": t.kind = 64; break;
-			case "as": t.kind = 66; break;
-			case "default": t.kind = 67; break;
-			case "class": t.kind = 68; break;
-			case "extends": t.kind = 69; break;
-			case "trait": t.kind = 70; break;
-			case "ghost": t.kind = 71; break;
-			case "static": t.kind = 72; break;
-			case "protected": t.kind = 73; break;
-			case "datatype": t.kind = 74; break;
-			case "codatatype": t.kind = 75; break;
-			case "var": t.kind = 76; break;
-			case "newtype": t.kind = 77; break;
-			case "type": t.kind = 78; break;
-			case "iterator": t.kind = 79; break;
-			case "yields": t.kind = 80; break;
-			case "returns": t.kind = 81; break;
-			case "method": t.kind = 82; break;
-			case "colemma": t.kind = 83; break;
-			case "comethod": t.kind = 84; break;
-			case "constructor": t.kind = 85; break;
-			case "free": t.kind = 86; break;
-			case "ensures": t.kind = 87; break;
-			case "yield": t.kind = 88; break;
-			case "label": t.kind = 90; break;
-			case "break": t.kind = 91; break;
-			case "where": t.kind = 92; break;
-			case "return": t.kind = 94; break;
-			case "new": t.kind = 96; break;
-			case "if": t.kind = 97; break;
-			case "while": t.kind = 98; break;
-			case "match": t.kind = 99; break;
-			case "assert": t.kind = 100; break;
-			case "print": t.kind = 101; break;
-			case "forall": t.kind = 102; break;
-			case "parallel": t.kind = 103; break;
-			case "modify": t.kind = 104; break;
-			case "exists": t.kind = 123; break;
-			case "in": t.kind = 125; break;
-			case "false": t.kind = 130; break;
-			case "true": t.kind = 131; break;
-			case "null": t.kind = 132; break;
-			case "this": t.kind = 133; break;
-			case "fresh": t.kind = 134; break;
-			case "old": t.kind = 135; break;
+			case "exclusively": t.kind = 62; break;
+			case "refines": t.kind = 63; break;
+			case "import": t.kind = 64; break;
+			case "opened": t.kind = 65; break;
+			case "as": t.kind = 67; break;
+			case "default": t.kind = 68; break;
+			case "class": t.kind = 69; break;
+			case "extends": t.kind = 70; break;
+			case "trait": t.kind = 71; break;
+			case "ghost": t.kind = 72; break;
+			case "static": t.kind = 73; break;
+			case "protected": t.kind = 74; break;
+			case "datatype": t.kind = 75; break;
+			case "codatatype": t.kind = 76; break;
+			case "var": t.kind = 77; break;
+			case "newtype": t.kind = 78; break;
+			case "type": t.kind = 79; break;
+			case "iterator": t.kind = 80; break;
+			case "yields": t.kind = 81; break;
+			case "returns": t.kind = 82; break;
+			case "method": t.kind = 83; break;
+			case "colemma": t.kind = 84; break;
+			case "comethod": t.kind = 85; break;
+			case "constructor": t.kind = 86; break;
+			case "free": t.kind = 87; break;
+			case "ensures": t.kind = 88; break;
+			case "yield": t.kind = 89; break;
+			case "label": t.kind = 91; break;
+			case "break": t.kind = 92; break;
+			case "where": t.kind = 93; break;
+			case "return": t.kind = 95; break;
+			case "new": t.kind = 97; break;
+			case "if": t.kind = 98; break;
+			case "while": t.kind = 99; break;
+			case "match": t.kind = 100; break;
+			case "assert": t.kind = 101; break;
+			case "print": t.kind = 102; break;
+			case "forall": t.kind = 103; break;
+			case "parallel": t.kind = 104; break;
+			case "modify": t.kind = 105; break;
+			case "exists": t.kind = 124; break;
+			case "in": t.kind = 126; break;
+			case "false": t.kind = 131; break;
+			case "true": t.kind = 132; break;
+			case "null": t.kind = 133; break;
+			case "this": t.kind = 134; break;
+			case "fresh": t.kind = 135; break;
+			case "old": t.kind = 136; break;
 			default: break;
 		}
 	}
@@ -829,52 +845,52 @@ public class Scanner {
 				else if (ch >= '0' && ch <= '9') {AddCh(); goto case 65;}
 				else {t.kind = 5; break;}
 			case 66:
-				{t.kind = 89; break;}
+				{t.kind = 90; break;}
 			case 67:
-				{t.kind = 93; break;}
+				{t.kind = 94; break;}
 			case 68:
-				{t.kind = 95; break;}
+				{t.kind = 96; break;}
 			case 69:
-				{t.kind = 105; break;}
+				{t.kind = 106; break;}
 			case 70:
-				{t.kind = 107; break;}
-			case 71:
 				{t.kind = 108; break;}
-			case 72:
+			case 71:
 				{t.kind = 109; break;}
-			case 73:
+			case 72:
 				{t.kind = 110; break;}
-			case 74:
+			case 73:
 				{t.kind = 111; break;}
-			case 75:
+			case 74:
 				{t.kind = 112; break;}
-			case 76:
+			case 75:
 				{t.kind = 113; break;}
+			case 76:
+				{t.kind = 114; break;}
 			case 77:
-				{t.kind = 115; break;}
+				{t.kind = 116; break;}
 			case 78:
 				if (ch == '&') {AddCh(); goto case 79;}
 				else {goto case 0;}
 			case 79:
-				{t.kind = 116; break;}
-			case 80:
 				{t.kind = 117; break;}
-			case 81:
+			case 80:
 				{t.kind = 118; break;}
-			case 82:
+			case 81:
 				{t.kind = 119; break;}
+			case 82:
+				{t.kind = 120; break;}
 			case 83:
-				{t.kind = 121; break;}
-			case 84:
 				{t.kind = 122; break;}
+			case 84:
+				{t.kind = 123; break;}
 			case 85:
-				{t.kind = 124; break;}
+				{t.kind = 125; break;}
 			case 86:
-				{t.kind = 126; break;}
+				{t.kind = 127; break;}
 			case 87:
-				{t.kind = 128; break;}
-			case 88:
 				{t.kind = 129; break;}
+			case 88:
+				{t.kind = 130; break;}
 			case 89:
 				recEnd = pos; recKind = 21;
 				if (ch == ':') {AddCh(); goto case 30;}
@@ -890,14 +906,14 @@ public class Scanner {
 				if (ch == '.') {AddCh(); goto case 97;}
 				else {t.kind = 26; break;}
 			case 92:
-				recEnd = pos; recKind = 65;
+				recEnd = pos; recKind = 66;
 				if (ch == '>') {AddCh(); goto case 33;}
 				else if (ch == '=') {AddCh(); goto case 98;}
-				else {t.kind = 65; break;}
+				else {t.kind = 66; break;}
 			case 93:
-				recEnd = pos; recKind = 127;
+				recEnd = pos; recKind = 128;
 				if (ch == '>') {AddCh(); goto case 34;}
-				else {t.kind = 127; break;}
+				else {t.kind = 128; break;}
 			case 94:
 				recEnd = pos; recKind = 51;
 				if (ch == '=') {AddCh(); goto case 99;}
@@ -907,26 +923,26 @@ public class Scanner {
 				if (ch == '=') {AddCh(); goto case 70;}
 				else {t.kind = 52; break;}
 			case 96:
-				recEnd = pos; recKind = 120;
+				recEnd = pos; recKind = 121;
 				if (ch == '=') {AddCh(); goto case 41;}
 				else if (ch == 'i') {AddCh(); goto case 44;}
-				else {t.kind = 120; break;}
+				else {t.kind = 121; break;}
 			case 97:
-				recEnd = pos; recKind = 136;
+				recEnd = pos; recKind = 137;
 				if (ch == '.') {AddCh(); goto case 47;}
-				else {t.kind = 136; break;}
+				else {t.kind = 137; break;}
 			case 98:
 				recEnd = pos; recKind = 53;
 				if (ch == '>') {AddCh(); goto case 75;}
 				else {t.kind = 53; break;}
 			case 99:
-				recEnd = pos; recKind = 106;
+				recEnd = pos; recKind = 107;
 				if (ch == '=') {AddCh(); goto case 100;}
-				else {t.kind = 106; break;}
+				else {t.kind = 107; break;}
 			case 100:
-				recEnd = pos; recKind = 114;
+				recEnd = pos; recKind = 115;
 				if (ch == '>') {AddCh(); goto case 73;}
-				else {t.kind = 114; break;}
+				else {t.kind = 115; break;}
 
 		}
 		t.val = new String(tval, 0, tlen);
diff --git a/Source/Dafny/Translator.cs b/Source/Dafny/Translator.cs
index c834d23e..cefce6b6 100644
--- a/Source/Dafny/Translator.cs
+++ b/Source/Dafny/Translator.cs
@@ -6250,9 +6250,7 @@ namespace Microsoft.Dafny {
           } else {
             bool splitHappened;  // we actually don't care
             foreach (var s in TrSplitExpr(p.E, etran, kind == MethodTranslationKind.InterModuleCall ? 0 : int.MaxValue, true /* kind == MethodTranslationKind.Implementation */, out splitHappened)) {
-              if ((kind == MethodTranslationKind.IntraModuleCall || kind == MethodTranslationKind.CoCall) && RefinementToken.IsInherited(s.E.tok, currentModule)) {
-                // this precondition was inherited into this module, so just ignore it
-              } else if (s.IsOnlyChecked && bodyKind) {
+              if (s.IsOnlyChecked && bodyKind) {
                 // don't include in split
               } else if (s.IsOnlyFree && !bodyKind) {
                 // don't include in split -- it would be ignored, anyhow
-- 
cgit v1.2.3


From 31005fdf54359aad3f33a54228d61d82e10bc679 Mon Sep 17 00:00:00 2001
From: Clément Pit--Claudel <clement.pitclaudel@live.com>
Date: Thu, 23 Jul 2015 11:35:01 -0700
Subject: Fix a bug with includes and /useBaseNameForFileName

If /useBasenameForFilename is specified, tokens just contain file names, which
is not enough to locate included files.

Solution based on Rustan's advice.
---
 Source/Dafny/Dafny.atg  | 16 ++++++++--------
 Source/Dafny/Parser.cs  | 16 ++++++++--------
 Source/Dafny/Scanner.cs |  9 +++++++--
 3 files changed, 23 insertions(+), 18 deletions(-)

(limited to 'Source/Dafny/Scanner.cs')

diff --git a/Source/Dafny/Dafny.atg b/Source/Dafny/Dafny.atg
index c4f038d4..8a3bdb0e 100644
--- a/Source/Dafny/Dafny.atg
+++ b/Source/Dafny/Dafny.atg
@@ -41,11 +41,11 @@ public static int Parse (string/*!*/ filename, ModuleDecl module, BuiltIns built
   string s;
   if (filename == "stdin.dfy") {
     s = Microsoft.Boogie.ParserHelper.Fill(System.Console.In, new List<string>());
-    return Parse(s, filename, module, builtIns, errors, verifyThisFile);
+    return Parse(s, filename, filename, module, builtIns, errors, verifyThisFile);
   } else {
     using (System.IO.StreamReader reader = new System.IO.StreamReader(filename)) {
       s = Microsoft.Boogie.ParserHelper.Fill(reader, new List<string>());
-      return Parse(s, DafnyOptions.Clo.UseBaseNameForFileName ? Path.GetFileName(filename) : filename, module, builtIns, errors, verifyThisFile);
+      return Parse(s, filename, DafnyOptions.Clo.UseBaseNameForFileName ? Path.GetFileName(filename) : filename, module, builtIns, errors, verifyThisFile);
     }
   }
 }
@@ -55,12 +55,12 @@ public static int Parse (string/*!*/ filename, ModuleDecl module, BuiltIns built
 /// Returns the number of parsing errors encountered.
 /// Note: first initialize the Scanner.
 ///</summary>
-public static int Parse (string/*!*/ s, string/*!*/ filename, ModuleDecl module, BuiltIns builtIns, bool verifyThisFile=true) {
+public static int Parse (string/*!*/ s, string/*!*/ fullFilename, string/*!*/ filename, ModuleDecl module, BuiltIns builtIns, bool verifyThisFile=true) {
   Contract.Requires(s != null);
   Contract.Requires(filename != null);
   Contract.Requires(module != null);
   Errors errors = new Errors();
-  return Parse(s, filename, module, builtIns, errors, verifyThisFile);
+  return Parse(s, fullFilename, filename, module, builtIns, errors, verifyThisFile);
 }
 ///<summary>
 /// Parses top-level things (modules, classes, datatypes, class members)
@@ -68,15 +68,15 @@ public static int Parse (string/*!*/ s, string/*!*/ filename, ModuleDecl module,
 /// Returns the number of parsing errors encountered.
 /// Note: first initialize the Scanner with the given Errors sink.
 ///</summary>
-public static int Parse (string/*!*/ s, string/*!*/ filename, ModuleDecl module, BuiltIns builtIns,
-                         Errors/*!*/ errors, bool verifyThisFile=true) {
+public static int Parse (string/*!*/ s, string/*!*/ fullFilename, string/*!*/ filename, ModuleDecl module,
+                         BuiltIns builtIns, Errors/*!*/ errors, bool verifyThisFile=true) {
   Contract.Requires(s != null);
   Contract.Requires(filename != null);
   Contract.Requires(module != null);
   Contract.Requires(errors != null);
   byte[]/*!*/ buffer = cce.NonNull( UTF8Encoding.Default.GetBytes(s));
   MemoryStream ms = new MemoryStream(buffer,false);
-  Scanner scanner = new Scanner(ms, errors, filename);
+  Scanner scanner = new Scanner(ms, errors, fullFilename, filename);
   Parser parser = new Parser(scanner, errors, module, builtIns, verifyThisFile);
   parser.Parse();
   return parser.errors.count;
@@ -506,7 +506,7 @@ Dafny
      Contract.Assert(defaultModule != null);
   .)
   { "include" stringToken               (. {
-                                             string parsedFile = t.filename;
+                                             string parsedFile = scanner.FullFilename;
                                              bool isVerbatimString;
                                              string includedFile = Util.RemoveParsedStringQuotes(t.val, out isVerbatimString);
                                              includedFile = Util.RemoveEscaping(includedFile, isVerbatimString);
diff --git a/Source/Dafny/Parser.cs b/Source/Dafny/Parser.cs
index d50a4dd6..dae1b95e 100644
--- a/Source/Dafny/Parser.cs
+++ b/Source/Dafny/Parser.cs
@@ -112,11 +112,11 @@ public static int Parse (string/*!*/ filename, ModuleDecl module, BuiltIns built
   string s;
   if (filename == "stdin.dfy") {
     s = Microsoft.Boogie.ParserHelper.Fill(System.Console.In, new List<string>());
-    return Parse(s, filename, module, builtIns, errors, verifyThisFile);
+    return Parse(s, filename, filename, module, builtIns, errors, verifyThisFile);
   } else {
     using (System.IO.StreamReader reader = new System.IO.StreamReader(filename)) {
       s = Microsoft.Boogie.ParserHelper.Fill(reader, new List<string>());
-      return Parse(s, DafnyOptions.Clo.UseBaseNameForFileName ? Path.GetFileName(filename) : filename, module, builtIns, errors, verifyThisFile);
+      return Parse(s, filename, DafnyOptions.Clo.UseBaseNameForFileName ? Path.GetFileName(filename) : filename, module, builtIns, errors, verifyThisFile);
     }
   }
 }
@@ -126,12 +126,12 @@ public static int Parse (string/*!*/ filename, ModuleDecl module, BuiltIns built
 /// Returns the number of parsing errors encountered.
 /// Note: first initialize the Scanner.
 ///</summary>
-public static int Parse (string/*!*/ s, string/*!*/ filename, ModuleDecl module, BuiltIns builtIns, bool verifyThisFile=true) {
+public static int Parse (string/*!*/ s, string/*!*/ fullFilename, string/*!*/ filename, ModuleDecl module, BuiltIns builtIns, bool verifyThisFile=true) {
   Contract.Requires(s != null);
   Contract.Requires(filename != null);
   Contract.Requires(module != null);
   Errors errors = new Errors();
-  return Parse(s, filename, module, builtIns, errors, verifyThisFile);
+  return Parse(s, fullFilename, filename, module, builtIns, errors, verifyThisFile);
 }
 ///<summary>
 /// Parses top-level things (modules, classes, datatypes, class members)
@@ -139,15 +139,15 @@ public static int Parse (string/*!*/ s, string/*!*/ filename, ModuleDecl module,
 /// Returns the number of parsing errors encountered.
 /// Note: first initialize the Scanner with the given Errors sink.
 ///</summary>
-public static int Parse (string/*!*/ s, string/*!*/ filename, ModuleDecl module, BuiltIns builtIns,
-                         Errors/*!*/ errors, bool verifyThisFile=true) {
+public static int Parse (string/*!*/ s, string/*!*/ fullFilename, string/*!*/ filename, ModuleDecl module,
+                         BuiltIns builtIns, Errors/*!*/ errors, bool verifyThisFile=true) {
   Contract.Requires(s != null);
   Contract.Requires(filename != null);
   Contract.Requires(module != null);
   Contract.Requires(errors != null);
   byte[]/*!*/ buffer = cce.NonNull( UTF8Encoding.Default.GetBytes(s));
   MemoryStream ms = new MemoryStream(buffer,false);
-  Scanner scanner = new Scanner(ms, errors, filename);
+  Scanner scanner = new Scanner(ms, errors, fullFilename, filename);
   Parser parser = new Parser(scanner, errors, module, builtIns, verifyThisFile);
   parser.Parse();
   return parser.errors.count;
@@ -536,7 +536,7 @@ bool IsType(ref IToken pt) {
 			Get();
 			Expect(20);
 			{
-			 string parsedFile = t.filename;
+			 string parsedFile = scanner.FullFilename;
 			 bool isVerbatimString;
 			 string includedFile = Util.RemoveParsedStringQuotes(t.val, out isVerbatimString);
 			 includedFile = Util.RemoveEscaping(includedFile, isVerbatimString);
diff --git a/Source/Dafny/Scanner.cs b/Source/Dafny/Scanner.cs
index 325a2f2c..a73f510d 100644
--- a/Source/Dafny/Scanner.cs
+++ b/Source/Dafny/Scanner.cs
@@ -224,6 +224,7 @@ public class Scanner {
 		Contract.Invariant(pt != null);
 		Contract.Invariant(tval != null);
 		Contract.Invariant(Filename != null);
+		Contract.Invariant(FullFilename != null);
 		Contract.Invariant(errorHandler != null);
 	}
 
@@ -258,6 +259,8 @@ public class Scanner {
 	private string/*!*/ Filename;
 	private Errors/*!*/ errorHandler;
 
+	internal string/*!*/ FullFilename { get; private set; }
+
 	static Scanner() {
 		start = new Hashtable(128);
 		for (int i = 63; i <= 63; ++i) start[i] = 1;
@@ -310,7 +313,7 @@ public class Scanner {
 	}
 
 //	[NotDelayed]
-	public Scanner (string/*!*/ fileName, Errors/*!*/ errorHandler, bool useBaseName = false) : base() {
+	public Scanner (string/*!*/ fullFilename, string/*!*/ fileName, Errors/*!*/ errorHandler, bool useBaseName = false) : base() {
 	  Contract.Requires(fileName != null);
 	  Contract.Requires(errorHandler != null);
 		this.errorHandler = errorHandler;
@@ -319,6 +322,7 @@ public class Scanner {
 		try {
 			Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
 			this._buffer = new Buffer(stream, false);
+			this.FullFilename = fullFilename;
 			Filename = useBaseName? GetBaseName(fileName): fileName;
 			Init();
 		} catch (IOException) {
@@ -327,7 +331,7 @@ public class Scanner {
 	}
 
 //	[NotDelayed]
-	public Scanner (Stream/*!*/ s, Errors/*!*/ errorHandler, string/*!*/ fileName, bool useBaseName = false) : base() {
+	public Scanner (Stream/*!*/ s, Errors/*!*/ errorHandler, string/*!*/ fullFilename, string/*!*/ fileName, bool useBaseName = false) : base() {
 	  Contract.Requires(s != null);
 	  Contract.Requires(errorHandler != null);
 	  Contract.Requires(fileName != null);
@@ -335,6 +339,7 @@ public class Scanner {
 		t = new Token(); // dummy because t is a non-null field
 		this._buffer = new Buffer(s, true);
 		this.errorHandler = errorHandler;
+		this.FullFilename = fullFilename;
 		this.Filename = useBaseName? GetBaseName(fileName) : fileName;
 		Init();
 	}
-- 
cgit v1.2.3


From 8a0df70ffb8d57d1bd210ce2e1c9522ba0967365 Mon Sep 17 00:00:00 2001
From: Clément Pit--Claudel <clement.pitclaudel@live.com>
Date: Tue, 18 Aug 2015 18:58:40 -0700
Subject: Refactor the error reporting code

The new error reporting system has a simpler interface, isn't tied to the
resolver, and contains error source information.
---
 Source/Dafny/Cloner.cs                    |   33 +-
 Source/Dafny/Dafny.atg                    |    6 +-
 Source/Dafny/DafnyAst.cs                  |   20 +-
 Source/Dafny/DafnyMain.cs                 |   12 +-
 Source/Dafny/DafnyPipeline.csproj         |    7 +-
 Source/Dafny/Parser.cs                    |   34 +-
 Source/Dafny/RefinementTransformer.cs     |  293 ++++----
 Source/Dafny/Reporting.cs                 |  164 +++++
 Source/Dafny/Resolver.cs                  | 1146 +++++++++++++----------------
 Source/Dafny/Rewriter.cs                  |  119 ++-
 Source/Dafny/Scanner.cs                   |   18 +-
 Source/Dafny/Translator.cs                |   15 +-
 Source/Dafny/TriggerGenerator.cs          |    4 +-
 Source/Dafny/Util.cs                      |   23 -
 Source/DafnyDriver/DafnyDriver.cs         |   35 +-
 Source/DafnyExtension/DafnyDriver.cs      |   77 +-
 Source/DafnyExtension/IdentifierTagger.cs |    4 +-
 Source/DafnyExtension/ResolverTagger.cs   |    4 +-
 Source/DafnyServer/DafnyHelper.cs         |   17 +-
 19 files changed, 1006 insertions(+), 1025 deletions(-)
 create mode 100644 Source/Dafny/Reporting.cs

(limited to 'Source/Dafny/Scanner.cs')

diff --git a/Source/Dafny/Cloner.cs b/Source/Dafny/Cloner.cs
index f959b537..323abc70 100644
--- a/Source/Dafny/Cloner.cs
+++ b/Source/Dafny/Cloner.cs
@@ -365,6 +365,7 @@ namespace Microsoft.Dafny
         return new NamedExpr(Tok(e.tok), e.Name, CloneExpr(e.Body));
       } else if (expr is ComprehensionExpr) {
         var e = (ComprehensionExpr)expr;
+
         var tk = Tok(e.tok);
         var bvs = e.BoundVars.ConvertAll(CloneBoundVar);
         var range = CloneExpr(e.Range);
@@ -703,22 +704,16 @@ namespace Microsoft.Dafny
   abstract class FixpointCloner : Cloner
   {
     protected readonly Expression k;
-    readonly Resolver resolver;
+    protected readonly ErrorReporter reporter;
     readonly string suffix;
-    protected FixpointCloner(Expression k, Resolver resolver)
+    protected FixpointCloner(Expression k, ErrorReporter reporter)
     {
       Contract.Requires(k != null);
-      Contract.Requires(resolver != null);
+      Contract.Requires(reporter != null);
       this.k = k;
-      this.resolver = resolver;
+      this.reporter = reporter;
       this.suffix = string.Format("#[{0}]", Printer.ExprToString(k));
     }
-    protected void ReportAdditionalInformation(IToken tok, string s)
-    {
-      Contract.Requires(tok != null);
-      Contract.Requires(s != null);
-      resolver.ReportAdditionalInformation(tok, s + suffix, s.Length);
-    }
   }
 
   /// <summary>
@@ -733,12 +728,12 @@ namespace Microsoft.Dafny
   {
     readonly bool isCoContext;
     readonly ISet<Expression> friendlyCalls;
-    public FixpointLemmaSpecificationSubstituter(ISet<Expression> friendlyCalls, Expression k, Resolver resolver, bool isCoContext)
-      : base(k, resolver)
+    public FixpointLemmaSpecificationSubstituter(ISet<Expression> friendlyCalls, Expression k, ErrorReporter reporter, bool isCoContext)
+      : base(k, reporter)
     {
       Contract.Requires(friendlyCalls != null);
       Contract.Requires(k != null);
-      Contract.Requires(resolver != null);
+      Contract.Requires(reporter != null);
       this.isCoContext = isCoContext;
       this.friendlyCalls = friendlyCalls;
     }
@@ -758,7 +753,7 @@ namespace Microsoft.Dafny
             args.Add(CloneExpr(arg));
           }
           var fexp = new FunctionCallExpr(Tok(e.tok), e.Name + "#", receiver, e.OpenParen, args);
-          ReportAdditionalInformation(e.tok, e.Name);
+          reporter.Info(MessageSource.Cloner, e.tok, e.Name);
           return fexp;
         }
       } else if (expr is BinaryExpr && isCoContext) {
@@ -769,7 +764,7 @@ namespace Microsoft.Dafny
           var B = CloneExpr(e.E1);
           var teq = new TernaryExpr(Tok(e.tok), op, k, A, B);
           var opString = op == TernaryExpr.Opcode.PrefixEqOp ? "==" : "!=";
-          ReportAdditionalInformation(e.tok, opString);
+          reporter.Info(MessageSource.Cloner, e.tok, opString);
           return teq;
         }
       }
@@ -804,12 +799,12 @@ namespace Microsoft.Dafny
   class FixpointLemmaBodyCloner : FixpointCloner
   {
     readonly FixpointLemma context;
-    public FixpointLemmaBodyCloner(FixpointLemma context, Expression k, Resolver resolver)
-      : base(k, resolver)
+    public FixpointLemmaBodyCloner(FixpointLemma context, Expression k, ErrorReporter reporter)
+      : base(k, reporter)
     {
       Contract.Requires(context != null);
       Contract.Requires(k != null);
-      Contract.Requires(resolver != null);
+      Contract.Requires(reporter != null);
       this.context = context;
     }
     public override AssignmentRhs CloneRHS(AssignmentRhs rhs) {
@@ -834,7 +829,7 @@ namespace Microsoft.Dafny
           apply.Args.ForEach(arg => args.Add(CloneExpr(arg)));
           var applyClone = new ApplySuffix(Tok(apply.tok), lhsClone, args);
           var c = new ExprRhs(applyClone);
-          ReportAdditionalInformation(apply.tok, mse.Member.Name);
+          reporter.Info(MessageSource.Cloner, apply.tok, mse.Member.Name);
           return c;
         }
       }
diff --git a/Source/Dafny/Dafny.atg b/Source/Dafny/Dafny.atg
index 8a3bdb0e..07f8e1c4 100644
--- a/Source/Dafny/Dafny.atg
+++ b/Source/Dafny/Dafny.atg
@@ -55,11 +55,11 @@ public static int Parse (string/*!*/ filename, ModuleDecl module, BuiltIns built
 /// Returns the number of parsing errors encountered.
 /// Note: first initialize the Scanner.
 ///</summary>
-public static int Parse (string/*!*/ s, string/*!*/ fullFilename, string/*!*/ filename, ModuleDecl module, BuiltIns builtIns, bool verifyThisFile=true) {
+public static int Parse (string/*!*/ s, string/*!*/ fullFilename, string/*!*/ filename, ModuleDecl module, BuiltIns builtIns, ErrorReporter reporter, bool verifyThisFile=true) {
   Contract.Requires(s != null);
   Contract.Requires(filename != null);
   Contract.Requires(module != null);
-  Errors errors = new Errors();
+  Errors errors = new Errors(reporter);
   return Parse(s, fullFilename, filename, module, builtIns, errors, verifyThisFile);
 }
 ///<summary>
@@ -79,7 +79,7 @@ public static int Parse (string/*!*/ s, string/*!*/ fullFilename, string/*!*/ fi
   Scanner scanner = new Scanner(ms, errors, fullFilename, filename);
   Parser parser = new Parser(scanner, errors, module, builtIns, verifyThisFile);
   parser.Parse();
-  return parser.errors.count;
+  return parser.errors.ErrorCount;
 }
 public Parser(Scanner/*!*/ scanner, Errors/*!*/ errors, ModuleDecl module, BuiltIns builtIns, bool verifyThisFile=true)
   : this(scanner, errors)  // the real work
diff --git a/Source/Dafny/DafnyAst.cs b/Source/Dafny/DafnyAst.cs
index 66b91ac2..efe94c66 100644
--- a/Source/Dafny/DafnyAst.cs
+++ b/Source/Dafny/DafnyAst.cs
@@ -27,20 +27,22 @@ namespace Microsoft.Dafny {
     public List<ModuleDefinition> CompileModules; // filled in during resolution.
                                                   // Contains the definitions to be used for compilation.
 
-    List<AdditionalInformation> _additionalInformation = new List<AdditionalInformation>();
-    public List<AdditionalInformation> AdditionalInformation { get { return _additionalInformation; } }
     public readonly ModuleDecl DefaultModule;
     public readonly ModuleDefinition DefaultModuleDef;
     public readonly BuiltIns BuiltIns;
     public readonly List<TranslationTask> TranslationTasks;
-    public Program(string name, [Captured] ModuleDecl module, [Captured] BuiltIns builtIns) {
+    public readonly ErrorReporter reporter;
+
+    public Program(string name, [Captured] ModuleDecl module, [Captured] BuiltIns builtIns, ErrorReporter reporter) {
       Contract.Requires(name != null);
       Contract.Requires(module != null);
       Contract.Requires(module is LiteralModuleDecl);
+      Contract.Requires(reporter != null);
       FullName = name;
       DefaultModule = module;
       DefaultModuleDef = (DefaultModuleDecl)((LiteralModuleDecl)module).ModuleDef;
       BuiltIns = builtIns;
+      this.reporter = reporter;
       Modules = new List<ModuleDefinition>();
       CompileModules = new List<ModuleDefinition>();
       TranslationTasks = new List<TranslationTask>();
@@ -330,13 +332,13 @@ namespace Microsoft.Dafny {
     /// - if "allowed" contains Int and Args contains one BigInteger literal, return true and set value to the BigInteger literal.  Otherwise,
     /// - if "allowed" contains String and Args contains one string literal, return true and set value to the string literal.  Otherwise,
     /// - if "allowed" contains Expression and Args contains one element, return true and set value to the one element (of type Expression).  Otherwise,
-    /// - return false, leave value unmodified, and call errorReporter with an error string.
+    /// - return false, leave value unmodified, and call reporter with an error string.
     /// </summary>
     public enum MatchingValueOption { Empty, Bool, Int, String, Expression }
-    public static bool ContainsMatchingValue(Attributes attrs, string nm, ref object value, IEnumerable<MatchingValueOption> allowed, Action<string> errorReporter) {
+    public static bool ContainsMatchingValue(Attributes attrs, string nm, ref object value, IEnumerable<MatchingValueOption> allowed, Action<string> reporter) {
       Contract.Requires(nm != null);
       Contract.Requires(allowed != null);
-      Contract.Requires(errorReporter != null);
+      Contract.Requires(reporter != null);
       List<Expression> args = FindExpressions(attrs, nm);
       if (args == null) {
         return false;
@@ -344,7 +346,7 @@ namespace Microsoft.Dafny {
         if (allowed.Contains(MatchingValueOption.Empty)) {
           return true;
         } else {
-          errorReporter("Attribute " + nm + " requires one argument");
+          reporter("Attribute " + nm + " requires one argument");
           return false;
         }
       } else if (args.Count == 1) {
@@ -364,11 +366,11 @@ namespace Microsoft.Dafny {
           value = arg;
           return true;
         } else {
-          errorReporter("Attribute " + nm + " expects an argument in one of the following categories: " + String.Join(", ", allowed));
+          reporter("Attribute " + nm + " expects an argument in one of the following categories: " + String.Join(", ", allowed));
           return false;
         }
       } else {
-        errorReporter("Attribute " + nm + " cannot have more than one argument");
+        reporter("Attribute " + nm + " cannot have more than one argument");
         return false;
       }
     }
diff --git a/Source/Dafny/DafnyMain.cs b/Source/Dafny/DafnyMain.cs
index 012ca4df..251d8656 100644
--- a/Source/Dafny/DafnyMain.cs
+++ b/Source/Dafny/DafnyMain.cs
@@ -29,7 +29,7 @@ namespace Microsoft.Dafny {
     /// <summary>
     /// Returns null on success, or an error string otherwise.
     /// </summary>
-    public static string ParseCheck(IList<string/*!*/>/*!*/ fileNames, string/*!*/ programName, out Program program)
+    public static string ParseCheck(IList<string/*!*/>/*!*/ fileNames, string/*!*/ programName, ErrorReporter reporter, out Program program)
       //modifies Bpl.CommandLineOptions.Clo.XmlSink.*;
     {
       Contract.Requires(programName != null);
@@ -47,20 +47,20 @@ namespace Microsoft.Dafny {
           Console.WriteLine("Parsing " + dafnyFileName);
         }
 
-        string err = ParseFile(dafnyFileName, Bpl.Token.NoToken, module, builtIns, new Errors());
+        string err = ParseFile(dafnyFileName, Bpl.Token.NoToken, module, builtIns, new Errors(reporter));
         if (err != null) {
           return err;
         }        
       }
 
       if (!DafnyOptions.O.DisallowIncludes) {
-        string errString = ParseIncludes(module, builtIns, fileNames, new Errors());
+        string errString = ParseIncludes(module, builtIns, fileNames, new Errors(reporter));
         if (errString != null) {
           return errString;
         }
       }
 
-      program = new Program(programName, module, builtIns);
+      program = new Program(programName, module, builtIns, reporter);
 
       MaybePrintProgram(program, DafnyOptions.O.DafnyPrintFile);
 
@@ -70,8 +70,8 @@ namespace Microsoft.Dafny {
       r.ResolveProgram(program);
       MaybePrintProgram(program, DafnyOptions.O.DafnyPrintResolvedFile);
 
-      if (r.ErrorCount != 0) {
-        return string.Format("{0} resolution/type errors detected in {1}", r.ErrorCount, program.Name);
+      if (reporter.Count(ErrorLevel.Error) != 0) {
+        return string.Format("{0} resolution/type errors detected in {1}", reporter.Count(ErrorLevel.Error), program.Name);
       }
 
       return null;  // success
diff --git a/Source/Dafny/DafnyPipeline.csproj b/Source/Dafny/DafnyPipeline.csproj
index a1452b8a..626bb26a 100644
--- a/Source/Dafny/DafnyPipeline.csproj
+++ b/Source/Dafny/DafnyPipeline.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?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>
@@ -8,7 +8,7 @@
     <ProjectGuid>{FE44674A-1633-4917-99F4-57635E6FA740}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>DafnyPipeline</RootNamespace>
+    <RootNamespace>Microsoft.Dafny</RootNamespace>
     <AssemblyName>DafnyPipeline</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
@@ -143,6 +143,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Cloner.cs" />
+    <Compile Include="Reporting.cs" />
     <Compile Include="TriggerGenerator.cs" />
     <Compile Include="Util.cs" />
     <Compile Include="Compiler.cs" />
@@ -193,4 +194,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
\ No newline at end of file
+</Project>
diff --git a/Source/Dafny/Parser.cs b/Source/Dafny/Parser.cs
index fd6fb026..2507cacc 100644
--- a/Source/Dafny/Parser.cs
+++ b/Source/Dafny/Parser.cs
@@ -126,11 +126,11 @@ public static int Parse (string/*!*/ filename, ModuleDecl module, BuiltIns built
 /// Returns the number of parsing errors encountered.
 /// Note: first initialize the Scanner.
 ///</summary>
-public static int Parse (string/*!*/ s, string/*!*/ fullFilename, string/*!*/ filename, ModuleDecl module, BuiltIns builtIns, bool verifyThisFile=true) {
+public static int Parse (string/*!*/ s, string/*!*/ fullFilename, string/*!*/ filename, ModuleDecl module, BuiltIns builtIns, ErrorReporter reporter, bool verifyThisFile=true) {
   Contract.Requires(s != null);
   Contract.Requires(filename != null);
   Contract.Requires(module != null);
-  Errors errors = new Errors();
+  Errors errors = new Errors(reporter);
   return Parse(s, fullFilename, filename, module, builtIns, errors, verifyThisFile);
 }
 ///<summary>
@@ -150,7 +150,7 @@ public static int Parse (string/*!*/ s, string/*!*/ fullFilename, string/*!*/ fi
   Scanner scanner = new Scanner(ms, errors, fullFilename, filename);
   Parser parser = new Parser(scanner, errors, module, builtIns, verifyThisFile);
   parser.Parse();
-  return parser.errors.count;
+  return parser.errors.ErrorCount;
 }
 public Parser(Scanner/*!*/ scanner, Errors/*!*/ errors, ModuleDecl module, BuiltIns builtIns, bool verifyThisFile=true)
   : this(scanner, errors)  // the real work
@@ -4426,16 +4426,22 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 
 public class Errors {
-	public int count = 0;                                    // number of errors detected
+    readonly ErrorReporter reporter;
+	public int ErrorCount;
+
+    public Errors(ErrorReporter reporter) {
+        Contract.Requires(reporter != null);
+        this.reporter = reporter;
+	}
 
 	public void SynErr(string filename, int line, int col, int n) {
 		SynErr(filename, line, col, GetSyntaxErrorString(n));
 	}
 
-	public virtual void SynErr(string filename, int line, int col, string msg) {
+	public void SynErr(string filename, int line, int col, string msg) {
 		Contract.Requires(msg != null);
-		Dafny.Util.ReportIssue("Error", filename, line, col, msg);
-		count++;
+		ErrorCount++;
+        reporter.Error(MessageSource.Parser, filename, line, col, msg);
 	}
 
 	string GetSyntaxErrorString(int n) {
@@ -4692,20 +4698,20 @@ public class Errors {
 	public void SemErr(IToken tok, string msg) {  // semantic errors
 		Contract.Requires(tok != null);
 		Contract.Requires(msg != null);
-		Dafny.Util.ReportIssue("Error", tok, msg);
-		count++;
+		ErrorCount++;
+        reporter.Error(MessageSource.Parser, tok, msg);
 	}
 
-	public virtual void SemErr(string filename, int line, int col, string msg) {
+	public void SemErr(string filename, int line, int col, string msg) {
 		Contract.Requires(msg != null);
-		Dafny.Util.ReportIssue("Error", filename, line, col, msg);
-		count++;
+		ErrorCount++;
+        reporter.Error(MessageSource.Parser, filename, line, col, msg);
 	}
 
-	public virtual void Warning(IToken tok, string msg) {  // warnings
+	public void Warning(IToken tok, string msg) {
 		Contract.Requires(tok != null);
 		Contract.Requires(msg != null);
-		Dafny.Util.ReportIssue("Warning", tok, msg);
+        reporter.Warning(MessageSource.Parser, tok, msg);
 	}
 } // Errors
 
diff --git a/Source/Dafny/RefinementTransformer.cs b/Source/Dafny/RefinementTransformer.cs
index f430933b..ba558ea6 100644
--- a/Source/Dafny/RefinementTransformer.cs
+++ b/Source/Dafny/RefinementTransformer.cs
@@ -52,16 +52,19 @@ namespace Microsoft.Dafny
 
   public class RefinementTransformer : IRewriter
   {
-    ResolutionErrorReporter reporter;
-    Action<AdditionalInformation> additionalInformationReporter;
     Cloner rawCloner; // This cloner just gives exactly the same thing back.
     RefinementCloner refinementCloner; // This cloner wraps things in a RefinementTransformer
+    
     Program program;
-    public RefinementTransformer(ResolutionErrorReporter reporter, Action<AdditionalInformation> additionalInformationReporter, Program p) {
-      Contract.Requires(reporter != null);
-      this.reporter = reporter;
-      this.additionalInformationReporter = additionalInformationReporter;
+
+    public RefinementTransformer(ErrorReporter reporter)
+      : base(reporter) {
       rawCloner = new Cloner();
+    }
+
+    public RefinementTransformer(Program p)
+      : this(p.reporter) {
+      Contract.Requires(p != null);
       program = p;
     }
 
@@ -71,17 +74,7 @@ namespace Microsoft.Dafny
     private Method currentMethod;
     public ModuleSignature RefinedSig;  // the intention is to use this field only after a successful PreResolve
 
-    void ReportAdditionalInformation(IToken token, string text, int length)
-    {
-      Contract.Requires(token != null);
-      Contract.Requires(text != null);
-      Contract.Requires(0 <= length);
-      if (additionalInformationReporter != null) {
-        additionalInformationReporter(new AdditionalInformation { Token = token, Text = text, Length = length });
-      }
-    }
-
-    public void PreResolve(ModuleDefinition m) {
+    internal override void PreResolve(ModuleDefinition m) {
       if (m.RefinementBaseRoot != null) {
         if (Resolver.ResolvePath(m.RefinementBaseRoot, m.RefinementBaseName, out RefinedSig, reporter)) {
           if (RefinedSig.ModuleDef != null) {
@@ -90,17 +83,17 @@ namespace Microsoft.Dafny
               if (null == m.RefinementBase.ExclusiveRefinement) {
                 m.RefinementBase.ExclusiveRefinement = m;
               } else {
-                this.reporter.Error(
+                reporter.Error(MessageSource.RefinementTransformer,
                     m.tok,
                     "no more than one exclusive refinement may exist for a given module.");
               }
             }
             PreResolveWorker(m);
           } else {
-            reporter.Error(m.RefinementBaseName[0], "module ({0}) named as refinement base is not a literal module or simple reference to a literal module", Util.Comma(".", m.RefinementBaseName, x => x.val));
+            reporter.Error(MessageSource.RefinementTransformer, m.RefinementBaseName[0], "module ({0}) named as refinement base is not a literal module or simple reference to a literal module", Util.Comma(".", m.RefinementBaseName, x => x.val));
           }
         } else {
-          reporter.Error(m.RefinementBaseName[0], "module ({0}) named as refinement base does not exist", Util.Comma(".", m.RefinementBaseName, x => x.val));
+          reporter.Error(MessageSource.RefinementTransformer, m.RefinementBaseName[0], "module ({0}) named as refinement base does not exist", Util.Comma(".", m.RefinementBaseName, x => x.val));
         }
       }
     }
@@ -135,9 +128,9 @@ namespace Microsoft.Dafny
           var nw = m.TopLevelDecls[index];
           if (d is ModuleDecl) {
             if (!(nw is ModuleDecl)) {
-              reporter.Error(nw, "a module ({0}) must refine another module", nw.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nw, "a module ({0}) must refine another module", nw.Name);
             } else if (!(d is ModuleFacadeDecl)) {
-              reporter.Error(nw, "a module ({0}) can only refine a module facade", nw.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nw, "a module ({0}) can only refine a module facade", nw.Name);
             } else {
               ModuleSignature original = ((ModuleFacadeDecl)d).OriginalSignature;
               ModuleSignature derived = null;
@@ -146,72 +139,72 @@ namespace Microsoft.Dafny
               } else if (nw is ModuleFacadeDecl) {
                 derived = ((ModuleFacadeDecl)nw).Signature;
               } else {
-                reporter.Error(nw, "a module ({0}) can only be refined by an alias module or a module facade", d.Name);
+                reporter.Error(MessageSource.RefinementTransformer, nw, "a module ({0}) can only be refined by an alias module or a module facade", d.Name);
               }
               if (derived != null) {
                 // check that the new module refines the previous declaration
                 if (!CheckIsRefinement(derived, original))
-                  reporter.Error(nw.tok, "a module ({0}) can only be replaced by a refinement of the original module", d.Name);
+                  reporter.Error(MessageSource.RefinementTransformer, nw.tok, "a module ({0}) can only be replaced by a refinement of the original module", d.Name);
               }
             }
           } else if (d is OpaqueTypeDecl) {
             if (nw is ModuleDecl) {
-              reporter.Error(nw, "a module ({0}) must refine another module", nw.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nw, "a module ({0}) must refine another module", nw.Name);
             } else {
               bool dDemandsEqualitySupport = ((OpaqueTypeDecl)d).MustSupportEquality;
               if (nw is OpaqueTypeDecl) {
                 if (dDemandsEqualitySupport != ((OpaqueTypeDecl)nw).MustSupportEquality) {
-                  reporter.Error(nw, "type declaration '{0}' is not allowed to change the requirement of supporting equality", nw.Name);
+                  reporter.Error(MessageSource.RefinementTransformer, nw, "type declaration '{0}' is not allowed to change the requirement of supporting equality", nw.Name);
                 }
                 if (nw.TypeArgs.Count != d.TypeArgs.Count) {
-                  reporter.Error(nw, "type '{0}' is not allowed to change its number of type parameters (got {1}, expected {2})", nw.Name, nw.TypeArgs.Count, d.TypeArgs.Count);
+                  reporter.Error(MessageSource.RefinementTransformer, nw, "type '{0}' is not allowed to change its number of type parameters (got {1}, expected {2})", nw.Name, nw.TypeArgs.Count, d.TypeArgs.Count);
                 }
               } else if (dDemandsEqualitySupport) {
                 if (nw is ClassDecl) {
                   // fine, as long as "nw" takes the right number of type parameters
                   if (nw.TypeArgs.Count != d.TypeArgs.Count) {
-                    reporter.Error(nw, "opaque type '{0}' is not allowed to be replaced by a class that takes a different number of type parameters (got {1}, expected {2})", nw.Name, nw.TypeArgs.Count, d.TypeArgs.Count);
+                    reporter.Error(MessageSource.RefinementTransformer, nw, "opaque type '{0}' is not allowed to be replaced by a class that takes a different number of type parameters (got {1}, expected {2})", nw.Name, nw.TypeArgs.Count, d.TypeArgs.Count);
                   }
                 } else if (nw is NewtypeDecl) {
                   // fine, as long as "nw" does not take any type parameters
                   if (nw.TypeArgs.Count != 0) {
-                    reporter.Error(nw, "opaque type '{0}', which has {1} type argument{2}, is not allowed to be replaced by a newtype, which takes none", nw.Name, d.TypeArgs.Count, d.TypeArgs.Count == 1 ? "" : "s");
+                    reporter.Error(MessageSource.RefinementTransformer, nw, "opaque type '{0}', which has {1} type argument{2}, is not allowed to be replaced by a newtype, which takes none", nw.Name, d.TypeArgs.Count, d.TypeArgs.Count == 1 ? "" : "s");
                   }
                 } else if (nw is CoDatatypeDecl) {
-                  reporter.Error(nw, "a type declaration that requires equality support cannot be replaced by a codatatype");
+                  reporter.Error(MessageSource.RefinementTransformer, nw, "a type declaration that requires equality support cannot be replaced by a codatatype");
                 } else {
                   Contract.Assert(nw is IndDatatypeDecl || nw is TypeSynonymDecl);
                   if (nw.TypeArgs.Count != d.TypeArgs.Count) {
-                    reporter.Error(nw, "opaque type '{0}' is not allowed to be replaced by a type that takes a different number of type parameters (got {1}, expected {2})", nw.Name, nw.TypeArgs.Count, d.TypeArgs.Count);
+                    reporter.Error(MessageSource.RefinementTransformer, nw, "opaque type '{0}' is not allowed to be replaced by a type that takes a different number of type parameters (got {1}, expected {2})", nw.Name, nw.TypeArgs.Count, d.TypeArgs.Count);
                   } else {
                     // Here, we need to figure out if the new type supports equality.  But we won't know about that until resolution has
                     // taken place, so we defer it until the PostResolve phase.
                     var udt = UserDefinedType.FromTopLevelDecl(nw.tok, nw);
                     postTasks.Enqueue(() => {
                       if (!udt.SupportsEquality) {
-                        reporter.Error(udt.tok, "type '{0}' is used to refine an opaque type with equality support, but '{0}' does not support equality", udt.Name);
+                        reporter.Error(MessageSource.RefinementTransformer, udt.tok, "type '{0}' is used to refine an opaque type with equality support, but '{0}' does not support equality", udt.Name);
                       }
                     });
                   }
                 }
               } else if (d.TypeArgs.Count != nw.TypeArgs.Count) {
-                reporter.Error(nw, "opaque type '{0}' is not allowed to be replaced by a type that takes a different number of type parameters (got {1}, expected {2})", nw.Name, nw.TypeArgs.Count, d.TypeArgs.Count);
+                reporter.Error(MessageSource.RefinementTransformer, nw, "opaque type '{0}' is not allowed to be replaced by a type that takes a different number of type parameters (got {1}, expected {2})", nw.Name, nw.TypeArgs.Count, d.TypeArgs.Count);
               }
             }
           } else if (nw is OpaqueTypeDecl) {
-            reporter.Error(nw, "an opaque type declaration ({0}) in a refining module cannot replace a more specific type declaration in the refinement base", nw.Name);
+            reporter.Error(MessageSource.RefinementTransformer, nw, "an opaque type declaration ({0}) in a refining module cannot replace a more specific type declaration in the refinement base", nw.Name);
           } else if (nw is DatatypeDecl) {
-            reporter.Error(nw, "a datatype declaration ({0}) in a refinement module can only replace an opaque type declaration", nw.Name);
+            reporter.Error(MessageSource.RefinementTransformer, nw, "a datatype declaration ({0}) in a refinement module can only replace an opaque type declaration", nw.Name);
           } else if (nw is IteratorDecl) {
             if (d is IteratorDecl) {
               m.TopLevelDecls[index] = MergeIterator((IteratorDecl)nw, (IteratorDecl)d);
             } else {
-              reporter.Error(nw, "an iterator declaration ({0}) is a refining module cannot replace a different kind of declaration in the refinement base", nw.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nw, "an iterator declaration ({0}) is a refining module cannot replace a different kind of declaration in the refinement base", nw.Name);
             }
           } else {
             Contract.Assert(nw is ClassDecl);
             if (d is DatatypeDecl) {
-              reporter.Error(nw, "a class declaration ({0}) in a refining module cannot replace a different kind of declaration in the refinement base", nw.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nw, "a class declaration ({0}) in a refining module cannot replace a different kind of declaration in the refinement base", nw.Name);
             } else {
               m.TopLevelDecls[index] = MergeClass((ClassDecl)nw, (ClassDecl)d);
             }
@@ -238,42 +231,42 @@ namespace Microsoft.Dafny
       // Second, we need to determine whether the specifications will be compatible
       // (i.e. substitutable), by translating to Boogie.
 
-      var errorCount = reporter.ErrorCount;
+      var errorCount = reporter.Count(ErrorLevel.Error);
       foreach (var kv in original.TopLevels) {
         var d = kv.Value;
         TopLevelDecl nw;
         if (derived.TopLevels.TryGetValue(kv.Key, out nw)) {
           if (d is ModuleDecl) {
             if (!(nw is ModuleDecl)) {
-              reporter.Error(nw, "a module ({0}) must refine another module", nw.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nw, "a module ({0}) must refine another module", nw.Name);
             } else {
               CheckIsRefinement(((ModuleDecl)nw).Signature, ((ModuleDecl)d).Signature);
             }
           } else if (d is OpaqueTypeDecl) {
             if (nw is ModuleDecl) {
-              reporter.Error(nw, "a module ({0}) must refine another module", nw.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nw, "a module ({0}) must refine another module", nw.Name);
             } else {
               bool dDemandsEqualitySupport = ((OpaqueTypeDecl)d).MustSupportEquality;
               if (nw is OpaqueTypeDecl) {
                 if (dDemandsEqualitySupport != ((OpaqueTypeDecl)nw).MustSupportEquality) {
-                  reporter.Error(nw, "type declaration '{0}' is not allowed to change the requirement of supporting equality", nw.Name);
+                  reporter.Error(MessageSource.RefinementTransformer, nw, "type declaration '{0}' is not allowed to change the requirement of supporting equality", nw.Name);
                 }
               } else if (dDemandsEqualitySupport) {
                 if (nw is ClassDecl) {
                   // fine, as long as "nw" does not take any type parameters
                   if (nw.TypeArgs.Count != 0) {
-                    reporter.Error(nw, "opaque type '{0}' is not allowed to be replaced by a class that takes type parameters", nw.Name);
+                    reporter.Error(MessageSource.RefinementTransformer, nw, "opaque type '{0}' is not allowed to be replaced by a class that takes type parameters", nw.Name);
                   }
                 } else if (nw is CoDatatypeDecl) {
-                  reporter.Error(nw, "a type declaration that requires equality support cannot be replaced by a codatatype");
+                  reporter.Error(MessageSource.RefinementTransformer, nw, "a type declaration that requires equality support cannot be replaced by a codatatype");
                 } else {
                   Contract.Assert(nw is IndDatatypeDecl);
                   if (nw.TypeArgs.Count != 0) {
-                    reporter.Error(nw, "opaque type '{0}' is not allowed to be replaced by a datatype that takes type parameters", nw.Name);
+                    reporter.Error(MessageSource.RefinementTransformer, nw, "opaque type '{0}' is not allowed to be replaced by a datatype that takes type parameters", nw.Name);
                   } else {
                     var udt = new UserDefinedType(nw.tok, nw.Name, nw, new List<Type>());
                     if (!(udt.SupportsEquality)) {
-                      reporter.Error(nw.tok, "datatype '{0}' is used to refine an opaque type with equality support, but '{0}' does not support equality", nw.Name);
+                      reporter.Error(MessageSource.RefinementTransformer, nw.tok, "datatype '{0}' is used to refine an opaque type with equality support, but '{0}' does not support equality", nw.Name);
                     }
                   }
                 }
@@ -282,18 +275,18 @@ namespace Microsoft.Dafny
           } else if (d is DatatypeDecl) {
             if (nw is DatatypeDecl) {
               if (d is IndDatatypeDecl && !(nw is IndDatatypeDecl)) {
-                reporter.Error(nw, "a datatype ({0}) must be replaced by a datatype, not a codatatype", d.Name);
+                reporter.Error(MessageSource.RefinementTransformer, nw, "a datatype ({0}) must be replaced by a datatype, not a codatatype", d.Name);
               } else if (d is CoDatatypeDecl && !(nw is CoDatatypeDecl)) {
-                reporter.Error(nw, "a codatatype ({0}) must be replaced by a codatatype, not a datatype", d.Name);
+                reporter.Error(MessageSource.RefinementTransformer, nw, "a codatatype ({0}) must be replaced by a codatatype, not a datatype", d.Name);
               }
               // check constructors, formals, etc.
               CheckDatatypesAreRefinements((DatatypeDecl)d, (DatatypeDecl)nw);
             } else {
-              reporter.Error(nw, "a {0} ({1}) must be refined by a {0}", d is IndDatatypeDecl ? "datatype" : "codatatype", d.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nw, "a {0} ({1}) must be refined by a {0}", d is IndDatatypeDecl ? "datatype" : "codatatype", d.Name);
             }
           } else if (d is ClassDecl) {
             if (!(nw is ClassDecl)) {
-              reporter.Error(nw, "a class declaration ({0}) must be refined by another class declaration", nw.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nw, "a class declaration ({0}) must be refined by another class declaration", nw.Name);
             } else {
               CheckClassesAreRefinements((ClassDecl)nw, (ClassDecl)d);
             }
@@ -301,15 +294,15 @@ namespace Microsoft.Dafny
             Contract.Assert(false); throw new cce.UnreachableException(); // unexpected toplevel
           }
         } else {
-          reporter.Error(d, "declaration {0} must have a matching declaration in the refining module", d.Name);
+          reporter.Error(MessageSource.RefinementTransformer, d, "declaration {0} must have a matching declaration in the refining module", d.Name);
         }
       }
-      return errorCount == reporter.ErrorCount;
+      return errorCount == reporter.Count(ErrorLevel.Error);
     }
 
     private void CheckClassesAreRefinements(ClassDecl nw, ClassDecl d) {
       if (nw.TypeArgs.Count != d.TypeArgs.Count) {
-        reporter.Error(nw, "a refining class ({0}) must have the same number of type parameters", nw.Name);
+        reporter.Error(MessageSource.RefinementTransformer, nw, "a refining class ({0}) must have the same number of type parameters", nw.Name);
       } else {
         var map = new Dictionary<string, MemberDecl>();
         foreach (var mem in nw.Members) {
@@ -319,33 +312,33 @@ namespace Microsoft.Dafny
           MemberDecl newMem;
           if (map.TryGetValue(m.Name, out newMem)) {
             if (m.HasStaticKeyword != newMem.HasStaticKeyword) {
-              reporter.Error(newMem, "member {0} must {1}", m.Name, m.HasStaticKeyword ? "be static" : "not be static");
+              reporter.Error(MessageSource.RefinementTransformer, newMem, "member {0} must {1}", m.Name, m.HasStaticKeyword ? "be static" : "not be static");
             }
             if (m is Field) {
               if (newMem is Field) {
                 var newField = (Field)newMem;
                 if (!ResolvedTypesAreTheSame(newField.Type, ((Field)m).Type))
-                  reporter.Error(newMem, "field must be refined by a field with the same type (got {0}, expected {1})", newField.Type, ((Field)m).Type);
+                  reporter.Error(MessageSource.RefinementTransformer, newMem, "field must be refined by a field with the same type (got {0}, expected {1})", newField.Type, ((Field)m).Type);
                 if (m.IsGhost || !newField.IsGhost)
-                  reporter.Error(newField, "a field re-declaration ({0}) must be to ghostify the field", newField.Name, nw.Name);
+                  reporter.Error(MessageSource.RefinementTransformer, newField, "a field re-declaration ({0}) must be to ghostify the field", newField.Name, nw.Name);
               } else {
-                reporter.Error(newMem, "a field declaration ({1}) must be replaced by a field in the refinement base (not {0})", newMem.Name, nw.Name);
+                reporter.Error(MessageSource.RefinementTransformer, newMem, "a field declaration ({1}) must be replaced by a field in the refinement base (not {0})", newMem.Name, nw.Name);
               }
             } else if (m is Method) {
               if (newMem is Method) {
                 CheckMethodsAreRefinements((Method)newMem, (Method)m);
               } else {
-                reporter.Error(newMem, "method must be refined by a method");
+                reporter.Error(MessageSource.RefinementTransformer, newMem, "method must be refined by a method");
               }
             } else if (m is Function) {
               if (newMem is Function) {
                 CheckFunctionsAreRefinements((Function)newMem, (Function)m);
               } else {
-                reporter.Error(newMem, "{0} must be refined by a {0}", m.WhatKind);
+                reporter.Error(MessageSource.RefinementTransformer, newMem, "{0} must be refined by a {0}", m.WhatKind);
               }
             }
           } else {
-            reporter.Error(nw is DefaultClassDecl ? nw.Module.tok : nw.tok, "refining {0} must have member {1}", nw is DefaultClassDecl ? "module" : "class", m.Name);
+            reporter.Error(MessageSource.RefinementTransformer, nw is DefaultClassDecl ? nw.Module.tok : nw.tok, "refining {0} must have member {1}", nw is DefaultClassDecl ? "module" : "class", m.Name);
           }
         }
       }
@@ -358,17 +351,17 @@ namespace Microsoft.Dafny
       Contract.Requires(thing != null);
       Contract.Requires(parameterKind != null);
       if (old.Count != nw.Count) {
-        reporter.Error(tok, "{0} '{1}' is declared with a different number of {2} ({3} instead of {4}) than the corresponding {0} in the module it refines", thing, name, parameterKind, nw.Count, old.Count);
+        reporter.Error(MessageSource.RefinementTransformer, tok, "{0} '{1}' is declared with a different number of {2} ({3} instead of {4}) than the corresponding {0} in the module it refines", thing, name, parameterKind, nw.Count, old.Count);
       } else {
         for (int i = 0; i < old.Count; i++) {
           var o = old[i];
           var n = nw[i];
           if (!o.IsGhost && n.IsGhost) {
-            reporter.Error(n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it refines, from non-ghost to ghost", parameterKind, n.Name, thing, name);
+            reporter.Error(MessageSource.RefinementTransformer, n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it refines, from non-ghost to ghost", parameterKind, n.Name, thing, name);
           } else if (o.IsGhost && !n.IsGhost) {
-            reporter.Error(n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it refines, from ghost to non-ghost", parameterKind, n.Name, thing, name);
+            reporter.Error(MessageSource.RefinementTransformer, n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it refines, from ghost to non-ghost", parameterKind, n.Name, thing, name);
           } else if (!ResolvedTypesAreTheSame(o.Type, n.Type)) {
-            reporter.Error(n.tok, "the type of {0} '{1}' is different from the type of the same {0} in the corresponding {2} in the module it refines ('{3}' instead of '{4}')", parameterKind, n.Name, thing, n.Type, o.Type);
+            reporter.Error(MessageSource.RefinementTransformer, n.tok, "the type of {0} '{1}' is different from the type of the same {0} in the corresponding {2} in the module it refines ('{3}' instead of '{4}')", parameterKind, n.Name, thing, n.Type, o.Type);
           }
         }
       }
@@ -382,22 +375,22 @@ namespace Microsoft.Dafny
     private void CheckFunctionsAreRefinements(Function nw, Function f) {
       if (f is Predicate) {
         if (!(nw is Predicate)) {
-          reporter.Error(nw, "a predicate declaration ({0}) can only be refined by a predicate", nw.Name);
+          reporter.Error(MessageSource.RefinementTransformer, nw, "a predicate declaration ({0}) can only be refined by a predicate", nw.Name);
         } else {
           CheckAgreement_TypeParameters(nw.tok, f.TypeArgs, nw.TypeArgs, nw.Name, "predicate", false);
           CheckAgreementResolvedParameters(nw.tok, f.Formals, nw.Formals, nw.Name, "predicate", "parameter");
         }
       } else if (f is FixpointPredicate) {
-        reporter.Error(nw, "refinement of {0}s is not supported", f.WhatKind);
+        reporter.Error(MessageSource.RefinementTransformer, nw, "refinement of {0}s is not supported", f.WhatKind);
       } else {
         // f is a plain Function
         if (nw is Predicate || nw is FixpointPredicate) {
-          reporter.Error(nw, "a {0} declaration ({1}) can only be refined by a function or function method", nw.IsGhost ? "function" : "function method", nw.Name);
+          reporter.Error(MessageSource.RefinementTransformer, nw, "a {0} declaration ({1}) can only be refined by a function or function method", nw.IsGhost ? "function" : "function method", nw.Name);
         } else {
           CheckAgreement_TypeParameters(nw.tok, f.TypeArgs, nw.TypeArgs, nw.Name, "function", false);
           CheckAgreementResolvedParameters(nw.tok, f.Formals, nw.Formals, nw.Name, "function", "parameter");
           if (!ResolvedTypesAreTheSame(nw.ResultType, f.ResultType)) {
-            reporter.Error(nw, "the result type of function '{0}' ({1}) differs from the result type of the corresponding function in the module it refines ({2})", nw.Name, nw.ResultType, f.ResultType);
+            reporter.Error(MessageSource.RefinementTransformer, nw, "the result type of function '{0}' ({1}) differs from the result type of the corresponding function in the module it refines ({2})", nw.Name, nw.ResultType, f.ResultType);
           }
         }
       }
@@ -408,7 +401,7 @@ namespace Microsoft.Dafny
     private void CheckDatatypesAreRefinements(DatatypeDecl dd, DatatypeDecl nn) {
       CheckAgreement_TypeParameters(nn.tok, dd.TypeArgs, nn.TypeArgs, dd.Name, "datatype", false);
       if (dd.Ctors.Count != nn.Ctors.Count) {
-        reporter.Error(nn.tok, "a refining datatype must have the same number of constructors");
+        reporter.Error(MessageSource.RefinementTransformer, nn.tok, "a refining datatype must have the same number of constructors");
       } else {
         var map = new Dictionary<string, DatatypeCtor>();
         foreach (var ctor in nn.Ctors) {
@@ -418,21 +411,21 @@ namespace Microsoft.Dafny
           DatatypeCtor newCtor;
           if (map.TryGetValue(ctor.Name, out newCtor)) {
             if (newCtor.Formals.Count != ctor.Formals.Count) {
-              reporter.Error(newCtor, "the constructor ({0}) must have the same number of formals as in the refined module", newCtor.Name); 
+              reporter.Error(MessageSource.RefinementTransformer, newCtor, "the constructor ({0}) must have the same number of formals as in the refined module", newCtor.Name);
             } else {
               for (int i = 0; i < newCtor.Formals.Count; i++) {
                 var a = ctor.Formals[i]; var b = newCtor.Formals[i];
                 if (a.HasName) {
                   if (!b.HasName || a.Name != b.Name)
-                    reporter.Error(b, "formal argument {0} in constructor {1} does not have the same name as in the refined module (should be {2})", i, ctor.Name, a.Name);
+                    reporter.Error(MessageSource.RefinementTransformer, b, "formal argument {0} in constructor {1} does not have the same name as in the refined module (should be {2})", i, ctor.Name, a.Name);
                 }
                 if (!ResolvedTypesAreTheSame(a.Type, b.Type)) {
-                  reporter.Error(b, "formal argument {0} in constructor {1} does not have the same type as in the refined module (should be {2}, not {3})", i, ctor.Name, a.Type.ToString(), b.Type.ToString());
+                  reporter.Error(MessageSource.RefinementTransformer, b, "formal argument {0} in constructor {1} does not have the same type as in the refined module (should be {2}, not {3})", i, ctor.Name, a.Type.ToString(), b.Type.ToString());
                 }
               }
             }
           } else {
-            reporter.Error(nn, "the constructor {0} must be present in the refining datatype", ctor.Name);
+            reporter.Error(MessageSource.RefinementTransformer, nn, "the constructor {0} must be present in the refining datatype", ctor.Name);
           }
         }
       }
@@ -501,7 +494,8 @@ namespace Microsoft.Dafny
         Contract.Assert(false); throw new cce.UnreachableException();  // unexpected type
       }
     }
-    public void PostResolve(ModuleDefinition m) {
+
+    internal override void PostResolve(ModuleDefinition m) {
       if (m == moduleUnderConstruction) {
         while (this.postTasks.Count != 0) {
           var a = postTasks.Dequeue();
@@ -512,8 +506,7 @@ namespace Microsoft.Dafny
       }
       moduleUnderConstruction = null;
     }
-    public void PostCyclicityResolve(ModuleDefinition m) { 
-    }
+
     Function CloneFunction(IToken tok, Function f, bool isGhost, List<Expression> moreEnsures, Expression moreBody, Expression replacementBody, bool checkPrevPostconditions, Attributes moreAttributes) {
       Contract.Requires(tok != null);
       Contract.Requires(moreBody == null || f is Predicate);
@@ -611,26 +604,26 @@ namespace Microsoft.Dafny
       Contract.Requires(prev != null);
 
       if (nw.Requires.Count != 0) {
-        reporter.Error(nw.Requires[0].E.tok, "a refining iterator is not allowed to add preconditions");
+        reporter.Error(MessageSource.RefinementTransformer, nw.Requires[0].E.tok, "a refining iterator is not allowed to add preconditions");
       }
       if (nw.YieldRequires.Count != 0) {
-        reporter.Error(nw.YieldRequires[0].E.tok, "a refining iterator is not allowed to add yield preconditions");
+        reporter.Error(MessageSource.RefinementTransformer, nw.YieldRequires[0].E.tok, "a refining iterator is not allowed to add yield preconditions");
       }
       if (nw.Reads.Expressions.Count != 0) {
-        reporter.Error(nw.Reads.Expressions[0].E.tok, "a refining iterator is not allowed to extend the reads clause");
+        reporter.Error(MessageSource.RefinementTransformer, nw.Reads.Expressions[0].E.tok, "a refining iterator is not allowed to extend the reads clause");
       }
       if (nw.Modifies.Expressions.Count != 0) {
-        reporter.Error(nw.Modifies.Expressions[0].E.tok, "a refining iterator is not allowed to extend the modifies clause");
+        reporter.Error(MessageSource.RefinementTransformer, nw.Modifies.Expressions[0].E.tok, "a refining iterator is not allowed to extend the modifies clause");
       }
       if (nw.Decreases.Expressions.Count != 0) {
-        reporter.Error(nw.Decreases.Expressions[0].tok, "a refining iterator is not allowed to extend the decreases clause");
+        reporter.Error(MessageSource.RefinementTransformer, nw.Decreases.Expressions[0].tok, "a refining iterator is not allowed to extend the decreases clause");
       }
 
       if (nw.SignatureIsOmitted) {
         Contract.Assert(nw.TypeArgs.Count == 0);
         Contract.Assert(nw.Ins.Count == 0);
         Contract.Assert(nw.Outs.Count == 0);
-        ReportAdditionalInformation(nw.SignatureEllipsis, Printer.IteratorSignatureToString(prev), 3);
+        reporter.Info(MessageSource.RefinementTransformer, nw.SignatureEllipsis, Printer.IteratorSignatureToString(prev));
       } else {
         CheckAgreement_TypeParameters(nw.tok, prev.TypeArgs, nw.TypeArgs, nw.Name, "iterator");
         CheckAgreement_Parameters(nw.tok, prev.Ins, nw.Ins, nw.Name, "iterator", "in-parameter");
@@ -694,9 +687,9 @@ namespace Microsoft.Dafny
           if (nwMember is Field) {
             if (member is Field && TypesAreSyntacticallyEqual(((Field)nwMember).Type, ((Field)member).Type)) {
               if (member.IsGhost || !nwMember.IsGhost)
-                reporter.Error(nwMember, "a field re-declaration ({0}) must be to ghostify the field", nwMember.Name, nw.Name);
+                reporter.Error(MessageSource.RefinementTransformer, nwMember, "a field re-declaration ({0}) must be to ghostify the field", nwMember.Name, nw.Name);
             } else {
-              reporter.Error(nwMember, "a field declaration ({0}) in a refining class ({1}) must replace a field in the refinement base", nwMember.Name, nw.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nwMember, "a field declaration ({0}) in a refining class ({1}) must replace a field in the refinement base", nwMember.Name, nw.Name);
             }
             nwMember.RefinementBase = member;
 
@@ -709,38 +702,38 @@ namespace Microsoft.Dafny
               (isPredicate && !(member is Predicate)) ||
               (isIndPredicate && !(member is InductivePredicate)) ||
               (isCoPredicate && !(member is CoPredicate))) {
-              reporter.Error(nwMember, "a {0} declaration ({1}) can only refine a {0}", f.WhatKind, nwMember.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nwMember, "a {0} declaration ({1}) can only refine a {0}", f.WhatKind, nwMember.Name);
             } else if (f.IsProtected != ((Function)member).IsProtected) {
-              reporter.Error(f, "a {0} in a refinement module must be declared 'protected' if and only if the refined {0} is", f.WhatKind);
+              reporter.Error(MessageSource.RefinementTransformer, f, "a {0} in a refinement module must be declared 'protected' if and only if the refined {0} is", f.WhatKind);
             } else {
               var prevFunction = (Function)member;
               if (f.Req.Count != 0) {
-                reporter.Error(f.Req[0].tok, "a refining {0} is not allowed to add preconditions", f.WhatKind);
+                reporter.Error(MessageSource.RefinementTransformer, f.Req[0].tok, "a refining {0} is not allowed to add preconditions", f.WhatKind);
               }
               if (f.Reads.Count != 0) {
-                reporter.Error(f.Reads[0].E.tok, "a refining {0} is not allowed to extend the reads clause", f.WhatKind);
+                reporter.Error(MessageSource.RefinementTransformer, f.Reads[0].E.tok, "a refining {0} is not allowed to extend the reads clause", f.WhatKind);
               }
               if (f.Decreases.Expressions.Count != 0) {
-                reporter.Error(f.Decreases.Expressions[0].tok, "decreases clause on refining {0} not supported", f.WhatKind);
+                reporter.Error(MessageSource.RefinementTransformer, f.Decreases.Expressions[0].tok, "decreases clause on refining {0} not supported", f.WhatKind);
               }
 
               if (prevFunction.HasStaticKeyword != f.HasStaticKeyword) {
-                reporter.Error(f, "a function in a refining module cannot be changed from static to non-static or vice versa: {0}", f.Name);
+                reporter.Error(MessageSource.RefinementTransformer, f, "a function in a refining module cannot be changed from static to non-static or vice versa: {0}", f.Name);
               }
               if (!prevFunction.IsGhost && f.IsGhost) {
-                reporter.Error(f, "a function method cannot be changed into a (ghost) function in a refining module: {0}", f.Name);
+                reporter.Error(MessageSource.RefinementTransformer, f, "a function method cannot be changed into a (ghost) function in a refining module: {0}", f.Name);
               } else if (prevFunction.IsGhost && !f.IsGhost && prevFunction.Body != null) {
-                reporter.Error(f, "a function can be changed into a function method in a refining module only if the function has not yet been given a body: {0}", f.Name);
+                reporter.Error(MessageSource.RefinementTransformer, f, "a function can be changed into a function method in a refining module only if the function has not yet been given a body: {0}", f.Name);
               }
               if (f.SignatureIsOmitted) {
                 Contract.Assert(f.TypeArgs.Count == 0);
                 Contract.Assert(f.Formals.Count == 0);
-                ReportAdditionalInformation(f.SignatureEllipsis, Printer.FunctionSignatureToString(prevFunction), 3);
+                reporter.Info(MessageSource.RefinementTransformer, f.SignatureEllipsis, Printer.FunctionSignatureToString(prevFunction));
               } else {
                 CheckAgreement_TypeParameters(f.tok, prevFunction.TypeArgs, f.TypeArgs, f.Name, "function");
                 CheckAgreement_Parameters(f.tok, prevFunction.Formals, f.Formals, f.Name, "function", "parameter");
                 if (!TypesAreSyntacticallyEqual(prevFunction.ResultType, f.ResultType)) {
-                  reporter.Error(f, "the result type of function '{0}' ({1}) differs from the result type of the corresponding function in the module it refines ({2})", f.Name, f.ResultType, prevFunction.ResultType);
+                  reporter.Error(MessageSource.RefinementTransformer, f, "the result type of function '{0}' ({1}) differs from the result type of the corresponding function in the module it refines ({2})", f.Name, f.ResultType, prevFunction.ResultType);
                 }
               }
 
@@ -752,9 +745,9 @@ namespace Microsoft.Dafny
                 if (isPredicate && f.IsProtected) {
                   moreBody = f.Body;
                 } else if (isPredicate) {
-                  reporter.Error(nwMember, "a refining predicate is not allowed to extend/change the body unless it is declared 'protected'");
+                  reporter.Error(MessageSource.RefinementTransformer, nwMember, "a refining predicate is not allowed to extend/change the body unless it is declared 'protected'");
                 } else {
-                  reporter.Error(nwMember, "a refining function is not allowed to extend/change the body");
+                  reporter.Error(MessageSource.RefinementTransformer, nwMember, "a refining function is not allowed to extend/change the body");
                 }
               }
               var newF = CloneFunction(f.tok, prevFunction, f.IsGhost, f.Ens, moreBody, replacementBody, prevFunction.Body == null, f.Attributes);
@@ -765,14 +758,14 @@ namespace Microsoft.Dafny
           } else {
             var m = (Method)nwMember;
             if (!(member is Method)) {
-              reporter.Error(nwMember, "a method declaration ({0}) can only refine a method", nwMember.Name);
+              reporter.Error(MessageSource.RefinementTransformer, nwMember, "a method declaration ({0}) can only refine a method", nwMember.Name);
             } else {
               var prevMethod = (Method)member;
               if (m.Req.Count != 0) {
-                reporter.Error(m.Req[0].E.tok, "a refining method is not allowed to add preconditions");
+                reporter.Error(MessageSource.RefinementTransformer, m.Req[0].E.tok, "a refining method is not allowed to add preconditions");
               }
               if (m.Mod.Expressions.Count != 0) {
-                reporter.Error(m.Mod.Expressions[0].E.tok, "a refining method is not allowed to extend the modifies clause");
+                reporter.Error(MessageSource.RefinementTransformer, m.Mod.Expressions[0].E.tok, "a refining method is not allowed to extend the modifies clause");
               }
               // If the previous method was not specified with "decreases *", then the new method is not allowed to provide any "decreases" clause.
               // Any "decreases *" clause is not inherited, so if the previous method was specified with "decreases *", then the new method needs
@@ -785,23 +778,23 @@ namespace Microsoft.Dafny
               } else {
                 if (!Contract.Exists(prevMethod.Decreases.Expressions, e => e is WildcardExpr)) {
                   // If the previous loop was not specified with "decreases *", then the new loop is not allowed to provide any "decreases" clause.
-                  reporter.Error(m.Decreases.Expressions[0].tok, "decreases clause on refining method not supported, unless the refined method was specified with 'decreases *'");
+                  reporter.Error(MessageSource.RefinementTransformer, m.Decreases.Expressions[0].tok, "decreases clause on refining method not supported, unless the refined method was specified with 'decreases *'");
                 }
                 decreases = m.Decreases;
               }
               if (prevMethod.HasStaticKeyword != m.HasStaticKeyword) {
-                reporter.Error(m, "a method in a refining module cannot be changed from static to non-static or vice versa: {0}", m.Name);
+                reporter.Error(MessageSource.RefinementTransformer, m, "a method in a refining module cannot be changed from static to non-static or vice versa: {0}", m.Name);
               }
               if (prevMethod.IsGhost && !m.IsGhost) {
-                reporter.Error(m, "a method cannot be changed into a ghost method in a refining module: {0}", m.Name);
+                reporter.Error(MessageSource.RefinementTransformer, m, "a method cannot be changed into a ghost method in a refining module: {0}", m.Name);
               } else if (!prevMethod.IsGhost && m.IsGhost) {
-                reporter.Error(m, "a ghost method cannot be changed into a non-ghost method in a refining module: {0}", m.Name);
+                reporter.Error(MessageSource.RefinementTransformer, m, "a ghost method cannot be changed into a non-ghost method in a refining module: {0}", m.Name);
               }
               if (m.SignatureIsOmitted) {
                 Contract.Assert(m.TypeArgs.Count == 0);
                 Contract.Assert(m.Ins.Count == 0);
                 Contract.Assert(m.Outs.Count == 0);
-                ReportAdditionalInformation(m.SignatureEllipsis, Printer.MethodSignatureToString(prevMethod), 3);
+                reporter.Info(MessageSource.RefinementTransformer, m.SignatureEllipsis, Printer.MethodSignatureToString(prevMethod));
               } else {
                 CheckAgreement_TypeParameters(m.tok, prevMethod.TypeArgs, m.TypeArgs, m.Name, "method");
                 CheckAgreement_Parameters(m.tok, prevMethod.Ins, m.Ins, m.Name, "method", "in-parameter");
@@ -833,13 +826,13 @@ namespace Microsoft.Dafny
       Contract.Requires(name != null);
       Contract.Requires(thing != null);
       if (old.Count != nw.Count) {
-        reporter.Error(tok, "{0} '{1}' is declared with a different number of type parameters ({2} instead of {3}) than the corresponding {0} in the module it refines", thing, name, nw.Count, old.Count);
+        reporter.Error(MessageSource.RefinementTransformer, tok, "{0} '{1}' is declared with a different number of type parameters ({2} instead of {3}) than the corresponding {0} in the module it refines", thing, name, nw.Count, old.Count);
       } else {
         for (int i = 0; i < old.Count; i++) {
           var o = old[i];
           var n = nw[i];
           if (o.Name != n.Name && checkNames) { // if checkNames is false, then just treat the parameters positionally.
-            reporter.Error(n.tok, "type parameters are not allowed to be renamed from the names given in the {0} in the module being refined (expected '{1}', found '{2}')", thing, o.Name, n.Name);
+            reporter.Error(MessageSource.RefinementTransformer, n.tok, "type parameters are not allowed to be renamed from the names given in the {0} in the module being refined (expected '{1}', found '{2}')", thing, o.Name, n.Name);
           } else {
             // This explains what we want to do and why:
             // switch (o.EqualitySupport) {
@@ -859,7 +852,7 @@ namespace Microsoft.Dafny
             // }
             // Here's how we actually compute it:
             if (o.EqualitySupport != TypeParameter.EqualitySupportValue.InferredRequired && o.EqualitySupport != n.EqualitySupport) {
-              reporter.Error(n.tok, "type parameter '{0}' is not allowed to change the requirement of supporting equality", n.Name);
+              reporter.Error(MessageSource.RefinementTransformer, n.tok, "type parameter '{0}' is not allowed to change the requirement of supporting equality", n.Name);
             }
           }
         }
@@ -872,7 +865,7 @@ namespace Microsoft.Dafny
         CheckOverrideResolvedParameters(nw.tok, f.Formals, nw.Formals, nw.Name, "function", "parameter");
         if (!ResolvedTypesAreTheSame(nw.ResultType, f.ResultType))
         {
-            reporter.Error(nw, "the result type of function '{0}' ({1}) differs from the result type of the corresponding function in the module it overrides ({2})", nw.Name, nw.ResultType, f.ResultType);
+            reporter.Error(MessageSource.RefinementTransformer, nw, "the result type of function '{0}' ({1}) differs from the result type of the corresponding function in the module it overrides ({2})", nw.Name, nw.ResultType, f.ResultType);
         }
     }
 
@@ -892,7 +885,7 @@ namespace Microsoft.Dafny
         Contract.Requires(thing != null);
         if (old.Count != nw.Count)
         {
-            reporter.Error(tok, "{0} '{1}' is declared with a different number of type parameters ({2} instead of {3}) than the corresponding {0} in the module it overrides", thing, name, nw.Count, old.Count);
+            reporter.Error(MessageSource.RefinementTransformer, tok, "{0} '{1}' is declared with a different number of type parameters ({2} instead of {3}) than the corresponding {0} in the module it overrides", thing, name, nw.Count, old.Count);
         }
         else
         {
@@ -902,14 +895,14 @@ namespace Microsoft.Dafny
                 var n = nw[i];
                 if (o.Name != n.Name && checkNames)
                 { // if checkNames is false, then just treat the parameters positionally.
-                    reporter.Error(n.tok, "type parameters are not allowed to be renamed from the names given in the {0} in the module being overriden (expected '{1}', found '{2}')", thing, o.Name, n.Name);
+                    reporter.Error(MessageSource.RefinementTransformer, n.tok, "type parameters are not allowed to be renamed from the names given in the {0} in the module being overriden (expected '{1}', found '{2}')", thing, o.Name, n.Name);
                 }
                 else
                 {
                     // Here's how we actually compute it:
                     if (o.EqualitySupport != TypeParameter.EqualitySupportValue.InferredRequired && o.EqualitySupport != n.EqualitySupport)
                     {
-                        reporter.Error(n.tok, "type parameter '{0}' is not allowed to change the requirement of supporting equality", n.Name);
+                        reporter.Error(MessageSource.RefinementTransformer, n.tok, "type parameter '{0}' is not allowed to change the requirement of supporting equality", n.Name);
                     }
                 }
             }
@@ -926,7 +919,7 @@ namespace Microsoft.Dafny
         Contract.Requires(parameterKind != null);
         if (old.Count != nw.Count)
         {
-            reporter.Error(tok, "{0} '{1}' is declared with a different number of {2} ({3} instead of {4}) than the corresponding {0} in the module it overrides", thing, name, parameterKind, nw.Count, old.Count);
+            reporter.Error(MessageSource.RefinementTransformer, tok, "{0} '{1}' is declared with a different number of {2} ({3} instead of {4}) than the corresponding {0} in the module it overrides", thing, name, parameterKind, nw.Count, old.Count);
         }
         else
         {
@@ -936,15 +929,15 @@ namespace Microsoft.Dafny
                 var n = nw[i];
                 if (!o.IsGhost && n.IsGhost)
                 {
-                    reporter.Error(n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it overrides, from non-ghost to ghost", parameterKind, n.Name, thing, name);
+                    reporter.Error(MessageSource.RefinementTransformer, n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it overrides, from non-ghost to ghost", parameterKind, n.Name, thing, name);
                 }
                 else if (o.IsGhost && !n.IsGhost)
                 {
-                    reporter.Error(n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it overrides, from ghost to non-ghost", parameterKind, n.Name, thing, name);
+                    reporter.Error(MessageSource.RefinementTransformer, n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it overrides, from ghost to non-ghost", parameterKind, n.Name, thing, name);
                 }
                 else if (!ResolvedTypesAreTheSame(o.Type, n.Type))
                 {
-                    reporter.Error(n.tok, "the type of {0} '{1}' is different from the type of the same {0} in the corresponding {2} in the module it overrides ('{3}' instead of '{4}')", parameterKind, n.Name, thing, n.Type, o.Type);
+                    reporter.Error(MessageSource.RefinementTransformer, n.tok, "the type of {0} '{1}' is different from the type of the same {0} in the corresponding {2} in the module it overrides ('{3}' instead of '{4}')", parameterKind, n.Name, thing, n.Type, o.Type);
                 }
             }
         }
@@ -958,19 +951,19 @@ namespace Microsoft.Dafny
       Contract.Requires(thing != null);
       Contract.Requires(parameterKind != null);
       if (old.Count != nw.Count) {
-        reporter.Error(tok, "{0} '{1}' is declared with a different number of {2} ({3} instead of {4}) than the corresponding {0} in the module it refines", thing, name, parameterKind, nw.Count, old.Count);
+        reporter.Error(MessageSource.RefinementTransformer, tok, "{0} '{1}' is declared with a different number of {2} ({3} instead of {4}) than the corresponding {0} in the module it refines", thing, name, parameterKind, nw.Count, old.Count);
       } else {
         for (int i = 0; i < old.Count; i++) {
           var o = old[i];
           var n = nw[i];
           if (o.Name != n.Name) {
-            reporter.Error(n.tok, "there is a difference in name of {0} {1} ('{2}' versus '{3}') of {4} {5} compared to corresponding {4} in the module it refines", parameterKind, i, n.Name, o.Name, thing, name);
+            reporter.Error(MessageSource.RefinementTransformer, n.tok, "there is a difference in name of {0} {1} ('{2}' versus '{3}') of {4} {5} compared to corresponding {4} in the module it refines", parameterKind, i, n.Name, o.Name, thing, name);
           } else if (!o.IsGhost && n.IsGhost) {
-            reporter.Error(n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it refines, from non-ghost to ghost", parameterKind, n.Name, thing, name);
+            reporter.Error(MessageSource.RefinementTransformer, n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it refines, from non-ghost to ghost", parameterKind, n.Name, thing, name);
           } else if (o.IsGhost && !n.IsGhost) {
-            reporter.Error(n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it refines, from ghost to non-ghost", parameterKind, n.Name, thing, name);
+            reporter.Error(MessageSource.RefinementTransformer, n.tok, "{0} '{1}' of {2} {3} cannot be changed, compared to the corresponding {2} in the module it refines, from ghost to non-ghost", parameterKind, n.Name, thing, name);
           } else if (!TypesAreSyntacticallyEqual(o.Type, n.Type)) {
-            reporter.Error(n.tok, "the type of {0} '{1}' is different from the type of the same {0} in the corresponding {2} in the module it refines ('{3}' instead of '{4}')", parameterKind, n.Name, thing, n.Type, o.Type);
+            reporter.Error(MessageSource.RefinementTransformer, n.tok, "the type of {0} '{1}' is different from the type of the same {0} in the corresponding {2} in the module it refines ('{3}' instead of '{4}')", parameterKind, n.Name, thing, n.Type, o.Type);
           }
         }
       }
@@ -996,7 +989,7 @@ namespace Microsoft.Dafny
           } else if (((SkeletonStatement)cur).S == null) {
             // the "..." matches the empty statement sequence
           } else {
-            reporter.Error(cur.Tok, "skeleton statement does not match old statement");
+            reporter.Error(MessageSource.RefinementTransformer, cur.Tok, "skeleton statement does not match old statement");
           }
           i++;
         } else {
@@ -1050,7 +1043,7 @@ namespace Microsoft.Dafny
                   Contract.Assert(c.NameReplacements.Count == c.ExprReplacements.Count);
                   for (int k = 0; k < c.NameReplacements.Count; k++) {
                     if (subExprs.ContainsKey(c.NameReplacements[k].val)) {
-                      reporter.Error(c.NameReplacements[k], "replacement definition must contain at most one definition for a given label");
+                      reporter.Error(MessageSource.RefinementTransformer, c.NameReplacements[k], "replacement definition must contain at most one definition for a given label");
                     } else subExprs.Add(c.NameReplacements[k].val, c.ExprReplacements[k]);
                   }
                   subber = new SubstitutionCloner(subExprs, rawCloner);
@@ -1071,12 +1064,12 @@ namespace Microsoft.Dafny
                   oldS = oldStmt.Body[j];
                 }
                 if (hoverTextA.Length != 0) {
-                  ReportAdditionalInformation(c.Tok, hoverTextA, 3);
+                  reporter.Info(MessageSource.RefinementTransformer, c.Tok, hoverTextA);
                 }
                 if (subber != null && subber.SubstitutionsMade.Count < subber.Exprs.Count) {
                   foreach (var s in subber.SubstitutionsMade)
                     subber.Exprs.Remove(s);
-                  reporter.Error(c.Tok, "could not find labeled expression(s): " + Util.Comma(", ", subber.Exprs.Keys, x => x));
+                  reporter.Error(MessageSource.RefinementTransformer, c.Tok, "could not find labeled expression(s): " + Util.Comma(", ", subber.Exprs.Keys, x => x));
                 }
               }
               i++;
@@ -1086,7 +1079,7 @@ namespace Microsoft.Dafny
               Contract.Assert(c.ConditionOmitted);
               var oldAssume = oldS as PredicateStmt;
               if (oldAssume == null) {
-                reporter.Error(cur.Tok, "assert template does not match inherited statement");
+                reporter.Error(MessageSource.RefinementTransformer, cur.Tok, "assert template does not match inherited statement");
                 i++;
               } else {
                 // Clone the expression, but among the new assert's attributes, indicate
@@ -1097,7 +1090,7 @@ namespace Microsoft.Dafny
                 var attrs = refinementCloner.MergeAttributes(oldAssume.Attributes, skel.Attributes);
                 body.Add(new AssertStmt(new Translator.ForceCheckToken(skel.Tok), new Translator.ForceCheckToken(skel.EndTok),
                   e, new Attributes("prependAssertToken", new List<Expression>(), attrs)));
-                ReportAdditionalInformation(c.ConditionEllipsis, "assume->assert: " + Printer.ExprToString(e), 3);
+                reporter.Info(MessageSource.RefinementTransformer, c.ConditionEllipsis, "assume->assert: " + Printer.ExprToString(e));
                 i++; j++;
               }
 
@@ -1106,13 +1099,13 @@ namespace Microsoft.Dafny
               Contract.Assert(c.ConditionOmitted);
               var oldAssume = oldS as AssumeStmt;
               if (oldAssume == null) {
-                reporter.Error(cur.Tok, "assume template does not match inherited statement");
+                reporter.Error(MessageSource.RefinementTransformer, cur.Tok, "assume template does not match inherited statement");
                 i++;
               } else {
                 var e = refinementCloner.CloneExpr(oldAssume.Expr);
                 var attrs = refinementCloner.MergeAttributes(oldAssume.Attributes, skel.Attributes);
                 body.Add(new AssumeStmt(skel.Tok, skel.EndTok, e, attrs));
-                ReportAdditionalInformation(c.ConditionEllipsis, Printer.ExprToString(e), 3);
+                reporter.Info(MessageSource.RefinementTransformer, c.ConditionEllipsis, Printer.ExprToString(e));
                 i++; j++;
               }
 
@@ -1121,7 +1114,7 @@ namespace Microsoft.Dafny
               Contract.Assert(c.ConditionOmitted);
               var oldIf = oldS as IfStmt;
               if (oldIf == null) {
-                reporter.Error(cur.Tok, "if-statement template does not match inherited statement");
+                reporter.Error(MessageSource.RefinementTransformer, cur.Tok, "if-statement template does not match inherited statement");
                 i++;
               } else {
                 var resultingThen = MergeBlockStmt(skel.Thn, oldIf.Thn);
@@ -1129,7 +1122,7 @@ namespace Microsoft.Dafny
                 var e = refinementCloner.CloneExpr(oldIf.Guard);
                 var r = new IfStmt(skel.Tok, skel.EndTok, e, resultingThen, resultingElse);
                 body.Add(r);
-                ReportAdditionalInformation(c.ConditionEllipsis, Printer.GuardToString(e), 3);
+                reporter.Info(MessageSource.RefinementTransformer, c.ConditionEllipsis, Printer.GuardToString(e));
                 i++; j++;
               }
 
@@ -1137,16 +1130,16 @@ namespace Microsoft.Dafny
               var skel = (WhileStmt)S;
               var oldWhile = oldS as WhileStmt;
               if (oldWhile == null) {
-                reporter.Error(cur.Tok, "while-statement template does not match inherited statement");
+                reporter.Error(MessageSource.RefinementTransformer, cur.Tok, "while-statement template does not match inherited statement");
                 i++;
               } else {
                 Expression guard;
                 if (c.ConditionOmitted) {
                   guard = refinementCloner.CloneExpr(oldWhile.Guard);
-                  ReportAdditionalInformation(c.ConditionEllipsis, Printer.GuardToString(oldWhile.Guard), 3);
+                  reporter.Info(MessageSource.RefinementTransformer, c.ConditionEllipsis, Printer.GuardToString(oldWhile.Guard));
                 } else {
                   if (oldWhile.Guard != null) {
-                    reporter.Error(skel.Guard.tok, "a skeleton while statement with a guard can only replace a while statement with a non-deterministic guard");
+                    reporter.Error(MessageSource.RefinementTransformer, skel.Guard.tok, "a skeleton while statement with a guard can only replace a while statement with a non-deterministic guard");
                   }
                   guard = skel.Guard;
                 }
@@ -1162,7 +1155,7 @@ namespace Microsoft.Dafny
               Contract.Assert(c.ConditionOmitted);
               var oldModifyStmt = oldS as ModifyStmt;
               if (oldModifyStmt == null) {
-                reporter.Error(cur.Tok, "modify template does not match inherited statement");
+                reporter.Error(MessageSource.RefinementTransformer, cur.Tok, "modify template does not match inherited statement");
                 i++;
               } else {
                 var mod = refinementCloner.CloneSpecFrameExpr(oldModifyStmt.Mod);
@@ -1172,13 +1165,13 @@ namespace Microsoft.Dafny
                 } else if (oldModifyStmt.Body == null) {
                   mbody = skel.Body;
                 } else if (skel.Body == null) {
-                  reporter.Error(cur.Tok, "modify template must have a body if the inherited modify statement does");
+                  reporter.Error(MessageSource.RefinementTransformer, cur.Tok, "modify template must have a body if the inherited modify statement does");
                   mbody = null;
                 } else {
                   mbody = MergeBlockStmt(skel.Body, oldModifyStmt.Body);
                 }
                 body.Add(new ModifyStmt(skel.Tok, skel.EndTok, mod.Expressions, mod.Attributes, mbody));
-                ReportAdditionalInformation(c.ConditionEllipsis, Printer.FrameExprListToString(mod.Expressions), 3);
+                reporter.Info(MessageSource.RefinementTransformer, c.ConditionEllipsis, Printer.FrameExprListToString(mod.Expressions));
                 i++; j++;
               }
 
@@ -1341,7 +1334,7 @@ namespace Microsoft.Dafny
         sep = "\n";
       }
       if (hoverText.Length != 0) {
-        ReportAdditionalInformation(skeleton.EndTok, hoverText, 3);
+        reporter.Info(MessageSource.RefinementTransformer, skeleton.EndTok, hoverText);
       }
       return new BlockStmt(skeleton.Tok, skeleton.EndTok, body);
     }
@@ -1447,7 +1440,7 @@ namespace Microsoft.Dafny
       } else {
         if (!Contract.Exists(cOld.Decreases.Expressions, e => e is WildcardExpr)) {
           // If the previous loop was not specified with "decreases *", then the new loop is not allowed to provide any "decreases" clause.
-          reporter.Error(cNew.Decreases.Expressions[0].tok, "a refining loop can provide a decreases clause only if the loop being refined was declared with 'decreases *'");
+          reporter.Error(MessageSource.RefinementTransformer, cNew.Decreases.Expressions[0].tok, "a refining loop can provide a decreases clause only if the loop being refined was declared with 'decreases *'");
         }
         decr = cNew.Decreases;
       }
@@ -1489,9 +1482,9 @@ namespace Microsoft.Dafny
     void MergeAddStatement(Statement s, List<Statement> stmtList) {
       Contract.Requires(s != null);
       Contract.Requires(stmtList != null);
-      var prevErrorCount = reporter.ErrorCount;
+      var prevErrorCount = reporter.Count(ErrorLevel.Error);
       CheckIsOkayNewStatement(s, new Stack<string>(), 0);
-      if (reporter.ErrorCount == prevErrorCount) {
+      if (reporter.Count(ErrorLevel.Error) == prevErrorCount) {
         stmtList.Add(s);
       }
     }
@@ -1508,30 +1501,30 @@ namespace Microsoft.Dafny
         labels.Push(n.Data.Name);
       }
       if (s is SkeletonStatement) {
-        reporter.Error(s, "skeleton statement may not be used here; it does not have a matching statement in what is being replaced");
+        reporter.Error(MessageSource.RefinementTransformer, s, "skeleton statement may not be used here; it does not have a matching statement in what is being replaced");
       } else if (s is ReturnStmt) {
         // allow return statements, but make note of that this requires verifying the postcondition
         ((ReturnStmt)s).ReverifyPost = true;
       } else if (s is YieldStmt) {
-        reporter.Error(s, "yield statements are not allowed in skeletons");
+        reporter.Error(MessageSource.RefinementTransformer, s, "yield statements are not allowed in skeletons");
       } else if (s is BreakStmt) {
         var b = (BreakStmt)s;
         if (b.TargetLabel != null ? !labels.Contains(b.TargetLabel) : loopLevels < b.BreakCount) {
-          reporter.Error(s, "break statement in skeleton is not allowed to break outside the skeleton fragment");
+          reporter.Error(MessageSource.RefinementTransformer, s, "break statement in skeleton is not allowed to break outside the skeleton fragment");
         }
       } else if (s is AssignStmt) {
         // TODO: To be a refinement automatically (that is, without any further verification), only variables and fields defined
         // in this module are allowed.  This needs to be checked.  If the LHS refers to an l-value that was not declared within
         // this module, then either an error should be reported or the Translator needs to know to translate new proof obligations.
         var a = (AssignStmt)s;
-        reporter.Error(a.Tok, "cannot have assignment statement");
+        reporter.Error(MessageSource.RefinementTransformer, a.Tok, "cannot have assignment statement");
       } else if (s is ConcreteUpdateStatement) {
         postTasks.Enqueue(() =>
         {
-          CheckIsOkayUpdateStmt((ConcreteUpdateStatement)s, moduleUnderConstruction, reporter);
+          CheckIsOkayUpdateStmt((ConcreteUpdateStatement)s, moduleUnderConstruction);
         });
       } else if (s is CallStmt) {
-        reporter.Error(s.Tok, "cannot have call statement");
+        reporter.Error(MessageSource.RefinementTransformer, s.Tok, "cannot have call statement");
       } else {
         if (s is WhileStmt || s is AlternativeLoopStmt) {
           loopLevels++;
@@ -1547,7 +1540,7 @@ namespace Microsoft.Dafny
     }
 
     // Checks that statement stmt, defined in the constructed module m, is a refinement of skip in the parent module
-    void CheckIsOkayUpdateStmt(ConcreteUpdateStatement stmt, ModuleDefinition m, ResolutionErrorReporter reporter) {
+    void CheckIsOkayUpdateStmt(ConcreteUpdateStatement stmt, ModuleDefinition m) {
       foreach (var lhs in stmt.Lhss) {
         var l = lhs.Resolved;
         if (l is IdentifierExpr) {
@@ -1555,23 +1548,23 @@ namespace Microsoft.Dafny
           Contract.Assert(ident.Var is LocalVariable || ident.Var is Formal); // LHS identifier expressions must be locals or out parameters (ie. formals)
           if ((ident.Var is LocalVariable && RefinementToken.IsInherited(((LocalVariable)ident.Var).Tok, m)) || ident.Var is Formal) {
             // for some reason, formals are not considered to be inherited.
-            reporter.Error(l.tok, "refinement method cannot assign to variable defined in parent module ('{0}')", ident.Var.Name);
+            reporter.Error(MessageSource.RefinementTransformer, l.tok, "refinement method cannot assign to variable defined in parent module ('{0}')", ident.Var.Name);
           }
         } else if (l is MemberSelectExpr) {
           var member = ((MemberSelectExpr)l).Member;
           if (RefinementToken.IsInherited(member.tok, m)) {
-            reporter.Error(l.tok, "refinement method cannot assign to a field defined in parent module ('{0}')", member.Name);
+            reporter.Error(MessageSource.RefinementTransformer, l.tok, "refinement method cannot assign to a field defined in parent module ('{0}')", member.Name);
           }
         } else {
           // must be an array element
-          reporter.Error(l.tok, "new assignments in a refinement method can only assign to state that the module defines (which never includes array elements)");
+          reporter.Error(MessageSource.RefinementTransformer, l.tok, "new assignments in a refinement method can only assign to state that the module defines (which never includes array elements)");
         }
       }
       if (stmt is UpdateStmt) {
         var s = (UpdateStmt)stmt;
         foreach (var rhs in s.Rhss) {
           if (rhs.CanAffectPreviouslyKnownExpressions) {
-            reporter.Error(rhs.Tok, "assignment RHS in refinement method is not allowed to affect previously defined state");
+            reporter.Error(MessageSource.RefinementTransformer, rhs.Tok, "assignment RHS in refinement method is not allowed to affect previously defined state");
           }
         }
       }
diff --git a/Source/Dafny/Reporting.cs b/Source/Dafny/Reporting.cs
new file mode 100644
index 00000000..c3797574
--- /dev/null
+++ b/Source/Dafny/Reporting.cs
@@ -0,0 +1,164 @@
+using Microsoft.Boogie;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.Linq;
+using System.Text;
+
+namespace Microsoft.Dafny {
+  public enum ErrorLevel {
+    Info, Warning, Error
+  }
+
+  public enum MessageSource {
+    Parser, Resolver, Translator, Rewriter, Other,
+    RefinementTransformer,
+    Cloner
+  }
+
+  public struct ErrorMessage {
+    public IToken token;
+    public string message;
+    public MessageSource source;
+  }
+
+  public abstract class ErrorReporter {
+    public bool ErrorsOnly { get; set; }
+    public Dictionary<ErrorLevel, List<ErrorMessage>> AllMessages { get; private set; }
+
+    protected ErrorReporter() {
+      ErrorsOnly = false;
+      AllMessages = new Dictionary<ErrorLevel, List<ErrorMessage>>();
+      AllMessages[ErrorLevel.Error] = new List<ErrorMessage>();
+      AllMessages[ErrorLevel.Warning] = new List<ErrorMessage>();
+      AllMessages[ErrorLevel.Info] = new List<ErrorMessage>();
+    }
+
+    protected bool ShouldDiscard(MessageSource source, ErrorLevel level) {
+      return ((ErrorsOnly && level != ErrorLevel.Error) ||
+              (!DafnyOptions.O.PrintTooltips && level == ErrorLevel.Info));
+    }
+
+    // This is the only thing that needs to be overriden
+    public virtual bool Message(MessageSource source, ErrorLevel level, IToken tok, string msg) {
+      var discard = ShouldDiscard(source, level);
+
+      if (!discard) {
+        AllMessages[level].Add(new ErrorMessage { token = tok, message = msg });
+        return true;
+      }
+
+      return false;
+    }
+
+    public int Count(ErrorLevel level) {
+      return AllMessages[level].Count;
+    }
+
+    public void Error(MessageSource source, IToken tok, string msg) {
+      Contract.Requires(tok != null);
+      Contract.Requires(msg != null);
+      Message(source, ErrorLevel.Error, tok, msg);
+    }
+
+    // This method required by the Parser
+    internal void Error(MessageSource source, string filename, int line, int col, string msg) {
+      var tok = new Token(line, col);
+      tok.filename = filename;
+      Error(source, tok, msg);
+    }
+
+    public void Error(MessageSource source, IToken tok, string msg, params object[] args) {
+      Contract.Requires(tok != null);
+      Contract.Requires(msg != null);
+      Error(source, tok, String.Format(msg, args));
+    }
+
+    public void Error(MessageSource source, Declaration d, string msg, params object[] args) {
+      Contract.Requires(d != null);
+      Contract.Requires(msg != null);
+      Error(source, d.tok, msg, args);
+    }
+
+    public void Error(MessageSource source, Statement s, string msg, params object[] args) {
+      Contract.Requires(s != null);
+      Contract.Requires(msg != null);
+      Error(source, s.Tok, msg, args);
+    }
+
+    public void Error(MessageSource source, NonglobalVariable v, string msg, params object[] args) {
+      Contract.Requires(v != null);
+      Contract.Requires(msg != null);
+      Error(source, v.tok, msg, args);
+    }
+
+    public void Error(MessageSource source, Expression e, string msg, params object[] args) {
+      Contract.Requires(e != null);
+      Contract.Requires(msg != null);
+      Error(source, e.tok, msg, args);
+    }
+
+    public void Warning(MessageSource source, IToken tok, string msg) {
+      Contract.Requires(tok != null);
+      Contract.Requires(msg != null);
+      Message(source, ErrorLevel.Warning, tok, msg);
+    }
+
+    public void Warning(MessageSource source, IToken tok, string msg, params object[] args) {
+      Contract.Requires(tok != null);
+      Contract.Requires(msg != null);
+      Warning(source, tok, String.Format(msg, args));
+    }
+
+    public void Info(MessageSource source, IToken tok, string msg) {
+      Contract.Requires(tok != null);
+      Contract.Requires(msg != null);
+      Message(source, ErrorLevel.Info, tok, msg);
+    }
+
+    public void Info(MessageSource source, IToken tok, string msg, params object[] args) {
+      Contract.Requires(tok != null);
+      Contract.Requires(msg != null);
+      Info(source, tok, String.Format(msg, args));
+    }
+
+    public string ErrorToString(ErrorLevel header, IToken tok, string msg) {
+      return ErrorToString_Internal(": " + header.ToString(), tok.filename, tok.line, tok.col, ": " + msg);
+    }
+
+    public string ErrorToString(ErrorLevel header, string filename, int oneBasedLine, int oneBasedColumn, string msg) {
+      return ErrorToString_Internal(": " + header.ToString(), filename, oneBasedLine, oneBasedColumn, ": " + msg);
+    }
+
+    public string ErrorToString_Internal(string header, string filename, int oneBasedLine, int oneBasedColumn, string msg) {
+      return String.Format("{0}({1},{2}){3}{4}", filename, oneBasedLine, oneBasedColumn - 1, header, msg ?? "");
+    }
+  }
+
+  public class ConsoleErrorReporter : ErrorReporter {
+    private ConsoleColor ColorForLevel(ErrorLevel level) {
+      switch (level) {
+        case ErrorLevel.Error:
+          return ConsoleColor.Red;
+        case ErrorLevel.Warning:
+          return ConsoleColor.Yellow;
+        case ErrorLevel.Info:
+          return ConsoleColor.Green;
+        default:
+          throw new cce.UnreachableException();
+      }
+    }
+
+    public override bool Message(MessageSource source, ErrorLevel level, IToken tok, string msg) {
+      if (base.Message(source, level, tok, msg)) {
+        ConsoleColor previousColor = Console.ForegroundColor;
+        Console.ForegroundColor = ColorForLevel(level);
+        Console.WriteLine(ErrorToString(level, tok, msg));
+        Console.ForegroundColor = previousColor;
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+}
diff --git a/Source/Dafny/Resolver.cs b/Source/Dafny/Resolver.cs
index a58d6e6c..db087109 100644
--- a/Source/Dafny/Resolver.cs
+++ b/Source/Dafny/Resolver.cs
@@ -12,75 +12,11 @@ using Microsoft.Boogie;
 
 namespace Microsoft.Dafny
 {
-  public class ResolutionErrorReporter
-  {
-    public int ErrorCount = 0;
-
-    /// <summary>
-    /// This method is virtual, because it is overridden in the VSX plug-in for Dafny.
-    /// </summary>
-    public virtual void Error(IToken tok, string msg, params object[] args) {
-      Contract.Requires(tok != null);
-      Contract.Requires(msg != null);
-      ConsoleColor col = Console.ForegroundColor;
-      Console.ForegroundColor = ConsoleColor.Red;
-      Dafny.Util.ReportIssue("Error", tok, msg, args);
-      Console.ForegroundColor = col;
-      ErrorCount++;
-    }
-    public void Error(Declaration d, string msg, params object[] args) {
-      Contract.Requires(d != null);
-      Contract.Requires(msg != null);
-      Error(d.tok, msg, args);
-    }
-    public void Error(Statement s, string msg, params object[] args) {
-      Contract.Requires(s != null);
-      Contract.Requires(msg != null);
-      Error(s.Tok, msg, args);
-    }
-    public void Error(NonglobalVariable v, string msg, params object[] args) {
-      Contract.Requires(v != null);
-      Contract.Requires(msg != null);
-      Error(v.tok, msg, args);
-    }
-    public void Error(Expression e, string msg, params object[] args) {
-      Contract.Requires(e != null);
-      Contract.Requires(msg != null);
-      Error(e.tok, msg, args);
-    }
-
-    protected bool reportWarnings = true;
-    /// <summary>
-    /// Set whether or not to report warnings. Return the state of the previous behavior.
-    /// </summary>
-    public bool ReportWarnings(bool b) {
-      var old = reportWarnings;
-      reportWarnings = b;
-      return old;
-    }
-    public virtual void Warning(IToken tok, string msg, params object[] args) {
-      Contract.Requires(tok != null);
-      Contract.Requires(msg != null);
-      if (reportWarnings) {
-        ConsoleColor col = Console.ForegroundColor;
-        Console.ForegroundColor = ConsoleColor.Yellow;
-        Dafny.Util.ReportIssue("Warning", tok, msg, args);
-        Console.ForegroundColor = col;
-      }
-    }
-  }
-
-  public struct AdditionalInformation
-  {
-    public IToken Token;
-    public string Text;
-    public int Length;
-  }
-
-  public class Resolver : ResolutionErrorReporter
+  public class Resolver
   {
     readonly BuiltIns builtIns;
 
+    readonly ErrorReporter reporter;
     ModuleSignature moduleInfo = null;
 
     FreshIdGenerator defaultTempVarIdGenerator;
@@ -99,18 +35,6 @@ namespace Microsoft.Dafny
       return defaultTempVarIdGenerator.FreshId(prefix);
     }
 
-    public Action<AdditionalInformation> AdditionalInformationReporter;
-
-    internal void ReportAdditionalInformation(IToken token, string text, int length)
-    {
-      Contract.Requires(token != null);
-      Contract.Requires(text != null);
-      Contract.Requires(0 <= length); //FIXME: KRML: This should (probably) be the length of the token
-      if (AdditionalInformationReporter != null) {
-        AdditionalInformationReporter(new AdditionalInformation { Token = token, Text = text, Length = length });
-      }
-    }
-
     interface IAmbiguousThing<Thing>
     {
       /// <summary>
@@ -259,13 +183,10 @@ namespace Microsoft.Dafny
     public Resolver(Program prog) {
       Contract.Requires(prog != null);
       builtIns = prog.BuiltIns;
+      reporter = prog.reporter;
       // Populate the members of the basic types
       var trunc = new SpecialField(Token.NoToken, "Trunc", "ToBigInteger()", "", "", false, false, false, Type.Int, null);
       basicTypeMembers[(int)BasicTypeVariety.Real].Add(trunc.Name, trunc);
-
-      if (DafnyOptions.O.PrintTooltips) {
-        AdditionalInformationReporter = DefaultInformationReporter;
-      }
     }
 
     [ContractInvariantMethod]
@@ -276,26 +197,22 @@ namespace Microsoft.Dafny
       Contract.Invariant(cce.NonNullDictionaryAndValues(datatypeCtors) && Contract.ForAll(datatypeCtors.Values, v => cce.NonNullDictionaryAndValues(v)));
     }
 
-    public static void DefaultInformationReporter(AdditionalInformation info) {
-      Dafny.Util.ReportIssue("Info", info.Token, info.Text);
-    }
-
     public void ResolveProgram(Program prog) {
       Contract.Requires(prog != null);
-      var origErrorCount = ErrorCount;
+      var origErrorCount = reporter.Count(ErrorLevel.Error); //FIXME (Clement): This is used further below, but not in the >0 comparisons in the next few lines. Is that right?
       var bindings = new ModuleBindings(null);
       var b = BindModuleNames(prog.DefaultModuleDef, bindings);
       bindings.BindName("_module", prog.DefaultModule, b);
-      if (ErrorCount > 0) { return; } // if there were errors, then the implict ModuleBindings data structure invariant
+      if (reporter.Count(ErrorLevel.Error) > 0) { return; } // if there were errors, then the implict ModuleBindings data structure invariant
       // is violated, so Processing dependencies will not succeed.
       ProcessDependencies(prog.DefaultModule, b, dependencies);
       // check for cycles in the import graph
       List<ModuleDecl> cycle = dependencies.TryFindCycle();
       if (cycle != null) {
         var cy = Util.Comma(" -> ", cycle, m => m.Name);
-        Error(cycle[0], "module definition contains a cycle (note: parent modules implicitly depend on submodules): {0}", cy);
+        reporter.Error(MessageSource.Resolver, cycle[0], "module definition contains a cycle (note: parent modules implicitly depend on submodules): {0}", cy);
       }
-      if (ErrorCount > 0) { return; } // give up on trying to resolve anything else
+      if (reporter.Count(ErrorLevel.Error) > 0) { return; } // give up on trying to resolve anything else
 
       // fill in module heights
       List<ModuleDecl> sortedDecls = dependencies.TopologicallySortedComponents();
@@ -311,16 +228,16 @@ namespace Microsoft.Dafny
       }
 
       var rewriters = new List<IRewriter>();
-      var refinementTransformer = new RefinementTransformer(this, AdditionalInformationReporter, prog);
+      var refinementTransformer = new RefinementTransformer(prog);
       rewriters.Add(refinementTransformer);
-      rewriters.Add(new AutoContractsRewriter());
-      var opaqueRewriter = new OpaqueFunctionRewriter(this);
-      rewriters.Add(new AutoReqFunctionRewriter(this, opaqueRewriter));
+      rewriters.Add(new AutoContractsRewriter(reporter));
+      var opaqueRewriter = new OpaqueFunctionRewriter(this.reporter);
+      rewriters.Add(new AutoReqFunctionRewriter(this.reporter, opaqueRewriter));
       rewriters.Add(opaqueRewriter);
-      rewriters.Add(new TimeLimitRewriter());
+      rewriters.Add(new TimeLimitRewriter(reporter));
 
       if (DafnyOptions.O.AutoTriggers) {
-        rewriters.Add(new TriggersRewriter(this));
+        rewriters.Add(new TriggerGeneratingRewriter(this.reporter));
       }
 
       systemNameInfo = RegisterTopLevelDecls(prog.BuiltIns.SystemModule, false);
@@ -365,7 +282,7 @@ namespace Microsoft.Dafny
           var literalDecl = (LiteralModuleDecl)decl;
           var m = literalDecl.ModuleDef;
 
-          var errorCount = ErrorCount;
+          var errorCount = reporter.Count(ErrorLevel.Error);
           foreach (var r in rewriters) {
             r.PreResolve(m);
           }
@@ -374,19 +291,20 @@ namespace Microsoft.Dafny
           literalDecl.Signature.Refines = refinementTransformer.RefinedSig;
           var sig = literalDecl.Signature;
           // set up environment
-          var preResolveErrorCount = ErrorCount;
+          var preResolveErrorCount = reporter.Count(ErrorLevel.Error);
           ResolveModuleDefinition(m, sig);
           foreach (var r in rewriters) {
-            if (ErrorCount != preResolveErrorCount) {
+            if (reporter.Count(ErrorLevel.Error) != preResolveErrorCount) {
               break;
             }
             r.PostResolve(m);
           }
-          if (ErrorCount == errorCount && !m.IsAbstract) {
+          if (reporter.Count(ErrorLevel.Error) == errorCount && !m.IsAbstract) {
             // compilation should only proceed if everything is good, including the signature (which preResolveErrorCount does not include);
             Contract.Assert(!useCompileSignatures);
             useCompileSignatures = true;  // set Resolver-global flag to indicate that Signatures should be followed to their CompiledSignature
-            var oldWarnings = ReportWarnings(false);  // turn off warning reporting for the clone
+            var oldErrorsOnly = reporter.ErrorsOnly;
+            reporter.ErrorsOnly = true; // turn off warning reporting for the clone
             var nw = new Cloner().CloneModuleDefinition(m, m.CompileName + "_Compile");
             var compileSig = RegisterTopLevelDecls(nw, true);
             compileSig.Refines = refinementTransformer.RefinedSig;
@@ -394,13 +312,13 @@ namespace Microsoft.Dafny
             ResolveModuleDefinition(nw, compileSig);
             prog.CompileModules.Add(nw);
             useCompileSignatures = false;  // reset the flag
-            ReportWarnings(oldWarnings);
+            reporter.ErrorsOnly = oldErrorsOnly;
           }
         } else if (decl is AliasModuleDecl) {
           var alias = (AliasModuleDecl)decl;
           // resolve the path
           ModuleSignature p;
-          if (ResolvePath(alias.Root, alias.Path, out p, this)) {
+          if (ResolvePath(alias.Root, alias.Path, out p, reporter)) {
             alias.Signature = p;
           } else {
             alias.Signature = new ModuleSignature(); // there was an error, give it a valid but empty signature
@@ -408,18 +326,18 @@ namespace Microsoft.Dafny
         } else if (decl is ModuleFacadeDecl) {
           var abs = (ModuleFacadeDecl)decl;
           ModuleSignature p;
-          if (ResolvePath(abs.Root, abs.Path, out p, this)) {
+          if (ResolvePath(abs.Root, abs.Path, out p, reporter)) {
             abs.OriginalSignature = p;
             // ModuleDefinition.ExclusiveRefinement may not be set at this point but ExclusiveRefinementCount will be.
             if (0 == abs.Root.Signature.ModuleDef.ExclusiveRefinementCount) {
               abs.Signature = MakeAbstractSignature(p, abs.FullCompileName, abs.Height, prog.Modules);
               ModuleSignature compileSig;
               if (abs.CompilePath != null) {
-                if (ResolvePath(abs.CompileRoot, abs.CompilePath, out compileSig, this)) {
+                if (ResolvePath(abs.CompileRoot, abs.CompilePath, out compileSig, reporter)) {
                   if (refinementTransformer.CheckIsRefinement(compileSig, p)) {
                     abs.Signature.CompileSignature = compileSig;
                   } else {
-                    Error(
+                    reporter.Error(MessageSource.Resolver,
                       abs.CompilePath[0],
                       "module " + Util.Comma(".", abs.CompilePath, x => x.val) + " must be a refinement of "
                       + Util.Comma(".", abs.Path, x => x.val));
@@ -437,7 +355,7 @@ namespace Microsoft.Dafny
         } else { Contract.Assert(false); }
         Contract.Assert(decl.Signature != null);
       }
-      if (ErrorCount != origErrorCount) {
+      if (reporter.Count(ErrorLevel.Error) != origErrorCount) {
         // do nothing else
         return;
       }
@@ -493,7 +411,7 @@ namespace Microsoft.Dafny
       }
       foreach (var module in prog.Modules) {
         foreach (var iter in ModuleDefinition.AllIteratorDecls(module.TopLevelDecls)) {
-          ReportAdditionalInformation(iter.tok, Printer.IteratorClassToString(iter), iter.Name.Length);
+          reporter.Info(MessageSource.Resolver, iter.tok, Printer.IteratorClassToString(iter));
         }
       }
       // fill in other additional information
@@ -514,19 +432,19 @@ namespace Microsoft.Dafny
 
       // Determine, for each function, whether someone tries to adjust its fuel parameter
       foreach (var module in prog.Modules) {
-        CheckForFuelAdjustments(module.tok, module.Attributes, module, this);
+        CheckForFuelAdjustments(module.tok, module.Attributes, module);
         foreach (var clbl in ModuleDefinition.AllItersAndCallables(module.TopLevelDecls)) {
           Statement body = null;
           if (clbl is Method) {
             body = ((Method)clbl).Body;
-            CheckForFuelAdjustments(clbl.Tok,((Method)clbl).Attributes, module, this);
+            CheckForFuelAdjustments(clbl.Tok,((Method)clbl).Attributes, module);
           } else if (clbl is IteratorDecl) {
             body = ((IteratorDecl)clbl).Body;
-            CheckForFuelAdjustments(clbl.Tok, ((IteratorDecl)clbl).Attributes, module, this);
+            CheckForFuelAdjustments(clbl.Tok, ((IteratorDecl)clbl).Attributes, module);
           }
           if (body != null) {
             var c = new FuelAdjustment_Visitor(this);
-            c.Visit(body, new FuelAdjustment_Context(module, this));
+            c.Visit(body, new FuelAdjustment_Context(module));
           }
         }
       }
@@ -572,7 +490,7 @@ namespace Microsoft.Dafny
               }
               // Note, in the following line, we use the location information for "clbl", not "m".  These
               // are the same, except in the case where "clbl" is a CoLemma and "m" is a prefix lemma.
-              ReportAdditionalInformation(clbl.Tok, s, clbl.Tok.val.Length);
+              reporter.Info(MessageSource.Resolver, clbl.Tok, s);
             }
           }
         }
@@ -595,7 +513,7 @@ namespace Microsoft.Dafny
       var decr = clbl.Decreases.Expressions;
       if (DafnyOptions.O.Dafnycc) {
         if (decr.Count > 1) {
-          Error(decr[1].tok, "In dafnycc mode, only one decreases expression is allowed");
+          reporter.Error(MessageSource.Resolver, decr[1].tok, "In dafnycc mode, only one decreases expression is allowed");
         }
         // In dafnycc mode, only consider first argument
         if (decr.Count == 0 && clbl.Ins.Count > 0) {
@@ -757,11 +675,11 @@ namespace Microsoft.Dafny
       // resolve
       var datatypeDependencies = new Graph<IndDatatypeDecl>();
       var codatatypeDependencies = new Graph<CoDatatypeDecl>();
-      int prevErrorCount = ErrorCount;
+      int prevErrorCount = reporter.Count(ErrorLevel.Error);
       ResolveTopLevelDecls_Signatures(m, m.TopLevelDecls, datatypeDependencies, codatatypeDependencies);
       ResolveAttributes(m.Attributes, new ResolveOpts(new NoContext(m.Module), false)); // Must follow ResolveTopLevelDecls_Signatures, in case attributes refer to members
-      if (ErrorCount == prevErrorCount) {
-        ResolveTopLevelDecls_Meat(m.TopLevelDecls, datatypeDependencies, codatatypeDependencies);
+      if (reporter.Count(ErrorLevel.Error) == prevErrorCount) {
+        ResolveTopLevelDecls_Core(m.TopLevelDecls, datatypeDependencies, codatatypeDependencies);
       }
     }
 
@@ -819,17 +737,17 @@ namespace Microsoft.Dafny
           var subdecl = (LiteralModuleDecl)tld;
           var subBindings = BindModuleNames(subdecl.ModuleDef, bindings);
           if (!bindings.BindName(subdecl.Name, subdecl, subBindings)) {
-            Error(subdecl.tok, "Duplicate module name: {0}", subdecl.Name);
+            reporter.Error(MessageSource.Resolver, subdecl.tok, "Duplicate module name: {0}", subdecl.Name);
           }
         } else if (tld is ModuleFacadeDecl) {
           var subdecl = (ModuleFacadeDecl)tld;
           if (!bindings.BindName(subdecl.Name, subdecl, null)) {
-            Error(subdecl.tok, "Duplicate module name: {0}", subdecl.Name);
+            reporter.Error(MessageSource.Resolver, subdecl.tok, "Duplicate module name: {0}", subdecl.Name);
           }
         } else if (tld is AliasModuleDecl) {
           var subdecl = (AliasModuleDecl)tld;
           if (!bindings.BindName(subdecl.Name, subdecl, null)) {
-            Error(subdecl.tok, "Duplicate module name: {0}", subdecl.Name);
+            reporter.Error(MessageSource.Resolver, subdecl.tok, "Duplicate module name: {0}", subdecl.Name);
           }
         }
       }
@@ -840,9 +758,9 @@ namespace Microsoft.Dafny
       if (m.RefinementBaseName != null) {
         ModuleDecl other;
         if (!bindings.TryLookup(m.RefinementBaseName[0], out other)) {
-          Error(m.RefinementBaseName[0], "module {0} named as refinement base does not exist", m.RefinementBaseName[0].val);
+          reporter.Error(MessageSource.Resolver, m.RefinementBaseName[0], "module {0} named as refinement base does not exist", m.RefinementBaseName[0].val);
         } else if (other is LiteralModuleDecl && ((LiteralModuleDecl)other).ModuleDef == m) {
-          Error(m.RefinementBaseName[0], "module cannot refine itself: {0}", m.RefinementBaseName[0].val);
+          reporter.Error(MessageSource.Resolver, m.RefinementBaseName[0], "module cannot refine itself: {0}", m.RefinementBaseName[0].val);
         } else {
           Contract.Assert(other != null);  // follows from postcondition of TryGetValue
           dependencies.AddEdge(decl, other);
@@ -866,7 +784,7 @@ namespace Microsoft.Dafny
         var alias = moduleDecl as AliasModuleDecl;
         ModuleDecl root;
         if (!bindings.TryLookupIgnore(alias.Path[0], out root, alias))
-          Error(alias.tok, ModuleNotFoundErrorMessage(0, alias.Path));
+          reporter.Error(MessageSource.Resolver, alias.tok, ModuleNotFoundErrorMessage(0, alias.Path));
         else {
           dependencies.AddEdge(moduleDecl, root);
           alias.Root = root;
@@ -875,14 +793,14 @@ namespace Microsoft.Dafny
         var abs = moduleDecl as ModuleFacadeDecl;
         ModuleDecl root;
         if (!bindings.TryLookup(abs.Path[0], out root))
-          Error(abs.tok, ModuleNotFoundErrorMessage(0, abs.Path));
+          reporter.Error(MessageSource.Resolver, abs.tok, ModuleNotFoundErrorMessage(0, abs.Path));
         else {
           dependencies.AddEdge(moduleDecl, root);
           abs.Root = root;
         }
         if (abs.CompilePath != null) {
           if (!bindings.TryLookup(abs.CompilePath[0], out root))
-            Error(abs.tok, ModuleNotFoundErrorMessage(0, abs.CompilePath));
+            reporter.Error(MessageSource.Resolver, abs.tok, ModuleNotFoundErrorMessage(0, abs.CompilePath));
           else {
             dependencies.AddEdge(moduleDecl, root);
             abs.CompileRoot = root;
@@ -990,7 +908,7 @@ namespace Microsoft.Dafny
         Contract.Assert(d != null);
         // register the class/datatype/module name
         if (toplevels.ContainsKey(d.Name)) {
-          Error(d, "Duplicate name of top-level declaration: {0}", d.Name);
+          reporter.Error(MessageSource.Resolver, d, "Duplicate name of top-level declaration: {0}", d.Name);
         } else {
           toplevels[d.Name] = d;
           sig.TopLevels[d.Name] = d;
@@ -1014,7 +932,7 @@ namespace Microsoft.Dafny
           // First, register the iterator's in- and out-parameters as readonly fields
           foreach (var p in iter.Ins) {
             if (members.ContainsKey(p.Name)) {
-              Error(p, "Name of in-parameter is used by another member of the iterator: {0}", p.Name);
+              reporter.Error(MessageSource.Resolver, p, "Name of in-parameter is used by another member of the iterator: {0}", p.Name);
             } else {
               var field = new SpecialField(p.tok, p.Name, p.CompileName, "", "", p.IsGhost, false, false, p.Type, null);
               field.EnclosingClass = iter;  // resolve here
@@ -1024,7 +942,7 @@ namespace Microsoft.Dafny
           }
           foreach (var p in iter.Outs) {
             if (members.ContainsKey(p.Name)) {
-              Error(p, "Name of yield-parameter is used by another member of the iterator: {0}", p.Name);
+              reporter.Error(MessageSource.Resolver, p, "Name of yield-parameter is used by another member of the iterator: {0}", p.Name);
             } else {
               var field = new SpecialField(p.tok, p.Name, p.CompileName, "", "", p.IsGhost, true, true, p.Type, null);
               field.EnclosingClass = iter;  // resolve here
@@ -1036,7 +954,7 @@ namespace Microsoft.Dafny
           foreach (var p in iter.Outs) {
             var nm = p.Name + "s";
             if (members.ContainsKey(nm)) {
-              Error(p.tok, "Name of implicit yield-history variable '{0}' is already used by another member of the iterator", p.Name);
+              reporter.Error(MessageSource.Resolver, p.tok, "Name of implicit yield-history variable '{0}' is already used by another member of the iterator", p.Name);
             } else {
               var tp = new SeqType(p.Type.IsSubrangeType ? new IntType() : p.Type);
               var field = new SpecialField(p.tok, nm, nm, "", "", true, true, false, tp, null);
@@ -1108,7 +1026,7 @@ namespace Microsoft.Dafny
           iter.Member_MoveNext = moveNext;
           MemberDecl member;
           if (members.TryGetValue(init.Name, out member)) {
-            Error(member.tok, "member name '{0}' is already predefined for this iterator", init.Name);
+            reporter.Error(MessageSource.Resolver, member.tok, "member name '{0}' is already predefined for this iterator", init.Name);
           } else {
             members.Add(init.Name, init);
             iter.Members.Add(init);
@@ -1116,13 +1034,13 @@ namespace Microsoft.Dafny
           // If the name of the iterator is "Valid" or "MoveNext", one of the following will produce an error message.  That
           // error message may not be as clear as it could be, but the situation also seems unlikely to ever occur in practice.
           if (members.TryGetValue("Valid", out member)) {
-            Error(member.tok, "member name 'Valid' is already predefined for iterators");
+            reporter.Error(MessageSource.Resolver, member.tok, "member name 'Valid' is already predefined for iterators");
           } else {
             members.Add(valid.Name, valid);
             iter.Members.Add(valid);
           }
           if (members.TryGetValue("MoveNext", out member)) {
-            Error(member.tok, "member name 'MoveNext' is already predefined for iterators");
+            reporter.Error(MessageSource.Resolver, member.tok, "member name 'MoveNext' is already predefined for iterators");
           } else {
             members.Add(moveNext.Name, moveNext);
             iter.Members.Add(moveNext);
@@ -1140,7 +1058,7 @@ namespace Microsoft.Dafny
               members.Add(m.Name, m);
               if (m is Constructor) {
                 if (cl is TraitDecl) {
-                  Error(m.tok, "a trait is not allowed to declare a constructor");
+                  reporter.Error(MessageSource.Resolver, m.tok, "a trait is not allowed to declare a constructor");
                 } else {
                   cl.HasConstructor = true;
                 }
@@ -1196,9 +1114,9 @@ namespace Microsoft.Dafny
                 members.Add(extraName, extraMember);
               }
             } else if (m is Constructor && !((Constructor)m).HasName) {
-              Error(m, "More than one anonymous constructor");
+              reporter.Error(MessageSource.Resolver, m, "More than one anonymous constructor");
             } else {
-              Error(m, "Duplicate member name: {0}", m.Name);
+              reporter.Error(MessageSource.Resolver, m, "Duplicate member name: {0}", m.Name);
             }
           }
           if (cl.IsDefaultClass) {
@@ -1222,9 +1140,9 @@ namespace Microsoft.Dafny
 
           foreach (DatatypeCtor ctor in dt.Ctors) {
             if (ctor.Name.EndsWith("?")) {
-              Error(ctor, "a datatype constructor name is not allowed to end with '?'");
+              reporter.Error(MessageSource.Resolver, ctor, "a datatype constructor name is not allowed to end with '?'");
             } else if (ctors.ContainsKey(ctor.Name)) {
-              Error(ctor, "Duplicate datatype constructor name: {0}", ctor.Name);
+              reporter.Error(MessageSource.Resolver, ctor, "Duplicate datatype constructor name: {0}", ctor.Name);
             } else {
               ctors.Add(ctor.Name, ctor);
 
@@ -1251,7 +1169,7 @@ namespace Microsoft.Dafny
             foreach (var formal in ctor.Formals) {
               bool nameError = false;
               if (formal.HasName && members.ContainsKey(formal.Name)) {
-                Error(ctor, "Name of deconstructor is used by another member of the datatype: {0}", formal.Name);
+                reporter.Error(MessageSource.Resolver, ctor, "Name of deconstructor is used by another member of the datatype: {0}", formal.Name);
                 nameError = true;
               }
               var dtor = new DatatypeDestructor(formal.tok, ctor, formal, formal.Name, "dtor_" + formal.CompileName, "", "", formal.IsGhost, formal.Type, null);
@@ -1301,8 +1219,7 @@ namespace Microsoft.Dafny
     }
 
 
-    public static bool ResolvePath(ModuleDecl root, List<IToken> Path, out ModuleSignature p, ResolutionErrorReporter reporter) {
-      Contract.Requires(reporter != null);
+    public static bool ResolvePath(ModuleDecl root, List<IToken> Path, out ModuleSignature p, ErrorReporter reporter) {
       p = root.Signature;
       int i = 1;
       while (i < Path.Count) {
@@ -1311,7 +1228,7 @@ namespace Microsoft.Dafny
           p = pp;
           i++;
         } else {
-          reporter.Error(Path[i], ModuleNotFoundErrorMessage(i, Path));
+          reporter.Error(MessageSource.Resolver, Path[i], ModuleNotFoundErrorMessage(i, Path));
           break;
         }
       }
@@ -1366,7 +1283,7 @@ namespace Microsoft.Dafny
               {
                 if (!(def.IsDefaultModule)) // _module is allowed to contain abstract modules, but not be abstract itself. Note this presents a challenge to
                                             // trusted verification, as toplevels can't be trusted if they invoke abstract module members.
-                Error(d.tok, "an abstract module can only be imported into other abstract modules, not a concrete one.");
+                  reporter.Error(MessageSource.Resolver, d.tok, "an abstract module can only be imported into other abstract modules, not a concrete one.");
               } else {
                 // physical modules are allowed everywhere
               }
@@ -1392,7 +1309,7 @@ namespace Microsoft.Dafny
       if (cycle != null) {
         Contract.Assert(cycle.Count != 0);
         var erste = cycle[0];
-        Error(erste.Tok, "Cycle among redirecting types (newtypes, type synonyms): {0} -> {1}", Util.Comma(" -> ", cycle, syn => syn.Name), erste.Name);
+        reporter.Error(MessageSource.Resolver, erste.Tok, "Cycle among redirecting types (newtypes, type synonyms): {0} -> {1}", Util.Comma(" -> ", cycle, syn => syn.Name), erste.Name);
       }
     }
 
@@ -1416,14 +1333,14 @@ namespace Microsoft.Dafny
       new NativeType("long", Int64.MinValue, 0x8000000000000000, "L", false),
     };
 
-    public void ResolveTopLevelDecls_Meat(List<TopLevelDecl/*!*/>/*!*/ declarations, Graph<IndDatatypeDecl/*!*/>/*!*/ datatypeDependencies, Graph<CoDatatypeDecl/*!*/>/*!*/ codatatypeDependencies) {
+    public void ResolveTopLevelDecls_Core(List<TopLevelDecl/*!*/>/*!*/ declarations, Graph<IndDatatypeDecl/*!*/>/*!*/ datatypeDependencies, Graph<CoDatatypeDecl/*!*/>/*!*/ codatatypeDependencies) {
       Contract.Requires(declarations != null);
       Contract.Requires(cce.NonNullElements(datatypeDependencies));
       Contract.Requires(cce.NonNullElements(codatatypeDependencies));
       Contract.Requires(NFBC_Count == 0);
       Contract.Ensures(NFBC_Count == 0);
 
-      int prevErrorCount = ErrorCount;
+      int prevErrorCount = reporter.Count(ErrorLevel.Error);
 
       // Resolve the meat of classes and iterators, the definitions of type synonyms, and the type parameters of all top-level type declarations
       // First, resolve the newtype declarations and the constraint clauses, including filling in .ResolvedOp fields.  This is needed for the
@@ -1438,7 +1355,7 @@ namespace Microsoft.Dafny
           ResolveAttributes(d.Attributes, new ResolveOpts(new NoContext(d.Module), false));
           // this check can be done only after it has been determined that the redirected types do not involve cycles
           if (!dd.BaseType.IsNumericBased()) {
-            Error(dd.tok, "newtypes must be based on some numeric type (got {0})", dd.BaseType);
+            reporter.Error(MessageSource.Resolver, dd.tok, "newtypes must be based on some numeric type (got {0})", dd.BaseType);
           }
           // type check the constraint, if any
           if (dd.Var != null) {
@@ -1451,10 +1368,10 @@ namespace Microsoft.Dafny
             ResolveExpression(dd.Constraint, new ResolveOpts(dd, false, true));
             Contract.Assert(dd.Constraint.Type != null);  // follows from postcondition of ResolveExpression
             if (!UnifyTypes(dd.Constraint.Type, Type.Bool)) {
-              Error(dd.Constraint, "newtype constraint must be of type bool (instead got {0})", dd.Constraint.Type);
+              reporter.Error(MessageSource.Resolver, dd.Constraint, "newtype constraint must be of type bool (instead got {0})", dd.Constraint.Type);
             }
             if (!CheckTypeInference_Visitor.IsDetermined(dd.BaseType.NormalizeExpand())) {
-              Error(dd.tok, "newtype's base type is not fully determined; add an explicit type for '{0}'", dd.Var.Name);
+              reporter.Error(MessageSource.Resolver, dd.tok, "newtype's base type is not fully determined; add an explicit type for '{0}'", dd.Var.Name);
             }
             CheckTypeInference(dd.Constraint);
             scope.PopMarker();
@@ -1464,7 +1381,7 @@ namespace Microsoft.Dafny
       // Now, we're ready for the other declarations.
       foreach (TopLevelDecl d in declarations) {
         if (d is TraitDecl && d.TypeArgs.Count > 0) {
-          Error(d, "sorry, traits with type parameters are not supported");
+          reporter.Error(MessageSource.Resolver, d, "sorry, traits with type parameters are not supported");
         }
         allTypeParameters.PushMarker();
         ResolveTypeParameters(d.TypeArgs, false, d);
@@ -1483,15 +1400,15 @@ namespace Microsoft.Dafny
         allTypeParameters.PopMarker();
       }
 
-      if (ErrorCount == prevErrorCount) {
+      if (reporter.Count(ErrorLevel.Error) == prevErrorCount) {
         foreach (var e in needFiniteBoundsChecks_SetComprehension) {
           var missingBounds = new List<BoundVar>();
           CheckTypeInference(e.Range);  // we need to resolve operators before the call to DiscoverBounds
-          e.Bounds = DiscoverBounds(e.tok, e.BoundVars, e.Range, true, false, missingBounds);
+          e.Bounds = DiscoverBounds(e.tok, e.BoundVars, e.Range, true, false, missingBounds, reporter);
           if (missingBounds.Count != 0) {
             e.MissingBounds = missingBounds;
             foreach (var bv in e.MissingBounds) {
-              Error(e, "a set comprehension must produce a finite set, but Dafny's heuristics can't figure out how to produce a bounded set of values for '{0}'", bv.Name);
+              reporter.Error(MessageSource.Resolver, e, "a set comprehension must produce a finite set, but Dafny's heuristics can't figure out how to produce a bounded set of values for '{0}'", bv.Name);
             }
           }
         }
@@ -1501,11 +1418,11 @@ namespace Microsoft.Dafny
           var constraint = e.RHSs[0];
           var missingBounds = new List<IVariable>();
           CheckTypeInference(constraint);  // we need to resolve operators before the call to DiscoverBounds
-          var allBounds = DiscoverBoundsAux(e.tok, new List<IVariable>(e.BoundVars), constraint, true, true, true, missingBounds);
+          var allBounds = DiscoverBoundsAux(e.tok, new List<IVariable>(e.BoundVars), constraint, true, true, true, missingBounds, reporter);
           if (missingBounds.Count != 0) {
             e.Constraint_MissingBounds = missingBounds;
             foreach (var bv in e.Constraint_MissingBounds) {
-              Error(e, "a non-ghost let-such-that constraint must be compilable, but Dafny's heuristics can't figure out how to produce a bounded set of values for '{0}'", bv.Name);
+              reporter.Error(MessageSource.Resolver, e, "a non-ghost let-such-that constraint must be compilable, but Dafny's heuristics can't figure out how to produce a bounded set of values for '{0}'", bv.Name);
             }
           } else {
             e.Constraint_Bounds = new List<ComprehensionExpr.BoundedPool>();
@@ -1525,7 +1442,7 @@ namespace Microsoft.Dafny
         nativeTypeMap.Add(nativeType.Name, nativeType);
       }
 
-      if (ErrorCount == prevErrorCount) {
+      if (reporter.Count(ErrorLevel.Error) == prevErrorCount) {
         // Check that type inference went well everywhere; this will also fill in the .ResolvedOp field in binary expressions
         foreach (TopLevelDecl d in declarations) {
           if (d is IteratorDecl) {
@@ -1547,7 +1464,7 @@ namespace Microsoft.Dafny
                 Attributes.MatchingValueOption.Empty,
                 Attributes.MatchingValueOption.Bool,
                 Attributes.MatchingValueOption.String },
-              err => Error(dd, err));
+              err => reporter.Error(MessageSource.Resolver, dd, err));
             if (hasNativeTypeAttr) {
               if (nativeTypeAttr is bool) {
                 boolNativeType = (bool)nativeTypeAttr;
@@ -1556,16 +1473,16 @@ namespace Microsoft.Dafny
                 if (nativeTypeMap.ContainsKey(keyString)) {
                   stringNativeType = nativeTypeMap[keyString];
                 } else {
-                  Error(dd, "Unsupported nativeType {0}", keyString);
+                  reporter.Error(MessageSource.Resolver, dd, "Unsupported nativeType {0}", keyString);
                 }
               }
             }
             if (stringNativeType != null || boolNativeType == true) {
               if (!dd.BaseType.IsNumericBased(Type.NumericPersuation.Int)) {
-                Error(dd, "nativeType can only be used on integral types");
+                reporter.Error(MessageSource.Resolver, dd, "nativeType can only be used on integral types");
               }
               if (dd.Var == null) {
-                Error(dd, "nativeType can only be used if newtype specifies a constraint");
+                reporter.Error(MessageSource.Resolver, dd, "nativeType can only be used if newtype specifies a constraint");
               }
             }
             if (dd.Var != null) {
@@ -1588,7 +1505,7 @@ namespace Microsoft.Dafny
               };
               var missingBounds = new List<BoundVar>();
               var bounds = DiscoverBounds(dd.Constraint.tok, new List<BoundVar> { dd.Var }, dd.Constraint,
-                true, true, missingBounds);
+                true, true, missingBounds, reporter);
               List<NativeType> potentialNativeTypes =
                 (stringNativeType != null) ? new List<NativeType> { stringNativeType } :
                 (boolNativeType == false) ? new List<NativeType>() :
@@ -1621,18 +1538,18 @@ namespace Microsoft.Dafny
                 }
               }
               if (dd.NativeType == null && (boolNativeType == true || stringNativeType != null)) {
-                Error(dd, "Dafny's heuristics cannot find a compatible native type.  " +
+                reporter.Error(MessageSource.Resolver, dd, "Dafny's heuristics cannot find a compatible native type.  " +
                   "Hint: try writing a newtype constraint of the form 'i:int | lowerBound <= i < upperBound && (...any additional constraints...)'");
               }
               if (dd.NativeType != null && stringNativeType == null) {
-                ReportAdditionalInformation(dd.tok, "{:nativeType \"" + dd.NativeType.Name + "\"}", dd.tok.val.Length);
+                reporter.Info(MessageSource.Resolver, dd.tok, "{:nativeType \"" + dd.NativeType.Name + "\"}");
               }
             }
           }
         }
       }
 
-      if (ErrorCount == prevErrorCount) {
+      if (reporter.Count(ErrorLevel.Error) == prevErrorCount) {
         // fill in the postconditions and bodies of prefix lemmas
         foreach (var com in ModuleDefinition.AllFixpointLemmas(declarations)) {
           var prefixLemma = com.PrefixLemma;
@@ -1646,7 +1563,7 @@ namespace Microsoft.Dafny
             foreach (var p in com.Ens) {
               var coConclusions = new HashSet<Expression>();
               CollectFriendlyCallsInFixpointLemmaSpecification(p.E, true, coConclusions, true);
-              var subst = new FixpointLemmaSpecificationSubstituter(coConclusions, new IdentifierExpr(k.tok, k.Name), this, true);
+              var subst = new FixpointLemmaSpecificationSubstituter(coConclusions, new IdentifierExpr(k.tok, k.Name), this.reporter, true);
               var post = subst.CloneExpr(p.E);
               prefixLemma.Ens.Add(new MaybeFreeExpression(post, p.IsFree));
             }
@@ -1656,7 +1573,7 @@ namespace Microsoft.Dafny
             foreach (var p in com.Req) {
               var antecedents = new HashSet<Expression>();
               CollectFriendlyCallsInFixpointLemmaSpecification(p.E, true, antecedents, false);
-              var subst = new FixpointLemmaSpecificationSubstituter(antecedents, new IdentifierExpr(k.tok, k.Name), this, false);
+              var subst = new FixpointLemmaSpecificationSubstituter(antecedents, new IdentifierExpr(k.tok, k.Name), this.reporter, false);
               var pre = subst.CloneExpr(p.E);
               prefixLemma.Req.Add(new MaybeFreeExpression(pre, p.IsFree));
             }
@@ -1665,7 +1582,7 @@ namespace Microsoft.Dafny
           Contract.Assume(prefixLemma.Body == null);  // this is not supposed to have been filled in before
           if (com.Body != null) {
             var kMinusOne = new BinaryExpr(com.tok, BinaryExpr.Opcode.Sub, new IdentifierExpr(k.tok, k.Name), new LiteralExpr(com.tok, 1));
-            var subst = new FixpointLemmaBodyCloner(com, kMinusOne, this);
+            var subst = new FixpointLemmaBodyCloner(com, kMinusOne, this.reporter);
             var mainBody = subst.CloneBlockStmt(com.Body);
             var kPositive = new BinaryExpr(com.tok, BinaryExpr.Opcode.Lt, new LiteralExpr(com.tok, 0), new IdentifierExpr(k.tok, k.Name));
             var condBody = new IfStmt(com.BodyStartTok, mainBody.EndTok, kPositive, mainBody, null);
@@ -1699,7 +1616,7 @@ namespace Microsoft.Dafny
         }
       }
 
-      if (ErrorCount == prevErrorCount) {  // because CheckCoCalls requires the given expression to have been successfully resolved
+      if (reporter.Count(ErrorLevel.Error) == prevErrorCount) {  // because CheckCoCalls requires the given expression to have been successfully resolved
         // Perform the guardedness check on co-datatypes
         foreach (var repr in ModuleDefinition.AllFunctionSCCs(declarations)) {
           var module = repr.EnclosingModule;
@@ -1734,7 +1651,7 @@ namespace Microsoft.Dafny
               foreach (var c in coCandidates) {
                 c.CandidateCall.CoCall = FunctionCallExpr.CoCallResolution.Yes;
                 c.EnclosingCoConstructor.IsCoCall = true;
-                ReportAdditionalInformation(c.CandidateCall.tok, "co-recursive call", c.CandidateCall.Name.Length);
+                reporter.Info(MessageSource.Resolver, c.CandidateCall.tok, "co-recursive call");
               }
               // Finally, fill in the CoClusterTarget field
               // Start by setting all the CoClusterTarget fields to CoRecursiveTargetAllTheWay.
@@ -1929,11 +1846,11 @@ namespace Microsoft.Dafny
                 // Check here for the presence of any 'ensures' clauses, which are not allowed (because we're not sure
                 // of their soundness)
                 if (fn.Ens.Count != 0) {
-                  Error(fn.Ens[0].tok, "a {0} is not allowed to declare any ensures clause", member.WhatKind);
+                  reporter.Error(MessageSource.Resolver, fn.Ens[0].tok, "a {0} is not allowed to declare any ensures clause", member.WhatKind);
                 }
                 // Also check for 'reads' clauses
                 if (fn.Reads.Count != 0) {
-                  Error(fn.Reads[0].tok, "a {0} is not allowed to declare any reads clause", member.WhatKind);  // (why?)
+                  reporter.Error(MessageSource.Resolver, fn.Reads[0].tok, "a {0} is not allowed to declare any reads clause", member.WhatKind);  // (why?)
                 }
                 if (fn.Body != null) {
                   FixpointPredicateChecks(fn.Body, fn, CallingPosition.Positive);
@@ -1949,7 +1866,7 @@ namespace Microsoft.Dafny
             var dd = (NewtypeDecl)d;
             if (dd.Module.CallGraph.GetSCCSize(dd) != 1) {
               var cycle = Util.Comma(" -> ", dd.Module.CallGraph.GetSCC(dd), clbl => clbl.NameRelativeToModule);
-              Error(dd.tok, "recursive dependency involving a newtype: " + cycle);
+              reporter.Error(MessageSource.Resolver, dd.tok, "recursive dependency involving a newtype: " + cycle);
             }
           }
         }
@@ -1967,45 +1884,14 @@ namespace Microsoft.Dafny
         Contract.Requires(resolver != null);
         this.resolver = resolver;
       }
-      public void Error(IToken tok, string msg, params object[] args) {
-        Contract.Requires(tok != null);
-        Contract.Requires(msg != null);
-        Contract.Requires(args != null);
-        resolver.Error(tok, msg, args);
-      }
-      public void Error(Expression expr, string msg, params object[] args) {
-        Contract.Requires(expr != null);
-        Contract.Requires(msg != null);
-        Contract.Requires(args != null);
-        Error(expr.tok, msg, args);
-      }
     }
     abstract class ResolverTopDownVisitor<T> : TopDownVisitor<T>
     {
-      Resolver resolver;
+      protected Resolver resolver;
       public ResolverTopDownVisitor(Resolver resolver) {
         Contract.Requires(resolver != null);
         this.resolver = resolver;
       }
-      protected void Error(IToken tok, string msg, params object[] args)
-      {
-        Contract.Requires(tok != null);
-        Contract.Requires(msg != null);
-        Contract.Requires(args != null);
-        resolver.Error(tok, msg, args);
-      }
-      protected void Error(Expression expr, string msg, params object[] args)
-      {
-        Contract.Requires(expr != null);
-        Contract.Requires(msg != null);
-        Contract.Requires(args != null);
-        Error(expr.tok, msg, args);
-      }
-      protected void ReportAdditionalInformation(IToken tok, string text, int length)
-      {
-        Contract.Requires(tok != null);
-        resolver.ReportAdditionalInformation(tok, text, length);
-      }
     }
     #endregion Visitors
 
@@ -2027,12 +1913,12 @@ namespace Microsoft.Dafny
           if (hasTailRecursionPreference && !tail) {
             // the user specifically requested no tail recursion, so do nothing else
           } else if (hasTailRecursionPreference && tail && m.IsGhost) {
-            Error(m.tok, "tail recursion can be specified only for methods that will be compiled, not for ghost methods");
+            reporter.Error(MessageSource.Resolver, m.tok, "tail recursion can be specified only for methods that will be compiled, not for ghost methods");
           } else {
             var module = m.EnclosingClass.Module;
             var sccSize = module.CallGraph.GetSCCSize(m);
             if (hasTailRecursionPreference && 2 <= sccSize) {
-              Error(m.tok, "sorry, tail-call optimizations are not supported for mutually recursive methods");
+              reporter.Error(MessageSource.Resolver, m.tok, "sorry, tail-call optimizations are not supported for mutually recursive methods");
             } else if (hasTailRecursionPreference || sccSize == 1) {
               CallStmt tailCall = null;
               var status = CheckTailRecursive(m.Body.Body, m, ref tailCall, hasTailRecursionPreference);
@@ -2040,7 +1926,7 @@ namespace Microsoft.Dafny
                 m.IsTailRecursive = true;
                 if (tailCall != null) {
                   // this means there was at least one recursive call
-                  ReportAdditionalInformation(m.tok, "tail recursive", m.Name.Length);
+                  reporter.Info(MessageSource.Resolver, m.tok, "tail recursive");
                 }
               }
             }
@@ -2048,7 +1934,7 @@ namespace Microsoft.Dafny
         }
       } else if (member is Function) {
         var f = (Function)member;
-        var errorCount = ErrorCount;
+        var errorCount = reporter.Count(ErrorLevel.Error);
         f.Req.Iter(CheckTypeInference);
         f.Ens.Iter(CheckTypeInference);
         f.Reads.Iter(fe => CheckTypeInference(fe.E));
@@ -2057,10 +1943,10 @@ namespace Microsoft.Dafny
           CheckTypeInference(f.Body);
           bool tail = true;
           if (Attributes.ContainsBool(f.Attributes, "tailrecursion", ref tail) && tail) {
-            Error(f.tok, "sorry, tail-call functions are not supported");
+            reporter.Error(MessageSource.Resolver, f.tok, "sorry, tail-call functions are not supported");
           }
         }
-        if (errorCount == ErrorCount && f is FixpointPredicate) {
+        if (errorCount == reporter.Count(ErrorLevel.Error) && f is FixpointPredicate) {
           var cop = (FixpointPredicate)f;
           CheckTypeInference_Member(cop.PrefixPredicate);
         }
@@ -2120,7 +2006,7 @@ namespace Microsoft.Dafny
           if (e != null) {
             foreach (var bv in e.BoundVars) {
               if (!IsDetermined(bv.Type.Normalize())) {
-                Error(bv.tok, "type of bound variable '{0}' could not be determined; please specify the type explicitly",
+                resolver.reporter.Error(MessageSource.Resolver, bv.tok, "type of bound variable '{0}' could not be determined; please specify the type explicitly",
                   bv.Name);
               }
             }
@@ -2130,7 +2016,7 @@ namespace Microsoft.Dafny
           if (e.Member is Function || e.Member is Method) {
             foreach (var p in e.TypeApplication) {
               if (!IsDetermined(p.Normalize())) {
-                Error(e.tok, "type '{0}' to the {2} '{1}' is not determined", p, e.Member.Name, e.Member.WhatKind);
+                resolver.reporter.Error(MessageSource.Resolver, e.tok, "type '{0}' to the {2} '{1}' is not determined", p, e.Member.Name, e.Member.WhatKind);
               }
             }
           }
@@ -2138,7 +2024,7 @@ namespace Microsoft.Dafny
           var e = (FunctionCallExpr)expr;
           foreach (var p in e.TypeArgumentSubstitutions) {
             if (!IsDetermined(p.Value.Normalize())) {
-              Error(e.tok, "type variable '{0}' in the function call to '{1}' could not be determined{2}", p.Key.Name, e.Name,
+              resolver.reporter.Error(MessageSource.Resolver, e.tok, "type variable '{0}' in the function call to '{1}' could not be determined{2}", p.Key.Name, e.Name,
                 (e.Name.Contains("reveal_") || e.Name.Contains("_FULL")) //CLEMENT should this be StartsWith and EndsWith?
                 ? ". If you are making an opaque function, make sure that the function can be called."
                 : ""
@@ -2150,7 +2036,7 @@ namespace Microsoft.Dafny
           foreach (var p in e.LHSs) {
             foreach (var x in p.Vars) {
               if (!IsDetermined(x.Type.Normalize())) {
-                Error(e.tok, "the type of the bound variable '{0}' could not be determined", x.Name);
+                resolver.reporter.Error(MessageSource.Resolver, e.tok, "the type of the bound variable '{0}' could not be determined", x.Name);
               }
             }
           }
@@ -2218,7 +2104,7 @@ namespace Microsoft.Dafny
           var proxy = (TypeProxy)t;
           if (!UnderspecifiedTypeProxies.Contains(proxy)) {
             // report an error for this TypeProxy only once
-            Error(tok, "the type of this {0} is underspecified", what);
+            resolver.reporter.Error(MessageSource.Resolver, tok, "the type of this {0} is underspecified", what);
             UnderspecifiedTypeProxies.Add(proxy);
           }
           return false;
@@ -2274,7 +2160,7 @@ namespace Microsoft.Dafny
           if (status == TailRecursionStatus.TailCallSpent) {
             // a tail call cannot be followed by non-ghost code
             if (reportErrors) {
-              Error(tailCall.Tok, "this recursive call is not recognized as being tail recursive, because it is followed by non-ghost code");
+              reporter.Error(MessageSource.Resolver, tailCall.Tok, "this recursive call is not recognized as being tail recursive, because it is followed by non-ghost code");
             }
             return TailRecursionStatus.NotTailRecursive;
           }
@@ -2322,7 +2208,7 @@ namespace Microsoft.Dafny
                 // all is good
               } else {
                 if (reportErrors) {
-                  Error(s.Tok, "the recursive call to '{0}' is not tail recursive because the actual out-parameter {1} is not the formal out-parameter '{2}'", s.Method.Name, i, formal.Name);
+                  reporter.Error(MessageSource.Resolver, s.Tok, "the recursive call to '{0}' is not tail recursive because the actual out-parameter {1} is not the formal out-parameter '{2}'", s.Method.Name, i, formal.Name);
                 }
                 return TailRecursionStatus.NotTailRecursive;
               }
@@ -2368,7 +2254,7 @@ namespace Microsoft.Dafny
           if (status == TailRecursionStatus.NotTailRecursive) {
             // an error has already been reported
           } else if (reportErrors) {
-            Error(tailCall.Tok, "a recursive call inside a loop is not recognized as being a tail call");
+            reporter.Error(MessageSource.Resolver, tailCall.Tok, "a recursive call inside a loop is not recognized as being a tail call");
           }
           return TailRecursionStatus.NotTailRecursive;
         }
@@ -2380,7 +2266,7 @@ namespace Microsoft.Dafny
             if (status == TailRecursionStatus.NotTailRecursive) {
               // an error has already been reported
             } else if (reportErrors) {
-              Error(tailCall.Tok, "a recursive call inside a loop is not recognized as being a tail call");
+              reporter.Error(MessageSource.Resolver, tailCall.Tok, "a recursive call inside a loop is not recognized as being a tail call");
             }
             return TailRecursionStatus.NotTailRecursive;
           }
@@ -2395,7 +2281,7 @@ namespace Microsoft.Dafny
           if (status == TailRecursionStatus.NotTailRecursive) {
             // an error has already been reported
           } else if (reportErrors) {
-            Error(tailCall.Tok, "a recursive call inside a forall statement is not a tail call");
+            reporter.Error(MessageSource.Resolver, tailCall.Tok, "a recursive call inside a forall statement is not a tail call");
           }
           return TailRecursionStatus.NotTailRecursive;
         }
@@ -2432,7 +2318,7 @@ namespace Microsoft.Dafny
     // ------------------------------------------------------------------------------------------------------
     #region FuelAdjustmentChecks
 
-    protected static void CheckForFuelAdjustments(IToken tok, Attributes attrs, ModuleDefinition currentModule, ResolutionErrorReporter reporter) {
+    protected void CheckForFuelAdjustments(IToken tok, Attributes attrs, ModuleDefinition currentModule) {
       List<List<Expression>> results = Attributes.FindAllExpressions(attrs, "fuel");
 
       if (results != null) {
@@ -2445,7 +2331,7 @@ namespace Microsoft.Dafny
               if (f != null) {
                 f.IsFueled = true;
                 if (f.IsProtected && currentModule != f.EnclosingClass.Module) {
-                  reporter.Error(tok, "cannot adjust fuel for protected function {0} from another module", f.Name);
+                  reporter.Error(MessageSource.Resolver, tok, "cannot adjust fuel for protected function {0} from another module", f.Name);
                 }
               }
             }
@@ -2457,10 +2343,8 @@ namespace Microsoft.Dafny
     public class FuelAdjustment_Context
     {
       public ModuleDefinition currentModule;
-      public ResolutionErrorReporter reporter;
-      public FuelAdjustment_Context(ModuleDefinition currentModule, ResolutionErrorReporter reporter) {
+      public FuelAdjustment_Context(ModuleDefinition currentModule) {
         this.currentModule = currentModule;
-        this.reporter = reporter;
       }
     }
 
@@ -2472,7 +2356,7 @@ namespace Microsoft.Dafny
       }
 
       protected override bool VisitOneStmt(Statement stmt, ref FuelAdjustment_Context st) {
-        Resolver.CheckForFuelAdjustments(stmt.Tok, stmt.Attributes, st.currentModule, st.reporter);
+        resolver.CheckForFuelAdjustments(stmt.Tok, stmt.Attributes, st.currentModule);
         return true;
       }
     }
@@ -2594,7 +2478,7 @@ namespace Microsoft.Dafny
             var article = context is InductivePredicate ? "an" : "a";
             // we're looking at a recursive call
             if (!(context is InductivePredicate ? e.Function is InductivePredicate : e.Function is CoPredicate)) {
-              Error(e, "a recursive call from {0} {1} can go only to other {1}s", article, context.WhatKind);
+              resolver.reporter.Error(MessageSource.Resolver, e, "a recursive call from {0} {1} can go only to other {1}s", article, context.WhatKind);
             } else if (cp != CallingPosition.Positive) {
               var msg = string.Format("{0} {1} can be called recursively only in positive positions", article, context.WhatKind);
               if (cp == CallingPosition.Neither) {
@@ -2603,10 +2487,10 @@ namespace Microsoft.Dafny
               } else {
                 // the fixpoint-call is not inside an quantifier, so don't bother mentioning the part of existentials/universals in the error message
               }
-              Error(e, msg);
+              resolver.reporter.Error(MessageSource.Resolver, e, msg);
             } else {
               e.CoCall = FunctionCallExpr.CoCallResolution.Yes;
-              ReportAdditionalInformation(e.tok, e.Function.Name + "#[_k - 1]", e.Function.Name.Length);
+              resolver.reporter.Info(MessageSource.Resolver, e.tok, e.Function.Name + "#[_k - 1]");
             }
           }
           // do the sub-parts with cp := Neither
@@ -2621,7 +2505,7 @@ namespace Microsoft.Dafny
           if (ModuleDefinition.InSameSCC(context, s.Method)) {
             // we're looking at a recursive call
             var article = context is InductivePredicate ? "an" : "a";
-            Error(stmt.Tok, "a recursive call from {0} {1} can go only to other {1}s", article, context.WhatKind);
+            resolver.reporter.Error(MessageSource.Resolver, stmt.Tok, "a recursive call from {0} {1} can go only to other {1}s", article, context.WhatKind);
           }
           // do the sub-parts with the same "cp"
           return true;
@@ -2662,7 +2546,7 @@ namespace Microsoft.Dafny
             if (ModuleDefinition.InSameSCC(context, s.Method)) {
               // we're looking at a recursive call (to a non-fixpoint-lemma)
               var article = context is InductiveLemma ? "an" : "a";
-              Error(s.Tok, "a recursive call from {0} {1} can go only to other {1}s and prefix lemmas", article, context.WhatKind);
+              resolver.reporter.Error(MessageSource.Resolver, s.Tok, "a recursive call from {0} {1} can go only to other {1}s and prefix lemmas", article, context.WhatKind);
             }
           }
         }
@@ -2674,7 +2558,7 @@ namespace Microsoft.Dafny
           // the call goes from a colemma context to a non-colemma callee
           if (ModuleDefinition.InSameSCC(context, e.Function)) {
             // we're looking at a recursive call (to a non-colemma)
-            Error(e.tok, "a recursive call from a colemma can go only to other colemmas and prefix lemmas");
+            resolver.reporter.Error(MessageSource.Resolver, e.tok, "a recursive call from a colemma can go only to other colemmas and prefix lemmas");
           }
         }
       }
@@ -2733,7 +2617,7 @@ namespace Microsoft.Dafny
           foreach (var formalTypeArg in s.Method.TypeArgs) {
             var actualTypeArg = s.MethodSelect.TypeArgumentSubstitutions()[formalTypeArg];
             if (formalTypeArg.MustSupportEquality && !actualTypeArg.SupportsEquality) {
-              Error(s.Tok, "type parameter {0} ({1}) passed to method {2} must support equality (got {3}){4}", i, formalTypeArg.Name, s.Method.Name, actualTypeArg, TypeEqualityErrorMessageHint(actualTypeArg));
+              resolver.reporter.Error(MessageSource.Resolver, s.Tok, "type parameter {0} ({1}) passed to method {2} must support equality (got {3}){4}", i, formalTypeArg.Name, s.Method.Name, actualTypeArg, TypeEqualityErrorMessageHint(actualTypeArg));
             }
             i++;
           }
@@ -2788,9 +2672,9 @@ namespace Microsoft.Dafny
               } else if (e1 != null && e1.Arguments.Count == 0) {
                 // oh yeah!
               } else if (!t0.SupportsEquality) {
-                Error(e.E0, "{0} can only be applied to expressions of types that support equality (got {1}){2}", BinaryExpr.OpcodeString(e.Op), t0, TypeEqualityErrorMessageHint(t0));
+                resolver.reporter.Error(MessageSource.Resolver, e.E0, "{0} can only be applied to expressions of types that support equality (got {1}){2}", BinaryExpr.OpcodeString(e.Op), t0, TypeEqualityErrorMessageHint(t0));
               } else if (!t1.SupportsEquality) {
-                Error(e.E1, "{0} can only be applied to expressions of types that support equality (got {1}){2}", BinaryExpr.OpcodeString(e.Op), t1, TypeEqualityErrorMessageHint(t1));
+                resolver.reporter.Error(MessageSource.Resolver, e.E1, "{0} can only be applied to expressions of types that support equality (got {1}){2}", BinaryExpr.OpcodeString(e.Op), t1, TypeEqualityErrorMessageHint(t1));
               }
               break;
             default:
@@ -2803,12 +2687,12 @@ namespace Microsoft.Dafny
                 case BinaryExpr.ResolvedOpcode.Prefix:
                 case BinaryExpr.ResolvedOpcode.ProperPrefix:
                   if (!t1.SupportsEquality) {
-                    Error(e.E1, "{0} can only be applied to expressions of sequence types that support equality (got {1}){2}", BinaryExpr.OpcodeString(e.Op), t1, TypeEqualityErrorMessageHint(t1));
+                    resolver.reporter.Error(MessageSource.Resolver, e.E1, "{0} can only be applied to expressions of sequence types that support equality (got {1}){2}", BinaryExpr.OpcodeString(e.Op), t1, TypeEqualityErrorMessageHint(t1));
                   } else if (!t0.SupportsEquality) {
                     if (e.ResolvedOp == BinaryExpr.ResolvedOpcode.InSet || e.ResolvedOp == BinaryExpr.ResolvedOpcode.NotInSeq) {
-                      Error(e.E0, "{0} can only be applied to expressions of types that support equality (got {1}){2}", BinaryExpr.OpcodeString(e.Op), t0, TypeEqualityErrorMessageHint(t0));
+                      resolver.reporter.Error(MessageSource.Resolver, e.E0, "{0} can only be applied to expressions of types that support equality (got {1}){2}", BinaryExpr.OpcodeString(e.Op), t0, TypeEqualityErrorMessageHint(t0));
                     } else {
-                      Error(e.E0, "{0} can only be applied to expressions of sequence types that support equality (got {1}){2}", BinaryExpr.OpcodeString(e.Op), t0, TypeEqualityErrorMessageHint(t0));
+                      resolver.reporter.Error(MessageSource.Resolver, e.E0, "{0} can only be applied to expressions of sequence types that support equality (got {1}){2}", BinaryExpr.OpcodeString(e.Op), t0, TypeEqualityErrorMessageHint(t0));
                     }
                   }
                   break;
@@ -2834,7 +2718,7 @@ namespace Microsoft.Dafny
             foreach (var tp in ((ICallable)e.Member).TypeArgs) {
               var actualTp = e.TypeApplication[e.Member.EnclosingClass.TypeArgs.Count + i];
               if (tp.MustSupportEquality && !actualTp.SupportsEquality) {
-                Error(e.tok, "type parameter {0} ({1}) passed to {5} '{2}' must support equality (got {3}){4}", i, tp.Name, e.Member.Name, actualTp, TypeEqualityErrorMessageHint(actualTp), e.Member.WhatKind);
+                resolver.reporter.Error(MessageSource.Resolver, e.tok, "type parameter {0} ({1}) passed to {5} '{2}' must support equality (got {3}){4}", i, tp.Name, e.Member.Name, actualTp, TypeEqualityErrorMessageHint(actualTp), e.Member.WhatKind);
               }
               i++;
             }
@@ -2846,7 +2730,7 @@ namespace Microsoft.Dafny
           foreach (var formalTypeArg in e.Function.TypeArgs) {
             var actualTypeArg = e.TypeArgumentSubstitutions[formalTypeArg];
             if (formalTypeArg.MustSupportEquality && !actualTypeArg.SupportsEquality) {
-              Error(e.tok, "type parameter {0} ({1}) passed to function {2} must support equality (got {3}){4}", i, formalTypeArg.Name, e.Function.Name, actualTypeArg, TypeEqualityErrorMessageHint(actualTypeArg));
+              resolver.reporter.Error(MessageSource.Resolver, e.tok, "type parameter {0} ({1}) passed to function {2} must support equality (got {3}){4}", i, formalTypeArg.Name, e.Function.Name, actualTypeArg, TypeEqualityErrorMessageHint(actualTypeArg));
             }
             i++;
           }
@@ -2878,21 +2762,21 @@ namespace Microsoft.Dafny
           var st = (SetType)type;
           var argType = st.Arg;
           if (!argType.SupportsEquality) {
-            Error(tok, "{2}set argument type must support equality (got {0}){1}", argType, TypeEqualityErrorMessageHint(argType), st.Finite ? "" : "i");
+            resolver.reporter.Error(MessageSource.Resolver, tok, "{2}set argument type must support equality (got {0}){1}", argType, TypeEqualityErrorMessageHint(argType), st.Finite ? "" : "i");
           }
           CheckEqualityTypes_Type(tok, argType);
 
         } else if (type is MultiSetType) {
           var argType = ((MultiSetType)type).Arg;
           if (!argType.SupportsEquality) {
-            Error(tok, "multiset argument type must support equality (got {0}){1}", argType, TypeEqualityErrorMessageHint(argType));
+            resolver.reporter.Error(MessageSource.Resolver, tok, "multiset argument type must support equality (got {0}){1}", argType, TypeEqualityErrorMessageHint(argType));
           }
           CheckEqualityTypes_Type(tok, argType);
 
         } else if (type is MapType) {
           var mt = (MapType)type;
           if (!mt.Domain.SupportsEquality) {
-            Error(tok, "{2}map domain type must support equality (got {0}){1}", mt.Domain, TypeEqualityErrorMessageHint(mt.Domain), mt.Finite ? "" : "i");
+            resolver.reporter.Error(MessageSource.Resolver, tok, "{2}map domain type must support equality (got {0}){1}", mt.Domain, TypeEqualityErrorMessageHint(mt.Domain), mt.Finite ? "" : "i");
           }
           CheckEqualityTypes_Type(tok, mt.Domain);
           CheckEqualityTypes_Type(tok, mt.Range);
@@ -2918,7 +2802,7 @@ namespace Microsoft.Dafny
             foreach (var argType in udt.TypeArgs) {
               var formalTypeArg = formalTypeArgs[i];
               if (formalTypeArg.MustSupportEquality && !argType.SupportsEquality) {
-                Error(tok, "type parameter {0} ({1}) passed to type {2} must support equality (got {3}){4}", i, formalTypeArg.Name, udt.ResolvedClass.Name, argType, TypeEqualityErrorMessageHint(argType));
+                resolver.reporter.Error(MessageSource.Resolver, tok, "type parameter {0} ({1}) passed to type {2} must support equality (got {3}){4}", i, formalTypeArg.Name, udt.ResolvedClass.Name, argType, TypeEqualityErrorMessageHint(argType));
               }
               CheckEqualityTypes_Type(tok, argType);
               i++;
@@ -3007,10 +2891,10 @@ namespace Microsoft.Dafny
             for (int i = 0; i < cs.Method.Ins.Count; i++) {
               argsSubstMap.Add(cs.Method.Ins[i], cs.Args[i]);
             }
-            var substituter = new Translator.AlphaConverting_Substituter(cs.Receiver, argsSubstMap, new Dictionary<TypeParameter, Type>(), new Translator());
+            var substituter = new Translator.AlphaConverting_Substituter(cs.Receiver, argsSubstMap, new Dictionary<TypeParameter, Type>(), new Translator(resolver.reporter));
             foreach (var ens in cs.Method.Ens) {
               var p = substituter.Substitute(ens.E);  // substitute the call's actuals for the method's formals
-              resolver.ReportAdditionalInformation(s.Tok, "ensures " + Printer.ExprToString(p) + ";", s.Tok.val.Length);
+              resolver.reporter.Info(MessageSource.Resolver, s.Tok, "ensures " + Printer.ExprToString(p) + ";");
             }
           }
         }
@@ -3088,26 +2972,26 @@ namespace Microsoft.Dafny
       currentClass = cl;
 
       if (cl.TraitsTyp.Count > 0 && cl.TypeArgs.Count > 0) {
-        Error(cl.tok, "sorry, traits are currently supported only for classes that take no type arguments");  // TODO: do the work to remove this limitation
+        reporter.Error(MessageSource.Resolver, cl.tok, "sorry, traits are currently supported only for classes that take no type arguments");  // TODO: do the work to remove this limitation
       }
 
       // Resolve names of traits extended
       foreach (var tt in cl.TraitsTyp) {
-        var prevErrorCount = ErrorCount;
+        var prevErrorCount = reporter.Count(ErrorLevel.Error);
         ResolveType(cl.tok, tt, new NoContext(cl.Module), ResolveTypeOptionEnum.DontInfer, null);
-        if (ErrorCount == prevErrorCount) {
+        if (reporter.Count(ErrorLevel.Error) == prevErrorCount) {
           var udt = tt as UserDefinedType;
           if (udt != null && udt.ResolvedClass is TraitDecl) {
             var trait = (TraitDecl)udt.ResolvedClass;
             //disallowing inheritance in multi module case
             if (cl.Module != trait.Module) {
-              Error(udt.tok, "class '{0}' is in a different module than trait '{1}'. A class may only extend a trait in the same module.", cl.Name, trait.FullName);
+              reporter.Error(MessageSource.Resolver, udt.tok, "class '{0}' is in a different module than trait '{1}'. A class may only extend a trait in the same module.", cl.Name, trait.FullName);
             } else {
               // all is good
               cl.TraitsObj.Add(trait);
             }
           } else {
-            Error(udt != null ? udt.tok : cl.tok, "a class can only extend traits (found '{0}')", tt);
+            reporter.Error(MessageSource.Resolver, udt != null ? udt.tok : cl.tok, "a class can only extend traits (found '{0}')", tt);
           }
         }
       }
@@ -3150,12 +3034,12 @@ namespace Microsoft.Dafny
 
         } else if (member is Function) {
           var f = (Function)member;
-          var ec = ErrorCount;
+          var ec = reporter.Count(ErrorLevel.Error);
           allTypeParameters.PushMarker();
           ResolveTypeParameters(f.TypeArgs, true, f);
           ResolveFunctionSignature(f);
           allTypeParameters.PopMarker();
-          if (f is FixpointPredicate && ec == ErrorCount) {
+          if (f is FixpointPredicate && ec == reporter.Count(ErrorLevel.Error)) {
             var ff = ((FixpointPredicate)f).PrefixPredicate;
             ff.EnclosingClass = cl;
             allTypeParameters.PushMarker();
@@ -3166,13 +3050,13 @@ namespace Microsoft.Dafny
 
         } else if (member is Method) {
           var m = (Method)member;
-          var ec = ErrorCount;
+          var ec = reporter.Count(ErrorLevel.Error);
           allTypeParameters.PushMarker();
           ResolveTypeParameters(m.TypeArgs, true, m);
           ResolveMethodSignature(m);
           allTypeParameters.PopMarker();
           var com = m as FixpointLemma;
-          if (com != null && com.PrefixLemma != null && ec == ErrorCount) {
+          if (com != null && com.PrefixLemma != null && ec == reporter.Count(ErrorLevel.Error)) {
             var mm = com.PrefixLemma;
             // resolve signature of the prefix lemma
             mm.EnclosingClass = cl;
@@ -3193,7 +3077,7 @@ namespace Microsoft.Dafny
     void InheritTraitMembers(ClassDecl cl) {
       Contract.Requires(cl != null);
 
-      var refinementTransformer = new RefinementTransformer(this, AdditionalInformationReporter, null);
+      var refinementTransformer = new RefinementTransformer(reporter);
       //merging class members with parent members if any
       var clMembers = classMembers[cl];
       foreach (TraitDecl trait in cl.TraitsObj) {
@@ -3213,37 +3097,37 @@ namespace Microsoft.Dafny
             } else if (traitMember is Function) {
               var func = (Function)traitMember;
               if (func.Body == null) {
-                Error(cl.tok, "class '{0}' does not implement trait function '{1}.{2}'", cl.Name, trait.Name, traitMember.Name);
+                reporter.Error(MessageSource.Resolver, cl.tok, "class '{0}' does not implement trait function '{1}.{2}'", cl.Name, trait.Name, traitMember.Name);
               } else if (!func.IsGhost && !func.IsStatic) {
                 cl.InheritedMembers.Add(func);
               }
             } else if (traitMember is Method) {
               var method = (Method)traitMember;
               if (method.Body == null) {
-                Error(cl.tok, "class '{0}' does not implement trait method '{1}.{2}'", cl.Name, trait.Name, traitMember.Name);
+                reporter.Error(MessageSource.Resolver, cl.tok, "class '{0}' does not implement trait method '{1}.{2}'", cl.Name, trait.Name, traitMember.Name);
               } else if (!method.IsGhost && !method.IsStatic) {
                 cl.InheritedMembers.Add(method);
               }
             }
           } else if (clMember.EnclosingClass != cl) {
             // The class inherits the member from two places
-            Error(clMember.tok, "member name '{0}' in class '{1}' inherited from both traits '{2}' and '{3}'", traitMember.Name, cl.Name, clMember.EnclosingClass.Name, trait.Name);
+            reporter.Error(MessageSource.Resolver, clMember.tok, "member name '{0}' in class '{1}' inherited from both traits '{2}' and '{3}'", traitMember.Name, cl.Name, clMember.EnclosingClass.Name, trait.Name);
 
           } else if (traitMember is Field) {
             // The class is not allowed to do anything with the field other than silently inherit it.
             if (clMember is Field) {
-              Error(clMember.tok, "field '{0}' is inherited from trait '{1}' and is not allowed to be re-declared", traitMember.Name, trait.Name);
+              reporter.Error(MessageSource.Resolver, clMember.tok, "field '{0}' is inherited from trait '{1}' and is not allowed to be re-declared", traitMember.Name, trait.Name);
             } else {
-              Error(clMember.tok, "member name '{0}' in class '{1}' clashes with inherited field from trait '{2}'", traitMember.Name, cl.Name, trait.Name);
+              reporter.Error(MessageSource.Resolver, clMember.tok, "member name '{0}' in class '{1}' clashes with inherited field from trait '{2}'", traitMember.Name, cl.Name, trait.Name);
             }
 
           } else if (traitMember is Method) {
             var traitMethod = (Method)traitMember;
             if (traitMethod.Body != null) {
               // The method was defined in the trait, so the class is not allowed to do anything with the method other than silently inherit it.
-              Error(clMember.tok, "member '{0}' in class '{1}' overrides fully defined method inherited from trait '{2}'", clMember.Name, cl.Name, trait.Name);
+              reporter.Error(MessageSource.Resolver, clMember.tok, "member '{0}' in class '{1}' overrides fully defined method inherited from trait '{2}'", clMember.Name, cl.Name, trait.Name);
             } else if (!(clMember is Method)) {
-              Error(clMember.tok, "non-method member '{0}' overrides method '{1}' inherited from trait '{2}'", clMember.Name, traitMethod.Name, trait.Name);
+              reporter.Error(MessageSource.Resolver, clMember.tok, "non-method member '{0}' overrides method '{1}' inherited from trait '{2}'", clMember.Name, traitMethod.Name, trait.Name);
             } else {
               var classMethod = (Method)clMember;
               classMethod.OverriddenMethod = traitMethod;
@@ -3255,7 +3139,7 @@ namespace Microsoft.Dafny
               var traitMethodAllowsNonTermination = Contract.Exists(traitMethod.Decreases.Expressions, e => e is WildcardExpr);
               var classMethodAllowsNonTermination = Contract.Exists(classMethod.Decreases.Expressions, e => e is WildcardExpr);
               if (classMethodAllowsNonTermination && !traitMethodAllowsNonTermination) {
-                Error(classMethod.tok, "not allowed to override a terminating method with a possibly non-terminating method ('{0}')", classMethod.Name);
+                reporter.Error(MessageSource.Resolver, classMethod.tok, "not allowed to override a terminating method with a possibly non-terminating method ('{0}')", classMethod.Name);
               }
             }
 
@@ -3263,9 +3147,9 @@ namespace Microsoft.Dafny
             var traitFunction = (Function)traitMember;
             if (traitFunction.Body != null) {
               // The function was defined in the trait, so the class is not allowed to do anything with the function other than silently inherit it.
-              Error(clMember.tok, "member '{0}' in class '{1}' overrides fully defined function inherited from trait '{2}'", clMember.Name, cl.Name, trait.Name);
+              reporter.Error(MessageSource.Resolver, clMember.tok, "member '{0}' in class '{1}' overrides fully defined function inherited from trait '{2}'", clMember.Name, cl.Name, trait.Name);
             } else if (!(clMember is Function)) {
-              Error(clMember.tok, "non-function member '{0}' overrides function '{1}' inherited from trait '{2}'", clMember.Name, traitFunction.Name, trait.Name);
+              reporter.Error(MessageSource.Resolver, clMember.tok, "non-function member '{0}' overrides function '{1}' inherited from trait '{2}'", clMember.Name, traitFunction.Name, trait.Name);
             } else {
               var classFunction = (Function)clMember;
               classFunction.OverriddenFunction = traitFunction;
@@ -3298,12 +3182,12 @@ namespace Microsoft.Dafny
 
         } else if (member is Function) {
           var f = (Function)member;
-          var ec = ErrorCount;
+          var ec = reporter.Count(ErrorLevel.Error);
           allTypeParameters.PushMarker();
           ResolveTypeParameters(f.TypeArgs, false, f);
           ResolveFunction(f);
           allTypeParameters.PopMarker();
-          if (f is FixpointPredicate && ec == ErrorCount) {
+          if (f is FixpointPredicate && ec == reporter.Count(ErrorLevel.Error)) {
             var ff = ((FixpointPredicate)f).PrefixPredicate;
             allTypeParameters.PushMarker();
             ResolveTypeParameters(ff.TypeArgs, false, ff);
@@ -3313,7 +3197,7 @@ namespace Microsoft.Dafny
 
         } else if (member is Method) {
           var m = (Method)member;
-          var ec = ErrorCount;
+          var ec = reporter.Count(ErrorLevel.Error);
           allTypeParameters.PushMarker();
           ResolveTypeParameters(m.TypeArgs, false, m);
           ResolveMethod(m);
@@ -3420,7 +3304,7 @@ namespace Microsoft.Dafny
           // whatever is in scc-cleared now failed to pass the test
           foreach (var dt in scc) {
             if (dt.DefaultCtor == null) {
-              Error(dt, "because of cyclic dependencies among constructor argument types, no instances of datatype '{0}' can be constructed", dt.Name);
+              reporter.Error(MessageSource.Resolver, dt, "because of cyclic dependencies among constructor argument types, no instances of datatype '{0}' can be constructed", dt.Name);
             }
           }
           return;
@@ -3598,12 +3482,12 @@ namespace Microsoft.Dafny
       Contract.Requires(args != null);
       foreach (var arg in args) {
         Contract.Assert(arg != null);
-        int prevErrors = ErrorCount;
+        int prevErrors = reporter.Count(ErrorLevel.Error);
         ResolveExpression(arg, opts);
         if (!allowGhosts) {
           CheckIsNonGhost(arg);
         }
-        if (prevErrors == ErrorCount) {
+        if (prevErrors == reporter.Count(ErrorLevel.Error)) {
           CheckTypeInference(arg);
         }
       }
@@ -3623,9 +3507,9 @@ namespace Microsoft.Dafny
         var r = allTypeParameters.Push(tp.Name, tp);
         if (emitErrors) {
           if (r == Scope<TypeParameter>.PushResult.Duplicate) {
-            Error(tp, "Duplicate type-parameter name: {0}", tp.Name);
+            reporter.Error(MessageSource.Resolver, tp, "Duplicate type-parameter name: {0}", tp.Name);
           } else if (r == Scope<TypeParameter>.PushResult.Shadow) {
-            Warning(tp.tok, "Shadowed type-parameter name: {0}", tp.Name);
+            reporter.Warning(MessageSource.Resolver, tp.tok, "Shadowed type-parameter name: {0}", tp.Name);
           }
         }
       }
@@ -3649,10 +3533,10 @@ namespace Microsoft.Dafny
         case Scope<Thing>.PushResult.Success:
           break;
         case Scope<Thing>.PushResult.Duplicate:
-          Error(tok, "Duplicate {0} name: {1}", kind, name);
+          reporter.Error(MessageSource.Resolver, tok, "Duplicate {0} name: {1}", kind, name);
           break;
         case Scope<Thing>.PushResult.Shadow:
-          Warning(tok, "Shadowed {0} name: {1}", kind, name);
+          reporter.Warning(MessageSource.Resolver, tok, "Shadowed {0} name: {1}", kind, name);
           break;
       }
     }
@@ -3664,7 +3548,7 @@ namespace Microsoft.Dafny
       Contract.Requires(f != null);
       scope.PushMarker();
       if (f.SignatureIsOmitted) {
-        Error(f, "function signature can be omitted only in refining functions");
+        reporter.Error(MessageSource.Resolver, f, "function signature can be omitted only in refining functions");
       }
       var option = f.TypeArgs.Count == 0 ? new ResolveTypeOption(f) : new ResolveTypeOption(ResolveTypeOptionEnum.AllowPrefix);
       foreach (Formal p in f.Formals) {
@@ -3692,7 +3576,7 @@ namespace Microsoft.Dafny
         ResolveExpression(r, new ResolveOpts(f, false, true));
         Contract.Assert(r.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(r.Type, Type.Bool)) {
-          Error(r, "Precondition must be a boolean (got {0})", r.Type);
+          reporter.Error(MessageSource.Resolver, r, "Precondition must be a boolean (got {0})", r.Type);
         }
       }
       foreach (FrameExpression fr in f.Reads) {
@@ -3702,7 +3586,7 @@ namespace Microsoft.Dafny
         ResolveExpression(r, new ResolveOpts(f, false, true));  // since this is a function, the postcondition is still a one-state predicate
         Contract.Assert(r.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(r.Type, Type.Bool)) {
-          Error(r, "Postcondition must be a boolean (got {0})", r.Type);
+          reporter.Error(MessageSource.Resolver, r, "Postcondition must be a boolean (got {0})", r.Type);
         }
       }
       ResolveAttributes(f.Decreases.Attributes, new ResolveOpts(f, false, true));
@@ -3711,14 +3595,14 @@ namespace Microsoft.Dafny
         // any type is fine
       }
       if (f.Body != null) {
-        var prevErrorCount = ErrorCount;
+        var prevErrorCount = reporter.Count(ErrorLevel.Error);
         ResolveExpression(f.Body, new ResolveOpts(f, false));
-        if (!f.IsGhost && prevErrorCount == ErrorCount) {
+        if (!f.IsGhost && prevErrorCount == reporter.Count(ErrorLevel.Error)) {
           CheckIsNonGhost(f.Body);
         }
         Contract.Assert(f.Body.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(f.Body.Type, f.ResultType)) {
-          Error(f, "Function body type mismatch (expected {0}, got {1})", f.ResultType, f.Body.Type);
+          reporter.Error(MessageSource.Resolver, f, "Function body type mismatch (expected {0}, got {1})", f.ResultType, f.Body.Type);
         }
       }
       scope.PopMarker();
@@ -3746,7 +3630,7 @@ namespace Microsoft.Dafny
         t = collType.Arg;
       }
       if (!UnifyTypes(t, new ObjectType())) {
-        Error(fe.E, "a {0}-clause expression must denote an object or a collection of objects (instead got {1})", readsFrame ? "reads" : "modifies", fe.E.Type);
+        reporter.Error(MessageSource.Resolver, fe.E, "a {0}-clause expression must denote an object or a collection of objects (instead got {1})", readsFrame ? "reads" : "modifies", fe.E.Type);
       } else if (fe.FieldName != null) {
         NonProxyType nptype;
         MemberDecl member = ResolveMember(fe.E.tok, t, fe.FieldName, out nptype);
@@ -3754,9 +3638,9 @@ namespace Microsoft.Dafny
         if (member == null) {
           // error has already been reported by ResolveMember
         } else if (!(member is Field)) {
-          Error(fe.E, "member {0} in type {1} does not refer to a field", fe.FieldName, ctype.Name);
+          reporter.Error(MessageSource.Resolver, fe.E, "member {0} in type {1} does not refer to a field", fe.FieldName, ctype.Name);
         } else if (!readsFrame && isGhostContext && !member.IsGhost) {
-          Error(fe.E, "in a ghost context, only ghost fields can be mentioned as modifies frame targets ({0})", fe.FieldName);
+          reporter.Error(MessageSource.Resolver, fe.E, "in a ghost context, only ghost fields can be mentioned as modifies frame targets ({0})", fe.FieldName);
         } else {
           Contract.Assert(ctype != null && ctype.ResolvedClass != null);  // follows from postcondition of ResolveMember
           fe.Field = (Field)member;
@@ -3771,7 +3655,7 @@ namespace Microsoft.Dafny
       Contract.Requires(m != null);
       scope.PushMarker();
       if (m.SignatureIsOmitted) {
-        Error(m, "method signature can be omitted only in refining methods");
+        reporter.Error(MessageSource.Resolver, m, "method signature can be omitted only in refining methods");
       }
       var option = m.TypeArgs.Count == 0 ? new ResolveTypeOption(m) : new ResolveTypeOption(ResolveTypeOptionEnum.AllowPrefix);
       // resolve in-parameters
@@ -3812,14 +3696,14 @@ namespace Microsoft.Dafny
           ResolveExpression(e.E, new ResolveOpts(m, false, true));
           Contract.Assert(e.E.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(e.E.Type, Type.Bool)) {
-            Error(e.E, "Precondition must be a boolean (got {0})", e.E.Type);
+            reporter.Error(MessageSource.Resolver, e.E, "Precondition must be a boolean (got {0})", e.E.Type);
           }
         }
         ResolveAttributes(m.Mod.Attributes, new ResolveOpts(m, false, true));
         foreach (FrameExpression fe in m.Mod.Expressions) {
           ResolveFrameExpression(fe, false, m.IsGhost, m);
           if (m is Lemma || m is FixpointLemma) {
-            Error(fe.tok, "{0}s are not allowed to have modifies clauses", m.WhatKind);
+            reporter.Error(MessageSource.Resolver, fe.tok, "{0}s are not allowed to have modifies clauses", m.WhatKind);
           }
         }
         ResolveAttributes(m.Decreases.Attributes, new ResolveOpts(m, false, true));
@@ -3827,7 +3711,7 @@ namespace Microsoft.Dafny
           ResolveExpression(e, new ResolveOpts(m, false, true));
           // any type is fine
           if (m.IsGhost && e is WildcardExpr) {
-            Error(e, "'decreases *' is not allowed on ghost methods");
+            reporter.Error(MessageSource.Resolver, e, "'decreases *' is not allowed on ghost methods");
           }
         }
 
@@ -3835,7 +3719,7 @@ namespace Microsoft.Dafny
         // Don't care about any duplication errors among the out-parameters, since they have already been reported
         scope.PushMarker();
         if (m is FixpointLemma && m.Outs.Count != 0) {
-          Error(m.Outs[0].tok, "{0}s are not allowed to have out-parameters", m.WhatKind);
+          reporter.Error(MessageSource.Resolver, m.Outs[0].tok, "{0}s are not allowed to have out-parameters", m.WhatKind);
         } else {
           foreach (Formal p in m.Outs) {
             scope.Push(p.Name, p);
@@ -3848,7 +3732,7 @@ namespace Microsoft.Dafny
           ResolveExpression(e.E, new ResolveOpts(m, true, true));
           Contract.Assert(e.E.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(e.E.Type, Type.Bool)) {
-            Error(e.E, "Postcondition must be a boolean (got {0})", e.E.Type);
+            reporter.Error(MessageSource.Resolver, e.E, "Postcondition must be a boolean (got {0})", e.E.Type);
           }
         }
 
@@ -3896,7 +3780,7 @@ namespace Microsoft.Dafny
       Contract.Requires(iter != null);
       scope.PushMarker();
       if (iter.SignatureIsOmitted) {
-        Error(iter, "iterator signature can be omitted only in refining methods");
+        reporter.Error(MessageSource.Resolver, iter, "iterator signature can be omitted only in refining methods");
       }
       var option = iter.TypeArgs.Count == 0 ? new ResolveTypeOption(iter) : new ResolveTypeOption(ResolveTypeOptionEnum.AllowPrefix);
       // resolve the types of the parameters
@@ -3918,7 +3802,7 @@ namespace Microsoft.Dafny
       Contract.Requires(currentClass == null);
       Contract.Ensures(currentClass == null);
 
-      var initialErrorCount = ErrorCount;
+      var initialErrorCount = reporter.Count(ErrorLevel.Error);
 
       // Add in-parameters to the scope, but don't care about any duplication errors, since they have already been reported
       scope.PushMarker();
@@ -3937,7 +3821,7 @@ namespace Microsoft.Dafny
         var d = iter.DecreasesFields[i];
         if (!UnifyTypes(d.Type, e.Type)) {
           // bummer, there was a use--and a bad use--of the field before, so this won't be the best of error messages
-          Error(e, "type of field {0} is {1}, but has been constrained elsewhere to be of type {2}", d.Name, e.Type, d.Type);
+          reporter.Error(MessageSource.Resolver, e, "type of field {0} is {1}, but has been constrained elsewhere to be of type {2}", d.Name, e.Type, d.Type);
         }
       }
       foreach (FrameExpression fe in iter.Reads.Expressions) {
@@ -3950,7 +3834,7 @@ namespace Microsoft.Dafny
         ResolveExpression(e.E, new ResolveOpts(iter, false, true));
         Contract.Assert(e.E.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(e.E.Type, Type.Bool)) {
-          Error(e.E, "Precondition must be a boolean (got {0})", e.E.Type);
+          reporter.Error(MessageSource.Resolver, e.E, "Precondition must be a boolean (got {0})", e.E.Type);
         }
       }
 
@@ -3966,27 +3850,27 @@ namespace Microsoft.Dafny
         ResolveExpression(e.E, new ResolveOpts(iter, false, true));
         Contract.Assert(e.E.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(e.E.Type, Type.Bool)) {
-          Error(e.E, "Yield precondition must be a boolean (got {0})", e.E.Type);
+          reporter.Error(MessageSource.Resolver, e.E, "Yield precondition must be a boolean (got {0})", e.E.Type);
         }
       }
       foreach (MaybeFreeExpression e in iter.YieldEnsures) {
         ResolveExpression(e.E, new ResolveOpts(iter, true, true));
         Contract.Assert(e.E.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(e.E.Type, Type.Bool)) {
-          Error(e.E, "Yield postcondition must be a boolean (got {0})", e.E.Type);
+          reporter.Error(MessageSource.Resolver, e.E, "Yield postcondition must be a boolean (got {0})", e.E.Type);
         }
       }
       foreach (MaybeFreeExpression e in iter.Ensures) {
         ResolveExpression(e.E, new ResolveOpts(iter, true, true));
         Contract.Assert(e.E.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(e.E.Type, Type.Bool)) {
-          Error(e.E, "Postcondition must be a boolean (got {0})", e.E.Type);
+          reporter.Error(MessageSource.Resolver, e.E, "Postcondition must be a boolean (got {0})", e.E.Type);
         }
       }
 
       ResolveAttributes(iter.Attributes, new ResolveOpts(iter, false, true));
 
-      var postSpecErrorCount = ErrorCount;
+      var postSpecErrorCount = reporter.Count(ErrorLevel.Error);
 
       // Resolve body
       if (iter.Body != null) {
@@ -4031,7 +3915,7 @@ namespace Microsoft.Dafny
       Expression frameSet = new SetDisplayExpr(iter.tok, true, modSetSingletons);
       foreach (var fr in iter.Reads.Expressions) {
         if (fr.FieldName != null) {
-          Error(fr.tok, "sorry, a reads clause for an iterator is not allowed to designate specific fields");
+          reporter.Error(MessageSource.Resolver, fr.tok, "sorry, a reads clause for an iterator is not allowed to designate specific fields");
         } else if (fr.E.Type.IsRefType) {
           modSetSingletons.Add(fr.E);
         } else {
@@ -4046,7 +3930,7 @@ namespace Microsoft.Dafny
       frameSet = new SetDisplayExpr(iter.tok, true, modSetSingletons);
       foreach (var fr in iter.Modifies.Expressions) {
         if (fr.FieldName != null) {
-          Error(fr.tok, "sorry, a modifies clause for an iterator is not allowed to designate specific fields");
+          reporter.Error(MessageSource.Resolver, fr.tok, "sorry, a modifies clause for an iterator is not allowed to designate specific fields");
         } else if (fr.E.Type.IsRefType) {
           modSetSingletons.Add(fr.E);
         } else {
@@ -4232,7 +4116,7 @@ namespace Microsoft.Dafny
         // nothing to resolve
       } else if (type is MapType) {
         var mt = (MapType)type;
-        var errorCount = ErrorCount;
+        var errorCount = reporter.Count(ErrorLevel.Error);
         int typeArgumentCount = 0;
         if (mt.HasTypeArg()) {
           ResolveType(tok, mt.Domain, context, option, defaultTypeArguments);
@@ -4253,19 +4137,19 @@ namespace Microsoft.Dafny
         }
         // defaults and auto have been applied; check if we now have the right number of arguments
         if (2 != typeArgumentCount) {
-          Error(tok, "Wrong number of type arguments ({0} instead of 2) passed to type: {1}", typeArgumentCount, mt.CollectionTypeName);
+          reporter.Error(MessageSource.Resolver, tok, "Wrong number of type arguments ({0} instead of 2) passed to type: {1}", typeArgumentCount, mt.CollectionTypeName);
           // add proxy types, to make sure that MapType will have have a non-null Arg/Domain and Range
           if (typeArgumentCount == 0) {
             mt.SetTypeArg(new InferredTypeProxy());
           }
           mt.SetRangetype(new InferredTypeProxy());
         }
-        if (errorCount == ErrorCount && (mt.Domain.IsSubrangeType || mt.Range.IsSubrangeType)) {
-          Error(tok, "sorry, cannot instantiate collection type with a subrange type");
+        if (errorCount == reporter.Count(ErrorLevel.Error) && (mt.Domain.IsSubrangeType || mt.Range.IsSubrangeType)) {
+          reporter.Error(MessageSource.Resolver, tok, "sorry, cannot instantiate collection type with a subrange type");
         }
       } else if (type is CollectionType) {
         var t = (CollectionType)type;
-        var errorCount = ErrorCount;
+        var errorCount = reporter.Count(ErrorLevel.Error);
         if (t.HasTypeArg()) {
           ResolveType(tok, t.Arg, context, option, defaultTypeArguments);
         } else if (option.Opt != ResolveTypeOptionEnum.DontInfer) {
@@ -4278,13 +4162,13 @@ namespace Microsoft.Dafny
         }
         if (!t.HasTypeArg()) {
           // defaults and auto have been applied; check if we now have the right number of arguments
-          Error(tok, "Wrong number of type arguments (0 instead of 1) passed to type: {0}", t.CollectionTypeName);
+          reporter.Error(MessageSource.Resolver, tok, "Wrong number of type arguments (0 instead of 1) passed to type: {0}", t.CollectionTypeName);
           // add a proxy type, to make sure that CollectionType will have have a non-null Arg
           t.SetTypeArg(new InferredTypeProxy());
         }
 
-        if (errorCount == ErrorCount && t.Arg.IsSubrangeType) {
-          Error(tok, "sorry, cannot instantiate collection type with a subrange type");
+        if (errorCount == reporter.Count(ErrorLevel.Error) && t.Arg.IsSubrangeType) {
+          reporter.Error(MessageSource.Resolver, tok, "sorry, cannot instantiate collection type with a subrange type");
         }
 
       } else if (type is UserDefinedType) {
@@ -4293,7 +4177,7 @@ namespace Microsoft.Dafny
           // Apparently, this type has already been resolved
           return null;
         }
-        var prevErrorCount = ErrorCount;
+        var prevErrorCount = reporter.Count(ErrorLevel.Error);
         if (t.NamePath is ExprDotName) {
           var ret = ResolveDotSuffix_Type((ExprDotName)t.NamePath, new ResolveOpts(context, true, true), allowDanglingDotName, option, defaultTypeArguments);
           if (ret != null) {
@@ -4303,10 +4187,10 @@ namespace Microsoft.Dafny
           var s = (NameSegment)t.NamePath;
           ResolveNameSegment_Type(s, new ResolveOpts(context, true, true), option, defaultTypeArguments);
         }
-        if (ErrorCount == prevErrorCount) {
+        if (reporter.Count(ErrorLevel.Error) == prevErrorCount) {
           var r = t.NamePath.Resolved as Resolver_IdentifierExpr;
           if (r == null || !(r.Type is Resolver_IdentifierExpr.ResolverType_Type)) {
-            Error(t.tok, "expected type");
+            reporter.Error(MessageSource.Resolver, t.tok, "expected type");
           } else if (r.Type is Resolver_IdentifierExpr.ResolverType_Type && r.TypeParamDecl != null) {
             t.ResolvedParam = r.TypeParamDecl;
           } else if (r.Type is Resolver_IdentifierExpr.ResolverType_Type) {
@@ -4328,7 +4212,7 @@ namespace Microsoft.Dafny
                 caller.EnclosingModule.CallGraph.AddEdge(caller, dd);
                 if (caller == dd) {
                   // detect self-loops here, since they don't show up in the graph's SSC methods
-                  Error(dd.tok, "recursive dependency involving a newtype: {0} -> {0}", dd.Name);
+                  reporter.Error(MessageSource.Resolver, dd.tok, "recursive dependency involving a newtype: {0} -> {0}", dd.Name);
                 }
               }
               t.ResolvedClass = dd;
@@ -4343,7 +4227,7 @@ namespace Microsoft.Dafny
             }
             // defaults and auto have been applied; check if we now have the right number of arguments
             if (d.TypeArgs.Count != t.TypeArgs.Count) {
-              Error(t.tok, "Wrong number of type arguments ({0} instead of {1}) passed to {2}: {3}", t.TypeArgs.Count, d.TypeArgs.Count, d.WhatKind, t.Name);
+              reporter.Error(MessageSource.Resolver, t.tok, "Wrong number of type arguments ({0} instead of {1}) passed to {2}: {3}", t.TypeArgs.Count, d.TypeArgs.Count, d.WhatKind, t.Name);
             }
 
           }
@@ -4839,14 +4723,14 @@ namespace Microsoft.Dafny
         ResolveExpression(s.Expr, new ResolveOpts(codeContext, true, true));
         Contract.Assert(s.Expr.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(s.Expr.Type, Type.Bool)) {
-          Error(s.Expr, "condition is expected to be of type {0}, but is {1}", Type.Bool, s.Expr.Type);
+          reporter.Error(MessageSource.Resolver, s.Expr, "condition is expected to be of type {0}, but is {1}", Type.Bool, s.Expr.Type);
         }
 
       } else if (stmt is PrintStmt) {
         PrintStmt s = (PrintStmt)stmt;
         ResolveAttributeArgs(s.Args, new ResolveOpts(codeContext, false, specContextOnly), false);
         if (specContextOnly) {
-          Error(stmt, "print statement is not allowed in this context (because this is a ghost method or because the statement is guarded by a specification-only expression)");
+          reporter.Error(MessageSource.Resolver, stmt, "print statement is not allowed in this context (because this is a ghost method or because the statement is guarded by a specification-only expression)");
         }
 
       } else if (stmt is BreakStmt) {
@@ -4854,17 +4738,17 @@ namespace Microsoft.Dafny
         if (s.TargetLabel != null) {
           Statement target = labeledStatements.Find(s.TargetLabel);
           if (target == null) {
-            Error(s, "break label is undefined or not in scope: {0}", s.TargetLabel);
+            reporter.Error(MessageSource.Resolver, s, "break label is undefined or not in scope: {0}", s.TargetLabel);
           } else {
             s.TargetStmt = target;
             bool targetIsLoop = target is WhileStmt || target is AlternativeLoopStmt;
             if (specContextOnly && !s.TargetStmt.IsGhost && !inSpecOnlyContext[s.TargetStmt]) {
-              Error(stmt, "ghost-context break statement is not allowed to break out of non-ghost " + (targetIsLoop ? "loop" : "structure"));
+              reporter.Error(MessageSource.Resolver, stmt, "ghost-context break statement is not allowed to break out of non-ghost " + (targetIsLoop ? "loop" : "structure"));
             }
           }
         } else {
           if (loopStack.Count < s.BreakCount) {
-            Error(s, "trying to break out of more loop levels than there are enclosing loops");
+            reporter.Error(MessageSource.Resolver, s, "trying to break out of more loop levels than there are enclosing loops");
           } else {
             Statement target = loopStack[loopStack.Count - s.BreakCount];
             if (target.Labels == null) {
@@ -4873,7 +4757,7 @@ namespace Microsoft.Dafny
             }
             s.TargetStmt = target;
             if (specContextOnly && !target.IsGhost && !inSpecOnlyContext[target]) {
-              Error(stmt, "ghost-context break statement is not allowed to break out of non-ghost loop");
+              reporter.Error(MessageSource.Resolver, stmt, "ghost-context break statement is not allowed to break out of non-ghost loop");
             }
           }
         }
@@ -4881,11 +4765,11 @@ namespace Microsoft.Dafny
       } else if (stmt is ProduceStmt) {
         var kind = stmt is YieldStmt ? "yield" : "return";
         if (stmt is YieldStmt && !(codeContext is IteratorDecl)) {
-          Error(stmt, "yield statement is allowed only in iterators");
+          reporter.Error(MessageSource.Resolver, stmt, "yield statement is allowed only in iterators");
         } else if (stmt is ReturnStmt && !(codeContext is Method)) {
-          Error(stmt, "return statement is allowed only in method");
+          reporter.Error(MessageSource.Resolver, stmt, "return statement is allowed only in method");
         } else if (specContextOnly && !codeContext.IsGhost) {
-          Error(stmt, "{0} statement is not allowed in this context (because it is guarded by a specification-only expression)", kind);
+          reporter.Error(MessageSource.Resolver, stmt, "{0} statement is not allowed in this context (because it is guarded by a specification-only expression)", kind);
         }
         var s = (ProduceStmt)stmt;
         if (s.rhss != null) {
@@ -4893,7 +4777,7 @@ namespace Microsoft.Dafny
           if (cmc == null) {
             // an error has already been reported above
           } else if (cmc.Outs.Count != s.rhss.Count) {
-            Error(s, "number of {2} parameters does not match declaration (found {0}, expected {1})", s.rhss.Count, cmc.Outs.Count, kind);
+            reporter.Error(MessageSource.Resolver, s, "number of {2} parameters does not match declaration (found {0}, expected {1})", s.rhss.Count, cmc.Outs.Count, kind);
           } else {
             Contract.Assert(s.rhss.Count > 0);
             // Create a hidden update statement using the out-parameter formals, resolve the RHS, and check that the RHS is good.
@@ -4986,24 +4870,24 @@ namespace Microsoft.Dafny
           {
             if (currentMethod == null)
             {
-              Error(local.Tok, "assumption variable can only be declared in a method");
+              reporter.Error(MessageSource.Resolver, local.Tok, "assumption variable can only be declared in a method");
             }
             if (!local.IsGhost)
             {
-              Error(local.Tok, "assumption variable must be ghost");
+              reporter.Error(MessageSource.Resolver, local.Tok, "assumption variable must be ghost");
             }
             if (!(local.Type.IsBoolType))
             {
-              Error(s, "assumption variable must be of type 'bool'");
+              reporter.Error(MessageSource.Resolver, s, "assumption variable must be of type 'bool'");
             }
           }
         }
 
       } else if (stmt is AssignStmt) {
         AssignStmt s = (AssignStmt)stmt;
-        int prevErrorCount = ErrorCount;
+        int prevErrorCount = reporter.Count(ErrorLevel.Error);
         ResolveExpression(s.Lhs, new ResolveOpts(codeContext, true, specContextOnly));  // allow ghosts for now, tighted up below
-        bool lhsResolvedSuccessfully = ErrorCount == prevErrorCount;
+        bool lhsResolvedSuccessfully = reporter.Count(ErrorLevel.Error) == prevErrorCount;
         Contract.Assert(s.Lhs.Type != null);  // follows from postcondition of ResolveExpression
         // check that LHS denotes a mutable variable or a field
         bool lvalueIsGhost = false;
@@ -5016,7 +4900,7 @@ namespace Microsoft.Dafny
             lvalueIsGhost = var.IsGhost || codeContext.IsGhost;
             CheckIsLvalue(lhs, codeContext);
             if (!lvalueIsGhost && specContextOnly) {
-              Error(stmt, "Assignment to non-ghost variable is not allowed in this context (because this is a ghost method or because the statement is guarded by a specification-only expression)");
+              reporter.Error(MessageSource.Resolver, stmt, "Assignment to non-ghost variable is not allowed in this context (because this is a ghost method or because the statement is guarded by a specification-only expression)");
             }
 
             var localVar = var as LocalVariable;
@@ -5035,7 +4919,7 @@ namespace Microsoft.Dafny
               }
               else
               {
-                Error(stmt, string.Format("there may be at most one assignment to an assumption variable, the RHS of which must match the expression \"{0} && <boolean expression>\"", localVar.Name));
+                reporter.Error(MessageSource.Resolver, stmt, string.Format("there may be at most one assignment to an assumption variable, the RHS of which must match the expression \"{0} && <boolean expression>\"", localVar.Name));
               }
             }
           }
@@ -5045,12 +4929,12 @@ namespace Microsoft.Dafny
             lvalueIsGhost = fse.Member.IsGhost;
             if (!lvalueIsGhost) {
               if (specContextOnly) {
-                Error(stmt, "Assignment to non-ghost field is not allowed in this context (because this is a ghost method or because the statement is guarded by a specification-only expression)");
+                reporter.Error(MessageSource.Resolver, stmt, "Assignment to non-ghost field is not allowed in this context (because this is a ghost method or because the statement is guarded by a specification-only expression)");
               } else {
                 // It is now that we wish we would have resolved s.Lhs to not allow ghosts.  Too late, so we do
                 // the next best thing.
                 if (lhsResolvedSuccessfully && UsesSpecFeatures(fse.Obj)) {
-                  Error(stmt, "Assignment to non-ghost field is not allowed to use specification-only expressions in the receiver");
+                  reporter.Error(MessageSource.Resolver, stmt, "Assignment to non-ghost field is not allowed to use specification-only expressions in the receiver");
                 }
               }
             }
@@ -5062,14 +4946,14 @@ namespace Microsoft.Dafny
           if (lhsResolvedSuccessfully) {
             Contract.Assert(slhs.Seq.Type != null);
             if (specContextOnly) {
-              Error(stmt, "Assignment to array element is not allowed in this context (because this is a ghost method or because the statement is guarded by a specification-only expression)");
+              reporter.Error(MessageSource.Resolver, stmt, "Assignment to array element is not allowed in this context (because this is a ghost method or because the statement is guarded by a specification-only expression)");
             }
             CheckIsLvalue(slhs, codeContext);
           }
 
         } else if (lhs is MultiSelectExpr) {
           if (specContextOnly) {
-            Error(stmt, "Assignment to array element is not allowed in this context (because this is a ghost method or because the statement is guarded by a specification-only expression)");
+            reporter.Error(MessageSource.Resolver, stmt, "Assignment to array element is not allowed in this context (because this is a ghost method or because the statement is guarded by a specification-only expression)");
           }
           CheckIsLvalue(lhs, codeContext);
 
@@ -5087,7 +4971,7 @@ namespace Microsoft.Dafny
           }
           Contract.Assert(rr.Expr.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(lhsType, rr.Expr.Type)) {
-            Error(stmt, "RHS (of type {0}) not assignable to LHS (of type {1})", rr.Expr.Type, lhsType);
+            reporter.Error(MessageSource.Resolver, stmt, "RHS (of type {0}) not assignable to LHS (of type {1})", rr.Expr.Type, lhsType);
           }
         } else if (s.Rhs is TypeRhs) {
           TypeRhs rr = (TypeRhs)s.Rhs;
@@ -5105,7 +4989,7 @@ namespace Microsoft.Dafny
             }
           }
           if (!UnifyTypes(lhsType, t)) {
-            Error(stmt, "type {0} is not assignable to LHS (of type {1})", t, lhsType);
+            reporter.Error(MessageSource.Resolver, stmt, "type {0} is not assignable to LHS (of type {1})", t, lhsType);
           }
         } else if (s.Rhs is HavocRhs) {
           // nothing else to do
@@ -5130,12 +5014,12 @@ namespace Microsoft.Dafny
         IfStmt s = (IfStmt)stmt;
         bool branchesAreSpecOnly = specContextOnly;
         if (s.Guard != null) {
-          int prevErrorCount = ErrorCount;
+          int prevErrorCount = reporter.Count(ErrorLevel.Error);
           ResolveExpression(s.Guard, new ResolveOpts(codeContext, true, specContextOnly));
           Contract.Assert(s.Guard.Type != null);  // follows from postcondition of ResolveExpression
-          bool successfullyResolved = ErrorCount == prevErrorCount;
+          bool successfullyResolved = reporter.Count(ErrorLevel.Error) == prevErrorCount;
           if (!UnifyTypes(s.Guard.Type, Type.Bool)) {
-            Error(s.Guard, "condition is expected to be of type {0}, but is {1}", Type.Bool, s.Guard.Type);
+            reporter.Error(MessageSource.Resolver, s.Guard, "condition is expected to be of type {0}, but is {1}", Type.Bool, s.Guard.Type);
           }
           if (!specContextOnly && successfullyResolved) {
             branchesAreSpecOnly = UsesSpecFeatures(s.Guard);
@@ -5163,13 +5047,13 @@ namespace Microsoft.Dafny
         bool bodyMustBeSpecOnly = specContextOnly;
         var fvs = new HashSet<IVariable>();
         if (s.Guard != null) {
-          int prevErrorCount = ErrorCount;
+          int prevErrorCount = reporter.Count(ErrorLevel.Error);
           ResolveExpression(s.Guard, new ResolveOpts(codeContext, true, specContextOnly));
           Contract.Assert(s.Guard.Type != null);  // follows from postcondition of ResolveExpression
-          bool successfullyResolved = ErrorCount == prevErrorCount;
+          bool successfullyResolved = reporter.Count(ErrorLevel.Error) == prevErrorCount;
           Translator.ComputeFreeVariables(s.Guard, fvs);
           if (!UnifyTypes(s.Guard.Type, Type.Bool)) {
-            Error(s.Guard, "condition is expected to be of type {0}, but is {1}", Type.Bool, s.Guard.Type);
+            reporter.Error(MessageSource.Resolver, s.Guard, "condition is expected to be of type {0}, but is {1}", Type.Bool, s.Guard.Type);
           }
           if (!specContextOnly && successfullyResolved) {
             bodyMustBeSpecOnly = UsesSpecFeatures(s.Guard);
@@ -5182,7 +5066,7 @@ namespace Microsoft.Dafny
           Contract.Assert(inv.E.Type != null);  // follows from postcondition of ResolveExpression
           Translator.ComputeFreeVariables(inv.E, fvs);
           if (!UnifyTypes(inv.E.Type, Type.Bool)) {
-            Error(inv.E, "invariant is expected to be of type {0}, but is {1}", Type.Bool, inv.E.Type);
+            reporter.Error(MessageSource.Resolver, inv.E, "invariant is expected to be of type {0}, but is {1}", Type.Bool, inv.E.Type);
           }
         }
 
@@ -5191,9 +5075,9 @@ namespace Microsoft.Dafny
           ResolveExpression(e, new ResolveOpts(codeContext, true, true));
           if (e is WildcardExpr) {
             if (bodyMustBeSpecOnly) {
-              Error(e, "'decreases *' is not allowed on ghost loops");
+              reporter.Error(MessageSource.Resolver, e, "'decreases *' is not allowed on ghost loops");
             } else if (!codeContext.AllowsNontermination && !DafnyOptions.O.Dafnycc) {
-              Error(e, "a possibly infinite loop is allowed only if the enclosing method is declared (with 'decreases *') to be possibly non-terminating");
+              reporter.Error(MessageSource.Resolver, e, "a possibly infinite loop is allowed only if the enclosing method is declared (with 'decreases *') to be possibly non-terminating");
             }
           }
           // any type is fine
@@ -5225,7 +5109,7 @@ namespace Microsoft.Dafny
             }
           }
           text += "};";  // always terminate with a semi-colon
-          ReportAdditionalInformation(s.Tok, text, s.Tok.val.Length);
+          reporter.Info(MessageSource.Resolver, s.Tok, text);
         }
 
       } else if (stmt is AlternativeLoopStmt) {
@@ -5235,7 +5119,7 @@ namespace Microsoft.Dafny
           ResolveExpression(inv.E, new ResolveOpts(codeContext, true, true));
           Contract.Assert(inv.E.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(inv.E.Type, Type.Bool)) {
-            Error(inv.E, "invariant is expected to be of type {0}, but is {1}", Type.Bool, inv.E.Type);
+            reporter.Error(MessageSource.Resolver, inv.E, "invariant is expected to be of type {0}, but is {1}", Type.Bool, inv.E.Type);
           }
         }
 
@@ -5243,9 +5127,9 @@ namespace Microsoft.Dafny
           ResolveExpression(e, new ResolveOpts(codeContext, true, true));
           if (e is WildcardExpr) {
             if (s.IsGhost) {
-              Error(e, "'decreases *' is not allowed on ghost loops");
+              reporter.Error(MessageSource.Resolver, e, "'decreases *' is not allowed on ghost loops");
             } else if (!codeContext.AllowsNontermination && !DafnyOptions.O.Dafnycc) {
-              Error(e, "a possibly infinite loop is allowed only if the enclosing method is declared (with 'decreases *') to be possibly non-terminating");
+              reporter.Error(MessageSource.Resolver, e, "a possibly infinite loop is allowed only if the enclosing method is declared (with 'decreases *') to be possibly non-terminating");
             }
           }
           // any type is fine
@@ -5254,7 +5138,7 @@ namespace Microsoft.Dafny
       } else if (stmt is ForallStmt) {
         var s = (ForallStmt)stmt;
 
-        int prevErrorCount = ErrorCount;
+        int prevErrorCount = reporter.Count(ErrorLevel.Error);
         scope.PushMarker();
         foreach (BoundVar v in s.BoundVars) {
           ScopePushAndReport(scope, v, "local-variable");
@@ -5263,24 +5147,24 @@ namespace Microsoft.Dafny
         ResolveExpression(s.Range, new ResolveOpts(codeContext, true, specContextOnly));
         Contract.Assert(s.Range.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(s.Range.Type, Type.Bool)) {
-          Error(stmt, "range restriction in forall statement must be of type bool (instead got {0})", s.Range.Type);
+          reporter.Error(MessageSource.Resolver, stmt, "range restriction in forall statement must be of type bool (instead got {0})", s.Range.Type);
         }
         foreach (var ens in s.Ens) {
           ResolveExpression(ens.E, new ResolveOpts(codeContext, true, true));
           Contract.Assert(ens.E.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(ens.E.Type, Type.Bool)) {
-            Error(ens.E, "ensures condition is expected to be of type {0}, but is {1}", Type.Bool, ens.E.Type);
+            reporter.Error(MessageSource.Resolver, ens.E, "ensures condition is expected to be of type {0}, but is {1}", Type.Bool, ens.E.Type);
           }
         }
         // Since the range and postconditions are more likely to infer the types of the bound variables, resolve them
         // first (above) and only then resolve the attributes (below).
         ResolveAttributes(s.Attributes, new ResolveOpts(codeContext, true, true));
 
-        bool bodyMustBeSpecOnly = specContextOnly || (prevErrorCount == ErrorCount && UsesSpecFeatures(s.Range));
-        if (!bodyMustBeSpecOnly && prevErrorCount == ErrorCount) {
+        bool bodyMustBeSpecOnly = specContextOnly || (prevErrorCount == reporter.Count(ErrorLevel.Error) && UsesSpecFeatures(s.Range));
+        if (!bodyMustBeSpecOnly && prevErrorCount == reporter.Count(ErrorLevel.Error)) {
           var missingBounds = new List<BoundVar>();
           CheckTypeInference(s.Range);  // we need to resolve operators before the call to DiscoverBounds
-          s.Bounds = DiscoverBounds(s.Tok, s.BoundVars, s.Range, true, false, missingBounds);
+          s.Bounds = DiscoverBounds(s.Tok, s.BoundVars, s.Range, true, false, missingBounds, reporter);
           if (missingBounds.Count != 0) {
             bodyMustBeSpecOnly = true;
           }
@@ -5299,7 +5183,7 @@ namespace Microsoft.Dafny
         }
         scope.PopMarker();
 
-        if (prevErrorCount == ErrorCount) {
+        if (prevErrorCount == reporter.Count(ErrorLevel.Error)) {
           // determine the Kind and run some additional checks on the body
           if (s.Ens.Count != 0) {
             // The only supported kind with ensures clauses is Proof.
@@ -5323,13 +5207,13 @@ namespace Microsoft.Dafny
               // add the conclusion of the calc as a free postcondition
               var result = ((CalcStmt)s0).Result;
               s.Ens.Add(new MaybeFreeExpression(result, true));
-              ReportAdditionalInformation(s.Tok, "ensures " + Printer.ExprToString(result) + ";", s.Tok.val.Length);
+              reporter.Info(MessageSource.Resolver, s.Tok, "ensures " + Printer.ExprToString(result) + ";");
             } else {
               s.Kind = ForallStmt.ParBodyKind.Proof;
               if (s.Body is BlockStmt && ((BlockStmt)s.Body).Body.Count == 0) {
                 // an empty statement, so don't produce any warning
               } else {
-                Warning(s.Tok, "the conclusion of the body of this forall statement will not be known outside the forall statement; consider using an 'ensures' clause");
+                reporter.Warning(MessageSource.Resolver, s.Tok, "the conclusion of the body of this forall statement will not be known outside the forall statement; consider using an 'ensures' clause");
               }
             }
           }
@@ -5351,7 +5235,7 @@ namespace Microsoft.Dafny
         s.IsGhost = specContextOnly;
 
       } else if (stmt is CalcStmt) {
-        var prevErrorCount = ErrorCount;
+        var prevErrorCount = reporter.Count(ErrorLevel.Error);
         CalcStmt s = (CalcStmt)stmt;
         s.IsGhost = true;
         if (s.Lines.Count > 0) {
@@ -5359,12 +5243,12 @@ namespace Microsoft.Dafny
           ResolveExpression(e0, new ResolveOpts(codeContext, true, true));
           Contract.Assert(e0.Type != null);  // follows from postcondition of ResolveExpression
           for (int i = 1; i < s.Lines.Count; i++) {
-            if (i < s.Lines.Count - 1 || prevErrorCount == ErrorCount) { // do not resolve the dummy step if there were errors, it might generate more errors
+            if (i < s.Lines.Count - 1 || prevErrorCount == reporter.Count(ErrorLevel.Error)) { // do not resolve the dummy step if there were errors, it might generate more errors
               var e1 = s.Lines[i];
               ResolveExpression(e1, new ResolveOpts(codeContext, true, true));
               Contract.Assert(e1.Type != null);  // follows from postcondition of ResolveExpression
               if (!UnifyTypes(e0.Type, e1.Type)) {
-                Error(e1, "all lines in a calculation must have the same type (got {0} after {1})", e1.Type, e0.Type);
+                reporter.Error(MessageSource.Resolver, e1, "all lines in a calculation must have the same type (got {0} after {1})", e1.Type, e0.Type);
               } else {
                 var step = s.StepOps[i - 1].StepExpr(e0, e1); // Use custom line operator
                 ResolveExpression(step, new ResolveOpts(codeContext, true, true));
@@ -5387,7 +5271,7 @@ namespace Microsoft.Dafny
           loopStack = prevLoopStack;
 
         }
-        if (prevErrorCount == ErrorCount && s.Lines.Count > 0) {
+        if (prevErrorCount == reporter.Count(ErrorLevel.Error) && s.Lines.Count > 0) {
           // do not build Result from the lines if there were errors, as it might be ill-typed and produce unnecessary resolution errors
           s.Result = s.ResultOp.StepExpr(s.Lines.First(), s.Lines.Last());
         } else {
@@ -5395,13 +5279,13 @@ namespace Microsoft.Dafny
         }
         ResolveExpression(s.Result, new ResolveOpts(codeContext, true, true));
         Contract.Assert(s.Result != null);
-        Contract.Assert(prevErrorCount != ErrorCount || s.Steps.Count == s.Hints.Count);
+        Contract.Assert(prevErrorCount != reporter.Count(ErrorLevel.Error) || s.Steps.Count == s.Hints.Count);
 
       } else if (stmt is MatchStmt) {
         ResolveMatchStmt(stmt, specContextOnly, codeContext);
       } else if (stmt is SkeletonStatement) {
         var s = (SkeletonStatement)stmt;
-        Error(s.Tok, "skeleton statements are allowed only in refining methods");
+        reporter.Error(MessageSource.Resolver, s.Tok, "skeleton statements are allowed only in refining methods");
         // nevertheless, resolve the underlying statement; hey, why not
         if (s.S != null) {
           ResolveStatement(s.S, specContextOnly, codeContext);
@@ -5416,10 +5300,10 @@ namespace Microsoft.Dafny
       DesugarMatchStmtWithTupleExpression(s);
 
       bool bodyIsSpecOnly = specContextOnly;
-      int prevErrorCount = ErrorCount;
+      int prevErrorCount = reporter.Count(ErrorLevel.Error);
       ResolveExpression(s.Source, new ResolveOpts(codeContext, true, specContextOnly));
       Contract.Assert(s.Source.Type != null);  // follows from postcondition of ResolveExpression
-      bool successfullyResolved = ErrorCount == prevErrorCount;
+      bool successfullyResolved = reporter.Count(ErrorLevel.Error) == prevErrorCount;
       if (!specContextOnly && successfullyResolved) {
         bodyIsSpecOnly = UsesSpecFeatures(s.Source);
       }
@@ -5432,7 +5316,7 @@ namespace Microsoft.Dafny
       var subst = new Dictionary<TypeParameter, Type>();
       Dictionary<string, DatatypeCtor> ctors;
       if (dtd == null) {
-        Error(s.Source, "the type of the match source expression must be a datatype (instead found {0})", s.Source.Type);
+        reporter.Error(MessageSource.Resolver, s.Source, "the type of the match source expression must be a datatype (instead found {0})", s.Source.Type);
         ctors = null;
       } else {
         Contract.Assert(sourceType != null);  // dtd and sourceType are set together above
@@ -5462,15 +5346,15 @@ namespace Microsoft.Dafny
         if (ctors != null) {
           Contract.Assert(dtd != null);
           if (!ctors.TryGetValue(mc.Id, out ctor)) {
-            Error(mc.tok, "member {0} does not exist in datatype {1}", mc.Id, dtd.Name);
+            reporter.Error(MessageSource.Resolver, mc.tok, "member {0} does not exist in datatype {1}", mc.Id, dtd.Name);
           } else {
             Contract.Assert(ctor != null);  // follows from postcondition of TryGetValue
             mc.Ctor = ctor;
             if (ctor.Formals.Count != mc.Arguments.Count) {
-              Error(mc.tok, "member {0} has wrong number of formals (found {1}, expected {2})", mc.Id, mc.Arguments.Count, ctor.Formals.Count);
+              reporter.Error(MessageSource.Resolver, mc.tok, "member {0} has wrong number of formals (found {1}, expected {2})", mc.Id, mc.Arguments.Count, ctor.Formals.Count);
             }
             if (memberNamesUsed.Contains(mc.Id)) {
-              Error(mc.tok, "member {0} appears in more than one case", mc.Id);
+              reporter.Error(MessageSource.Resolver, mc.tok, "member {0} appears in more than one case", mc.Id);
             } else {
               memberNamesUsed.Add(mc.Id);  // add mc.Id to the set of names used
             }
@@ -5486,7 +5370,7 @@ namespace Microsoft.Dafny
               Formal formal = ctor.Formals[i];
               Type st = SubstType(formal.Type, subst);
               if (!UnifyTypes(v.Type, st)) {
-                Error(stmt, "the declared type of the formal ({0}) does not agree with the corresponding type in the constructor's signature ({1})", v.Type, st);
+                reporter.Error(MessageSource.Resolver, stmt, "the declared type of the formal ({0}) does not agree with the corresponding type in the constructor's signature ({1})", v.Type, st);
               }
               v.IsGhost = formal.IsGhost;
 
@@ -5557,7 +5441,7 @@ namespace Microsoft.Dafny
       if (me.Source is DatatypeValue) {
         var e = (DatatypeValue)me.Source;
         if (e.Arguments.Count < 1) {
-          Error(me.Tok, "match source tuple needs at least 1 argument");
+          reporter.Error(MessageSource.Resolver, me.Tok, "match source tuple needs at least 1 argument");
         } else {
           Expression source = e.Arguments[0];
           List<MatchCaseStmt> cases = new List<MatchCaseStmt>();
@@ -5566,7 +5450,7 @@ namespace Microsoft.Dafny
           bool keepOrigToken = true; 
           foreach (MatchCaseStmt mc in me.Cases) {
             if (mc.CasePatterns == null || mc.CasePatterns.Count != e.Arguments.Count) {
-              Error(mc.tok, "case arguments count does not match source arguments count");
+              reporter.Error(MessageSource.Resolver, mc.tok, "case arguments count does not match source arguments count");
             } else {
               CasePattern cp = mc.CasePatterns[0];
               List<CasePattern> patterns;
@@ -5723,7 +5607,7 @@ namespace Microsoft.Dafny
           ScopePushAndReport(scope, v, "parameter");
         } else {
           if (scope.Find(v.Name) != null) {
-            Error(v, "Duplicate parameter name: {0}", v.Name);
+            reporter.Error(MessageSource.Resolver, v, "Duplicate parameter name: {0}", v.Name);
           }
         }
       } else {
@@ -5938,26 +5822,26 @@ namespace Microsoft.Dafny
           }
         }
         s += ";";  // always terminate with a semi-colon, even in the case of an empty decreases clause
-        ReportAdditionalInformation(loopStmt.Tok, s, loopStmt.Tok.val.Length);
+        reporter.Info(MessageSource.Resolver, loopStmt.Tok, s);
       }
     }
     private void ResolveConcreteUpdateStmt(ConcreteUpdateStatement s, bool specContextOnly, ICodeContext codeContext) {
       Contract.Requires(codeContext != null);
 
       // First, resolve all LHS's and expression-looking RHS's.
-      int errorCountBeforeCheckingLhs = ErrorCount;
+      int errorCountBeforeCheckingLhs = reporter.Count(ErrorLevel.Error);
       var update = s as UpdateStmt;
 
       var lhsNameSet = new HashSet<string>();  // used to check for duplicate identifiers on the left (full duplication checking for references and the like is done during verification)
       foreach (var lhs in s.Lhss) {
-        var ec = ErrorCount;
+        var ec = reporter.Count(ErrorLevel.Error);
         ResolveExpression(lhs, new ResolveOpts(codeContext, true, specContextOnly));
-        if (ec == ErrorCount) {
+        if (ec == reporter.Count(ErrorLevel.Error)) {
           if (update == null && specContextOnly && !AssignStmt.LhsIsToGhost(lhs) && !codeContext.IsGhost) {
-            Error(lhs, "cannot assign to non-ghost variable in a ghost context");
+            reporter.Error(MessageSource.Resolver, lhs, "cannot assign to non-ghost variable in a ghost context");
           }
           if (lhs is SeqSelectExpr && !((SeqSelectExpr)lhs).SelectOne) {
-            Error(lhs, "cannot assign to a range of array elements (try the 'forall' statement)");
+            reporter.Error(MessageSource.Resolver, lhs, "cannot assign to a range of array elements (try the 'forall' statement)");
           }
         }
       }
@@ -6018,10 +5902,10 @@ namespace Microsoft.Dafny
       if (firstEffectfulRhs == null) {
         if (update.Lhss.Count == 0) {
           Contract.Assert(update.Rhss.Count == 1);  // guaranteed by the parser
-          Error(update, "expected method call, found expression");
+          reporter.Error(MessageSource.Resolver, update, "expected method call, found expression");
         } else if (update.Lhss.Count != update.Rhss.Count) {
-          Error(update, "the number of left-hand sides ({0}) and right-hand sides ({1}) must match for a multi-assignment", update.Lhss.Count, update.Rhss.Count);
-        } else if (ErrorCount == errorCountBeforeCheckingLhs) {
+          reporter.Error(MessageSource.Resolver, update, "the number of left-hand sides ({0}) and right-hand sides ({1}) must match for a multi-assignment", update.Lhss.Count, update.Rhss.Count);
+        } else if (reporter.Count(ErrorLevel.Error) == errorCountBeforeCheckingLhs) {
           // add the statements here in a sequence, but don't use that sequence later for translation (instead, should translate properly as multi-assignment)
           for (int i = 0; i < update.Lhss.Count; i++) {
             var a = new AssignStmt(update.Tok, update.EndTok, update.Lhss[i].Resolved, update.Rhss[i]);
@@ -6031,19 +5915,19 @@ namespace Microsoft.Dafny
 
       } else if (update.CanMutateKnownState) {
         if (1 < update.Rhss.Count) {
-          Error(firstEffectfulRhs, "cannot have effectful parameter in multi-return statement.");
+          reporter.Error(MessageSource.Resolver, firstEffectfulRhs, "cannot have effectful parameter in multi-return statement.");
         } else { // it might be ok, if it is a TypeRhs
           Contract.Assert(update.Rhss.Count == 1);
           if (methodCallInfo != null) {
-            Error(methodCallInfo.Tok, "cannot have method call in return statement.");
+            reporter.Error(MessageSource.Resolver, methodCallInfo.Tok, "cannot have method call in return statement.");
           } else {
             // we have a TypeRhs
             Contract.Assert(update.Rhss[0] is TypeRhs);
             var tr = (TypeRhs)update.Rhss[0];
             Contract.Assert(tr.InitCall != null); // there were effects, so this must have been a call.
             if (tr.CanAffectPreviouslyKnownExpressions) {
-              Error(tr.Tok, "can only have initialization methods which modify at most 'this'.");
-            } else if (ErrorCount == errorCountBeforeCheckingLhs) {
+              reporter.Error(MessageSource.Resolver, tr.Tok, "can only have initialization methods which modify at most 'this'.");
+            } else if (reporter.Count(ErrorLevel.Error) == errorCountBeforeCheckingLhs) {
               var a = new AssignStmt(update.Tok, update.EndTok, update.Lhss[0].Resolved, tr);
               update.ResolvedStatements.Add(a);
             }
@@ -6053,17 +5937,17 @@ namespace Microsoft.Dafny
       } else {
         // if there was an effectful RHS, that must be the only RHS
         if (update.Rhss.Count != 1) {
-          Error(firstEffectfulRhs, "an update statement is allowed an effectful RHS only if there is just one RHS");
+          reporter.Error(MessageSource.Resolver, firstEffectfulRhs, "an update statement is allowed an effectful RHS only if there is just one RHS");
         } else if (methodCallInfo == null) {
           // must be a single TypeRhs
           if (update.Lhss.Count != 1) {
             Contract.Assert(2 <= update.Lhss.Count);  // the parser allows 0 Lhss only if the whole statement looks like an expression (not a TypeRhs)
-            Error(update.Lhss[1].tok, "the number of left-hand sides ({0}) and right-hand sides ({1}) must match for a multi-assignment", update.Lhss.Count, update.Rhss.Count);
-          } else if (ErrorCount == errorCountBeforeCheckingLhs) {
+            reporter.Error(MessageSource.Resolver, update.Lhss[1].tok, "the number of left-hand sides ({0}) and right-hand sides ({1}) must match for a multi-assignment", update.Lhss.Count, update.Rhss.Count);
+          } else if (reporter.Count(ErrorLevel.Error) == errorCountBeforeCheckingLhs) {
             var a = new AssignStmt(update.Tok, update.EndTok, update.Lhss[0].Resolved, update.Rhss[0]);
             update.ResolvedStatements.Add(a);
           }
-        } else if (ErrorCount == errorCountBeforeCheckingLhs) {
+        } else if (reporter.Count(ErrorLevel.Error) == errorCountBeforeCheckingLhs) {
           // a call statement
           var resolvedLhss = new List<Expression>();
           foreach (var ll in update.Lhss) {
@@ -6090,7 +5974,7 @@ namespace Microsoft.Dafny
         foreach (var lhs in s.Lhss) {
           var ide = lhs.Resolved as IdentifierExpr;
           if (ide == null) {
-            Error(lhs, "the assign-such-that statement currently only supports local-variable LHSs");
+            reporter.Error(MessageSource.Resolver, lhs, "the assign-such-that statement currently only supports local-variable LHSs");
           } else {
             varLhss.Add(ide.Var);
           }
@@ -6098,17 +5982,17 @@ namespace Microsoft.Dafny
       }
 
       s.IsGhost = s.Lhss.TrueForAll(AssignStmt.LhsIsToGhost);
-      var ec = ErrorCount;
+      var ec = reporter.Count(ErrorLevel.Error);
       ResolveExpression(s.Expr, new ResolveOpts(codeContext, true, specContextOnly));
       if (!UnifyTypes(s.Expr.Type, Type.Bool)) {
-        Error(s.Expr, "type of RHS of assign-such-that statement must be boolean (got {0})", s.Expr.Type);
+        reporter.Error(MessageSource.Resolver, s.Expr, "type of RHS of assign-such-that statement must be boolean (got {0})", s.Expr.Type);
       }
-      if (ec == ErrorCount && !s.IsGhost && s.AssumeToken == null && !specContextOnly) {
+      if (ec == reporter.Count(ErrorLevel.Error) && !s.IsGhost && s.AssumeToken == null && !specContextOnly) {
         CheckIsNonGhost(s.Expr);
 
         var missingBounds = new List<IVariable>();
         CheckTypeInference(s.Expr);  // we need to resolve operators before the call to DiscoverBoundsAux
-        var allBounds = DiscoverBoundsAux(s.Tok, varLhss, s.Expr, true, true, true, missingBounds);
+        var allBounds = DiscoverBoundsAux(s.Tok, varLhss, s.Expr, true, true, true, missingBounds, reporter);
         if (missingBounds.Count != 0) {
           s.MissingBounds = missingBounds;  // so that an error message can be produced during compilation
         } else {
@@ -6130,12 +6014,12 @@ namespace Microsoft.Dafny
       bool isGhost = specContextOnly;
       // first, resolve the guards, which tells us whether or not the entire statement is a ghost statement
       foreach (var alternative in alternatives) {
-        int prevErrorCount = ErrorCount;
+        int prevErrorCount = reporter.Count(ErrorLevel.Error);
         ResolveExpression(alternative.Guard, new ResolveOpts(codeContext, true, specContextOnly));
         Contract.Assert(alternative.Guard.Type != null);  // follows from postcondition of ResolveExpression
-        bool successfullyResolved = ErrorCount == prevErrorCount;
+        bool successfullyResolved = reporter.Count(ErrorLevel.Error) == prevErrorCount;
         if (!UnifyTypes(alternative.Guard.Type, Type.Bool)) {
-          Error(alternative.Guard, "condition is expected to be of type {0}, but is {1}", Type.Bool, alternative.Guard.Type);
+          reporter.Error(MessageSource.Resolver, alternative.Guard, "condition is expected to be of type {0}, but is {1}", Type.Bool, alternative.Guard.Type);
         }
         if (!specContextOnly && successfullyResolved) {
           isGhost = isGhost || UsesSpecFeatures(alternative.Guard);
@@ -6174,11 +6058,11 @@ namespace Microsoft.Dafny
       var callee = s.Method;
       Contract.Assert(callee != null);  // follows from the invariant of CallStmt
       if (!isInitCall && callee is Constructor) {
-        Error(s, "a constructor is allowed to be called only when an object is being allocated");
+        reporter.Error(MessageSource.Resolver, s, "a constructor is allowed to be called only when an object is being allocated");
       }
       s.IsGhost = callee.IsGhost;
       if (specContextOnly && !callee.IsGhost) {
-        Error(s, "only ghost methods can be called from this context");
+        reporter.Error(MessageSource.Resolver, s, "only ghost methods can be called from this context");
       }
 
       // resolve left-hand sides
@@ -6192,49 +6076,49 @@ namespace Microsoft.Dafny
       int j = 0;
       foreach (Expression e in s.Args) {
         bool allowGhost = s.IsGhost || callee.Ins.Count <= j || callee.Ins[j].IsGhost;
-        var ec = ErrorCount;
+        var ec = reporter.Count(ErrorLevel.Error);
         ResolveExpression(e, new ResolveOpts(codeContext, true, allowGhost));
-        if (ec == ErrorCount && !allowGhost) {
+        if (ec == reporter.Count(ErrorLevel.Error) && !allowGhost) {
           CheckIsNonGhost(e);
         }
         j++;
       }
 
       if (callee.Ins.Count != s.Args.Count) {
-        Error(s, "wrong number of method arguments (got {0}, expected {1})", s.Args.Count, callee.Ins.Count);
+        reporter.Error(MessageSource.Resolver, s, "wrong number of method arguments (got {0}, expected {1})", s.Args.Count, callee.Ins.Count);
       } else if (callee.Outs.Count != s.Lhs.Count) {
         if (isInitCall) {
-          Error(s, "a method called as an initialization method must not have any result arguments");
+          reporter.Error(MessageSource.Resolver, s, "a method called as an initialization method must not have any result arguments");
         } else {
-          Error(s, "wrong number of method result arguments (got {0}, expected {1})", s.Lhs.Count, callee.Outs.Count);
+          reporter.Error(MessageSource.Resolver, s, "wrong number of method result arguments (got {0}, expected {1})", s.Lhs.Count, callee.Outs.Count);
         }
       } else {
         if (isInitCall) {
           if (callee.IsStatic) {
-            Error(s.Tok, "a method called as an initialization method must not be 'static'");
+            reporter.Error(MessageSource.Resolver, s.Tok, "a method called as an initialization method must not be 'static'");
           }
         } else if (!callee.IsStatic) {
           if (!scope.AllowInstance && s.Receiver is ThisExpr) {
             // The call really needs an instance, but that instance is given as 'this', which is not
             // available in this context.  For more details, see comment in the resolution of a
             // FunctionCallExpr.
-            Error(s.Receiver, "'this' is not allowed in a 'static' context");
+            reporter.Error(MessageSource.Resolver, s.Receiver, "'this' is not allowed in a 'static' context");
           } else if (s.Receiver is StaticReceiverExpr) {
-            Error(s.Receiver, "call to instance method requires an instance");
+            reporter.Error(MessageSource.Resolver, s.Receiver, "call to instance method requires an instance");
           }
         }
         // type check the arguments
         for (int i = 0; i < callee.Ins.Count; i++) {
           Type st = SubstType(callee.Ins[i].Type, s.MethodSelect.TypeArgumentSubstitutions());
           if (!UnifyTypes(cce.NonNull(s.Args[i].Type), st)) {
-            Error(s, "incorrect type of method in-parameter {0} (expected {1}, got {2})", i, st, s.Args[i].Type);
+            reporter.Error(MessageSource.Resolver, s, "incorrect type of method in-parameter {0} (expected {1}, got {2})", i, st, s.Args[i].Type);
           }
         }
         for (int i = 0; i < callee.Outs.Count; i++) {
           Type st = SubstType(callee.Outs[i].Type, s.MethodSelect.TypeArgumentSubstitutions());
           var lhs = s.Lhs[i];
           if (!UnifyTypes(cce.NonNull(lhs.Type), st)) {
-            Error(s, "incorrect type of method out-parameter {0} (expected {1}, got {2})", i, st, lhs.Type);
+            reporter.Error(MessageSource.Resolver, s, "incorrect type of method out-parameter {0} (expected {1}, got {2})", i, st, lhs.Type);
           } else {
             var resolvedLhs = lhs.Resolved;
             if (!specContextOnly && (s.IsGhost || callee.Outs[i].IsGhost)) {
@@ -6246,17 +6130,17 @@ namespace Microsoft.Dafny
                     // the variable was actually declared in this statement, so auto-declare it as ghost
                     ((LocalVariable)ll.Var).MakeGhost();
                   } else {
-                    Error(s, "actual out-parameter {0} is required to be a ghost variable", i);
+                    reporter.Error(MessageSource.Resolver, s, "actual out-parameter {0} is required to be a ghost variable", i);
                   }
                 }
               } else if (resolvedLhs is MemberSelectExpr) {
                 var ll = (MemberSelectExpr)resolvedLhs;
                 if (!ll.Member.IsGhost) {
-                  Error(s, "actual out-parameter {0} is required to be a ghost field", i);
+                  reporter.Error(MessageSource.Resolver, s, "actual out-parameter {0} is required to be a ghost field", i);
                 }
               } else {
                 // this is an array update, and arrays are always non-ghost
-                Error(s, "actual out-parameter {0} is required to be a ghost variable", i);
+                reporter.Error(MessageSource.Resolver, s, "actual out-parameter {0} is required to be a ghost variable", i);
               }
             }
             // LHS must denote a mutable field.
@@ -6283,7 +6167,7 @@ namespace Microsoft.Dafny
         }
       }
       if (Contract.Exists(callee.Decreases.Expressions, e => e is WildcardExpr) && !codeContext.AllowsNontermination) {
-        Error(s.Tok, "a call to a possibly non-terminating method is allowed only if the calling method is also declared (with 'decreases *') to be possibly non-terminating");
+        reporter.Error(MessageSource.Resolver, s.Tok, "a call to a possibly non-terminating method is allowed only if the calling method is also declared (with 'decreases *') to be possibly non-terminating");
       }
     }
 
@@ -6298,26 +6182,26 @@ namespace Microsoft.Dafny
       if (lhs is IdentifierExpr) {
         var ll = (IdentifierExpr)lhs;
         if (!ll.Var.IsMutable) {
-          Error(lhs, "LHS of assignment must denote a mutable variable");
+          reporter.Error(MessageSource.Resolver, lhs, "LHS of assignment must denote a mutable variable");
         }
       } else if (lhs is MemberSelectExpr) {
         var ll = (MemberSelectExpr)lhs;
         var field = ll.Member as Field;
         if (field == null || !field.IsUserMutable) {
-          Error(lhs, "LHS of assignment must denote a mutable field");
+          reporter.Error(MessageSource.Resolver, lhs, "LHS of assignment must denote a mutable field");
         }
       } else if (lhs is SeqSelectExpr) {
         var ll = (SeqSelectExpr)lhs;
         if (!UnifyTypes(ll.Seq.Type, ResolvedArrayType(ll.Seq.tok, 1, new InferredTypeProxy(), codeContext))) {
-          Error(ll.Seq, "LHS of array assignment must denote an array element (found {0})", ll.Seq.Type);
+          reporter.Error(MessageSource.Resolver, ll.Seq, "LHS of array assignment must denote an array element (found {0})", ll.Seq.Type);
         }
         if (!ll.SelectOne) {
-          Error(ll.Seq, "cannot assign to a range of array elements (try the 'forall' statement)");
+          reporter.Error(MessageSource.Resolver, ll.Seq, "cannot assign to a range of array elements (try the 'forall' statement)");
         }
       } else if (lhs is MultiSelectExpr) {
         // nothing to check; this can only denote an array element
       } else {
-        Error(lhs, "LHS of assignment must denote a mutable variable or field");
+        reporter.Error(MessageSource.Resolver, lhs, "LHS of assignment must denote a mutable variable or field");
       }
     }
 
@@ -6333,9 +6217,9 @@ namespace Microsoft.Dafny
           Contract.Assert(lnode.Name != null);  // LabelNode's with .Label==null are added only during resolution of the break statements with 'stmt' as their target, which hasn't happened yet
           var prev = labeledStatements.Find(lnode.Name);
           if (prev == ss) {
-            Error(lnode.Tok, "duplicate label");
+            reporter.Error(MessageSource.Resolver, lnode.Tok, "duplicate label");
           } else if (prev != null) {
-            Error(lnode.Tok, "label shadows an enclosing label");
+            reporter.Error(MessageSource.Resolver, lnode.Tok, "label shadows an enclosing label");
           } else {
             var r = labeledStatements.Push(lnode.Name, ss);
             Contract.Assert(r == Scope<Statement>.PushResult.Success);  // since we just checked for duplicates, we expect the Push to succeed
@@ -6357,13 +6241,13 @@ namespace Microsoft.Dafny
       if (stmt is PredicateStmt) {
         // cool
       } else if (stmt is PrintStmt) {
-        Error(stmt, "print statement is not allowed inside a forall statement");
+        reporter.Error(MessageSource.Resolver, stmt, "print statement is not allowed inside a forall statement");
       } else if (stmt is BreakStmt) {
         // this case is checked already in the first pass through the forall-statement body, by doing so from an empty set of labeled statements and resetting the loop-stack
       } else if (stmt is ReturnStmt) {
-        Error(stmt, "return statement is not allowed inside a forall statement");
+        reporter.Error(MessageSource.Resolver, stmt, "return statement is not allowed inside a forall statement");
       } else if (stmt is YieldStmt) {
-        Error(stmt, "yield statement is not allowed inside a forall statement");
+        reporter.Error(MessageSource.Resolver, stmt, "yield statement is not allowed inside a forall statement");
       } else if (stmt is AssignSuchThatStmt) {
         var s = (AssignSuchThatStmt)stmt;
         foreach (var lhs in s.Lhss) {
@@ -6385,9 +6269,9 @@ namespace Microsoft.Dafny
         var rhs = s.Rhs;  // ExprRhs and HavocRhs are fine, but TypeRhs is not
         if (rhs is TypeRhs) {
           if (kind == ForallStmt.ParBodyKind.Assign) {
-            Error(rhs.Tok, "new allocation not supported in forall statements");
+            reporter.Error(MessageSource.Resolver, rhs.Tok, "new allocation not supported in forall statements");
           } else {
-            Error(rhs.Tok, "new allocation not allowed in ghost context");
+            reporter.Error(MessageSource.Resolver, rhs.Tok, "new allocation not allowed in ghost context");
           }
         }
       } else if (stmt is CallStmt) {
@@ -6396,14 +6280,14 @@ namespace Microsoft.Dafny
           var idExpr = lhs as IdentifierExpr;
           if (idExpr != null) {
             if (scope.ContainsDecl(idExpr.Var)) {
-              Error(stmt, "body of forall statement is attempting to update a variable declared outside the forall statement");
+              reporter.Error(MessageSource.Resolver, stmt, "body of forall statement is attempting to update a variable declared outside the forall statement");
             }
           } else {
-            Error(stmt, "the body of the enclosing forall statement is not allowed to update heap locations");
+            reporter.Error(MessageSource.Resolver, stmt, "the body of the enclosing forall statement is not allowed to update heap locations");
           }
         }
         if (s.Method.Mod.Expressions.Count != 0) {
-          Error(stmt, "the body of the enclosing forall statement is not allowed to update heap locations, so any call must be to a method with an empty modifies clause");
+          reporter.Error(MessageSource.Resolver, stmt, "the body of the enclosing forall statement is not allowed to update heap locations, so any call must be to a method with an empty modifies clause");
         }
         if (!s.Method.IsGhost) {
           // The reason for this restriction is that the compiler is going to omit the forall statement altogether--it has
@@ -6411,7 +6295,7 @@ namespace Microsoft.Dafny
           // a method that prints something, all calls to non-ghost methods are disallowed.  (Note, if this restriction
           // is somehow lifted in the future, then it is still necessary to enforce s.Method.Mod.Expressions.Count != 0 for
           // calls to non-ghost methods.)
-          Error(s, "the body of the enclosing forall statement is not allowed to call non-ghost methods");
+          reporter.Error(MessageSource.Resolver, s, "the body of the enclosing forall statement is not allowed to call non-ghost methods");
         }
 
       } else if (stmt is BlockStmt) {
@@ -6455,7 +6339,7 @@ namespace Microsoft.Dafny
         var s = (ForallStmt)stmt;
         switch (s.Kind) {
           case ForallStmt.ParBodyKind.Assign:
-            Error(stmt, "a forall statement with heap updates is not allowed inside the body of another forall statement");
+            reporter.Error(MessageSource.Resolver, stmt, "a forall statement with heap updates is not allowed inside the body of another forall statement");
             break;
           case ForallStmt.ParBodyKind.Call:
           case ForallStmt.ParBodyKind.Proof:
@@ -6486,10 +6370,10 @@ namespace Microsoft.Dafny
       var idExpr = lhs as IdentifierExpr;
       if (idExpr != null) {
         if (scope.ContainsDecl(idExpr.Var)) {
-          Error(tok, "body of forall statement is attempting to update a variable declared outside the forall statement");
+          reporter.Error(MessageSource.Resolver, tok, "body of forall statement is attempting to update a variable declared outside the forall statement");
         }
       } else if (kind != ForallStmt.ParBodyKind.Assign) {
-        Error(tok, "the body of the enclosing forall statement is not allowed to update heap locations");
+        reporter.Error(MessageSource.Resolver, tok, "the body of the enclosing forall statement is not allowed to update heap locations");
       }
     }
 
@@ -6506,9 +6390,9 @@ namespace Microsoft.Dafny
       } else if (stmt is BreakStmt) {
         // already checked while resolving hints
       } else if (stmt is ReturnStmt) {
-        Error(stmt, "return statement is not allowed inside a hint");
+        reporter.Error(MessageSource.Resolver, stmt, "return statement is not allowed inside a hint");
       } else if (stmt is YieldStmt) {
-        Error(stmt, "yield statement is not allowed inside a hint");
+        reporter.Error(MessageSource.Resolver, stmt, "yield statement is not allowed inside a hint");
       } else if (stmt is AssignSuchThatStmt) {
         var s = (AssignSuchThatStmt)stmt;
         foreach (var lhs in s.Lhss) {
@@ -6520,7 +6404,7 @@ namespace Microsoft.Dafny
       } else if (stmt is CallStmt) {
         var s = (CallStmt)stmt;
         if (s.Method.Mod.Expressions.Count != 0) {
-          Error(stmt, "calls to methods with side-effects are not allowed inside a hint");
+          reporter.Error(MessageSource.Resolver, stmt, "calls to methods with side-effects are not allowed inside a hint");
         }
       } else if (stmt is UpdateStmt) {
         var s = (UpdateStmt)stmt;
@@ -6558,7 +6442,7 @@ namespace Microsoft.Dafny
       } else if (stmt is WhileStmt) {
         var s = (WhileStmt)stmt;
         if (s.Mod.Expressions != null && s.Mod.Expressions.Count != 0) {
-          Error(s.Mod.Expressions[0].tok, "a while statement used inside a hint is not allowed to have a modifies clause");
+          reporter.Error(MessageSource.Resolver, s.Mod.Expressions[0].tok, "a while statement used inside a hint is not allowed to have a modifies clause");
         }
         if (s.Body != null) {
           CheckHintRestrictions(s.Body);
@@ -6576,7 +6460,7 @@ namespace Microsoft.Dafny
         var s = (ForallStmt)stmt;
         switch (s.Kind) {
           case ForallStmt.ParBodyKind.Assign:
-            Error(stmt, "a forall statement with heap updates is not allowed inside a hint");
+            reporter.Error(MessageSource.Resolver, stmt, "a forall statement with heap updates is not allowed inside a hint");
             break;
           case ForallStmt.ParBodyKind.Call:
           case ForallStmt.ParBodyKind.Proof:
@@ -6609,9 +6493,9 @@ namespace Microsoft.Dafny
     void CheckHintLhs(IToken tok, Expression lhs) {
       var idExpr = lhs as IdentifierExpr;
       if (idExpr == null) {
-        Error(tok, "a hint is not allowed to update heap locations");
+        reporter.Error(MessageSource.Resolver, tok, "a hint is not allowed to update heap locations");
       } else if (scope.ContainsDecl(idExpr.Var)) {
-        Error(tok, "a hint is not allowed to update a variable declared outside the hint");
+        reporter.Error(MessageSource.Resolver, tok, "a hint is not allowed to update a variable declared outside the hint");
       }
     }
 
@@ -6623,7 +6507,7 @@ namespace Microsoft.Dafny
 
       // "new" is not allowed in ghost contexts
       if (specContextOnly) {
-        Error(rr.Tok, "'new' is not allowed in ghost contexts");
+        reporter.Error(MessageSource.Resolver, rr.Tok, "'new' is not allowed in ghost contexts");
       }
       if (rr.Type == null) {
         if (rr.ArrayDimensions != null) {
@@ -6635,7 +6519,7 @@ namespace Microsoft.Dafny
             Contract.Assert(dim != null);
             ResolveExpression(dim, new ResolveOpts(codeContext, true));
             if (!UnifyTypes(dim.Type, new OperationTypeProxy(true, false, false, false, false, false))) {
-              Error(stmt, "new must use an integer-based expression for the array size (got {0} for index {1})", dim.Type, i);
+              reporter.Error(MessageSource.Resolver, stmt, "new must use an integer-based expression for the array size (got {0} for index {1})", dim.Type, i);
             }
             i++;
           }
@@ -6645,7 +6529,7 @@ namespace Microsoft.Dafny
           if (rr.Arguments == null) {
             ResolveType(stmt.Tok, rr.EType, codeContext, ResolveTypeOptionEnum.InferTypeProxies, null);
             if (!rr.EType.IsRefType) {
-              Error(stmt, "new can be applied only to reference types (got {0})", rr.EType);
+              reporter.Error(MessageSource.Resolver, stmt, "new can be applied only to reference types (got {0})", rr.EType);
             }
           } else {
             string initCallName = null;
@@ -6668,18 +6552,18 @@ namespace Microsoft.Dafny
               initCallTok = rr.Tok;
             }
             if (!rr.EType.IsRefType) {
-              Error(stmt, "new can be applied only to reference types (got {0})", rr.EType);
+              reporter.Error(MessageSource.Resolver, stmt, "new can be applied only to reference types (got {0})", rr.EType);
             } else {
               // ---------- new C.Init(EE)
               Contract.Assert(initCallName != null);
-              var prevErrorCount = ErrorCount;
+              var prevErrorCount = reporter.Count(ErrorLevel.Error);
 
               // We want to create a MemberSelectExpr for the initializing method.  To do that, we create a throw-away receiver of the appropriate
               // type, create an dot-suffix expression around this receiver, and then resolve it in the usual way for dot-suffix expressions.
               var lhs = new ImplicitThisExpr(initCallTok) { Type = rr.EType };
               var callLhs = new ExprDotName(initCallTok, lhs, initCallName, ret == null ? null : ret.LastComponent.OptTypeArguments);
               ResolveDotSuffix(callLhs, true, rr.Arguments, new ResolveOpts(codeContext, true, specContextOnly), true);
-              if (prevErrorCount == ErrorCount) {
+              if (prevErrorCount == reporter.Count(ErrorLevel.Error)) {
                 Contract.Assert(callLhs.ResolvedExpression is MemberSelectExpr);  // since ResolveApplySuffix succeeded and call.Lhs denotes an expression (not a module or a type)
                 var methodSel = (MemberSelectExpr)callLhs.ResolvedExpression;
                 if (methodSel.Member is Method) {
@@ -6689,7 +6573,7 @@ namespace Microsoft.Dafny
                     callsConstructor = true;
                   }
                 } else {
-                  Error(initCallTok, "object initialization must denote an initializing method or constructor ({0})", initCallName);
+                  reporter.Error(MessageSource.Resolver, initCallTok, "object initialization must denote an initializing method or constructor ({0})", initCallName);
                 }
               }
             }
@@ -6699,10 +6583,10 @@ namespace Microsoft.Dafny
             if (udt != null) {
               var cl = (ClassDecl)udt.ResolvedClass;  // cast is guaranteed by the call to rr.EType.IsRefType above, together with the "rr.EType is UserDefinedType" test
               if (cl is TraitDecl) {
-                Error(stmt, "new cannot be applied to a trait");
+                reporter.Error(MessageSource.Resolver, stmt, "new cannot be applied to a trait");
               }
               if (!callsConstructor && cl.HasConstructor) {
-                Error(stmt, "when allocating an object of type '{0}', one of its constructor methods must be called", cl.Name);
+                reporter.Error(MessageSource.Resolver, stmt, "when allocating an object of type '{0}', one of its constructor methods must be called", cl.Name);
               }
             }
           }
@@ -6731,7 +6615,7 @@ namespace Microsoft.Dafny
         }
       }
       if (receiverType is TypeProxy) {
-        Error(tok, "type of the receiver is not fully determined at this program point", receiverType);
+        reporter.Error(MessageSource.Resolver, tok, "type of the receiver is not fully determined at this program point", receiverType);
         return null;
       }
       Contract.Assert(receiverType is NonProxyType);  // there are only two kinds of types: proxies and non-proxies
@@ -6744,20 +6628,20 @@ namespace Microsoft.Dafny
         if (!classMembers[cd].TryGetValue(memberName, out member)) {
           var kind = cd is IteratorDecl ? "iterator" : "class";
           if (memberName == "_ctor") {
-            Error(tok, "{0} {1} does not have an anonymous constructor", kind, ctype.Name);
+            reporter.Error(MessageSource.Resolver, tok, "{0} {1} does not have an anonymous constructor", kind, ctype.Name);
           } else {
             // search the static members of the enclosing module or its imports
             if (moduleInfo.StaticMembers.TryGetValue(memberName, out member)) {
               Contract.Assert(member.IsStatic); // moduleInfo.StaticMembers is supposed to contain only static members of the module's implicit class _default
               if (member is AmbiguousMemberDecl) {
                 var ambiguousMember = (AmbiguousMemberDecl)member;
-                Error(tok, "The name {0} ambiguously refers to a static member in one of the modules {1} (try qualifying the member name with the module name)", memberName, ambiguousMember.ModuleNames());
+                reporter.Error(MessageSource.Resolver, tok, "The name {0} ambiguously refers to a static member in one of the modules {1} (try qualifying the member name with the module name)", memberName, ambiguousMember.ModuleNames());
               } else {
                 nptype = GetReceiverType(tok, member);
                 return member;
               }
             } else {
-              Error(tok, "member {0} does not exist in {2} {1}", memberName, ctype.Name, kind);
+              reporter.Error(MessageSource.Resolver, tok, "member {0} does not exist in {2} {1}", memberName, ctype.Name, kind);
             }
           }
           return null;
@@ -6771,7 +6655,7 @@ namespace Microsoft.Dafny
       if (dtd != null) {
         MemberDecl member;
         if (!datatypeMembers[dtd].TryGetValue(memberName, out member)) {
-          Error(tok, "member {0} does not exist in datatype {1}", memberName, dtd.Name);
+          reporter.Error(MessageSource.Resolver, tok, "member {0} does not exist in datatype {1}", memberName, dtd.Name);
           return null;
         } else {
           nptype = (UserDefinedType)receiverType;
@@ -6797,7 +6681,7 @@ namespace Microsoft.Dafny
         }
       }
 
-      Error(tok, "type {0} does not have a member {1}", receiverType, memberName);
+      reporter.Error(MessageSource.Resolver, tok, "type {0} does not have a member {1}", receiverType, memberName);
       return null;
     }
 
@@ -7021,10 +6905,10 @@ namespace Microsoft.Dafny
 
       } else if (expr is NegationExpression) {
         var e = (NegationExpression)expr;
-        var errorCount = ErrorCount;
+        var errorCount = reporter.Count(ErrorLevel.Error);
         ResolveExpression(e.E, opts);
         e.Type = e.E.Type;
-        if (errorCount != ErrorCount) {
+        if (errorCount != reporter.Count(ErrorLevel.Error)) {
           // there were errors resolving the operand; take the quick way out and
           // just let the (already erronous) subexpression be what the negation expression
           // will resolve to
@@ -7074,7 +6958,7 @@ namespace Microsoft.Dafny
         }
       } else if (expr is ThisExpr) {
         if (!scope.AllowInstance) {
-          Error(expr, "'this' is not allowed in a 'static' context");
+          reporter.Error(MessageSource.Resolver, expr, "'this' is not allowed in a 'static' context");
         }
         if (currentClass != null) {
           expr.Type = GetThisType(expr.tok, currentClass);  // do this regardless of scope.AllowInstance, for better error reporting
@@ -7086,19 +6970,19 @@ namespace Microsoft.Dafny
         if (e.Var != null) {
           expr.Type = e.Var.Type;
         } else {
-          Error(expr, "Identifier does not denote a local variable, parameter, or bound variable: {0}", e.Name);
+          reporter.Error(MessageSource.Resolver, expr, "Identifier does not denote a local variable, parameter, or bound variable: {0}", e.Name);
         }
 
       } else if (expr is DatatypeValue) {
         DatatypeValue dtv = (DatatypeValue)expr;
         TopLevelDecl d;
         if (!moduleInfo.TopLevels.TryGetValue(dtv.DatatypeName, out d)) {
-          Error(expr.tok, "Undeclared datatype: {0}", dtv.DatatypeName);
+          reporter.Error(MessageSource.Resolver, expr.tok, "Undeclared datatype: {0}", dtv.DatatypeName);
         } else if (d is AmbiguousTopLevelDecl) {
           var ad = (AmbiguousTopLevelDecl)d;
-          Error(expr.tok, "The name {0} ambiguously refers to a type in one of the modules {1} (try qualifying the type name with the module name)", dtv.DatatypeName, ad.ModuleNames());
+          reporter.Error(MessageSource.Resolver, expr.tok, "The name {0} ambiguously refers to a type in one of the modules {1} (try qualifying the type name with the module name)", dtv.DatatypeName, ad.ModuleNames());
         } else if (!(d is DatatypeDecl)) {
-          Error(expr.tok, "Expected datatype: {0}", dtv.DatatypeName);
+          reporter.Error(MessageSource.Resolver, expr.tok, "Expected datatype: {0}", dtv.DatatypeName);
         } else {
           ResolveDatatypeValue(opts, dtv, (DatatypeDecl)d);
         }
@@ -7110,7 +6994,7 @@ namespace Microsoft.Dafny
           ResolveExpression(ee, opts);
           Contract.Assert(ee.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(elementType, ee.Type)) {
-            Error(ee, "All elements of display must be of the same type (got {0}, but type of previous elements is {1})", ee.Type, elementType);
+            reporter.Error(MessageSource.Resolver, ee, "All elements of display must be of the same type (got {0}, but type of previous elements is {1})", ee.Type, elementType);
           }
         }
         if (expr is SetDisplayExpr) {
@@ -7129,12 +7013,12 @@ namespace Microsoft.Dafny
           ResolveExpression(p.A, opts);
           Contract.Assert(p.A.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(domainType, p.A.Type)) {
-            Error(p.A, "All elements of display must be of the same type (got {0}, but type of previous elements is {1})", p.A.Type, domainType);
+            reporter.Error(MessageSource.Resolver, p.A, "All elements of display must be of the same type (got {0}, but type of previous elements is {1})", p.A.Type, domainType);
           }
           ResolveExpression(p.B, opts);
           Contract.Assert(p.B.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(rangeType, p.B.Type)) {
-            Error(p.B, "All elements of display must be of the same type (got {0}, but type of previous elements is {1})", p.B.Type, rangeType);
+            reporter.Error(MessageSource.Resolver, p.B, "All elements of display must be of the same type (got {0}, but type of previous elements is {1})", p.B.Type, rangeType);
           }
         }
         expr.Type = new MapType(e.Finite, domainType, rangeType);
@@ -7142,18 +7026,18 @@ namespace Microsoft.Dafny
         var e = (NameSegment)expr;
         ResolveNameSegment(e, true, null, opts, false);
         if (e.Type is Resolver_IdentifierExpr.ResolverType_Module) {
-          Error(e.tok, "name of module ({0}) is used as a variable", e.Name);
+          reporter.Error(MessageSource.Resolver, e.tok, "name of module ({0}) is used as a variable", e.Name);
         } else if (e.Type is Resolver_IdentifierExpr.ResolverType_Type) {
-          Error(e.tok, "name of type ({0}) is used as a variable", e.Name);
+          reporter.Error(MessageSource.Resolver, e.tok, "name of type ({0}) is used as a variable", e.Name);
         }
 
       } else if (expr is ExprDotName) {
         var e = (ExprDotName)expr;
         ResolveDotSuffix(e, true, null, opts, false);
         if (e.Type is Resolver_IdentifierExpr.ResolverType_Module) {
-          Error(e.tok, "name of module ({0}) is used as a variable", e.SuffixName);
+          reporter.Error(MessageSource.Resolver, e.tok, "name of module ({0}) is used as a variable", e.SuffixName);
         } else if (e.Type is Resolver_IdentifierExpr.ResolverType_Type) {
-          Error(e.tok, "name of type ({0}) is used as a variable", e.SuffixName);
+          reporter.Error(MessageSource.Resolver, e.tok, "name of type ({0}) is used as a variable", e.SuffixName);
         }
 
       } else if (expr is ApplySuffix) {
@@ -7193,7 +7077,7 @@ namespace Microsoft.Dafny
           var field = (Field)member;
           e.Member = field;
           if (e.Obj is StaticReceiverExpr) {
-            Error(expr, "a field must be selected via an object, not just a class name");
+            reporter.Error(MessageSource.Resolver, expr, "a field must be selected via an object, not just a class name");
           }
           var ctype = nptype as UserDefinedType;
           if (ctype == null) {
@@ -7205,7 +7089,7 @@ namespace Microsoft.Dafny
             e.Type = SubstType(field.Type, subst);
           }
         } else {
-          Error(expr, "member {0} in type {1} does not refer to a field or a function", e.MemberName, nptype);
+          reporter.Error(MessageSource.Resolver, expr, "member {0} in type {1} does not refer to a field or a function", e.MemberName, nptype);
         }
 
       } else if (expr is SeqSelectExpr) {
@@ -7219,7 +7103,7 @@ namespace Microsoft.Dafny
         Contract.Assert(e.Array.Type != null);  // follows from postcondition of ResolveExpression
         Type elementType = new InferredTypeProxy();
         if (!UnifyTypes(e.Array.Type, ResolvedArrayType(e.Array.tok, e.Indices.Count, elementType, opts.codeContext))) {
-          Error(e.Array, "array selection requires an array{0} (got {1})", e.Indices.Count, e.Array.Type);
+          reporter.Error(MessageSource.Resolver, e.Array, "array selection requires an array{0} (got {1})", e.Indices.Count, e.Array.Type);
         }
         int i = 0;
         foreach (Expression idx in e.Indices) {
@@ -7227,7 +7111,7 @@ namespace Microsoft.Dafny
           ResolveExpression(idx, opts);
           Contract.Assert(idx.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(idx.Type, new OperationTypeProxy(true, false, false, false, false, false))) {
-            Error(idx, "array selection requires integer-based numeric indices (got {0} for index {1})", idx.Type, i);
+            reporter.Error(MessageSource.Resolver, idx, "array selection requires integer-based numeric indices (got {0} for index {1})", idx.Type, i);
           }
           i++;
         }
@@ -7244,42 +7128,42 @@ namespace Microsoft.Dafny
           ResolveExpression(e.Index, opts);
           Contract.Assert(e.Index.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(e.Index.Type, Type.Int)) {
-            Error(e.Index, "sequence update requires integer index (got {0})", e.Index.Type);
+            reporter.Error(MessageSource.Resolver, e.Index, "sequence update requires integer index (got {0})", e.Index.Type);
           }
           ResolveExpression(e.Value, opts);
           Contract.Assert(e.Value.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(e.Value.Type, elementType)) {
-            Error(e.Value, "sequence update requires the value to have the element type of the sequence (got {0})", e.Value.Type);
+            reporter.Error(MessageSource.Resolver, e.Value, "sequence update requires the value to have the element type of the sequence (got {0})", e.Value.Type);
           }
           expr.Type = e.Seq.Type;
         } else if (UnifyTypes(e.Seq.Type, new MapType(true, domainType, rangeType))) {
           ResolveExpression(e.Index, opts);
           if (!UnifyTypes(e.Index.Type, domainType)) {
-            Error(e.Index, "map update requires domain element to be of type {0} (got {1})", domainType, e.Index.Type);
+            reporter.Error(MessageSource.Resolver, e.Index, "map update requires domain element to be of type {0} (got {1})", domainType, e.Index.Type);
           }
           ResolveExpression(e.Value, opts);
           if (!UnifyTypes(e.Value.Type, rangeType)) {
-            Error(e.Value, "map update requires the value to have the range type {0} (got {1})", rangeType, e.Value.Type);
+            reporter.Error(MessageSource.Resolver, e.Value, "map update requires the value to have the range type {0} (got {1})", rangeType, e.Value.Type);
           }
           expr.Type = e.Seq.Type;
         } else if (UnifyTypes(e.Seq.Type, new MapType(false, domainType, rangeType))) {
           ResolveExpression(e.Index, opts);
           if (!UnifyTypes(e.Index.Type, domainType)) {
-            Error(e.Index, "imap update requires domain element to be of type {0} (got {1})", domainType, e.Index.Type);
+            reporter.Error(MessageSource.Resolver, e.Index, "imap update requires domain element to be of type {0} (got {1})", domainType, e.Index.Type);
           }
           ResolveExpression(e.Value, opts);
           if (!UnifyTypes(e.Value.Type, rangeType)) {
-            Error(e.Value, "imap update requires the value to have the range type {0} (got {1})", rangeType, e.Value.Type);
+            reporter.Error(MessageSource.Resolver, e.Value, "imap update requires the value to have the range type {0} (got {1})", rangeType, e.Value.Type);
           }
           expr.Type = e.Seq.Type;
         } else if (UnifyTypes(e.Seq.Type, new MultiSetType(elementType))) {
           ResolveExpression(e.Index, opts);
           if (!UnifyTypes(e.Index.Type, elementType)) {
-            Error(e.Index, "multiset update requires domain element to be of type {0} (got {1})", elementType, e.Index.Type);
+            reporter.Error(MessageSource.Resolver, e.Index, "multiset update requires domain element to be of type {0} (got {1})", elementType, e.Index.Type);
           }
           ResolveExpression(e.Value, opts);
           if (!UnifyTypes(e.Value.Type, new OperationTypeProxy(true, false, false, false, false, false))) {
-            Error(e.Value, "multiset update requires integer-based numeric value (got {0})", e.Value.Type);
+            reporter.Error(MessageSource.Resolver, e.Value, "multiset update requires integer-based numeric value (got {0})", e.Value.Type);
           }
           expr.Type = e.Seq.Type;
 
@@ -7297,7 +7181,7 @@ namespace Microsoft.Dafny
             var ei = (SeqUpdateExpr)eIter;
 
             if (!(ei.Index is NameSegment|| (ei.Index is LiteralExpr && ((LiteralExpr)ei.Index).Value is BigInteger))) {
-              Error(expr, "datatype updates must be to datatype destructors");
+              reporter.Error(MessageSource.Resolver, expr, "datatype updates must be to datatype destructors");
             } else {
               string destructor_str = null;
 
@@ -7313,12 +7197,12 @@ namespace Microsoft.Dafny
               if (IndexToValue.ContainsKey(destructor_str)) {
                 // Don't bother trying to optimize this case; we'd have to drop one of the updates,
                 // which makes resolving the dropped update an annoyance.
-                Warning(ei.tok, "update to {0} overwritten by another update to {1}", destructor_str, destructor_str);
+                reporter.Warning(MessageSource.Resolver, ei.tok, "update to {0} overwritten by another update to {1}", destructor_str, destructor_str);
                 break;
               }
               MemberDecl member;
               if (!datatypeMembers[dt].TryGetValue(destructor_str, out member)) {
-                Error(expr, "member {0} does not exist in datatype {1}", destructor_str, dt.Name);
+                reporter.Error(MessageSource.Resolver, expr, "member {0} does not exist in datatype {1}", destructor_str, dt.Name);
               } else {
                 DatatypeDestructor destructor = (DatatypeDestructor)member;
                 if (ctor != null && ctor != destructor.EnclosingCtor) {
@@ -7367,7 +7251,7 @@ namespace Microsoft.Dafny
 
           expr.Type = e0.Type;
         } else {
-          Error(expr, "update requires a sequence, map, or datatype (got {0})", e.Seq.Type);
+          reporter.Error(MessageSource.Resolver, expr, "update requires a sequence, map, or datatype (got {0})", e.Seq.Type);
         }
 
       } else if (expr is FunctionCallExpr) {
@@ -7382,13 +7266,13 @@ namespace Microsoft.Dafny
         }
         var fnType = e.Function.Type.AsArrowType;
         if (fnType == null) {
-          Error(e.tok, "non-function expression (of type {0}) is called with parameters", e.Function.Type);
+          reporter.Error(MessageSource.Resolver, e.tok, "non-function expression (of type {0}) is called with parameters", e.Function.Type);
         } else if (fnType.Arity != e.Args.Count) {
-          Error(e.tok, "wrong number of arguments to function application (function type '{0}' expects {1}, got {2})", fnType, fnType.Arity, e.Args.Count);
+          reporter.Error(MessageSource.Resolver, e.tok, "wrong number of arguments to function application (function type '{0}' expects {1}, got {2})", fnType, fnType.Arity, e.Args.Count);
         } else {
           for (var i = 0; i < fnType.Arity; i++) {
             if (!UnifyTypes(fnType.Args[i], e.Args[i].Type)) {
-              Error(e.Args[i].tok, "type mismatch for argument {0} (function expects {1}, got {2})", i, fnType.Args[i], e.Args[i].Type);
+              reporter.Error(MessageSource.Resolver, e.Args[i].tok, "type mismatch for argument {0} (function expects {1}, got {2})", i, fnType.Args[i], e.Args[i].Type);
             }
           }
         }
@@ -7397,7 +7281,7 @@ namespace Microsoft.Dafny
       } else if (expr is OldExpr) {
         OldExpr e = (OldExpr)expr;
         if (!opts.twoState) {
-          Error(expr, "old expressions are not allowed in this context");
+          reporter.Error(MessageSource.Resolver, expr, "old expressions are not allowed in this context");
         }
         ResolveExpression(e.E, opts);
         expr.Type = e.E.Type;
@@ -7406,7 +7290,7 @@ namespace Microsoft.Dafny
         MultiSetFormingExpr e = (MultiSetFormingExpr)expr;
         ResolveExpression(e.E, opts);
         if (!UnifyTypes(e.E.Type, new SetType(true, new InferredTypeProxy())) && !UnifyTypes(e.E.Type, new SeqType(new InferredTypeProxy()))) {
-          Error(e.tok, "can only form a multiset from a seq or set.");
+          reporter.Error(MessageSource.Resolver, e.tok, "can only form a multiset from a seq or set.");
         }
         expr.Type = new MultiSetType(e.E.Type.AsCollectionType.Arg);
 
@@ -7417,19 +7301,19 @@ namespace Microsoft.Dafny
         switch (e.Op) {
           case UnaryOpExpr.Opcode.Not:
             if (!UnifyTypes(e.E.Type, Type.Bool)) {
-              Error(expr, "logical negation expects a boolean argument (instead got {0})", e.E.Type);
+              reporter.Error(MessageSource.Resolver, expr, "logical negation expects a boolean argument (instead got {0})", e.E.Type);
             }
             expr.Type = Type.Bool;
             break;
           case UnaryOpExpr.Opcode.Cardinality:
             if (!UnifyTypes(e.E.Type, new CollectionTypeProxy(new InferredTypeProxy(), false, false))) {
-              Error(expr, "size operator expects a collection argument (instead got {0})", e.E.Type);
+              reporter.Error(MessageSource.Resolver, expr, "size operator expects a collection argument (instead got {0})", e.E.Type);
             }
             expr.Type = Type.Int;
             break;
           case UnaryOpExpr.Opcode.Fresh:
             if (!opts.twoState) {
-              Error(expr, "fresh expressions are not allowed in this context");
+              reporter.Error(MessageSource.Resolver, expr, "fresh expressions are not allowed in this context");
             }
             // the type of e.E must be either an object or a collection of objects
             Type t = e.E.Type.NormalizeExpand();
@@ -7444,7 +7328,7 @@ namespace Microsoft.Dafny
             } else if (t.IsDatatype) {
               // fine, treat this as the datatype itself.
             } else {
-              Error(expr, "the argument of a fresh expression must denote an object or a collection of objects (instead got {0})", e.E.Type);
+              reporter.Error(MessageSource.Resolver, expr, "the argument of a fresh expression must denote an object or a collection of objects (instead got {0})", e.E.Type);
             }
             expr.Type = Type.Bool;
             break;
@@ -7458,14 +7342,14 @@ namespace Microsoft.Dafny
         ResolveExpression(e.E, opts);
         if (e.ToType.IsNumericBased(Type.NumericPersuation.Int)) {
           if (!UnifyTypes(e.E.Type, new OperationTypeProxy(true, true, false, false, false, false))) {
-            Error(expr, "type conversion to an int-based type is allowed only from numeric types (got {0})", e.E.Type);
+            reporter.Error(MessageSource.Resolver, expr, "type conversion to an int-based type is allowed only from numeric types (got {0})", e.E.Type);
           }
         } else if (e.ToType.IsNumericBased(Type.NumericPersuation.Real)) {
           if (!UnifyTypes(e.E.Type, new OperationTypeProxy(true, true, false, false, false, false))) {
-            Error(expr, "type conversion to a real-based type is allowed only from numeric types (got {0})", e.E.Type);
+            reporter.Error(MessageSource.Resolver, expr, "type conversion to a real-based type is allowed only from numeric types (got {0})", e.E.Type);
           }
         } else {
-          Error(expr, "type conversions are not supported to this type (got {0})", e.ToType);
+          reporter.Error(MessageSource.Resolver, expr, "type conversions are not supported to this type (got {0})", e.ToType);
         }
         e.Type = e.ToType;
 
@@ -7482,10 +7366,10 @@ namespace Microsoft.Dafny
           case BinaryExpr.Opcode.And:
           case BinaryExpr.Opcode.Or:
             if (!UnifyTypes(e.E0.Type, Type.Bool)) {
-              Error(expr, "first argument to {0} must be of type bool (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E0.Type);
+              reporter.Error(MessageSource.Resolver, expr, "first argument to {0} must be of type bool (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E0.Type);
             }
             if (!UnifyTypes(e.E1.Type, Type.Bool)) {
-              Error(expr, "second argument to {0} must be of type bool (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E1.Type);
+              reporter.Error(MessageSource.Resolver, expr, "second argument to {0} must be of type bool (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E1.Type);
             }
             expr.Type = Type.Bool;
             break;
@@ -7506,7 +7390,7 @@ namespace Microsoft.Dafny
               // unification will succeed.
             } else {
               // The types are not comparable and do not unify.  It's time for an error message.
-              Error(expr, "arguments must have the same type (got {0} and {1})", e.E0.Type, e.E1.Type);
+              reporter.Error(MessageSource.Resolver, expr, "arguments must have the same type (got {0} and {1})", e.E0.Type, e.E1.Type);
             }
             expr.Type = Type.Bool;
             break;
@@ -7514,12 +7398,12 @@ namespace Microsoft.Dafny
           case BinaryExpr.Opcode.Disjoint:
             // TODO: the error messages are backwards from what (ideally) they should be. this is necessary because UnifyTypes can't backtrack.
             if (!UnifyTypes(e.E0.Type, e.E1.Type)) {
-              Error(expr, "arguments must have the same type (got {0} and {1})", e.E0.Type, e.E1.Type);
+              reporter.Error(MessageSource.Resolver, expr, "arguments must have the same type (got {0} and {1})", e.E0.Type, e.E1.Type);
             }
             if (!UnifyTypes(e.E0.Type, new SetType(true, new InferredTypeProxy())) &&
                 !UnifyTypes(e.E0.Type, new MultiSetType(new InferredTypeProxy())) &&
                 !UnifyTypes(e.E0.Type, new MapType(true, new InferredTypeProxy(), new InferredTypeProxy()))) {
-              Error(expr, "arguments must be of a [multi]set or map type (got {0})", e.E0.Type);
+              reporter.Error(MessageSource.Resolver, expr, "arguments must be of a [multi]set or map type (got {0})", e.E0.Type);
             }
             expr.Type = Type.Bool;
             break;
@@ -7531,26 +7415,26 @@ namespace Microsoft.Dafny
                 if (UnifyTypes(e.E1.Type, new DatatypeProxy(false, false))) {
                   e.ResolvedOp = BinaryExpr.ResolvedOpcode.RankLt;
                 } else {
-                  Error(expr, "arguments to rank comparison must be datatypes (instead of {0})", e.E1.Type);
+                  reporter.Error(MessageSource.Resolver, expr, "arguments to rank comparison must be datatypes (instead of {0})", e.E1.Type);
                 }
                 expr.Type = Type.Bool;
               } else if (e.Op == BinaryExpr.Opcode.Lt && e.E1.Type.NormalizeExpand().IsIndDatatype) {
                 if (UnifyTypes(e.E0.Type, new DatatypeProxy(false, true))) {
                   e.ResolvedOp = BinaryExpr.ResolvedOpcode.RankLt;
                 } else {
-                  Error(expr, "arguments to rank comparison must be datatypes (instead of {0})", e.E0.Type);
+                  reporter.Error(MessageSource.Resolver, expr, "arguments to rank comparison must be datatypes (instead of {0})", e.E0.Type);
                 }
                 expr.Type = Type.Bool;
               } else {
                 bool err = false;
                 bool isComparison = e.Op != BinaryExpr.Opcode.Add;
                 if (!UnifyTypes(e.E0.Type, new OperationTypeProxy(true, true, isComparison, true, true, true))) {
-                  Error(expr, "arguments to {0} must be of a numeric type{2} or a collection type (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E0.Type,
+                  reporter.Error(MessageSource.Resolver, expr, "arguments to {0} must be of a numeric type{2} or a collection type (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E0.Type,
                     isComparison ? ", char," : "");
                   err = true;
                 }
                 if (!UnifyTypes(e.E1.Type, e.E0.Type)) {
-                  Error(expr, "arguments to {0} must have the same type (got {1} and {2})", BinaryExpr.OpcodeString(e.Op), e.E0.Type, e.E1.Type);
+                  reporter.Error(MessageSource.Resolver, expr, "arguments to {0} must have the same type (got {1} and {2})", BinaryExpr.OpcodeString(e.Op), e.E0.Type, e.E1.Type);
                   err = true;
                 }
                 if (isComparison) {
@@ -7570,26 +7454,26 @@ namespace Microsoft.Dafny
                 if (UnifyTypes(e.E1.Type, new DatatypeProxy(false, true))) {
                   e.ResolvedOp = BinaryExpr.ResolvedOpcode.RankGt;
                 } else {
-                  Error(expr, "arguments to rank comparison must be datatypes (instead of {0})", e.E1.Type);
+                  reporter.Error(MessageSource.Resolver, expr, "arguments to rank comparison must be datatypes (instead of {0})", e.E1.Type);
                 }
                 expr.Type = Type.Bool;
               } else if (e.Op == BinaryExpr.Opcode.Gt && (e.E1.Type.NormalizeExpand().IsIndDatatype || e.E1.Type.IsTypeParameter)) {
                 if (UnifyTypes(e.E0.Type, new DatatypeProxy(false, false))) {
                   e.ResolvedOp = BinaryExpr.ResolvedOpcode.RankGt;
                 } else {
-                  Error(expr, "arguments to rank comparison must be datatypes (instead of {0})", e.E0.Type);
+                  reporter.Error(MessageSource.Resolver, expr, "arguments to rank comparison must be datatypes (instead of {0})", e.E0.Type);
                 }
                 expr.Type = Type.Bool;
               } else {
                 bool err = false;
                 bool isComparison = e.Op == BinaryExpr.Opcode.Gt || e.Op == BinaryExpr.Opcode.Ge;
                 if (!UnifyTypes(e.E0.Type, new OperationTypeProxy(true, true, isComparison, false, true, true))) {
-                  Error(expr, "arguments to {0} must be of a numeric type{2} or a set type (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E0.Type,
+                  reporter.Error(MessageSource.Resolver, expr, "arguments to {0} must be of a numeric type{2} or a set type (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E0.Type,
                     isComparison ? ", char, " : "");
                   err = true;
                 }
                 if (!UnifyTypes(e.E1.Type, e.E0.Type)) {
-                  Error(expr, "arguments to {0} must have the same type (got {1} and {2})", BinaryExpr.OpcodeString(e.Op), e.E0.Type, e.E1.Type);
+                  reporter.Error(MessageSource.Resolver, expr, "arguments to {0} must have the same type (got {1} and {2})", BinaryExpr.OpcodeString(e.Op), e.E0.Type, e.E1.Type);
                   err = true;
                 }
                 if (isComparison) {
@@ -7604,27 +7488,27 @@ namespace Microsoft.Dafny
           case BinaryExpr.Opcode.In:
           case BinaryExpr.Opcode.NotIn:
             if (!UnifyTypes(e.E1.Type, new CollectionTypeProxy(e.E0.Type, true, true))) {
-              Error(expr, "second argument to \"{0}\" must be a set, multiset, or sequence with elements of type {1}, or a map with domain {1} (instead got {2})", BinaryExpr.OpcodeString(e.Op), e.E0.Type, e.E1.Type);
+              reporter.Error(MessageSource.Resolver, expr, "second argument to \"{0}\" must be a set, multiset, or sequence with elements of type {1}, or a map with domain {1} (instead got {2})", BinaryExpr.OpcodeString(e.Op), e.E0.Type, e.E1.Type);
             }
             expr.Type = Type.Bool;
             break;
 
           case BinaryExpr.Opcode.Div:
             if (!UnifyTypes(e.E0.Type, new OperationTypeProxy(true, true, false, false, false, false))) {
-              Error(expr, "first argument to {0} must be of numeric type (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E0.Type);
+              reporter.Error(MessageSource.Resolver, expr, "first argument to {0} must be of numeric type (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E0.Type);
             }
             if (!UnifyTypes(e.E1.Type, e.E0.Type)) {
-              Error(expr, "arguments to {0} must have the same type (got {1} and {2})", BinaryExpr.OpcodeString(e.Op), e.E0.Type, e.E1.Type);
+              reporter.Error(MessageSource.Resolver, expr, "arguments to {0} must have the same type (got {1} and {2})", BinaryExpr.OpcodeString(e.Op), e.E0.Type, e.E1.Type);
             }
             expr.Type = e.E0.Type;
             break;
 
           case BinaryExpr.Opcode.Mod:
             if (!UnifyTypes(e.E0.Type, new OperationTypeProxy(true, false, false, false, false, false))) {
-              Error(expr, "first argument to {0} must be of type int (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E0.Type);
+              reporter.Error(MessageSource.Resolver, expr, "first argument to {0} must be of type int (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E0.Type);
             }
             if (!UnifyTypes(e.E1.Type, e.E0.Type)) {
-              Error(expr, "second argument to {0} must be of type int (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E1.Type);
+              reporter.Error(MessageSource.Resolver, expr, "second argument to {0} must be of type int (instead got {1})", BinaryExpr.OpcodeString(e.Op), e.E1.Type);
             }
             expr.Type = e.E0.Type;
             break;
@@ -7644,13 +7528,13 @@ namespace Microsoft.Dafny
           case TernaryExpr.Opcode.PrefixEqOp:
           case TernaryExpr.Opcode.PrefixNeqOp:
             if (!UnifyTypes(e.E0.Type, Type.Int)) {
-              Error(e.E0, "prefix-equality limit argument must be an integer expression (got {0})", e.E0.Type);
+              reporter.Error(MessageSource.Resolver, e.E0, "prefix-equality limit argument must be an integer expression (got {0})", e.E0.Type);
             }
             if (!UnifyTypes(e.E1.Type, new DatatypeProxy(true))) {
-              Error(expr, "arguments to prefix equality must be codatatypes (instead of {0})", e.E1.Type);
+              reporter.Error(MessageSource.Resolver, expr, "arguments to prefix equality must be codatatypes (instead of {0})", e.E1.Type);
             }
             if (!UnifyTypes(e.E1.Type, e.E2.Type)) {
-              Error(expr, "arguments must have the same type (got {0} and {1})", e.E1.Type, e.E2.Type);
+              reporter.Error(MessageSource.Resolver, expr, "arguments must have the same type (got {0} and {1})", e.E1.Type, e.E2.Type);
             }
             expr.Type = Type.Bool;
             break;
@@ -7667,7 +7551,7 @@ namespace Microsoft.Dafny
           }
           scope.PushMarker();
           if (e.LHSs.Count != e.RHSs.Count) {
-            Error(expr, "let expression must have same number of LHSs (found {0}) as RHSs (found {1})", e.LHSs.Count, e.RHSs.Count);
+            reporter.Error(MessageSource.Resolver, expr, "let expression must have same number of LHSs (found {0}) as RHSs (found {1})", e.LHSs.Count, e.RHSs.Count);
           }
           var i = 0;
           foreach (var lhs in e.LHSs) {
@@ -7681,14 +7565,14 @@ namespace Microsoft.Dafny
             }
             if (c == 0) {
               // Every identifier-looking thing in the pattern resolved to a constructor; that is, this LHS is a constant literal
-              Error(lhs.tok, "LHS is a constant literal; to be legal, it must introduce at least one bound variable");
+              reporter.Error(MessageSource.Resolver, lhs.tok, "LHS is a constant literal; to be legal, it must introduce at least one bound variable");
             }
             i++;
           }
         } else {
           // let-such-that expression
           if (e.RHSs.Count != 1) {
-            Error(expr, "let-such-that expression must have just one RHS (found {0})", e.RHSs.Count);
+            reporter.Error(MessageSource.Resolver, expr, "let-such-that expression must have just one RHS (found {0})", e.RHSs.Count);
           }
           // the bound variables are in scope in the RHS of a let-such-that expression
           scope.PushMarker();
@@ -7701,7 +7585,7 @@ namespace Microsoft.Dafny
           foreach (var rhs in e.RHSs) {
             ResolveExpression(rhs, opts);
             if (!UnifyTypes(rhs.Type, Type.Bool)) {
-              Error(rhs.tok, "type of RHS of let-such-that expression must be boolean (got {0})", rhs.Type);
+              reporter.Error(MessageSource.Resolver, rhs.tok, "type of RHS of let-such-that expression must be boolean (got {0})", rhs.Type);
             }
           }
           if (!opts.DontCareAboutCompilation && !e.BoundVars.All(bv => bv.IsGhost)) {
@@ -7720,7 +7604,7 @@ namespace Microsoft.Dafny
         e.Type = e.Body.Type;
       } else if (expr is QuantifierExpr) {
         QuantifierExpr e = (QuantifierExpr)expr;
-        int prevErrorCount = ErrorCount;
+        int prevErrorCount = reporter.Count(ErrorLevel.Error);
         bool _val = true;
         bool typeQuantifier = Attributes.ContainsBool(e.Attributes, "typeQuantifier", ref _val) && _val;
         allTypeParameters.PushMarker();
@@ -7732,19 +7616,19 @@ namespace Microsoft.Dafny
           ResolveType(v.tok, v.Type, opts.codeContext, option, typeQuantifier ? e.TypeArgs : null);
         }
         if (e.TypeArgs.Count > 0 && !typeQuantifier) {
-          Error(expr, "a quantifier cannot quantify over types. Possible fix: use the experimental attribute :typeQuantifier");
+          reporter.Error(MessageSource.Resolver, expr, "a quantifier cannot quantify over types. Possible fix: use the experimental attribute :typeQuantifier");
         }
         if (e.Range != null) {
           ResolveExpression(e.Range, new ResolveOpts(opts, true));
           Contract.Assert(e.Range.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(e.Range.Type, Type.Bool)) {
-            Error(expr, "range of quantifier must be of type bool (instead got {0})", e.Range.Type);
+            reporter.Error(MessageSource.Resolver, expr, "range of quantifier must be of type bool (instead got {0})", e.Range.Type);
           }
         }
         ResolveExpression(e.Term, new ResolveOpts(opts, true));
         Contract.Assert(e.Term.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(e.Term.Type, Type.Bool)) {
-          Error(expr, "body of quantifier must be of type bool (instead got {0})", e.Term.Type);
+          reporter.Error(MessageSource.Resolver, expr, "body of quantifier must be of type bool (instead got {0})", e.Term.Type);
         }
         // Since the body is more likely to infer the types of the bound variables, resolve it
         // first (above) and only then resolve the attributes (below).
@@ -7753,10 +7637,10 @@ namespace Microsoft.Dafny
         allTypeParameters.PopMarker();
         expr.Type = Type.Bool;
 
-        if (prevErrorCount == ErrorCount) {
+        if (prevErrorCount == reporter.Count(ErrorLevel.Error)) {
           var missingBounds = new List<BoundVar>();
           CheckTypeInference(e.LogicalBody());  // we need to resolve operators before the call to DiscoverBounds
-          e.Bounds = DiscoverBounds(e.tok, e.BoundVars, e.LogicalBody(), e is ExistsExpr, false, missingBounds);
+          e.Bounds = DiscoverBounds(e.tok, e.BoundVars, e.LogicalBody(), e is ExistsExpr, false, missingBounds, reporter);
           if (missingBounds.Count != 0) {
             // Report errors here about quantifications that depend on the allocation state.
             var mb = missingBounds;
@@ -7764,7 +7648,7 @@ namespace Microsoft.Dafny
               mb = new List<BoundVar>();  // (who cares if we allocate another array; this happens only in the case of a resolution error anyhow)
               foreach (var bv in missingBounds) {
                 if (bv.Type.IsRefType) {
-                  Error(expr, "a quantifier involved in a function definition is not allowed to depend on the set of allocated references; Dafny's heuristics can't figure out a bound for the values of '{0}'", bv.Name);
+                  reporter.Error(MessageSource.Resolver, expr, "a quantifier involved in a function definition is not allowed to depend on the set of allocated references; Dafny's heuristics can't figure out a bound for the values of '{0}'", bv.Name);
                 } else {
                   mb.Add(bv);
                 }
@@ -7778,7 +7662,7 @@ namespace Microsoft.Dafny
 
       } else if (expr is SetComprehension) {
         var e = (SetComprehension)expr;
-        int prevErrorCount = ErrorCount;
+        int prevErrorCount = reporter.Count(ErrorLevel.Error);
         scope.PushMarker();
         foreach (BoundVar v in e.BoundVars) {
           ScopePushAndReport(scope, v, "bound-variable");
@@ -7787,7 +7671,7 @@ namespace Microsoft.Dafny
         ResolveExpression(e.Range, opts);
         Contract.Assert(e.Range.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(e.Range.Type, Type.Bool)) {
-          Error(expr, "range of comprehension must be of type bool (instead got {0})", e.Range.Type);
+          reporter.Error(MessageSource.Resolver, expr, "range of comprehension must be of type bool (instead got {0})", e.Range.Type);
         }
         ResolveExpression(e.Term, opts);
         Contract.Assert(e.Term.Type != null);  // follows from postcondition of ResolveExpression
@@ -7804,10 +7688,10 @@ namespace Microsoft.Dafny
 
       } else if (expr is MapComprehension) {
         var e = (MapComprehension)expr;
-        int prevErrorCount = ErrorCount;
+        int prevErrorCount = reporter.Count(ErrorLevel.Error);
         scope.PushMarker();
         if (e.BoundVars.Count != 1) {
-          Error(e.tok, "a map comprehension must have exactly one bound variable.");
+          reporter.Error(MessageSource.Resolver, e.tok, "a map comprehension must have exactly one bound variable.");
         }
         foreach (BoundVar v in e.BoundVars) {
           ScopePushAndReport(scope, v, "bound-variable");
@@ -7816,7 +7700,7 @@ namespace Microsoft.Dafny
         ResolveExpression(e.Range, opts);
         Contract.Assert(e.Range.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(e.Range.Type, Type.Bool)) {
-          Error(expr, "range of comprehension must be of type bool (instead got {0})", e.Range.Type);
+          reporter.Error(MessageSource.Resolver, expr, "range of comprehension must be of type bool (instead got {0})", e.Range.Type);
         }
         ResolveExpression(e.Term, opts);
         Contract.Assert(e.Term.Type != null);  // follows from postcondition of ResolveExpression
@@ -7825,22 +7709,22 @@ namespace Microsoft.Dafny
         scope.PopMarker();
         expr.Type = new MapType(e.Finite, e.BoundVars[0].Type, e.Term.Type);
 
-        if (prevErrorCount == ErrorCount) {
+        if (prevErrorCount == reporter.Count(ErrorLevel.Error)) {
           var missingBounds = new List<BoundVar>();
           CheckTypeInference(e.Range);  // we need to resolve operators before the call to DiscoverBounds
-          e.Bounds = DiscoverBounds(e.tok, e.BoundVars, e.Range, true, false, missingBounds);
+          e.Bounds = DiscoverBounds(e.tok, e.BoundVars, e.Range, true, false, missingBounds, reporter);
           if (missingBounds.Count != 0) {
             e.MissingBounds = missingBounds;
             if (e.Finite) {
               foreach (var bv in e.MissingBounds) {
-                Error(expr, "a map comprehension must produce a finite domain, but Dafny's heuristics can't figure out how to produce a bounded set of values for '{0}'", bv.Name);
+                reporter.Error(MessageSource.Resolver, expr, "a map comprehension must produce a finite domain, but Dafny's heuristics can't figure out how to produce a bounded set of values for '{0}'", bv.Name);
               }
             }
           }
         }
       } else if (expr is LambdaExpr) {
         var e = (LambdaExpr)expr;
-        int prevErrorCount = ErrorCount;
+        int prevErrorCount = reporter.Count(ErrorLevel.Error);
         scope.PushMarker();
         foreach (BoundVar v in e.BoundVars) {
           ScopePushAndReport(scope, v, "bound-variable");
@@ -7851,7 +7735,7 @@ namespace Microsoft.Dafny
           ResolveExpression(e.Range, opts);
           Contract.Assert(e.Range.Type != null);  // follows from postcondition of ResolveExpression
           if (!UnifyTypes(e.Range.Type, Type.Bool)) {
-            Error(expr, "Precondition must be boolean (got {0})", e.Range.Type);
+            reporter.Error(MessageSource.Resolver, expr, "Precondition must be boolean (got {0})", e.Range.Type);
           }
         }
 
@@ -7867,14 +7751,14 @@ namespace Microsoft.Dafny
         expr.Type = new SetType(true, new ObjectType());
       } else if (expr is StmtExpr) {
         var e = (StmtExpr)expr;
-        int prevErrorCount = ErrorCount;
+        int prevErrorCount = reporter.Count(ErrorLevel.Error);
         ResolveStatement(e.S, true, opts.codeContext);
-        if (ErrorCount == prevErrorCount) {
+        if (reporter.Count(ErrorLevel.Error) == prevErrorCount) {
           var r = e.S as UpdateStmt;
           if (r != null && r.ResolvedStatements.Count == 1) {
             var call = r.ResolvedStatements[0] as CallStmt;
             if (call.Method.Mod.Expressions.Count != 0) {
-              Error(call, "calls to methods with side-effects are not allowed inside a statement expression");
+              reporter.Error(MessageSource.Resolver, call, "calls to methods with side-effects are not allowed inside a statement expression");
             }
           }
         }
@@ -7891,12 +7775,12 @@ namespace Microsoft.Dafny
         ResolveExpression(e.Els, opts);
         Contract.Assert(e.Els.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(e.Test.Type, Type.Bool)) {
-          Error(expr, "guard condition in if-then-else expression must be a boolean (instead got {0})", e.Test.Type);
+          reporter.Error(MessageSource.Resolver, expr, "guard condition in if-then-else expression must be a boolean (instead got {0})", e.Test.Type);
         }
         if (UnifyTypes(e.Thn.Type, e.Els.Type)) {
           expr.Type = e.Thn.Type;
         } else {
-          Error(expr, "the two branches of an if-then-else expression must have the same type (got {0} and {1})", e.Thn.Type, e.Els.Type);
+          reporter.Error(MessageSource.Resolver, expr, "the two branches of an if-then-else expression must have the same type (got {0} and {1})", e.Thn.Type, e.Els.Type);
         }
 
       } else if (expr is MatchExpr) {
@@ -7926,7 +7810,7 @@ namespace Microsoft.Dafny
       var subst = new Dictionary<TypeParameter, Type>();
       Dictionary<string, DatatypeCtor> ctors;
       if (dtd == null) {
-        Error(me.Source, "the type of the match source expression must be a datatype (instead found {0})", me.Source.Type);
+        reporter.Error(MessageSource.Resolver, me.Source, "the type of the match source expression must be a datatype (instead found {0})", me.Source.Type);
         ctors = null;
       } else {
         Contract.Assert(sourceType != null);  // dtd and sourceType are set together above
@@ -7955,15 +7839,15 @@ namespace Microsoft.Dafny
         if (ctors != null) {
           Contract.Assert(dtd != null);
           if (!ctors.TryGetValue(mc.Id, out ctor)) {
-            Error(mc.tok, "member {0} does not exist in datatype {1}", mc.Id, dtd.Name);
+            reporter.Error(MessageSource.Resolver, mc.tok, "member {0} does not exist in datatype {1}", mc.Id, dtd.Name);
           } else {
             Contract.Assert(ctor != null);  // follows from postcondition of TryGetValue
             mc.Ctor = ctor;
             if (ctor.Formals.Count != mc.Arguments.Count) {
-              Error(mc.tok, "member {0} has wrong number of formals (found {1}, expected {2})", mc.Id, mc.Arguments.Count, ctor.Formals.Count);
+              reporter.Error(MessageSource.Resolver, mc.tok, "member {0} has wrong number of formals (found {1}, expected {2})", mc.Id, mc.Arguments.Count, ctor.Formals.Count);
             }
             if (memberNamesUsed.Contains(mc.Id)) {
-              Error(mc.tok, "member {0} appears in more than one case", mc.Id);
+              reporter.Error(MessageSource.Resolver, mc.tok, "member {0} appears in more than one case", mc.Id);
             } else {
               memberNamesUsed.Add(mc.Id);  // add mc.Id to the set of names used
             }
@@ -7979,7 +7863,7 @@ namespace Microsoft.Dafny
               Formal formal = ctor.Formals[i];
               Type st = SubstType(formal.Type, subst);
               if (!UnifyTypes(v.Type, st)) {
-                Error(expr, "the declared type of the formal ({0}) does not agree with the corresponding type in the constructor's signature ({1})", v.Type, st);
+                reporter.Error(MessageSource.Resolver, expr, "the declared type of the formal ({0}) does not agree with the corresponding type in the constructor's signature ({1})", v.Type, st);
               }
               v.IsGhost = formal.IsGhost;
 
@@ -8006,7 +7890,7 @@ namespace Microsoft.Dafny
 
         Contract.Assert(mc.Body.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(expr.Type, mc.Body.Type)) {
-          Error(mc.Body.tok, "type of case bodies do not agree (found {0}, previous types {1})", mc.Body.Type, expr.Type);
+          reporter.Error(MessageSource.Resolver, mc.Body.tok, "type of case bodies do not agree (found {0}, previous types {1})", mc.Body.Type, expr.Type);
         }
         scope.PopMarker();
       }
@@ -8044,13 +7928,13 @@ namespace Microsoft.Dafny
       if (me.Source is DatatypeValue) {
         var e = (DatatypeValue)me.Source;
         if (e.Arguments.Count < 1) {
-          Error(me.tok, "match source tuple needs at least 1 argument");
+          reporter.Error(MessageSource.Resolver, me.tok, "match source tuple needs at least 1 argument");
         } else {
           Expression source = e.Arguments[0];
           List<MatchCaseExpr> cases = new List<MatchCaseExpr>();
           foreach (MatchCaseExpr mc in me.Cases) {
             if (mc.CasePatterns == null || mc.CasePatterns.Count != e.Arguments.Count) {
-              Error(mc.tok, "case arguments count does not match source arguments count");
+              reporter.Error(MessageSource.Resolver, mc.tok, "case arguments count does not match source arguments count");
             } else {
               CasePattern cp = mc.CasePatterns[0];
               List<CasePattern> patterns;
@@ -8342,17 +8226,17 @@ namespace Microsoft.Dafny
         var v = pat.Var;
         ResolveType(v.tok, v.Type, context, ResolveTypeOptionEnum.InferTypeProxies, null);
         if (!UnifyTypes(v.Type, sourceType)) {
-          Error(v.tok, "type of corresponding source/RHS ({0}) does not match type of bound variable ({1})", sourceType, v.Type);
+          reporter.Error(MessageSource.Resolver, v.tok, "type of corresponding source/RHS ({0}) does not match type of bound variable ({1})", sourceType, v.Type);
         }
         pat.AssembleExpr(null);
       } else if (dtd == null) {
-        Error(pat.tok, "to use a pattern, the type of the source/RHS expression must be a datatype (instead found {0})", sourceType);
+        reporter.Error(MessageSource.Resolver, pat.tok, "to use a pattern, the type of the source/RHS expression must be a datatype (instead found {0})", sourceType);
       } else if (ctor == null) {
-        Error(pat.tok, "constructor {0} does not exist in datatype {1}", pat.Id, dtd.Name);
+        reporter.Error(MessageSource.Resolver, pat.tok, "constructor {0} does not exist in datatype {1}", pat.Id, dtd.Name);
       } else {
         var argCount = pat.Arguments == null ? 0 : pat.Arguments.Count;
         if (ctor.Formals.Count != argCount) {
-          Error(pat.tok, "pattern for constructor {0} has wrong number of formals (found {1}, expected {2})", pat.Id, argCount, ctor.Formals.Count);
+          reporter.Error(MessageSource.Resolver, pat.tok, "pattern for constructor {0} has wrong number of formals (found {1}, expected {2})", pat.Id, argCount, ctor.Formals.Count);
         }
         // build the type-parameter substitution map for this use of the datatype
         Contract.Assert(dtd.TypeArgs.Count == udt.TypeArgs.Count);  // follows from the type previously having been successfully resolved
@@ -8408,7 +8292,7 @@ namespace Microsoft.Dafny
         foreach (var ty in expr.OptTypeArguments) {
           ResolveType(expr.tok, ty, opts.codeContext, ResolveTypeOptionEnum.InferTypeProxies, null);
           if (ty.IsSubrangeType) {
-            Error(expr.tok, "sorry, cannot instantiate type parameter with a subrange type");
+            reporter.Error(MessageSource.Resolver, expr.tok, "sorry, cannot instantiate type parameter with a subrange type");
           }
         }
       }
@@ -8431,7 +8315,7 @@ namespace Microsoft.Dafny
       if (v != null) {
         // ----- 0. local variable, parameter, or bound variable
         if (expr.OptTypeArguments != null) {
-          Error(expr.tok, "variable '{0}' does not take any type parameters", expr.Name);
+          reporter.Error(MessageSource.Resolver, expr.tok, "variable '{0}' does not take any type parameters", expr.Name);
         }
         var rr = new IdentifierExpr(expr.tok, expr.Name);
         rr.Var = v; rr.Type = v.Type;
@@ -8443,7 +8327,7 @@ namespace Microsoft.Dafny
           receiver = new StaticReceiverExpr(expr.tok, (ClassDecl)member.EnclosingClass, true);
         } else {
           if (!scope.AllowInstance) {
-            Error(expr.tok, "'this' is not allowed in a 'static' context"); //FIXME: Rephrase this
+            reporter.Error(MessageSource.Resolver, expr.tok, "'this' is not allowed in a 'static' context"); //FIXME: Rephrase this
             // nevertheless, set "receiver" to a value so we can continue resolution
           }
           receiver = new ImplicitThisExpr(expr.tok);
@@ -8454,10 +8338,10 @@ namespace Microsoft.Dafny
         // ----- 2. datatype constructor
         if (pair.Item2) {
           // there is more than one constructor with this name
-          Error(expr.tok, "the name '{0}' denotes a datatype constructor, but does not do so uniquely; add an explicit qualification (for example, '{1}.{0}')", expr.Name, pair.Item1.EnclosingDatatype.Name);
+          reporter.Error(MessageSource.Resolver, expr.tok, "the name '{0}' denotes a datatype constructor, but does not do so uniquely; add an explicit qualification (for example, '{1}.{0}')", expr.Name, pair.Item1.EnclosingDatatype.Name);
         } else {
           if (expr.OptTypeArguments != null) {
-            Error(expr.tok, "datatype constructor does not take any type parameters ('{0}')", expr.Name);
+            reporter.Error(MessageSource.Resolver, expr.tok, "datatype constructor does not take any type parameters ('{0}')", expr.Name);
           }
           var rr = new DatatypeValue(expr.tok, pair.Item1.EnclosingDatatype.Name, expr.Name, args ?? new List<Expression>());
           ResolveDatatypeValue(opts, rr, pair.Item1.EnclosingDatatype);
@@ -8472,7 +8356,7 @@ namespace Microsoft.Dafny
         // ----- 3. Member of the enclosing module
         if (decl is AmbiguousTopLevelDecl) {
           var ad = (AmbiguousTopLevelDecl)decl;
-          Error(expr.tok, "The name {0} ambiguously refers to a type in one of the modules {1} (try qualifying the type name with the module name)", expr.Name, ad.ModuleNames());
+          reporter.Error(MessageSource.Resolver, expr.tok, "The name {0} ambiguously refers to a type in one of the modules {1} (try qualifying the type name with the module name)", expr.Name, ad.ModuleNames());
         } else {
           // We have found a module name or a type name, neither of which is an expression. However, the NameSegment we're
           // looking at may be followed by a further suffix that makes this into an expresion. We postpone the rest of the
@@ -8486,7 +8370,7 @@ namespace Microsoft.Dafny
         Contract.Assert(member.IsStatic); // moduleInfo.StaticMembers is supposed to contain only static members of the module's implicit class _default
         if (member is AmbiguousMemberDecl) {
           var ambiguousMember = (AmbiguousMemberDecl)member;
-          Error(expr.tok, "The name {0} ambiguously refers to a static member in one of the modules {1} (try qualifying the member name with the module name)", expr.Name, ambiguousMember.ModuleNames());
+          reporter.Error(MessageSource.Resolver, expr.tok, "The name {0} ambiguously refers to a static member in one of the modules {1} (try qualifying the member name with the module name)", expr.Name, ambiguousMember.ModuleNames());
         } else {
           var receiver = new StaticReceiverExpr(expr.tok, (ClassDecl)member.EnclosingClass, true);
           r = ResolveExprDotCall(expr.tok, receiver, member, expr.OptTypeArguments, opts.codeContext, allowMethodCall);
@@ -8494,7 +8378,7 @@ namespace Microsoft.Dafny
 
       } else {
         // ----- None of the above
-        Error(expr.tok, "unresolved identifier: {0}", expr.Name);
+        reporter.Error(MessageSource.Resolver, expr.tok, "unresolved identifier: {0}", expr.Name);
       }
 
       if (r == null) {
@@ -8526,7 +8410,7 @@ namespace Microsoft.Dafny
         foreach (var ty in expr.OptTypeArguments) {
           ResolveType(expr.tok, ty, opts.codeContext, option, defaultTypeArguments);
           if (ty.IsSubrangeType) {
-            Error(expr.tok, "sorry, cannot instantiate type parameter with a subrange type");
+            reporter.Error(MessageSource.Resolver, expr.tok, "sorry, cannot instantiate type parameter with a subrange type");
           }
         }
       }
@@ -8550,7 +8434,7 @@ namespace Microsoft.Dafny
         if (expr.OptTypeArguments == null) {
           r = new Resolver_IdentifierExpr(expr.tok, tp);
         } else {
-          Error(expr.tok, "Type parameter expects no type arguments: {0}", expr.Name);
+          reporter.Error(MessageSource.Resolver, expr.tok, "Type parameter expects no type arguments: {0}", expr.Name);
         }
 #if ASYNC_TASK_TYPES  // At the moment, there is no way for a class member to part of a type name, but this changes with async task types
       } else if (currentClass != null && classMembers.TryGetValue(currentClass, out members) && members.TryGetValue(expr.Name, out member)) {
@@ -8572,7 +8456,7 @@ namespace Microsoft.Dafny
         // ----- 2. Member of the enclosing module
         if (decl is AmbiguousTopLevelDecl) {
           var ad = (AmbiguousTopLevelDecl)decl;
-          Error(expr.tok, "The name {0} ambiguously refers to a type in one of the modules {1} (try qualifying the type name with the module name)", expr.Name, ad.ModuleNames());
+          reporter.Error(MessageSource.Resolver, expr.tok, "The name {0} ambiguously refers to a type in one of the modules {1} (try qualifying the type name with the module name)", expr.Name, ad.ModuleNames());
         } else {
           // We have found a module name or a type name, neither of which is a type expression. However, the NameSegment we're
           // looking at may be followed by a further suffix that makes this into a type expresion. We postpone the rest of the
@@ -8594,7 +8478,7 @@ namespace Microsoft.Dafny
 #endif
       } else {
         // ----- None of the above
-        Error(expr.tok, "Undeclared top-level type or type parameter: {0} (did you forget to qualify a name or declare a module import 'opened?')", expr.Name);
+        reporter.Error(MessageSource.Resolver, expr.tok, "Undeclared top-level type or type parameter: {0} (did you forget to qualify a name or declare a module import 'opened?')", expr.Name);
       }
 
       if (r == null) {
@@ -8615,7 +8499,7 @@ namespace Microsoft.Dafny
       if (optTypeArguments != null) {
         // type arguments were supplied; they must be equal in number to those expected
         if (n != decl.TypeArgs.Count) {
-          Error(tok, "Wrong number of type arguments ({0} instead of {1}) passed to {2}: {3}", n, decl.TypeArgs.Count, decl.WhatKind, name);
+          reporter.Error(MessageSource.Resolver, tok, "Wrong number of type arguments ({0} instead of {1}) passed to {2}: {3}", n, decl.TypeArgs.Count, decl.WhatKind, name);
         }
       }
       List<Type> tpArgs = new List<Type>();
@@ -8667,7 +8551,7 @@ namespace Microsoft.Dafny
         foreach (var ty in expr.OptTypeArguments) {
           ResolveType(expr.tok, ty, opts.codeContext, ResolveTypeOptionEnum.InferTypeProxies, null);
           if (ty.IsSubrangeType) {
-            Error(expr.tok, "sorry, cannot instantiate type parameter with a subrange type");
+            reporter.Error(MessageSource.Resolver, expr.tok, "sorry, cannot instantiate type parameter with a subrange type");
           }
         }
       }
@@ -8690,10 +8574,10 @@ namespace Microsoft.Dafny
           // ----- 0. datatype constructor
           if (pair.Item2) {
             // there is more than one constructor with this name
-            Error(expr.tok, "the name '{0}' denotes a datatype constructor in module {2}, but does not do so uniquely; add an explicit qualification (for example, '{1}.{0}')", expr.SuffixName, pair.Item1.EnclosingDatatype.Name, ((ModuleDecl)ri.Decl).Name);
+            reporter.Error(MessageSource.Resolver, expr.tok, "the name '{0}' denotes a datatype constructor in module {2}, but does not do so uniquely; add an explicit qualification (for example, '{1}.{0}')", expr.SuffixName, pair.Item1.EnclosingDatatype.Name, ((ModuleDecl)ri.Decl).Name);
           } else {
             if (expr.OptTypeArguments != null) {
-              Error(expr.tok, "datatype constructor does not take any type parameters ('{0}')", expr.SuffixName);
+              reporter.Error(MessageSource.Resolver, expr.tok, "datatype constructor does not take any type parameters ('{0}')", expr.SuffixName);
             }
             var rr = new DatatypeValue(expr.tok, pair.Item1.EnclosingDatatype.Name, expr.SuffixName, args ?? new List<Expression>());
             ResolveExpression(rr, opts);
@@ -8708,7 +8592,7 @@ namespace Microsoft.Dafny
           // ----- 1. Member of the specified module
           if (decl is AmbiguousTopLevelDecl) {
             var ad = (AmbiguousTopLevelDecl)decl;
-            Error(expr.tok, "The name {0} ambiguously refers to a type in one of the modules {1} (try qualifying the type name with the module name)", expr.SuffixName, ad.ModuleNames());
+            reporter.Error(MessageSource.Resolver, expr.tok, "The name {0} ambiguously refers to a type in one of the modules {1} (try qualifying the type name with the module name)", expr.SuffixName, ad.ModuleNames());
           } else {
             // We have found a module name or a type name, neither of which is an expression. However, the ExprDotName we're
             // looking at may be followed by a further suffix that makes this into an expresion. We postpone the rest of the
@@ -8721,13 +8605,13 @@ namespace Microsoft.Dafny
           Contract.Assert(member.IsStatic); // moduleInfo.StaticMembers is supposed to contain only static members of the module's implicit class _default
           if (member is AmbiguousMemberDecl) {
             var ambiguousMember = (AmbiguousMemberDecl)member;
-            Error(expr.tok, "The name {0} ambiguously refers to a static member in one of the modules {1} (try qualifying the member name with the module name)", expr.SuffixName, ambiguousMember.ModuleNames());
+            reporter.Error(MessageSource.Resolver, expr.tok, "The name {0} ambiguously refers to a static member in one of the modules {1} (try qualifying the member name with the module name)", expr.SuffixName, ambiguousMember.ModuleNames());
           } else {
             var receiver = new StaticReceiverExpr(expr.tok, (ClassDecl)member.EnclosingClass, true);
             r = ResolveExprDotCall(expr.tok, receiver, member, expr.OptTypeArguments, opts.codeContext, allowMethodCall);
           }
         } else {
-          Error(expr.tok, "unresolved identifier: {0}", expr.SuffixName);
+          reporter.Error(MessageSource.Resolver, expr.tok, "unresolved identifier: {0}", expr.SuffixName);
         }
 
       } else if (lhs != null && lhs.Type is Resolver_IdentifierExpr.ResolverType_Type) {
@@ -8746,7 +8630,7 @@ namespace Microsoft.Dafny
           Dictionary<string, MemberDecl> members;
           if (classMembers.TryGetValue(cd, out members) && members.TryGetValue(expr.SuffixName, out member)) {
             if (!member.IsStatic) {
-              Error(expr.tok, "accessing member '{0}' requires an instance expression", expr.SuffixName); //FIXME Unify with similar error message
+              reporter.Error(MessageSource.Resolver, expr.tok, "accessing member '{0}' requires an instance expression", expr.SuffixName); //FIXME Unify with similar error message
               // nevertheless, continue creating an expression that approximates a correct one
             }
             var receiver = new StaticReceiverExpr(expr.tok, (UserDefinedType)ty.NormalizeExpand(), (ClassDecl)member.EnclosingClass, false);
@@ -8759,7 +8643,7 @@ namespace Microsoft.Dafny
           DatatypeCtor ctor;
           if (datatypeCtors.TryGetValue(dt, out members) && members.TryGetValue(expr.SuffixName, out ctor)) {
             if (expr.OptTypeArguments != null) {
-              Error(expr.tok, "datatype constructor does not take any type parameters ('{0}')", expr.SuffixName);
+              reporter.Error(MessageSource.Resolver, expr.tok, "datatype constructor does not take any type parameters ('{0}')", expr.SuffixName);
             }
             var rr = new DatatypeValue(expr.tok, ctor.EnclosingDatatype.Name, expr.SuffixName, args ?? new List<Expression>());
             ResolveDatatypeValue(opts, rr, ctor.EnclosingDatatype);
@@ -8772,7 +8656,7 @@ namespace Microsoft.Dafny
           }
         }
         if (r == null) {
-          Error(expr.tok, "member '{0}' does not exist in type '{1}'", expr.SuffixName, ri.TypeParamDecl != null ? ri.TypeParamDecl.Name : ri.Decl.Name);
+          reporter.Error(MessageSource.Resolver, expr.tok, "member '{0}' does not exist in type '{1}'", expr.SuffixName, ri.TypeParamDecl != null ? ri.TypeParamDecl.Name : ri.Decl.Name);
         }
       } else if (lhs != null) {
         // ----- 4. Look up name in the type of the Lhs
@@ -8832,7 +8716,7 @@ namespace Microsoft.Dafny
         foreach (var ty in expr.OptTypeArguments) {
           ResolveType(expr.tok, ty, opts.codeContext, option, defaultTypeArguments);
           if (ty.IsSubrangeType) {
-            Error(expr.tok, "sorry, cannot instantiate type parameter with a subrange type");
+            reporter.Error(MessageSource.Resolver, expr.tok, "sorry, cannot instantiate type parameter with a subrange type");
           }
         }
       }
@@ -8851,7 +8735,7 @@ namespace Microsoft.Dafny
           // ----- 0. Member of the specified module
           if (decl is AmbiguousTopLevelDecl) {
             var ad = (AmbiguousTopLevelDecl)decl;
-            Error(expr.tok, "The name {0} ambiguously refers to a type in one of the modules {1} (try qualifying the type name with the module name)", expr.SuffixName, ad.ModuleNames());
+            reporter.Error(MessageSource.Resolver, expr.tok, "The name {0} ambiguously refers to a type in one of the modules {1} (try qualifying the type name with the module name)", expr.SuffixName, ad.ModuleNames());
           } else {
             // We have found a module name or a type name.  We create a temporary expression that will never be seen by the compiler
             // or verifier, just to have a placeholder where we can recorded what we have found.
@@ -8869,7 +8753,7 @@ namespace Microsoft.Dafny
           }
 #endif
         } else {
-          Error(expr.tok, "module '{0}' does not declare a type '{1}'", ri.Decl.Name, expr.SuffixName);
+          reporter.Error(MessageSource.Resolver, expr.tok, "module '{0}' does not declare a type '{1}'", ri.Decl.Name, expr.SuffixName);
         }
 
       } else if (lhs != null && lhs.Type is Resolver_IdentifierExpr.ResolverType_Type) {
@@ -8885,7 +8769,7 @@ namespace Microsoft.Dafny
           return new ResolveTypeReturn(ty, expr);
         }
         if (r == null) {
-          Error(expr.tok, "member '{0}' does not exist in type '{1}' or cannot be part of type name", expr.SuffixName, ri.TypeParamDecl != null ? ri.TypeParamDecl.Name : ri.Decl.Name);
+          reporter.Error(MessageSource.Resolver, expr.tok, "member '{0}' does not exist in type '{1}' or cannot be part of type name", expr.SuffixName, ri.TypeParamDecl != null ? ri.TypeParamDecl.Name : ri.Decl.Name);
         }
       }
 
@@ -8922,14 +8806,14 @@ namespace Microsoft.Dafny
 
       if (member is Field) {
         if (optTypeArguments != null) {
-          Error(tok, "a field ({0}) does not take any type arguments (got {1})", member.Name, optTypeArguments.Count);
+          reporter.Error(MessageSource.Resolver, tok, "a field ({0}) does not take any type arguments (got {1})", member.Name, optTypeArguments.Count);
         }
         rr.Type = SubstType(((Field)member).Type, subst);
       } else if (member is Function) {
         var fn = (Function)member;
         int suppliedTypeArguments = optTypeArguments == null ? 0 : optTypeArguments.Count;
         if (optTypeArguments != null && suppliedTypeArguments != fn.TypeArgs.Count) {
-          Error(tok, "function '{0}' expects {1} type arguments (got {2})", member.Name, fn.TypeArgs.Count, suppliedTypeArguments);
+          reporter.Error(MessageSource.Resolver, tok, "function '{0}' expects {1} type arguments (got {2})", member.Name, fn.TypeArgs.Count, suppliedTypeArguments);
         }
         rr.TypeApplication = new List<Type>();
         if (udt != null && udt.ResolvedClass != null) {
@@ -8947,11 +8831,11 @@ namespace Microsoft.Dafny
         var m = (Method)member;
         if (!allowMethodCall) {
           // it's a method and method calls are not allowed in the given context
-          Error(tok, "expression is not allowed to invoke a method ({0})", member.Name);
+          reporter.Error(MessageSource.Resolver, tok, "expression is not allowed to invoke a method ({0})", member.Name);
         }
         int suppliedTypeArguments = optTypeArguments == null ? 0 : optTypeArguments.Count;
         if (optTypeArguments != null && suppliedTypeArguments != m.TypeArgs.Count) {
-          Error(tok, "method '{0}' expects {1} type arguments (got {2})", member.Name, m.TypeArgs.Count, suppliedTypeArguments);
+          reporter.Error(MessageSource.Resolver, tok, "method '{0}' expects {1} type arguments (got {2})", member.Name, m.TypeArgs.Count, suppliedTypeArguments);
         }
         rr.TypeApplication = new List<Type>();
         if (udt != null && udt.ResolvedClass != null) {
@@ -8996,7 +8880,7 @@ namespace Microsoft.Dafny
       Contract.Requires(opts != null);
       Contract.Ensures(Contract.Result<MethodCallInformation>() == null || allowMethodCall);
       Expression r = null;  // upon success, the expression to which the ApplySuffix resolves
-      var errorCount = ErrorCount;
+      var errorCount = reporter.Count(ErrorLevel.Error);
       if (e.Lhs is NameSegment) {
         r = ResolveNameSegment((NameSegment)e.Lhs, true, e.Args, opts, allowMethodCall);
         // note, if r is non-null, then e.Args have been resolved and r is a resolved expression that incorporates e.Args
@@ -9014,18 +8898,18 @@ namespace Microsoft.Dafny
         if (fnType == null) {
           var lhs = e.Lhs.Resolved;
           if (lhs != null && lhs.Type is Resolver_IdentifierExpr.ResolverType_Module) {
-            Error(e.tok, "name of module ({0}) is used as a function", ((Resolver_IdentifierExpr)lhs).Decl.Name);
+            reporter.Error(MessageSource.Resolver, e.tok, "name of module ({0}) is used as a function", ((Resolver_IdentifierExpr)lhs).Decl.Name);
           } else if (lhs != null && lhs.Type is Resolver_IdentifierExpr.ResolverType_Type) {
             // It may be a conversion expression
             var ri = (Resolver_IdentifierExpr)lhs;
             if (ri.TypeParamDecl != null) {
-              Error(e.tok, "name of type parameter ({0}) is used as a function", ri.TypeParamDecl.Name);
+              reporter.Error(MessageSource.Resolver, e.tok, "name of type parameter ({0}) is used as a function", ri.TypeParamDecl.Name);
             } else {
               var decl = ri.Decl;
               var ty = new UserDefinedType(e.tok, decl.Name, decl, ri.TypeArgs);
               if (ty.AsNewtype != null) {
                 if (e.Args.Count != 1) {
-                  Error(e.tok, "conversion operation to {0} got wrong number of arguments (expected 1, got {1})", decl.Name, e.Args.Count);
+                  reporter.Error(MessageSource.Resolver, e.tok, "conversion operation to {0} got wrong number of arguments (expected 1, got {1})", decl.Name, e.Args.Count);
                 }
                 var conversionArg = 1 <= e.Args.Count ? e.Args[0] :
                   ty.IsNumericBased(Type.NumericPersuation.Int) ? LiteralExpr.CreateIntLiteral(e.tok, 0) :
@@ -9037,7 +8921,7 @@ namespace Microsoft.Dafny
                   ResolveExpression(e.Args[i], opts);
                 }
               } else {
-                Error(e.tok, "name of type ({0}) is used as a function", decl.Name);
+                reporter.Error(MessageSource.Resolver, e.tok, "name of type ({0}) is used as a function", decl.Name);
               }
             }
           } else {
@@ -9047,10 +8931,10 @@ namespace Microsoft.Dafny
                 var cRhs = new MethodCallInformation(e.tok, mse, e.Args);
                 return cRhs;
               } else {
-                Error(e.tok, "method call is not allowed to be used in an expression context ({0})", mse.Member.Name);
+                reporter.Error(MessageSource.Resolver, e.tok, "method call is not allowed to be used in an expression context ({0})", mse.Member.Name);
               }
             } else if (lhs != null) {  // if e.Lhs.Resolved is null, then e.Lhs was not successfully resolved and an error has already been reported
-              Error(e.tok, "non-function expression (of type {0}) is called with parameters", e.Lhs.Type);
+              reporter.Error(MessageSource.Resolver, e.tok, "non-function expression (of type {0}) is called with parameters", e.Lhs.Type);
             }
           }
         } else {
@@ -9058,14 +8942,14 @@ namespace Microsoft.Dafny
           var callee = mse == null ? null : mse.Member as Function;
           if (fnType.Arity != e.Args.Count) {
             var what = callee != null ? string.Format("function '{0}'", callee.Name) : string.Format("function type '{0}'", fnType);
-            Error(e.tok, "wrong number of arguments to function application ({0} expects {1}, got {2})", what, fnType.Arity, e.Args.Count);
+            reporter.Error(MessageSource.Resolver, e.tok, "wrong number of arguments to function application ({0} expects {1}, got {2})", what, fnType.Arity, e.Args.Count);
           } else {
             for (var i = 0; i < fnType.Arity; i++) {
               if (!UnifyTypes(fnType.Args[i], e.Args[i].Type)) {
-                Error(e.Args[i].tok, "type mismatch for argument {0} (function expects {1}, got {2})", i, fnType.Args[i], e.Args[i].Type);
+                reporter.Error(MessageSource.Resolver, e.Args[i].tok, "type mismatch for argument {0} (function expects {1}, got {2})", i, fnType.Args[i], e.Args[i].Type);
               }
             }
-            if (errorCount != ErrorCount) {
+            if (errorCount != reporter.Count(ErrorLevel.Error)) {
               // do nothing else; error has been reported
             } else if (callee != null) {
               // produce a FunctionCallExpr instead of an ApplyExpr(MemberSelectExpr)
@@ -9090,7 +8974,7 @@ namespace Microsoft.Dafny
                 Contract.Assert(farg.Type != null);  // follows from postcondition of ResolveExpression
                 Type s = SubstType(callee.Formals[i].Type, rr.TypeArgumentSubstitutions);
                 if (!UnifyTypes(farg.Type, s)) {
-                  Error(rr, "incorrect type of function argument {0} (expected {1}, got {2})", i, s, farg.Type);
+                  reporter.Error(MessageSource.Resolver, rr, "incorrect type of function argument {0} (expected {1}, got {2})", i, s, farg.Type);
                 }
               }
               rr.Type = SubstType(callee.ResultType, rr.TypeArgumentSubstitutions);
@@ -9132,12 +9016,12 @@ namespace Microsoft.Dafny
 
       DatatypeCtor ctor;
       if (!datatypeCtors[dt].TryGetValue(dtv.MemberName, out ctor)) {
-        Error(dtv.tok, "undeclared constructor {0} in datatype {1}", dtv.MemberName, dtv.DatatypeName);
+        reporter.Error(MessageSource.Resolver, dtv.tok, "undeclared constructor {0} in datatype {1}", dtv.MemberName, dtv.DatatypeName);
       } else {
         Contract.Assert(ctor != null);  // follows from postcondition of TryGetValue
         dtv.Ctor = ctor;
         if (ctor.Formals.Count != dtv.Arguments.Count) {
-          Error(dtv.tok, "wrong number of arguments to datatype constructor {0} (found {1}, expected {2})", ctor.Name, dtv.Arguments.Count, ctor.Formals.Count);
+          reporter.Error(MessageSource.Resolver, dtv.tok, "wrong number of arguments to datatype constructor {0} (found {1}, expected {2})", ctor.Name, dtv.Arguments.Count, ctor.Formals.Count);
         }
       }
       int j = 0;
@@ -9148,7 +9032,7 @@ namespace Microsoft.Dafny
         if (formal != null) {
           Type st = SubstType(formal.Type, subst);
           if (!UnifyTypes(arg.Type, st)) {
-            Error(arg.tok, "incorrect type of datatype constructor argument (found {0}, expected {1})", arg.Type, st);
+            reporter.Error(MessageSource.Resolver, arg.tok, "incorrect type of datatype constructor argument (found {0}, expected {1})", arg.Type, st);
           }
         }
         j++;
@@ -9192,14 +9076,14 @@ namespace Microsoft.Dafny
       if (expr is IdentifierExpr) {
         var e = (IdentifierExpr)expr;
         if (e.Var != null && e.Var.IsGhost) {
-          Error(expr, "ghost variables are allowed only in specification contexts");
+          reporter.Error(MessageSource.Resolver, expr, "ghost variables are allowed only in specification contexts");
           return;
         }
 
       } else if (expr is MemberSelectExpr) {
         var e = (MemberSelectExpr)expr;
         if (e.Member != null && e.Member.IsGhost) {
-          Error(expr, "ghost fields are allowed only in specification contexts");
+          reporter.Error(MessageSource.Resolver, expr, "ghost fields are allowed only in specification contexts");
           return;
         }
 
@@ -9207,7 +9091,7 @@ namespace Microsoft.Dafny
         var e = (FunctionCallExpr)expr;
         if (e.Function != null) {
           if (e.Function.IsGhost) {
-            Error(expr, "function calls are allowed only in specification contexts (consider declaring the function a 'function method')");
+            reporter.Error(MessageSource.Resolver, expr, "function calls are allowed only in specification contexts (consider declaring the function a 'function method')");
             return;
           }
           // function is okay, so check all NON-ghost arguments
@@ -9232,13 +9116,13 @@ namespace Microsoft.Dafny
         return;
 
       } else if (expr is OldExpr) {
-        Error(expr, "old expressions are allowed only in specification and ghost contexts");
+        reporter.Error(MessageSource.Resolver, expr, "old expressions are allowed only in specification and ghost contexts");
         return;
 
       } else if (expr is UnaryOpExpr) {
         var e = (UnaryOpExpr)expr;
         if (e.Op == UnaryOpExpr.Opcode.Fresh) {
-          Error(expr, "fresh expressions are allowed only in specification and ghost contexts");
+          reporter.Error(MessageSource.Resolver, expr, "fresh expressions are allowed only in specification and ghost contexts");
           return;
         }
 
@@ -9253,7 +9137,7 @@ namespace Microsoft.Dafny
         switch (e.ResolvedOp_PossiblyStillUndetermined) {
           case BinaryExpr.ResolvedOpcode.RankGt:
           case BinaryExpr.ResolvedOpcode.RankLt:
-            Error(expr, "rank comparisons are allowed only in specification and ghost contexts");
+            reporter.Error(MessageSource.Resolver, expr, "rank comparisons are allowed only in specification and ghost contexts");
             return;
           default:
             break;
@@ -9264,7 +9148,7 @@ namespace Microsoft.Dafny
         switch (e.Op) {
           case TernaryExpr.Opcode.PrefixEqOp:
           case TernaryExpr.Opcode.PrefixNeqOp:
-            Error(expr, "prefix equalities are allowed only in specification and ghost contexts");
+            reporter.Error(MessageSource.Resolver, expr, "prefix equalities are allowed only in specification and ghost contexts");
             return;
           default:
             break;
@@ -9294,7 +9178,7 @@ namespace Microsoft.Dafny
         var e = (QuantifierExpr)expr;
         if (e.MissingBounds != null) {
           foreach (var bv in e.MissingBounds) {
-            Error(expr, "quantifiers in non-ghost contexts must be compilable, but Dafny's heuristics can't figure out how to produce a bounded set of values for '{0}'", bv.Name);
+            reporter.Error(MessageSource.Resolver, expr, "quantifiers in non-ghost contexts must be compilable, but Dafny's heuristics can't figure out how to produce a bounded set of values for '{0}'", bv.Name);
           }
           return;
         }
@@ -9302,7 +9186,7 @@ namespace Microsoft.Dafny
         var e = (MapComprehension)expr;
         if (e.MissingBounds != null && !e.Finite) {
           foreach (var bv in e.MissingBounds) {
-            Error(expr, "imaps in non-ghost contexts must be compilable, but Dafny's heuristics can't figure out how to produce a bounded set of values for '{0}'", bv.Name);
+            reporter.Error(MessageSource.Resolver, expr, "imaps in non-ghost contexts must be compilable, but Dafny's heuristics can't figure out how to produce a bounded set of values for '{0}'", bv.Name);
           }
           return;
         }
@@ -9339,9 +9223,9 @@ namespace Microsoft.Dafny
       if (member == null) {
         // error has already been reported by ResolveMember
       } else if (member is Method) {
-        Error(e, "member {0} in type {1} refers to a method, but only functions can be used in this context", e.Name, cce.NonNull(ctype).Name);
+        reporter.Error(MessageSource.Resolver, e, "member {0} in type {1} refers to a method, but only functions can be used in this context", e.Name, cce.NonNull(ctype).Name);
       } else if (!(member is Function)) {
-        Error(e, "member {0} in type {1} does not refer to a function", e.Name, cce.NonNull(ctype).Name);
+        reporter.Error(MessageSource.Resolver, e, "member {0} in type {1} does not refer to a function", e.Name, cce.NonNull(ctype).Name);
       } else {
         Function function = (Function)member;
         e.Function = function;
@@ -9349,10 +9233,10 @@ namespace Microsoft.Dafny
           ((FixpointPredicate)function).Uses.Add(e);
         }
         if (e.Receiver is StaticReceiverExpr && !function.IsStatic) {
-          Error(e, "an instance function must be selected via an object, not just a class name");
+          reporter.Error(MessageSource.Resolver, e, "an instance function must be selected via an object, not just a class name");
         }
         if (function.Formals.Count != e.Args.Count) {
-          Error(e, "wrong number of function arguments (got {0}, expected {1})", e.Args.Count, function.Formals.Count);
+          reporter.Error(MessageSource.Resolver, e, "wrong number of function arguments (got {0}, expected {1})", e.Args.Count, function.Formals.Count);
         } else {
           Contract.Assert(ctype != null);  // follows from postcondition of ResolveMember
           if (!function.IsStatic) {
@@ -9364,9 +9248,9 @@ namespace Microsoft.Dafny
               // in the event that a static function calls another static function (and note that we need the
               // type of the receiver in order to find the method, so we could not have made this check
               // earlier).
-              Error(e.Receiver, "'this' is not allowed in a 'static' context");
+              reporter.Error(MessageSource.Resolver, e.Receiver, "'this' is not allowed in a 'static' context");
             } else if (e.Receiver is StaticReceiverExpr) {
-              Error(e.Receiver, "call to instance function requires an instance");
+              reporter.Error(MessageSource.Resolver, e.Receiver, "call to instance function requires an instance");
             }
           }
           // build the type substitution map
@@ -9384,7 +9268,7 @@ namespace Microsoft.Dafny
             Contract.Assert(farg.Type != null);  // follows from postcondition of ResolveExpression
             Type s = SubstType(function.Formals[i].Type, e.TypeArgumentSubstitutions);
             if (!UnifyTypes(farg.Type, s)) {
-              Error(e, "incorrect type of function argument {0} (expected {1}, got {2})", i, s, farg.Type);
+              reporter.Error(MessageSource.Resolver, e, "incorrect type of function argument {0} (expected {1}, got {2})", i, s, farg.Type);
             }
           }
           e.Type = SubstType(function.ResultType, e.TypeArgumentSubstitutions);
@@ -9435,8 +9319,8 @@ namespace Microsoft.Dafny
     /// <summary>
     /// For a description, see DiscoverBoundsAux.
     /// </summary>
-    public static List<ComprehensionExpr.BoundedPool> DiscoverBounds<VT>(IToken tok, List<VT> bvars, Expression expr, bool polarity, bool returnAllBounds, List<VT> missingBounds) where VT : IVariable {
-      var pairs = DiscoverBoundsAux(tok, bvars, expr, polarity, returnAllBounds, false, missingBounds);
+    public static List<ComprehensionExpr.BoundedPool> DiscoverBounds<VT>(IToken tok, List<VT> bvars, Expression expr, bool polarity, bool returnAllBounds, List<VT> missingBounds, ErrorReporter reporter) where VT : IVariable {
+      var pairs = DiscoverBoundsAux(tok, bvars, expr, polarity, returnAllBounds, false, missingBounds, reporter);
       if (pairs == null) {
         return null;
       }
@@ -9464,7 +9348,7 @@ namespace Microsoft.Dafny
     /// If "allowAnyIntegers", then integer variables will always be given a bound, but this bound may be WiggleWaggle if
     /// there is no better bound.
     /// </summary>
-    public static List<Tuple<VT, List<ComprehensionExpr.BoundedPool>>> DiscoverBoundsAux<VT>(IToken tok, List<VT> bvars, Expression expr, bool polarity, bool returnAllBounds, bool allowAnyIntegers, List<VT> missingBounds) where VT : IVariable {
+    public static List<Tuple<VT, List<ComprehensionExpr.BoundedPool>>> DiscoverBoundsAux<VT>(IToken tok, List<VT> bvars, Expression expr, bool polarity, bool returnAllBounds, bool allowAnyIntegers, List<VT> missingBounds, ErrorReporter reporter) where VT : IVariable {
       Contract.Requires(tok != null);
       Contract.Requires(bvars != null);
       Contract.Requires(missingBounds != null);
@@ -9483,7 +9367,7 @@ namespace Microsoft.Dafny
       var allBounds = new List<Tuple<VT, List<ComprehensionExpr.BoundedPool>>>();
       bool foundError = false;
       foreach (var bv in bvars) {
-        var c = TypeConstraint(bv, bv.Type);
+        var c = TypeConstraint(bv, bv.Type, reporter);
         expr = polarity ? Expression.CreateAnd(c, expr) : Expression.CreateImplies(c, expr);
       }
       for (int j = 0; j < bvars.Count; j++) {
@@ -9619,15 +9503,15 @@ namespace Microsoft.Dafny
       return foundError ? null : allBounds;
     }
 
-    static Expression TypeConstraint(IVariable bv, Type ty) {
+    static Expression TypeConstraint(IVariable bv, Type ty, ErrorReporter reporter) {
       Contract.Requires(bv != null);
       Contract.Requires(ty != null);
       ty = ty.NormalizeExpand();
       var dd = ty.AsNewtype;
       if (dd != null) {
-        var c = TypeConstraint(bv, dd.BaseType);
+        var c = TypeConstraint(bv, dd.BaseType, reporter);
         if (dd.Var != null) {
-          c = Expression.CreateAnd(c, new Translator().Substitute(dd.Constraint, dd.Var, Expression.CreateIdentExpr(bv)));
+          c = Expression.CreateAnd(c, new Translator(reporter).Substitute(dd.Constraint, dd.Var, Expression.CreateIdentExpr(bv)));
         }
         return c;
       }
@@ -9971,7 +9855,7 @@ namespace Microsoft.Dafny
 
       IndexableTypeProxy expectedType = new IndexableTypeProxy(domainType, elementType, argType, true, true, true);
       if (!UnifyTypes(e.Seq.Type, expectedType)) {
-        Error(e, "sequence/array/multiset/map selection requires a sequence, array, multiset, or map (got {0})", e.Seq.Type);
+        reporter.Error(MessageSource.Resolver, e, "sequence/array/multiset/map selection requires a sequence, array, multiset, or map (got {0})", e.Seq.Type);
         seqErr = true;
       }
       if (!e.SelectOne)  // require sequence or array
@@ -9979,13 +9863,13 @@ namespace Microsoft.Dafny
         if (!allowNonUnitArraySelection) {
           // require seq
           if (!UnifyTypes(expectedType, new SeqType(new InferredTypeProxy()))) {
-            Error(e, "selection requires a sequence (got {0})", e.Seq.Type);
+            reporter.Error(MessageSource.Resolver, e, "selection requires a sequence (got {0})", e.Seq.Type);
           }
         } else {
           if (UnifyTypes(expectedType, new MapType(true, new InferredTypeProxy(), new InferredTypeProxy()))) {
-            Error(e, "cannot multiselect a map (got {0} as map type)", e.Seq.Type);
+            reporter.Error(MessageSource.Resolver, e, "cannot multiselect a map (got {0} as map type)", e.Seq.Type);
           } else if (UnifyTypes(expectedType, new MapType(false, new InferredTypeProxy(), new InferredTypeProxy()))) {
-            Error(e, "cannot multiselect an imap (got {0} as imap type)", e.Seq.Type);
+            reporter.Error(MessageSource.Resolver, e, "cannot multiselect an imap (got {0} as imap type)", e.Seq.Type);
           }
         }
       }
@@ -9993,7 +9877,7 @@ namespace Microsoft.Dafny
         ResolveExpression(e.E0, opts);
         Contract.Assert(e.E0.Type != null);  // follows from postcondition of ResolveExpression
         if (!UnifyTypes(e.E0.Type, domainType)) {
-          Error(e.E0, "sequence/array/multiset/map selection requires {1} indices (got {0})", e.E0.Type, domainType);
+          reporter.Error(MessageSource.Resolver, e.E0, "sequence/array/multiset/map selection requires {1} indices (got {0})", e.E0.Type, domainType);
         }
       }
       if (e.E1 != null) {
@@ -10001,7 +9885,7 @@ namespace Microsoft.Dafny
         Contract.Assert(e.E1.Type != null);  // follows from postcondition of ResolveExpression
         var domType = e.E0 == null ? domainType : new OperationTypeProxy(true, false, false, false, false, false);  // reuse 'domainType' if .E0 did not use it; otherwise, create a new proxy to allow .E1 to be any integer-based numeric type, independent of the integer-based numeric type used by .E0
         if (!UnifyTypes(e.E1.Type, domType)) {
-          Error(e.E1, "sequence/array/multiset/map selection requires {1} indices (got {0})", e.E1.Type, domType);
+          reporter.Error(MessageSource.Resolver, e.E1, "sequence/array/multiset/map selection requires {1} indices (got {0})", e.E1.Type, domType);
         }
       }
       if (!seqErr) {
@@ -10193,7 +10077,7 @@ namespace Microsoft.Dafny
         } else {
           return false;
         }
-    } else if (expr is SeqSelectExpr) {
+      } else if (expr is SeqSelectExpr) {
         SeqSelectExpr e = (SeqSelectExpr)expr;
         return UsesSpecFeatures(e.Seq) ||
                (e.E0 != null && UsesSpecFeatures(e.E0)) ||
diff --git a/Source/Dafny/Rewriter.cs b/Source/Dafny/Rewriter.cs
index 4223fb7f..cb71b80d 100644
--- a/Source/Dafny/Rewriter.cs
+++ b/Source/Dafny/Rewriter.cs
@@ -6,24 +6,25 @@ using IToken = Microsoft.Boogie.IToken;
 
 namespace Microsoft.Dafny
 {
-  [ContractClass(typeof(IRewriterContracts))]
-  public interface IRewriter
+  public abstract class IRewriter
   {
-    void PreResolve(ModuleDefinition m);
-    void PostResolve(ModuleDefinition m);
-    // After SCC/Cyclicity/Recursivity analysis:
-    void PostCyclicityResolve(ModuleDefinition m);
-  }
-  [ContractClassFor(typeof(IRewriter))]
-  abstract class IRewriterContracts : IRewriter
-  {
-    public void PreResolve(ModuleDefinition m) {
+    protected readonly ErrorReporter reporter;
+
+    public IRewriter(ErrorReporter reporter) {
+      Contract.Requires(reporter != null);
+      this.reporter = reporter;
+    }
+
+    internal virtual void PreResolve(ModuleDefinition m) {
       Contract.Requires(m != null);
     }
-    public void PostResolve(ModuleDefinition m) {
+
+    internal virtual void PostResolve(ModuleDefinition m) {
       Contract.Requires(m != null);
     }
-    public void PostCyclicityResolve(ModuleDefinition m) {
+
+    // After SCC/Cyclicity/Recursivity analysis:
+    internal virtual void PostCyclicityResolve(ModuleDefinition m) {
       Contract.Requires(m != null);
     }
   }
@@ -37,33 +38,26 @@ namespace Microsoft.Dafny
     }
   }
 
-  public class TriggersRewriter : IRewriter {
-    Resolver Resolver;
-
-    internal TriggersRewriter(Resolver resolver) {
-      Contract.Requires(resolver != null);
-      this.Resolver = resolver;
+  public class TriggerGeneratingRewriter : IRewriter {
+    internal TriggerGeneratingRewriter(ErrorReporter reporter) : base(reporter) {
+      Contract.Requires(reporter != null);
     }
 
-    public void PreResolve(ModuleDefinition m) { }
-
-    public void PostResolve(ModuleDefinition m) {
+    internal override void PostResolve(ModuleDefinition m) {
       foreach (var decl in ModuleDefinition.AllCallables(m.TopLevelDecls)) {
         if (decl is Function) {
           var function = (Function)decl;
-          TriggerGenerator.AddTriggers(function.Ens, Resolver);
-          TriggerGenerator.AddTriggers(function.Req, Resolver);
-          TriggerGenerator.AddTriggers(function.Body, Resolver);
+          //TriggerGenerator.AddTriggers(function.Ens, Resolver);
+          //TriggerGenerator.AddTriggers(function.Req, Resolver);
+          //TriggerGenerator.AddTriggers(function.Body, Resolver);
         } else if (decl is Method) {
           var method = (Method)decl;
-          TriggerGenerator.AddTriggers(method.Ens, Resolver);
-          TriggerGenerator.AddTriggers(method.Req, Resolver);
-          TriggerGenerator.AddTriggers(method.Body, Resolver);
+          //TriggerGenerator.AddTriggers(method.Ens, Resolver);
+          //TriggerGenerator.AddTriggers(method.Req, Resolver);
+          //TriggerGenerator.AddTriggers(method.Body, Resolver);
         }
       }
     }
-
-    public void PostCyclicityResolve(ModuleDefinition m) { }
   }
 
   /// <summary>
@@ -106,7 +100,12 @@ namespace Microsoft.Dafny
   /// </summary>
   public class AutoContractsRewriter : IRewriter
   {
-    public void PreResolve(ModuleDefinition m) {
+    public AutoContractsRewriter(ErrorReporter reporter)
+      : base(reporter) {
+      Contract.Requires(reporter != null);
+    }
+
+    internal override void PreResolve(ModuleDefinition m) {
       foreach (var d in m.TopLevelDecls) {
         bool sayYes = true;
         if (d is ClassDecl && Attributes.ContainsBool(d.Attributes, "autocontracts", ref sayYes) && sayYes) {
@@ -162,7 +161,7 @@ namespace Microsoft.Dafny
       }
     }
 
-    public void PostResolve(ModuleDefinition m) {
+    internal override void PostResolve(ModuleDefinition m) {
       foreach (var d in m.TopLevelDecls) {
         bool sayYes = true;
         if (d is ClassDecl && Attributes.ContainsBool(d.Attributes, "autocontracts", ref sayYes) && sayYes) {
@@ -171,9 +170,6 @@ namespace Microsoft.Dafny
       }
     }
 
-    public void PostCyclicityResolve(ModuleDefinition m) { 
-    }
-
     void ProcessClassPostResolve(ClassDecl cl) {
       // Find all fields of a reference type, and make a note of whether or not the reference type has a Repr field.
       // Also, find the Repr field and the function Valid in class "cl"
@@ -416,20 +412,20 @@ namespace Microsoft.Dafny
   /// specifically asks to see it via the reveal_foo() lemma
   /// </summary>
   public class OpaqueFunctionRewriter : IRewriter {
-    readonly ResolutionErrorReporter reporter;
     protected Dictionary<Function, Function> fullVersion; // Given an opaque function, retrieve the full
     protected Dictionary<Function, Function> original;    // Given a full version of an opaque function, find the original opaque version
     protected Dictionary<Lemma, Function> revealOriginal; // Map reveal_* lemmas back to their original functions
 
-    public OpaqueFunctionRewriter(ResolutionErrorReporter reporter)
-      : base() {
-      this.reporter = reporter;
+    public OpaqueFunctionRewriter(ErrorReporter reporter)
+      : base(reporter) {
+      Contract.Requires(reporter != null);
+
       fullVersion = new Dictionary<Function, Function>();
       original = new Dictionary<Function, Function>();
       revealOriginal = new Dictionary<Lemma, Function>();
     }
 
-    public void PreResolve(ModuleDefinition m) {
+    internal override void PreResolve(ModuleDefinition m) {
       foreach (var d in m.TopLevelDecls) {
         if (d is ClassDecl) {
           DuplicateOpaqueClassFunctions((ClassDecl)d);
@@ -437,7 +433,7 @@ namespace Microsoft.Dafny
       }
     }    
 
-    public void PostResolve(ModuleDefinition m) {
+    internal override void PostResolve(ModuleDefinition m) {
       // Fix up the ensures clause of the full version of the function,
       // since it may refer to the original opaque function      
       foreach (var fn in ModuleDefinition.AllFunctions(m.TopLevelDecls)) {        
@@ -462,7 +458,7 @@ namespace Microsoft.Dafny
       }
     }
 
-    public void PostCyclicityResolve(ModuleDefinition m) {
+    internal override void PostCyclicityResolve(ModuleDefinition m) {
       // Add layer quantifier if the function is recursive 
       foreach (var decl in ModuleDefinition.AllCallables(m.TopLevelDecls)) {
         if (decl is Lemma) {
@@ -507,7 +503,7 @@ namespace Microsoft.Dafny
           if (!Attributes.Contains(f.Attributes, "opaque")) {
             // Nothing to do
           } else if (f.IsProtected) {
-            reporter.Error(f.tok, ":opaque is not allowed to be applied to protected functions (this will be allowed when the language introduces 'opaque'/'reveal' as keywords)");
+            reporter.Error(MessageSource.Rewriter, f.tok, ":opaque is not allowed to be applied to protected functions (this will be allowed when the language introduces 'opaque'/'reveal' as keywords)");
           } else if (!RefinementToken.IsInherited(f.tok, c.Module)) {
             // Create a copy, which will be the internal version with a full body
             // which will allow us to verify that the ensures are true
@@ -721,19 +717,16 @@ namespace Microsoft.Dafny
   /// </summary>
   public class AutoReqFunctionRewriter : IRewriter {
     Function parentFunction;
-    Resolver resolver;
     OpaqueFunctionRewriter opaqueInfo;
     bool containsMatch; // TODO: Track this per-requirement, rather than per-function
 
-    public AutoReqFunctionRewriter(Resolver r, OpaqueFunctionRewriter o) {
-      this.resolver = r;
+    public AutoReqFunctionRewriter(ErrorReporter reporter, OpaqueFunctionRewriter o)
+      : base(reporter) {
+      Contract.Requires(reporter != null);
       this.opaqueInfo = o;
     }
 
-    public void PreResolve(ModuleDefinition m) { 
-    }    
-
-    public void PostResolve(ModuleDefinition m) {
+    internal override void PostResolve(ModuleDefinition m) {
       var components = m.CallGraph.TopologicallySortedComponents();
 
       foreach (var scComponent in components) {  // Visit the call graph bottom up, so anything we call already has its prequisites calculated
@@ -806,9 +799,6 @@ namespace Microsoft.Dafny
       }
     }
 
-    public void PostCyclicityResolve(ModuleDefinition m) { 
-    }
-
     Expression subVars(List<Formal> formals, List<Expression> values, Expression e, Expression f_this) {
       Contract.Assert(formals != null);
       Contract.Assert(values != null);
@@ -839,7 +829,7 @@ namespace Microsoft.Dafny
       }
 
       if (!tip.Equals("")) {
-        resolver.ReportAdditionalInformation(f.tok, tip, f.tok.val.Length);
+        reporter.Info(MessageSource.Rewriter, f.tok, tip);
         if (DafnyOptions.O.AutoReqPrintFile != null) {
           using (System.IO.TextWriter writer = new System.IO.StreamWriter(DafnyOptions.O.AutoReqPrintFile, true)) {
             writer.WriteLine(f.Name);
@@ -866,7 +856,7 @@ namespace Microsoft.Dafny
       }
 
       if (!tip.Equals("")) {
-        resolver.ReportAdditionalInformation(method.tok, tip, method.tok.val.Length);
+        reporter.Info(MessageSource.Rewriter, method.tok, tip);
         if (DafnyOptions.O.AutoReqPrintFile != null) {
           using (System.IO.TextWriter writer = new System.IO.StreamWriter(DafnyOptions.O.AutoReqPrintFile, true)) {
             writer.WriteLine(method.Name);
@@ -1061,7 +1051,7 @@ namespace Microsoft.Dafny
             Expression allReqsSatisfied = andify(e.Term.tok, auto_reqs);
             Expression allReqsSatisfiedAndTerm = Expression.CreateAnd(allReqsSatisfied, e.Term);
             e.UpdateTerm(allReqsSatisfiedAndTerm);
-            resolver.ReportAdditionalInformation(e.tok, "autoreq added (" + Printer.ExtendedExprToString(allReqsSatisfied) + ") &&", e.tok.val.Length);
+            reporter.Info(MessageSource.Rewriter, e.tok, "autoreq added (" + Printer.ExtendedExprToString(allReqsSatisfied) + ") &&");
         }
       } else if (expr is SetComprehension) {
         var e = (SetComprehension)expr;
@@ -1108,7 +1098,12 @@ namespace Microsoft.Dafny
   /// </summary>
   public class TimeLimitRewriter : IRewriter
   {
-    public void PreResolve(ModuleDefinition m) {
+    public TimeLimitRewriter(ErrorReporter reporter)
+      : base(reporter) {
+      Contract.Requires(reporter != null);
+    }
+
+    internal override void PreResolve(ModuleDefinition m) {
       foreach (var d in m.TopLevelDecls) {
         if (d is ClassDecl) {
           var c = (ClassDecl)d;
@@ -1136,16 +1131,6 @@ namespace Microsoft.Dafny
         }
       }
     }
-
-    public void PostResolve(ModuleDefinition m)
-    {
-      // Nothing to do here
-    }
-
-    public void PostCyclicityResolve(ModuleDefinition m) {
-      // Nothing to do here
-    }
-
   }
 
 
diff --git a/Source/Dafny/Scanner.cs b/Source/Dafny/Scanner.cs
index a73f510d..e6c97f22 100644
--- a/Source/Dafny/Scanner.cs
+++ b/Source/Dafny/Scanner.cs
@@ -314,8 +314,8 @@ public class Scanner {
 
 //	[NotDelayed]
 	public Scanner (string/*!*/ fullFilename, string/*!*/ fileName, Errors/*!*/ errorHandler, bool useBaseName = false) : base() {
-	  Contract.Requires(fileName != null);
-	  Contract.Requires(errorHandler != null);
+		Contract.Requires(fileName != null);
+		Contract.Requires(errorHandler != null);
 		this.errorHandler = errorHandler;
 		pt = tokens = new Token();  // first token is a dummy
 		t = new Token(); // dummy because t is a non-null field
@@ -332,9 +332,9 @@ public class Scanner {
 
 //	[NotDelayed]
 	public Scanner (Stream/*!*/ s, Errors/*!*/ errorHandler, string/*!*/ fullFilename, string/*!*/ fileName, bool useBaseName = false) : base() {
-	  Contract.Requires(s != null);
-	  Contract.Requires(errorHandler != null);
-	  Contract.Requires(fileName != null);
+		Contract.Requires(s != null);
+		Contract.Requires(errorHandler != null);
+		Contract.Requires(fileName != null);
 		pt = tokens = new Token();  // first token is a dummy
 		t = new Token(); // dummy because t is a non-null field
 		this._buffer = new Buffer(s, true);
@@ -344,9 +344,9 @@ public class Scanner {
 		Init();
 	}
 
-    string GetBaseName(string fileName) {
-        return System.IO.Path.GetFileName(fileName); // Return basename
-    }
+	string GetBaseName(string fileName) {
+		return System.IO.Path.GetFileName(fileName); // Return basename
+	}
 
 	void Init() {
 		pos = -1; line = 1; col = 0;
@@ -991,6 +991,4 @@ public class Scanner {
 } // end Scanner
 
 public delegate void ErrorProc(int n, string filename, int line, int col);
-
-
 }
\ No newline at end of file
diff --git a/Source/Dafny/Translator.cs b/Source/Dafny/Translator.cs
index b8c4b8ec..039aa56f 100644
--- a/Source/Dafny/Translator.cs
+++ b/Source/Dafny/Translator.cs
@@ -93,9 +93,13 @@ namespace Microsoft.Dafny {
   }
 
   public class Translator {
+    readonly ErrorReporter reporter;
 
     [NotDelayed]
-    public Translator() {
+    public Translator(ErrorReporter reporter) {
+      Contract.Requires(reporter != null);
+      
+      this.reporter = reporter;
       InsertChecksums = 0 < CommandLineOptions.Clo.VerifySnapshots;
       Bpl.Program boogieProgram = ReadPrelude();
       if (boogieProgram != null) {
@@ -3609,7 +3613,7 @@ namespace Microsoft.Dafny {
       Contract.Requires(tok != null);
       Contract.Ensures(Contract.Result<Bpl.Cmd>() != null);
       var col = tok.col + (isEndToken ? tok.val.Length : 0);
-      string description = Util.ReportIssueToString_Bare(additionalInfo == null ? "" : ": ", tok.filename, tok.line, tok.col, additionalInfo ?? "");
+      string description = reporter.ErrorToString_Internal(additionalInfo == null ? "" : ": ", tok.filename, tok.line, tok.col, additionalInfo ?? "");
       QKeyValue kv = new QKeyValue(tok, "captureState", new List<object>() { description }, null);
       return new Bpl.AssumeCmd(tok, Bpl.Expr.True, kv);
     }
@@ -7679,7 +7683,7 @@ namespace Microsoft.Dafny {
       }
 
       var missingBounds = new List<BoundVar>();
-      var bounds = Resolver.DiscoverBounds(x.tok, new List<BoundVar>() { x }, expr, true, true, missingBounds);
+      var bounds = Resolver.DiscoverBounds(x.tok, new List<BoundVar>() { x }, expr, true, true, missingBounds, reporter);
       if (missingBounds.Count == 0) {
         foreach (var bound in bounds) {
           if (bound is ComprehensionExpr.IntBoundedPool) {
@@ -12955,9 +12959,8 @@ namespace Microsoft.Dafny {
             return true;
           } else {
             // Skip inlining, as it would cause arbitrary expressions to pop up in the trigger
-            // CLEMENT: Report inlining issue in a VS plugin friendly way
-            //CLEMENT this should appear at the outmost call site, not at the innermost. See SnapshotableTrees.dfy
-            Dafny.Util.ReportIssue("Info", fexp.tok, "Some instances of this call cannot safely be inlined.");
+            // CLEMENT this should appear at the outmost call site, not at the innermost. See SnapshotableTrees.dfy
+            reporter.Info(MessageSource.Translator, fexp.tok, "Some instances of this call cannot safely be inlined.");
           }
         }
 
diff --git a/Source/Dafny/TriggerGenerator.cs b/Source/Dafny/TriggerGenerator.cs
index cf677e0e..04d96b01 100644
--- a/Source/Dafny/TriggerGenerator.cs
+++ b/Source/Dafny/TriggerGenerator.cs
@@ -513,7 +513,7 @@ namespace Microsoft.Dafny {
         return;
 
       DebugTriggers("== From {0} visiting expr: {1}", new StackFrame(1).GetMethod().Name, Printer.ExprToString(root));
-      TriggerGenerator generator = new TriggerGenerator(resolver.ReportAdditionalInformation);
+      TriggerGenerator generator = new TriggerGenerator(null);
       generator.AddTriggers_Internal(root);
     }
 
@@ -522,7 +522,7 @@ namespace Microsoft.Dafny {
         return;
 
       DebugTriggers("== From {0} visiting statement: {1}", new StackFrame(1).GetMethod().Name, Printer.StatementToString(root));
-      TriggerGenerator generator = new TriggerGenerator(resolver.ReportAdditionalInformation);
+      TriggerGenerator generator = new TriggerGenerator(null);
       generator.AddTriggers_Internal(root);
     }
 
diff --git a/Source/Dafny/Util.cs b/Source/Dafny/Util.cs
index 508d23c6..eaf599e3 100644
--- a/Source/Dafny/Util.cs
+++ b/Source/Dafny/Util.cs
@@ -67,29 +67,6 @@ namespace Microsoft.Dafny {
       return res;
     }
 
-    public static void ReportIssue(string header, IToken tok, string msg, params object[] args) {
-      ReportIssue(header, tok, String.Format(msg, args));
-    }
-
-    public static void ReportIssue(string header, IToken tok, string msg) {
-      ReportIssue(header, tok.filename, tok.line, tok.col, msg);
-    }
-
-    public static void ReportIssue(string header, string filename, int line, int column, string msg) {
-      Console.WriteLine(ReportIssueToString(header, filename, line, column, msg));
-    }
-
-    public static string ReportIssueToString(string header, string filename, int line, int column, string msg) {
-      Contract.Requires(header != null);
-      Contract.Requires(filename != null);
-      Contract.Requires(msg != null);
-      return ReportIssueToString_Bare(": " + header, filename, line, column, ": " + msg);
-    }
-
-    public static string ReportIssueToString_Bare(string header, string filename, int line, int column, string msg) {
-      return String.Format("{0}({1},{2}){3}{4}", filename, line, column - 1, header, msg ?? "");
-    }
-
     /// <summary>
     /// Returns s but with all occurrences of '_' removed.
     /// </summary>
diff --git a/Source/DafnyDriver/DafnyDriver.cs b/Source/DafnyDriver/DafnyDriver.cs
index d22899ab..4b5ae8d8 100644
--- a/Source/DafnyDriver/DafnyDriver.cs
+++ b/Source/DafnyDriver/DafnyDriver.cs
@@ -22,7 +22,6 @@ namespace Microsoft.Dafny
 
   public class DafnyDriver
   {
-
     enum ExitValue { VERIFIED = 0, PREPROCESSING_ERROR, DAFNY_ERROR, NOT_VERIFIED }
 
 
@@ -42,8 +41,7 @@ namespace Microsoft.Dafny
     {
       Contract.Requires(cce.NonNullElements(args));
          
-      printer = new DafnyConsolePrinter();
-      ExecutionEngine.printer = printer;
+      ExecutionEngine.printer = new DafnyConsolePrinter(); // For boogie errors
 
       DafnyOptions.Install(new DafnyOptions());
 
@@ -57,14 +55,14 @@ namespace Microsoft.Dafny
 
       if (CommandLineOptions.Clo.Files.Count == 0)
       {
-        printer.ErrorWriteLine(Console.Out, "*** Error: No input files were specified.");
+        ExecutionEngine.printer.ErrorWriteLine(Console.Out, "*** Error: No input files were specified.");
         exitValue = ExitValue.PREPROCESSING_ERROR;
         goto END;
       }
       if (CommandLineOptions.Clo.XmlSink != null) {
         string errMsg = CommandLineOptions.Clo.XmlSink.Open();
         if (errMsg != null) {
-          printer.ErrorWriteLine(Console.Out, "*** Error: " + errMsg);
+          ExecutionEngine.printer.ErrorWriteLine(Console.Out, "*** Error: " + errMsg);
           exitValue = ExitValue.PREPROCESSING_ERROR;
           goto END;
         }
@@ -87,12 +85,11 @@ namespace Microsoft.Dafny
       {Contract.Assert(file != null);
         string extension = Path.GetExtension(file);
         if (extension != null) { extension = extension.ToLower(); }
-        if (extension != ".dfy")
-        {
-            printer.ErrorWriteLine(Console.Out, "*** Error: '{0}': Filename extension '{1}' is not supported. Input files must be Dafny programs (.dfy).", file,
-                extension == null ? "" : extension);
-            exitValue = ExitValue.PREPROCESSING_ERROR;
-            goto END;
+        if (extension != ".dfy") {
+          ExecutionEngine.printer.ErrorWriteLine(Console.Out, "*** Error: '{0}': Filename extension '{1}' is not supported. Input files must be Dafny programs (.dfy).", file,
+            extension == null ? "" : extension);
+          exitValue = ExitValue.PREPROCESSING_ERROR;
+          goto END;
         }
       }
       exitValue = ProcessFiles(CommandLineOptions.Clo.Files);
@@ -156,14 +153,15 @@ namespace Microsoft.Dafny
       
       using (XmlFileScope xf = new XmlFileScope(CommandLineOptions.Clo.XmlSink, fileNames[fileNames.Count-1])) {
         Dafny.Program dafnyProgram;
+        ErrorReporter reporter = new ConsoleErrorReporter();
         string programName = fileNames.Count == 1 ? fileNames[0] : "the program";
-        string err = Dafny.Main.ParseCheck(fileNames, programName, out dafnyProgram);
+        string err = Dafny.Main.ParseCheck(fileNames, programName, reporter, out dafnyProgram);
         if (err != null) {
           exitValue = ExitValue.DAFNY_ERROR;
-          printer.ErrorWriteLine(Console.Out, err);
+          ExecutionEngine.printer.ErrorWriteLine(Console.Out, err);
         } else if (dafnyProgram != null && !CommandLineOptions.Clo.NoResolve && !CommandLineOptions.Clo.NoTypecheck
             && DafnyOptions.O.DafnyVerify) {
-          Dafny.Translator translator = new Dafny.Translator();
+          Dafny.Translator translator = new Dafny.Translator(dafnyProgram.reporter);
           Bpl.Program boogieProgram = translator.Translate(dafnyProgram);
           if (CommandLineOptions.Clo.PrintFile != null)
           {
@@ -184,12 +182,12 @@ namespace Microsoft.Dafny
           var allOk = stats.ErrorCount == 0 && stats.InconclusiveCount == 0 && stats.TimeoutCount == 0 && stats.OutOfMemoryCount == 0;
           switch (oc) {
             case PipelineOutcome.VerificationCompleted:
-              printer.WriteTrailer(stats);
+              ExecutionEngine.printer.WriteTrailer(stats);
               if ((DafnyOptions.O.Compile && allOk && CommandLineOptions.Clo.ProcsToCheck == null) || DafnyOptions.O.ForceCompile)
                 CompileDafnyProgram(dafnyProgram, fileNames[0]);
               break;
             case PipelineOutcome.Done:
-              printer.WriteTrailer(stats);
+              ExecutionEngine.printer.WriteTrailer(stats);
               if (DafnyOptions.O.ForceCompile)
                 CompileDafnyProgram(dafnyProgram, fileNames[0]);
               break;
@@ -265,10 +263,7 @@ namespace Microsoft.Dafny
 
 
     #region Output
-
-    static OutputPrinter printer;
-
-
+    
     class DafnyConsolePrinter : ConsolePrinter
     {
       public override void ReportBplError(IToken tok, string message, bool error, TextWriter tw, string category = null)
diff --git a/Source/DafnyExtension/DafnyDriver.cs b/Source/DafnyExtension/DafnyDriver.cs
index 50d8c2e3..36664a9b 100644
--- a/Source/DafnyExtension/DafnyDriver.cs
+++ b/Source/DafnyExtension/DafnyDriver.cs
@@ -115,19 +115,21 @@ namespace DafnyLanguage
     bool ParseAndTypeCheck() {
       Dafny.ModuleDecl module = new Dafny.LiteralModuleDecl(new Dafny.DefaultModuleDecl(), null);
       Dafny.BuiltIns builtIns = new Dafny.BuiltIns();
-      Dafny.Errors parseErrors = new VSErrors(this);
+
+      var errorReporter = new VSErrorReporter(this);
+      var parseErrors = new Dafny.Errors(errorReporter);
+
       int errorCount = Dafny.Parser.Parse(_snapshot.GetText(), _filename, _filename, module, builtIns, parseErrors);
       string errString = Dafny.Main.ParseIncludes(module, builtIns, new List<string>(), parseErrors);
       if (errorCount != 0 || errString != null)
         return false;
-      Dafny.Program program = new Dafny.Program(_filename, module, builtIns);
+      Dafny.Program program = new Dafny.Program(_filename, module, builtIns, errorReporter);
 
-      var r = new VSResolver(program, this);
+      var r = new Resolver(program);
       r.ResolveProgram(program);
-      if (r.ErrorCount != 0)
+      if (errorReporter.Count(ErrorLevel.Error) != 0)
         return false;
 
-      program.AdditionalInformation.AddRange(r.AdditionalInformation);
       _program = program;
       return true;  // success
     }
@@ -137,56 +139,31 @@ namespace DafnyLanguage
       _errors.Add(new DafnyError(filename, line - 1, col - 1, cat, msg, _snapshot, isRecycled, null, System.IO.Path.GetFullPath(this._filename) == filename));
     }
 
-    class VSErrors : Dafny.Errors
-    {
-      DafnyDriver dd;
-      public VSErrors(DafnyDriver dd) {
-        this.dd = dd;
-      }
-      public override void SynErr(string filename, int line, int col, string msg) {
-        dd.RecordError(filename, line, col, ErrorCategory.ParseError, msg);
-        count++;
-      }
-      public override void SemErr(string filename, int line, int col, string msg) {
-        dd.RecordError(filename, line, col, ErrorCategory.ResolveError, msg);
-        count++;
-      }
-      public override void Warning(IToken tok, string msg) {
-        dd.RecordError(tok.filename, tok.line, tok.col, ErrorCategory.ParseWarning, msg);
-      }
-    }
-
-    class VSResolver : Dafny.Resolver
+    class VSErrorReporter : Dafny.ErrorReporter
     {
       DafnyDriver dd;
-      Dictionary<IToken, HashSet<AdditionalInformation>> _additionalInformation = new Dictionary<IToken, HashSet<AdditionalInformation>>();
-      public List<AdditionalInformation> AdditionalInformation { get { return _additionalInformation.Values.SelectMany(i => i).ToList(); } }
 
-      public VSResolver(Dafny.Program program, DafnyDriver dd)
-        : base(program) {
+      public VSErrorReporter(DafnyDriver dd) {
         this.dd = dd;
-
-        AdditionalInformationReporter =
-          (addinfo)
-            =>
-            {
-              if (!_additionalInformation.ContainsKey(addinfo.Token)) {
-                _additionalInformation.Add(addinfo.Token, new HashSet<AdditionalInformation>());
-              }
-              _additionalInformation[addinfo.Token].Add(addinfo);
-            };
-      }
-
-      public override void Error(Bpl.IToken tok, string msg, params object[] args) {
-        string s = string.Format(msg, args);
-        dd.RecordError(tok.filename, tok.line, tok.col, ErrorCategory.ResolveError, s);
-        ErrorCount++;
       }
 
-      public override void Warning(IToken tok, string msg, params object[] args) {
-        if (reportWarnings) {
-          string s = string.Format(msg, args);
-          dd.RecordError(tok.filename, tok.line, tok.col, ErrorCategory.ResolveWarning, s);
+      // TODO: The error tracking could be made better to track the full information returned by Dafny
+      public override bool Message(MessageSource source, ErrorLevel level, IToken tok, string msg) {
+        if (base.Message(source, level, tok, msg)) {
+          switch (level) {
+            case ErrorLevel.Error:
+              dd.RecordError(tok.filename, tok.line, tok.col, source == MessageSource.Parser ? ErrorCategory.ParseError : ErrorCategory.ResolveError, msg);
+              break;
+            case ErrorLevel.Warning:
+              dd.RecordError(tok.filename, tok.line, tok.col, source == MessageSource.Parser ? ErrorCategory.ParseWarning : ErrorCategory.ResolveWarning, msg);
+              break;
+            case ErrorLevel.Info:
+              // The AllMessages variable already keeps track of this
+              break;
+          }
+          return true;
+        } else {
+          return false;
         }
       }
     }
@@ -273,7 +250,7 @@ namespace DafnyLanguage
     }
 
     public static bool Verify(Dafny.Program dafnyProgram, ResolverTagger resolver, string uniqueIdPrefix, string requestId, ErrorReporterDelegate er) {
-      Dafny.Translator translator = new Dafny.Translator();
+      Dafny.Translator translator = new Dafny.Translator(dafnyProgram.reporter);
       translator.InsertChecksums = true;
       translator.UniqueIdPrefix = uniqueIdPrefix;
       Bpl.Program boogieProgram = translator.Translate(dafnyProgram);
diff --git a/Source/DafnyExtension/IdentifierTagger.cs b/Source/DafnyExtension/IdentifierTagger.cs
index 262dddcd..13991496 100644
--- a/Source/DafnyExtension/IdentifierTagger.cs
+++ b/Source/DafnyExtension/IdentifierTagger.cs
@@ -136,9 +136,9 @@ namespace DafnyLanguage
 
       List<IdRegion> newRegions = new List<IdRegion>();
 
-      foreach (var addInfo in program.AdditionalInformation)
+      foreach (var info in program.reporter.AllMessages[ErrorLevel.Info])
       {
-        IdRegion.Add(newRegions, addInfo.Token, addInfo.Text, addInfo.Length);
+        IdRegion.Add(newRegions, info.token, info.message, info.token.val.Length);
       }
 
       foreach (var module in program.Modules) {
diff --git a/Source/DafnyExtension/ResolverTagger.cs b/Source/DafnyExtension/ResolverTagger.cs
index 6eaec5a6..0ce68809 100644
--- a/Source/DafnyExtension/ResolverTagger.cs
+++ b/Source/DafnyExtension/ResolverTagger.cs
@@ -74,10 +74,10 @@ namespace DafnyLanguage
       switch (err.Category) {
         case ErrorCategory.ProcessError:
         case ErrorCategory.ParseError:
-        case ErrorCategory.ParseWarning:
           return "syntax error";  // COLOR: red
         case ErrorCategory.ResolveError:
           return "compiler error";  // COLOR: blue
+        case ErrorCategory.ParseWarning:
         case ErrorCategory.ResolveWarning:
           return "compiler warning";  // COLOR: blue
         case ErrorCategory.InternalError:
@@ -403,7 +403,7 @@ namespace DafnyLanguage
         chng(this, new SnapshotSpanEventArgs(new SnapshotSpan(snapshot, 0, snapshot.Length)));
     }
 
-    static TaskErrorCategory CategoryConversion(ErrorCategory cat)
+    static TaskErrorCategory CategoryConversion(ErrorCategory cat) //CLEMENT: We've lost that info
     {
       switch (cat)
       {
diff --git a/Source/DafnyServer/DafnyHelper.cs b/Source/DafnyServer/DafnyHelper.cs
index 10d98677..d6c3f5c7 100644
--- a/Source/DafnyServer/DafnyHelper.cs
+++ b/Source/DafnyServer/DafnyHelper.cs
@@ -30,14 +30,14 @@ namespace Microsoft.Dafny {
     private string fname;
     private string source;
 
-    private Dafny.Errors errors;
+    private readonly Dafny.ErrorReporter reporter;
     private Dafny.Program dafnyProgram;
     private Bpl.Program boogieProgram;
 
     public DafnyHelper(string fname, string source) {
       this.fname = fname;
       this.source = source;
-      this.errors = new Dafny.Errors();
+      this.reporter = new Dafny.ConsoleErrorReporter();
     }
 
     public bool Verify() {
@@ -47,10 +47,10 @@ namespace Microsoft.Dafny {
     private bool Parse() {
       Dafny.ModuleDecl module = new Dafny.LiteralModuleDecl(new Dafny.DefaultModuleDecl(), null);
       Dafny.BuiltIns builtIns = new Dafny.BuiltIns();
-      var success = (Dafny.Parser.Parse(source, fname, fname, module, builtIns, errors) == 0 &&
-                     Dafny.Main.ParseIncludes(module, builtIns, new List<string>(), errors) == null);
+      var success = (Dafny.Parser.Parse(source, fname, fname, module, builtIns, new Dafny.Errors(reporter)) == 0 &&
+                     Dafny.Main.ParseIncludes(module, builtIns, new List<string>(), new Dafny.Errors(reporter)) == null);
       if (success) {
-        dafnyProgram = new Dafny.Program(fname, module, builtIns);
+        dafnyProgram = new Dafny.Program(fname, module, builtIns, reporter);
       }
       return success;
     }
@@ -58,11 +58,11 @@ namespace Microsoft.Dafny {
     private bool Resolve() {
       var resolver = new Dafny.Resolver(dafnyProgram);
       resolver.ResolveProgram(dafnyProgram);
-      return resolver.ErrorCount == 0;
+      return reporter.Count(ErrorLevel.Error) == 0;
     }
 
     private bool Translate() {
-      var translator = new Dafny.Translator() { InsertChecksums = true, UniqueIdPrefix = null }; //FIXME check if null is OK for UniqueIdPrefix
+      var translator = new Dafny.Translator(reporter) { InsertChecksums = true, UniqueIdPrefix = null }; //FIXME check if null is OK for UniqueIdPrefix
       boogieProgram = translator.Translate(dafnyProgram); // FIXME how are translation errors reported?
       return true;
     }
@@ -74,7 +74,8 @@ namespace Microsoft.Dafny {
         ExecutionEngine.CoalesceBlocks(boogieProgram);
         ExecutionEngine.Inline(boogieProgram);
 
-        switch (ExecutionEngine.InferAndVerify(boogieProgram, new PipelineStatistics(), "ServerProgram", null, DateTime.UtcNow.Ticks.ToString())) { // FIXME check if null is ok for error delegate
+        //FIXME Could capture errors instead of printing them (pass a delegate instead of null)
+        switch (ExecutionEngine.InferAndVerify(boogieProgram, new PipelineStatistics(), "ServerProgram", null, DateTime.UtcNow.Ticks.ToString())) {
           case PipelineOutcome.Done:
           case PipelineOutcome.VerificationCompleted:
             return true;
-- 
cgit v1.2.3


From e07d86d6cc4423703dbfb479f09b44c80f877ef9 Mon Sep 17 00:00:00 2001
From: leino <unknown>
Date: Sat, 3 Oct 2015 02:40:41 -0700
Subject: Parsing and pretty printing of the new "existential guards" of the
 two kinds of "if" statements.

---
 Source/Dafny/Cloner.cs                   |    4 +-
 Source/Dafny/Dafny.atg                   |   64 +-
 Source/Dafny/DafnyAst.cs                 |   12 +-
 Source/Dafny/Parser.cs                   | 1268 ++++++++++++++++--------------
 Source/Dafny/Printer.cs                  |   60 +-
 Source/Dafny/RefinementTransformer.cs    |    8 +-
 Source/Dafny/Resolver.cs                 |    2 +-
 Source/Dafny/Rewriter.cs                 |    2 +-
 Source/Dafny/Scanner.cs                  |  264 +++----
 Source/Dafny/Translator.cs               |    4 +-
 Test/dafny0/ExistentialGuards.dfy        |   89 +++
 Test/dafny0/ExistentialGuards.dfy.expect |   94 +++
 Test/dafny0/Simple.dfy                   |   27 +
 Test/dafny0/Simple.dfy.expect            |   29 +
 14 files changed, 1137 insertions(+), 790 deletions(-)
 create mode 100644 Test/dafny0/ExistentialGuards.dfy
 create mode 100644 Test/dafny0/ExistentialGuards.dfy.expect

(limited to 'Source/Dafny/Scanner.cs')

diff --git a/Source/Dafny/Cloner.cs b/Source/Dafny/Cloner.cs
index 45d8a2c9..9a93a340 100644
--- a/Source/Dafny/Cloner.cs
+++ b/Source/Dafny/Cloner.cs
@@ -531,7 +531,7 @@ namespace Microsoft.Dafny
 
       } else if (stmt is IfStmt) {
         var s = (IfStmt)stmt;
-        r = new IfStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Guard), CloneBlockStmt(s.Thn), CloneStmt(s.Els));
+        r = new IfStmt(Tok(s.Tok), Tok(s.EndTok), s.IsExistentialGuard, CloneExpr(s.Guard), CloneBlockStmt(s.Thn), CloneStmt(s.Els));
 
       } else if (stmt is AlternativeStmt) {
         var s = (AlternativeStmt)stmt;
@@ -631,7 +631,7 @@ namespace Microsoft.Dafny
     }
 
     public GuardedAlternative CloneGuardedAlternative(GuardedAlternative alt) {
-      return new GuardedAlternative(Tok(alt.Tok), CloneExpr(alt.Guard), alt.Body.ConvertAll(CloneStmt));
+      return new GuardedAlternative(Tok(alt.Tok), alt.IsExistentialGuard, CloneExpr(alt.Guard), alt.Body.ConvertAll(CloneStmt));
     }
 
     public Function CloneFunction(Function f, string newName = null) {
diff --git a/Source/Dafny/Dafny.atg b/Source/Dafny/Dafny.atg
index 954448af..66dff8a2 100644
--- a/Source/Dafny/Dafny.atg
+++ b/Source/Dafny/Dafny.atg
@@ -104,6 +104,25 @@ bool IsAlternative() {
   return la.kind == _lbrace && x.kind == _case;
 }
 
+// an existential guard starts with an identifier and is then followed by
+// * a colon (if the first identifier is given an explicit type),
+// * a comma (if there's a list a bound variables and the first one is not given an explicit type),
+// * a start-attribute (if there's one bound variable and it is not given an explicit type and there are attributes), or
+// * a bored smiley (if there's one bound variable and it is not given an explicit type).
+bool IsExistentialGuard() {
+  scanner.ResetPeek();
+  if (la.kind == _ident) {
+    Token x = scanner.Peek();
+    if (x.kind == _colon || x.kind == _comma || x.kind == _boredSmiley) {
+      return true;
+    } else if (x.kind == _lbrace) {
+      x = scanner.Peek();
+      return x.kind == _colon;
+    }
+  }
+  return false;
+}
+
 bool IsLoopSpec() {
   return la.kind == _invariant | la.kind == _decreases | la.kind == _modifies;
 }
@@ -456,6 +475,7 @@ TOKENS
   comma = ','.
   verticalbar = '|'.
   doublecolon = "::".
+  boredSmiley = ":|".
   bullet = '\u2022'.
   dot = '.'.
   semi = ';'.
@@ -1651,7 +1671,7 @@ VarDeclStatement<.out Statement/*!*/ s.>
   .
 IfStmt<out Statement/*!*/ ifStmt>
 = (. Contract.Ensures(Contract.ValueAtReturn(out ifStmt) != null); IToken/*!*/ x;
-     Expression guard = null;  IToken guardEllipsis = null;
+     Expression guard = null;  IToken guardEllipsis = null;  bool isExistentialGuard = false;
      BlockStmt/*!*/ thn;
      BlockStmt/*!*/ bs;
      Statement/*!*/ s;
@@ -1663,11 +1683,13 @@ IfStmt<out Statement/*!*/ ifStmt>
   "if"                       (. x = t; .)
   (
     IF(IsAlternative())
-    AlternativeBlock<out alternatives, out endTok>
+    AlternativeBlock<true, out alternatives, out endTok>
     (. ifStmt = new AlternativeStmt(x, endTok, alternatives); .)
   |
-    ( Guard<out guard>
-    | "..."                  (. guardEllipsis = t; .)
+    ( IF(IsExistentialGuard())
+      ExistentialGuard<out guard, true>  (. isExistentialGuard = true; .)
+    | Guard<out guard>
+    | "..."                              (. guardEllipsis = t; .)
     )
     BlockStmt<out thn, out bodyStart, out bodyEnd>    (. endTok = thn.EndTok; .)
     [ "else"
@@ -1676,26 +1698,29 @@ IfStmt<out Statement/*!*/ ifStmt>
       )
     ]
     (. if (guardEllipsis != null) {
-         ifStmt = new SkeletonStatement(new IfStmt(x, endTok, guard, thn, els), guardEllipsis, null);
+         ifStmt = new SkeletonStatement(new IfStmt(x, endTok, isExistentialGuard, guard, thn, els), guardEllipsis, null);
        } else {
-         ifStmt = new IfStmt(x, endTok, guard, thn, els);
+         ifStmt = new IfStmt(x, endTok, isExistentialGuard, guard, thn, els);
        }
     .)
   )
   .
-AlternativeBlock<.out List<GuardedAlternative> alternatives, out IToken endTok.>
+AlternativeBlock<.bool allowExistentialGuards, out List<GuardedAlternative> alternatives, out IToken endTok.>
 = (. alternatives = new List<GuardedAlternative>();
      IToken x;
-     Expression e;
+     Expression e; bool isExistentialGuard;
      List<Statement> body;
   .)
   "{"
-  { "case"                      (. x = t; .)
-    Expression<out e, true, false> // NB: don't allow lambda here
+  { "case"                             (. x = t; isExistentialGuard = false; e = dummyExpr; .)
+    ( IF(allowExistentialGuards && IsExistentialGuard())
+      ExistentialGuard<out e, false >  (. isExistentialGuard = true; .)  // NB: don't allow lambda here
+    | Expression<out e, true, false> // NB: don't allow lambda here
+    )
     "=>"
     (. body = new List<Statement>(); .)
     { Stmt<body> }
-    (. alternatives.Add(new GuardedAlternative(x, e, body)); .)
+    (. alternatives.Add(new GuardedAlternative(x, isExistentialGuard, e, body)); .)
   }
   "}"                           (. endTok = t; .)
   .
@@ -1719,7 +1744,7 @@ WhileStmt<out Statement stmt>
   (
     IF(IsLoopSpec() || IsAlternative())
     { LoopSpec<invariants, decreases, ref mod, ref decAttrs, ref modAttrs> }
-    AlternativeBlock<out alternatives, out endTok>
+    AlternativeBlock<false, out alternatives, out endTok>
     (. stmt = new AlternativeLoopStmt(x, endTok, invariants, new Specification<Expression>(decreases, decAttrs), new Specification<FrameExpression>(mod, modAttrs), alternatives); .)
   |
     ( Guard<out guard>           (. Contract.Assume(guard == null || cce.Owner.None(guard)); .)
@@ -1799,6 +1824,21 @@ Guard<out Expression e>   /* null represents demonic-choice */
   | Expression<out ee, true, true>        (. e = ee; .)
   )
   .
+ExistentialGuard<out Expression e, bool allowLambda>
+= (. var bvars = new List<BoundVar>();
+     BoundVar bv;  IToken x;
+     Attributes attrs = null;
+     Expression body;
+  .)
+  IdentTypeOptional<out bv>                    (. bvars.Add(bv); x = bv.tok; .)
+  { ","
+    IdentTypeOptional<out bv>                  (. bvars.Add(bv); .)
+  }
+  { Attribute<ref attrs> }
+  ":|"
+  Expression<out body, true, allowLambda>
+  (. e = new ExistsExpr(x, bvars, null, body, attrs); .)
+  .
 MatchStmt<out Statement/*!*/ s>
 = (. Contract.Ensures(Contract.ValueAtReturn(out s) != null);
      Token x;  Expression/*!*/ e;  MatchCaseStmt/*!*/ c;
diff --git a/Source/Dafny/DafnyAst.cs b/Source/Dafny/DafnyAst.cs
index 4fc48f2f..64af1425 100644
--- a/Source/Dafny/DafnyAst.cs
+++ b/Source/Dafny/DafnyAst.cs
@@ -4411,20 +4411,24 @@ namespace Microsoft.Dafny {
   }
 
   public class IfStmt : Statement {
+    public readonly bool IsExistentialGuard;
     public readonly Expression Guard;
     public readonly BlockStmt Thn;
     public readonly Statement Els;
     [ContractInvariantMethod]
     void ObjectInvariant() {
+      Contract.Invariant(!IsExistentialGuard || (Guard is ExistsExpr && ((ExistsExpr)Guard).Range == null));
       Contract.Invariant(Thn != null);
       Contract.Invariant(Els == null || Els is BlockStmt || Els is IfStmt || Els is SkeletonStatement);
     }
-    public IfStmt(IToken tok, IToken endTok, Expression guard, BlockStmt thn, Statement els)
+    public IfStmt(IToken tok, IToken endTok, bool isExistentialGuard, Expression guard, BlockStmt thn, Statement els)
       : base(tok, endTok) {
       Contract.Requires(tok != null);
       Contract.Requires(endTok != null);
+      Contract.Requires(!isExistentialGuard || (guard is ExistsExpr && ((ExistsExpr)guard).Range == null));
       Contract.Requires(thn != null);
       Contract.Requires(els == null || els is BlockStmt || els is IfStmt || els is SkeletonStatement);
+      this.IsExistentialGuard = isExistentialGuard;
       this.Guard = guard;
       this.Thn = thn;
       this.Els = els;
@@ -4450,20 +4454,24 @@ namespace Microsoft.Dafny {
   public class GuardedAlternative
   {
     public readonly IToken Tok;
+    public readonly bool IsExistentialGuard;
     public readonly Expression Guard;
     public readonly List<Statement> Body;
     [ContractInvariantMethod]
     void ObjectInvariant() {
       Contract.Invariant(Tok != null);
       Contract.Invariant(Guard != null);
+      Contract.Invariant(!IsExistentialGuard || (Guard is ExistsExpr && ((ExistsExpr)Guard).Range == null));
       Contract.Invariant(Body != null);
     }
-    public GuardedAlternative(IToken tok, Expression guard, List<Statement> body)
+    public GuardedAlternative(IToken tok, bool isExistentialGuard, Expression guard, List<Statement> body)
     {
       Contract.Requires(tok != null);
       Contract.Requires(guard != null);
+      Contract.Requires(!isExistentialGuard || (guard is ExistsExpr && ((ExistsExpr)guard).Range == null));
       Contract.Requires(body != null);
       this.Tok = tok;
+      this.IsExistentialGuard = isExistentialGuard;
       this.Guard = guard;
       this.Body = body;
     }
diff --git a/Source/Dafny/Parser.cs b/Source/Dafny/Parser.cs
index 7dafb572..c79c1051 100644
--- a/Source/Dafny/Parser.cs
+++ b/Source/Dafny/Parser.cs
@@ -38,40 +38,41 @@ public class Parser {
 	public const int _comma = 22;
 	public const int _verticalbar = 23;
 	public const int _doublecolon = 24;
-	public const int _bullet = 25;
-	public const int _dot = 26;
-	public const int _semi = 27;
-	public const int _darrow = 28;
-	public const int _arrow = 29;
-	public const int _assume = 30;
-	public const int _calc = 31;
-	public const int _case = 32;
-	public const int _then = 33;
-	public const int _else = 34;
-	public const int _decreases = 35;
-	public const int _invariant = 36;
-	public const int _function = 37;
-	public const int _predicate = 38;
-	public const int _inductive = 39;
-	public const int _lemma = 40;
-	public const int _copredicate = 41;
-	public const int _modifies = 42;
-	public const int _reads = 43;
-	public const int _requires = 44;
-	public const int _lbrace = 45;
-	public const int _rbrace = 46;
-	public const int _lbracket = 47;
-	public const int _rbracket = 48;
-	public const int _openparen = 49;
-	public const int _closeparen = 50;
-	public const int _openAngleBracket = 51;
-	public const int _closeAngleBracket = 52;
-	public const int _eq = 53;
-	public const int _neq = 54;
-	public const int _neqAlt = 55;
-	public const int _star = 56;
-	public const int _notIn = 57;
-	public const int _ellipsis = 58;
+	public const int _boredSmiley = 25;
+	public const int _bullet = 26;
+	public const int _dot = 27;
+	public const int _semi = 28;
+	public const int _darrow = 29;
+	public const int _arrow = 30;
+	public const int _assume = 31;
+	public const int _calc = 32;
+	public const int _case = 33;
+	public const int _then = 34;
+	public const int _else = 35;
+	public const int _decreases = 36;
+	public const int _invariant = 37;
+	public const int _function = 38;
+	public const int _predicate = 39;
+	public const int _inductive = 40;
+	public const int _lemma = 41;
+	public const int _copredicate = 42;
+	public const int _modifies = 43;
+	public const int _reads = 44;
+	public const int _requires = 45;
+	public const int _lbrace = 46;
+	public const int _rbrace = 47;
+	public const int _lbracket = 48;
+	public const int _rbracket = 49;
+	public const int _openparen = 50;
+	public const int _closeparen = 51;
+	public const int _openAngleBracket = 52;
+	public const int _closeAngleBracket = 53;
+	public const int _eq = 54;
+	public const int _neq = 55;
+	public const int _neqAlt = 56;
+	public const int _star = 57;
+	public const int _notIn = 58;
+	public const int _ellipsis = 59;
 	public const int maxT = 138;
 
 	const bool _T = true;
@@ -175,6 +176,25 @@ bool IsAlternative() {
   return la.kind == _lbrace && x.kind == _case;
 }
 
+// an existential guard starts with an identifier and is then followed by
+// * a colon (if the first identifier is given an explicit type),
+// * a comma (if there's a list a bound variables and the first one is not given an explicit type),
+// * a start-attribute (if there's one bound variable and it is not given an explicit type and there are attributes), or
+// * a bored smiley (if there's one bound variable and it is not given an explicit type).
+bool IsExistentialGuard() {
+  scanner.ResetPeek();
+  if (la.kind == _ident) {
+    Token x = scanner.Peek();
+    if (x.kind == _colon || x.kind == _comma || x.kind == _boredSmiley) {
+      return true;
+    } else if (x.kind == _lbrace) {
+      x = scanner.Peek();
+      return x.kind == _colon;
+    }
+  }
+  return false;
+}
+
 bool IsLoopSpec() {
   return la.kind == _invariant | la.kind == _decreases | la.kind == _modifies;
 }
@@ -532,7 +552,7 @@ bool IsType(ref IToken pt) {
 		TraitDecl/*!*/ trait;
 		Contract.Assert(defaultModule != null);
 		
-		while (la.kind == 59) {
+		while (la.kind == 60) {
 			Get();
 			Expect(20);
 			{
@@ -552,42 +572,42 @@ bool IsType(ref IToken pt) {
 		}
 		while (StartOf(1)) {
 			switch (la.kind) {
-			case 60: case 61: case 64: {
+			case 61: case 62: case 65: {
 				SubModuleDecl(defaultModule, out submodule);
 				defaultModule.TopLevelDecls.Add(submodule); 
 				break;
 			}
-			case 69: {
+			case 70: {
 				ClassDecl(defaultModule, out c);
 				defaultModule.TopLevelDecls.Add(c); 
 				break;
 			}
-			case 75: case 76: {
+			case 76: case 77: {
 				DatatypeDecl(defaultModule, out dt);
 				defaultModule.TopLevelDecls.Add(dt); 
 				break;
 			}
-			case 78: {
+			case 79: {
 				NewtypeDecl(defaultModule, out td);
 				defaultModule.TopLevelDecls.Add(td); 
 				break;
 			}
-			case 79: {
+			case 80: {
 				OtherTypeDecl(defaultModule, out td);
 				defaultModule.TopLevelDecls.Add(td); 
 				break;
 			}
-			case 80: {
+			case 81: {
 				IteratorDecl(defaultModule, out iter);
 				defaultModule.TopLevelDecls.Add(iter); 
 				break;
 			}
-			case 71: {
+			case 72: {
 				TraitDecl(defaultModule, out trait);
 				defaultModule.TopLevelDecls.Add(trait); 
 				break;
 			}
-			case 37: case 38: case 39: case 40: case 41: case 72: case 73: case 74: case 77: case 83: case 84: case 85: case 86: {
+			case 38: case 39: case 40: case 41: case 42: case 73: case 74: case 75: case 78: case 84: case 85: case 86: case 87: {
 				ClassMemberDecl(membersDefaultClass, false, !DafnyOptions.O.AllowGlobals, false);
 				break;
 			}
@@ -621,20 +641,20 @@ bool IsType(ref IToken pt) {
 		bool isExclusively = false;
 		bool opened = false;
 		
-		if (la.kind == 60 || la.kind == 61) {
-			if (la.kind == 60) {
+		if (la.kind == 61 || la.kind == 62) {
+			if (la.kind == 61) {
 				Get();
 				isAbstract = true; 
 			}
-			Expect(61);
-			while (la.kind == 45) {
+			Expect(62);
+			while (la.kind == 46) {
 				Attribute(ref attrs);
 			}
 			NoUSIdent(out id);
-			if (la.kind == 62 || la.kind == 63) {
-				if (la.kind == 62) {
+			if (la.kind == 63 || la.kind == 64) {
+				if (la.kind == 63) {
 					Get();
-					Expect(63);
+					Expect(64);
 					QualifiedModuleName(out idRefined);
 					isExclusively = true; 
 				} else {
@@ -644,79 +664,79 @@ bool IsType(ref IToken pt) {
 				}
 			}
 			module = new ModuleDefinition(id, id.val, isAbstract, false, isExclusively, idRefined == null ? null : idRefined, parent, attrs, false, this); 
-			Expect(45);
+			Expect(46);
 			module.BodyStartTok = t; 
 			while (StartOf(1)) {
 				switch (la.kind) {
-				case 60: case 61: case 64: {
+				case 61: case 62: case 65: {
 					SubModuleDecl(module, out sm);
 					module.TopLevelDecls.Add(sm); 
 					break;
 				}
-				case 69: {
+				case 70: {
 					ClassDecl(module, out c);
 					module.TopLevelDecls.Add(c); 
 					break;
 				}
-				case 71: {
+				case 72: {
 					TraitDecl(module, out trait);
 					module.TopLevelDecls.Add(trait); 
 					break;
 				}
-				case 75: case 76: {
+				case 76: case 77: {
 					DatatypeDecl(module, out dt);
 					module.TopLevelDecls.Add(dt); 
 					break;
 				}
-				case 78: {
+				case 79: {
 					NewtypeDecl(module, out td);
 					module.TopLevelDecls.Add(td); 
 					break;
 				}
-				case 79: {
+				case 80: {
 					OtherTypeDecl(module, out td);
 					module.TopLevelDecls.Add(td); 
 					break;
 				}
-				case 80: {
+				case 81: {
 					IteratorDecl(module, out iter);
 					module.TopLevelDecls.Add(iter); 
 					break;
 				}
-				case 37: case 38: case 39: case 40: case 41: case 72: case 73: case 74: case 77: case 83: case 84: case 85: case 86: {
+				case 38: case 39: case 40: case 41: case 42: case 73: case 74: case 75: case 78: case 84: case 85: case 86: case 87: {
 					ClassMemberDecl(namedModuleDefaultClassMembers, false, !DafnyOptions.O.AllowGlobals, DafnyOptions.O.IronDafny && isAbstract);
 					break;
 				}
 				}
 			}
-			Expect(46);
+			Expect(47);
 			module.BodyEndTok = t;
 			module.TopLevelDecls.Add(new DefaultClassDecl(module, namedModuleDefaultClassMembers));
 			submodule = new LiteralModuleDecl(module, parent); 
-		} else if (la.kind == 64) {
+		} else if (la.kind == 65) {
 			Get();
-			if (la.kind == 65) {
+			if (la.kind == 66) {
 				Get();
 				opened = true;
 			}
 			NoUSIdent(out id);
-			if (la.kind == 66 || la.kind == 67) {
-				if (la.kind == 66) {
+			if (la.kind == 67 || la.kind == 68) {
+				if (la.kind == 67) {
 					Get();
 					QualifiedModuleName(out idPath);
 					submodule = new AliasModuleDecl(idPath, id, parent, opened); 
 				} else {
 					Get();
 					QualifiedModuleName(out idPath);
-					if (la.kind == 68) {
+					if (la.kind == 69) {
 						Get();
 						QualifiedModuleName(out idAssignment);
 					}
 					submodule = new ModuleFacadeDecl(idPath, id, parent, idAssignment, opened); 
 				}
 			}
-			if (la.kind == 27) {
-				while (!(la.kind == 0 || la.kind == 27)) {SynErr(139); Get();}
+			if (la.kind == 28) {
+				while (!(la.kind == 0 || la.kind == 28)) {SynErr(139); Get();}
 				Get();
 				errors.Warning(t, "the semi-colon that used to terminate a sub-module declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 			}
@@ -740,16 +760,16 @@ bool IsType(ref IToken pt) {
 		List<MemberDecl/*!*/> members = new List<MemberDecl/*!*/>();
 		IToken bodyStart;
 		
-		while (!(la.kind == 0 || la.kind == 69)) {SynErr(141); Get();}
-		Expect(69);
-		while (la.kind == 45) {
+		while (!(la.kind == 0 || la.kind == 70)) {SynErr(141); Get();}
+		Expect(70);
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		NoUSIdent(out id);
-		if (la.kind == 51) {
+		if (la.kind == 52) {
 			GenericParameters(typeArgs);
 		}
-		if (la.kind == 70) {
+		if (la.kind == 71) {
 			Get();
 			Type(out trait);
 			traits.Add(trait); 
@@ -759,12 +779,12 @@ bool IsType(ref IToken pt) {
 				traits.Add(trait); 
 			}
 		}
-		Expect(45);
+		Expect(46);
 		bodyStart = t;  
 		while (StartOf(2)) {
 			ClassMemberDecl(members, true, false, false);
 		}
-		Expect(46);
+		Expect(47);
 		c = new ClassDecl(id, id.val, module, typeArgs, members, attrs, traits);
 		c.BodyStartTok = bodyStart;
 		c.BodyEndTok = t;
@@ -781,29 +801,29 @@ bool IsType(ref IToken pt) {
 		IToken bodyStart = Token.NoToken;  // dummy assignment
 		bool co = false;
 		
-		while (!(la.kind == 0 || la.kind == 75 || la.kind == 76)) {SynErr(142); Get();}
-		if (la.kind == 75) {
+		while (!(la.kind == 0 || la.kind == 76 || la.kind == 77)) {SynErr(142); Get();}
+		if (la.kind == 76) {
 			Get();
-		} else if (la.kind == 76) {
+		} else if (la.kind == 77) {
 			Get();
 			co = true; 
 		} else SynErr(143);
-		while (la.kind == 45) {
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		NoUSIdent(out id);
-		if (la.kind == 51) {
+		if (la.kind == 52) {
 			GenericParameters(typeArgs);
 		}
-		Expect(66);
+		Expect(67);
 		bodyStart = t; 
 		DatatypeMemberDecl(ctors);
 		while (la.kind == 23) {
 			Get();
 			DatatypeMemberDecl(ctors);
 		}
-		if (la.kind == 27) {
-			while (!(la.kind == 0 || la.kind == 27)) {SynErr(144); Get();}
+		if (la.kind == 28) {
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(144); Get();}
 			Get();
 			errors.Warning(t, "the semi-colon that used to terminate a (co)datatype declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 		}
@@ -824,12 +844,12 @@ bool IsType(ref IToken pt) {
 		Type baseType = null;
 		Expression wh;
 		
-		Expect(78);
-		while (la.kind == 45) {
+		Expect(79);
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		NoUSIdent(out id);
-		Expect(66);
+		Expect(67);
 		if (IsIdentColonOrBar()) {
 			NoUSIdent(out bvId);
 			if (la.kind == 21) {
@@ -854,24 +874,24 @@ bool IsType(ref IToken pt) {
 		td = null;
 		Type ty;
 		
-		Expect(79);
-		while (la.kind == 45) {
+		Expect(80);
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		NoUSIdent(out id);
-		if (la.kind == 49) {
+		if (la.kind == 50) {
 			Get();
-			Expect(53);
-			Expect(50);
+			Expect(54);
+			Expect(51);
 			eqSupport = TypeParameter.EqualitySupportValue.Required; 
-			if (la.kind == 51) {
+			if (la.kind == 52) {
 				GenericParameters(typeArgs);
 			}
 		} else if (StartOf(4)) {
-			if (la.kind == 51) {
+			if (la.kind == 52) {
 				GenericParameters(typeArgs);
 			}
-			if (la.kind == 66) {
+			if (la.kind == 67) {
 				Get();
 				Type(out ty);
 				td = new TypeSynonymDecl(id, id.val, typeArgs, module, ty, attrs); 
@@ -881,8 +901,8 @@ bool IsType(ref IToken pt) {
 		 td = new OpaqueTypeDecl(id, id.val, module, eqSupport, typeArgs, attrs);
 		}
 		
-		if (la.kind == 27) {
-			while (!(la.kind == 0 || la.kind == 27)) {SynErr(147); Get();}
+		if (la.kind == 28) {
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(147); Get();}
 			Get();
 			errors.Warning(t, "the semi-colon that used to terminate an opaque-type declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 		}
@@ -911,19 +931,19 @@ bool IsType(ref IToken pt) {
 		IToken bodyStart = Token.NoToken;
 		IToken bodyEnd = Token.NoToken;
 		
-		while (!(la.kind == 0 || la.kind == 80)) {SynErr(148); Get();}
-		Expect(80);
-		while (la.kind == 45) {
+		while (!(la.kind == 0 || la.kind == 81)) {SynErr(148); Get();}
+		Expect(81);
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		NoUSIdent(out id);
-		if (la.kind == 49 || la.kind == 51) {
-			if (la.kind == 51) {
+		if (la.kind == 50 || la.kind == 52) {
+			if (la.kind == 52) {
 				GenericParameters(typeArgs);
 			}
 			Formals(true, true, ins);
-			if (la.kind == 81 || la.kind == 82) {
-				if (la.kind == 81) {
+			if (la.kind == 82 || la.kind == 83) {
+				if (la.kind == 82) {
 					Get();
 				} else {
 					Get();
@@ -931,14 +951,14 @@ bool IsType(ref IToken pt) {
 				}
 				Formals(false, true, outs);
 			}
-		} else if (la.kind == 58) {
+		} else if (la.kind == 59) {
 			Get();
 			signatureEllipsis = t; 
 		} else SynErr(149);
 		while (StartOf(5)) {
 			IteratorSpec(reads, mod, decreases, req, ens, yieldReq, yieldEns, ref readsAttrs, ref modAttrs, ref decrAttrs);
 		}
-		if (la.kind == 45) {
+		if (la.kind == 46) {
 			BlockStmt(out body, out bodyStart, out bodyEnd);
 		}
 		iter = new IteratorDecl(id, id.val, module, typeArgs, ins, outs,
@@ -961,21 +981,21 @@ bool IsType(ref IToken pt) {
 		List<MemberDecl/*!*/> members = new List<MemberDecl/*!*/>();
 		IToken bodyStart;
 		
-		while (!(la.kind == 0 || la.kind == 71)) {SynErr(150); Get();}
-		Expect(71);
-		while (la.kind == 45) {
+		while (!(la.kind == 0 || la.kind == 72)) {SynErr(150); Get();}
+		Expect(72);
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		NoUSIdent(out id);
-		if (la.kind == 51) {
+		if (la.kind == 52) {
 			GenericParameters(typeArgs);
 		}
-		Expect(45);
+		Expect(46);
 		bodyStart = t; 
 		while (StartOf(2)) {
 			ClassMemberDecl(members, true, false, false);
 		}
-		Expect(46);
+		Expect(47);
 		trait = new TraitDecl(id, id.val, module, typeArgs, members, attrs);
 		trait.BodyStartTok = bodyStart;
 		trait.BodyEndTok = t;
@@ -989,11 +1009,11 @@ bool IsType(ref IToken pt) {
 		MemberModifiers mmod = new MemberModifiers();
 		IToken staticToken = null, protectedToken = null;
 		
-		while (la.kind == 72 || la.kind == 73 || la.kind == 74) {
-			if (la.kind == 72) {
+		while (la.kind == 73 || la.kind == 74 || la.kind == 75) {
+			if (la.kind == 73) {
 				Get();
 				mmod.IsGhost = true; 
-			} else if (la.kind == 73) {
+			} else if (la.kind == 74) {
 				Get();
 				mmod.IsStatic = true; staticToken = t; 
 			} else {
@@ -1001,7 +1021,7 @@ bool IsType(ref IToken pt) {
 				mmod.IsProtected = true; protectedToken = t; 
 			}
 		}
-		if (la.kind == 77) {
+		if (la.kind == 78) {
 			if (moduleLevelDecl) {
 			 SemErr(la, "fields are not allowed to be declared at the module level; instead, wrap the field in a 'class' declaration");
 			 mmod.IsStatic = false;
@@ -1036,14 +1056,14 @@ bool IsType(ref IToken pt) {
 		IToken x; string name;
 		var args = new List<Expression>();
 		
-		Expect(45);
+		Expect(46);
 		Expect(21);
 		NoUSIdent(out x);
 		name = x.val; 
 		if (StartOf(7)) {
 			Expressions(args);
 		}
-		Expect(46);
+		Expect(47);
 		attrs = new Attributes(name, args, attrs); 
 	}
 
@@ -1061,7 +1081,7 @@ bool IsType(ref IToken pt) {
 		IToken id; ids = new List<IToken>(); 
 		Ident(out id);
 		ids.Add(id); 
-		while (la.kind == 26) {
+		while (la.kind == 27) {
 			Get();
 			Ident(out id);
 			ids.Add(id); 
@@ -1079,13 +1099,13 @@ bool IsType(ref IToken pt) {
 		IToken/*!*/ id;
 		TypeParameter.EqualitySupportValue eqSupport;
 		
-		Expect(51);
+		Expect(52);
 		NoUSIdent(out id);
 		eqSupport = TypeParameter.EqualitySupportValue.Unspecified; 
-		if (la.kind == 49) {
+		if (la.kind == 50) {
 			Get();
-			Expect(53);
-			Expect(50);
+			Expect(54);
+			Expect(51);
 			eqSupport = TypeParameter.EqualitySupportValue.Required; 
 		}
 		typeArgs.Add(new TypeParameter(id, id.val, eqSupport)); 
@@ -1093,15 +1113,15 @@ bool IsType(ref IToken pt) {
 			Get();
 			NoUSIdent(out id);
 			eqSupport = TypeParameter.EqualitySupportValue.Unspecified; 
-			if (la.kind == 49) {
+			if (la.kind == 50) {
 				Get();
-				Expect(53);
-				Expect(50);
+				Expect(54);
+				Expect(51);
 				eqSupport = TypeParameter.EqualitySupportValue.Required; 
 			}
 			typeArgs.Add(new TypeParameter(id, id.val, eqSupport)); 
 		}
-		Expect(52);
+		Expect(53);
 	}
 
 	void Type(out Type ty) {
@@ -1114,11 +1134,11 @@ bool IsType(ref IToken pt) {
 		Attributes attrs = null;
 		IToken/*!*/ id;  Type/*!*/ ty;
 		
-		while (!(la.kind == 0 || la.kind == 77)) {SynErr(152); Get();}
-		Expect(77);
+		while (!(la.kind == 0 || la.kind == 78)) {SynErr(152); Get();}
+		Expect(78);
 		if (mmod.IsStatic) { SemErr(t, "fields cannot be declared 'static'"); }
 		
-		while (la.kind == 45) {
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		FIdentType(out id, out ty);
@@ -1150,48 +1170,48 @@ bool IsType(ref IToken pt) {
 		IToken signatureEllipsis = null;
 		bool missingOpenParen;
 		
-		if (la.kind == 37) {
+		if (la.kind == 38) {
 			Get();
-			if (la.kind == 83) {
+			if (la.kind == 84) {
 				Get();
 				isFunctionMethod = true; 
 			}
 			if (mmod.IsGhost) { SemErr(t, "functions cannot be declared 'ghost' (they are ghost by default)"); }
 			
-			while (la.kind == 45) {
+			while (la.kind == 46) {
 				Attribute(ref attrs);
 			}
 			NoUSIdent(out id);
-			if (la.kind == 49 || la.kind == 51) {
-				if (la.kind == 51) {
+			if (la.kind == 50 || la.kind == 52) {
+				if (la.kind == 52) {
 					GenericParameters(typeArgs);
 				}
 				Formals(true, isFunctionMethod, formals);
 				Expect(21);
 				Type(out returnType);
-			} else if (la.kind == 58) {
+			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
 			} else SynErr(153);
-		} else if (la.kind == 38) {
+		} else if (la.kind == 39) {
 			Get();
 			isPredicate = true; 
-			if (la.kind == 83) {
+			if (la.kind == 84) {
 				Get();
 				isFunctionMethod = true; 
 			}
 			if (mmod.IsGhost) { SemErr(t, "predicates cannot be declared 'ghost' (they are ghost by default)"); }
 			
-			while (la.kind == 45) {
+			while (la.kind == 46) {
 				Attribute(ref attrs);
 			}
 			NoUSIdent(out id);
 			if (StartOf(8)) {
-				if (la.kind == 51) {
+				if (la.kind == 52) {
 					GenericParameters(typeArgs);
 				}
 				missingOpenParen = true; 
-				if (la.kind == 49) {
+				if (la.kind == 50) {
 					Formals(true, isFunctionMethod, formals);
 					missingOpenParen = false; 
 				}
@@ -1200,22 +1220,22 @@ bool IsType(ref IToken pt) {
 					Get();
 					SemErr(t, "predicates do not have an explicitly declared return type; it is always bool"); 
 				}
-			} else if (la.kind == 58) {
+			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
 			} else SynErr(154);
-		} else if (la.kind == 39) {
+		} else if (la.kind == 40) {
 			Get();
-			Expect(38);
+			Expect(39);
 			isIndPredicate = true; 
 			if (mmod.IsGhost) { SemErr(t, "inductive predicates cannot be declared 'ghost' (they are ghost by default)"); }
 			
-			while (la.kind == 45) {
+			while (la.kind == 46) {
 				Attribute(ref attrs);
 			}
 			NoUSIdent(out id);
-			if (la.kind == 49 || la.kind == 51) {
-				if (la.kind == 51) {
+			if (la.kind == 50 || la.kind == 52) {
+				if (la.kind == 52) {
 					GenericParameters(typeArgs);
 				}
 				Formals(true, isFunctionMethod, formals);
@@ -1223,21 +1243,21 @@ bool IsType(ref IToken pt) {
 					Get();
 					SemErr(t, "inductive predicates do not have an explicitly declared return type; it is always bool"); 
 				}
-			} else if (la.kind == 58) {
+			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
 			} else SynErr(155);
-		} else if (la.kind == 41) {
+		} else if (la.kind == 42) {
 			Get();
 			isCoPredicate = true; 
 			if (mmod.IsGhost) { SemErr(t, "copredicates cannot be declared 'ghost' (they are ghost by default)"); }
 			
-			while (la.kind == 45) {
+			while (la.kind == 46) {
 				Attribute(ref attrs);
 			}
 			NoUSIdent(out id);
-			if (la.kind == 49 || la.kind == 51) {
-				if (la.kind == 51) {
+			if (la.kind == 50 || la.kind == 52) {
+				if (la.kind == 52) {
 					GenericParameters(typeArgs);
 				}
 				Formals(true, isFunctionMethod, formals);
@@ -1245,7 +1265,7 @@ bool IsType(ref IToken pt) {
 					Get();
 					SemErr(t, "copredicates do not have an explicitly declared return type; it is always bool"); 
 				}
-			} else if (la.kind == 58) {
+			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
 			} else SynErr(156);
@@ -1254,7 +1274,7 @@ bool IsType(ref IToken pt) {
 		while (StartOf(9)) {
 			FunctionSpec(reqs, reads, ens, decreases);
 		}
-		if (la.kind == 45) {
+		if (la.kind == 46) {
 			FunctionBody(out body, out bodyStart, out bodyEnd);
 		}
 		if (!isWithinAbstractModule && DafnyOptions.O.DisallowSoundnessCheating && body == null && ens.Count > 0 && !Attributes.Contains(attrs, "axiom") && !Attributes.Contains(attrs, "imported")) {
@@ -1310,34 +1330,34 @@ bool IsType(ref IToken pt) {
 		
 		while (!(StartOf(10))) {SynErr(158); Get();}
 		switch (la.kind) {
-		case 83: {
+		case 84: {
 			Get();
 			break;
 		}
-		case 40: {
+		case 41: {
 			Get();
 			isLemma = true; 
 			break;
 		}
-		case 84: {
+		case 85: {
 			Get();
 			isCoLemma = true; 
 			break;
 		}
-		case 85: {
+		case 86: {
 			Get();
 			isCoLemma = true;
 			errors.Warning(t, "the 'comethod' keyword has been deprecated; it has been renamed to 'colemma'");
 			
 			break;
 		}
-		case 39: {
+		case 40: {
 			Get();
-			Expect(40);
+			Expect(41);
 			isIndLemma = true; 
 			break;
 		}
-		case 86: {
+		case 87: {
 			Get();
 			if (allowConstructor) {
 			 isConstructor = true;
@@ -1371,7 +1391,7 @@ bool IsType(ref IToken pt) {
 		 }
 		}
 		
-		while (la.kind == 45) {
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		if (la.kind == 1) {
@@ -1385,24 +1405,24 @@ bool IsType(ref IToken pt) {
 		 }
 		}
 		
-		if (la.kind == 49 || la.kind == 51) {
-			if (la.kind == 51) {
+		if (la.kind == 50 || la.kind == 52) {
+			if (la.kind == 52) {
 				GenericParameters(typeArgs);
 			}
 			Formals(true, !mmod.IsGhost, ins);
-			if (la.kind == 82) {
+			if (la.kind == 83) {
 				Get();
 				if (isConstructor) { SemErr(t, "constructors cannot have out-parameters"); } 
 				Formals(false, !mmod.IsGhost, outs);
 			}
-		} else if (la.kind == 58) {
+		} else if (la.kind == 59) {
 			Get();
 			signatureEllipsis = t; 
 		} else SynErr(160);
 		while (StartOf(11)) {
 			MethodSpec(req, mod, ens, dec, ref decAttrs, ref modAttrs);
 		}
-		if (la.kind == 45) {
+		if (la.kind == 46) {
 			BlockStmt(out body, out bodyStart, out bodyEnd);
 		}
 		if (!isWithinAbstractModule && DafnyOptions.O.DisallowSoundnessCheating && body == null && ens.Count > 0 && !Attributes.Contains(attrs, "axiom") && !Attributes.Contains(attrs, "imported") && !Attributes.Contains(attrs, "decl") && theVerifyThisFile) {
@@ -1437,11 +1457,11 @@ bool IsType(ref IToken pt) {
 		IToken/*!*/ id;
 		List<Formal/*!*/> formals = new List<Formal/*!*/>();
 		
-		while (la.kind == 45) {
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		NoUSIdent(out id);
-		if (la.kind == 49) {
+		if (la.kind == 50) {
 			FormalsOptionalIds(formals);
 		}
 		ctors.Add(new DatatypeCtor(id, id.val, formals, attrs)); 
@@ -1449,7 +1469,7 @@ bool IsType(ref IToken pt) {
 
 	void FormalsOptionalIds(List<Formal/*!*/>/*!*/ formals) {
 		Contract.Requires(cce.NonNullElements(formals)); IToken/*!*/ id;  Type/*!*/ ty;  string/*!*/ name;  bool isGhost; 
-		Expect(49);
+		Expect(50);
 		if (StartOf(12)) {
 			TypeIdentOptional(out id, out name, out ty, out isGhost);
 			formals.Add(new Formal(id, name, ty, true, isGhost)); 
@@ -1459,7 +1479,7 @@ bool IsType(ref IToken pt) {
 				formals.Add(new Formal(id, name, ty, true, isGhost)); 
 			}
 		}
-		Expect(50);
+		Expect(51);
 	}
 
 	void FIdentType(out IToken/*!*/ id, out Type/*!*/ ty) {
@@ -1477,8 +1497,8 @@ bool IsType(ref IToken pt) {
 	}
 
 	void OldSemi() {
-		if (la.kind == 27) {
-			while (!(la.kind == 0 || la.kind == 27)) {SynErr(162); Get();}
+		if (la.kind == 28) {
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(162); Get();}
 			Get();
 		}
 	}
@@ -1487,7 +1507,7 @@ bool IsType(ref IToken pt) {
 		Expression e0; IToken endTok; 
 		EquivExpression(out e, allowSemi, allowLambda);
 		if (SemiFollowsCall(allowSemi, e)) {
-			Expect(27);
+			Expect(28);
 			endTok = t; 
 			Expression(out e0, allowSemi, allowLambda);
 			e = new StmtExpr(e.tok,
@@ -1501,7 +1521,7 @@ bool IsType(ref IToken pt) {
 		Contract.Ensures(Contract.ValueAtReturn(out id)!=null);
 		Contract.Ensures(Contract.ValueAtReturn(out ty)!=null);
 		isGhost = false; 
-		if (la.kind == 72) {
+		if (la.kind == 73) {
 			Get();
 			if (allowGhostKeyword) { isGhost = true; } else { SemErr(t, "formal cannot be declared 'ghost' in this context"); } 
 		}
@@ -1553,7 +1573,7 @@ bool IsType(ref IToken pt) {
 		Contract.Ensures(Contract.ValueAtReturn(out ty)!=null);
 		Contract.Ensures(Contract.ValueAtReturn(out identName)!=null);
 		string name = null; id = Token.NoToken; ty = new BoolType()/*dummy*/; isGhost = false; 
-		if (la.kind == 72) {
+		if (la.kind == 73) {
 			Get();
 			isGhost = true; 
 		}
@@ -1623,7 +1643,7 @@ bool IsType(ref IToken pt) {
 		case 13: {
 			Get();
 			tok = t;  gt = new List<Type>(); 
-			if (la.kind == 51) {
+			if (la.kind == 52) {
 				GenericInstantiation(gt);
 			}
 			if (gt.Count > 1) {
@@ -1636,7 +1656,7 @@ bool IsType(ref IToken pt) {
 		case 14: {
 			Get();
 			tok = t;  gt = new List<Type>(); 
-			if (la.kind == 51) {
+			if (la.kind == 52) {
 				GenericInstantiation(gt);
 			}
 			if (gt.Count > 1) {
@@ -1649,7 +1669,7 @@ bool IsType(ref IToken pt) {
 		case 15: {
 			Get();
 			tok = t;  gt = new List<Type>(); 
-			if (la.kind == 51) {
+			if (la.kind == 52) {
 				GenericInstantiation(gt);
 			}
 			if (gt.Count > 1) {
@@ -1662,7 +1682,7 @@ bool IsType(ref IToken pt) {
 		case 16: {
 			Get();
 			tok = t;  gt = new List<Type>(); 
-			if (la.kind == 51) {
+			if (la.kind == 52) {
 				GenericInstantiation(gt);
 			}
 			if (gt.Count > 1) {
@@ -1680,7 +1700,7 @@ bool IsType(ref IToken pt) {
 		case 17: {
 			Get();
 			tok = t;  gt = new List<Type>(); 
-			if (la.kind == 51) {
+			if (la.kind == 52) {
 				GenericInstantiation(gt);
 			}
 			if (gt.Count == 0) {
@@ -1697,7 +1717,7 @@ bool IsType(ref IToken pt) {
 		case 18: {
 			Get();
 			tok = t;  gt = new List<Type>(); 
-			if (la.kind == 51) {
+			if (la.kind == 52) {
 				GenericInstantiation(gt);
 			}
 			if (gt.Count == 0) {
@@ -1714,7 +1734,7 @@ bool IsType(ref IToken pt) {
 		case 5: {
 			Get();
 			tok = t;  gt = null; 
-			if (la.kind == 51) {
+			if (la.kind == 52) {
 				gt = new List<Type>(); 
 				GenericInstantiation(gt);
 			}
@@ -1723,7 +1743,7 @@ bool IsType(ref IToken pt) {
 			
 			break;
 		}
-		case 49: {
+		case 50: {
 			Get();
 			tok = t; tupleArgTypes = new List<Type>(); 
 			if (StartOf(3)) {
@@ -1735,7 +1755,7 @@ bool IsType(ref IToken pt) {
 					tupleArgTypes.Add(ty); 
 				}
 			}
-			Expect(50);
+			Expect(51);
 			if (tupleArgTypes.Count == 1) {
 			 // just return the type 'ty'
 			} else {
@@ -1750,11 +1770,11 @@ bool IsType(ref IToken pt) {
 			Expression e; tok = t; 
 			NameSegmentForTypeName(out e);
 			tok = t; 
-			while (la.kind == 26) {
+			while (la.kind == 27) {
 				Get();
 				Expect(1);
 				tok = t; List<Type> typeArgs = null; 
-				if (la.kind == 51) {
+				if (la.kind == 52) {
 					typeArgs = new List<Type>(); 
 					GenericInstantiation(typeArgs);
 				}
@@ -1765,7 +1785,7 @@ bool IsType(ref IToken pt) {
 		}
 		default: SynErr(164); break;
 		}
-		if (la.kind == 29) {
+		if (la.kind == 30) {
 			Type t2; 
 			Get();
 			tok = t; 
@@ -1783,8 +1803,8 @@ bool IsType(ref IToken pt) {
 
 	void Formals(bool incoming, bool allowGhostKeyword, List<Formal> formals) {
 		Contract.Requires(cce.NonNullElements(formals)); IToken id;  Type ty;  bool isGhost; 
-		Expect(49);
-		if (la.kind == 1 || la.kind == 72) {
+		Expect(50);
+		if (la.kind == 1 || la.kind == 73) {
 			GIdentType(allowGhostKeyword, out id, out ty, out isGhost);
 			formals.Add(new Formal(id, id.val, ty, incoming, isGhost)); 
 			while (la.kind == 22) {
@@ -1793,7 +1813,7 @@ bool IsType(ref IToken pt) {
 				formals.Add(new Formal(id, id.val, ty, incoming, isGhost)); 
 			}
 		}
-		Expect(50);
+		Expect(51);
 	}
 
 	void IteratorSpec(List<FrameExpression/*!*/>/*!*/ reads, List<FrameExpression/*!*/>/*!*/ mod, List<Expression/*!*/> decreases,
@@ -1803,7 +1823,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 		Expression/*!*/ e; FrameExpression/*!*/ fe; bool isFree = false; bool isYield = false; Attributes ensAttrs = null;
 		
 		while (!(StartOf(13))) {SynErr(165); Get();}
-		if (la.kind == 43) {
+		if (la.kind == 44) {
 			Get();
 			while (IsAttribute()) {
 				Attribute(ref readsAttrs);
@@ -1816,7 +1836,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 				reads.Add(fe); 
 			}
 			OldSemi();
-		} else if (la.kind == 42) {
+		} else if (la.kind == 43) {
 			Get();
 			while (IsAttribute()) {
 				Attribute(ref modAttrs);
@@ -1830,17 +1850,17 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 			}
 			OldSemi();
 		} else if (StartOf(14)) {
-			if (la.kind == 87) {
+			if (la.kind == 88) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
 				
 			}
-			if (la.kind == 89) {
+			if (la.kind == 90) {
 				Get();
 				isYield = true; 
 			}
-			if (la.kind == 44) {
+			if (la.kind == 45) {
 				Get();
 				Expression(out e, false, false);
 				OldSemi();
@@ -1850,7 +1870,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 				 req.Add(new MaybeFreeExpression(e, isFree));
 				}
 				
-			} else if (la.kind == 88) {
+			} else if (la.kind == 89) {
 				Get();
 				while (IsAttribute()) {
 					Attribute(ref ensAttrs);
@@ -1864,7 +1884,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 				}
 				
 			} else SynErr(166);
-		} else if (la.kind == 35) {
+		} else if (la.kind == 36) {
 			Get();
 			while (IsAttribute()) {
 				Attribute(ref decrAttrs);
@@ -1878,12 +1898,12 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 		Contract.Ensures(Contract.ValueAtReturn(out block) != null);
 		List<Statement/*!*/> body = new List<Statement/*!*/>();
 		
-		Expect(45);
+		Expect(46);
 		bodyStart = t; 
 		while (StartOf(15)) {
 			Stmt(body);
 		}
-		Expect(46);
+		Expect(47);
 		bodyEnd = t;
 		block = new BlockStmt(bodyStart, bodyEnd, body); 
 	}
@@ -1894,7 +1914,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression/*!*/ e;  FrameExpression/*!*/ fe;  bool isFree = false; Attributes ensAttrs = null;
 		
 		while (!(StartOf(16))) {SynErr(168); Get();}
-		if (la.kind == 42) {
+		if (la.kind == 43) {
 			Get();
 			while (IsAttribute()) {
 				Attribute(ref modAttrs);
@@ -1907,19 +1927,19 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				mod.Add(fe); 
 			}
 			OldSemi();
-		} else if (la.kind == 44 || la.kind == 87 || la.kind == 88) {
-			if (la.kind == 87) {
+		} else if (la.kind == 45 || la.kind == 88 || la.kind == 89) {
+			if (la.kind == 88) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
 				
 			}
-			if (la.kind == 44) {
+			if (la.kind == 45) {
 				Get();
 				Expression(out e, false, false);
 				OldSemi();
 				req.Add(new MaybeFreeExpression(e, isFree)); 
-			} else if (la.kind == 88) {
+			} else if (la.kind == 89) {
 				Get();
 				while (IsAttribute()) {
 					Attribute(ref ensAttrs);
@@ -1928,7 +1948,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				OldSemi();
 				ens.Add(new MaybeFreeExpression(e, isFree, ensAttrs)); 
 			} else SynErr(169);
-		} else if (la.kind == 35) {
+		} else if (la.kind == 36) {
 			Get();
 			while (IsAttribute()) {
 				Attribute(ref decAttrs);
@@ -1948,13 +1968,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (StartOf(7)) {
 			Expression(out e, allowSemi, allowLambda);
 			feTok = e.tok; 
-			if (la.kind == 90) {
+			if (la.kind == 91) {
 				Get();
 				Ident(out id);
 				fieldName = id.val;  feTok = id; 
 			}
 			fe = new FrameExpression(feTok, e, fieldName); 
-		} else if (la.kind == 90) {
+		} else if (la.kind == 91) {
 			Get();
 			Ident(out id);
 			fieldName = id.val; 
@@ -1985,7 +2005,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void GenericInstantiation(List<Type/*!*/>/*!*/ gt) {
 		Contract.Requires(cce.NonNullElements(gt)); Type/*!*/ ty; 
-		Expect(51);
+		Expect(52);
 		Type(out ty);
 		gt.Add(ty); 
 		while (la.kind == 22) {
@@ -1993,7 +2013,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Type(out ty);
 			gt.Add(ty); 
 		}
-		Expect(52);
+		Expect(53);
 	}
 
 	void NameSegmentForTypeName(out Expression e) {
@@ -2001,7 +2021,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<Type> typeArgs = null;
 		
 		Ident(out id);
-		if (la.kind == 51) {
+		if (la.kind == 52) {
 			typeArgs = new List<Type>(); 
 			GenericInstantiation(typeArgs);
 		}
@@ -2015,12 +2035,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Requires(decreases == null || cce.NonNullElements(decreases));
 		Expression/*!*/ e;  FrameExpression/*!*/ fe; 
 		while (!(StartOf(17))) {SynErr(172); Get();}
-		if (la.kind == 44) {
+		if (la.kind == 45) {
 			Get();
 			Expression(out e, false, false);
 			OldSemi();
 			reqs.Add(e); 
-		} else if (la.kind == 43) {
+		} else if (la.kind == 44) {
 			Get();
 			PossiblyWildFrameExpression(out fe, false);
 			reads.Add(fe); 
@@ -2030,12 +2050,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				reads.Add(fe); 
 			}
 			OldSemi();
-		} else if (la.kind == 88) {
+		} else if (la.kind == 89) {
 			Get();
 			Expression(out e, false, false);
 			OldSemi();
 			ens.Add(e); 
-		} else if (la.kind == 35) {
+		} else if (la.kind == 36) {
 			Get();
 			if (decreases == null) {
 			 SemErr(t, "'decreases' clauses are meaningless for copredicates, so they are not allowed");
@@ -2049,16 +2069,16 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void FunctionBody(out Expression/*!*/ e, out IToken bodyStart, out IToken bodyEnd) {
 		Contract.Ensures(Contract.ValueAtReturn(out e) != null); e = dummyExpr; 
-		Expect(45);
+		Expect(46);
 		bodyStart = t; 
 		Expression(out e, true, true);
-		Expect(46);
+		Expect(47);
 		bodyEnd = t; 
 	}
 
 	void PossiblyWildFrameExpression(out FrameExpression fe, bool allowSemi) {
 		Contract.Ensures(Contract.ValueAtReturn(out fe) != null); fe = dummyFrameExpr; 
-		if (la.kind == 56) {
+		if (la.kind == 57) {
 			Get();
 			fe = new FrameExpression(t, new WildcardExpr(t), null); 
 		} else if (StartOf(18)) {
@@ -2069,7 +2089,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 	void PossiblyWildExpression(out Expression e, bool allowLambda) {
 		Contract.Ensures(Contract.ValueAtReturn(out e)!=null);
 		e = dummyExpr; 
-		if (la.kind == 56) {
+		if (la.kind == 57) {
 			Get();
 			e = new WildcardExpr(t); 
 		} else if (StartOf(7)) {
@@ -2093,7 +2113,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		
 		while (!(StartOf(19))) {SynErr(176); Get();}
 		switch (la.kind) {
-		case 45: {
+		case 46: {
 			BlockStmt(out bs, out bodyStart, out bodyEnd);
 			s = bs; 
 			break;
@@ -2102,7 +2122,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			AssertStmt(out s);
 			break;
 		}
-		case 30: {
+		case 31: {
 			AssumeStmt(out s);
 			break;
 		}
@@ -2110,11 +2130,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			PrintStmt(out s);
 			break;
 		}
-		case 1: case 2: case 3: case 4: case 8: case 10: case 19: case 20: case 23: case 49: case 131: case 132: case 133: case 134: case 135: case 136: {
+		case 1: case 2: case 3: case 4: case 8: case 10: case 19: case 20: case 23: case 50: case 131: case 132: case 133: case 134: case 135: case 136: {
 			UpdateStmt(out s);
 			break;
 		}
-		case 72: case 77: {
+		case 73: case 78: {
 			VarDeclStatement(out s);
 			break;
 		}
@@ -2134,7 +2154,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			ForallStmt(out s);
 			break;
 		}
-		case 31: {
+		case 32: {
 			CalcStmt(out s);
 			break;
 		}
@@ -2142,7 +2162,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			ModifyStmt(out s);
 			break;
 		}
-		case 91: {
+		case 92: {
 			Get();
 			x = t; 
 			NoUSIdent(out id);
@@ -2151,28 +2171,28 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			s.Labels = new LList<Label>(new Label(x, id.val), s.Labels); 
 			break;
 		}
-		case 92: {
+		case 93: {
 			Get();
 			x = t; breakCount = 1; label = null; 
 			if (la.kind == 1) {
 				NoUSIdent(out id);
 				label = id.val; 
-			} else if (la.kind == 27 || la.kind == 92) {
-				while (la.kind == 92) {
+			} else if (la.kind == 28 || la.kind == 93) {
+				while (la.kind == 93) {
 					Get();
 					breakCount++; 
 				}
 			} else SynErr(177);
-			while (!(la.kind == 0 || la.kind == 27)) {SynErr(178); Get();}
-			Expect(27);
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(178); Get();}
+			Expect(28);
 			s = label != null ? new BreakStmt(x, t, label) : new BreakStmt(x, t, breakCount); 
 			break;
 		}
-		case 89: case 95: {
+		case 90: case 96: {
 			ReturnStmt(out s);
 			break;
 		}
-		case 58: {
+		case 59: {
 			SkeletonStmt(out s);
 			break;
 		}
@@ -2192,11 +2212,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		}
 		if (StartOf(7)) {
 			Expression(out e, false, true);
-		} else if (la.kind == 58) {
+		} else if (la.kind == 59) {
 			Get();
 			dotdotdot = t; 
 		} else SynErr(180);
-		Expect(27);
+		Expect(28);
 		if (dotdotdot != null) {
 		 s = new SkeletonStatement(new AssertStmt(x, t, new LiteralExpr(x, true), attrs), dotdotdot, null);
 		} else {
@@ -2210,18 +2230,18 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression e = dummyExpr; Attributes attrs = null;
 		IToken dotdotdot = null;
 		
-		Expect(30);
+		Expect(31);
 		x = t; 
 		while (IsAttribute()) {
 			Attribute(ref attrs);
 		}
 		if (StartOf(7)) {
 			Expression(out e, false, true);
-		} else if (la.kind == 58) {
+		} else if (la.kind == 59) {
 			Get();
 			dotdotdot = t; 
 		} else SynErr(181);
-		Expect(27);
+		Expect(28);
 		if (dotdotdot != null) {
 		 s = new SkeletonStatement(new AssumeStmt(x, t, new LiteralExpr(x, true), attrs), dotdotdot, null);
 		} else {
@@ -2244,7 +2264,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Expression(out e, false, true);
 			args.Add(e); 
 		}
-		Expect(27);
+		Expect(28);
 		s = new PrintStmt(x, t, args); 
 	}
 
@@ -2259,20 +2279,20 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		
 		Lhs(out e);
 		x = e.tok; 
-		if (la.kind == 27 || la.kind == 45) {
-			while (la.kind == 45) {
+		if (la.kind == 28 || la.kind == 46) {
+			while (la.kind == 46) {
 				Attribute(ref attrs);
 			}
-			Expect(27);
+			Expect(28);
 			endTok = t; rhss.Add(new ExprRhs(e, attrs)); 
-		} else if (la.kind == 22 || la.kind == 94 || la.kind == 96) {
+		} else if (la.kind == 22 || la.kind == 25 || la.kind == 95) {
 			lhss.Add(e); 
 			while (la.kind == 22) {
 				Get();
 				Lhs(out e);
 				lhss.Add(e); 
 			}
-			if (la.kind == 94) {
+			if (la.kind == 95) {
 				Get();
 				x = t; 
 				Rhs(out r);
@@ -2282,16 +2302,16 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					Rhs(out r);
 					rhss.Add(r); 
 				}
-			} else if (la.kind == 96) {
+			} else if (la.kind == 25) {
 				Get();
 				x = t; 
 				if (la.kind == _assume) {
-					Expect(30);
+					Expect(31);
 					suchThatAssume = t; 
 				}
 				Expression(out suchThat, false, true);
 			} else SynErr(182);
-			Expect(27);
+			Expect(28);
 			endTok = t; 
 		} else if (la.kind == 21) {
 			Get();
@@ -2320,27 +2340,27 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Attributes attrs = null;
 		IToken endTok;
 		
-		if (la.kind == 72) {
+		if (la.kind == 73) {
 			Get();
 			isGhost = true;  x = t; 
 		}
-		Expect(77);
+		Expect(78);
 		if (!isGhost) { x = t; } 
-		while (la.kind == 45) {
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		LocalIdentTypeOptional(out d, isGhost);
 		lhss.Add(d); d.Attributes = attrs; attrs = null; 
 		while (la.kind == 22) {
 			Get();
-			while (la.kind == 45) {
+			while (la.kind == 46) {
 				Attribute(ref attrs);
 			}
 			LocalIdentTypeOptional(out d, isGhost);
 			lhss.Add(d); d.Attributes = attrs; attrs = null; 
 		}
-		if (la.kind == 45 || la.kind == 94 || la.kind == 96) {
-			if (la.kind == 94) {
+		if (la.kind == 25 || la.kind == 46 || la.kind == 95) {
+			if (la.kind == 95) {
 				Get();
 				assignTok = t; 
 				Rhs(out r);
@@ -2351,20 +2371,20 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					rhss.Add(r); 
 				}
 			} else {
-				while (la.kind == 45) {
+				while (la.kind == 46) {
 					Attribute(ref attrs);
 				}
-				Expect(96);
+				Expect(25);
 				assignTok = t; 
 				if (la.kind == _assume) {
-					Expect(30);
+					Expect(31);
 					suchThatAssume = t; 
 				}
 				Expression(out suchThat, false, true);
 			}
 		}
-		while (!(la.kind == 0 || la.kind == 27)) {SynErr(184); Get();}
-		Expect(27);
+		while (!(la.kind == 0 || la.kind == 28)) {SynErr(184); Get();}
+		Expect(28);
 		endTok = t; 
 		ConcreteUpdateStatement update;
 		if (suchThat != null) {
@@ -2388,7 +2408,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void IfStmt(out Statement/*!*/ ifStmt) {
 		Contract.Ensures(Contract.ValueAtReturn(out ifStmt) != null); IToken/*!*/ x;
-		Expression guard = null;  IToken guardEllipsis = null;
+		Expression guard = null;  IToken guardEllipsis = null;  bool isExistentialGuard = false;
 		BlockStmt/*!*/ thn;
 		BlockStmt/*!*/ bs;
 		Statement/*!*/ s;
@@ -2400,10 +2420,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expect(98);
 		x = t; 
 		if (IsAlternative()) {
-			AlternativeBlock(out alternatives, out endTok);
+			AlternativeBlock(true, out alternatives, out endTok);
 			ifStmt = new AlternativeStmt(x, endTok, alternatives); 
 		} else if (StartOf(20)) {
-			if (StartOf(21)) {
+			if (IsExistentialGuard()) {
+				ExistentialGuard(out guard, true);
+				isExistentialGuard = true; 
+			} else if (StartOf(21)) {
 				Guard(out guard);
 			} else {
 				Get();
@@ -2411,20 +2434,20 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			BlockStmt(out thn, out bodyStart, out bodyEnd);
 			endTok = thn.EndTok; 
-			if (la.kind == 34) {
+			if (la.kind == 35) {
 				Get();
 				if (la.kind == 98) {
 					IfStmt(out s);
 					els = s; endTok = s.EndTok; 
-				} else if (la.kind == 45) {
+				} else if (la.kind == 46) {
 					BlockStmt(out bs, out bodyStart, out bodyEnd);
 					els = bs; endTok = bs.EndTok; 
 				} else SynErr(185);
 			}
 			if (guardEllipsis != null) {
-			 ifStmt = new SkeletonStatement(new IfStmt(x, endTok, guard, thn, els), guardEllipsis, null);
+			 ifStmt = new SkeletonStatement(new IfStmt(x, endTok, isExistentialGuard, guard, thn, els), guardEllipsis, null);
 			} else {
-			 ifStmt = new IfStmt(x, endTok, guard, thn, els);
+			 ifStmt = new IfStmt(x, endTok, isExistentialGuard, guard, thn, els);
 			}
 			
 		} else SynErr(186);
@@ -2452,7 +2475,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			while (StartOf(22)) {
 				LoopSpec(invariants, decreases, ref mod, ref decAttrs, ref modAttrs);
 			}
-			AlternativeBlock(out alternatives, out endTok);
+			AlternativeBlock(false, out alternatives, out endTok);
 			stmt = new AlternativeLoopStmt(x, endTok, invariants, new Specification<Expression>(decreases, decAttrs), new Specification<FrameExpression>(mod, modAttrs), alternatives); 
 		} else if (StartOf(20)) {
 			if (StartOf(21)) {
@@ -2469,7 +2492,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				BlockStmt(out body, out bodyStart, out bodyEnd);
 				endTok = body.EndTok; isDirtyLoop = false; 
 			} else if (la.kind == _ellipsis) {
-				Expect(58);
+				Expect(59);
 				bodyEllipsis = t; endTok = t; isDirtyLoop = false; 
 			} else if (StartOf(23)) {
 			} else SynErr(187);
@@ -2503,13 +2526,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		x = t; 
 		Expression(out e, true, true);
 		if (la.kind == _lbrace) {
-			Expect(45);
+			Expect(46);
 			usesOptionalBrace = true; 
-			while (la.kind == 32) {
+			while (la.kind == 33) {
 				CaseStatement(out c);
 				cases.Add(c); 
 			}
-			Expect(46);
+			Expect(47);
 		} else if (StartOf(23)) {
 			while (la.kind == _case) {
 				CaseStatement(out c);
@@ -2542,11 +2565,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			
 		} else SynErr(190);
 		if (la.kind == _openparen) {
-			Expect(49);
+			Expect(50);
 			if (la.kind == 1) {
 				QuantifierDomain(out bvars, out attrs, out range);
 			}
-			Expect(50);
+			Expect(51);
 		} else if (StartOf(24)) {
 			if (la.kind == _ident) {
 				QuantifierDomain(out bvars, out attrs, out range);
@@ -2555,15 +2578,15 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (bvars == null) { bvars = new List<BoundVar>(); }
 		if (range == null) { range = new LiteralExpr(x, true); }
 		
-		while (la.kind == 87 || la.kind == 88) {
+		while (la.kind == 88 || la.kind == 89) {
 			isFree = false; 
-			if (la.kind == 87) {
+			if (la.kind == 88) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
 				
 			}
-			Expect(88);
+			Expect(89);
 			Expression(out e, false, true);
 			ens.Add(new MaybeFreeExpression(e, isFree)); 
 			OldSemi();
@@ -2597,7 +2620,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken opTok;
 		IToken danglingOperator = null;
 		
-		Expect(31);
+		Expect(32);
 		x = t; 
 		while (IsAttribute()) {
 			Attribute(ref attrs);
@@ -2611,11 +2634,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			resOp = calcOp;
 			
 		}
-		Expect(45);
+		Expect(46);
 		while (StartOf(7)) {
 			Expression(out e, false, true);
 			lines.Add(e); stepOp = calcOp; danglingOperator = null; 
-			Expect(27);
+			Expect(28);
 			if (StartOf(25)) {
 				CalcOp(out opTok, out op);
 				maybeOp = resOp.ResultOp(op);
@@ -2635,10 +2658,10 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			BlockStmt subBlock; Statement subCalc;
 			
 			while (la.kind == _lbrace || la.kind == _calc) {
-				if (la.kind == 45) {
+				if (la.kind == 46) {
 					BlockStmt(out subBlock, out t0, out t1);
 					hintEnd = subBlock.EndTok; subhints.Add(subBlock); 
-				} else if (la.kind == 31) {
+				} else if (la.kind == 32) {
 					CalcStmt(out subCalc);
 					hintEnd = subCalc.EndTok; subhints.Add(subCalc); 
 				} else SynErr(192);
@@ -2648,7 +2671,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			if (h.Body.Count != 0) { danglingOperator = null; }
 			
 		}
-		Expect(46);
+		Expect(47);
 		if (danglingOperator != null) {
 		 SemErr(danglingOperator, "a calculation cannot end with an operator");
 		}
@@ -2680,14 +2703,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				FrameExpression(out fe, false, true);
 				mod.Add(fe); 
 			}
-		} else if (la.kind == 58) {
+		} else if (la.kind == 59) {
 			Get();
 			ellipsisToken = t; 
 		} else SynErr(193);
-		if (la.kind == 45) {
+		if (la.kind == 46) {
 			BlockStmt(out body, out bodyStart, out endTok);
-		} else if (la.kind == 27) {
-			while (!(la.kind == 0 || la.kind == 27)) {SynErr(194); Get();}
+		} else if (la.kind == 28) {
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(194); Get();}
 			Get();
 			endTok = t; 
 		} else SynErr(195);
@@ -2704,10 +2727,10 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		AssignmentRhs r;
 		bool isYield = false;
 		
-		if (la.kind == 95) {
+		if (la.kind == 96) {
 			Get();
 			returnTok = t; 
-		} else if (la.kind == 89) {
+		} else if (la.kind == 90) {
 			Get();
 			returnTok = t; isYield = true; 
 		} else SynErr(196);
@@ -2720,7 +2743,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				rhss.Add(r); 
 			}
 		}
-		Expect(27);
+		Expect(28);
 		if (isYield) {
 		 s = new YieldStmt(returnTok, t, rhss);
 		} else {
@@ -2734,9 +2757,9 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<Expression> exprs = null;
 		IToken tok, dotdotdot, whereTok;
 		Expression e; 
-		Expect(58);
+		Expect(59);
 		dotdotdot = t; 
-		if (la.kind == 93) {
+		if (la.kind == 94) {
 			Get();
 			names = new List<IToken>(); exprs = new List<Expression>(); whereTok = t;
 			Ident(out tok);
@@ -2746,7 +2769,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Ident(out tok);
 				names.Add(tok); 
 			}
-			Expect(94);
+			Expect(95);
 			Expression(out e, false, true);
 			exprs.Add(e); 
 			while (la.kind == 22) {
@@ -2760,7 +2783,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			
 		}
-		Expect(27);
+		Expect(28);
 		s = new SkeletonStatement(dotdotdot, t, names, exprs); 
 	}
 
@@ -2777,12 +2800,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 			newToken = t; 
 			TypeAndToken(out x, out ty);
-			if (la.kind == 47 || la.kind == 49) {
-				if (la.kind == 47) {
+			if (la.kind == 48 || la.kind == 50) {
+				if (la.kind == 48) {
 					Get();
 					ee = new List<Expression>(); 
 					Expressions(ee);
-					Expect(48);
+					Expect(49);
 					var tmp = theBuiltIns.ArrayType(ee.Count, new IntType(), true);
 					
 				} else {
@@ -2791,7 +2814,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					if (StartOf(7)) {
 						Expressions(args);
 					}
-					Expect(50);
+					Expect(51);
 				}
 			}
 			if (ee != null) {
@@ -2802,14 +2825,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 r = new TypeRhs(newToken, ty);
 			}
 			
-		} else if (la.kind == 56) {
+		} else if (la.kind == 57) {
 			Get();
 			r = new HavocRhs(t); 
 		} else if (StartOf(7)) {
 			Expression(out e, false, true);
 			r = new ExprRhs(e); 
 		} else SynErr(197);
-		while (la.kind == 45) {
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		r.Attributes = attrs; 
@@ -2820,13 +2843,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		
 		if (la.kind == 1) {
 			NameSegment(out e);
-			while (la.kind == 26 || la.kind == 47 || la.kind == 49) {
+			while (la.kind == 27 || la.kind == 48 || la.kind == 50) {
 				Suffix(ref e);
 			}
 		} else if (StartOf(27)) {
 			ConstAtomExpression(out e, false, false);
 			Suffix(ref e);
-			while (la.kind == 26 || la.kind == 47 || la.kind == 49) {
+			while (la.kind == 27 || la.kind == 48 || la.kind == 50) {
 				Suffix(ref e);
 			}
 		} else SynErr(198);
@@ -2843,71 +2866,97 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		}
 	}
 
-	void AlternativeBlock(out List<GuardedAlternative> alternatives, out IToken endTok) {
+	void AlternativeBlock(bool allowExistentialGuards, out List<GuardedAlternative> alternatives, out IToken endTok) {
 		alternatives = new List<GuardedAlternative>();
 		IToken x;
-		Expression e;
+		Expression e; bool isExistentialGuard;
 		List<Statement> body;
 		
-		Expect(45);
-		while (la.kind == 32) {
-			Get();
-			x = t; 
-			Expression(out e, true, false);
-			Expect(28);
+		Expect(46);
+		while (la.kind == 33) {
+			Get();
+			x = t; isExistentialGuard = false; e = dummyExpr; 
+			if (allowExistentialGuards && IsExistentialGuard()) {
+				ExistentialGuard(out e, false );
+				isExistentialGuard = true; 
+			} else if (StartOf(7)) {
+				Expression(out e, true, false);
+			} else SynErr(199);
+			Expect(29);
 			body = new List<Statement>(); 
 			while (StartOf(15)) {
 				Stmt(body);
 			}
-			alternatives.Add(new GuardedAlternative(x, e, body)); 
+			alternatives.Add(new GuardedAlternative(x, isExistentialGuard, e, body)); 
 		}
-		Expect(46);
+		Expect(47);
 		endTok = t; 
 	}
 
+	void ExistentialGuard(out Expression e, bool allowLambda) {
+		var bvars = new List<BoundVar>();
+		BoundVar bv;  IToken x;
+		Attributes attrs = null;
+		Expression body;
+		
+		IdentTypeOptional(out bv);
+		bvars.Add(bv); x = bv.tok; 
+		while (la.kind == 22) {
+			Get();
+			IdentTypeOptional(out bv);
+			bvars.Add(bv); 
+		}
+		while (la.kind == 46) {
+			Attribute(ref attrs);
+		}
+		Expect(25);
+		Expression(out body, true, allowLambda);
+		e = new ExistsExpr(x, bvars, null, body, attrs); 
+	}
+
 	void Guard(out Expression e) {
 		Expression/*!*/ ee;  e = null; 
-		if (la.kind == 56) {
+		if (la.kind == 57) {
 			Get();
 			e = null; 
 		} else if (IsParenStar()) {
-			Expect(49);
-			Expect(56);
 			Expect(50);
+			Expect(57);
+			Expect(51);
 			e = null; 
 		} else if (StartOf(7)) {
 			Expression(out ee, true, true);
 			e = ee; 
-		} else SynErr(199);
+		} else SynErr(200);
 	}
 
 	void LoopSpec(List<MaybeFreeExpression> invariants, List<Expression> decreases, ref List<FrameExpression> mod, ref Attributes decAttrs, ref Attributes modAttrs) {
 		Expression e; FrameExpression fe;
 		bool isFree = false; Attributes attrs = null;
 		
-		if (la.kind == 36 || la.kind == 87) {
-			while (!(la.kind == 0 || la.kind == 36 || la.kind == 87)) {SynErr(200); Get();}
-			if (la.kind == 87) {
+		if (la.kind == 37 || la.kind == 88) {
+			while (!(la.kind == 0 || la.kind == 37 || la.kind == 88)) {SynErr(201); Get();}
+			if (la.kind == 88) {
 				Get();
 				isFree = true; errors.Warning(t, "the 'free' keyword is soon to be deprecated"); 
 			}
-			Expect(36);
+			Expect(37);
 			while (IsAttribute()) {
 				Attribute(ref attrs);
 			}
 			Expression(out e, false, true);
 			invariants.Add(new MaybeFreeExpression(e, isFree, attrs)); 
 			OldSemi();
-		} else if (la.kind == 35) {
-			while (!(la.kind == 0 || la.kind == 35)) {SynErr(201); Get();}
+		} else if (la.kind == 36) {
+			while (!(la.kind == 0 || la.kind == 36)) {SynErr(202); Get();}
 			Get();
 			while (IsAttribute()) {
 				Attribute(ref decAttrs);
 			}
 			DecreasesList(decreases, true, true);
 			OldSemi();
-		} else if (la.kind == 42) {
-			while (!(la.kind == 0 || la.kind == 42)) {SynErr(202); Get();}
+		} else if (la.kind == 43) {
+			while (!(la.kind == 0 || la.kind == 43)) {SynErr(203); Get();}
 			Get();
 			mod = mod ?? new List<FrameExpression>(); 
 			while (IsAttribute()) {
@@ -2921,7 +2970,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				mod.Add(fe); 
 			}
 			OldSemi();
-		} else SynErr(203);
+		} else SynErr(204);
 	}
 
 	void CaseStatement(out MatchCaseStmt/*!*/ c) {
@@ -2932,12 +2981,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<Statement/*!*/> body = new List<Statement/*!*/>();
 		string/*!*/ name = "";
 		
-		Expect(32);
+		Expect(33);
 		x = t; 
 		if (la.kind == 1) {
 			Ident(out id);
 			name = id.val; 
-			if (la.kind == 49) {
+			if (la.kind == 50) {
 				Get();
 				CasePattern(out pat);
 				arguments.Add(pat); 
@@ -2946,9 +2995,9 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					CasePattern(out pat);
 					arguments.Add(pat); 
 				}
-				Expect(50);
+				Expect(51);
 			}
-		} else if (la.kind == 49) {
+		} else if (la.kind == 50) {
 			Get();
 			CasePattern(out pat);
 			arguments.Add(pat); 
@@ -2957,13 +3006,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				CasePattern(out pat);
 				arguments.Add(pat); 
 			}
-			Expect(50);
-		} else SynErr(204);
-		Expect(28);
-		while (!(StartOf(28))) {SynErr(205); Get();}
+			Expect(51);
+		} else SynErr(205);
+		Expect(29);
+		while (!(StartOf(28))) {SynErr(206); Get();}
 		while (IsNotEndOfCase()) {
 			Stmt(body);
-			while (!(StartOf(28))) {SynErr(206); Get();}
+			while (!(StartOf(28))) {SynErr(207); Get();}
 		}
 		c = new MatchCaseStmt(x, name, arguments, body); 
 	}
@@ -2975,9 +3024,9 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		
 		if (IsIdentParen()) {
 			Ident(out id);
-			Expect(49);
+			Expect(50);
 			arguments = new List<CasePattern>(); 
-			if (la.kind == 1 || la.kind == 49) {
+			if (la.kind == 1 || la.kind == 50) {
 				CasePattern(out pat);
 				arguments.Add(pat); 
 				while (la.kind == 22) {
@@ -2986,14 +3035,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					arguments.Add(pat); 
 				}
 			}
-			Expect(50);
+			Expect(51);
 			pat = new CasePattern(id, id.val, arguments); 
-		} else if (la.kind == 49) {
+		} else if (la.kind == 50) {
 			Get();
 			id = t;                                                           
 			arguments = new List<CasePattern>(); 
 			
-			if (la.kind == 1 || la.kind == 49) {
+			if (la.kind == 1 || la.kind == 50) {
 				CasePattern(out pat);
 				arguments.Add(pat); 
 				while (la.kind == 22) {
@@ -3002,7 +3051,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					arguments.Add(pat); 
 				}
 			}
-			Expect(50);
+			Expect(51);
 			theBuiltIns.TupleType(id, arguments.Count, true); // make sure the tuple type exists
 			string ctor = BuiltIns.TupleTypeCtorName;  //use the TupleTypeCtors
 			pat = new CasePattern(id, ctor, arguments); 
@@ -3011,7 +3060,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			IdentTypeOptional(out bv);
 			pat = new CasePattern(bv.tok, bv);
 			
-		} else SynErr(207);
+		} else SynErr(208);
 		if (pat == null) {
 		 pat = new CasePattern(t, "_ParseError", new List<CasePattern>());
 		}
@@ -3046,23 +3095,23 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		x = null;
 		
 		switch (la.kind) {
-		case 53: {
+		case 54: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Eq; 
 			if (la.kind == 106) {
 				Get();
-				Expect(47);
-				Expression(out k, true, true);
 				Expect(48);
+				Expression(out k, true, true);
+				Expect(49);
 			}
 			break;
 		}
-		case 51: {
+		case 52: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Lt; 
 			break;
 		}
-		case 52: {
+		case 53: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Gt; 
 			break;
@@ -3077,12 +3126,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  binOp = BinaryExpr.Opcode.Ge; 
 			break;
 		}
-		case 54: {
+		case 55: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Neq; 
 			break;
 		}
-		case 55: {
+		case 56: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Neq; 
 			break;
@@ -3112,7 +3161,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  binOp = BinaryExpr.Opcode.Exp; 
 			break;
 		}
-		default: SynErr(208); break;
+		default: SynErr(209); break;
 		}
 		if (k == null) {
 		 op = new Microsoft.Dafny.CalcStmt.BinaryCalcOp(binOp);
@@ -3127,7 +3176,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 		} else if (la.kind == 112) {
 			Get();
-		} else SynErr(209);
+		} else SynErr(210);
 	}
 
 	void ImpliesOp() {
@@ -3135,7 +3184,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 		} else if (la.kind == 114) {
 			Get();
-		} else SynErr(210);
+		} else SynErr(211);
 	}
 
 	void ExpliesOp() {
@@ -3143,7 +3192,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 		} else if (la.kind == 116) {
 			Get();
-		} else SynErr(211);
+		} else SynErr(212);
 	}
 
 	void AndOp() {
@@ -3151,7 +3200,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 		} else if (la.kind == 118) {
 			Get();
-		} else SynErr(212);
+		} else SynErr(213);
 	}
 
 	void OrOp() {
@@ -3159,7 +3208,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 		} else if (la.kind == 120) {
 			Get();
-		} else SynErr(213);
+		} else SynErr(214);
 	}
 
 	void NegOp() {
@@ -3167,7 +3216,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 		} else if (la.kind == 122) {
 			Get();
-		} else SynErr(214);
+		} else SynErr(215);
 	}
 
 	void Forall() {
@@ -3175,7 +3224,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 		} else if (la.kind == 123) {
 			Get();
-		} else SynErr(215);
+		} else SynErr(216);
 	}
 
 	void Exists() {
@@ -3183,15 +3232,15 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 		} else if (la.kind == 125) {
 			Get();
-		} else SynErr(216);
+		} else SynErr(217);
 	}
 
 	void QSep() {
 		if (la.kind == 24) {
 			Get();
-		} else if (la.kind == 25) {
+		} else if (la.kind == 26) {
 			Get();
-		} else SynErr(217);
+		} else SynErr(218);
 	}
 
 	void EquivExpression(out Expression e0, bool allowSemi, bool allowLambda) {
@@ -3225,7 +3274,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					LogicalExpression(out e1, allowSemi, allowLambda);
 					e0 = new BinaryExpr(x, BinaryExpr.Opcode.Exp, e0, e1); 
 				}
-			} else SynErr(218);
+			} else SynErr(219);
 		}
 	}
 
@@ -3255,7 +3304,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					RelationalExpression(out e1, allowSemi, allowLambda);
 					e0 = new BinaryExpr(x, BinaryExpr.Opcode.Or, e0, e1); 
 				}
-			} else SynErr(219);
+			} else SynErr(220);
 		}
 	}
 
@@ -3388,23 +3437,23 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		k = null;
 		
 		switch (la.kind) {
-		case 53: {
+		case 54: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Eq; 
 			if (la.kind == 106) {
 				Get();
-				Expect(47);
-				Expression(out k, true, true);
 				Expect(48);
+				Expression(out k, true, true);
+				Expect(49);
 			}
 			break;
 		}
-		case 51: {
+		case 52: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Lt; 
 			break;
 		}
-		case 52: {
+		case 53: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Gt; 
 			break;
@@ -3419,14 +3468,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.Ge; 
 			break;
 		}
-		case 54: {
+		case 55: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Neq; 
 			if (la.kind == 106) {
 				Get();
-				Expect(47);
-				Expression(out k, true, true);
 				Expect(48);
+				Expression(out k, true, true);
+				Expect(49);
 			}
 			break;
 		}
@@ -3435,7 +3484,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.In; 
 			break;
 		}
-		case 57: {
+		case 58: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.NotIn; 
 			break;
@@ -3458,7 +3507,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			
 			break;
 		}
-		case 55: {
+		case 56: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Neq; 
 			break;
@@ -3473,7 +3522,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.Ge; 
 			break;
 		}
-		default: SynErr(220); break;
+		default: SynErr(221); break;
 		}
 	}
 
@@ -3495,7 +3544,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 128) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Sub; 
-		} else SynErr(221);
+		} else SynErr(222);
 	}
 
 	void UnaryExpression(out Expression e, bool allowSemi, bool allowLambda) {
@@ -3540,7 +3589,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			while (IsSuffix()) {
 				Suffix(ref e);
 			}
-		} else if (la.kind == 45 || la.kind == 47) {
+		} else if (la.kind == 46 || la.kind == 48) {
 			DisplayExpr(out e);
 			while (IsSuffix()) {
 				Suffix(ref e);
@@ -3555,12 +3604,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			while (IsSuffix()) {
 				Suffix(ref e);
 			}
-		} else SynErr(222);
+		} else SynErr(223);
 	}
 
 	void MulOp(out IToken x, out BinaryExpr.Opcode op) {
 		Contract.Ensures(Contract.ValueAtReturn(out x) != null); x = Token.NoToken;  op = BinaryExpr.Opcode.Add/*(dummy)*/; 
-		if (la.kind == 56) {
+		if (la.kind == 57) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Mul; 
 		} else if (la.kind == 129) {
@@ -3569,7 +3618,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 130) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Mod; 
-		} else SynErr(223);
+		} else SynErr(224);
 	}
 
 	void MapDisplayExpr(IToken/*!*/ mapToken, bool finite, out Expression e) {
@@ -3577,12 +3626,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<ExpressionPair/*!*/>/*!*/ elements= new List<ExpressionPair/*!*/>() ;
 		e = dummyExpr;
 		
-		Expect(47);
+		Expect(48);
 		if (StartOf(7)) {
 			MapLiteralExpressions(out elements);
 		}
 		e = new MapDisplayExpr(mapToken, finite, elements);
-		Expect(48);
+		Expect(49);
 	}
 
 	void Suffix(ref Expression e) {
@@ -3592,7 +3641,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<Expression> multipleLengths = null; bool takeRest = false; // takeRest is relevant only if multipleLengths is non-null
 		List<Expression> multipleIndices = null;
 		
-		if (la.kind == 26) {
+		if (la.kind == 27) {
 			DotSuffix(out id, out x);
 			if (x != null) {
 			 // process id as a Suffix in its own right
@@ -3607,13 +3656,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			} else if (la.kind == 106) {
 				HashCall(id, out openParen, out typeArgs, out args);
 			} else if (StartOf(30)) {
-			} else SynErr(224);
+			} else SynErr(225);
 			e = new ExprDotName(id, e, id.val, typeArgs);
 			if (openParen != null) {
 			 e = new ApplySuffix(openParen, e, args);
 			}
 			
-		} else if (la.kind == 47) {
+		} else if (la.kind == 48) {
 			Get();
 			x = t; 
 			if (StartOf(7)) {
@@ -3626,7 +3675,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 						Expression(out ee, true, true);
 						e1 = ee; 
 					}
-				} else if (la.kind == 94) {
+				} else if (la.kind == 95) {
 					Get();
 					Expression(out ee, true, true);
 					e1 = ee; 
@@ -3649,7 +3698,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 							takeRest = true; 
 						}
 					}
-				} else if (la.kind == 22 || la.kind == 48) {
+				} else if (la.kind == 22 || la.kind == 49) {
 					while (la.kind == 22) {
 						Get();
 						Expression(out ee, true, true);
@@ -3660,7 +3709,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 						multipleIndices.Add(ee);
 						
 					}
-				} else SynErr(225);
+				} else SynErr(226);
 			} else if (la.kind == 137) {
 				Get();
 				anyDots = true; 
@@ -3668,7 +3717,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					Expression(out ee, true, true);
 					e1 = ee; 
 				}
-			} else SynErr(226);
+			} else SynErr(227);
 			if (multipleIndices != null) {
 			 e = new MultiSelectExpr(x, e, multipleIndices);
 			 // make sure an array class with this dimensionality exists
@@ -3703,16 +3752,16 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 }
 			}
 			
-			Expect(48);
-		} else if (la.kind == 49) {
+			Expect(49);
+		} else if (la.kind == 50) {
 			Get();
 			IToken openParen = t; var args = new List<Expression>(); 
 			if (StartOf(7)) {
 				Expressions(args);
 			}
-			Expect(50);
+			Expect(51);
 			e = new ApplySuffix(openParen, e, args); 
-		} else SynErr(227);
+		} else SynErr(228);
 	}
 
 	void ISetDisplayExpr(IToken/*!*/ setToken, bool finite, out Expression e) {
@@ -3720,12 +3769,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<Expression> elements = new List<Expression/*!*/>();;
 		e = dummyExpr;
 		
-		Expect(45);
+		Expect(46);
 		if (StartOf(7)) {
 			Expressions(elements);
 		}
 		e = new SetDisplayExpr(setToken, finite, elements);
-		Expect(46);
+		Expect(47);
 	}
 
 	void LambdaExpression(out Expression e, bool allowSemi) {
@@ -3741,7 +3790,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 1) {
 			WildIdent(out id, true);
 			x = t; bvs.Add(new BoundVar(id, id.val, new InferredTypeProxy())); 
-		} else if (la.kind == 49) {
+		} else if (la.kind == 50) {
 			Get();
 			x = t; 
 			if (la.kind == 1) {
@@ -3753,10 +3802,10 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					bvs.Add(bv); 
 				}
 			}
-			Expect(50);
-		} else SynErr(228);
-		while (la.kind == 43 || la.kind == 44) {
-			if (la.kind == 43) {
+			Expect(51);
+		} else SynErr(229);
+		while (la.kind == 44 || la.kind == 45) {
+			if (la.kind == 44) {
 				Get();
 				PossiblyWildFrameExpression(out fe, true);
 				reads.Add(fe); 
@@ -3784,9 +3833,9 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 			x = t; 
 			Expression(out e, true, true);
-			Expect(33);
-			Expression(out e0, true, true);
 			Expect(34);
+			Expression(out e0, true, true);
+			Expect(35);
 			Expression(out e1, allowSemi, allowLambda);
 			e = new ITEExpr(x, e, e0, e1); 
 			break;
@@ -3811,13 +3860,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			SetComprehensionExpr(x, false, out e, allowSemi, allowLambda);
 			break;
 		}
-		case 30: case 31: case 101: {
+		case 31: case 32: case 101: {
 			StmtInExpr(out s);
 			Expression(out e, allowSemi, allowLambda);
 			e = new StmtExpr(s.Tok, s, e); 
 			break;
 		}
-		case 72: case 77: {
+		case 73: case 78: {
 			LetExpr(out e, allowSemi, allowLambda);
 			break;
 		}
@@ -3833,11 +3882,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			MapComprehensionExpr(x, false, out e, allowSemi, allowLambda);
 			break;
 		}
-		case 91: {
+		case 92: {
 			NamedExpr(out e, allowSemi, allowLambda);
 			break;
 		}
-		default: SynErr(229); break;
+		default: SynErr(230); break;
 		}
 	}
 
@@ -3852,7 +3901,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 106) {
 			HashCall(id, out openParen, out typeArgs, out args);
 		} else if (StartOf(30)) {
-		} else SynErr(230);
+		} else SynErr(231);
 		e = new NameSegment(id, id.val, typeArgs);
 		if (openParen != null) {
 		 e = new ApplySuffix(openParen, e, args);
@@ -3865,23 +3914,23 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken x;  List<Expression> elements;
 		e = dummyExpr;
 		
-		if (la.kind == 45) {
+		if (la.kind == 46) {
 			Get();
 			x = t;  elements = new List<Expression/*!*/>(); 
 			if (StartOf(7)) {
 				Expressions(elements);
 			}
 			e = new SetDisplayExpr(x, true, elements);
-			Expect(46);
-		} else if (la.kind == 47) {
+			Expect(47);
+		} else if (la.kind == 48) {
 			Get();
 			x = t;  elements = new List<Expression/*!*/>(); 
 			if (StartOf(7)) {
 				Expressions(elements);
 			}
 			e = new SeqDisplayExpr(x, elements); 
-			Expect(48);
-		} else SynErr(231);
+			Expect(49);
+		} else SynErr(232);
 	}
 
 	void MultiSetExpr(out Expression e) {
@@ -3891,21 +3940,21 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		
 		Expect(15);
 		x = t; 
-		if (la.kind == 45) {
+		if (la.kind == 46) {
 			Get();
 			elements = new List<Expression/*!*/>(); 
 			if (StartOf(7)) {
 				Expressions(elements);
 			}
 			e = new MultiSetDisplayExpr(x, elements);
-			Expect(46);
-		} else if (la.kind == 49) {
+			Expect(47);
+		} else if (la.kind == 50) {
 			Get();
 			x = t;  elements = new List<Expression/*!*/>(); 
 			Expression(out e, true, true);
 			e = new MultiSetFormingExpr(x, e); 
-			Expect(50);
-		} else SynErr(232);
+			Expect(51);
+		} else SynErr(233);
 	}
 
 	void ConstAtomExpression(out Expression e, bool allowSemi, bool allowLambda) {
@@ -3960,18 +4009,18 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		case 135: {
 			Get();
 			x = t; 
-			Expect(49);
-			Expression(out e, true, true);
 			Expect(50);
+			Expression(out e, true, true);
+			Expect(51);
 			e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Fresh, e); 
 			break;
 		}
 		case 136: {
 			Get();
 			x = t; 
-			Expect(49);
-			Expression(out e, true, true);
 			Expect(50);
+			Expression(out e, true, true);
+			Expect(51);
 			e = new OldExpr(x, e); 
 			break;
 		}
@@ -3991,17 +4040,17 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Get();
 				x = t; toType = new RealType(); 
 			}
-			Expect(49);
-			Expression(out e, true, true);
 			Expect(50);
+			Expression(out e, true, true);
+			Expect(51);
 			e = new ConversionExpr(x, e, toType); 
 			break;
 		}
-		case 49: {
+		case 50: {
 			ParensExpression(out e, allowSemi, allowLambda);
 			break;
 		}
-		default: SynErr(233); break;
+		default: SynErr(234); break;
 		}
 	}
 
@@ -4030,7 +4079,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 n = BigInteger.Zero;
 			}
 			
-		} else SynErr(234);
+		} else SynErr(235);
 	}
 
 	void Dec(out Basetypes.BigDec d) {
@@ -4050,12 +4099,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken x;
 		var args = new List<Expression>();
 		
-		Expect(49);
+		Expect(50);
 		x = t; 
 		if (StartOf(7)) {
 			Expressions(args);
 		}
-		Expect(50);
+		Expect(51);
 		if (args.Count == 1) {
 		 e = new ParensExpression(x, args[0]);
 		} else {
@@ -4068,26 +4117,26 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void LambdaArrow(out bool oneShot) {
 		oneShot = true; 
-		if (la.kind == 28) {
+		if (la.kind == 29) {
 			Get();
 			oneShot = false; 
-		} else if (la.kind == 29) {
+		} else if (la.kind == 30) {
 			Get();
 			oneShot = true; 
-		} else SynErr(235);
+		} else SynErr(236);
 	}
 
 	void MapLiteralExpressions(out List<ExpressionPair> elements) {
 		Expression/*!*/ d, r;
 		elements = new List<ExpressionPair/*!*/>(); 
 		Expression(out d, true, true);
-		Expect(94);
+		Expect(95);
 		Expression(out r, true, true);
 		elements.Add(new ExpressionPair(d,r)); 
 		while (la.kind == 22) {
 			Get();
 			Expression(out d, true, true);
-			Expect(94);
+			Expect(95);
 			Expression(out r, true, true);
 			elements.Add(new ExpressionPair(d,r)); 
 		}
@@ -4103,7 +4152,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		
 		IdentTypeOptional(out bv);
 		bvars.Add(bv); 
-		while (la.kind == 45) {
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		if (la.kind == 23) {
@@ -4125,19 +4174,19 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		x = t; 
 		Expression(out e, allowSemi, allowLambda);
 		if (la.kind == _lbrace) {
-			Expect(45);
+			Expect(46);
 			usesOptionalBrace = true; 
-			while (la.kind == 32) {
+			while (la.kind == 33) {
 				CaseExpression(out c, true, true);
 				cases.Add(c); 
 			}
-			Expect(46);
+			Expect(47);
 		} else if (StartOf(31)) {
 			while (la.kind == _case) {
 				CaseExpression(out c, allowSemi, allowLambda);
 				cases.Add(c); 
 			}
-		} else SynErr(236);
+		} else SynErr(237);
 		e = new MatchExpr(x, e, cases, usesOptionalBrace); 
 	}
 
@@ -4155,7 +4204,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 124 || la.kind == 125) {
 			Exists();
 			x = t; 
-		} else SynErr(237);
+		} else SynErr(238);
 		QuantifierDomain(out bvars, out attrs, out range);
 		QSep();
 		Expression(out body, allowSemi, allowLambda);
@@ -4182,7 +4231,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			IdentTypeOptional(out bv);
 			bvars.Add(bv); 
 		}
-		while (la.kind == 45) {
+		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		Expect(23);
@@ -4200,11 +4249,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		s = dummyStmt; 
 		if (la.kind == 101) {
 			AssertStmt(out s);
-		} else if (la.kind == 30) {
-			AssumeStmt(out s);
 		} else if (la.kind == 31) {
+			AssumeStmt(out s);
+		} else if (la.kind == 32) {
 			CalcStmt(out s);
-		} else SynErr(238);
+		} else SynErr(239);
 	}
 
 	void LetExpr(out Expression e, bool allowSemi, bool allowLambda) {
@@ -4217,11 +4266,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Attributes attrs = null;
 		e = dummyExpr;
 		
-		if (la.kind == 72) {
+		if (la.kind == 73) {
 			Get();
 			isGhost = true;  x = t; 
 		}
-		Expect(77);
+		Expect(78);
 		if (!isGhost) { x = t; } 
 		CasePattern(out pat);
 		if (isGhost) { pat.Vars.Iter(bv => bv.IsGhost = true); }
@@ -4234,13 +4283,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			letLHSs.Add(pat);
 			
 		}
-		if (la.kind == 94) {
+		if (la.kind == 95) {
 			Get();
-		} else if (la.kind == 45 || la.kind == 96) {
-			while (la.kind == 45) {
+		} else if (la.kind == 25 || la.kind == 46) {
+			while (la.kind == 46) {
 				Attribute(ref attrs);
 			}
-			Expect(96);
+			Expect(25);
 			exact = false;
 			foreach (var lhs in letLHSs) {
 			 if (lhs.Arguments != null) {
@@ -4248,7 +4297,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 }
 			}
 			
-		} else SynErr(239);
+		} else SynErr(240);
 		Expression(out e, false, true);
 		letRHSs.Add(e); 
 		while (la.kind == 22) {
@@ -4256,7 +4305,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Expression(out e, false, true);
 			letRHSs.Add(e); 
 		}
-		Expect(27);
+		Expect(28);
 		Expression(out e, allowSemi, allowLambda);
 		e = new LetExpr(x, letLHSs, letRHSs, e, exact, attrs); 
 	}
@@ -4266,7 +4315,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;
 		Expression expr;
 		
-		Expect(91);
+		Expect(92);
 		x = t; 
 		NoUSIdent(out d);
 		Expect(21);
@@ -4282,12 +4331,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression/*!*/ body;
 		string/*!*/ name = "";
 		
-		Expect(32);
+		Expect(33);
 		x = t; 
 		if (la.kind == 1) {
 			Ident(out id);
 			name = id.val; 
-			if (la.kind == 49) {
+			if (la.kind == 50) {
 				Get();
 				CasePattern(out pat);
 				arguments.Add(pat); 
@@ -4296,9 +4345,9 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					CasePattern(out pat);
 					arguments.Add(pat); 
 				}
-				Expect(50);
+				Expect(51);
 			}
-		} else if (la.kind == 49) {
+		} else if (la.kind == 50) {
 			Get();
 			CasePattern(out pat);
 			arguments.Add(pat); 
@@ -4307,9 +4356,9 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				CasePattern(out pat);
 				arguments.Add(pat); 
 			}
-			Expect(50);
-		} else SynErr(240);
-		Expect(28);
+			Expect(51);
+		} else SynErr(241);
+		Expect(29);
 		Expression(out body, allowSemi, allowLambda);
 		c = new MatchCaseExpr(x, name, arguments, body); 
 	}
@@ -4318,20 +4367,20 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression k; args = new List<Expression>(); typeArgs = null; 
 		Expect(106);
 		id.val = id.val + "#"; 
-		if (la.kind == 51) {
+		if (la.kind == 52) {
 			typeArgs = new List<Type>(); 
 			GenericInstantiation(typeArgs);
 		}
-		Expect(47);
-		Expression(out k, true, true);
 		Expect(48);
-		args.Add(k); 
+		Expression(out k, true, true);
 		Expect(49);
+		args.Add(k); 
+		Expect(50);
 		openParen = t; 
 		if (StartOf(7)) {
 			Expressions(args);
 		}
-		Expect(50);
+		Expect(51);
 	}
 
 	void DotSuffix(out IToken x, out IToken y) {
@@ -4339,7 +4388,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		x = Token.NoToken;
 		y = null;
 		
-		Expect(26);
+		Expect(27);
 		if (la.kind == 1) {
 			Get();
 			x = t; 
@@ -4367,13 +4416,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 }
 			}
 			
-		} else if (la.kind == 44) {
+		} else if (la.kind == 45) {
 			Get();
 			x = t; 
-		} else if (la.kind == 43) {
+		} else if (la.kind == 44) {
 			Get();
 			x = t; 
-		} else SynErr(241);
+		} else SynErr(242);
 	}
 
 
@@ -4388,50 +4437,50 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 	}
 
 	static readonly bool[,] set = {
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_T, _x,_x,_T,_T, _T,_x,_x,_T, _T,_x,_x,_T, _T,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _T,_x,_x,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _T,_x,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_x, _x,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _T,_x,_x,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_T,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_x,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_x, _T,_x,_x,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_T,_T, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_x, _T,_x,_x,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_T,_T, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x}
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_T, _T,_T,_x,_x, _T,_T,_x,_x, _T,_T,_x,_T, _T,_T,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_x, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_T, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _x,_x,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _T,_T,_T,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_x,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x}
 
 	};
 } // end Parser
 
 
 public class Errors {
-    readonly ErrorReporter reporter;
+	readonly ErrorReporter Reporting;
 	public int ErrorCount;
 
-    public Errors(ErrorReporter reporter) {
-        Contract.Requires(reporter != null);
-        this.reporter = reporter;
+	public Errors(ErrorReporter Reporting) {
+		Contract.Requires(Reporting != null);
+		this.Reporting = Reporting;
 	}
 
 	public void SynErr(string filename, int line, int col, int n) {
@@ -4441,7 +4490,7 @@ public class Errors {
 	public void SynErr(string filename, int line, int col, string msg) {
 		Contract.Requires(msg != null);
 		ErrorCount++;
-        reporter.Error(MessageSource.Parser, filename, line, col, msg);
+		Reporting.Error(MessageSource.Parser, filename, line, col, msg);
 	}
 
 	string GetSyntaxErrorString(int n) {
@@ -4472,78 +4521,78 @@ public class Errors {
 			case 22: s = "comma expected"; break;
 			case 23: s = "verticalbar expected"; break;
 			case 24: s = "doublecolon expected"; break;
-			case 25: s = "bullet expected"; break;
-			case 26: s = "dot expected"; break;
-			case 27: s = "semi expected"; break;
-			case 28: s = "darrow expected"; break;
-			case 29: s = "arrow expected"; break;
-			case 30: s = "assume expected"; break;
-			case 31: s = "calc expected"; break;
-			case 32: s = "case expected"; break;
-			case 33: s = "then expected"; break;
-			case 34: s = "else expected"; break;
-			case 35: s = "decreases expected"; break;
-			case 36: s = "invariant expected"; break;
-			case 37: s = "function expected"; break;
-			case 38: s = "predicate expected"; break;
-			case 39: s = "inductive expected"; break;
-			case 40: s = "lemma expected"; break;
-			case 41: s = "copredicate expected"; break;
-			case 42: s = "modifies expected"; break;
-			case 43: s = "reads expected"; break;
-			case 44: s = "requires expected"; break;
-			case 45: s = "lbrace expected"; break;
-			case 46: s = "rbrace expected"; break;
-			case 47: s = "lbracket expected"; break;
-			case 48: s = "rbracket expected"; break;
-			case 49: s = "openparen expected"; break;
-			case 50: s = "closeparen expected"; break;
-			case 51: s = "openAngleBracket expected"; break;
-			case 52: s = "closeAngleBracket expected"; break;
-			case 53: s = "eq expected"; break;
-			case 54: s = "neq expected"; break;
-			case 55: s = "neqAlt expected"; break;
-			case 56: s = "star expected"; break;
-			case 57: s = "notIn expected"; break;
-			case 58: s = "ellipsis expected"; break;
-			case 59: s = "\"include\" expected"; break;
-			case 60: s = "\"abstract\" expected"; break;
-			case 61: s = "\"module\" expected"; break;
-			case 62: s = "\"exclusively\" expected"; break;
-			case 63: s = "\"refines\" expected"; break;
-			case 64: s = "\"import\" expected"; break;
-			case 65: s = "\"opened\" expected"; break;
-			case 66: s = "\"=\" expected"; break;
-			case 67: s = "\"as\" expected"; break;
-			case 68: s = "\"default\" expected"; break;
-			case 69: s = "\"class\" expected"; break;
-			case 70: s = "\"extends\" expected"; break;
-			case 71: s = "\"trait\" expected"; break;
-			case 72: s = "\"ghost\" expected"; break;
-			case 73: s = "\"static\" expected"; break;
-			case 74: s = "\"protected\" expected"; break;
-			case 75: s = "\"datatype\" expected"; break;
-			case 76: s = "\"codatatype\" expected"; break;
-			case 77: s = "\"var\" expected"; break;
-			case 78: s = "\"newtype\" expected"; break;
-			case 79: s = "\"type\" expected"; break;
-			case 80: s = "\"iterator\" expected"; break;
-			case 81: s = "\"yields\" expected"; break;
-			case 82: s = "\"returns\" expected"; break;
-			case 83: s = "\"method\" expected"; break;
-			case 84: s = "\"colemma\" expected"; break;
-			case 85: s = "\"comethod\" expected"; break;
-			case 86: s = "\"constructor\" expected"; break;
-			case 87: s = "\"free\" expected"; break;
-			case 88: s = "\"ensures\" expected"; break;
-			case 89: s = "\"yield\" expected"; break;
-			case 90: s = "\"`\" expected"; break;
-			case 91: s = "\"label\" expected"; break;
-			case 92: s = "\"break\" expected"; break;
-			case 93: s = "\"where\" expected"; break;
-			case 94: s = "\":=\" expected"; break;
-			case 95: s = "\"return\" expected"; break;
-			case 96: s = "\":|\" expected"; break;
+			case 25: s = "boredSmiley expected"; break;
+			case 26: s = "bullet expected"; break;
+			case 27: s = "dot expected"; break;
+			case 28: s = "semi expected"; break;
+			case 29: s = "darrow expected"; break;
+			case 30: s = "arrow expected"; break;
+			case 31: s = "assume expected"; break;
+			case 32: s = "calc expected"; break;
+			case 33: s = "case expected"; break;
+			case 34: s = "then expected"; break;
+			case 35: s = "else expected"; break;
+			case 36: s = "decreases expected"; break;
+			case 37: s = "invariant expected"; break;
+			case 38: s = "function expected"; break;
+			case 39: s = "predicate expected"; break;
+			case 40: s = "inductive expected"; break;
+			case 41: s = "lemma expected"; break;
+			case 42: s = "copredicate expected"; break;
+			case 43: s = "modifies expected"; break;
+			case 44: s = "reads expected"; break;
+			case 45: s = "requires expected"; break;
+			case 46: s = "lbrace expected"; break;
+			case 47: s = "rbrace expected"; break;
+			case 48: s = "lbracket expected"; break;
+			case 49: s = "rbracket expected"; break;
+			case 50: s = "openparen expected"; break;
+			case 51: s = "closeparen expected"; break;
+			case 52: s = "openAngleBracket expected"; break;
+			case 53: s = "closeAngleBracket expected"; break;
+			case 54: s = "eq expected"; break;
+			case 55: s = "neq expected"; break;
+			case 56: s = "neqAlt expected"; break;
+			case 57: s = "star expected"; break;
+			case 58: s = "notIn expected"; break;
+			case 59: s = "ellipsis expected"; break;
+			case 60: s = "\"include\" expected"; break;
+			case 61: s = "\"abstract\" expected"; break;
+			case 62: s = "\"module\" expected"; break;
+			case 63: s = "\"exclusively\" expected"; break;
+			case 64: s = "\"refines\" expected"; break;
+			case 65: s = "\"import\" expected"; break;
+			case 66: s = "\"opened\" expected"; break;
+			case 67: s = "\"=\" expected"; break;
+			case 68: s = "\"as\" expected"; break;
+			case 69: s = "\"default\" expected"; break;
+			case 70: s = "\"class\" expected"; break;
+			case 71: s = "\"extends\" expected"; break;
+			case 72: s = "\"trait\" expected"; break;
+			case 73: s = "\"ghost\" expected"; break;
+			case 74: s = "\"static\" expected"; break;
+			case 75: s = "\"protected\" expected"; break;
+			case 76: s = "\"datatype\" expected"; break;
+			case 77: s = "\"codatatype\" expected"; break;
+			case 78: s = "\"var\" expected"; break;
+			case 79: s = "\"newtype\" expected"; break;
+			case 80: s = "\"type\" expected"; break;
+			case 81: s = "\"iterator\" expected"; break;
+			case 82: s = "\"yields\" expected"; break;
+			case 83: s = "\"returns\" expected"; break;
+			case 84: s = "\"method\" expected"; break;
+			case 85: s = "\"colemma\" expected"; break;
+			case 86: s = "\"comethod\" expected"; break;
+			case 87: s = "\"constructor\" expected"; break;
+			case 88: s = "\"free\" expected"; break;
+			case 89: s = "\"ensures\" expected"; break;
+			case 90: s = "\"yield\" expected"; break;
+			case 91: s = "\"`\" expected"; break;
+			case 92: s = "\"label\" expected"; break;
+			case 93: s = "\"break\" expected"; break;
+			case 94: s = "\"where\" expected"; break;
+			case 95: s = "\":=\" expected"; break;
+			case 96: s = "\"return\" expected"; break;
 			case 97: s = "\"new\" expected"; break;
 			case 98: s = "\"if\" expected"; break;
 			case 99: s = "\"while\" expected"; break;
@@ -4646,49 +4695,50 @@ public class Errors {
 			case 196: s = "invalid ReturnStmt"; break;
 			case 197: s = "invalid Rhs"; break;
 			case 198: s = "invalid Lhs"; break;
-			case 199: s = "invalid Guard"; break;
-			case 200: s = "this symbol not expected in LoopSpec"; break;
+			case 199: s = "invalid AlternativeBlock"; break;
+			case 200: s = "invalid Guard"; break;
 			case 201: s = "this symbol not expected in LoopSpec"; break;
 			case 202: s = "this symbol not expected in LoopSpec"; break;
-			case 203: s = "invalid LoopSpec"; break;
-			case 204: s = "invalid CaseStatement"; break;
-			case 205: s = "this symbol not expected in CaseStatement"; break;
+			case 203: s = "this symbol not expected in LoopSpec"; break;
+			case 204: s = "invalid LoopSpec"; break;
+			case 205: s = "invalid CaseStatement"; break;
 			case 206: s = "this symbol not expected in CaseStatement"; break;
-			case 207: s = "invalid CasePattern"; break;
-			case 208: s = "invalid CalcOp"; break;
-			case 209: s = "invalid EquivOp"; break;
-			case 210: s = "invalid ImpliesOp"; break;
-			case 211: s = "invalid ExpliesOp"; break;
-			case 212: s = "invalid AndOp"; break;
-			case 213: s = "invalid OrOp"; break;
-			case 214: s = "invalid NegOp"; break;
-			case 215: s = "invalid Forall"; break;
-			case 216: s = "invalid Exists"; break;
-			case 217: s = "invalid QSep"; break;
-			case 218: s = "invalid ImpliesExpliesExpression"; break;
-			case 219: s = "invalid LogicalExpression"; break;
-			case 220: s = "invalid RelOp"; break;
-			case 221: s = "invalid AddOp"; break;
-			case 222: s = "invalid UnaryExpression"; break;
-			case 223: s = "invalid MulOp"; break;
-			case 224: s = "invalid Suffix"; break;
+			case 207: s = "this symbol not expected in CaseStatement"; break;
+			case 208: s = "invalid CasePattern"; break;
+			case 209: s = "invalid CalcOp"; break;
+			case 210: s = "invalid EquivOp"; break;
+			case 211: s = "invalid ImpliesOp"; break;
+			case 212: s = "invalid ExpliesOp"; break;
+			case 213: s = "invalid AndOp"; break;
+			case 214: s = "invalid OrOp"; break;
+			case 215: s = "invalid NegOp"; break;
+			case 216: s = "invalid Forall"; break;
+			case 217: s = "invalid Exists"; break;
+			case 218: s = "invalid QSep"; break;
+			case 219: s = "invalid ImpliesExpliesExpression"; break;
+			case 220: s = "invalid LogicalExpression"; break;
+			case 221: s = "invalid RelOp"; break;
+			case 222: s = "invalid AddOp"; break;
+			case 223: s = "invalid UnaryExpression"; break;
+			case 224: s = "invalid MulOp"; break;
 			case 225: s = "invalid Suffix"; break;
 			case 226: s = "invalid Suffix"; break;
 			case 227: s = "invalid Suffix"; break;
-			case 228: s = "invalid LambdaExpression"; break;
-			case 229: s = "invalid EndlessExpression"; break;
-			case 230: s = "invalid NameSegment"; break;
-			case 231: s = "invalid DisplayExpr"; break;
-			case 232: s = "invalid MultiSetExpr"; break;
-			case 233: s = "invalid ConstAtomExpression"; break;
-			case 234: s = "invalid Nat"; break;
-			case 235: s = "invalid LambdaArrow"; break;
-			case 236: s = "invalid MatchExpression"; break;
-			case 237: s = "invalid QuantifierGuts"; break;
-			case 238: s = "invalid StmtInExpr"; break;
-			case 239: s = "invalid LetExpr"; break;
-			case 240: s = "invalid CaseExpression"; break;
-			case 241: s = "invalid DotSuffix"; break;
+			case 228: s = "invalid Suffix"; break;
+			case 229: s = "invalid LambdaExpression"; break;
+			case 230: s = "invalid EndlessExpression"; break;
+			case 231: s = "invalid NameSegment"; break;
+			case 232: s = "invalid DisplayExpr"; break;
+			case 233: s = "invalid MultiSetExpr"; break;
+			case 234: s = "invalid ConstAtomExpression"; break;
+			case 235: s = "invalid Nat"; break;
+			case 236: s = "invalid LambdaArrow"; break;
+			case 237: s = "invalid MatchExpression"; break;
+			case 238: s = "invalid QuantifierGuts"; break;
+			case 239: s = "invalid StmtInExpr"; break;
+			case 240: s = "invalid LetExpr"; break;
+			case 241: s = "invalid CaseExpression"; break;
+			case 242: s = "invalid DotSuffix"; break;
 
 			default: s = "error " + n; break;
 		}
@@ -4699,19 +4749,19 @@ public class Errors {
 		Contract.Requires(tok != null);
 		Contract.Requires(msg != null);
 		ErrorCount++;
-        reporter.Error(MessageSource.Parser, tok, msg);
+		Reporting.Error(MessageSource.Parser, tok, msg);
 	}
 
 	public void SemErr(string filename, int line, int col, string msg) {
 		Contract.Requires(msg != null);
 		ErrorCount++;
-        reporter.Error(MessageSource.Parser, filename, line, col, msg);
+		Reporting.Error(MessageSource.Parser, filename, line, col, msg);
 	}
 
 	public void Warning(IToken tok, string msg) {
 		Contract.Requires(tok != null);
 		Contract.Requires(msg != null);
-        reporter.Warning(MessageSource.Parser, tok, msg);
+		Reporting.Warning(MessageSource.Parser, tok, msg);
 	}
 } // Errors
 
diff --git a/Source/Dafny/Printer.cs b/Source/Dafny/Printer.cs
index e242c8bb..5e69bce8 100644
--- a/Source/Dafny/Printer.cs
+++ b/Source/Dafny/Printer.cs
@@ -38,10 +38,11 @@ namespace Microsoft.Dafny {
       }
     }
 
-    public static string GuardToString(Expression expr) {
+    public static string GuardToString(bool isExistentialGuard, Expression expr) {
+      Contract.Requires(!isExistentialGuard || (expr is ExistsExpr && ((ExistsExpr)expr).Range == null));
       using (var wr = new System.IO.StringWriter()) {
         var pr = new Printer(wr);
-        pr.PrintGuard(expr);
+        pr.PrintGuard(isExistentialGuard, expr);
         return wr.ToString();
       }
     }
@@ -1045,26 +1046,18 @@ namespace Microsoft.Dafny {
     }
 
     void PrintIfStatement(int indent, IfStmt s, bool omitGuard) {
-      while (true) {
-        if (omitGuard) {
-          wr.Write("if ... ");
-        } else {
-          wr.Write("if ");
-          PrintGuard(s.Guard);
-          wr.Write(" ");
-        }
-        PrintStatement(s.Thn, indent);
-        if (s.Els == null) {
-          break;
-        }
-        wr.Write(" else ");
-        if (s.Els is IfStmt) {
-          s = (IfStmt)s.Els;
-        } else {
-          PrintStatement(s.Els, indent);
-          break;
-        }
+      if (omitGuard) {
+        wr.Write("if ... ");
+      } else {
+        wr.Write("if ");
+        PrintGuard(s.IsExistentialGuard, s.Guard);
+        wr.Write(" ");
       }
+      PrintStatement(s.Thn, indent);
+      if (s.Els != null) {
+        wr.Write(" else ");
+        PrintStatement(s.Els, indent);
+      }
     }
 
     void PrintWhileStatement(int indent, WhileStmt s, bool omitGuard, bool omitBody) {
@@ -1073,7 +1066,7 @@ namespace Microsoft.Dafny {
         wr.WriteLine("while ...");
       } else {
         wr.Write("while ");
-        PrintGuard(s.Guard);
+        PrintGuard(false, s.Guard);
         wr.WriteLine();
       }
 
@@ -1094,8 +1087,13 @@ namespace Microsoft.Dafny {
       int caseInd = indent + IndentAmount;
       foreach (var alternative in alternatives) {
         Indent(caseInd);
-        wr.Write("case ");
-        PrintExpression(alternative.Guard, false);
+        wr.Write("case ");
+        if (alternative.IsExistentialGuard) {
+          var exists = (ExistsExpr)alternative.Guard;
+          PrintExistentialGuard(exists);
+        } else {
+          PrintExpression(alternative.Guard, false);
+        }
         wr.WriteLine(" =>");
         foreach (Statement s in alternative.Body) {
           Indent(caseInd + IndentAmount);
@@ -1142,12 +1140,24 @@ namespace Microsoft.Dafny {
       }
     }
 
-    void PrintGuard(Expression guard) {
+    void PrintGuard(bool isExistentialGuard, Expression guard) {
+      Contract.Requires(!isExistentialGuard || (guard is ExistsExpr && ((ExistsExpr)guard).Range == null));
       if (guard == null) {
         wr.Write("*");
+      } else if (isExistentialGuard) {
+        var exists = (ExistsExpr)guard;
+        PrintExistentialGuard(exists);
       } else {
         PrintExpression(guard, false);
       }
+    }
+
+    void PrintExistentialGuard(ExistsExpr guard) {
+      Contract.Requires(guard != null);
+      Contract.Requires(guard.Range == null);
+      PrintQuantifierDomain(guard.BoundVars, guard.Attributes, null);
+      wr.Write(" :| ");
+      PrintExpression(guard.Term, false);
     }
 
     void PrintCalcOp(CalcStmt.CalcOp op) {
diff --git a/Source/Dafny/RefinementTransformer.cs b/Source/Dafny/RefinementTransformer.cs
index 24d1126f..82ddddf1 100644
--- a/Source/Dafny/RefinementTransformer.cs
+++ b/Source/Dafny/RefinementTransformer.cs
@@ -1120,9 +1120,9 @@ namespace Microsoft.Dafny
                 var resultingThen = MergeBlockStmt(skel.Thn, oldIf.Thn);
                 var resultingElse = MergeElse(skel.Els, oldIf.Els);
                 var e = refinementCloner.CloneExpr(oldIf.Guard);
-                var r = new IfStmt(skel.Tok, skel.EndTok, e, resultingThen, resultingElse);
+                var r = new IfStmt(skel.Tok, skel.EndTok, oldIf.IsExistentialGuard, e, resultingThen, resultingElse);
                 body.Add(r);
-                reporter.Info(MessageSource.RefinementTransformer, c.ConditionEllipsis, Printer.GuardToString(e));
+                reporter.Info(MessageSource.RefinementTransformer, c.ConditionEllipsis, Printer.GuardToString(oldIf.IsExistentialGuard, e));
                 i++; j++;
               }
 
@@ -1136,7 +1136,7 @@ namespace Microsoft.Dafny
                 Expression guard;
                 if (c.ConditionOmitted) {
                   guard = refinementCloner.CloneExpr(oldWhile.Guard);
-                  reporter.Info(MessageSource.RefinementTransformer, c.ConditionEllipsis, Printer.GuardToString(oldWhile.Guard));
+                  reporter.Info(MessageSource.RefinementTransformer, c.ConditionEllipsis, Printer.GuardToString(false, oldWhile.Guard));
                 } else {
                   if (oldWhile.Guard != null) {
                     reporter.Error(MessageSource.RefinementTransformer, skel.Guard.tok, "a skeleton while statement with a guard can only replace a while statement with a non-deterministic guard");
@@ -1287,7 +1287,7 @@ namespace Microsoft.Dafny
             var cNew = (IfStmt)cur;
             var cOld = oldS as IfStmt;
             if (cOld != null && cOld.Guard == null) {
-              var r = new IfStmt(cNew.Tok, cNew.EndTok, cNew.Guard, MergeBlockStmt(cNew.Thn, cOld.Thn), MergeElse(cNew.Els, cOld.Els));
+              var r = new IfStmt(cNew.Tok, cNew.EndTok, cNew.IsExistentialGuard, cNew.Guard, MergeBlockStmt(cNew.Thn, cOld.Thn), MergeElse(cNew.Els, cOld.Els));
               body.Add(r);
               i++; j++;
             } else {
diff --git a/Source/Dafny/Resolver.cs b/Source/Dafny/Resolver.cs
index 7a540722..bc94e491 100644
--- a/Source/Dafny/Resolver.cs
+++ b/Source/Dafny/Resolver.cs
@@ -1605,7 +1605,7 @@ namespace Microsoft.Dafny
             var subst = new FixpointLemmaBodyCloner(com, kMinusOne, focalPredicates, this.reporter);
             var mainBody = subst.CloneBlockStmt(com.Body);
             var kPositive = new BinaryExpr(com.tok, BinaryExpr.Opcode.Lt, new LiteralExpr(com.tok, 0), new IdentifierExpr(k.tok, k.Name));
-            var condBody = new IfStmt(com.BodyStartTok, mainBody.EndTok, kPositive, mainBody, null);
+            var condBody = new IfStmt(com.BodyStartTok, mainBody.EndTok, false, kPositive, mainBody, null);
             prefixLemma.Body = new BlockStmt(com.tok, condBody.EndTok, new List<Statement>() { condBody });
           }
           // The prefix lemma now has all its components, so it's finally time we resolve it
diff --git a/Source/Dafny/Rewriter.cs b/Source/Dafny/Rewriter.cs
index 9bc24c30..fa5fdfbe 100644
--- a/Source/Dafny/Rewriter.cs
+++ b/Source/Dafny/Rewriter.cs
@@ -356,7 +356,7 @@ namespace Microsoft.Dafny
         e = BinBoolExpr(tok, BinaryExpr.ResolvedOpcode.NeqCommon, F, cNull);
         var thn = new BlockStmt(tok, tok, new List<Statement>() { s });
         thn.IsGhost = true;
-        s = new IfStmt(tok, tok, e, thn, null);
+        s = new IfStmt(tok, tok, false, e, thn, null);
         s.IsGhost = true;
         // finally, add s to the body
         bodyStatements.Add(s);
diff --git a/Source/Dafny/Scanner.cs b/Source/Dafny/Scanner.cs
index e6c97f22..6e2107c3 100644
--- a/Source/Dafny/Scanner.cs
+++ b/Source/Dafny/Scanner.cs
@@ -267,32 +267,32 @@ public class Scanner {
 		for (int i = 65; i <= 90; ++i) start[i] = 1;
 		for (int i = 95; i <= 95; ++i) start[i] = 1;
 		for (int i = 98; i <= 122; ++i) start[i] = 1;
-		for (int i = 49; i <= 57; ++i) start[i] = 48;
-		start[97] = 49; 
-		start[39] = 50; 
-		start[48] = 51; 
+		for (int i = 49; i <= 57; ++i) start[i] = 49;
+		start[97] = 50; 
+		start[39] = 51; 
+		start[48] = 52; 
 		start[34] = 21; 
 		start[64] = 26; 
 		start[58] = 89; 
 		start[44] = 29; 
 		start[124] = 90; 
-		start[8226] = 31; 
+		start[8226] = 32; 
 		start[46] = 91; 
-		start[59] = 32; 
+		start[59] = 33; 
 		start[61] = 92; 
 		start[45] = 93; 
-		start[123] = 35; 
-		start[125] = 36; 
-		start[91] = 37; 
-		start[93] = 38; 
-		start[40] = 39; 
-		start[41] = 40; 
+		start[123] = 36; 
+		start[125] = 37; 
+		start[91] = 38; 
+		start[93] = 39; 
+		start[40] = 40; 
+		start[41] = 41; 
 		start[60] = 94; 
 		start[62] = 95; 
 		start[33] = 96; 
-		start[8800] = 42; 
-		start[42] = 43; 
-		start[96] = 66; 
+		start[8800] = 43; 
+		start[42] = 44; 
+		start[96] = 67; 
 		start[35] = 69; 
 		start[8804] = 71; 
 		start[8805] = 72; 
@@ -524,55 +524,55 @@ public class Scanner {
 			case "seq": t.kind = 16; break;
 			case "map": t.kind = 17; break;
 			case "imap": t.kind = 18; break;
-			case "assume": t.kind = 30; break;
-			case "calc": t.kind = 31; break;
-			case "case": t.kind = 32; break;
-			case "then": t.kind = 33; break;
-			case "else": t.kind = 34; break;
-			case "decreases": t.kind = 35; break;
-			case "invariant": t.kind = 36; break;
-			case "function": t.kind = 37; break;
-			case "predicate": t.kind = 38; break;
-			case "inductive": t.kind = 39; break;
-			case "lemma": t.kind = 40; break;
-			case "copredicate": t.kind = 41; break;
-			case "modifies": t.kind = 42; break;
-			case "reads": t.kind = 43; break;
-			case "requires": t.kind = 44; break;
-			case "include": t.kind = 59; break;
-			case "abstract": t.kind = 60; break;
-			case "module": t.kind = 61; break;
-			case "exclusively": t.kind = 62; break;
-			case "refines": t.kind = 63; break;
-			case "import": t.kind = 64; break;
-			case "opened": t.kind = 65; break;
-			case "as": t.kind = 67; break;
-			case "default": t.kind = 68; break;
-			case "class": t.kind = 69; break;
-			case "extends": t.kind = 70; break;
-			case "trait": t.kind = 71; break;
-			case "ghost": t.kind = 72; break;
-			case "static": t.kind = 73; break;
-			case "protected": t.kind = 74; break;
-			case "datatype": t.kind = 75; break;
-			case "codatatype": t.kind = 76; break;
-			case "var": t.kind = 77; break;
-			case "newtype": t.kind = 78; break;
-			case "type": t.kind = 79; break;
-			case "iterator": t.kind = 80; break;
-			case "yields": t.kind = 81; break;
-			case "returns": t.kind = 82; break;
-			case "method": t.kind = 83; break;
-			case "colemma": t.kind = 84; break;
-			case "comethod": t.kind = 85; break;
-			case "constructor": t.kind = 86; break;
-			case "free": t.kind = 87; break;
-			case "ensures": t.kind = 88; break;
-			case "yield": t.kind = 89; break;
-			case "label": t.kind = 91; break;
-			case "break": t.kind = 92; break;
-			case "where": t.kind = 93; break;
-			case "return": t.kind = 95; break;
+			case "assume": t.kind = 31; break;
+			case "calc": t.kind = 32; break;
+			case "case": t.kind = 33; break;
+			case "then": t.kind = 34; break;
+			case "else": t.kind = 35; break;
+			case "decreases": t.kind = 36; break;
+			case "invariant": t.kind = 37; break;
+			case "function": t.kind = 38; break;
+			case "predicate": t.kind = 39; break;
+			case "inductive": t.kind = 40; break;
+			case "lemma": t.kind = 41; break;
+			case "copredicate": t.kind = 42; break;
+			case "modifies": t.kind = 43; break;
+			case "reads": t.kind = 44; break;
+			case "requires": t.kind = 45; break;
+			case "include": t.kind = 60; break;
+			case "abstract": t.kind = 61; break;
+			case "module": t.kind = 62; break;
+			case "exclusively": t.kind = 63; break;
+			case "refines": t.kind = 64; break;
+			case "import": t.kind = 65; break;
+			case "opened": t.kind = 66; break;
+			case "as": t.kind = 68; break;
+			case "default": t.kind = 69; break;
+			case "class": t.kind = 70; break;
+			case "extends": t.kind = 71; break;
+			case "trait": t.kind = 72; break;
+			case "ghost": t.kind = 73; break;
+			case "static": t.kind = 74; break;
+			case "protected": t.kind = 75; break;
+			case "datatype": t.kind = 76; break;
+			case "codatatype": t.kind = 77; break;
+			case "var": t.kind = 78; break;
+			case "newtype": t.kind = 79; break;
+			case "type": t.kind = 80; break;
+			case "iterator": t.kind = 81; break;
+			case "yields": t.kind = 82; break;
+			case "returns": t.kind = 83; break;
+			case "method": t.kind = 84; break;
+			case "colemma": t.kind = 85; break;
+			case "comethod": t.kind = 86; break;
+			case "constructor": t.kind = 87; break;
+			case "free": t.kind = 88; break;
+			case "ensures": t.kind = 89; break;
+			case "yield": t.kind = 90; break;
+			case "label": t.kind = 92; break;
+			case "break": t.kind = 93; break;
+			case "where": t.kind = 94; break;
+			case "return": t.kind = 96; break;
 			case "new": t.kind = 97; break;
 			case "if": t.kind = 98; break;
 			case "while": t.kind = 99; break;
@@ -696,7 +696,7 @@ public class Scanner {
 			case 21:
 				if (ch <= 9 || ch >= 11 && ch <= 12 || ch >= 14 && ch <= '!' || ch >= '#' && ch <= '[' || ch >= ']' && ch <= 65535) {AddCh(); goto case 21;}
 				else if (ch == '"') {AddCh(); goto case 28;}
-				else if (ch == 92) {AddCh(); goto case 54;}
+				else if (ch == 92) {AddCh(); goto case 55;}
 				else {goto case 0;}
 			case 22:
 				if (ch >= '0' && ch <= '9' || ch >= 'A' && ch <= 'F' || ch >= 'a' && ch <= 'f') {AddCh(); goto case 23;}
@@ -715,7 +715,7 @@ public class Scanner {
 				else {goto case 0;}
 			case 27:
 				if (ch <= '!' || ch >= '#' && ch <= 65535) {AddCh(); goto case 27;}
-				else if (ch == '"') {AddCh(); goto case 55;}
+				else if (ch == '"') {AddCh(); goto case 56;}
 				else {goto case 0;}
 			case 28:
 				{t.kind = 20; break;}
@@ -726,13 +726,13 @@ public class Scanner {
 			case 31:
 				{t.kind = 25; break;}
 			case 32:
-				{t.kind = 27; break;}
+				{t.kind = 26; break;}
 			case 33:
 				{t.kind = 28; break;}
 			case 34:
 				{t.kind = 29; break;}
 			case 35:
-				{t.kind = 45; break;}
+				{t.kind = 30; break;}
 			case 36:
 				{t.kind = 46; break;}
 			case 37:
@@ -744,117 +744,117 @@ public class Scanner {
 			case 40:
 				{t.kind = 50; break;}
 			case 41:
-				{t.kind = 54; break;}
+				{t.kind = 51; break;}
 			case 42:
 				{t.kind = 55; break;}
 			case 43:
 				{t.kind = 56; break;}
 			case 44:
-				if (ch == 'n') {AddCh(); goto case 45;}
-				else {goto case 0;}
+				{t.kind = 57; break;}
 			case 45:
-				if (ch <= '&' || ch >= '(' && ch <= '/' || ch >= ':' && ch <= '>' || ch == '@' || ch >= '[' && ch <= '^' || ch == '`' || ch >= '{' && ch <= 65535) {apx++; AddCh(); goto case 46;}
+				if (ch == 'n') {AddCh(); goto case 46;}
 				else {goto case 0;}
 			case 46:
+				if (ch <= '&' || ch >= '(' && ch <= '/' || ch >= ':' && ch <= '>' || ch == '@' || ch >= '[' && ch <= '^' || ch == '`' || ch >= '{' && ch <= 65535) {apx++; AddCh(); goto case 47;}
+				else {goto case 0;}
+			case 47:
 				{
 					tlen -= apx;
 					SetScannerBehindT();
-					t.kind = 57; break;}
-			case 47:
-				{t.kind = 58; break;}
+					t.kind = 58; break;}
 			case 48:
+				{t.kind = 59; break;}
+			case 49:
 				recEnd = pos; recKind = 2;
-				if (ch >= '0' && ch <= '9') {AddCh(); goto case 48;}
-				else if (ch == '_') {AddCh(); goto case 56;}
+				if (ch >= '0' && ch <= '9') {AddCh(); goto case 49;}
+				else if (ch == '_') {AddCh(); goto case 57;}
 				else if (ch == '.') {AddCh(); goto case 12;}
 				else {t.kind = 2; break;}
-			case 49:
+			case 50:
 				recEnd = pos; recKind = 1;
 				if (ch == 39 || ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'q' || ch >= 's' && ch <= 'z') {AddCh(); goto case 2;}
-				else if (ch == 'r') {AddCh(); goto case 57;}
+				else if (ch == 'r') {AddCh(); goto case 58;}
 				else {t.kind = 1; t.val = new String(tval, 0, tlen); CheckLiteral(); return t;}
-			case 50:
+			case 51:
 				recEnd = pos; recKind = 1;
-				if (ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 58;}
-				else if (ch == 39) {AddCh(); goto case 59;}
+				if (ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 59;}
+				else if (ch == 39) {AddCh(); goto case 60;}
 				else if (ch <= 9 || ch >= 11 && ch <= 12 || ch >= 14 && ch <= '&' || ch >= '(' && ch <= '/' || ch >= ':' && ch <= '>' || ch == '@' || ch == '[' || ch >= ']' && ch <= '^' || ch == '`' || ch >= '{' && ch <= 65535) {AddCh(); goto case 15;}
-				else if (ch == 92) {AddCh(); goto case 53;}
+				else if (ch == 92) {AddCh(); goto case 54;}
 				else {t.kind = 1; t.val = new String(tval, 0, tlen); CheckLiteral(); return t;}
-			case 51:
+			case 52:
 				recEnd = pos; recKind = 2;
-				if (ch >= '0' && ch <= '9') {AddCh(); goto case 48;}
-				else if (ch == '_') {AddCh(); goto case 56;}
+				if (ch >= '0' && ch <= '9') {AddCh(); goto case 49;}
+				else if (ch == '_') {AddCh(); goto case 57;}
 				else if (ch == 'x') {AddCh(); goto case 9;}
 				else if (ch == '.') {AddCh(); goto case 12;}
 				else {t.kind = 2; break;}
-			case 52:
+			case 53:
 				recEnd = pos; recKind = 1;
-				if (ch == 39 || ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 52;}
+				if (ch == 39 || ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 53;}
 				else {t.kind = 1; t.val = new String(tval, 0, tlen); CheckLiteral(); return t;}
-			case 53:
+			case 54:
 				if (ch == '"' || ch == 39 || ch == '0' || ch == 92 || ch == 'n' || ch == 'r' || ch == 't') {AddCh(); goto case 15;}
 				else if (ch == 'u') {AddCh(); goto case 16;}
 				else {goto case 0;}
-			case 54:
+			case 55:
 				if (ch == '"' || ch == 39 || ch == '0' || ch == 92 || ch == 'n' || ch == 'r' || ch == 't') {AddCh(); goto case 21;}
 				else if (ch == 'u') {AddCh(); goto case 22;}
 				else {goto case 0;}
-			case 55:
+			case 56:
 				recEnd = pos; recKind = 20;
 				if (ch == '"') {AddCh(); goto case 27;}
 				else {t.kind = 20; break;}
-			case 56:
-				if (ch >= '0' && ch <= '9') {AddCh(); goto case 48;}
-				else {goto case 0;}
 			case 57:
+				if (ch >= '0' && ch <= '9') {AddCh(); goto case 49;}
+				else {goto case 0;}
+			case 58:
 				recEnd = pos; recKind = 1;
 				if (ch == 39 || ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'q' || ch >= 's' && ch <= 'z') {AddCh(); goto case 3;}
-				else if (ch == 'r') {AddCh(); goto case 60;}
+				else if (ch == 'r') {AddCh(); goto case 61;}
 				else {t.kind = 1; t.val = new String(tval, 0, tlen); CheckLiteral(); return t;}
-			case 58:
+			case 59:
 				recEnd = pos; recKind = 1;
-				if (ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 61;}
-				else if (ch == 39) {AddCh(); goto case 62;}
+				if (ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 62;}
+				else if (ch == 39) {AddCh(); goto case 63;}
 				else {t.kind = 1; t.val = new String(tval, 0, tlen); CheckLiteral(); return t;}
-			case 59:
+			case 60:
 				recEnd = pos; recKind = 1;
-				if (ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 61;}
+				if (ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 62;}
 				else if (ch == 39) {AddCh(); goto case 7;}
 				else {t.kind = 1; t.val = new String(tval, 0, tlen); CheckLiteral(); return t;}
-			case 60:
+			case 61:
 				recEnd = pos; recKind = 1;
 				if (ch == 39 || ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'b' && ch <= 'z') {AddCh(); goto case 4;}
-				else if (ch == 'a') {AddCh(); goto case 63;}
+				else if (ch == 'a') {AddCh(); goto case 64;}
 				else {t.kind = 1; t.val = new String(tval, 0, tlen); CheckLiteral(); return t;}
-			case 61:
+			case 62:
 				recEnd = pos; recKind = 1;
 				if (ch == 39 || ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 8;}
 				else {t.kind = 1; t.val = new String(tval, 0, tlen); CheckLiteral(); return t;}
-			case 62:
+			case 63:
 				recEnd = pos; recKind = 19;
 				if (ch == 39 || ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 8;}
 				else {t.kind = 19; break;}
-			case 63:
+			case 64:
 				recEnd = pos; recKind = 1;
 				if (ch == 39 || ch >= '0' && ch <= '9' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'x' || ch == 'z') {AddCh(); goto case 5;}
-				else if (ch == 'y') {AddCh(); goto case 64;}
+				else if (ch == 'y') {AddCh(); goto case 65;}
 				else {t.kind = 1; t.val = new String(tval, 0, tlen); CheckLiteral(); return t;}
-			case 64:
+			case 65:
 				recEnd = pos; recKind = 5;
 				if (ch == 39 || ch == '0' || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 6;}
-				else if (ch >= '1' && ch <= '9') {AddCh(); goto case 65;}
+				else if (ch >= '1' && ch <= '9') {AddCh(); goto case 66;}
 				else {t.kind = 5; break;}
-			case 65:
+			case 66:
 				recEnd = pos; recKind = 5;
-				if (ch == 39 || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 52;}
-				else if (ch >= '0' && ch <= '9') {AddCh(); goto case 65;}
+				if (ch == 39 || ch == '?' || ch >= 'A' && ch <= 'Z' || ch == '_' || ch >= 'a' && ch <= 'z') {AddCh(); goto case 53;}
+				else if (ch >= '0' && ch <= '9') {AddCh(); goto case 66;}
 				else {t.kind = 5; break;}
-			case 66:
-				{t.kind = 90; break;}
 			case 67:
-				{t.kind = 94; break;}
+				{t.kind = 91; break;}
 			case 68:
-				{t.kind = 96; break;}
+				{t.kind = 95; break;}
 			case 69:
 				{t.kind = 106; break;}
 			case 70:
@@ -899,47 +899,47 @@ public class Scanner {
 			case 89:
 				recEnd = pos; recKind = 21;
 				if (ch == ':') {AddCh(); goto case 30;}
-				else if (ch == '=') {AddCh(); goto case 67;}
-				else if (ch == '|') {AddCh(); goto case 68;}
+				else if (ch == '|') {AddCh(); goto case 31;}
+				else if (ch == '=') {AddCh(); goto case 68;}
 				else {t.kind = 21; break;}
 			case 90:
 				recEnd = pos; recKind = 23;
 				if (ch == '|') {AddCh(); goto case 81;}
 				else {t.kind = 23; break;}
 			case 91:
-				recEnd = pos; recKind = 26;
+				recEnd = pos; recKind = 27;
 				if (ch == '.') {AddCh(); goto case 97;}
-				else {t.kind = 26; break;}
+				else {t.kind = 27; break;}
 			case 92:
-				recEnd = pos; recKind = 66;
-				if (ch == '>') {AddCh(); goto case 33;}
+				recEnd = pos; recKind = 67;
+				if (ch == '>') {AddCh(); goto case 34;}
 				else if (ch == '=') {AddCh(); goto case 98;}
-				else {t.kind = 66; break;}
+				else {t.kind = 67; break;}
 			case 93:
 				recEnd = pos; recKind = 128;
-				if (ch == '>') {AddCh(); goto case 34;}
+				if (ch == '>') {AddCh(); goto case 35;}
 				else {t.kind = 128; break;}
 			case 94:
-				recEnd = pos; recKind = 51;
+				recEnd = pos; recKind = 52;
 				if (ch == '=') {AddCh(); goto case 99;}
-				else {t.kind = 51; break;}
+				else {t.kind = 52; break;}
 			case 95:
-				recEnd = pos; recKind = 52;
+				recEnd = pos; recKind = 53;
 				if (ch == '=') {AddCh(); goto case 70;}
-				else {t.kind = 52; break;}
+				else {t.kind = 53; break;}
 			case 96:
 				recEnd = pos; recKind = 121;
-				if (ch == '=') {AddCh(); goto case 41;}
-				else if (ch == 'i') {AddCh(); goto case 44;}
+				if (ch == '=') {AddCh(); goto case 42;}
+				else if (ch == 'i') {AddCh(); goto case 45;}
 				else {t.kind = 121; break;}
 			case 97:
 				recEnd = pos; recKind = 137;
-				if (ch == '.') {AddCh(); goto case 47;}
+				if (ch == '.') {AddCh(); goto case 48;}
 				else {t.kind = 137; break;}
 			case 98:
-				recEnd = pos; recKind = 53;
+				recEnd = pos; recKind = 54;
 				if (ch == '>') {AddCh(); goto case 75;}
-				else {t.kind = 53; break;}
+				else {t.kind = 54; break;}
 			case 99:
 				recEnd = pos; recKind = 107;
 				if (ch == '=') {AddCh(); goto case 100;}
diff --git a/Source/Dafny/Translator.cs b/Source/Dafny/Translator.cs
index af8225da..c84f0cec 100644
--- a/Source/Dafny/Translator.cs
+++ b/Source/Dafny/Translator.cs
@@ -13936,7 +13936,7 @@ namespace Microsoft.Dafny {
           r = SubstBlockStmt((BlockStmt)stmt);
         } else if (stmt is IfStmt) {
           var s = (IfStmt)stmt;
-          r = new IfStmt(s.Tok, s.EndTok, Substitute(s.Guard), SubstBlockStmt(s.Thn), SubstStmt(s.Els));
+          r = new IfStmt(s.Tok, s.EndTok, s.IsExistentialGuard, Substitute(s.Guard), SubstBlockStmt(s.Thn), SubstStmt(s.Els));
         } else if (stmt is AlternativeStmt) {
           var s = (AlternativeStmt)stmt;
           r = new AlternativeStmt(s.Tok, s.EndTok, s.Alternatives.ConvertAll(SubstGuardedAlternative));
@@ -14025,7 +14025,7 @@ namespace Microsoft.Dafny {
 
       protected GuardedAlternative SubstGuardedAlternative(GuardedAlternative alt) {
         Contract.Requires(alt != null);
-        return new GuardedAlternative(alt.Tok, Substitute(alt.Guard), alt.Body.ConvertAll(SubstStmt));
+        return new GuardedAlternative(alt.Tok, alt.IsExistentialGuard, Substitute(alt.Guard), alt.Body.ConvertAll(SubstStmt));
       }
 
       protected MaybeFreeExpression SubstMayBeFreeExpr(MaybeFreeExpression expr) {
diff --git a/Test/dafny0/ExistentialGuards.dfy b/Test/dafny0/ExistentialGuards.dfy
new file mode 100644
index 00000000..001acb55
--- /dev/null
+++ b/Test/dafny0/ExistentialGuards.dfy
@@ -0,0 +1,89 @@
+// RUN: %dafny /dprint:- "%s" > "%t"
+// RUN: %diff "%s.expect" "%t"
+
+predicate P(n: int)
+
+predicate R(r: real)
+
+method M0()
+{
+  if x :| P(x) {
+  }
+}
+
+method M1()
+{
+  if x: int :| P(x) {
+  }
+}
+
+method M2()
+{
+  if x, y :| P(x) && R(y) {
+  }
+}
+
+method M3()
+{
+  if x: int, y :| P(x) && R(y) {
+  }
+}
+
+method M4()
+{
+  if x, y: real :| P(x) && R(y) {
+  }
+}
+
+method M5()
+{
+  if x: int, y: real :| P(x) && R(y) {
+  }
+}
+
+method M6()
+{
+  if x {:myattribute x, "hello"} :| P(x) {
+  }
+  if x, y {:myattribute y, "sveika"} :| P(x) && R(y) {
+  }
+  if x: int {:myattribute x, "chello"} :| P(x) {
+  }
+  if x {:myattribute x, "hola"} {:yourattribute x + x, "hej"} :| P(x) {
+  }
+}
+
+method M7()
+{
+  if x :| P(x) {
+  } else if * {
+  } else if y :| R(y) {
+  } else if y :| P(y) {
+  }
+}
+
+method P0(m: int, n: int)
+  requires m < n
+{
+  if {
+    case x :| P(x) =>
+    case x: int :| P(x) =>
+    case x, y :| P(x) && R(y) =>
+    case x: int, y :| P(x) && R(y) =>
+    case m < n =>  // just to be different
+    case x, y: real :| P(x) && R(y) =>
+    case x: int, y: real :| P(x) && R(y) =>
+  }
+}
+
+method P1(m: int, n: int)
+  requires m < n
+{
+  if {
+    case x {:myattribute x, "hello"} :| P(x) =>
+    case x, y {:myattribute y, "sveika"} :| P(x) && R(y) =>
+    case x: int {:myattribute x, "chello"} :| P(x) =>
+    case x {:myattribute x, "hola"} {:yourattribute x + x, "hej"} :| P(x) =>
+    case m < n =>
+  }
+}
diff --git a/Test/dafny0/ExistentialGuards.dfy.expect b/Test/dafny0/ExistentialGuards.dfy.expect
new file mode 100644
index 00000000..cf229553
--- /dev/null
+++ b/Test/dafny0/ExistentialGuards.dfy.expect
@@ -0,0 +1,94 @@
+// Dafny program verifier version 1.9.5.20511, Copyright (c) 2003-2015, Microsoft.
+// Command Line Options: -nologo -countVerificationErrors:0 -useBaseNameForFileName /dprint:- C:\dafny\Test\dafny0\ExistentialGuards.dfy
+// ExistentialGuards.dfy
+
+predicate P(n: int)
+
+predicate R(r: real)
+
+method M0()
+{
+  if x :| P(x) {
+  }
+}
+
+method M1()
+{
+  if x: int :| P(x) {
+  }
+}
+
+method M2()
+{
+  if x, y :| P(x) && R(y) {
+  }
+}
+
+method M3()
+{
+  if x: int, y :| P(x) && R(y) {
+  }
+}
+
+method M4()
+{
+  if x, y: real :| P(x) && R(y) {
+  }
+}
+
+method M5()
+{
+  if x: int, y: real :| P(x) && R(y) {
+  }
+}
+
+method M6()
+{
+  if x {:myattribute x, "hello"} :| P(x) {
+  }
+  if x, y {:myattribute y, "sveika"} :| P(x) && R(y) {
+  }
+  if x: int {:myattribute x, "chello"} :| P(x) {
+  }
+  if x {:myattribute x, "hola"} {:yourattribute x + x, "hej"} :| P(x) {
+  }
+}
+
+method M7()
+{
+  if x :| P(x) {
+  } else if * {
+  } else if y :| R(y) {
+  } else if y :| P(y) {
+  }
+}
+
+method P0(m: int, n: int)
+  requires m < n
+{
+  if {
+    case x :| P(x) =>
+    case x: int :| P(x) =>
+    case x, y :| P(x) && R(y) =>
+    case x: int, y :| P(x) && R(y) =>
+    case m < n =>
+    case x, y: real :| P(x) && R(y) =>
+    case x: int, y: real :| P(x) && R(y) =>
+  }
+}
+
+method P1(m: int, n: int)
+  requires m < n
+{
+  if {
+    case x {:myattribute x, "hello"} :| P(x) =>
+    case x, y {:myattribute y, "sveika"} :| P(x) && R(y) =>
+    case x: int {:myattribute x, "chello"} :| P(x) =>
+    case x {:myattribute x, "hola"} {:yourattribute x + x, "hej"} :| P(x) =>
+    case m < n =>
+  }
+}
+
+Dafny program verifier finished with 22 verified, 0 errors
+Compilation error: Function _module._default.P has no body
+Compilation error: Function _module._default.R has no body
diff --git a/Test/dafny0/Simple.dfy b/Test/dafny0/Simple.dfy
index f7bfcb70..0b6a620e 100644
--- a/Test/dafny0/Simple.dfy
+++ b/Test/dafny0/Simple.dfy
@@ -74,3 +74,30 @@ class CF {
   static protected function method I(): real
   protected static predicate method J()
 }
+
+// test printing of various if statements, including with omitted guards
+module A {
+  method P(x: int, y: int) {
+    if x==2 {
+    } else if * {
+    }
+    if x==10 {
+    }
+    if y==0 {
+    } else if y==1 {
+    } else if * {
+    } else if y==2 {
+    } else if (*) {
+    } else if y == 3 {
+    } else {
+    }
+  }
+}
+module B refines A {
+  method P... {
+    if ... {
+    } else if x==3 {
+    }
+    ...;
+  }
+}
diff --git a/Test/dafny0/Simple.dfy.expect b/Test/dafny0/Simple.dfy.expect
index e6647c8a..d5eb6722 100644
--- a/Test/dafny0/Simple.dfy.expect
+++ b/Test/dafny0/Simple.dfy.expect
@@ -67,6 +67,35 @@ class CF {
   static protected predicate method J()
 }
 
+module A {
+  method P(x: int, y: int)
+  {
+    if x == 2 {
+    } else if * {
+    }
+    if x == 10 {
+    }
+    if y == 0 {
+    } else if y == 1 {
+    } else if * {
+    } else if y == 2 {
+    } else if * {
+    } else if y == 3 {
+    } else {
+    }
+  }
+}
+
+module B refines A {
+  method P ...
+  {
+    if ... {
+    } else if x == 3 {
+    }
+    ...;
+  }
+}
+
 lemma M(x: int)
   ensures x < 8
 {
-- 
cgit v1.2.3


From 17405efd598d2a8a2dac304ee9a7f7d9bd30a558 Mon Sep 17 00:00:00 2001
From: "Richard L. Ford" <richford@microsoft.com>
Date: Wed, 27 Jan 2016 14:09:16 -0800
Subject: Implement 'extern' declaration modifier.

The 'extern' declaration modifier provides a more convenient
way of interfacing Dafny code with C# source files and
.Net DLLs.

We support an 'extern' keyword on a module, class, function method,
or method (cannot extern ghost). We check the CompileNames of
all modules to make sure there are no duplicate names.

Every Dafny-generated C# class is marked partial, so it can
potentially be extended.

The extern keyword could be accompanied by an optional string naming
the corresponding C# method/class to connect to. If not given
the name of the method/class is used.

An 'extern' keyword implies an {:axiom} attribute for functions
and methods, so their ensures clauses are assumed to be true
without proof.

In addition to the .dfy files, the user may supply
C# files (.cs) and dynamic linked libraries (.dll) on
command line. These will be passed onto the C# compiler,
the .cs files as sources, and the .dll files as references.

As part of this change the grammar was refactored some.
New productions are

- TopDecls - a list of top-level declarations.
- TopDecl - a single top-level declaration
- DeclModifiers - a list of declaration modifiers which are
  either 'abstract', 'ghost', 'static', 'protected', or 'extern'.
  They can be in any order and we diagnose duplicates.
  In addition, since they are not all allowed in all contexts,
  we check and give diagnostics if an DeclModifier appears
  where it is not allowed.
---
 Source/Dafny/Compiler.cs              |    2 +-
 Source/Dafny/Dafny.atg                |  356 +++++---
 Source/Dafny/DafnyAst.cs              |   31 +-
 Source/Dafny/Makefile                 |    4 +-
 Source/Dafny/Parser.cs                | 1534 ++++++++++++++++++---------------
 Source/Dafny/Resolver.cs              |   29 +
 Source/Dafny/Scanner.cs               |  169 ++--
 Source/DafnyDriver/DafnyDriver.cs     |  121 ++-
 Source/DafnyExtension/DafnyDriver.cs  |    6 +-
 Test/dafny0/Extern.dfy                |   27 +
 Test/dafny0/Extern.dfy.expect         |    4 +
 Test/dafny0/Extern2.cs                |   14 +
 Test/dafny0/ExternHelloLibrary.cs     |   15 +
 Test/dafny0/ExternHelloLibrary.dll    |  Bin 0 -> 3072 bytes
 Test/dafny0/ExternNegative.dfy        |   26 +
 Test/dafny0/ExternNegative.dfy.expect |    3 +
 Test/dafny0/ExternNegative2.dfy       |   26 +
 17 files changed, 1407 insertions(+), 960 deletions(-)
 create mode 100644 Test/dafny0/Extern.dfy
 create mode 100644 Test/dafny0/Extern.dfy.expect
 create mode 100644 Test/dafny0/Extern2.cs
 create mode 100644 Test/dafny0/ExternHelloLibrary.cs
 create mode 100644 Test/dafny0/ExternHelloLibrary.dll
 create mode 100644 Test/dafny0/ExternNegative.dfy
 create mode 100644 Test/dafny0/ExternNegative.dfy.expect
 create mode 100644 Test/dafny0/ExternNegative2.dfy

(limited to 'Source/Dafny/Scanner.cs')

diff --git a/Source/Dafny/Compiler.cs b/Source/Dafny/Compiler.cs
index 1a99a8af..f5f95bd2 100644
--- a/Source/Dafny/Compiler.cs
+++ b/Source/Dafny/Compiler.cs
@@ -254,7 +254,7 @@ namespace Microsoft.Dafny {
           else if (d is ClassDecl) {
             var cl = (ClassDecl)d;
             Indent(indent, wr);
-            wr.Write("public class @{0}", cl.CompileName);
+            wr.Write("public partial class @{0}", cl.CompileName);
             if (cl.TypeArgs.Count != 0) {
               wr.Write("<{0}>", TypeParameters(cl.TypeArgs));
             }
diff --git a/Source/Dafny/Dafny.atg b/Source/Dafny/Dafny.atg
index 08c22db4..87e75541 100644
--- a/Source/Dafny/Dafny.atg
+++ b/Source/Dafny/Dafny.atg
@@ -23,10 +23,113 @@ readonly BuiltIns theBuiltIns;
 readonly bool theVerifyThisFile;
 int anonymousIds = 0;
 
-struct MemberModifiers {
+/// <summary>
+/// Holds the modifiers given for a declaration
+///
+/// Not all modifiers are applicable to all kinds of declarations.
+/// Errors are given when a modify does not apply.
+/// We also record the tokens for the specified modifiers so that
+/// they can be used in error messages.
+/// </summary>
+struct DeclModifierData {
+  public bool IsAbstract;
+  public IToken AbstractToken;
   public bool IsGhost;
+  public IToken GhostToken;
   public bool IsStatic;
+  public IToken StaticToken;
   public bool IsProtected;
+  public IToken ProtectedToken;
+  public bool IsExtern;
+  public IToken ExternToken;
+  public StringLiteralExpr ExternName;
+
+}
+
+// Check that token has not been set, then set it.
+public void CheckAndSetToken(ref IToken token)
+{
+    if (token != null) {
+      SemErr(t, "Duplicate declaration modifier: " + t.val);
+    }
+    token = t;
+}
+
+/// <summary>
+// A flags type used to tell what declaration modifiers are allowed for a declaration.
+/// </summary>
+[Flags]
+enum AllowedDeclModifiers {
+  None = 0,
+  Abstract = 1,
+  Ghost = 2,
+
+  // Means ghost not allowed because already implicitly ghost.
+  AlreadyGhost = 4,
+  Static = 8,
+  Protected = 16, 
+  Extern = 32
+};
+
+/// <summary>
+/// Check the declaration modifiers against those that are allowed.
+///
+/// The 'allowed' parameter specifies which declaratio modifiers are allowed.
+/// The 'declCaption' parameter should be a string describing the kind of declaration. 
+/// It is used in error messages.
+/// Any declaration modifiers that are present but not allowed are cleared.
+///</summary>
+void CheckDeclModifiers(DeclModifierData dmod, string declCaption, AllowedDeclModifiers allowed)
+{
+  if (dmod.IsAbstract && ((allowed & AllowedDeclModifiers.Abstract) == 0)) {
+    SemErr(dmod.AbstractToken, declCaption + " cannot be declared 'abstract'.");
+    dmod.IsAbstract = false;
+  }
+  if (dmod.IsGhost) {
+    if ((allowed & AllowedDeclModifiers.AlreadyGhost) != 0) {
+      SemErr(dmod.GhostToken, declCaption + " cannot be declared ghost (they are 'ghost' by default).");
+      dmod.IsGhost = false;
+    } else if ((allowed & AllowedDeclModifiers.Ghost) == 0) {
+      SemErr(dmod.GhostToken, declCaption + " cannot be declared 'ghost'.");
+      dmod.IsGhost = false;
+    }
+  }
+  if (dmod.IsStatic && ((allowed & AllowedDeclModifiers.Static) == 0)) {
+    SemErr(dmod.StaticToken, declCaption + " cannot be declared 'static'.");
+    dmod.IsStatic = false;
+  }
+  if (dmod.IsProtected && ((allowed & AllowedDeclModifiers.Protected) == 0)) {
+    SemErr(dmod.ProtectedToken, declCaption + " cannot be declared 'protected'.");
+    dmod.IsProtected = false;
+  }
+  if (dmod.IsExtern && ((allowed & AllowedDeclModifiers.Extern) == 0)) {
+    SemErr(dmod.ExternToken, declCaption + " cannot be declared 'extern'.");
+    dmod.IsExtern = false;
+  }
+}
+
+/// <summary>
+/// Encode an 'extern' declaration modifier as an {:extern name} attribute.
+///
+/// We also include an {:axiom} attribute since the specification of an
+/// external entity is assumed to hold, but only for methods or functions.
+///</summary>
+static void EncodeExternAsAttribute(DeclModifierData dmod, ref Attributes attrs, IToken/*!*/ id, bool needAxiom) {
+  if (dmod.IsExtern) {
+    StringLiteralExpr name = dmod.ExternName;
+    if (name == null) {
+      bool isVerbatimString = false;
+      name = new StringLiteralExpr(id, id.val, isVerbatimString);
+    }
+    var args = new List<Expression>();
+    args.Add(name);
+    attrs = new Attributes("extern", args, attrs);
+
+    // Also 'extern' implies 'axiom' for methods or functions.
+    if (needAxiom) {
+      attrs = new Attributes("axiom", new List<Expression>(), attrs);
+    }
+  }
 }
 
 ///<summary>
@@ -516,13 +619,10 @@ IGNORE cr + lf + tab
 /*------------------------------------------------------------------------*/
 PRODUCTIONS
 Dafny
-= (. ClassDecl/*!*/ c; DatatypeDecl/*!*/ dt; TopLevelDecl td; IteratorDecl iter;
-     List<MemberDecl/*!*/> membersDefaultClass = new List<MemberDecl/*!*/>();
-     ModuleDecl submodule;
+= (. List<MemberDecl/*!*/> membersDefaultClass = new List<MemberDecl/*!*/>();
      // to support multiple files, create a default module only if theModule is null
      DefaultModuleDecl defaultModule = (DefaultModuleDecl)((LiteralModuleDecl)theModule).ModuleDef;
      // theModule should be a DefaultModuleDecl (actually, the singular DefaultModuleDecl)
-	 TraitDecl/*!*/ trait;
      Contract.Assert(defaultModule != null);
   .)
   { "include" stringToken               (. {
@@ -540,15 +640,7 @@ Dafny
                                            }
                                         .)
   }
-  { SubModuleDecl<defaultModule, out submodule> (. defaultModule.TopLevelDecls.Add(submodule); .)
-  | ClassDecl<defaultModule, out c>             (. defaultModule.TopLevelDecls.Add(c); .)
-  | DatatypeDecl<defaultModule, out dt>         (. defaultModule.TopLevelDecls.Add(dt); .)
-  | NewtypeDecl<defaultModule, out td>          (. defaultModule.TopLevelDecls.Add(td); .)
-  | OtherTypeDecl<defaultModule, out td>        (. defaultModule.TopLevelDecls.Add(td); .)
-  | IteratorDecl<defaultModule, out iter>       (. defaultModule.TopLevelDecls.Add(iter); .)
-  | TraitDecl<defaultModule, out trait>    (. defaultModule.TopLevelDecls.Add(trait); .)
-  | ClassMemberDecl<membersDefaultClass, false, !DafnyOptions.O.AllowGlobals, false>
-  }
+  TopDecls<defaultModule, membersDefaultClass, /* isTopLevel */ true, /* isAbstract */ false>
   (. // find the default class in the default module, then append membersDefaultClass to its member list
      DefaultClassDecl defaultClass = null;
      foreach (TopLevelDecl topleveldecl in defaultModule.TopLevelDecls) {
@@ -564,43 +656,71 @@ Dafny
      } .)
   EOF
   .
-SubModuleDecl<ModuleDefinition parent, out ModuleDecl submodule>
-= (. ClassDecl/*!*/ c; DatatypeDecl/*!*/ dt; TopLevelDecl td; IteratorDecl iter;
-     Attributes attrs = null;  IToken/*!*/ id;
-     TraitDecl/*!*/ trait;
-	 List<MemberDecl/*!*/> namedModuleDefaultClassMembers = new List<MemberDecl>();;
+
+TopDecls<. ModuleDefinition module, List<MemberDecl/*!*/> membersDefaultClass, bool isTopLevel, bool isAbstract .>
+= { TopDecl<module, membersDefaultClass, isTopLevel, isAbstract> }
+  .
+
+DeclModifiers<out DeclModifierData dmod>
+= (. dmod = new DeclModifierData(); .)
+  { "abstract"                             (. dmod.IsAbstract = true;  CheckAndSetToken(ref dmod.AbstractToken); .)
+  | "ghost"                                (. dmod.IsGhost = true;  CheckAndSetToken(ref dmod.GhostToken); .)
+  | "static"                               (. dmod.IsStatic = true; CheckAndSetToken(ref dmod.StaticToken); .)
+  | "protected"                            (. dmod.IsProtected = true; CheckAndSetToken(ref dmod.ProtectedToken); .)
+  | "extern"                               (. dmod.IsExtern = true; CheckAndSetToken(ref dmod.ExternToken); .)
+    [ stringToken                          (. bool isVerbatimString;
+                                              string s = Util.RemoveParsedStringQuotes(t.val, out isVerbatimString);
+                                              dmod.ExternName = new StringLiteralExpr(t, s, isVerbatimString);
+                                           .)
+    ]
+  }
+  .
+
+TopDecl<. ModuleDefinition module, List<MemberDecl/*!*/> membersDefaultClass, bool isTopLevel, bool isAbstract .>
+= (. DeclModifierData dmod; ModuleDecl submodule;
+     ClassDecl/*!*/ c; DatatypeDecl/*!*/ dt; TopLevelDecl td; IteratorDecl iter;
+  	 TraitDecl/*!*/ trait;
+  .)
+  DeclModifiers<out dmod>
+  ( SubModuleDecl<dmod, module, out submodule> (. module.TopLevelDecls.Add(submodule); .)
+  | ClassDecl<dmod, module, out c>             (. module.TopLevelDecls.Add(c); .)
+  | DatatypeDecl<dmod, module, out dt>         (. module.TopLevelDecls.Add(dt); .)
+  | NewtypeDecl<dmod, module, out td>          (. module.TopLevelDecls.Add(td); .)
+  | OtherTypeDecl<dmod, module, out td>        (. module.TopLevelDecls.Add(td); .)
+  | IteratorDecl<dmod, module, out iter>       (. module.TopLevelDecls.Add(iter); .)
+  | TraitDecl<dmod, module, out trait>         (. module.TopLevelDecls.Add(trait); .)
+  | ClassMemberDecl<dmod, membersDefaultClass, false, !DafnyOptions.O.AllowGlobals, 
+                    !isTopLevel && DafnyOptions.O.IronDafny && isAbstract>
+  ) .
+
+SubModuleDecl<DeclModifierData dmod, ModuleDefinition parent, out ModuleDecl submodule>
+= (. Attributes attrs = null;  IToken/*!*/ id;
+	   List<MemberDecl/*!*/> namedModuleDefaultClassMembers = new List<MemberDecl>();;
      List<IToken> idRefined = null, idPath = null, idAssignment = null;
      ModuleDefinition module;
-     ModuleDecl sm;
      submodule = null; // appease compiler
-     bool isAbstract = false;
+     bool isAbstract = dmod.IsAbstract;
      bool isExclusively = false;
      bool opened = false;
+     CheckDeclModifiers(dmod, "Modules", AllowedDeclModifiers.Abstract | AllowedDeclModifiers.Extern);
   .)
-  ( [ "abstract"  (. isAbstract = true; .) ]
-    "module"
+  ( "module"
     { Attribute<ref attrs> }
     NoUSIdent<out id>
+    (. EncodeExternAsAttribute(dmod, ref attrs, id, /* needAxiom */ false); .)
 
       [ "exclusively" "refines" QualifiedModuleName<out idRefined> (. isExclusively = true; .)  
       | "refines" QualifiedModuleName<out idRefined> (. isExclusively = false; .) ] 
             (. module = new ModuleDefinition(id, id.val, isAbstract, false, isExclusively, idRefined == null ? null : idRefined, parent, attrs, false, this); .)  
        "{"                                             (. module.BodyStartTok = t; .)
-        { SubModuleDecl<module, out sm>                (. module.TopLevelDecls.Add(sm); .)
-        | ClassDecl<module, out c>                     (. module.TopLevelDecls.Add(c); .)
-        | TraitDecl<module, out trait>                 (. module.TopLevelDecls.Add(trait); .)
-		| DatatypeDecl<module, out dt>                 (. module.TopLevelDecls.Add(dt); .)
-        | NewtypeDecl<module, out td>                  (. module.TopLevelDecls.Add(td); .)
-        | OtherTypeDecl<module, out td>                (. module.TopLevelDecls.Add(td); .)
-        | IteratorDecl<module, out iter>               (. module.TopLevelDecls.Add(iter); .)
-        | ClassMemberDecl<namedModuleDefaultClassMembers, false, !DafnyOptions.O.AllowGlobals, DafnyOptions.O.IronDafny && isAbstract>
-        }
-      "}"                                  (. module.BodyEndTok = t;
+            TopDecls<module, namedModuleDefaultClassMembers, /* isTopLevel */ false, isAbstract>
+       "}"                                 (. module.BodyEndTok = t;
                                               module.TopLevelDecls.Add(new DefaultClassDecl(module, namedModuleDefaultClassMembers));
                                               submodule = new LiteralModuleDecl(module, parent); .)
   |
     "import" ["opened" (.opened = true;.)]
     NoUSIdent<out id>
+    (. EncodeExternAsAttribute(dmod, ref attrs, id, /* needAxiom */ false); .)
     [ "=" QualifiedModuleName<out idPath>
       (. submodule = new AliasModuleDecl(idPath, id, parent, opened); .)
     | "as" QualifiedModuleName<out idPath>  ["default" QualifiedModuleName<out idAssignment> ]
@@ -629,7 +749,7 @@ QualifiedModuleName<.out List<IToken> ids.>
   }
   .
 
-ClassDecl<ModuleDefinition/*!*/ module, out ClassDecl/*!*/ c>
+ClassDecl<DeclModifierData dmodClass, ModuleDefinition/*!*/ module, out ClassDecl/*!*/ c>
 = (. Contract.Requires(module != null);
      Contract.Ensures(Contract.ValueAtReturn(out c) != null);
      IToken/*!*/ id;
@@ -639,18 +759,21 @@ ClassDecl<ModuleDefinition/*!*/ module, out ClassDecl/*!*/ c>
      List<TypeParameter/*!*/> typeArgs = new List<TypeParameter/*!*/>();
      List<MemberDecl/*!*/> members = new List<MemberDecl/*!*/>();
      IToken bodyStart;
+     CheckDeclModifiers(dmodClass, "Classes", AllowedDeclModifiers.Extern);
+     DeclModifierData dmod; 
   .)
   SYNC
   "class"
   { Attribute<ref attrs> }
   NoUSIdent<out id>
+  (. EncodeExternAsAttribute(dmodClass, ref attrs, id, /* needAxiom */ false); .)
   [ GenericParameters<typeArgs> ]
   ["extends" 
   Type<out trait>		(. traits.Add(trait); .) 
   {"," Type<out trait>  (. traits.Add(trait); .) }
   ]         
   "{"                                            (. bodyStart = t;  .)
-  { ClassMemberDecl<members, true, false, false>
+  { DeclModifiers<out dmod> ClassMemberDecl<dmod, members, true, false, false>
   }
   "}"
   (. c = new ClassDecl(id, id.val, module, typeArgs, members, attrs, traits);
@@ -659,14 +782,16 @@ ClassDecl<ModuleDefinition/*!*/ module, out ClassDecl/*!*/ c>
   .)
   .
 
-    TraitDecl<ModuleDefinition/*!*/ module, out TraitDecl/*!*/ trait>
-  = (. Contract.Requires(module != null);
+TraitDecl<DeclModifierData dmodIn, ModuleDefinition/*!*/ module, out TraitDecl/*!*/ trait>
+  = (. Contract.Requires(module != null);     
+     CheckDeclModifiers(dmodIn, "Traits", AllowedDeclModifiers.None);
 	   Contract.Ensures(Contract.ValueAtReturn(out trait) != null);
 	   IToken/*!*/ id;
 	   Attributes attrs = null;
 	   List<TypeParameter/*!*/> typeArgs = new List<TypeParameter/*!*/>(); //traits should not support type parameters at the moment
 	   List<MemberDecl/*!*/> members = new List<MemberDecl/*!*/>();
 	   IToken bodyStart;
+     DeclModifierData dmod; 
     .)
 	SYNC
 	"trait"
@@ -674,7 +799,7 @@ ClassDecl<ModuleDefinition/*!*/ module, out ClassDecl/*!*/ c>
 	NoUSIdent<out id>
 	[ GenericParameters<typeArgs> ]
 	"{"                                            (. bodyStart = t; .)
-    { ClassMemberDecl<members, true, false, false>
+    { DeclModifiers<out dmod> ClassMemberDecl<dmod, members, true, false, false>
     }
     "}"
 	(. trait = new TraitDecl(id, id.val, module, typeArgs, members, attrs);
@@ -683,44 +808,33 @@ ClassDecl<ModuleDefinition/*!*/ module, out ClassDecl/*!*/ c>
     .)
 	.
 
-ClassMemberDecl<.List<MemberDecl> mm, bool allowConstructors, bool moduleLevelDecl, bool isWithinAbstractModule.>
+ClassMemberDecl<. DeclModifierData dmod, List<MemberDecl> mm, bool allowConstructors, bool moduleLevelDecl, bool isWithinAbstractModule.>
 = (. Contract.Requires(cce.NonNullElements(mm));
      Method/*!*/ m;
      Function/*!*/ f;
-     MemberModifiers mmod = new MemberModifiers();
-     IToken staticToken = null, protectedToken = null;
   .)
-  { "ghost"                                (. mmod.IsGhost = true; .)
-  | "static"                               (. mmod.IsStatic = true; staticToken = t; .)
-  | "protected"                            (. mmod.IsProtected = true; protectedToken = t; .)
-  }
   ( (. if (moduleLevelDecl) {
          SemErr(la, "fields are not allowed to be declared at the module level; instead, wrap the field in a 'class' declaration");
-         mmod.IsStatic = false;
-         mmod.IsProtected = false;
+         dmod.IsStatic = false;
        }
     .)
-    FieldDecl<mmod, mm>
+    FieldDecl<dmod, mm>
   | IF(IsFunctionDecl())
-    (. if (moduleLevelDecl && staticToken != null) {
-         errors.Warning(staticToken, "module-level functions are always non-instance, so the 'static' keyword is not allowed here");
-         mmod.IsStatic = false;
+    (. if (moduleLevelDecl && dmod.StaticToken != null) {
+         errors.Warning(dmod.StaticToken, "module-level functions are always non-instance, so the 'static' keyword is not allowed here");
+         dmod.IsStatic = false;
        }
     .)
-    FunctionDecl<mmod, isWithinAbstractModule, out f>                   (. mm.Add(f); .)
-  | (. if (moduleLevelDecl && staticToken != null) {
-         errors.Warning(staticToken, "module-level methods are always non-instance, so the 'static' keyword is not allowed here");
-         mmod.IsStatic = false;
-       }
-       if (protectedToken != null) {
-         SemErr(protectedToken, "only functions, not methods, can be declared 'protected'");
-         mmod.IsProtected = false;
+    FunctionDecl<dmod, isWithinAbstractModule, out f>                   (. mm.Add(f); .)
+  | (. if (moduleLevelDecl && dmod.StaticToken != null) {
+         errors.Warning(dmod.StaticToken, "module-level methods are always non-instance, so the 'static' keyword is not allowed here");
+         dmod.IsStatic = false;
        }
     .)
-    MethodDecl<mmod, allowConstructors, isWithinAbstractModule, out m>  (. mm.Add(m); .)
+    MethodDecl<dmod, allowConstructors, isWithinAbstractModule, out m>  (. mm.Add(m); .)
   )
   .
-DatatypeDecl<ModuleDefinition/*!*/ module, out DatatypeDecl/*!*/ dt>
+DatatypeDecl<DeclModifierData dmod, ModuleDefinition/*!*/ module, out DatatypeDecl/*!*/ dt>
 = (. Contract.Requires(module != null);
      Contract.Ensures(Contract.ValueAtReturn(out dt)!=null);
      IToken/*!*/ id;
@@ -729,6 +843,7 @@ DatatypeDecl<ModuleDefinition/*!*/ module, out DatatypeDecl/*!*/ dt>
      List<DatatypeCtor/*!*/> ctors = new List<DatatypeCtor/*!*/>();
      IToken bodyStart = Token.NoToken;  // dummy assignment
      bool co = false;
+     CheckDeclModifiers(dmod, "Datatypes or codatatypes", AllowedDeclModifiers.None);
   .)
   SYNC
   ( "datatype"
@@ -766,27 +881,27 @@ DatatypeMemberDecl<.List<DatatypeCtor/*!*/>/*!*/ ctors.>
   [ FormalsOptionalIds<formals> ]
   (. ctors.Add(new DatatypeCtor(id, id.val, formals, attrs)); .)
   .
-FieldDecl<.MemberModifiers mmod, List<MemberDecl/*!*/>/*!*/ mm.>
+FieldDecl<.DeclModifierData dmod, List<MemberDecl/*!*/>/*!*/ mm.>
 = (. Contract.Requires(cce.NonNullElements(mm));
      Attributes attrs = null;
      IToken/*!*/ id;  Type/*!*/ ty;
+     CheckDeclModifiers(dmod, "Fields", AllowedDeclModifiers.Ghost);
   .)
   SYNC
   "var"
-  (. if (mmod.IsStatic) { SemErr(t, "fields cannot be declared 'static'"); }
-  .)
   { Attribute<ref attrs> }
-  FIdentType<out id, out ty>                        (. mm.Add(new Field(id, id.val, mmod.IsGhost, ty, attrs)); .)
-  { "," FIdentType<out id, out ty>                  (. mm.Add(new Field(id, id.val, mmod.IsGhost, ty, attrs)); .)
+  FIdentType<out id, out ty>                        (. mm.Add(new Field(id, id.val, dmod.IsGhost, ty, attrs)); .)
+  { "," FIdentType<out id, out ty>                  (. mm.Add(new Field(id, id.val, dmod.IsGhost, ty, attrs)); .)
   }
   OldSemi
   .
-NewtypeDecl<ModuleDefinition module, out TopLevelDecl td>
+NewtypeDecl<DeclModifierData dmod, ModuleDefinition module, out TopLevelDecl td>
 = (. IToken id, bvId;
      Attributes attrs = null;
      td = null;
      Type baseType = null;
      Expression wh;
+     CheckDeclModifiers(dmod, "Newtypes", AllowedDeclModifiers.None);
   .)
   "newtype"
   { Attribute<ref attrs> }
@@ -800,13 +915,14 @@ NewtypeDecl<ModuleDefinition module, out TopLevelDecl td>
   | Type<out baseType>               (. td = new NewtypeDecl(theVerifyThisFile ? id : new IncludeToken(id), id.val, module, baseType, attrs); .)
   )
   .
-OtherTypeDecl<ModuleDefinition module, out TopLevelDecl td>
+OtherTypeDecl<DeclModifierData dmod, ModuleDefinition module, out TopLevelDecl td>
 = (. IToken id;
      Attributes attrs = null;
      var eqSupport = TypeParameter.EqualitySupportValue.Unspecified;
      var typeArgs = new List<TypeParameter>();
      td = null;
      Type ty;
+     CheckDeclModifiers(dmod, "Type aliases", AllowedDeclModifiers.None);
   .)
   "type"
   { Attribute<ref attrs> }
@@ -902,7 +1018,7 @@ TypeIdentOptional<out IToken/*!*/ id, out string/*!*/ identName, out Type/*!*/ t
   .)
   .
 /*------------------------------------------------------------------------*/
-IteratorDecl<ModuleDefinition module, out IteratorDecl/*!*/ iter>
+IteratorDecl<DeclModifierData dmod, ModuleDefinition module, out IteratorDecl/*!*/ iter>
 = (. Contract.Ensures(Contract.ValueAtReturn(out iter) != null);
      IToken/*!*/ id;
      Attributes attrs = null;
@@ -924,6 +1040,7 @@ IteratorDecl<ModuleDefinition module, out IteratorDecl/*!*/ iter>
      IToken signatureEllipsis = null;
      IToken bodyStart = Token.NoToken;
      IToken bodyEnd = Token.NoToken;
+     CheckDeclModifiers(dmod, "Iterators", AllowedDeclModifiers.None);
   .)
   SYNC
   "iterator"
@@ -969,7 +1086,7 @@ GenericParameters<.List<TypeParameter/*!*/>/*!*/ typeArgs.>
   ">"
   .
 /*------------------------------------------------------------------------*/
-MethodDecl<MemberModifiers mmod, bool allowConstructor, bool isWithinAbstractModule, out Method/*!*/ m>
+MethodDecl<DeclModifierData dmod, bool allowConstructor, bool isWithinAbstractModule, out Method/*!*/ m>
 = (. Contract.Ensures(Contract.ValueAtReturn(out m) !=null);
      IToken/*!*/ id = Token.NoToken;
      bool hasName = false;  IToken keywordToken;
@@ -991,43 +1108,36 @@ MethodDecl<MemberModifiers mmod, bool allowConstructor, bool isWithinAbstractMod
      IToken signatureEllipsis = null;
      IToken bodyStart = Token.NoToken;
      IToken bodyEnd = Token.NoToken;
+     AllowedDeclModifiers allowed = AllowedDeclModifiers.None;
+     string caption = "";
   .)
   SYNC
-  ( "method"
-  | "lemma"                         (. isLemma = true; .)
-  | "colemma"                       (. isCoLemma = true; .)
-  | "comethod"                      (. isCoLemma = true;
+  ( "method"                        (. caption = "Methods";
+                                       allowed = AllowedDeclModifiers.Ghost | AllowedDeclModifiers.Static 
+                                         | AllowedDeclModifiers.Extern; .)
+  | "lemma"                         (. isLemma = true; caption = "Lemmas";
+                                       allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static 
+                                         | AllowedDeclModifiers.Protected; .)
+  | "colemma"                       (. isCoLemma = true; caption = "Colemmas";
+                                       allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static 
+                                         | AllowedDeclModifiers.Protected; .)
+  | "comethod"                      (. isCoLemma = true; caption = "Comethods";
+                                       allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static 
+                                         | AllowedDeclModifiers.Protected;
                                        errors.Warning(t, "the 'comethod' keyword has been deprecated; it has been renamed to 'colemma'");
                                     .)
-  | "inductive" "lemma"             (. isIndLemma = true; .)
+  | "inductive" "lemma"             (. isIndLemma = true;  caption = "Inductive lemmas";
+                                       allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static;.)
   | "constructor"                   (. if (allowConstructor) {
                                          isConstructor = true;
                                        } else {
                                          SemErr(t, "constructors are allowed only in classes");
-                                       }
+                                       } 
+                                       caption = "Constructors";
+                                       allowed = AllowedDeclModifiers.None;
                                     .)
-  )                                 (. keywordToken = t; .)
-  (. if (isLemma) {
-       if (mmod.IsGhost) {
-         SemErr(t, "lemmas cannot be declared 'ghost' (they are automatically 'ghost')");
-       }
-     } else if (isConstructor) {
-       if (mmod.IsGhost) {
-         SemErr(t, "constructors cannot be declared 'ghost'");
-       }
-       if (mmod.IsStatic) {
-         SemErr(t, "constructors cannot be declared 'static'");
-       }
-     } else if (isIndLemma) {
-       if (mmod.IsGhost) {
-         SemErr(t, "inductive lemmas cannot be declared 'ghost' (they are automatically 'ghost')");
-       }
-     } else if (isCoLemma) {
-       if (mmod.IsGhost) {
-         SemErr(t, "colemmas cannot be declared 'ghost' (they are automatically 'ghost')");
-       }
-     }
-  .)
+  )                                 (. keywordToken = t; 
+                                       CheckDeclModifiers(dmod, caption, allowed); .)
   { Attribute<ref attrs> }
   [ NoUSIdent<out id>               (. hasName = true; .)
   ]
@@ -1037,12 +1147,13 @@ MethodDecl<MemberModifiers mmod, bool allowConstructor, bool isWithinAbstractMod
          SemErr(la, "a method must be given a name (expecting identifier)");
        }
      }
+     EncodeExternAsAttribute(dmod, ref attrs, id, /* needAxiom */ true);
   .)
   (
     [ GenericParameters<typeArgs> ]
-    Formals<true, !mmod.IsGhost, ins>
+    Formals<true, !dmod.IsGhost, ins>
     [ "returns"                                 (. if (isConstructor) { SemErr(t, "constructors cannot have out-parameters"); } .)
-      Formals<false, !mmod.IsGhost, outs>
+      Formals<false, !dmod.IsGhost, outs>
     ]
   | "..."                                       (. signatureEllipsis = t; .)
   )
@@ -1059,16 +1170,16 @@ MethodDecl<MemberModifiers mmod, bool allowConstructor, bool isWithinAbstractMod
        m = new Constructor(tok, hasName ? id.val : "_ctor", typeArgs, ins,
                            req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
      } else if (isIndLemma) {
-       m = new InductiveLemma(tok, id.val, mmod.IsStatic, typeArgs, ins, outs,
+       m = new InductiveLemma(tok, id.val, dmod.IsStatic, typeArgs, ins, outs,
                               req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
      } else if (isCoLemma) {
-       m = new CoLemma(tok, id.val, mmod.IsStatic, typeArgs, ins, outs,
+       m = new CoLemma(tok, id.val, dmod.IsStatic, typeArgs, ins, outs,
                        req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
      } else if (isLemma) {
-       m = new Lemma(tok, id.val, mmod.IsStatic, typeArgs, ins, outs,
+       m = new Lemma(tok, id.val, dmod.IsStatic, typeArgs, ins, outs,
                      req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
      } else {
-       m = new Method(tok, id.val, mmod.IsStatic, mmod.IsGhost, typeArgs, ins, outs,
+       m = new Method(tok, id.val, dmod.IsStatic, dmod.IsGhost, typeArgs, ins, outs,
                       req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
      }
      m.BodyStartTok = bodyStart;
@@ -1273,7 +1384,7 @@ GenericInstantiation<.List<Type/*!*/>/*!*/ gt.>
   ">"
   .
 /*------------------------------------------------------------------------*/
-FunctionDecl<MemberModifiers mmod, bool isWithinAbstractModule, out Function/*!*/ f>
+FunctionDecl<DeclModifierData dmod, bool isWithinAbstractModule, out Function/*!*/ f>
 = (. Contract.Ensures(Contract.ValueAtReturn(out f)!=null);
      Attributes attrs = null;
      IToken/*!*/ id = Token.NoToken;  // to please compiler
@@ -1296,7 +1407,13 @@ FunctionDecl<MemberModifiers mmod, bool isWithinAbstractModule, out Function/*!*
   ( "function"
     [ "method"                 (. isFunctionMethod = true; .)
     ]
-    (. if (mmod.IsGhost) { SemErr(t, "functions cannot be declared 'ghost' (they are ghost by default)"); }
+    (. AllowedDeclModifiers allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static | AllowedDeclModifiers.Protected;
+       string caption = "Functions";
+       if (isFunctionMethod) { 
+         allowed |= AllowedDeclModifiers.Extern; 
+         caption = "Function methods";
+       }
+       CheckDeclModifiers(dmod, caption, allowed);
     .)
     { Attribute<ref attrs> }
     NoUSIdent<out id>
@@ -1312,7 +1429,13 @@ FunctionDecl<MemberModifiers mmod, bool isWithinAbstractModule, out Function/*!*
   | "predicate"                (. isPredicate = true; .)
     [ "method"                 (. isFunctionMethod = true; .)
     ]
-    (. if (mmod.IsGhost) { SemErr(t, "predicates cannot be declared 'ghost' (they are ghost by default)"); }
+    (. AllowedDeclModifiers allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static | AllowedDeclModifiers.Protected;
+       string caption = "Predicates";
+       if (isFunctionMethod) { 
+         allowed |= AllowedDeclModifiers.Extern; 
+         caption = "Predicate methods";
+       }
+       CheckDeclModifiers(dmod, caption, allowed);
     .)
     { Attribute<ref attrs> }
     NoUSIdent<out id>
@@ -1327,7 +1450,8 @@ FunctionDecl<MemberModifiers mmod, bool isWithinAbstractModule, out Function/*!*
 
   /* ----- inductive predicate ----- */
   | "inductive" "predicate"    (. isIndPredicate = true; .)
-    (. if (mmod.IsGhost) { SemErr(t, "inductive predicates cannot be declared 'ghost' (they are ghost by default)"); }
+    (. CheckDeclModifiers(dmod, "Inductive predicates",
+         AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static | AllowedDeclModifiers.Protected);
     .)
     { Attribute<ref attrs> }
     NoUSIdent<out id>
@@ -1341,7 +1465,8 @@ FunctionDecl<MemberModifiers mmod, bool isWithinAbstractModule, out Function/*!*
 
   /* ----- copredicate ----- */
   | "copredicate"              (. isCoPredicate = true; .)
-    (. if (mmod.IsGhost) { SemErr(t, "copredicates cannot be declared 'ghost' (they are ghost by default)"); }
+    (. CheckDeclModifiers(dmod, "Copredicates",
+         AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static | AllowedDeclModifiers.Protected);
     .)
     { Attribute<ref attrs> }
     NoUSIdent<out id>
@@ -1358,22 +1483,23 @@ FunctionDecl<MemberModifiers mmod, bool isWithinAbstractModule, out Function/*!*
   { FunctionSpec<reqs, reads, ens, decreases> }
   [ FunctionBody<out body, out bodyStart, out bodyEnd>
   ]
-  (. if (!isWithinAbstractModule && DafnyOptions.O.DisallowSoundnessCheating && body == null && ens.Count > 0 && !Attributes.Contains(attrs, "axiom") && !Attributes.Contains(attrs, "imported")) {
+  (. if (!isWithinAbstractModule && DafnyOptions.O.DisallowSoundnessCheating && body == null && ens.Count > 0 &&
+         !Attributes.Contains(attrs, "axiom") && !Attributes.Contains(attrs, "imported")) {
         SemErr(t, "a function with an ensures clause must have a body, unless given the :axiom attribute");
      }
-
+     EncodeExternAsAttribute(dmod, ref attrs, id, /* needAxiom */ true);
      IToken tok = theVerifyThisFile ? id : new IncludeToken(id);
      if (isPredicate) {
-        f = new Predicate(tok, id.val, mmod.IsStatic, mmod.IsProtected, !isFunctionMethod, typeArgs, formals,
+        f = new Predicate(tok, id.val, dmod.IsStatic, dmod.IsProtected, !isFunctionMethod, typeArgs, formals,
                           reqs, reads, ens, new Specification<Expression>(decreases, null), body, Predicate.BodyOriginKind.OriginalOrInherited, attrs, signatureEllipsis);
      } else if (isIndPredicate) {
-        f = new InductivePredicate(tok, id.val, mmod.IsStatic, mmod.IsProtected, typeArgs, formals,
+        f = new InductivePredicate(tok, id.val, dmod.IsStatic, dmod.IsProtected, typeArgs, formals,
                                    reqs, reads, ens, body, attrs, signatureEllipsis);
      } else if (isCoPredicate) {
-        f = new CoPredicate(tok, id.val, mmod.IsStatic, mmod.IsProtected, typeArgs, formals,
+        f = new CoPredicate(tok, id.val, dmod.IsStatic, dmod.IsProtected, typeArgs, formals,
                             reqs, reads, ens, body, attrs, signatureEllipsis);
      } else {
-        f = new Function(tok, id.val, mmod.IsStatic, mmod.IsProtected, !isFunctionMethod, typeArgs, formals, returnType,
+        f = new Function(tok, id.val, dmod.IsStatic, dmod.IsProtected, !isFunctionMethod, typeArgs, formals, returnType,
                          reqs, reads, ens, new Specification<Expression>(decreases, null), body, attrs, signatureEllipsis);
      }
      f.BodyStartTok = bodyStart;
diff --git a/Source/Dafny/DafnyAst.cs b/Source/Dafny/DafnyAst.cs
index 4c1e2bd7..a51e30de 100644
--- a/Source/Dafny/DafnyAst.cs
+++ b/Source/Dafny/DafnyAst.cs
@@ -1059,7 +1059,7 @@ namespace Microsoft.Dafny {
     public virtual string FullCompileName {
       get {
         if (ResolvedClass != null && !ResolvedClass.Module.IsDefaultModule) {
-          return ResolvedClass.Module.CompileName + ".@" + CompileName;
+          return ResolvedClass.Module.CompileName + ".@" + ResolvedClass.CompileName;
         } else {
           return CompileName;
         }
@@ -1536,7 +1536,17 @@ namespace Microsoft.Dafny {
     public virtual string CompileName {
       get {
         if (compileName == null) {
-          compileName = NonglobalVariable.CompilerizeName(Name);
+          object externValue = "";
+          string errorMessage = "";
+          bool isExternal = Attributes.ContainsMatchingValue(this.Attributes, "extern", ref externValue,
+            new Attributes.MatchingValueOption[] { Attributes.MatchingValueOption.String },
+            err => errorMessage = err);
+          if (isExternal) {
+            compileName = (string)externValue;
+          }
+          else {
+            compileName = NonglobalVariable.CompilerizeName(Name);
+          }
         }
         return compileName;
       }
@@ -1835,10 +1845,19 @@ namespace Microsoft.Dafny {
     public string CompileName {
       get {
         if (compileName == null) {
-          if (IsBuiltinName)
-            compileName = Name;
-          else
-            compileName = "_" + Height.ToString() + "_" + NonglobalVariable.CompilerizeName(Name);
+          object externValue = "";
+          string errorMessage = "";
+          bool isExternal = Attributes.ContainsMatchingValue(this.Attributes, "extern", ref externValue,
+            new Attributes.MatchingValueOption[] { Attributes.MatchingValueOption.String },
+            err => errorMessage = err);
+          if (isExternal) {
+            compileName = (string)externValue;
+          } else {
+            if (IsBuiltinName)
+              compileName = Name;
+            else
+              compileName = "_" + Height.ToString() + "_" + NonglobalVariable.CompilerizeName(Name);
+          }
         }
         return compileName;
       }
diff --git a/Source/Dafny/Makefile b/Source/Dafny/Makefile
index 68ab7a2d..a61539b0 100644
--- a/Source/Dafny/Makefile
+++ b/Source/Dafny/Makefile
@@ -4,8 +4,8 @@
 # from http://boogiepartners.codeplex.com/. Update the FRAME_DIR variable to
 # point to whatever directory you install that into.
 # ###############################################################################
-COCO_EXE_DIR = ..\..\..\boogie-partners\CocoR\bin
-FRAME_DIR = ..\..\..\boogie-partners\CocoR\Modified
+COCO_EXE_DIR = ..\..\..\coco
+FRAME_DIR = ..\..\..\boogiepartners\CocoR\Modified
 COCO = $(COCO_EXE_DIR)\Coco.exe
 
 # "all" depends on 2 files, really (Parser.cs and Scanner.cs), but they
diff --git a/Source/Dafny/Parser.cs b/Source/Dafny/Parser.cs
index 922aad75..dc661fc5 100644
--- a/Source/Dafny/Parser.cs
+++ b/Source/Dafny/Parser.cs
@@ -73,7 +73,7 @@ public class Parser {
 	public const int _star = 57;
 	public const int _notIn = 58;
 	public const int _ellipsis = 59;
-	public const int maxT = 138;
+	public const int maxT = 139;
 
 	const bool _T = true;
 	const bool _x = false;
@@ -95,10 +95,113 @@ readonly BuiltIns theBuiltIns;
 readonly bool theVerifyThisFile;
 int anonymousIds = 0;
 
-struct MemberModifiers {
+/// <summary>
+/// Holds the modifiers given for a declaration
+///
+/// Not all modifiers are applicable to all kinds of declarations.
+/// Errors are given when a modify does not apply.
+/// We also record the tokens for the specified modifiers so that
+/// they can be used in error messages.
+/// </summary>
+struct DeclModifierData {
+  public bool IsAbstract;
+  public IToken AbstractToken;
   public bool IsGhost;
+  public IToken GhostToken;
   public bool IsStatic;
+  public IToken StaticToken;
   public bool IsProtected;
+  public IToken ProtectedToken;
+  public bool IsExtern;
+  public IToken ExternToken;
+  public StringLiteralExpr ExternName;
+
+}
+
+// Check that token has not been set, then set it.
+public void CheckAndSetToken(ref IToken token)
+{
+    if (token != null) {
+      SemErr(t, "Duplicate declaration modifier: " + t.val);
+    }
+    token = t;
+}
+
+/// <summary>
+// A flags type used to tell what declaration modifiers are allowed for a declaration.
+/// </summary>
+[Flags]
+enum AllowedDeclModifiers {
+  None = 0,
+  Abstract = 1,
+  Ghost = 2,
+
+  // Means ghost not allowed because already implicitly ghost.
+  AlreadyGhost = 4,
+  Static = 8,
+  Protected = 16, 
+  Extern = 32
+};
+
+/// <summary>
+/// Check the declaration modifiers against those that are allowed.
+///
+/// The 'allowed' parameter specifies which declaratio modifiers are allowed.
+/// The 'declCaption' parameter should be a string describing the kind of declaration. 
+/// It is used in error messages.
+/// Any declaration modifiers that are present but not allowed are cleared.
+///</summary>
+void CheckDeclModifiers(DeclModifierData dmod, string declCaption, AllowedDeclModifiers allowed)
+{
+  if (dmod.IsAbstract && ((allowed & AllowedDeclModifiers.Abstract) == 0)) {
+    SemErr(dmod.AbstractToken, declCaption + " cannot be declared 'abstract'.");
+    dmod.IsAbstract = false;
+  }
+  if (dmod.IsGhost) {
+    if ((allowed & AllowedDeclModifiers.AlreadyGhost) != 0) {
+      SemErr(dmod.GhostToken, declCaption + " cannot be declared ghost (they are 'ghost' by default).");
+      dmod.IsGhost = false;
+    } else if ((allowed & AllowedDeclModifiers.Ghost) == 0) {
+      SemErr(dmod.GhostToken, declCaption + " cannot be declared 'ghost'.");
+      dmod.IsGhost = false;
+    }
+  }
+  if (dmod.IsStatic && ((allowed & AllowedDeclModifiers.Static) == 0)) {
+    SemErr(dmod.StaticToken, declCaption + " cannot be declared 'static'.");
+    dmod.IsStatic = false;
+  }
+  if (dmod.IsProtected && ((allowed & AllowedDeclModifiers.Protected) == 0)) {
+    SemErr(dmod.ProtectedToken, declCaption + " cannot be declared 'protected'.");
+    dmod.IsProtected = false;
+  }
+  if (dmod.IsExtern && ((allowed & AllowedDeclModifiers.Extern) == 0)) {
+    SemErr(dmod.ExternToken, declCaption + " cannot be declared 'extern'.");
+    dmod.IsExtern = false;
+  }
+}
+
+/// <summary>
+/// Encode an 'extern' declaration modifier as an {:extern name} attribute.
+///
+/// We also include an {:axiom} attribute since the specification of an
+/// external entity is assumed to hold, but only for methods or functions.
+///</summary>
+static void EncodeExternAsAttribute(DeclModifierData dmod, ref Attributes attrs, IToken/*!*/ id, bool needAxiom) {
+  if (dmod.IsExtern) {
+    StringLiteralExpr name = dmod.ExternName;
+    if (name == null) {
+      bool isVerbatimString = false;
+      name = new StringLiteralExpr(id, id.val, isVerbatimString);
+    }
+    var args = new List<Expression>();
+    args.Add(name);
+    attrs = new Attributes("extern", args, attrs);
+
+    // Also 'extern' implies 'axiom' for methods or functions.
+    if (needAxiom) {
+      attrs = new Attributes("axiom", new List<Expression>(), attrs);
+    }
+  }
 }
 
 ///<summary>
@@ -543,13 +646,10 @@ bool IsType(ref IToken pt) {
 
 
 	void Dafny() {
-		ClassDecl/*!*/ c; DatatypeDecl/*!*/ dt; TopLevelDecl td; IteratorDecl iter;
 		List<MemberDecl/*!*/> membersDefaultClass = new List<MemberDecl/*!*/>();
-		ModuleDecl submodule;
 		// to support multiple files, create a default module only if theModule is null
 		DefaultModuleDecl defaultModule = (DefaultModuleDecl)((LiteralModuleDecl)theModule).ModuleDef;
 		// theModule should be a DefaultModuleDecl (actually, the singular DefaultModuleDecl)
-		TraitDecl/*!*/ trait;
 		Contract.Assert(defaultModule != null);
 		
 		while (la.kind == 60) {
@@ -570,49 +670,7 @@ bool IsType(ref IToken pt) {
 			}
 			
 		}
-		while (StartOf(1)) {
-			switch (la.kind) {
-			case 61: case 62: case 65: {
-				SubModuleDecl(defaultModule, out submodule);
-				defaultModule.TopLevelDecls.Add(submodule); 
-				break;
-			}
-			case 70: {
-				ClassDecl(defaultModule, out c);
-				defaultModule.TopLevelDecls.Add(c); 
-				break;
-			}
-			case 76: case 77: {
-				DatatypeDecl(defaultModule, out dt);
-				defaultModule.TopLevelDecls.Add(dt); 
-				break;
-			}
-			case 79: {
-				NewtypeDecl(defaultModule, out td);
-				defaultModule.TopLevelDecls.Add(td); 
-				break;
-			}
-			case 80: {
-				OtherTypeDecl(defaultModule, out td);
-				defaultModule.TopLevelDecls.Add(td); 
-				break;
-			}
-			case 81: {
-				IteratorDecl(defaultModule, out iter);
-				defaultModule.TopLevelDecls.Add(iter); 
-				break;
-			}
-			case 72: {
-				TraitDecl(defaultModule, out trait);
-				defaultModule.TopLevelDecls.Add(trait); 
-				break;
-			}
-			case 38: case 39: case 40: case 41: case 42: case 73: case 74: case 75: case 78: case 84: case 85: case 86: case 87: {
-				ClassMemberDecl(membersDefaultClass, false, !DafnyOptions.O.AllowGlobals, false);
-				break;
-			}
-			}
-		}
+		TopDecls(defaultModule, membersDefaultClass, /* isTopLevel */ true, /* isAbstract */ false);
 		DefaultClassDecl defaultClass = null;
 		foreach (TopLevelDecl topleveldecl in defaultModule.TopLevelDecls) {
 		 defaultClass = topleveldecl as DefaultClassDecl;
@@ -628,33 +686,114 @@ bool IsType(ref IToken pt) {
 		Expect(0);
 	}
 
-	void SubModuleDecl(ModuleDefinition parent, out ModuleDecl submodule) {
+	void TopDecls(ModuleDefinition module, List<MemberDecl/*!*/> membersDefaultClass, bool isTopLevel, bool isAbstract ) {
+		while (StartOf(1)) {
+			TopDecl(module, membersDefaultClass, isTopLevel, isAbstract);
+		}
+	}
+
+	void TopDecl(ModuleDefinition module, List<MemberDecl/*!*/> membersDefaultClass, bool isTopLevel, bool isAbstract ) {
+		DeclModifierData dmod; ModuleDecl submodule;
 		ClassDecl/*!*/ c; DatatypeDecl/*!*/ dt; TopLevelDecl td; IteratorDecl iter;
-		Attributes attrs = null;  IToken/*!*/ id;
 		TraitDecl/*!*/ trait;
+		
+		DeclModifiers(out dmod);
+		switch (la.kind) {
+		case 66: case 69: {
+			SubModuleDecl(dmod, module, out submodule);
+			module.TopLevelDecls.Add(submodule); 
+			break;
+		}
+		case 74: {
+			ClassDecl(dmod, module, out c);
+			module.TopLevelDecls.Add(c); 
+			break;
+		}
+		case 77: case 78: {
+			DatatypeDecl(dmod, module, out dt);
+			module.TopLevelDecls.Add(dt); 
+			break;
+		}
+		case 80: {
+			NewtypeDecl(dmod, module, out td);
+			module.TopLevelDecls.Add(td); 
+			break;
+		}
+		case 81: {
+			OtherTypeDecl(dmod, module, out td);
+			module.TopLevelDecls.Add(td); 
+			break;
+		}
+		case 82: {
+			IteratorDecl(dmod, module, out iter);
+			module.TopLevelDecls.Add(iter); 
+			break;
+		}
+		case 76: {
+			TraitDecl(dmod, module, out trait);
+			module.TopLevelDecls.Add(trait); 
+			break;
+		}
+		case 38: case 39: case 40: case 41: case 42: case 79: case 85: case 86: case 87: case 88: {
+			ClassMemberDecl(dmod, membersDefaultClass, false, !DafnyOptions.O.AllowGlobals, 
+!isTopLevel && DafnyOptions.O.IronDafny && isAbstract);
+			break;
+		}
+		default: SynErr(140); break;
+		}
+	}
+
+	void DeclModifiers(out DeclModifierData dmod) {
+		dmod = new DeclModifierData(); 
+		while (StartOf(2)) {
+			if (la.kind == 61) {
+				Get();
+				dmod.IsAbstract = true;  CheckAndSetToken(ref dmod.AbstractToken); 
+			} else if (la.kind == 62) {
+				Get();
+				dmod.IsGhost = true;  CheckAndSetToken(ref dmod.GhostToken); 
+			} else if (la.kind == 63) {
+				Get();
+				dmod.IsStatic = true; CheckAndSetToken(ref dmod.StaticToken); 
+			} else if (la.kind == 64) {
+				Get();
+				dmod.IsProtected = true; CheckAndSetToken(ref dmod.ProtectedToken); 
+			} else {
+				Get();
+				dmod.IsExtern = true; CheckAndSetToken(ref dmod.ExternToken); 
+				if (la.kind == 20) {
+					Get();
+					bool isVerbatimString;
+					string s = Util.RemoveParsedStringQuotes(t.val, out isVerbatimString);
+					dmod.ExternName = new StringLiteralExpr(t, s, isVerbatimString);
+					
+				}
+			}
+		}
+	}
+
+	void SubModuleDecl(DeclModifierData dmod, ModuleDefinition parent, out ModuleDecl submodule) {
+		Attributes attrs = null;  IToken/*!*/ id;
 		List<MemberDecl/*!*/> namedModuleDefaultClassMembers = new List<MemberDecl>();;
 		List<IToken> idRefined = null, idPath = null, idAssignment = null;
 		ModuleDefinition module;
-		ModuleDecl sm;
 		submodule = null; // appease compiler
-		bool isAbstract = false;
+		bool isAbstract = dmod.IsAbstract;
 		bool isExclusively = false;
 		bool opened = false;
+		CheckDeclModifiers(dmod, "Modules", AllowedDeclModifiers.Abstract | AllowedDeclModifiers.Extern);
 		
-		if (la.kind == 61 || la.kind == 62) {
-			if (la.kind == 61) {
-				Get();
-				isAbstract = true; 
-			}
-			Expect(62);
+		if (la.kind == 66) {
+			Get();
 			while (la.kind == 46) {
 				Attribute(ref attrs);
 			}
 			NoUSIdent(out id);
-			if (la.kind == 63 || la.kind == 64) {
-				if (la.kind == 63) {
+			EncodeExternAsAttribute(dmod, ref attrs, id, /* needAxiom */ false); 
+			if (la.kind == 67 || la.kind == 68) {
+				if (la.kind == 67) {
 					Get();
-					Expect(64);
+					Expect(68);
 					QualifiedModuleName(out idRefined);
 					isExclusively = true; 
 				} else {
@@ -666,69 +805,28 @@ bool IsType(ref IToken pt) {
 			module = new ModuleDefinition(id, id.val, isAbstract, false, isExclusively, idRefined == null ? null : idRefined, parent, attrs, false, this); 
 			Expect(46);
 			module.BodyStartTok = t; 
-			while (StartOf(1)) {
-				switch (la.kind) {
-				case 61: case 62: case 65: {
-					SubModuleDecl(module, out sm);
-					module.TopLevelDecls.Add(sm); 
-					break;
-				}
-				case 70: {
-					ClassDecl(module, out c);
-					module.TopLevelDecls.Add(c); 
-					break;
-				}
-				case 72: {
-					TraitDecl(module, out trait);
-					module.TopLevelDecls.Add(trait); 
-					break;
-				}
-				case 76: case 77: {
-					DatatypeDecl(module, out dt);
-					module.TopLevelDecls.Add(dt); 
-					break;
-				}
-				case 79: {
-					NewtypeDecl(module, out td);
-					module.TopLevelDecls.Add(td); 
-					break;
-				}
-				case 80: {
-					OtherTypeDecl(module, out td);
-					module.TopLevelDecls.Add(td); 
-					break;
-				}
-				case 81: {
-					IteratorDecl(module, out iter);
-					module.TopLevelDecls.Add(iter); 
-					break;
-				}
-				case 38: case 39: case 40: case 41: case 42: case 73: case 74: case 75: case 78: case 84: case 85: case 86: case 87: {
-					ClassMemberDecl(namedModuleDefaultClassMembers, false, !DafnyOptions.O.AllowGlobals, DafnyOptions.O.IronDafny && isAbstract);
-					break;
-				}
-				}
-			}
+			TopDecls(module, namedModuleDefaultClassMembers, /* isTopLevel */ false, isAbstract);
 			Expect(47);
 			module.BodyEndTok = t;
 			module.TopLevelDecls.Add(new DefaultClassDecl(module, namedModuleDefaultClassMembers));
 			submodule = new LiteralModuleDecl(module, parent); 
-		} else if (la.kind == 65) {
+		} else if (la.kind == 69) {
 			Get();
-			if (la.kind == 66) {
+			if (la.kind == 70) {
 				Get();
 				opened = true;
 			}
 			NoUSIdent(out id);
-			if (la.kind == 67 || la.kind == 68) {
-				if (la.kind == 67) {
+			EncodeExternAsAttribute(dmod, ref attrs, id, /* needAxiom */ false); 
+			if (la.kind == 71 || la.kind == 72) {
+				if (la.kind == 71) {
 					Get();
 					QualifiedModuleName(out idPath);
 					submodule = new AliasModuleDecl(idPath, id, parent, opened); 
 				} else {
 					Get();
 					QualifiedModuleName(out idPath);
-					if (la.kind == 69) {
+					if (la.kind == 73) {
 						Get();
 						QualifiedModuleName(out idAssignment);
 					}
@@ -736,7 +834,7 @@ bool IsType(ref IToken pt) {
 				}
 			}
 			if (la.kind == 28) {
-				while (!(la.kind == 0 || la.kind == 28)) {SynErr(139); Get();}
+				while (!(la.kind == 0 || la.kind == 28)) {SynErr(141); Get();}
 				Get();
 				errors.Warning(t, "the semi-colon that used to terminate a sub-module declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 			}
@@ -746,10 +844,10 @@ bool IsType(ref IToken pt) {
 			 submodule = new AliasModuleDecl(idPath, id, parent, opened);
 			}
 			
-		} else SynErr(140);
+		} else SynErr(142);
 	}
 
-	void ClassDecl(ModuleDefinition/*!*/ module, out ClassDecl/*!*/ c) {
+	void ClassDecl(DeclModifierData dmodClass, ModuleDefinition/*!*/ module, out ClassDecl/*!*/ c) {
 		Contract.Requires(module != null);
 		Contract.Ensures(Contract.ValueAtReturn(out c) != null);
 		IToken/*!*/ id;
@@ -759,17 +857,20 @@ bool IsType(ref IToken pt) {
 		List<TypeParameter/*!*/> typeArgs = new List<TypeParameter/*!*/>();
 		List<MemberDecl/*!*/> members = new List<MemberDecl/*!*/>();
 		IToken bodyStart;
+		CheckDeclModifiers(dmodClass, "Classes", AllowedDeclModifiers.Extern);
+		DeclModifierData dmod; 
 		
-		while (!(la.kind == 0 || la.kind == 70)) {SynErr(141); Get();}
-		Expect(70);
+		while (!(la.kind == 0 || la.kind == 74)) {SynErr(143); Get();}
+		Expect(74);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		NoUSIdent(out id);
+		EncodeExternAsAttribute(dmodClass, ref attrs, id, /* needAxiom */ false); 
 		if (la.kind == 52) {
 			GenericParameters(typeArgs);
 		}
-		if (la.kind == 71) {
+		if (la.kind == 75) {
 			Get();
 			Type(out trait);
 			traits.Add(trait); 
@@ -781,8 +882,9 @@ bool IsType(ref IToken pt) {
 		}
 		Expect(46);
 		bodyStart = t;  
-		while (StartOf(2)) {
-			ClassMemberDecl(members, true, false, false);
+		while (StartOf(3)) {
+			DeclModifiers(out dmod);
+			ClassMemberDecl(dmod, members, true, false, false);
 		}
 		Expect(47);
 		c = new ClassDecl(id, id.val, module, typeArgs, members, attrs, traits);
@@ -791,7 +893,7 @@ bool IsType(ref IToken pt) {
 		
 	}
 
-	void DatatypeDecl(ModuleDefinition/*!*/ module, out DatatypeDecl/*!*/ dt) {
+	void DatatypeDecl(DeclModifierData dmod, ModuleDefinition/*!*/ module, out DatatypeDecl/*!*/ dt) {
 		Contract.Requires(module != null);
 		Contract.Ensures(Contract.ValueAtReturn(out dt)!=null);
 		IToken/*!*/ id;
@@ -800,14 +902,15 @@ bool IsType(ref IToken pt) {
 		List<DatatypeCtor/*!*/> ctors = new List<DatatypeCtor/*!*/>();
 		IToken bodyStart = Token.NoToken;  // dummy assignment
 		bool co = false;
+		CheckDeclModifiers(dmod, "Datatypes or codatatypes", AllowedDeclModifiers.None);
 		
-		while (!(la.kind == 0 || la.kind == 76 || la.kind == 77)) {SynErr(142); Get();}
-		if (la.kind == 76) {
+		while (!(la.kind == 0 || la.kind == 77 || la.kind == 78)) {SynErr(144); Get();}
+		if (la.kind == 77) {
 			Get();
-		} else if (la.kind == 77) {
+		} else if (la.kind == 78) {
 			Get();
 			co = true; 
-		} else SynErr(143);
+		} else SynErr(145);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -815,7 +918,7 @@ bool IsType(ref IToken pt) {
 		if (la.kind == 52) {
 			GenericParameters(typeArgs);
 		}
-		Expect(67);
+		Expect(71);
 		bodyStart = t; 
 		DatatypeMemberDecl(ctors);
 		while (la.kind == 23) {
@@ -823,7 +926,7 @@ bool IsType(ref IToken pt) {
 			DatatypeMemberDecl(ctors);
 		}
 		if (la.kind == 28) {
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(144); Get();}
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(146); Get();}
 			Get();
 			errors.Warning(t, "the semi-colon that used to terminate a (co)datatype declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 		}
@@ -837,19 +940,20 @@ bool IsType(ref IToken pt) {
 		
 	}
 
-	void NewtypeDecl(ModuleDefinition module, out TopLevelDecl td) {
+	void NewtypeDecl(DeclModifierData dmod, ModuleDefinition module, out TopLevelDecl td) {
 		IToken id, bvId;
 		Attributes attrs = null;
 		td = null;
 		Type baseType = null;
 		Expression wh;
+		CheckDeclModifiers(dmod, "Newtypes", AllowedDeclModifiers.None);
 		
-		Expect(79);
+		Expect(80);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		NoUSIdent(out id);
-		Expect(67);
+		Expect(71);
 		if (IsIdentColonOrBar()) {
 			NoUSIdent(out bvId);
 			if (la.kind == 21) {
@@ -860,21 +964,22 @@ bool IsType(ref IToken pt) {
 			Expect(23);
 			Expression(out wh, false, true);
 			td = new NewtypeDecl(theVerifyThisFile ? id : new IncludeToken(id), id.val, module, new BoundVar(bvId, bvId.val, baseType), wh, attrs); 
-		} else if (StartOf(3)) {
+		} else if (StartOf(4)) {
 			Type(out baseType);
 			td = new NewtypeDecl(theVerifyThisFile ? id : new IncludeToken(id), id.val, module, baseType, attrs); 
-		} else SynErr(145);
+		} else SynErr(147);
 	}
 
-	void OtherTypeDecl(ModuleDefinition module, out TopLevelDecl td) {
+	void OtherTypeDecl(DeclModifierData dmod, ModuleDefinition module, out TopLevelDecl td) {
 		IToken id;
 		Attributes attrs = null;
 		var eqSupport = TypeParameter.EqualitySupportValue.Unspecified;
 		var typeArgs = new List<TypeParameter>();
 		td = null;
 		Type ty;
+		CheckDeclModifiers(dmod, "Type aliases", AllowedDeclModifiers.None);
 		
-		Expect(80);
+		Expect(81);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -887,28 +992,28 @@ bool IsType(ref IToken pt) {
 			if (la.kind == 52) {
 				GenericParameters(typeArgs);
 			}
-		} else if (StartOf(4)) {
+		} else if (StartOf(5)) {
 			if (la.kind == 52) {
 				GenericParameters(typeArgs);
 			}
-			if (la.kind == 67) {
+			if (la.kind == 71) {
 				Get();
 				Type(out ty);
 				td = new TypeSynonymDecl(id, id.val, typeArgs, module, ty, attrs); 
 			}
-		} else SynErr(146);
+		} else SynErr(148);
 		if (td == null) {
 		 td = new OpaqueTypeDecl(id, id.val, module, eqSupport, typeArgs, attrs);
 		}
 		
 		if (la.kind == 28) {
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(147); Get();}
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(149); Get();}
 			Get();
 			errors.Warning(t, "the semi-colon that used to terminate an opaque-type declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 		}
 	}
 
-	void IteratorDecl(ModuleDefinition module, out IteratorDecl/*!*/ iter) {
+	void IteratorDecl(DeclModifierData dmod, ModuleDefinition module, out IteratorDecl/*!*/ iter) {
 		Contract.Ensures(Contract.ValueAtReturn(out iter) != null);
 		IToken/*!*/ id;
 		Attributes attrs = null;
@@ -930,9 +1035,10 @@ bool IsType(ref IToken pt) {
 		IToken signatureEllipsis = null;
 		IToken bodyStart = Token.NoToken;
 		IToken bodyEnd = Token.NoToken;
+		CheckDeclModifiers(dmod, "Iterators", AllowedDeclModifiers.None);
 		
-		while (!(la.kind == 0 || la.kind == 81)) {SynErr(148); Get();}
-		Expect(81);
+		while (!(la.kind == 0 || la.kind == 82)) {SynErr(150); Get();}
+		Expect(82);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -942,8 +1048,8 @@ bool IsType(ref IToken pt) {
 				GenericParameters(typeArgs);
 			}
 			Formals(true, true, ins);
-			if (la.kind == 82 || la.kind == 83) {
-				if (la.kind == 82) {
+			if (la.kind == 83 || la.kind == 84) {
+				if (la.kind == 83) {
 					Get();
 				} else {
 					Get();
@@ -954,8 +1060,8 @@ bool IsType(ref IToken pt) {
 		} else if (la.kind == 59) {
 			Get();
 			signatureEllipsis = t; 
-		} else SynErr(149);
-		while (StartOf(5)) {
+		} else SynErr(151);
+		while (StartOf(6)) {
 			IteratorSpec(reads, mod, decreases, req, ens, yieldReq, yieldEns, ref readsAttrs, ref modAttrs, ref decrAttrs);
 		}
 		if (la.kind == 46) {
@@ -972,17 +1078,19 @@ bool IsType(ref IToken pt) {
 		
 	}
 
-	void TraitDecl(ModuleDefinition/*!*/ module, out TraitDecl/*!*/ trait) {
-		Contract.Requires(module != null);
+	void TraitDecl(DeclModifierData dmodIn, ModuleDefinition/*!*/ module, out TraitDecl/*!*/ trait) {
+		Contract.Requires(module != null);     
+		CheckDeclModifiers(dmodIn, "Traits", AllowedDeclModifiers.None);
 		Contract.Ensures(Contract.ValueAtReturn(out trait) != null);
 		IToken/*!*/ id;
 		Attributes attrs = null;
 		List<TypeParameter/*!*/> typeArgs = new List<TypeParameter/*!*/>(); //traits should not support type parameters at the moment
 		List<MemberDecl/*!*/> members = new List<MemberDecl/*!*/>();
 		IToken bodyStart;
+		DeclModifierData dmod; 
 		
-		while (!(la.kind == 0 || la.kind == 72)) {SynErr(150); Get();}
-		Expect(72);
+		while (!(la.kind == 0 || la.kind == 76)) {SynErr(152); Get();}
+		Expect(76);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -992,8 +1100,9 @@ bool IsType(ref IToken pt) {
 		}
 		Expect(46);
 		bodyStart = t; 
-		while (StartOf(2)) {
-			ClassMemberDecl(members, true, false, false);
+		while (StartOf(3)) {
+			DeclModifiers(out dmod);
+			ClassMemberDecl(dmod, members, true, false, false);
 		}
 		Expect(47);
 		trait = new TraitDecl(id, id.val, module, typeArgs, members, attrs);
@@ -1002,54 +1111,35 @@ bool IsType(ref IToken pt) {
 		
 	}
 
-	void ClassMemberDecl(List<MemberDecl> mm, bool allowConstructors, bool moduleLevelDecl, bool isWithinAbstractModule) {
+	void ClassMemberDecl(DeclModifierData dmod, List<MemberDecl> mm, bool allowConstructors, bool moduleLevelDecl, bool isWithinAbstractModule) {
 		Contract.Requires(cce.NonNullElements(mm));
 		Method/*!*/ m;
 		Function/*!*/ f;
-		MemberModifiers mmod = new MemberModifiers();
-		IToken staticToken = null, protectedToken = null;
 		
-		while (la.kind == 73 || la.kind == 74 || la.kind == 75) {
-			if (la.kind == 73) {
-				Get();
-				mmod.IsGhost = true; 
-			} else if (la.kind == 74) {
-				Get();
-				mmod.IsStatic = true; staticToken = t; 
-			} else {
-				Get();
-				mmod.IsProtected = true; protectedToken = t; 
-			}
-		}
-		if (la.kind == 78) {
+		if (la.kind == 79) {
 			if (moduleLevelDecl) {
 			 SemErr(la, "fields are not allowed to be declared at the module level; instead, wrap the field in a 'class' declaration");
-			 mmod.IsStatic = false;
-			 mmod.IsProtected = false;
+			 dmod.IsStatic = false;
 			}
 			
-			FieldDecl(mmod, mm);
+			FieldDecl(dmod, mm);
 		} else if (IsFunctionDecl()) {
-			if (moduleLevelDecl && staticToken != null) {
-			 errors.Warning(staticToken, "module-level functions are always non-instance, so the 'static' keyword is not allowed here");
-			 mmod.IsStatic = false;
+			if (moduleLevelDecl && dmod.StaticToken != null) {
+			 errors.Warning(dmod.StaticToken, "module-level functions are always non-instance, so the 'static' keyword is not allowed here");
+			 dmod.IsStatic = false;
 			}
 			
-			FunctionDecl(mmod, isWithinAbstractModule, out f);
+			FunctionDecl(dmod, isWithinAbstractModule, out f);
 			mm.Add(f); 
-		} else if (StartOf(6)) {
-			if (moduleLevelDecl && staticToken != null) {
-			 errors.Warning(staticToken, "module-level methods are always non-instance, so the 'static' keyword is not allowed here");
-			 mmod.IsStatic = false;
-			}
-			if (protectedToken != null) {
-			 SemErr(protectedToken, "only functions, not methods, can be declared 'protected'");
-			 mmod.IsProtected = false;
+		} else if (StartOf(7)) {
+			if (moduleLevelDecl && dmod.StaticToken != null) {
+			 errors.Warning(dmod.StaticToken, "module-level methods are always non-instance, so the 'static' keyword is not allowed here");
+			 dmod.IsStatic = false;
 			}
 			
-			MethodDecl(mmod, allowConstructors, isWithinAbstractModule, out m);
+			MethodDecl(dmod, allowConstructors, isWithinAbstractModule, out m);
 			mm.Add(m); 
-		} else SynErr(151);
+		} else SynErr(153);
 	}
 
 	void Attribute(ref Attributes attrs) {
@@ -1060,7 +1150,7 @@ bool IsType(ref IToken pt) {
 		Expect(21);
 		NoUSIdent(out x);
 		name = x.val; 
-		if (StartOf(7)) {
+		if (StartOf(8)) {
 			Expressions(args);
 		}
 		Expect(47);
@@ -1129,29 +1219,28 @@ bool IsType(ref IToken pt) {
 		TypeAndToken(out tok, out ty);
 	}
 
-	void FieldDecl(MemberModifiers mmod, List<MemberDecl/*!*/>/*!*/ mm) {
+	void FieldDecl(DeclModifierData dmod, List<MemberDecl/*!*/>/*!*/ mm) {
 		Contract.Requires(cce.NonNullElements(mm));
 		Attributes attrs = null;
 		IToken/*!*/ id;  Type/*!*/ ty;
+		CheckDeclModifiers(dmod, "Fields", AllowedDeclModifiers.Ghost);
 		
-		while (!(la.kind == 0 || la.kind == 78)) {SynErr(152); Get();}
-		Expect(78);
-		if (mmod.IsStatic) { SemErr(t, "fields cannot be declared 'static'"); }
-		
+		while (!(la.kind == 0 || la.kind == 79)) {SynErr(154); Get();}
+		Expect(79);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
 		FIdentType(out id, out ty);
-		mm.Add(new Field(id, id.val, mmod.IsGhost, ty, attrs)); 
+		mm.Add(new Field(id, id.val, dmod.IsGhost, ty, attrs)); 
 		while (la.kind == 22) {
 			Get();
 			FIdentType(out id, out ty);
-			mm.Add(new Field(id, id.val, mmod.IsGhost, ty, attrs)); 
+			mm.Add(new Field(id, id.val, dmod.IsGhost, ty, attrs)); 
 		}
 		OldSemi();
 	}
 
-	void FunctionDecl(MemberModifiers mmod, bool isWithinAbstractModule, out Function/*!*/ f) {
+	void FunctionDecl(DeclModifierData dmod, bool isWithinAbstractModule, out Function/*!*/ f) {
 		Contract.Ensures(Contract.ValueAtReturn(out f)!=null);
 		Attributes attrs = null;
 		IToken/*!*/ id = Token.NoToken;  // to please compiler
@@ -1172,11 +1261,17 @@ bool IsType(ref IToken pt) {
 		
 		if (la.kind == 38) {
 			Get();
-			if (la.kind == 84) {
+			if (la.kind == 85) {
 				Get();
 				isFunctionMethod = true; 
 			}
-			if (mmod.IsGhost) { SemErr(t, "functions cannot be declared 'ghost' (they are ghost by default)"); }
+			AllowedDeclModifiers allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static | AllowedDeclModifiers.Protected;
+			string caption = "Functions";
+			if (isFunctionMethod) { 
+			 allowed |= AllowedDeclModifiers.Extern; 
+			 caption = "Function methods";
+			}
+			CheckDeclModifiers(dmod, caption, allowed);
 			
 			while (la.kind == 46) {
 				Attribute(ref attrs);
@@ -1192,21 +1287,27 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(153);
+			} else SynErr(155);
 		} else if (la.kind == 39) {
 			Get();
 			isPredicate = true; 
-			if (la.kind == 84) {
+			if (la.kind == 85) {
 				Get();
 				isFunctionMethod = true; 
 			}
-			if (mmod.IsGhost) { SemErr(t, "predicates cannot be declared 'ghost' (they are ghost by default)"); }
+			AllowedDeclModifiers allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static | AllowedDeclModifiers.Protected;
+			string caption = "Predicates";
+			if (isFunctionMethod) { 
+			 allowed |= AllowedDeclModifiers.Extern; 
+			 caption = "Predicate methods";
+			}
+			CheckDeclModifiers(dmod, caption, allowed);
 			
 			while (la.kind == 46) {
 				Attribute(ref attrs);
 			}
 			NoUSIdent(out id);
-			if (StartOf(8)) {
+			if (StartOf(9)) {
 				if (la.kind == 52) {
 					GenericParameters(typeArgs);
 				}
@@ -1223,12 +1324,13 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(154);
+			} else SynErr(156);
 		} else if (la.kind == 40) {
 			Get();
 			Expect(39);
 			isIndPredicate = true; 
-			if (mmod.IsGhost) { SemErr(t, "inductive predicates cannot be declared 'ghost' (they are ghost by default)"); }
+			CheckDeclModifiers(dmod, "Inductive predicates",
+			 AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static | AllowedDeclModifiers.Protected);
 			
 			while (la.kind == 46) {
 				Attribute(ref attrs);
@@ -1246,11 +1348,12 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(155);
+			} else SynErr(157);
 		} else if (la.kind == 42) {
 			Get();
 			isCoPredicate = true; 
-			if (mmod.IsGhost) { SemErr(t, "copredicates cannot be declared 'ghost' (they are ghost by default)"); }
+			CheckDeclModifiers(dmod, "Copredicates",
+			 AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static | AllowedDeclModifiers.Protected);
 			
 			while (la.kind == 46) {
 				Attribute(ref attrs);
@@ -1268,31 +1371,32 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(156);
-		} else SynErr(157);
+			} else SynErr(158);
+		} else SynErr(159);
 		decreases = isIndPredicate || isCoPredicate ? null : new List<Expression/*!*/>(); 
-		while (StartOf(9)) {
+		while (StartOf(10)) {
 			FunctionSpec(reqs, reads, ens, decreases);
 		}
 		if (la.kind == 46) {
 			FunctionBody(out body, out bodyStart, out bodyEnd);
 		}
-		if (!isWithinAbstractModule && DafnyOptions.O.DisallowSoundnessCheating && body == null && ens.Count > 0 && !Attributes.Contains(attrs, "axiom") && !Attributes.Contains(attrs, "imported")) {
+		if (!isWithinAbstractModule && DafnyOptions.O.DisallowSoundnessCheating && body == null && ens.Count > 0 &&
+		   !Attributes.Contains(attrs, "axiom") && !Attributes.Contains(attrs, "imported")) {
 		  SemErr(t, "a function with an ensures clause must have a body, unless given the :axiom attribute");
 		}
-		
+		EncodeExternAsAttribute(dmod, ref attrs, id, /* needAxiom */ true);
 		IToken tok = theVerifyThisFile ? id : new IncludeToken(id);
 		if (isPredicate) {
-		  f = new Predicate(tok, id.val, mmod.IsStatic, mmod.IsProtected, !isFunctionMethod, typeArgs, formals,
+		  f = new Predicate(tok, id.val, dmod.IsStatic, dmod.IsProtected, !isFunctionMethod, typeArgs, formals,
 		                    reqs, reads, ens, new Specification<Expression>(decreases, null), body, Predicate.BodyOriginKind.OriginalOrInherited, attrs, signatureEllipsis);
 		} else if (isIndPredicate) {
-		  f = new InductivePredicate(tok, id.val, mmod.IsStatic, mmod.IsProtected, typeArgs, formals,
+		  f = new InductivePredicate(tok, id.val, dmod.IsStatic, dmod.IsProtected, typeArgs, formals,
 		                             reqs, reads, ens, body, attrs, signatureEllipsis);
 		} else if (isCoPredicate) {
-		  f = new CoPredicate(tok, id.val, mmod.IsStatic, mmod.IsProtected, typeArgs, formals,
+		  f = new CoPredicate(tok, id.val, dmod.IsStatic, dmod.IsProtected, typeArgs, formals,
 		                      reqs, reads, ens, body, attrs, signatureEllipsis);
 		} else {
-		  f = new Function(tok, id.val, mmod.IsStatic, mmod.IsProtected, !isFunctionMethod, typeArgs, formals, returnType,
+		  f = new Function(tok, id.val, dmod.IsStatic, dmod.IsProtected, !isFunctionMethod, typeArgs, formals, returnType,
 		                   reqs, reads, ens, new Specification<Expression>(decreases, null), body, attrs, signatureEllipsis);
 		}
 		f.BodyStartTok = bodyStart;
@@ -1305,7 +1409,7 @@ bool IsType(ref IToken pt) {
 		
 	}
 
-	void MethodDecl(MemberModifiers mmod, bool allowConstructor, bool isWithinAbstractModule, out Method/*!*/ m) {
+	void MethodDecl(DeclModifierData dmod, bool allowConstructor, bool isWithinAbstractModule, out Method/*!*/ m) {
 		Contract.Ensures(Contract.ValueAtReturn(out m) !=null);
 		IToken/*!*/ id = Token.NoToken;
 		bool hasName = false;  IToken keywordToken;
@@ -1327,26 +1431,37 @@ bool IsType(ref IToken pt) {
 		IToken signatureEllipsis = null;
 		IToken bodyStart = Token.NoToken;
 		IToken bodyEnd = Token.NoToken;
+		AllowedDeclModifiers allowed = AllowedDeclModifiers.None;
+		string caption = "";
 		
-		while (!(StartOf(10))) {SynErr(158); Get();}
+		while (!(StartOf(11))) {SynErr(160); Get();}
 		switch (la.kind) {
-		case 84: {
+		case 85: {
 			Get();
+			caption = "Methods";
+			allowed = AllowedDeclModifiers.Ghost | AllowedDeclModifiers.Static 
+			 | AllowedDeclModifiers.Extern; 
 			break;
 		}
 		case 41: {
 			Get();
-			isLemma = true; 
+			isLemma = true; caption = "Lemmas";
+			allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static 
+			 | AllowedDeclModifiers.Protected; 
 			break;
 		}
-		case 85: {
+		case 86: {
 			Get();
-			isCoLemma = true; 
+			isCoLemma = true; caption = "Colemmas";
+			allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static 
+			 | AllowedDeclModifiers.Protected; 
 			break;
 		}
-		case 86: {
+		case 87: {
 			Get();
-			isCoLemma = true;
+			isCoLemma = true; caption = "Comethods";
+			allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static 
+			 | AllowedDeclModifiers.Protected;
 			errors.Warning(t, "the 'comethod' keyword has been deprecated; it has been renamed to 'colemma'");
 			
 			break;
@@ -1354,43 +1469,26 @@ bool IsType(ref IToken pt) {
 		case 40: {
 			Get();
 			Expect(41);
-			isIndLemma = true; 
+			isIndLemma = true;  caption = "Inductive lemmas";
+			allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static;
 			break;
 		}
-		case 87: {
+		case 88: {
 			Get();
 			if (allowConstructor) {
 			 isConstructor = true;
 			} else {
 			 SemErr(t, "constructors are allowed only in classes");
-			}
+			} 
+			caption = "Constructors";
+			allowed = AllowedDeclModifiers.None;
 			
 			break;
 		}
-		default: SynErr(159); break;
+		default: SynErr(161); break;
 		}
 		keywordToken = t; 
-		if (isLemma) {
-		 if (mmod.IsGhost) {
-		   SemErr(t, "lemmas cannot be declared 'ghost' (they are automatically 'ghost')");
-		 }
-		} else if (isConstructor) {
-		 if (mmod.IsGhost) {
-		   SemErr(t, "constructors cannot be declared 'ghost'");
-		 }
-		 if (mmod.IsStatic) {
-		   SemErr(t, "constructors cannot be declared 'static'");
-		 }
-		} else if (isIndLemma) {
-		 if (mmod.IsGhost) {
-		   SemErr(t, "inductive lemmas cannot be declared 'ghost' (they are automatically 'ghost')");
-		 }
-		} else if (isCoLemma) {
-		 if (mmod.IsGhost) {
-		   SemErr(t, "colemmas cannot be declared 'ghost' (they are automatically 'ghost')");
-		 }
-		}
-		
+		CheckDeclModifiers(dmod, caption, allowed); 
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -1404,22 +1502,23 @@ bool IsType(ref IToken pt) {
 		   SemErr(la, "a method must be given a name (expecting identifier)");
 		 }
 		}
+		EncodeExternAsAttribute(dmod, ref attrs, id, /* needAxiom */ true);
 		
 		if (la.kind == 50 || la.kind == 52) {
 			if (la.kind == 52) {
 				GenericParameters(typeArgs);
 			}
-			Formals(true, !mmod.IsGhost, ins);
-			if (la.kind == 83) {
+			Formals(true, !dmod.IsGhost, ins);
+			if (la.kind == 84) {
 				Get();
 				if (isConstructor) { SemErr(t, "constructors cannot have out-parameters"); } 
-				Formals(false, !mmod.IsGhost, outs);
+				Formals(false, !dmod.IsGhost, outs);
 			}
 		} else if (la.kind == 59) {
 			Get();
 			signatureEllipsis = t; 
-		} else SynErr(160);
-		while (StartOf(11)) {
+		} else SynErr(162);
+		while (StartOf(12)) {
 			MethodSpec(req, mod, ens, dec, ref decAttrs, ref modAttrs);
 		}
 		if (la.kind == 46) {
@@ -1434,16 +1533,16 @@ bool IsType(ref IToken pt) {
 		 m = new Constructor(tok, hasName ? id.val : "_ctor", typeArgs, ins,
 		                     req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
 		} else if (isIndLemma) {
-		 m = new InductiveLemma(tok, id.val, mmod.IsStatic, typeArgs, ins, outs,
+		 m = new InductiveLemma(tok, id.val, dmod.IsStatic, typeArgs, ins, outs,
 		                        req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
 		} else if (isCoLemma) {
-		 m = new CoLemma(tok, id.val, mmod.IsStatic, typeArgs, ins, outs,
+		 m = new CoLemma(tok, id.val, dmod.IsStatic, typeArgs, ins, outs,
 		                 req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
 		} else if (isLemma) {
-		 m = new Lemma(tok, id.val, mmod.IsStatic, typeArgs, ins, outs,
+		 m = new Lemma(tok, id.val, dmod.IsStatic, typeArgs, ins, outs,
 		               req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
 		} else {
-		 m = new Method(tok, id.val, mmod.IsStatic, mmod.IsGhost, typeArgs, ins, outs,
+		 m = new Method(tok, id.val, dmod.IsStatic, dmod.IsGhost, typeArgs, ins, outs,
 		                req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
 		}
 		m.BodyStartTok = bodyStart;
@@ -1470,7 +1569,7 @@ bool IsType(ref IToken pt) {
 	void FormalsOptionalIds(List<Formal/*!*/>/*!*/ formals) {
 		Contract.Requires(cce.NonNullElements(formals)); IToken/*!*/ id;  Type/*!*/ ty;  string/*!*/ name;  bool isGhost; 
 		Expect(50);
-		if (StartOf(12)) {
+		if (StartOf(13)) {
 			TypeIdentOptional(out id, out name, out ty, out isGhost);
 			formals.Add(new Formal(id, name, ty, true, isGhost)); 
 			while (la.kind == 22) {
@@ -1491,14 +1590,14 @@ bool IsType(ref IToken pt) {
 		} else if (la.kind == 2) {
 			Get();
 			id = t; 
-		} else SynErr(161);
+		} else SynErr(163);
 		Expect(21);
 		Type(out ty);
 	}
 
 	void OldSemi() {
 		if (la.kind == 28) {
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(162); Get();}
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(164); Get();}
 			Get();
 		}
 	}
@@ -1521,7 +1620,7 @@ bool IsType(ref IToken pt) {
 		Contract.Ensures(Contract.ValueAtReturn(out id)!=null);
 		Contract.Ensures(Contract.ValueAtReturn(out ty)!=null);
 		isGhost = false; 
-		if (la.kind == 73) {
+		if (la.kind == 62) {
 			Get();
 			if (allowGhostKeyword) { isGhost = true; } else { SemErr(t, "formal cannot be declared 'ghost' in this context"); } 
 		}
@@ -1573,11 +1672,11 @@ bool IsType(ref IToken pt) {
 		Contract.Ensures(Contract.ValueAtReturn(out ty)!=null);
 		Contract.Ensures(Contract.ValueAtReturn(out identName)!=null);
 		string name = null; id = Token.NoToken; ty = new BoolType()/*dummy*/; isGhost = false; 
-		if (la.kind == 73) {
+		if (la.kind == 62) {
 			Get();
 			isGhost = true; 
 		}
-		if (StartOf(3)) {
+		if (StartOf(4)) {
 			TypeAndToken(out id, out ty);
 			if (la.kind == 21) {
 				Get();
@@ -1595,7 +1694,7 @@ bool IsType(ref IToken pt) {
 			id = t; name = id.val;
 			Expect(21);
 			Type(out ty);
-		} else SynErr(163);
+		} else SynErr(165);
 		if (name != null) {
 		 identName = name;
 		} else {
@@ -1746,7 +1845,7 @@ bool IsType(ref IToken pt) {
 		case 50: {
 			Get();
 			tok = t; tupleArgTypes = new List<Type>(); 
-			if (StartOf(3)) {
+			if (StartOf(4)) {
 				Type(out ty);
 				tupleArgTypes.Add(ty); 
 				while (la.kind == 22) {
@@ -1783,7 +1882,7 @@ bool IsType(ref IToken pt) {
 			ty = new UserDefinedType(e.tok, e); 
 			break;
 		}
-		default: SynErr(164); break;
+		default: SynErr(166); break;
 		}
 		if (la.kind == 30) {
 			Type t2; 
@@ -1804,7 +1903,7 @@ bool IsType(ref IToken pt) {
 	void Formals(bool incoming, bool allowGhostKeyword, List<Formal> formals) {
 		Contract.Requires(cce.NonNullElements(formals)); IToken id;  Type ty;  bool isGhost; 
 		Expect(50);
-		if (la.kind == 1 || la.kind == 73) {
+		if (la.kind == 1 || la.kind == 62) {
 			GIdentType(allowGhostKeyword, out id, out ty, out isGhost);
 			formals.Add(new Formal(id, id.val, ty, incoming, isGhost)); 
 			while (la.kind == 22) {
@@ -1822,7 +1921,7 @@ List<MaybeFreeExpression/*!*/>/*!*/ yieldReq, List<MaybeFreeExpression/*!*/>/*!*
 ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 		Expression/*!*/ e; FrameExpression/*!*/ fe; bool isFree = false; bool isYield = false; Attributes ensAttrs = null;
 		
-		while (!(StartOf(13))) {SynErr(165); Get();}
+		while (!(StartOf(14))) {SynErr(167); Get();}
 		if (la.kind == 44) {
 			Get();
 			while (IsAttribute()) {
@@ -1849,14 +1948,14 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 				mod.Add(fe); 
 			}
 			OldSemi();
-		} else if (StartOf(14)) {
-			if (la.kind == 88) {
+		} else if (StartOf(15)) {
+			if (la.kind == 89) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
 				
 			}
-			if (la.kind == 90) {
+			if (la.kind == 91) {
 				Get();
 				isYield = true; 
 			}
@@ -1870,7 +1969,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 				 req.Add(new MaybeFreeExpression(e, isFree));
 				}
 				
-			} else if (la.kind == 89) {
+			} else if (la.kind == 90) {
 				Get();
 				while (IsAttribute()) {
 					Attribute(ref ensAttrs);
@@ -1883,7 +1982,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 				 ens.Add(new MaybeFreeExpression(e, isFree, ensAttrs));
 				}
 				
-			} else SynErr(166);
+			} else SynErr(168);
 		} else if (la.kind == 36) {
 			Get();
 			while (IsAttribute()) {
@@ -1891,7 +1990,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 			}
 			DecreasesList(decreases, false, false);
 			OldSemi();
-		} else SynErr(167);
+		} else SynErr(169);
 	}
 
 	void BlockStmt(out BlockStmt/*!*/ block, out IToken bodyStart, out IToken bodyEnd) {
@@ -1900,7 +1999,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 		
 		Expect(46);
 		bodyStart = t; 
-		while (StartOf(15)) {
+		while (StartOf(16)) {
 			Stmt(body);
 		}
 		Expect(47);
@@ -1913,7 +2012,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Requires(cce.NonNullElements(req)); Contract.Requires(cce.NonNullElements(mod)); Contract.Requires(cce.NonNullElements(ens)); Contract.Requires(cce.NonNullElements(decreases));
 		Expression/*!*/ e;  FrameExpression/*!*/ fe;  bool isFree = false; Attributes ensAttrs = null;
 		
-		while (!(StartOf(16))) {SynErr(168); Get();}
+		while (!(StartOf(17))) {SynErr(170); Get();}
 		if (la.kind == 43) {
 			Get();
 			while (IsAttribute()) {
@@ -1927,8 +2026,8 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				mod.Add(fe); 
 			}
 			OldSemi();
-		} else if (la.kind == 45 || la.kind == 88 || la.kind == 89) {
-			if (la.kind == 88) {
+		} else if (la.kind == 45 || la.kind == 89 || la.kind == 90) {
+			if (la.kind == 89) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
@@ -1939,7 +2038,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Expression(out e, false, false);
 				OldSemi();
 				req.Add(new MaybeFreeExpression(e, isFree)); 
-			} else if (la.kind == 89) {
+			} else if (la.kind == 90) {
 				Get();
 				while (IsAttribute()) {
 					Attribute(ref ensAttrs);
@@ -1947,7 +2046,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Expression(out e, false, false);
 				OldSemi();
 				ens.Add(new MaybeFreeExpression(e, isFree, ensAttrs)); 
-			} else SynErr(169);
+			} else SynErr(171);
 		} else if (la.kind == 36) {
 			Get();
 			while (IsAttribute()) {
@@ -1955,7 +2054,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			DecreasesList(decreases, true, false);
 			OldSemi();
-		} else SynErr(170);
+		} else SynErr(172);
 	}
 
 	void FrameExpression(out FrameExpression fe, bool allowSemi, bool allowLambda) {
@@ -1965,21 +2064,21 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		string fieldName = null;  IToken feTok = null;
 		fe = null;
 		
-		if (StartOf(7)) {
+		if (StartOf(8)) {
 			Expression(out e, allowSemi, allowLambda);
 			feTok = e.tok; 
-			if (la.kind == 91) {
+			if (la.kind == 92) {
 				Get();
 				Ident(out id);
 				fieldName = id.val;  feTok = id; 
 			}
 			fe = new FrameExpression(feTok, e, fieldName); 
-		} else if (la.kind == 91) {
+		} else if (la.kind == 92) {
 			Get();
 			Ident(out id);
 			fieldName = id.val; 
 			fe = new FrameExpression(id, new ImplicitThisExpr(id), fieldName); 
-		} else SynErr(171);
+		} else SynErr(173);
 	}
 
 	void DecreasesList(List<Expression> decreases, bool allowWildcard, bool allowLambda) {
@@ -2034,7 +2133,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Requires(cce.NonNullElements(reads));
 		Contract.Requires(decreases == null || cce.NonNullElements(decreases));
 		Expression/*!*/ e;  FrameExpression/*!*/ fe; 
-		while (!(StartOf(17))) {SynErr(172); Get();}
+		while (!(StartOf(18))) {SynErr(174); Get();}
 		if (la.kind == 45) {
 			Get();
 			Expression(out e, false, false);
@@ -2050,7 +2149,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				reads.Add(fe); 
 			}
 			OldSemi();
-		} else if (la.kind == 89) {
+		} else if (la.kind == 90) {
 			Get();
 			Expression(out e, false, false);
 			OldSemi();
@@ -2064,7 +2163,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			
 			DecreasesList(decreases, false, false);
 			OldSemi();
-		} else SynErr(173);
+		} else SynErr(175);
 	}
 
 	void FunctionBody(out Expression/*!*/ e, out IToken bodyStart, out IToken bodyEnd) {
@@ -2081,9 +2180,9 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 57) {
 			Get();
 			fe = new FrameExpression(t, new WildcardExpr(t), null); 
-		} else if (StartOf(18)) {
+		} else if (StartOf(19)) {
 			FrameExpression(out fe, allowSemi, false);
-		} else SynErr(174);
+		} else SynErr(176);
 	}
 
 	void PossiblyWildExpression(out Expression e, bool allowLambda) {
@@ -2092,9 +2191,9 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 57) {
 			Get();
 			e = new WildcardExpr(t); 
-		} else if (StartOf(7)) {
+		} else if (StartOf(8)) {
 			Expression(out e, false, allowLambda);
-		} else SynErr(175);
+		} else SynErr(177);
 	}
 
 	void Stmt(List<Statement/*!*/>/*!*/ ss) {
@@ -2111,14 +2210,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken bodyStart, bodyEnd;
 		int breakCount;
 		
-		while (!(StartOf(19))) {SynErr(176); Get();}
+		while (!(StartOf(20))) {SynErr(178); Get();}
 		switch (la.kind) {
 		case 46: {
 			BlockStmt(out bs, out bodyStart, out bodyEnd);
 			s = bs; 
 			break;
 		}
-		case 101: {
+		case 102: {
 			AssertStmt(out s);
 			break;
 		}
@@ -2126,31 +2225,31 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			AssumeStmt(out s);
 			break;
 		}
-		case 102: {
+		case 103: {
 			PrintStmt(out s);
 			break;
 		}
-		case 1: case 2: case 3: case 4: case 8: case 10: case 19: case 20: case 23: case 50: case 131: case 132: case 133: case 134: case 135: case 136: {
+		case 1: case 2: case 3: case 4: case 8: case 10: case 19: case 20: case 23: case 50: case 132: case 133: case 134: case 135: case 136: case 137: {
 			UpdateStmt(out s);
 			break;
 		}
-		case 73: case 78: {
+		case 62: case 79: {
 			VarDeclStatement(out s);
 			break;
 		}
-		case 98: {
+		case 99: {
 			IfStmt(out s);
 			break;
 		}
-		case 99: {
+		case 100: {
 			WhileStmt(out s);
 			break;
 		}
-		case 100: {
+		case 101: {
 			MatchStmt(out s);
 			break;
 		}
-		case 103: case 104: {
+		case 104: case 105: {
 			ForallStmt(out s);
 			break;
 		}
@@ -2158,11 +2257,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			CalcStmt(out s);
 			break;
 		}
-		case 105: {
+		case 106: {
 			ModifyStmt(out s);
 			break;
 		}
-		case 92: {
+		case 93: {
 			Get();
 			x = t; 
 			NoUSIdent(out id);
@@ -2171,24 +2270,24 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			s.Labels = new LList<Label>(new Label(x, id.val), s.Labels); 
 			break;
 		}
-		case 93: {
+		case 94: {
 			Get();
 			x = t; breakCount = 1; label = null; 
 			if (la.kind == 1) {
 				NoUSIdent(out id);
 				label = id.val; 
-			} else if (la.kind == 28 || la.kind == 93) {
-				while (la.kind == 93) {
+			} else if (la.kind == 28 || la.kind == 94) {
+				while (la.kind == 94) {
 					Get();
 					breakCount++; 
 				}
-			} else SynErr(177);
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(178); Get();}
+			} else SynErr(179);
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(180); Get();}
 			Expect(28);
 			s = label != null ? new BreakStmt(x, t, label) : new BreakStmt(x, t, breakCount); 
 			break;
 		}
-		case 90: case 96: {
+		case 91: case 97: {
 			ReturnStmt(out s);
 			break;
 		}
@@ -2196,7 +2295,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			SkeletonStmt(out s);
 			break;
 		}
-		default: SynErr(179); break;
+		default: SynErr(181); break;
 		}
 	}
 
@@ -2205,17 +2304,17 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression e = dummyExpr; Attributes attrs = null;
 		IToken dotdotdot = null;
 		
-		Expect(101);
+		Expect(102);
 		x = t; 
 		while (IsAttribute()) {
 			Attribute(ref attrs);
 		}
-		if (StartOf(7)) {
+		if (StartOf(8)) {
 			Expression(out e, false, true);
 		} else if (la.kind == 59) {
 			Get();
 			dotdotdot = t; 
-		} else SynErr(180);
+		} else SynErr(182);
 		Expect(28);
 		if (dotdotdot != null) {
 		 s = new SkeletonStatement(new AssertStmt(x, t, new LiteralExpr(x, true), attrs), dotdotdot, null);
@@ -2235,12 +2334,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		while (IsAttribute()) {
 			Attribute(ref attrs);
 		}
-		if (StartOf(7)) {
+		if (StartOf(8)) {
 			Expression(out e, false, true);
 		} else if (la.kind == 59) {
 			Get();
 			dotdotdot = t; 
-		} else SynErr(181);
+		} else SynErr(183);
 		Expect(28);
 		if (dotdotdot != null) {
 		 s = new SkeletonStatement(new AssumeStmt(x, t, new LiteralExpr(x, true), attrs), dotdotdot, null);
@@ -2255,7 +2354,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken x;  Expression e;
 		var args = new List<Expression>();
 		
-		Expect(102);
+		Expect(103);
 		x = t; 
 		Expression(out e, false, true);
 		args.Add(e); 
@@ -2285,14 +2384,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			Expect(28);
 			endTok = t; rhss.Add(new ExprRhs(e, attrs)); 
-		} else if (la.kind == 22 || la.kind == 25 || la.kind == 95) {
+		} else if (la.kind == 22 || la.kind == 25 || la.kind == 96) {
 			lhss.Add(e); 
 			while (la.kind == 22) {
 				Get();
 				Lhs(out e);
 				lhss.Add(e); 
 			}
-			if (la.kind == 95) {
+			if (la.kind == 96) {
 				Get();
 				x = t; 
 				Rhs(out r);
@@ -2310,13 +2409,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					suchThatAssume = t; 
 				}
 				Expression(out suchThat, false, true);
-			} else SynErr(182);
+			} else SynErr(184);
 			Expect(28);
 			endTok = t; 
 		} else if (la.kind == 21) {
 			Get();
 			SemErr(t, "invalid statement (did you forget the 'label' keyword?)"); 
-		} else SynErr(183);
+		} else SynErr(185);
 		if (suchThat != null) {
 		 s = new AssignSuchThatStmt(x, endTok, lhss, suchThat, suchThatAssume, null);
 		} else {
@@ -2341,11 +2440,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken endTok;
 		s = dummyStmt;
 		
-		if (la.kind == 73) {
+		if (la.kind == 62) {
 			Get();
 			isGhost = true;  x = t; 
 		}
-		Expect(78);
+		Expect(79);
 		if (!isGhost) { x = t; } 
 		if (la.kind == 1 || la.kind == 46) {
 			while (la.kind == 46) {
@@ -2361,8 +2460,8 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				LocalIdentTypeOptional(out d, isGhost);
 				lhss.Add(d); d.Attributes = attrs; attrs = null; 
 			}
-			if (la.kind == 25 || la.kind == 46 || la.kind == 95) {
-				if (la.kind == 95) {
+			if (la.kind == 25 || la.kind == 46 || la.kind == 96) {
+				if (la.kind == 96) {
 					Get();
 					assignTok = t; 
 					Rhs(out r);
@@ -2385,7 +2484,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					Expression(out suchThat, false, true);
 				}
 			}
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(184); Get();}
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(186); Get();}
 			Expect(28);
 			endTok = t; 
 			ConcreteUpdateStatement update;
@@ -2431,7 +2530,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			if (isGhost) { pat.Vars.Iter(bv => bv.IsGhost = true); }
 			letLHSs.Add(pat);
 			
-			if (la.kind == 95) {
+			if (la.kind == 96) {
 				Get();
 			} else if (la.kind == 25 || la.kind == 46) {
 				while (la.kind == 46) {
@@ -2439,12 +2538,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				}
 				Expect(25);
 				SemErr(pat.tok, "LHS of assign-such-that expression must be variables, not general patterns"); 
-			} else SynErr(185);
+			} else SynErr(187);
 			Expression(out e, false, true);
 			letRHSs.Add(e); 
 			Expect(28);
 			s = new LetStmt(e.tok, e.tok, letLHSs, letRHSs); 
-		} else SynErr(186);
+		} else SynErr(188);
 	}
 
 	void IfStmt(out Statement/*!*/ ifStmt) {
@@ -2458,16 +2557,16 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<GuardedAlternative> alternatives;
 		ifStmt = dummyStmt;  // to please the compiler
 		
-		Expect(98);
+		Expect(99);
 		x = t; 
 		if (IsAlternative()) {
 			AlternativeBlock(true, out alternatives, out endTok);
 			ifStmt = new AlternativeStmt(x, endTok, alternatives); 
-		} else if (StartOf(20)) {
+		} else if (StartOf(21)) {
 			if (IsExistentialGuard()) {
 				ExistentialGuard(out guard, true);
 				isExistentialGuard = true; 
-			} else if (StartOf(21)) {
+			} else if (StartOf(22)) {
 				Guard(out guard);
 			} else {
 				Get();
@@ -2477,13 +2576,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			endTok = thn.EndTok; 
 			if (la.kind == 35) {
 				Get();
-				if (la.kind == 98) {
+				if (la.kind == 99) {
 					IfStmt(out s);
 					els = s; endTok = s.EndTok; 
 				} else if (la.kind == 46) {
 					BlockStmt(out bs, out bodyStart, out bodyEnd);
 					els = bs; endTok = bs.EndTok; 
-				} else SynErr(187);
+				} else SynErr(189);
 			}
 			if (guardEllipsis != null) {
 			 ifStmt = new SkeletonStatement(new IfStmt(x, endTok, isExistentialGuard, guard, thn, els), guardEllipsis, null);
@@ -2491,7 +2590,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 ifStmt = new IfStmt(x, endTok, isExistentialGuard, guard, thn, els);
 			}
 			
-		} else SynErr(188);
+		} else SynErr(190);
 	}
 
 	void WhileStmt(out Statement stmt) {
@@ -2510,23 +2609,23 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		stmt = dummyStmt;  // to please the compiler
 		bool isDirtyLoop = true;
 		
-		Expect(99);
+		Expect(100);
 		x = t; 
 		if (IsLoopSpec() || IsAlternative()) {
-			while (StartOf(22)) {
+			while (StartOf(23)) {
 				LoopSpec(invariants, decreases, ref mod, ref decAttrs, ref modAttrs);
 			}
 			AlternativeBlock(false, out alternatives, out endTok);
 			stmt = new AlternativeLoopStmt(x, endTok, invariants, new Specification<Expression>(decreases, decAttrs), new Specification<FrameExpression>(mod, modAttrs), alternatives); 
-		} else if (StartOf(20)) {
-			if (StartOf(21)) {
+		} else if (StartOf(21)) {
+			if (StartOf(22)) {
 				Guard(out guard);
 				Contract.Assume(guard == null || cce.Owner.None(guard)); 
 			} else {
 				Get();
 				guardEllipsis = t; 
 			}
-			while (StartOf(22)) {
+			while (StartOf(23)) {
 				LoopSpec(invariants, decreases, ref mod, ref decAttrs, ref modAttrs);
 			}
 			if (la.kind == _lbrace) {
@@ -2535,8 +2634,8 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			} else if (la.kind == _ellipsis) {
 				Expect(59);
 				bodyEllipsis = t; endTok = t; isDirtyLoop = false; 
-			} else if (StartOf(23)) {
-			} else SynErr(189);
+			} else if (StartOf(24)) {
+			} else SynErr(191);
 			if (guardEllipsis != null || bodyEllipsis != null) {
 			 if (mod != null) {
 			   SemErr(mod[0].E.tok, "'modifies' clauses are not allowed on refining loops");
@@ -2554,7 +2653,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 stmt = new WhileStmt(x, endTok, guard, invariants, new Specification<Expression>(decreases, decAttrs), new Specification<FrameExpression>(mod, modAttrs), body);
 			}
 			
-		} else SynErr(190);
+		} else SynErr(192);
 	}
 
 	void MatchStmt(out Statement/*!*/ s) {
@@ -2563,7 +2662,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<MatchCaseStmt/*!*/> cases = new List<MatchCaseStmt/*!*/>();
 		bool usesOptionalBrace = false;
 		
-		Expect(100);
+		Expect(101);
 		x = t; 
 		Expression(out e, true, true);
 		if (la.kind == _lbrace) {
@@ -2574,12 +2673,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				cases.Add(c); 
 			}
 			Expect(47);
-		} else if (StartOf(23)) {
+		} else if (StartOf(24)) {
 			while (la.kind == _case) {
 				CaseStatement(out c);
 				cases.Add(c); 
 			}
-		} else SynErr(191);
+		} else SynErr(193);
 		s = new MatchStmt(x, t, e, cases, usesOptionalBrace); 
 	}
 
@@ -2596,38 +2695,38 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken bodyStart, bodyEnd;
 		IToken tok = Token.NoToken;
 		
-		if (la.kind == 103) {
+		if (la.kind == 104) {
 			Get();
 			x = t; tok = x; 
-		} else if (la.kind == 104) {
+		} else if (la.kind == 105) {
 			Get();
 			x = t;
 			errors.Warning(t, "the 'parallel' keyword has been deprecated; the comprehension statement now uses the keyword 'forall' (and the parentheses around the bound variables are now optional)");
 			
-		} else SynErr(192);
+		} else SynErr(194);
 		if (la.kind == _openparen) {
 			Expect(50);
 			if (la.kind == 1) {
 				QuantifierDomain(out bvars, out attrs, out range);
 			}
 			Expect(51);
-		} else if (StartOf(24)) {
+		} else if (StartOf(25)) {
 			if (la.kind == _ident) {
 				QuantifierDomain(out bvars, out attrs, out range);
 			}
-		} else SynErr(193);
+		} else SynErr(195);
 		if (bvars == null) { bvars = new List<BoundVar>(); }
 		if (range == null) { range = new LiteralExpr(x, true); }
 		
-		while (la.kind == 88 || la.kind == 89) {
+		while (la.kind == 89 || la.kind == 90) {
 			isFree = false; 
-			if (la.kind == 88) {
+			if (la.kind == 89) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
 				
 			}
-			Expect(89);
+			Expect(90);
 			Expression(out e, false, true);
 			ens.Add(new MaybeFreeExpression(e, isFree)); 
 			OldSemi();
@@ -2666,7 +2765,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		while (IsAttribute()) {
 			Attribute(ref attrs);
 		}
-		if (StartOf(25)) {
+		if (StartOf(26)) {
 			CalcOp(out opTok, out calcOp);
 			maybeOp = calcOp.ResultOp(calcOp); // guard against non-transitive calcOp (like !=)
 			if (maybeOp == null) {
@@ -2676,11 +2775,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			
 		}
 		Expect(46);
-		while (StartOf(7)) {
+		while (StartOf(8)) {
 			Expression(out e, false, true);
 			lines.Add(e); stepOp = calcOp; danglingOperator = null; 
 			Expect(28);
-			if (StartOf(25)) {
+			if (StartOf(26)) {
 				CalcOp(out opTok, out op);
 				maybeOp = resOp.ResultOp(op);
 				if (maybeOp == null) {
@@ -2705,7 +2804,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				} else if (la.kind == 32) {
 					CalcStmt(out subCalc);
 					hintEnd = subCalc.EndTok; subhints.Add(subCalc); 
-				} else SynErr(194);
+				} else SynErr(196);
 			}
 			var h = new BlockStmt(hintStart, hintEnd, subhints); // if the hint is empty, hintStart is the first token of the next line, but it doesn't matter because the block statement is just used as a container
 			hints.Add(h);
@@ -2731,12 +2830,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		BlockStmt body = null;  IToken bodyStart;
 		IToken ellipsisToken = null;
 		
-		Expect(105);
+		Expect(106);
 		tok = t; 
 		while (IsAttribute()) {
 			Attribute(ref attrs);
 		}
-		if (StartOf(18)) {
+		if (StartOf(19)) {
 			FrameExpression(out fe, false, true);
 			mod.Add(fe); 
 			while (la.kind == 22) {
@@ -2747,14 +2846,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 59) {
 			Get();
 			ellipsisToken = t; 
-		} else SynErr(195);
+		} else SynErr(197);
 		if (la.kind == 46) {
 			BlockStmt(out body, out bodyStart, out endTok);
 		} else if (la.kind == 28) {
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(196); Get();}
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(198); Get();}
 			Get();
 			endTok = t; 
-		} else SynErr(197);
+		} else SynErr(199);
 		s = new ModifyStmt(tok, endTok, mod, attrs, body);
 		if (ellipsisToken != null) {
 		 s = new SkeletonStatement(s, ellipsisToken, null);
@@ -2768,14 +2867,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		AssignmentRhs r;
 		bool isYield = false;
 		
-		if (la.kind == 96) {
+		if (la.kind == 97) {
 			Get();
 			returnTok = t; 
-		} else if (la.kind == 90) {
+		} else if (la.kind == 91) {
 			Get();
 			returnTok = t; isYield = true; 
-		} else SynErr(198);
-		if (StartOf(26)) {
+		} else SynErr(200);
+		if (StartOf(27)) {
 			Rhs(out r);
 			rhss = new List<AssignmentRhs>(); rhss.Add(r); 
 			while (la.kind == 22) {
@@ -2800,7 +2899,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression e; 
 		Expect(59);
 		dotdotdot = t; 
-		if (la.kind == 94) {
+		if (la.kind == 95) {
 			Get();
 			names = new List<IToken>(); exprs = new List<Expression>(); whereTok = t;
 			Ident(out tok);
@@ -2810,7 +2909,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Ident(out tok);
 				names.Add(tok); 
 			}
-			Expect(95);
+			Expect(96);
 			Expression(out e, false, true);
 			exprs.Add(e); 
 			while (la.kind == 22) {
@@ -2837,7 +2936,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		r = dummyRhs;  // to please compiler
 		Attributes attrs = null;
 		
-		if (la.kind == 97) {
+		if (la.kind == 98) {
 			Get();
 			newToken = t; 
 			TypeAndToken(out x, out ty);
@@ -2852,7 +2951,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				} else {
 					x = null; args = new List<Expression/*!*/>(); 
 					Get();
-					if (StartOf(7)) {
+					if (StartOf(8)) {
 						Expressions(args);
 					}
 					Expect(51);
@@ -2869,10 +2968,10 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 57) {
 			Get();
 			r = new HavocRhs(t); 
-		} else if (StartOf(7)) {
+		} else if (StartOf(8)) {
 			Expression(out e, false, true);
 			r = new ExprRhs(e); 
-		} else SynErr(199);
+		} else SynErr(201);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -2887,13 +2986,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			while (la.kind == 27 || la.kind == 48 || la.kind == 50) {
 				Suffix(ref e);
 			}
-		} else if (StartOf(27)) {
+		} else if (StartOf(28)) {
 			ConstAtomExpression(out e, false, false);
 			Suffix(ref e);
 			while (la.kind == 27 || la.kind == 48 || la.kind == 50) {
 				Suffix(ref e);
 			}
-		} else SynErr(200);
+		} else SynErr(202);
 	}
 
 	void Expressions(List<Expression> args) {
@@ -2950,7 +3049,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			IdentTypeOptional(out bv);
 			pat = new CasePattern(bv.tok, bv);
 			
-		} else SynErr(201);
+		} else SynErr(203);
 		if (pat == null) {
 		 pat = new CasePattern(t, "_ParseError", new List<CasePattern>());
 		}
@@ -2970,12 +3069,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			if (allowExistentialGuards && IsExistentialGuard()) {
 				ExistentialGuard(out e, false );
 				isExistentialGuard = true; 
-			} else if (StartOf(7)) {
+			} else if (StartOf(8)) {
 				Expression(out e, true, false);
-			} else SynErr(202);
+			} else SynErr(204);
 			Expect(29);
 			body = new List<Statement>(); 
-			while (StartOf(15)) {
+			while (StartOf(16)) {
 				Stmt(body);
 			}
 			alternatives.Add(new GuardedAlternative(x, isExistentialGuard, e, body)); 
@@ -3015,19 +3114,19 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Expect(57);
 			Expect(51);
 			e = null; 
-		} else if (StartOf(7)) {
+		} else if (StartOf(8)) {
 			Expression(out ee, true, true);
 			e = ee; 
-		} else SynErr(203);
+		} else SynErr(205);
 	}
 
 	void LoopSpec(List<MaybeFreeExpression> invariants, List<Expression> decreases, ref List<FrameExpression> mod, ref Attributes decAttrs, ref Attributes modAttrs) {
 		Expression e; FrameExpression fe;
 		bool isFree = false; Attributes attrs = null;
 		
-		if (la.kind == 37 || la.kind == 88) {
-			while (!(la.kind == 0 || la.kind == 37 || la.kind == 88)) {SynErr(204); Get();}
-			if (la.kind == 88) {
+		if (la.kind == 37 || la.kind == 89) {
+			while (!(la.kind == 0 || la.kind == 37 || la.kind == 89)) {SynErr(206); Get();}
+			if (la.kind == 89) {
 				Get();
 				isFree = true; errors.Warning(t, "the 'free' keyword is soon to be deprecated"); 
 			}
@@ -3039,7 +3138,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			invariants.Add(new MaybeFreeExpression(e, isFree, attrs)); 
 			OldSemi();
 		} else if (la.kind == 36) {
-			while (!(la.kind == 0 || la.kind == 36)) {SynErr(205); Get();}
+			while (!(la.kind == 0 || la.kind == 36)) {SynErr(207); Get();}
 			Get();
 			while (IsAttribute()) {
 				Attribute(ref decAttrs);
@@ -3047,7 +3146,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			DecreasesList(decreases, true, true);
 			OldSemi();
 		} else if (la.kind == 43) {
-			while (!(la.kind == 0 || la.kind == 43)) {SynErr(206); Get();}
+			while (!(la.kind == 0 || la.kind == 43)) {SynErr(208); Get();}
 			Get();
 			mod = mod ?? new List<FrameExpression>(); 
 			while (IsAttribute()) {
@@ -3061,7 +3160,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				mod.Add(fe); 
 			}
 			OldSemi();
-		} else SynErr(207);
+		} else SynErr(209);
 	}
 
 	void CaseStatement(out MatchCaseStmt/*!*/ c) {
@@ -3098,12 +3197,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				arguments.Add(pat); 
 			}
 			Expect(51);
-		} else SynErr(208);
+		} else SynErr(210);
 		Expect(29);
-		while (!(StartOf(28))) {SynErr(209); Get();}
+		while (!(StartOf(29))) {SynErr(211); Get();}
 		while (IsNotEndOfCase()) {
 			Stmt(body);
-			while (!(StartOf(28))) {SynErr(210); Get();}
+			while (!(StartOf(29))) {SynErr(212); Get();}
 		}
 		c = new MatchCaseStmt(x, name, arguments, body); 
 	}
@@ -3139,7 +3238,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		case 54: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Eq; 
-			if (la.kind == 106) {
+			if (la.kind == 107) {
 				Get();
 				Expect(48);
 				Expression(out k, true, true);
@@ -3157,12 +3256,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  binOp = BinaryExpr.Opcode.Gt; 
 			break;
 		}
-		case 107: {
+		case 108: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 108: {
+		case 109: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Ge; 
 			break;
@@ -3177,32 +3276,32 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  binOp = BinaryExpr.Opcode.Neq; 
 			break;
 		}
-		case 109: {
+		case 110: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 110: {
+		case 111: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Ge; 
 			break;
 		}
-		case 111: case 112: {
+		case 112: case 113: {
 			EquivOp();
 			x = t;  binOp = BinaryExpr.Opcode.Iff; 
 			break;
 		}
-		case 113: case 114: {
+		case 114: case 115: {
 			ImpliesOp();
 			x = t;  binOp = BinaryExpr.Opcode.Imp; 
 			break;
 		}
-		case 115: case 116: {
+		case 116: case 117: {
 			ExpliesOp();
 			x = t;  binOp = BinaryExpr.Opcode.Exp; 
 			break;
 		}
-		default: SynErr(211); break;
+		default: SynErr(213); break;
 		}
 		if (k == null) {
 		 op = new Microsoft.Dafny.CalcStmt.BinaryCalcOp(binOp);
@@ -3213,67 +3312,67 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 	}
 
 	void EquivOp() {
-		if (la.kind == 111) {
+		if (la.kind == 112) {
 			Get();
-		} else if (la.kind == 112) {
+		} else if (la.kind == 113) {
 			Get();
-		} else SynErr(212);
+		} else SynErr(214);
 	}
 
 	void ImpliesOp() {
-		if (la.kind == 113) {
+		if (la.kind == 114) {
 			Get();
-		} else if (la.kind == 114) {
+		} else if (la.kind == 115) {
 			Get();
-		} else SynErr(213);
+		} else SynErr(215);
 	}
 
 	void ExpliesOp() {
-		if (la.kind == 115) {
+		if (la.kind == 116) {
 			Get();
-		} else if (la.kind == 116) {
+		} else if (la.kind == 117) {
 			Get();
-		} else SynErr(214);
+		} else SynErr(216);
 	}
 
 	void AndOp() {
-		if (la.kind == 117) {
+		if (la.kind == 118) {
 			Get();
-		} else if (la.kind == 118) {
+		} else if (la.kind == 119) {
 			Get();
-		} else SynErr(215);
+		} else SynErr(217);
 	}
 
 	void OrOp() {
-		if (la.kind == 119) {
+		if (la.kind == 120) {
 			Get();
-		} else if (la.kind == 120) {
+		} else if (la.kind == 121) {
 			Get();
-		} else SynErr(216);
+		} else SynErr(218);
 	}
 
 	void NegOp() {
-		if (la.kind == 121) {
+		if (la.kind == 122) {
 			Get();
-		} else if (la.kind == 122) {
+		} else if (la.kind == 123) {
 			Get();
-		} else SynErr(217);
+		} else SynErr(219);
 	}
 
 	void Forall() {
-		if (la.kind == 103) {
+		if (la.kind == 104) {
 			Get();
-		} else if (la.kind == 123) {
+		} else if (la.kind == 124) {
 			Get();
-		} else SynErr(218);
+		} else SynErr(220);
 	}
 
 	void Exists() {
-		if (la.kind == 124) {
+		if (la.kind == 125) {
 			Get();
-		} else if (la.kind == 125) {
+		} else if (la.kind == 126) {
 			Get();
-		} else SynErr(219);
+		} else SynErr(221);
 	}
 
 	void QSep() {
@@ -3281,7 +3380,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 		} else if (la.kind == 26) {
 			Get();
-		} else SynErr(220);
+		} else SynErr(222);
 	}
 
 	void EquivExpression(out Expression e0, bool allowSemi, bool allowLambda) {
@@ -3299,12 +3398,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Ensures(Contract.ValueAtReturn(out e0) != null); IToken/*!*/ x;  Expression/*!*/ e1; 
 		LogicalExpression(out e0, allowSemi, allowLambda);
 		if (IsImpliesOp() || IsExpliesOp()) {
-			if (la.kind == 113 || la.kind == 114) {
+			if (la.kind == 114 || la.kind == 115) {
 				ImpliesOp();
 				x = t; 
 				ImpliesExpression(out e1, allowSemi, allowLambda);
 				e0 = new BinaryExpr(x, BinaryExpr.Opcode.Imp, e0, e1); 
-			} else if (la.kind == 115 || la.kind == 116) {
+			} else if (la.kind == 116 || la.kind == 117) {
 				ExpliesOp();
 				x = t; 
 				LogicalExpression(out e1, allowSemi, allowLambda);
@@ -3316,7 +3415,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					e0 = new BinaryExpr(x, BinaryExpr.Opcode.Exp, e1, e0); 
 					
 				}
-			} else SynErr(221);
+			} else SynErr(223);
 		}
 	}
 
@@ -3324,7 +3423,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Ensures(Contract.ValueAtReturn(out e0) != null); IToken/*!*/ x;  Expression/*!*/ e1; 
 		RelationalExpression(out e0, allowSemi, allowLambda);
 		if (IsAndOp() || IsOrOp()) {
-			if (la.kind == 117 || la.kind == 118) {
+			if (la.kind == 118 || la.kind == 119) {
 				AndOp();
 				x = t; 
 				RelationalExpression(out e1, allowSemi, allowLambda);
@@ -3335,7 +3434,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					RelationalExpression(out e1, allowSemi, allowLambda);
 					e0 = new BinaryExpr(x, BinaryExpr.Opcode.And, e0, e1); 
 				}
-			} else if (la.kind == 119 || la.kind == 120) {
+			} else if (la.kind == 120 || la.kind == 121) {
 				OrOp();
 				x = t; 
 				RelationalExpression(out e1, allowSemi, allowLambda);
@@ -3346,7 +3445,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					RelationalExpression(out e1, allowSemi, allowLambda);
 					e0 = new BinaryExpr(x, BinaryExpr.Opcode.Or, e0, e1); 
 				}
-			} else SynErr(222);
+			} else SynErr(224);
 		}
 	}
 
@@ -3482,7 +3581,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		case 54: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Eq; 
-			if (la.kind == 106) {
+			if (la.kind == 107) {
 				Get();
 				Expect(48);
 				Expression(out k, true, true);
@@ -3500,12 +3599,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.Gt; 
 			break;
 		}
-		case 107: {
+		case 108: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 108: {
+		case 109: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Ge; 
 			break;
@@ -3513,7 +3612,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		case 55: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Neq; 
-			if (la.kind == 106) {
+			if (la.kind == 107) {
 				Get();
 				Expect(48);
 				Expression(out k, true, true);
@@ -3521,7 +3620,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			break;
 		}
-		case 126: {
+		case 127: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.In; 
 			break;
@@ -3531,11 +3630,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.NotIn; 
 			break;
 		}
-		case 121: {
+		case 122: {
 			Get();
 			x = t;  y = Token.NoToken; 
 			if (la.val == "!") {
-				Expect(121);
+				Expect(122);
 				y = t; 
 			}
 			if (y == Token.NoToken) {
@@ -3554,17 +3653,17 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.Neq; 
 			break;
 		}
-		case 109: {
+		case 110: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 110: {
+		case 111: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Ge; 
 			break;
 		}
-		default: SynErr(223); break;
+		default: SynErr(225); break;
 		}
 	}
 
@@ -3580,23 +3679,23 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void AddOp(out IToken x, out BinaryExpr.Opcode op) {
 		Contract.Ensures(Contract.ValueAtReturn(out x) != null); x = Token.NoToken;  op=BinaryExpr.Opcode.Add/*(dummy)*/; 
-		if (la.kind == 127) {
+		if (la.kind == 128) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Add; 
-		} else if (la.kind == 128) {
+		} else if (la.kind == 129) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Sub; 
-		} else SynErr(224);
+		} else SynErr(226);
 	}
 
 	void UnaryExpression(out Expression e, bool allowSemi, bool allowLambda) {
 		Contract.Ensures(Contract.ValueAtReturn(out e) != null); IToken/*!*/ x;  e = dummyExpr; 
-		if (la.kind == 128) {
+		if (la.kind == 129) {
 			Get();
 			x = t; 
 			UnaryExpression(out e, allowSemi, allowLambda);
 			e = new NegationExpression(x, e); 
-		} else if (la.kind == 121 || la.kind == 122) {
+		} else if (la.kind == 122 || la.kind == 123) {
 			NegOp();
 			x = t; 
 			UnaryExpression(out e, allowSemi, allowLambda);
@@ -3624,7 +3723,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 		} else if (IsLambda(allowLambda)) {
 			LambdaExpression(out e, allowSemi);
-		} else if (StartOf(29)) {
+		} else if (StartOf(30)) {
 			EndlessExpression(out e, allowSemi, allowLambda);
 		} else if (la.kind == 1) {
 			NameSegment(out e);
@@ -3641,12 +3740,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			while (IsSuffix()) {
 				Suffix(ref e);
 			}
-		} else if (StartOf(27)) {
+		} else if (StartOf(28)) {
 			ConstAtomExpression(out e, allowSemi, allowLambda);
 			while (IsSuffix()) {
 				Suffix(ref e);
 			}
-		} else SynErr(225);
+		} else SynErr(227);
 	}
 
 	void MulOp(out IToken x, out BinaryExpr.Opcode op) {
@@ -3654,13 +3753,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 57) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Mul; 
-		} else if (la.kind == 129) {
+		} else if (la.kind == 130) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Div; 
-		} else if (la.kind == 130) {
+		} else if (la.kind == 131) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Mod; 
-		} else SynErr(226);
+		} else SynErr(228);
 	}
 
 	void MapDisplayExpr(IToken/*!*/ mapToken, bool finite, out Expression e) {
@@ -3669,7 +3768,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;
 		
 		Expect(48);
-		if (StartOf(7)) {
+		if (StartOf(8)) {
 			MapLiteralExpressions(out elements);
 		}
 		e = new MapDisplayExpr(mapToken, finite, elements);
@@ -3699,7 +3798,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				}
 				Expect(51);
 				e = new DatatypeUpdateExpr(x, e, updates); 
-			} else if (StartOf(30)) {
+			} else if (StartOf(31)) {
 				DotSuffix(out id, out x);
 				if (x != null) {
 				 // process id as a Suffix in its own right
@@ -3711,30 +3810,30 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				if (IsGenericInstantiation()) {
 					typeArgs = new List<Type>(); 
 					GenericInstantiation(typeArgs);
-				} else if (la.kind == 106) {
+				} else if (la.kind == 107) {
 					HashCall(id, out openParen, out typeArgs, out args);
-				} else if (StartOf(31)) {
-				} else SynErr(227);
+				} else if (StartOf(32)) {
+				} else SynErr(229);
 				e = new ExprDotName(id, e, id.val, typeArgs);
 				if (openParen != null) {
 				 e = new ApplySuffix(openParen, e, args);
 				}
 				
-			} else SynErr(228);
+			} else SynErr(230);
 		} else if (la.kind == 48) {
 			Get();
 			x = t; 
-			if (StartOf(7)) {
+			if (StartOf(8)) {
 				Expression(out ee, true, true);
 				e0 = ee; 
-				if (la.kind == 137) {
+				if (la.kind == 138) {
 					Get();
 					anyDots = true; 
-					if (StartOf(7)) {
+					if (StartOf(8)) {
 						Expression(out ee, true, true);
 						e1 = ee; 
 					}
-				} else if (la.kind == 95) {
+				} else if (la.kind == 96) {
 					Get();
 					Expression(out ee, true, true);
 					e1 = ee; 
@@ -3744,7 +3843,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					multipleLengths.Add(e0);  // account for the Expression read before the colon
 					takeRest = true;
 					
-					if (StartOf(7)) {
+					if (StartOf(8)) {
 						Expression(out ee, true, true);
 						multipleLengths.Add(ee); takeRest = false; 
 						while (IsNonFinalColon()) {
@@ -3768,15 +3867,15 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 						multipleIndices.Add(ee);
 						
 					}
-				} else SynErr(229);
-			} else if (la.kind == 137) {
+				} else SynErr(231);
+			} else if (la.kind == 138) {
 				Get();
 				anyDots = true; 
-				if (StartOf(7)) {
+				if (StartOf(8)) {
 					Expression(out ee, true, true);
 					e1 = ee; 
 				}
-			} else SynErr(230);
+			} else SynErr(232);
 			if (multipleIndices != null) {
 			 e = new MultiSelectExpr(x, e, multipleIndices);
 			 // make sure an array class with this dimensionality exists
@@ -3815,12 +3914,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 50) {
 			Get();
 			IToken openParen = t; var args = new List<Expression>(); 
-			if (StartOf(7)) {
+			if (StartOf(8)) {
 				Expressions(args);
 			}
 			Expect(51);
 			e = new ApplySuffix(openParen, e, args); 
-		} else SynErr(231);
+		} else SynErr(233);
 	}
 
 	void ISetDisplayExpr(IToken/*!*/ setToken, bool finite, out Expression e) {
@@ -3829,7 +3928,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;
 		
 		Expect(46);
-		if (StartOf(7)) {
+		if (StartOf(8)) {
 			Expressions(elements);
 		}
 		e = new SetDisplayExpr(setToken, finite, elements);
@@ -3862,7 +3961,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				}
 			}
 			Expect(51);
-		} else SynErr(232);
+		} else SynErr(234);
 		while (la.kind == 44 || la.kind == 45) {
 			if (la.kind == 44) {
 				Get();
@@ -3888,7 +3987,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;
 		
 		switch (la.kind) {
-		case 98: {
+		case 99: {
 			Get();
 			x = t; 
 			Expression(out e, true, true);
@@ -3899,11 +3998,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			e = new ITEExpr(x, e, e0, e1); 
 			break;
 		}
-		case 100: {
+		case 101: {
 			MatchExpression(out e, allowSemi, allowLambda);
 			break;
 		}
-		case 103: case 123: case 124: case 125: {
+		case 104: case 124: case 125: case 126: {
 			QuantifierGuts(out e, allowSemi, allowLambda);
 			break;
 		}
@@ -3919,13 +4018,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			SetComprehensionExpr(x, false, out e, allowSemi, allowLambda);
 			break;
 		}
-		case 31: case 32: case 101: {
+		case 31: case 32: case 102: {
 			StmtInExpr(out s);
 			Expression(out e, allowSemi, allowLambda);
 			e = new StmtExpr(s.Tok, s, e); 
 			break;
 		}
-		case 73: case 78: {
+		case 62: case 79: {
 			LetExpr(out e, allowSemi, allowLambda);
 			break;
 		}
@@ -3941,11 +4040,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			MapComprehensionExpr(x, false, out e, allowSemi, allowLambda);
 			break;
 		}
-		case 92: {
+		case 93: {
 			NamedExpr(out e, allowSemi, allowLambda);
 			break;
 		}
-		default: SynErr(233); break;
+		default: SynErr(235); break;
 		}
 	}
 
@@ -3957,10 +4056,10 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (IsGenericInstantiation()) {
 			typeArgs = new List<Type>(); 
 			GenericInstantiation(typeArgs);
-		} else if (la.kind == 106) {
+		} else if (la.kind == 107) {
 			HashCall(id, out openParen, out typeArgs, out args);
-		} else if (StartOf(31)) {
-		} else SynErr(234);
+		} else if (StartOf(32)) {
+		} else SynErr(236);
 		e = new NameSegment(id, id.val, typeArgs);
 		if (openParen != null) {
 		 e = new ApplySuffix(openParen, e, args);
@@ -3976,7 +4075,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 46) {
 			Get();
 			x = t;  elements = new List<Expression/*!*/>(); 
-			if (StartOf(7)) {
+			if (StartOf(8)) {
 				Expressions(elements);
 			}
 			e = new SetDisplayExpr(x, true, elements);
@@ -3984,12 +4083,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 48) {
 			Get();
 			x = t;  elements = new List<Expression/*!*/>(); 
-			if (StartOf(7)) {
+			if (StartOf(8)) {
 				Expressions(elements);
 			}
 			e = new SeqDisplayExpr(x, elements); 
 			Expect(49);
-		} else SynErr(235);
+		} else SynErr(237);
 	}
 
 	void MultiSetExpr(out Expression e) {
@@ -4002,7 +4101,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 46) {
 			Get();
 			elements = new List<Expression/*!*/>(); 
-			if (StartOf(7)) {
+			if (StartOf(8)) {
 				Expressions(elements);
 			}
 			e = new MultiSetDisplayExpr(x, elements);
@@ -4013,7 +4112,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Expression(out e, true, true);
 			e = new MultiSetFormingExpr(x, e); 
 			Expect(51);
-		} else SynErr(236);
+		} else SynErr(238);
 	}
 
 	void ConstAtomExpression(out Expression e, bool allowSemi, bool allowLambda) {
@@ -4022,17 +4121,17 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;  Type toType = null;
 		
 		switch (la.kind) {
-		case 131: {
+		case 132: {
 			Get();
 			e = new LiteralExpr(t, false); 
 			break;
 		}
-		case 132: {
+		case 133: {
 			Get();
 			e = new LiteralExpr(t, true); 
 			break;
 		}
-		case 133: {
+		case 134: {
 			Get();
 			e = new LiteralExpr(t); 
 			break;
@@ -4060,12 +4159,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			
 			break;
 		}
-		case 134: {
+		case 135: {
 			Get();
 			e = new ThisExpr(t); 
 			break;
 		}
-		case 135: {
+		case 136: {
 			Get();
 			x = t; 
 			Expect(50);
@@ -4074,7 +4173,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Fresh, e); 
 			break;
 		}
-		case 136: {
+		case 137: {
 			Get();
 			x = t; 
 			Expect(50);
@@ -4109,7 +4208,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			ParensExpression(out e, allowSemi, allowLambda);
 			break;
 		}
-		default: SynErr(237); break;
+		default: SynErr(239); break;
 		}
 	}
 
@@ -4138,7 +4237,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 n = BigInteger.Zero;
 			}
 			
-		} else SynErr(238);
+		} else SynErr(240);
 	}
 
 	void Dec(out Basetypes.BigDec d) {
@@ -4160,7 +4259,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		
 		Expect(50);
 		x = t; 
-		if (StartOf(7)) {
+		if (StartOf(8)) {
 			Expressions(args);
 		}
 		Expect(51);
@@ -4182,20 +4281,20 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 30) {
 			Get();
 			oneShot = true; 
-		} else SynErr(239);
+		} else SynErr(241);
 	}
 
 	void MapLiteralExpressions(out List<ExpressionPair> elements) {
 		Expression/*!*/ d, r;
 		elements = new List<ExpressionPair/*!*/>(); 
 		Expression(out d, true, true);
-		Expect(95);
+		Expect(96);
 		Expression(out r, true, true);
 		elements.Add(new ExpressionPair(d,r)); 
 		while (la.kind == 22) {
 			Get();
 			Expression(out d, true, true);
-			Expect(95);
+			Expect(96);
 			Expression(out r, true, true);
 			elements.Add(new ExpressionPair(d,r)); 
 		}
@@ -4229,7 +4328,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<MatchCaseExpr/*!*/> cases = new List<MatchCaseExpr/*!*/>();
 		bool usesOptionalBrace = false;
 		
-		Expect(100);
+		Expect(101);
 		x = t; 
 		Expression(out e, allowSemi, allowLambda);
 		if (la.kind == _lbrace) {
@@ -4240,12 +4339,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				cases.Add(c); 
 			}
 			Expect(47);
-		} else if (StartOf(32)) {
+		} else if (StartOf(33)) {
 			while (la.kind == _case) {
 				CaseExpression(out c, allowSemi, allowLambda);
 				cases.Add(c); 
 			}
-		} else SynErr(240);
+		} else SynErr(242);
 		e = new MatchExpr(x, e, cases, usesOptionalBrace); 
 	}
 
@@ -4257,13 +4356,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression range;
 		Expression/*!*/ body;
 		
-		if (la.kind == 103 || la.kind == 123) {
+		if (la.kind == 104 || la.kind == 124) {
 			Forall();
 			x = t;  univ = true; 
-		} else if (la.kind == 124 || la.kind == 125) {
+		} else if (la.kind == 125 || la.kind == 126) {
 			Exists();
 			x = t; 
-		} else SynErr(241);
+		} else SynErr(243);
 		QuantifierDomain(out bvars, out attrs, out range);
 		QSep();
 		Expression(out body, allowSemi, allowLambda);
@@ -4306,13 +4405,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void StmtInExpr(out Statement s) {
 		s = dummyStmt; 
-		if (la.kind == 101) {
+		if (la.kind == 102) {
 			AssertStmt(out s);
 		} else if (la.kind == 31) {
 			AssumeStmt(out s);
 		} else if (la.kind == 32) {
 			CalcStmt(out s);
-		} else SynErr(242);
+		} else SynErr(244);
 	}
 
 	void LetExpr(out Expression e, bool allowSemi, bool allowLambda) {
@@ -4325,11 +4424,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Attributes attrs = null;
 		e = dummyExpr;
 		
-		if (la.kind == 73) {
+		if (la.kind == 62) {
 			Get();
 			isGhost = true;  x = t; 
 		}
-		Expect(78);
+		Expect(79);
 		if (!isGhost) { x = t; } 
 		CasePattern(out pat);
 		if (isGhost) { pat.Vars.Iter(bv => bv.IsGhost = true); }
@@ -4342,7 +4441,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			letLHSs.Add(pat);
 			
 		}
-		if (la.kind == 95) {
+		if (la.kind == 96) {
 			Get();
 		} else if (la.kind == 25 || la.kind == 46) {
 			while (la.kind == 46) {
@@ -4356,7 +4455,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 }
 			}
 			
-		} else SynErr(243);
+		} else SynErr(245);
 		Expression(out e, false, true);
 		letRHSs.Add(e); 
 		while (la.kind == 22) {
@@ -4374,7 +4473,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;
 		Expression expr;
 		
-		Expect(92);
+		Expect(93);
 		x = t; 
 		NoUSIdent(out d);
 		Expect(21);
@@ -4416,7 +4515,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				arguments.Add(pat); 
 			}
 			Expect(51);
-		} else SynErr(244);
+		} else SynErr(246);
 		Expect(29);
 		Expression(out body, allowSemi, allowLambda);
 		c = new MatchCaseExpr(x, name, arguments, body); 
@@ -4424,7 +4523,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void HashCall(IToken id, out IToken openParen, out List<Type> typeArgs, out List<Expression> args) {
 		Expression k; args = new List<Expression>(); typeArgs = null; 
-		Expect(106);
+		Expect(107);
 		id.val = id.val + "#"; 
 		if (la.kind == 52) {
 			typeArgs = new List<Type>(); 
@@ -4436,7 +4535,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		args.Add(k); 
 		Expect(50);
 		openParen = t; 
-		if (StartOf(7)) {
+		if (StartOf(8)) {
 			Expressions(args);
 		}
 		Expect(51);
@@ -4450,8 +4549,8 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 2) {
 			Get();
 			id = t; 
-		} else SynErr(245);
-		Expect(95);
+		} else SynErr(247);
+		Expect(96);
 		Expression(out e, true, true);
 	}
 
@@ -4493,7 +4592,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 44) {
 			Get();
 			x = t; 
-		} else SynErr(246);
+		} else SynErr(248);
 	}
 
 
@@ -4508,39 +4607,40 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 	}
 
 	static readonly bool[,] set = {
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_T, _T,_T,_x,_x, _T,_T,_x,_x, _T,_T,_x,_T, _T,_T,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_x, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_T, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _x,_x,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _T,_T,_T,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_T,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_x,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_x, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_x,_x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_T,_x, _T,_T,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x}
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_T, _T,_T,_x,_x, _T,_T,_x,_x, _T,_T,_x,_T, _T,_T,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _x,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_x, _x,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_T,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_T, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_x, _x,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _x,_x,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_x, _x,_T,_T,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_x,_x,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x}
 
 	};
 } // end Parser
@@ -4630,191 +4730,193 @@ public class Errors {
 			case 59: s = "ellipsis expected"; break;
 			case 60: s = "\"include\" expected"; break;
 			case 61: s = "\"abstract\" expected"; break;
-			case 62: s = "\"module\" expected"; break;
-			case 63: s = "\"exclusively\" expected"; break;
-			case 64: s = "\"refines\" expected"; break;
-			case 65: s = "\"import\" expected"; break;
-			case 66: s = "\"opened\" expected"; break;
-			case 67: s = "\"=\" expected"; break;
-			case 68: s = "\"as\" expected"; break;
-			case 69: s = "\"default\" expected"; break;
-			case 70: s = "\"class\" expected"; break;
-			case 71: s = "\"extends\" expected"; break;
-			case 72: s = "\"trait\" expected"; break;
-			case 73: s = "\"ghost\" expected"; break;
-			case 74: s = "\"static\" expected"; break;
-			case 75: s = "\"protected\" expected"; break;
-			case 76: s = "\"datatype\" expected"; break;
-			case 77: s = "\"codatatype\" expected"; break;
-			case 78: s = "\"var\" expected"; break;
-			case 79: s = "\"newtype\" expected"; break;
-			case 80: s = "\"type\" expected"; break;
-			case 81: s = "\"iterator\" expected"; break;
-			case 82: s = "\"yields\" expected"; break;
-			case 83: s = "\"returns\" expected"; break;
-			case 84: s = "\"method\" expected"; break;
-			case 85: s = "\"colemma\" expected"; break;
-			case 86: s = "\"comethod\" expected"; break;
-			case 87: s = "\"constructor\" expected"; break;
-			case 88: s = "\"free\" expected"; break;
-			case 89: s = "\"ensures\" expected"; break;
-			case 90: s = "\"yield\" expected"; break;
-			case 91: s = "\"`\" expected"; break;
-			case 92: s = "\"label\" expected"; break;
-			case 93: s = "\"break\" expected"; break;
-			case 94: s = "\"where\" expected"; break;
-			case 95: s = "\":=\" expected"; break;
-			case 96: s = "\"return\" expected"; break;
-			case 97: s = "\"new\" expected"; break;
-			case 98: s = "\"if\" expected"; break;
-			case 99: s = "\"while\" expected"; break;
-			case 100: s = "\"match\" expected"; break;
-			case 101: s = "\"assert\" expected"; break;
-			case 102: s = "\"print\" expected"; break;
-			case 103: s = "\"forall\" expected"; break;
-			case 104: s = "\"parallel\" expected"; break;
-			case 105: s = "\"modify\" expected"; break;
-			case 106: s = "\"#\" expected"; break;
-			case 107: s = "\"<=\" expected"; break;
-			case 108: s = "\">=\" expected"; break;
-			case 109: s = "\"\\u2264\" expected"; break;
-			case 110: s = "\"\\u2265\" expected"; break;
-			case 111: s = "\"<==>\" expected"; break;
-			case 112: s = "\"\\u21d4\" expected"; break;
-			case 113: s = "\"==>\" expected"; break;
-			case 114: s = "\"\\u21d2\" expected"; break;
-			case 115: s = "\"<==\" expected"; break;
-			case 116: s = "\"\\u21d0\" expected"; break;
-			case 117: s = "\"&&\" expected"; break;
-			case 118: s = "\"\\u2227\" expected"; break;
-			case 119: s = "\"||\" expected"; break;
-			case 120: s = "\"\\u2228\" expected"; break;
-			case 121: s = "\"!\" expected"; break;
-			case 122: s = "\"\\u00ac\" expected"; break;
-			case 123: s = "\"\\u2200\" expected"; break;
-			case 124: s = "\"exists\" expected"; break;
-			case 125: s = "\"\\u2203\" expected"; break;
-			case 126: s = "\"in\" expected"; break;
-			case 127: s = "\"+\" expected"; break;
-			case 128: s = "\"-\" expected"; break;
-			case 129: s = "\"/\" expected"; break;
-			case 130: s = "\"%\" expected"; break;
-			case 131: s = "\"false\" expected"; break;
-			case 132: s = "\"true\" expected"; break;
-			case 133: s = "\"null\" expected"; break;
-			case 134: s = "\"this\" expected"; break;
-			case 135: s = "\"fresh\" expected"; break;
-			case 136: s = "\"old\" expected"; break;
-			case 137: s = "\"..\" expected"; break;
-			case 138: s = "??? expected"; break;
-			case 139: s = "this symbol not expected in SubModuleDecl"; break;
-			case 140: s = "invalid SubModuleDecl"; break;
-			case 141: s = "this symbol not expected in ClassDecl"; break;
-			case 142: s = "this symbol not expected in DatatypeDecl"; break;
-			case 143: s = "invalid DatatypeDecl"; break;
+			case 62: s = "\"ghost\" expected"; break;
+			case 63: s = "\"static\" expected"; break;
+			case 64: s = "\"protected\" expected"; break;
+			case 65: s = "\"extern\" expected"; break;
+			case 66: s = "\"module\" expected"; break;
+			case 67: s = "\"exclusively\" expected"; break;
+			case 68: s = "\"refines\" expected"; break;
+			case 69: s = "\"import\" expected"; break;
+			case 70: s = "\"opened\" expected"; break;
+			case 71: s = "\"=\" expected"; break;
+			case 72: s = "\"as\" expected"; break;
+			case 73: s = "\"default\" expected"; break;
+			case 74: s = "\"class\" expected"; break;
+			case 75: s = "\"extends\" expected"; break;
+			case 76: s = "\"trait\" expected"; break;
+			case 77: s = "\"datatype\" expected"; break;
+			case 78: s = "\"codatatype\" expected"; break;
+			case 79: s = "\"var\" expected"; break;
+			case 80: s = "\"newtype\" expected"; break;
+			case 81: s = "\"type\" expected"; break;
+			case 82: s = "\"iterator\" expected"; break;
+			case 83: s = "\"yields\" expected"; break;
+			case 84: s = "\"returns\" expected"; break;
+			case 85: s = "\"method\" expected"; break;
+			case 86: s = "\"colemma\" expected"; break;
+			case 87: s = "\"comethod\" expected"; break;
+			case 88: s = "\"constructor\" expected"; break;
+			case 89: s = "\"free\" expected"; break;
+			case 90: s = "\"ensures\" expected"; break;
+			case 91: s = "\"yield\" expected"; break;
+			case 92: s = "\"`\" expected"; break;
+			case 93: s = "\"label\" expected"; break;
+			case 94: s = "\"break\" expected"; break;
+			case 95: s = "\"where\" expected"; break;
+			case 96: s = "\":=\" expected"; break;
+			case 97: s = "\"return\" expected"; break;
+			case 98: s = "\"new\" expected"; break;
+			case 99: s = "\"if\" expected"; break;
+			case 100: s = "\"while\" expected"; break;
+			case 101: s = "\"match\" expected"; break;
+			case 102: s = "\"assert\" expected"; break;
+			case 103: s = "\"print\" expected"; break;
+			case 104: s = "\"forall\" expected"; break;
+			case 105: s = "\"parallel\" expected"; break;
+			case 106: s = "\"modify\" expected"; break;
+			case 107: s = "\"#\" expected"; break;
+			case 108: s = "\"<=\" expected"; break;
+			case 109: s = "\">=\" expected"; break;
+			case 110: s = "\"\\u2264\" expected"; break;
+			case 111: s = "\"\\u2265\" expected"; break;
+			case 112: s = "\"<==>\" expected"; break;
+			case 113: s = "\"\\u21d4\" expected"; break;
+			case 114: s = "\"==>\" expected"; break;
+			case 115: s = "\"\\u21d2\" expected"; break;
+			case 116: s = "\"<==\" expected"; break;
+			case 117: s = "\"\\u21d0\" expected"; break;
+			case 118: s = "\"&&\" expected"; break;
+			case 119: s = "\"\\u2227\" expected"; break;
+			case 120: s = "\"||\" expected"; break;
+			case 121: s = "\"\\u2228\" expected"; break;
+			case 122: s = "\"!\" expected"; break;
+			case 123: s = "\"\\u00ac\" expected"; break;
+			case 124: s = "\"\\u2200\" expected"; break;
+			case 125: s = "\"exists\" expected"; break;
+			case 126: s = "\"\\u2203\" expected"; break;
+			case 127: s = "\"in\" expected"; break;
+			case 128: s = "\"+\" expected"; break;
+			case 129: s = "\"-\" expected"; break;
+			case 130: s = "\"/\" expected"; break;
+			case 131: s = "\"%\" expected"; break;
+			case 132: s = "\"false\" expected"; break;
+			case 133: s = "\"true\" expected"; break;
+			case 134: s = "\"null\" expected"; break;
+			case 135: s = "\"this\" expected"; break;
+			case 136: s = "\"fresh\" expected"; break;
+			case 137: s = "\"old\" expected"; break;
+			case 138: s = "\"..\" expected"; break;
+			case 139: s = "??? expected"; break;
+			case 140: s = "invalid TopDecl"; break;
+			case 141: s = "this symbol not expected in SubModuleDecl"; break;
+			case 142: s = "invalid SubModuleDecl"; break;
+			case 143: s = "this symbol not expected in ClassDecl"; break;
 			case 144: s = "this symbol not expected in DatatypeDecl"; break;
-			case 145: s = "invalid NewtypeDecl"; break;
-			case 146: s = "invalid OtherTypeDecl"; break;
-			case 147: s = "this symbol not expected in OtherTypeDecl"; break;
-			case 148: s = "this symbol not expected in IteratorDecl"; break;
-			case 149: s = "invalid IteratorDecl"; break;
-			case 150: s = "this symbol not expected in TraitDecl"; break;
-			case 151: s = "invalid ClassMemberDecl"; break;
-			case 152: s = "this symbol not expected in FieldDecl"; break;
-			case 153: s = "invalid FunctionDecl"; break;
-			case 154: s = "invalid FunctionDecl"; break;
+			case 145: s = "invalid DatatypeDecl"; break;
+			case 146: s = "this symbol not expected in DatatypeDecl"; break;
+			case 147: s = "invalid NewtypeDecl"; break;
+			case 148: s = "invalid OtherTypeDecl"; break;
+			case 149: s = "this symbol not expected in OtherTypeDecl"; break;
+			case 150: s = "this symbol not expected in IteratorDecl"; break;
+			case 151: s = "invalid IteratorDecl"; break;
+			case 152: s = "this symbol not expected in TraitDecl"; break;
+			case 153: s = "invalid ClassMemberDecl"; break;
+			case 154: s = "this symbol not expected in FieldDecl"; break;
 			case 155: s = "invalid FunctionDecl"; break;
 			case 156: s = "invalid FunctionDecl"; break;
 			case 157: s = "invalid FunctionDecl"; break;
-			case 158: s = "this symbol not expected in MethodDecl"; break;
-			case 159: s = "invalid MethodDecl"; break;
-			case 160: s = "invalid MethodDecl"; break;
-			case 161: s = "invalid FIdentType"; break;
-			case 162: s = "this symbol not expected in OldSemi"; break;
-			case 163: s = "invalid TypeIdentOptional"; break;
-			case 164: s = "invalid TypeAndToken"; break;
-			case 165: s = "this symbol not expected in IteratorSpec"; break;
-			case 166: s = "invalid IteratorSpec"; break;
-			case 167: s = "invalid IteratorSpec"; break;
-			case 168: s = "this symbol not expected in MethodSpec"; break;
-			case 169: s = "invalid MethodSpec"; break;
-			case 170: s = "invalid MethodSpec"; break;
-			case 171: s = "invalid FrameExpression"; break;
-			case 172: s = "this symbol not expected in FunctionSpec"; break;
-			case 173: s = "invalid FunctionSpec"; break;
-			case 174: s = "invalid PossiblyWildFrameExpression"; break;
-			case 175: s = "invalid PossiblyWildExpression"; break;
-			case 176: s = "this symbol not expected in OneStmt"; break;
-			case 177: s = "invalid OneStmt"; break;
+			case 158: s = "invalid FunctionDecl"; break;
+			case 159: s = "invalid FunctionDecl"; break;
+			case 160: s = "this symbol not expected in MethodDecl"; break;
+			case 161: s = "invalid MethodDecl"; break;
+			case 162: s = "invalid MethodDecl"; break;
+			case 163: s = "invalid FIdentType"; break;
+			case 164: s = "this symbol not expected in OldSemi"; break;
+			case 165: s = "invalid TypeIdentOptional"; break;
+			case 166: s = "invalid TypeAndToken"; break;
+			case 167: s = "this symbol not expected in IteratorSpec"; break;
+			case 168: s = "invalid IteratorSpec"; break;
+			case 169: s = "invalid IteratorSpec"; break;
+			case 170: s = "this symbol not expected in MethodSpec"; break;
+			case 171: s = "invalid MethodSpec"; break;
+			case 172: s = "invalid MethodSpec"; break;
+			case 173: s = "invalid FrameExpression"; break;
+			case 174: s = "this symbol not expected in FunctionSpec"; break;
+			case 175: s = "invalid FunctionSpec"; break;
+			case 176: s = "invalid PossiblyWildFrameExpression"; break;
+			case 177: s = "invalid PossiblyWildExpression"; break;
 			case 178: s = "this symbol not expected in OneStmt"; break;
 			case 179: s = "invalid OneStmt"; break;
-			case 180: s = "invalid AssertStmt"; break;
-			case 181: s = "invalid AssumeStmt"; break;
-			case 182: s = "invalid UpdateStmt"; break;
-			case 183: s = "invalid UpdateStmt"; break;
-			case 184: s = "this symbol not expected in VarDeclStatement"; break;
-			case 185: s = "invalid VarDeclStatement"; break;
-			case 186: s = "invalid VarDeclStatement"; break;
-			case 187: s = "invalid IfStmt"; break;
-			case 188: s = "invalid IfStmt"; break;
-			case 189: s = "invalid WhileStmt"; break;
-			case 190: s = "invalid WhileStmt"; break;
-			case 191: s = "invalid MatchStmt"; break;
-			case 192: s = "invalid ForallStmt"; break;
-			case 193: s = "invalid ForallStmt"; break;
-			case 194: s = "invalid CalcStmt"; break;
-			case 195: s = "invalid ModifyStmt"; break;
-			case 196: s = "this symbol not expected in ModifyStmt"; break;
+			case 180: s = "this symbol not expected in OneStmt"; break;
+			case 181: s = "invalid OneStmt"; break;
+			case 182: s = "invalid AssertStmt"; break;
+			case 183: s = "invalid AssumeStmt"; break;
+			case 184: s = "invalid UpdateStmt"; break;
+			case 185: s = "invalid UpdateStmt"; break;
+			case 186: s = "this symbol not expected in VarDeclStatement"; break;
+			case 187: s = "invalid VarDeclStatement"; break;
+			case 188: s = "invalid VarDeclStatement"; break;
+			case 189: s = "invalid IfStmt"; break;
+			case 190: s = "invalid IfStmt"; break;
+			case 191: s = "invalid WhileStmt"; break;
+			case 192: s = "invalid WhileStmt"; break;
+			case 193: s = "invalid MatchStmt"; break;
+			case 194: s = "invalid ForallStmt"; break;
+			case 195: s = "invalid ForallStmt"; break;
+			case 196: s = "invalid CalcStmt"; break;
 			case 197: s = "invalid ModifyStmt"; break;
-			case 198: s = "invalid ReturnStmt"; break;
-			case 199: s = "invalid Rhs"; break;
-			case 200: s = "invalid Lhs"; break;
-			case 201: s = "invalid CasePattern"; break;
-			case 202: s = "invalid AlternativeBlock"; break;
-			case 203: s = "invalid Guard"; break;
-			case 204: s = "this symbol not expected in LoopSpec"; break;
-			case 205: s = "this symbol not expected in LoopSpec"; break;
+			case 198: s = "this symbol not expected in ModifyStmt"; break;
+			case 199: s = "invalid ModifyStmt"; break;
+			case 200: s = "invalid ReturnStmt"; break;
+			case 201: s = "invalid Rhs"; break;
+			case 202: s = "invalid Lhs"; break;
+			case 203: s = "invalid CasePattern"; break;
+			case 204: s = "invalid AlternativeBlock"; break;
+			case 205: s = "invalid Guard"; break;
 			case 206: s = "this symbol not expected in LoopSpec"; break;
-			case 207: s = "invalid LoopSpec"; break;
-			case 208: s = "invalid CaseStatement"; break;
-			case 209: s = "this symbol not expected in CaseStatement"; break;
-			case 210: s = "this symbol not expected in CaseStatement"; break;
-			case 211: s = "invalid CalcOp"; break;
-			case 212: s = "invalid EquivOp"; break;
-			case 213: s = "invalid ImpliesOp"; break;
-			case 214: s = "invalid ExpliesOp"; break;
-			case 215: s = "invalid AndOp"; break;
-			case 216: s = "invalid OrOp"; break;
-			case 217: s = "invalid NegOp"; break;
-			case 218: s = "invalid Forall"; break;
-			case 219: s = "invalid Exists"; break;
-			case 220: s = "invalid QSep"; break;
-			case 221: s = "invalid ImpliesExpliesExpression"; break;
-			case 222: s = "invalid LogicalExpression"; break;
-			case 223: s = "invalid RelOp"; break;
-			case 224: s = "invalid AddOp"; break;
-			case 225: s = "invalid UnaryExpression"; break;
-			case 226: s = "invalid MulOp"; break;
-			case 227: s = "invalid Suffix"; break;
-			case 228: s = "invalid Suffix"; break;
+			case 207: s = "this symbol not expected in LoopSpec"; break;
+			case 208: s = "this symbol not expected in LoopSpec"; break;
+			case 209: s = "invalid LoopSpec"; break;
+			case 210: s = "invalid CaseStatement"; break;
+			case 211: s = "this symbol not expected in CaseStatement"; break;
+			case 212: s = "this symbol not expected in CaseStatement"; break;
+			case 213: s = "invalid CalcOp"; break;
+			case 214: s = "invalid EquivOp"; break;
+			case 215: s = "invalid ImpliesOp"; break;
+			case 216: s = "invalid ExpliesOp"; break;
+			case 217: s = "invalid AndOp"; break;
+			case 218: s = "invalid OrOp"; break;
+			case 219: s = "invalid NegOp"; break;
+			case 220: s = "invalid Forall"; break;
+			case 221: s = "invalid Exists"; break;
+			case 222: s = "invalid QSep"; break;
+			case 223: s = "invalid ImpliesExpliesExpression"; break;
+			case 224: s = "invalid LogicalExpression"; break;
+			case 225: s = "invalid RelOp"; break;
+			case 226: s = "invalid AddOp"; break;
+			case 227: s = "invalid UnaryExpression"; break;
+			case 228: s = "invalid MulOp"; break;
 			case 229: s = "invalid Suffix"; break;
 			case 230: s = "invalid Suffix"; break;
 			case 231: s = "invalid Suffix"; break;
-			case 232: s = "invalid LambdaExpression"; break;
-			case 233: s = "invalid EndlessExpression"; break;
-			case 234: s = "invalid NameSegment"; break;
-			case 235: s = "invalid DisplayExpr"; break;
-			case 236: s = "invalid MultiSetExpr"; break;
-			case 237: s = "invalid ConstAtomExpression"; break;
-			case 238: s = "invalid Nat"; break;
-			case 239: s = "invalid LambdaArrow"; break;
-			case 240: s = "invalid MatchExpression"; break;
-			case 241: s = "invalid QuantifierGuts"; break;
-			case 242: s = "invalid StmtInExpr"; break;
-			case 243: s = "invalid LetExpr"; break;
-			case 244: s = "invalid CaseExpression"; break;
-			case 245: s = "invalid MemberBindingUpdate"; break;
-			case 246: s = "invalid DotSuffix"; break;
+			case 232: s = "invalid Suffix"; break;
+			case 233: s = "invalid Suffix"; break;
+			case 234: s = "invalid LambdaExpression"; break;
+			case 235: s = "invalid EndlessExpression"; break;
+			case 236: s = "invalid NameSegment"; break;
+			case 237: s = "invalid DisplayExpr"; break;
+			case 238: s = "invalid MultiSetExpr"; break;
+			case 239: s = "invalid ConstAtomExpression"; break;
+			case 240: s = "invalid Nat"; break;
+			case 241: s = "invalid LambdaArrow"; break;
+			case 242: s = "invalid MatchExpression"; break;
+			case 243: s = "invalid QuantifierGuts"; break;
+			case 244: s = "invalid StmtInExpr"; break;
+			case 245: s = "invalid LetExpr"; break;
+			case 246: s = "invalid CaseExpression"; break;
+			case 247: s = "invalid MemberBindingUpdate"; break;
+			case 248: s = "invalid DotSuffix"; break;
 
 			default: s = "error " + n; break;
 		}
diff --git a/Source/Dafny/Resolver.cs b/Source/Dafny/Resolver.cs
index 4d900a1b..eb82df72 100644
--- a/Source/Dafny/Resolver.cs
+++ b/Source/Dafny/Resolver.cs
@@ -197,6 +197,33 @@ namespace Microsoft.Dafny
       Contract.Invariant(cce.NonNullDictionaryAndValues(datatypeCtors) && Contract.ForAll(datatypeCtors.Values, v => cce.NonNullDictionaryAndValues(v)));
     }
 
+    /// <summary>
+    /// Check that now two modules that are being compiled have the same CompileName.
+    /// 
+    /// This could happen if they are given the same name using the 'extern' declaration modifier.
+    /// </summary>
+    /// <param name="prog">The Dafny program being compiled.</param>
+    void CheckDupModuleNames(Program prog)
+    {
+      // Check that none of the modules have the same CompileName.
+      Dictionary<string, ModuleDefinition> compileNameMap = new Dictionary<string, ModuleDefinition>();
+      foreach (ModuleDefinition m in prog.CompileModules) {
+        if (m.IsAbstract) {
+          // the purpose of an abstract module is to skip compilation
+          continue;
+        }
+        string compileName = m.CompileName;
+        ModuleDefinition priorModDef;
+        if (compileNameMap.TryGetValue(compileName, out priorModDef)) {
+          reporter.Error(MessageSource.Resolver, m.tok, 
+            "Modules '{0}' and '{1}' both have CompileName '{2}'.",
+            priorModDef.tok.val, m.tok.val, compileName);
+        }
+        else {
+          compileNameMap.Add(compileName, m);
+        }
+      }
+    }
     public void ResolveProgram(Program prog) {
       Contract.Requires(prog != null);
       var origErrorCount = reporter.Count(ErrorLevel.Error); //TODO: This is used further below, but not in the >0 comparisons in the next few lines. Is that right?
@@ -459,6 +486,8 @@ namespace Microsoft.Dafny
           }
         }
       }
+
+      CheckDupModuleNames(prog);
     }
 
     void FillInDefaultDecreasesClauses(Program prog)
diff --git a/Source/Dafny/Scanner.cs b/Source/Dafny/Scanner.cs
index 6e2107c3..784f9cd5 100644
--- a/Source/Dafny/Scanner.cs
+++ b/Source/Dafny/Scanner.cs
@@ -211,8 +211,8 @@ public class UTF8Buffer: Buffer {
 public class Scanner {
 	const char EOL = '\n';
 	const int eofSym = 0; /* pdt */
-	const int maxT = 138;
-	const int noSym = 138;
+	const int maxT = 139;
+	const int noSym = 139;
 
 
 	[ContractInvariantMethod]
@@ -541,55 +541,56 @@ public class Scanner {
 			case "requires": t.kind = 45; break;
 			case "include": t.kind = 60; break;
 			case "abstract": t.kind = 61; break;
-			case "module": t.kind = 62; break;
-			case "exclusively": t.kind = 63; break;
-			case "refines": t.kind = 64; break;
-			case "import": t.kind = 65; break;
-			case "opened": t.kind = 66; break;
-			case "as": t.kind = 68; break;
-			case "default": t.kind = 69; break;
-			case "class": t.kind = 70; break;
-			case "extends": t.kind = 71; break;
-			case "trait": t.kind = 72; break;
-			case "ghost": t.kind = 73; break;
-			case "static": t.kind = 74; break;
-			case "protected": t.kind = 75; break;
-			case "datatype": t.kind = 76; break;
-			case "codatatype": t.kind = 77; break;
-			case "var": t.kind = 78; break;
-			case "newtype": t.kind = 79; break;
-			case "type": t.kind = 80; break;
-			case "iterator": t.kind = 81; break;
-			case "yields": t.kind = 82; break;
-			case "returns": t.kind = 83; break;
-			case "method": t.kind = 84; break;
-			case "colemma": t.kind = 85; break;
-			case "comethod": t.kind = 86; break;
-			case "constructor": t.kind = 87; break;
-			case "free": t.kind = 88; break;
-			case "ensures": t.kind = 89; break;
-			case "yield": t.kind = 90; break;
-			case "label": t.kind = 92; break;
-			case "break": t.kind = 93; break;
-			case "where": t.kind = 94; break;
-			case "return": t.kind = 96; break;
-			case "new": t.kind = 97; break;
-			case "if": t.kind = 98; break;
-			case "while": t.kind = 99; break;
-			case "match": t.kind = 100; break;
-			case "assert": t.kind = 101; break;
-			case "print": t.kind = 102; break;
-			case "forall": t.kind = 103; break;
-			case "parallel": t.kind = 104; break;
-			case "modify": t.kind = 105; break;
-			case "exists": t.kind = 124; break;
-			case "in": t.kind = 126; break;
-			case "false": t.kind = 131; break;
-			case "true": t.kind = 132; break;
-			case "null": t.kind = 133; break;
-			case "this": t.kind = 134; break;
-			case "fresh": t.kind = 135; break;
-			case "old": t.kind = 136; break;
+			case "ghost": t.kind = 62; break;
+			case "static": t.kind = 63; break;
+			case "protected": t.kind = 64; break;
+			case "extern": t.kind = 65; break;
+			case "module": t.kind = 66; break;
+			case "exclusively": t.kind = 67; break;
+			case "refines": t.kind = 68; break;
+			case "import": t.kind = 69; break;
+			case "opened": t.kind = 70; break;
+			case "as": t.kind = 72; break;
+			case "default": t.kind = 73; break;
+			case "class": t.kind = 74; break;
+			case "extends": t.kind = 75; break;
+			case "trait": t.kind = 76; break;
+			case "datatype": t.kind = 77; break;
+			case "codatatype": t.kind = 78; break;
+			case "var": t.kind = 79; break;
+			case "newtype": t.kind = 80; break;
+			case "type": t.kind = 81; break;
+			case "iterator": t.kind = 82; break;
+			case "yields": t.kind = 83; break;
+			case "returns": t.kind = 84; break;
+			case "method": t.kind = 85; break;
+			case "colemma": t.kind = 86; break;
+			case "comethod": t.kind = 87; break;
+			case "constructor": t.kind = 88; break;
+			case "free": t.kind = 89; break;
+			case "ensures": t.kind = 90; break;
+			case "yield": t.kind = 91; break;
+			case "label": t.kind = 93; break;
+			case "break": t.kind = 94; break;
+			case "where": t.kind = 95; break;
+			case "return": t.kind = 97; break;
+			case "new": t.kind = 98; break;
+			case "if": t.kind = 99; break;
+			case "while": t.kind = 100; break;
+			case "match": t.kind = 101; break;
+			case "assert": t.kind = 102; break;
+			case "print": t.kind = 103; break;
+			case "forall": t.kind = 104; break;
+			case "parallel": t.kind = 105; break;
+			case "modify": t.kind = 106; break;
+			case "exists": t.kind = 125; break;
+			case "in": t.kind = 127; break;
+			case "false": t.kind = 132; break;
+			case "true": t.kind = 133; break;
+			case "null": t.kind = 134; break;
+			case "this": t.kind = 135; break;
+			case "fresh": t.kind = 136; break;
+			case "old": t.kind = 137; break;
 			default: break;
 		}
 	}
@@ -852,50 +853,50 @@ public class Scanner {
 				else if (ch >= '0' && ch <= '9') {AddCh(); goto case 66;}
 				else {t.kind = 5; break;}
 			case 67:
-				{t.kind = 91; break;}
+				{t.kind = 92; break;}
 			case 68:
-				{t.kind = 95; break;}
+				{t.kind = 96; break;}
 			case 69:
-				{t.kind = 106; break;}
+				{t.kind = 107; break;}
 			case 70:
-				{t.kind = 108; break;}
-			case 71:
 				{t.kind = 109; break;}
-			case 72:
+			case 71:
 				{t.kind = 110; break;}
-			case 73:
+			case 72:
 				{t.kind = 111; break;}
-			case 74:
+			case 73:
 				{t.kind = 112; break;}
-			case 75:
+			case 74:
 				{t.kind = 113; break;}
-			case 76:
+			case 75:
 				{t.kind = 114; break;}
+			case 76:
+				{t.kind = 115; break;}
 			case 77:
-				{t.kind = 116; break;}
+				{t.kind = 117; break;}
 			case 78:
 				if (ch == '&') {AddCh(); goto case 79;}
 				else {goto case 0;}
 			case 79:
-				{t.kind = 117; break;}
-			case 80:
 				{t.kind = 118; break;}
-			case 81:
+			case 80:
 				{t.kind = 119; break;}
-			case 82:
+			case 81:
 				{t.kind = 120; break;}
+			case 82:
+				{t.kind = 121; break;}
 			case 83:
-				{t.kind = 122; break;}
-			case 84:
 				{t.kind = 123; break;}
+			case 84:
+				{t.kind = 124; break;}
 			case 85:
-				{t.kind = 125; break;}
+				{t.kind = 126; break;}
 			case 86:
-				{t.kind = 127; break;}
+				{t.kind = 128; break;}
 			case 87:
-				{t.kind = 129; break;}
-			case 88:
 				{t.kind = 130; break;}
+			case 88:
+				{t.kind = 131; break;}
 			case 89:
 				recEnd = pos; recKind = 21;
 				if (ch == ':') {AddCh(); goto case 30;}
@@ -911,14 +912,14 @@ public class Scanner {
 				if (ch == '.') {AddCh(); goto case 97;}
 				else {t.kind = 27; break;}
 			case 92:
-				recEnd = pos; recKind = 67;
+				recEnd = pos; recKind = 71;
 				if (ch == '>') {AddCh(); goto case 34;}
 				else if (ch == '=') {AddCh(); goto case 98;}
-				else {t.kind = 67; break;}
+				else {t.kind = 71; break;}
 			case 93:
-				recEnd = pos; recKind = 128;
+				recEnd = pos; recKind = 129;
 				if (ch == '>') {AddCh(); goto case 35;}
-				else {t.kind = 128; break;}
+				else {t.kind = 129; break;}
 			case 94:
 				recEnd = pos; recKind = 52;
 				if (ch == '=') {AddCh(); goto case 99;}
@@ -928,26 +929,26 @@ public class Scanner {
 				if (ch == '=') {AddCh(); goto case 70;}
 				else {t.kind = 53; break;}
 			case 96:
-				recEnd = pos; recKind = 121;
+				recEnd = pos; recKind = 122;
 				if (ch == '=') {AddCh(); goto case 42;}
 				else if (ch == 'i') {AddCh(); goto case 45;}
-				else {t.kind = 121; break;}
+				else {t.kind = 122; break;}
 			case 97:
-				recEnd = pos; recKind = 137;
+				recEnd = pos; recKind = 138;
 				if (ch == '.') {AddCh(); goto case 48;}
-				else {t.kind = 137; break;}
+				else {t.kind = 138; break;}
 			case 98:
 				recEnd = pos; recKind = 54;
 				if (ch == '>') {AddCh(); goto case 75;}
 				else {t.kind = 54; break;}
 			case 99:
-				recEnd = pos; recKind = 107;
+				recEnd = pos; recKind = 108;
 				if (ch == '=') {AddCh(); goto case 100;}
-				else {t.kind = 107; break;}
+				else {t.kind = 108; break;}
 			case 100:
-				recEnd = pos; recKind = 115;
+				recEnd = pos; recKind = 116;
 				if (ch == '>') {AddCh(); goto case 73;}
-				else {t.kind = 115; break;}
+				else {t.kind = 116; break;}
 
 		}
 		t.val = new String(tval, 0, tlen);
diff --git a/Source/DafnyDriver/DafnyDriver.cs b/Source/DafnyDriver/DafnyDriver.cs
index 6cfbe7e1..a60971b1 100644
--- a/Source/DafnyDriver/DafnyDriver.cs
+++ b/Source/DafnyDriver/DafnyDriver.cs
@@ -13,6 +13,7 @@ namespace Microsoft.Dafny
   using System;
   using System.CodeDom.Compiler;
   using System.Collections.Generic;
+  using System.Collections.ObjectModel;
   using System.Diagnostics.Contracts;
   using System.IO;
   using System.Reflection;
@@ -82,18 +83,27 @@ namespace Microsoft.Dafny
         Console.WriteLine("--------------------");
       }
 
+      var dafnyFiles = new List<string>();
+      var otherFiles = new List<string>();
+
       foreach (string file in CommandLineOptions.Clo.Files)
-      {Contract.Assert(file != null);
+      { Contract.Assert(file != null);
         string extension = Path.GetExtension(file);
         if (extension != null) { extension = extension.ToLower(); }
-        if (extension != ".dfy") {
-          ExecutionEngine.printer.ErrorWriteLine(Console.Out, "*** Error: '{0}': Filename extension '{1}' is not supported. Input files must be Dafny programs (.dfy).", file,
+        if (extension == ".dfy") {
+          dafnyFiles.Add(file);
+        }
+        else if ((extension == ".cs") || (extension == ".dll")) {
+          otherFiles.Add(file);
+        }
+        else {
+          ExecutionEngine.printer.ErrorWriteLine(Console.Out, "*** Error: '{0}': Filename extension '{1}' is not supported. Input files must be Dafny programs (.dfy) or C# files (.cs) or managed DLLS (.dll)", file,
             extension == null ? "" : extension);
           exitValue = ExitValue.PREPROCESSING_ERROR;
           goto END;
         }
       }
-      exitValue = ProcessFiles(CommandLineOptions.Clo.Files, reporter);
+      exitValue = ProcessFiles(dafnyFiles, otherFiles.AsReadOnly(), reporter);
 
       END:
         if (CommandLineOptions.Clo.XmlSink != null) {
@@ -113,9 +123,10 @@ namespace Microsoft.Dafny
     }
 
 
-    static ExitValue ProcessFiles(IList<string/*!*/>/*!*/ fileNames, ErrorReporter reporter, bool lookForSnapshots = true, string programId = null)
-    {
-      Contract.Requires(cce.NonNullElements(fileNames));
+    static ExitValue ProcessFiles(IList<string/*!*/>/*!*/ dafnyFileNames, ReadOnlyCollection<string> otherFileNames, 
+                                  ErrorReporter reporter, bool lookForSnapshots = true, string programId = null)
+   {
+      Contract.Requires(cce.NonNullElements(dafnyFileNames));
 
       if (programId == null)
       {
@@ -123,13 +134,18 @@ namespace Microsoft.Dafny
       }
 
       ExitValue exitValue = ExitValue.VERIFIED;
-      if (CommandLineOptions.Clo.VerifySeparately && 1 < fileNames.Count)
+      if (CommandLineOptions.Clo.VerifySeparately && 1 < dafnyFileNames.Count)
       {
-        foreach (var f in fileNames)
+        foreach (var f in dafnyFileNames)
         {
+          string extension = Path.GetExtension(f);
+          if (extension != null) { extension = extension.ToLower(); }
+          if (extension != ".dfy"){
+            continue;
+          }
           Console.WriteLine();
           Console.WriteLine("-------------------- {0} --------------------", f);
-          var ev = ProcessFiles(new List<string> { f }, reporter, lookForSnapshots, f);
+          var ev = ProcessFiles(new List<string> { f }, new List<string>().AsReadOnly(), reporter, lookForSnapshots, f);
           if (exitValue != ev && ev != ExitValue.VERIFIED)
           {
             exitValue = ev;
@@ -140,10 +156,10 @@ namespace Microsoft.Dafny
 
       if (0 <= CommandLineOptions.Clo.VerifySnapshots && lookForSnapshots)
       {
-        var snapshotsByVersion = ExecutionEngine.LookForSnapshots(fileNames);
+        var snapshotsByVersion = ExecutionEngine.LookForSnapshots(dafnyFileNames);
         foreach (var s in snapshotsByVersion)
         {
-          var ev = ProcessFiles(new List<string>(s), reporter, false, programId);
+          var ev = ProcessFiles(new List<string>(s), new List<string>().AsReadOnly(), reporter, false, programId);
           if (exitValue != ev && ev != ExitValue.VERIFIED)
           {
             exitValue = ev;
@@ -152,10 +168,10 @@ namespace Microsoft.Dafny
         return exitValue;
       }
       
-      using (XmlFileScope xf = new XmlFileScope(CommandLineOptions.Clo.XmlSink, fileNames[fileNames.Count-1])) {
+      using (XmlFileScope xf = new XmlFileScope(CommandLineOptions.Clo.XmlSink, dafnyFileNames[dafnyFileNames.Count-1])) {
         Dafny.Program dafnyProgram;
-        string programName = fileNames.Count == 1 ? fileNames[0] : "the program";
-        string err = Dafny.Main.ParseCheck(fileNames, programName, reporter, out dafnyProgram);
+        string programName = dafnyFileNames.Count == 1 ? dafnyFileNames[0] : "the program";
+        string err = Dafny.Main.ParseCheck(dafnyFileNames, programName, reporter, out dafnyProgram);
         if (err != null) {
           exitValue = ExitValue.DAFNY_ERROR;
           ExecutionEngine.printer.ErrorWriteLine(Console.Out, err);
@@ -172,7 +188,7 @@ namespace Microsoft.Dafny
           if (CommandLineOptions.Clo.PrintFile != null) {
             bplFilename = CommandLineOptions.Clo.PrintFile;
           } else {
-            string baseName = cce.NonNull(Path.GetFileName(fileNames[fileNames.Count-1]));
+            string baseName = cce.NonNull(Path.GetFileName(dafnyFileNames[dafnyFileNames.Count-1]));
             baseName = cce.NonNull(Path.ChangeExtension(baseName, "bpl"));
             bplFilename = Path.Combine(Path.GetTempPath(), baseName);
           }
@@ -184,12 +200,12 @@ namespace Microsoft.Dafny
             case PipelineOutcome.VerificationCompleted:
               ExecutionEngine.printer.WriteTrailer(stats);
               if ((DafnyOptions.O.Compile && allOk && CommandLineOptions.Clo.ProcsToCheck == null) || DafnyOptions.O.ForceCompile)
-                CompileDafnyProgram(dafnyProgram, fileNames[0]);
+                CompileDafnyProgram(dafnyProgram, dafnyFileNames[0], otherFileNames);
               break;
             case PipelineOutcome.Done:
               ExecutionEngine.printer.WriteTrailer(stats);
               if (DafnyOptions.O.ForceCompile)
-                CompileDafnyProgram(dafnyProgram, fileNames[0]);
+                CompileDafnyProgram(dafnyProgram, dafnyFileNames[0], otherFileNames);
               break;
             default:
               // error has already been reported to user
@@ -289,7 +305,23 @@ namespace Microsoft.Dafny
 
     #region Compilation
 
-    public static void CompileDafnyProgram(Dafny.Program dafnyProgram, string dafnyProgramName, TextWriter outputWriter = null)
+    static string WriteDafnyProgramToFile(string dafnyProgramName, string csharpProgram, bool completeProgram, TextWriter outputWriter)
+    {
+      string targetFilename = Path.ChangeExtension(dafnyProgramName, "cs");
+      using (TextWriter target = new StreamWriter(new FileStream(targetFilename, System.IO.FileMode.Create))) {
+        target.Write(csharpProgram);
+        if (completeProgram) {
+          outputWriter.WriteLine("Compiled program written to {0}", targetFilename);
+        }
+        else {
+          outputWriter.WriteLine("File {0} contains the partially compiled program", targetFilename);
+        }
+      }
+      return targetFilename;
+    }
+
+    public static void CompileDafnyProgram(Dafny.Program dafnyProgram, string dafnyProgramName,
+                                           ReadOnlyCollection<string> otherFileNames, TextWriter outputWriter = null)
     {
       Contract.Requires(dafnyProgram != null);
 
@@ -311,22 +343,11 @@ namespace Microsoft.Dafny
       var csharpProgram = sw.ToString();
       bool completeProgram = compiler.ErrorCount == 0;
 
-      // blurt out the code to a file
-      if (DafnyOptions.O.SpillTargetCode)
+      // blurt out the code to a file, if requested, or if other files were specified for the C# command line.
+      string targetFilename = null;
+      if (DafnyOptions.O.SpillTargetCode || (otherFileNames.Count > 0))
       {
-        string targetFilename = Path.ChangeExtension(dafnyProgramName, "cs");
-        using (TextWriter target = new StreamWriter(new FileStream(targetFilename, System.IO.FileMode.Create)))
-        {
-          target.Write(csharpProgram);
-          if (completeProgram)
-          {
-            outputWriter.WriteLine("Compiled program written to {0}", targetFilename);
-          }
-          else
-          {
-            outputWriter.WriteLine("File {0} contains the partially compiled program", targetFilename);
-          }
-        }
+        targetFilename = WriteDafnyProgramToFile(dafnyProgramName, csharpProgram, completeProgram, outputWriter);
       }
 
       // compile the program into an assembly
@@ -367,7 +388,37 @@ namespace Microsoft.Dafny
           cp.ReferencedAssemblies.Add("System.Runtime.dll");
         }
 
-        var cr = provider.CompileAssemblyFromSource(cp, csharpProgram);
+        int numOtherSourceFiles = 0;
+        if (otherFileNames.Count > 0) {
+          foreach (var file in otherFileNames) {
+            string extension = Path.GetExtension(file);
+            if (extension != null) { extension = extension.ToLower(); }
+            if (extension == ".cs") {
+              numOtherSourceFiles++;
+            }
+            else if (extension == ".dll") {
+              cp.ReferencedAssemblies.Add(file);
+            }
+          }
+        }
+
+        CompilerResults cr;
+        if (numOtherSourceFiles > 0) {
+          string[] sourceFiles = new string[numOtherSourceFiles + 1];
+          sourceFiles[0] = targetFilename;
+          int index = 1;
+          foreach (var file in otherFileNames) {
+            string extension = Path.GetExtension(file);
+            if (extension != null) { extension = extension.ToLower(); }
+            if (extension == ".cs") {
+              sourceFiles[index++] = file;
+            }
+          }
+          cr = provider.CompileAssemblyFromFile(cp, sourceFiles);
+        }
+        else {
+          cr = provider.CompileAssemblyFromSource(cp, csharpProgram);
+        }
         var assemblyName = Path.GetFileName(cr.PathToAssembly);
         if (DafnyOptions.O.RunAfterCompile && cr.Errors.Count == 0) {
           outputWriter.WriteLine("Program compiled successfully");
diff --git a/Source/DafnyExtension/DafnyDriver.cs b/Source/DafnyExtension/DafnyDriver.cs
index 037d0cd3..13b53a1b 100644
--- a/Source/DafnyExtension/DafnyDriver.cs
+++ b/Source/DafnyExtension/DafnyDriver.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Diagnostics.Contracts;
 using System.IO;
 using System.Linq;
@@ -198,7 +199,10 @@ namespace DafnyLanguage
     public static void Compile(Dafny.Program dafnyProgram, TextWriter outputWriter)
     {
       Microsoft.Dafny.DafnyOptions.O.SpillTargetCode = true;
-      Microsoft.Dafny.DafnyDriver.CompileDafnyProgram(dafnyProgram, dafnyProgram.FullName, outputWriter);
+      // Currently there are no provisions for specifying other files to compile with from the 
+      // VS interface, so just send an empty list.
+      ReadOnlyCollection<string> otherFileNames = new List<string>().AsReadOnly();
+      Microsoft.Dafny.DafnyDriver.CompileDafnyProgram(dafnyProgram, dafnyProgram.FullName, otherFileNames, outputWriter);
     }
 
     #endregion
diff --git a/Test/dafny0/Extern.dfy b/Test/dafny0/Extern.dfy
new file mode 100644
index 00000000..cbdffe34
--- /dev/null
+++ b/Test/dafny0/Extern.dfy
@@ -0,0 +1,27 @@
+// RUN: %dafny /compile:1 /print:"%t.print" /dprint:"%t.dprint" "%s" "%S\Extern2.cs" "%S\ExternHelloLibrary.dll" > "%t"
+// RUN: %diff "%s.expect" "%t"
+extern "Modx" module Mod1 
+{
+  extern "classx" class Class1
+  {
+    extern "Fun1x" static function method Fun1() : int
+      ensures Fun1() > 0
+    extern "Method1x" static method Method1() returns (x: int)
+      ensures x > 0
+    static function method Fun2() : int
+    	ensures Fun2() > 0
+    {
+    	Fun1()
+    }
+    static method Method2() returns (x: int)
+      ensures x > 0
+    {
+    	x := Method1();
+    }
+  }
+  method Main()
+  {
+    var m2 := Class1.Method2();
+    print ("Fun2() = ", Class1.Fun2(), "Method2() = ", m2, "\n");
+  }
+}
diff --git a/Test/dafny0/Extern.dfy.expect b/Test/dafny0/Extern.dfy.expect
new file mode 100644
index 00000000..fec087d9
--- /dev/null
+++ b/Test/dafny0/Extern.dfy.expect
@@ -0,0 +1,4 @@
+
+Dafny program verifier finished with 7 verified, 0 errors
+Compiled program written to D:\de\dafny\Test\dafny0\Extern.cs
+Compiled assembly into Extern.exe
diff --git a/Test/dafny0/Extern2.cs b/Test/dafny0/Extern2.cs
new file mode 100644
index 00000000..2fcaf18b
--- /dev/null
+++ b/Test/dafny0/Extern2.cs
@@ -0,0 +1,14 @@
+using System.Numerics;
+namespace @Modx {
+
+  public partial class @classx {
+    public static BigInteger @Fun1x() {
+      return BigInteger.One;
+    }
+    public static void @Method1x(out BigInteger @x)
+    {
+      ExternHelloLibrary.ExternHelloLibrary.SayHello();
+      @x = BigInteger.One;
+    }
+  }
+}
diff --git a/Test/dafny0/ExternHelloLibrary.cs b/Test/dafny0/ExternHelloLibrary.cs
new file mode 100644
index 00000000..81163997
--- /dev/null
+++ b/Test/dafny0/ExternHelloLibrary.cs
@@ -0,0 +1,15 @@
+// Note that  ExternHelloLibrary.dll was produced from this file using
+// csc /t:library ExternHelloLibrary.cs 
+
+using System;
+
+namespace ExternHelloLibrary
+{
+  public static class ExternHelloLibrary
+  {
+    public static void SayHello()
+    {
+      Console.WriteLine("Hello from ExternHelloLibrary.");
+    }
+  }
+}
diff --git a/Test/dafny0/ExternHelloLibrary.dll b/Test/dafny0/ExternHelloLibrary.dll
new file mode 100644
index 00000000..914e4248
Binary files /dev/null and b/Test/dafny0/ExternHelloLibrary.dll differ
diff --git a/Test/dafny0/ExternNegative.dfy b/Test/dafny0/ExternNegative.dfy
new file mode 100644
index 00000000..4ae73232
--- /dev/null
+++ b/Test/dafny0/ExternNegative.dfy
@@ -0,0 +1,26 @@
+// RUN: %dafny /compile:0 /print:"%t.print" /dprint:"%t.dprint" "%s" > "%t"
+// RUN: %diff "%s.expect" "%t"
+extern "Modx" module Mod1 
+{
+  extern "classx" class Class1
+  {
+    extern "Fun1x" static function method Fun1() : int
+      ensures Fun1() > 0
+    extern "Method1x" static method Method1() returns (x: int)
+      ensures x > 0
+    static abstract function method Fun2() : int
+	ensures Fun2() > 0
+    {
+	Fun1()
+    }
+    static static method Method2() returns (x: int)
+      ensures x > 0
+    {
+	x := Method1();
+    }
+  }
+}
+// Will give error about duplicate CompileName for module.
+extern "Modx" module Mod2
+{
+}
diff --git a/Test/dafny0/ExternNegative.dfy.expect b/Test/dafny0/ExternNegative.dfy.expect
new file mode 100644
index 00000000..5d95ced7
--- /dev/null
+++ b/Test/dafny0/ExternNegative.dfy.expect
@@ -0,0 +1,3 @@
+ExternNegative.dfy(11,11): Error: Function methods cannot be declared 'abstract'.
+ExternNegative.dfy(16,11): Error: Duplicate declaration modifier: static
+2 parse errors detected in ExternNegative.dfy
diff --git a/Test/dafny0/ExternNegative2.dfy b/Test/dafny0/ExternNegative2.dfy
new file mode 100644
index 00000000..3d09913b
--- /dev/null
+++ b/Test/dafny0/ExternNegative2.dfy
@@ -0,0 +1,26 @@
+// RUN: %dafny /compile:0 /print:"%t.print" /dprint:"%t.dprint" "%s" > "%t"
+// RUN: %diff "%s.expect" "%t"
+extern "Modx" module Mod1 
+{
+  extern "classx" class Class1
+  {
+    extern "Fun1x" static function method Fun1() : int
+      ensures Fun1() > 0
+    extern "Method1x" static method Method1() returns (x: int)
+      ensures x > 0
+    static function method Fun2() : int
+	ensures Fun2() > 0
+    {
+	Fun1()
+    }
+    static method Method2() returns (x: int)
+      ensures x > 0
+    {
+	x := Method1();
+    }
+  }
+}
+// Will give error about duplicate CompileName for module.
+extern "Modx" module Mod2
+{
+}
-- 
cgit v1.2.3


From e4da5fcd52bbdd0b8345056a3475333d6e27e65f Mon Sep 17 00:00:00 2001
From: qunyanm <unknown>
Date: Fri, 29 Jan 2016 13:01:02 -0800
Subject: Implement module export so we can export a subset of items defined in
 the module.

---
 Source/Dafny/Cloner.cs              |    5 +
 Source/Dafny/Dafny.atg              |   47 +-
 Source/Dafny/DafnyAst.cs            |   36 ++
 Source/Dafny/Parser.cs              | 1069 +++++++++++++++++++----------------
 Source/Dafny/Resolver.cs            |  106 +++-
 Source/Dafny/Scanner.cs             |  175 +++---
 Test/dafny0/ModuleExport.dfy        |   68 +++
 Test/dafny0/ModuleExport.dfy.expect |    9 +
 8 files changed, 923 insertions(+), 592 deletions(-)
 create mode 100644 Test/dafny0/ModuleExport.dfy
 create mode 100644 Test/dafny0/ModuleExport.dfy.expect

(limited to 'Source/Dafny/Scanner.cs')

diff --git a/Source/Dafny/Cloner.cs b/Source/Dafny/Cloner.cs
index 6b3b0caa..8971d2c1 100644
--- a/Source/Dafny/Cloner.cs
+++ b/Source/Dafny/Cloner.cs
@@ -126,6 +126,11 @@ namespace Microsoft.Dafny
           abs.Signature = a.Signature;
           abs.OriginalSignature = a.OriginalSignature;
           return abs;
+        } else if (d is ModuleExportDecl) {
+          var a = (ModuleExportDecl)d;
+          var export = new ModuleExportDecl(a.tok, m, a.IsDefault, a.Exports, a.Extends);
+          export.Signature = a.Signature;
+          return export;
         } else {
           Contract.Assert(false);  // unexpected declaration
           return null;  // to please compiler
diff --git a/Source/Dafny/Dafny.atg b/Source/Dafny/Dafny.atg
index eb0c3303..e3696c5b 100644
--- a/Source/Dafny/Dafny.atg
+++ b/Source/Dafny/Dafny.atg
@@ -502,6 +502,13 @@ bool IsType(ref IToken pt) {
   }
 }
 
+
+bool IsDefaultImport() {
+  scanner.ResetPeek();  
+  Token x = scanner.Peek();  // lookahead token again 
+  return la.val == "default" && x.val != "export";
+}
+
 /*--------------------------------------------------------------------------*/
 CHARACTERS
   letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
@@ -708,7 +715,7 @@ SubModuleDecl<DeclModifierData dmod, ModuleDefinition parent, out ModuleDecl sub
       | "refines" QualifiedModuleName<out idRefined> (. isExclusively = false; .) ] 
             (. module = new ModuleDefinition(id, id.val, isAbstract, false, isExclusively, idRefined == null ? null : idRefined, parent, attrs, false, this); .)  
        "{"                                             (. module.BodyStartTok = t; .)
-            { TopDecl<module, namedModuleDefaultClassMembers, /* isTopLevel */ false, isAbstract> }
+            { TopDecl<module, namedModuleDefaultClassMembers, /* isTopLevel */ false, isAbstract>}
        "}"                                 (. module.BodyEndTok = t;
                                               module.TopLevelDecls.Add(new DefaultClassDecl(module, namedModuleDefaultClassMembers));
                                               submodule = new LiteralModuleDecl(module, parent); .)
@@ -718,8 +725,16 @@ SubModuleDecl<DeclModifierData dmod, ModuleDefinition parent, out ModuleDecl sub
     (. EncodeExternAsAttribute(dmod, ref attrs, id, /* needAxiom */ false); .)
     [ "=" QualifiedModuleName<out idPath>
       (. submodule = new AliasModuleDecl(idPath, id, parent, opened); .)
-    | "as" QualifiedModuleName<out idPath>  ["default" QualifiedModuleName<out idAssignment> ]
+    | "as" QualifiedModuleName<out idPath> [IF(IsDefaultImport()) "default" QualifiedModuleName<out idAssignment> ]
+      (. submodule = new ModuleFacadeDecl(idPath, id, parent, idAssignment, opened); 
+         //errors.Warning(t, "\"import A as B\" has been deprecated; in the new syntax, it is \"import A:B\"");
+      .)
+    | ":" QualifiedModuleName<out idPath>
       (. submodule = new ModuleFacadeDecl(idPath, id, parent, idAssignment, opened); .)
+    | "." QualifiedModuleName<out idPath>
+      (. idPath.Insert(0, id);
+			   submodule = new AliasModuleDecl(idPath, id, parent, opened); 
+      .)
     ]
     [ SYNC ";"
         // This semi-colon used to be required, but it seems silly to have it.
@@ -733,6 +748,33 @@ SubModuleDecl<DeclModifierData dmod, ModuleDefinition parent, out ModuleDecl sub
          submodule = new AliasModuleDecl(idPath, id, parent, opened);
        }
     .)
+	| (. 		 
+		  bool isDefault = false;
+			bool includeBody;
+			IToken exportId;
+			List<ExportSignature> exports = new List<ExportSignature>();;
+      List<string> extends = new List<string>(); 
+		.)
+	  ["default"  (. isDefault = true; .) ]
+		"export"
+		NoUSIdent<out exportId>
+		["extends" 
+     NoUSIdent<out id>(. extends.Add(id.val); .) 
+     {"," NoUSIdent<out id>  (. extends.Add(id.val); .) }
+    ] 
+		"{"
+		   NoUSIdent<out id>   (. includeBody = false; .)
+			 ['+' (. includeBody = true; .)]
+			 (. exports.Add(new ExportSignature(id, includeBody)); .)
+       { ","
+         NoUSIdent<out id> (. includeBody = false; .)
+			   ['+' (. includeBody = true; .)]
+			   (. exports.Add(new ExportSignature(id, includeBody)); .)
+       }
+		"}"
+		(.
+		   submodule = new ModuleExportDecl(exportId, parent, isDefault, exports, extends);
+		.)
   )
 .
 
@@ -744,6 +786,7 @@ QualifiedModuleName<.out List<IToken> ids.>
   }
   .
 
+
 ClassDecl<DeclModifierData dmodClass, ModuleDefinition/*!*/ module, out ClassDecl/*!*/ c>
 = (. Contract.Requires(module != null);
      Contract.Ensures(Contract.ValueAtReturn(out c) != null);
diff --git a/Source/Dafny/DafnyAst.cs b/Source/Dafny/DafnyAst.cs
index a51e30de..33186a76 100644
--- a/Source/Dafny/DafnyAst.cs
+++ b/Source/Dafny/DafnyAst.cs
@@ -1662,6 +1662,8 @@ namespace Microsoft.Dafny {
   public class LiteralModuleDecl : ModuleDecl
   {
     public readonly ModuleDefinition ModuleDef;
+    public ModuleSignature DefaultExport;  // the default export of the module. fill in by the resolver.
+
     public LiteralModuleDecl(ModuleDefinition module, ModuleDefinition parent)
       : base(module.tok, module.Name, parent, false) {
       ModuleDef = module;
@@ -1680,6 +1682,7 @@ namespace Microsoft.Dafny {
     }
     public override object Dereference() { return Signature.ModuleDef; }
   }
+
   // Represents "module name as path [ = compilePath];", where name is a identifier and path is a possibly qualified name.
   public class ModuleFacadeDecl : ModuleDecl
   {
@@ -1698,6 +1701,39 @@ namespace Microsoft.Dafny {
     public override object Dereference() { return this; }
   }
 
+  // Represents the exports of a module. 
+  public class ModuleExportDecl : ModuleDecl
+  {
+    public bool IsDefault;
+    public List<ExportSignature> Exports; // list of TopLevelDecl that are included in the export
+    public List<string> Extends; // list of exports that are extended
+    public readonly List<ModuleExportDecl> ExtendDecls = new List<ModuleExportDecl>(); // fill in by the resolver
+
+    public ModuleExportDecl(IToken tok, ModuleDefinition parent, bool isDefault, 
+      List<ExportSignature> exports, List<string> extends) 
+      : base(tok, tok.val, parent, false) {
+      IsDefault = isDefault;
+      Exports = exports;
+      Extends = extends;
+    }
+
+    public override object Dereference() { return this; }
+  }
+
+  public class ExportSignature
+  {
+    public bool IncludeBody;
+    public IToken Id;
+    public string Name;
+    public Declaration Decl;  // fill in  by the resolver
+
+    public ExportSignature(IToken id, bool includeBody) {
+      Id = id;
+      Name = id.val;
+      IncludeBody = includeBody;
+    }
+  }
+
   public class ModuleSignature {
     private ModuleDefinition exclusiveRefinement = null;
     public readonly Dictionary<string, TopLevelDecl> TopLevels = new Dictionary<string, TopLevelDecl>();
diff --git a/Source/Dafny/Parser.cs b/Source/Dafny/Parser.cs
index 943e2cf6..c7955dc8 100644
--- a/Source/Dafny/Parser.cs
+++ b/Source/Dafny/Parser.cs
@@ -73,7 +73,7 @@ public class Parser {
 	public const int _star = 57;
 	public const int _notIn = 58;
 	public const int _ellipsis = 59;
-	public const int maxT = 139;
+	public const int maxT = 140;
 
 	const bool _T = true;
 	const bool _x = false;
@@ -574,6 +574,13 @@ bool IsType(ref IToken pt) {
   }
 }
 
+
+bool IsDefaultImport() {
+  scanner.ResetPeek();  
+  Token x = scanner.Peek();  // lookahead token again 
+  return la.val == "default" && x.val != "export";
+}
+
 /*--------------------------------------------------------------------------*/
 
 
@@ -697,47 +704,47 @@ bool IsType(ref IToken pt) {
 			DeclModifier(ref dmod);
 		}
 		switch (la.kind) {
-		case 66: case 69: {
+		case 66: case 69: case 73: case 74: {
 			SubModuleDecl(dmod, module, out submodule);
 			module.TopLevelDecls.Add(submodule); 
 			break;
 		}
-		case 74: {
+		case 77: {
 			ClassDecl(dmod, module, out c);
 			module.TopLevelDecls.Add(c); 
 			break;
 		}
-		case 77: case 78: {
+		case 79: case 80: {
 			DatatypeDecl(dmod, module, out dt);
 			module.TopLevelDecls.Add(dt); 
 			break;
 		}
-		case 80: {
+		case 82: {
 			NewtypeDecl(dmod, module, out td);
 			module.TopLevelDecls.Add(td); 
 			break;
 		}
-		case 81: {
+		case 83: {
 			OtherTypeDecl(dmod, module, out td);
 			module.TopLevelDecls.Add(td); 
 			break;
 		}
-		case 82: {
+		case 84: {
 			IteratorDecl(dmod, module, out iter);
 			module.TopLevelDecls.Add(iter); 
 			break;
 		}
-		case 76: {
+		case 78: {
 			TraitDecl(dmod, module, out trait);
 			module.TopLevelDecls.Add(trait); 
 			break;
 		}
-		case 38: case 39: case 40: case 41: case 42: case 79: case 85: case 86: case 87: case 88: {
+		case 38: case 39: case 40: case 41: case 42: case 81: case 87: case 88: case 89: case 90: {
 			ClassMemberDecl(dmod, membersDefaultClass, false, !DafnyOptions.O.AllowGlobals, 
 !isTopLevel && DafnyOptions.O.IronDafny && isAbstract);
 			break;
 		}
-		default: SynErr(140); break;
+		default: SynErr(141); break;
 		}
 	}
 
@@ -764,7 +771,7 @@ bool IsType(ref IToken pt) {
 				dmod.ExternName = new StringLiteralExpr(t, s, isVerbatimString);
 				
 			}
-		} else SynErr(141);
+		} else SynErr(142);
 	}
 
 	void SubModuleDecl(DeclModifierData dmod, ModuleDefinition parent, out ModuleDecl submodule) {
@@ -815,23 +822,35 @@ bool IsType(ref IToken pt) {
 			}
 			NoUSIdent(out id);
 			EncodeExternAsAttribute(dmod, ref attrs, id, /* needAxiom */ false); 
-			if (la.kind == 71 || la.kind == 72) {
+			if (StartOf(3)) {
 				if (la.kind == 71) {
 					Get();
 					QualifiedModuleName(out idPath);
 					submodule = new AliasModuleDecl(idPath, id, parent, opened); 
-				} else {
+				} else if (la.kind == 72) {
 					Get();
 					QualifiedModuleName(out idPath);
-					if (la.kind == 73) {
-						Get();
+					if (IsDefaultImport()) {
+						Expect(73);
 						QualifiedModuleName(out idAssignment);
 					}
 					submodule = new ModuleFacadeDecl(idPath, id, parent, idAssignment, opened); 
+					//errors.Warning(t, "\"import A as B\" has been deprecated; in the new syntax, it is \"import A:B\"");
+					
+				} else if (la.kind == 21) {
+					Get();
+					QualifiedModuleName(out idPath);
+					submodule = new ModuleFacadeDecl(idPath, id, parent, idAssignment, opened); 
+				} else {
+					Get();
+					QualifiedModuleName(out idPath);
+					idPath.Insert(0, id);
+					submodule = new AliasModuleDecl(idPath, id, parent, opened); 
+					
 				}
 			}
 			if (la.kind == 28) {
-				while (!(la.kind == 0 || la.kind == 28)) {SynErr(142); Get();}
+				while (!(la.kind == 0 || la.kind == 28)) {SynErr(143); Get();}
 				Get();
 				errors.Warning(t, "the semi-colon that used to terminate a sub-module declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 			}
@@ -841,7 +860,51 @@ bool IsType(ref IToken pt) {
 			 submodule = new AliasModuleDecl(idPath, id, parent, opened);
 			}
 			
-		} else SynErr(143);
+		} else if (la.kind == 73 || la.kind == 74) {
+			bool isDefault = false;
+			bool includeBody;
+			IToken exportId;
+			List<ExportSignature> exports = new List<ExportSignature>();;
+			 List<string> extends = new List<string>(); 
+			
+			if (la.kind == 73) {
+				Get();
+				isDefault = true; 
+			}
+			Expect(74);
+			NoUSIdent(out exportId);
+			if (la.kind == 75) {
+				Get();
+				NoUSIdent(out id);
+				extends.Add(id.val); 
+				while (la.kind == 22) {
+					Get();
+					NoUSIdent(out id);
+					extends.Add(id.val); 
+				}
+			}
+			Expect(46);
+			NoUSIdent(out id);
+			includeBody = false; 
+			if (la.kind == 76) {
+				Get();
+				includeBody = true; 
+			}
+			exports.Add(new ExportSignature(id, includeBody)); 
+			while (la.kind == 22) {
+				Get();
+				NoUSIdent(out id);
+				includeBody = false; 
+				if (la.kind == 76) {
+					Get();
+					includeBody = true; 
+				}
+				exports.Add(new ExportSignature(id, includeBody)); 
+			}
+			Expect(47);
+			submodule = new ModuleExportDecl(exportId, parent, isDefault, exports, extends);
+			
+		} else SynErr(144);
 	}
 
 	void ClassDecl(DeclModifierData dmodClass, ModuleDefinition/*!*/ module, out ClassDecl/*!*/ c) {
@@ -857,8 +920,8 @@ bool IsType(ref IToken pt) {
 		CheckDeclModifiers(dmodClass, "Classes", AllowedDeclModifiers.Extern);
 		DeclModifierData dmod; 
 		
-		while (!(la.kind == 0 || la.kind == 74)) {SynErr(144); Get();}
-		Expect(74);
+		while (!(la.kind == 0 || la.kind == 77)) {SynErr(145); Get();}
+		Expect(77);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -879,7 +942,7 @@ bool IsType(ref IToken pt) {
 		}
 		Expect(46);
 		bodyStart = t;  
-		while (StartOf(3)) {
+		while (StartOf(4)) {
 			dmod = new DeclModifierData(); 
 			while (StartOf(2)) {
 				DeclModifier(ref dmod);
@@ -904,13 +967,13 @@ bool IsType(ref IToken pt) {
 		bool co = false;
 		CheckDeclModifiers(dmod, "Datatypes or codatatypes", AllowedDeclModifiers.None);
 		
-		while (!(la.kind == 0 || la.kind == 77 || la.kind == 78)) {SynErr(145); Get();}
-		if (la.kind == 77) {
+		while (!(la.kind == 0 || la.kind == 79 || la.kind == 80)) {SynErr(146); Get();}
+		if (la.kind == 79) {
 			Get();
-		} else if (la.kind == 78) {
+		} else if (la.kind == 80) {
 			Get();
 			co = true; 
-		} else SynErr(146);
+		} else SynErr(147);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -926,7 +989,7 @@ bool IsType(ref IToken pt) {
 			DatatypeMemberDecl(ctors);
 		}
 		if (la.kind == 28) {
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(147); Get();}
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(148); Get();}
 			Get();
 			errors.Warning(t, "the semi-colon that used to terminate a (co)datatype declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 		}
@@ -948,7 +1011,7 @@ bool IsType(ref IToken pt) {
 		Expression wh;
 		CheckDeclModifiers(dmod, "Newtypes", AllowedDeclModifiers.None);
 		
-		Expect(80);
+		Expect(82);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -964,10 +1027,10 @@ bool IsType(ref IToken pt) {
 			Expect(23);
 			Expression(out wh, false, true);
 			td = new NewtypeDecl(theVerifyThisFile ? id : new IncludeToken(id), id.val, module, new BoundVar(bvId, bvId.val, baseType), wh, attrs); 
-		} else if (StartOf(4)) {
+		} else if (StartOf(5)) {
 			Type(out baseType);
 			td = new NewtypeDecl(theVerifyThisFile ? id : new IncludeToken(id), id.val, module, baseType, attrs); 
-		} else SynErr(148);
+		} else SynErr(149);
 	}
 
 	void OtherTypeDecl(DeclModifierData dmod, ModuleDefinition module, out TopLevelDecl td) {
@@ -979,7 +1042,7 @@ bool IsType(ref IToken pt) {
 		Type ty;
 		CheckDeclModifiers(dmod, "Type aliases", AllowedDeclModifiers.None);
 		
-		Expect(81);
+		Expect(83);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -992,7 +1055,7 @@ bool IsType(ref IToken pt) {
 			if (la.kind == 52) {
 				GenericParameters(typeArgs);
 			}
-		} else if (StartOf(5)) {
+		} else if (StartOf(6)) {
 			if (la.kind == 52) {
 				GenericParameters(typeArgs);
 			}
@@ -1001,13 +1064,13 @@ bool IsType(ref IToken pt) {
 				Type(out ty);
 				td = new TypeSynonymDecl(id, id.val, typeArgs, module, ty, attrs); 
 			}
-		} else SynErr(149);
+		} else SynErr(150);
 		if (td == null) {
 		 td = new OpaqueTypeDecl(id, id.val, module, eqSupport, typeArgs, attrs);
 		}
 		
 		if (la.kind == 28) {
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(150); Get();}
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(151); Get();}
 			Get();
 			errors.Warning(t, "the semi-colon that used to terminate an opaque-type declaration has been deprecated; in the new syntax, just leave off the semi-colon"); 
 		}
@@ -1037,8 +1100,8 @@ bool IsType(ref IToken pt) {
 		IToken bodyEnd = Token.NoToken;
 		CheckDeclModifiers(dmod, "Iterators", AllowedDeclModifiers.None);
 		
-		while (!(la.kind == 0 || la.kind == 82)) {SynErr(151); Get();}
-		Expect(82);
+		while (!(la.kind == 0 || la.kind == 84)) {SynErr(152); Get();}
+		Expect(84);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -1048,8 +1111,8 @@ bool IsType(ref IToken pt) {
 				GenericParameters(typeArgs);
 			}
 			Formals(true, true, ins);
-			if (la.kind == 83 || la.kind == 84) {
-				if (la.kind == 83) {
+			if (la.kind == 85 || la.kind == 86) {
+				if (la.kind == 85) {
 					Get();
 				} else {
 					Get();
@@ -1060,8 +1123,8 @@ bool IsType(ref IToken pt) {
 		} else if (la.kind == 59) {
 			Get();
 			signatureEllipsis = t; 
-		} else SynErr(152);
-		while (StartOf(6)) {
+		} else SynErr(153);
+		while (StartOf(7)) {
 			IteratorSpec(reads, mod, decreases, req, ens, yieldReq, yieldEns, ref readsAttrs, ref modAttrs, ref decrAttrs);
 		}
 		if (la.kind == 46) {
@@ -1080,8 +1143,8 @@ bool IsType(ref IToken pt) {
 
 	void TraitDecl(DeclModifierData dmodIn, ModuleDefinition/*!*/ module, out TraitDecl/*!*/ trait) {
 		Contract.Requires(module != null);     
-		CheckDeclModifiers(dmodIn, "Traits", AllowedDeclModifiers.None);
 		Contract.Ensures(Contract.ValueAtReturn(out trait) != null);
+		CheckDeclModifiers(dmodIn, "Traits", AllowedDeclModifiers.None);
 		IToken/*!*/ id;
 		Attributes attrs = null;
 		List<TypeParameter/*!*/> typeArgs = new List<TypeParameter/*!*/>(); //traits should not support type parameters at the moment
@@ -1089,8 +1152,8 @@ bool IsType(ref IToken pt) {
 		IToken bodyStart;
 		DeclModifierData dmod; 
 		
-		while (!(la.kind == 0 || la.kind == 76)) {SynErr(153); Get();}
-		Expect(76);
+		while (!(la.kind == 0 || la.kind == 78)) {SynErr(154); Get();}
+		Expect(78);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -1100,7 +1163,7 @@ bool IsType(ref IToken pt) {
 		}
 		Expect(46);
 		bodyStart = t; 
-		while (StartOf(3)) {
+		while (StartOf(4)) {
 			dmod  = new DeclModifierData(); 
 			while (StartOf(2)) {
 				DeclModifier(ref dmod);
@@ -1119,7 +1182,7 @@ bool IsType(ref IToken pt) {
 		Method/*!*/ m;
 		Function/*!*/ f;
 		
-		if (la.kind == 79) {
+		if (la.kind == 81) {
 			if (moduleLevelDecl) {
 			 SemErr(la, "fields are not allowed to be declared at the module level; instead, wrap the field in a 'class' declaration");
 			 dmod.IsStatic = false;
@@ -1134,7 +1197,7 @@ bool IsType(ref IToken pt) {
 			
 			FunctionDecl(dmod, isWithinAbstractModule, out f);
 			mm.Add(f); 
-		} else if (StartOf(7)) {
+		} else if (StartOf(8)) {
 			if (moduleLevelDecl && dmod.StaticToken != null) {
 			 errors.Warning(dmod.StaticToken, "module-level methods are always non-instance, so the 'static' keyword is not allowed here");
 			 dmod.IsStatic = false;
@@ -1142,7 +1205,7 @@ bool IsType(ref IToken pt) {
 			
 			MethodDecl(dmod, allowConstructors, isWithinAbstractModule, out m);
 			mm.Add(m); 
-		} else SynErr(154);
+		} else SynErr(155);
 	}
 
 	void Attribute(ref Attributes attrs) {
@@ -1153,7 +1216,7 @@ bool IsType(ref IToken pt) {
 		Expect(21);
 		NoUSIdent(out x);
 		name = x.val; 
-		if (StartOf(8)) {
+		if (StartOf(9)) {
 			Expressions(args);
 		}
 		Expect(47);
@@ -1228,8 +1291,8 @@ bool IsType(ref IToken pt) {
 		IToken/*!*/ id;  Type/*!*/ ty;
 		CheckDeclModifiers(dmod, "Fields", AllowedDeclModifiers.Ghost);
 		
-		while (!(la.kind == 0 || la.kind == 79)) {SynErr(155); Get();}
-		Expect(79);
+		while (!(la.kind == 0 || la.kind == 81)) {SynErr(156); Get();}
+		Expect(81);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -1264,7 +1327,7 @@ bool IsType(ref IToken pt) {
 		
 		if (la.kind == 38) {
 			Get();
-			if (la.kind == 85) {
+			if (la.kind == 87) {
 				Get();
 				isFunctionMethod = true; 
 			}
@@ -1290,11 +1353,11 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(156);
+			} else SynErr(157);
 		} else if (la.kind == 39) {
 			Get();
 			isPredicate = true; 
-			if (la.kind == 85) {
+			if (la.kind == 87) {
 				Get();
 				isFunctionMethod = true; 
 			}
@@ -1310,7 +1373,7 @@ bool IsType(ref IToken pt) {
 				Attribute(ref attrs);
 			}
 			NoUSIdent(out id);
-			if (StartOf(9)) {
+			if (StartOf(10)) {
 				if (la.kind == 52) {
 					GenericParameters(typeArgs);
 				}
@@ -1327,7 +1390,7 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(157);
+			} else SynErr(158);
 		} else if (la.kind == 40) {
 			Get();
 			Expect(39);
@@ -1351,7 +1414,7 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(158);
+			} else SynErr(159);
 		} else if (la.kind == 42) {
 			Get();
 			isCoPredicate = true; 
@@ -1374,10 +1437,10 @@ bool IsType(ref IToken pt) {
 			} else if (la.kind == 59) {
 				Get();
 				signatureEllipsis = t; 
-			} else SynErr(159);
-		} else SynErr(160);
+			} else SynErr(160);
+		} else SynErr(161);
 		decreases = isIndPredicate || isCoPredicate ? null : new List<Expression/*!*/>(); 
-		while (StartOf(10)) {
+		while (StartOf(11)) {
 			FunctionSpec(reqs, reads, ens, decreases);
 		}
 		if (la.kind == 46) {
@@ -1437,9 +1500,9 @@ bool IsType(ref IToken pt) {
 		AllowedDeclModifiers allowed = AllowedDeclModifiers.None;
 		string caption = "";
 		
-		while (!(StartOf(11))) {SynErr(161); Get();}
+		while (!(StartOf(12))) {SynErr(162); Get();}
 		switch (la.kind) {
-		case 85: {
+		case 87: {
 			Get();
 			caption = "Methods";
 			allowed = AllowedDeclModifiers.Ghost | AllowedDeclModifiers.Static 
@@ -1453,14 +1516,14 @@ bool IsType(ref IToken pt) {
 			 | AllowedDeclModifiers.Protected; 
 			break;
 		}
-		case 86: {
+		case 88: {
 			Get();
 			isCoLemma = true; caption = "Colemmas";
 			allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static 
 			 | AllowedDeclModifiers.Protected; 
 			break;
 		}
-		case 87: {
+		case 89: {
 			Get();
 			isCoLemma = true; caption = "Comethods";
 			allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static 
@@ -1476,7 +1539,7 @@ bool IsType(ref IToken pt) {
 			allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static;
 			break;
 		}
-		case 88: {
+		case 90: {
 			Get();
 			if (allowConstructor) {
 			 isConstructor = true;
@@ -1488,7 +1551,7 @@ bool IsType(ref IToken pt) {
 			
 			break;
 		}
-		default: SynErr(162); break;
+		default: SynErr(163); break;
 		}
 		keywordToken = t; 
 		CheckDeclModifiers(dmod, caption, allowed); 
@@ -1512,7 +1575,7 @@ bool IsType(ref IToken pt) {
 				GenericParameters(typeArgs);
 			}
 			Formals(true, !dmod.IsGhost, ins);
-			if (la.kind == 84) {
+			if (la.kind == 86) {
 				Get();
 				if (isConstructor) { SemErr(t, "constructors cannot have out-parameters"); } 
 				Formals(false, !dmod.IsGhost, outs);
@@ -1520,8 +1583,8 @@ bool IsType(ref IToken pt) {
 		} else if (la.kind == 59) {
 			Get();
 			signatureEllipsis = t; 
-		} else SynErr(163);
-		while (StartOf(12)) {
+		} else SynErr(164);
+		while (StartOf(13)) {
 			MethodSpec(req, mod, ens, dec, ref decAttrs, ref modAttrs);
 		}
 		if (la.kind == 46) {
@@ -1572,7 +1635,7 @@ bool IsType(ref IToken pt) {
 	void FormalsOptionalIds(List<Formal/*!*/>/*!*/ formals) {
 		Contract.Requires(cce.NonNullElements(formals)); IToken/*!*/ id;  Type/*!*/ ty;  string/*!*/ name;  bool isGhost; 
 		Expect(50);
-		if (StartOf(13)) {
+		if (StartOf(14)) {
 			TypeIdentOptional(out id, out name, out ty, out isGhost);
 			formals.Add(new Formal(id, name, ty, true, isGhost)); 
 			while (la.kind == 22) {
@@ -1593,14 +1656,14 @@ bool IsType(ref IToken pt) {
 		} else if (la.kind == 2) {
 			Get();
 			id = t; 
-		} else SynErr(164);
+		} else SynErr(165);
 		Expect(21);
 		Type(out ty);
 	}
 
 	void OldSemi() {
 		if (la.kind == 28) {
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(165); Get();}
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(166); Get();}
 			Get();
 		}
 	}
@@ -1679,7 +1742,7 @@ bool IsType(ref IToken pt) {
 			Get();
 			isGhost = true; 
 		}
-		if (StartOf(4)) {
+		if (StartOf(5)) {
 			TypeAndToken(out id, out ty);
 			if (la.kind == 21) {
 				Get();
@@ -1697,7 +1760,7 @@ bool IsType(ref IToken pt) {
 			id = t; name = id.val;
 			Expect(21);
 			Type(out ty);
-		} else SynErr(166);
+		} else SynErr(167);
 		if (name != null) {
 		 identName = name;
 		} else {
@@ -1848,7 +1911,7 @@ bool IsType(ref IToken pt) {
 		case 50: {
 			Get();
 			tok = t; tupleArgTypes = new List<Type>(); 
-			if (StartOf(4)) {
+			if (StartOf(5)) {
 				Type(out ty);
 				tupleArgTypes.Add(ty); 
 				while (la.kind == 22) {
@@ -1885,7 +1948,7 @@ bool IsType(ref IToken pt) {
 			ty = new UserDefinedType(e.tok, e); 
 			break;
 		}
-		default: SynErr(167); break;
+		default: SynErr(168); break;
 		}
 		if (la.kind == 30) {
 			Type t2; 
@@ -1924,7 +1987,7 @@ List<MaybeFreeExpression/*!*/>/*!*/ yieldReq, List<MaybeFreeExpression/*!*/>/*!*
 ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 		Expression/*!*/ e; FrameExpression/*!*/ fe; bool isFree = false; bool isYield = false; Attributes ensAttrs = null;
 		
-		while (!(StartOf(14))) {SynErr(168); Get();}
+		while (!(StartOf(15))) {SynErr(169); Get();}
 		if (la.kind == 44) {
 			Get();
 			while (IsAttribute()) {
@@ -1951,14 +2014,14 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 				mod.Add(fe); 
 			}
 			OldSemi();
-		} else if (StartOf(15)) {
-			if (la.kind == 89) {
+		} else if (StartOf(16)) {
+			if (la.kind == 91) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
 				
 			}
-			if (la.kind == 91) {
+			if (la.kind == 93) {
 				Get();
 				isYield = true; 
 			}
@@ -1972,7 +2035,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 				 req.Add(new MaybeFreeExpression(e, isFree));
 				}
 				
-			} else if (la.kind == 90) {
+			} else if (la.kind == 92) {
 				Get();
 				while (IsAttribute()) {
 					Attribute(ref ensAttrs);
@@ -1985,7 +2048,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 				 ens.Add(new MaybeFreeExpression(e, isFree, ensAttrs));
 				}
 				
-			} else SynErr(169);
+			} else SynErr(170);
 		} else if (la.kind == 36) {
 			Get();
 			while (IsAttribute()) {
@@ -1993,7 +2056,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 			}
 			DecreasesList(decreases, false, false);
 			OldSemi();
-		} else SynErr(170);
+		} else SynErr(171);
 	}
 
 	void BlockStmt(out BlockStmt/*!*/ block, out IToken bodyStart, out IToken bodyEnd) {
@@ -2002,7 +2065,7 @@ ref Attributes readsAttrs, ref Attributes modAttrs, ref Attributes decrAttrs) {
 		
 		Expect(46);
 		bodyStart = t; 
-		while (StartOf(16)) {
+		while (StartOf(17)) {
 			Stmt(body);
 		}
 		Expect(47);
@@ -2015,7 +2078,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Requires(cce.NonNullElements(req)); Contract.Requires(cce.NonNullElements(mod)); Contract.Requires(cce.NonNullElements(ens)); Contract.Requires(cce.NonNullElements(decreases));
 		Expression/*!*/ e;  FrameExpression/*!*/ fe;  bool isFree = false; Attributes ensAttrs = null;
 		
-		while (!(StartOf(17))) {SynErr(171); Get();}
+		while (!(StartOf(18))) {SynErr(172); Get();}
 		if (la.kind == 43) {
 			Get();
 			while (IsAttribute()) {
@@ -2029,8 +2092,8 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				mod.Add(fe); 
 			}
 			OldSemi();
-		} else if (la.kind == 45 || la.kind == 89 || la.kind == 90) {
-			if (la.kind == 89) {
+		} else if (la.kind == 45 || la.kind == 91 || la.kind == 92) {
+			if (la.kind == 91) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
@@ -2041,7 +2104,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Expression(out e, false, false);
 				OldSemi();
 				req.Add(new MaybeFreeExpression(e, isFree)); 
-			} else if (la.kind == 90) {
+			} else if (la.kind == 92) {
 				Get();
 				while (IsAttribute()) {
 					Attribute(ref ensAttrs);
@@ -2049,7 +2112,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Expression(out e, false, false);
 				OldSemi();
 				ens.Add(new MaybeFreeExpression(e, isFree, ensAttrs)); 
-			} else SynErr(172);
+			} else SynErr(173);
 		} else if (la.kind == 36) {
 			Get();
 			while (IsAttribute()) {
@@ -2057,7 +2120,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			DecreasesList(decreases, true, false);
 			OldSemi();
-		} else SynErr(173);
+		} else SynErr(174);
 	}
 
 	void FrameExpression(out FrameExpression fe, bool allowSemi, bool allowLambda) {
@@ -2067,21 +2130,21 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		string fieldName = null;  IToken feTok = null;
 		fe = null;
 		
-		if (StartOf(8)) {
+		if (StartOf(9)) {
 			Expression(out e, allowSemi, allowLambda);
 			feTok = e.tok; 
-			if (la.kind == 92) {
+			if (la.kind == 94) {
 				Get();
 				Ident(out id);
 				fieldName = id.val;  feTok = id; 
 			}
 			fe = new FrameExpression(feTok, e, fieldName); 
-		} else if (la.kind == 92) {
+		} else if (la.kind == 94) {
 			Get();
 			Ident(out id);
 			fieldName = id.val; 
 			fe = new FrameExpression(id, new ImplicitThisExpr(id), fieldName); 
-		} else SynErr(174);
+		} else SynErr(175);
 	}
 
 	void DecreasesList(List<Expression> decreases, bool allowWildcard, bool allowLambda) {
@@ -2136,7 +2199,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Requires(cce.NonNullElements(reads));
 		Contract.Requires(decreases == null || cce.NonNullElements(decreases));
 		Expression/*!*/ e;  FrameExpression/*!*/ fe; 
-		while (!(StartOf(18))) {SynErr(175); Get();}
+		while (!(StartOf(19))) {SynErr(176); Get();}
 		if (la.kind == 45) {
 			Get();
 			Expression(out e, false, false);
@@ -2152,7 +2215,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				reads.Add(fe); 
 			}
 			OldSemi();
-		} else if (la.kind == 90) {
+		} else if (la.kind == 92) {
 			Get();
 			Expression(out e, false, false);
 			OldSemi();
@@ -2166,7 +2229,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			
 			DecreasesList(decreases, false, false);
 			OldSemi();
-		} else SynErr(176);
+		} else SynErr(177);
 	}
 
 	void FunctionBody(out Expression/*!*/ e, out IToken bodyStart, out IToken bodyEnd) {
@@ -2183,9 +2246,9 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 57) {
 			Get();
 			fe = new FrameExpression(t, new WildcardExpr(t), null); 
-		} else if (StartOf(19)) {
+		} else if (StartOf(20)) {
 			FrameExpression(out fe, allowSemi, false);
-		} else SynErr(177);
+		} else SynErr(178);
 	}
 
 	void PossiblyWildExpression(out Expression e, bool allowLambda) {
@@ -2194,9 +2257,9 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 57) {
 			Get();
 			e = new WildcardExpr(t); 
-		} else if (StartOf(8)) {
+		} else if (StartOf(9)) {
 			Expression(out e, false, allowLambda);
-		} else SynErr(178);
+		} else SynErr(179);
 	}
 
 	void Stmt(List<Statement/*!*/>/*!*/ ss) {
@@ -2213,14 +2276,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken bodyStart, bodyEnd;
 		int breakCount;
 		
-		while (!(StartOf(20))) {SynErr(179); Get();}
+		while (!(StartOf(21))) {SynErr(180); Get();}
 		switch (la.kind) {
 		case 46: {
 			BlockStmt(out bs, out bodyStart, out bodyEnd);
 			s = bs; 
 			break;
 		}
-		case 102: {
+		case 104: {
 			AssertStmt(out s);
 			break;
 		}
@@ -2228,31 +2291,31 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			AssumeStmt(out s);
 			break;
 		}
-		case 103: {
+		case 105: {
 			PrintStmt(out s);
 			break;
 		}
-		case 1: case 2: case 3: case 4: case 8: case 10: case 19: case 20: case 23: case 50: case 132: case 133: case 134: case 135: case 136: case 137: {
+		case 1: case 2: case 3: case 4: case 8: case 10: case 19: case 20: case 23: case 50: case 133: case 134: case 135: case 136: case 137: case 138: {
 			UpdateStmt(out s);
 			break;
 		}
-		case 62: case 79: {
+		case 62: case 81: {
 			VarDeclStatement(out s);
 			break;
 		}
-		case 99: {
+		case 101: {
 			IfStmt(out s);
 			break;
 		}
-		case 100: {
+		case 102: {
 			WhileStmt(out s);
 			break;
 		}
-		case 101: {
+		case 103: {
 			MatchStmt(out s);
 			break;
 		}
-		case 104: case 105: {
+		case 106: case 107: {
 			ForallStmt(out s);
 			break;
 		}
@@ -2260,11 +2323,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			CalcStmt(out s);
 			break;
 		}
-		case 106: {
+		case 108: {
 			ModifyStmt(out s);
 			break;
 		}
-		case 93: {
+		case 95: {
 			Get();
 			x = t; 
 			NoUSIdent(out id);
@@ -2273,24 +2336,24 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			s.Labels = new LList<Label>(new Label(x, id.val), s.Labels); 
 			break;
 		}
-		case 94: {
+		case 96: {
 			Get();
 			x = t; breakCount = 1; label = null; 
 			if (la.kind == 1) {
 				NoUSIdent(out id);
 				label = id.val; 
-			} else if (la.kind == 28 || la.kind == 94) {
-				while (la.kind == 94) {
+			} else if (la.kind == 28 || la.kind == 96) {
+				while (la.kind == 96) {
 					Get();
 					breakCount++; 
 				}
-			} else SynErr(180);
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(181); Get();}
+			} else SynErr(181);
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(182); Get();}
 			Expect(28);
 			s = label != null ? new BreakStmt(x, t, label) : new BreakStmt(x, t, breakCount); 
 			break;
 		}
-		case 91: case 97: {
+		case 93: case 99: {
 			ReturnStmt(out s);
 			break;
 		}
@@ -2298,7 +2361,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			SkeletonStmt(out s);
 			break;
 		}
-		default: SynErr(182); break;
+		default: SynErr(183); break;
 		}
 	}
 
@@ -2307,17 +2370,17 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression e = dummyExpr; Attributes attrs = null;
 		IToken dotdotdot = null;
 		
-		Expect(102);
+		Expect(104);
 		x = t; 
 		while (IsAttribute()) {
 			Attribute(ref attrs);
 		}
-		if (StartOf(8)) {
+		if (StartOf(9)) {
 			Expression(out e, false, true);
 		} else if (la.kind == 59) {
 			Get();
 			dotdotdot = t; 
-		} else SynErr(183);
+		} else SynErr(184);
 		Expect(28);
 		if (dotdotdot != null) {
 		 s = new SkeletonStatement(new AssertStmt(x, t, new LiteralExpr(x, true), attrs), dotdotdot, null);
@@ -2337,12 +2400,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		while (IsAttribute()) {
 			Attribute(ref attrs);
 		}
-		if (StartOf(8)) {
+		if (StartOf(9)) {
 			Expression(out e, false, true);
 		} else if (la.kind == 59) {
 			Get();
 			dotdotdot = t; 
-		} else SynErr(184);
+		} else SynErr(185);
 		Expect(28);
 		if (dotdotdot != null) {
 		 s = new SkeletonStatement(new AssumeStmt(x, t, new LiteralExpr(x, true), attrs), dotdotdot, null);
@@ -2357,7 +2420,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken x;  Expression e;
 		var args = new List<Expression>();
 		
-		Expect(103);
+		Expect(105);
 		x = t; 
 		Expression(out e, false, true);
 		args.Add(e); 
@@ -2387,14 +2450,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			Expect(28);
 			endTok = t; rhss.Add(new ExprRhs(e, attrs)); 
-		} else if (la.kind == 22 || la.kind == 25 || la.kind == 96) {
+		} else if (la.kind == 22 || la.kind == 25 || la.kind == 98) {
 			lhss.Add(e); 
 			while (la.kind == 22) {
 				Get();
 				Lhs(out e);
 				lhss.Add(e); 
 			}
-			if (la.kind == 96) {
+			if (la.kind == 98) {
 				Get();
 				x = t; 
 				Rhs(out r);
@@ -2412,13 +2475,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					suchThatAssume = t; 
 				}
 				Expression(out suchThat, false, true);
-			} else SynErr(185);
+			} else SynErr(186);
 			Expect(28);
 			endTok = t; 
 		} else if (la.kind == 21) {
 			Get();
 			SemErr(t, "invalid statement (did you forget the 'label' keyword?)"); 
-		} else SynErr(186);
+		} else SynErr(187);
 		if (suchThat != null) {
 		 s = new AssignSuchThatStmt(x, endTok, lhss, suchThat, suchThatAssume, null);
 		} else {
@@ -2447,7 +2510,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 			isGhost = true;  x = t; 
 		}
-		Expect(79);
+		Expect(81);
 		if (!isGhost) { x = t; } 
 		if (la.kind == 1 || la.kind == 46) {
 			while (la.kind == 46) {
@@ -2463,8 +2526,8 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				LocalIdentTypeOptional(out d, isGhost);
 				lhss.Add(d); d.Attributes = attrs; attrs = null; 
 			}
-			if (la.kind == 25 || la.kind == 46 || la.kind == 96) {
-				if (la.kind == 96) {
+			if (la.kind == 25 || la.kind == 46 || la.kind == 98) {
+				if (la.kind == 98) {
 					Get();
 					assignTok = t; 
 					Rhs(out r);
@@ -2487,7 +2550,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					Expression(out suchThat, false, true);
 				}
 			}
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(187); Get();}
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(188); Get();}
 			Expect(28);
 			endTok = t; 
 			ConcreteUpdateStatement update;
@@ -2533,7 +2596,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			if (isGhost) { pat.Vars.Iter(bv => bv.IsGhost = true); }
 			letLHSs.Add(pat);
 			
-			if (la.kind == 96) {
+			if (la.kind == 98) {
 				Get();
 			} else if (la.kind == 25 || la.kind == 46) {
 				while (la.kind == 46) {
@@ -2541,12 +2604,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				}
 				Expect(25);
 				SemErr(pat.tok, "LHS of assign-such-that expression must be variables, not general patterns"); 
-			} else SynErr(188);
+			} else SynErr(189);
 			Expression(out e, false, true);
 			letRHSs.Add(e); 
 			Expect(28);
 			s = new LetStmt(e.tok, e.tok, letLHSs, letRHSs); 
-		} else SynErr(189);
+		} else SynErr(190);
 	}
 
 	void IfStmt(out Statement/*!*/ ifStmt) {
@@ -2560,16 +2623,16 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<GuardedAlternative> alternatives;
 		ifStmt = dummyStmt;  // to please the compiler
 		
-		Expect(99);
+		Expect(101);
 		x = t; 
 		if (IsAlternative()) {
 			AlternativeBlock(true, out alternatives, out endTok);
 			ifStmt = new AlternativeStmt(x, endTok, alternatives); 
-		} else if (StartOf(21)) {
+		} else if (StartOf(22)) {
 			if (IsExistentialGuard()) {
 				ExistentialGuard(out guard, true);
 				isExistentialGuard = true; 
-			} else if (StartOf(22)) {
+			} else if (StartOf(23)) {
 				Guard(out guard);
 			} else {
 				Get();
@@ -2579,13 +2642,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			endTok = thn.EndTok; 
 			if (la.kind == 35) {
 				Get();
-				if (la.kind == 99) {
+				if (la.kind == 101) {
 					IfStmt(out s);
 					els = s; endTok = s.EndTok; 
 				} else if (la.kind == 46) {
 					BlockStmt(out bs, out bodyStart, out bodyEnd);
 					els = bs; endTok = bs.EndTok; 
-				} else SynErr(190);
+				} else SynErr(191);
 			}
 			if (guardEllipsis != null) {
 			 ifStmt = new SkeletonStatement(new IfStmt(x, endTok, isExistentialGuard, guard, thn, els), guardEllipsis, null);
@@ -2593,7 +2656,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 ifStmt = new IfStmt(x, endTok, isExistentialGuard, guard, thn, els);
 			}
 			
-		} else SynErr(191);
+		} else SynErr(192);
 	}
 
 	void WhileStmt(out Statement stmt) {
@@ -2612,23 +2675,23 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		stmt = dummyStmt;  // to please the compiler
 		bool isDirtyLoop = true;
 		
-		Expect(100);
+		Expect(102);
 		x = t; 
 		if (IsLoopSpec() || IsAlternative()) {
-			while (StartOf(23)) {
+			while (StartOf(24)) {
 				LoopSpec(invariants, decreases, ref mod, ref decAttrs, ref modAttrs);
 			}
 			AlternativeBlock(false, out alternatives, out endTok);
 			stmt = new AlternativeLoopStmt(x, endTok, invariants, new Specification<Expression>(decreases, decAttrs), new Specification<FrameExpression>(mod, modAttrs), alternatives); 
-		} else if (StartOf(21)) {
-			if (StartOf(22)) {
+		} else if (StartOf(22)) {
+			if (StartOf(23)) {
 				Guard(out guard);
 				Contract.Assume(guard == null || cce.Owner.None(guard)); 
 			} else {
 				Get();
 				guardEllipsis = t; 
 			}
-			while (StartOf(23)) {
+			while (StartOf(24)) {
 				LoopSpec(invariants, decreases, ref mod, ref decAttrs, ref modAttrs);
 			}
 			if (la.kind == _lbrace) {
@@ -2637,8 +2700,8 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			} else if (la.kind == _ellipsis) {
 				Expect(59);
 				bodyEllipsis = t; endTok = t; isDirtyLoop = false; 
-			} else if (StartOf(24)) {
-			} else SynErr(192);
+			} else if (StartOf(25)) {
+			} else SynErr(193);
 			if (guardEllipsis != null || bodyEllipsis != null) {
 			 if (mod != null) {
 			   SemErr(mod[0].E.tok, "'modifies' clauses are not allowed on refining loops");
@@ -2656,7 +2719,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 stmt = new WhileStmt(x, endTok, guard, invariants, new Specification<Expression>(decreases, decAttrs), new Specification<FrameExpression>(mod, modAttrs), body);
 			}
 			
-		} else SynErr(193);
+		} else SynErr(194);
 	}
 
 	void MatchStmt(out Statement/*!*/ s) {
@@ -2665,7 +2728,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<MatchCaseStmt/*!*/> cases = new List<MatchCaseStmt/*!*/>();
 		bool usesOptionalBrace = false;
 		
-		Expect(101);
+		Expect(103);
 		x = t; 
 		Expression(out e, true, true);
 		if (la.kind == _lbrace) {
@@ -2676,12 +2739,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				cases.Add(c); 
 			}
 			Expect(47);
-		} else if (StartOf(24)) {
+		} else if (StartOf(25)) {
 			while (la.kind == _case) {
 				CaseStatement(out c);
 				cases.Add(c); 
 			}
-		} else SynErr(194);
+		} else SynErr(195);
 		s = new MatchStmt(x, t, e, cases, usesOptionalBrace); 
 	}
 
@@ -2698,38 +2761,38 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		IToken bodyStart, bodyEnd;
 		IToken tok = Token.NoToken;
 		
-		if (la.kind == 104) {
+		if (la.kind == 106) {
 			Get();
 			x = t; tok = x; 
-		} else if (la.kind == 105) {
+		} else if (la.kind == 107) {
 			Get();
 			x = t;
 			errors.Warning(t, "the 'parallel' keyword has been deprecated; the comprehension statement now uses the keyword 'forall' (and the parentheses around the bound variables are now optional)");
 			
-		} else SynErr(195);
+		} else SynErr(196);
 		if (la.kind == _openparen) {
 			Expect(50);
 			if (la.kind == 1) {
 				QuantifierDomain(out bvars, out attrs, out range);
 			}
 			Expect(51);
-		} else if (StartOf(25)) {
+		} else if (StartOf(26)) {
 			if (la.kind == _ident) {
 				QuantifierDomain(out bvars, out attrs, out range);
 			}
-		} else SynErr(196);
+		} else SynErr(197);
 		if (bvars == null) { bvars = new List<BoundVar>(); }
 		if (range == null) { range = new LiteralExpr(x, true); }
 		
-		while (la.kind == 89 || la.kind == 90) {
+		while (la.kind == 91 || la.kind == 92) {
 			isFree = false; 
-			if (la.kind == 89) {
+			if (la.kind == 91) {
 				Get();
 				isFree = true;
 				errors.Warning(t, "the 'free' keyword is soon to be deprecated");
 				
 			}
-			Expect(90);
+			Expect(92);
 			Expression(out e, false, true);
 			ens.Add(new MaybeFreeExpression(e, isFree)); 
 			OldSemi();
@@ -2768,7 +2831,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		while (IsAttribute()) {
 			Attribute(ref attrs);
 		}
-		if (StartOf(26)) {
+		if (StartOf(27)) {
 			CalcOp(out opTok, out calcOp);
 			maybeOp = calcOp.ResultOp(calcOp); // guard against non-transitive calcOp (like !=)
 			if (maybeOp == null) {
@@ -2778,11 +2841,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			
 		}
 		Expect(46);
-		while (StartOf(8)) {
+		while (StartOf(9)) {
 			Expression(out e, false, true);
 			lines.Add(e); stepOp = calcOp; danglingOperator = null; 
 			Expect(28);
-			if (StartOf(26)) {
+			if (StartOf(27)) {
 				CalcOp(out opTok, out op);
 				maybeOp = resOp.ResultOp(op);
 				if (maybeOp == null) {
@@ -2807,7 +2870,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				} else if (la.kind == 32) {
 					CalcStmt(out subCalc);
 					hintEnd = subCalc.EndTok; subhints.Add(subCalc); 
-				} else SynErr(197);
+				} else SynErr(198);
 			}
 			var h = new BlockStmt(hintStart, hintEnd, subhints); // if the hint is empty, hintStart is the first token of the next line, but it doesn't matter because the block statement is just used as a container
 			hints.Add(h);
@@ -2833,12 +2896,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		BlockStmt body = null;  IToken bodyStart;
 		IToken ellipsisToken = null;
 		
-		Expect(106);
+		Expect(108);
 		tok = t; 
 		while (IsAttribute()) {
 			Attribute(ref attrs);
 		}
-		if (StartOf(19)) {
+		if (StartOf(20)) {
 			FrameExpression(out fe, false, true);
 			mod.Add(fe); 
 			while (la.kind == 22) {
@@ -2849,14 +2912,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 59) {
 			Get();
 			ellipsisToken = t; 
-		} else SynErr(198);
+		} else SynErr(199);
 		if (la.kind == 46) {
 			BlockStmt(out body, out bodyStart, out endTok);
 		} else if (la.kind == 28) {
-			while (!(la.kind == 0 || la.kind == 28)) {SynErr(199); Get();}
+			while (!(la.kind == 0 || la.kind == 28)) {SynErr(200); Get();}
 			Get();
 			endTok = t; 
-		} else SynErr(200);
+		} else SynErr(201);
 		s = new ModifyStmt(tok, endTok, mod, attrs, body);
 		if (ellipsisToken != null) {
 		 s = new SkeletonStatement(s, ellipsisToken, null);
@@ -2870,14 +2933,14 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		AssignmentRhs r;
 		bool isYield = false;
 		
-		if (la.kind == 97) {
+		if (la.kind == 99) {
 			Get();
 			returnTok = t; 
-		} else if (la.kind == 91) {
+		} else if (la.kind == 93) {
 			Get();
 			returnTok = t; isYield = true; 
-		} else SynErr(201);
-		if (StartOf(27)) {
+		} else SynErr(202);
+		if (StartOf(28)) {
 			Rhs(out r);
 			rhss = new List<AssignmentRhs>(); rhss.Add(r); 
 			while (la.kind == 22) {
@@ -2902,7 +2965,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression e; 
 		Expect(59);
 		dotdotdot = t; 
-		if (la.kind == 95) {
+		if (la.kind == 97) {
 			Get();
 			names = new List<IToken>(); exprs = new List<Expression>(); whereTok = t;
 			Ident(out tok);
@@ -2912,7 +2975,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				Ident(out tok);
 				names.Add(tok); 
 			}
-			Expect(96);
+			Expect(98);
 			Expression(out e, false, true);
 			exprs.Add(e); 
 			while (la.kind == 22) {
@@ -2939,7 +3002,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		r = dummyRhs;  // to please compiler
 		Attributes attrs = null;
 		
-		if (la.kind == 98) {
+		if (la.kind == 100) {
 			Get();
 			newToken = t; 
 			TypeAndToken(out x, out ty);
@@ -2954,7 +3017,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				} else {
 					x = null; args = new List<Expression/*!*/>(); 
 					Get();
-					if (StartOf(8)) {
+					if (StartOf(9)) {
 						Expressions(args);
 					}
 					Expect(51);
@@ -2971,10 +3034,10 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 57) {
 			Get();
 			r = new HavocRhs(t); 
-		} else if (StartOf(8)) {
+		} else if (StartOf(9)) {
 			Expression(out e, false, true);
 			r = new ExprRhs(e); 
-		} else SynErr(202);
+		} else SynErr(203);
 		while (la.kind == 46) {
 			Attribute(ref attrs);
 		}
@@ -2989,13 +3052,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			while (la.kind == 27 || la.kind == 48 || la.kind == 50) {
 				Suffix(ref e);
 			}
-		} else if (StartOf(28)) {
+		} else if (StartOf(29)) {
 			ConstAtomExpression(out e, false, false);
 			Suffix(ref e);
 			while (la.kind == 27 || la.kind == 48 || la.kind == 50) {
 				Suffix(ref e);
 			}
-		} else SynErr(203);
+		} else SynErr(204);
 	}
 
 	void Expressions(List<Expression> args) {
@@ -3052,7 +3115,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			IdentTypeOptional(out bv);
 			pat = new CasePattern(bv.tok, bv);
 			
-		} else SynErr(204);
+		} else SynErr(205);
 		if (pat == null) {
 		 pat = new CasePattern(t, "_ParseError", new List<CasePattern>());
 		}
@@ -3072,12 +3135,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			if (allowExistentialGuards && IsExistentialGuard()) {
 				ExistentialGuard(out e, false );
 				isExistentialGuard = true; 
-			} else if (StartOf(8)) {
+			} else if (StartOf(9)) {
 				Expression(out e, true, false);
-			} else SynErr(205);
+			} else SynErr(206);
 			Expect(29);
 			body = new List<Statement>(); 
-			while (StartOf(16)) {
+			while (StartOf(17)) {
 				Stmt(body);
 			}
 			alternatives.Add(new GuardedAlternative(x, isExistentialGuard, e, body)); 
@@ -3117,19 +3180,19 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Expect(57);
 			Expect(51);
 			e = null; 
-		} else if (StartOf(8)) {
+		} else if (StartOf(9)) {
 			Expression(out ee, true, true);
 			e = ee; 
-		} else SynErr(206);
+		} else SynErr(207);
 	}
 
 	void LoopSpec(List<MaybeFreeExpression> invariants, List<Expression> decreases, ref List<FrameExpression> mod, ref Attributes decAttrs, ref Attributes modAttrs) {
 		Expression e; FrameExpression fe;
 		bool isFree = false; Attributes attrs = null;
 		
-		if (la.kind == 37 || la.kind == 89) {
-			while (!(la.kind == 0 || la.kind == 37 || la.kind == 89)) {SynErr(207); Get();}
-			if (la.kind == 89) {
+		if (la.kind == 37 || la.kind == 91) {
+			while (!(la.kind == 0 || la.kind == 37 || la.kind == 91)) {SynErr(208); Get();}
+			if (la.kind == 91) {
 				Get();
 				isFree = true; errors.Warning(t, "the 'free' keyword is soon to be deprecated"); 
 			}
@@ -3141,7 +3204,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			invariants.Add(new MaybeFreeExpression(e, isFree, attrs)); 
 			OldSemi();
 		} else if (la.kind == 36) {
-			while (!(la.kind == 0 || la.kind == 36)) {SynErr(208); Get();}
+			while (!(la.kind == 0 || la.kind == 36)) {SynErr(209); Get();}
 			Get();
 			while (IsAttribute()) {
 				Attribute(ref decAttrs);
@@ -3149,7 +3212,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			DecreasesList(decreases, true, true);
 			OldSemi();
 		} else if (la.kind == 43) {
-			while (!(la.kind == 0 || la.kind == 43)) {SynErr(209); Get();}
+			while (!(la.kind == 0 || la.kind == 43)) {SynErr(210); Get();}
 			Get();
 			mod = mod ?? new List<FrameExpression>(); 
 			while (IsAttribute()) {
@@ -3163,7 +3226,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				mod.Add(fe); 
 			}
 			OldSemi();
-		} else SynErr(210);
+		} else SynErr(211);
 	}
 
 	void CaseStatement(out MatchCaseStmt/*!*/ c) {
@@ -3200,12 +3263,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				arguments.Add(pat); 
 			}
 			Expect(51);
-		} else SynErr(211);
+		} else SynErr(212);
 		Expect(29);
-		while (!(StartOf(29))) {SynErr(212); Get();}
+		while (!(StartOf(30))) {SynErr(213); Get();}
 		while (IsNotEndOfCase()) {
 			Stmt(body);
-			while (!(StartOf(29))) {SynErr(213); Get();}
+			while (!(StartOf(30))) {SynErr(214); Get();}
 		}
 		c = new MatchCaseStmt(x, name, arguments, body); 
 	}
@@ -3241,7 +3304,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		case 54: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Eq; 
-			if (la.kind == 107) {
+			if (la.kind == 109) {
 				Get();
 				Expect(48);
 				Expression(out k, true, true);
@@ -3259,12 +3322,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  binOp = BinaryExpr.Opcode.Gt; 
 			break;
 		}
-		case 108: {
+		case 110: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 109: {
+		case 111: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Ge; 
 			break;
@@ -3279,32 +3342,32 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  binOp = BinaryExpr.Opcode.Neq; 
 			break;
 		}
-		case 110: {
+		case 112: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 111: {
+		case 113: {
 			Get();
 			x = t;  binOp = BinaryExpr.Opcode.Ge; 
 			break;
 		}
-		case 112: case 113: {
+		case 114: case 115: {
 			EquivOp();
 			x = t;  binOp = BinaryExpr.Opcode.Iff; 
 			break;
 		}
-		case 114: case 115: {
+		case 116: case 117: {
 			ImpliesOp();
 			x = t;  binOp = BinaryExpr.Opcode.Imp; 
 			break;
 		}
-		case 116: case 117: {
+		case 118: case 119: {
 			ExpliesOp();
 			x = t;  binOp = BinaryExpr.Opcode.Exp; 
 			break;
 		}
-		default: SynErr(214); break;
+		default: SynErr(215); break;
 		}
 		if (k == null) {
 		 op = new Microsoft.Dafny.CalcStmt.BinaryCalcOp(binOp);
@@ -3315,14 +3378,6 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 	}
 
 	void EquivOp() {
-		if (la.kind == 112) {
-			Get();
-		} else if (la.kind == 113) {
-			Get();
-		} else SynErr(215);
-	}
-
-	void ImpliesOp() {
 		if (la.kind == 114) {
 			Get();
 		} else if (la.kind == 115) {
@@ -3330,7 +3385,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else SynErr(216);
 	}
 
-	void ExpliesOp() {
+	void ImpliesOp() {
 		if (la.kind == 116) {
 			Get();
 		} else if (la.kind == 117) {
@@ -3338,7 +3393,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else SynErr(217);
 	}
 
-	void AndOp() {
+	void ExpliesOp() {
 		if (la.kind == 118) {
 			Get();
 		} else if (la.kind == 119) {
@@ -3346,7 +3401,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else SynErr(218);
 	}
 
-	void OrOp() {
+	void AndOp() {
 		if (la.kind == 120) {
 			Get();
 		} else if (la.kind == 121) {
@@ -3354,7 +3409,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else SynErr(219);
 	}
 
-	void NegOp() {
+	void OrOp() {
 		if (la.kind == 122) {
 			Get();
 		} else if (la.kind == 123) {
@@ -3362,28 +3417,36 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else SynErr(220);
 	}
 
-	void Forall() {
-		if (la.kind == 104) {
+	void NegOp() {
+		if (la.kind == 124) {
 			Get();
-		} else if (la.kind == 124) {
+		} else if (la.kind == 125) {
 			Get();
 		} else SynErr(221);
 	}
 
-	void Exists() {
-		if (la.kind == 125) {
+	void Forall() {
+		if (la.kind == 106) {
 			Get();
 		} else if (la.kind == 126) {
 			Get();
 		} else SynErr(222);
 	}
 
+	void Exists() {
+		if (la.kind == 127) {
+			Get();
+		} else if (la.kind == 128) {
+			Get();
+		} else SynErr(223);
+	}
+
 	void QSep() {
 		if (la.kind == 24) {
 			Get();
 		} else if (la.kind == 26) {
 			Get();
-		} else SynErr(223);
+		} else SynErr(224);
 	}
 
 	void EquivExpression(out Expression e0, bool allowSemi, bool allowLambda) {
@@ -3401,12 +3464,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Ensures(Contract.ValueAtReturn(out e0) != null); IToken/*!*/ x;  Expression/*!*/ e1; 
 		LogicalExpression(out e0, allowSemi, allowLambda);
 		if (IsImpliesOp() || IsExpliesOp()) {
-			if (la.kind == 114 || la.kind == 115) {
+			if (la.kind == 116 || la.kind == 117) {
 				ImpliesOp();
 				x = t; 
 				ImpliesExpression(out e1, allowSemi, allowLambda);
 				e0 = new BinaryExpr(x, BinaryExpr.Opcode.Imp, e0, e1); 
-			} else if (la.kind == 116 || la.kind == 117) {
+			} else if (la.kind == 118 || la.kind == 119) {
 				ExpliesOp();
 				x = t; 
 				LogicalExpression(out e1, allowSemi, allowLambda);
@@ -3418,7 +3481,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					e0 = new BinaryExpr(x, BinaryExpr.Opcode.Exp, e1, e0); 
 					
 				}
-			} else SynErr(224);
+			} else SynErr(225);
 		}
 	}
 
@@ -3426,7 +3489,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Contract.Ensures(Contract.ValueAtReturn(out e0) != null); IToken/*!*/ x;  Expression/*!*/ e1; 
 		RelationalExpression(out e0, allowSemi, allowLambda);
 		if (IsAndOp() || IsOrOp()) {
-			if (la.kind == 118 || la.kind == 119) {
+			if (la.kind == 120 || la.kind == 121) {
 				AndOp();
 				x = t; 
 				RelationalExpression(out e1, allowSemi, allowLambda);
@@ -3437,7 +3500,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					RelationalExpression(out e1, allowSemi, allowLambda);
 					e0 = new BinaryExpr(x, BinaryExpr.Opcode.And, e0, e1); 
 				}
-			} else if (la.kind == 120 || la.kind == 121) {
+			} else if (la.kind == 122 || la.kind == 123) {
 				OrOp();
 				x = t; 
 				RelationalExpression(out e1, allowSemi, allowLambda);
@@ -3448,7 +3511,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					RelationalExpression(out e1, allowSemi, allowLambda);
 					e0 = new BinaryExpr(x, BinaryExpr.Opcode.Or, e0, e1); 
 				}
-			} else SynErr(225);
+			} else SynErr(226);
 		}
 	}
 
@@ -3584,7 +3647,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		case 54: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Eq; 
-			if (la.kind == 107) {
+			if (la.kind == 109) {
 				Get();
 				Expect(48);
 				Expression(out k, true, true);
@@ -3602,12 +3665,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.Gt; 
 			break;
 		}
-		case 108: {
+		case 110: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 109: {
+		case 111: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Ge; 
 			break;
@@ -3615,7 +3678,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		case 55: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Neq; 
-			if (la.kind == 107) {
+			if (la.kind == 109) {
 				Get();
 				Expect(48);
 				Expression(out k, true, true);
@@ -3623,7 +3686,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 			break;
 		}
-		case 127: {
+		case 129: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.In; 
 			break;
@@ -3633,11 +3696,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.NotIn; 
 			break;
 		}
-		case 122: {
+		case 124: {
 			Get();
 			x = t;  y = Token.NoToken; 
 			if (la.val == "!") {
-				Expect(122);
+				Expect(124);
 				y = t; 
 			}
 			if (y == Token.NoToken) {
@@ -3656,17 +3719,17 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			x = t;  op = BinaryExpr.Opcode.Neq; 
 			break;
 		}
-		case 110: {
+		case 112: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Le; 
 			break;
 		}
-		case 111: {
+		case 113: {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Ge; 
 			break;
 		}
-		default: SynErr(226); break;
+		default: SynErr(227); break;
 		}
 	}
 
@@ -3682,23 +3745,23 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void AddOp(out IToken x, out BinaryExpr.Opcode op) {
 		Contract.Ensures(Contract.ValueAtReturn(out x) != null); x = Token.NoToken;  op=BinaryExpr.Opcode.Add/*(dummy)*/; 
-		if (la.kind == 128) {
+		if (la.kind == 76) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Add; 
-		} else if (la.kind == 129) {
+		} else if (la.kind == 130) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Sub; 
-		} else SynErr(227);
+		} else SynErr(228);
 	}
 
 	void UnaryExpression(out Expression e, bool allowSemi, bool allowLambda) {
 		Contract.Ensures(Contract.ValueAtReturn(out e) != null); IToken/*!*/ x;  e = dummyExpr; 
-		if (la.kind == 129) {
+		if (la.kind == 130) {
 			Get();
 			x = t; 
 			UnaryExpression(out e, allowSemi, allowLambda);
 			e = new NegationExpression(x, e); 
-		} else if (la.kind == 122 || la.kind == 123) {
+		} else if (la.kind == 124 || la.kind == 125) {
 			NegOp();
 			x = t; 
 			UnaryExpression(out e, allowSemi, allowLambda);
@@ -3726,7 +3789,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			}
 		} else if (IsLambda(allowLambda)) {
 			LambdaExpression(out e, allowSemi);
-		} else if (StartOf(30)) {
+		} else if (StartOf(31)) {
 			EndlessExpression(out e, allowSemi, allowLambda);
 		} else if (la.kind == 1) {
 			NameSegment(out e);
@@ -3743,12 +3806,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			while (IsSuffix()) {
 				Suffix(ref e);
 			}
-		} else if (StartOf(28)) {
+		} else if (StartOf(29)) {
 			ConstAtomExpression(out e, allowSemi, allowLambda);
 			while (IsSuffix()) {
 				Suffix(ref e);
 			}
-		} else SynErr(228);
+		} else SynErr(229);
 	}
 
 	void MulOp(out IToken x, out BinaryExpr.Opcode op) {
@@ -3756,13 +3819,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 57) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Mul; 
-		} else if (la.kind == 130) {
+		} else if (la.kind == 131) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Div; 
-		} else if (la.kind == 131) {
+		} else if (la.kind == 132) {
 			Get();
 			x = t;  op = BinaryExpr.Opcode.Mod; 
-		} else SynErr(229);
+		} else SynErr(230);
 	}
 
 	void MapDisplayExpr(IToken/*!*/ mapToken, bool finite, out Expression e) {
@@ -3771,7 +3834,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;
 		
 		Expect(48);
-		if (StartOf(8)) {
+		if (StartOf(9)) {
 			MapLiteralExpressions(out elements);
 		}
 		e = new MapDisplayExpr(mapToken, finite, elements);
@@ -3801,7 +3864,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				}
 				Expect(51);
 				e = new DatatypeUpdateExpr(x, e, updates); 
-			} else if (StartOf(31)) {
+			} else if (StartOf(32)) {
 				DotSuffix(out id, out x);
 				if (x != null) {
 				 // process id as a Suffix in its own right
@@ -3813,30 +3876,30 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				if (IsGenericInstantiation()) {
 					typeArgs = new List<Type>(); 
 					GenericInstantiation(typeArgs);
-				} else if (la.kind == 107) {
+				} else if (la.kind == 109) {
 					HashCall(id, out openParen, out typeArgs, out args);
-				} else if (StartOf(32)) {
-				} else SynErr(230);
+				} else if (StartOf(33)) {
+				} else SynErr(231);
 				e = new ExprDotName(id, e, id.val, typeArgs);
 				if (openParen != null) {
 				 e = new ApplySuffix(openParen, e, args);
 				}
 				
-			} else SynErr(231);
+			} else SynErr(232);
 		} else if (la.kind == 48) {
 			Get();
 			x = t; 
-			if (StartOf(8)) {
+			if (StartOf(9)) {
 				Expression(out ee, true, true);
 				e0 = ee; 
-				if (la.kind == 138) {
+				if (la.kind == 139) {
 					Get();
 					anyDots = true; 
-					if (StartOf(8)) {
+					if (StartOf(9)) {
 						Expression(out ee, true, true);
 						e1 = ee; 
 					}
-				} else if (la.kind == 96) {
+				} else if (la.kind == 98) {
 					Get();
 					Expression(out ee, true, true);
 					e1 = ee; 
@@ -3846,7 +3909,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 					multipleLengths.Add(e0);  // account for the Expression read before the colon
 					takeRest = true;
 					
-					if (StartOf(8)) {
+					if (StartOf(9)) {
 						Expression(out ee, true, true);
 						multipleLengths.Add(ee); takeRest = false; 
 						while (IsNonFinalColon()) {
@@ -3870,15 +3933,15 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 						multipleIndices.Add(ee);
 						
 					}
-				} else SynErr(232);
-			} else if (la.kind == 138) {
+				} else SynErr(233);
+			} else if (la.kind == 139) {
 				Get();
 				anyDots = true; 
-				if (StartOf(8)) {
+				if (StartOf(9)) {
 					Expression(out ee, true, true);
 					e1 = ee; 
 				}
-			} else SynErr(233);
+			} else SynErr(234);
 			if (multipleIndices != null) {
 			 e = new MultiSelectExpr(x, e, multipleIndices);
 			 // make sure an array class with this dimensionality exists
@@ -3917,12 +3980,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 50) {
 			Get();
 			IToken openParen = t; var args = new List<Expression>(); 
-			if (StartOf(8)) {
+			if (StartOf(9)) {
 				Expressions(args);
 			}
 			Expect(51);
 			e = new ApplySuffix(openParen, e, args); 
-		} else SynErr(234);
+		} else SynErr(235);
 	}
 
 	void ISetDisplayExpr(IToken/*!*/ setToken, bool finite, out Expression e) {
@@ -3931,7 +3994,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;
 		
 		Expect(46);
-		if (StartOf(8)) {
+		if (StartOf(9)) {
 			Expressions(elements);
 		}
 		e = new SetDisplayExpr(setToken, finite, elements);
@@ -3964,7 +4027,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				}
 			}
 			Expect(51);
-		} else SynErr(235);
+		} else SynErr(236);
 		while (la.kind == 44 || la.kind == 45) {
 			if (la.kind == 44) {
 				Get();
@@ -3990,7 +4053,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;
 		
 		switch (la.kind) {
-		case 99: {
+		case 101: {
 			Get();
 			x = t; 
 			Expression(out e, true, true);
@@ -4001,11 +4064,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			e = new ITEExpr(x, e, e0, e1); 
 			break;
 		}
-		case 101: {
+		case 103: {
 			MatchExpression(out e, allowSemi, allowLambda);
 			break;
 		}
-		case 104: case 124: case 125: case 126: {
+		case 106: case 126: case 127: case 128: {
 			QuantifierGuts(out e, allowSemi, allowLambda);
 			break;
 		}
@@ -4021,13 +4084,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			SetComprehensionExpr(x, false, out e, allowSemi, allowLambda);
 			break;
 		}
-		case 31: case 32: case 102: {
+		case 31: case 32: case 104: {
 			StmtInExpr(out s);
 			Expression(out e, allowSemi, allowLambda);
 			e = new StmtExpr(s.Tok, s, e); 
 			break;
 		}
-		case 62: case 79: {
+		case 62: case 81: {
 			LetExpr(out e, allowSemi, allowLambda);
 			break;
 		}
@@ -4043,11 +4106,11 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			MapComprehensionExpr(x, false, out e, allowSemi, allowLambda);
 			break;
 		}
-		case 93: {
+		case 95: {
 			NamedExpr(out e, allowSemi, allowLambda);
 			break;
 		}
-		default: SynErr(236); break;
+		default: SynErr(237); break;
 		}
 	}
 
@@ -4059,10 +4122,10 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (IsGenericInstantiation()) {
 			typeArgs = new List<Type>(); 
 			GenericInstantiation(typeArgs);
-		} else if (la.kind == 107) {
+		} else if (la.kind == 109) {
 			HashCall(id, out openParen, out typeArgs, out args);
-		} else if (StartOf(32)) {
-		} else SynErr(237);
+		} else if (StartOf(33)) {
+		} else SynErr(238);
 		e = new NameSegment(id, id.val, typeArgs);
 		if (openParen != null) {
 		 e = new ApplySuffix(openParen, e, args);
@@ -4078,7 +4141,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 46) {
 			Get();
 			x = t;  elements = new List<Expression/*!*/>(); 
-			if (StartOf(8)) {
+			if (StartOf(9)) {
 				Expressions(elements);
 			}
 			e = new SetDisplayExpr(x, true, elements);
@@ -4086,12 +4149,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 48) {
 			Get();
 			x = t;  elements = new List<Expression/*!*/>(); 
-			if (StartOf(8)) {
+			if (StartOf(9)) {
 				Expressions(elements);
 			}
 			e = new SeqDisplayExpr(x, elements); 
 			Expect(49);
-		} else SynErr(238);
+		} else SynErr(239);
 	}
 
 	void MultiSetExpr(out Expression e) {
@@ -4104,7 +4167,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		if (la.kind == 46) {
 			Get();
 			elements = new List<Expression/*!*/>(); 
-			if (StartOf(8)) {
+			if (StartOf(9)) {
 				Expressions(elements);
 			}
 			e = new MultiSetDisplayExpr(x, elements);
@@ -4115,7 +4178,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Expression(out e, true, true);
 			e = new MultiSetFormingExpr(x, e); 
 			Expect(51);
-		} else SynErr(239);
+		} else SynErr(240);
 	}
 
 	void ConstAtomExpression(out Expression e, bool allowSemi, bool allowLambda) {
@@ -4124,17 +4187,17 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;  Type toType = null;
 		
 		switch (la.kind) {
-		case 132: {
+		case 133: {
 			Get();
 			e = new LiteralExpr(t, false); 
 			break;
 		}
-		case 133: {
+		case 134: {
 			Get();
 			e = new LiteralExpr(t, true); 
 			break;
 		}
-		case 134: {
+		case 135: {
 			Get();
 			e = new LiteralExpr(t); 
 			break;
@@ -4162,12 +4225,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			
 			break;
 		}
-		case 135: {
+		case 136: {
 			Get();
 			e = new ThisExpr(t); 
 			break;
 		}
-		case 136: {
+		case 137: {
 			Get();
 			x = t; 
 			Expect(50);
@@ -4176,7 +4239,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Fresh, e); 
 			break;
 		}
-		case 137: {
+		case 138: {
 			Get();
 			x = t; 
 			Expect(50);
@@ -4211,7 +4274,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			ParensExpression(out e, allowSemi, allowLambda);
 			break;
 		}
-		default: SynErr(240); break;
+		default: SynErr(241); break;
 		}
 	}
 
@@ -4240,7 +4303,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 n = BigInteger.Zero;
 			}
 			
-		} else SynErr(241);
+		} else SynErr(242);
 	}
 
 	void Dec(out Basetypes.BigDec d) {
@@ -4262,7 +4325,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		
 		Expect(50);
 		x = t; 
-		if (StartOf(8)) {
+		if (StartOf(9)) {
 			Expressions(args);
 		}
 		Expect(51);
@@ -4284,20 +4347,20 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 30) {
 			Get();
 			oneShot = true; 
-		} else SynErr(242);
+		} else SynErr(243);
 	}
 
 	void MapLiteralExpressions(out List<ExpressionPair> elements) {
 		Expression/*!*/ d, r;
 		elements = new List<ExpressionPair/*!*/>(); 
 		Expression(out d, true, true);
-		Expect(96);
+		Expect(98);
 		Expression(out r, true, true);
 		elements.Add(new ExpressionPair(d,r)); 
 		while (la.kind == 22) {
 			Get();
 			Expression(out d, true, true);
-			Expect(96);
+			Expect(98);
 			Expression(out r, true, true);
 			elements.Add(new ExpressionPair(d,r)); 
 		}
@@ -4331,7 +4394,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		List<MatchCaseExpr/*!*/> cases = new List<MatchCaseExpr/*!*/>();
 		bool usesOptionalBrace = false;
 		
-		Expect(101);
+		Expect(103);
 		x = t; 
 		Expression(out e, allowSemi, allowLambda);
 		if (la.kind == _lbrace) {
@@ -4342,12 +4405,12 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				cases.Add(c); 
 			}
 			Expect(47);
-		} else if (StartOf(33)) {
+		} else if (StartOf(34)) {
 			while (la.kind == _case) {
 				CaseExpression(out c, allowSemi, allowLambda);
 				cases.Add(c); 
 			}
-		} else SynErr(243);
+		} else SynErr(244);
 		e = new MatchExpr(x, e, cases, usesOptionalBrace); 
 	}
 
@@ -4359,13 +4422,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		Expression range;
 		Expression/*!*/ body;
 		
-		if (la.kind == 104 || la.kind == 124) {
+		if (la.kind == 106 || la.kind == 126) {
 			Forall();
 			x = t;  univ = true; 
-		} else if (la.kind == 125 || la.kind == 126) {
+		} else if (la.kind == 127 || la.kind == 128) {
 			Exists();
 			x = t; 
-		} else SynErr(244);
+		} else SynErr(245);
 		QuantifierDomain(out bvars, out attrs, out range);
 		QSep();
 		Expression(out body, allowSemi, allowLambda);
@@ -4408,13 +4471,13 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void StmtInExpr(out Statement s) {
 		s = dummyStmt; 
-		if (la.kind == 102) {
+		if (la.kind == 104) {
 			AssertStmt(out s);
 		} else if (la.kind == 31) {
 			AssumeStmt(out s);
 		} else if (la.kind == 32) {
 			CalcStmt(out s);
-		} else SynErr(245);
+		} else SynErr(246);
 	}
 
 	void LetExpr(out Expression e, bool allowSemi, bool allowLambda) {
@@ -4431,7 +4494,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			Get();
 			isGhost = true;  x = t; 
 		}
-		Expect(79);
+		Expect(81);
 		if (!isGhost) { x = t; } 
 		CasePattern(out pat);
 		if (isGhost) { pat.Vars.Iter(bv => bv.IsGhost = true); }
@@ -4444,7 +4507,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			letLHSs.Add(pat);
 			
 		}
-		if (la.kind == 96) {
+		if (la.kind == 98) {
 			Get();
 		} else if (la.kind == 25 || la.kind == 46) {
 			while (la.kind == 46) {
@@ -4458,7 +4521,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 			 }
 			}
 			
-		} else SynErr(246);
+		} else SynErr(247);
 		Expression(out e, false, true);
 		letRHSs.Add(e); 
 		while (la.kind == 22) {
@@ -4476,7 +4539,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		e = dummyExpr;
 		Expression expr;
 		
-		Expect(93);
+		Expect(95);
 		x = t; 
 		NoUSIdent(out d);
 		Expect(21);
@@ -4518,7 +4581,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 				arguments.Add(pat); 
 			}
 			Expect(51);
-		} else SynErr(247);
+		} else SynErr(248);
 		Expect(29);
 		Expression(out body, allowSemi, allowLambda);
 		c = new MatchCaseExpr(x, name, arguments, body); 
@@ -4526,7 +4589,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 
 	void HashCall(IToken id, out IToken openParen, out List<Type> typeArgs, out List<Expression> args) {
 		Expression k; args = new List<Expression>(); typeArgs = null; 
-		Expect(107);
+		Expect(109);
 		id.val = id.val + "#"; 
 		if (la.kind == 52) {
 			typeArgs = new List<Type>(); 
@@ -4538,7 +4601,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		args.Add(k); 
 		Expect(50);
 		openParen = t; 
-		if (StartOf(8)) {
+		if (StartOf(9)) {
 			Expressions(args);
 		}
 		Expect(51);
@@ -4552,8 +4615,8 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 2) {
 			Get();
 			id = t; 
-		} else SynErr(248);
-		Expect(96);
+		} else SynErr(249);
+		Expect(98);
 		Expression(out e, true, true);
 	}
 
@@ -4595,7 +4658,7 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 		} else if (la.kind == 44) {
 			Get();
 			x = t; 
-		} else SynErr(249);
+		} else SynErr(250);
 	}
 
 
@@ -4610,40 +4673,41 @@ List<Expression/*!*/>/*!*/ decreases, ref Attributes decAttrs, ref Attributes mo
 	}
 
 	static readonly bool[,] set = {
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_T, _T,_T,_x,_x, _T,_T,_x,_x, _T,_T,_x,_T, _T,_T,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _x,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_x, _x,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_T,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_T, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_x, _x,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _x,_x,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_x, _x,_T,_T,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_x,_x,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _x,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_T,_x,_x, _x},
-		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_T, _x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x},
-		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_x,_T, _T,_T,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x}
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_T, _T,_T,_x,_x, _T,_T,_x,_x, _T,_T,_x,_T, _T,_T,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _T,_x,_x,_T, _T,_T,_T,_T, _T,_T,_x,_T, _T,_x,_x,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_T,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_T, _x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_T,_T, _T,_T,_T,_x, _T,_T,_T,_T, _x,_x,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_T,_T,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_T, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_T, _T,_x,_x,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_T,_T,_T, _x,_T,_T,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _T,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_T,_T, _T,_x,_T,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_x,_x,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_T, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_x,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_x, _x,_x},
+		{_x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_T,_x, _x,_T,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_T, _x,_x,_x,_x, _x,_T,_x,_T, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_T,_T, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_x,_T,_T,_x, _T,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _T,_T,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x,_x,_x, _x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_T,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_T,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_x},
+		{_T,_T,_T,_T, _T,_x,_x,_x, _T,_x,_T,_x, _x,_x,_x,_x, _x,_x,_x,_T, _T,_T,_T,_T, _T,_x,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_T,_T,_T, _T,_T,_T,_x, _x,_T,_x,_x, _x,_T,_T,_x, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_T,_T, _x,_T,_T,_T, _T,_T,_T,_T, _T,_x,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _T,_x,_x,_x, _x,_T,_T,_T, _T,_T,_T,_T, _T,_T,_T,_T, _x,_x}
 
 	};
 } // end Parser
@@ -4745,182 +4809,183 @@ public class Errors {
 			case 71: s = "\"=\" expected"; break;
 			case 72: s = "\"as\" expected"; break;
 			case 73: s = "\"default\" expected"; break;
-			case 74: s = "\"class\" expected"; break;
+			case 74: s = "\"export\" expected"; break;
 			case 75: s = "\"extends\" expected"; break;
-			case 76: s = "\"trait\" expected"; break;
-			case 77: s = "\"datatype\" expected"; break;
-			case 78: s = "\"codatatype\" expected"; break;
-			case 79: s = "\"var\" expected"; break;
-			case 80: s = "\"newtype\" expected"; break;
-			case 81: s = "\"type\" expected"; break;
-			case 82: s = "\"iterator\" expected"; break;
-			case 83: s = "\"yields\" expected"; break;
-			case 84: s = "\"returns\" expected"; break;
-			case 85: s = "\"method\" expected"; break;
-			case 86: s = "\"colemma\" expected"; break;
-			case 87: s = "\"comethod\" expected"; break;
-			case 88: s = "\"constructor\" expected"; break;
-			case 89: s = "\"free\" expected"; break;
-			case 90: s = "\"ensures\" expected"; break;
-			case 91: s = "\"yield\" expected"; break;
-			case 92: s = "\"`\" expected"; break;
-			case 93: s = "\"label\" expected"; break;
-			case 94: s = "\"break\" expected"; break;
-			case 95: s = "\"where\" expected"; break;
-			case 96: s = "\":=\" expected"; break;
-			case 97: s = "\"return\" expected"; break;
-			case 98: s = "\"new\" expected"; break;
-			case 99: s = "\"if\" expected"; break;
-			case 100: s = "\"while\" expected"; break;
-			case 101: s = "\"match\" expected"; break;
-			case 102: s = "\"assert\" expected"; break;
-			case 103: s = "\"print\" expected"; break;
-			case 104: s = "\"forall\" expected"; break;
-			case 105: s = "\"parallel\" expected"; break;
-			case 106: s = "\"modify\" expected"; break;
-			case 107: s = "\"#\" expected"; break;
-			case 108: s = "\"<=\" expected"; break;
-			case 109: s = "\">=\" expected"; break;
-			case 110: s = "\"\\u2264\" expected"; break;
-			case 111: s = "\"\\u2265\" expected"; break;
-			case 112: s = "\"<==>\" expected"; break;
-			case 113: s = "\"\\u21d4\" expected"; break;
-			case 114: s = "\"==>\" expected"; break;
-			case 115: s = "\"\\u21d2\" expected"; break;
-			case 116: s = "\"<==\" expected"; break;
-			case 117: s = "\"\\u21d0\" expected"; break;
-			case 118: s = "\"&&\" expected"; break;
-			case 119: s = "\"\\u2227\" expected"; break;
-			case 120: s = "\"||\" expected"; break;
-			case 121: s = "\"\\u2228\" expected"; break;
-			case 122: s = "\"!\" expected"; break;
-			case 123: s = "\"\\u00ac\" expected"; break;
-			case 124: s = "\"\\u2200\" expected"; break;
-			case 125: s = "\"exists\" expected"; break;
-			case 126: s = "\"\\u2203\" expected"; break;
-			case 127: s = "\"in\" expected"; break;
-			case 128: s = "\"+\" expected"; break;
-			case 129: s = "\"-\" expected"; break;
-			case 130: s = "\"/\" expected"; break;
-			case 131: s = "\"%\" expected"; break;
-			case 132: s = "\"false\" expected"; break;
-			case 133: s = "\"true\" expected"; break;
-			case 134: s = "\"null\" expected"; break;
-			case 135: s = "\"this\" expected"; break;
-			case 136: s = "\"fresh\" expected"; break;
-			case 137: s = "\"old\" expected"; break;
-			case 138: s = "\"..\" expected"; break;
-			case 139: s = "??? expected"; break;
-			case 140: s = "invalid TopDecl"; break;
-			case 141: s = "invalid DeclModifier"; break;
-			case 142: s = "this symbol not expected in SubModuleDecl"; break;
-			case 143: s = "invalid SubModuleDecl"; break;
-			case 144: s = "this symbol not expected in ClassDecl"; break;
-			case 145: s = "this symbol not expected in DatatypeDecl"; break;
-			case 146: s = "invalid DatatypeDecl"; break;
-			case 147: s = "this symbol not expected in DatatypeDecl"; break;
-			case 148: s = "invalid NewtypeDecl"; break;
-			case 149: s = "invalid OtherTypeDecl"; break;
-			case 150: s = "this symbol not expected in OtherTypeDecl"; break;
-			case 151: s = "this symbol not expected in IteratorDecl"; break;
-			case 152: s = "invalid IteratorDecl"; break;
-			case 153: s = "this symbol not expected in TraitDecl"; break;
-			case 154: s = "invalid ClassMemberDecl"; break;
-			case 155: s = "this symbol not expected in FieldDecl"; break;
-			case 156: s = "invalid FunctionDecl"; break;
+			case 76: s = "\"+\" expected"; break;
+			case 77: s = "\"class\" expected"; break;
+			case 78: s = "\"trait\" expected"; break;
+			case 79: s = "\"datatype\" expected"; break;
+			case 80: s = "\"codatatype\" expected"; break;
+			case 81: s = "\"var\" expected"; break;
+			case 82: s = "\"newtype\" expected"; break;
+			case 83: s = "\"type\" expected"; break;
+			case 84: s = "\"iterator\" expected"; break;
+			case 85: s = "\"yields\" expected"; break;
+			case 86: s = "\"returns\" expected"; break;
+			case 87: s = "\"method\" expected"; break;
+			case 88: s = "\"colemma\" expected"; break;
+			case 89: s = "\"comethod\" expected"; break;
+			case 90: s = "\"constructor\" expected"; break;
+			case 91: s = "\"free\" expected"; break;
+			case 92: s = "\"ensures\" expected"; break;
+			case 93: s = "\"yield\" expected"; break;
+			case 94: s = "\"`\" expected"; break;
+			case 95: s = "\"label\" expected"; break;
+			case 96: s = "\"break\" expected"; break;
+			case 97: s = "\"where\" expected"; break;
+			case 98: s = "\":=\" expected"; break;
+			case 99: s = "\"return\" expected"; break;
+			case 100: s = "\"new\" expected"; break;
+			case 101: s = "\"if\" expected"; break;
+			case 102: s = "\"while\" expected"; break;
+			case 103: s = "\"match\" expected"; break;
+			case 104: s = "\"assert\" expected"; break;
+			case 105: s = "\"print\" expected"; break;
+			case 106: s = "\"forall\" expected"; break;
+			case 107: s = "\"parallel\" expected"; break;
+			case 108: s = "\"modify\" expected"; break;
+			case 109: s = "\"#\" expected"; break;
+			case 110: s = "\"<=\" expected"; break;
+			case 111: s = "\">=\" expected"; break;
+			case 112: s = "\"\\u2264\" expected"; break;
+			case 113: s = "\"\\u2265\" expected"; break;
+			case 114: s = "\"<==>\" expected"; break;
+			case 115: s = "\"\\u21d4\" expected"; break;
+			case 116: s = "\"==>\" expected"; break;
+			case 117: s = "\"\\u21d2\" expected"; break;
+			case 118: s = "\"<==\" expected"; break;
+			case 119: s = "\"\\u21d0\" expected"; break;
+			case 120: s = "\"&&\" expected"; break;
+			case 121: s = "\"\\u2227\" expected"; break;
+			case 122: s = "\"||\" expected"; break;
+			case 123: s = "\"\\u2228\" expected"; break;
+			case 124: s = "\"!\" expected"; break;
+			case 125: s = "\"\\u00ac\" expected"; break;
+			case 126: s = "\"\\u2200\" expected"; break;
+			case 127: s = "\"exists\" expected"; break;
+			case 128: s = "\"\\u2203\" expected"; break;
+			case 129: s = "\"in\" expected"; break;
+			case 130: s = "\"-\" expected"; break;
+			case 131: s = "\"/\" expected"; break;
+			case 132: s = "\"%\" expected"; break;
+			case 133: s = "\"false\" expected"; break;
+			case 134: s = "\"true\" expected"; break;
+			case 135: s = "\"null\" expected"; break;
+			case 136: s = "\"this\" expected"; break;
+			case 137: s = "\"fresh\" expected"; break;
+			case 138: s = "\"old\" expected"; break;
+			case 139: s = "\"..\" expected"; break;
+			case 140: s = "??? expected"; break;
+			case 141: s = "invalid TopDecl"; break;
+			case 142: s = "invalid DeclModifier"; break;
+			case 143: s = "this symbol not expected in SubModuleDecl"; break;
+			case 144: s = "invalid SubModuleDecl"; break;
+			case 145: s = "this symbol not expected in ClassDecl"; break;
+			case 146: s = "this symbol not expected in DatatypeDecl"; break;
+			case 147: s = "invalid DatatypeDecl"; break;
+			case 148: s = "this symbol not expected in DatatypeDecl"; break;
+			case 149: s = "invalid NewtypeDecl"; break;
+			case 150: s = "invalid OtherTypeDecl"; break;
+			case 151: s = "this symbol not expected in OtherTypeDecl"; break;
+			case 152: s = "this symbol not expected in IteratorDecl"; break;
+			case 153: s = "invalid IteratorDecl"; break;
+			case 154: s = "this symbol not expected in TraitDecl"; break;
+			case 155: s = "invalid ClassMemberDecl"; break;
+			case 156: s = "this symbol not expected in FieldDecl"; break;
 			case 157: s = "invalid FunctionDecl"; break;
 			case 158: s = "invalid FunctionDecl"; break;
 			case 159: s = "invalid FunctionDecl"; break;
 			case 160: s = "invalid FunctionDecl"; break;
-			case 161: s = "this symbol not expected in MethodDecl"; break;
-			case 162: s = "invalid MethodDecl"; break;
+			case 161: s = "invalid FunctionDecl"; break;
+			case 162: s = "this symbol not expected in MethodDecl"; break;
 			case 163: s = "invalid MethodDecl"; break;
-			case 164: s = "invalid FIdentType"; break;
-			case 165: s = "this symbol not expected in OldSemi"; break;
-			case 166: s = "invalid TypeIdentOptional"; break;
-			case 167: s = "invalid TypeAndToken"; break;
-			case 168: s = "this symbol not expected in IteratorSpec"; break;
-			case 169: s = "invalid IteratorSpec"; break;
+			case 164: s = "invalid MethodDecl"; break;
+			case 165: s = "invalid FIdentType"; break;
+			case 166: s = "this symbol not expected in OldSemi"; break;
+			case 167: s = "invalid TypeIdentOptional"; break;
+			case 168: s = "invalid TypeAndToken"; break;
+			case 169: s = "this symbol not expected in IteratorSpec"; break;
 			case 170: s = "invalid IteratorSpec"; break;
-			case 171: s = "this symbol not expected in MethodSpec"; break;
-			case 172: s = "invalid MethodSpec"; break;
+			case 171: s = "invalid IteratorSpec"; break;
+			case 172: s = "this symbol not expected in MethodSpec"; break;
 			case 173: s = "invalid MethodSpec"; break;
-			case 174: s = "invalid FrameExpression"; break;
-			case 175: s = "this symbol not expected in FunctionSpec"; break;
-			case 176: s = "invalid FunctionSpec"; break;
-			case 177: s = "invalid PossiblyWildFrameExpression"; break;
-			case 178: s = "invalid PossiblyWildExpression"; break;
-			case 179: s = "this symbol not expected in OneStmt"; break;
-			case 180: s = "invalid OneStmt"; break;
-			case 181: s = "this symbol not expected in OneStmt"; break;
-			case 182: s = "invalid OneStmt"; break;
-			case 183: s = "invalid AssertStmt"; break;
-			case 184: s = "invalid AssumeStmt"; break;
-			case 185: s = "invalid UpdateStmt"; break;
+			case 174: s = "invalid MethodSpec"; break;
+			case 175: s = "invalid FrameExpression"; break;
+			case 176: s = "this symbol not expected in FunctionSpec"; break;
+			case 177: s = "invalid FunctionSpec"; break;
+			case 178: s = "invalid PossiblyWildFrameExpression"; break;
+			case 179: s = "invalid PossiblyWildExpression"; break;
+			case 180: s = "this symbol not expected in OneStmt"; break;
+			case 181: s = "invalid OneStmt"; break;
+			case 182: s = "this symbol not expected in OneStmt"; break;
+			case 183: s = "invalid OneStmt"; break;
+			case 184: s = "invalid AssertStmt"; break;
+			case 185: s = "invalid AssumeStmt"; break;
 			case 186: s = "invalid UpdateStmt"; break;
-			case 187: s = "this symbol not expected in VarDeclStatement"; break;
-			case 188: s = "invalid VarDeclStatement"; break;
+			case 187: s = "invalid UpdateStmt"; break;
+			case 188: s = "this symbol not expected in VarDeclStatement"; break;
 			case 189: s = "invalid VarDeclStatement"; break;
-			case 190: s = "invalid IfStmt"; break;
+			case 190: s = "invalid VarDeclStatement"; break;
 			case 191: s = "invalid IfStmt"; break;
-			case 192: s = "invalid WhileStmt"; break;
+			case 192: s = "invalid IfStmt"; break;
 			case 193: s = "invalid WhileStmt"; break;
-			case 194: s = "invalid MatchStmt"; break;
-			case 195: s = "invalid ForallStmt"; break;
+			case 194: s = "invalid WhileStmt"; break;
+			case 195: s = "invalid MatchStmt"; break;
 			case 196: s = "invalid ForallStmt"; break;
-			case 197: s = "invalid CalcStmt"; break;
-			case 198: s = "invalid ModifyStmt"; break;
-			case 199: s = "this symbol not expected in ModifyStmt"; break;
-			case 200: s = "invalid ModifyStmt"; break;
-			case 201: s = "invalid ReturnStmt"; break;
-			case 202: s = "invalid Rhs"; break;
-			case 203: s = "invalid Lhs"; break;
-			case 204: s = "invalid CasePattern"; break;
-			case 205: s = "invalid AlternativeBlock"; break;
-			case 206: s = "invalid Guard"; break;
-			case 207: s = "this symbol not expected in LoopSpec"; break;
+			case 197: s = "invalid ForallStmt"; break;
+			case 198: s = "invalid CalcStmt"; break;
+			case 199: s = "invalid ModifyStmt"; break;
+			case 200: s = "this symbol not expected in ModifyStmt"; break;
+			case 201: s = "invalid ModifyStmt"; break;
+			case 202: s = "invalid ReturnStmt"; break;
+			case 203: s = "invalid Rhs"; break;
+			case 204: s = "invalid Lhs"; break;
+			case 205: s = "invalid CasePattern"; break;
+			case 206: s = "invalid AlternativeBlock"; break;
+			case 207: s = "invalid Guard"; break;
 			case 208: s = "this symbol not expected in LoopSpec"; break;
 			case 209: s = "this symbol not expected in LoopSpec"; break;
-			case 210: s = "invalid LoopSpec"; break;
-			case 211: s = "invalid CaseStatement"; break;
-			case 212: s = "this symbol not expected in CaseStatement"; break;
+			case 210: s = "this symbol not expected in LoopSpec"; break;
+			case 211: s = "invalid LoopSpec"; break;
+			case 212: s = "invalid CaseStatement"; break;
 			case 213: s = "this symbol not expected in CaseStatement"; break;
-			case 214: s = "invalid CalcOp"; break;
-			case 215: s = "invalid EquivOp"; break;
-			case 216: s = "invalid ImpliesOp"; break;
-			case 217: s = "invalid ExpliesOp"; break;
-			case 218: s = "invalid AndOp"; break;
-			case 219: s = "invalid OrOp"; break;
-			case 220: s = "invalid NegOp"; break;
-			case 221: s = "invalid Forall"; break;
-			case 222: s = "invalid Exists"; break;
-			case 223: s = "invalid QSep"; break;
-			case 224: s = "invalid ImpliesExpliesExpression"; break;
-			case 225: s = "invalid LogicalExpression"; break;
-			case 226: s = "invalid RelOp"; break;
-			case 227: s = "invalid AddOp"; break;
-			case 228: s = "invalid UnaryExpression"; break;
-			case 229: s = "invalid MulOp"; break;
-			case 230: s = "invalid Suffix"; break;
+			case 214: s = "this symbol not expected in CaseStatement"; break;
+			case 215: s = "invalid CalcOp"; break;
+			case 216: s = "invalid EquivOp"; break;
+			case 217: s = "invalid ImpliesOp"; break;
+			case 218: s = "invalid ExpliesOp"; break;
+			case 219: s = "invalid AndOp"; break;
+			case 220: s = "invalid OrOp"; break;
+			case 221: s = "invalid NegOp"; break;
+			case 222: s = "invalid Forall"; break;
+			case 223: s = "invalid Exists"; break;
+			case 224: s = "invalid QSep"; break;
+			case 225: s = "invalid ImpliesExpliesExpression"; break;
+			case 226: s = "invalid LogicalExpression"; break;
+			case 227: s = "invalid RelOp"; break;
+			case 228: s = "invalid AddOp"; break;
+			case 229: s = "invalid UnaryExpression"; break;
+			case 230: s = "invalid MulOp"; break;
 			case 231: s = "invalid Suffix"; break;
 			case 232: s = "invalid Suffix"; break;
 			case 233: s = "invalid Suffix"; break;
 			case 234: s = "invalid Suffix"; break;
-			case 235: s = "invalid LambdaExpression"; break;
-			case 236: s = "invalid EndlessExpression"; break;
-			case 237: s = "invalid NameSegment"; break;
-			case 238: s = "invalid DisplayExpr"; break;
-			case 239: s = "invalid MultiSetExpr"; break;
-			case 240: s = "invalid ConstAtomExpression"; break;
-			case 241: s = "invalid Nat"; break;
-			case 242: s = "invalid LambdaArrow"; break;
-			case 243: s = "invalid MatchExpression"; break;
-			case 244: s = "invalid QuantifierGuts"; break;
-			case 245: s = "invalid StmtInExpr"; break;
-			case 246: s = "invalid LetExpr"; break;
-			case 247: s = "invalid CaseExpression"; break;
-			case 248: s = "invalid MemberBindingUpdate"; break;
-			case 249: s = "invalid DotSuffix"; break;
+			case 235: s = "invalid Suffix"; break;
+			case 236: s = "invalid LambdaExpression"; break;
+			case 237: s = "invalid EndlessExpression"; break;
+			case 238: s = "invalid NameSegment"; break;
+			case 239: s = "invalid DisplayExpr"; break;
+			case 240: s = "invalid MultiSetExpr"; break;
+			case 241: s = "invalid ConstAtomExpression"; break;
+			case 242: s = "invalid Nat"; break;
+			case 243: s = "invalid LambdaArrow"; break;
+			case 244: s = "invalid MatchExpression"; break;
+			case 245: s = "invalid QuantifierGuts"; break;
+			case 246: s = "invalid StmtInExpr"; break;
+			case 247: s = "invalid LetExpr"; break;
+			case 248: s = "invalid CaseExpression"; break;
+			case 249: s = "invalid MemberBindingUpdate"; break;
+			case 250: s = "invalid DotSuffix"; break;
 
 			default: s = "error " + n; break;
 		}
diff --git a/Source/Dafny/Resolver.cs b/Source/Dafny/Resolver.cs
index eb82df72..bddf62e2 100644
--- a/Source/Dafny/Resolver.cs
+++ b/Source/Dafny/Resolver.cs
@@ -324,6 +324,7 @@ namespace Microsoft.Dafny
           // set up environment
           var preResolveErrorCount = reporter.Count(ErrorLevel.Error);
           ResolveModuleDefinition(m, sig);
+          ResolveModuleExport(literalDecl, sig);
           foreach (var r in rewriters) {
             if (reporter.Count(ErrorLevel.Error) != preResolveErrorCount) {
               break;
@@ -368,7 +369,7 @@ namespace Microsoft.Dafny
                   if (refinementTransformer.CheckIsRefinement(compileSig, p)) {
                     abs.Signature.CompileSignature = compileSig;
                   } else {
-                    reporter.Error(MessageSource.Resolver, 
+                    reporter.Error(MessageSource.Resolver,
                       abs.CompilePath[0],
                       "module " + Util.Comma(".", abs.CompilePath, x => x.val) + " must be a refinement of "
                       + Util.Comma(".", abs.Path, x => x.val));
@@ -383,6 +384,11 @@ namespace Microsoft.Dafny
           } else {
             abs.Signature = new ModuleSignature(); // there was an error, give it a valid but empty signature
           }
+        } else if (decl is ModuleExportDecl) {
+          ModuleExportDecl export = (ModuleExportDecl)decl;
+          export.Signature = new ModuleSignature();
+          export.Signature.IsAbstract = false;
+          export.Signature.ModuleDef = null;
         } else { Contract.Assert(false); }
         Contract.Assert(decl.Signature != null);
       }
@@ -720,6 +726,96 @@ namespace Microsoft.Dafny
       }
     }
 
+    // Resolve the exports and detect cycles.
+    private void ResolveModuleExport(LiteralModuleDecl literalDecl, ModuleSignature sig) {
+      ModuleDefinition m = literalDecl.ModuleDef;
+      literalDecl.DefaultExport = sig;
+      Graph<ModuleExportDecl> exportDependencies = new Graph<ModuleExportDecl>();
+      foreach (TopLevelDecl toplevel in m.TopLevelDecls) {
+        if (toplevel is ModuleExportDecl) {
+          ModuleExportDecl d = (ModuleExportDecl) toplevel;
+          exportDependencies.AddVertex(d);
+          foreach (string s in d.Extends) {
+            TopLevelDecl top;
+            if (sig.TopLevels.TryGetValue(s, out top) && top is ModuleExportDecl) {
+              ModuleExportDecl extend = (ModuleExportDecl) top;
+              d.ExtendDecls.Add(extend);
+              exportDependencies.AddEdge(d, extend);
+            } else {
+              reporter.Error(MessageSource.Resolver, m.tok, s + " must be an export of" + m + " to be extended");
+            }
+          }
+          foreach (ExportSignature export in d.Exports) {
+            // check to see if it is a datatype or a member or
+            // static function or method in the enclosing module or its imports
+            TopLevelDecl decl;
+            MemberDecl member;
+            string name = export.Name;
+            if (sig.TopLevels.TryGetValue(name, out decl)) {
+              // Member of the enclosing module
+              export.Decl = decl;
+            } else if (sig.StaticMembers.TryGetValue(name, out member)) {
+              export.Decl = member;
+            } else {
+              reporter.Error(MessageSource.Resolver, d.tok, name + " must be a member of " + m + " to be exported");
+            }
+          }
+        }
+      }
+
+      // detect cycles in the extend
+      var cycle = exportDependencies.TryFindCycle();
+      if (cycle != null) {
+        var cy = Util.Comma(" -> ", cycle, c => c.Name);
+        reporter.Error(MessageSource.Resolver, cycle[0], "module export contains a cycle: {0}", cy);
+        return;
+      }
+
+      // fill in the exports for the extends.
+      List<ModuleExportDecl> sortedDecls = exportDependencies.TopologicallySortedComponents();
+      ModuleExportDecl defaultExport = null;
+      foreach (ModuleExportDecl decl in sortedDecls) {
+        if (decl.IsDefault) {
+          if (defaultExport == null) {
+            defaultExport = decl;
+          } else {
+            reporter.Error(MessageSource.Resolver, m.tok, "more than one default export declared: {0}, {1}", defaultExport, decl);
+          }
+        }
+        // fill in export signature
+        ModuleSignature signature = decl.Signature;
+        foreach (ModuleExportDecl extend in decl.ExtendDecls) {
+          ModuleSignature s = extend.Signature;
+          foreach (var kv in s.TopLevels) {
+            if (!signature.TopLevels.ContainsKey(kv.Key)) {
+              signature.TopLevels.Add(kv.Key, kv.Value);
+            }
+          }
+          foreach (var kv in s.Ctors) {
+            if (!signature.Ctors.ContainsKey(kv.Key)) {
+              signature.Ctors.Add(kv.Key, kv.Value);
+            }
+          }
+          foreach (var kv in s.StaticMembers) {
+            if (!signature.StaticMembers.ContainsKey(kv.Key)) {
+              signature.StaticMembers.Add(kv.Key, kv.Value);
+            }
+          }
+        }
+        foreach (ExportSignature export in decl.Exports) {
+          if (export.Decl is TopLevelDecl) {
+            signature.TopLevels.Add(export.Name, (TopLevelDecl)export.Decl);
+          } else if (export.Decl is MemberDecl) {
+            signature.StaticMembers.Add(export.Name, (MemberDecl)export.Decl);
+          }
+        }
+      }
+
+      // set the default export if it exists, otherwise, default is export everything     
+      if (defaultExport != null) {
+        literalDecl.DefaultExport = defaultExport.Signature;
+      }
+    }
 
     public class ModuleBindings
     {
@@ -1326,6 +1422,13 @@ namespace Microsoft.Dafny
 
 
     public static bool ResolvePath(ModuleDecl root, List<IToken> Path, out ModuleSignature p, ErrorReporter reporter) {
+      if (Path.Count == 1 && root is LiteralModuleDecl) {
+        // use the default export when the importing the root
+        LiteralModuleDecl decl = (LiteralModuleDecl)root;
+        p = decl.DefaultExport;
+        return true;
+      }
+
       p = root.Signature;
       int i = 1;
       while (i < Path.Count) {
@@ -1590,6 +1693,7 @@ namespace Microsoft.Dafny
         }
       }
 
+
       // ---------------------------------- Pass 2 ----------------------------------
       // This pass fills in various additional information.
       // ----------------------------------------------------------------------------
diff --git a/Source/Dafny/Scanner.cs b/Source/Dafny/Scanner.cs
index 784f9cd5..cb3dbe7e 100644
--- a/Source/Dafny/Scanner.cs
+++ b/Source/Dafny/Scanner.cs
@@ -211,8 +211,8 @@ public class UTF8Buffer: Buffer {
 public class Scanner {
 	const char EOL = '\n';
 	const int eofSym = 0; /* pdt */
-	const int maxT = 139;
-	const int noSym = 139;
+	const int maxT = 140;
+	const int noSym = 140;
 
 
 	[ContractInvariantMethod]
@@ -292,20 +292,20 @@ public class Scanner {
 		start[33] = 96; 
 		start[8800] = 43; 
 		start[42] = 44; 
-		start[96] = 67; 
-		start[35] = 69; 
-		start[8804] = 71; 
-		start[8805] = 72; 
-		start[8660] = 74; 
-		start[8658] = 76; 
-		start[8656] = 77; 
-		start[38] = 78; 
-		start[8743] = 80; 
-		start[8744] = 82; 
-		start[172] = 83; 
-		start[8704] = 84; 
-		start[8707] = 85; 
-		start[43] = 86; 
+		start[43] = 67; 
+		start[96] = 68; 
+		start[35] = 70; 
+		start[8804] = 72; 
+		start[8805] = 73; 
+		start[8660] = 75; 
+		start[8658] = 77; 
+		start[8656] = 78; 
+		start[38] = 79; 
+		start[8743] = 81; 
+		start[8744] = 83; 
+		start[172] = 84; 
+		start[8704] = 85; 
+		start[8707] = 86; 
 		start[47] = 87; 
 		start[37] = 88; 
 		start[Buffer.EOF] = -1;
@@ -552,45 +552,46 @@ public class Scanner {
 			case "opened": t.kind = 70; break;
 			case "as": t.kind = 72; break;
 			case "default": t.kind = 73; break;
-			case "class": t.kind = 74; break;
+			case "export": t.kind = 74; break;
 			case "extends": t.kind = 75; break;
-			case "trait": t.kind = 76; break;
-			case "datatype": t.kind = 77; break;
-			case "codatatype": t.kind = 78; break;
-			case "var": t.kind = 79; break;
-			case "newtype": t.kind = 80; break;
-			case "type": t.kind = 81; break;
-			case "iterator": t.kind = 82; break;
-			case "yields": t.kind = 83; break;
-			case "returns": t.kind = 84; break;
-			case "method": t.kind = 85; break;
-			case "colemma": t.kind = 86; break;
-			case "comethod": t.kind = 87; break;
-			case "constructor": t.kind = 88; break;
-			case "free": t.kind = 89; break;
-			case "ensures": t.kind = 90; break;
-			case "yield": t.kind = 91; break;
-			case "label": t.kind = 93; break;
-			case "break": t.kind = 94; break;
-			case "where": t.kind = 95; break;
-			case "return": t.kind = 97; break;
-			case "new": t.kind = 98; break;
-			case "if": t.kind = 99; break;
-			case "while": t.kind = 100; break;
-			case "match": t.kind = 101; break;
-			case "assert": t.kind = 102; break;
-			case "print": t.kind = 103; break;
-			case "forall": t.kind = 104; break;
-			case "parallel": t.kind = 105; break;
-			case "modify": t.kind = 106; break;
-			case "exists": t.kind = 125; break;
-			case "in": t.kind = 127; break;
-			case "false": t.kind = 132; break;
-			case "true": t.kind = 133; break;
-			case "null": t.kind = 134; break;
-			case "this": t.kind = 135; break;
-			case "fresh": t.kind = 136; break;
-			case "old": t.kind = 137; break;
+			case "class": t.kind = 77; break;
+			case "trait": t.kind = 78; break;
+			case "datatype": t.kind = 79; break;
+			case "codatatype": t.kind = 80; break;
+			case "var": t.kind = 81; break;
+			case "newtype": t.kind = 82; break;
+			case "type": t.kind = 83; break;
+			case "iterator": t.kind = 84; break;
+			case "yields": t.kind = 85; break;
+			case "returns": t.kind = 86; break;
+			case "method": t.kind = 87; break;
+			case "colemma": t.kind = 88; break;
+			case "comethod": t.kind = 89; break;
+			case "constructor": t.kind = 90; break;
+			case "free": t.kind = 91; break;
+			case "ensures": t.kind = 92; break;
+			case "yield": t.kind = 93; break;
+			case "label": t.kind = 95; break;
+			case "break": t.kind = 96; break;
+			case "where": t.kind = 97; break;
+			case "return": t.kind = 99; break;
+			case "new": t.kind = 100; break;
+			case "if": t.kind = 101; break;
+			case "while": t.kind = 102; break;
+			case "match": t.kind = 103; break;
+			case "assert": t.kind = 104; break;
+			case "print": t.kind = 105; break;
+			case "forall": t.kind = 106; break;
+			case "parallel": t.kind = 107; break;
+			case "modify": t.kind = 108; break;
+			case "exists": t.kind = 127; break;
+			case "in": t.kind = 129; break;
+			case "false": t.kind = 133; break;
+			case "true": t.kind = 134; break;
+			case "null": t.kind = 135; break;
+			case "this": t.kind = 136; break;
+			case "fresh": t.kind = 137; break;
+			case "old": t.kind = 138; break;
 			default: break;
 		}
 	}
@@ -853,59 +854,59 @@ public class Scanner {
 				else if (ch >= '0' && ch <= '9') {AddCh(); goto case 66;}
 				else {t.kind = 5; break;}
 			case 67:
-				{t.kind = 92; break;}
+				{t.kind = 76; break;}
 			case 68:
-				{t.kind = 96; break;}
+				{t.kind = 94; break;}
 			case 69:
-				{t.kind = 107; break;}
+				{t.kind = 98; break;}
 			case 70:
 				{t.kind = 109; break;}
 			case 71:
-				{t.kind = 110; break;}
-			case 72:
 				{t.kind = 111; break;}
-			case 73:
+			case 72:
 				{t.kind = 112; break;}
-			case 74:
+			case 73:
 				{t.kind = 113; break;}
-			case 75:
+			case 74:
 				{t.kind = 114; break;}
-			case 76:
+			case 75:
 				{t.kind = 115; break;}
+			case 76:
+				{t.kind = 116; break;}
 			case 77:
 				{t.kind = 117; break;}
 			case 78:
-				if (ch == '&') {AddCh(); goto case 79;}
-				else {goto case 0;}
+				{t.kind = 119; break;}
 			case 79:
-				{t.kind = 118; break;}
+				if (ch == '&') {AddCh(); goto case 80;}
+				else {goto case 0;}
 			case 80:
-				{t.kind = 119; break;}
-			case 81:
 				{t.kind = 120; break;}
-			case 82:
+			case 81:
 				{t.kind = 121; break;}
+			case 82:
+				{t.kind = 122; break;}
 			case 83:
 				{t.kind = 123; break;}
 			case 84:
-				{t.kind = 124; break;}
+				{t.kind = 125; break;}
 			case 85:
 				{t.kind = 126; break;}
 			case 86:
 				{t.kind = 128; break;}
 			case 87:
-				{t.kind = 130; break;}
-			case 88:
 				{t.kind = 131; break;}
+			case 88:
+				{t.kind = 132; break;}
 			case 89:
 				recEnd = pos; recKind = 21;
 				if (ch == ':') {AddCh(); goto case 30;}
 				else if (ch == '|') {AddCh(); goto case 31;}
-				else if (ch == '=') {AddCh(); goto case 68;}
+				else if (ch == '=') {AddCh(); goto case 69;}
 				else {t.kind = 21; break;}
 			case 90:
 				recEnd = pos; recKind = 23;
-				if (ch == '|') {AddCh(); goto case 81;}
+				if (ch == '|') {AddCh(); goto case 82;}
 				else {t.kind = 23; break;}
 			case 91:
 				recEnd = pos; recKind = 27;
@@ -917,38 +918,38 @@ public class Scanner {
 				else if (ch == '=') {AddCh(); goto case 98;}
 				else {t.kind = 71; break;}
 			case 93:
-				recEnd = pos; recKind = 129;
+				recEnd = pos; recKind = 130;
 				if (ch == '>') {AddCh(); goto case 35;}
-				else {t.kind = 129; break;}
+				else {t.kind = 130; break;}
 			case 94:
 				recEnd = pos; recKind = 52;
 				if (ch == '=') {AddCh(); goto case 99;}
 				else {t.kind = 52; break;}
 			case 95:
 				recEnd = pos; recKind = 53;
-				if (ch == '=') {AddCh(); goto case 70;}
+				if (ch == '=') {AddCh(); goto case 71;}
 				else {t.kind = 53; break;}
 			case 96:
-				recEnd = pos; recKind = 122;
+				recEnd = pos; recKind = 124;
 				if (ch == '=') {AddCh(); goto case 42;}
 				else if (ch == 'i') {AddCh(); goto case 45;}
-				else {t.kind = 122; break;}
+				else {t.kind = 124; break;}
 			case 97:
-				recEnd = pos; recKind = 138;
+				recEnd = pos; recKind = 139;
 				if (ch == '.') {AddCh(); goto case 48;}
-				else {t.kind = 138; break;}
+				else {t.kind = 139; break;}
 			case 98:
 				recEnd = pos; recKind = 54;
-				if (ch == '>') {AddCh(); goto case 75;}
+				if (ch == '>') {AddCh(); goto case 76;}
 				else {t.kind = 54; break;}
 			case 99:
-				recEnd = pos; recKind = 108;
+				recEnd = pos; recKind = 110;
 				if (ch == '=') {AddCh(); goto case 100;}
-				else {t.kind = 108; break;}
+				else {t.kind = 110; break;}
 			case 100:
-				recEnd = pos; recKind = 116;
-				if (ch == '>') {AddCh(); goto case 73;}
-				else {t.kind = 116; break;}
+				recEnd = pos; recKind = 118;
+				if (ch == '>') {AddCh(); goto case 74;}
+				else {t.kind = 118; break;}
 
 		}
 		t.val = new String(tval, 0, tlen);
diff --git a/Test/dafny0/ModuleExport.dfy b/Test/dafny0/ModuleExport.dfy
new file mode 100644
index 00000000..81fe0ed5
--- /dev/null
+++ b/Test/dafny0/ModuleExport.dfy
@@ -0,0 +1,68 @@
+// RUN: %dafny /compile:0 "%s" > "%t"
+// RUN: %diff "%s.expect" "%t"
+
+module A {
+	default export Public { f, h}
+	export E1 { f, g}
+	export E2 extends Public, E1 {T}
+  export Friend extends Public {g, T}
+	export Fruit {Data}
+
+  method h() {}
+  function f(): int { 818 }
+  function g() : int { 819 }
+	function k() : int { 820 }
+  
+	class T 
+	{
+	  static method l() {}
+	}
+
+	datatype Data = Lemon | Kiwi(int)
+
+}
+
+module B {
+  import X = A.Public
+	method m() {
+	  X.h();  // OK
+	  assert X.f() == 818; // OK
+		assert X.g() == 819; // error
+		assert X.k() == 820; // error
+		X.T.l(); // error
+	}
+}
+
+module C {
+  import X = A.Friend
+	method m() {
+	  X.h();  // OK
+	  assert X.f() == 818; // OK
+		assert X.g() == 819; // OK
+		assert X.k() == 820; // error
+		X.T.l(); // OK
+	}
+}
+
+module D {
+  import opened A
+	method m() {
+	  h();  // OK
+	  assert f() == 818; // OK
+		assert g() == 819; // error
+		assert k() == 820; // error
+	 }
+}
+
+module E {
+  import opened A.Fruit
+
+  function G(d: Data): int
+    requires d != Data.Lemon
+  {
+    match d
+    case Lemon => G(d)
+    case Kiwi(x) => 7
+		case Orang => 8  // error
+  } 
+}
\ No newline at end of file
diff --git a/Test/dafny0/ModuleExport.dfy.expect b/Test/dafny0/ModuleExport.dfy.expect
new file mode 100644
index 00000000..c7444bdb
--- /dev/null
+++ b/Test/dafny0/ModuleExport.dfy.expect
@@ -0,0 +1,9 @@
+ModuleExport.dfy(30,11): Error: unresolved identifier: g
+ModuleExport.dfy(31,11): Error: unresolved identifier: k
+ModuleExport.dfy(32,4): Error: unresolved identifier: T
+ModuleExport.dfy(32,7): Error: expected method call, found expression
+ModuleExport.dfy(42,11): Error: unresolved identifier: k
+ModuleExport.dfy(52,9): Error: unresolved identifier: g
+ModuleExport.dfy(53,9): Error: unresolved identifier: k
+ModuleExport.dfy(66,2): Error: member Orang does not exist in datatype Data
+8 resolution/type errors detected in ModuleExport.dfy
-- 
cgit v1.2.3