diff --git a/src/image.c b/src/image.c
index 6a167452..b063a680 100644
--- a/src/image.c
+++ b/src/image.c
@@ -543,7 +543,7 @@ void show_image_cv_ipl(IplImage *disp, const char *name)
 			//printf("\n cvCreateVideoWriter, DST output_video = %p  \n", output_video);
 		}
 
-		cvWriteFrame(output_video, disp);	// comment this line to improve FPS !!!
+		//cvWriteFrame(output_video, disp);	// comment this line to improve FPS !!!
 		printf("\n cvWriteFrame \n");
 	}
 
@@ -626,8 +626,8 @@ image get_image_from_stream_resize(CvCapture *cap, int w, int h, IplImage** in_i
 	*in_img = cvCreateImage(cvSize(src->width, src->height), IPL_DEPTH_8U, 3);
 	cvResize(src, *in_img, CV_INTER_LINEAR);
 	cvResize(src, new_img, CV_INTER_LINEAR);
-	src = new_img;
-	image im = ipl_to_image(src);
+	image im = ipl_to_image(new_img);
+	cvReleaseImage(&new_img);
 	rgbgr_image(im);
 	return im;
 }
diff --git a/src/layer.c b/src/layer.c
index 5fb5d240..b88c9412 100644
--- a/src/layer.c
+++ b/src/layer.c
@@ -4,41 +4,93 @@
 
 void free_layer(layer l)
 {
-    if(l.type == DROPOUT){
-        if(l.rand)           free(l.rand);
+	if (l.type == DROPOUT) {
+		if (l.rand)           free(l.rand);
 #ifdef GPU
-        if(l.rand_gpu)             cuda_free(l.rand_gpu);
+		if (l.rand_gpu)             cuda_free(l.rand_gpu);
 #endif
-        return;
-    }
-    if(l.indexes)        free(l.indexes);
-    if(l.rand)           free(l.rand);
-    if(l.cost)           free(l.cost);
-    if(l.biases)         free(l.biases);
-    if(l.bias_updates)   free(l.bias_updates);
-    if(l.weights)        free(l.weights);
-    if(l.weight_updates) free(l.weight_updates);
-    if(l.col_image)      free(l.col_image);
-    if(l.input_layers)   free(l.input_layers);
-    if(l.input_sizes)    free(l.input_sizes);
-    if(l.delta)          free(l.delta);
-    if(l.output)         free(l.output);
-    if(l.squared)        free(l.squared);
-    if(l.norms)          free(l.norms);
+		return;
+	}
+	if (l.cweights)           free(l.cweights);
+	if (l.indexes)            free(l.indexes);
+	if (l.input_layers)       free(l.input_layers);
+	if (l.input_sizes)        free(l.input_sizes);
+	if (l.map)                free(l.map);
+	if (l.rand)               free(l.rand);
+	if (l.cost)               free(l.cost);
+	if (l.state)              free(l.state);
+	if (l.prev_state)         free(l.prev_state);
+	if (l.forgot_state)       free(l.forgot_state);
+	if (l.forgot_delta)       free(l.forgot_delta);
+	if (l.state_delta)        free(l.state_delta);
+	if (l.concat)             free(l.concat);
+	if (l.concat_delta)       free(l.concat_delta);
+	if (l.binary_weights)     free(l.binary_weights);
+	if (l.biases)             free(l.biases);
+	if (l.bias_updates)       free(l.bias_updates);
+	if (l.scales)             free(l.scales);
+	if (l.scale_updates)      free(l.scale_updates);
+	if (l.weights)            free(l.weights);
+	if (l.weight_updates)     free(l.weight_updates);
+	if (l.delta)              free(l.delta);
+	if (l.output)             free(l.output);
+	if (l.squared)            free(l.squared);
+	if (l.norms)              free(l.norms);
+	if (l.spatial_mean)       free(l.spatial_mean);
+	if (l.mean)               free(l.mean);
+	if (l.variance)           free(l.variance);
+	if (l.mean_delta)         free(l.mean_delta);
+	if (l.variance_delta)     free(l.variance_delta);
+	if (l.rolling_mean)       free(l.rolling_mean);
+	if (l.rolling_variance)   free(l.rolling_variance);
+	if (l.x)                  free(l.x);
+	if (l.x_norm)             free(l.x_norm);
+	if (l.m)                  free(l.m);
+	if (l.v)                  free(l.v);
+	if (l.z_cpu)              free(l.z_cpu);
+	if (l.r_cpu)              free(l.r_cpu);
+	if (l.h_cpu)              free(l.h_cpu);
+	if (l.binary_input)       free(l.binary_input);
 
 #ifdef GPU
-    if(l.indexes_gpu)          cuda_free((float *)l.indexes_gpu);
-    //if(l.weights_gpu)          cuda_free(l.weights_gpu);			// duplicated
-    //if(l.weight_updates_gpu)   cuda_free(l.weight_updates_gpu);	// duplicated
-    if(l.col_image_gpu)        cuda_free(l.col_image_gpu);
-    if(l.weights_gpu)          cuda_free(l.weights_gpu);
-    if(l.biases_gpu)           cuda_free(l.biases_gpu);
-    if(l.weight_updates_gpu)   cuda_free(l.weight_updates_gpu);
-    if(l.bias_updates_gpu)     cuda_free(l.bias_updates_gpu);
-    if(l.output_gpu)           cuda_free(l.output_gpu);
-    if(l.delta_gpu)            cuda_free(l.delta_gpu);
-    if(l.rand_gpu)             cuda_free(l.rand_gpu);
-    if(l.squared_gpu)          cuda_free(l.squared_gpu);
-    if(l.norms_gpu)            cuda_free(l.norms_gpu);
+	if (l.indexes_gpu)           cuda_free((float *)l.indexes_gpu);
+
+	if (l.z_gpu)                   cuda_free(l.z_gpu);
+	if (l.r_gpu)                   cuda_free(l.r_gpu);
+	if (l.h_gpu)                   cuda_free(l.h_gpu);
+	if (l.m_gpu)                   cuda_free(l.m_gpu);
+	if (l.v_gpu)                   cuda_free(l.v_gpu);
+	if (l.prev_state_gpu)          cuda_free(l.prev_state_gpu);
+	if (l.forgot_state_gpu)        cuda_free(l.forgot_state_gpu);
+	if (l.forgot_delta_gpu)        cuda_free(l.forgot_delta_gpu);
+	if (l.state_gpu)               cuda_free(l.state_gpu);
+	if (l.state_delta_gpu)         cuda_free(l.state_delta_gpu);
+	if (l.gate_gpu)                cuda_free(l.gate_gpu);
+	if (l.gate_delta_gpu)          cuda_free(l.gate_delta_gpu);
+	if (l.save_gpu)                cuda_free(l.save_gpu);
+	if (l.save_delta_gpu)          cuda_free(l.save_delta_gpu);
+	if (l.concat_gpu)              cuda_free(l.concat_gpu);
+	if (l.concat_delta_gpu)        cuda_free(l.concat_delta_gpu);
+	if (l.binary_input_gpu)        cuda_free(l.binary_input_gpu);
+	if (l.binary_weights_gpu)      cuda_free(l.binary_weights_gpu);
+	if (l.mean_gpu)                cuda_free(l.mean_gpu);
+	if (l.variance_gpu)            cuda_free(l.variance_gpu);
+	if (l.rolling_mean_gpu)        cuda_free(l.rolling_mean_gpu);
+	if (l.rolling_variance_gpu)    cuda_free(l.rolling_variance_gpu);
+	if (l.variance_delta_gpu)      cuda_free(l.variance_delta_gpu);
+	if (l.mean_delta_gpu)          cuda_free(l.mean_delta_gpu);
+	if (l.x_gpu)                   cuda_free(l.x_gpu);
+	if (l.x_norm_gpu)              cuda_free(l.x_norm_gpu);
+	if (l.weights_gpu)             cuda_free(l.weights_gpu);
+	if (l.weight_updates_gpu)      cuda_free(l.weight_updates_gpu);
+	if (l.biases_gpu)              cuda_free(l.biases_gpu);
+	if (l.bias_updates_gpu)        cuda_free(l.bias_updates_gpu);
+	if (l.scales_gpu)              cuda_free(l.scales_gpu);
+	if (l.scale_updates_gpu)       cuda_free(l.scale_updates_gpu);
+	if (l.output_gpu)              cuda_free(l.output_gpu);
+	if (l.delta_gpu)               cuda_free(l.delta_gpu);
+	if (l.rand_gpu)                cuda_free(l.rand_gpu);
+	if (l.squared_gpu)             cuda_free(l.squared_gpu);
+	if (l.norms_gpu)               cuda_free(l.norms_gpu);
 #endif
 }
diff --git a/src/network.c b/src/network.c
index 0914e37e..0a49bf1f 100644
--- a/src/network.c
+++ b/src/network.c
@@ -590,15 +590,16 @@ float network_accuracy_multi(network net, data d, int n)
 
 void free_network(network net)
 {
-    int i;
-    for(i = 0; i < net.n; ++i){
-        free_layer(net.layers[i]);
-    }
-    free(net.layers);
+	int i;
+	for (i = 0; i < net.n; ++i) {
+		free_layer(net.layers[i]);
+	}
+	free(net.layers);
+	free(net.workspace);
 #ifdef GPU
-    if(*net.input_gpu) cuda_free(*net.input_gpu);
-    if(*net.truth_gpu) cuda_free(*net.truth_gpu);
-    if(net.input_gpu) free(net.input_gpu);
-    if(net.truth_gpu) free(net.truth_gpu);
+	if (*net.input_gpu) cuda_free(*net.input_gpu);
+	if (*net.truth_gpu) cuda_free(*net.truth_gpu);
+	if (net.input_gpu) free(net.input_gpu);
+	if (net.truth_gpu) free(net.truth_gpu);
 #endif
 }