#!/usr/local/bin/python3.8

from random import randrange, seed
from copy import deepcopy
from itertools import combinations 
import datetime

Same_all_day = False

def shuffle(a):
	 i = len(a)
	 while i > 1:
		 i -= 1
		 j = randrange(i + 1) # Fisher-Yates, not Sattolo
		 a[j], a[i] = a[i], a[j]

def add_2_vert_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if i == gd_sz - 1:
			continue
		if gd[i][j]  + gd[i + 1][j] == a:
			if kk[i][j] == 0 and kk[i + 1][j] == 0:
				kk[i][j] = kk[i + 1][j] = '  v{0:02d}+  '.format(a)
				s.append([(i, j), (i + 1, j)])
				k += 1
				if k == count:
					break

def add_2_horz_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if j == gd_sz - 1:
			continue
		if gd[i][j] + gd[i][j + 1] == a:
			if kk[i][j] == 0 and kk[i][j + 1] == 0:
				kk[i][j] = kk[i][j + 1] = '  h{0:d}+   '.format(a)
				s.append([(i, j), (i, j + 1)])
				k += 1
				if k == count:
					break

def add_3_horz_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if j >= gd_sz - 2:
			continue
		if gd[i][j] + gd[i][j + 1] + gd[i][j + 2] == a:
			if kk[i][j] == 0 and kk[i][j + 1] == 0 and kk[i][j + 2] == 0:
				kk[i][j] = kk[i][j + 1] = kk[i][j + 2] = '  3h{0:02d}+ '.format(a)
				s.append([(i, j), (i, j + 1)])
				s.append([(i, j), (i, j + 2)])
				s.append([(i, j + 1), (i, j + 2)])
				k += 1
				if k == count:
					break

def add_3_vert_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if i >= gd_sz - 2:
			continue
		if gd[i][j] + gd[i + 1][j] + gd[i + 2][j] == a:
			if kk[i][j] == 0 and kk[i + 1][j] == 0 and kk[i + 2][j] == 0:
				kk[i][j] = kk[i + 1][j] = kk[i + 2][j] = '  3v{0:02d}+ '.format(a)
				s.append([(i, j), (i + 1, j)])
				s.append([(i, j), (i + 2, j)])
				s.append([(i + 1, j), (i + 2, j)])
				k += 1
				if k == count:
					break

def add_2_horz_3_vert_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if (i > gd_sz - 3) or (j == gd_sz - 1):
			continue
		if gd[i][j]  + gd[i + 1][j] + gd[i + 1][j + 1] + gd[i + 2][j + 1] == a:
				if kk[i][j] == 0 and kk[i + 1][j] == 0 and kk[i + 1][j + 1] == 0 and kk[i + 2][j + 1] == 0:
					kk[i][j] = kk[i + 1][j] = kk[i + 1][j + 1] = kk[i + 2][j + 1] = ' hv{0:03d}+ '.format(a)
					s.append([(i, j), (i + 1, j)])
					s.append([(i, j), (i + 1, j + 1)])
					s.append([(i, j), (i + 2, j + 1)])
					s.append([(i + 1, j), (i + 1, j + 1)])
					s.append([(i + 1, j), (i + 2, j + 1)])
					s.append([(i + 1, j + 1), (i + 2, j + 1)])
					k += 1
					if k == count:
						break

# Note that a is an array of allowed products of four integers
def multiply_2_square_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]
	
	for pr in rand_mt:
		i, j = pr
		if (i == gd_sz - 1) or (j == gd_sz - 1):
			continue
		if gd[i][j] * gd[i + 1][j] * gd[i][j + 1] * gd[i + 1][j + 1] in a:
			if kk[i][j] == 0 and kk[i + 1][j] == 0 and kk[i][j + 1] == 0 and kk[i + 1][j + 1] == 0:
				temp = gd[i][j] * gd[i + 1][j] * gd[i][j + 1] * gd[i + 1][j + 1]
				kk[i][j] = kk[i + 1][j] = kk[i][j + 1] = kk[i + 1][j + 1] ='  sq{0:02d}x '.format(temp)
				s.append([(i, j), (i + 1, j)])
				s.append([(i, j), (i, j + 1)])
				s.append([(i, j), (i + 1, j + 1)])
				s.append([(i + 1, j), (i, j + 1)])
				s.append([(i + 1, j), (i + 1, j + 1)])
				s.append([(i, j + 1), (i + 1, j + 1)])
				k += 1
				if k == count:
					break

