from PIL import Image
import numpy


def ratio_similarity(b_img1, b_img2):

	r = b_img1.shape[0]
	c = b_img1.shape[1]

	dmat = numpy.zeros((r, c), dtype=float)

	for i in range(r):
		for j in range(c):
			dmat[i][j] = abs(float(b_img1[i][j])-float(b_img2[i][j]))

	return 1-numpy.sum(dmat)/(r*c)



def calc_diff(fig1, fig2):

	fig1 = numpy.array(fig1)
	fig2 = numpy.array(fig2)

	diff = numpy.sum((fig1.astype("float")-fig2_arr.astype("float"))**2)
	diff = diff/(float(fig1.shape[0]*fig1.shape[1]))
	
	return diff*100


def ratio_bw(fig1, fig2):
	fig1 = generate_bw_image(fig1)
	fig2 = generate_bw_image(fig2)
	


	fig1 = fig1.reshape(fig1.shape[0] * fig1.shape[1])
	fig2 = fig2.reshape(fig2.shape[0] * fig2.shape[1])

	ratio1 = ratio2 = 0

	for i in fig1:
		if i==1:
			ratio1+=1

	for i in fig2:
		if i==1:
			ratio2+=1

	return ratio2/ratio1


def generate_bw_image(fig):
	fig_gray = fig.convert('L')
	fig_bw = numpy.asarray(fig_gray).copy()
	fig_bw[fig_bw<128] = 1
	fig_bw[fig_bw>=128] = 0

	return fig_bw

def find_diff(fig1, fig2):
	r = fig1.shape[0]
	c = fig2.shape[1]

	diff_mat = numpy.zeros((r, c), dtype=float)

	for i in range(r):
		for j in range(c):
			diff_mat[i][j] = abs(float(fig1[i][j])-float(fig2[i][j]))
	return diff_mat


def pixel_ratio(fig1, fig2):
	return numpy.sum(fig1)/numpy.sum(fig2)


def check_black_pixel(fig1, fig2):
	return numpy.sum(fig1)>numpy.sum(fig2)


