Problem:
Problem B: Cleaning Robot

Dr. Asimov, a robotics researcher, loves to research, but hates houseworks and his house were really dirty. So, he has developed a cleaning robot.

As shown in the following figure, his house has 9 rooms, where each room is identified by an alphabet:

The robot he developed operates as follows:

If the battery runs down, the robot stops.

If not so, the robot chooses a direction from four cardinal points with the equal probability, and moves to the room in that direction. Then, the robot clean the room and consumes 1 point of the battery.

However, if there is no room in that direction, the robot does not move and remains the same room. In addition, there is a junk room in the house where the robot can not enter, and the robot also remains when it tries to enter the junk room. The robot also consumes 1 point of the battery when it remains the same place.

A battery charger for the robot is in a room. It would be convenient for Dr. Asimov if the robot stops at the battery room when its battery run down.

Your task is to write a program which computes the probability of the robot stopping at the battery room.

Input

The input consists of several datasets. Each dataset consists of:

n
s t b

n is an integer that indicates the initial battery point. s, t, b are alphabets respectively represent the room where the robot is initially, the battery room, and the junk room.

The input ends with a dataset which consists of single 0 for n. Your program should not output for this dataset.

Output

For each dataset, print the probability as a floating point number in a line. The answer may not have an error greater than 0.000001.

Constraints

Judge data includes at most 100 data sets.

n ≤ 15

s, t, b are distinct.

Sample Input

1
E A C
1
E B C
2
E A B
0

Output for the Sample Input

0.00000000
0.25000000
0.06250000

Solution in JAVA (judge verdict: Memory Limit Exceeded)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	static byte charger;
	static byte storeroom;
	static double probability;

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line = "";

		byte battery;
		byte start;

		while ((line = br.readLine()) != null && !line.isEmpty()) {
			if ((battery = Byte.parseByte(line)) == 0) {
				break;
			}

			line = br.readLine();
			start = (byte) (line.toCharArray()[0] - 'A');
			charger = (byte) (line.toCharArray()[2] - 'A');
			storeroom = (byte) (line.toCharArray()[4] - 'A');

			probability = 0;
			clean(start, battery, 1);
			System.out.println(probability);
		}
	}

	static void clean(byte current, int battery, double p) {
		if (battery == 0) {
			if (current == charger) {
				probability += p;
			}
			return;
		} else if (battery == 1) {
			boolean b = false;
			for (byte n : next(current)) {
				b |= (n != charger);
			}
			if (!b)
				return;
		} else {
			for (byte n : next(current)) {
				if (n < 0 || n == storeroom) {
					clean(current, battery - 1, p / 4);
				} else {
					clean(n, battery - 1, p / 4);
				}
			}
		}
	}

	static byte[] next(byte current) {
		// 東,西,南,北
		final byte nexts[][] = {//
		{ 1, -1, 3, -1 },// 0
				{ 2, 0, 4, -1 },// 1
				{ -1, 1, 5, -1 },// 2
				{ 4, -1, 6, 0 },// 3
				{ 5, 3, 7, 1 },// 4
				{ -1, 4, 8, 2 },// 5
				{ 7, -1, -1, 3 },// 6
				{ 8, 6, -1, 4 },// 7
				{ -1, 7, -1, 5 },// 8
		};

		byte[] result = null;

		switch (current) {
		case 0:
			result = nexts[0];
			break;
		case 1:
			result = nexts[1];
			break;
		case 2:
			result = nexts[2];
			break;
		case 3:
			result = nexts[3];
			break;
		case 4:
			result = nexts[4];
			break;
		case 5:
			result = nexts[5];
			break;
		case 6:
			result = nexts[6];
			break;
		case 7:
			result = nexts[7];
			break;
		case 8:
			result = nexts[8];
			break;
		}
		return result;
	}
}