def show(puzzle):
	for a_row in puzzle:
		for el in a_row:
			print(el, end = '  ')
		print()

def legit_row(arr):
	global gd_sz, digs
	result = True
	
	for k in digs:
		counted = False
		for el in arr:
			if el == k:
				if counted:
					result = False
					break
				counted = True
		if not counted:
			result = False
		if not result:
			break
	return result

def legit_col(gd, j):
	global gd_sz
	arr = []

	for row in gd:
		arr.append(row[j])

	return legit_row(arr)

def legit_gd(gd):
	global gd_sz
	result = True

	for row in gd:
		if not legit_row(row):
			result = False
			break
	if result:
		for j in range(gd_sz):
			if not legit_col(gd, j):
				result = False
				break
	return result

def subtract_2_vert_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if i == gd_sz - 1:
			continue
		if abs(gd[i][j] - gd[i + 1][j]) == a:
			if kk[i][j] == 0 and kk[i + 1][j] == 0:
				kk[i][j] = kk[i + 1][j] = '  v{0:d}-   '.format(a)
				s.append([(i, j), (i + 1, j)])
				k += 1
				if k == count:
					break

def subtract_2_horz_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if j == gd_sz - 1:
			continue
		if abs(gd[i][j] - gd[i][j + 1]) == a:
			if kk[i][j] == 0 and kk[i][j + 1] == 0:
				kk[i][j] = kk[i][j + 1] = '  h{0:d}-   '.format(a)
				s.append([(i, j), (i, j + 1)])
				k += 1
				if k == count:
					break
					
# Note that a is an array of allowed products of 2 integers
def multiply_2_horz_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if j == gd_sz - 1:
			continue
		if gd[i][j] * gd[i][j + 1] in a:
			if kk[i][j] == 0 and kk[i][j + 1] == 0:
				kk[i][j] = kk[i][j + 1] = '  h{0:02d}x  '.format(gd[i][j] * gd[i][j + 1])
				s.append([(i, j), (i, j + 1)])
				k += 1
				if k == count:
					break

# Note that a is an array of allowed products of 2 integers
def multiply_2_vert_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if i == gd_sz - 1:
			continue
		if gd[i][j] * gd[i + 1][j] in a:
			if kk[i][j] == 0 and kk[i + 1][j] == 0:
				kk[i][j] = kk[i + 1][j] = '  v{0:02d}x  '.format(gd[i][j] * gd[i + 1][j])
				s.append([(i, j), (i + 1, j)])
				k += 1
				if k == count:
					break

# Note that a is an array of allowed products of 3 integers
def multiply_3_horz_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if j >= gd_sz - 2:
			continue
		if gd[i][j] * gd[i][j + 1] * gd[i][j + 2] in a:
			if kk[i][j] == 0 and kk[i][j + 1] == 0 and kk [i][j + 2] == 0:
				temp = gd[i][j] * gd[i][j + 1] * gd[i][j + 2]
				kk[i][j] = kk[i][j + 1] = kk[i][j + 2] = '  3h{0:02d}x '.format(temp)
				s.append([(i, j), (i, j + 1)])
				s.append([(i, j), (i, j + 2)])
				s.append([(i, j + 1), (i, j + 2)])
				k += 1
				if k == count:
					break

