diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..17e0575
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,7 @@
+BasedOnStyle: LLVM
+IndentWidth: 8
+UseTab: AlignWithSpaces
+BreakBeforeBraces: Linux
+AllowShortIfStatementsOnASingleLine: false
+IndentCaseLabels: false
+ColumnLimit: 80
diff --git a/README.md b/README.md
index 54ce4cb..7ffc94b 100755
--- a/README.md
+++ b/README.md
@@ -21,3 +21,5 @@ Pour ouvrir l'éditeur de niveau (Python et Pygame obligatoire).
 Pour compiler le jeu (fxsdk + gint obligatoire).
 `$ fxsdk build-cg`
 
+Appliquer le formatage au code après vos modifications.
+`$ clang-format -style=file -i src/* include*`
diff --git a/include/save.h b/include/save.h
old mode 100755
new mode 100644
index 4c13d6d..dc4dc45
--- a/include/save.h
+++ b/include/save.h
@@ -3,4 +3,3 @@ int loadtime(int idlevel);
 void loadfile(void);
 void restore(void);
 void savetimes(float framelevel, int id_level);
-
diff --git a/include/setlevel.h b/include/setlevel.h
old mode 100755
new mode 100644
index 09df303..43c6edd
--- a/include/setlevel.h
+++ b/include/setlevel.h
@@ -1,3 +1,4 @@
-void set_level(int id_level, char level[], int *startx, int *starty, char *gravity, int *appear, int *disappear);
+void set_level(int id_level, char level[], int *startx, int *starty,
+               char *gravity, int *appear, int *disappear);
 void set_gravity(int id_level, char *default_gravity);
 void del_level(char level[]);
diff --git a/src/collide.c b/src/collide.c
old mode 100755
new mode 100644
index a9fd2fc..7a8a35c
--- a/src/collide.c
+++ b/src/collide.c
@@ -1,44 +1,51 @@
 #include "collide.h"
 #include "define.h"
 
-#define DEAD_COLLISION 3 //make the collision with the deadly block less effective
+#define DEAD_COLLISION                                                         \
+	3 // make the collision with the deadly block less effective
 
-char collide(int x, int y, char level[], char block) //detect if player is in a block
+char collide(int x, int y, char level[],
+             char block) // detect if player is in a block
 {
-	if((level[(int)(x/16) + (int)((y + PLAYER_HEIGHT)/16) * 25] == block || 
-	level[(int)((x + PLAYER_HEIGHT)/16) + (int)((y + PLAYER_HEIGHT)/16) * 25] == block || 
-	level[(int)(x/16) + (int)((y/16) * 25)] == block || 
-	level[(int)((x + PLAYER_HEIGHT)/16) + (int)((y/16) * 25)] == block)) return 1;
+	if ((level[(int)(x / 16) + (int)((y + PLAYER_HEIGHT) / 16) * 25] ==
+	         block ||
+	     level[(int)((x + PLAYER_HEIGHT) / 16) +
+	           (int)((y + PLAYER_HEIGHT) / 16) * 25] == block ||
+	     level[(int)(x / 16) + (int)((y / 16) * 25)] == block ||
+	     level[(int)((x + PLAYER_HEIGHT) / 16) + (int)((y / 16) * 25)] ==
+	         block))
+		return 1;
 	return 0;
 }
 
 char collide_solid(int x, int y, char level[])
 {
-	return collide(x, y, level, '1')
-	|| collide(x, y, level, '3')
-	|| collide(x, y, level, '4')
-	|| collide(x, y, level, 'c')
-	|| collide(x, y, level, 'C')
-	|| collide(x, y, level, 'B')
-	|| collide(x, y, level, 'i')
-	|| collide(x, y, level, 'H');
+	return collide(x, y, level, '1') || collide(x, y, level, '3') ||
+	       collide(x, y, level, '4') || collide(x, y, level, 'c') ||
+	       collide(x, y, level, 'C') || collide(x, y, level, 'B') ||
+	       collide(x, y, level, 'i') || collide(x, y, level, 'H');
 }
 
 char collide_dead(int x, int y, char level[])
 {
-	return collide_point(x + DEAD_COLLISION, y + DEAD_COLLISION, level, 'd') || 
-	collide_point(x + PLAYER_HEIGHT - DEAD_COLLISION, y + DEAD_COLLISION, level, 'd') || 
-	collide_point(x + DEAD_COLLISION, y + PLAYER_HEIGHT - DEAD_COLLISION, level, 'd') || 
-	collide_point(x + PLAYER_HEIGHT - DEAD_COLLISION, y + PLAYER_HEIGHT - DEAD_COLLISION, level, 'd') ||
-	collide_point(x + 1, y + 1, level, 'C') || 
-	collide_point(x + PLAYER_HEIGHT - 1, y + 1, level, 'C') || 
-	collide_point(x + 1, y + PLAYER_HEIGHT - 1, level, 'C') || 
-	collide_point(x + PLAYER_HEIGHT - 1, y + PLAYER_HEIGHT - 1, level, 'C');
+	return collide_point(x + DEAD_COLLISION, y + DEAD_COLLISION, level,
+	                     'd') ||
+	       collide_point(x + PLAYER_HEIGHT - DEAD_COLLISION,
+	                     y + DEAD_COLLISION, level, 'd') ||
+	       collide_point(x + DEAD_COLLISION,
+	                     y + PLAYER_HEIGHT - DEAD_COLLISION, level, 'd') ||
+	       collide_point(x + PLAYER_HEIGHT - DEAD_COLLISION,
+	                     y + PLAYER_HEIGHT - DEAD_COLLISION, level, 'd') ||
+	       collide_point(x + 1, y + 1, level, 'C') ||
+	       collide_point(x + PLAYER_HEIGHT - 1, y + 1, level, 'C') ||
+	       collide_point(x + 1, y + PLAYER_HEIGHT - 1, level, 'C') ||
+	       collide_point(x + PLAYER_HEIGHT - 1, y + PLAYER_HEIGHT - 1,
+	                     level, 'C');
 }
 
 char collide_point(int x, int y, char level[], char block)
 {
-	return (level[(int)(x/16) + (int)(y/16) * 25] == block);
+	return (level[(int)(x / 16) + (int)(y / 16) * 25] == block);
 }
 
 char collide_end(int x, int y, char level[])
