/*
 *  Copyright 2007,2008 Daniel Blazewicz  
 *
 *  e - mail : klajok @ interia . pl
 */

/*
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *      Niniejszy program jest wolnym oprogramowaniem; mozesz go
 *      rozprowadzac dalej i/lub modyfikowac na warunkach Powszechnej
 *      Licencji Publicznej GNU, wydanej przez Fundacje Wolnego
 *      Oprogramowania - wedlug wersji 2 tej Licencji lub (wedlug twojego
 *      wyboru) ktorejs z pozniejszych wersji.
 *
 *      Niniejszy program rozpowszechniany jest z nadzieja, iz bedzie on
 *      uzyteczny - jednak BEZ JAKIEJKOLWIEK GWARANCJI, nawet domyslnej
 *      gwarancji PRZYDATNOSCI HANDLOWEJ albo PRZYDATNOSCI DO OKRESLONYCH
 *      ZASTOSOWAN. W celu uzyskania blizszych informacji siegnij do
 *      Powszechnej Licencji Publicznej GNU.
 *
 *      Z pewnoscia wraz z niniejszym programem otrzymales tez egzemplarz
 *      Powszechnej Licencji Publicznej GNU (GNU General Public License);
 *      jesli nie - napisz do Free Software Foundation, Inc., 59 Temple
 *      Place, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  przykladowa kompilacja: 
 * 
 *    g++ -Wall -Wextra -O3 -DTEST -DFAST -DUSEDISC -DNDEBUG klotski.cpp -o klotski.x
 * 
 *   FAST   - szuka tylko najkrotszego rozwiazania, gdy nie zdefiniowane
 *            przeszukuje wszystkie mozliwosci dajac kilka informacji wiecej
 *   TEST   - wyswietla dodatkowe informacje odnosnie wykorzystania pamieci
 *  USEDISC - zrzuca wiekszosc konfiguracji na dysk, dla zaoszczedzenia pamieci
 *  NDEBUG  - nie wykonuj makr assert (nie 'debuguj'), gdy nie zdefiniowane
 * 			  wykonuje dodatkowe czynnosci sprawdzajace poprawnosc programu
 */

/*
 *   This program solves some positions of Klotski game
 *  Ten program rozwiazuje niektore z plansz gry Klotski
 *
 *  version: 0.9.0
 *
 */

// jest to pierwsza wersja z uwzglednieniem 'odwrotnego' zapisu konfiguracji
// czyli zamiast zapisywac pozycje wszystkich klockow 1x1 mozna czasem oszczedniej
// postapic zapisujac pozycje wolnych miejsc
// warunek konieczny do tego: klocki 1x1 musza byc zapisane na samym koncu!!!

#include <iostream>
#include <sstream>
#include <string>
#include <assert.h>

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//!!!!!!! PIERWSZA CZESC INICJALIZACJI DANYCH  (SZTYWNA)   !!!!!!!!

//---------  WBUDOWANE OGRANICZENIA PROGRAMU, ISTOTNE!!   -------

//uzycie RAM = (max_N  +  14)  x  max_liczba_konfiguracji [bajtow]

//maksymalny rozmiar konfiguracji spakowanej (liczony w bajtach)
#define max_N_spakowane (2)
//maksymalna liczba konfiguracji, ktora moze byc  rozpatrywana
// (najlepiej, jesli to liczba pierwsza)
//970MB RAM:
//max_N =  7 -> 48500033 (dla nadmiaru 1/4
//         6 -> 52000019 (dla 1/4)
//        10 -> 38976617 (dla nadmiaru 1/2)
//		  12 -> 36216889 (dla nadmiaru 1/2)
//		  15 -> 34931903 (dla nadmiaru 1/4)
//		  20 -> 28043441 (dla nadmiaru 1/2)
#define max_liczba_konfiguracji (485033)
//maksymalna ilosc hashow (= ilosc konf. + nadmiar ok. 2/9 - 1/3 ilosci konf.)
#define max_liczba_hashy ((5*(max_liczba_konfiguracji)) / 4)

//----------------------------------------------------------------

//--------    inne ograniczenia, praktycznie nieistotne  --------
//najwiekszy rozmiar planszy
#define max_plansza_x (16)
#define max_plansza_y (16)
//najwiekszy klocek moze sie skladac z nastepujacej ilosci kwadracikow:
#define max_rozmiar_klocka (255)
//maksymalna liczba rodzajow klockow, ktore wystepuja na planszy
#define max_M (255)
//maksymalna dlugosc opisu slownego klocka
#define max_opis_slowny (255)
//maksymalna odleglosc konfiguracji od konf. poczatkowej
#define max_odl_konf (30000)
//maksymalna liczba warunkow rozwiazania
#define max_l_war_wyjscia (255)
//maksymalna liczba klockow z ktorych sklada sie plansza
#define max_N_rozpakowane (255)

#ifdef TEST
int maks_bitow_przy_pakowaniu = -1;
int maks_bitow_przy_rozpakowaniu = -1;
#endif

//!!!!!!!!!!!!!!!    KONIEC PIERWSZEJ CZESCI      !!!!!!!!!!!!!!!!!
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//-------definicje klockow, konfiguracji, planszy, itp. spraw.-------

typedef unsigned char bajt; //dla oszczednosci przy wielkich tablicach, 1 bajt
typedef unsigned int uint; //dla wygody w hashach, 4 bajty
typedef int typ_plansza[max_plansza_x][max_plansza_y];

//liczba klockow, ktore wystepuja na planszy
int N_rozp = 0;
//liczba bajtow, w ktorych miesci sie spakowany zapis ukladu klockow na planszy
int N_spak = 0;
//liczba rodzajow klockow, ktore wystepuja na planszy
int M = 0;
//opis klockow, ich rozmiarow i ksztaltow
struct klocek {
    int rozmiar, ksztalt[max_rozmiar_klocka][2];
    char opis_slowny[max_opis_slowny];
} klocki[max_M];

//rozmiar planszy
int plansza_x = 0,plansza_y = 0;
//ile jest klockow poszczegolnych rodzajow
int ilosc_danego_rodzaju[max_M];
//nadmiarowa tablica, to przechowywania jaki jest typ klocka
//o ustalonym numerze kolejnym
int rodzaj_klocka[max_N_rozpakowane];
//ilosc konf. zapisanych w tablicy tkonf (globalnie, by nie przekazywac
//ciagle tego parametru)
int ltkonf = 0;
//liczba posuniec
unsigned int lpos = 0;

union konf_rozpakowana {
    bajt r[max_N_rozpakowane];//polozenia kolejnych klockow zakodowane po 4 bity (skad max. 16x16)
};
union konf_spakowana {
    bajt s[max_N_spakowane];//spakowana konfiguracja (p. procedura 'spakuj_konfiguracje')
};

//warunek, kiedy ukladanka jest rozwiazana
struct warunek_wyjscia {
    int nr_klocka;
    int polx, poly;
} wyjscie[max_l_war_wyjscia];

//liczba warunkow, ktore musi spelnic rozwiazanie
int l_war_wyjscia = 0;
//tablica z konfiguracjami klockow, alokowana dynamicznie
konf_spakowana * tkonf_spak;
//tablica z rodzicami, alokowana dynamicznie
int * trodzic;
//tablice hashy dla konfiguracji
int * thash; //thash[hash(nr konf.)] = nr konf.
//ile hashy juz jest w nadmiarowej tablicy hashow (na poczatku 0)
int wierzch_thash = max_liczba_konfiguracji;
int * thash_potomek;
//pierwsza w kolejnosci konf., ktora jest w tablicy hashy
int pierw_w_thash = -1;
//tablica z pozycjami pierwszych konfiguracji o danej odleglosci od poczatkowej
int * todl_konf;
//aktualnie najwieksza odleglosc konf. sposrod juz rozpatrzonych
int najw_odl=-1;

//jesli juz znalazlem rozwiazanie, ustaw na pozycje w tablicy tkonf
int nr_rozw = -1;

//tabelka z minimalna liczba bitow potrzebna do zapisania danej liczby
// np. tlbit[8] = 3, tlbit[32] = 5, tlbit[33] = 6 itp.
//zrobiona dla szybkosci dzialania, bo te dane sa potrzebne wiele milionow razy
const int max_tlbit = max_plansza_x * max_plansza_y;
int tlbit[max_tlbit];

//jest to wykorzystywane tylko i wylacznie podczas pakowania i rozpakowywania konfiguracji:
//czy wykorzystujemy konfiguracje 'odwrotne', domyslnie: nie.
bool odwrotne = false;
//N_rozp wynikajacy z uzycia 'odwrotnego' zapisu
int N_rozp_w_praktyce = -1;
//liczba klockow bez klockow 1x1;
int N_rozp_bez_1x1 = -1;
//liczba klockow 1x1 i wolnych miejsc na planszy
int liczba_wolnych_miejsc = -1;

//-------------------pomocne procedury------------------------

void inicjuj_tlbit(){
int lbit = 0;
int potega_2 = 1; //2^0 = 1;

for (int i = 0; i < max_tlbit; ++i) {
	if (i > potega_2) {
		potega_2 *= 2;
		++lbit;
	}
	tlbit[i] = lbit;
}
}

void inicjuj_odwrotne(){

	//zakladamy, ze jako ostatnie zdefiniowane sa klocki 1x1
	assert (klocki[M-1].rozmiar == 1);

	N_rozp_bez_1x1 =  N_rozp - ilosc_danego_rodzaju[M-1];

	//liczba wolnych miejsc jest suma rzeczywiscie wolnych miejsc i tych zajmowanych przez klocki 1x1
	liczba_wolnych_miejsc = plansza_x * plansza_y;
	for (int i = 0; i < M-1; ++i)
		liczba_wolnych_miejsc -= klocki[i].rozmiar * ilosc_danego_rodzaju[i];

	N_rozp_w_praktyce = N_rozp_bez_1x1 + liczba_wolnych_miejsc - ilosc_danego_rodzaju[M-1];
	
	//std::cerr << "inicjuj odwrotne: " << N_rozp_bez_1x1 << " " << liczba_wolnych_miejsc << " " << N_rozp_w_praktyce <<"\n";

}

std::string * plansza_do_napis(const typ_plansza * plansza, std::string * napis);

konf_spakowana * spakuj_konfiguracje_odwrotne(const konf_rozpakowana * rozp, konf_spakowana * spak){

	static typ_plansza plansza;
	for (int i = 0; i < plansza_x; ++i)
		for (int j = 0; j < plansza_y; ++j)
			plansza[i][j] = 0;

	for (int i = 0; i < N_spak; ++i)
		(*spak).s[i] = 0;

	bajt l_mozliwych_polozen[N_rozp_w_praktyce]; //liczba polozen, w ktorych moze byc ten klocek umieszczony na planszy
	bajt numer_polozenia[N_rozp_w_praktyce]; //numer kolejny polozenia klocka na rozpatrywanej planszy


    for (int  i = 0; i < N_rozp_bez_1x1; ++i) {

        int typ_klocka = rodzaj_klocka[i];
        int rozmiar = klocki[typ_klocka].rozmiar - 1;//-1 dla wygody
        int orig_wsp_x = int((*rozp).r[i] & 15);
        int orig_wsp_y = int((*rozp).r[i] >> 4);

		l_mozliwych_polozen[i] = 0;

		for (int wsp_x = 0; wsp_x < plansza_x; ++wsp_x)
			for (int wsp_y = 0; wsp_y < plansza_y; ++wsp_y) {

				bool tutaj_moze_byc = true;

            	if (plansza[wsp_x][wsp_y] != 0) {
           			tutaj_moze_byc = false;
           			continue;
		    	}

	        	for (int k = 0; k < rozmiar; ++k){

	        		int wsp_x_kawalka = wsp_x + klocki[typ_klocka].ksztalt[k][0];
	        		int wsp_y_kawalka = wsp_y + klocki[typ_klocka].ksztalt[k][1];

	            	if ((wsp_x_kawalka >= plansza_x) ||
	                	(wsp_y_kawalka >= plansza_y) ||
            	    	(wsp_x_kawalka < 0) ||
            	    	(wsp_y_kawalka < 0) ||
                    	(plansza[wsp_x_kawalka][wsp_y_kawalka] != 0)) {
               			tutaj_moze_byc = false;
               			break;
			    	}
                
            	}
				
				if ((wsp_x == orig_wsp_x) && (wsp_y == orig_wsp_y)) 
					numer_polozenia[i] = l_mozliwych_polozen[i]; //liczony od zera

				if (tutaj_moze_byc)
				  	++l_mozliwych_polozen[i];

			}

		assert(l_mozliwych_polozen[i] > 0);

        plansza[orig_wsp_x][orig_wsp_y] = i + 1;
       	for (int k = 0; k < rozmiar; ++k)
            plansza[orig_wsp_x + klocki[typ_klocka].ksztalt[k][0]]
                   [orig_wsp_y + klocki[typ_klocka].ksztalt[k][1]] = i + 1;
    }
	
	//zaznacz na planszy miejsca klockow 1x1 (pozostale miejsca sa juz na pewno wolne)
    for (int  i = N_rozp_bez_1x1; i < N_rozp; ++i) 
        plansza [ int((*rozp).r[i] & 15) ] [ int((*rozp).r[i] >> 4) ] = -1;
        
    int nr_odwrotnego_klocka = N_rozp_bez_1x1;
    int efektywna_liczba_wolnych_miejsc = liczba_wolnych_miejsc;
    int aktualna_pozycja_odwrotnego_klocka = 0;

	for (int wsp_y = 0; wsp_y < plansza_y; ++wsp_y)
		for (int wsp_x = 0; wsp_x < plansza_x; ++wsp_x) {

			int co_tu_jest = plansza[wsp_x][wsp_y];

           	if (co_tu_jest == -1) { //miejsce zajete przez klocek 1x1
           		aktualna_pozycja_odwrotnego_klocka++;
           		continue;
			}
            	
           	if (co_tu_jest == 0) { //miejsce 'odwrotnego' klocka
           		l_mozliwych_polozen[nr_odwrotnego_klocka] = efektywna_liczba_wolnych_miejsc;
           		efektywna_liczba_wolnych_miejsc -= aktualna_pozycja_odwrotnego_klocka + 1;
           		numer_polozenia[nr_odwrotnego_klocka] = aktualna_pozycja_odwrotnego_klocka;
           		aktualna_pozycja_odwrotnego_klocka = 0;
           		nr_odwrotnego_klocka++;
			}
	}

	assert(nr_odwrotnego_klocka == N_rozp_w_praktyce);
	assert(aktualna_pozycja_odwrotnego_klocka == efektywna_liczba_wolnych_miejsc);

	//do testowania i do assercji
	int suma_bitow = 0;

	for (int i = N_rozp_w_praktyce - 1; i >= 0; --i) {

		bajt a=numer_polozenia[i];
		int liczba_bitow = tlbit[ l_mozliwych_polozen[i] ];

		suma_bitow += liczba_bitow;
		
		for (int j = 0; j < N_spak; ++j) {
			bajt b = (*spak).s[j] >> (8 - liczba_bitow); //to przejdzie do nastepnego bajtu
			(*spak).s[j] <<= liczba_bitow;
			(*spak).s[j] |= a;
			a = b;
		}
	}

	assert (suma_bitow <= 8 * N_spak);

#ifdef TEST
	if (maks_bitow_przy_pakowaniu < suma_bitow) 
 		maks_bitow_przy_pakowaniu = suma_bitow;
#endif
	 		/* static std::string napis;
	 		std::cout << "Spakuj odwrotnie: " << (*plansza_do_napis(&plansza, &napis));
	 		std::cout << "Spakowana odwrotnie do: ";
	 		for (int i =0; i < N_spak; ++i)
	 			 std::cout<<(unsigned int)(*spak).s[i] << " ";
	 		std::cout<<"\n"; */

	return spak;
	
}

konf_rozpakowana * rozpakuj_konfiguracje_odwrotne(const konf_spakowana * spak_, konf_rozpakowana * rozp, typ_plansza * plansza){

#ifdef TEST
	int suma_bitow = 0;
#endif

	for (int i = 0; i < plansza_x; ++i)
		for (int j = 0; j < plansza_y; ++j)
			(*plansza)[i][j] = 0;
	
	konf_spakowana spak;
	for (int i = 0; i < N_spak; ++i)
		spak.s[i] = (*spak_).s[i];

    for (int  i = 0; i < N_rozp_bez_1x1; ++i) {

		bajt l_mozliwych_polozen = 0; //liczba polozen, w ktorych moze byc ten klocek umieszczony na planszy

        int typ_klocka = rodzaj_klocka[i];
        int rozmiar = klocki[typ_klocka].rozmiar - 1;//-1 dla wygody

		for (int wsp_x = 0; wsp_x < plansza_x; ++wsp_x)
			for (int wsp_y = 0; wsp_y < plansza_y; ++wsp_y) {

				bool tutaj_moze_byc = true;

            	if ((*plansza)[wsp_x][wsp_y] != 0) {
           			tutaj_moze_byc = false;
           			continue;
		    	}

	        	for (int k = 0; k < rozmiar; ++k){

	        		int wsp_x_kawalka = wsp_x + klocki[typ_klocka].ksztalt[k][0];
	        		int wsp_y_kawalka = wsp_y + klocki[typ_klocka].ksztalt[k][1];

	            	if ((wsp_x_kawalka >= plansza_x) ||
	                	(wsp_y_kawalka >= plansza_y) ||
            	    	(wsp_x_kawalka < 0) ||
            	    	(wsp_y_kawalka < 0) ||
                    	((*plansza)[wsp_x_kawalka][wsp_y_kawalka] != 0)) {
               			tutaj_moze_byc = false;
               			break;
			    	}
                
            	}

				if (tutaj_moze_byc)
				  	++l_mozliwych_polozen;

			}

		assert(l_mozliwych_polozen > 0);

		int liczba_bitow = tlbit[ l_mozliwych_polozen ];
#ifdef TEST
  		suma_bitow += liczba_bitow;
#endif
		
		bajt a = 0;

		for (int j = N_spak - 1; j >= 0; --j) {
			bajt b = spak.s[j] & ((1 << liczba_bitow) - 1); //to przejdzie do poprzedniego bajtu
			spak.s[j] >>= liczba_bitow;
			spak.s[j] |= a << (8 - liczba_bitow);
			a = b;
		}

		bajt numer_polozenia = a;
		l_mozliwych_polozen = 0;
		
		bool juz_wypelnilem_tym_klockiem = false;
		for (int wsp_x = 0; wsp_x < plansza_x; ++wsp_x) {

			if (juz_wypelnilem_tym_klockiem)
				break;

			for (int wsp_y = 0; wsp_y < plansza_y; ++wsp_y) {

				bool tutaj_moze_byc = true;

            	if ((*plansza)[wsp_x][wsp_y] != 0) {
           			tutaj_moze_byc = false;
           			continue;
		    	}

	        	for (int k = 0; k < rozmiar; ++k){

	        		int wsp_x_kawalka = wsp_x + klocki[typ_klocka].ksztalt[k][0];
	        		int wsp_y_kawalka = wsp_y + klocki[typ_klocka].ksztalt[k][1];

	            	if ((wsp_x_kawalka >= plansza_x) ||
	                	(wsp_y_kawalka >= plansza_y) ||
            	    	(wsp_x_kawalka < 0) ||
            	    	(wsp_y_kawalka < 0) ||
                    	((*plansza)[wsp_x_kawalka][wsp_y_kawalka] != 0)) {
               			tutaj_moze_byc = false;
               			break;
			    	}
                
            	}

				if (tutaj_moze_byc) {

					if (l_mozliwych_polozen == numer_polozenia) {

				        (*plansza)[wsp_x][wsp_y] = i + 1;
       					for (int k = 0; k < rozmiar; ++k)
            				(*plansza)[wsp_x + klocki[typ_klocka].ksztalt[k][0]]
                   				      [wsp_y + klocki[typ_klocka].ksztalt[k][1]] = i + 1;
                   		
                   		(*rozp).r[i] = wsp_x + (wsp_y << 4);

						juz_wypelnilem_tym_klockiem = true;
						break;
					}

				  	++l_mozliwych_polozen;

				}

			}
		}
	}

    int nr_odwrotnego_klocka = N_rozp_bez_1x1;
    int nr_klocka_1x1 = N_rozp_bez_1x1;
    int efektywna_liczba_wolnych_miejsc = liczba_wolnych_miejsc;

	int liczba_bitow = tlbit[efektywna_liczba_wolnych_miejsc];
#ifdef TEST
	suma_bitow += liczba_bitow;
#endif
		
	bajt a = 0;
	for (int j = N_spak - 1; j >= 0; --j) {
		bajt b = spak.s[j] & ((1 << liczba_bitow) - 1); //to przejdzie do poprzedniego bajtu
		spak.s[j] >>= liczba_bitow;
		spak.s[j] |= a << (8 - liczba_bitow);
		a = b;
	}
	bajt pozycja_odwrotnego_klocka = a;
    int aktualna_pozycja_odwrotnego_klocka = 0;

	for (int wsp_y = 0; wsp_y < plansza_y; ++wsp_y) 
		for (int wsp_x = 0; wsp_x < plansza_x; ++wsp_x)
			if ((*plansza)[wsp_x][wsp_y] == 0)
				
				if (pozycja_odwrotnego_klocka == aktualna_pozycja_odwrotnego_klocka) {

				    nr_odwrotnego_klocka++;
				    if (nr_odwrotnego_klocka < N_rozp_w_praktyce) {
	           			efektywna_liczba_wolnych_miejsc -= aktualna_pozycja_odwrotnego_klocka + 1;
						liczba_bitow = tlbit[efektywna_liczba_wolnych_miejsc];
#ifdef TEST
						suma_bitow += liczba_bitow;
#endif
						a = 0;
						for (int j = N_spak - 1; j >= 0; --j) {
							bajt b = spak.s[j] & ((1 << liczba_bitow) - 1); //to przejdzie do poprzedniego bajtu
							spak.s[j] >>= liczba_bitow;
							spak.s[j] |= a << (8 - liczba_bitow);
							a = b;
						}
						pozycja_odwrotnego_klocka = a;
						aktualna_pozycja_odwrotnego_klocka = 0;
					} else 
						pozycja_odwrotnego_klocka = (max_plansza_x * max_plansza_y - 1); //wiecej 'odwrotnych' klockow juz nie ma

				} else {

					(*rozp).r[nr_klocka_1x1] = wsp_x + (wsp_y << 4);
					nr_klocka_1x1++;
					(*plansza)[wsp_x][wsp_y] = nr_klocka_1x1;
					aktualna_pozycja_odwrotnego_klocka++;

				}

	assert(nr_odwrotnego_klocka == N_rozp_w_praktyce);
	assert(nr_klocka_1x1 == N_rozp);
	assert(aktualna_pozycja_odwrotnego_klocka+1 == efektywna_liczba_wolnych_miejsc);
	assert(pozycja_odwrotnego_klocka == (max_plansza_x * max_plansza_y - 1));

#ifdef TEST
	if (maks_bitow_przy_rozpakowaniu < suma_bitow) 
 		maks_bitow_przy_rozpakowaniu = suma_bitow;
	assert (suma_bitow <= 8 * N_spak);
#endif
	 		/* static std::string napis;
	 		std::cout << "Rozpakuj odwrotne: ";
	 		for (int i =0; i < N_spak; ++i)
	 			 std::cout<<(unsigned int)((*spak_).s[i]) << " ";
	 		std::cout<<"\n";
	 		std::cout << "Rozpakowane odwrotne do: " << (*plansza_do_napis(plansza, &napis)); */

	return rozp;
	
}