# Note that a is an array of allowed products of 3 integers
def multiply_3_vert_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if i >= gd_sz - 2:
			continue
		if gd[i][j] * gd[i + 1][j] * gd[i + 2][j] in a:
			if kk[i][j] == 0 and kk[i + 1][j] == 0 and kk[i + 2][j]== 0:
				temp = gd[i][j] * gd[i + 1][j] * gd[i + 2][j]
				kk[i][j] = kk[i + 1][j] = kk[i + 2][j] = '  3v{0:02d}x '.format(temp)
				s.append([(i, j), (i + 1, j)])
				s.append([(i, j), (i + 2, j)])
				s.append([(i + 1, j), (i + 2, j)])
				k += 1
				if k == count:
					break

# Note that a is an array of allowed products of 3 integers
def multiply_ll_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if (i == 0) or (j == gd_sz - 1):
			continue
		if gd[i][j] * gd[i - 1][j] * gd[i][j + 1] in a:
			if kk[i][j] == 0 and kk[i - 1][j] == 0 and kk[i][j + 1] == 0:
				temp = gd[i][j] * gd[i - 1][j] * gd[i][j + 1]
				kk[i][j] = kk[i - 1][j] = kk[i][j + 1] = ' ll{0:02d}x  '.format(temp)
				s.append([(i, j), (i - 1, j)])
				s.append([(i, j), (i, j + 1)])
				s.append([(i - 1, j), (i, j + 1)])
				k += 1
				if k == count:
					break

# Note that a is an array of allowed products of 3 integers
def multiply_ul_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if (i == gd_sz - 1) or (j == gd_sz - 1):
			continue
		if gd[i][j] * gd[i + 1][j] * gd[i][j + 1] in a:
			if kk[i][j] == 0 and kk[i + 1][j] == 0 and kk[i][j + 1] == 0:
				temp = gd[i][j] * gd[i + 1][j] * gd[i][j + 1]
				kk[i][j] = kk[i + 1][j] = kk[i][j + 1] = ' ul{0:02d}x  '.format(temp)
				s.append([(i, j), (i + 1, j)])
				s.append([(i, j), (i, j + 1)])
				s.append([(i + 1, j), (i, j + 1)])
				k += 1
				if k == count:
					break

# Note that a is an array of allowed products of 3 integers
def multiply_ur_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if (i == gd_sz - 1) or (j == 0):
			continue
		if gd[i][j] * gd[i][j - 1] * gd[i + 1][j] in a:
			if kk[i][j] == 0 and kk[i][j - 1] == 0 and kk[i + 1][j] == 0:
				temp = gd[i][j] * gd[i][j - 1] * gd[i + 1][j]
				kk[i][j] = kk[i][j - 1] = kk[i + 1][j] = ' ur{0:02d}x  '.format(temp)
				s.append([(i, j), (i, j - 1)])
				s.append([(i, j), (i + 1, j)])
				s.append([(i, j - 1), (i + 1, j)])
				k += 1
				if k == count:
					break

# Note that a is an array of allowed products of 3 integers
def multiply_lr_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if (i == 0) or (j == 0):
			continue
		if gd[i][j] * gd[i][j - 1] * gd[i - 1][j] in a:
			if kk[i][j] == 0 and kk[i][j - 1] == 0 and kk[i - 1][j] == 0:
				temp = gd[i][j] * gd[i][j - 1] * gd[i - 1][j]
				kk[i][j] = kk[i][j - 1] = kk[i - 1][j] = ' lr{0:03d}x '.format(temp)
				s.append([(i, j), (i, j - 1)])
				s.append([(i, j), (i - 1, j)])
				s.append([(i, j - 1), (i - 1, j)])
				k += 1
				if k == count:
					break