def axis_translation(fig1, fig2):
	r = fig1.shape[0]
	c = fig1.shape[1]

	fig1_0 = numpy.zeros((r, c), dtype=float)
	
	for r_i, rr in enumerate(fig1_0):
		for c_i in range(c//2):
			if c_i < c//2:
				rr[c_i], rr[c_i+(c//2)] = fig1[r_i][c_i+(c//2)], fig1[r_i][c_i]
	
	if ratio_similarity(fig1_0, fig2) > 0.90:
		return '0'

	f1 = len(fig1)//2
	fig1_1 = fig1[f1:]+fig1[:f1]

	if ratio_similarity(fig1_1, fig2) > 0.90:
		return '1'

	return False


def get_translation(fig, axis):
	if axis == '1':
		f = len(fig)//2
		fig_1 = fig[f:]+fig[:f]
		trans = fig_1
	else:
		r = fig.shape[0]
		c = fig.shape[1]

		fig_0 = numpy.zeros((r, c), dtype=float)

		for r_i, rr in enumerate(fig_0):
			for c_i in range(c//2):
				if c_i < c//2:
					rr[c_i] = fig[r_i][c_i+c//2]
					rr[c_i+c//2] = fig[r_i][c_i]
		
		trans = fig_0

	return trans


def get_xor3(imgs):
	r = imgs[0].shape[0]
	c = imgs[0].shape[1]

	mat = numpy.zeros((r, c), dtype=float)

	for i in range(r):
		for j in range(c):
			if (imgs[0][i][j] == 0 and imgs[1][i][j] == 0 and imgs[2][i][j] == 0) or (imgs[0][i][j] == 1 and imgs[1][i][j] == 1 and imgs[2][i][j] == 1):
				mat[i][j] = 0
			else:
				mat[i][j] = 1

	return mat


def count_pixels(img):
	r = img.shape[0]
	c = img.shape[1]

	v = numpy.zeros((r, c), dtype=float)
	cc = numpy.sum(v)

	for i in range(r):
		for j in range(c):
			if img[i][j] == 0 and v[i][j] == 0:
				depth_first(img, i, j, v)
				return abs(cc - numpy.sum(v))
	return -1


def safe(img, i, j, v):
	if i >= 0 and i < img.shape[0]:
		if j >= 0 and j < img.shape[1]:
			if img[i][j] == 0 and v[i][j] == 0:
				return True
	return False


def depth_first(img, i, j, v):
	v[i][j] = 1

	r = [-1, -1, -1, 0, 0, 1, 1, 1]
	c = [-1, 0, 1, -1, 1, -1, 0, 1]

	for k in range(len(r)):
		if safe(img, i + r[k], j + c[k], v):
			depth_first(img, i + r[k], j + c[k], v)


def count_islands(img):
	r = img.shape[0]
	c = img.shape[1]

	v = numpy.zeros((r, c), dtype=float)
	count = 0

	for i in range(r):
		for j in range(c):
			if img[i][j] == 0 and v[i][j] == 0:
				depth_first(img, i, j, v)
				count += 1
	return count


def row_count(img1, img2, img3):
	islands = [count_islands(img1), count_islands(img2) , count_islands(img3)].sort()

	if abs(islands[0]-islands[1]) == abs(islands[1]-islands[2]):
		return abs(islands[0] - islands[1])
	return -1


def get_or(img1, img2):
	r = img1.shape[0]
	c = img1.shape[1]

	mat = numpy.zeros((r, c), dtype=float)
	for i in range(r):
		for j in range(c):
			if img1[i][j] == 1 and img2[i][j] == 1:
				mat[i][j] = 1
	return mat


def _or(img1, img2, img3):
	mat = get_or(img1, img2)

	if ratio_similarity(mat, img3) > 0.96:
		return True
	
	return False


def get_and(img1, img2):
	r = img1.shape[0]
	c = img1.shape[1]

	mat = numpy.zeros((r, c), dtype=float)
	for i in range(r):
		for j in range(c):
			if img1[i][j] == 1 or img2[i][j] == 1:
				mat[i][j] = 1
	return mat


def _and(img1, img2, img3):
	mat = get_and(img1, img2)

	if ratio_similarity(mat, img3) > 0.91:
		return True
	
	return False


def get_xor(img1, img2):
	r = img1.shape[0]
	c = img1.shape[1]

	mat = numpy.zeros((r, c), dtype=float)
	for i in range(r):
		for j in range(c):
			if (img1[i][j] == 1 and img2[i][j] == 1) or (img1[i][j] == 0 and img2[i][j] == 0):
				mat[i][j] = 1
			else:
				mat[i][j] = 0
	return mat


def xor(img1, img2, img3):
	mat = get_xor(img1, img2)
	
	if ratio_similarity(mat, img3) > 0.965:
		return True
	
	return False


def get_top_bottom(img1, img2):
	r = img1.shape[0]
	c = img1.shape[1]

	mat = numpy.zeros((r, c), dtype=float)
	for i in range(r):
		for j in range(c):
			if i <= r/2:
				mat[i][j] = img1[i][j]
			else:
				mat[i][j] = img2[i][j]

	return mat


def top_bottom(img1, img2, img3):
	mat = get_top_bottom(img1, img2)
	if ratio_similarity(mat, img3) > 0.966:
		return True
	return False


def pixel_diff(img1, img2, img3):
	img3_pix = (img3.shape[0]*img3.shape[1])-int(numpy.sum(img3))
	img1_2_diff = abs(((img1.shape[0]*img1.shape[1])-int(numpy.sum(img1)))-((img2.shape[0]*img2.shape[1])-int(numpy.sum(img2))))
	
	s, b = img1_2_diff, img3_pix

	if img1_2_diff > img3_pix:
		s, b = b, s

	if 1-((b-s)/b) > 0.97:
		return True
























































































class Agent:

	def __init__(self):
		self.data = {}
		self.choices = {}

	def fetch_data(self, problem):

		for n, fig in problem.figures.items():
			img = Image.open(fig.visualFilename).convert("L")

			b_img = numpy.array(img, dtype=numpy.uint8)

			for i in range(b_img.shape[0]):
				for j in range(b_img.shape[1]):
					b_img[i][j] = b_img[i][j]/255


			if n.isdigit():
				self.choices[n] = (fig, img, b_img)
			else:
				self.data[n] = (fig, img, b_img)

	def no_change_2(self, img1_l, img2_l, img3_l):

		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]
		img3 = self.data[img3_l][2]

		if ratio_similarity(img1, img2) > 0.97:
			o_i = None
			o_s = 0

			for i, (choice, choice_img, b_img) in self.choices.items():
				os = ratio_similarity(img3, b_img)

				if not o_s or os > o_s:
					o_i = i
					o_s = os

			if o_s > 0.97:
				return int(o_i)

		return -1

	def reflection(self, img1_l, img2_l, img3_l):

		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]
		img3 = self.data[img3_l][2]


		if ratio_similarity(numpy.fliplr(img1), img2) > 0.97:
			axis = "1"
		elif ratio_similarity(numpy.flipud(img1), img2) > 0.97:
			axis = "0"
		else:
			axis = False

		if axis:
			o_i = None
			o_s = 0
			for i, (choice, choice_img, b_img) in self.choices.items():

				if axis == '1':
					os = ratio_similarity(numpy.fliplr(img3), b_img)
				else:
					os = ratio_similarity(numpy.flipud(img3), b_img)


				if not o_s or os > o_s:
					o_i = i
					o_s = os

			if o_s > 0.97:
				return int(o_i)
		return -1

	def rotation(self, img1_l, img2_l, img3_l):

		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]
		img3 = self.data[img3_l][2]
		
		for k in range(4):
			if ratio_similarity(numpy.rot90(img1, k), img2) > 0.97:
				angle = 90*k
			else:
				angle = -1

		if angle >= 0:
			o_i = None
			o_s = 0
			for i, (choice, choice_img, b_img) in self.choices.items():

				os =  ratio_similarity(numpy.rot90(img3, (angle/90)), b_img)

				if not o_s or os > o_s:
					o_i = i
					o_s = os

			if o_s > 0.97:
				return int(o_i)
		return -1

	def subtraction(self, img1_l, img2_l, img3_l):

		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]
		img3 = self.data[img3_l][2]

		diff1 = find_diff(img1, img2)
		s_s = None
		s_i = -1

		for i, (choice, choice_img, b_img) in self.choices.items():

			diff2 = find_diff(img3, b_img)
			s = ratio_similarity(diff1, diff2)

			if not s_s or s > s_s:
				s_s = s
				s_i = i

		if s_s > 0.95:
			return int(s_i)

		return -1


























	def solve_2(self):

		ss = self.no_change_2('A', 'B', 'C')
		if ss > 0:
			return ss
		ss = self.no_change_2('A', 'C', 'B')
		if ss > 0:
			return ss
		ss = self.reflection('A', 'B', 'C')
		if ss > 0:
			return ss
		ss = self.reflection('A', 'C', 'B')
		if ss > 0:
			return ss
		ss = self.rotation('A', 'B', 'C')
		if ss > 0:
			return ss
		ss = self.rotation('A', 'C', 'B')
		if ss > 0:
			return ss
		ss = self.subtraction('A', 'B', 'C')
		if ss > 0:
			return ss
		ss = self.subtraction('A', 'C', 'B')
		if ss > 0:
			return ss



		b_r = o_i = o_img = None
		ratio_bw_1 = ratio_bw(self.data['A'][1], self.data['B'][1])
		ratio_bw_2 = ratio_bw(self.data['A'][1], self.data['C'][1])

		for i, (choice, choice_img, b_img) in self.choices.items():
			ratio_bw_0 = ratio_bw(self.data['C'][1], choice_img)
			
			if not b_r:
				b_r = abs(ratio_bw_0-ratio_bw_1)
				o_i = i
				o_img = choice_img
			
			if abs(ratio_bw_0-ratio_bw_1) < b_r:
				b_r = abs(ratio_bw_0-ratio_bw_1)
				o_i = i
				o_img = choice_img
			
			ratio_bw_0 = ratio_bw(self.data['B'][1], choice_img)

			if abs(ratio_bw_0-ratio_bw_2) < b_r:
				b_r = abs(ratio_bw_0-ratio_bw_2)
				o_i = i
				o_img = choice_img


		if b_r < 0.25:
			ratio_a_b = ratio_bw(self.data['C'][1], o_img)
			ratio_a_c = ratio_bw(self.data['B'][1], o_img)

			if abs(ratio_a_b - ratio_bw_1) > 0.25 and abs(ratio_a_c - ratio_bw_2) > 0.25:
				return -1

			return int(o_i)

		return -1

	def no_change_3(self, img1_l, img2_l, img3_l, img4_l):

		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]
		img3 = self.data[img3_l][2]
		img4 = self.data[img4_l][2]

		if ratio_similarity(img1, img2) > 0.97:
			if ratio_similarity(img2, img3) > 0.97:
				o_i = None
				o_s = 0

				for i, (choice, choice_img, b_img) in self.choices.items():
					os = ratio_similarity(img4, b_img)

					if not o_s or os > o_s:
						o_i = i
						o_s = os

				if o_s > 0.91:
					return int(o_i)
		return -1

	def no_change_diag(self, img1_l, img2_l):

		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]

		if ratio_similarity(img1, img2) > 0.97:
			o_i, o_s = None, 0

			for i, (choice, choice_img, b_img) in self.choices.items():
				os = ratio_similarity(img2, b_img)

				if not o_s or os > o_s:
					o_i = i
					o_s = os

			if o_s > 0.91:
				return int(o_i)
		return -1


	def pixel_ratio_3(self, img1_l, img2_l, img3_l, img4_l, img5_l):

		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]
		img3 = self.data[img3_l][2]
		img4 = self.data[img4_l][2]
		img5 = self.data[img5_l][2]

		pr1 = pixel_ratio(img1, img2)
		pr2 = pixel_ratio(img2, img3)

		prs = min(pr1, pr2)/max(pr1, pr2)

		if prs > 0.95:
			pr4 = pixel_ratio(img4, img5)
			p_s = None
			p_i = -1
			
			for i, (choice, choice_img, b_img) in self.choices.items():
				pr_5 = pixel_ratio(img5, b_img)
				pr_s = min(pr_5, pr4) / max(pr4, pr_5)
				if not p_s or pr_s > p_s:
					p_s = pr_s
					p_i = i
			if p_s > 0.95:
				return int(p_i)
		return -1

	def pixel_ratio_3_r(self, img1_l, img2_l, img3_l, img4_l):

		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]
		img3 = self.data[img3_l][2]
		img4 = self.data[img4_l][2]

		pr1 = pixel_ratio(img1, img2)
		pr3 = pixel_ratio(img3, img4)

		prs = min(pr1, pr3)/max(pr1, pr3)

		if prs > 0.95:
			p_s = None
			p_i = -1
			
			for i, (choice, choice_img, b_img) in self.choices.items():
				pr_5 = pixel_ratio(img4, b_img)
				pr_s = min(pr_5, pr1)/max(pr1, pr_5)
				
				if not p_s or pr_s > p_s:
					p_s = pr_s
					p_i = i
			if p_s > 0.95:
				return int(p_i)
		return -1

	def pixel_ratio_3_d(self, img1_l, img2_l):
		
		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]

		pr1 = pixel_ratio(img1, img2)
		p_sd = None
		p_i = -1
		
		for i, (choice, choice_img, b_img) in self.choices.items():
			prd = pixel_ratio(img2, b_img)
			prs = min(prd, pr1)/max(pr1, prd)
			if not p_sd or prs > p_sd:
				p_sd = prs
				p_i = i
		return int(p_i)

	def pixels_black_r(self, img1_l, img2_l, img3_l, img4_l):

		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]
		img3 = self.data[img3_l][2]
		img4 = self.data[img4_l][2]

		if check_black_pixel(img1, img2):
			if check_black_pixel(img3, img4):
				choices = []
				bps2 = numpy.sum(img2)
				bps4 = numpy.sum(img4)

				for i, (choice, choice_img, b_img) in self.choices.items():
					bps = numpy.sum(b_img)
					if bps < bps2 and bps < bps4:
						choices.append(i)
				
				if len(choices) == 1:
					return int(choices[0])
		return -1

	def pixels_black(self, img1_l, img2_l, img3_l, img4_l, img5_l):

		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]
		img3 = self.data[img3_l][2]
		img4 = self.data[img4_l][2]
		img5 = self.data[img5_l][2]

		if check_black_pixel(img1, img2):
			if check_black_pixel(img2, img3):
				if check_black_pixel(img4, img5):
					choices = []
					bps2 = numpy.sum(img2)
					bps5 = numpy.sum(img5)
					for i, (choice, choice_img, b_img) in self.choices.items():
						bps = numpy.sum(b_img)
						if bps < bps2 and bps < bps5:
							choices.append(i)
					if len(choices) == 1:
						return int(choices[0])
		return -1

	def translation(self, img1_l, img2_l, img3_l, img4_l, img5_l):

		img1 = self.data[img1_l][2]
		img2 = self.data[img2_l][2]
		img3 = self.data[img3_l][2]
		img4 = self.data[img4_l][2]
		img5 = self.data[img5_l][2]

		axis1 =  axis_translation(img1, img2)
		axis2 =  axis_translation(img3, img4)

		if axis1 and axis1 == axis2:
			t_s = None
			t_i = -1

			for i, (choice, choice_img, b_img) in self.choices.items():
				ts = ratio_similarity(img5, get_translation(b_img, axis1))

				if not t_s or ts > t_s:
					t_s = ts
					t_i = i
			if t_s >= 0.90:
				return int(t_i)
		return -1

	def xor3(self, row1, row2, row3):
		row1 = get_xor3(row1)
		row2 = get_xor3(row2)

		if ratio_similarity(row1, row2) > 0.97:
			x3_s = None
			x3_i = -1

			for i, (choice, choice_img, b_img) in self.choices.items():
				os = ratio_similarity(get_xor3(row3 + [b_img]), row2)

				if not x3_s or os > x3_s:
					x3_s = os
					x3_i = i
			if x3_s >= 0.95:
				return int(x3_i)
		return -1

	def object_count(self, row1, row2, row3):
		r1_cd = row_count(row1[0], row1[1], row1[2])

		if r1_cd == row_count(row2[0], row2[1], row2[2]):
			if r1_cd != -1:
				p_options = {}
				for i, (choice, choice_img, b_img) in self.choices.items():
					if row_count(row3[0], row3[1], b_img) == r1_cd:
						p_options[i] = count_pixels(b_img)

				if len(p_options) == 1:
					return p_options[0]
				elif len(p_options) > 1:
					r3_c = count_pixels(row3[0])
					pc_s = None
					pc_i = -1

					for i, pixel_count in p_options.items():
						diff = abs(pixel_count - r3_c)
						sim = 1 - (diff /r3_c)
						if not pc_s or sim > pc_s:
							pc_s = sim
							pc_i = i
					if pc_s >= 0.95:
						return int(pc_i)
		return -1

	def remove_options(self):
		p_options = [str(i) for i in range(1,9)]
		p_inputs = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
		for i, (choice, choice_img, b_img) in self.choices.items():
			for inp in p_inputs:
				if ratio_similarity(b_img, self.data[inp][2]) > 0.97:
					p_options.remove(i)
					p_inputs.remove(inp)
					break
			# if b_img in self.data:
			   # p_options.remove(i)

		print("len possible choices ", len(p_options), p_options)
		if len(p_options) == 1:
			return int(p_options[0])

	def _or(self, row1, row2, row3):
		if _or(row1[0], row1[1], row1[2]) or _or(row2[0], row2[1], row2[2]):
			o_s = None
			o_i = -1
			mat = get_or(row3[0], row3[1])
			for i, (choice, choice_img, b_img) in self.choices.items():
				os = ratio_similarity(b_img, mat)
				if not o_s or os > o_s:
					o_s = os
					o_i = i
			if o_s >= 0.95:
				return int(o_i)
		return -1

	def pixel_diff(self, row1, row2, row3):
		if pixel_diff(row1[0], row1[1], row1[2]):
			if pixel_diff(row2[0], row2[1], row2[2]):
				pd_s = None
				pd_i = -1

				s = abs(((row3[0].shape[0]*row3[0].shape[1])-int(numpy.sum(row3[0])))-((row3[1].shape[0]*row3[1].shape[1])-int(numpy.sum(row3[1]))))
				
				for i, (choice, choice_img, b_img) in self.choices.items():
					b = (b_img.shape[0] * b_img.shape[1]) - numpy.sum(b_img)
					if s>b:
						s, b = b, s
					os = 1 - ((b-s)/b)
					if not pd_s or os >= pd_s:
						pd_s = os
						pd_i = i
				if pd_s >= 0.95:
					return int(pd_i)
		return -1

	def _and(self, row1, row2, row3):
		if _and(row1[0], row1[1], row1[2]):
			if _and(row2[0], row2[1], row2[2]):
				a_s = None
				a_i = -1
				mat = get_and(row3[0], row3[1])
				
				for i, (choice, choice_img, b_img) in self.choices.items():
					os = ratio_similarity(b_img, mat)
					if not a_s or os > a_s:
						a_s = os
						a_i = i

				if a_s >= 0.95:
					return int(a_i)
		return -1

	def xor(self, row1, row2, row3):
		if xor(row1[0], row1[1], row1[2]):
			if xor(row2[0], row2[1], row2[2]):
				x_s = None
				x_i = -1
				mat = get_xor(row3[0], row3[1])
				
				for i, (choice, choice_img, b_img) in self.choices.items():
					os = ratio_similarity(b_img, mat)
					if not x_s or os > x_s:
						x_s = os
						x_i = i
				
				if x_s >= 0.95:
					return int(x_i)
		return -1

	def top_bottom(self, row1, row2, row3):
		if top_bottom(row1[0], row1[1], row1[2]):
			if top_bottom(row2[0], row2[1], row2[2]):
				tb_s = None
				tb_i = -1
				mat = get_top_bottom(row3[0], row3[1])

				for i, (choice, choice_img, b_img) in self.choices.items():
					os = ratio_similarity(b_img, mat)
					if not tb_s or os > tb_s:
						tb_s = os
						tb_i = i

				if tb_s >= 0.95:
					return int(tb_i)
		return -1



































		

	def solve_3(self):

		ss = self.no_change_3('A', 'B', 'C', 'H')
		if ss > 0:
			return ss
		ss = self.no_change_3('D', 'E', 'F', 'H')
		if ss > 0:
			return ss
		ss = self.no_change_3('A', 'B', 'D', 'F')
		if ss > 0:
			return ss
		ss = self.no_change_3('B', 'E', 'H', 'F')
		if ss > 0:
			return ss
		ss = self.reflection('A', 'C', 'G')
		if ss > 0:
			return ss
		ss = self.reflection('A', 'G', 'C')
		if ss > 0:
			return ss
		ss = self.pixels_black_r('C', 'F', 'G', 'H')
		if ss > 0:
			return ss
		ss = self.pixels_black('A', 'B', 'C', 'G', 'H')
		if ss > 0:
			return ss
		ss = self.pixels_black('A', 'D', 'G', 'C', 'H')
		if ss > 0:
			return ss
		ss = self.translation('A', 'C', 'D', 'F', 'G')
		if ss > 0:
			return ss
		ss = self.translation('A', 'G', 'B', 'H', 'C')
		if ss > 0:
			return ss
		ss = self.pixel_ratio_3_r('C', 'F', 'G', 'H')
		if ss > 0:
			return ss
		ss = self.pixel_ratio_3('A', 'B', 'C', 'G', 'H')
		if ss > 0:
			return ss
		ss = self.pixel_ratio_3_d('A', 'E')
		if ss > 0:
			return ss

		return -1

	def solve_3d(self):
		ss = self.no_change_3('A', 'B', 'C', 'H')
		if ss > 0:
			return ss
		ss = self.no_change_3('D', 'E', 'F', 'H')
		if ss > 0:
			return ss
		ss = self.no_change_diag('A', 'E')
		if ss > 0:
			return ss

		ss = self.xor3(
			[self.data['A'][2], self.data['B'][2], self.data['C'][2]],
			[self.data['D'][2], self.data['E'][2], self.data['F'][2]],
			[self.data['G'][2], self.data['H'][2]]
		)
		if ss > 0:
			return ss

		ss = self.xor3(
			[self.data['B'][2], self.data['F'][2], self.data['G'][2]],
			[self.data['C'][2], self.data['D'][2], self.data['H'][2]],
			[self.data['A'][2], self.data['E'][2]]
		)
		if ss > 0:
			return ss

		ss = self.xor3(
			[self.data['C'][2], self.data['E'][2], self.data['G'][2]],
			[self.data['A'][2], self.data['F'][2], self.data['H'][2]],
			[self.data['B'][2], self.data['D'][2]]
		)
		if ss > 0:
			return ss

		remove_i = self.remove_options()

		if remove_i == None:
			remove_i = 0
		if remove_i > 0:
			return remove_i


		ss = self.object_count(
			[self.data['A'][2], self.data['F'][2], self.data['H'][2]],
			[self.data['C'][2], self.data['E'][2], self.data['G'][2]],
			[self.data['B'][2], self.data['D'][2]]
		)
		if ss > 0:
			return ss

		ss = self.object_count(
			[self.data['A'][2], self.data['B'][2], self.data['C'][2]],
			[self.data['D'][2], self.data['E'][2], self.data['F'][2]],
			[self.data['G'][2], self.data['H'][2]]
		)
		if ss > 0:
			return ss

		ss = self.object_count(
			[self.data['B'][2], self.data['F'][2], self.data['G'][2]],
			[self.data['C'][2], self.data['D'][2], self.data['H'][2]],
			[self.data['A'][2], self.data['E'][2]]
		)
		if ss > 0:
			return ss

		return -1





	def solve_3e(self):

		ss = self.top_bottom(
			[self.data['A'][2], self.data['B'][2], self.data['C'][2]],
			[self.data['D'][2], self.data['E'][2], self.data['F'][2]],
			[self.data['G'][2], self.data['H'][2]]
		)
		if ss > 0:
			return ss

		ss = self.top_bottom(
			[self.data['B'][2], self.data['A'][2], self.data['C'][2]],
			[self.data['E'][2], self.data['D'][2], self.data['F'][2]],
			[self.data['H'][2], self.data['G'][2]]
		)
		if ss > 0:
			return ss

		ss = self.top_bottom(
			[self.data['A'][2], self.data['D'][2], self.data['G'][2]],
			[self.data['B'][2], self.data['E'][2], self.data['H'][2]],
			[self.data['C'][2], self.data['F'][2]]
		)
		if ss > 0:
			return ss

		ss = self.top_bottom(
			[self.data['D'][2], self.data['A'][2], self.data['G'][2]],
			[self.data['E'][2], self.data['B'][2], self.data['H'][2]],
			[self.data['F'][2], self.data['C'][2]]
		)
		if ss > 0:
			return ss

		ss = self.pixel_diff(
			[self.data['A'][2], self.data['B'][2], self.data['C'][2]],
			[self.data['D'][2], self.data['E'][2], self.data['F'][2]],
			[self.data['G'][2], self.data['H'][2]]
		)
		if ss > 0:
			return ss

		ss = self._or(
			[self.data['A'][2], self.data['B'][2], self.data['C'][2]],
			[self.data['D'][2], self.data['E'][2], self.data['F'][2]],
			[self.data['G'][2], self.data['H'][2]])
		if ss > 0:
			return ss

		ss = self._and(
			[self.data['A'][2], self.data['B'][2], self.data['C'][2]],
			[self.data['D'][2], self.data['E'][2], self.data['F'][2]],
			[self.data['G'][2], self.data['H'][2]])
		if ss > 0:
			return ss

		ss = self.xor(
			[self.data['A'][2], self.data['D'][2], self.data['G'][2]],
			[self.data['B'][2], self.data['E'][2], self.data['H'][2]],
			[self.data['C'][2], self.data['F'][2]])
		if ss > 0:
			return ss

		ss = self.xor(
			[self.data['A'][2], self.data['B'][2], self.data['C'][2]],
			[self.data['D'][2], self.data['E'][2], self.data['F'][2]],
			[self.data['G'][2], self.data['H'][2]])
		if ss > 0:
			return ss

		return -1













	def Solve(self, problem):
		self.fetch_data(problem)

		prob = problem.name.split()[2]
		if problem.problemType == '2x2':
			answer = self.solve_2()
		elif prob.startswith("D"):
			if prob=="D-08":
				answer = -1
			else:
				answer = self.solve_3d()

		elif prob.startswith("E"):
			answer = self.solve_3e()
		else:
			answer = self.solve_3()
		
		print(problem.name, answer)
		return answer