konf_spakowana * spakuj_konfiguracje(const konf_rozpakowana * rozp, konf_spakowana * spak){

	if (odwrotne)
		return spakuj_konfiguracje_odwrotne(rozp, spak);

	typ_plansza plansza;
	for (int i = 0; i < plansza_x; ++i)
		for (int j = 0; j < plansza_y; ++j)
			plansza[i][j] = 0;

	for (int i = 0; i < N_spak; ++i)
		(*spak).s[i] = 0;

	bajt l_mozliwych_polozen[N_rozp]; //liczba polozen, w ktorych moze byc ten klocek umieszczony na planszy
	bajt numer_polozenia[N_rozp]; //numer kolejny polozenia klocka na rozpatrywanej planszy

    for (int  i = 0; i < N_rozp; ++i) {

        int typ_klocka = rodzaj_klocka[i];
        int rozmiar = klocki[typ_klocka].rozmiar - 1;//-1 dla wygody
        int orig_wsp_x = int((*rozp).r[i] & 15);
        int orig_wsp_y = int((*rozp).r[i] >> 4);

		l_mozliwych_polozen[i] = 0;

		for (int wsp_x = 0; wsp_x < plansza_x; ++wsp_x)
			for (int wsp_y = 0; wsp_y < plansza_y; ++wsp_y) {

				bool tutaj_moze_byc = true;

            	if (plansza[wsp_x][wsp_y] != 0) {
           			tutaj_moze_byc = false;
           			continue;
		    	}

	        	for (int k = 0; k < rozmiar; ++k){

	        		int wsp_x_kawalka = wsp_x + klocki[typ_klocka].ksztalt[k][0];
	        		int wsp_y_kawalka = wsp_y + klocki[typ_klocka].ksztalt[k][1];

	            	if ((wsp_x_kawalka >= plansza_x) ||
	                	(wsp_y_kawalka >= plansza_y) ||
            	    	(wsp_x_kawalka < 0) ||
            	    	(wsp_y_kawalka < 0) ||
                    	(plansza[wsp_x_kawalka][wsp_y_kawalka] != 0)) {
               			tutaj_moze_byc = false;
               			break;
			    	}
                
            	}
				
				if ((wsp_x == orig_wsp_x) && (wsp_y == orig_wsp_y)) 
					numer_polozenia[i] = l_mozliwych_polozen[i]; //liczony od zera

				if (tutaj_moze_byc)
				  	++l_mozliwych_polozen[i];

			}

		assert(l_mozliwych_polozen[i] > 0);

        plansza[orig_wsp_x][orig_wsp_y] = i + 1;
       	for (int k = 0; k < rozmiar; ++k)
            plansza[orig_wsp_x + klocki[typ_klocka].ksztalt[k][0]]
                   [orig_wsp_y + klocki[typ_klocka].ksztalt[k][1]] = i + 1;
    }
	
	//do testowania i do assercji
	int suma_bitow = 0;

	for (int i = N_rozp - 1; i >= 0; --i) {

		bajt a=numer_polozenia[i];
		int liczba_bitow = tlbit[ l_mozliwych_polozen[i] ];

		suma_bitow += liczba_bitow;
		
		for (int j = 0; j < N_spak; ++j) {
			bajt b = (*spak).s[j] >> (8 - liczba_bitow); //to przejdzie do nastepnego bajtu
			(*spak).s[j] <<= liczba_bitow;
			(*spak).s[j] |= a;
			a = b;
		}
	}

	assert (suma_bitow <= 8 * N_spak);

#ifdef TEST
	if (maks_bitow_przy_pakowaniu < suma_bitow) 
 		maks_bitow_przy_pakowaniu = suma_bitow;
#endif
	 		/*static std::string napis;
	 		std::cout << "Spakuj: " << (*plansza_do_napis(&plansza, &napis));
	 		std::cout << "Spakowana do: ";
	 		for (int i =0; i < N_spak; ++i)
	 			 std::cout<<(unsigned int)(*spak).s[i];
	 		std::cout<<"\n";*/

	return spak;
	
}

konf_rozpakowana * rozpakuj_konfiguracje(const konf_spakowana * spak_, konf_rozpakowana * rozp, typ_plansza * plansza){

	if (odwrotne)
		return rozpakuj_konfiguracje_odwrotne(spak_, rozp, plansza);

#ifdef TEST
	int suma_bitow = 0;
#endif

	for (int i = 0; i < plansza_x; ++i)
		for (int j = 0; j < plansza_y; ++j)
			(*plansza)[i][j] = 0;
	
	konf_spakowana spak;
	for (int i = 0; i < N_spak; ++i)
		spak.s[i] = (*spak_).s[i];

    for (int  i = 0; i < N_rozp; ++i) {

		bajt l_mozliwych_polozen = 0; //liczba polozen, w ktorych moze byc ten klocek umieszczony na planszy

        int typ_klocka = rodzaj_klocka[i];
        int rozmiar = klocki[typ_klocka].rozmiar - 1;//-1 dla wygody

		for (int wsp_x = 0; wsp_x < plansza_x; ++wsp_x)
			for (int wsp_y = 0; wsp_y < plansza_y; ++wsp_y) {

				bool tutaj_moze_byc = true;

            	if ((*plansza)[wsp_x][wsp_y] != 0) {
           			tutaj_moze_byc = false;
           			continue;
		    	}

	        	for (int k = 0; k < rozmiar; ++k){

	        		int wsp_x_kawalka = wsp_x + klocki[typ_klocka].ksztalt[k][0];
	        		int wsp_y_kawalka = wsp_y + klocki[typ_klocka].ksztalt[k][1];

	            	if ((wsp_x_kawalka >= plansza_x) ||
	                	(wsp_y_kawalka >= plansza_y) ||
            	    	(wsp_x_kawalka < 0) ||
            	    	(wsp_y_kawalka < 0) ||
                    	((*plansza)[wsp_x_kawalka][wsp_y_kawalka] != 0)) {
               			tutaj_moze_byc = false;
               			break;
			    	}
                
            	}

				if (tutaj_moze_byc)
				  	++l_mozliwych_polozen;

			}

		assert(l_mozliwych_polozen > 0);

		int liczba_bitow = tlbit[ l_mozliwych_polozen ];
#ifdef TEST
  		suma_bitow += liczba_bitow;
#endif
		
		bajt a = 0;

		for (int j = N_spak - 1; j >= 0; --j) {
			bajt b = spak.s[j] & ((1 << liczba_bitow) - 1); //to przejdzie do poprzedniego bajtu
			spak.s[j] >>= liczba_bitow;
			spak.s[j] |= a << (8 - liczba_bitow);
			a = b;
		}

		bajt numer_polozenia = a;
		l_mozliwych_polozen = 0;
		
		bool juz_wypelnilem_tym_klockiem = false;
		for (int wsp_x = 0; wsp_x < plansza_x; ++wsp_x) {

			if (juz_wypelnilem_tym_klockiem)
				break;

			for (int wsp_y = 0; wsp_y < plansza_y; ++wsp_y) {

				bool tutaj_moze_byc = true;

            	if ((*plansza)[wsp_x][wsp_y] != 0) {
           			tutaj_moze_byc = false;
           			continue;
		    	}

	        	for (int k = 0; k < rozmiar; ++k){

	        		int wsp_x_kawalka = wsp_x + klocki[typ_klocka].ksztalt[k][0];
	        		int wsp_y_kawalka = wsp_y + klocki[typ_klocka].ksztalt[k][1];

	            	if ((wsp_x_kawalka >= plansza_x) ||
	                	(wsp_y_kawalka >= plansza_y) ||
            	    	(wsp_x_kawalka < 0) ||
            	    	(wsp_y_kawalka < 0) ||
                    	((*plansza)[wsp_x_kawalka][wsp_y_kawalka] != 0)) {
               			tutaj_moze_byc = false;
               			break;
			    	}
                
            	}

				if (tutaj_moze_byc) {

					if (l_mozliwych_polozen == numer_polozenia) {

				        (*plansza)[wsp_x][wsp_y] = i + 1;
       					for (int k = 0; k < rozmiar; ++k)
            				(*plansza)[wsp_x + klocki[typ_klocka].ksztalt[k][0]]
                   				      [wsp_y + klocki[typ_klocka].ksztalt[k][1]] = i + 1;
                   		
                   		(*rozp).r[i] = wsp_x + (wsp_y << 4);

						juz_wypelnilem_tym_klockiem = true;
						break;
					}

				  	++l_mozliwych_polozen;

				}

			}
		}
	}

#ifdef TEST
	if (maks_bitow_przy_rozpakowaniu < suma_bitow) 
 		maks_bitow_przy_rozpakowaniu = suma_bitow;
	assert (suma_bitow <= 8 * N_spak);
#endif
	 		/*static std::string napis;
	 		std::cout << "Rozpakuj: ";
	 		for (int i =0; i < N_spak; ++i)
	 			 std::cout<<(unsigned int)((*spak_).s[i]);
	 		std::cout<<"\n";
	 		std::cout << "Rozpakowane do: " << (*plansza_do_napis(plansza, &napis));*/

	return rozp;
	
}

int todl(const int pozycja) {
  //algorytm prymitywny, ale powinien w zupelnosci wystarczyc (jak na razie)

  assert(pozycja < ltkonf);

  for(int i = najw_odl; i >= 0; --i)
  	if(todl_konf[i] <= pozycja)
  		return i;
  		
  //nigdy tutaj nie powinnismy dojsc...
  assert(0 > 1);
  return -1;
  

}

void kopiuj_konf_spak(const int pozycja_zrodlo, const int pozycja_cel){
    //kopiuje konfiguracje w tablicy tkonf_spak

	assert(pozycja_cel < ltkonf);
	assert(pozycja_cel >= 0);
    
    for (int i = 0; i < N_spak; ++i) 
        tkonf_spak[pozycja_cel].s[i] = tkonf_spak[pozycja_zrodlo].s[i];
}

void kopiuj_konf_rozp(const konf_rozpakowana * zrodlo, konf_rozpakowana * cel){
    //kopiuje rozpakowane konfiguracje, nic nie sprawdza
    
    for (int i = 0; i < N_rozp; ++i) 
        (*cel).r[i] = (*zrodlo).r[i];
}

void kopiuj_konf_spak(const konf_spakowana * zrodlo, konf_spakowana * cel){
    //kopiuje spakowane konfiguracje, nic nie sprawdza
    
    for (int i = 0; i < N_spak; ++i) 
        (*cel).s[i] = (*zrodlo).s[i];
}

int sortuj_klocki(konf_rozpakowana * rozp, const int nr_klocka){
    //sortuje klocki o typie takim samym jak typ nr_klocka
    //jesli nic nie zmieniono zwraca 0, w przeciwnym wypadku 1.

    int ilosc = ilosc_danego_rodzaju[rodzaj_klocka[nr_klocka]];
    if ( ilosc < 2) return 0; //nie ma co sortowac

    int poz1 = 0;//pozycja pierwszego klocka o tym samym typie
    for (int i = 0; i < N_rozp; ++i){
        poz1 = i;
        if (rodzaj_klocka[i] == rodzaj_klocka[nr_klocka]) break;
    }

    //wlasciwy moment sortowania
    bajt pol = (*rozp).r[nr_klocka];

    int nowe_polozenie = poz1;
    //moze trzeba przesunac w lewo?
    for (int i = nr_klocka - 1; i >= poz1; --i)
        if ( (*rozp).r[i] < pol ) {
            nowe_polozenie = i + 1;
            break;
        }

    if (nowe_polozenie == nr_klocka) {//skoro nie w lewo, to moze trzeba przesunac w prawo?
        nowe_polozenie = poz1 + ilosc - 1;
        for (int i = nr_klocka + 1; i < poz1 + ilosc; ++i)
            if ( (*rozp).r[i] > pol ) {
                nowe_polozenie = i - 1;
                break;
            }
    }
    
    if (nowe_polozenie == nr_klocka) return 0; //nie trzeba nic przesuwac

    if (nowe_polozenie < nr_klocka){ //przesuwamy w lewo
        for (int i = nr_klocka; i > nowe_polozenie; --i)
            (*rozp).r[i] = (*rozp).r[i-1];
        (*rozp).r[nowe_polozenie] = pol;
    } else { //przesuwamy w prawo
        for (int i = nr_klocka; i < nowe_polozenie; ++i)
            (*rozp).r[i] = (*rozp).r[i+1];
        (*rozp).r[nowe_polozenie] = pol;
    }
    return 1;
}

int wylicz_hash(const int nr_konf){

assert(nr_konf < ltkonf);
assert(nr_konf >= 0);

    //wylicza hash dla zadanej konfiguracji i go zwraca
    konf_spakowana * badana = &(tkonf_spak[nr_konf]);

    int j = 0;
    uint x[(N_spak+3)/4], y=0;
    for (int i=0; i<N_spak; ++i) {

    	++j; if (j > 16) j=1;

		switch (j & 3) {

		case 0:
			y+= uint((*badana).s[i]) << 24;
			x[i>>2] = (y << (j>>1)) + (y >> (32-(j>>1))); // eqv. to: y rotate_left (j/2)
			break;

		case 1:
			y = uint((*badana).s[i]);
			break;

		case 2:
			y += uint((*badana).s[i]) << 8;
			break;

		case 3:
			y += uint((*badana).s[i]) << 16;
			break;

		}

    }

    if (j & 3) {
		x[(N_spak-1)/4] = (y << 5) + (y >> 27);
    }

    uint hash = x[0];
    for (int i=1; i<(N_spak+3)/4; ++i)
      hash = hash xor x[i];
    return hash % max_liczba_konfiguracji;
}

void dodaj_hash(const int pozycja) {
    //dodaje wpis to tablicy hashow dla 'pozycja'-tej konfiguracji

assert(pozycja < ltkonf);
assert(pozycja >= 0);

    int poz = wylicz_hash(pozycja);

assert(poz < max_liczba_hashy);
assert(poz >= 0);

    if (thash[poz] == -1)
        thash[poz] = pozycja;
    else {
        if (wierzch_thash == max_liczba_hashy) {
            std::cerr << "Brak pamieci na nowe hashe!\n";
            exit(-2);
        }
        while (thash_potomek[poz] != -1)
            poz = thash_potomek[poz];

assert(poz < max_liczba_hashy);
assert(poz >= 0);

        thash_potomek[poz] = wierzch_thash;

assert(wierzch_thash < max_liczba_hashy);
assert(wierzch_thash >= max_liczba_konfiguracji);

        thash[wierzch_thash] = pozycja;

        wierzch_thash++;
    }
}

int rodzic(const int poz){
//funkcja zwraca rodzica w liscie jednokierunkowej dla elementu 'poz' tablicy hashy
	assert(poz >= max_liczba_konfiguracji);
	assert(poz < max_liczba_hashy);
	int poz_prim=wylicz_hash( thash[poz] );
	assert(thash[poz_prim] >= 0);
	int rodzic_prim=poz_prim;
	poz_prim=thash_potomek[poz_prim];
	assert( poz_prim >= max_liczba_konfiguracji );
	assert( poz_prim < max_liczba_hashy );
	while (poz_prim != poz) {
		rodzic_prim=poz_prim;
		poz_prim=thash_potomek[poz_prim];
		assert( poz_prim >= max_liczba_konfiguracji );
		assert( poz_prim < max_liczba_hashy );
	}
	return rodzic_prim;
}

int poz_w_thash(const int pozycja){
	//funkcja znajduje 'poz' w thash, ktore wskazuje na konf. o numerze 'pozycja'
    if (pozycja < pierw_w_thash) return -1;
	assert(pozycja < ltkonf);

    int poz = wylicz_hash(pozycja);
	assert(poz < max_liczba_konfiguracji);
	assert(poz >= 0);
    while (thash[poz] != pozycja) {
       	poz = thash_potomek[poz];
		assert(poz >= max_liczba_konfiguracji);
		assert(poz < max_liczba_hashy);
    }
    return poz;

}

void usun_hash(const int pozycja_){
    
	assert(pozycja_ < ltkonf);

    for (int pozycja = pozycja_; pozycja >= pierw_w_thash; --pozycja) {

	    int poz_rodzica = -1;
        int poz = wylicz_hash(pozycja);

        while (thash[poz] != pozycja) {
        	poz_rodzica = poz;
        	poz = thash_potomek[poz];
			assert(poz >= max_liczba_konfiguracji);
			assert(poz < max_liczba_hashy);
        }

assert(poz < max_liczba_hashy);
assert(poz >= 0);

        if (poz >= max_liczba_konfiguracji) {

assert(poz_rodzica >= 0);
assert(thash_potomek[poz] < max_liczba_hashy);

            thash_potomek[ poz_rodzica ] = thash_potomek[poz];

            wierzch_thash--;

assert(wierzch_thash < max_liczba_hashy);
assert(wierzch_thash >= 0);

            if (poz < wierzch_thash) {
                thash[poz] = thash[wierzch_thash];
                thash_potomek[poz] = thash_potomek[wierzch_thash];
                thash_potomek[ rodzic(wierzch_thash) ] = poz;
            }
            thash[wierzch_thash] = -1;
            thash_potomek[wierzch_thash] = -1;

        } else {

            if (thash_potomek[poz] == -1)

                thash[poz] = -1;

            else {

                int poz_pot = thash_potomek[poz];

assert(poz_pot < max_liczba_hashy);
assert(poz_pot >= max_liczba_konfiguracji);

                thash[poz] = thash[poz_pot];
                thash_potomek[poz] = thash_potomek[poz_pot];

assert(thash[poz] < ltkonf);
assert(thash[poz] >= 0);

                wierzch_thash--;

assert(wierzch_thash < max_liczba_hashy);
assert(wierzch_thash >= max_liczba_konfiguracji);

                if (poz_pot < wierzch_thash) {
                    thash[poz_pot] = thash[wierzch_thash];
                    thash_potomek[poz_pot] = thash_potomek[wierzch_thash];

                    thash_potomek[ rodzic(wierzch_thash) ] = poz_pot;

                }
                thash[wierzch_thash] = -1;
                thash_potomek[wierzch_thash] = -1;
            }

        }
    }

	if (pozycja_ >= pierw_w_thash)
    	pierw_w_thash = pozycja_+1;

}

