Problem: After decades of fruitless efforts, one of the expedition teams of ITO (Intersolar Tourism Organization) finally found a planet that would surely provide one of the best tourist attractions within a ten light-year radius from our solar system. The most attractive feature of the planet, besides its comfortable gravity and calm weather, is the area called Mare Triangularis. Despite the name, the area is not covered with water but is a great plane. Its unique feature is that it is divided into equilateral triangular sections of the same size, called trigons. The trigons provide a unique impressive landscape, a must for tourism. It is no wonder the board of ITO decided to invest a vast amount on the planet.

Despite the expected secrecy of the staff, the Society of Astrogeology caught this information in no time, as always. They immediately sent their president's letter to the Institute of Science and Education of the Commonwealth Galactica claiming that authoritative academic inspections were to be completed before any commercial exploitation might damage the nature.

Fortunately, astrogeologists do not plan to practice all the possible inspections on all of the trigons; there are far too many of them. Inspections are planned only on some characteristic trigons and, for each of them, in one of twenty different scientific aspects.

To accelerate building this new tourist resort, ITO's construction machinery team has already succeeded in putting their brand-new invention in practical use. It is a rover vehicle of the shape of an icosahedron, a regular polyhedron with twenty faces of equilateral triangles. The machine is customized so that each of the twenty faces exactly fits each of the trigons. Controlling the high-tech gyromotor installed inside its body, the rover can roll onto one of the three trigons neighboring the one its bottom is on.

<image> |  Figure E.1: The Rover on Mare Triangularis
---

Each of the twenty faces has its own function. The set of equipments installed on the bottom face touching the ground can be applied to the trigon it is on. Of course, the rover was meant to accelerate construction of the luxury hotels to host rich interstellar travelers, but, changing the installed equipment sets, it can also be used to accelerate academic inspections.

You are the driver of this rover and are asked to move the vehicle onto the trigon specified by the leader of the scientific commission with the smallest possible steps. What makes your task more difficult is that the designated face installed with the appropriate set of equipments has to be the bottom. The direction of the rover does not matter.

<image> |  <image> |  Figure E.2:The Coordinate System  |  Figure E.3: Face Numbering
---|---

The trigons of Mare Triangularis are given two-dimensional coordinates as shown in Figure E.2. Like maps used for the Earth, the x axis is from the west to the east, and the y axis is from the south to the north. Note that all the trigons with its coordinates (x , y) has neighboring trigons with coordinates (x - 1 , y) and (x + 1 , y). In addition to these, when x + y is even, it has a neighbor (x , y + 1); otherwise, that is, when x + y is odd, it has a neighbor (x , y - 1).

Figure E.3 shows a development of the skin of the rover. The top face of the development makes the exterior. That is, if the numbers on faces of the development were actually marked on the faces of the rover, they should been readable from its outside. These numbers are used to identify the faces.

When you start the rover, it is on the trigon (0,0) and the face 0 is touching the ground. The rover is placed so that rolling towards north onto the trigon (0,1) makes the face numbered 5 to be at the bottom.

As your first step, you can choose one of the three adjacent trigons, namely those with coordinates (-1,0), (1,0), and (0,1), to visit. The bottom will be the face numbered 4, 1, and 5, respectively. If you choose to go to (1,0) in the first rolling step, the second step can bring the rover to either of (0,0), (2,0), or (1,-1). The bottom face will be either of 0, 6, or 2, correspondingly. The rover may visit any of the trigons twice or more, including the start and the goal trigons, when appropriate.

The theoretical design section of ITO showed that the rover can reach any goal trigon on the specified bottom face within a finite number of steps.



Input

The input consists of a number of datasets. The number of datasets does not exceed 50.

Each of the datasets has three integers x, y, and n in one line, separated by a space. Here, (x,y) specifies the coordinates of the trigon to which you have to move the rover, and n specifies the face that should be at the bottom.

The end of the input is indicated by a line containing three zeros.

Output

The output for each dataset should be a line containing a single integer that gives the minimum number of steps required to set the rover on the specified trigon with the specified face touching the ground. No other characters should appear in the output.

You can assume that the maximum number of required steps does not exceed 100. Mare Triangularis is broad enough so that any of its edges cannot be reached within that number of steps.

Example

Input

0 0 1
3 5 2
-4 1 3
13 -13 2
-32 15 9
-50 50 0
0 0 0


Output

6
10
9
30
47
100

Solution (in CPP):

