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 <stdio.h>
#include <algorithm>
#include <string>

const int N = 4;
const int N2 = 16;
const int LIMIT = 100;

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

int mdt[N2][N2];
int path[LIMIT];

struct Puzzle
{
	int f[N2];
	int space;
	int md;
};

Puzzle state;
int limit;

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

int getAllmd(const Puzzle& in)
{
	int sum = 0;
	for (int i = 0; i < N2; i++)
	{
		if (in.f[i] == N2)
			continue;
		sum += mdt[i][in.f[i] - 1];
	}
	return sum;
}

bool dfs(int depth, int prev)
{
	if (state.md == 0)
		return true;
	if (depth + state.md > limit)
		return false;

	int sx = state.space / N;
	int sy = state.space % N;
	Puzzle tmp;

	for (int r = 0; r < 4; r++)
	{
		int tx = sx + dx[r];
		int ty = sy + dy[r];
		if (tx < 0 || ty < 0 || tx >= N || ty >= N)
			continue;
		if (std::max(prev, r) - std::min(prev, r) == 2)
			continue;

		tmp = state;
		state.md -= mdt[tx * N + ty][state.f[tx * N + ty] - 1];
		state.md += mdt[sx * N + sy][state.f[tx * N + ty] - 1];
		std::swap(state.f[tx * N + ty], state.f[sx * N + sy]);
		state.space = tx * N + ty;
		if (dfs(depth + 1, r))
		{
			path[depth] = r;
			return true;
		}
		state = tmp;
	}
	return false;
}

std::string iterative_deepening(Puzzle in)
{
	in.md = getAllmd(in);
	for (limit = in.md; limit <= LIMIT; limit++)
	{
		state = in;
		if (dfs(0, -100))
		{
			std::string ans;
			for (int i = 0; i < limit; i++)
				ans += dir[path[i]];
			return ans;
		}
	}

	return "unsolvable";
}

int main()
{
	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);

	Puzzle in;

	for (int i = 0; i < N2; i++)
	{
		scanf("%d", &in.f[i]);
		if (in.f[i] == 0)
		{
			in.f[i] = N2;
			in.space = i;
		}
	}
	std::string ans = iterative_deepening(in);
	printf("%d\n", (int)ans.length());

	return 0;
}