#include <iostream>
#include <map>
#include <stack>
#include <vector>
#include <cstring>
using namespace std;
typedef struct Coordinate {
    int x;
    int y;
} Coor;
bool visited[31];
int loc[9][10]; //此在5*6格子数组中添加额外的行和列，拓展为9*10的数组，即设置边界，便于找到可以前进的节点 
map<int, Coor> coors; //用于记录每个位置的坐标 

//获得可以前进的节点，即符合“日”字形，且未访问过 
vector<int> getAdjacents(int i, int j) {
    vector<int> result;
    if (loc[i-2][j-1] != 0 && visited[loc[i-2][j-1]] == false)
       result.push_back(loc[i-2][j-1]);
    if (loc[i-2][j+1] != 0 && visited[loc[i-2][j+1]] == false)
       result.push_back(loc[i-2][j+1]); 
    if (loc[i-1][j-2] != 0 && visited[loc[i-1][j-2]] == false)
       result.push_back(loc[i-1][j-2]);
    if (loc[i-1][j+2] != 0 && visited[loc[i-1][j+2]] == false)
       result.push_back(loc[i-1][j+2]);
    if (loc[i+1][j-2] != 0 && visited[loc[i+1][j-2]] == false)
       result.push_back(loc[i+1][j-2]);
    if (loc[i+1][j+2] != 0 && visited[loc[i+1][j+2]] == false)
       result.push_back(loc[i+1][j+2]);
    if (loc[i+2][j-1] != 0 && visited[loc[i+2][j-1]] == false)
       result.push_back(loc[i+2][j-1]);
    if (loc[i+2][j+1] != 0 && visited[loc[i+2][j+1]] == false)
       result.push_back(loc[i+2][j+1]);
    return result;
}

void search(int start, int &steps, stack<int> &road) {
     vector<int> adjacents = getAdjacents(coors[start].x, coors[start].y);
     //当没有可以走的下一个格子时 
     if (adjacents.size() == 0) {
        //如果已经走了29步，此时需要检测是否已经走完了所有节点 
        if (steps == 29) {
           bool complete = true;
           for (int j = 1; j <= 30; j++) {
               if (visited[j] == false) {
                  complete = false;
                  break;
               }
           }
           //是，则回溯输出依次经过的节点 
           if (complete == true) {
               vector<int> result;
               while(!road.empty()) {
                   result.push_back(road.top());
                   road.pop();
               }
               for (int j = result.size()-1; j >= 0; j--)
                   cout << result[j] << " ";
               cout << endl;
           } else {
              //否，则在保留已经经过了的节点的栈中删除该节点，同时使步数减一和设置该节点未访问过来使的可以
              //通过其他节点到达该节点 
              visited[road.top()] = false;
              steps--;
              road.pop();
           }
        } else {
              //未达到上限的29步，则直接保留已经经过了的节点的栈中删除该节点，同时使步数减一和设置该节点未访问过来使的可以
              //通过其他节点到达该节点
              visited[road.top()] = false;
              steps--;
              road.pop();
        }
     } else {
          //当前节点存在相邻的可以走的节点，则依次深搜遍历相邻节点 
          for (int i = 0; i < adjacents.size(); i++) {
              visited[adjacents[i]] = true;
              steps++;
              road.push(adjacents[i]);
              search(road.top(), steps, road);
          }
          //刚开始这里未加 !road.empty()，出现runtime error的错误，因为在找到该路径之后，即上面
          //的for循环跳出之后，此时road已经为空了，所以如果未判断!road.empty会是空的road调用 
          //此步是解决本题的关键，即当遍历完一个节点的所有相邻节点后，如果既没有达到遍历完所有节点，即!road.empty
          //相邻节点也没有一个进栈的，即均不合格，则此时应该回溯，将该栈顶节点出栈，同时设置为未访问过，步数减一 
          if (!road.empty() && road.top() == start) {
              visited[road.top()] = false;
              steps--;
              road.pop();
          }
     }
}

int main() {
    memset(loc, 0, sizeof(loc));
    int value = 1;
    for (int i = 2; i <= 6; i++) {
        for (int j = 2; j <= 7; j++) {
            coors[value].x = i;
            coors[value].y = j;
            loc[i][j] = value++;
        }
    }
    
    int start;
    while (cin>>start&&start!=-1) {
          memset(visited, false, sizeof(visited));
          int steps = 0;
          stack<int> road;
          road.push(start);
          visited[road.top()] = true;
          search(road.top(), steps, road);
    }
    return 0;
}