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

    /*Bazisok lancolt listaja*/
    typedef struct bazis
    {
            unsigned sorszam; /*bazis sorszama*/
            unsigned koord_ed; /*bazis E-D koordinataja*/
            unsigned koord_kny; /*bazis K-Ny koordinataja*/
            unsigned befizetes; /*bazisra erkezett osszbefizetes*/
            struct rendeles *rendelesek; /*figyelni!!!*/
            struct bazis *kovetkezo;
    }bazis;

    typedef struct ajandek
    {
            unsigned sorszam; /*rendeles sorszama (melyik rendeles tartalmazza)*/
            unsigned ar; /*a rendelt termek ara*/
            struct ajandek *kovetkezo;
    }ajandek;

    typedef struct rendeles
    {
            unsigned sorszam; /*rendeles sorszama*/
            unsigned koord_ed; /*rendeles E-D koordinataja*/
            unsigned koord_kny; /*rendeles K-Ny koordinataja*/
            unsigned osszeg; /*szulok altal mellekelt osszeg*/
            unsigned bazis; /*hozzatartozo bazis sorszamat tartalmazza*/
            int lista[26];
            unsigned seged; /*ebben tarolom, hogy mennyi penz maradt az ajandekokra*/
            unsigned megoldas;
            struct rendeles *kovetkezo;
    }rendeles;

    /* double n_gyok(double m)
    {
            double i=0;
            int j;
            double x1,x2;
            while( (i*i) <= m )
                    i = i+0.1;
            x1=i;
            for(j=0;j<10;j++)
            {
            x2=m;
                    x2 = x2/x1;
                    x2 = x2+x1;
                    x2 = x2/2;
                    x1 = x2;
            }

            return x2;
    } */

    double tavolsag(double ed_bazis, double kny_bazis, double ed_rendeles, double kny_rendeles)   /*kiszamolja a megadott ket pont tavolsagat a koordinata rendszerben*/
    {
            double x;
            x = sqrt((ed_rendeles-ed_bazis)*(ed_rendeles-ed_bazis) + (kny_rendeles-kny_bazis)*(kny_rendeles-kny_bazis));
    /*      printf("%lf\n", x); */
            return x;
    }

    void kiszallitas_koltseg(struct bazis *gyoker){ /*kiszamolja, hogy az egyes rendelesek utikoltsege mennyi, es igy eltarolja, hogy mennyi penz marad az ajandekokra*/
            struct bazis *p_bazis=gyoker; /*bazis lancolt lista futovaltozo*/
            struct rendeles *p_rendeles=0, *p_elozo=0; /*rendeles lancolt lista futovaltozo es segedvaltozo az utak bejarasahoz*/
            double tav=0, mintav=0; /*tav: 2 pont tavolsaga, mintav: egy ponttol a legkisebb tavolsagra levo pont tavolsaga*/
            unsigned minsorszam=0; /*adott ponthoz a legkozelebb levo pont tavolsaga*/
            int n, i; /*segedvaltozok*/

    /*      printf("\n meg van hivva\n"); */
            while(p_bazis){ /*bazisokon vegigfutas*/
                    p_rendeles=p_bazis->rendelesek; /*bazison beluli rendelesek hivasa*/

                    n=0;
                    while (p_rendeles) { /*megszamolja, hogy hany rendeles van a kesobbi for ciklushoz*/
                            n++; /*n darab rendeles van*/
                            p_rendeles=p_rendeles->kovetkezo; /*ugras a kov. rendelesre*/
                    }
    /*              printf("rendelesek szama: %d\n", n); */
    /*bazishoz legkozelebbi rendeles vizsgalata*/
                    p_rendeles=p_bazis->rendelesek; /*bazison beluli rendelesek hivasa*/
                    /*inicializaljuk a mintav valtozot*/
                    printf ("%lf\n", (tavolsag(p_bazis->koord_ed, p_bazis->koord_kny, p_rendeles->koord_ed, p_rendeles->koord_kny)));
    /*              mintav=8589934591; /*ez igy nem jo, majd valahogy mashogy inicializalni kene a mintavot!!!*/
                    mintav = (tavolsag(p_bazis->koord_ed, p_bazis->koord_kny, p_rendeles->koord_ed, p_rendeles->koord_kny));
                    printf ("mintav: %lf\n", mintav);
                    while(p_rendeles){
                            tav=tavolsag(p_bazis->koord_ed, p_bazis->koord_kny, p_rendeles->koord_ed, p_rendeles->koord_kny);
    /*                      printf("tavok: %lf\n ", tav); */
                            if (tav<=mintav) {
                                    mintav=tav; /*bazishoz legkozelebb levo rendeles tavolsaga*/
                                    minsorszam=p_rendeles->sorszam; /*bazishoz legkozelebb levo rendeles sorszama*/
                                    printf("mintav1: %lf\n ", mintav);
                                                                    printf("minsorszam: %u\n ", minsorszam);
                            }
                    p_rendeles=p_rendeles->kovetkezo; /*ugras a kov. rendelesre*/
                    }

    /*              printf("minsorszam2: %u\n ", minsorszam);  */
                    p_rendeles=p_bazis->rendelesek; /*bazison beluli rendelesek hivasa*/
                    while(p_rendeles){
                            if (p_rendeles->sorszam == minsorszam) { /*megkeressuk azon sorszamu rendelest, amire elozoleg kiszamoltuk, hogy a legkozelebb all a bazishoz*/
                                    p_rendeles->seged = p_rendeles->osszeg - (((int)(mintav/ 1000 ) + 1) * 2);/*megadjuk, mennyi marad ajandekokra*/
                                    p_elozo=p_rendeles; /*adott rendeles beallitasa, hogy a kovetkezonel ossze lehessen vele hasonlítani a tavot*/
    /*                              printf("%u\n", p_elozo->koord_ed); */
                            }
                            p_rendeles=p_rendeles->kovetkezo; /*ugras a kov. rendelesre*/
                    }
    /*tobbi rendeles vizsgalata*/
    /*a ciklussal a bazishoz nem a legkozelebb levo rendeleseket jarjuk be es mentjuk el a maradek penzt*/
    /*printf("eddig OK, %u\n", p_elozo->koord_ed); */
                    for (i=1; i<n; i++) {
            /*inicializaljuk a mintav valtozot*/

    //      mintav=8589934591; /*ez igy nem jo, majd valahogy mashogy inicializalni kene a mintavot!!!*/
            p_rendeles=p_bazis->rendelesek; /*bazison beluli rendelesek hivasa*/
                            while (p_rendeles->seged != 0) {
                                    p_rendeles=p_rendeles->kovetkezo;
                            }
                            printf("mintav2: %lf\n",mintav=(tavolsag(p_elozo->koord_ed, p_elozo->koord_kny, p_rendeles->koord_ed, p_rendeles->koord_kny) ));
                                    printf("elozo1: %u\n", p_elozo->koord_ed);

            p_rendeles=p_bazis->rendelesek;
            while(p_rendeles){
                    if (p_rendeles->seged == 0) {
            /*              printf("elozo d_koord: %u\n", p_elozo->koord_ed); */
                            tav=tavolsag(p_elozo->koord_ed, p_elozo->koord_kny, p_rendeles->koord_ed, p_rendeles->koord_kny);
                            if (tav<=mintav) {
                                    mintav=tav; /*elozo rendeleshez legkozelebb levo rendeles tavolsaga*/
                                    minsorszam=p_rendeles->sorszam; /*bazishoz legkozelebb levo rendeles sorszama*/
                            }
                    }
                            p_rendeles=p_rendeles->kovetkezo; /*ugras a kov. rendelesre*/
                    }

                    /*              printf("minsorszam: %u\n ", minsorszam); */
                    p_rendeles=p_bazis->rendelesek; /*bazison beluli rendelesek hivasa*/
                    while(p_rendeles){
                            if (p_rendeles->sorszam == minsorszam) { /*megkeressuk azon sorszamu rendelest, amire elozoleg kiszamoltuk, hogy a legkozelebb all az elozo bazishoz*/
                                    p_rendeles->seged = p_rendeles->osszeg - (((int)(mintav/ 1000 ) + 1) * 2);/*megadjuk, mennyi marad ajandekokra*/
                                    /*                      printf("%u\n", p_rendeles->seged); */
                                    p_elozo=p_rendeles; /*adott rendeles beallitasa, hogy a kovetkezonel ossze lehessen vele hasonlítani a tavot*/
                            }
                            p_rendeles=p_rendeles->kovetkezo; /*ugras a kov. rendelesre*/
                    }
            }
                    p_bazis=p_bazis->kovetkezo; /*ugras a kov. bazisra*/
            }
    }


    void ertek_szamol(struct bazis *gyoker){ /*kiszamolja, mekkora erteku ajandekot kapott egy-egy gyerek es, egy-egy bazisrol mekkora osszerteku ajandekot szallitottak*/
            struct bazis *p_bazis=gyoker; /* bazis lancolt lista futovaltozo*/
            struct rendeles *p_rendeles=0; /*rendelesek lancolt lista futovaltozo*/
            unsigned max, bazisossz;
            int i;

            while(p_bazis){ /*bazisokon valo vegigfutas*/
                    bazisossz=0;
                    p_rendeles=p_bazis->rendelesek;
                    while(p_rendeles){ /*rendeleseken valo vegigfutas*/
                            max=0;
                            for (i=0; i<26; i++) { /*rendelesen beluli ajandek arlista vegigolvasasa*/
                                    max=max+p_rendeles->lista[i]; /*maximum ertek, amit az ajandekok osszerteke felvehet, mert meg kijon a befizetett osszegbol*/
                                    if (max <= p_rendeles->seged) {
                                            p_rendeles->megoldas=max; /*lehetseges rendelet ajandekok ossz ertekenek lista elembe mentese*/
                                    }
                            }
                            bazisossz=bazisossz+p_rendeles->megoldas; /*bazisrol kiszallitott ajandekok osszerteken osszeszamolasa*/
                            p_rendeles=p_rendeles->kovetkezo; /*kov. rendeles*/
                                    }
                    p_bazis->befizetes=bazisossz; /*bazisrol kiszallitott ajandekok osszertekenek listaelembe mentese*/
                    p_bazis=p_bazis->kovetkezo; /*kov. bazis*/
            }
    }

    unsigned legosszert_bazis(struct bazis *gyoker){ /*bazis megkeresese, ahonnan a legtobb osszerteku ajandekot szallitottak, visszateresi ertek ezen bazis sorszama*/
    struct  bazis *p_bazis=gyoker; /* bazis lancolt lista futovaltozo*/
            unsigned max, szam=0;

            max=p_bazis->befizetes; /* max segedvaltozo inicializalasa*/
            while(p_bazis){ /*bazisokon valo vegigfutas*/
                    if (max <= p_bazis->befizetes) { /*legnagyobb osszerteku kiszallitas megkeresese (maximum kereses)*/
                                    max = p_bazis->befizetes;
                    szam = p_bazis->sorszam ; /*a jelnelegi legnagyobb osszertekes kiszallitasos bazis sorszamat a segedvaltozoba mentem*/
                    }
                    p_bazis=p_bazis->kovetkezo; /*kov. bazis*/
                    }
            return szam;
    }


    /*unsigned legdelibb_ertek(unsigned sorszam, struct bazis *gyoker){ /*legdelebbi rendeles ajandek ertekenek kiszamolasa (ha a deli ertek a legnagyobb), visszateresi ertek a feladat vegeredmenye*/
    /*      struct bazis *p_bazis=gyoker; /* bazis lancolt lista futovaltozo*/
    /*      struct rendeles *p_rendeles=0; /* rendeles lancolt lista futovaltozo*/
    /*      unsigned max=0, ertek=0;

            while(p_bazis){ /*bazisokon vegigfutas*/
    /*              if (p_bazis->sorszam == sorszam) { /*megkeresi azt a bazist, aminek az erteket parameterkent megkapta (legnagyobb osszert. bazis)*/
    /*              p_rendeles=p_bazis->rendelesek; /*bazison beluli rendelesek hivasa*/
    /*                      max=p_rendeles->koord_ed; /*segedvaltozo inicializalas*/
    /*                      while(p_rendeles){ /*rendeleseken vegigfutas*/
    /*                      if (max <= p_rendeles->koord_ed) { /*rendelesek vizsgalata, legdelebbi megkeresese*/
    /*                              max = p_rendeles->koord_ed;
    /*                      ertek = p_rendeles->megoldas;  /*legdelebbi rendeles ajandek ertekenek segedvaltozoba helyezese*/
    /*                      }
    /*                      p_rendeles=p_rendeles->kovetkezo;  /*kov. rendeles*/
    /*              }
    /*              }
                    p_bazis=p_bazis->kovetkezo;  /*kov. bazis*/
    /*      }
    /*      printf("legdelibb.ertek: %u\n", ertek); */
    /*      return ertek;
    } */

    unsigned legdelibb_ertek(unsigned sorszam, struct bazis *gyoker){ /*legdelebbi rendeles ajandek ertekenek kiszamolasa (ha a deli ertek a legkisebb), visszateresi ertek a feladat vegeredmenye*/
            struct bazis *p_bazis=gyoker; /* bazis lancolt lista futovaltozo*/
            struct rendeles *p_rendeles=0; /* rendeles lancolt lista futovaltozo*/
            unsigned min=0, ertek=0;

            while(p_bazis){ /*bazisokon vegigfutas*/
                    if (p_bazis->sorszam == sorszam) { /*megkeresi azt a bazist, aminek az erteket parameterkent megkapta (legnagyobb osszert. bazis)*/
                            p_rendeles=p_bazis->rendelesek; /*bazison beluli rendelesek hivasa*/
                            min=p_rendeles->koord_ed; /*segedvaltozo inicializalas*/
                            while(p_rendeles){ /*rendeleseken vegigfutas*/
                                    if (min >= p_rendeles->koord_ed) { /*rendelesek vizsgalata, legdelebbi megkeresese*/
                                            min = p_rendeles->koord_ed;
                                            ertek = p_rendeles->megoldas; /*legdelebbi rendeles ajandek ertekenek segedvaltozoba helyezese*/
                                    }
                                    p_rendeles=p_rendeles->kovetkezo; /*kov. rendeles*/
                            }
                    }
                    p_bazis=p_bazis->kovetkezo; /*kov. bazis*/
            }
            /*      printf("legdelibb.ertek: %u\n", ertek); */
            return ertek;
    }



    void bazis_tolt(struct bazis **gyoker, unsigned sorszam, unsigned koord_ed, unsigned koord_kny)    /*bazisok helyet sorszamat tartalmazo lista feltoltese **first=gyoker */
    {
            unsigned befizetes=0;
            struct bazis *p_bazis;
            struct bazis *p_tarolo = NULL;

            if(!(*gyoker)){
                    /*Elso bazis felvetele, ha eddig ures az adatszerkezet*/
                    p_tarolo=(struct bazis*)malloc(sizeof(struct bazis));
                    if (p_tarolo==NULL) {
                            printf("sikertelen memoria foglalas\n");
                            fflush(stdin); getchar(); exit(1);
                    }
            p_tarolo->sorszam = sorszam;
            p_tarolo->koord_ed = koord_ed;
            p_tarolo->koord_kny = koord_kny;
            p_tarolo->befizetes =befizetes;
            p_tarolo->rendelesek=p_tarolo->kovetkezo=NULL;
            *gyoker=p_tarolo;
            }

            p_bazis=*gyoker; /*Elso bazisra allitas*/
            while(p_bazis->koord_ed!=koord_ed && p_bazis->koord_kny!=koord_kny){ /*Bazist megtalaltuk? (ha meg nem volt ilyen koordinataju, mehet tovabb)*/
                    if(!p_bazis->kovetkezo){ /*van meg bazis?*/
                            /*ha van, uj bazis letrehozasa*/
                            p_tarolo=(bazis*)malloc(sizeof(bazis));
                            if (p_tarolo==NULL) {
                                    printf("\n sikertelen memoria foglalas\n");
                                    fflush(stdin); getchar(); exit(1);
                            }
                            p_tarolo->kovetkezo=p_tarolo->rendelesek=NULL;
                            p_tarolo->sorszam = sorszam;
                            p_tarolo->koord_ed = koord_ed;
                            p_tarolo->koord_kny = koord_kny;
                            p_tarolo->befizetes =befizetes;
                            p_bazis->kovetkezo=p_tarolo;
                    }
                    p_bazis=p_bazis->kovetkezo; /*kov. bazis*/
            }
    }

    void arak_tolt(struct ajandek **gyoker, unsigned sorszam, unsigned ar)
    {
            struct ajandek *p_ajandek;
            struct ajandek *p_tarolo = NULL;

            if(!(*gyoker)){
                    /*Elso bazis felvetele*/
                    p_tarolo=(struct ajandek*)malloc(sizeof(struct ajandek));
                    if (p_tarolo==NULL) {
                            printf("sikertelen memoria foglalas\n");
                            fflush(stdin); getchar(); exit(1);
                    }
                    p_tarolo->sorszam = sorszam;
                    p_tarolo->ar =ar;
                    p_tarolo->kovetkezo=NULL;
                    *gyoker=p_tarolo;
            }

            p_ajandek=*gyoker;
            while(p_ajandek->sorszam!=sorszam){
                    if(!p_ajandek->kovetkezo){
                            /*bazis felvetele, ha meg nem letezik*/
                            p_tarolo=(ajandek*)malloc(sizeof(ajandek));
                            if (p_tarolo==NULL) {
                                    printf("\n sikertelen memoria foglalas\n");
                                    fflush(stdin); getchar(); exit(1);
                            }
                            p_tarolo->kovetkezo=NULL;
                            p_tarolo->sorszam = sorszam;
                            p_tarolo->ar = ar;
                            p_ajandek->kovetkezo=p_tarolo;
                    }
                    p_ajandek=p_ajandek->kovetkezo;
            }
    }


    void rendeles_tolt(struct bazis *bazisgyoker,unsigned koord_ed, unsigned koord_kny, unsigned sorszam,int *t,unsigned osszeg)
    {
            struct rendeles *p_rendeles;
            struct rendeles *p_ujrendeles = NULL;
            struct bazis *p_bazis = bazisgyoker; /*lepeteto pointer a bazis listara, a felfuzeshez*/
            double tav=0, mintav=0;
            int i;
            p_ujrendeles = (struct rendeles*)malloc(sizeof(struct rendeles));  /*memoriafoglalas uj elemnek + hibajelzes*/
            if (p_ujrendeles==NULL) {
                    printf("sikertelen memoria foglalas\n");
                    fflush(stdin); getchar(); exit(1);
            }

            /*az uj elem adatainak feltoltese*/

            p_ujrendeles->sorszam = sorszam;
            p_ujrendeles->koord_ed = koord_ed;
            p_ujrendeles->koord_kny = koord_kny;
            p_ujrendeles->osszeg = osszeg;
            p_ujrendeles->seged = 0;
            p_ujrendeles->megoldas = 0;
            p_ujrendeles->kovetkezo = NULL;
            for(i=0;i<26;i++)
            {
                    p_ujrendeles->lista[i] = t[i];
            }
            p_ujrendeles->kovetkezo = NULL;
            if(p_bazis == bazisgyoker) /*beallitja a mintav-ot a kereseshez*/
            {
                    tav=tavolsag(p_bazis->koord_ed, p_bazis->koord_kny, koord_ed, koord_kny);
                    mintav=tav;
                    p_ujrendeles->bazis = p_bazis->sorszam;
            }
            do  /*megkeresi melyik bazis van a legkozelebb a rendeleshez es a bazis kodjat elmenti*/
            {
                    tav=tavolsag(p_bazis->koord_ed, p_bazis->koord_kny, koord_ed, koord_kny);
                    if(mintav>tav)
                    {
                            mintav=tav;
                            p_ujrendeles->bazis = p_bazis->sorszam;
                    }
            }while(p_bazis=p_bazis->kovetkezo);

            /*adatok feltoltest kovetoen a listaba helyezes a bazisokhoz valo tavolsag alapjan*/

            p_bazis=bazisgyoker;

            do /*do-while ciklusban vegigfuftunk a pazisokon*/
            {
                    if(p_bazis->sorszam == p_ujrendeles->bazis) /*ha az aktualis bazis van a legkozelebb a rendeleshez*/
                    {
                            if(p_bazis->rendelesek == NULL) /*akkor ha arrol a bazisrol meg nem log rendeles, fuzzuk ra az elsot*/
                            {
                                    p_bazis->rendelesek = p_ujrendeles;
                            }
                            else /*ha az aktualis bazison mar van rendeles*/
                            {
                                    p_rendeles=p_bazis->rendelesek; /*akkor segedvaltozot allitsuk ra*/
                                    if(p_rendeles->kovetkezo == NULL) /*ha nincs kovetkezo rendeles (tehat az utolso, vagyis eddig egy darab rendeles van)*/
                                    {
                                            p_rendeles->kovetkezo = p_ujrendeles; /*tegyuk be kovetkezonek az aktualis rendelest*/
                                    }
                                    else /*ha tobb rendeles log mar az aktualis bazison*/
                                    {
                                            while(p_rendeles->kovetkezo) /*vegigfutunk rajta*/
                                            {
                                                    p_rendeles=p_rendeles->kovetkezo;
                                            }
                                    }
                                    p_rendeles->kovetkezo = p_ujrendeles; /*a rendeleslista vegere berakjuk az aktualis rendelest*/
                            }
                    }
            }while(p_bazis=p_bazis->kovetkezo);
    }

    void datolvas_bazis(FILE*f,struct bazis **bazisgyoker){ /*olvasando fajl, felepitendo adatszerkezet (a gyoker mutato megvaltozott erteket pointerben adja viszza)*/
            unsigned a, b, sorszam;/* dat fajl olvasasahoz segedvaltozok*/
            a=b=0;
            sorszam=1;
            while(fread(&a,4,1,f)){
                    fread(&b,4,1,f); /*4-es helyett lehet: sizeof(unsigned int) is*/
                    if(!feof (f))                           /*vizsgalat, hogy az utolso elem ne 2-szer legyen beirva*/
                    {
                            bazis_tolt(bazisgyoker,sorszam,a,b);
                    }
                    sorszam++;
            }
    }

    void datolvas_arak(FILE *f, struct ajandek **ajandekgyoker)  /*price beolvas·sa*/
    {
            unsigned ar;
            unsigned sorszam;

            sorszam = 0;
            while(fread(&ar,4,1,f)) /*soronkent olvasunk, amig el nem fogynak*/
            {
                    if(!feof (f))            /*vizsgalat, hogy az utolso elem ne 2-szer legyen beirva*/
                    {
                            arak_tolt(ajandekgyoker,sorszam,ar);
                    }

                    sorszam++;
            }
    }

    void txtolvas_rendeles(FILE*f, struct bazis *bazisgyoker, struct ajandek *gyoker){

            ajandek *p_ajandek = gyoker;
            int d, i;
            unsigned a, b, sorszam=1; //
            unsigned osszeg;

            char c;
            int lista[26]={'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
            a=b=c=d=osszeg=0;
            while (fscanf(f, "%u %u\n",&a,&b)==2) { /*beolvassuk az e-d es k-ny koordinatakat*/

                    for(i=0;i<26;i++)
                    {
                            lista[i]=0;
                    }

                    i=0;
                    while((c=fgetc(f))!='\n'){
                            d=c-65;
            /*              printf("%d ", d); */
                            p_ajandek = gyoker;
                            while (p_ajandek) {
                                    if (p_ajandek->sorszam == d) {
                            /*      printf("%d ", p_ajandek->sorszam); */
                                            lista[i] = p_ajandek->ar; /*termekek erteket kellene tarolni, de egyelore a lancra fuzesen van a hangsuly*/
                            /*      printf("%u ", lista[i]); */
                            i++;
                                    }
                            p_ajandek=p_ajandek->kovetkezo;
                            }
            //      i++;
                    }
                    fscanf(f, "%u\n",&osszeg); /*beolvasom a befizetett osszeget*/
    /*              printf(" %u %u  %u \n", a, b, osszeg);  */
                    rendeles_tolt(bazisgyoker,a,b,sorszam,lista,osszeg);
                    sorszam++;
            }
    }



    void listakiir1(struct bazis *gyoker){ //rendelesek adatszerkezete
            bazis *p_bazis=gyoker; // bazis lancolt lista futovaltozo
            if (p_bazis) {
                    while(p_bazis){ //bazisokon valo vegigfutas
                            printf(" %u,  %u,  %u\n",p_bazis->koord_ed, p_bazis->koord_kny, p_bazis->sorszam);
                            p_bazis=p_bazis->kovetkezo; //kov. bazis
                    }
            }else printf("\n lista ures\n");
    }

    void listakiir(bazis*gyoker){ //rendelesek adatszerkezete
            struct bazis *p_bazis=gyoker; // bazis lancolt lista futovaltozo
            struct rendeles *p_rendeles=0; //rendelesek lancolt lista futovaltozo
            while(p_bazis){ //bazisokon valo vegigfutas
                    printf(" %u,  %u,  %u, %u\n",p_bazis->koord_ed, p_bazis->koord_kny, p_bazis->sorszam, p_bazis->befizetes);
                    p_rendeles=p_bazis->rendelesek; //bazison beluli rendeles(ek) "hivasa"
                    while(p_rendeles){ //rendeleseken valo vegigfutas
                            printf("   %u %u %u %u ajandek ert.: %u\n",p_rendeles->koord_ed, p_rendeles->koord_kny , p_rendeles->sorszam, p_rendeles->seged, p_rendeles->megoldas );
                            p_rendeles=p_rendeles->kovetkezo; //kov. rendeles
                    }
                    p_bazis=p_bazis->kovetkezo; //kov. bazis
            }
    }

    void ajandek_listakiir(ajandek *gyoker){ //rendelesek adatszerkezete
            struct ajandek *p_ajandek=gyoker; // bazis lancolt lista futovaltozo
            if (p_ajandek) {
                    while(p_ajandek){ //bazisokon valo vegigfutas
                            printf(" %u,  %u\n",p_ajandek->sorszam, p_ajandek->ar);
                            p_ajandek=p_ajandek->kovetkezo; //kov. bazis
                    }
            }else printf("\n lista ures\n");
    }


    int main () {
            unsigned x=0, y=0;
            FILE*f; /*file-ok eleresehez mutato */
            struct bazis *bazisgyoker=NULL;
            struct ajandek *ajandekgyoker=NULL;
            /*base.dat ellenorzes es kiiratas*/
    /*      if (f=fopen("base.dat", "rb")) { //ha nem letezik a base.dat fajl, azt jelezze*/
    /*              printf("%s", "base.dat  letezik\n");
            }
            else {
                    printf("%s", "base.dat nem letezik\n");   } */
            f=fopen("base.dat","rb"); //nyissa meg a base.dat-ot
            datolvas_bazis(f,&bazisgyoker);
            fclose(f);
    /*      listakiir1(bazisgyoker); /*lancolt lista kiiratasa kepernyore */
            /*price.dat ellenorzes es beolvasas */
    /*      if (f=fopen("price.dat", "rb")) { /*ha nem letezik a price.dat fajl, azt jelezze */
    /*              printf("%s", "price.dat  letezik\n");
            }
            else {
                    printf("%s", "price.dat nem letezik\n");   } */
            f=fopen("price.dat","rb");
            datolvas_arak(f, &ajandekgyoker);
            fclose(f);
    /*      if (f=fopen("gift.txt", "r")) { /*ha nem letezik a gift.txt fajl, azt jelezze */
    /*              printf("%s", "gift.txt  letezik\n");
            }
            else {
                    printf("%s", "gift.txt nem letezik\n");   } */
            f=fopen("gift.txt","r");
            txtolvas_rendeles(f, bazisgyoker, ajandekgyoker);
            fclose(f);
    /*      ajandek_listakiir(ajandekgyoker); */
    /*      listakiir(bazisgyoker);  */
            kiszallitas_koltseg(bazisgyoker);
            ertek_szamol(bazisgyoker);
            listakiir(bazisgyoker);
            y=legosszert_bazis(bazisgyoker);
            x=legdelibb_ertek(y, bazisgyoker);
            printf("%d\n", x);
    /*      printf("max.sorszama: %u\n", y); */
    /*      fflush(stdin); getchar();  */

        return 0;
    }