#include<iostream> 
#include<vector>//1153马的周游问题：（优化基本思想）先搜索可行格较少的格子 
#include<algorithm> 
using namespace std;
const int SIZE = 65;
int visited[SIZE];
int route[SIZE];
int cnt_size[SIZE];
int dx[8] = {-1, -2, -2, -1, 1, 2, 2, 1};
int dy[8] = {-2, -1, 1, 2, -2, -1, 1, 2};
vector<int> neighbors[SIZE];//neighbors[i][j]记录的是马可以从i到j 

bool cmp(int x, int y)
{
return cnt_size[x] < cnt_size[y];
}

int get_child_size(int child)
{
int size = 0;
for(int i = 0; i < neighbors[child].size(); i++)
{
if(!visited[neighbors[child][i]])
    size++;
}
return size;
}

void get_children(int x, vector<int> &children)
{
    for(int i = 0; i < neighbors[x].size(); i++)
    {
        int child = neighbors[x][i];
        if(!visited[child])
        {
            children.push_back(child);
            cnt_size[child] = get_child_size(child);
        }
    }
    sort(children.begin(), children.end(), cmp);//排序，可行格较少的排在前面 
}

void print_route()
{
    for(int i = 1; i < SIZE - 1; i++)
        cout << route[i] << " ";
    cout << route[SIZE - 1] << endl;
}

bool dfs(int x, int depth)
{
    route[depth] = x;//route[]记录路径 
    if(depth == (SIZE - 1))
    {
        print_route();
        return true;
    }

    visited[x] = 1;

    vector<int> children;//存放x点的还未被visit的neighbors 

    get_children(x, children);

    for(int i = 0; i < children.size(); i++)
    {
        if(dfs(children[i], depth + 1))//如果某一个点可以继续搜下去，就返回true 
            return true;
        //如果不能继续搜下去，就搜索下一个children 
    }
    visited[x] = false;//如果这个点的所有children都搜索不下去，则回溯 
    return false;
}

int main()
{
    int start;//马的起点为start，范围是1到64 
    while(cin >> start && start != -1)
    {
    //初始化 
        for(int i = 0; i < SIZE; i++)
            visited[i] = 0;        
        for(int i = 0; i < SIZE; i++)
            neighbors[i].clear();

        for(int i = 1; i < SIZE; i++)
        {
            int row = (i + 7) / 8;//计算i点在第几行 
            int column = i - (row - 1)* 8;//计算i点在第几列 
            for(int j = 0; j < 8; j++)//对于每一个i点，计算出它的neighbors 
            {
                int nx = row + dx[j];
                int ny = column + dy[j];
                if(nx >= 1 && nx <= 8 && ny >=1 && ny <= 8)
                    neighbors[i].push_back((nx - 1) * 8 + ny);
            }
        }
        dfs(start, 1);
    }
    return 0;
}