Problem: Problem Statement

Let's consider operations on monochrome images that consist of hexagonal pixels, each of which is colored in either black or white. Because of the shape of pixels, each of them has exactly six neighbors (e.g. pixels that share an edge with it.)

"Filtering" is an operation to determine the color of a pixel from the colors of itself and its six neighbors. Examples of filterings are shown below.

Example 1: Color a pixel in white when all of its neighboring pixels are white. Otherwise the color will not change.

<image>

Performing this operation on all the pixels simultaneously results in "noise canceling," which removes isolated black pixels.

Example 2: Color a pixel in white when its all neighboring pixels are black. Otherwise the color will not change.

<image>

Performing this operation on all the pixels simultaneously results in "edge detection," which leaves only the edges of filled areas.

Example 3: Color a pixel with the color of the pixel just below it, ignoring any other neighbors.

<image>

Performing this operation on all the pixels simultaneously results in "shifting up" the whole image by one pixel.

Applying some filter, such as "noise canceling" and "edge detection," twice to any image yields the exactly same result as if they were applied only once. We call such filters idempotent. The "shifting up" filter is not idempotent since every repeated application shifts the image up by one pixel.

Your task is to determine whether the given filter is idempotent or not.

Input

The input consists of multiple datasets. The number of dataset is less than $100$. Each dataset is a string representing a filter and has the following format (without spaces between digits).

> $c_0c_1\cdots{}c_{127}$

$c_i$ is either '0' (represents black) or '1' (represents white), which indicates the output of the filter for a pixel when the binary representation of the pixel and its neighboring six pixels is $i$. The mapping from the pixels to the bits is as following:

<image>

and the binary representation $i$ is defined as $i = \sum_{j=0}^6{\mathit{bit}_j \times 2^j}$, where $\mathit{bit}_j$ is $0$ or $1$ if the corresponding pixel is in black or white, respectively. Note that the filter is applied on the center pixel, denoted as bit 3.

The input ends with a line that contains only a single "#".

Output

For each dataset, print "yes" in a line if the given filter is idempotent, or "no" otherwise (quotes are for clarity).

Sample Input


00000000111111110000000011111111000000001111111100000000111111110000000011111111000000001111111100000000111111110000000111111111
10000000111111110000000011111111000000001111111100000000111111110000000011111111000000001111111100000000111111110000000011111111
01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101


Output for the Sample Input


yes
yes
no





Example

Input

00000000111111110000000011111111000000001111111100000000111111110000000011111111000000001111111100000000111111110000000111111111
10000000111111110000000011111111000000001111111100000000111111110000000011111111000000001111111100000000111111110000000011111111
01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101
#


Output

yes
yes
no

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;

const int all = (1 << 7) - 1;

string c;

int t[5][5];
int u[3][3];

const int dx[] = { -1, 0, -1, 0, 1, 0, 1 };
const int dy[] = { -1, -1, 0, 0, 0, 1, 1 };

int calc1(int x, int y) {
	int val = 0;
	for (int i = 0; i < 7; i++) {
		val |= t[x + dx[i]][y + dy[i]] << i;
	}
	return c[val] - '0';
}

int calc2(int x, int y) {
	int val = 0;
	for (int i = 0; i < 7; i++) {
		val |= u[x + dx[i]][y + dy[i]] << i;
	}
	return c[val] - '0';
}

int main()
{
	while (cin >> c, c != "#") {
		bool ok = true;
		int off[] = { 0, 0, 0, 1, 2 };
		int cnt[] = { 3, 4, 5, 4, 3 };
		for (int i = 0; i < (1 << 19); i++) {
			for (int j = 0, k = 0, l = 0; j < 19; j++) {
				t[off[k] + l][k] = (i >> j) & 1;
				++l;
				if (l == cnt[k]) {
					l = 0;
					++k;
				}
			}
			bool flag = false;
			for (int x = 1; x < 4; x++) {
				for (int y = 1; y < 4; y++) {
					u[x - 1][y - 1] = calc1(x, y);
					if (u[x - 1][y - 1] != t[x][y]) {
						flag = true;
					}
				}
			}
			if (!flag) continue;
			if (calc2(1, 1) != u[1][1]) {
				ok = false;
			}
		}
		puts(ok ? "yes" : "no");
	}
	return 0;
}