Problem: The goal of the 15 puzzle problem is to complete pieces on $4 \times 4$ cells where one of the cells is empty space.

In this problem, the space is represented by 0 and pieces are represented by integers from 1 to 15 as shown below.


1 2 3 4
6 7 8 0
5 10 11 12
9 13 14 15


You can move a piece toward the empty space at one step. Your goal is to make the pieces the following configuration in the shortest move (fewest steps).


1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0


Write a program which reads an initial state of the puzzle and prints the fewest steps to solve the puzzle.

Constraints

* The given puzzle is solvable in at most 45 steps.

Input

The $4 \times 4$ integers denoting the pieces or space are given.

Output

Print the fewest steps in a line.

Example

Input

1 2 3 4
6 7 8 0
5 10 11 12
9 13 14 15


Output

8

Solution (in CPP):

Solution:
#include <cstdio>           // printf(), scanf()
#include <cstdlib>          // abs()
#include <string>
#include <algorithm>        // max(), min(), swap()

using namespace std;
static const int N = 4;
static const int N2 = 16;
static const int LIMIT = 100;

struct puzzle
{
	int f[N2];
	int space;
	int MD;
};

puzzle state;
int limit;
int path[LIMIT];
int MDT[N2][N2];

int
get_all_MD(puzzle pz)
{
	int sum = 0;
	for (int i = 0; i < N2; ++i)
	{
		if (pz.f[i] != N2)
			sum += MDT[i][pz.f[i] - 1];
	}

	return sum;
}

bool
is_solved()
{
	for (int i = 0; i < N2; ++i)
	{
		if (state.f[i] != i + 1)
			return false;
	}

	return true;
}

static const int dx[4] = {-1, 0, 1, 0};
static const int dy[4] = {0, -1, 0, 1};
static const char dir[4] = {'u', 'l', 'd', 'r'};

bool
dfs(int depth, int prev)
{
	puzzle u;

	if (state.MD == 0)
		return true;

	/* ?????¨?????±???????????\??????????????£??????????¶?????????¶???????¶?????????????????????? */
	if (depth + state.MD > limit)
		return false;

	int sx = state.space / N;
	int sy = state.space % N;
	for (int r = 0; r < 4; ++r)
	{
		int tx = sx + dx[r];
		int ty = sy + dy[r];
		if (tx < 0 || N <= tx || ty < 0 || N <= ty || (max(prev, r) - min(prev, r) == 2))
			continue;

		u = state;
		/* ???????????????????????¢?????????????¨???????????????????????????????????????? */
		int s = sx * N + sy;
		int t = tx * N + ty;
		state.MD -= MDT[t][state.f[t] - 1];
		state.MD += MDT[s][state.f[t] - 1];
		swap(state.f[t], state.f[s]);
		state.space = t;
		if (dfs(depth + 1, r))
		{
			path[depth] = r;
			return true;
		}

		state = u;
	}

	return false;
}

/* ????????±??? */
string
iterative_deepening(puzzle in)
{
	in.MD = get_all_MD(in); /* ????????????????????????????????¢ */
	for (limit = in.MD; limit <= LIMIT; ++limit)
	{
		state = in;
		if (dfs(0, -100))
		{
			string ans = "";
			for (int i = 0; i < limit; ++i)
				ans += dir[path[i]];

			return ans;
		}
	}

	return "unsolvable";
}

int
main(int argc, char** argv)
{
	puzzle in;

	for (int i = 0; i < N2; ++i)
	{
		for (int j = 0; j < N2; ++j)
			MDT[i][j] = abs(i / N - j / N) + abs(i % N - j % N);
	}

	for (int i = 0; i < N2; ++i)
	{
		scanf("%d", &in.f[i]);
		if (in.f[i] == 0)
		{
			in.f[i] = N2;
			in.space = i;
		}
	}

	string ans = iterative_deepening(in);
	printf("%lu\n", ans.size());
	return 0;
}