anchor.diff:      import java.util.HashSet;
       import java.util.Set;
       import java.util.Arrays;
  -    import platu.lpn.LPN;
  -    import platu.lpn.VarSet;
  -    import platu.lpn.LpnTranList;
  -    import platu.lpn.LPNTran;
  -    import platu.lpn.DualHashMap;
  -    import platu.lpn.VarExpr;
  -    import platu.lpn.VarExprList;
  -    import platu.stategraph.StateGraph;
  -    import platu.project.Project;
  -    import platu.expression.*; 
  +    import verification.platu.lpn.LPN;
  +    import verification.platu.lpn.VarSet;
  +    import verification.platu.lpn.LpnTranList;
  +    import verification.platu.lpn.LPNTran;
  +    import verification.platu.lpn.DualHashMap;
  +    import verification.platu.lpn.VarExpr;
  +    import verification.platu.lpn.VarExprList;
  +    import verification.platu.stategraph.StateGraph;
  +    import verification.platu.project.Project;
  +    import verification.platu.expression.*;
  +    
  +    import lpn.parser.LhpnFile;
  +    import lpn.parser.Place;
  +    import lpn.parser.Transition;
  +    import lpn.parser.Variable;
  +    import lpn.parser.ExprTree;
  +     
  +    
  +    
   }
   
   @members{
   	// static variables
       static private int INFINITY = Integer.MAX_VALUE;
       static private boolean main = false;
  -    static private ExpressionNode ZERO = new ConstNode("FALSE", 0);  // constant false node
  -    static private ExpressionNode ONE = new ConstNode("TRUE", 1);  // constant true node
  -    static private Expression TrueExpr = new Expression(ONE); // constant true expression
  -    static private HashMap<String, LPN> LpnMap = new HashMap<String, LPN>();  // all modules parsed, keyed by module name
  +//    static private ExprTree ZERO = new ExprTree("false"); // constant false node
  +//    static private ExprTree ONE = new ExprTree("true");  // constant true node    
  +    static private HashMap<String, LhpnFile> LpnMap = new HashMap<String, LhpnFile>();  // all modules parsed, keyed by module name
       static private HashMap<String, Integer> GlobalVarHashMap = new HashMap<String, Integer>();  // global variables and associated values
  -    static private HashMap<String, LPN> GlobalOutputMap = new HashMap<String, LPN>();  // maps potential output variables to associated lpn
  +    static private HashMap<String, LhpnFile> GlobalOutputMap = new HashMap<String, LhpnFile>();  // maps potential output variables to associated lpn
       static private HashMap<String, Integer> GlobalInterfaceMap = new HashMap<String, Integer>();  // maps variables to initial values, input have null value until associated output is found
  -    static private HashMap<String, List<LPN>> GlobalInputMap = new HashMap<String, List<LPN>>(); // maps input variables to associated lpn
  -    static private HashMap<String, List<LPNTran>> GlobalTranMap = new HashMap<String, List<LPNTran>>();  // maps potential output variables to lpn transitions which affect it
  -    static private HashMap<String, VarNode> GlobalVarNodeMap = new HashMap<String, VarNode>(); // maps global variable name to variable object
  +    static private HashMap<String, List<LhpnFile>> GlobalInputMap = new HashMap<String, List<LhpnFile>>(); // maps input variables to associated lpn
  +    static private HashMap<String, List<Transition>> GlobalTranMap = new HashMap<String, List<Transition>>();  // maps potential output variables to lpn transitions which affect it
  +    static private HashMap<String, ExprTree> GlobalVarNodeMap = new HashMap<String, ExprTree>(); // maps global variable name to variable object
  +    //static private ExpressionNode ZERO = new ConstNode("FALSE", 0);  
  +    //static private ExpressionNode ONE = new ConstNode("TRUE", 1);  // constant true node
  +    //static private Expression TrueExpr = new Expression(ONE); // constant true expression
  +//    static private HashMap<String, LPN> LpnMap = new HashMap<String, LPN>();  // all modules parsed, keyed by module name
  +//    static private HashMap<String, Integer> GlobalVarHashMap = new HashMap<String, Integer>();  // global variables and associated values
  +//    static private HashMap<String, LPN> GlobalOutputMap = new HashMap<String, LPN>();  // maps potential output variables to associated lpn
  +//    static private HashMap<String, Integer> GlobalInterfaceMap = new HashMap<String, Integer>();  // maps variables to initial values, input have null value until associated output is found
  +//    static private HashMap<String, List<LPN>> GlobalInputMap = new HashMap<String, List<LPN>>(); // maps input variables to associated lpn
  +//    static private HashMap<String, List<LPNTran>> GlobalTranMap = new HashMap<String, List<LPNTran>>();  // maps potential output variables to lpn transitions which affect it
  +//    static private HashMap<String, VarNode> GlobalVarNodeMap = new HashMap<String, VarNode>(); // maps global variable name to variable object
  +    
  +    static private HashSet<String> initMarkedPlaces = new HashSet<String>();
  +    //static private HashSet<Integer> initMarkedPlaces = new HashSet<Integer>();
       
       // non-static variables
       private boolean Instance = false;
  -    private HashMap<String, VarNode> VarNodeMap = null; // maps variable name to variable object
  +    private HashMap<String, ExprTree> VarNodeMap = null; // maps variable name to variable object
       private HashMap<String, ArrayNode> ArrayNodeMap = null; // maps array variable name to variable object
  -	private DualHashMap<String, Integer> VarIndexMap = null;  // maps variables to an array index
  +	  private DualHashMap<String, Integer> VarIndexMap = null;  // maps variables to an array index
       private HashMap<String, Integer> GlobalConstHashMap = new HashMap<String, Integer>();  // global constants within a single lpn file
       private HashMap<String, Integer> ConstHashMap = null;  // constants within a single module
       private HashMap<String, Integer> StatevectorMap = null;  // module variables mapped to initial values
       private HashMap<String, Integer> VarCountMap = null; // count of the references to each module variable
  -    private List<LPNTran> inputTranList = null;  // list of lpn transitions which affect a modules input
  -    private List<LPNTran> outputTranList = null; // list of lpn transitions which affect a modules output
  +    private List<Transition> inputTranList = null;  // list of lpn transitions which affect a modules input
  +    private List<Transition> outputTranList = null; // list of lpn transitions which affect a modules output
       private VarSet Inputs = null;  // module inputs
       private VarSet Internals = null; // module internal variables
       private VarSet Outputs = null;  // module outputs
  
positive.code: 			}
  	;
  	
  negation returns [ExpressionNode expr]
  	:	{boolean neg = false;}
  		('!' {if(neg){neg = false;} else{neg = true;}})* bitwiseNegation
  			{
  				if(neg){
  					$expr = new NegNode($bitwiseNegation.expr);
  				}
  				else{
  					$expr = $bitwiseNegation.expr;
  
negative.code: 					for(int i = 0; i < arraySize; i++){
  						String name = $arrayName.text + varCount++;
  						int index = VariableIndex++;
  						//VarNode v = new VarNode(name, index);
  						ExprTree v = new ExprTree(name);
  						array.add(v);
  						
  						// add variable and value to state vector
  						StatevectorMap.put(name, 0);
  						
  						// generate variable index and create new var node  
  		   			VarIndexMap.insert(name, index);
  					}
  					// TODO: ArrayNodeMap? 
  //					ArrayNodeMap.put($arrayName.text, new ArrayNode($arrayName.text, array, 1));
  					VarCountMap.put($arrayName.text, 0);
  				}
  