Correct Matrix not printing in Visual Studio

[iosiflazaridis]

I have made a Matrix Struct in Visual Studio to use with a linear algebra operations library I am also making but when I am trying to print a test Matrix in main (I have already allocated), I get a different one.
PLEASE help. I have being trying for days to solve this problem but I can't.
I will include all the functions I am using at the moment. Forgive me for posting such a long code, but I think it is easy to be read by anyone.

/*main*/
void main(void)
{
	Matrix B,s,x;
	int i=2,j=3;
	/*Matrix Dimensions*/
	int m=4,l=1;
	double val=1.0,d=2.0;
	InitMatrix(&s,&m,&l);
	InitMatrix(&B,&m,&m);

	/*B Matrix*/
	B.val[0]=3;
	B.val[1]=2;
	B.val[2]=-1;
	B.val[3]=2;
	B.val[4]=1;
	B.val[5]=4;
	B.val[6]=0;
	B.val[7]=2;
	B.val[8]=2;
	B.val[9]=1;
	B.val[10]=2;
	B.val[11]=-1;
	B.val[12]=1;
	B.val[13]=1;
	B.val[14]=-1;
	B.val[15]=3;
	/**********/


	/*s Matrix*/
	s.val[0]=-2;
	s.val[1]=1;
	s.val[2]=3;
	s.val[3]=4;
	/**********/
	
	PrintMatrix(B);
	printf("\n");
	PrintMatrix(s);
	printf("\n");
	d=GetElement(B,m,m);
	printf("%f",d);
	printf("\n");
	printf("\n");
	x=LUsolver(&B,&s);
	PrintMatrix(x);
}

/*Matrix struct*/
#include "Matrix.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


//Allocation of a Matrix and set to 0
//	Input:  M - Pointer to Matrix
//			m - Number of rows
//			n - Number of columns
//	Output: M - Allocated Matrix
void InitMatrix(Matrix *M,const int *m,const int *n)
{
	M->alloc=1;
	M->rows=*m;
	M->cols=*n;
	M->val=(double *)malloc((*m)*(*n)*sizeof(double));
}


//Deallocation of a Matrix if allocated
//	Input:  M - Pointer to Matrix
//	Output: M - Deallocated Matrix
void DelMatrix(Matrix *M)
{
	if (M->alloc==1)
	{
		M->alloc=0;
		M->rows=0;
		M->cols=0;
		free(M->val);
		M->val=NULL;
	}
}

//Fills in an allocated Matrix with a double val
//	Input:  M - Matrix to be filled in
//			val - the number to fill in the Matrix
//	Output: M - Filled Matrix
void Number(const Matrix *M,const double *val)
{
	int i;
	if (M->alloc==1)
	{
		for(i=0;i<M->cols*M->rows;i++)
			M->val[i]=*val;
	}
}

//Returns the element (i,j) of Matrix M
//	Input:  M - Matrix
//			k - row i
//			l - column j
//	Output: element (i,j)
double GetElement(const Matrix M,const int k,const int l)
{
	int p,m;
	m=M.rows;
	p=(k-1)*m+(l-1);
	return(M.val[p]);
}

//Changes the value of element (i,j) of Matrix M with a double
//	Input:  M - Matrix
//			k - row i
//			l - column j
//			y - double to change element (i,j)
//	Output: Matrix M with element (i,j) changed to double y
void PutElement(const Matrix *M,const int *k,const int *l,const double y)
{
	int p,m,i,j;
	m=M->rows;
	i=*k,j=*l;
	p=(i-1)*m+(j-1);
	M->val[p]=y;
}

//Prints the Matrix M
//	Input:  M - Matrix
//	Output: Printed Matrix
void PrintMatrix(const Matrix M)
{
	int m=0,n=0,i=0,j=0,k,l;
	double d;
	m=M.rows;
	n=M.cols;
	
	for(i;i<m;i++)
	{
		k=i+1;
		j=0;
		for(j;j<n;j++)
		{
			l=j+1;
			d=GetElement(M,k,l);
			if(d>=0)
				printf(" ");
			printf("%f",d);
			printf("   ");
		}
		printf("\n");
	}
}

