#include <stdlib.h>
#include <iostream>
#include <stdio.h>

using namespace std;

struct element_zrodla
{
	int symbol;
	int frequency;
};

struct element_zrodla model[256];
int licznik_symboli = 0;

int nazwa_pliku_Huffman(char *nazwa_pliku, char *rozszerzenie, char *nazwa_pliku_z_nowym_rozszerzeniem)
{
	int i = 0;
	int n = 0;
	for (i = 0; i<35; i++)
	{
		nazwa_pliku_z_nowym_rozszerzeniem[i] = 0;
	}
	while ((nazwa_pliku[n] != 46) && (nazwa_pliku[n] != ''))
	{
		n++;
	}
	for (i = 0; i<n; i++)
	{
		nazwa_pliku_z_nowym_rozszerzeniem[i] = nazwa_pliku[i];
	}
	nazwa_pliku_z_nowym_rozszerzeniem[i] = 46;
	n = 0;
	i++;
	while (rozszerzenie[n] != '')
	{
		nazwa_pliku_z_nowym_rozszerzeniem[i] = rozszerzenie[n];
		i++;
		n++;
	}
	return 0;
}
int utworz_model_niepelny_Huffman(struct element_zrodla model[], struct element_zrodla model_pelny[256])
{
	int n = 0;
	for (int i = 0; i<256; i++)
	{
		if (model_pelny[i].frequency>0)
		{
			model[n].symbol = model_pelny[i].symbol;
			model[n].frequency = model_pelny[i].frequency;
			n++;
		}
	}
	return n;
}
int oblicz_model_Huffman(char *nazwa_pliku, char *nazwa_pliku_model, char *nazwa_pliku_wynik, struct element_zrodla model[])
{
	int liczba_znakow = 0;
	int n = 0;
	unsigned char BUFOR_WEJSCIOWY[1000];
	struct element_zrodla model_pelny[256];
	for(int i = 0; i < 256; i++)
	{
		model_pelny[i].symbol = i;
		model_pelny[i].frequency = 0;
	}
	FILE *plik;
	plik = fopen(nazwa_pliku,"rb");
	if(plik == NULL)
	{
		cout <<"Nie udalo sie otworzyc pliku zrodlowego"<<endl;
		exit(0);
	}
	else
	{
	    cout <<"nOdczytuje plik zrodlowy"<<endl;
		while(n = fread(BUFOR_WEJSCIOWY, sizeof(unsigned char), 1000, plik))
		{
			for(int j = 0; j < n; j++)
			{
				model_pelny[BUFOR_WEJSCIOWY[j]].frequency++;
			}
			liczba_znakow += n;
		}
		cout << "nW pliku wejsciowym bylo  " << liczba_znakow  << " znakow "<<endl;
		fclose(plik);
		plik = fopen(nazwa_pliku_wynik, "wb");
		if(plik == NULL)
		{
			cout << "Nie mozna otworzyc pliku " << nazwa_pliku <<endl;
			exit(0);
		}
		else
		{
			fprintf(plik, "%d n", liczba_znakow);
			fclose(plik);
		}
		licznik_symboli = utworz_model_niepelny_Huffman(model, model_pelny);
		plik = fopen(nazwa_pliku_model, "wb");
		if(plik == NULL)
		{
			cout << "Nie mozna otworzyc pliku " <<nazwa_pliku_model <<endl;
			exit(0);
		}
		else
		{
			for(int k = 0; k < licznik_symboli; k++)
			{
				fprintf(plik, "%d %d n", model[k].symbol, model[k].frequency);
			}
			fclose(plik);
		}
	}
	return 0;
}

int funkcja_porownujaca(const void *element1, const void *element2)
{
	const struct element_zrodla *p1 = (const struct element_zrodla*) element1;
	const struct element_zrodla *p2 = (const struct element_zrodla*) element2;
	if ((p1->frequency) == (p2->frequency)) return 0;
	else if ((p1->frequency)<(p2->frequency)) return 1;
	else return -1;
}
int posortuj_model_Huffmana(struct element_zrodla model[], int liczba_elementow, char*plik_model_posortowany)
{
	qsort(model, liczba_elementow, sizeof(struct element_zrodla), funkcja_porownujaca);
	FILE *plik;
	plik = fopen(plik_model_posortowany, "wb");
	if (plik == NULL)
	{
		cout << "Blad w trakcie otwierania pliku do zapisu posortowanego modelu" <<endl;
		exit(0);
	}
	else
	{
		for (int i = 0; i<liczba_elementow; i++)
		{
			fprintf(plik, "%d %dn", model[i].symbol, model[i].frequency);
		}
		fclose(plik);
	}
}

