Print out values from open & closed lists?

list<int> Level::planPathAStar(short currentX, short currentY, short goalX, short goalY, short debugMode)
{
	list<int> path; // Final path to be constructed
	list<graphNode> open; // List of open nodes to be explored
	list<graphNode> closed; // List of closed nodes which have been explored 
	int goalIndex; // Index of the goal node
	int currentIndex; // Index of the current node
	graphNode currentNode; // Current graph node  
	goalIndex = index(goalX, goalY); // Set goal node index
	currentIndex = index(currentX, currentY); // Set current node index 
	currentNode.index = currentIndex; // Set the index of the currentgraph node
	currentNode.parentIndex = -1; // Set the parent of the current node to NULL
	currentNode.score(0.0, currentX, currentY, goalX, goalY); // Score the current node 
	open.push_back(currentNode); // Put the current node on the open list  
	while(currentIndex != goalIndex)
	{
		open.sort(); // Sort the list of open node by list quality 
		currentNode = open.front(); // Take the node that scored best on the open list
		open.pop_front(); // Take it off the open list
		closed.push_back(currentNode); // Add that node to the closed list
		currentIndex = currentNode.index; // Set the current index 
		// Look in the adjacency matrix for connections to other nodes
		for(int otherIndex = 0; otherIndex < nNodes; otherIndex++)
		{	
			// Check for a connection
			if(adjacencyMatrix[currentIndex][otherIndex])
			{
				// If there is a connection 
				list<graphNode>::iterator graphListIter;
				bool onClosed = false;
				bool onOpen = false;
				
				// Find out whether it's on the closed list
				for(graphListIter = closed.begin();graphListIter != closed.end();++graphListIter)
				{
					if((*graphListIter).index == otherIndex)
					{
						// Found on closed list
						onClosed = true;
						// Check g value
						// If the current g value is less than that of the node found on the closed list
						// then update that nodes parent to the current node
						if(currentNode.g + 1.0 < (*graphListIter).g)
						{
							(*graphListIter).parentIndex = currentIndex;
						}
					}
				} 
				if(!onClosed)
				{
					// Find out whether it's on the open list list
					for(graphListIter = open.begin();graphListIter != open.end();++graphListIter)
					{
						if((*graphListIter).index == otherIndex)
						{
							// Found on closed list
							onOpen = true;
							// Check g values
							// If the current g value is less than that of the node found on the closed list
							// then update that nodes parent to the current node
							if(currentNode.g + 1.0 < (*graphListIter).g)
							{
								(*graphListIter).parentIndex = currentIndex;
							}
						}
					}
				} 
				if(!onClosed && !onOpen)
				{
					// It its not on open or closed
					graphNode tmpNode; 
					// Set the parent node to the curretn node
					tmpNode.parentIndex = currentIndex;
					// Set the node index to other index
					tmpNode.index = otherIndex;
					// Find the X and Y posiiton of that node
					inverseIndex(otherIndex,&currentX, &currentY);
					// Score the node
					tmpNode.score(currentNode.g, currentX, currentY, goalX, goalY);
					// Add it to the open list
					open.push_back(tmpNode);
				}
			}
		}
	} 
	// Reconstruct the path
	// Start with goal node working backwards towarsd the first node
	// We know that we're at the first node because it has a parent of -1
	int parent;
	list<graphNode>::iterator graphListIter; 
	currentNode = closed.back(); // Set the current node to goal node
	parent = currentNode.parentIndex; // Set parent to be the parent of the current node
	path.push_front(currentIndex); // Add the current node the the start of the path
	closed.pop_back(); // Remove the curretn node from the closed list 
	//Now work backwards throught the closed list reconstructing the path
	for(graphListIter = closed.end(), graphListIter--;graphListIter != closed.begin();--graphListIter)
	{
		currentNode = *graphListIter;
		if(currentNode.index == parent) // Fount the node
		{
			// Add it to the path
			path.push_front(parent);
			// Set parent to be this nodes parent
			parent = currentNode.parentIndex;
			// Remove this node from the closed list
			closed.erase(graphListIter);
			// Start working backward throguht the cloased list again from the end
			graphListIter = closed.end();
		}
	}
	return path;
}