import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;

/**
 * Created by Piotruś on 23.04.2017.
 */
public class Algorithms
{
	public static final int N = 3;
	public static final int c;
	HashMap<Pair<Integer, Integer>, ArrayList<Integer>> domain;
	public final ArrayList<Integer> colors;
	int[][] matrix;

	static
	{
		c = ((N % 2) == 0 ? 2 * N : 2 * N + 1);
	}
	{
		HashMap<Pair<Integer, Integer>, ArrayList<Integer>> d = new HashMap<>();
		colors = new ArrayList<>();
		for (int i = 1; i < c + 1; i++)
			colors.add(i);
		for (int i = 0; i < N; i++)
			for (int j = 0; j < N; j++)
			{
				d.put(new Pair<Integer, Integer>(i, j), new ArrayList<>(colors));
			}
		domain = d;
	}

	Algorithms()
	{
		matrix = new int[N][N];

	}

	public int backtracking(int[][] matrix, Pair<Integer, Integer> position, int acc, HashSet<HashSet<Integer>> edges)
	{
		for (Integer color : colors)
		{
			int[][] copy = matrix.clone();
			HashSet<HashSet<Integer>> edgesCopy = new HashSet<>(edges);
			if (constraintsOk(copy, position, color, edgesCopy))// ograniczenia
			{
				copy[position.getFirst()][position.getSecond()] = color;
				if (isFinished(copy))
				{
					acc += 1;
					continue;
				}
				acc = backtracking(copy, getNext(copy, position), acc, edgesCopy);
			}
		}
		return acc;
	}

	boolean isFinished(int[][] tab)
	{

		for (int i = 0; i < N; i++)
		{
			for (int j = 0; j < N; j++)
			{
				if (tab[i][j] == 0)
				{
					return false;
				}
			}
		}
		for (int i = 0; i < N; i++)
		{
			for (int j = 0; j < N; j++)
			{
				System.out.print(tab[i][j]+" ");
			}
			System.out.print("\n");
		}
		System.out.print("\n");
		return true;

	}

	Pair<Integer, Integer> getNext(int[][] matrix, Pair<Integer, Integer> pos)
	{
		if (pos.getSecond() == N - 1)
			return new Pair<Integer, Integer>(pos.getFirst() + 1, 0);
		else
			return new Pair<Integer, Integer>(pos.getFirst(), pos.getSecond() + 1);
	}

	boolean constraintsOk(int[][] matrix, Pair<Integer, Integer> pos, int color, HashSet<HashSet<Integer>> edges)
	{
		boolean flag = false;
		int x = pos.getFirst();
		int y = pos.getSecond();
		ArrayList<Pair<Integer, Integer>> neighbours = new ArrayList<>();
		if (y > 0)
			neighbours.add(new Pair<Integer, Integer>(x, y - 1));
		if (y < N - 1)
			neighbours.add(new Pair<Integer, Integer>(x, y + 1));
		if (x > 0)
			neighbours.add(new Pair<Integer, Integer>(x - 1, y));
		if (x < N - 1)
			neighbours.add(new Pair<Integer, Integer>(x + 1, y));
		HashSet<HashSet<Integer>> temp = new HashSet<>(edges);

		for (Pair<Integer, Integer> pair : neighbours)
		{
			if (matrix[pair.getFirst()][pair.getSecond()] != color
					&& (!temp.contains(new HashSet<>(Arrays.asList(color, matrix[pair.getFirst()][pair.getSecond()])))
							|| matrix[pair.getFirst()][pair.getSecond()] == 0))
			{
				flag = true;
				temp.add(new HashSet<>(Arrays.asList(color, matrix[pair.getFirst()][pair.getSecond()])));


			} else
			{
				flag = false;
				break;
			}
		}

		if (flag)
			edges.addAll(temp);
		return flag;
	}

	public static void main(String args[])
	{
		HashSet<HashSet<Integer>> edges = new HashSet<>();
		Algorithms alg = new Algorithms();
		System.out.println(alg.backtracking(alg.matrix, new Pair<Integer, Integer>(0, 0), 0, edges));
	}
}