struct galaz_drzewa
{
	int ojciec;
	int potomek1;
	int potomek2;
};

struct element_tablicy
{
	int symbol;
	unsigned char slowo[4];
	int liczba_bitow;
};

struct galaz_drzewa drzewo_kodowania[255];
struct element_tablicy tablica_kodowania[256];
struct element_tablicy tablica_kodowania_odczytana[256];

int utworz_drzewo(struct element_zrodla model[], struct galaz_drzewa drzewo[], int liczba_symboli, char* plik_drzewa, char* plik_mod_model)
{
	int licznik_pomocniczy = liczba_symboli;
	int licznik_symboli = liczba_symboli;
	int licznik_elementow_drzewa = 0;
	int licznik_dodanych = 0;
	int i = 0;
	for(i = 0; i<liczba_symboli - 1; i++)
	{
		drzewo[i].ojciec = 256 + i;
		drzewo[i].potomek1 = model[liczba_symboli - 1 - i].symbol;
		drzewo[i].potomek2 = model[liczba_symboli - 2 - i].symbol;
		model[liczba_symboli - 2 - i].symbol = 256 + i;
		model[liczba_symboli - 2 - i].frequency = model[liczba_symboli - 2 - i].frequency + model[liczba_symboli - 1 - i].frequency;
		licznik_symboli--;
		licznik_elementow_drzewa++;
		qsort(model, licznik_symboli, sizeof(struct element_zrodla), funkcja_porownujaca);
		licznik_dodanych++;
	}
	FILE *plik;
	plik = fopen(plik_mod_model, "wb");
	if (plik == NULL)
	{
		cout << "Blad w trakcie otwierania pliku ze zmodyfikowanym modelem" <<endl;
		exit(0);
	}
	else
	{
		for (i = 0; i<liczba_symboli; i++)
		{
			fprintf(plik, "%d %dn", model[i].symbol, model[i].frequency);
		}
		fclose(plik);
	}
	plik = fopen(plik_drzewa, "a+");
	if (plik == NULL)
	{
		cout << "Blad w trakcie otwierania pliku z drzewem " <<endl;
        exit(0);
	}
	else
	{
		fprintf(plik, "%d n", licznik_dodanych);
		for (i = 0; i<licznik_elementow_drzewa; i++)
		{
			fprintf(plik, "%d %d %d n", drzewo[i].ojciec, drzewo[i].potomek1, drzewo[i].potomek2);
		}
		fclose(plik);
	}
}

