char** createLab(int n,int clients)
{
    struct room
    {
        bool left_wall;
        bool top_wall;
        bool visited;
    };
    int size_lab=n;
    bool rand_start=0;


    room labyrinth[size_lab][size_lab];

    int i,j;

    for(i=0;i<size_lab;i++)
    {
        for(j=0;j<size_lab;j++)
        {
            labyrinth[i][j].left_wall=1;
            labyrinth[i][j].top_wall=1;
            labyrinth[i][j].visited=0;
        }
    }

    int x_hall,y_hall,hall_size,max_hall_size;

    int x_start=0;
    int y_start=0;
    if (!rand_start)
    {
        x_start=(rand() % size_lab)+0;
        y_start=(rand() % size_lab)+0;
        rand_start=1;
    }
    int direction=0;
    bool koniec=1;
    while(koniec==1)
    {
        if(labyrinth[x_start][y_start].visited==0)
            labyrinth[x_start][y_start].visited=1;

        direction=(rand()%4)+0;
        if (direction==0)
        {
            if (y_start<size_lab-1){
                if (labyrinth[x_start][y_start+1].visited==0)
                    labyrinth[x_start][y_start+1].top_wall=0;
                y_start++;
            }
        }
        else if (direction==1)
        {
            if (y_start>0)
            {
                if (labyrinth[x_start][y_start-1].visited==0)
                    labyrinth[x_start][y_start].top_wall=0;
                y_start--;
            }
        }
        else if (direction==2)
        {
            if (x_start>0)
            {
                if (labyrinth[x_start-1][y_start].visited==0)
                    labyrinth[x_start][y_start].left_wall=0;
                x_start--;
            }
        }
        else if(direction==3)
        {
            if (x_start<size_lab-1)
            {
                if (labyrinth[x_start+1][y_start].visited==0)
                    labyrinth[x_start+1][y_start].left_wall=0;
                x_start++;
            }
        }

        for(int i=0;i<size_lab;i++)
        {
            for(int j=0;j<size_lab;j++)
            {
                if (labyrinth[i][j].visited==0)
                {
                    koniec=1;
                    break;
                }
                else
                    koniec=0;
            }
            if(koniec==1)
                break;
        }
    }

    char perfect [2*size_lab+1][2*size_lab+1];

    for(int i=0;i<2*size_lab+1;i++)
    {
        for(int j=0;j<2*size_lab+1;j++)
        {
            if ((i==2*size_lab))
                perfect[j][i]='1';
            else if ((j==2*size_lab))
                perfect[j][i]='1';
            else if ((i%2==1)&&(j%2==1))
                perfect[j][i]='0';
            else if ((i%2==0)&&(j%2==1))
            {
                if (labyrinth[j/2][i/2].top_wall==0)
                    perfect[j][i]='0';
                else
                    perfect[j][i]='1';
            }
            else if ((i%2==1)&&(j%2==0))
            {
                if (labyrinth[j/2][i/2].left_wall==0)
                    perfect[j][i]='0';
                else
                    perfect[j][i]='1';
            }
            else if ((i%2==0)&&(j%2==0))
                perfect[j][i]='1';
        }
    }

    max_hall_size=size_lab/3;
    int copies_count=size_lab/3;
    for (int k=0;k<copies_count;k++)
    {
        x_hall=(rand() % (2*size_lab-max_hall_size)) + (max_hall_size/2+1);
        y_hall=(rand() % (2*size_lab-max_hall_size)) + (max_hall_size/2+1);
        hall_size=(rand() % (max_hall_size-1)) + 2;

        for( i=(x_hall-(hall_size/2));i<(x_hall+hall_size/2+1);i++)
        {
            for(j=(y_hall-(hall_size/2));j<(y_hall+hall_size/2+1);j++)
                perfect[i][j]='0';
        }
    }

    int row[copies_count];
    int column[copies_count];
    for(int k=0;k<copies_count;k++)
    {
        row[k]=(rand() % (2*size_lab-1)) + 1;
        column[k]=(rand() % (2*size_lab-1)) + 1;
    }
    char perfect_with_halls [2*size_lab+1][2*size_lab+1+copies_count];
    int displacement=0;
    int copies;
    for(int j=0;j<2*size_lab+1;j++)
    {
        copies=1;
        for(int k=0;k<copies_count;k++)
            if (column[k]==j)
                copies++;

        for(int l=0;l<copies;l++)
        {
            if (l>0)
                displacement++;
            for(int i=0;i<2*size_lab+1;i++)
                perfect_with_halls[i][j+displacement]=perfect[i][j];
        }
    }

    displacement=0;
    copies=1;
    char ** true_labyrinth = NULL;

    true_labyrinth=(char**)calloc(2*size_lab+2, sizeof(char*));

    for(int i=0;i<2*size_lab+2;i++)
    {
        true_labyrinth[i]=(char*)calloc(2*size_lab+2,sizeof(char));
    }


    for(int i=0;i<2*size_lab+1+copies_count;i++)
    {
        copies=1;
            for(int k=0;k<copies_count;k++)
            {
                if (row[k]==i)
                    copies++;
            }
            for(int l=0;l<copies;l++)
            {
                if (l>0)
                    displacement++;

                for(int j=0;j<2*size_lab+1+copies_count;j++)
                    true_labyrinth[i+displacement][j]=perfect_with_halls[i][j];

            }
    }

    for(int i=0;i<2*size_lab+1+copies_count;i++)
    {
        for(int j=0;j<2*size_lab+1+copies_count;j++)
        {
            if (true_labyrinth[j][i]=='0')
                printf(" ");
            if (true_labyrinth[j][i]=='1')
                printf("X");
        }
        printf("\n");
    }
    printf("\n");

    return true_labyrinth;
}