--- trunk/src/mdParser/MDTreeParser.cpp	2005/12/02 15:38:03	770
+++ trunk/src/mdParser/MDTreeParser.cpp	2009/09/07 16:31:51	1360
@@ -1,4 +1,4 @@
-/* $ANTLR 2.7.5 (20050406): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
+/* $ANTLR 2.7.7 (20090623): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
 #include "MDTreeParser.hpp"
 #include <antlr/Token.hpp>
 #include <antlr/AST.hpp>
@@ -13,7 +13,7 @@ void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)Re
 }
 
 void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	
 	try {      // for error handling
 		{ // ( ... )*
@@ -44,7 +44,7 @@ void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
 }
 
 void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	
 	try {      // for error handling
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -74,6 +74,12 @@ void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
 			_t = _retTree;
 			break;
 		}
+		case RESTRAINT:
+		{
+			restraintblock(_t);
+			_t = _retTree;
+			break;
+		}
 		default:
 		{
 			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
@@ -89,7 +95,7 @@ void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antl
 }
 
 void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
 	
 	try {      // for error handling
@@ -114,16 +120,16 @@ void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
 }
 
 void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	
 	try {      // for error handling
-		ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
 		ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
 		match(_t,COMPONENT);
 		_t = _t->getFirstChild();
-#line 69 "MDTreeParser.g"
+#line 63 "MDTreeParser.g"
 		Component* currComponet = new Component(); blockStack.push(currComponet);
-#line 127 "MDTreeParser.cpp"
+#line 133 "MDTreeParser.cpp"
 		{ // ( ... )*
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -133,20 +139,20 @@ void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
 				_t = _retTree;
 			}
 			else {
-				goto _loop15;
+				goto _loop11;
 			}
 			
 		}
-		_loop15:;
+		_loop11:;
 		} // ( ... )*
 		ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
 		match(_t,ENDBLOCK);
 		_t = _t->getNextSibling();
-		_t = __t13;
+		_t = __t9;
 		_t = _t->getNextSibling();
-#line 71 "MDTreeParser.g"
+#line 65 "MDTreeParser.g"
 		blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
-#line 150 "MDTreeParser.cpp"
+#line 156 "MDTreeParser.cpp"
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
 		reportError(ex);
@@ -157,16 +163,16 @@ void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
 }
 
 void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	
 	try {      // for error handling
 		ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t;
 		ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
 		match(_t,MOLECULE);
 		_t = _t->getFirstChild();
-#line 79 "MDTreeParser.g"
+#line 78 "MDTreeParser.g"
 		MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
-#line 170 "MDTreeParser.cpp"
+#line 176 "MDTreeParser.cpp"
 		{ // ( ... )*
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -187,9 +193,9 @@ void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
 		_t = _t->getNextSibling();
 		_t = __t21;
 		_t = _t->getNextSibling();
-#line 81 "MDTreeParser.g"
+#line 80 "MDTreeParser.g"
 		blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
-#line 193 "MDTreeParser.cpp"
+#line 199 "MDTreeParser.cpp"
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
 		reportError(ex);
@@ -200,16 +206,16 @@ void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
 }
 
 void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	
 	try {      // for error handling
-		ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
 		ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
 		match(_t,ZCONSTRAINT);
 		_t = _t->getFirstChild();
-#line 74 "MDTreeParser.g"
+#line 68 "MDTreeParser.g"
 		ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
-#line 213 "MDTreeParser.cpp"
+#line 219 "MDTreeParser.cpp"
 		{ // ( ... )*
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -219,20 +225,63 @@ void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
 				_t = _retTree;
 			}
 			else {
+				goto _loop15;
+			}
+			
+		}
+		_loop15:;
+		} // ( ... )*
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
+		match(_t,ENDBLOCK);
+		_t = _t->getNextSibling();
+		_t = __t13;
+		_t = _t->getNextSibling();
+#line 70 "MDTreeParser.g"
+		blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
+#line 242 "MDTreeParser.cpp"
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+	ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	
+	try {      // for error handling
+		ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
+		match(_t,RESTRAINT);
+		_t = _t->getFirstChild();
+#line 73 "MDTreeParser.g"
+		RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
+#line 262 "MDTreeParser.cpp"
+		{ // ( ... )*
+		for (;;) {
+			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+				_t = ASTNULL;
+			if ((_t->getType() == ASSIGNEQUAL)) {
+				assignment(_t);
+				_t = _retTree;
+			}
+			else {
 				goto _loop19;
 			}
 			
 		}
 		_loop19:;
 		} // ( ... )*
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
 		match(_t,ENDBLOCK);
 		_t = _t->getNextSibling();
 		_t = __t17;
 		_t = _t->getNextSibling();
-#line 76 "MDTreeParser.g"
-		blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
-#line 236 "MDTreeParser.cpp"
+#line 75 "MDTreeParser.g"
+		blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
+#line 285 "MDTreeParser.cpp"
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
 		reportError(ex);
@@ -245,33 +294,48 @@ void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
 void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
 	ANTLR_USE_NAMESPACE(antlr)RefAST id
 ) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
 	ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
+#line 48 "MDTreeParser.g"
 	
+	int ival;
+	RealType dval;
+	
+#line 306 "MDTreeParser.cpp"
+	
 	try {      // for error handling
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
 			_t = ASTNULL;
 		switch ( _t->getType()) {
-		case OCTALINT:
-		case DECIMALINT:
-		case HEXADECIMALINT:
-		case MINUS:
-		case FLOATONE:
-		case FLOATTWO:
-		{
-			signedIntOrFloat(_t,id);
+		case NUM_INT:
+		case NUM_LONG:
+		{
+			ival=intConst(_t);
 			_t = _retTree;
+#line 53 "MDTreeParser.g"
+			blockStack.top()->assign(id->getText(), ival);
+#line 319 "MDTreeParser.cpp"
 			break;
 		}
+		case NUM_FLOAT:
+		case NUM_DOUBLE:
+		{
+			dval=floatConst(_t);
+			_t = _retTree;
+#line 54 "MDTreeParser.g"
+			blockStack.top()->assign(id->getText(), dval);
+#line 329 "MDTreeParser.cpp"
+			break;
+		}
 		case ID:
 		{
 			str1 = _t;
 			match(_t,ID);
 			_t = _t->getNextSibling();
-#line 49 "MDTreeParser.g"
+#line 55 "MDTreeParser.g"
 			blockStack.top()->assign(id->getText(), str1->getText());
-#line 275 "MDTreeParser.cpp"
+#line 339 "MDTreeParser.cpp"
 			break;
 		}
 		case StringLiteral:
@@ -279,12 +343,12 @@ void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
 			str2 = _t;
 			match(_t,StringLiteral);
 			_t = _t->getNextSibling();
-#line 50 "MDTreeParser.g"
+#line 56 "MDTreeParser.g"
 			std::string s =  str2->getText();
 			s = s.substr(1, s.length()-2);
 			blockStack.top()->assign(id->getText(),s);
 			
-#line 288 "MDTreeParser.cpp"
+#line 352 "MDTreeParser.cpp"
 			break;
 		}
 		default:
@@ -301,166 +365,38 @@ void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
 	_retTree = _t;
 }
 
-void MDTreeParser::signedIntOrFloat(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
-	ANTLR_USE_NAMESPACE(antlr)RefAST id
-) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST signedIntOrFloat_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-	ANTLR_USE_NAMESPACE(antlr)RefAST icMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
-	ANTLR_USE_NAMESPACE(antlr)RefAST fcMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
-	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
-	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
-#line 56 "MDTreeParser.g"
-	
+int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+#line 268 "MDTreeParser.g"
 	int ival;
-	double dval;
+#line 372 "MDTreeParser.cpp"
+	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
+	ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
 	
-#line 318 "MDTreeParser.cpp"
-	
 	try {      // for error handling
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
 			_t = ASTNULL;
 		switch ( _t->getType()) {
-		case MINUS:
+		case NUM_INT:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
-			match(_t,MINUS);
-			_t = _t->getFirstChild();
-			{
-			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
-				_t = ASTNULL;
-			switch ( _t->getType()) {
-			case OCTALINT:
-			case DECIMALINT:
-			case HEXADECIMALINT:
-			{
-				icMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-				intConst(_t);
-				_t = _retTree;
-#line 61 "MDTreeParser.g"
-				ival = lexi_cast<int>(icMinus->getText()); ival = -ival; blockStack.top()->assign(id->getText(), ival);
-#line 343 "MDTreeParser.cpp"
-				break;
-			}
-			case FLOATONE:
-			case FLOATTWO:
-			{
-				fcMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-				floatConst(_t);
-				_t = _retTree;
-				break;
-			}
-			default:
-			{
-				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
-			}
-			}
-			}
-#line 62 "MDTreeParser.g"
-			dval = lexi_cast<double>(fcMinus->getText());dval = -dval;  blockStack.top()->assign(id->getText(), dval);
-#line 362 "MDTreeParser.cpp"
-			_t = __t9;
+			i1 = _t;
+			match(_t,NUM_INT);
 			_t = _t->getNextSibling();
+#line 269 "MDTreeParser.g"
+			ival = lexi_cast<int>(i1->getText());
+#line 388 "MDTreeParser.cpp"
 			break;
 		}
-		case OCTALINT:
-		case DECIMALINT:
-		case HEXADECIMALINT:
-		case FLOATONE:
-		case FLOATTWO:
+		case NUM_LONG:
 		{
-			{
-			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
-				_t = ASTNULL;
-			switch ( _t->getType()) {
-			case OCTALINT:
-			case DECIMALINT:
-			case HEXADECIMALINT:
-			{
-				ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-				intConst(_t);
-				_t = _retTree;
-#line 64 "MDTreeParser.g"
-				ival = lexi_cast<int>(ic->getText()); blockStack.top()->assign(id->getText(), ival);
-#line 386 "MDTreeParser.cpp"
-				break;
-			}
-			case FLOATONE:
-			case FLOATTWO:
-			{
-				fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-				floatConst(_t);
-				_t = _retTree;
-#line 65 "MDTreeParser.g"
-				dval = lexi_cast<double>(fc->getText());  blockStack.top()->assign(id->getText(), dval);
-#line 397 "MDTreeParser.cpp"
-				break;
-			}
-			default:
-			{
-				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
-			}
-			}
-			}
-			break;
-		}
-		default:
-		{
-			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
-		}
-		}
-	}
-	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
-		reportError(ex);
-		if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+			i2 = _t;
+			match(_t,NUM_LONG);
 			_t = _t->getNextSibling();
-	}
-	_retTree = _t;
-}
-
-int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-#line 249 "MDTreeParser.g"
-	int ival;
-#line 425 "MDTreeParser.cpp"
-	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-	ANTLR_USE_NAMESPACE(antlr)RefAST oival = ANTLR_USE_NAMESPACE(antlr)nullAST;
-	ANTLR_USE_NAMESPACE(antlr)RefAST dival = ANTLR_USE_NAMESPACE(antlr)nullAST;
-	ANTLR_USE_NAMESPACE(antlr)RefAST hival = ANTLR_USE_NAMESPACE(antlr)nullAST;
-	
-	try {      // for error handling
-		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
-			_t = ASTNULL;
-		switch ( _t->getType()) {
-		case OCTALINT:
-		{
-			oival = _t;
-			match(_t,OCTALINT);
-			_t = _t->getNextSibling();
-#line 250 "MDTreeParser.g"
-			ival = lexi_cast<int>(oival->getText());
-#line 442 "MDTreeParser.cpp"
+#line 270 "MDTreeParser.g"
+			ival = lexi_cast<int>(i2->getText());
+#line 398 "MDTreeParser.cpp"
 			break;
 		}
-		case DECIMALINT:
-		{
-			dival = _t;
-			match(_t,DECIMALINT);
-			_t = _t->getNextSibling();
-#line 251 "MDTreeParser.g"
-			ival = lexi_cast<int>(dival->getText());
-#line 452 "MDTreeParser.cpp"
-			break;
-		}
-		case HEXADECIMALINT:
-		{
-			hival = _t;
-			match(_t,HEXADECIMALINT);
-			_t = _t->getNextSibling();
-#line 252 "MDTreeParser.g"
-			ival = lexi_cast<int>(hival->getText());
-#line 462 "MDTreeParser.cpp"
-			break;
-		}
 		default:
 		{
 			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
@@ -476,11 +412,11 @@ int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
 	return ival;
 }
 
-double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-#line 266 "MDTreeParser.g"
-	double dval;
-#line 483 "MDTreeParser.cpp"
-	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+#line 282 "MDTreeParser.g"
+	RealType dval;
+#line 419 "MDTreeParser.cpp"
+	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
 	ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
 	
@@ -488,24 +424,24 @@ double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
 			_t = ASTNULL;
 		switch ( _t->getType()) {
-		case FLOATONE:
+		case NUM_FLOAT:
 		{
 			d1 = _t;
-			match(_t,FLOATONE);
+			match(_t,NUM_FLOAT);
 			_t = _t->getNextSibling();
-#line 267 "MDTreeParser.g"
-			dval = lexi_cast<double>(d1->getText());
-#line 499 "MDTreeParser.cpp"
+#line 283 "MDTreeParser.g"
+			dval = lexi_cast<RealType>(d1->getText());
+#line 435 "MDTreeParser.cpp"
 			break;
 		}
-		case FLOATTWO:
+		case NUM_DOUBLE:
 		{
 			d2 = _t;
-			match(_t,FLOATTWO);
+			match(_t,NUM_DOUBLE);
 			_t = _t->getNextSibling();
-#line 268 "MDTreeParser.g"
-			dval = lexi_cast<double>(d2->getText());
-#line 509 "MDTreeParser.cpp"
+#line 284 "MDTreeParser.g"
+			dval = lexi_cast<RealType>(d2->getText());
+#line 445 "MDTreeParser.cpp"
 			break;
 		}
 		default:
@@ -524,7 +460,7 @@ void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
 }
 
 void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	
 	try {      // for error handling
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -560,6 +496,12 @@ void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
 			_t = _retTree;
 			break;
 		}
+		case INVERSION:
+		{
+			inversionblock(_t);
+			_t = _retTree;
+			break;
+		}
 		case RIGIDBODY:
 		{
 			rigidbodyblock(_t);
@@ -593,23 +535,23 @@ void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
 }
 
 void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 #line 94 "MDTreeParser.g"
 	
 	int index;
 	
-#line 602 "MDTreeParser.cpp"
+#line 544 "MDTreeParser.cpp"
 	
 	try {      // for error handling
 		ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
 		match(_t,ATOM);
 		_t = _t->getFirstChild();
 		index=intConst(_t);
 		_t = _retTree;
 #line 98 "MDTreeParser.g"
 		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
-#line 613 "MDTreeParser.cpp"
+#line 555 "MDTreeParser.cpp"
 		{ // ( ... )*
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -625,7 +567,7 @@ void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
 		}
 		_loop28:;
 		} // ( ... )*
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
 		match(_t,ENDBLOCK);
 		_t = _t->getNextSibling();
 		_t = __t26;
@@ -637,7 +579,7 @@ void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
 		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
 		currMoleculeStamp->addAtomStamp(currAtomStamp); 
 		
-#line 641 "MDTreeParser.cpp"
+#line 583 "MDTreeParser.cpp"
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
 		reportError(ex);
@@ -648,16 +590,16 @@ void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
 }
 
 void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	
 	try {      // for error handling
 		ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
 		match(_t,BOND);
 		_t = _t->getFirstChild();
 #line 120 "MDTreeParser.g"
 		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
-#line 661 "MDTreeParser.cpp"
+#line 603 "MDTreeParser.cpp"
 		{ // ( ... )*
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -673,7 +615,7 @@ void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
 		}
 		_loop35:;
 		} // ( ... )*
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
 		match(_t,ENDBLOCK);
 		_t = _t->getNextSibling();
 		_t = __t33;
@@ -684,7 +626,7 @@ void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
 		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
 		currMoleculeStamp->addBondStamp(currBondStamp); 
 		
-#line 688 "MDTreeParser.cpp"
+#line 630 "MDTreeParser.cpp"
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
 		reportError(ex);
@@ -695,16 +637,16 @@ void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
 }
 
 void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	
 	try {      // for error handling
 		ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
 		match(_t,BEND);
 		_t = _t->getFirstChild();
 #line 138 "MDTreeParser.g"
 		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
-#line 708 "MDTreeParser.cpp"
+#line 650 "MDTreeParser.cpp"
 		{ // ( ... )*
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -720,7 +662,7 @@ void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
 		}
 		_loop41:;
 		} // ( ... )*
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
 		match(_t,ENDBLOCK);
 		_t = _t->getNextSibling();
 		_t = __t39;
@@ -732,7 +674,7 @@ void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
 		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
 		currMoleculeStamp->addBendStamp(currBendStamp); 
 		
-#line 736 "MDTreeParser.cpp"
+#line 678 "MDTreeParser.cpp"
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
 		reportError(ex);
@@ -743,16 +685,16 @@ void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
 }
 
 void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	
 	try {      // for error handling
 		ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
 		match(_t,TORSION);
 		_t = _t->getFirstChild();
 #line 157 "MDTreeParser.g"
 		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
-#line 756 "MDTreeParser.cpp"
+#line 698 "MDTreeParser.cpp"
 		{ // ( ... )*
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -768,7 +710,7 @@ void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
 		}
 		_loop47:;
 		} // ( ... )*
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
 		match(_t,ENDBLOCK);
 		_t = _t->getNextSibling();
 		_t = __t45;
@@ -780,7 +722,7 @@ void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
 		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
 		currMoleculeStamp->addTorsionStamp(currTorsionStamp); 
 		
-#line 784 "MDTreeParser.cpp"
+#line 726 "MDTreeParser.cpp"
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
 		reportError(ex);
@@ -790,30 +732,23 @@ void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
 	_retTree = _t;
 }
 
-void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-#line 176 "MDTreeParser.g"
-	
-	int index;
-	
-#line 800 "MDTreeParser.cpp"
+void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+	ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	
 	try {      // for error handling
 		ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
-		match(_t,RIGIDBODY);
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
+		match(_t,INVERSION);
 		_t = _t->getFirstChild();
-		index=intConst(_t);
-		_t = _retTree;
-#line 180 "MDTreeParser.g"
-		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
-#line 811 "MDTreeParser.cpp"
+#line 176 "MDTreeParser.g"
+		InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
+#line 746 "MDTreeParser.cpp"
 		{ // ( ... )*
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
 				_t = ASTNULL;
-			if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
-				rigidbodystatement(_t);
+			if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
+				inversionstatement(_t);
 				_t = _retTree;
 			}
 			else {
@@ -823,19 +758,19 @@ void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
 		}
 		_loop53:;
 		} // ( ... )*
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
 		match(_t,ENDBLOCK);
 		_t = _t->getNextSibling();
 		_t = __t51;
 		_t = _t->getNextSibling();
-#line 182 "MDTreeParser.g"
+#line 178 "MDTreeParser.g"
 		
 		blockStack.top()->validate();
 		blockStack.pop(); 
 		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
-		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp); 
+		currMoleculeStamp->addInversionStamp(currInversionStamp); 
 		
-#line 839 "MDTreeParser.cpp"
+#line 774 "MDTreeParser.cpp"
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
 		reportError(ex);
@@ -845,23 +780,30 @@ void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
 	_retTree = _t;
 }
 
-void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+#line 195 "MDTreeParser.g"
 	
+	int index;
+	
+#line 790 "MDTreeParser.cpp"
+	
 	try {      // for error handling
 		ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
-		match(_t,CUTOFFGROUP);
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
+		match(_t,RIGIDBODY);
 		_t = _t->getFirstChild();
+		index=intConst(_t);
+		_t = _retTree;
 #line 199 "MDTreeParser.g"
-		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
-#line 859 "MDTreeParser.cpp"
+		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
+#line 801 "MDTreeParser.cpp"
 		{ // ( ... )*
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
 				_t = ASTNULL;
 			if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
-				cutoffgroupstatement(_t);
+				rigidbodystatement(_t);
 				_t = _retTree;
 			}
 			else {
@@ -871,7 +813,7 @@ void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
 		}
 		_loop59:;
 		} // ( ... )*
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
 		match(_t,ENDBLOCK);
 		_t = _t->getNextSibling();
 		_t = __t57;
@@ -881,9 +823,57 @@ void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
 		blockStack.top()->validate();
 		blockStack.pop(); 
 		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
+		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp); 
+		
+#line 829 "MDTreeParser.cpp"
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	
+	try {      // for error handling
+		ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
+		match(_t,CUTOFFGROUP);
+		_t = _t->getFirstChild();
+#line 218 "MDTreeParser.g"
+		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
+#line 849 "MDTreeParser.cpp"
+		{ // ( ... )*
+		for (;;) {
+			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+				_t = ASTNULL;
+			if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
+				cutoffgroupstatement(_t);
+				_t = _retTree;
+			}
+			else {
+				goto _loop65;
+			}
+			
+		}
+		_loop65:;
+		} // ( ... )*
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
+		match(_t,ENDBLOCK);
+		_t = _t->getNextSibling();
+		_t = __t63;
+		_t = _t->getNextSibling();
+#line 220 "MDTreeParser.g"
+		
+		blockStack.top()->validate();
+		blockStack.pop(); 
+		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
 		currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp); 
 		
-#line 887 "MDTreeParser.cpp"
+#line 877 "MDTreeParser.cpp"
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
 		reportError(ex);
@@ -894,21 +884,21 @@ void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
 }
 
 void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-#line 218 "MDTreeParser.g"
+	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+#line 237 "MDTreeParser.g"
 	int ival;
-#line 901 "MDTreeParser.cpp"
+#line 891 "MDTreeParser.cpp"
 	
 	try {      // for error handling
-		ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
 		match(_t,FRAGMENT);
 		_t = _t->getFirstChild();
 		ival=intConst(_t);
 		_t = _retTree;
-#line 219 "MDTreeParser.g"
+#line 238 "MDTreeParser.g"
 		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
-#line 912 "MDTreeParser.cpp"
+#line 902 "MDTreeParser.cpp"
 		{ // ( ... )*
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -918,25 +908,25 @@ void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
 				_t = _retTree;
 			}
 			else {
-				goto _loop65;
+				goto _loop71;
 			}
 			
 		}
-		_loop65:;
+		_loop71:;
 		} // ( ... )*
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
 		match(_t,ENDBLOCK);
 		_t = _t->getNextSibling();
-		_t = __t63;
+		_t = __t69;
 		_t = _t->getNextSibling();
-#line 221 "MDTreeParser.g"
+#line 240 "MDTreeParser.g"
 		
 		blockStack.top()->validate();
 		blockStack.pop(); 
 		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
 		currMoleculeStamp->addFragmentStamp(currFragmentStamp); 
 		
-#line 940 "MDTreeParser.cpp"
+#line 930 "MDTreeParser.cpp"
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
 		reportError(ex);
@@ -947,14 +937,14 @@ void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
 }
 
 void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 #line 108 "MDTreeParser.g"
 	
-	vector<double> dvec;
+	vector<RealType> dvec;
 	AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
 	
 	
-#line 958 "MDTreeParser.cpp"
+#line 948 "MDTreeParser.cpp"
 	
 	try {      // for error handling
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -969,31 +959,31 @@ void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
 		case POSITION:
 		{
 			ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
 			match(_t,POSITION);
 			_t = _t->getFirstChild();
-			dvec=signedNumberTuple(_t);
+			dvec=doubleNumberTuple(_t);
 			_t = _retTree;
 			_t = __t30;
 			_t = _t->getNextSibling();
 #line 115 "MDTreeParser.g"
 			currAtomStamp->setPosition(dvec);
-#line 982 "MDTreeParser.cpp"
+#line 972 "MDTreeParser.cpp"
 			break;
 		}
 		case ORIENTATION:
 		{
 			ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
 			match(_t,ORIENTATION);
 			_t = _t->getFirstChild();
-			dvec=signedNumberTuple(_t);
+			dvec=doubleNumberTuple(_t);
 			_t = _retTree;
 			_t = __t31;
 			_t = _t->getNextSibling();
 #line 116 "MDTreeParser.g"
 			currAtomStamp->setOrientation(dvec);
-#line 997 "MDTreeParser.cpp"
+#line 987 "MDTreeParser.cpp"
 			break;
 		}
 		default:
@@ -1010,37 +1000,37 @@ void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
 	_retTree = _t;
 }
 
-vector<double>  MDTreeParser::signedNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-#line 234 "MDTreeParser.g"
-	vector<double> dvec;
-#line 1017 "MDTreeParser.cpp"
-	ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-#line 234 "MDTreeParser.g"
+vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+#line 253 "MDTreeParser.g"
+	vector<RealType> dvec;
+#line 1007 "MDTreeParser.cpp"
+	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+#line 253 "MDTreeParser.g"
 	
-	double dval;
+	RealType dval;
 	
-#line 1023 "MDTreeParser.cpp"
+#line 1013 "MDTreeParser.cpp"
 	
 	try {      // for error handling
 		{ // ( ... )+
-		int _cnt69=0;
+		int _cnt75=0;
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
 				_t = ASTNULL;
-			if ((_tokenSet_2.member(_t->getType()))) {
-				dval=signedNumber(_t);
+			if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
+				dval=doubleNumber(_t);
 				_t = _retTree;
-#line 238 "MDTreeParser.g"
+#line 257 "MDTreeParser.g"
 				dvec.push_back(dval);
-#line 1036 "MDTreeParser.cpp"
+#line 1026 "MDTreeParser.cpp"
 			}
 			else {
-				if ( _cnt69>=1 ) { goto _loop69; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+				if ( _cnt75>=1 ) { goto _loop75; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
 			}
 			
-			_cnt69++;
+			_cnt75++;
 		}
-		_loop69:;
+		_loop75:;
 		}  // ( ... )+
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
@@ -1053,13 +1043,13 @@ void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
 }
 
 void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 #line 129 "MDTreeParser.g"
 	
 	vector<int> ivec;
 	BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
 	
-#line 1063 "MDTreeParser.cpp"
+#line 1053 "MDTreeParser.cpp"
 	
 	try {      // for error handling
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -1074,7 +1064,7 @@ void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
 		case MEMBERS:
 		{
 			ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
 			match(_t,MEMBERS);
 			_t = _t->getFirstChild();
 			ivec=inttuple(_t);
@@ -1083,7 +1073,7 @@ void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
 			_t = _t->getNextSibling();
 #line 135 "MDTreeParser.g"
 			currBondStamp->setMembers(ivec);
-#line 1087 "MDTreeParser.cpp"
+#line 1077 "MDTreeParser.cpp"
 			break;
 		}
 		default:
@@ -1101,36 +1091,36 @@ vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
 }
 
 vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-#line 241 "MDTreeParser.g"
+#line 260 "MDTreeParser.g"
 	vector<int> ivec;
-#line 1107 "MDTreeParser.cpp"
-	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-#line 241 "MDTreeParser.g"
+#line 1097 "MDTreeParser.cpp"
+	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+#line 260 "MDTreeParser.g"
 	
 	int ival;
 	
-#line 1113 "MDTreeParser.cpp"
+#line 1103 "MDTreeParser.cpp"
 	
 	try {      // for error handling
 		{ // ( ... )+
-		int _cnt72=0;
+		int _cnt78=0;
 		for (;;) {
 			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
 				_t = ASTNULL;
-			if (((_t->getType() >= OCTALINT && _t->getType() <= HEXADECIMALINT))) {
+			if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
 				ival=intConst(_t);
 				_t = _retTree;
-#line 245 "MDTreeParser.g"
+#line 264 "MDTreeParser.g"
 				ivec.push_back(ival);
-#line 1126 "MDTreeParser.cpp"
+#line 1116 "MDTreeParser.cpp"
 			}
 			else {
-				if ( _cnt72>=1 ) { goto _loop72; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+				if ( _cnt78>=1 ) { goto _loop78; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
 			}
 			
-			_cnt72++;
+			_cnt78++;
 		}
-		_loop72:;
+		_loop78:;
 		}  // ( ... )+
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
@@ -1143,13 +1133,13 @@ void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
 }
 
 void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 #line 148 "MDTreeParser.g"
 	
 	vector<int> ivec;
 	BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
 	
-#line 1153 "MDTreeParser.cpp"
+#line 1143 "MDTreeParser.cpp"
 	
 	try {      // for error handling
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -1164,7 +1154,7 @@ void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
 		case MEMBERS:
 		{
 			ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
 			match(_t,MEMBERS);
 			_t = _t->getFirstChild();
 			ivec=inttuple(_t);
@@ -1173,7 +1163,7 @@ void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
 			_t = _t->getNextSibling();
 #line 154 "MDTreeParser.g"
 			currBendStamp->setMembers(ivec);
-#line 1177 "MDTreeParser.cpp"
+#line 1167 "MDTreeParser.cpp"
 			break;
 		}
 		default:
@@ -1191,13 +1181,13 @@ void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
 }
 
 void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 #line 167 "MDTreeParser.g"
 	
 	vector<int> ivec;
 	TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
 	
-#line 1201 "MDTreeParser.cpp"
+#line 1191 "MDTreeParser.cpp"
 	
 	try {      // for error handling
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -1212,7 +1202,7 @@ void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
 		case MEMBERS:
 		{
 			ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
 			match(_t,MEMBERS);
 			_t = _t->getFirstChild();
 			ivec=inttuple(_t);
@@ -1221,7 +1211,7 @@ void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
 			_t = _t->getNextSibling();
 #line 173 "MDTreeParser.g"
 			currTorsionStamp->setMembers(ivec);
-#line 1225 "MDTreeParser.cpp"
+#line 1215 "MDTreeParser.cpp"
 			break;
 		}
 		default:
@@ -1238,14 +1228,14 @@ void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
 	_retTree = _t;
 }
 
-void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-#line 190 "MDTreeParser.g"
+void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+	ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+#line 186 "MDTreeParser.g"
 	
-	vector<int> ivec;
-	RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
+	int icent;
+	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
 	
-#line 1249 "MDTreeParser.cpp"
+#line 1239 "MDTreeParser.cpp"
 	
 	try {      // for error handling
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -1257,19 +1247,19 @@ void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
 			_t = _retTree;
 			break;
 		}
-		case MEMBERS:
+		case CENTER:
 		{
 			ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
-			match(_t,MEMBERS);
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
+			match(_t,CENTER);
 			_t = _t->getFirstChild();
-			ivec=inttuple(_t);
+			icent=intConst(_t);
 			_t = _retTree;
 			_t = __t55;
 			_t = _t->getNextSibling();
-#line 196 "MDTreeParser.g"
-			currRigidBodyStamp->setMembers(ivec);
-#line 1273 "MDTreeParser.cpp"
+#line 192 "MDTreeParser.g"
+			currInversionStamp->setCenter(icent);
+#line 1263 "MDTreeParser.cpp"
 			break;
 		}
 		default:
@@ -1286,14 +1276,14 @@ void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
 	_retTree = _t;
 }
 
-void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 #line 209 "MDTreeParser.g"
 	
 	vector<int> ivec;
-	CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
+	RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
 	
-#line 1297 "MDTreeParser.cpp"
+#line 1287 "MDTreeParser.cpp"
 	
 	try {      // for error handling
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
@@ -1308,7 +1298,7 @@ void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
 		case MEMBERS:
 		{
 			ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
 			match(_t,MEMBERS);
 			_t = _t->getFirstChild();
 			ivec=inttuple(_t);
@@ -1316,8 +1306,56 @@ void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
 			_t = __t61;
 			_t = _t->getNextSibling();
 #line 215 "MDTreeParser.g"
+			currRigidBodyStamp->setMembers(ivec);
+#line 1311 "MDTreeParser.cpp"
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+#line 228 "MDTreeParser.g"
+	
+	vector<int> ivec;
+	CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
+	
+#line 1335 "MDTreeParser.cpp"
+	
+	try {      // for error handling
+		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case ASSIGNEQUAL:
+		{
+			assignment(_t);
+			_t = _retTree;
+			break;
+		}
+		case MEMBERS:
+		{
+			ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
+			match(_t,MEMBERS);
+			_t = _t->getFirstChild();
+			ivec=inttuple(_t);
+			_t = _retTree;
+			_t = __t67;
+			_t = _t->getNextSibling();
+#line 234 "MDTreeParser.g"
 			currCutoffGroupStamp->setMembers(ivec);
-#line 1321 "MDTreeParser.cpp"
+#line 1359 "MDTreeParser.cpp"
 			break;
 		}
 		default:
@@ -1335,7 +1373,7 @@ void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
 }
 
 void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	
 	try {      // for error handling
 		assignment(_t);
@@ -1349,13 +1387,11 @@ void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
 	_retTree = _t;
 }
 
-double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
-#line 256 "MDTreeParser.g"
-	double dval;
-#line 1356 "MDTreeParser.cpp"
-	ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-	ANTLR_USE_NAMESPACE(antlr)RefAST icMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
-	ANTLR_USE_NAMESPACE(antlr)RefAST fcMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
+RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+#line 274 "MDTreeParser.g"
+	RealType dval;
+#line 1394 "MDTreeParser.cpp"
+	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
 	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
 	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
 	
@@ -1363,88 +1399,26 @@ double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE
 		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
 			_t = ASTNULL;
 		switch ( _t->getType()) {
-		case MINUS:
+		case NUM_INT:
+		case NUM_LONG:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
-			match(_t,MINUS);
-			_t = _t->getFirstChild();
-			{
-			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
-				_t = ASTNULL;
-			switch ( _t->getType()) {
-			case OCTALINT:
-			case DECIMALINT:
-			case HEXADECIMALINT:
-			{
-				icMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-				intConst(_t);
-				_t = _retTree;
-#line 257 "MDTreeParser.g"
-				dval = lexi_cast<double>(icMinus->getText()); dval = -dval;
-#line 1386 "MDTreeParser.cpp"
-				break;
-			}
-			case FLOATONE:
-			case FLOATTWO:
-			{
-				fcMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-				floatConst(_t);
-				_t = _retTree;
-				break;
-			}
-			default:
-			{
-				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
-			}
-			}
-			}
-#line 258 "MDTreeParser.g"
-			dval = lexi_cast<double>(fcMinus->getText());dval = -dval;
-#line 1405 "MDTreeParser.cpp"
-			_t = __t75;
-			_t = _t->getNextSibling();
+			ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+			intConst(_t);
+			_t = _retTree;
+#line 276 "MDTreeParser.g"
+			dval = lexi_cast<RealType>(ic->getText());
+#line 1411 "MDTreeParser.cpp"
 			break;
 		}
-		case OCTALINT:
-		case DECIMALINT:
-		case HEXADECIMALINT:
-		case FLOATONE:
-		case FLOATTWO:
+		case NUM_FLOAT:
+		case NUM_DOUBLE:
 		{
-			{
-			if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
-				_t = ASTNULL;
-			switch ( _t->getType()) {
-			case OCTALINT:
-			case DECIMALINT:
-			case HEXADECIMALINT:
-			{
-				ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-				intConst(_t);
-				_t = _retTree;
-#line 260 "MDTreeParser.g"
-				dval = lexi_cast<double>(ic->getText());
-#line 1429 "MDTreeParser.cpp"
-				break;
-			}
-			case FLOATONE:
-			case FLOATTWO:
-			{
-				fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
-				floatConst(_t);
-				_t = _retTree;
-#line 261 "MDTreeParser.g"
-				dval = lexi_cast<double>(fc->getText());
-#line 1440 "MDTreeParser.cpp"
-				break;
-			}
-			default:
-			{
-				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
-			}
-			}
-			}
+			fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+			floatConst(_t);
+			_t = _retTree;
+#line 277 "MDTreeParser.g"
+			dval = lexi_cast<RealType>(fc->getText());
+#line 1422 "MDTreeParser.cpp"
 			break;
 		}
 		default:
@@ -1473,14 +1447,17 @@ const char* MDTreeParser::tokenNames[] = {
 	"\"component\"",
 	"\"molecule\"",
 	"\"zconstraint\"",
+	"\"restraint\"",
 	"\"atom\"",
 	"\"bond\"",
 	"\"bend\"",
 	"\"torsion\"",
+	"\"inversion\"",
 	"\"rigidBody\"",
 	"\"cutoffGroup\"",
 	"\"fragment\"",
 	"\"members\"",
+	"\"center\"",
 	"\"position\"",
 	"\"orientation\"",
 	"ENDBLOCK",
@@ -1495,13 +1472,10 @@ const char* MDTreeParser::tokenNames[] = {
 	"LPAREN",
 	"RPAREN",
 	"COMMA",
-	"OCTALINT",
-	"DECIMALINT",
-	"HEXADECIMALINT",
-	"PLUS",
-	"MINUS",
-	"FLOATONE",
-	"FLOATTWO",
+	"NUM_INT",
+	"NUM_LONG",
+	"NUM_FLOAT",
+	"NUM_DOUBLE",
 	"DOT",
 	"COLON",
 	"QUESTIONMARK",
@@ -1514,26 +1488,21 @@ const char* MDTreeParser::tokenNames[] = {
 	"CharLiteral",
 	"EndOfLine",
 	"Escape",
+	"Vocabulary",
 	"Digit",
 	"Decimal",
-	"LongSuffix",
-	"UnsignedSuffix",
-	"FloatSuffix",
-	"Exponent",
-	"Vocabulary",
-	"Number",
+	"HEX_DIGIT",
+	"EXPONENT",
+	"FLOAT_SUFFIX",
 	0
 };
 
-const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
-// "component" "molecule" "zconstraint" ASSIGNEQUAL 
+const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 4194544UL, 0UL, 0UL, 0UL };
+// "component" "molecule" "zconstraint" "restraint" ASSIGNEQUAL 
 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
-const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 540544UL, 0UL, 0UL, 0UL };
-// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment" 
-// ASSIGNEQUAL 
+const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 4259584UL, 0UL, 0UL, 0UL };
+// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup" 
+// "fragment" ASSIGNEQUAL 
 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
-const unsigned long MDTreeParser::_tokenSet_2_data_[] = { 3758096384UL, 14UL, 0UL, 0UL };
-// OCTALINT DECIMALINT HEXADECIMALINT MINUS FLOATONE FLOATTWO 
-const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_2(_tokenSet_2_data_,4);