int utworz_tablice_kodowania(struct galaz_drzewa drzewo[], int liczba_symboli, struct element_tablicy tablica[], char *nazwa_pliku_tablicy, char* nazwa_pliku_tablicy_mod)
{
	int liczba_drzewa = liczba_symboli - 2;
	int licznik_tablicy = 0;
	int ojciec;
	int indeks_ojca_tablica;
	int liczba_bajtow;
	int liczba_bitow;
	int jedynka = 1;
	unsigned char bajty[4];

	for (int i = 0; i<2 * liczba_symboli; i++)
	{
		tablica[i].symbol = 0;
		tablica[i].liczba_bitow = 0;
		for (int j = 0; j<4; j++)
		{
			tablica[i].slowo[j] = 0;
		}
	}
	tablica[licznik_tablicy].symbol = drzewo[liczba_drzewa].ojciec;
	while (liczba_drzewa + 1)
	{
		ojciec = drzewo[liczba_drzewa].ojciec;
		tablica[licznik_tablicy + 1].symbol = drzewo[liczba_drzewa].potomek1;
		tablica[licznik_tablicy + 2].symbol = drzewo[liczba_drzewa].potomek2;
		indeks_ojca_tablica = -1;
		for (int i = 0; i<licznik_tablicy + 1; i++)
		{
			if ((tablica[i].symbol) == (ojciec))
			{
				indeks_ojca_tablica = i;
				break;
			}
		}
		if (indeks_ojca_tablica == -1)
		{
			cout <<"Blad tworzenia tablicy kodowania" <<endl;
			exit(0);
		}
		else
		{
			for (int i = 0; i<4; i++)
			{
				tablica[licznik_tablicy + 1].slowo[i] = tablica[indeks_ojca_tablica].slowo[i];
                tablica[licznik_tablicy + 2].slowo[i] = tablica[indeks_ojca_tablica].slowo[i];
			}
			liczba_bajtow = (tablica[indeks_ojca_tablica].liczba_bitow) / 8;
			liczba_bitow = (tablica[indeks_ojca_tablica].liczba_bitow) % 8;
			jedynka = 1;
			jedynka = jedynka << 7 - liczba_bitow;
			jedynka = tablica[indeks_ojca_tablica].slowo[liczba_bajtow] | jedynka;
			tablica[licznik_tablicy + 1].slowo[liczba_bajtow] = jedynka;
			tablica[licznik_tablicy + 1].liczba_bitow = tablica[indeks_ojca_tablica].liczba_bitow + 1;
			tablica[licznik_tablicy + 2].liczba_bitow = tablica[indeks_ojca_tablica].liczba_bitow + 1;
			licznik_tablicy = licznik_tablicy + 2;
			liczba_drzewa--;
		}
	}
	FILE *plik;
	plik = fopen(nazwa_pliku_tablicy, "wb");
	if (plik == NULL)
	{
		cout << "Blad w trakcie otwierania pliku z tablica kodowania" <<endl;
		exit(0);
	}
	else
	{
		for (int i = 0; i<2 * liczba_symboli - 1; i++)
		{
			for (int j = 0; j<4; j++)
			{
				bajty[j] = tablica[i].slowo[j];
			}
			fprintf(plik, "%d %d %d %d %d %dn", tablica[i].symbol, bajty[0], bajty[1], bajty[2], bajty[3], tablica[i].liczba_bitow);
		}
		fclose(plik);
	}
	plik = fopen(nazwa_pliku_tablicy_mod, "wb");
	if (plik == NULL)
	{
		cout << "Blad w trakcie otwierania pliku z tablica kodowania" <<endl;
		exit(0);
	}
	else
	{
		for (int i = 0; i<2 * liczba_symboli - 1; i++)
		{
			if (tablica[i].symbol < 256)
			{
				for (int j = 0; j < 4; j++)
				{
					bajty[j] = tablica[i].slowo[j];
				}
				fprintf(plik, "%d %d %d %d %d %dn", tablica[i].symbol, bajty[0], bajty[1], bajty[2], bajty[3], tablica[i].liczba_bitow);
			}
		}
		fclose(plik);
	}
}
int odczytaj_tablice_kodowania(struct element_tablicy tablica_kodowania[], char* plik_mod_tablicy)
{
	int dlugosc_slowa;
	int bajty[4];
	int kod_znaku;
	int liczba_znakow = 0;
	FILE *plik;
	plik = fopen(plik_mod_tablicy, "rb");
	if (plik == NULL)
	{
		cout << "Blad otwarcia pliku ze zmodyfikowana tablica kodowania" <<endl;
		exit(0);
	}
	else
	{
		while (fscanf(plik, "%d %d %d %d %d %d n", &kod_znaku, &bajty[0], &bajty[1], &bajty[2], &bajty[3], &dlugosc_slowa) != EOF)
		{
			if (dlugosc_slowa>0)
			{
				tablica_kodowania[liczba_znakow].symbol = kod_znaku;
				tablica_kodowania[liczba_znakow].liczba_bitow = dlugosc_slowa;
				for (int i = 0; i<4; i++)
				{
					tablica_kodowania[liczba_znakow].slowo[i] = bajty[i];
				}
				liczba_znakow++;
			}
		}
		fclose(plik);
		printf("Odczytano %d znakow z pliku ze zmodyfikowana tablica kodowanian", liczba_znakow);
	}
	return liczba_znakow;
}

