Knight's Tour-Help Please!

Anyone familiar with the Knight's tour problem? Where you have to move a knight across a chess board, reaching all squares without touching any square twice.

I've been working on this code for a week now. I'm at my limits and out of ideas. My program solves all the way up to 62 moves, but enters a never ending loop when I try and solve for the last 2 moves.

I'm guessing I have some little bug that's throwing something off. I have no idea what it could be. If anyone could look over my code and give me any sort of hint, anything at all. I would be very happy.

Thanks

Code:

#include <iostream>
#include <vector>
#include <iterator>

using std::cout;
using std::endl;
using std::vector;

const int rowMoves [8] = {-2,-2, 1, 1, 2, 2, 1,-1};//Possible moves knight can make
const int colMoves [8] = {-1, 1,-2, 2, 1,-1,-2,-2};

int grid [8][8];  //The size of chessboard, keeps track of where I have been
					//I add a '1' if I've been there.

vector <int> pathRow; //vectors used to record moves
vector <int> pathCol;
int counter = 0;

bool ktour (int,int);
int display (); //Not part of logic, just displays at end.

int main (void) 
{	
	int row = 0;
	int col = 0;

	if (ktour (row, col));  //Calls ktour, which will run recursivly
	{
		cout << "done" << endl;
	}
	display();
	system ("pause");
	return 1;
}

bool ktour (int row, int col)
{
	pathRow.push_back (row);  //Starts off with adding move to vectors
	pathCol.push_back (col);
	grid [row] [col] = 1;		//adds a one to place in grid, so I can show I've been there
	counter++;

	if (pathRow.size() == 64)  //This drops the program out of the recursive, checks to see if vector is 64
		return true;			//needs to be 64 for 8 x 8, but I can only do 62.

	int possRow, possCol, moveOption;

	for (moveOption = 0; moveOption < 8; moveOption++) //Cycles through the 8 possible moves
	{
		possRow = row + rowMoves [moveOption];
		possCol = col + colMoves [moveOption];
		
		//The below if statement tries each of the 8 moves to see if its legal
		//If it finds a good move, it call the program again, sending the move location back to the top
		//where I can add to vector and start again.
		if (possRow < 8 && possRow >= 0 && possCol < 8 && possCol >= 0 && grid [possRow] [possCol] != 1)
		{
			if (ktour (possRow, possCol))  //recursion
				return true;
		}
	}

	//The below lines of code will be reached if all 8 moves have been tried, and all have failed
	//This code will attempt to back up my program, by returning false to lase stack and resetting counters
	grid [pathRow.back()][pathCol.back()] = 0;	//Dead end, set that spot back to 0
	pathRow.pop_back ();			//remove move history from vectors
	pathCol.pop_back ();
	counter--;
	return false;
}

int display () //Displays moves after program has solved.
{
        for (int index=0; index<(int)pathRow.size(); ++index)
		{	
			cout << "Move#: " << index+1 << " Square: ";
			cout << pathRow.at(index) << ", ";
			cout << pathCol.at(index);
			cout << endl;
		}
		return 1;
}

This line:

Code:

const int rowMoves [8] = {-2,-2, 1, 1, 2, 2, 1,-1};//Possible moves knight can make

lacks the symmetry you would expect out of a knight move listing.