Gros probleme labyrinthe , boucle infini

voila mon code source pour g=E9n=E9rer all=E9atoirement un labyrinthe :

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void initialisation (int,int);
void liberer2d(int***,int);
void propager4(int ,int ,int,int,int ,int**);
void propager(int ,int ,int,int,int,int**);
int **allouer2d(int ,int);
void afficher(int,int, int**);
void Pcc(int,int,int,int,int,int**);
void compte_casezero(int, int , int ,int**);

int main (void){
srand(time(NULL));
initialisation(7,8);
return 0;
}

void initialisation (int n, int m){
int k,i,j,nbcaseAzero,x,y,d,maxl,maxh,stockvaleur;
int **laby;
maxl=3D2*n+1;
maxh=3D2*m+1;
laby=3Dallouer2d(maxl,maxh);
nbcaseAzero=3Dn*m;
k=3D0;
for (i=3D0;i<maxl;i++){
for (j=3D0;j<maxh; j++){
if ((i%2!=3D0) && j%2!=3D0){
laby[i][j]=3Dk++;
}
else laby[i][j]=3D-1;
}
}
afficher (maxh , maxl, laby);
while (nbcaseAzero>0){
x=3D(rand()%(maxl-2)) + 1;
y=3D(rand() %(maxh-2)) + 1;
while ((x&1)=3D=3D(y&1)){
x=3D(rand()%(maxl-2)) + 1;
y=3D(rand() %(maxh-2)) + 1;
}
if (x&1){
d=3Dlaby[x][y-1]-laby[x][y+1];
if (d>0) {
laby[x][y]=3Dlaby[x][y+1];
stockvaleur=3Dlaby[x][y+1];
propager4(x,(y-1),laby[x][y+1], stockvaleur,nbcaseAzero,laby);
compte_casezero(nbcaseAzero,maxh,maxl,laby);
}
else if (d<0){
laby[x][y]=3Dlaby[x][y-1];
stockvaleur=3Dlaby[x][y-1];
propager4(x,(y+1),laby[x][y-1], stockvaleur,nbcaseAzero,laby);
compte_casezero(nbcaseAzero,maxh,maxl,laby);
afficher (maxh , maxl, laby);
}
}
else if (y&1){
d=3Dlaby[x-1][y]-laby[x+1][x];
if (d>0) {
laby[x][y]=3Dlaby[x+1][y];
stockvaleur=3Dlaby[x+1][y];
propager4((x-1),y,laby[x+1][y], stockvaleur,nbcaseAzero,laby);
compte_casezero(nbcaseAzero,maxh,maxl,laby);
}
else if (d<0){
laby[x][y]=3Dlaby[x-1][y];
stockvaleur=3Dlaby[x-1][y];
propager4((x+1),y,laby[x-1][y], stockvaleur,nbcaseAzero,laby);
compte_casezero(nbcaseAzero,maxh,maxl,laby);
}
}
}
afficher (maxh , maxl, laby);
}

int **allouer2d(int l,int h){
int i, **t;
t=3Dmalloc(h*sizeof*t);
assert(t);
for (i=3D0;i<h;i++){
t[i]=3Dmalloc (l*sizeof*t[i]);
assert (t[i]);
}
return t;
}


void liberer2d(int*** q,int h){
int i;
for (i=3D0;i<h;i++)
free(*q);
*q=3DNULL;
}
void propager(int x,int y,int nouvelvaleur,int ancienvaleur,int nb,int
**matrice) {
if (nb=3D=3D0) exit(0);
if(matrice[x][y]!=3Dancienvaleur) return;
matrice[x][y]=3Dnouvelvaleur;
}

void propager4(int x,int y,int nouvelvaleur,int ancienvaleur, int
nb ,int **matrice){
propager((x+1),y,nouvelvaleur,ancienvaleur,nb,matrice);
propager((x-1),y,nouvelvaleur,ancienvaleur,nb,matrice);
propager(x,(y+1),nouvelvaleur,ancienvaleur,nb,matrice);
propager(x,(y-1),nouvelvaleur,ancienvaleur,nb,matrice);
}

/*fonction propagerfait ms gro pb*/
/*fonction calcule chemin*/
/*fonction affiche chemin*/
/*fonction copie labyrinthe*/


void afficher(int l, int h,int **pointeur){
int i,j;
for (i=3D0; i<h;i++){
for (j=3D0; j<l; j++){
printf ("%3d",pointeur[i][j]);
}
printf("\n");
}
printf("\n");
}

void Pcc(int x1,int y1,int x2,int y2,int v,int **L){
v=3Dv+1;
L[x1][y1]=3Dv;
if(x1=3D=3Dx2&&y1=3D=3Dy2) return;
if (v < L[x1+1][y1] || L[x1+1][y1] =3D=3D 0)
Pcc(x1, y1+1, x2, y2, v,L);
if (v < L[x1-1][y1] || L[x1-1][y1] =3D=3D 0)
Pcc(x1, y1-1, x2, y2, v,L);
if (v < L[x1][y1+1] || L[x1][y1+1] =3D=3D 0)
Pcc(x1+1, y1, x2, y2, v,L);
if (v < L[x1][y1-1] || L[x1][y1-1] =3D=3D 0)
Pcc(x1-1, y1, x2, y2, v,L);
}

void compte_casezero(int m, int l, int h,int **matrice){
int i,j;
for (i=3D0;i<h;i++)
for (j=3D0; j<l; j++)
if (matrice[i][j]=3D=3D0 && (i&1) && (j&1))
m--;
printf("%d\n",m);

}


voila , il se trouve que je ne sais vraiment pas pourquoi ma fonction
est infini, je pense que c'est a cause du return dans ma fonction
propager , mais je n'en sui pas sur, je suis blocker =E0 cette fonction
depuis 3 jour.
Svp aidez moi , j'utilise cette algo pour g=E9n=E9rer mon labyrinthe.

http://209.85.135.104/search?q=3Dcache:KqVCk5OegmQJ:www.ai.univ-paris8.fr/~=
amsi/SD0607S1/supports/cours07.pdf+Le+plus+court+chemin+dans+un+labyrinthe&=
hl=3Dfr&ct=3Dclnk&cd=3D9&gl=3Dfr