C Program crashes after compiling without error

Hello there.

I'm heaving trouble with a C Program that I'm writing to simulate a Multi-Layer Neural Network. It compiles without any issues, but when I run it, it crashes instantanously. I would be very thankful if anyone could give me a hint. The code is below:

/* Multi layer network to classification of data */

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

#define MAX_SIZE 1000
#define LRATE 1e-5
#define ERR_LIMIT 1e-3
#define MAX_TIME 55

#define INPUTS 2
#define NEURONSLAYER1 4
#define NEURONSLAYER2 3
#define NEURONSLAYER3 1

#define sqr(x) ((x) * (x))

float max1,max2;

void mapping1(float in[][INPUTS+1], int n) {

int i, j;

if(in[0][1]<0) max1 = (in[0][1])*(-1.0);
else max1=in[0][1];

printf("%f\n", max1);

for(i=1;i<n-1;i++)
{
if(in[i][1]>max1 && in[i][1] < 0)max1 = in[i][1]*(-1.0);
if(in[i][1]>max1 && in[i][1] >= 0)max1 = in[i][1];
}

printf("%f\n", max1);

for(j=0;j<n-1;j++)
{
in[j][1] = in[j][1]/max1;
}

return;
}

void mapping2(float in[][INPUTS+1], int n) {

int i, j;

if(in[0][2]<0) max2 = in[0][2]*(-1.0);
else max2=in[0][2];

printf("%f\n", max2);

for(i=1;i<n-1;i++)
{
if(in[i][2]>max2 && in[i][2] < 0)max2 = in[i][2]*(-1.0);
if(in[i][2]>max2 && in[i][2] >= 0)max2 = in[i][2];
}

printf("%f\n", max2);

for(j=0;j<n-1;j++)
{
in[j][2] = in[j][2]/max2;
}

return;
}