void sortuj_konfiguracje(konf_rozpakowana * konf){
    //ustala 'normalna' postac zapisu danej konfiguracji
    //sortuje wszystkie klocki po kolei, co zwykle nie jest najwydajniejsze
    int zmieniono=1;
    while (zmieniono) {
    	zmieniono=0;
    	for (int i = 0; i < N_rozp; ++i)
        	zmieniono+=sortuj_klocki(konf, i);
    }
}

bool identyczne_konfiguracje(const int pierwsza, const int druga) {
    //zwraca prawde, jesli konfiguracje sa identyczne

assert(pierwsza < ltkonf);
assert(pierwsza >= 0);
assert(druga < ltkonf);
assert(druga >= 0);
    
    for (int j = 0; j < N_spak; ++j)
        if (tkonf_spak[pierwsza].s[j] != tkonf_spak[druga].s[j])
            return false;
    return true;
}

int nowa_konfiguracja (const int pozycja){
    //zwraca -1 jesli tkonf[pozycja] jest nowa, lub numer konf, ktora juz jest
    int poz = wylicz_hash(pozycja);

assert(poz < max_liczba_konfiguracji);
assert(poz >= 0);

    if (thash[poz] == -1 ) return -1;

    //moze to ta konfiguracja, co w tablicy hashow?
    do {

assert(poz < max_liczba_hashy);
assert(poz >= 0);

        int konf = thash[poz];
        if ( identyczne_konfiguracje(konf, pozycja) )
            return konf;
        poz = thash_potomek[poz];
    } while (poz != -1);

    return -1;
}
bool dobra_konfiguracja(const konf_rozpakowana * konf){

    typ_plansza plansza;
    //wyczysc plansze
    for (int i = 0; i < plansza_x; ++i)
        for (int j = 0; j < plansza_y; ++j)
            plansza[i][j] = 0;
    //zapisz pozycje klockow na planszy
    for (int  i = 0; i < N_rozp; ++i) {
        int typ_klocka = rodzaj_klocka[i];
        int wsp_x = int((*konf).r[i] & 15);
        int wsp_y = int((*konf).r[i] >> 4);

        if ((wsp_x >= plansza_x) || (wsp_y >= plansza_y))
            return false;
        if ((wsp_x < 0) || (wsp_y < 0))
            return false;
        if (plansza[wsp_x][wsp_y] != 0)
            return false;
        
        plansza[wsp_x][wsp_y] = i + 1;
        for (int k = 0; k < klocki[typ_klocka].rozmiar - 1; ++k){

            if ((wsp_x + klocki[typ_klocka].ksztalt[k][0] >= plansza_x)
                || (wsp_y + klocki[typ_klocka].ksztalt[k][1] >= plansza_y))
                return false;
            if ((wsp_x + klocki[typ_klocka].ksztalt[k][0] < 0)
                || (wsp_y + klocki[typ_klocka].ksztalt[k][1] < 0))
                return false;
            if (plansza[wsp_x + klocki[typ_klocka].ksztalt[k][0]]
                [wsp_y + klocki[typ_klocka].ksztalt[k][1]] != 0)
                return false;

            plansza[wsp_x + klocki[typ_klocka].ksztalt[k][0]]
                [wsp_y + klocki[typ_klocka].ksztalt[k][1]] = i + 1;
        }
    }

    return true;
}

std::string * plansza_do_napis(const typ_plansza * plansza, std::string * napis){
	std::ostringstream oss;
    for (int i_ = plansza_y - 1; i_ >= 0; --i_){
        for (int j_ = 0; j_ < plansza_x; ++j_){
            oss << (*plansza)[j_][i_] << " ";
		}
        oss << "\n";
    }
    (*napis) = oss.str();
    return napis;
}

typ_plansza * konf_rozp_do_plansza(const konf_rozpakowana * konf, typ_plansza * plansza){

   //wyczysc plansze
    for (int i = 0; i < plansza_x; ++i)
        for (int j = 0; j < plansza_y; ++j)
            (*plansza)[i][j] = 0;
    
    //zapisz pozycje klockow na planszy
    for (int  i = 0; i < N_rozp; ++i) {
        int typ_klocka = rodzaj_klocka[i];
        int wsp_x = int((*konf).r[i] & 15);
        int wsp_y = int((*konf).r[i] >> 4);

        if ((wsp_x >= plansza_x) || (wsp_y >= plansza_y)) {
            std::cerr << "Blad w linii "<<__LINE__<<"\n";
            std::cerr<<"Info: i="<<i<<".\n";
            exit(-1);
        }
        if ((wsp_x < 0) || (wsp_y < 0)) {
            std::cerr << "Blad w linii "<<__LINE__<<"\n";
            std::cerr<<"Info: i="<<i<<".\n";
            exit(-1);
        }
        if ((*plansza)[wsp_x][wsp_y] != 0) {
            std::cerr << "Blad w linii "<<__LINE__<<"\n";
            std::cerr<<"Info: i="<<i<<".\n";
            exit(-1);
        }

        (*plansza)[wsp_x][wsp_y] = i + 1;
        for (int k = 0; k < klocki[typ_klocka].rozmiar - 1; ++k){

            if ((wsp_x + klocki[typ_klocka].ksztalt[k][0] >= plansza_x)
                || (wsp_y + klocki[typ_klocka].ksztalt[k][1] >= plansza_y)) {
                std::cerr << "Blad w linii "<<__LINE__<<"\n";
                std::cerr<<"Info: i="<<i<<" k="<<k<<".\n";
                exit(-1);
            }
            if ((wsp_x + klocki[typ_klocka].ksztalt[k][0] < 0)
                || (wsp_y + klocki[typ_klocka].ksztalt[k][1] < 0)) {
                std::cerr << "Blad w linii "<<__LINE__<<"\n";
                std::cerr<<"Info: i="<<i<<" k="<<k<<".\n";
                exit(-1);
            }
            if ((*plansza)[wsp_x + klocki[typ_klocka].ksztalt[k][0]]
                [wsp_y + klocki[typ_klocka].ksztalt[k][1]] != 0) {
                std::cerr << "Blad w linii "<<__LINE__<<"\n";
                std::cerr<<"Info: i="<<i<<" k="<<k<<".\n";
                exit(-1);
            }

            (*plansza)[wsp_x + klocki[typ_klocka].ksztalt[k][0]]
                [wsp_y + klocki[typ_klocka].ksztalt[k][1]] = i + 1;
        }
    }

	return plansza;
}

void wypisz_konf_rozp(const konf_rozpakowana * konf){
    static typ_plansza plansza;
    static std::string napis;
	konf_rozp_do_plansza(konf, &plansza);
    std::cout << "plansza\n" << *plansza_do_napis(&plansza, &napis);
}

void wypisz_konf_rozp(const konf_rozpakowana * konf, const int odl){
    static typ_plansza plansza;
    static std::string napis;
	konf_rozp_do_plansza(konf, &plansza);
    std::cout << "plansza "<< odl << "\n" << *plansza_do_napis(&plansza, &napis);
}

void wypisz_konf_rozp_std_cerr(const konf_rozpakowana * konf){
    static typ_plansza plansza;
    static std::string napis;
	konf_rozp_do_plansza(konf, &plansza);
    std::cerr << "plansza\n" << (*plansza_do_napis(&plansza, &napis)).c_str();
}

void wypisz_konf_spak(const konf_spakowana * konf){
    static konf_rozpakowana rozp;
    static typ_plansza plansza;
    static std::string napis;
    rozpakuj_konfiguracje(konf, &rozp, &plansza);
    std::cout << "plansza\n" << *plansza_do_napis(&plansza, &napis);
}

void wypisz_konf_spak(const konf_spakowana * konf, const int odl){
    static konf_rozpakowana rozp;
    static typ_plansza plansza;
    static std::string napis;
    rozpakuj_konfiguracje(konf, &rozp, &plansza);
    plansza_do_napis(&plansza, &napis);
    std::cout << "plansza "<< odl << "\n" << napis;
}

void wypisz_konf_spak_std_cerr(const konf_spakowana * konf, const int odl){
    static konf_rozpakowana rozp;
    static typ_plansza plansza;
    static std::string napis;
    rozpakuj_konfiguracje(konf, &rozp, &plansza);
    std::cerr << "plansza "<< odl << "\n" << *plansza_do_napis(&plansza, &napis);
}

bool rozwiazanie(const konf_rozpakowana * konf){

bool wypelniona_plansza = false;
typ_plansza plansza;

	for (int war = 0; war < l_war_wyjscia; ++war) {
		if (wyjscie[war].nr_klocka == -1) {//-1 oznacza puste pole
			if (!wypelniona_plansza) {
			    for (int i = 0; i < plansza_x; ++i)
        			for (int j = 0; j < plansza_y; ++j)
            			plansza[i][j] = 0;
			    for (int  i = 0; i < N_rozp; ++i) {
        			int typ_klocka = rodzaj_klocka[i];
        			int wsp_x = int((*konf).r[i] & 15);
        			int wsp_y = int((*konf).r[i] >> 4);
			        plansza[wsp_x][wsp_y] = i + 1;
        			for (int k = 0; k < klocki[typ_klocka].rozmiar - 1; ++k)
			            plansza[wsp_x + klocki[typ_klocka].ksztalt[k][0]]
            				   [wsp_y + klocki[typ_klocka].ksztalt[k][1]] = i + 1;
    			}
    			wypelniona_plansza = true;
			}
			if (plansza[wyjscie[war].polx][wyjscie[war].poly]) return false;
		} else {
			if (((*konf).r[wyjscie[war].nr_klocka]&15) != wyjscie[war].polx) return false;
            if (((*konf).r[wyjscie[war].nr_klocka]>>4) != wyjscie[war].poly) return false;
		}
	}
	return true;
}

void znajdz_potomkow(const int pozycja){
    //znajduje wszystkich potomkow, ktorzy jeszcze nie byli rozpatrywani

assert(pozycja < ltkonf);
assert(pozycja >= 0);


    static typ_plansza plansza;// plansza z wyjsciowa konf.
    static konf_rozpakowana konf, nowa_konf;

    rozpakuj_konfiguracje(&tkonf_spak[pozycja], &konf, &plansza);
    
    //znajduje potomne konfiguracje dla tej zapisanej

    usun_hash(trodzic[pozycja]-1); //dla szybszego wyszukiwania

    for (int i = 1; i <= N_rozp; ++i) { //idz po wszystkich klockach

        typ_plansza plansza_wz;//plansza z wyjs. konf. bez jednego klocka
        typ_plansza miejsca;   //plansza z miejscami, ktore testowac

        //przygotuj tablice
        for (int j = 0; j < plansza_x; ++j)
            for (int k = 0; k < plansza_y; ++k)
                if (plansza[j][k] == i) {
                    plansza_wz[j][k] = 0;
                    miejsca[j][k] = 0;
                } else {
                    plansza_wz[j][k] = plansza[j][k];
                    if (plansza[j][k] != 0)
                        miejsca[j][k] = -1;
                    else
                        miejsca[j][k] = 0;
                }
        
        // w tym miejscu jest konf. wyjsciowa
        miejsca [konf.r[i-1] & 15] [konf.r[i-1] >> 4] = 1;

        //szukaj poprzez przesuwanie klocka w obszary, gdzie potencjalnie da sie to zrobic

        int typ_klocka = rodzaj_klocka[i-1];
        int rozmiar = klocki[typ_klocka].rozmiar - 1; //dla wygodniejszej petli: " - 1"
        int ksztalt[max_rozmiar_klocka][2];
        for (int pom = 0; pom < rozmiar; ++pom) {
            ksztalt[pom][0] = klocki[typ_klocka].ksztalt[pom][0];
            ksztalt[pom][1] = klocki[typ_klocka].ksztalt[pom][1];
        }

        bool znalazlem = true; //czy znalazlem jakas dobra konfiguracje?
        while (znalazlem) {
            znalazlem = false;
            for (int j = 0; j < plansza_x; ++j)
                for (int k = 0; k < plansza_y; ++k) {
                    if ((miejsca[j][k] == 0) && (
                            ((j > 0) && (miejsca[j-1][k] == 1)) ||
                            ((k > 0) && (miejsca[j][k-1] == 1)) ||
                            ((j < plansza_x-1 ) && (miejsca[j+1][k] == 1)) ||
                            ((k < plansza_y-1 ) && (miejsca[j][k+1] == 1))
                            ) ) {
                        bool dobra_konf = true;
                        for (int l = 0; l < rozmiar; ++l)
                            if ( (j + ksztalt[l][0] >= plansza_x) ||
                                 (k + ksztalt[l][1] >= plansza_y) ||
                                 (j + ksztalt[l][0] < 0) ||
                                 (k + ksztalt[l][1] < 0) ||
                                 (plansza_wz [j+ksztalt[l][0]] [k+ksztalt[l][1]] != 0) ) {
                                dobra_konf = false;
                                break;
                            }
                        if (dobra_konf) {
                            znalazlem = true;
                            lpos++;
                            miejsca[j][k] = 1;

                            if (ltkonf >= max_liczba_konfiguracji) {
                                std::cerr << "Brak pamieci na nowe konfiguracje!\n";
                                exit(-2);
                            }
                            

                            kopiuj_konf_rozp(&konf, &nowa_konf);
                            nowa_konf.r[i-1] = bajt(j) + (bajt(k) << 4);
                            sortuj_klocki(&nowa_konf, i-1);
                            spakuj_konfiguracje(&nowa_konf, &tkonf_spak[ltkonf]);
                            ltkonf++;
                            
                            int poz_konf = nowa_konfiguracja(ltkonf-1);
                            if (poz_konf == -1) {
                                trodzic[ltkonf-1] = pozycja;
                                dodaj_hash(ltkonf-1);
                                if (rozwiazanie(&nowa_konf)) {
                                    if (nr_rozw == -1)
                                        nr_rozw = ltkonf-1;
#ifdef FAST
//szukamy tylko jednego rozwiazania najkrotszego, nic wiecej
                                    return;
#endif                                    
                                }
                            } else 
			     			    ltkonf--;
                        }
                    }
                }
        }
    }
}

int zaladuj_konf(const int odl, const int pozycja, konf_spakowana * konf){
  //algorytm prymitywny, ale powinien w zupelnosci wystarczyc (jak na razie)
  //na wejsciu 'pozycja'= trodzic z pliku konf_'odl'.dat
  //na wyjsciu zwraca konfiguracje i pozycje rodzica
  static int rodzic_;
  static int l_wyrzuconych;

  assert(pozycja < ltkonf);
  assert(odl >= 0);

  if (pozycja >= 0) {
    kopiuj_konf_spak(&tkonf_spak[pozycja], konf);
    return trodzic[pozycja];
  }
	
  FILE * plik;
  char nazwa_pliku[20];
  sprintf(nazwa_pliku,"konf_%d.dat",odl);
  if (!(plik = fopen(nazwa_pliku,"rb"))) {
     std::cerr << "Nie moge otworzyc pliku " << nazwa_pliku << " !\n";
     exit(-5);
  }

  fseek(plik,0,SEEK_SET);
  fread(&l_wyrzuconych, sizeof(int), 1, plik);

  int pozycja_w_pliku = pozycja + l_wyrzuconych;

  fseek(plik,sizeof(int)+pozycja_w_pliku*sizeof(konf_spakowana),SEEK_SET);  
  fread(konf, sizeof(konf_spakowana), 1, plik);

  fseek(plik,sizeof(int)+l_wyrzuconych*sizeof(konf_spakowana)+
             pozycja_w_pliku*sizeof(int), SEEK_SET);  
  fread(&rodzic_, sizeof(int), 1, plik);

  fclose(plik);

  return rodzic_;

}

void wypisz_rozw(const int pozycja_){
    //wypisz tylko jedno z mozliwych rozwiazan!

  assert(pozycja_ < ltkonf);
  //assert(pozycja_ >= 0);
	
  int pozycja = pozycja_;
  int odleglosc = todl(pozycja_);
  
  konf_spakowana * konf;
  konf = new konf_spakowana[odleglosc+1];
  
  for (int i = odleglosc; i>=0; --i)
    pozycja = zaladuj_konf(i, pozycja, &konf[i]);
   
  for (int i = 0; i<=odleglosc; ++i)
    wypisz_konf_spak(&konf[i], i);
    
  delete [] konf;
}

//-------------------glowny program----------------------------