# Note that a is an array of allowed products of four integers
def multiply_3_vert_2_horz(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]
	
	for pr in rand_mt:
		i, j = pr
		if (i > gd_sz - 3) or (j == gd_sz - 1):
			continue
		if gd[i][j] * gd[i + 1][j] * gd[i + 2][j] * gd[i + 2][j + 1] in a:
			if kk[i][j] == 0 and kk[i + 1][j] == 0 and kk[i + 2][j] == 0 and kk[i + 2][j + 1] == 0:
				temp = gd[i][j] * gd[i + 1][j] * gd[i + 2][j] * gd[i + 2][j + 1]
				kk[i][j] = kk[i + 1][j] = kk[i + 2][j] = kk[i + 2][j + 1] ='  vh{0:03d}x'.format(temp)
				s.append([(i, j), (i + 1, j)])
				s.append([(i, j), (i + 2, j)])
				s.append([(i, j), (i + 2, j + 1)])
				s.append([(i + 1, j), (i + 2, j)])
				s.append([(i + 1, j), (i + 2, j + 1)])
				s.append([(i + 2, j), (i + 2, j + 1)])
				k += 1
				if k == count:
					break

# Note that a is an array of allowed ratios of two integers
def divide_2_horz_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if j == gd_sz - 1:
			continue
		rat = max(gd[i][j], gd[i][j + 1]) / min(gd[i][j], gd[i][j + 1])
		if (rat in a) and (kk[i][j] == 0 and kk[i][j + 1] == 0):
			kk[i][j] = kk[i][j + 1] = '  h{0:1.0f}\u00F7   '.format(rat)
			s.append([(i, j), (i, j + 1)])
			k += 1
			if k == count:
				break

def divide_2_vert_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]
	
	for pr in rand_mt:
		i, j = pr
		if i == gd_sz - 1:
			continue
		rat = max(gd[i][j], gd[i + 1][j]) / min(gd[i][j], gd[i + 1][j])
		if (rat in a) and (kk[i][j] == 0 and kk[i + 1][j] == 0):
			kk[i][j] = kk[i + 1][j] = '  v{0:1.0f}\u00F7   '.format(rat)
			s.append([(i, j), (i + 1, j)])
			k += 1
			if k == count:
				break

def add_ur_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if (i == gd_sz - 1) or (j == 0):
			continue
		if gd[i][j] + gd[i][j - 1] + gd[i + 1][j] == a:
			if kk[i][j] == 0 and kk[i][j - 1] == 0 and kk[i + 1][j] == 0:
				kk[i][j] = kk[i][j - 1] = kk[i + 1][j] = ' ur{0:02d}+  '.format(a)
				s.append([(i, j), (i, j - 1)])
				s.append([(i, j), (i + 1, j)])
				s.append([(i, j - 1), (i + 1, j)])
				k += 1
				if k == count:
					break

def add_ul_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if (i == gd_sz - 1) or (j == gd_sz - 1):
			continue
		if gd[i][j] + gd[i + 1][j] + gd[i][j + 1] == a:
			if kk[i][j] == 0 and kk[i + 1][j] == 0 and kk[i][j + 1] == 0:
				kk[i][j] = kk[i + 1][j] = kk[i][j + 1] = ' ul{0:02d}+  '.format(a)
				s.append([(i, j), (i + 1, j)])
				s.append([(i, j), (i, j + 1)])
				s.append([(i + 1, j), (i, j + 1)])
				k += 1
				if k == count:
					break

def add_ll_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if (i == 0) or (j == gd_sz - 1):
			continue
		if gd[i][j] + gd[i - 1][j] + gd[i][j + 1] == a:
			if kk[i][j] == 0 and kk[i - 1][j] == 0 and kk[i][j + 1] == 0:
				kk[i][j] = kk[i - 1][j] = kk[i][j + 1] = ' ll{0:02d}+  '.format(a)
				s.append([(i, j), (i - 1, j)])
				s.append([(i, j), (i, j + 1)])
				s.append([(i - 1, j), (i, j + 1)])
				k += 1
				if k == count:
					break

