#include <bits/stdc++.h>

using namespace std;
const int V = 30;

// Tulostaa kuvion
/*void tulostus(bool *arvot)
{
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";
	for (int i = 0; i < V; ++i)
	{
		for (int j = 0; j < V; ++j)
		{
			if (*(arvot + V*j + i) == 0)
			{
				cout << "  ";
			}
			else
			{
				cout << " X";
			}
		}
		cout << "|\n";
	}
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";
}*/

int main()
{
	// Lopussa tarvittavia
	int siirtoja = 0;
	int siirrot_talteen_alku[201][2];
	int siirrot_talteen_loppu[201][2];
	int vaihtoehtoja = 0;
	int valinta = 0;
	int alkupiste = 0;
	bool onko_mahdollisia_siirtoja = 0;
	int mahdollisia_siirtoja = 0;
/*	bool onko_mukavaa_siirtoa = 0;
	int mukava_siirto[6];
	int mukavan_tyyppi = 0;
	int suunta_x = 0;
	int suunta_y = 0;*/


	bool ruutu[V][V];
	bool mahdollisuus[V][V][4];
	for (int i = 0; i < V; ++i)
	{
		for (int j = 0; j < V; ++j)
		{
			ruutu[i][j] = 0;
			for (int k = 0; k < 4; ++k)
			{
				mahdollisuus[i][j][k] = 0;
			}
		}
	}

	// 0 = ->
	// 1 = <-
	// 2 = ylös
	// 3 = alas
	// 4 = koillinen
	// 5 = kaakko
	// 6 = lounas
	// 7 = luode
	bool suunnat[V][V][4];
	for (int i = 0; i < V; ++i)
	{
		for (int j = 0; j < V; ++j)
		{
			for (int k = 0; k < 4; ++k)
			{
				suunnat[i][j][k] = 0;
			}
		}
	}

	// Ristin vasen reuna
	ruutu[10][13] = 1;
	ruutu[10][14] = 1;
	ruutu[10][15] = 1;
	ruutu[10][16] = 1;

	// Ristin oikea reuna
	ruutu[19][13] = 1;
	ruutu[19][14] = 1;
	ruutu[19][15] = 1;
	ruutu[19][16] = 1;

	// Ristin alareuna
	ruutu[13][19] = 1;
	ruutu[14][19] = 1;
	ruutu[15][19] = 1;
	ruutu[16][19] = 1;

	// Ristin yläreuna
	ruutu[13][10] = 1;
	ruutu[14][10] = 1;
	ruutu[15][10] = 1;
	ruutu[16][10] = 1;

	// Ristin koillisreuna
	ruutu[16][11] = 1;
	ruutu[16][12] = 1;
	ruutu[16][13] = 1;
	ruutu[17][13] = 1;
	ruutu[18][13] = 1;

	// Ristin kaakkoisreuna
	ruutu[16][18] = 1;
	ruutu[16][17] = 1;
	ruutu[16][16] = 1;
	ruutu[17][16] = 1;
	ruutu[18][16] = 1;

	// Ristin lounaisreuna
	ruutu[13][18] = 1;
	ruutu[13][17] = 1;
	ruutu[13][16] = 1;
	ruutu[12][16] = 1;
	ruutu[11][16] = 1;

	// Ristin luoteisreuna
	ruutu[13][11] = 1;
	ruutu[13][12] = 1;
	ruutu[13][13] = 1;
	ruutu[12][13] = 1;
	ruutu[11][13] = 1;

	// Testi
//	ruutu[21][4] = 1;
//	ruutu[22][3] = 1;
//	ruutu[23][2] = 1;
//	ruutu[24][1] = 1;
//	ruutu[25][0] = 1;


	// Laittaa kaikkien pisteiden suunniksi ykköset
	for (int i = 0; i < V; ++i)
	{
		for (int j = 0; j < V; ++j)
		{
			if (ruutu[i][j] == 1)
			{
				for (int k = 0; k < 4; ++k)
				{
					suunnat[i][j][k] = 1;
				}
			}
		}
	}



	// *************************************************************************
	// Palaa tähän
	alku:
	for (int i = 0; i < V; ++i)
	{
		for (int j = 0; j < V; ++j)
		{
			for (int k = 0; k < 4; ++k)
			{
				mahdollisuus[i][j][k] = 0;
			}
		}
	}

	onko_mahdollisia_siirtoja = 0;
	mahdollisia_siirtoja = 0;
//	onko_mukavaa_siirtoa = 0;
//	for (int i = 0; i < 6; ++i)
//	{
//		mukava_siirto[i] = 0;
//	}

	// Etsii sopivat (sivuttain)
	bool testi = 0;
	int eteen = 0;
	int taakse = 0;
	bool eteen_0 = 0;
	bool taakse_0 = 0;
	for (int i = 0; i < V; ++i)
	{
		for (int j = 0; j < V; ++j)
		{
			testi = 0;
			if (ruutu[i][j] == 0)
			{
				eteen = 0;
				taakse = 0;
				eteen_0 = 0;
				taakse_0 = 0;
				for (int k = 0; k < 4; ++k)
				{
					if (i + k + 1 < V && ruutu[i+k+1][j] == 1 && suunnat[i+k+1][j][0] == 1 && eteen_0 == 0)
					{
						eteen++;
					}
					else
					{
						eteen_0 = 1;
					}

					if (i - k - 1 >= 0 && ruutu[i-k-1][j] == 1 && suunnat[i-k-1][j][0] == 1 && taakse_0 == 0)
					{
						taakse++;
					}
					else
					{
						taakse_0 = 1;
					}
				}
				if (eteen + taakse > 3)
				{
					mahdollisuus[i][j][0] = 1;
					onko_mahdollisia_siirtoja = 1;
					// Etsii mahdollisen reunan, jos löytyy, laittaa mahd. lähelle sitä
/*					if (suunnat[i+eteen+1][j][0] == 0 && ruutu[i+eteen+1][j] == 1)
					{
						cout << "mukava: " << eteen << " " << taakse << "\n";
						onko_mukavaa_siirtoa = 1;
						mukavan_tyyppi = 0;
						mukava_siirto[0] = i + eteen - 4;
						mukava_siirto[1] = j;
						mukava_siirto[2] = i + eteen;
						mukava_siirto[3] = j;
						mukava_siirto[4] = i;
						mukava_siirto[5] = j;
					}
					else if (suunnat[i-taakse-1][j][0] == 0 && ruutu[i-taakse-1][j] == 1)
					{
						cout << "mukava: " << eteen << " " << taakse << "\n";
						onko_mukavaa_siirtoa = 1;
						mukavan_tyyppi = 0;
						mukava_siirto[0] = i - taakse;
						mukava_siirto[1] = j;
						mukava_siirto[2] = i - taakse + 4;
						mukava_siirto[3] = j;
						mukava_siirto[4] = i;
						mukava_siirto[5] = j;
					}*/
				}
			}
		}
	}
	// Etsii sopivat pystyttäin
	for (int i = 0; i < V; ++i)
	{
		for (int j = 0; j < V; ++j)
		{
			testi = 0;
			if (ruutu[i][j] == 0)
			{
				eteen = 0;
				taakse = 0;
				eteen_0 = 0;
				taakse_0 = 0;
				for (int k = 0; k < 4; ++k)
				{
					if (j + k + 1 < V && ruutu[i][j+k+1] == 1 && suunnat[i][j+k+1][1] == 1 && eteen_0 == 0)
					{
						eteen++;
					}
					else
					{
						eteen_0 = 1;
					}

					if (j - k - 1 >= 0 && ruutu[i][j-k-1] == 1 && suunnat[i][j-k-1][1] == 1 && taakse_0 == 0)
					{
						taakse++;
					}
					else
					{
						taakse_0 = 1;
					}
				}
				if (eteen + taakse > 3)
				{
					mahdollisuus[i][j][1] = 1;
					onko_mahdollisia_siirtoja = 1;
				}
			}
		}
	}

/*	for (int i = 0; i < V - 4; ++i)
	{
		for (int j = 0; j < V; ++j)
		{
			testi = 0;
			if (ruutu[i][j] == 0)
			{
				if (ruutu[i+1][j] == 1)
				{
					for (int k = 0; k < 3; ++k)
					{
						if (ruutu[i+k+2][j] != 1)
						{
							testi = 1;
						}
					}
					if (testi == 0)
					{
						mahdollisuus[i][j][0] = 1;
					}
				}
			}
		}
	}*/
/*	// Etsii sopivat (<-)
	testi = 0;
	for (int i = 4; i < V; ++i)
	{
		for (int j = 0; j < V; ++j)
		{
			testi = 0;
			if (ruutu[i][j] == 0)
			{
				if (ruutu[i-1][j] == 1)
				{
					for (int k = 0; k < 3; ++k)
					{
						if (ruutu[i-k-2][j] != 1)
						{
							testi = 1;
						}
					}
					if (testi == 0)
					{
						mahdollisuus[i][j][1] = 1;
					}
				}
			}
		}
	}*/
/*	// Etsii sopivat (ylös)
	testi = 0;
	for (int i = 0; i < V; ++i)
	{
		for (int j = 4; j < V; ++j)
		{
			testi = 0;
			if (ruutu[i][j] == 0)
			{
				if (ruutu[i][j-1] == 1)
				{
					for (int k = 0; k < 3; ++k)
					{
						if (ruutu[i][j-k-1] != 1)
						{
							testi = 1;
						}
					}
					if (testi == 0)
					{
						mahdollisuus[i][j][2] = 1;
					}
				}
			}
		}
	}*/
/*	// Etsii sopivat (alas)
	testi = 0;
	for (int i = 0; i < V; ++i)
	{
		for (int j = 0; j < V - 4; ++j)
		{
			testi = 0;
			if (ruutu[i][j] == 0)
			{
				if (ruutu[i][j+1] == 1)
				{
					for (int k = 0; k < 3; ++k)
					{
						if (ruutu[i][j+k+2] != 1)
						{
							testi = 1;
						}
					}
					if (testi == 0)
					{
						mahdollisuus[i][j][3] = 1;
					}
				}
			}
		}
	}*/
	// Etsii sopivat (koillinen – lounas)
	testi = 0;
	for (int i = 0; i < V; ++i)
	{
		for (int j = 0; j < V; ++j)
		{
			testi = 0;
			if (ruutu[i][j] == 0)
			{
				eteen = 0;
				taakse = 0;
				eteen_0 = 0;
				taakse_0 = 0;
				for (int k = 0; k < 4; ++k)
				{
					if (i + k + 1 < V && j - k - 1 >= 0 && ruutu[i+k+1][j-k-1] == 1 && suunnat[i+k+1][j-k-1][2] == 1 && eteen_0 == 0)
					{
						eteen++;
					}
					else
					{
						eteen_0 = 1;
					}

					if (i - k - 1 >= 0 && j + k + 1 < V && ruutu[i-k-1][j+k+1] == 1 && suunnat[i-k-1][j+k+1][2] == 1 && taakse_0 == 0)
					{
						taakse++;
					}
					else
					{
						taakse_0 = 1;
					}
				}
				if (eteen + taakse > 3)
				{
					mahdollisuus[i][j][2] = 1;
					onko_mahdollisia_siirtoja = 1;
				}
/*				if (ruutu[i+1][j-1] == 1)
				{
					for (int k = 0; k < 3; ++k)
					{
						if (ruutu[i+k+2][j-k-2] != 1)
						{
							testi = 1;
						}
					}
					if (testi == 0)
					{
						mahdollisuus[i][j][4] = 1;
					}
				}*/
			}
		}
	}
	// Etsii sopivat (kaakko – luode)
	testi = 0;
	for (int i = 0; i < V; ++i)
	{
		for (int j = 0; j < V; ++j)
		{
			testi = 0;
			if (ruutu[i][j] == 0)
			{
				eteen = 0;
				taakse = 0;
				eteen_0 = 0;
				taakse_0 = 0;
				for (int k = 0; k < 4; ++k)
				{
					if (i + k + 1 < V && j + k + 1 < V && ruutu[i+k+1][j+k+1] == 1 && suunnat[i+k+1][j+k+1][3] == 1 && eteen_0 == 0)
					{
						eteen++;
					}
					else
					{
						eteen_0 = 1;
					}

					if (i - k - 1 >= 0 && j - k - 1 >= 0 && ruutu[i-k-1][j-k-1] == 1 && suunnat[i-k-1][j-k-1][3] == 1 && taakse_0 == 0)
					{
						taakse++;
					}
					else
					{
						taakse_0 = 1;
					}
				}
				if (eteen + taakse > 3)
				{
					mahdollisuus[i][j][3] = 1;
					onko_mahdollisia_siirtoja = 1;
				}
			}
		}
	}
/*	// Etsii sopivat (kaakko)
	testi = 0;
	for (int i = 0; i < V - 4; ++i)
	{
		for (int j = 0; j < V - 4; ++j)
		{
			testi = 0;
			if (ruutu[i][j] == 0)
			{
				if (ruutu[i+1][j+1] == 1)
				{
					for (int k = 0; k < 3; ++k)
					{
						if (ruutu[i+k+2][j+k+2] != 1)
						{
							testi = 1;
						}
					}
					if (testi == 0)
					{
						mahdollisuus[i][j][5] = 1;
					}
				}
			}
		}
	}*/
/*	// Etsii sopivat (lounas)
	testi = 0;
	for (int i = 4; i < V; ++i)
	{
		for (int j = 0; j < V - 4; ++j)
		{
			testi = 0;
			if (ruutu[i][j] == 0)
			{
				if (ruutu[i-1][j+1] == 1)
				{
					for (int k = 0; k < 3; ++k)
					{
						if (ruutu[i-k-2][j+k+2] != 1)
						{
							testi = 1;
						}
					}
					if (testi == 0)
					{
						mahdollisuus[i][j][6] = 1;
					}
				}
			}
		}
	}*/
/*	// Etsii sopivat (luode)
	testi = 0;
	for (int i = 4; i < V; ++i)
	{
		for (int j = 4; j < V; ++j)
		{
			testi = 0;
			if (ruutu[i][j] == 0)
			{
				if (ruutu[i-1][j-1] == 1)
				{
					for (int k = 0; k < 3; ++k)
					{
						if (ruutu[i-k-2][j-k-2] != 1)
						{
							testi = 1;
						}
					}
					if (testi == 0)
					{
						mahdollisuus[i][j][7] = 1;
					}
				}
			}
		}
	}*/

	string kirjaimet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
	int koordinaatit[50][2];
	int menneet = 0;
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";
	for (int i = 0; i < V; ++i)
	{
		cout << "|";
		for (int j = 0; j < V; ++j)
		{
			testi = 0;
			if (ruutu[j][i] == 0)
			{
				for (int k = 0; k < 4; ++k)
				{
					if (mahdollisuus[j][i][k] == 1)
					{
						testi = 1;
					}
				}
				if (testi == 0)
				{
					cout << "  ";
				}
				else
				{
					cout << " " << kirjaimet[menneet%50];
					koordinaatit[menneet%50][0] = j;
					koordinaatit[menneet%50][1] = i;
					menneet++;
					mahdollisia_siirtoja++;
				}
			}
			else
			{
				cout << " ·";
			}
		}
		cout << "|\n";
	}
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";

	// Tulostaa suunnan nolla pisteet
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";
	for (int i = 0; i < V; ++i)
	{
		cout << "|";
		for (int j = 0; j < V; ++j)
		{
			if (ruutu[j][i] == 1)
			{
				if (suunnat[j][i][0] == 1)
				{
					cout << " ·";
				}
				else
				{
					cout << " X";
				}
			}
			else
			{
				cout << "  ";
			}
		}
		cout << "|\n";
	}
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";

	// Tulostaa suunnan yksi pisteet
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";
	for (int i = 0; i < V; ++i)
	{
		cout << "|";
		for (int j = 0; j < V; ++j)
		{
			if (ruutu[j][i] == 1)
			{
				if (suunnat[j][i][1] == 1)
				{
					cout << " ·";
				}
				else
				{
					cout << " X";
				}
			}
			else
			{
				cout << "  ";
			}
		}
		cout << "|\n";
	}
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";

	// Tulostaa suunnan kaksi pisteet
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";
	for (int i = 0; i < V; ++i)
	{
		cout << "|";
		for (int j = 0; j < V; ++j)
		{
			if (ruutu[j][i] == 1)
			{
				if (suunnat[j][i][2] == 1)
				{
					cout << " ·";
				}
				else
				{
					cout << " X";
				}
			}
			else
			{
				cout << "  ";
			}
		}
		cout << "|\n";
	}
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";

	// Tulostaa suunnan kolme pisteet
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";
	for (int i = 0; i < V; ++i)
	{
		cout << "|";
		for (int j = 0; j < V; ++j)
		{
			if (ruutu[j][i] == 1)
			{
				if (suunnat[j][i][3] == 1)
				{
					cout << " ·";
				}
				else
				{
					cout << " X";
				}
			}
			else
			{
				cout << "  ";
			}
		}
		cout << "|\n";
	}
	cout << "–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––\n";

//	tulostus(ruutu);

	// Talletus
	char pelattava;
	// Manuaalinen valinta
//	cin >> pelattava;
	// Automaattinen valinta
	pelattava = 'a';
	// Monimutkaisempi
	if (siirtoja%4 == 2)
	{
//		cout << mahdollisia_siirtoja << kirjaimet[mahdollisia_siirtoja%50];
		if (mahdollisia_siirtoja > 1)
		{
			pelattava = kirjaimet[(mahdollisia_siirtoja-1)%50];
		}
	}
	else if (siirtoja%4 == 1)
	{
//		cout << mahdollisia_siirtoja << kirjaimet[mahdollisia_siirtoja%50];
		if (mahdollisia_siirtoja > 2)
		{
			pelattava = kirjaimet[(mahdollisia_siirtoja/2-1)%50];
		}
	}
	else if (siirtoja%4 == 3)
	{
//		cout << mahdollisia_siirtoja << kirjaimet[mahdollisia_siirtoja%50];
		if (mahdollisia_siirtoja > 4)
		{
			pelattava = kirjaimet[(mahdollisia_siirtoja/2+1)%50];
		}
	}

	if (pelattava == '0' || onko_mahdollisia_siirtoja == 0)
	{
		cout << siirtoja << "\n";
		for (int i = 0; i < siirtoja; ++i)
		{
			cout << siirrot_talteen_alku[i][0] - 14 << " " << siirrot_talteen_alku[i][1] - 14 << " " << siirrot_talteen_loppu[i][0] - 14 << " " << siirrot_talteen_loppu[i][1] - 14 << "\n";
		}
		return 0;
	}
	for (int i = 0; i < 50; ++i)
	{
/*		if (onko_mukavaa_siirtoa == 1)
		{
			// Laittaa uuden pisteen suuntien arvoiksi 1 (vapaa)
			for (int j = 0; j < 4; ++j)
			{
				suunnat[mukava_siirto[4]][mukava_siirto[5]][j] = 1;
			}
			// Merkkaa ruudun käytetyksi
			ruutu[mukava_siirto[4]][mukava_siirto[5]] = 1;
			// Tallettaa siirron
			siirrot_talteen_alku[siirtoja][0] = mukava_siirto[0];
			siirrot_talteen_alku[siirtoja][1] = mukava_siirto[1];
			siirrot_talteen_loppu[siirtoja][0] = mukava_siirto[2];
			siirrot_talteen_loppu[siirtoja][1] = mukava_siirto[3];
			siirtoja++;
			// Merkkaa janan keskipisteisiin tämän suunnan käydyksi
			for (int j = 1; j < 4; ++j)
			{
				if (mukavan_tyyppi == 0)
				{
					suunta_x = j;
					suunta_y = 0;
				}
				suunnat[mukava_siirto[0] + suunta_x][mukava_siirto[1] + suunta_y][mukavan_tyyppi] = 0;
			}
			cout << "(" << mukava_siirto[4] - 14 << " " << mukava_siirto[5] - 14 << ")\n";
//			cin >> onko_mukavaa_siirtoa;
			break;
		}
		else*/ if (pelattava == kirjaimet[i])
		{
			vaihtoehtoja = 0;
			ruutu[koordinaatit[i][0]][koordinaatit[i][1]] = 1;
			for (int j = 0; j < 4; ++j)
			{
				if (mahdollisuus[koordinaatit[i][0]][koordinaatit[i][1]][j] == 1)
				{
					vaihtoehtoja += pow(2, j);
				}
			}

			// Laittaa uuden pisteen suuntien arvoiksi 1
			for (int j = 0; j < 4; ++j)
			{
				suunnat[koordinaatit[i][0]][koordinaatit[i][1]][j] = 1;
			}
//			cout << vaihtoehtoja << "\n";
			cout << pelattava << " ";
			if (vaihtoehtoja%2 == 1)
			{
				cout << "Vaaka (1)";
				valinta = 1;
			}
			if (vaihtoehtoja%4 > 1)
			{
				if (vaihtoehtoja%2 == 1)
				{
					cout << ", "; 
				}
				cout << "Pysty (2)";
				valinta = 2;
			}
			if (vaihtoehtoja%8 > 3)
			{
				if (vaihtoehtoja%4 != 0)
				{
					cout << ", ";
				}
				cout << "Koillis–lounas (3)";
				valinta = 3;
			}
			if (vaihtoehtoja%16 > 7)
			{
				if (vaihtoehtoja != 8)
				{
					cout << ", ";
				}
				cout << "Kaakko–luode (4)";
				valinta = 4;
			}
			cout << "\n";
			if (vaihtoehtoja != 1 && vaihtoehtoja != 2 && vaihtoehtoja != 4 && vaihtoehtoja != 8)
			{
				cout << "Valitse haluamasi suunta: ";
				cin >> valinta;
			}

			if (valinta == 1)
			{
				eteen = 0;
				taakse = 0;
				eteen_0 = 0;
				taakse_0 = 0;
				for (int k = 0; k < 4; ++k)
				{
					if (koordinaatit[i][0] + k + 1 < V && ruutu[koordinaatit[i][0]+k+1][koordinaatit[i][1]] == 1 && suunnat[koordinaatit[i][0]+k+1][koordinaatit[i][1]][0] == 1 && eteen_0 == 0)
					{
						eteen++;
					}
					else
					{
						eteen_0 = 1;
					}

					if (koordinaatit[i][0] - k - 1 >= 0 && ruutu[koordinaatit[i][0]-k-1][koordinaatit[i][1]] == 1 && suunnat[koordinaatit[i][0]-k-1][koordinaatit[i][1]][0] == 1 && taakse_0 == 0)
					{
						taakse++;
					}
					else
					{
						taakse_0 = 1;
					}
				}

				if (eteen + taakse == 4)
				{
					// Tallettaa siirron
					siirrot_talteen_alku[siirtoja][0] = koordinaatit[i][0] - taakse;
					siirrot_talteen_alku[siirtoja][1] = koordinaatit[i][1];
					siirrot_talteen_loppu[siirtoja][0] = koordinaatit[i][0] + eteen;
					siirrot_talteen_loppu[siirtoja][1] = koordinaatit[i][1];
					siirtoja++;
					// Merkkaa janan keskipisteisiin tämän suunnan käydyksi
					for (int j = 1; j < 4; ++j)
					{
						// [x - taakse + j][y][suunta]
						suunnat[koordinaatit[i][0] - taakse + j][koordinaatit[i][1]][0] = 0;
					}
				}
				if (eteen + taakse > 4)
				{
					cout << "Vaihtoehdot:";
					for (int j = 4; j <= eteen + taakse; ++j)
					{
						cout << " [" << j-3 << "]: (" << koordinaatit[i][0] - taakse - 18 + j << " " << koordinaatit[i][1] - 14 << ")";
					}
					cout << "\nValitse alkupiste:";

					// Manuaalinen valinta
//					cin >> alkupiste;
					// Automaattinen valinta
					alkupiste = 1;
					// Etsii mahdollisen reunan, jos löytyy, laittaa mahd. lähelle sitä
					if (suunnat[koordinaatit[i][0]+eteen+1][koordinaatit[i][1]][0] == 1)
					{
						// Suurin mahdollinen
						alkupiste = eteen + taakse - 3;
					}
					cout << alkupiste << "\n";
					// Automaattinen valinta päättyy

					// Merkkaa janan keskipisteisiin, tämän suunnan käydyksi
					for (int k = 0; k < 3; ++k)
					{
						suunnat[koordinaatit[i][0] - taakse + k + alkupiste][koordinaatit[i][1]][0] = 0;
					}
					// Tallettaa siirron
					// alku[x] = x - taakse (+ vakio)
					// alku[y] = y - taakse (+ vakio)
					// loppu[x] = x + eteen (+ vakio)
					// loppu[y] = x + eteen (+ vakio)
					siirrot_talteen_alku[siirtoja][0] = koordinaatit[i][0] - taakse + alkupiste - 1;
					siirrot_talteen_alku[siirtoja][1] = koordinaatit[i][1];
					siirrot_talteen_loppu[siirtoja][0] = koordinaatit[i][0] - taakse + alkupiste + 3;
					siirrot_talteen_loppu[siirtoja][1] = koordinaatit[i][1];
					siirtoja++;
				}
//				cout << eteen << " " << taakse << "\n";
			}
			else if (valinta == 2)
			{
				eteen = 0;
				taakse = 0;
				eteen_0 = 0;
				taakse_0 = 0;
				for (int k = 0; k < 4; ++k)
				{
					if (koordinaatit[i][1] + k + 1 < V && ruutu[koordinaatit[i][0]][koordinaatit[i][1]+k+1] == 1 && suunnat[koordinaatit[i][0]][koordinaatit[i][1]+k+1][1] == 1 && eteen_0 == 0)
					{
						eteen++;
					}
					else
					{
						eteen_0 = 1;
					}

					if (koordinaatit[i][1] - k - 1 >= 0 && ruutu[koordinaatit[i][0]][koordinaatit[i][1]-k-1] == 1 && suunnat[koordinaatit[i][0]][koordinaatit[i][1]-k-1][1] == 1 && taakse_0 == 0)
					{
						taakse++;
					}
					else
					{
						taakse_0 = 1;
					}
				}

				if (eteen + taakse == 4)
				{
					// Tallettaa siirron
					siirrot_talteen_alku[siirtoja][0] = koordinaatit[i][0];
					siirrot_talteen_alku[siirtoja][1] = koordinaatit[i][1] - taakse;
					siirrot_talteen_loppu[siirtoja][0] = koordinaatit[i][0];
					siirrot_talteen_loppu[siirtoja][1] = koordinaatit[i][1] + eteen;
					siirtoja++;
					for (int j = 1; j < 4; ++j)
					{
						suunnat[koordinaatit[i][0]][koordinaatit[i][1] - taakse + j][1] = 0;
					}
				}
				if (eteen + taakse > 4)
				{
					cout << "Vaihtoehdot:";
					for (int j = 4; j <= eteen + taakse; ++j)
					{
						cout << " [" << j-3 << "]: (" << koordinaatit[i][0] - 14 << " " << koordinaatit[i][1] - taakse - 18 + j << ")";
					}
					cout << "\nValitse alkupiste:";

					// Manuaalinen valinta
//					cin >> alkupiste;
					// Automaattinen valinta
					alkupiste = 1;
					// Etsii mahdollisen reunan, jos löytyy, laittaa mahd. lähelle sitä
					if (suunnat[koordinaatit[i][0]][koordinaatit[i][1]+eteen+1][1] == 1)
					{
						// Suurin mahdollinen
						alkupiste = eteen + taakse - 3;
					}
					cout << alkupiste << "\n";
					// Automaattinen valinta päättyy

					for (int k = 0; k < 3; ++k)
					{
						suunnat[koordinaatit[i][0]][koordinaatit[i][1] - taakse + k + alkupiste][1] = 0;
					}
					// Tallettaa siirron
					// alku[x] = x - taakse (+ vakio)
					// alku[y] = y - taakse (+ vakio)
					// loppu[x] = x + eteen (+ vakio)
					// loppu[y] = x + eteen (+ vakio)
					siirrot_talteen_alku[siirtoja][0] = koordinaatit[i][0];
					siirrot_talteen_alku[siirtoja][1] = koordinaatit[i][1] - taakse + alkupiste - 1;
					siirrot_talteen_loppu[siirtoja][0] = koordinaatit[i][0];
					siirrot_talteen_loppu[siirtoja][1] = koordinaatit[i][1] - taakse + alkupiste + 3;
					siirtoja++;
				}
			}
			else if (valinta == 3)
			{
				eteen = 0;
				taakse = 0;
				eteen_0 = 0;
				taakse_0 = 0;
				for (int k = 0; k < 4; ++k)
				{
					// Jos x-koordinaatti + jotain on tarpeeksi pieni &&
					// Jos y-koordinaatti - jotain on riittävän suuri &&
					// Jos ruudussa (x, y) on piste &&
					// Jos ruudun (x, y) kautta ei ole samansuuntaista janaa &&
					// Jos edelliset kohdat toimineet (ts. lopettaa, jos hyppy [xx-x -> vain 2])
					if (koordinaatit[i][0] + k + 1 < V && koordinaatit[i][1] - k - 1 >= 0 && ruutu[koordinaatit[i][0]+k+1][koordinaatit[i][1]-k-1] == 1 && suunnat[koordinaatit[i][0]+k+1][koordinaatit[i][1]-k-1][2] == 1 && eteen_0 == 0)
					{
						eteen++;
					}
					else
					{
						eteen_0 = 1;
					}

					if (koordinaatit[i][0] - k - 1 >= 0 && koordinaatit[i][1] + k + 1 < V && ruutu[koordinaatit[i][0]-k-1][koordinaatit[i][1]+k+1] == 1 && suunnat[koordinaatit[i][0]-k-1][koordinaatit[i][1]+k+1][2] == 1 && taakse_0 == 0)
					{
						taakse++;
					}
					else
					{
						taakse_0 = 1;
					}
				}

				if (eteen + taakse == 4)
				{
					// Tallettaa siirron
					// alku[x] = x - taakse
					// alku[y] = y + taakse
					// loppu[x] = x + eteen
					// loppu[y] = x - eteen
					siirrot_talteen_alku[siirtoja][0] = koordinaatit[i][0] - taakse;
					siirrot_talteen_alku[siirtoja][1] = koordinaatit[i][1] + taakse;
					siirrot_talteen_loppu[siirtoja][0] = koordinaatit[i][0] + eteen;
					siirrot_talteen_loppu[siirtoja][1] = koordinaatit[i][1] - eteen;
					siirtoja++;
					for (int j = 1; j < 4; ++j)
					{
						suunnat[koordinaatit[i][0] - taakse + j][koordinaatit[i][1] + taakse - j][2] = 0;
					}
				}
				if (eteen + taakse > 4)
				{
					cout << "Vaihtoehdot:";
					for (int j = 4; j <= eteen + taakse; ++j)
					{
						cout << " [" << j-3 << "]: (" << koordinaatit[i][0] - taakse - 18 + j << " " << koordinaatit[i][1] - taakse - 18 + j << ")";
					}
					cout << "\nValitse alkupiste:";

					// Manuaalinen valinta
//					cin >> alkupiste;
					// Automaattinen valinta
					alkupiste = 1;
					// Etsii mahdollisen reunan, jos löytyy, laittaa mahd. lähelle sitä
					if (suunnat[koordinaatit[i][0]+eteen+1][koordinaatit[i][1]-eteen-1][2] == 1)
					{
						// Suurin mahdollinen
						alkupiste = eteen + taakse - 3;
					}
					cout << alkupiste << "\n";
					// Automaattinen valinta päättyy

					for (int k = 0; k < 3; ++k)
					{
						suunnat[koordinaatit[i][0] - taakse + k + alkupiste][koordinaatit[i][1] + taakse + k + alkupiste][2] = 0;
					}
					// Tallettaa siirron
					// alku[x] = x - taakse (+ vakio)
					// alku[y] = y - taakse (+ vakio)
					// loppu[x] = x + eteen (+ vakio)
					// loppu[y] = x + eteen (+ vakio)
					siirrot_talteen_alku[siirtoja][0] = koordinaatit[i][0] - taakse + alkupiste - 1;
					siirrot_talteen_alku[siirtoja][1] = koordinaatit[i][1] + taakse + alkupiste - 1;
					siirrot_talteen_loppu[siirtoja][0] = koordinaatit[i][0] - taakse + alkupiste + 3;
					siirrot_talteen_loppu[siirtoja][1] = koordinaatit[i][1] + taakse + alkupiste - 5;
					siirtoja++;
				}
			}
			else if (valinta == 4)
			{
				eteen = 0;
				taakse = 0;
				eteen_0 = 0;
				taakse_0 = 0;
				for (int k = 0; k < 4; ++k)
				{
					// Jos x-koordinaatti + jotain on tarpeeksi pieni &&
					// Jos y-koordinaatti + jotain on tarpeeksi pieni &&
					// Jos ruudussa (x, y) on piste &&
					// Jos ruudun (x, y) kautta ei ole samansuuntaista janaa &&
					// Jos edelliset kohdat toimineet (ts. lopettaa, jos hyppy [xx-x -> vain 2])
					if (koordinaatit[i][0] + k + 1 < V && koordinaatit[i][1] + k + 1 < V && ruutu[koordinaatit[i][0]+k+1][koordinaatit[i][1]+k+1] == 1 && suunnat[koordinaatit[i][0]+k+1][koordinaatit[i][1]+k+1][3] == 1 && eteen_0 == 0)
					{
						eteen++;
					}
					else
					{
						eteen_0 = 1;
					}

					if (koordinaatit[i][0] - k - 1 >= 0 && koordinaatit[i][1] - k - 1 >= 0 && ruutu[koordinaatit[i][0]-k-1][koordinaatit[i][1]-k-1] == 1 && suunnat[koordinaatit[i][0]-k-1][koordinaatit[i][1]-k-1][3] == 1 && taakse_0 == 0)
					{
						taakse++;
					}
					else
					{
						taakse_0 = 1;
					}
				}

				if (eteen + taakse == 4)
				{
					// Tallettaa siirron
					// alku[x] = x - taakse
					// alku[y] = y - taakse
					// loppu[x] = x + eteen
					// loppu[y] = x + eteen
					siirrot_talteen_alku[siirtoja][0] = koordinaatit[i][0] - taakse;
					siirrot_talteen_alku[siirtoja][1] = koordinaatit[i][1] - taakse;
					siirrot_talteen_loppu[siirtoja][0] = koordinaatit[i][0] + eteen;
					siirrot_talteen_loppu[siirtoja][1] = koordinaatit[i][1] + eteen;
					siirtoja++;

					// Merkkaa janan keskipisteisiin, tämän suunnan käydyksi
					for (int j = 1; j < 4; ++j)
					{
						// [x-taakse+j][y-taakse+j]
						suunnat[koordinaatit[i][0] - taakse + j][koordinaatit[i][1] - taakse + j][3] = 0;
					}
				}
				if (eteen + taakse > 4)
				{
					cout << "Vaihtoehdot:";
					for (int j = 4; j <= eteen + taakse; ++j)
					{
						cout << " [" << j-3 << "]: (" << koordinaatit[i][0] - taakse - 18 + j << " " << koordinaatit[i][1] - taakse - 18 + j << ")";
					}
					cout << "\nValitse alkupiste:";

					// Manuaalinen valinta
//					cin >> alkupiste;
					// Automaattinen valinta
					alkupiste = 1;
					// Etsii mahdollisen reunan, jos löytyy, laittaa mahd. lähelle sitä
					if (suunnat[koordinaatit[i][0]+eteen+1][koordinaatit[i][1]+eteen+1][3] == 1)
					{
						// Suurin mahdollinen
						alkupiste = eteen + taakse - 3;
					}
					cout << alkupiste << "\n";
					// Automaattinen valinta päättyy

					for (int k = 0; k < 3; ++k)
					{
						suunnat[koordinaatit[i][0] - taakse + k + alkupiste][koordinaatit[i][1] - taakse + k + alkupiste][3] = 0;
					}
					// Tallettaa siirron
					// alku[x] = x - taakse (+ vakio)
					// alku[y] = y - taakse (+ vakio)
					// loppu[x] = x + eteen (+ vakio)
					// loppu[y] = x + eteen (+ vakio)
					siirrot_talteen_alku[siirtoja][0] = koordinaatit[i][0] - taakse + alkupiste - 1;
					siirrot_talteen_alku[siirtoja][1] = koordinaatit[i][1] - taakse + alkupiste - 1;
					siirrot_talteen_loppu[siirtoja][0] = koordinaatit[i][0] - taakse + alkupiste + 3;
					siirrot_talteen_loppu[siirtoja][1] = koordinaatit[i][1] - taakse + alkupiste + 3;
					siirtoja++;
				}
			}
		}
	}

	goto alku;


	return 0;
}