/*LUsolver*/
Matrix LUsolver(const Matrix *A,const Matrix *s)
{
	Matrix L,U,y,x;
	int i=1,j,k,m;
	//assist variables d,w,c,z
	double d,w,c,z=0,sum1,sum2,sum3,sum4;
	m=A->rows;
	InitMatrix(&L,&m,&m);
	InitMatrix(&U,&m,&m);
	InitMatrix(&y,&m,&i);
	InitMatrix(&x,&m,&i);
	Number(&L,&z);
	Number(&U,&z);

/******************************************/
/*************LU FACTORIZATION*************/
/******************************************/

	//l(1,1)
	i=1;
	d=GetElement(*A,i,i);
	PutElement(&L,&i,&i,d);

	//diag. of U
	for(i=1;i<=m;i++)
	{
		PutElement(&U,&i,&i,1.0);
	}

	//first row of U
	i=1;
	d=GetElement(L,i,i);
	for(j=2;j<=m;j++)
	{
		w=GetElement(*A,i,j);
		z=w/d;
		PutElement(&U,&i,&j,z);
	}

	//first col. of L
	for(j=2;j<=m;j++)
	{
		w=GetElement(*A,j,i);
		PutElement(&L,&j,&i,w);
	}

	//rest of the matrices L,U except l(n,n)
	for(i=2;i<=m-1;i++)
	{
		sum1=0;
		for(k=1;k<=i-1;k++)
			sum1+=GetElement(L,i,k)*GetElement(U,k,i);
	d=GetElement(*A,i,i)-sum1;
	PutElement(&L,&i,&i,d);

	for(j=i+1;j<=m;j++)
	{
		sum2=0;
		for(k=1;k<=i-1;k++)
			sum2+=GetElement(L,i,k)*GetElement(U,k,j);
		w=(GetElement(*A,i,j)-sum2)/GetElement(L,i,i);
		PutElement(&U,&i,&j,w);
		
		sum3=0;
		for(k=1;k<=i-1;k++)
			sum3+=GetElement(L,j,k)*GetElement(U,k,i);
		c=GetElement(*A,j,i)-sum3;
		PutElement(&L,&j,&i,c);
	}
	}

	//l(n,n)
	sum4=0;
	for(k=1;k<=m-1;k++)
		sum4+=GetElement(L,m,k)*GetElement(U,k,m);
	d=GetElement(*A,m,m)-sum4;
	PutElement(&L,&m,&m,d);

/******************************************/


/******************************************/
/*******SOLUTION TO THE SYSTEM LUx=s*******/
/******************************************/
	//assist variables d,w,c set to zero and k refers to the single column of a vector-matrix
	d=0;w=0;c=0;z=0;  /**/k=1;/**/
	i=1;j=0;

	//Forward Substitution, system Ly=s
	d=GetElement(*s,i,i);
	w=GetElement(L,i,i);
	c=d/w;
	PutElement(&y,&i,&i,c);
	for(i=2;i<=m;i++)
	{
		sum1=0;
		for(j=1;j<=i-1;j++)
		{
			d=GetElement(L,i,j);
			w=GetElement(y,j,k);
			sum1+=d*w;
		}
		d=GetElement(*s,i,k);
		w=GetElement(L,i,i);
		c=1/w;
		z=c*(d-sum1);
		PutElement(&y,&i,&k,z);
	}

	//Backward Substitution, system Ux=y
	d=GetElement(y,m,k);
	PutElement(&x,&m,&k,d);

	for(i=m-1;i>=1;i--)
	{
		sum1=0;
		for(j=i+1;j<=m;j++)
		{
			d=GetElement(U,i,j);
			w=GetElement(x,j,k);
			sum1+=d*w;
		}
		d=GetElement(y,i,k);
		c=d-sum1;
		PutElement(&x,&i,&k,c);
	}
	return (x);
}

And the results from main are {I press Start Without Debugging}:

-B Matrix-
3.000000 2.000000 -1.000000 2.000000
1.000000 4.000000 0.000000 2.000000
2.000000 1.000000 2.000000 -1.000000
1.000000 1.000000 -1.000000 3.000000

-s matrix-
-2.000000
0.000000
2.000000
2.000000

-GetElement result-
3.000000

-LUsolver result-
-0.454545
-0.954545
3.000000
2.136364
Press any key to continue . . .