int main(){

    konf_rozpakowana konf;

//------------- DRUGA CZESC INICJALIZACJI DANYCH ----------------
/*


* wspinaczka 15 : >= 51 bitow , ok. <= 55, czyli 7 bajtow
* wspinaczka 24 : >= 101 bitow, ok. <= 106, czyli raczej spokojnie 13 bajtow, ale moze trzeba 14.
* peloponez     : >= 42 bitow
* rekin maks. 78 bitow, a dla odwrotnego zapisu 53 bity
* transeuropa maks. 85 bitow
* american pie maks. 182 bity, a dla odwrotngo zapisu 156 bitow



*/

/*  rekin  
	//trzeba na hashe wiecej miejsca: + ok. 2/5.
    N_rozp = 20;
    N_spak = 7; // <= 53 bity
    M = 5;
    plansza_x = 6;
    plansza_y = 6;

	odwrotne = true;

    int k=-1, r=-1; // dla latwiejszego zapisu
    klocki[++k].rozmiar = 4;
    klocki[k].ksztalt[0][0] = 1;
    klocki[k].ksztalt[0][1] = 0;
    klocki[k].ksztalt[1][0] = 2;
    klocki[k].ksztalt[1][1] = 0;
    klocki[k].ksztalt[2][0] = 1;
    klocki[k].ksztalt[2][1] = 1;
    strcpy(klocki[k].opis_slowny,"Odwrocone T");
    ilosc_danego_rodzaju[k] = 1;
    konf.r[++r] = 0 + (3 << 4);

	l_war_wyjscia=2;
    wyjscie[0].nr_klocka = k;
    wyjscie[0].polx = 3;
    wyjscie[0].poly = 0;
    wyjscie[1].nr_klocka = -1;
    wyjscie[1].polx = 5;
    wyjscie[1].poly = 1;

    klocki[++k].rozmiar = 4;
    klocki[k].ksztalt[0][0] = 1;
    klocki[k].ksztalt[0][1] = 0;
    klocki[k].ksztalt[1][0] = 0;
    klocki[k].ksztalt[1][1] = 1;
    klocki[k].ksztalt[2][0] = 1;
    klocki[k].ksztalt[2][1] = 1;
    strcpy(klocki[k].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[k] = 1;
    konf.r[++r] = 3 + (0 << 4);

    klocki[++k].rozmiar = 2;
    klocki[k].ksztalt[0][0] = 1;
    klocki[k].ksztalt[0][1] = 0;
    strcpy(klocki[k].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[k] = 3;
    konf.r[++r] = 1 + (5 << 4);
    konf.r[++r] = 0 + (1 << 4);
    konf.r[++r] = 0 + (2 << 4);

    klocki[++k].rozmiar = 2;
    klocki[k].ksztalt[0][0] = 0;
    klocki[k].ksztalt[0][1] = 1;
    strcpy(klocki[k].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[k] = 4;
    konf.r[++r] = 2 + (0 << 4);
    konf.r[++r] = 3 + (2 << 4);
    konf.r[++r] = 5 + (2 << 4);
    konf.r[++r] = 0 + (4 << 4);

    klocki[++k].rozmiar = 1;
    strcpy(klocki[k].opis_slowny,"Kwadrat");
    ilosc_danego_rodzaju[k] = 11;
    konf.r[++r] = 0 + (0 << 4);
    konf.r[++r] = 1 + (0 << 4);
    konf.r[++r] = 5 + (0 << 4);
    konf.r[++r] = 5 + (1 << 4);
    konf.r[++r] = 4 + (2 << 4);
    konf.r[++r] = 2 + (2 << 4);
    konf.r[++r] = 4 + (3 << 4);
    konf.r[++r] = 2 + (4 << 4);
    konf.r[++r] = 3 + (4 << 4);
    konf.r[++r] = 5 + (4 << 4);
    konf.r[++r] = 4 + (5 << 4);
*/
/* kosc  
    N_rozp = 9;
    N_spak = 5; //  bitow
    M = 3;
    plansza_x = 4;
    plansza_y = 4;
    
    odwrotne = true;

    int k=-1, r=-1; // dla latwiejszego zapisu

    klocki[++k].rozmiar = 3;
    klocki[k].ksztalt[0][0] = 0;
    klocki[k].ksztalt[0][1] = 1;
    klocki[k].ksztalt[1][0] = 0;
    klocki[k].ksztalt[1][1] = 2;
    strcpy(klocki[k].opis_slowny,"Pionowy 1x3 do wyjscia");
    ilosc_danego_rodzaju[k] = 1;
    konf.r[++r] = 3 + (1 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = k;
    wyjscie[0].polx = 1;
    wyjscie[0].poly = 0;

    klocki[++k].rozmiar = 2;
    klocki[k].ksztalt[0][0] = 1;
    klocki[k].ksztalt[0][1] = 0;
    strcpy(klocki[k].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[k] = 2;
    konf.r[++r] = 1 + (1 << 4);
    konf.r[++r] = 1 + (2 << 4);

    klocki[++k].rozmiar = 1;
    strcpy(klocki[k].opis_slowny,"Kwadrat");
    ilosc_danego_rodzaju[k] = 6;
    konf.r[++r] = 1 + (0 << 4);
    konf.r[++r] = 2 + (0 << 4);
    konf.r[++r] = 3 + (0 << 4);
    konf.r[++r] = 0 + (3 << 4);
    konf.r[++r] = 1 + (3 << 4);
    konf.r[++r] = 2 + (3 << 4);
*/
/*  zwyciestwo  
    N_rozp = 12;
    N_spak = 5; // 38 bitow
    M = 4;
    plansza_x = 5;
    plansza_y = 4;

    int k=-1, r=-1; // dla latwiejszego zapisu
    klocki[++k].rozmiar = 2;
    klocki[k].ksztalt[0][0] = 1;
    klocki[k].ksztalt[0][1] = 0;
    strcpy(klocki[k].opis_slowny,"Poziomy 2x1 do wyjscia");
    ilosc_danego_rodzaju[k] = 1;
    konf.r[++r] = 0 + (3 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = k;
    wyjscie[0].polx = 3;
    wyjscie[0].poly = 1;

    klocki[++k].rozmiar = 2;
    klocki[k].ksztalt[0][0] = 1;
    klocki[k].ksztalt[0][1] = 0;
    strcpy(klocki[k].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[k] = 2;
    konf.r[++r] = 2 + (3 << 4);
    konf.r[++r] = 0 + (0 << 4);

    klocki[++k].rozmiar = 2;
    klocki[k].ksztalt[0][0] = 0;
    klocki[k].ksztalt[0][1] = 1;
    strcpy(klocki[k].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[k] = 3;
    konf.r[++r] = 2 + (0 << 4);
    konf.r[++r] = 3 + (1 << 4);
    konf.r[++r] = 4 + (1 << 4);

    klocki[++k].rozmiar = 1;
    strcpy(klocki[k].opis_slowny,"Kwadrat");
    ilosc_danego_rodzaju[k] = 6;
    konf.r[++r] = 0 + (1 << 4);
    konf.r[++r] = 0 + (2 << 4);
    konf.r[++r] = 1 + (1 << 4);
    konf.r[++r] = 1 + (2 << 4);
    konf.r[++r] = 2 + (2 << 4);
    konf.r[++r] = 4 + (3 << 4);
*/
/*  kleopatra  
    N_rozp = 10;
    N_spak = 3; // normalnie 31 bitow (przy odwrotnym kodowaniu klockow 1x1 18 bitow)
    M = 4;
    plansza_x = 4;
    plansza_y = 4;

    odwrotne = true;

    klocki[0].rozmiar = 3;
    klocki[0].ksztalt[0][0] = 0;
    klocki[0].ksztalt[0][1] = 1;
    klocki[0].ksztalt[1][0] = -1;
    klocki[0].ksztalt[1][1] = 1;
    strcpy(klocki[0].opis_slowny,"Zgiety lg");
    ilosc_danego_rodzaju[0] = 1;
    konf.r[0] = 1 + (1 << 4);

	l_war_wyjscia=2;
    wyjscie[0].nr_klocka = 0;
    wyjscie[0].polx = 3;
    wyjscie[0].poly = 0;
    wyjscie[1].nr_klocka = -1;
    wyjscie[1].polx = 2;
    wyjscie[1].poly = 0;

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    strcpy(klocki[1].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[1] = 2 + (2 << 4);

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[2] = 1;
    konf.r[2] = 0 + (0 << 4);

    klocki[3].rozmiar = 1;
    strcpy(klocki[3].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[3] = 7;
    konf.r[3] = 0 + (3 << 4);
    konf.r[4] = 1 + (3 << 4);
    konf.r[5] = 2 + (3 << 4);
    konf.r[6] = 3 + (3 << 4);
    konf.r[7] = 1 + (0 << 4);
    konf.r[8] = 2 + (1 << 4);
    konf.r[9] = 3 + (0 << 4);
*/
/*  fortuna  
    N_rozp = 10;
    N_spak = 5; //35 bitow
    M = 5;
    plansza_x = 4;
    plansza_y = 6;

    klocki[0].rozmiar = 4;
    klocki[0].ksztalt[0][0] = 0;
    klocki[0].ksztalt[0][1] = 1;
    klocki[0].ksztalt[1][0] = 0;
    klocki[0].ksztalt[1][1] = 2;
    klocki[0].ksztalt[2][0] = 1;
    klocki[0].ksztalt[2][1] = 2;
    strcpy(klocki[0].opis_slowny,"Zgiety o 4 elementach");
    ilosc_danego_rodzaju[0] = 1;
    konf.r[0] = 0 + (0 << 4);

	l_war_wyjscia=3;
    wyjscie[0].nr_klocka = 0;
    wyjscie[0].polx = 2;
    wyjscie[0].poly = 3;
    wyjscie[1].nr_klocka = -1;
    wyjscie[1].polx = 3;
    wyjscie[1].poly = 3;
    wyjscie[2].nr_klocka = -1;
    wyjscie[2].polx = 3;
    wyjscie[2].poly = 4;

    klocki[1].rozmiar = 4;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    klocki[1].ksztalt[1][0] = 1;
    klocki[1].ksztalt[1][1] = 1;
    klocki[1].ksztalt[2][0] = 1;
    klocki[1].ksztalt[2][1] = 0;
    strcpy(klocki[1].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[1] = 0 + (3 << 4);

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    strcpy(klocki[2].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[2] = 2;
    konf.r[2] = 1 + (0 << 4);
    konf.r[3] = 2 + (2 << 4);

    klocki[3].rozmiar = 2;
    klocki[3].ksztalt[0][0] = 0;
    klocki[3].ksztalt[0][1] = 1;
    strcpy(klocki[3].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[3] = 2;
    konf.r[4] = 2 + (3 << 4);
    konf.r[5] = 3 + (0 << 4);

    klocki[4].rozmiar = 1;
    strcpy(klocki[4].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[4] = 4;
    konf.r[6] = 1 + (1 << 4);
    konf.r[7] = 2 + (1 << 4);
    konf.r[8] = 0 + (5 << 4);
    konf.r[9] = 1 + (5 << 4);
*/
/*  glupek  
    N_rozp = 13;
    N_spak = 10;
    M = 5;
    plansza_x = 6;
    plansza_y = 4;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[0] = 6;
    konf.r[0] = 1 + (1 << 4);
    konf.r[1] = 0 + (1 << 4);
    konf.r[2] = 0 + (0 << 4);
    konf.r[3] = 1 + (0 << 4);
    konf.r[4] = 3 + (3 << 4);
    konf.r[5] = 3 + (2 << 4);

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    strcpy(klocki[1].opis_slowny,"Poziomy prostokat 2x1, kotry ma wyjsc");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[6] = 4 + (0 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 6;
    wyjscie[0].polx = 0;
    wyjscie[0].poly = 3;

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[2] = 3;
    konf.r[7] = 2 + (2 << 4);
    konf.r[8] = 4 + (1 << 4);
    konf.r[9] = 5 + (1 << 4);

    klocki[3].rozmiar = 2;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    strcpy(klocki[3].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[3] = 2;
    konf.r[10] = 2 + (0 << 4);
    konf.r[11] = 2 + (1 << 4);

    klocki[4].rozmiar = 4;
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 1;
    klocki[4].ksztalt[1][1] = 1;
    klocki[4].ksztalt[2][0] = 1;
    klocki[4].ksztalt[2][1] = 0;
    strcpy(klocki[4].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[4] = 1;
    konf.r[12] = 0 + (2 << 4);
*/
/*  test zliczania  
    N_rozp = 3;
    N_spak = 1;
    M = 2;
    plansza_x = 2;
    plansza_y = 2;

    odwrotne = true;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1, ktory trzeba wyprowadzic");
    ilosc_danego_rodzaju[0] = 1;
    konf.r[0] = 1 + (1 << 4);
    
	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 0;
    wyjscie[0].polx = 0;
    wyjscie[0].poly = 0;
  
    klocki[1].rozmiar = 1;
    strcpy(klocki[1].opis_slowny,"Zwykly kwadrat 1x1");
    ilosc_danego_rodzaju[1] = 2;
    konf.r[1] = 0 + (1 << 4);
    konf.r[2] = 1 + (0 << 4);
*/    
/*  salomon  
    N_rozp = 13;
    M = 5;
    plansza_x = 5;
    plansza_y = 5;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[0] = 6;
    konf.r[0] = 1 + (1 << 4);
    konf.r[1] = 2 + (1 << 4);
    konf.r[2] = 3 + (1 << 4);
    konf.r[3] = 2 + (2 << 4);
    konf.r[4] = 2 + (3 << 4);
    konf.r[5] = 4 + (2 << 4);

    klocki[1].rozmiar = 3;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    klocki[1].ksztalt[1][0] = 1;
    klocki[1].ksztalt[1][1] = 1;
    strcpy(klocki[1].opis_slowny,"Zgiety ld");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[6] = 3 + (0 << 4);

	l_war_wyjscia=2;
    wyjscie[0].nr_klocka = 6;
    wyjscie[0].polx = 0;
    wyjscie[0].poly = 3;
    wyjscie[1].nr_klocka = -1;
    wyjscie[1].polx = 0;
    wyjscie[1].poly = 4;

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[2] = 3;
    konf.r[7] = 1 + (2 << 4);
    konf.r[8] = 3 + (2 << 4);
    konf.r[9] = 4 + (3 << 4);

    klocki[3].rozmiar = 2;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    strcpy(klocki[3].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[3] = 2;
    konf.r[10] = 1 + (0 << 4);
    konf.r[11] = 2 + (4 << 4);

    klocki[4].rozmiar = 3;
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 0;
    klocki[4].ksztalt[1][1] = 2;
    strcpy(klocki[4].opis_slowny,"Pionowy protokat 1x3");
    ilosc_danego_rodzaju[4] = 1;
    konf.r[12] = 0 + (0 << 4);
*/
/*  rekin  
    N_rozp = 20;
    M = 5;
    plansza_x = 6;
    plansza_y = 6;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[0] = 11;
    konf.r[0] = 0 + (0 << 4);
    konf.r[1] = 1 + (0 << 4);
    konf.r[2] = 2 + (2 << 4);
    konf.r[3] = 2 + (4 << 4);
    konf.r[4] = 3 + (4 << 4);
    konf.r[5] = 4 + (5 << 4);
    konf.r[6] = 4 + (3 << 4);
    konf.r[7] = 4 + (2 << 4);
    konf.r[8] = 5 + (0 << 4);
    konf.r[9] = 5 + (1 << 4);
    konf.r[10] = 5 + (4 << 4);


    klocki[1].rozmiar = 4;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    klocki[1].ksztalt[1][0] = 1;
    klocki[1].ksztalt[1][1] = 1;
    klocki[1].ksztalt[2][0] = 2;
    klocki[1].ksztalt[2][1] = 0;
    strcpy(klocki[1].opis_slowny,"Odwrocone T");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[11] = 0 + (3 << 4);

	l_war_wyjscia=2;
    wyjscie[0].nr_klocka = 11;
    wyjscie[0].polx = 3;
    wyjscie[0].poly = 0;
    wyjscie[1].nr_klocka = -1;
    wyjscie[1].polx = 5;
    wyjscie[1].poly = 1;

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[2] = 4;
    konf.r[12] = 0 + (4 << 4);
    konf.r[13] = 2 + (0 << 4);
    konf.r[14] = 3 + (2 << 4);
    konf.r[15] = 5 + (2 << 4);

    klocki[3].rozmiar = 2;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    strcpy(klocki[3].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[3] = 3;
    konf.r[16] = 0 + (1 << 4);
    konf.r[17] = 0 + (2 << 4);
    konf.r[18] = 1 + (5 << 4);

    klocki[4].rozmiar = 4;
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 1;
    klocki[4].ksztalt[1][1] = 1;
    klocki[4].ksztalt[2][0] = 1;
    klocki[4].ksztalt[2][1] = 0;
    strcpy(klocki[4].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[4] = 1;
    konf.r[19] = 3 + (0 << 4);
*/
/*  rzym  
    N_rozp = 12;
    M = 5;
    plansza_x = 6;
    plansza_y = 4;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[0] = 6;
    konf.r[0] = 0 + (3 << 4);
    konf.r[1] = 1 + (3 << 4);
    konf.r[2] = 2 + (1 << 4);
    konf.r[3] = 3 + (1 << 4);
    konf.r[4] = 3 + (0 << 4);
    konf.r[5] = 4 + (0 << 4);

    klocki[1].rozmiar = 3;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    klocki[1].ksztalt[1][0] = -1;
    klocki[1].ksztalt[1][1] = 1;
    strcpy(klocki[1].opis_slowny,"Zgiety lg");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[6] = 5 + (2 << 4);

	l_war_wyjscia=2;
    wyjscie[0].nr_klocka = 6;
    wyjscie[0].polx = 1;
    wyjscie[0].poly = 0;
    wyjscie[1].nr_klocka = -1;
    wyjscie[1].polx = 0;
    wyjscie[1].poly = 0;

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[2] = 2;
    konf.r[7] = 4 + (1 << 4);
    konf.r[8] = 5 + (0 << 4);

    klocki[3].rozmiar = 2;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    strcpy(klocki[3].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[3] = 2;
    konf.r[9] = 2 + (2 << 4);
    konf.r[10] = 2 + (3 << 4);

    klocki[4].rozmiar = 4;
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 1;
    klocki[4].ksztalt[1][1] = 1;
    klocki[4].ksztalt[2][0] = 1;
    klocki[4].ksztalt[2][1] = 0;
    strcpy(klocki[4].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[4] = 1;
    konf.r[11] = 0 + (1 << 4);
*/
/*  morze baltyckie  
    N_rozp = 13;
    M = 6;
    plansza_x = 4;
    plansza_y = 6;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[0] = 7;
    konf.r[0] = 1 + (0 << 4);
    konf.r[1] = 1 + (1 << 4);
    konf.r[2] = 1 + (4 << 4);
    konf.r[3] = 1 + (5 << 4);
    konf.r[4] = 2 + (4 << 4);
    konf.r[5] = 2 + (5 << 4);
    konf.r[6] = 3 + (2 << 4);

    klocki[1].rozmiar = 4;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    klocki[1].ksztalt[1][0] = 0;
    klocki[1].ksztalt[1][1] = 2;
    klocki[1].ksztalt[2][0] = 0;
    klocki[1].ksztalt[2][1] = 3;
    strcpy(klocki[1].opis_slowny,"Pionowy 1x4");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[7] = 0 + (0 << 4);

    klocki[2].rozmiar = 3;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    klocki[2].ksztalt[1][0] = 0;
    klocki[2].ksztalt[1][1] = 2;
    strcpy(klocki[2].opis_slowny,"Pionowy 1x3");
    ilosc_danego_rodzaju[2] = 1;
    konf.r[8] = 3 + (3 << 4);

    klocki[3].rozmiar = 2;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    strcpy(klocki[3].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[3] = 2;
    konf.r[9] = 1 + (2 << 4);
    konf.r[10] = 1 + (3 << 4);

    klocki[4].rozmiar = 2;
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    strcpy(klocki[4].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[4] = 1;
    konf.r[11] = 2 + (0 << 4);

    klocki[5].rozmiar = 2;
    klocki[5].ksztalt[0][0] = 0;
    klocki[5].ksztalt[0][1] = 1;
    strcpy(klocki[5].opis_slowny,"Pionowy prostokat - do wyjscia");
    ilosc_danego_rodzaju[5] = 1;
    konf.r[12] = 3 + (0 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 12;
    wyjscie[0].polx = 0;
    wyjscie[0].poly = 4;

*/
/*  korek  
    N_rozp = 14;
    M = 6;
    plansza_x = 6;
    plansza_y = 5;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[0] = 6;
    konf.r[0] = 2 + (2 << 4);
    konf.r[1] = 3 + (0 << 4);
    konf.r[2] = 3 + (1 << 4);
    konf.r[3] = 3 + (2 << 4);
    konf.r[4] = 4 + (3 << 4);
    konf.r[5] = 5 + (4 << 4);

    klocki[1].rozmiar = 3;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    klocki[1].ksztalt[1][0] = 1;
    klocki[1].ksztalt[1][1] = 1;
    strcpy(klocki[1].opis_slowny,"Zgiety pg");
    ilosc_danego_rodzaju[1] = 2;
    konf.r[6] = 0 + (0 << 4);
    konf.r[7] = 3 + (3 << 4);

    klocki[2].rozmiar = 3;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 1;
    klocki[2].ksztalt[1][1] = 1;
    strcpy(klocki[2].opis_slowny,"Zgiety ld");
    ilosc_danego_rodzaju[2] = 2;
    konf.r[8] = 1 + (0 << 4);
    konf.r[9] = 4 + (2 << 4);

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 0;
    klocki[3].ksztalt[1][1] = 1;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[3] = 1;
    konf.r[10] = 0 + (3 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 10;
    wyjscie[0].polx = 4;
    wyjscie[0].poly = 0;

    klocki[4].rozmiar = 2;
    klocki[4].ksztalt[0][0] = 1;
    klocki[4].ksztalt[0][1] = 0;
    strcpy(klocki[4].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[4] = 1;
    konf.r[11] = 0 + (2 << 4);

    klocki[5].rozmiar = 2;
    klocki[5].ksztalt[0][0] = 0;
    klocki[5].ksztalt[0][1] = 1;
    strcpy(klocki[5].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[5] = 2;
    konf.r[12] = 4 + (0 << 4);
    konf.r[13] = 5 + (0 << 4);
*/
/*  agatka */
    N_rozp = 9;
    N_spak = 2; //16 bitow dla 'odwrotnego' zapisu
    M = 3;
    plansza_x = 5;
    plansza_y = 3;
    
    odwrotne = true;
    
    int k=-1, r=-1; // dla latwiejszego zapisu
    klocki[++k].rozmiar = 3;
    klocki[k].ksztalt[0][0] = 0;
    klocki[k].ksztalt[0][1] = 1;
    klocki[k].ksztalt[1][0] = 1;
    klocki[k].ksztalt[1][1] = 1;
    strcpy(klocki[k].opis_slowny,"Zgiety pg");
    ilosc_danego_rodzaju[k] = 1;
    konf.r[++r] = 0 + (1 << 4);

/*	l_war_wyjscia=2;
	wyjscie[0].nr_klocka = k;
    wyjscie[0].polx = 3;
    wyjscie[0].poly = 1;
	wyjscie[1].nr_klocka = -1;
    wyjscie[1].polx = 4;
    wyjscie[1].poly = 1; */
    
    //inne podejscie:
	l_war_wyjscia=3;
	wyjscie[0].nr_klocka = k;
    wyjscie[0].polx = 3;
    wyjscie[0].poly = 0;
	wyjscie[1].nr_klocka = -1;
    wyjscie[1].polx = 3;
    wyjscie[1].poly = 2; 
	wyjscie[2].nr_klocka = -1;
    wyjscie[2].polx = 4;
    wyjscie[2].poly = 2; 

    klocki[++k].rozmiar = 2;
    klocki[k].ksztalt[0][0] = 1;
    klocki[k].ksztalt[0][1] = 0;
    strcpy(klocki[k].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[k] = 2;
    konf.r[++r] = 1 + (1 << 4);
    konf.r[++r] = 2 + (2 << 4);

    klocki[++k].rozmiar = 1;
    strcpy(klocki[k].opis_slowny,"Kwadrat");
    ilosc_danego_rodzaju[k] = 6;
    konf.r[++r] = 0 + (0 << 4);
    konf.r[++r] = 1 + (0 << 4);
    konf.r[++r] = 2 + (0 << 4);
    konf.r[++r] = 3 + (1 << 4);
    konf.r[++r] = 4 + (1 << 4);
    konf.r[++r] = 4 + (2 << 4);


/*  wspinaczka 15 deszcz  
    N_rozp = 15;
    N_spak = 7;//najprawdopodobniej 54 bity (dla zamienionych miejscami prostokatow 2x1 z 1x2)
    M = 10;
    plansza_x = 7;
    plansza_y = 9;

    klocki[0].rozmiar = 27;
    strcpy(klocki[0].opis_slowny,"Obramowka");
    klocki[0].ksztalt[0][0] = 0;
    klocki[0].ksztalt[0][1] = 1;
    klocki[0].ksztalt[1][0] = 0;
    klocki[0].ksztalt[1][1] = 2;
    klocki[0].ksztalt[2][0] = 0;
    klocki[0].ksztalt[2][1] = 3;
    klocki[0].ksztalt[3][0] = 0;
    klocki[0].ksztalt[3][1] = 4;
    klocki[0].ksztalt[4][0] = 0;
    klocki[0].ksztalt[4][1] = 5;
    klocki[0].ksztalt[5][0] = 0;
    klocki[0].ksztalt[5][1] = 6;
    klocki[0].ksztalt[6][0] = 1;
    klocki[0].ksztalt[6][1] = 0;
    klocki[0].ksztalt[7][0] = 1;
    klocki[0].ksztalt[7][1] = 8;
    klocki[0].ksztalt[8][0] = 2;
    klocki[0].ksztalt[8][1] = 0;
    klocki[0].ksztalt[9][0] = 3;
    klocki[0].ksztalt[9][1] = 0;
    klocki[0].ksztalt[10][0] = 4;
    klocki[0].ksztalt[10][1] = 0;
    klocki[0].ksztalt[11][0] = 4;
    klocki[0].ksztalt[11][1] = 8;
    klocki[0].ksztalt[12][0] = 5;
    klocki[0].ksztalt[12][1] = 0;
    klocki[0].ksztalt[13][0] = 6;
    klocki[0].ksztalt[13][1] = 1;
    klocki[0].ksztalt[14][0] = 6;
    klocki[0].ksztalt[14][1] = 2;
    klocki[0].ksztalt[15][0] = 6;
    klocki[0].ksztalt[15][1] = 3;
    klocki[0].ksztalt[16][0] = 6;
    klocki[0].ksztalt[16][1] = 4;
    klocki[0].ksztalt[17][0] = 6;
    klocki[0].ksztalt[17][1] = 5;
    klocki[0].ksztalt[18][0] = 6;
    klocki[0].ksztalt[18][1] = 6;
    klocki[0].ksztalt[19][0] = 2;
    klocki[0].ksztalt[19][1] = 8;
    klocki[0].ksztalt[20][0] = 5;
    klocki[0].ksztalt[20][1] = 8;
    klocki[0].ksztalt[21][0] = 6;
    klocki[0].ksztalt[21][1] = 0;
    klocki[0].ksztalt[22][0] = 0;
    klocki[0].ksztalt[22][1] = 7;
    klocki[0].ksztalt[23][0] = 0;
    klocki[0].ksztalt[23][1] = 8;
    klocki[0].ksztalt[24][0] = 6;
    klocki[0].ksztalt[24][1] = 7;
    klocki[0].ksztalt[25][0] = 6;
    klocki[0].ksztalt[25][1] = 8;
    ilosc_danego_rodzaju[0] = 1;
    konf.r[0] = 0 + (0 << 4);

    klocki[1].rozmiar = 4;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    klocki[1].ksztalt[1][0] = 2;
    klocki[1].ksztalt[1][1] = 0;
    klocki[1].ksztalt[2][0] = 1;
    klocki[1].ksztalt[2][1] = 1;
    strcpy(klocki[1].opis_slowny,"Odwrocone T");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[1] = 2 + (1 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 1;
    wyjscie[0].polx = 2;
    wyjscie[0].poly = 7;

    klocki[2].rozmiar = 4;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    klocki[2].ksztalt[1][0] = 1;
    klocki[2].ksztalt[1][1] = 0;
    klocki[2].ksztalt[2][0] = 1;
    klocki[2].ksztalt[2][1] = 1;
    strcpy(klocki[2].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[2] = 1;
    konf.r[2] = 3 + (3 << 4);

    klocki[3].rozmiar = 3;
    klocki[3].ksztalt[0][0] = 0;
    klocki[3].ksztalt[0][1] = 1;
    klocki[3].ksztalt[1][0] = 1;
    klocki[3].ksztalt[1][1] = 0;
    strcpy(klocki[3].opis_slowny,"Zgiety pd");
    ilosc_danego_rodzaju[3] = 1;
    konf.r[3] = 1 + (2 << 4);

    klocki[4].rozmiar = 3;
    klocki[4].ksztalt[0][0] = 1;
    klocki[4].ksztalt[0][1] = 0;
    klocki[4].ksztalt[1][0] = 1;
    klocki[4].ksztalt[1][1] = 1;
    strcpy(klocki[4].opis_slowny,"Zgiety ld");
    ilosc_danego_rodzaju[4] = 1;
    konf.r[4] = 4 + (2 << 4);

    klocki[5].rozmiar = 3;
    klocki[5].ksztalt[0][0] = 0;
    klocki[5].ksztalt[0][1] = 1;
    klocki[5].ksztalt[1][0] = 1;
    klocki[5].ksztalt[1][1] = 1;
    strcpy(klocki[5].opis_slowny,"Zgiety pg");
    ilosc_danego_rodzaju[5] = 1;
    konf.r[5] = 1 + (4 << 4);

    klocki[6].rozmiar = 3;
    klocki[6].ksztalt[0][0] = 0;
    klocki[6].ksztalt[0][1] = 1;
    klocki[6].ksztalt[1][0] = -1;
    klocki[6].ksztalt[1][1] = 1;
    strcpy(klocki[6].opis_slowny,"Zgiety lg");
    ilosc_danego_rodzaju[6] = 1;
    konf.r[6] = 5 + (4 << 4);

    klocki[7].rozmiar = 2;
    klocki[7].ksztalt[0][0] = 1;
    klocki[7].ksztalt[0][1] = 0;
    strcpy(klocki[7].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[7] = 2;
    konf.r[7] = 4 + (6 << 4);
    konf.r[8] = 1 + (6 << 4);

    klocki[8].rozmiar = 2;
    klocki[8].ksztalt[0][0] = 0;
    klocki[8].ksztalt[0][1] = 1;
    strcpy(klocki[8].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[8] = 2;
    konf.r[9] = 2 + (3 << 4);
    konf.r[10] = 3 + (5 << 4);

    klocki[9].rozmiar = 1;
    strcpy(klocki[9].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[9] = 4;
    konf.r[11] = 1 + (7 << 4);
    konf.r[12] = 5 + (1 << 4);
    konf.r[13] = 5 + (7 << 4);
    konf.r[14] = 1 + (1 << 4);
*/
/*  wspinaczka 15 lato  
    N_rozp = 15;
    M = 10;
    plansza_x = 7;
    plansza_y = 9;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[0] = 4;
    konf.r[0] = 1 + (1 << 4);
    konf.r[1] = 1 + (7 << 4);
    konf.r[2] = 5 + (1 << 4);
    konf.r[3] = 5 + (7 << 4);

    klocki[1].rozmiar = 3;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    klocki[1].ksztalt[1][0] = 1;
    klocki[1].ksztalt[1][1] = 0;
    strcpy(klocki[1].opis_slowny,"Zgiety pd");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[4] = 1 + (2 << 4);

    klocki[2].rozmiar = 3;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 1;
    klocki[2].ksztalt[1][1] = 1;
    strcpy(klocki[2].opis_slowny,"Zgiety ld");
    ilosc_danego_rodzaju[2] = 1;
    konf.r[5] = 4 + (2 << 4);

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 2;
    klocki[3].ksztalt[1][1] = 0;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Odwrocone T");
    ilosc_danego_rodzaju[3] = 1;
    konf.r[6] = 2 + (1 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 6;
    wyjscie[0].polx = 2;
    wyjscie[0].poly = 7;

    klocki[4].rozmiar = 27;
    strcpy(klocki[4].opis_slowny,"Obramowka");
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 0;
    klocki[4].ksztalt[1][1] = 2;
    klocki[4].ksztalt[2][0] = 0;
    klocki[4].ksztalt[2][1] = 3;
    klocki[4].ksztalt[3][0] = 0;
    klocki[4].ksztalt[3][1] = 4;
    klocki[4].ksztalt[4][0] = 0;
    klocki[4].ksztalt[4][1] = 5;
    klocki[4].ksztalt[5][0] = 0;
    klocki[4].ksztalt[5][1] = 6;
    klocki[4].ksztalt[6][0] = 1;
    klocki[4].ksztalt[6][1] = 0;
    klocki[4].ksztalt[7][0] = 1;
    klocki[4].ksztalt[7][1] = 8;
    klocki[4].ksztalt[8][0] = 2;
    klocki[4].ksztalt[8][1] = 0;
    klocki[4].ksztalt[9][0] = 3;
    klocki[4].ksztalt[9][1] = 0;
    klocki[4].ksztalt[10][0] = 4;
    klocki[4].ksztalt[10][1] = 0;
    klocki[4].ksztalt[11][0] = 4;
    klocki[4].ksztalt[11][1] = 8;
    klocki[4].ksztalt[12][0] = 5;
    klocki[4].ksztalt[12][1] = 0;
    klocki[4].ksztalt[13][0] = 6;
    klocki[4].ksztalt[13][1] = 1;
    klocki[4].ksztalt[14][0] = 6;
    klocki[4].ksztalt[14][1] = 2;
    klocki[4].ksztalt[15][0] = 6;
    klocki[4].ksztalt[15][1] = 3;
    klocki[4].ksztalt[16][0] = 6;
    klocki[4].ksztalt[16][1] = 4;
    klocki[4].ksztalt[17][0] = 6;
    klocki[4].ksztalt[17][1] = 5;
    klocki[4].ksztalt[18][0] = 6;
    klocki[4].ksztalt[18][1] = 6;
    klocki[4].ksztalt[19][0] = 2;
    klocki[4].ksztalt[19][1] = 8;
    klocki[4].ksztalt[20][0] = 5;
    klocki[4].ksztalt[20][1] = 8;
    klocki[4].ksztalt[21][0] = 6;
    klocki[4].ksztalt[21][1] = 0;
    klocki[4].ksztalt[22][0] = 0;
    klocki[4].ksztalt[22][1] = 7;
    klocki[4].ksztalt[23][0] = 0;
    klocki[4].ksztalt[23][1] = 8;
    klocki[4].ksztalt[24][0] = 6;
    klocki[4].ksztalt[24][1] = 7;
    klocki[4].ksztalt[25][0] = 6;
    klocki[4].ksztalt[25][1] = 8;
    ilosc_danego_rodzaju[4] = 1;
    konf.r[7] = 0 + (0 << 4);

    klocki[5].rozmiar = 2;
    klocki[5].ksztalt[0][0] = 0;
    klocki[5].ksztalt[0][1] = 1;
    strcpy(klocki[5].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[5] = 2;
    konf.r[8] = 3 + (3 << 4);
    konf.r[9] = 3 + (5 << 4);

    klocki[6].rozmiar = 2;
    klocki[6].ksztalt[0][0] = 1;
    klocki[6].ksztalt[0][1] = 0;
    strcpy(klocki[6].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[6] = 2;
    konf.r[10] = 1 + (5 << 4);
    konf.r[11] = 1 + (6 << 4);

    klocki[7].rozmiar = 3;
    klocki[7].ksztalt[0][0] = 0;
    klocki[7].ksztalt[0][1] = 1;
    klocki[7].ksztalt[1][0] = 1;
    klocki[7].ksztalt[1][1] = 1;
    strcpy(klocki[7].opis_slowny,"Zgiety pg");
    ilosc_danego_rodzaju[7] = 1;
    konf.r[12] = 4 + (3 << 4);

    klocki[8].rozmiar = 3;
    klocki[8].ksztalt[0][0] = 0;
    klocki[8].ksztalt[0][1] = 1;
    klocki[8].ksztalt[1][0] = -1;
    klocki[8].ksztalt[1][1] = 1;
    strcpy(klocki[8].opis_slowny,"Zgiety lg");
    ilosc_danego_rodzaju[8] = 1;
    konf.r[13] = 2 + (3 << 4);

    klocki[9].rozmiar = 4;
    klocki[9].ksztalt[0][0] = 0;
    klocki[9].ksztalt[0][1] = 1;
    klocki[9].ksztalt[1][0] = 1;
    klocki[9].ksztalt[1][1] = 0;
    klocki[9].ksztalt[2][0] = 1;
    klocki[9].ksztalt[2][1] = 1;
    strcpy(klocki[9].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[9] = 1;
    konf.r[14] = 4 + (5 << 4);
*/
/*  wspinaczka 15 wiosna 
    N_rozp = 15;
    M = 10;
    plansza_x = 7;
    plansza_y = 9;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[0] = 4;
    konf.r[0] = 1 + (1 << 4);
    konf.r[1] = 1 + (7 << 4);
    konf.r[2] = 5 + (1 << 4);
    konf.r[3] = 5 + (7 << 4);

    klocki[1].rozmiar = 3;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    klocki[1].ksztalt[1][0] = 1;
    klocki[1].ksztalt[1][1] = 0;
    strcpy(klocki[1].opis_slowny,"Zgiety pd");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[4] = 3 + (5 << 4);

    klocki[2].rozmiar = 3;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 1;
    klocki[2].ksztalt[1][1] = 1;
    strcpy(klocki[2].opis_slowny,"Zgiety ld");
    ilosc_danego_rodzaju[2] = 1;
    konf.r[5] = 2 + (3 << 4);

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 2;
    klocki[3].ksztalt[1][1] = 0;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Odwrocone T");
    ilosc_danego_rodzaju[3] = 1;
    konf.r[6] = 2 + (1 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 6;
    wyjscie[0].polx = 2;
    wyjscie[0].poly = 7;

    klocki[4].rozmiar = 27;
    strcpy(klocki[4].opis_slowny,"Obramowka");
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 0;
    klocki[4].ksztalt[1][1] = 2;
    klocki[4].ksztalt[2][0] = 0;
    klocki[4].ksztalt[2][1] = 3;
    klocki[4].ksztalt[3][0] = 0;
    klocki[4].ksztalt[3][1] = 4;
    klocki[4].ksztalt[4][0] = 0;
    klocki[4].ksztalt[4][1] = 5;
    klocki[4].ksztalt[5][0] = 0;
    klocki[4].ksztalt[5][1] = 6;
    klocki[4].ksztalt[6][0] = 1;
    klocki[4].ksztalt[6][1] = 0;
    klocki[4].ksztalt[7][0] = 1;
    klocki[4].ksztalt[7][1] = 8;
    klocki[4].ksztalt[8][0] = 2;
    klocki[4].ksztalt[8][1] = 0;
    klocki[4].ksztalt[9][0] = 3;
    klocki[4].ksztalt[9][1] = 0;
    klocki[4].ksztalt[10][0] = 4;
    klocki[4].ksztalt[10][1] = 0;
    klocki[4].ksztalt[11][0] = 4;
    klocki[4].ksztalt[11][1] = 8;
    klocki[4].ksztalt[12][0] = 5;
    klocki[4].ksztalt[12][1] = 0;
    klocki[4].ksztalt[13][0] = 6;
    klocki[4].ksztalt[13][1] = 1;
    klocki[4].ksztalt[14][0] = 6;
    klocki[4].ksztalt[14][1] = 2;
    klocki[4].ksztalt[15][0] = 6;
    klocki[4].ksztalt[15][1] = 3;
    klocki[4].ksztalt[16][0] = 6;
    klocki[4].ksztalt[16][1] = 4;
    klocki[4].ksztalt[17][0] = 6;
    klocki[4].ksztalt[17][1] = 5;
    klocki[4].ksztalt[18][0] = 6;
    klocki[4].ksztalt[18][1] = 6;
    klocki[4].ksztalt[19][0] = 2;
    klocki[4].ksztalt[19][1] = 8;
    klocki[4].ksztalt[20][0] = 5;
    klocki[4].ksztalt[20][1] = 8;
    klocki[4].ksztalt[21][0] = 6;
    klocki[4].ksztalt[21][1] = 0;
    klocki[4].ksztalt[22][0] = 0;
    klocki[4].ksztalt[22][1] = 7;
    klocki[4].ksztalt[23][0] = 0;
    klocki[4].ksztalt[23][1] = 8;
    klocki[4].ksztalt[24][0] = 6;
    klocki[4].ksztalt[24][1] = 7;
    klocki[4].ksztalt[25][0] = 6;
    klocki[4].ksztalt[25][1] = 8;
    ilosc_danego_rodzaju[4] = 1;
    konf.r[7] = 0 + (0 << 4);

    klocki[5].rozmiar = 2;
    klocki[5].ksztalt[0][0] = 0;
    klocki[5].ksztalt[0][1] = 1;
    strcpy(klocki[5].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[5] = 2;
    konf.r[8] = 1 + (5 << 4);
    konf.r[9] = 2 + (5 << 4);

    klocki[6].rozmiar = 2;
    klocki[6].ksztalt[0][0] = 1;
    klocki[6].ksztalt[0][1] = 0;
    strcpy(klocki[6].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[6] = 2;
    konf.r[10] = 1 + (2 << 4);
    konf.r[11] = 4 + (2 << 4);

    klocki[7].rozmiar = 3;
    klocki[7].ksztalt[0][0] = 0;
    klocki[7].ksztalt[0][1] = 1;
    klocki[7].ksztalt[1][0] = 1;
    klocki[7].ksztalt[1][1] = 1;
    strcpy(klocki[7].opis_slowny,"Zgiety pg");
    ilosc_danego_rodzaju[7] = 1;
    konf.r[12] = 1 + (3 << 4);

    klocki[8].rozmiar = 3;
    klocki[8].ksztalt[0][0] = 0;
    klocki[8].ksztalt[0][1] = 1;
    klocki[8].ksztalt[1][0] = -1;
    klocki[8].ksztalt[1][1] = 1;
    strcpy(klocki[8].opis_slowny,"Zgiety lg");
    ilosc_danego_rodzaju[8] = 1;
    konf.r[13] = 5 + (5 << 4);

    klocki[9].rozmiar = 4;
    klocki[9].ksztalt[0][0] = 0;
    klocki[9].ksztalt[0][1] = 1;
    klocki[9].ksztalt[1][0] = 1;
    klocki[9].ksztalt[1][1] = 0;
    klocki[9].ksztalt[2][0] = 1;
    klocki[9].ksztalt[2][1] = 1;
    strcpy(klocki[9].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[9] = 1;
    konf.r[14] = 4 + (3 << 4);
*/
/*  wspinaczka 15 zima 
    N_rozp = 15;
    M = 10;
    plansza_x = 7;
    plansza_y = 9;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[0] = 4;
    konf.r[0] = 1 + (7 << 4);
    konf.r[1] = 2 + (6 << 4);
    konf.r[2] = 4 + (6 << 4);
    konf.r[3] = 5 + (7 << 4);

    klocki[1].rozmiar = 3;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    klocki[1].ksztalt[1][0] = 1;
    klocki[1].ksztalt[1][1] = 0;
    strcpy(klocki[1].opis_slowny,"Zgiety pd");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[4] = 1 + (5 << 4);

    klocki[2].rozmiar = 3;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 1;
    klocki[2].ksztalt[1][1] = 1;
    strcpy(klocki[2].opis_slowny,"Zgiety ld");
    ilosc_danego_rodzaju[2] = 1;
    konf.r[5] = 4 + (5 << 4);

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 2;
    klocki[3].ksztalt[1][1] = 0;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Odwrocone T");
    ilosc_danego_rodzaju[3] = 1;
    konf.r[6] = 2 + (1 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 6;
    wyjscie[0].polx = 2;
    wyjscie[0].poly = 7;

    klocki[4].rozmiar = 27;
    strcpy(klocki[4].opis_slowny,"Obramowka");
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 0;
    klocki[4].ksztalt[1][1] = 2;
    klocki[4].ksztalt[2][0] = 0;
    klocki[4].ksztalt[2][1] = 3;
    klocki[4].ksztalt[3][0] = 0;
    klocki[4].ksztalt[3][1] = 4;
    klocki[4].ksztalt[4][0] = 0;
    klocki[4].ksztalt[4][1] = 5;
    klocki[4].ksztalt[5][0] = 0;
    klocki[4].ksztalt[5][1] = 6;
    klocki[4].ksztalt[6][0] = 1;
    klocki[4].ksztalt[6][1] = 0;
    klocki[4].ksztalt[7][0] = 1;
    klocki[4].ksztalt[7][1] = 8;
    klocki[4].ksztalt[8][0] = 2;
    klocki[4].ksztalt[8][1] = 0;
    klocki[4].ksztalt[9][0] = 3;
    klocki[4].ksztalt[9][1] = 0;
    klocki[4].ksztalt[10][0] = 4;
    klocki[4].ksztalt[10][1] = 0;
    klocki[4].ksztalt[11][0] = 4;
    klocki[4].ksztalt[11][1] = 8;
    klocki[4].ksztalt[12][0] = 5;
    klocki[4].ksztalt[12][1] = 0;
    klocki[4].ksztalt[13][0] = 6;
    klocki[4].ksztalt[13][1] = 1;
    klocki[4].ksztalt[14][0] = 6;
    klocki[4].ksztalt[14][1] = 2;
    klocki[4].ksztalt[15][0] = 6;
    klocki[4].ksztalt[15][1] = 3;
    klocki[4].ksztalt[16][0] = 6;
    klocki[4].ksztalt[16][1] = 4;
    klocki[4].ksztalt[17][0] = 6;
    klocki[4].ksztalt[17][1] = 5;
    klocki[4].ksztalt[18][0] = 6;
    klocki[4].ksztalt[18][1] = 6;
    klocki[4].ksztalt[19][0] = 2;
    klocki[4].ksztalt[19][1] = 8;
    klocki[4].ksztalt[20][0] = 5;
    klocki[4].ksztalt[20][1] = 8;
    klocki[4].ksztalt[21][0] = 6;
    klocki[4].ksztalt[21][1] = 0;
    klocki[4].ksztalt[22][0] = 0;
    klocki[4].ksztalt[22][1] = 7;
    klocki[4].ksztalt[23][0] = 0;
    klocki[4].ksztalt[23][1] = 8;
    klocki[4].ksztalt[24][0] = 6;
    klocki[4].ksztalt[24][1] = 7;
    klocki[4].ksztalt[25][0] = 6;
    klocki[4].ksztalt[25][1] = 8;
    ilosc_danego_rodzaju[4] = 1;
    konf.r[7] = 0 + (0 << 4);

    klocki[5].rozmiar = 2;
    klocki[5].ksztalt[0][0] = 0;
    klocki[5].ksztalt[0][1] = 1;
    strcpy(klocki[5].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[5] = 2;
    konf.r[8] = 3 + (3 << 4);
    konf.r[9] = 3 + (5 << 4);

    klocki[6].rozmiar = 2;
    klocki[6].ksztalt[0][0] = 1;
    klocki[6].ksztalt[0][1] = 0;
    strcpy(klocki[6].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[6] = 2;
    konf.r[10] = 4 + (3 << 4);
    konf.r[11] = 4 + (4 << 4);

    klocki[7].rozmiar = 3;
    klocki[7].ksztalt[0][0] = 0;
    klocki[7].ksztalt[0][1] = 1;
    klocki[7].ksztalt[1][0] = 1;
    klocki[7].ksztalt[1][1] = 1;
    strcpy(klocki[7].opis_slowny,"Zgiety pg");
    ilosc_danego_rodzaju[7] = 1;
    konf.r[12] = 1 + (1 << 4);

    klocki[8].rozmiar = 3;
    klocki[8].ksztalt[0][0] = 0;
    klocki[8].ksztalt[0][1] = 1;
    klocki[8].ksztalt[1][0] = -1;
    klocki[8].ksztalt[1][1] = 1;
    strcpy(klocki[8].opis_slowny,"Zgiety lg");
    ilosc_danego_rodzaju[8] = 1;
    konf.r[13] = 5 + (1 << 4);

    klocki[9].rozmiar = 4;
    klocki[9].ksztalt[0][0] = 0;
    klocki[9].ksztalt[0][1] = 1;
    klocki[9].ksztalt[1][0] = 1;
    klocki[9].ksztalt[1][1] = 0;
    klocki[9].ksztalt[2][0] = 1;
    klocki[9].ksztalt[2][1] = 1;
    strcpy(klocki[9].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[9] = 1;
    konf.r[14] = 1 + (3 << 4);
*/
/*  wspinaczka 12 pro  
    N_rozp = 12;
    M = 7;
    plansza_x = 7;
    plansza_y = 7;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[0] = 4;
    konf.r[0] = 1 + (1 << 4);
    konf.r[1] = 5 + (1 << 4);
    konf.r[2] = 2 + (4 << 4);
    konf.r[3] = 4 + (3 << 4);

    klocki[1].rozmiar = 3;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    klocki[1].ksztalt[1][0] = 1;
    klocki[1].ksztalt[1][1] = 0;
    strcpy(klocki[1].opis_slowny,"Zgiety pd");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[4] = 1 + (2 << 4);

    klocki[2].rozmiar = 3;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 1;
    klocki[2].ksztalt[1][1] = 1;
    strcpy(klocki[2].opis_slowny,"Zgiety ld");
    ilosc_danego_rodzaju[2] = 1;
    konf.r[5] = 4 + (2 << 4);

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 2;
    klocki[3].ksztalt[1][1] = 0;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Odwrocone T");
    ilosc_danego_rodzaju[3] = 1;
    konf.r[6] = 2 + (1 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 6;
    wyjscie[0].polx = 2;
    wyjscie[0].poly = 5;

    klocki[4].rozmiar = 23;
    strcpy(klocki[4].opis_slowny,"Obramowka");
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 0;
    klocki[4].ksztalt[1][1] = 2;
    klocki[4].ksztalt[2][0] = 0;
    klocki[4].ksztalt[2][1] = 3;
    klocki[4].ksztalt[3][0] = 0;
    klocki[4].ksztalt[3][1] = 4;
    klocki[4].ksztalt[4][0] = 0;
    klocki[4].ksztalt[4][1] = 5;
    klocki[4].ksztalt[5][0] = 0;
    klocki[4].ksztalt[5][1] = 6;
    klocki[4].ksztalt[6][0] = 1;
    klocki[4].ksztalt[6][1] = 0;
    klocki[4].ksztalt[7][0] = 1;
    klocki[4].ksztalt[7][1] = 6;
    klocki[4].ksztalt[8][0] = 2;
    klocki[4].ksztalt[8][1] = 0;
    klocki[4].ksztalt[9][0] = 3;
    klocki[4].ksztalt[9][1] = 0;
    klocki[4].ksztalt[10][0] = 4;
    klocki[4].ksztalt[10][1] = 0;
    klocki[4].ksztalt[11][0] = 4;
    klocki[4].ksztalt[11][1] = 6;
    klocki[4].ksztalt[12][0] = 5;
    klocki[4].ksztalt[12][1] = 0;
    klocki[4].ksztalt[13][0] = 6;
    klocki[4].ksztalt[13][1] = 1;
    klocki[4].ksztalt[14][0] = 6;
    klocki[4].ksztalt[14][1] = 2;
    klocki[4].ksztalt[15][0] = 6;
    klocki[4].ksztalt[15][1] = 3;
    klocki[4].ksztalt[16][0] = 6;
    klocki[4].ksztalt[16][1] = 4;
    klocki[4].ksztalt[17][0] = 6;
    klocki[4].ksztalt[17][1] = 5;
    klocki[4].ksztalt[18][0] = 6;
    klocki[4].ksztalt[18][1] = 6;
    klocki[4].ksztalt[19][0] = 2;
    klocki[4].ksztalt[19][1] = 6;
    klocki[4].ksztalt[20][0] = 5;
    klocki[4].ksztalt[20][1] = 6;
    klocki[4].ksztalt[21][0] = 6;
    klocki[4].ksztalt[21][1] = 0;
    ilosc_danego_rodzaju[4] = 1;
    konf.r[7] = 0 + (0 << 4);

    klocki[5].rozmiar = 2;
    klocki[5].ksztalt[0][0] = 0;
    klocki[5].ksztalt[0][1] = 1;
    strcpy(klocki[5].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[5] = 2;
    konf.r[8] = 1 + (4 << 4);
    konf.r[9] = 5 + (4 << 4);

    klocki[6].rozmiar = 2;
    klocki[6].ksztalt[0][0] = 1;
    klocki[6].ksztalt[0][1] = 0;
    strcpy(klocki[6].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[6] = 2;
    konf.r[10] = 2 + (3 << 4);
    konf.r[11] = 3 + (4 << 4);
*/
/*  wspinaczka 12 
    N_rozp = 12;
    M = 7;
    plansza_x = 7;
    plansza_y = 7;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[0] = 4;
    konf.r[0] = 1 + (1 << 4);
    konf.r[1] = 5 + (1 << 4);
    konf.r[2] = 1 + (3 << 4);
    konf.r[3] = 5 + (3 << 4);

    klocki[1].rozmiar = 3;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    klocki[1].ksztalt[1][0] = 1;
    klocki[1].ksztalt[1][1] = 1;
    strcpy(klocki[1].opis_slowny,"Zgiety pg");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[4] = 2 + (3 << 4);

    klocki[2].rozmiar = 3;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 1;
    klocki[2].ksztalt[1][1] = 1;
    strcpy(klocki[2].opis_slowny,"Zgiety ld");
    ilosc_danego_rodzaju[2] = 1;
    konf.r[5] = 3 + (3 << 4);

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 2;
    klocki[3].ksztalt[1][1] = 0;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Odwrocone T");
    ilosc_danego_rodzaju[3] = 1;
    konf.r[6] = 2 + (1 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 6;
    wyjscie[0].polx = 2;
    wyjscie[0].poly = 5;

    klocki[4].rozmiar = 23;
    strcpy(klocki[4].opis_slowny,"Obramowka");
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 0;
    klocki[4].ksztalt[1][1] = 2;
    klocki[4].ksztalt[2][0] = 0;
    klocki[4].ksztalt[2][1] = 3;
    klocki[4].ksztalt[3][0] = 0;
    klocki[4].ksztalt[3][1] = 4;
    klocki[4].ksztalt[4][0] = 0;
    klocki[4].ksztalt[4][1] = 5;
    klocki[4].ksztalt[5][0] = 0;
    klocki[4].ksztalt[5][1] = 6;
    klocki[4].ksztalt[6][0] = 1;
    klocki[4].ksztalt[6][1] = 0;
    klocki[4].ksztalt[7][0] = 1;
    klocki[4].ksztalt[7][1] = 6;
    klocki[4].ksztalt[8][0] = 2;
    klocki[4].ksztalt[8][1] = 0;
    klocki[4].ksztalt[9][0] = 3;
    klocki[4].ksztalt[9][1] = 0;
    klocki[4].ksztalt[10][0] = 4;
    klocki[4].ksztalt[10][1] = 0;
    klocki[4].ksztalt[11][0] = 4;
    klocki[4].ksztalt[11][1] = 6;
    klocki[4].ksztalt[12][0] = 5;
    klocki[4].ksztalt[12][1] = 0;
    klocki[4].ksztalt[13][0] = 6;
    klocki[4].ksztalt[13][1] = 1;
    klocki[4].ksztalt[14][0] = 6;
    klocki[4].ksztalt[14][1] = 2;
    klocki[4].ksztalt[15][0] = 6;
    klocki[4].ksztalt[15][1] = 3;
    klocki[4].ksztalt[16][0] = 6;
    klocki[4].ksztalt[16][1] = 4;
    klocki[4].ksztalt[17][0] = 6;
    klocki[4].ksztalt[17][1] = 5;
    klocki[4].ksztalt[18][0] = 6;
    klocki[4].ksztalt[18][1] = 6;
    klocki[4].ksztalt[19][0] = 2;
    klocki[4].ksztalt[19][1] = 6;
    klocki[4].ksztalt[20][0] = 5;
    klocki[4].ksztalt[20][1] = 6;
    klocki[4].ksztalt[21][0] = 6;
    klocki[4].ksztalt[21][1] = 0;
    ilosc_danego_rodzaju[4] = 1;
    konf.r[7] = 0 + (0 << 4);

    klocki[5].rozmiar = 2;
    klocki[5].ksztalt[0][0] = 0;
    klocki[5].ksztalt[0][1] = 1;
    strcpy(klocki[5].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[5] = 2;
    konf.r[8] = 1 + (4 << 4);
    konf.r[9] = 5 + (4 << 4);

    klocki[6].rozmiar = 2;
    klocki[6].ksztalt[0][0] = 1;
    klocki[6].ksztalt[0][1] = 0;
    strcpy(klocki[6].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[6] = 2;
    konf.r[10] = 1 + (2 << 4);
    konf.r[11] = 4 + (2 << 4);
*/
/*  blok 10 
    N_rozp = 10;
    M = 6;
    plansza_x = 6;
    plansza_y = 7;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");

    klocki[1].rozmiar = 3;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    klocki[1].ksztalt[1][0] = 1;
    klocki[1].ksztalt[1][1] = 1;
    strcpy(klocki[1].opis_slowny,"Zgiety pg");


    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 0;
    klocki[3].ksztalt[1][1] = 1;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Kwadrat 2x2");

    klocki[4].rozmiar = 20;
    strcpy(klocki[4].opis_slowny,"Obramowka");
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 0;
    klocki[4].ksztalt[1][1] = 2;
    klocki[4].ksztalt[2][0] = 0;
    klocki[4].ksztalt[2][1] = 3;
    klocki[4].ksztalt[3][0] = 0;
    klocki[4].ksztalt[3][1] = 4;
    klocki[4].ksztalt[4][0] = 0;
    klocki[4].ksztalt[4][1] = 5;
    klocki[4].ksztalt[5][0] = 0;
    klocki[4].ksztalt[5][1] = 6;
    klocki[4].ksztalt[6][0] = 1;
    klocki[4].ksztalt[6][1] = 0;
    klocki[4].ksztalt[7][0] = 1;
    klocki[4].ksztalt[7][1] = 6;
    klocki[4].ksztalt[8][0] = 2;
    klocki[4].ksztalt[8][1] = 0;
    klocki[4].ksztalt[9][0] = 3;
    klocki[4].ksztalt[9][1] = 0;
    klocki[4].ksztalt[10][0] = 4;
    klocki[4].ksztalt[10][1] = 0;
    klocki[4].ksztalt[11][0] = 4;
    klocki[4].ksztalt[11][1] = 6;
    klocki[4].ksztalt[12][0] = 5;
    klocki[4].ksztalt[12][1] = 0;
    klocki[4].ksztalt[13][0] = 5;
    klocki[4].ksztalt[13][1] = 1;
    klocki[4].ksztalt[14][0] = 5;
    klocki[4].ksztalt[14][1] = 2;
    klocki[4].ksztalt[15][0] = 5;
    klocki[4].ksztalt[15][1] = 3;
    klocki[4].ksztalt[16][0] = 5;
    klocki[4].ksztalt[16][1] = 4;
    klocki[4].ksztalt[17][0] = 5;
    klocki[4].ksztalt[17][1] = 5;
    klocki[4].ksztalt[18][0] = 5;
    klocki[4].ksztalt[18][1] = 6;

    klocki[5].rozmiar = 3;
    klocki[5].ksztalt[0][0] = 1;
    klocki[5].ksztalt[0][1] = 0;
    klocki[5].ksztalt[1][0] = 1;
    klocki[5].ksztalt[1][1] = 1;
    strcpy(klocki[5].opis_slowny,"Zgiety ld");

    ilosc_danego_rodzaju[0] = 4;
    ilosc_danego_rodzaju[1] = 1;
    ilosc_danego_rodzaju[2] = 2;
    ilosc_danego_rodzaju[3] = 1;
    ilosc_danego_rodzaju[4] = 1;
    ilosc_danego_rodzaju[5] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 7;
    wyjscie[0].polx = 2;
    wyjscie[0].poly = 5;

    konf.r[0] = 1 + (1 << 4);
    konf.r[1] = 4 + (1 << 4);
    konf.r[2] = 2 + (4 << 4);
    konf.r[3] = 3 + (3 << 4);

    konf.r[4] = 1 + (2 << 4);

    konf.r[5] = 1 + (4 << 4);
    konf.r[6] = 4 + (2 << 4);

    konf.r[7] = 2 + (1 << 4);

    konf.r[8] = 0 + (0 << 4);

    konf.r[9] = 3 + (4 << 4);
*/
/*  wspinaczka 24 pro 
    N_rozp = 24;
    M = 11;
    plansza_x = 9;
    plansza_y = 11;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");
    ilosc_danego_rodzaju[0] = 4;
    konf.r[0] = 3 + (2 << 4);
    konf.r[1] = 5 + (2 << 4);
    konf.r[2] = 4 + (4 << 4);
    konf.r[3] = 4 + (5 << 4);

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    strcpy(klocki[1].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[1] = 4;
    konf.r[4] = 1 + (4 << 4);
    konf.r[5] = 3 + (4 << 4);
    konf.r[6] = 5 + (4 << 4);
    konf.r[7] = 7 + (4 << 4);

    klocki[2].rozmiar = 4;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 0;
    klocki[2].ksztalt[1][1] = 1;
    klocki[2].ksztalt[2][0] = 1;
    klocki[2].ksztalt[2][1] = 1;
    strcpy(klocki[2].opis_slowny,"Kwadrat 2x2 - ale taki zwykly");
    ilosc_danego_rodzaju[2] = 4;
    konf.r[8]  = 1 + (1 << 4);
    konf.r[9]  = 6 + (1 << 4);
    konf.r[10] = 1 + (7 << 4);
    konf.r[11] = 6 + (7 << 4);

    klocki[3].rozmiar = 2;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    strcpy(klocki[3].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[3] = 2;
    konf.r[12] = 1 + (9 << 4);
    konf.r[13] = 6 + (9 << 4);

    klocki[4].rozmiar = 3;
    klocki[4].ksztalt[0][0] = 1;
    klocki[4].ksztalt[0][1] = 0;
    klocki[4].ksztalt[1][0] = 2;
    klocki[4].ksztalt[1][1] = 0;
    strcpy(klocki[4].opis_slowny,"Poziomy prostokat 3x1");
    ilosc_danego_rodzaju[4] = 2;
    konf.r[14] = 3 + (3 << 4);
    konf.r[15] = 3 + (8 << 4);

    klocki[5].rozmiar = 3;
    klocki[5].ksztalt[0][0] = 1;
    klocki[5].ksztalt[0][1] = 0;
    klocki[5].ksztalt[1][0] = 1;
    klocki[5].ksztalt[1][1] = 1;
    strcpy(klocki[5].opis_slowny,"Zgiety ld");
    ilosc_danego_rodzaju[5] = 1;
    konf.r[16] = 1 + (3 << 4);

    klocki[6].rozmiar = 3;
    klocki[6].ksztalt[0][0] = 0;
    klocki[6].ksztalt[0][1] = 1;
    klocki[6].ksztalt[1][0] = 1;
    klocki[6].ksztalt[1][1] = 1;
    strcpy(klocki[6].opis_slowny,"Zgiety pg");
    ilosc_danego_rodzaju[6] = 1;
    konf.r[17] = 6 + (5 << 4);

    klocki[7].rozmiar = 3;
    klocki[7].ksztalt[0][0] = 1;
    klocki[7].ksztalt[0][1] = 0;
    klocki[7].ksztalt[1][0] = 1;
    klocki[7].ksztalt[1][1] = -1;
    strcpy(klocki[7].opis_slowny,"Zgiety lg");
    ilosc_danego_rodzaju[7] = 2;
    konf.r[18] = 1 + (6 << 4);
    konf.r[19] = 4 + (7 << 4);

    klocki[8].rozmiar = 3;
    klocki[8].ksztalt[0][0] = 0;
    klocki[8].ksztalt[0][1] = 1;
    klocki[8].ksztalt[1][0] = 1;
    klocki[8].ksztalt[1][1] = 0;
    strcpy(klocki[8].opis_slowny,"Zgiety pd");
    ilosc_danego_rodzaju[8] = 2;
    konf.r[20] = 3 + (6 << 4);
    konf.r[21] = 6 + (3 << 4);

    klocki[9].rozmiar = 35;
    klocki[9].ksztalt[0][0] = 0;
    klocki[9].ksztalt[0][1] = 1;
    klocki[9].ksztalt[1][0] = 0;
    klocki[9].ksztalt[1][1] = 2;
    klocki[9].ksztalt[2][0] = 0;
    klocki[9].ksztalt[2][1] = 3;
    klocki[9].ksztalt[3][0] = 0;
    klocki[9].ksztalt[3][1] = 4;
    klocki[9].ksztalt[4][0] = 0;
    klocki[9].ksztalt[4][1] = 5;
    klocki[9].ksztalt[5][0] = 0;
    klocki[9].ksztalt[5][1] = 6;
    klocki[9].ksztalt[6][0] = 0;
    klocki[9].ksztalt[6][1] = 7;
    klocki[9].ksztalt[7][0] = 0;
    klocki[9].ksztalt[7][1] = 8;
    klocki[9].ksztalt[8][0] = 0;
    klocki[9].ksztalt[8][1] = 9;
    klocki[9].ksztalt[9][0] =  0;
    klocki[9].ksztalt[9][1] =  10;
    klocki[9].ksztalt[10][0] = 1;
    klocki[9].ksztalt[10][1] = 0;
    klocki[9].ksztalt[11][0] = 2;
    klocki[9].ksztalt[11][1] = 0;
    klocki[9].ksztalt[12][0] = 3;
    klocki[9].ksztalt[12][1] = 0;
    klocki[9].ksztalt[13][0] = 4;
    klocki[9].ksztalt[13][1] = 0;
    klocki[9].ksztalt[14][0] = 5;
    klocki[9].ksztalt[14][1] = 0;
    klocki[9].ksztalt[15][0] = 6;
    klocki[9].ksztalt[15][1] = 0;
    klocki[9].ksztalt[16][0] = 7;
    klocki[9].ksztalt[16][1] = 0;
    klocki[9].ksztalt[17][0] = 8;
    klocki[9].ksztalt[17][1] = 0;
    klocki[9].ksztalt[18][0] = 8;
    klocki[9].ksztalt[18][1] = 1;
    klocki[9].ksztalt[19][0] = 8;
    klocki[9].ksztalt[19][1] = 2;
    klocki[9].ksztalt[20][0] = 8;
    klocki[9].ksztalt[20][1] = 3;
    klocki[9].ksztalt[21][0] = 8;
    klocki[9].ksztalt[21][1] = 4;
    klocki[9].ksztalt[22][0] = 8;
    klocki[9].ksztalt[22][1] = 5;
    klocki[9].ksztalt[23][0] = 8;
    klocki[9].ksztalt[23][1] = 6;
    klocki[9].ksztalt[24][0] = 8;
    klocki[9].ksztalt[24][1] = 7;
    klocki[9].ksztalt[25][0] = 8;
    klocki[9].ksztalt[25][1] = 8;
    klocki[9].ksztalt[26][0] = 8;
    klocki[9].ksztalt[26][1] = 9;
    klocki[9].ksztalt[27][0] = 8;
    klocki[9].ksztalt[27][1] = 10;
    klocki[9].ksztalt[28][0] = 1;
    klocki[9].ksztalt[28][1] = 10;
    klocki[9].ksztalt[29][0] = 2;
    klocki[9].ksztalt[29][1] = 10;
    klocki[9].ksztalt[30][0] = 3;
    klocki[9].ksztalt[30][1] = 10;
    klocki[9].ksztalt[31][0] = 5;
    klocki[9].ksztalt[31][1] = 10;
    klocki[9].ksztalt[32][0] = 6;
    klocki[9].ksztalt[32][1] = 10;
    klocki[9].ksztalt[33][0] = 7;
    klocki[9].ksztalt[33][1] = 10;
    strcpy(klocki[9].opis_slowny,"Odwodka");
    ilosc_danego_rodzaju[9] = 1;
    konf.r[22] = 0 + (0 << 4);

    klocki[10].rozmiar = 4;
    klocki[10].ksztalt[0][0] = 1;
    klocki[10].ksztalt[0][1] = 0;
    klocki[10].ksztalt[1][0] = 2;
    klocki[10].ksztalt[1][1] = 0;
    klocki[10].ksztalt[2][0] = 1;
    klocki[10].ksztalt[2][1] = 1;
    strcpy(klocki[10].opis_slowny,"Odwrocone T");
    ilosc_danego_rodzaju[10] = 1;
    konf.r[23]  = 3 + (1 << 4);
	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 23;
    wyjscie[0].polx = 3;
    wyjscie[0].poly = 9;

*/
/*  L/odzianka  
    N_rozp = 12;
    N_spak = 6; // 48 bitow
    M = 6;
    plansza_x = 7;
    plansza_y = 5;

    int k=-1, r=-1; // dla latwiejszego zapisu
    klocki[++k].rozmiar = 6;
    klocki[k].ksztalt[0][0] = 1;
    klocki[k].ksztalt[0][1] = 0;
    klocki[k].ksztalt[1][0] = 0;
    klocki[k].ksztalt[1][1] = 1;
    klocki[k].ksztalt[2][0] = 1;
    klocki[k].ksztalt[2][1] = 1;
    klocki[k].ksztalt[3][0] = 2;
    klocki[k].ksztalt[3][1] = 0;
    klocki[k].ksztalt[4][0] = 2;
    klocki[k].ksztalt[4][1] = 1;
    strcpy(klocki[k].opis_slowny,"Kwadrat 3x2");
    ilosc_danego_rodzaju[k] = 1;
    konf.r[++r] = 0 + (0 << 4);

    klocki[++k].rozmiar = 4;
    klocki[k].ksztalt[0][0] = 1;
    klocki[k].ksztalt[0][1] = 0;
    klocki[k].ksztalt[1][0] = 0;
    klocki[k].ksztalt[1][1] = 1;
    klocki[k].ksztalt[2][0] = 1;
    klocki[k].ksztalt[2][1] = 1;
    strcpy(klocki[k].opis_slowny,"Kwadrat 2x2 - ale taki zwykly");
    ilosc_danego_rodzaju[k] = 1;
    konf.r[++r] = 3 + (3 << 4);

    klocki[++k].rozmiar = 4;
    klocki[k].ksztalt[0][0] = 1;
    klocki[k].ksztalt[0][1] = 0;
    klocki[k].ksztalt[1][0] = 0;
    klocki[k].ksztalt[1][1] = 1;
    klocki[k].ksztalt[2][0] = 1;
    klocki[k].ksztalt[2][1] = 1;
    strcpy(klocki[k].opis_slowny,"Kwadrat 2x2 - ale taki co musi przejsc plansze");
    ilosc_danego_rodzaju[k] = 1;
    konf.r[++r] = 0 + (3 << 4);
    
	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = k;
    wyjscie[0].polx = 5;
    wyjscie[0].poly = 0;

    klocki[++k].rozmiar = 2;
    klocki[k].ksztalt[0][0] = 0;
    klocki[k].ksztalt[0][1] = 1;
    strcpy(klocki[k].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[k] = 3;
    konf.r[++r] = 3 + (0 << 4);
    konf.r[++r] = 4 + (0 << 4);
    konf.r[++r] = 2 + (3 << 4);

    klocki[++k].rozmiar = 2;
    klocki[k].ksztalt[0][0] = 1;
    klocki[k].ksztalt[0][1] = 0;
    strcpy(klocki[k].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[k] = 3;
    konf.r[++r] = 0 + (2 << 4);
    konf.r[++r] = 5 + (3 << 4);
    konf.r[++r] = 5 + (4 << 4);

    klocki[++k].rozmiar = 1;
    strcpy(klocki[k].opis_slowny,"Kwadrat");
    ilosc_danego_rodzaju[k] = 3;
    konf.r[++r] = 2 + (2 << 4);
    konf.r[++r] = 3 + (2 << 4);
    konf.r[++r] = 4 + (2 << 4);
*/
/*  puzzle proporcowe 
    N_rozp = 9;
    M = 4;
    plansza_x = 4;
    plansza_y = 5;
    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    strcpy(klocki[1].opis_slowny,"Poziomy prostokat");

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 0;
    klocki[3].ksztalt[1][1] = 1;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Kwadrat 2x2");

    ilosc_danego_rodzaju[0] = 2;
    ilosc_danego_rodzaju[1] = 4;
    ilosc_danego_rodzaju[2] = 2;
    ilosc_danego_rodzaju[3] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 8;
    wyjscie[0].polx = 0;
    wyjscie[0].poly = 0;

    konf.r[0] = 0 + (2 << 4);
    konf.r[1] = 1 + (2 << 4);

    konf.r[2] = 2 + (0 << 4);
    konf.r[3] = 2 + (1 << 4);
    konf.r[4] = 2 + (3 << 4);
    konf.r[5] = 2 + (4 << 4);

    konf.r[6] = 0 + (0 << 4);
    konf.r[7] = 1 + (0 << 4);

    konf.r[8] = 0 + (3 << 4);
*/
/*  peloponez  
    N_rozp = 10;
    N_spak = 6;
    M = 8;
    plansza_x = 7;
    plansza_y = 6;
    
    klocki[0].rozmiar = 6;
    klocki[0].ksztalt[0][0] = 1;
    klocki[0].ksztalt[0][1] = 0;
    klocki[0].ksztalt[1][0] = 0;
    klocki[0].ksztalt[1][1] = 1;
    klocki[0].ksztalt[2][0] = 1;
    klocki[0].ksztalt[2][1] = 1;
    klocki[0].ksztalt[3][0] = 0;
    klocki[0].ksztalt[3][1] = 2;
    klocki[0].ksztalt[4][0] = 1;
    klocki[0].ksztalt[4][1] = 2;
    strcpy(klocki[0].opis_slowny,"Pionowy prostokat 2x3");
    ilosc_danego_rodzaju[0] = 1;
    konf.r[0] = 5 + (0 << 4);

    klocki[1].rozmiar = 6;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    klocki[1].ksztalt[1][0] = 0;
    klocki[1].ksztalt[1][1] = 1;
    klocki[1].ksztalt[2][0] = 1;
    klocki[1].ksztalt[2][1] = 1;
    klocki[1].ksztalt[3][0] = 2;
    klocki[1].ksztalt[3][1] = 0;
    klocki[1].ksztalt[4][0] = 2;
    klocki[1].ksztalt[4][1] = 1;
    strcpy(klocki[1].opis_slowny,"Poziomy prostokat 3x2");
    ilosc_danego_rodzaju[1] = 1;
    konf.r[1] = 1 + (4 << 4);

    klocki[2].rozmiar = 5;
    klocki[2].ksztalt[0][0] = 2;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 0;
    klocki[2].ksztalt[1][1] = 1;
    klocki[2].ksztalt[2][0] = 1;
    klocki[2].ksztalt[2][1] = 1;
    klocki[2].ksztalt[3][0] = 2;
    klocki[2].ksztalt[3][1] = 1;
    strcpy(klocki[2].opis_slowny,"Mostek 3x2 (z 5-ciu kwadracikow)");
    ilosc_danego_rodzaju[2] = 1;
    konf.r[2] = 4 + (4 << 4);

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 2;
    wyjscie[0].polx = 0;
    wyjscie[0].poly = 0;

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 0;
    klocki[3].ksztalt[1][1] = 1;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[3] = 1;
    konf.r[3] = 2 + (2 << 4);

    klocki[4].rozmiar = 3;
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 0;
    klocki[4].ksztalt[1][1] = 2;
    strcpy(klocki[4].opis_slowny,"Pionowy prostokat 1x3");
    ilosc_danego_rodzaju[4] = 1;
    konf.r[4] = 0 + (3 << 4);
    
    klocki[5].rozmiar = 2;
    klocki[5].ksztalt[0][0] = 1;
    klocki[5].ksztalt[0][1] = 0;
    strcpy(klocki[5].opis_slowny,"Poziomy prostokat 2x1");
    ilosc_danego_rodzaju[5] = 1;
    konf.r[5] = 5 + (3 << 4);

    klocki[6].rozmiar = 2;
    klocki[6].ksztalt[0][0] = 0;
    klocki[6].ksztalt[0][1] = 1;
    strcpy(klocki[6].opis_slowny,"Pionowy prostokat 1x2");
    ilosc_danego_rodzaju[6] = 2;
    konf.r[6] = 4 + (0 << 4);
    konf.r[7] = 4 + (2 << 4);

    klocki[7].rozmiar = 1;
    strcpy(klocki[7].opis_slowny,"Kwadrat 1x1");
    ilosc_danego_rodzaju[7] = 2;
    konf.r[8] = 1 + (3 << 4);
    konf.r[9] = 5 + (4 << 4);
*/
/*  fiolek 
    N_rozp = 12;
    M = 3;
    plansza_x = 4;
    plansza_y = 5;
    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    strcpy(klocki[1].opis_slowny,"Pionowy prostokat");

    klocki[2].rozmiar = 4;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 0;
    klocki[2].ksztalt[1][1] = 1;
    klocki[2].ksztalt[2][0] = 1;
    klocki[2].ksztalt[2][1] = 1;
    strcpy(klocki[2].opis_slowny,"Kwadrat 2x2");

    ilosc_danego_rodzaju[0] = 8;
    ilosc_danego_rodzaju[1] = 3;
    ilosc_danego_rodzaju[2] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 11;
    wyjscie[0].polx = 1;
    wyjscie[0].poly = 0;

    konf.r[0] = 0 + (0 << 4);
    konf.r[1] = 3 + (0 << 4);
    konf.r[2] = 1 + (1 << 4);
    konf.r[3] = 2 + (1 << 4);
    konf.r[4] = 3 + (1 << 4);
    konf.r[5] = 1 + (2 << 4);
    konf.r[6] = 2 + (2 << 4);
    konf.r[7] = 3 + (2 << 4);

    konf.r[8] = 0 + (1 << 4);
    konf.r[9] = 0 + (3 << 4);
    konf.r[10] = 3 + (3 << 4);

    konf.r[11] = 1 + (3 << 4);
*/
/*  stokrotka 
    N_rozp = 13;
    M = 3;
    plansza_x = 4;
    plansza_y = 5;
    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    strcpy(klocki[1].opis_slowny,"Pionowy prostokat");

    klocki[2].rozmiar = 4;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 0;
    klocki[2].ksztalt[1][1] = 1;
    klocki[2].ksztalt[2][0] = 1;
    klocki[2].ksztalt[2][1] = 1;
    strcpy(klocki[2].opis_slowny,"Kwadrat 2x2");

    ilosc_danego_rodzaju[0] = 10;
    ilosc_danego_rodzaju[1] = 2;
    ilosc_danego_rodzaju[2] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 12;
    wyjscie[0].polx = 1;
    wyjscie[0].poly = 0;

    konf.r[0] = 0 + (0 << 4);
    konf.r[1] = 3 + (0 << 4);
    konf.r[2] = 0 + (1 << 4);
    konf.r[3] = 1 + (1 << 4);
    konf.r[4] = 2 + (1 << 4);
    konf.r[5] = 3 + (1 << 4);
    konf.r[6] = 0 + (2 << 4);
    konf.r[7] = 1 + (2 << 4);
    konf.r[8] = 2 + (2 << 4);
    konf.r[9] = 3 + (2 << 4);

    konf.r[10] = 0 + (3 << 4);
    konf.r[11] = 3 + (3 << 4);

    konf.r[12] = 1 + (3 << 4);
*/
/*  tylko 18 krokow
    N_rozp = 15;
    M = 2;
    plansza_x = 4;
    plansza_y = 5;
    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");

    klocki[1].rozmiar = 4;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    klocki[1].ksztalt[1][0] = 0;
    klocki[1].ksztalt[1][1] = 1;
    klocki[1].ksztalt[2][0] = 1;
    klocki[1].ksztalt[2][1] = 1;
    strcpy(klocki[1].opis_slowny,"Kwadrat 2x2");

    ilosc_danego_rodzaju[0] = 14;
    ilosc_danego_rodzaju[1] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 14;
    wyjscie[0].polx = 1;
    wyjscie[0].poly = 0;

    konf.r[0] = 0 + (0 << 4);
    konf.r[1] = 3 + (0 << 4);
    konf.r[2] = 0 + (1 << 4);
    konf.r[3] = 1 + (1 << 4);
    konf.r[4] = 2 + (1 << 4);
    konf.r[5] = 3 + (1 << 4);
    konf.r[6] = 0 + (2 << 4);
    konf.r[7] = 1 + (2 << 4);
    konf.r[8] = 2 + (2 << 4);
    konf.r[9] = 3 + (2 << 4);
    konf.r[10] = 0 + (3 << 4);
    konf.r[11] = 3 + (3 << 4);
    konf.r[12] = 0 + (4 << 4);
    konf.r[13] = 3 + (4 << 4);

    konf.r[14] = 1 + (3 << 4);
*/
/*  bratek 
    N_rozp = 11;
    M = 3;
    plansza_x = 4;
    plansza_y = 5;
    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    strcpy(klocki[1].opis_slowny,"Pionowy prostokat");

    klocki[2].rozmiar = 4;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 0;
    klocki[2].ksztalt[1][1] = 1;
    klocki[2].ksztalt[2][0] = 1;
    klocki[2].ksztalt[2][1] = 1;
    strcpy(klocki[2].opis_slowny,"Kwadrat 2x2");

    ilosc_danego_rodzaju[0] = 6;
    ilosc_danego_rodzaju[1] = 4;
    ilosc_danego_rodzaju[2] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 10;
    wyjscie[0].polx = 1;
    wyjscie[0].poly = 0;

    konf.r[0] = 0 + (0 << 4);
    konf.r[1] = 3 + (0 << 4);
    konf.r[2] = 1 + (1 << 4);
    konf.r[3] = 2 + (1 << 4);
    konf.r[4] = 1 + (2 << 4);
    konf.r[5] = 2 + (2 << 4);

    konf.r[6] = 0 + (1 << 4);
    konf.r[7] = 3 + (1 << 4);
    konf.r[8] = 0 + (3 << 4);
    konf.r[9] = 3 + (3 << 4);

    konf.r[10] = 1 + (3 << 4);
*/
/*  sciezka
    N_rozp = 10;
    M = 4;
    plansza_x = 4;
    plansza_y = 5;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    strcpy(klocki[1].opis_slowny,"Poziomy prostokat");

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 0;
    klocki[3].ksztalt[1][1] = 1;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Kwadrat 2x2");

    ilosc_danego_rodzaju[0] = 4;
    ilosc_danego_rodzaju[1] = 3;
    ilosc_danego_rodzaju[2] = 2;
    ilosc_danego_rodzaju[3] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 9;
    wyjscie[0].polx = 1;
    wyjscie[0].poly = 0;

    konf.r[0] = 0 + (1 << 4);
    konf.r[1] = 3 + (1 << 4);
    konf.r[2] = 0 + (2 << 4);
    konf.r[3] = 3 + (2 << 4);

    konf.r[4] = 1 + (0 << 4);
    konf.r[5] = 1 + (1 << 4);
    konf.r[6] = 1 + (2 << 4);

    konf.r[7] = 0 + (3 << 4);
    konf.r[8] = 3 + (3 << 4);

    konf.r[9] = 1 + (3 << 4);
*/
/*  mak
    N_rozp = 12;
    M = 4;
    plansza_x = 4;
    plansza_y = 5;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    strcpy(klocki[1].opis_slowny,"Poziomy prostokat");

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 0;
    klocki[3].ksztalt[1][1] = 1;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Kwadrat 2x2");

    ilosc_danego_rodzaju[0] = 8;
    ilosc_danego_rodzaju[1] = 1;
    ilosc_danego_rodzaju[2] = 2;
    ilosc_danego_rodzaju[3] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 11;
    wyjscie[0].polx = 1;
    wyjscie[0].poly = 0;

    konf.r[0] = 0 + (0 << 4);
    konf.r[1] = 3 + (0 << 4);
    konf.r[2] = 0 + (1 << 4);
    konf.r[3] = 1 + (1 << 4);
    konf.r[4] = 2 + (1 << 4);
    konf.r[5] = 3 + (1 << 4);
    konf.r[6] = 0 + (2 << 4);
    konf.r[7] = 3 + (2 << 4);

    konf.r[8] = 1 + (2 << 4);

    konf.r[9] = 0 + (3 << 4);
    konf.r[10] = 3 + (3 << 4);

    konf.r[11] = 1 + (3 << 4);
*/
/*  zasadzka 
    N_rozp = 10;
    M = 4;

    plansza_x = 4;
    plansza_y = 5;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    strcpy(klocki[1].opis_slowny,"Poziomy prostokat");

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 0;
    klocki[3].ksztalt[1][1] = 1;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Kwadrat 2x2");

    ilosc_danego_rodzaju[0] = 4;
    ilosc_danego_rodzaju[1] = 3;
    ilosc_danego_rodzaju[2] = 2;
    ilosc_danego_rodzaju[3] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 9;
    wyjscie[0].polx = 1;
    wyjscie[0].poly = 0;

    konf.r[0] = 0 + (1 << 4);
    konf.r[1] = 3 + (1 << 4);
    konf.r[2] = 0 + (4 << 4);
    konf.r[3] = 3 + (4 << 4);

    konf.r[4] = 1 + (0 << 4);
    konf.r[5] = 1 + (1 << 4);
    konf.r[6] = 1 + (2 << 4);

    konf.r[7] = 0 + (2 << 4);
    konf.r[8] = 3 + (2 << 4);

    konf.r[9] = 1 + (3 << 4);
*/
/*  przebisnieg  
    N_rozp = 11;
    M = 4;

    plansza_x = 4;
    plansza_y = 5;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    strcpy(klocki[1].opis_slowny,"Poziomy prostokat");

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 0;
    klocki[3].ksztalt[1][1] = 1;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Kwadrat 2x2");

    ilosc_danego_rodzaju[0] = 6;
    ilosc_danego_rodzaju[1] = 1;
    ilosc_danego_rodzaju[2] = 3;
    ilosc_danego_rodzaju[3] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 10;
    wyjscie[0].polx = 1;
    wyjscie[0].poly = 0;

    konf.r[0] = 0 + (0 << 4);
    konf.r[1] = 3 + (0 << 4);
    konf.r[2] = 1 + (1 << 4);
    konf.r[3] = 2 + (1 << 4);
    konf.r[4] = 3 + (1 << 4);
    konf.r[5] = 3 + (2 << 4);

    konf.r[6] = 1 + (2 << 4);

    konf.r[7] = 0 + (1 << 4);
    konf.r[8] = 0 + (3 << 4);
    konf.r[9] = 3 + (3 << 4);

    konf.r[10] = 1 + (3 << 4);

*/
/*  czerwony osiol
    N_rozp = 10;
    M = 4;

    plansza_x = 4;
    plansza_y = 5;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 1;
    klocki[1].ksztalt[0][1] = 0;
    strcpy(klocki[1].opis_slowny,"Poziomy prostokat");

    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 0;
    klocki[3].ksztalt[1][1] = 1;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Kwadrat 2x2");

    ilosc_danego_rodzaju[0] = 4;
    ilosc_danego_rodzaju[1] = 1;
    ilosc_danego_rodzaju[2] = 4;
    ilosc_danego_rodzaju[3] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 9;
    wyjscie[0].polx = 1;
    wyjscie[0].poly = 0;

    konf.r[0] = 0 + (0 << 4);
    konf.r[1] = 3 + (0 << 4);
    konf.r[2] = 1 + (1 << 4);
    konf.r[3] = 2 + (1 << 4);

    konf.r[4] = 1 + (2 << 4);

    konf.r[5] = 0 + (1 << 4);
    konf.r[6] = 3 + (1 << 4);
    konf.r[7] = 0 + (3 << 4);
    konf.r[8] = 3 + (3 << 4);

    konf.r[9] = 1 + (3 << 4);
*/
/*  blok 10 pro 
    N_rozp = 10;
    M = 6;
    plansza_x = 6;
    plansza_y = 7;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat 1x1");

    klocki[1].rozmiar = 3;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    klocki[1].ksztalt[1][0] = 1;
    klocki[1].ksztalt[1][1] = 1;
    strcpy(klocki[1].opis_slowny,"L w prawo - poczatek jak nalezy");


    klocki[2].rozmiar = 2;
    klocki[2].ksztalt[0][0] = 0;
    klocki[2].ksztalt[0][1] = 1;
    strcpy(klocki[2].opis_slowny,"Pionowy prostokat");

    klocki[3].rozmiar = 4;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    klocki[3].ksztalt[1][0] = 0;
    klocki[3].ksztalt[1][1] = 1;
    klocki[3].ksztalt[2][0] = 1;
    klocki[3].ksztalt[2][1] = 1;
    strcpy(klocki[3].opis_slowny,"Kwadrat 2x2");

    klocki[4].rozmiar = 20;
    strcpy(klocki[4].opis_slowny,"Obramowka");
    klocki[4].ksztalt[0][0] = 0;
    klocki[4].ksztalt[0][1] = 1;
    klocki[4].ksztalt[1][0] = 0;
    klocki[4].ksztalt[1][1] = 2;
    klocki[4].ksztalt[2][0] = 0;
    klocki[4].ksztalt[2][1] = 3;
    klocki[4].ksztalt[3][0] = 0;
    klocki[4].ksztalt[3][1] = 4;
    klocki[4].ksztalt[4][0] = 0;
    klocki[4].ksztalt[4][1] = 5;
    klocki[4].ksztalt[5][0] = 0;
    klocki[4].ksztalt[5][1] = 6;
    klocki[4].ksztalt[6][0] = 1;
    klocki[4].ksztalt[6][1] = 0;
    klocki[4].ksztalt[7][0] = 1;
    klocki[4].ksztalt[7][1] = 6;
    klocki[4].ksztalt[8][0] = 2;
    klocki[4].ksztalt[8][1] = 0;
    klocki[4].ksztalt[9][0] = 3;
    klocki[4].ksztalt[9][1] = 0;
    klocki[4].ksztalt[10][0] = 4;
    klocki[4].ksztalt[10][1] = 0;
    klocki[4].ksztalt[11][0] = 4;
    klocki[4].ksztalt[11][1] = 6;
    klocki[4].ksztalt[12][0] = 5;
    klocki[4].ksztalt[12][1] = 0;
    klocki[4].ksztalt[13][0] = 5;
    klocki[4].ksztalt[13][1] = 1;
    klocki[4].ksztalt[14][0] = 5;
    klocki[4].ksztalt[14][1] = 2;
    klocki[4].ksztalt[15][0] = 5;
    klocki[4].ksztalt[15][1] = 3;
    klocki[4].ksztalt[16][0] = 5;
    klocki[4].ksztalt[16][1] = 4;
    klocki[4].ksztalt[17][0] = 5;
    klocki[4].ksztalt[17][1] = 5;
    klocki[4].ksztalt[18][0] = 5;
    klocki[4].ksztalt[18][1] = 6;

    klocki[5].rozmiar = 3;
    klocki[5].ksztalt[0][0] = 1;
    klocki[5].ksztalt[0][1] = 0;
    klocki[5].ksztalt[1][0] = 1;
    klocki[5].ksztalt[1][1] = -1;
    strcpy(klocki[5].opis_slowny,"L w lewo - poczatek na lewym koncu u gory");

    ilosc_danego_rodzaju[0] = 4;
    ilosc_danego_rodzaju[1] = 1;
    ilosc_danego_rodzaju[2] = 2;
    ilosc_danego_rodzaju[3] = 1;
    ilosc_danego_rodzaju[4] = 1;
    ilosc_danego_rodzaju[5] = 1;

	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 7;
    wyjscie[0].polx = 2;
    wyjscie[0].poly = 5;

    konf.r[0] = 1 + (1 << 4);
    konf.r[1] = 4 + (1 << 4);
    konf.r[2] = 1 + (5 << 4);
    konf.r[3] = 4 + (5 << 4);

    konf.r[4] = 3 + (3 << 4);

    konf.r[5] = 1 + (2 << 4);
    konf.r[6] = 4 + (2 << 4);

    konf.r[7] = 2 + (1 << 4);

    konf.r[8] = 0 + (0 << 4);

    konf.r[9] = 1 + (4 << 4);
*/
/* polonez 
    N_rozp = 10;
    M = 5;
    plansza_x = 5;
    plansza_y = 5;

    klocki[0].rozmiar = 1;
    strcpy(klocki[0].opis_slowny,"Kwadrat");
    ilosc_danego_rodzaju[0] = 4;
    konf.r[0] = 0 + (2 << 4);
    konf.r[1] = 1 + (2 << 4);
    konf.r[2] = 2 + (0 << 4);
    konf.r[3] = 3 + (3 << 4);

    klocki[1].rozmiar = 2;
    klocki[1].ksztalt[0][0] = 0;
    klocki[1].ksztalt[0][1] = 1;
    strcpy(klocki[1].opis_slowny,"Pionowy prostokat");
    ilosc_danego_rodzaju[1] = 2;
    konf.r[4] = 2 + (1 << 4);
    konf.r[5] = 2 + (3 << 4);

    klocki[2].rozmiar = 4;
    klocki[2].ksztalt[0][0] = 1;
    klocki[2].ksztalt[0][1] = 0;
    klocki[2].ksztalt[1][0] = 0;
    klocki[2].ksztalt[1][1] = 1;
    klocki[2].ksztalt[2][0] = 1;
    klocki[2].ksztalt[2][1] = 1;
    strcpy(klocki[2].opis_slowny,"Kwadrat 2x2");
    ilosc_danego_rodzaju[2] = 2;
    konf.r[6] = 0 + (3 << 4);
    konf.r[7] = 3 + (0 << 4);

    klocki[3].rozmiar = 2;
    klocki[3].ksztalt[0][0] = 1;
    klocki[3].ksztalt[0][1] = 0;
    strcpy(klocki[3].opis_slowny,"Poziomy prostokat");
    ilosc_danego_rodzaju[3] = 1;
    konf.r[8] = 3 + (2 << 4);

    klocki[4].rozmiar = 3;
    klocki[4].ksztalt[0][0] = 1;
    klocki[4].ksztalt[0][1] = 0;
    klocki[4].ksztalt[1][0] = 1;
    klocki[4].ksztalt[1][1] = -1;
    strcpy(klocki[4].opis_slowny,"L w lewo??");
    ilosc_danego_rodzaju[4] = 1;
    konf.r[9] = 3 + (4 << 4);
	l_war_wyjscia=1;
    wyjscie[0].nr_klocka = 9;
    wyjscie[0].polx = 0;
    wyjscie[0].poly = 1;
*/

//---------------KONIEC INICJALIZACJI----------------


	//********** kilka poczatkowych testow: *******

	if (N_rozp > max_N_rozpakowane) {
    	std::cout << "Za duza liczba klockow!\n";
    	exit(-3);
	}

	if (M > max_M) {
    	std::cout << "Za duza liczba rodzajow klockow!\n";
    	exit(-3);
	}

	if (l_war_wyjscia > max_l_war_wyjscia) {
    	std::cout << "Za duza liczba warunkow dla szukanych rozwiazan!\n";
    	exit(-3);
	}

	int suma = 0;
	for (int i = 0; i < M; ++i)
    	suma += ilosc_danego_rodzaju[i];
	if (suma != N_rozp) {
    	std::cout<<"Niezgodnosc miedzy liczba klockow a suma poszczegolnych ich rodzajow!\n";
    	exit(-3);
	}

	//wypelnij nadmiarowa tablice
    for (int i = 0, k = 0; i < M; ++i)
        for (int j = 0; j < ilosc_danego_rodzaju[i]; ++j)
            rodzaj_klocka[k++] = i;

	//test!..............................................
    wypisz_konf_rozp_std_cerr(&konf);

	//sortuj poczatkowa konfiguracje, by uzytkownik nie musial sie tym przejmowac
    sortuj_konfiguracje(&konf);

	if (!dobra_konfiguracja(&konf)) {
    	std::cout << "Konfiguracja poczatkowa jest zla, dodatkowe informacje:\n";
    	wypisz_konf_rozp(&konf);
    	exit(-3);
	}

	// *********** koniec testow poczatkowych **********

    tkonf_spak = new konf_spakowana[max_liczba_konfiguracji];
    todl_konf = new int[max_odl_konf];
    trodzic = new int[max_liczba_konfiguracji];
    thash = new int[max_liczba_hashy];
    thash_potomek = new int[max_liczba_hashy];
    
    ltkonf = 1;//liczba elementow w tkonf
    trodzic[0] = -1; //pierwszy element nie ma rodzica
    
    todl_konf[0]=0;//rozpatrzona jest tylko jedna konf. (tj. poczatkowa)
    todl_konf[1]=1;
    najw_odl=0;

    inicjuj_tlbit();
	if (odwrotne)
		inicjuj_odwrotne();

    
	for (int i = 0; i < max_liczba_hashy; ++i){
    	thash[i] = -1;
    	thash_potomek[i] = -1;
	}

	spakuj_konfiguracje(&konf, &tkonf_spak[0]);

#ifdef TEST
	//wypisz co mamy na poczatku
    wypisz_konf_rozp_std_cerr(&konf);
    wypisz_konf_spak_std_cerr(&tkonf_spak[0], 0);
#endif

    dodaj_hash(0);//dodaj pierwszy element to tablicy hashow
    pierw_w_thash=0;

	// ---------------glowna czesc obliczen ---------------------------
	// znajdz wszystkich potomkow dla pierwszej konfiguracji

    int ilosc_wyrzuconych = 0; // jeszcze nic nie wyrzucilismy (i jesli USEDISC jest 
                                // niezdefiniownane, to tak zostanie
    bool zn_rozw = false; //czy znalezlismy juz rozwiazanie?

    while (true) {

		++najw_odl; //w ponizszej petli szukamy potomkow dla konf. o odl. "najw_odl-1",
					//ale musimy ustawic taka wartosc najw_odl, zeby opisywac potomkow
		for (int pozycja=todl_konf[najw_odl-1]; pozycja<todl_konf[najw_odl]; ++pozycja) {
        	znajdz_potomkow(pozycja);

#ifdef TEST
	        if (pozycja % 10000 == 0) {

    	        std::cerr <<pozycja<<" "<<todl(pozycja)<<" "<<ltkonf<<" "<<
            		ltkonf+ilosc_wyrzuconych<<" "<<lpos/2<<" "<<wierzch_thash
            		<<" "<<maks_bitow_przy_pakowaniu<<" "<<maks_bitow_przy_rozpakowaniu<<"\n";
        	}
#endif

	        if ((nr_rozw > -1) && (!zn_rozw)) {
    	    	zn_rozw = true;

				assert(nr_rozw < ltkonf);
				assert(nr_rozw >= 0);

        		std::cout << "Najkrotsza droga do rozwiazania: "<<todl(nr_rozw)<<" posuniec.\n";
        		std::cout << "Przykladowe najkrotsze rozwiazanie:\n";
        		std::cout << "Jakies rozwiazanie:\n - Odleglosc:" << todl(nr_rozw) << "\n";
        		wypisz_rozw(nr_rozw);

#ifdef FAST
#ifdef TEST
				assert(pozycja < ltkonf);
                std::cerr <<pozycja<<" "<<todl(pozycja)<<" "<<ltkonf<<" "<<
	           		ltkonf+ilosc_wyrzuconych<<" "<<lpos/2<<" "<<wierzch_thash
            		<<" "<<maks_bitow_przy_pakowaniu<<" "<<maks_bitow_przy_rozpakowaniu<<"\n";
#endif
				delete [] tkonf;
				delete [] todl_konf;
				delete [] trodzic;
				delete [] thash;
				delete [] thash_potomek;
				return 0;
#endif
	        }
		}
        
        todl_konf[najw_odl+1]=ltkonf;

		if (todl_konf[najw_odl+1] == todl_konf[najw_odl])
			break;

#ifdef USEDISC

        if (najw_odl > 1) {

			assert(todl_konf[najw_odl-2] == 0);
			
            int ilosc_do_wyrzucenia = todl_konf[najw_odl-1];
            assert(ilosc_do_wyrzucenia > 0);
            ilosc_wyrzuconych += ilosc_do_wyrzucenia;
            
            usun_hash(ilosc_do_wyrzucenia-1);
            
            FILE * plik;
            char nazwa_pliku[20];
            sprintf(nazwa_pliku,"konf_%d.dat",najw_odl-2);
            if (!(plik = fopen(nazwa_pliku,"wb"))) {
                std::cerr << "Nie moge utworzyc pliku " << nazwa_pliku << " !\n";
                exit(-4);
            }
			std::cerr << "Wyrzucam konfiguracje w liczbie: " << ilosc_do_wyrzucenia << "\n";
			std::cerr << "Pozostalo ich                  : " << ltkonf-ilosc_do_wyrzucenia << "\n";
            fwrite(&ilosc_do_wyrzucenia, sizeof(int), 1, plik);
            fwrite(tkonf_spak, sizeof(konf_spakowana), ilosc_do_wyrzucenia, plik);
            fwrite(trodzic, sizeof(int), ilosc_do_wyrzucenia, plik);
            fclose(plik);
            
            for (int i = ilosc_do_wyrzucenia; i < ltkonf; ++i) {

                kopiuj_konf_spak(i, i - ilosc_do_wyrzucenia);
                trodzic[i - ilosc_do_wyrzucenia] = trodzic[i] - ilosc_do_wyrzucenia;

                if (i < pierw_w_thash) {
                	std::cerr << " B "<<ilosc_do_wyrzucenia<<" "<<i<<" "<<todl_konf[najw_odl]<<" "<<pierw_w_thash<<std::endl;
                	return -4;
				} else
               	thash[ poz_w_thash(i) ] -= ilosc_do_wyrzucenia;
            }

			for (int i = 0; i <= najw_odl+1; ++i)
				todl_konf[i] -= ilosc_do_wyrzucenia;

            ltkonf -= ilosc_do_wyrzucenia;
            pierw_w_thash -= ilosc_do_wyrzucenia;
			assert(ltkonf >= 1);
			assert(pierw_w_thash >= 0);

            if (zn_rozw)
            	nr_rozw -= ilosc_do_wyrzucenia;

        }
#endif


    } //koniec glownej petli


#ifdef TEST

                 std::cerr <<ltkonf<<" "<<todl(ltkonf-1)<<" "<<ltkonf<<" "<<
            		ltkonf+ilosc_wyrzuconych<<" "<<lpos/2<<" "<<wierzch_thash
            		<<" "<<maks_bitow_przy_pakowaniu<<" "<<maks_bitow_przy_rozpakowaniu<<"\n";
#endif
    
    if (zn_rozw) {

		assert(ltkonf-1 >= 0);

        int max_odl = todl(ltkonf-1);
        std::cout << "Najdluzsza z najkrotszych drog na planszy: "<<max_odl<<" posuniec.\n";
        std::cout << "Liczba mozliwych ukladow klockow: "<<ltkonf+ilosc_wyrzuconych<<" .\n";
        std::cout << "Liczba mozliwych ruchow: "<<lpos/2<<" .\n";
        std::cout << "\nNajodleglejsze konfiguracje:\n";
        int i=ltkonf-1;
        while ((i>=0) && (todl(i) == max_odl)) {
            wypisz_rozw(i--);
            std::cout << "\n";
        }
    } else {
        std::cout << "Brak rozwiazania!\n";
        return -1;
    }

delete [] tkonf_spak;
delete [] todl_konf;
delete [] trodzic;
delete [] thash;
delete [] thash_potomek;

}