int main (){

//Network parameters
float Input[MAX_SIZE][INPUTS +1];
float HLayer1In[NEURONSLAYER1 +1];
float HLayer1Out[NEURONSLAYER1 +1];
float HLayer2In[NEURONSLAYER2 +1];
float HLayer2Out[NEURONSLAYER2 +1];
float OLayerIn[NEURONSLAYER3 +1];
float OLayerOut[NEURONSLAYER3 +1];
float WeightsH1In[NEURONSLAYER1 +1][INPUTS +1];
float WeightsH2H1[NEURONSLAYER2 +1][NEURONSLAYER1 +1];
float WeightsOH2[NEURONSLAYER3 +1][NEURONSLAYER2 +1];
float BiasO;


//Training Parameters
float lin_error = 0, error_sum = 0, avg_error = 0;
float DevOutH1[NEURONSLAYER1 +1];
float DevOutH2[NEURONSLAYER2 +1];
float DevOutO[NEURONSLAYER3 +1];
int ExpectedOut[MAX_SIZE];
float deltaOut = 0;
float deltaLayer2[NEURONSLAYER2 +1];
float deltaLayer1[NEURONSLAYER1 +1];
float sumLayer1[NEURONSLAYER1 +1];

int i; // Index for Inputs
int j; // Index for Hidden 1
int k; // Index for Hidden 2
int m; // Index for Output
int n,l; // Index for test values

int flag = 0; // Indicates when the training is over
int read; // Loop variable

float c, d; //Store the maximum values for normalization

time_t start = time(NULL); // Timer variable


srand((unsigned)time(NULL));

// Initialize weights

for(i=1;i<INPUTS+1;i++)
{
for(j=0;j<NEURONSLAYER1+1;j++)
{
WeightsH1In[j][i] = (rand()%10)*pow(10,-(rand()%5));
}
}

for(j=1;j<NEURONSLAYER1+1;j++)
{
for(k=0;k<NEURONSLAYER2+1;k++)
{
WeightsH2H1[k][j] = (rand()%10)*pow(10,-(rand()%5));
}
}

for(k=1;k<NEURONSLAYER2+1;k++)
{
for(m=0;k<NEURONSLAYER3+1;m++)
{
WeightsOH2[m][k] = (rand()%10)*pow(10,-(rand()%5));
}
}

BiasO = (rand()%10)*pow(10,-(rand()%5));

n = 0;
l = 0;
j = 0;
k = 0;
m = 0;
i = 0;


do{

if(flag == 1)
{

read = scanf("%f, %f", &Input[n][1], &Input[n][2]);
if(read == EOF) return 0;
//Calculate the Outputs of Neurons in the first Layer and also their derivatives

Input[n][1] = Input[n][1]/c;
Input[n][2] = Input[n][2]/d;

for(j=1;j<NEURONSLAYER1+1;j++)
{
HLayer1In[j] = WeightsH1In[0][j];
for(i=1;i<INPUTS+1;i++)
{
HLayer1In[j] += Input[l][i]*WeightsH1In[j][i];
}
HLayer1Out[j] = tanh(HLayer1In[j]);
}
//Calculate the Outputs of Neurons in the second Layer and also their derivatives
for(k=1;k<NEURONSLAYER2+k;j++)
{
HLayer2In[k] = WeightsH2H1[0][k];
for(j=1;j<NEURONSLAYER1+1;j++)
{
HLayer2In[k] += HLayer1Out[j]*WeightsH2H1[k][j];
}
HLayer2Out[k] = tanh(HLayer2In[k]);
}
//Calculate the Outputs of Neurons in the output Layer and also their derivatives
for(m=1;m<NEURONSLAYER3+1;m++)
{
OLayerIn[m] = BiasO;
for(k=1;k<NEURONSLAYER2+1;k++)
{
OLayerIn[m] += HLayer2Out[k]*WeightsOH2[m][k];
}
OLayerOut[m] = tanh(OLayerIn[m]);
}
n++;
if(OLayerOut[m-1] > 0) printf("+1\n");
if(OLayerOut[m-1] <= 0) printf("-1\n");
}

//Training Routine
else
{
//Read Training
read = scanf("%f,%f,%d", &Input[n][1], &Input[n][2], &ExpectedOut[n]);
n++;
//Check condition for initialization of training
if(Input[n-1][1] == 0 && Input[n-1][2] == 0 && ExpectedOut[n-1] == 0)
{

mapping1(Input,n);
c = max1;
mapping2(Input,n);
d = max2;

//Begin Training
do{
//If the program takes too long, break
if((time(NULL) - start) > MAX_TIME)
{
flag = 1;
break;
}

//If the set is over but the training isn't, restart
if(l == (n-1))
{
l=0;
error_sum = 0;
}

//Initiates over the training set
for(l=0;l<n-1;l++)
{
for(j=1;j<NEURONSLAYER1+1;j++)
{
sumLayer1[j] = 0;
}
//Calculate the Outputs of Neurons in the first Layer and also their derivatives
for(j=1;j<NEURONSLAYER1+1;j++)
{
HLayer1In[j] = WeightsH1In[0][j];
for(i=1;i<INPUTS+1;i++)
{
HLayer1In[j] += Input[l][i]*WeightsH1In[j][i];
}
HLayer1Out[j] = tanh(HLayer1In[j]);
DevOutH1[j] = 1.0/(sqr(cosh(HLayer1In[j])));
}
//Calculate the Outputs of Neurons in the second Layer and also their derivatives
for(k=1;k<NEURONSLAYER2+k;j++)
{
HLayer2In[k] = WeightsH2H1[0][k];
for(j=1;j<NEURONSLAYER1+1;j++)
{
HLayer2In[k] += HLayer1Out[j]*WeightsH2H1[k][j];
}
HLayer2Out[k] = tanh(HLayer2In[k]);
DevOutH2[k] = 1.0/(sqr(cosh(HLayer2In[k])));
}
//Calculate the Outputs of Neurons in the output Layer and also their derivatives
for(m=1;m<NEURONSLAYER3+1;m++)
{
OLayerIn[m] = BiasO;
for(k=1;k<NEURONSLAYER2+1;k++)
{
OLayerIn[m] += HLayer2Out[k]*WeightsOH2[m][k];
}
OLayerOut[m] = tanh(OLayerIn[m]);
DevOutO[m] = 1.0/(sqr(cosh(OLayerIn[m])));
}
//Calculate error
lin_error = ExpectedOut[n] - OLayerOut[m];
error_sum += sqr(lin_error);
deltaOut = lin_error*DevOutO[m];
//Propagate error
for(m=1;m<NEURONSLAYER3 +1;m++)
{
for(k=1;k<NEURONSLAYER2 +1;k++)
{
deltaLayer2[k] = WeightsOH2[m][k]*deltaOut*DevOutH2[k];
}
}
//-----------------------------------------------------------
for(j=1;j<NEURONSLAYER1 +1;j++)
{
for(k=1;k<NEURONSLAYER2 +1;k++)
{
sumLayer1[j]+=WeightsH2H1[k][j]*deltaLayer2[k];
}
}
for(j=1;j<NEURONSLAYER1 +j;k++)
{
deltaLayer1[j]=sumLayer1[j]*DevOutH1[j];
}
//Update weights
//---Output Layer
BiasO += 2.0*LRATE*deltaOut;
for(m=1;m<NEURONSLAYER3 +1;m++)
{
for(k=1;k<NEURONSLAYER2 +1;k++)
{
WeightsOH2[m][k] += LRATE*deltaOut*HLayer2Out[k];
}
}
//---Hidden Layer 2
for(k=1;k<NEURONSLAYER2 +1;k++)
{
WeightsH2H1[0][k] += LRATE*deltaLayer2[k];
for(j=1;j<NEURONSLAYER1 +1;j++)
{
WeightsH2H1[k][j] += LRATE*deltaLayer2[k]*HLayer1Out[j];
}
}
//---Hidden Layer 1
for(j=1;j<NEURONSLAYER1 +1;j++)
{
WeightsH1In[0][j] += LRATE*deltaLayer1[j];
for(i=1;i<INPUTS +1;i++)
{
WeightsH1In[j][i] += LRATE*deltaLayer1[j]*HLayer1Out[i];
}
}
}
avg_error = error_sum/l;
}while(avg_error > ERR_LIMIT );
flag = 1;
}
}
}while(read != EOF);

return 0;
}