int kompresja_Huffman(struct element_tablicy tablica_kodowania[], char* plik_wejsciowy, char* plik_wynikowy, int liczba_elementow_tablicy)
{
	int n;
	int liczba_bitow_znaku;
	int suma_bitow=0;
	int kursor;
	int kursor_out;
	int liczba_pozostalych;
	int liczba_wolne_bity;
	int liczba_zak_symboli;
	int numer_slowa;
	int numer_bajtu;
	int dopisek;
	unsigned char maska;
	unsigned char znak;
	unsigned char bufor_wejsciowy[1000];
	unsigned char bufor_wyjsciowy[1000];
	unsigned char slowo_znaku[4];
	unsigned char bajt_out;
	FILE *plik;
	FILE *plik_out;
	plik_out = fopen(plik_wynikowy, "a+");
	if (plik_out == NULL)
	{
		printf("Nie udalo sie otworzyc pliku wynikowegon");
		exit(0);
	}
	plik = fopen(plik_wejsciowy, "rb");
	if (plik == NULL)
	{
		printf("Nie udalo sie otworzyc pliku wejsciowegon");
		exit(0);
	}
	kursor_out = 0;
	numer_slowa = 0;
	numer_bajtu = 0;
	bajt_out = 0;
	liczba_zak_symboli = 0;
	while (n = fread(bufor_wejsciowy, sizeof(unsigned char),1000, plik))
	{
		for (int i = 0; i < n; i++)
		{
			znak = bufor_wejsciowy[i];
			for (int j = 0; j < liczba_elementow_tablicy; j++)
			{
				if (znak == tablica_kodowania[j].symbol)
				{
					for (int k = 0; k < 4; k++)
					{
						slowo_znaku[k] = tablica_kodowania[j].slowo[k];
					}
					liczba_bitow_znaku = tablica_kodowania[j].liczba_bitow;
					suma_bitow = suma_bitow + liczba_bitow_znaku;
					kursor = 0;
					numer_slowa = 0;
					break;
				}
			}
			while (liczba_bitow_znaku > 0)
			{
				liczba_pozostalych = 8 - kursor;
				if (liczba_pozostalych > liczba_bitow_znaku)
				{
					liczba_pozostalych = liczba_bitow_znaku;
				}
				liczba_wolne_bity = 8 - kursor_out;
				if (liczba_pozostalych < liczba_wolne_bity)
				{
					liczba_wolne_bity = liczba_pozostalych;
				}
				maska = ((255 >> kursor)&(255 << (8 - (kursor + liczba_wolne_bity))));
				dopisek = slowo_znaku[numer_slowa] & maska;
				dopisek = dopisek << kursor;
				dopisek = dopisek >> kursor_out;
				bajt_out = bajt_out | dopisek;
				kursor_out += liczba_wolne_bity;
				liczba_bitow_znaku -= liczba_wolne_bity;
				kursor += liczba_wolne_bity;
				liczba_pozostalych -= liczba_wolne_bity;
				if (liczba_pozostalych == 0)
				{
					numer_slowa++;
					kursor = 0;
					if (liczba_bitow_znaku >= 8)
					{
						liczba_pozostalych = 8;
					}
					else
					{
						liczba_pozostalych = liczba_bitow_znaku;
					}
				}
				if (kursor_out == 8)
				{
					fwrite(&bajt_out, sizeof(unsigned char), 1, plik_out);
					numer_bajtu++;
					kursor_out = 0;
					bajt_out = 0;
				}
			}
		liczba_zak_symboli++;
		}
	}
	printf("Bajt wyjsciowy numer %d kod hec %x n", numer_bajtu, bajt_out);
	fwrite(&bajt_out, sizeof(unsigned char), 1, plik_out);
	printf("Liczba zakodowanych znakow pliku kompresowego: %dn", liczba_zak_symboli);
	printf("Liczba bajtow w pliku skompresowanym: %dn", numer_bajtu + 1);
	printf("Wskaznik upakowania: %5.1f procentn", 100 * (float)(numer_bajtu + 1) / (float)liczba_zak_symboli);
	fclose(plik);
	fclose(plik_out);
    return suma_bitow;
}
int dekompresja_Huffman(char *nazwa_pliku_skom, char *nazwa_pliku_dekom, char *nazwa_pliku_tree, struct galaz_drzewa drzewo_kodowania[])
{
	int n;
	int m;
	int ojciec;
	int potomek1;
	int potomek2;
	int ilosc_symboli;
	int rozmiar_drzewa;
	int licznik_drzewa;
	int suma_symboli;
	int suma_bitow;
	unsigned char bajt_wejsciowy;
	unsigned char bajt_wyjsciowy;
	unsigned char maska = 128;
	unsigned char bit;
	FILE *plik_dek = NULL;
	plik_dek = fopen(nazwa_pliku_dekom, "wb");
	if(plik_dek == NULL)
	{
		printf("nBlad w trakcie otwierania pliku zdekodowanego do zapisun");
		exit(0);
	}
	FILE *plik_tree = NULL;
	plik_tree = fopen(nazwa_pliku_tree, "rb");
	if(plik_tree == NULL)
	{
		printf("nBlad w trakcie otwierania pliku z drzewem do odczytun");
		exit(0);
	}
	FILE *plik = NULL;
	plik = fopen(nazwa_pliku_skom, "rb");
	if(plik == NULL)
	{
		printf("nBlad w trakcie otwierania zakodowanego plikun");
		exit(0);
	}
	else
	{
		fscanf(plik_tree, "%dn %dn", &ilosc_symboli, &rozmiar_drzewa);
		licznik_drzewa = 0;
		for(int i = 0; i < rozmiar_drzewa; i++)
		{
			fscanf(plik_tree, "%d %d %dn", &ojciec, &potomek1, &potomek2);
			drzewo_kodowania[licznik_drzewa].ojciec = ojciec;
			drzewo_kodowania[licznik_drzewa].potomek1 = potomek1;
			drzewo_kodowania[licznik_drzewa].potomek2 = potomek2;
			licznik_drzewa++;
		}
		suma_symboli = 0;
		suma_bitow = 0;
		ojciec = drzewo_kodowania[rozmiar_drzewa - 1].ojciec;
		potomek1 = drzewo_kodowania[rozmiar_drzewa - 1].potomek1;
		potomek2 = drzewo_kodowania[rozmiar_drzewa - 1].potomek2;
		while(suma_symboli < ilosc_symboli)
		{
			n = fread(&bajt_wejsciowy, sizeof(unsigned char), 1, plik);
			if(n == 1)
			{
				for(int j = 0; j < 8; j++)
				{
					bit = bajt_wejsciowy&maska;
					bajt_wejsciowy = bajt_wejsciowy<<1;
					suma_bitow++;
					if(bit)
					{
						ojciec = potomek1;
					}
					else
					{
						ojciec = potomek2;
					}
					if(ojciec < 256)
					{
						bajt_wyjsciowy = ojciec;
						fwrite(&bajt_wyjsciowy, sizeof(unsigned char), 1, plik_dek);
						suma_symboli++;
						licznik_drzewa = rozmiar_drzewa - 1;
						ojciec = drzewo_kodowania[rozmiar_drzewa - 1].ojciec;
						potomek1 = drzewo_kodowania[rozmiar_drzewa - 1].potomek1;
						potomek2 = drzewo_kodowania[rozmiar_drzewa - 1].potomek2;
						if(suma_symboli == ilosc_symboli)
						{
							break;
						}
					}
					else
					{
						m = rozmiar_drzewa - 1;
						while(m >= 0)
						{
							if(drzewo_kodowania[m].ojciec == ojciec)
							{
								licznik_drzewa = m;
								m = -1;
							}
							m = m - 1;
						}
						potomek1 = drzewo_kodowania[licznik_drzewa].potomek1;
						potomek2 = drzewo_kodowania[licznik_drzewa].potomek2;
					}
				}
			}
		}
		printf("nLiczba odczytanych bitow: %d, liczba zdekodowanych symboli %d.n", suma_bitow, suma_symboli);
		fclose(plik);
		fclose(plik_dek);
		fclose(plik_tree);
		return(suma_symboli);
	}
}
int main()
{
	int wybor;
	char znak;
	char nazwa_pliku[30];
	char nazwa_pliku_modelu[35];
	char nazwa_pliku_mod_modelu[35];
	char nazwa_pliku_sort[35];
	char nazwa_pliku_drzewo[35];
	char nazwa_pliku_tablicy[35];
	char nazwa_pliku_mod_tablicy[35];
	char nazwa_pliku_wynik[35];
	char nazwa_pliku_dekom[35];
	char rozszerzenie_modelu[] = "model";
	char rozszerzenie_mod_modelu[] = "modmodel";
	char rozszerzenie_sort[] = "sort";
	char rozszerzenie_drzewo[] = "tree";
	char rozszerzenie_tablicy[] = "tab";
	char rozszerzenie_mod_tablicy[] = "modtab";
	char rozszerzenie_wynik[] = "huff";
	char rozszerzenie_dekom[] = "dek.txt";
	int liczba_elementow_tablicy = 0;
	cout << "Teoria informacji i kodowania " <<endl;
	cout << "Kodowanie i dekodowanie metoda Huffmana" <<endl;


	do
	{
		system("CLS");

		cout << "Teoria informacji i kodowania" <<endl;
		cout << "_____________________________" <<endl;
		cout << "[1] Kompresja metoda Huffmana" <<endl;
		cout << "[2] Dekompresja metoda Huffmana" <<endl;
		cout << "[0] Wyjscie" <<endl;
		cin >> wybor;
		if(wybor == 1)
		{
                cout << "Podaj nazwe pliku do kompresji wraz z rozszerzeniem: " ;
			scanf("%s", &nazwa_pliku);
			nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_modelu, nazwa_pliku_modelu);
			printf("nNazwa pliku z modelem:                    %sn", nazwa_pliku_modelu);
			nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_sort, nazwa_pliku_sort);
			printf("Nazwa pliku z posortowanym modelem:       %sn", nazwa_pliku_sort);
			nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_mod_modelu, nazwa_pliku_mod_modelu);
			printf("Nazwa pliku ze zmod. modelem:             %sn", nazwa_pliku_mod_modelu);

			nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_drzewo, nazwa_pliku_drzewo);
			printf("Nazwa pliku z drzewem kodowania:          %sn", nazwa_pliku_drzewo);

			nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_tablicy, nazwa_pliku_tablicy);
			printf("Nazwa pliku z tablica kodowania:          %sn", nazwa_pliku_tablicy);

			nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_mod_tablicy, nazwa_pliku_mod_tablicy);
			printf("Nazwa pliku ze zmod. tablica kodowania:   %sn", nazwa_pliku_mod_tablicy);

			nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_wynik, nazwa_pliku_wynik);
			printf("Nazwa pliku wynikowego:                   %sn", nazwa_pliku_wynik);
			oblicz_model_Huffman(nazwa_pliku, nazwa_pliku_modelu, nazwa_pliku_drzewo, model);
			posortuj_model_Huffmana(model, licznik_symboli, nazwa_pliku_sort);
			utworz_drzewo(model, drzewo_kodowania, licznik_symboli, nazwa_pliku_drzewo, nazwa_pliku_mod_modelu);
			utworz_tablice_kodowania(drzewo_kodowania, licznik_symboli, tablica_kodowania, nazwa_pliku_tablicy, nazwa_pliku_mod_tablicy);
			odczytaj_tablice_kodowania(tablica_kodowania, nazwa_pliku_mod_tablicy);
			kompresja_Huffman(tablica_kodowania, nazwa_pliku, nazwa_pliku_wynik, licznik_symboli);
            cout <<endl;
			system("PAUSE");
		}
		else if(wybor == 2)
		{
		    cout << "nPodaj nazwe pliku do dekompresji wraz z rozszerzeniem: ";
		 	scanf("%s", &nazwa_pliku);
			nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_drzewo, nazwa_pliku_drzewo);
			printf("nNazwa pliku z drzewem kodowania:   %sn", nazwa_pliku_drzewo);
			nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_dekom, nazwa_pliku_dekom);
			printf("Nazwa pliku po dekompresji:        %sn", nazwa_pliku_dekom);
			dekompresja_Huffman(nazwa_pliku, nazwa_pliku_dekom, nazwa_pliku_drzewo, drzewo_kodowania);
			system("PAUSE");
		}
    }while(wybor!=0);
}