@@ -48,20 +55,18 @@ char collide_end(int x, int y, char level[])
 
 void collide_replace(int x, int y, char level[], char collide, char replace)
 {
-	if(collide_point(x, y, level, collide))
-	{
-		level[((x)/16)+((y)/16)*25] = replace;
+	if (collide_point(x, y, level, collide)) {
+		level[((x) / 16) + ((y) / 16) * 25] = replace;
 	}
-	if(collide_point(x + PLAYER_HEIGHT, y, level, collide))
-	{
-		level[((x + PLAYER_HEIGHT)/16)+((y)/16)*25] = replace;
+	if (collide_point(x + PLAYER_HEIGHT, y, level, collide)) {
+		level[((x + PLAYER_HEIGHT) / 16) + ((y) / 16) * 25] = replace;
 	}
-	if(collide_point(x, y + PLAYER_HEIGHT, level, collide))
-	{
-		level[((x)/16)+((y + PLAYER_HEIGHT)/16)*25] = replace;
+	if (collide_point(x, y + PLAYER_HEIGHT, level, collide)) {
+		level[((x) / 16) + ((y + PLAYER_HEIGHT) / 16) * 25] = replace;
 	}
-	if(collide_point(x + PLAYER_HEIGHT, y + PLAYER_HEIGHT, level, collide))
-	{
-		level[((x + PLAYER_HEIGHT)/16)+((y + PLAYER_HEIGHT)/16)*25] = replace;
+	if (collide_point(x + PLAYER_HEIGHT, y + PLAYER_HEIGHT, level,
+	                  collide)) {
+		level[((x + PLAYER_HEIGHT) / 16) +
+		      ((y + PLAYER_HEIGHT) / 16) * 25] = replace;
 	}
 }
diff --git a/src/drawlevel.c b/src/drawlevel.c
old mode 100755
new mode 100644
index 08f63c5..eac0f53
--- a/src/drawlevel.c
+++ b/src/drawlevel.c
@@ -1,33 +1,33 @@
 #include "drawlevel.h"
-#include <gint/std/string.h>
-#include <gint/display.h>
 #include "define.h"
 #include "times.h"
+#include <gint/display.h>
+#include <gint/std/string.h>
 
 #define VISIBLE_RECT 35
 
-extern bopti_image_t img_solid; //solid block
-extern bopti_image_t img_coin; //facultative coin
-extern bopti_image_t img_dead; //dead block
-extern bopti_image_t img_player; //player
-extern bopti_image_t img_end; //end of level
-extern bopti_image_t img_key1; //key 1
-extern bopti_image_t img_blackout; //blackout
-extern bopti_image_t img_chrono1; //chronoblock
-extern bopti_image_t img_chrono2; //chronoblock 2
-extern bopti_image_t img_key2; //key 2
-extern bopti_image_t img_damaged; //damaged block
-extern bopti_image_t img_chock; //chock block
-extern bopti_image_t img_switch; //switch block
-extern bopti_image_t img_ice; //switch block
-extern bopti_image_t img_appear; //appear block
+extern bopti_image_t img_solid;    // solid block
+extern bopti_image_t img_coin;     // facultative coin
+extern bopti_image_t img_dead;     // dead block
+extern bopti_image_t img_player;   // player
+extern bopti_image_t img_end;      // end of level
+extern bopti_image_t img_key1;     // key 1
+extern bopti_image_t img_blackout; // blackout
+extern bopti_image_t img_chrono1;  // chronoblock
+extern bopti_image_t img_chrono2;  // chronoblock 2
+extern bopti_image_t img_key2;     // key 2
+extern bopti_image_t img_damaged;  // damaged block
+extern bopti_image_t img_chock;    // chock block
+extern bopti_image_t img_switch;   // switch block
+extern bopti_image_t img_ice;      // switch block
+extern bopti_image_t img_appear;   // appear block
 
 extern bopti_image_t img_endscreen;
 extern bopti_image_t img_new;
 
 void draw_player(int x, int y, char type)
 {
-	dsubimage(x,y,&img_player, 12*(type-1),0,12,12, DIMAGE_NONE);
+	dsubimage(x, y, &img_player, 12 * (type - 1), 0, 12, 12, DIMAGE_NONE);
 }
 
 void draw_level(char level[])
@@ -36,76 +36,76 @@ void draw_level(char level[])
 	unsigned int x = 0;
 	unsigned int y = 0;
 	unsigned int i = 0;
-	while (i!=strlen(level))
-	{
-		switch(level[i])
-		{
-			case '1': //solid block
-				dimage(x,y,&img_solid);
-				break;
-			case 't': //coin (treasure)
-				dimage(x,y,&img_coin);
-				break;
-			case 'd': //dead block
-				dimage(x,y,&img_dead);
-				break;
-			case 'e': //end of level
-				dimage(x,y,&img_end);
-				break;
-			case '3': //block link to the key1
-				dsubimage(x,y,&img_key1,0,0,16,16,DIMAGE_NONE);
-				break;
-			case 'k': //key1
-				dsubimage(x,y,&img_key1,16,0,16,16,DIMAGE_NONE);
-				break;
-			case 'a': //block link to the key2 when it's not on
-				dsubimage(x,y,&img_key2,0,0,16,16,DIMAGE_NONE);
-				break;
-			case '4': //block link to the key2
-				dsubimage(x,y,&img_key2,16,0,16,16,DIMAGE_NONE);
-				break;
-			case 'K': //key2
-                dsubimage(x,y,&img_key2,32,0,16,16,DIMAGE_NONE);
-				break;
-			case 'c': //chrono blocks
-				dimage(x,y,&img_chrono1);
-				break;
-			case 'C': //chrono blocks
-                dsubimage(x,y,&img_chrono2,16,0,16,16,DIMAGE_NONE);
-				break;
-			case 'b': //blackout blocks
-				dimage(x,y,&img_blackout);
-				break;
-			case 'B': //damaged block
-				dimage(x,y,&img_damaged);
-				break;
-			case 'l': //chock blocks
-				dimage(x,y,&img_chock);
-				break;
-			case 'i': //chock blocks
-				dimage(x,y,&img_ice);
-				break;
-			case 'S': //chock blocks
-				dimage(x,y,&img_switch);
-				break;
-			case 'h': //void appear blocks
-				dsubimage(x,y,&img_appear,0,0,16,16,DIMAGE_NONE);
-				break;
-			case 'H': //appear blocks
-                dsubimage(x,y,&img_appear,16,0,16,16,DIMAGE_NONE);
-				break;
-			case 'y': //appear blocks
-				dsubimage(x,y,&img_appear,0,0,16,16,DIMAGE_NONE);
-				break;
-			case 'm': //chronoappear blocks
-                dsubimage(x,y,&img_chrono2,0,0,16,16,DIMAGE_NONE);
-				break;
+	while (i != strlen(level)) {
+		switch (level[i]) {
+		case '1': // solid block
+			dimage(x, y, &img_solid);
+			break;
+		case 't': // coin (treasure)
+			dimage(x, y, &img_coin);
+			break;
+		case 'd': // dead block
+			dimage(x, y, &img_dead);
+			break;
+		case 'e': // end of level
+			dimage(x, y, &img_end);
+			break;
+		case '3': // block link to the key1
+			dsubimage(x, y, &img_key1, 0, 0, 16, 16, DIMAGE_NONE);
+			break;
+		case 'k': // key1
+			dsubimage(x, y, &img_key1, 16, 0, 16, 16, DIMAGE_NONE);
+			break;
+		case 'a': // block link to the key2 when it's not on
+			dsubimage(x, y, &img_key2, 0, 0, 16, 16, DIMAGE_NONE);
+			break;
+		case '4': // block link to the key2
+			dsubimage(x, y, &img_key2, 16, 0, 16, 16, DIMAGE_NONE);
+			break;
+		case 'K': // key2
+			dsubimage(x, y, &img_key2, 32, 0, 16, 16, DIMAGE_NONE);
+			break;
+		case 'c': // chrono blocks
+			dimage(x, y, &img_chrono1);
+			break;
+		case 'C': // chrono blocks
+			dsubimage(x, y, &img_chrono2, 16, 0, 16, 16,
+			          DIMAGE_NONE);
+			break;
+		case 'b': // blackout blocks
+			dimage(x, y, &img_blackout);
+			break;
+		case 'B': // damaged block
+			dimage(x, y, &img_damaged);
+			break;
+		case 'l': // chock blocks
+			dimage(x, y, &img_chock);
+			break;
+		case 'i': // chock blocks
+			dimage(x, y, &img_ice);
+			break;
+		case 'S': // chock blocks
+			dimage(x, y, &img_switch);
+			break;
+		case 'h': // void appear blocks
+			dsubimage(x, y, &img_appear, 0, 0, 16, 16, DIMAGE_NONE);
+			break;
+		case 'H': // appear blocks
+			dsubimage(x, y, &img_appear, 16, 0, 16, 16,
+			          DIMAGE_NONE);
+			break;
+		case 'y': // appear blocks
+			dsubimage(x, y, &img_appear, 0, 0, 16, 16, DIMAGE_NONE);
+			break;
+		case 'm': // chronoappear blocks
+			dsubimage(x, y, &img_chrono2, 0, 0, 16, 16,
+			          DIMAGE_NONE);
+			break;
 		}
-		x+=16;
-		if(x==16*25)
-		{
-			x=0;
-			y+=16;
+		x += 16;
+		if (x == 16 * 25) {
+			x = 0;
+			y += 16;
 		}
 		i++;
 	}
@@ -113,35 +113,37 @@ void draw_level(char level[])
 
 void draw_blackout(int x, int y)
 {
-	x+=5;
-	y+=5;
-	drect(0, 0, 395, y-VISIBLE_RECT, C_BLACK); //top rect
-	drect(0, y-VISIBLE_RECT, x-VISIBLE_RECT, y+VISIBLE_RECT, C_BLACK); //left rect
-	drect(x+VISIBLE_RECT, y-VISIBLE_RECT, 395, y+VISIBLE_RECT, C_BLACK); //right rect
-	drect(0, y+VISIBLE_RECT, 395, 223, C_BLACK); //bottom rect
+	x += 5;
+	y += 5;
+	drect(0, 0, 395, y - VISIBLE_RECT, C_BLACK); // top rect
+	drect(0, y - VISIBLE_RECT, x - VISIBLE_RECT, y + VISIBLE_RECT,
+	      C_BLACK); // left rect
+	drect(x + VISIBLE_RECT, y - VISIBLE_RECT, 395, y + VISIBLE_RECT,
+	      C_BLACK);                                // right rect
+	drect(0, y + VISIBLE_RECT, 395, 223, C_BLACK); // bottom rect
 }
 
 void draw_timer(unsigned int frame)
 {
 	float framefloat = frame;
-	dprint_opt(0, 0, C_WHITE, C_BLACK, DTEXT_LEFT, DTEXT_TOP, "%.2j", (int)(framefloat/FPS*100));
+	dprint_opt(0, 0, C_WHITE, C_BLACK, DTEXT_LEFT, DTEXT_TOP, "%.2j",
+	           (int)(framefloat / FPS * 100));
 }
 
 void draw_end(int framelevel, int id_level, char record)
 {
 	float framefloat = framelevel;
-	dimage(144,60,&img_endscreen);
-	if(record!=2)
-	{
-		dprint_opt(220, 115, C_WHITE, C_BLACK, DTEXT_LEFT, DTEXT_TOP, "%d", framelevel);
-		dprint(166, 87, C_RED, "%.2j",(int)(framefloat/FPS*100));
+	dimage(144, 60, &img_endscreen);
+	if (record != 2) {
+		dprint_opt(220, 115, C_WHITE, C_BLACK, DTEXT_LEFT, DTEXT_TOP,
+		           "%d", framelevel);
+		dprint(166, 87, C_RED, "%.2j", (int)(framefloat / FPS * 100));
 		check_medal(framelevel, id_level, 178, 140);
-		if(record==1) dimage(60,100,&img_new);
-	}
-	else
-	{
+		if (record == 1)
+			dimage(60, 100, &img_new);
+	} else {
 		dprint(166, 87, C_RED, "GG !");
-		dprint(178, 140, C_RED, "%.2j",(int)(framefloat/FPS*100));
+		dprint(178, 140, C_RED, "%.2j", (int)(framefloat / FPS * 100));
 	}
 	dupdate();
 }
diff --git a/src/main.c b/src/main.c
old mode 100755
new mode 100644
index 32795cc..d002e52
--- a/src/main.c
+++ b/src/main.c
@@ -1,17 +1,17 @@
-#include <gint/display.h>
-#include <gint/keyboard.h>
 #include <gint/clock.h>
-#include <gint/timer.h>
+#include <gint/display.h>
 #include <gint/gint.h>
+#include <gint/keyboard.h>
 #include <gint/std/string.h>
+#include <gint/timer.h>
 
-#include "setlevel.h"
-#include "drawlevel.h"
 #include "collide.h"
-#include "menu.h"
-#include "times.h"
-#include "save.h"
 #include "define.h"
+#include "drawlevel.h"
+#include "menu.h"
+#include "save.h"
+#include "setlevel.h"
+#include "times.h"
 
 #define VACCELERATION 0.2
 #define HACCELERATION 0.4
@@ -23,391 +23,456 @@ void end(unsigned int frame);
 
 int callback(volatile int *frame_elapsed)
 {
-    *frame_elapsed = 1;
-    return TIMER_CONTINUE;
+	*frame_elapsed = 1;
+	return TIMER_CONTINUE;
 }
 
 void game(int *id_level, char mode, char *type)
 {
 	volatile int frame_elapsed = 1;
-	int timer = timer_setup(TIMER_ANY, 1000000/FPS, callback, &frame_elapsed);
+	int timer =
+	    timer_setup(TIMER_ANY, 1000000 / FPS, callback, &frame_elapsed);
 	timer_start(timer);
-	
+
 	char game_loop = 1;
 	unsigned int frame = 0;
 	int framelevel = 0;
 	int player_x = 20, player_y = 20;
 	char level[351];
-	char gravity = 0; //0 down 1 up
+	char gravity = 0; // 0 down 1 up
 	char check = 1;
 	char blackout = 0;
 	int start_x;
 	int start_y;
 	int death_count = 0;
-	
+
 	int coin = 0;
 	char check_coin = 0;
 	char double_check = 1;
-	
+
 	int appear = 10;
 	int disappear = 13;
-	
+
 	float vspd = 1.0;
 	float hspd = 0.0;
-	if(*id_level==10 && *type!=3) *type = 2;
-	else if(*type!=3) *type = 1;
+	if (*id_level == 10 && *type != 3)
+		*type = 2;
+	else if (*type != 3)
+		*type = 1;
 	extern bopti_image_t img_speedrun;
-	set_level(*id_level, level, &start_x, &start_y, &gravity, &appear, &disappear);
+	set_level(*id_level, level, &start_x, &start_y, &gravity, &appear,
+	          &disappear);
 	player_x = start_x;
 	player_y = start_y;
 	draw_level(level);
-	while(game_loop)
-	{
-		while(!frame_elapsed) sleep();
+	while (game_loop) {
+		while (!frame_elapsed)
+			sleep();
 		frame_elapsed = 0;
-		
+
 		frame++;
 		framelevel++;
-		if(!(frame%2))
-		{
+		if (!(frame % 2)) {
 			draw_level(level);
-			if(blackout) draw_blackout(player_x, player_y);
+			if (blackout)
+				draw_blackout(player_x, player_y);
 			draw_player(player_x, player_y, *type);
-			if(!mode) draw_timer(frame);
-			else draw_timer(framelevel);
-		
-		if(*id_level==0 && !mode)
-		{
-			dprint(85,180,C_RGB(245,245,0),"SHIFT");
-			dprint(120,3,C_RGB(220,220,220),"Keys has effects on blocks");
-			dprint(15,67,C_RGB(220,220,220),"Red blocks = death");
-			dprint(30,211,C_RGB(220,220,220),"^ special blocks");
-			dprint(290,131,C_RGB(110,110,110),"Well done !");
-		}
-			if(!mode) dprint_opt(330, 0, C_RGB(255,190,0), C_BLACK, DTEXT_LEFT, DTEXT_TOP, "Coin : %d", coin);
+			if (!mode)
+				draw_timer(frame);
+			else
+				draw_timer(framelevel);
+
+			if (*id_level == 0 && !mode) {
+				dprint(85, 180, C_RGB(245, 245, 0), "SHIFT");
+				dprint(120, 3, C_RGB(220, 220, 220),
+				       "Keys has effects on blocks");
+				dprint(15, 67, C_RGB(220, 220, 220),
+				       "Red blocks = death");
+				dprint(30, 211, C_RGB(220, 220, 220),
+				       "^ special blocks");
+				dprint(290, 131, C_RGB(110, 110, 110),
+				       "Well done !");
+			}
+			if (!mode)
+				dprint_opt(330, 0, C_RGB(255, 190, 0), C_BLACK,
+				           DTEXT_LEFT, DTEXT_TOP, "Coin : %d",
+				           coin);
 			dupdate();
 		}
-		
-		
+
 		pollevent();
-	
-		if(keydown(KEY_OPTN))
-		{
-			level[((player_x+6)/16)+((player_y+6)/16)*25] = 'd';
+
+		if (keydown(KEY_OPTN)) {
+			level[((player_x + 6) / 16) +
+			      ((player_y + 6) / 16) * 25] = 'd';
 			death_count--;
 		}
-		//Right collision
-		if(keydown(KEY_RIGHT))
-		{
+		// Right collision
+		if (keydown(KEY_RIGHT)) {
 			hspd *= 1 - FRICTION;
-			hspd += (keydown(KEY_RIGHT)-keydown(KEY_LEFT)) * HACCELERATION;
-			if(!collide_solid(player_x+round(hspd)+1, player_y, level)) player_x += round(hspd);
-			else if(!collide_solid(player_x+1, player_y, level)) player_x+=1;
-			if(player_x>=388) player_x=-4;
+			hspd += (keydown(KEY_RIGHT) - keydown(KEY_LEFT)) *
+				HACCELERATION;
+			if (!collide_solid(player_x + round(hspd) + 1, player_y,
+			                   level))
+				player_x += round(hspd);
+			else if (!collide_solid(player_x + 1, player_y, level))
+				player_x += 1;
+			if (player_x >= 388)
+				player_x = -4;
 		}
-		//Left collision
-		else if(keydown(KEY_LEFT))
-		{
+		// Left collision
+		else if (keydown(KEY_LEFT)) {
 			hspd *= 1 - FRICTION;
-			hspd += (keydown(KEY_RIGHT)-keydown(KEY_LEFT)) * HACCELERATION;
-			if(!collide_solid(player_x+round(hspd)-1, player_y, level)) player_x += round(hspd);
-			else if(!collide_solid(player_x-1, player_y, level)) player_x-=1;
-			if(player_x<-9) player_x=384;
-		}
-		else hspd=0;
-		//Action key
-		if(keydown(KEY_SHIFT) && !check && ((collide_solid(player_x, player_y-1, level) && gravity) || (collide_solid(player_x, player_y+1, level) && !gravity)))
-		{
+			hspd += (keydown(KEY_RIGHT) - keydown(KEY_LEFT)) *
+				HACCELERATION;
+			if (!collide_solid(player_x + round(hspd) - 1, player_y,
+			                   level))
+				player_x += round(hspd);
+			else if (!collide_solid(player_x - 1, player_y, level))
+				player_x -= 1;
+			if (player_x < -9)
+				player_x = 384;
+		} else
+			hspd = 0;
+		// Action key
+		if (keydown(KEY_SHIFT) && !check &&
+		    ((collide_solid(player_x, player_y - 1, level) &&
+		      gravity) ||
+		     (collide_solid(player_x, player_y + 1, level) &&
+		      !gravity))) {
 			vspd = 1;
-			if(!gravity) gravity=1;
-			else gravity=0;
-			check=1;
-		}
-		else if(!keydown(KEY_SHIFT) && check) check=0;
-		//Gravity
-		if(!gravity)
-		{
-			if(!collide_solid(player_x, player_y+(int)vspd+1, level))
-			{
-				if (vspd<MAX_VSPD) vspd+=VACCELERATION;
-				if(collide(player_x+1, player_y, level, 'i'))  vspd+=0.15;
-				if(collide(player_x-1, player_y, level, 'i'))  vspd+=0.15;
-				player_y+=(int)vspd;
-			}
-			else if(!collide_solid(player_x, player_y+(int)vspd, level))
-			{
-				vspd-=VACCELERATION;
-				player_y+=(int)vspd;
-			}
-			else if(!collide_solid(player_x, player_y+1, level))
-			{
+			if (!gravity)
+				gravity = 1;
+			else
+				gravity = 0;
+			check = 1;
+		} else if (!keydown(KEY_SHIFT) && check)
+			check = 0;
+		// Gravity
+		if (!gravity) {
+			if (!collide_solid(player_x, player_y + (int)vspd + 1,
+			                   level)) {
+				if (vspd < MAX_VSPD)
+					vspd += VACCELERATION;
+				if (collide(player_x + 1, player_y, level, 'i'))
+					vspd += 0.15;
+				if (collide(player_x - 1, player_y, level, 'i'))
+					vspd += 0.15;
+				player_y += (int)vspd;
+			} else if (!collide_solid(
+				       player_x, player_y + (int)vspd, level)) {
+				vspd -= VACCELERATION;
+				player_y += (int)vspd;
+			} else if (!collide_solid(player_x, player_y + 1,
+			                          level)) {
 				vspd = 1;
-				player_y+=1;
-			}
-			else vspd = 1;
-		}
-		else
-		{
-			if(!collide_solid(player_x, player_y-(int)vspd-1, level))
-			{
-				if (vspd<MAX_VSPD) vspd+=VACCELERATION;
-				if(collide(player_x+1, player_y, level, 'i'))  vspd+=0.15;
-				if(collide(player_x-1, player_y, level, 'i'))  vspd+=0.15;
-				player_y-=(int)vspd;
-			}
-			else if(!collide_solid(player_x, player_y-(int)vspd, level))
-			{
-				vspd-=VACCELERATION;
-				player_y-=(int)vspd;
-			}
-			else if(!collide_solid(player_x, player_y-1, level))
-			{
+				player_y += 1;
+			} else
+				vspd = 1;
+		} else {
+			if (!collide_solid(player_x, player_y - (int)vspd - 1,
+			                   level)) {
+				if (vspd < MAX_VSPD)
+					vspd += VACCELERATION;
+				if (collide(player_x + 1, player_y, level, 'i'))
+					vspd += 0.15;
+				if (collide(player_x - 1, player_y, level, 'i'))
+					vspd += 0.15;
+				player_y -= (int)vspd;
+			} else if (!collide_solid(
+				       player_x, player_y - (int)vspd, level)) {
+				vspd -= VACCELERATION;
+				player_y -= (int)vspd;
+			} else if (!collide_solid(player_x, player_y - 1,
+			                          level)) {
+				vspd = 1;
+				player_y -= 1;
+			} else
 				vspd = 1;
-				player_y-=1;
-			}
-			else vspd = 1;
 		}
-		//Collide with red block
-		if(collide_dead(player_x, player_y, level))
-		{
+		// Collide with red block
+		if (collide_dead(player_x, player_y, level)) {
 			vspd = 1;
 			player_x = start_x;
 			player_y = start_y;
-			if(check_coin) coin--;
+			if (check_coin)
+				coin--;
 			check_coin = 0;
-			set_level(*id_level, level, &start_x, &start_y, &gravity, &appear, &disappear);
+			set_level(*id_level, level, &start_x, &start_y,
+			          &gravity, &appear, &disappear);
 			blackout = 0;
 			death_count++;
 			double_check = 1;
 			framelevel = 0;
-            if(*id_level == 1 && !mode) 
-                frame = 0;
+			if (*id_level == 1 && !mode)
+				frame = 0;
 		}
-		//Collide with the end
-		if(collide_end(player_x, player_y, level))
-		{
-			if(!mode && *id_level !=0) *id_level+=1;
-			else break;
+		// Collide with the end
+		if (collide_end(player_x, player_y, level)) {
+			if (!mode && *id_level != 0)
+				*id_level += 1;
+			else
+				break;
 			check_coin = 0;
-			set_level(*id_level, level, &start_x, &start_y, &gravity, &appear, &disappear);
+			set_level(*id_level, level, &start_x, &start_y,
+			          &gravity, &appear, &disappear);
 			player_x = start_x;
 			player_y = start_y;
 			blackout = 0;
 			double_check = 1;
-			framelevel=0;
-			if(*id_level==10 && *type==1) *type = 2;
-			else if(*type!=3) *type = 1;
-			if(*id_level==LEVEL_MAX+1)
-			{
+			framelevel = 0;
+			if (*id_level == 10 && *type == 1)
+				*type = 2;
+			else if (*type != 3)
+				*type = 1;
+			if (*id_level == LEVEL_MAX + 1) {
 				timer_stop(timer);
 				end(frame);
 			}
 		}
-		if(collide(player_x, player_y, level, 'k')) //Collide with key1 = disappearance of blocks
+		if (collide(player_x, player_y, level,
+		            'k')) // Collide with key1 = disappearance of blocks
 		{
-			for (int i = 0; level[i]!='\0' ; i++) 
-			{
-				if(level[i]=='3') level[i]='0';
-				if(level[i]=='k') level[i]='0';
+			for (int i = 0; level[i] != '\0'; i++) {
+				if (level[i] == '3')
+					level[i] = '0';
+				if (level[i] == 'k')
+					level[i] = '0';
 			}
 		}
-		if(collide(player_x, player_y, level, 'K')) //Collide with key2 = appearance of blocks
+		if (collide(player_x, player_y, level,
+		            'K')) // Collide with key2 = appearance of blocks
 		{
-			for (int i = 0; level[i]!='\0' ; i++) 
-			{
-				if(level[i]=='a') level[i]='4';
-				if(level[i]=='K') level[i]='0';
+			for (int i = 0; level[i] != '\0'; i++) {
+				if (level[i] == 'a')
+					level[i] = '4';
+				if (level[i] == 'K')
+					level[i] = '0';
 			}
 		}
-		if(collide(player_x, player_y, level, 't') && !check_coin) //Collide with coin
+		if (collide(player_x, player_y, level, 't') &&
+		    !check_coin) // Collide with coin
 		{
-			for (int i = 0; level[i]!='\0' ; i++) 
-			{
-				if(level[i]=='t') 
-				{
-					level[i]='0';
+			for (int i = 0; level[i] != '\0'; i++) {
+				if (level[i] == 't') {
+					level[i] = '0';
 					break;
 				}
 			}
-			check_coin=1;
+			check_coin = 1;
 			coin++;
 		}
-		if(collide(player_x, player_y, level, 'b')) //Collide with blackout block
+		if (collide(player_x, player_y, level,
+		            'b')) // Collide with blackout block
 		{
-			for (int i = 0; level[i]!='\0' ; i++) 
-			{
-				if(level[i]=='b') 
-				{
-					level[i]='0';
+			for (int i = 0; level[i] != '\0'; i++) {
+				if (level[i] == 'b') {
+					level[i] = '0';
 					break;
 				}
 			}
-			blackout=1;
+			blackout = 1;
 		}
-		if(level[((player_x+6)/16)+((player_y+6)/16)*25] == 'l') //Collide with change block
+		if (level[((player_x + 6) / 16) + ((player_y + 6) / 16) * 25] ==
+		    'l') // Collide with change block
 		{
 			int x = 0;
 			int y = 0;
-			char level2[351] = { 0 };
+			char level2[351] = {0};
 			int j = 0;
-			level[((player_x+6)/16)+((player_y+6)/16)*25] = 'P';
-			for (int i = 349; i!=-1 ; i--) 
-			{
-				level2[j]=level[i];
+			level[((player_x + 6) / 16) +
+			      ((player_y + 6) / 16) * 25] = 'P';
+			for (int i = 349; i != -1; i--) {
+				level2[j] = level[i];
 				j++;
 			}
 			del_level(level);
-			strncpy(level,level2,351);
+			strncpy(level, level2, 351);
 			del_level(level2);
 			int i = 0;
-			while (i!=350)
-			{
-				switch(level[i])
-				{
-					case 'P':
-						player_x = x;
-						player_y = y;
-						level[i]='0';
-						break;
+			while (i != 350) {
+				switch (level[i]) {
+				case 'P':
+					player_x = x;
+					player_y = y;
+					level[i] = '0';
+					break;
 				}
-				x+=16;
-				if(x==16*25)
-				{
-					x=0;
-					y+=16;
+				x += 16;
+				if (x == 16 * 25) {
+					x = 0;
+					y += 16;
 				}
 				i++;
 			}
-			if(!gravity) gravity=1;
-			else gravity=0;
+			if (!gravity)
+				gravity = 1;
+			else
+				gravity = 0;
 		}
-		
-		if(collide(player_x, player_y+(int)vspd+2, level, 'B') && vspd>=5) //Damaged block 
+
+		if (collide(player_x, player_y + (int)vspd + 2, level, 'B') &&
+		    vspd >= 5) // Damaged block
 		{
-			if(level[((player_x)/16)+((player_y+25)/16)*25]=='B') level[((player_x)/16)+((player_y+25)/16)*25]='0';
-			if(level[((player_x+12)/16)+((player_y+25)/16)*25]=='B' && collide_point(player_x+12, player_y+22, level, 'B')) level[((player_x+12)/16)+((player_y+25)/16)*25]='0';
-			vspd=1.0;
+			if (level[((player_x) / 16) +
+			          ((player_y + 25) / 16) * 25] == 'B')
+				level[((player_x) / 16) +
+				      ((player_y + 25) / 16) * 25] = '0';
+			if (level[((player_x + 12) / 16) +
+			          ((player_y + 25) / 16) * 25] == 'B' &&
+			    collide_point(player_x + 12, player_y + 22, level,
+			                  'B'))
+				level[((player_x + 12) / 16) +
+				      ((player_y + 25) / 16) * 25] = '0';
+			vspd = 1.0;
 		}
-		if(collide(player_x, player_y-(int)vspd-2, level, 'B') && vspd>=5) //Damaged block
+		if (collide(player_x, player_y - (int)vspd - 2, level, 'B') &&
+		    vspd >= 5) // Damaged block
 		{
-			if(level[((player_x)/16)+((player_y-(int)vspd-2)/16)*25]=='B') level[((player_x)/16)+((player_y-(int)vspd-2)/16)*25]='0';
-			if(level[((player_x+12)/16)+((player_y-(int)vspd-2)/16)*25]=='B' && collide_point(player_x+12, player_y-12, level, 'B')) level[((player_x+12)/16)+((player_y-(int)vspd-2)/16)*25]='0';
-			vspd=1.0;
+			if (level[((player_x) / 16) +
+			          ((player_y - (int)vspd - 2) / 16) * 25] ==
+			    'B')
+				level[((player_x) / 16) +
+				      ((player_y - (int)vspd - 2) / 16) * 25] =
+				    '0';
+			if (level[((player_x + 12) / 16) +
+			          ((player_y - (int)vspd - 2) / 16) * 25] ==
+			        'B' &&
+			    collide_point(player_x + 12, player_y - 12, level,
+			                  'B'))
+				level[((player_x + 12) / 16) +
+				      ((player_y - (int)vspd - 2) / 16) * 25] =
+				    '0';
+			vspd = 1.0;
 		}
-		
-		collide_replace(player_x, player_y, level, 'h', 'y'); //Appear block
-		if(!collide(player_x, player_y, level, 'y') && double_check) //Appear block
+
+		collide_replace(player_x, player_y, level, 'h',
+		                'y'); // Appear block
+		if (!collide(player_x, player_y, level, 'y') &&
+		    double_check) // Appear block
 		{
-			for (int i = 0; level[i]!='\0' ; i++) 
-			{
-				if(level[i]=='y')
-				{
+			for (int i = 0; level[i] != '\0'; i++) {
+				if (level[i] == 'y') {
 					double_check = 1;
 					break;
-				}
-				else if(level[i]=='h')
-				{
+				} else if (level[i] == 'h') {
 					double_check = 1;
 					break;
-				}
-				else double_check = 0; //This loop is executed only when an h or y is on the level
+				} else
+					double_check =
+					    0; // This loop is executed only
+					       // when an h or y is on the level
 			}
-		for (int i = 0; level[i]!='\0'; ++i)
-		{
-			if(level[i]=='y')
-				{
-					level[i]='H';
+			for (int i = 0; level[i] != '\0'; ++i) {
+				if (level[i] == 'y') {
+					level[i] = 'H';
 				}
+			}
 		}
-		
-		}
-		if(level[((player_x+6)/16)+((player_y+6)/16)*25] == 'S') //Switch block
+		if (level[((player_x + 6) / 16) + ((player_y + 6) / 16) * 25] ==
+		    'S') // Switch block
 		{
-			level[((player_x+6)/16)+((player_y+6)/16)*25] = '0';
-			vspd=1.0;
-			if(!gravity) gravity=1;
-			else gravity=0;
+			level[((player_x + 6) / 16) +
+			      ((player_y + 6) / 16) * 25] = '0';
+			vspd = 1.0;
+			if (!gravity)
+				gravity = 1;
+			else
+				gravity = 0;
 		}
-		
-		if((framelevel/FPS)>disappear) for (int i = 0; level[i]!='\0' ; i++) if(level[i]=='c') level[i]='0'; //after x seconds blocks disappear
-		if((framelevel/FPS)>appear) for (int i = 0; level[i]!='\0' ; i++) if(level[i]=='m') level[i]='C'; //after x seconds blocks appear
-		
-		if(player_y>=212) player_y=-4;
-		if(player_y<-6) player_y=212;
-		
-		//Menu
-		if(keydown_any(KEY_EXIT, KEY_MENU, 0))
-		{
+
+		if ((framelevel / FPS) > disappear)
+			for (int i = 0; level[i] != '\0'; i++)
+				if (level[i] == 'c')
+					level[i] = '0'; // after x seconds
+					                // blocks disappear
+		if ((framelevel / FPS) > appear)
+			for (int i = 0; level[i] != '\0'; i++)
+				if (level[i] == 'm')
+					level[i] = 'C'; // after x seconds
+					                // blocks appear
+
+		if (player_y >= 212)
+			player_y = -4;
+		if (player_y < -6)
+			player_y = 212;
+
+		// Menu
+		if (keydown_any(KEY_EXIT, KEY_MENU, 0)) {
 			char menu_loop = 1;
 			char selected = 0;
 			int Y_POS = 18;
 			char buffer = 1;
-			while(menu_loop)
-			{
+			while (menu_loop) {
 				clearevents();
 				dclear(C_WHITE);
 				draw_level(level);
-				draw_player(player_x,player_y, *type);
-				dimage(0,0,&img_speedrun);
+				draw_player(player_x, player_y, *type);
+				dimage(0, 0, &img_speedrun);
 				selected += keydown(KEY_DOWN) - keydown(KEY_UP);
-				if (selected == 2) selected = 0;
-				else if (selected == -1) selected = 1;
+				if (selected == 2)
+					selected = 0;
+				else if (selected == -1)
+					selected = 1;
 				dtext(32, Y_POS, C_BLACK, "CONTINUE");
-				if(!mode) dtext(32, Y_POS + 12, C_BLACK, "MENU");
-				else dtext(32, Y_POS + 12, C_BLACK, "SPEEDRUN MENU");
-				dtext(16, Y_POS + (selected * 12), C_BLACK, ">");
-				dprint(180, 45, C_RGB(83,255,0), "LEVEL : %d", *id_level);
-				dprint(320, 3, C_RGB(255,178,0), "COIN : %d", coin);
-				dprint(311, 17, C_RGB(150,16,16), "DEATH : %d", death_count);
+				if (!mode)
+					dtext(32, Y_POS + 12, C_BLACK, "MENU");
+				else
+					dtext(32, Y_POS + 12, C_BLACK,
+					      "SPEEDRUN MENU");
+				dtext(16, Y_POS + (selected * 12), C_BLACK,
+				      ">");
+				dprint(180, 45, C_RGB(83, 255, 0), "LEVEL : %d",
+				       *id_level);
+				dprint(320, 3, C_RGB(255, 178, 0), "COIN : %d",
+				       coin);
+				dprint(311, 17, C_RGB(150, 16, 16),
+				       "DEATH : %d", death_count);
 				dupdate();
-				if (keydown_any(KEY_SHIFT, KEY_EXE, 0))
-				{
-					switch (selected)
-					{
-						case 0:
-							menu_loop = 0;
-							break;
-						case 1:
-							menu_loop = 0;
-							game_loop = 0;
-							break;
-					}
-				}
-				if(keydown_any(KEY_EXIT, KEY_MENU, 0))
-				{
-					if(!buffer)
-					{
+				if (keydown_any(KEY_SHIFT, KEY_EXE, 0)) {
+					switch (selected) {
+					case 0:
+						menu_loop = 0;
+						break;
+					case 1:
 						menu_loop = 0;
 						game_loop = 0;
 						break;
 					}
 				}
-				else buffer = 0;
-				while (keydown_any(KEY_UP, KEY_DOWN, 0)) clearevents();
+				if (keydown_any(KEY_EXIT, KEY_MENU, 0)) {
+					if (!buffer) {
+						menu_loop = 0;
+						game_loop = 0;
+						break;
+					}
+				} else
+					buffer = 0;
+				while (keydown_any(KEY_UP, KEY_DOWN, 0))
+					clearevents();
 			}
 		}
 	}
 	timer_stop(timer);
-	//when a level is quit
-	if(mode)
-	{
-		if(*id_level==0) *id_level=1;
-		if(game_loop) //end of a level with level selection
+	// when a level is quit
+	if (mode) {
+		if (*id_level == 0)
+			*id_level = 1;
+		if (game_loop) // end of a level with level selection
 		{
 			float framefloat = framelevel;
 			draw_end(framelevel, *id_level, 0);
 			savetimes(framefloat, *id_level);
 			sleep_ms(3000);
 		}
-		if(!speed_menu(id_level)) 
-		{
+		if (!speed_menu(id_level)) {
 			mode = 1;
 			death_count = 0;
 			game(id_level, mode, type);
-		}
-		else main();
-	}
-	else main();
+		} else
+			main();
+	} else
+		main();
 }
 
 void end(unsigned int frame)
@@ -418,28 +483,23 @@ void end(unsigned int frame)
 }
 
 int main(void)
-{	
+{
 	char mode = 0;
 	char type = 1;
 	char valeur = start_menu(&type);
-	if(!valeur) //normal game (level selection)
+	if (!valeur) // normal game (level selection)
 	{
 		int id_level = 1;
-		if(!speed_menu(&id_level)) 
-		{
+		if (!speed_menu(&id_level)) {
 			mode = 1;
 			game(&id_level, mode, &type);
-		}
-		else main();
-	}
-	else if(valeur==1)
-	{
+		} else
+			main();
+	} else if (valeur == 1) {
 		int id_level = 1;
 		mode = 0;
 		game(&id_level, mode, &type);
-	}
-	else if(valeur==2)
-	{
+	} else if (valeur == 2) {
 		int id_level = 0;
 		game(&id_level, mode, &type);
 	}
diff --git a/src/menu.c b/src/menu.c
old mode 100755
new mode 100644
index bbeda08..51680e9
--- a/src/menu.c
+++ b/src/menu.c
@@ -1,16 +1,16 @@
+#include "define.h"
 #include "drawlevel.h"
-#include <gint/display.h>
-#include <gint/keyboard.h>
+#include "save.h"
 #include "setlevel.h"
 #include "times.h"
-#include "define.h"
-#include "save.h"
+#include <gint/display.h>
 #include <gint/gint.h>
+#include <gint/keyboard.h>
 
-int round(float num) //round(2.5) = 3 round(-3.2) = -3
-{ 
-    return num < 0 ? num - 0.5 : num + 0.5; 
-} 
+int round(float num) // round(2.5) = 3 round(-3.2) = -3
+{
+	return num < 0 ? num - 0.5 : num + 0.5;
+}
 
 char start_menu(char *type)
 {
@@ -21,14 +21,15 @@ char start_menu(char *type)
 	char buffer2 = 1;
 	int Y_POS = 85;
 	gint_switch(restore);
-	while(menu_loop)
-	{
+	while (menu_loop) {
 		clearevents();
 		dclear(C_WHITE);
-		dimage(0,0,&img_menu);
+		dimage(0, 0, &img_menu);
 		selection += keydown(KEY_DOWN) - keydown(KEY_UP);
-		if (selection == 4) selection = 0;
-		else if (selection == -1) selection = 3;
+		if (selection == 4)
+			selection = 0;
+		else if (selection == -1)
+			selection = 3;
 		dtext(32, Y_POS, C_BLACK, "PLAY");
 		dtext(32, Y_POS + 12, C_BLACK, "ALL MODE");
 		dtext(32, Y_POS + 24, C_BLACK, "TUTORIAL");
@@ -36,15 +37,19 @@ char start_menu(char *type)
 		dtext(16, Y_POS + (selection * 12), C_BLACK, ">");
 		dupdate();
 		if (keydown_any(KEY_SHIFT, KEY_EXE, 0)) {
-			if(!buffer2) return selection;
-		}
-		else buffer2 = 0;
-		if(keydown_any(KEY_EXIT, KEY_MENU, 0)) {
-			if(!buffer) return -1;
-		}
-		else buffer = 0;
-		if(keydown_all(KEY_5,KEY_6)) *type = 3;
-		while (keydown_any(KEY_UP, KEY_DOWN, 0)) clearevents();
+			if (!buffer2)
+				return selection;
+		} else
+			buffer2 = 0;
+		if (keydown_any(KEY_EXIT, KEY_MENU, 0)) {
+			if (!buffer)
+				return -1;
+		} else
+			buffer = 0;
+		if (keydown_all(KEY_5, KEY_6))
+			*type = 3;
+		while (keydown_any(KEY_UP, KEY_DOWN, 0))
+			clearevents();
 	}
 	return selection;
 }
@@ -52,54 +57,61 @@ char start_menu(char *type)
 char speed_menu(int *id_level)
 {
 	char level[351];
-	char gravity = 0; //0 down 1 up
+	char gravity = 0; // 0 down 1 up
 	int start_x;
 	int start_y;
 	char buffer = 1;
 	int appear = 10;
 	int disappear = 13;
-	int sto = loadtime(*id_level-1);
+	int sto = loadtime(*id_level - 1);
 	char menu_loop = 1;
 	char check = 1;
 	extern bopti_image_t img_speedrun;
-	
-	while(menu_loop)
-	{
+
+	while (menu_loop) {
 		clearevents();
 		dclear(C_WHITE);
 		*id_level += keydown(KEY_RIGHT) - keydown(KEY_LEFT);
-		if (*id_level == LEVEL_MAX+1) *id_level = 1;
-		else if (*id_level == 0) *id_level = LEVEL_MAX;
-		if(keydown(KEY_RIGHT) || keydown(KEY_LEFT)) sto = loadtime(*id_level-1);
-		set_level(*id_level, level, &start_x, &start_y, &gravity, &appear, &disappear);
+		if (*id_level == LEVEL_MAX + 1)
+			*id_level = 1;
+		else if (*id_level == 0)
+			*id_level = LEVEL_MAX;
+		if (keydown(KEY_RIGHT) || keydown(KEY_LEFT))
+			sto = loadtime(*id_level - 1);
+		set_level(*id_level, level, &start_x, &start_y, &gravity,
+		          &appear, &disappear);
 		draw_level(level);
-		dimage(0,0,&img_speedrun);
-		if(sto != 0) check_medal(round(sto*0.01*FPS), *id_level, 335, 8);
+		dimage(0, 0, &img_speedrun);
+		if (sto != 0)
+			check_medal(round(sto * 0.01 * FPS), *id_level, 335, 8);
 		dtext(340, 214, C_BLACK, "TIMES");
 		dtext(190, 45, C_BLACK, "Time : ");
-		dprint(80,20,C_BLACK,"Level : %d",*id_level);
-		if(sto != 0) dprint(194,60,C_RED, "%.2j", sto);
-		else dprint(202,60,C_RED, "/");
-		if(*id_level == 14) dprint_opt(180, 8, C_RGB(0,255,255), C_BLACK, DTEXT_LEFT, DTEXT_TOP, "VVVVVV");
+		dprint(80, 20, C_BLACK, "Level : %d", *id_level);
+		if (sto != 0)
+			dprint(194, 60, C_RED, "%.2j", sto);
+		else
+			dprint(202, 60, C_RED, "/");
+		if (*id_level == 14)
+			dprint_opt(180, 8, C_RGB(0, 255, 255), C_BLACK,
+			           DTEXT_LEFT, DTEXT_TOP, "VVVVVV");
 		dupdate();
-		if (keydown_any(KEY_SHIFT, KEY_EXE, 0))
-		{
-			if(!check)
-			{
+		if (keydown_any(KEY_SHIFT, KEY_EXE, 0)) {
+			if (!check) {
 				del_level(level);
 				return 0;
 			}
-		}
-		else check = 0;
-		if (keydown(KEY_F6))
-		{
+		} else
+			check = 0;
+		if (keydown(KEY_F6)) {
 			draw_time(*id_level);
 		}
-		if(keydown_any(KEY_EXIT, KEY_MENU, 0)) {
-			if(!buffer) return 1;
-		}
-		else buffer = 0;
-		while (keydown_any(KEY_RIGHT, KEY_LEFT, 0)) clearevents();
+		if (keydown_any(KEY_EXIT, KEY_MENU, 0)) {
+			if (!buffer)
+				return 1;
+		} else
+			buffer = 0;
+		while (keydown_any(KEY_RIGHT, KEY_LEFT, 0))
+			clearevents();
 	}
 	return 0;
 }
diff --git a/src/save.c b/src/save.c
old mode 100755
new mode 100644
index 600994e..5ab16dc
--- a/src/save.c
+++ b/src/save.c
@@ -1,7 +1,7 @@
-#include <gint/bfile.h>
-#include <gint/gint.h>
 #include "define.h"
 #include "drawlevel.h"
+#include <gint/bfile.h>
+#include <gint/gint.h>
 #include <gint/keyboard.h>
 
 int retcode;
@@ -16,7 +16,7 @@ static const uint16_t *filepath = u"\\\\fls0\\AST3.sav";
 void savefile(void)
 {
 	int descriptor;
-	
+
 	descriptor = BFile_Open(filepath, BFile_WriteOnly);
 	BFile_Write(descriptor, times, sizeof(times));
 	BFile_Close(descriptor);
@@ -30,8 +30,8 @@ void loadfile(void)
 {
 	int descriptor;
 	descriptor = BFile_Open(filepath, BFile_ReadOnly);
-	BFile_Read(descriptor, &retcode,
-	           sizeof(times[0]), sizeof(times[0]) * id_leveltab);
+	BFile_Read(descriptor, &retcode, sizeof(times[0]),
+	           sizeof(times[0]) * id_leveltab);
 	BFile_Close(descriptor);
 }
 
@@ -40,9 +40,8 @@ void loadfile(void)
  * savefile() else, nothing append to avoid loading time. */
 void savetimes(float framelevel, int id_level)
 {
-	if(times[id_level - 1] > (int)(framelevel / FPS * 100) ||
-	   times[id_level - 1] == 0 || keydown(KEY_7)) 
-	{
+	if (times[id_level - 1] > (int)(framelevel / FPS * 100) ||
+	    times[id_level - 1] == 0 || keydown(KEY_7)) {
 		times[id_level - 1] = (int)(framelevel / FPS * 100);
 		draw_end((int)framelevel, id_level, 1);
 		gint_switch(savefile);
@@ -59,9 +58,10 @@ void restore(void)
 	uint16_t foundpath[30];
 	int size = sizeof(times);
 	int descriptor;
-	char checkfile = BFile_FindFirst(filepath, &handle, foundpath, &fileInfo);
+	char checkfile =
+	    BFile_FindFirst(filepath, &handle, foundpath, &fileInfo);
 	BFile_FindClose(handle);
-	if(checkfile == -1)
+	if (checkfile == -1)
 		BFile_Create(filepath, BFile_File, &size);
 	else {
 		descriptor = BFile_Open(filepath, BFile_ReadOnly);