Poprawka woznica

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

void wprowadz_dane(float &dana) {
    float zmienna;
    scanf("%f", &zmienna);
    dana = zmienna;
}

void wprowadz_dane(int &dana) {
    int zmienna;
    scanf("%d", &zmienna);
    dana = zmienna;
}

bool warunek_1(float *x1, float *x2, float *y1, float *y2, int *pod) {
    if (*x1 == *x2) return false;
    else if (*y1 == *y2) return false;
    else if (*pod < 0) return false;
    return true;
}

struct kwadrat {
    int iX, iY; // indexy
    float XLD, YLD, XPG, YPG; // lokalizacje
};

void wyswietlanie(struct kwadrat **k, int pod){
    for(int i=0 ; i<pow(2, pod) ; i++)
        for(int j=0 ; j<pow(2, pod);j++)
            printf("<%d:%d\t(%.2f;%.2f)\t(%.2f;%.2f)>\n",k[i][j].iX,k[i][j].iY,k[i][j].XLD,k[i][j].YLD,k[i][j].XPG,k[i][j].YPG); // 2 miejsca po przecinku dla czytelnosci
}

int main(int argc, char *argv[]) {
    int POD;       // deklaracja zmiennej na dana wejsciowa poziomu podziału
    /*
      deklaracja zmiennych na:
                 dane wejsciowe: definiujace prostokat w kartezianskim ukladzie wspolrzednych
                                 za pomoca przciwleglych wierzcholkow (XLD,YLD,XPG,YPG)
                 dane robocze: dlugosci bokow najmniejszych prostokatow wynikajacych z poziomu podzialu (DX, DY)
                               lewych dolnych wierzcholkow najmniejszych prostokatow wynikajacych z poziomu podzialu (X, Y)
                                      i nie tylko w tym celu
                               decyzja o ponownych obliczeniach (next_calc)
    */
    float XLD, YLD, XPG, YPG, DX, DY, X, Y;
    int next_calc;

    do {
        next_calc = 1;
        printf("Podaj wspolrzedna x dolnego lewewego wierzcholka prostokata\n");
        wprowadz_dane(XLD); // <------------------------------------Funkcja z wskaznikami
        printf("Podaj wspolrzedna y dolnego lewego wierzcholka prostokata \n");
        wprowadz_dane(YLD);
        printf("Podaj wspolrzedna x gornego prawego wierzcholka prostokata \n");
        wprowadz_dane(XPG);
        printf("Podaj wspolrzedna y gornego prawego wierzcholka prostokata \n");
        wprowadz_dane(YPG);
        printf("Podaj poziom podzialu \n");
        wprowadz_dane(POD);
        if (warunek_1(&XLD, &XPG, &YLD, &YPG, &POD)) {// walidacja ok. - liczymy <-------------------funckaj z adresami
            // normalizacja

            struct kwadrat **K = (kwadrat **) (malloc(
                    pow(2, POD) * sizeof(struct kwadrat *))); // deklaracja miejsca dla wierszy
            if (K == NULL) {
                printf("Nie przydzielono pamięci");
                return 2;
            }
            for (int i = 0; i < pow(2, POD); i++) { // deklaracja pamieci dla pozycji w wierszu
                K[i] = (kwadrat *) malloc(pow(2, POD) * sizeof(struct kwadrat));
            }


            X = XLD;
            Y = YLD;
            XLD = fminf(XLD, XPG);
            YLD = fminf(YLD, YPG);
            XPG = fmaxf(X, XPG);
            YPG = fmaxf(Y, YPG);
            // liczymy boki najmniejszych prostokatow
            DX = (XPG - XLD) / (pow(2, POD));
            DY = (YPG - YLD) / (pow(2, POD));
            //  ustawienie lewego dolnego wierzcholka prostokata bazowego
            X = XLD;
            Y = YLD;
            // wyznaczanie wierzcholkow prostokatow wynikajacych z podzialu
            for (int i = 0; i < pow(2, POD); i++) {
                for (int j = 0; j < pow(2, POD); j++) {
                    K[i][j].iX = i+1;
                    K[i][j].iY = j+1;
                    K[i][j].XLD = X;
                    K[i][j].YLD = Y;
                    K[i][j].XPG = X + DX;
                    K[i][j].YPG = Y + DY;
                    X = X + DX;
                }
                X = XLD;
                Y = Y + DY;
            }

            wyswietlanie(K, POD);

            free(K); // zwalnianie pamieci

            printf("Ponowna kalkulacja? TAK - wcisnij 0; NIE - wcisnij inny klawisz \n");
            scanf("%d", &next_calc);
        }
    }while(next_calc!='0');

    system("PAUSE");
    return 0;
}