Solution:
#include <iostream>
#include <queue>
#include <map>
#include <cassert>

/* development:
 *     /\  /\  /\  /\  /\
 *    / 0\/ 1\/ 2\/ 3\/ 4\
 *    --------------------
 *   /\ 5/\ 6/\ 7/\ 8/\ 9/
 *  /10\/11\/12\/13\/14\/
 *  --------------------
 *  \15/\16/\17/\18/\19/
 *   \/  \/  \/  \/  \/
 *
 * roll / direction (top view)
 *   direction = 0:   direction = 1:
 *     1 /\ 0             0
 *      /xx\             ----
 *      ----             \xx/
 *        2             1 \/ 2
 */

using namespace std;
typedef pair<int, int> pii;

class Dice20 {

private:
	struct Face3 {
		int index[3];
		Face3(int f = -1, int s = -1, int t = -1){
			index[0] = f; index[1] = s; index[2] = t;
		}
		void rotate(){
			int tmp = index[0];
			index[0] = index[1];
			index[1] = index[2];
			index[2] = tmp;
		}
	};
	static Face3 TABLE[3][20][20];
	static bool s_initialized;
	static void init_table(int t, int f1, int f2, int f3){
		Face3 f(f1, f2, f3);
		for(int i = 0; i < 3; ++i){
			for(int j = 0; j < 3; ++j){
				TABLE[j][t][f.index[j]] = f;
			}
			f.rotate();
		}
	}


public:
	int dir, top, first;

	Dice20(int d, int t, int f) : dir(d), top(t), first(f) {
		if(!s_initialized){
			s_initialized = true;
			for(int i = 0; i < 5; ++i){
				// 0 - 4
				init_table(i, (i + 1) % 5, (i + 4) % 5, i + 5);
				// 5 - 9
				init_table(i + 5, i, i + 10, 10 + (i + 1) % 5);
				// 10 - 14
				init_table(i + 10, i + 5, 5 + (i + 4) % 5, i + 15);
				// 15 - 19
				init_table(i + 15, i + 10, 15 + (i + 4) % 5, 15 + (i + 1) % 5);
			}
		}
	}

	void roll(int f){
		const Face3 &cur = TABLE[0][top][first];
		const Face3 &next = TABLE[(f + 1 + dir) % 3][cur.index[f]][top];
		top = cur.index[f];
		first = next.index[0];
		dir = 1 - dir;
	}
	int neighbor(int f){ return TABLE[0][top][first].index[f]; }

};

Dice20::Face3 Dice20::TABLE[3][20][20];
bool Dice20::s_initialized = false;

const int dx[2][3] = { { -1, 1, 0 }, { 0, 1, -1 } };
const int dy[2][3] = { { 0, 0, -1 }, { 1, 0, 0 } };
const int INF = 1000000000;

struct Entry {
	int x, y, top, first;
	Entry(int x, int y, int t, int f) : x(x), y(y), top(t), first(f) { }
};

int mindist[201][201][20][20];

int main(){
	for(int i = 0; i < 201; ++i){
		for(int j = 0; j < 201; ++j){
			for(int k = 0; k < 20; ++k){
				for(int l = 0; l < 20; ++l){ mindist[i][j][k][l] = INF; }
			}
		}
	}
	mindist[100][100][0][5] = 0;
	queue<Entry> q;
	q.push(Entry(100, 100, 0, 5));
	while(!q.empty()){
		Entry e = q.front();
		q.pop();
		int curcost = mindist[e.y][e.x][e.top][e.first];
		int dir = 1 - ((e.x + e.y) & 1);
		for(int i = 0; i < 3; ++i){
			Dice20 dice(dir, e.top, e.first);
			dice.roll(i);
			int nx = e.x + dx[dir][i], ny = e.y + dy[dir][i];
			int nt = dice.top, nf = dice.first;
			if(curcost < 100 && mindist[ny][nx][nt][nf] == INF){
				mindist[ny][nx][nt][nf] = curcost + 1;
				q.push(Entry(nx, ny, nt, nf));
			}
		}
	}
	while(true){
		int gx, gy, gt;
		cin >> gx >> gy >> gt;
		if(gx == 0 && gy == 0 && gt == 0){ break; }
		gx += 100; gy += 100;
		int answer = INF;
		for(int i = 0; i < 20; ++i){
			answer = min(answer, mindist[gy][gx][gt][i]);
		}
		cout << answer << endl;
	}
	return 0;
}