def add_lr_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]

	for pr in rand_mt:
		i, j = pr
		if (i == 0) or (j == 0):
			continue
		if gd[i][j] + gd[i][j - 1] + gd[i - 1][j] == a:
			if kk[i][j] == 0 and kk[i][j - 1] == 0 and kk[i - 1][j] == 0:
				kk[i][j] = kk[i][j - 1] = kk[i - 1][j] = ' lr{0:02d}+  '.format(a)
				s.append([(i, j), (i, j - 1)])
				s.append([(i, j), (i - 1, j)])
				s.append([(i, j - 1), (i - 1, j)])
				k += 1
				if k == count:
					break

# Note that a is an array of allowed sums of four integers
def add_2_square_target(count, indexer, gd, kk, s, a):
	global gd_sz
	k = 0

	shuffle(indexer)
	rand_mt = [divmod(el, gd_sz) for el in indexer]
	
	for pr in rand_mt:
		i, j = pr
		if (i == gd_sz - 1) or (j == gd_sz - 1):
			continue
		if gd[i][j] + gd[i + 1][j] + gd[i][j + 1] + gd[i + 1][j + 1] in a:
			if kk[i][j] == 0 and kk[i + 1][j] == 0 and kk[i][j + 1] == 0 and kk[i + 1][j + 1] == 0:
				temp = gd[i][j] + gd[i + 1][j] + gd[i][j + 1] + gd[i + 1][j + 1]
				kk[i][j] = kk[i + 1][j] = kk[i][j + 1] = kk[i + 1][j + 1] ='  sq{0:02d}+ '.format(temp)
				s.append([(i, j), (i + 1, j)])
				s.append([(i, j), (i, j + 1)])
				s.append([(i, j), (i + 1, j + 1)])
				s.append([(i + 1, j), (i, j + 1)])
				s.append([(i + 1, j), (i + 1, j + 1)])
				s.append([(i, j + 1), (i + 1, j + 1)])
				k += 1
				if k == count:
					break

def gimmes(gd, kk):
	count = 0
	for i in range(gd_sz):
		for j in range(gd_sz):
			if kk[i][j] == 0:
				count += 1
				kk[i][j] = '   {0:d}    '.format(gd[i][j])
	return count

# Begin program

# If program repeatability is needed, seed the generator with the Julian day.
if Same_all_day:
	dt = datetime.datetime.now()
	seed(int(dt.strftime("%j")))

gd_sz = 6
row_col_sum = (gd_sz * (gd_sz + 1)) // 2
digs = [k for k in range(1, gd_sz + 1)]
a_row = [i for i in range(1, gd_sz + 1)]
shuffle(a_row)
build_count = 0
indexer = [i for i in range(gd_sz * gd_sz)] # For accessing random gd elements

while True:
	build_count += 1
	print('Starting puzzle build number {0:d}.\n'.format(build_count))
	gd, row_count = [a_row], 1

	while row_count < gd_sz - 1:
		next_row = deepcopy(a_row)
		shuffle(next_row)
		result = True
		for a_row in gd:
			for i in range(gd_sz):
				if next_row[i] == a_row[i]:
					result = False
					break
			if result == False:
				break
		if result == True:
			gd.append(next_row)
			row_count += 1

	# Now the last row. Just choose the integers that make the sum for each
	# column correct.
	a_row = []
	for j in range(gd_sz):
		acc = 0
		for i in range(gd_sz - 1):
			acc += gd[i][j]
		a_row.append(row_col_sum - acc)

	gd.append(a_row)
	show(gd)
	print()
	found_a_dup = False

	# Set up a KenKen grid and fill it with sentinels.
	kk = []
	for _ in range(gd_sz):
		row = [0 for _ in range(gd_sz)] # Unused square sentinel
		kk.append(row)

	s = []
	multiply_3_vert_2_horz(1, indexer, gd, kk, s, [24, 72])
#	multiply_2_square_target(1, indexer, gd, kk, s, [24, 72])
	multiply_lr_target(1, indexer, gd, kk, s, [25, 50, 75, 100, 125, 150])
	multiply_3_vert_target(1, indexer, gd, kk, s, [40, 48])
	add_lr_target(1, indexer, gd, kk, s, 16)
	subtract_2_horz_target(2, indexer, gd, kk, s, 5)
	add_2_horz_3_vert_target(1, indexer, gd, kk, s, 14)
	add_3_horz_target(1, indexer, gd, kk, s, 12)
	add_3_vert_target(1, indexer, gd, kk, s, 13)
	subtract_2_vert_target(1, indexer, gd, kk, s, 5)
	subtract_2_vert_target(1, indexer, gd, kk, s, 4)
	subtract_2_horz_target(1, indexer, gd, kk, s, 3)
	subtract_2_horz_target(1, indexer, gd, kk, s, 1)
	subtract_2_vert_target(1, indexer, gd, kk, s, 2)
	subtract_2_horz_target(1, indexer, gd, kk, s, 2)
	subtract_2_vert_target(2, indexer, gd, kk, s, 1)
	multiply_2_horz_target(1, indexer, gd, kk, s, [6, 30])
	multiply_2_vert_target(1, indexer, gd, kk, s, [6, 20])
	multiply_3_horz_target(1, indexer, gd, kk, s, [10, 24, 40])
	divide_2_horz_target(2, indexer, gd, kk, s, [2, 3])
	divide_2_vert_target(2, indexer, gd, kk, s, [2, 3])
	add_2_vert_target(1, indexer, gd, kk, s, 7)
	add_2_horz_target(1, indexer, gd, kk, s, 5)
	add_ur_target(1, indexer, gd, kk, s, 9)
	divide_2_vert_target(1, indexer, gd, kk, s, [4, 5, 6])
	divide_2_horz_target(1, indexer, gd, kk, s, [4, 5, 6])
	# print(s)
	lst = [i for i in range(len(s))]
	comb = combinations(lst, 2)
	c = (list(comb))
	print('There are {0:d} combinations of swaps taken 2 at a time.'.format(len(c)))
	for i in c:
		(prs) = s[i[0]], s[i[1]]
		g2 = deepcopy(gd)
		for p in prs:
			temp = g2[p[0][0]][p[0][1]]
			g2[p[0][0]][p[0][1]] = g2[p[1][0]][p[1][1]]
			g2[p[1][0]][p[1][1]] = temp
		found_a_dup = legit_gd(g2)
		if found_a_dup:
			print('Found a duplicate with combinations of 2 pairs.\n')
			break
	if found_a_dup:
		continue
	comb = combinations(lst, 3)
	c = (list(comb))
	print('There are {0:d} combinations of swaps taken 3 at a time.'.format(len(c)))
	for i in c:
		(prs) = s[i[0]], s[i[1]], s[i[2]]
		g2 = deepcopy(gd)
		for p in prs:
			temp = g2[p[0][0]][p[0][1]]
			g2[p[0][0]][p[0][1]] = g2[p[1][0]][p[1][1]]
			g2[p[1][0]][p[1][1]] = temp
		found_a_dup = legit_gd(g2)
		if found_a_dup:
			print('Found a duplicate with combinations of 3 pairs.\n')
			break
	if found_a_dup:
		continue
	comb = combinations(lst, 4)
	c = (list(comb))
	print('There are {0:d} combinations of swaps taken 4 at a time.\n'.format(len(c)))
	for i in c:
		(prs) = s[i[0]], s[i[1]], s[i[2]], s[i[3]]
		g2 = deepcopy(gd)
		for p in prs:
			temp = g2[p[0][0]][p[0][1]]
			g2[p[0][0]][p[0][1]] = g2[p[1][0]][p[1][1]]
			g2[p[1][0]][p[1][1]] = temp
		found_a_dup = legit_gd(g2)
		if found_a_dup:
			print('Found a duplicate with combinations of 4 pairs.\n')
			break
	if not found_a_dup:
		break;

gimme_count = gimmes(gd, kk)
show(kk)
if gimme_count == 1:
	s_g = ''
else:
	s_g = 's'
print('\n{0:d} gimme{1:s}'.format(gimme_count, s_g))
print('\nGood to go.')