diff --git a/crc.c b/crc.c
index 250bf09..a60efdc 100644
--- a/crc.c
+++ b/crc.c
@@ -1,69 +1,67 @@
 #include <stdio.h>
 
 unsigned long CRCTable[256];
-int CRCTable_initialized=0;
+int CRCTable_initialized = 0;
 
 #define CRC32_POLYNOMIAL     0xEDB88320L
 
-void CRCTable_Init(){
-    int i;
-    int j;
-    unsigned long crc;
+void CRCTable_Init() {
+	int i;
+	int j;
+	unsigned long crc;
 
-	if(CRCTable_initialized){
+	if (CRCTable_initialized) {
 		return;
 	}
-	CRCTable_initialized=1;
+	CRCTable_initialized = 1;
 
-    for (i=0;i<256;i++){
-        crc=i;
-        for (j=8;j>0;j--){
-            if (crc&1)
-                crc=(crc>>1)^CRC32_POLYNOMIAL;
-            else
-                crc>>=1;
-        }
-        CRCTable[i]=crc;
-    }
+	for (i = 0; i < 256; i++) {
+		crc = i;
+		for (j = 8; j > 0; j--) {
+			if (crc & 1)
+				crc = (crc >> 1) ^ CRC32_POLYNOMIAL;
+			else
+				crc >>= 1;
+		}
+		CRCTable[i] = crc;
+	}
 }
 
-
-unsigned long CRC_Buffer(unsigned char *buffer,int len,unsigned long crc){
-    unsigned char *p;
-    unsigned long temp1;
-    unsigned long temp2;
+unsigned long CRC_Buffer(unsigned char *buffer, int len, unsigned long crc) {
+	unsigned char *p;
+	unsigned long temp1;
+	unsigned long temp2;
 
 	// Calcular CRC del buffer
-	p=(unsigned char*)buffer;
-	while(len--!=0) {
-		temp1=(crc>>8)&0x00FFFFFFL;
-		temp2=CRCTable[((int)crc^*p++)&0xff];
-		crc=temp1^temp2;
+	p = (unsigned char*) buffer;
+	while (len-- != 0) {
+		temp1 = (crc >> 8) & 0x00FFFFFFL;
+		temp2 = CRCTable[((int) crc ^ *p++) & 0xff];
+		crc = temp1 ^ temp2;
 	}
 
-	return(crc);
+	return (crc);
 }
 
-
-unsigned long CRC_File(FILE *file){
-    unsigned long crc;
-    int count;
-    unsigned char buffer[512];
-    unsigned char *p;
-    unsigned long temp1;
-    unsigned long temp2;
+unsigned long CRC_File(FILE *file) {
+	unsigned long crc;
+	int count;
+	unsigned char buffer[512];
+	unsigned char *p;
+	unsigned long temp1;
+	unsigned long temp2;
 
 	CRCTable_Init();
 
-    crc=0xFFFFFFFFL;
-    for(;;){
+	crc = 0xFFFFFFFFL;
+	for (;;) {
 		// Llenar el buffer
-        count=fread(buffer,1,512,file);
-        if(count==0)
-            break;
+		count = fread(buffer, 1, 512, file);
+		if (count == 0)
+			break;
 
 		// Calcular CRC del buffer
-		crc=CRC_Buffer(buffer,count,crc);
-    }
-    return(crc^=0xFFFFFFFFL);
+		crc = CRC_Buffer(buffer, count, crc);
+	}
+	return (crc ^= 0xFFFFFFFFL);
 }
diff --git a/crc.h b/crc.h
index b897705..82f9ef4 100644
--- a/crc.h
+++ b/crc.h
@@ -3,7 +3,7 @@
 
 #include <stdio.h>
 
-unsigned long CRC_Buffer(unsigned char *buffer,int len,unsigned long crc);
+unsigned long CRC_Buffer(unsigned char *buffer, int len, unsigned long crc);
 unsigned long CRC_File(FILE *file);
 
 #endif
diff --git a/filenode.c b/filenode.c
index 62d1a4e..9eedd11 100644
--- a/filenode.c
+++ b/filenode.c
@@ -7,547 +7,504 @@
 #include "fileutil.h"
 #include "filenode.h"
 
-
-
-FileNode *_free_filenode=NULL;
-int _n_filenode=0;
+FileNode *_free_filenode = NULL;
+int _n_filenode = 0;
 #define FileNode_Tocho 1024
-FileNode *FileNode_New(){
+FileNode *FileNode_New() {
 	FileNode *fn;
 
-	if(_free_filenode==NULL){
+	if (_free_filenode == NULL ) {
 		FileNode *nodos;
 		int i;
 		// Reservar un tocho
-		nodos=malloc(sizeof(FileNode)*FileNode_Tocho);
-		for(i=0;i<FileNode_Tocho-1;i++){
-			nodos[i].sig=&nodos[i+1];
+		nodos = malloc(sizeof(FileNode) * FileNode_Tocho);
+		for (i = 0; i < FileNode_Tocho - 1; i++) {
+			nodos[i].sig = &nodos[i + 1];
 		}
-		nodos[FileNode_Tocho-1].sig=NULL;
-		_free_filenode=&nodos[0];
+		nodos[FileNode_Tocho - 1].sig = NULL;
+		_free_filenode = &nodos[0];
 	}
 
 	// Obtener el primero libre
-	fn=_free_filenode;
-	_free_filenode=fn->sig;
+	fn = _free_filenode;
+	_free_filenode = fn->sig;
 	_n_filenode++;
 
 	// Iniciar
-	fn->name[0]=0;
-	fn->flags=0;
-	fn->estado=EstadoFichero_Nada;
-	fn->size=0;
-	fn->crc=0;
-	fn->ft=0;
-	fn->child=NULL;
-	fn->n_childs=0;
-	fn->sig=NULL;
-	fn->padre=NULL;
+	fn->name[0] = 0;
+	fn->flags = 0;
+	fn->estado = EstadoFichero_Nada;
+	fn->size = 0;
+	fn->crc = 0;
+	fn->ft = 0;
+	fn->child = NULL;
+	fn->n_childs = 0;
+	fn->sig = NULL;
+	fn->padre = NULL;
 
-	return(fn);
+	return (fn);
 }
 
-void FileNode_Delete(FileNode *fn){
-	fn->sig=_free_filenode;
-	_free_filenode=fn;
+void FileNode_Delete(FileNode *fn) {
+	fn->sig = _free_filenode;
+	_free_filenode = fn;
 	_n_filenode--;
 }
 
-void FileNode_AddChild(FileNode *file,FileNode *file2){
-	if(!file2 || !file)
+void FileNode_AddChild(FileNode *file, FileNode *file2) {
+	if (!file2 || !file)
 		return;
-	file2->sig=file->child;
-	file->child=file2;
+	file2->sig = file->child;
+	file->child = file2;
 	file->n_childs++;
-	file2->padre=file;
+	file2->padre = file;
 }
 
-
-void FileNode_SetEstadoRec(FileNode *file,EstadoFichero estado){
+void FileNode_SetEstadoRec(FileNode *file, EstadoFichero estado) {
 	FileNode *fn_child;
-	file->estado=estado;
-	fn_child=file->child;
-	while(fn_child!=NULL){
-		FileNode_SetEstadoRec(fn_child,estado);
-		fn_child=fn_child->sig;
+	file->estado = estado;
+	fn_child = file->child;
+	while (fn_child != NULL ) {
+		FileNode_SetEstadoRec(fn_child, estado);
+		fn_child = fn_child->sig;
 	}
 }
 
-void FileNode_GetPath_Rec(FileNode *fn,char **pathnode){
-	if(fn->padre){
-		pathnode[0]=fn->padre->name;
-		FileNode_GetPath_Rec(fn->padre,pathnode+1);
-	}else{
-		pathnode[0]=NULL;
+void FileNode_GetPath_Rec(FileNode *fn, char **pathnode) {
+	if (fn->padre) {
+		pathnode[0] = fn->padre->name;
+		FileNode_GetPath_Rec(fn->padre, pathnode + 1);
+	} else {
+		pathnode[0] = NULL;
 	}
 }
 char temppath[MaxPath];
-char *FileNode_GetPath(FileNode *fn,char *path){
+char *FileNode_GetPath(FileNode *fn, char *path) {
 	char *pathnodes[128];
-	int levels,i;
-	char *pathptr=temppath;
-	if(path)pathptr=path;
+	int levels, i;
+	char *pathptr = temppath;
+	if (path)
+		pathptr = path;
 
-	FileNode_GetPath_Rec(fn,pathnodes);
-	levels=0;while(pathnodes[levels]){levels++;}
-	strcpy(pathptr,"");
-	for(i=levels-1;i>=0;i--){
-		strcat(pathptr,pathnodes[i]);
-		strcat(pathptr,"/");
+	FileNode_GetPath_Rec(fn, pathnodes);
+	levels = 0;
+	while (pathnodes[levels]) {
+		levels++;
 	}
-	strcat(pathptr,fn->name);
+	strcpy(pathptr, "");
+	for (i = levels - 1; i >= 0; i--) {
+		strcat(pathptr, pathnodes[i]);
+		strcat(pathptr, "/");
+	}
+	strcat(pathptr, fn->name);
 	return temppath;
 }
-char *FileNode_GetFullPath(FileNode *fn,char *basePath,char *path){
+char *FileNode_GetFullPath(FileNode *fn, char *basePath, char *path) {
 	char *pathnodes[128];
-	int levels,i;
-	char *pathptr=temppath;
-	if(path)pathptr=path;
+	int levels, i;
+	char *pathptr = temppath;
+	if (path)
+		pathptr = path;
 
-	FileNode_GetPath_Rec(fn,pathnodes);
-	levels=0;while(pathnodes[levels]){levels++;}
-	strcpy(pathptr,basePath);
-	strcat(pathptr,"/");
-	for(i=levels-2;i>=0;i--){
-		strcat(pathptr,pathnodes[i]);
-		strcat(pathptr,"/");
+	FileNode_GetPath_Rec(fn, pathnodes);
+	levels = 0;
+	while (pathnodes[levels]) {
+		levels++;
 	}
-	strcat(pathptr,fn->name);
+	strcpy(pathptr, basePath);
+	strcat(pathptr, "/");
+	for (i = levels - 2; i >= 0; i--) {
+		strcat(pathptr, pathnodes[i]);
+		strcat(pathptr, "/");
+	}
+	strcat(pathptr, fn->name);
 	return temppath;
 }
 
-
-
-void FileNode_GetTamanho(FileNode *fn,char *file){
-	fn->flags|=FileFlag_TieneTamanho;
-	fn->size=File_TamanhoFichero(file);
+void FileNode_GetTamanho(FileNode *fn, char *file) {
+	fn->flags |= FileFlag_TieneTamanho;
+	fn->size = File_TamanhoFichero(file);
 }
 
-void FileNode_GetFecha(FileNode *fn,char *file){
-	fn->flags|=FileFlag_TieneFecha;
-	fn->ft=FileTime_Get(file);
+void FileNode_GetFecha(FileNode *fn, char *file) {
+	fn->flags |= FileFlag_TieneFecha;
+	fn->ft = FileTime_Get(file);
 }
 
-void FileNode_GetCRC(FileNode *fn,char *file){
+void FileNode_GetCRC(FileNode *fn, char *file) {
 	FILE *f;
-	f=fopen(file,"rb");
-	if(!f){ return; }
-	fn->flags|=FileFlag_TieneCRC;
-	fn->crc=CRC_File(f);
+	f = fopen(file, "rb");
+	if (!f) {
+		return;
+	}
+	fn->flags |= FileFlag_TieneCRC;
+	fn->crc = CRC_File(f);
 	fclose(f);
 }
 
-
-
-
-
-
-
-void FileNode_SaveNode(FileNode *fn,FILE *file){
+void FileNode_SaveNode(FileNode *fn, FILE *file) {
 	short name_len;
 
 	// Escribir nombre
-	name_len=strlen(fn->name);
-	fwrite((void *)&name_len,sizeof(name_len),1,file);
-	fputs(fn->name,file);
+	name_len = strlen(fn->name);
+	fwrite((void *) &name_len, sizeof(name_len), 1, file);
+	fputs(fn->name, file);
 
 	// Escribir flags
-	fwrite((void *)&fn->flags,sizeof(fn->flags),1,file);
+	fwrite((void *) &fn->flags, sizeof(fn->flags), 1, file);
 
 	// Escribir estado
-	fputc((char)fn->estado,file);
+	fputc((char) fn->estado, file);
 
 	// Escribir tamanho
-	if(fn->flags&FileFlag_TieneTamanho){
-		fwrite((void *)&fn->size,sizeof(fn->size),1,file);
+	if (fn->flags & FileFlag_TieneTamanho) {
+		fwrite((void *) &fn->size, sizeof(fn->size), 1, file);
 	}
 
 	// Escribir fecha
-	if(fn->flags&FileFlag_TieneFecha){
-		fwrite((void *)&fn->ft,sizeof(fn->ft),1,file);
+	if (fn->flags & FileFlag_TieneFecha) {
+		fwrite((void *) &fn->ft, sizeof(fn->ft), 1, file);
 	}
 
 	// Escribir CRC
-	if(fn->flags&FileFlag_TieneCRC){
-		fwrite((void *)&fn->crc,sizeof(fn->crc),1,file);
+	if (fn->flags & FileFlag_TieneCRC) {
+		fwrite((void *) &fn->crc, sizeof(fn->crc), 1, file);
 	}
 
 	// Escribir ficheros del directorio
-	if(fn->flags&FileFlag_Directorio){
+	if (fn->flags & FileFlag_Directorio) {
 		FileNode *fnc;
-		fwrite((void *)&fn->n_childs,sizeof(fn->n_childs),1,file);
-		fnc=fn->child;
-		while(fnc){
-			FileNode_SaveNode(fnc,file);
-			fnc=fnc->sig;
+		fwrite((void *) &fn->n_childs, sizeof(fn->n_childs), 1, file);
+		fnc = fn->child;
+		while (fnc) {
+			FileNode_SaveNode(fnc, file);
+			fnc = fnc->sig;
 		}
 	}
 }
 
-void FileNode_Save(FileNode *fn,char *fichero){
+void FileNode_Save(FileNode *fn, char *fichero) {
 	FILE *file;
 	char marca[5];
 	int version;
 
-	if(!fn)
+	if (!fn)
 		return;
-	file=fopen(fichero,"wb+");
-	if(!file)
+	file = fopen(fichero, "wb+");
+	if (!file)
 		return;
 
 	// Escribir marca y version
-	strcpy(marca,"sYnC");
-	fwrite((void *)marca,sizeof(char),4,file);
-	version=FileNode_Version;
-	fwrite((void *)&version,sizeof(int),1,file);
+	strcpy(marca, "sYnC");
+	fwrite((void *) marca, sizeof(char), 4, file);
+	version = FileNode_Version;
+	fwrite((void *) &version, sizeof(int), 1, file);
 
-
-	FileNode_SaveNode(fn,file);
+	FileNode_SaveNode(fn, file);
 	fclose(file);
 }
 
-
-FileNode *FileNode_LoadNode(FILE *file){
+FileNode *FileNode_LoadNode(FILE *file) {
 	short name_len;
 	FileNode *fn;
 	int i;
 
-	fn=FileNode_New();
+	fn = FileNode_New();
 
 	// Leer el nombre
-	fread((void *)&name_len,sizeof(name_len),1,file);
-	fread((void *)fn->name,sizeof(char),name_len,file);
-	fn->name[name_len]=0;
+	fread((void *) &name_len, sizeof(name_len), 1, file);
+	fread((void *) fn->name, sizeof(char), name_len, file);
+	fn->name[name_len] = 0;
 
 	// Leer vanderas
-	fread((void *)&fn->flags,sizeof(fn->flags),1,file);
+	fread((void *) &fn->flags, sizeof(fn->flags), 1, file);
 
 	// Leer estado
-	fn->estado=fgetc(file);
+	fn->estado = fgetc(file);
 
 	// Leer tamanho
-	if(fn->flags&FileFlag_TieneTamanho){
-		fread((void *)&fn->size,sizeof(fn->size),1,file);
+	if (fn->flags & FileFlag_TieneTamanho) {
+		fread((void *) &fn->size, sizeof(fn->size), 1, file);
 	}
 
 	// Leer fecha
-	if(fn->flags&FileFlag_TieneFecha){
-		fread((void *)&fn->ft,sizeof(fn->ft),1,file);
+	if (fn->flags & FileFlag_TieneFecha) {
+		fread((void *) &fn->ft, sizeof(fn->ft), 1, file);
 	}
 
 	// Leer CRC
-	if(fn->flags&FileFlag_TieneCRC){
-		fread((void *)&fn->crc,sizeof(fn->crc),1,file);
+	if (fn->flags & FileFlag_TieneCRC) {
+		fread((void *) &fn->crc, sizeof(fn->crc), 1, file);
 	}
 
 	// Leer ficheros del directorio
-	if(fn->flags&FileFlag_Directorio){
-		FileNode *fnca=NULL,*fnc;
-		fread((void *)&fn->n_childs,sizeof(fn->n_childs),1,file);
-		for(i=0;i<fn->n_childs;i++){
-			fnc=FileNode_LoadNode(file);
-			fnc->padre=fn;
-			if(!fnca){
-				fn->child=fnc;
-			}else{
-				fnca->sig=fnc;
+	if (fn->flags & FileFlag_Directorio) {
+		FileNode *fnca = NULL, *fnc;
+		fread((void *) &fn->n_childs, sizeof(fn->n_childs), 1, file);
+		for (i = 0; i < fn->n_childs; i++) {
+			fnc = FileNode_LoadNode(file);
+			fnc->padre = fn;
+			if (!fnca) {
+				fn->child = fnc;
+			} else {
+				fnca->sig = fnc;
 			}
-			fnca=fnc;
+			fnca = fnc;
 		}
 	}
 
-	return(fn);
+	return (fn);
 }
 
-
-FileNode *FileNode_Load(char *fichero){
+FileNode *FileNode_Load(char *fichero) {
 	FILE *file;
 	FileNode *fn;
 	char marca[5];
 	int version;
 
-	file=fopen(fichero,"rb");
-	if(!file)
-		return(NULL);
+	file = fopen(fichero, "rb");
+	if (!file)
+		return (NULL );
 
 	// Leer marca y version
-	fread((void *)marca,sizeof(char),4,file);
-	marca[4]=0;
-	if(strcmp(marca,"sYnC")){
+	fread((void *) marca, sizeof(char), 4, file);
+	marca[4] = 0;
+	if (strcmp(marca, "sYnC")) {
 		// Marca incorrecta
 		fclose(file);
-		return(NULL);
+		return (NULL );
 	}
-	fread((void *)&version,sizeof(int),1,file);
-	if(version!=FileNode_Version){
+	fread((void *) &version, sizeof(int), 1, file);
+	if (version != FileNode_Version) {
 		// Version incorrecta
 		fclose(file);
-		return(NULL);
+		return (NULL );
 	}
 
-
-	fn=FileNode_LoadNode(file);
+	fn = FileNode_LoadNode(file);
 	fclose(file);
 
-	return(fn);
+	return (fn);
 }
 
-
-void FileNode_PrintNode(FileNode *fn){
-	printf(FileNode_GetPath(fn,NULL));
-	if(fn->flags&FileFlag_Normal){
+void FileNode_PrintNode(FileNode *fn) {
+	printf(FileNode_GetPath(fn, NULL ));
+	if (fn->flags & FileFlag_Normal) {
 		printf(" File");
-	}else{
+	} else {
 		printf(" Dir");
 	}
-	printf(" %d",fn->estado);
-	if(fn->estado==EstadoFichero_Nuevo){
+	printf(" %d", fn->estado);
+	if (fn->estado == EstadoFichero_Nuevo) {
 		printf(" Nuevo");
 	}
-	if(fn->estado==EstadoFichero_Modificado){
+	if (fn->estado == EstadoFichero_Modificado) {
 		printf(" Modificado");
 	}
-	if(fn->estado==EstadoFichero_Borrado){
+	if (fn->estado == EstadoFichero_Borrado) {
 		printf(" Borrado!!!");
 	}
 	printf("\n");
 
-/*
-	// Tamanho
-	if(fn->flags&FileFlag_TieneTamanho){
-		printf("\\-Tamanho: %lld\n",fn->size);
-	}
+	/*
+	 // Tamanho
+	 if(fn->flags&FileFlag_TieneTamanho){
+	 printf("\\-Tamanho: %lld\n",fn->size);
+	 }
 
-	// Fecha
-	if(fn->flags&FileFlag_TieneFecha){
-		printf("\\-Fecha  : ");FileTime_Print(fn->ft);printf("\n");
-	}
+	 // Fecha
+	 if(fn->flags&FileFlag_TieneFecha){
+	 printf("\\-Fecha  : ");FileTime_Print(fn->ft);printf("\n");
+	 }
 
-	// CRC
-	if(fn->flags&FileFlag_TieneCRC){
-		printf("\\-CRC    : [%08X]\n",fn->crc);
-	}
-*/
+	 // CRC
+	 if(fn->flags&FileFlag_TieneCRC){
+	 printf("\\-CRC    : [%08X]\n",fn->crc);
+	 }
+	 */
 }
 
+void FileNode_Print(FileNode *fn) {
+	FileNode *fnAux = fn;
+	int end = 0;
 
-void FileNode_Print(FileNode *fn){
-	FileNode *fnAux=fn;
-	int end=0;
+	while (fnAux != NULL && !end) {
 
-	while(fnAux!=NULL && !end){
-
-		if(fnAux->padre!=NULL){
+		if (fnAux->padre != NULL ) {
 			FileNode_PrintNode(fnAux);
 		}
 
-		if(fnAux->child){
-			fnAux=fnAux->child;
-		}else{
-			while(fnAux->sig==NULL){
-				fnAux=fnAux->padre;
-				if(fnAux==fn || fnAux==NULL){
+		if (fnAux->child) {
+			fnAux = fnAux->child;
+		} else {
+			while (fnAux->sig == NULL ) {
+				fnAux = fnAux->padre;
+				if (fnAux == fn || fnAux == NULL ) {
 					printf("End\n");
-					end=1;
+					end = 1;
 					break;
 				}
 			}
-			if(!end){
-				fnAux=fnAux->sig;
+			if (!end) {
+				fnAux = fnAux->sig;
 			}
 		}
 	}
 }
 
+int FileNode_Build_Iterate(char *path, char *name, void *d);
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-int FileNode_Build_Iterate(char *path,char *name,void *d);
-
-FileNode *FileNode_Build(char *path){
+FileNode *FileNode_Build(char *path) {
 	FileNode *file;
 
-	if(!File_ExistePath(path))
-		return(NULL);
+	if (!File_ExistePath(path))
+		return (NULL );
 
 	// Crear el nodo
-	file=FileNode_New();
-	File_GetName(path,file->name);
+	file = FileNode_New();
+	File_GetName(path, file->name);
 
 	// Determinar si es un fichero o directorio
-	if(File_EsDirectorio(path)){
+	if (File_EsDirectorio(path)) {
 		// Obtener datos para los directorios
-		file->flags|=FileFlag_Directorio;
-		FileNode_GetFecha(file,path);
-		File_IterateDir(path,FileNode_Build_Iterate,file);
-	}else{
+		file->flags |= FileFlag_Directorio;
+		FileNode_GetFecha(file, path);
+		File_IterateDir(path, FileNode_Build_Iterate, file);
+	} else {
 		// Obtener datos para los ficheros
-		file->flags|=FileFlag_Normal;
-		FileNode_GetTamanho(file,path);
-		FileNode_GetFecha(file,path);
+		file->flags |= FileFlag_Normal;
+		FileNode_GetTamanho(file, path);
+		FileNode_GetFecha(file, path);
 	}
 
-	return(file);
+	return (file);
 }
 
+int FileNode_Build_Iterate(char *path, char *name, void *d) {
+	FileNode *file, *fn_padre = d;
+	;
 
-int FileNode_Build_Iterate(char *path,char *name,void *d){
-	FileNode *file,*fn_padre=d;;
-
-	if(!strcmp(name,FileNode_Filename)){
-		return(0);
+	if (!strcmp(name, FileNode_Filename)) {
+		return (0);
 	}
 
-	file=FileNode_Build(path);
-	FileNode_AddChild(fn_padre,file);
+	file = FileNode_Build(path);
+	FileNode_AddChild(fn_padre, file);
 
-	return(0);
+	return (0);
 }
 
+int FileNode_Refresh_Iterate(char *path, char *name, void *d);
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-int FileNode_Refresh_Iterate(char *path,char *name,void *d);
-
-FileNode *FileNode_Refresh(FileNode *fn,char *path){
-	if(!File_ExistePath(path)){
+FileNode *FileNode_Refresh(FileNode *fn, char *path) {
+	if (!File_ExistePath(path)) {
 		// El fichero/directorio ha sido borrado
-		if(!fn){
-			fn=FileNode_New();
-			File_GetName(path,fn->name);
+		if (!fn) {
+			fn = FileNode_New();
+			File_GetName(path, fn->name);
 		}
-		FileNode_SetEstadoRec(fn,EstadoFichero_Borrado);
-		return(fn);
+		FileNode_SetEstadoRec(fn, EstadoFichero_Borrado);
+		return (fn);
 	}
-	if(!fn){
+	if (!fn) {
 		// El fichero ha sido creado
-		fn=FileNode_Build(path);
-		FileNode_SetEstadoRec(fn,EstadoFichero_Nuevo);
-	}else{
+		fn = FileNode_Build(path);
+		FileNode_SetEstadoRec(fn, EstadoFichero_Nuevo);
+	} else {
 		// Comprobar si ha sido modificado
 		FileTime ft;
 		long long size;
 		int crc;
 
 		// Marcar normal
-		fn->estado=EstadoFichero_Nada;
-		fn->flags&=~FileFlag_MarcaRevision;
+		fn->estado = EstadoFichero_Nada;
+		fn->flags &= ~FileFlag_MarcaRevision;
 
 		// Determinar si es un fichero o directorio
-		if(File_EsDirectorio(path)){
+		if (File_EsDirectorio(path)) {
 			FileNode *fn_child;
 
 			// Comparar datos de los directorios
-			if(!(fn->flags&FileFlag_Directorio)){
-				fn->estado=EstadoFichero_Modificado;
-				fn->flags|=FileFlag_Directorio;
-				fn->flags&=~FileFlag_Normal;
+			if (!(fn->flags & FileFlag_Directorio)) {
+				fn->estado = EstadoFichero_Modificado;
+				fn->flags |= FileFlag_Directorio;
+				fn->flags &= ~FileFlag_Normal;
 			}
-			ft=FileTime_Get(path);
-			if(ft!=fn->ft){
-				fn->estado=EstadoFichero_Modificado;
-				fn->ft=ft;
+			ft = FileTime_Get(path);
+			if (ft != fn->ft) {
+				fn->estado = EstadoFichero_Modificado;
+				fn->ft = ft;
 			}
 
 			// Marcar hijos para determinar cual es actualizado
-			fn_child=fn->child;while(fn_child){
-				fn_child->flags|=FileFlag_MarcaRevision;
-				fn_child=fn_child->sig;
+			fn_child = fn->child;
+			while (fn_child) {
+				fn_child->flags |= FileFlag_MarcaRevision;
+				fn_child = fn_child->sig;
 			}
 
 			// Escanear subdirectorios
-			File_IterateDir(path,FileNode_Refresh_Iterate,fn);
+			File_IterateDir(path, FileNode_Refresh_Iterate, fn);
 
 			// Buscar que sigan marcados (borrados)
-			fn_child=fn->child;while(fn_child){
-				if(fn_child->flags&FileFlag_MarcaRevision){
-					fn_child->flags&=~FileFlag_MarcaRevision;
-					FileNode_SetEstadoRec(fn_child,EstadoFichero_Borrado);
+			fn_child = fn->child;
+			while (fn_child) {
+				if (fn_child->flags & FileFlag_MarcaRevision) {
+					fn_child->flags &= ~FileFlag_MarcaRevision;
+					FileNode_SetEstadoRec(fn_child, EstadoFichero_Borrado);
 				}
-				fn_child=fn_child->sig;
+				fn_child = fn_child->sig;
 			}
-		}else{
+		} else {
 			// Comprar datos de los ficheros
-			if(!(fn->flags&FileFlag_Normal)){
-				fn->estado=EstadoFichero_Modificado;
-				fn->flags|=FileFlag_Normal;
-				fn->flags&=~FileFlag_Directorio;
+			if (!(fn->flags & FileFlag_Normal)) {
+				fn->estado = EstadoFichero_Modificado;
+				fn->flags |= FileFlag_Normal;
+				fn->flags &= ~FileFlag_Directorio;
 			}
-			size=File_TamanhoFichero(path);
-			if(size!=fn->size){
-				fn->estado=EstadoFichero_Modificado;
-				fn->size=size;
+			size = File_TamanhoFichero(path);
+			if (size != fn->size) {
+				fn->estado = EstadoFichero_Modificado;
+				fn->size = size;
 			}
-			ft=FileTime_Get(path);
-			if(ft!=fn->ft){
-				fn->estado=EstadoFichero_Modificado;
-				fn->ft=ft;
+			ft = FileTime_Get(path);
+			if (ft != fn->ft) {
+				fn->estado = EstadoFichero_Modificado;
+				fn->ft = ft;
 			}
-			if(fn->estado==EstadoFichero_Modificado){
-				fn->flags&=~FileFlag_TieneCRC;
+			if (fn->estado == EstadoFichero_Modificado) {
+				fn->flags &= ~FileFlag_TieneCRC;
 			}
 		}
 	}
-	return(fn);
+	return (fn);
 }
 
-int FileNode_Refresh_Iterate(char *path,char *name,void *d){
-	FileNode *fn=d;
+int FileNode_Refresh_Iterate(char *path, char *name, void *d) {
+	FileNode *fn = d;
 	FileNode *fn_child;
 
-	if(!strcmp(name,FileNode_Filename)){
-		return(0);
+	if (!strcmp(name, FileNode_Filename)) {
+		return (0);
 	}
 
 	// Buscar el fichero entre los del arbol
-	fn_child=fn->child;
-	while(fn_child){
-		if(!strcmp(fn_child->name,name)){
+	fn_child = fn->child;
+	while (fn_child) {
+		if (!strcmp(fn_child->name, name)) {
 			break;
 		}
-		fn_child=fn_child->sig;
+		fn_child = fn_child->sig;
 	}
-	if(fn_child){
+	if (fn_child) {
 		// Existe, refrescar
-		FileNode_Refresh(fn_child,path);
-	}else{
+		FileNode_Refresh(fn_child, path);
+	} else {
 		// Nuevo, construir
-		fn_child=FileNode_Refresh(NULL,path);
-		FileNode_AddChild(fn,fn_child);
+		fn_child = FileNode_Refresh(NULL, path);
+		FileNode_AddChild(fn, fn_child);
 	}
 
-	return(0);
+	return (0);
 }
 
-
-
-
-
-
-
-
-
-
diff --git a/filenode.h b/filenode.h
index 7a37064..623c053 100644
--- a/filenode.h
+++ b/filenode.h
@@ -20,7 +20,7 @@ typedef enum {
 	EstadoFichero_Borrado
 } EstadoFichero;
 
-typedef struct FileNode_Tag{
+typedef struct FileNode_Tag {
 	char name[MaxFilename];
 
 	int flags;
@@ -42,24 +42,22 @@ typedef struct FileNode_Tag{
 
 FileNode *FileNode_New();
 void FileNode_Delete(FileNode *fn);
-void FileNode_AddChild(FileNode *file,FileNode *file2);
+void FileNode_AddChild(FileNode *file, FileNode *file2);
 
-char *FileNode_GetFullPath(FileNode *fn,char *basePath,char *path);
+char *FileNode_GetFullPath(FileNode *fn, char *basePath, char *path);
 
-void FileNode_GetTamanho(FileNode *fn,char *file);
-void FileNode_GetFecha(FileNode *fn,char *file);
-void FileNode_GetCRC(FileNode *fn,char *file);
+void FileNode_GetTamanho(FileNode *fn, char *file);
+void FileNode_GetFecha(FileNode *fn, char *file);
+void FileNode_GetCRC(FileNode *fn, char *file);
 
-void FileNode_Save(FileNode *fn,char *fichero);
+void FileNode_Save(FileNode *fn, char *fichero);
 FileNode *FileNode_Load(char *fichero);
 
 void FileNode_PrintNode(FileNode *fn);
 void FileNode_Print(FileNode *fn);
 
-
 FileNode *FileNode_Build(char *path);
 
-FileNode *FileNode_Refresh(FileNode *file,char *path);
-
+FileNode *FileNode_Refresh(FileNode *file, char *path);
 
 #endif
diff --git a/filenodecmp.c b/filenodecmp.c
index 51d8875..34fbc45 100644
--- a/filenodecmp.c
+++ b/filenodecmp.c
@@ -8,413 +8,392 @@
 #include "filenode.h"
 #include "filenodecmp.h"
 
-AccionFileNode *_free_accionfilenode=NULL;
-int _n_accionfilenode=0;
+AccionFileNode *_free_accionfilenode = NULL;
+int _n_accionfilenode = 0;
 #define AccionFileNode_Tocho 1024
-AccionFileNode *AccionFileNode_Crear(){
+AccionFileNode *AccionFileNode_Crear() {
 	AccionFileNode *afn;
 
-	if(_free_accionfilenode==NULL){
+	if (_free_accionfilenode == NULL ) {
 		AccionFileNode *nodos;
 		int i;
 		// Reservar un tocho
-		nodos=malloc(sizeof(AccionFileNode)*AccionFileNode_Tocho);
-		for(i=0;i<AccionFileNode_Tocho-1;i++){
-			nodos[i].sig=&nodos[i+1];
+		nodos = malloc(sizeof(AccionFileNode) * AccionFileNode_Tocho);
+		for (i = 0; i < AccionFileNode_Tocho - 1; i++) {
+			nodos[i].sig = &nodos[i + 1];
 		}
-		nodos[AccionFileNode_Tocho-1].sig=NULL;
-		_free_accionfilenode=&nodos[0];
+		nodos[AccionFileNode_Tocho - 1].sig = NULL;
+		_free_accionfilenode = &nodos[0];
 	}
 
 	// Obtener el primero libre
-	afn=_free_accionfilenode;
-	_free_accionfilenode=afn->sig;
+	afn = _free_accionfilenode;
+	_free_accionfilenode = afn->sig;
 	_n_accionfilenode++;
 
 	// Iniciar
-	afn->accion=AccionFileCmp_Nada;
-	afn->izquierda=NULL;
-	afn->derecha=NULL;
-	afn->sig=NULL;
+	afn->accion = AccionFileCmp_Nada;
+	afn->izquierda = NULL;
+	afn->derecha = NULL;
+	afn->sig = NULL;
 
-	return(afn);
+	return (afn);
 }
 
-
-void AccionFileNode_Destruir(AccionFileNode *afn){
-	afn->sig=_free_accionfilenode;
-	_free_accionfilenode=afn;
+void AccionFileNode_Destruir(AccionFileNode *afn) {
+	afn->sig = _free_accionfilenode;
+	_free_accionfilenode = afn;
 	_n_accionfilenode--;
 }
 
-AccionFileNode *AccionFileNode_CrearNormal(FileNode *fnIzq,FileNode *fnDer)
-{
+AccionFileNode *AccionFileNode_CrearNormal(FileNode *fnIzq, FileNode *fnDer) {
 	AccionFileNode *afnNew;
-	afnNew=AccionFileNode_Crear();
-	afnNew->accion=AccionFileCmp_Nada;
-	afnNew->izquierda=fnIzq;
-	afnNew->derecha=fnDer;
+	afnNew = AccionFileNode_Crear();
+	afnNew->accion = AccionFileCmp_Nada;
+	afnNew->izquierda = fnIzq;
+	afnNew->derecha = fnDer;
 	return afnNew;
 }
 
-void AccionFileNode_CompareChilds(
-	AccionFileNode *afnRaiz,
-	AccionFileNode **afnCola,
-	void (*CheckPair)(FileNode *fnIzq,FileNode *fnDer,AccionFileNode **afnCola))
-{
-	FileNode *fnIzq,*fnDer;
-	AccionFileNode *afnColaStart=(*afnCola);
+void AccionFileNode_CompareChilds(AccionFileNode *afnRaiz,
+		AccionFileNode **afnCola,
+		void (*CheckPair)(FileNode *fnIzq, FileNode *fnDer,
+				AccionFileNode **afnCola)) {
+	FileNode *fnIzq, *fnDer;
+	AccionFileNode *afnColaStart = (*afnCola);
 
 	// Comprobar si hay algo que comparar
-	if(!afnRaiz->izquierda && !afnRaiz->derecha){
+	if (!afnRaiz->izquierda && !afnRaiz->derecha) {
 		// Nada que hacer
 		return;
 	}
 
 	// Iterar todos los nodos de la izquierda
-	if(afnRaiz->izquierda){
-		fnIzq=afnRaiz->izquierda->child;
-		while(fnIzq){
-			if(afnRaiz->derecha){
-				fnDer=afnRaiz->derecha->child;
-				while(fnDer){
-					if(!strcmp(fnIzq->name,fnDer->name)){
+	if (afnRaiz->izquierda) {
+		fnIzq = afnRaiz->izquierda->child;
+		while (fnIzq) {
+			if (afnRaiz->derecha) {
+				fnDer = afnRaiz->derecha->child;
+				while (fnDer) {
+					if (!strcmp(fnIzq->name, fnDer->name)) {
 						break;
-					}else{
-						fnDer=fnDer->sig;
+					} else {
+						fnDer = fnDer->sig;
 					}
 				}
-			}else{
-				fnDer=NULL;
+			} else {
+				fnDer = NULL;
 			}
 
-			CheckPair(fnIzq,fnDer,afnCola);
+			CheckPair(fnIzq, fnDer, afnCola);
 
-			fnIzq=fnIzq->sig;
+			fnIzq = fnIzq->sig;
 		}
 	}
 
-
 	// Iterar todos los nodos de la derecha,
 	//   ignorando las comparaciones ya realizadas
-	if(afnRaiz->derecha){
-		fnDer=afnRaiz->derecha->child;
-		while(fnDer){
-			int doCheck=1;
-			if(afnRaiz->izquierda){
-				fnIzq=afnRaiz->izquierda->child;
-				while(fnIzq){
-					AccionFileNode *afnCheck=afnColaStart;
-					while(afnCheck){
-						if(afnCheck->izquierda==fnIzq && afnCheck->derecha==fnDer){
+	if (afnRaiz->derecha) {
+		fnDer = afnRaiz->derecha->child;
+		while (fnDer) {
+			int doCheck = 1;
+			if (afnRaiz->izquierda) {
+				fnIzq = afnRaiz->izquierda->child;
+				while (fnIzq) {
+					AccionFileNode *afnCheck = afnColaStart;
+					while (afnCheck) {
+						if (afnCheck->izquierda == fnIzq
+								&& afnCheck->derecha == fnDer) {
 							break;
-						}else{
-							afnCheck=afnCheck->sig;
+						} else {
+							afnCheck = afnCheck->sig;
 						}
 					}
-					if(afnCheck){
-						doCheck=0;
+					if (afnCheck) {
+						doCheck = 0;
 						break;
 					}
 
-					if(!strcmp(fnIzq->name,fnDer->name)){
+					if (!strcmp(fnIzq->name, fnDer->name)) {
 						break;
-					}else{
-						fnIzq=fnIzq->sig;
+					} else {
+						fnIzq = fnIzq->sig;
 					}
 				}
-			}else{
-				fnIzq=NULL;
+			} else {
+				fnIzq = NULL;
 			}
 
-			if(doCheck){
-				CheckPair(fnIzq,fnDer,afnCola);
+			if (doCheck) {
+				CheckPair(fnIzq, fnDer, afnCola);
 			}
 
-			fnDer=fnDer->sig;
+			fnDer = fnDer->sig;
 		}
 	}
 
 }
 
+void AccionFileNode_DeletePair(FileNode *fnIzq, FileNode *fnDer,
+		AccionFileNode **afnCola) {
+	AccionFileNode *afnNew = AccionFileNode_CrearNormal(fnIzq, fnDer);
 
-
-void AccionFileNode_DeletePair(
-	FileNode *fnIzq,FileNode *fnDer,AccionFileNode **afnCola)
-{
-	AccionFileNode *afnNew=AccionFileNode_CrearNormal(fnIzq,fnDer);
-
-	if(!fnIzq && !fnDer){
+	if (!fnIzq && !fnDer) {
 		AccionFileNode_Destruir(afnNew);
 		return;
 	}
-	if(!fnIzq && fnDer){
-		if(fnDer->flags&FileFlag_Directorio){
+	if (!fnIzq && fnDer) {
+		if (fnDer->flags & FileFlag_Directorio) {
 			// Iterar hijos para borrarlos
-			AccionFileNode_CompareChilds(afnNew,afnCola,
-				AccionFileNode_DeletePair);
+			AccionFileNode_CompareChilds(afnNew, afnCola,
+					AccionFileNode_DeletePair);
 		}
 
-		if(fnDer->estado!=EstadoFichero_Borrado){
+		if (fnDer->estado != EstadoFichero_Borrado) {
 			// Accion de borrado para el nodo
-			afnNew->accion=AccionFileCmp_BorrarDerecha;
-			(*afnCola)->sig=afnNew;
-			(*afnCola)=afnNew;
-		}else{
+			afnNew->accion = AccionFileCmp_BorrarDerecha;
+			(*afnCola)->sig = afnNew;
+			(*afnCola) = afnNew;
+		} else {
 			AccionFileNode_Destruir(afnNew);
 		}
 	}
-	if(fnIzq && !fnDer){
-		if(fnIzq->flags&FileFlag_Directorio){
+	if (fnIzq && !fnDer) {
+		if (fnIzq->flags & FileFlag_Directorio) {
 			// Iterar hijos para borrarlos
-			AccionFileNode_CompareChilds(afnNew,afnCola,
-				AccionFileNode_DeletePair);
+			AccionFileNode_CompareChilds(afnNew, afnCola,
+					AccionFileNode_DeletePair);
 		}
 
-		if(fnIzq->estado!=EstadoFichero_Borrado){
+		if (fnIzq->estado != EstadoFichero_Borrado) {
 			// Accion de borrado para el nodo
-			afnNew->accion=AccionFileCmp_BorrarIzquierda;
-			(*afnCola)->sig=afnNew;
-			(*afnCola)=afnNew;
-		}else{
+			afnNew->accion = AccionFileCmp_BorrarIzquierda;
+			(*afnCola)->sig = afnNew;
+			(*afnCola) = afnNew;
+		} else {
 			AccionFileNode_Destruir(afnNew);
 		}
 	}
-	if(fnIzq && fnDer){
-		if(fnIzq->flags&FileFlag_Directorio ||
-			fnDer->flags&FileFlag_Directorio)
-		{
+	if (fnIzq && fnDer) {
+		if ((fnIzq->flags & FileFlag_Directorio)
+				|| (fnDer->flags & FileFlag_Directorio)) {
 			// Alguno es directorio
 
 			// Iterar hijos para borrarlos
-			AccionFileNode_CompareChilds(afnNew,afnCola,
-				AccionFileNode_DeletePair);
+			AccionFileNode_CompareChilds(afnNew, afnCola,
+					AccionFileNode_DeletePair);
 		}
 
-		if(fnIzq->estado!=EstadoFichero_Borrado){
+		if (fnIzq->estado != EstadoFichero_Borrado) {
 			// Accion de borrado para el nodo izquierdo
-			afnNew->accion=AccionFileCmp_BorrarIzquierda;
-			(*afnCola)->sig=afnNew;
-			(*afnCola)=afnNew;
-			afnNew=NULL;
+			afnNew->accion = AccionFileCmp_BorrarIzquierda;
+			(*afnCola)->sig = afnNew;
+			(*afnCola) = afnNew;
+			afnNew = NULL;
 		}
-		if(fnDer->estado!=EstadoFichero_Borrado){
-			if(!afnNew){ afnNew=AccionFileNode_CrearNormal(fnIzq,fnDer); }
+		if (fnDer->estado != EstadoFichero_Borrado) {
+			if (!afnNew) {
+				afnNew = AccionFileNode_CrearNormal(fnIzq, fnDer);
+			}
 			// Accion de borrado para el nodo derecho
-			afnNew->accion=AccionFileCmp_BorrarDerecha;
-			(*afnCola)->sig=afnNew;
-			(*afnCola)=afnNew;
-			afnNew=NULL;
+			afnNew->accion = AccionFileCmp_BorrarDerecha;
+			(*afnCola)->sig = afnNew;
+			(*afnCola) = afnNew;
+			afnNew = NULL;
 		}
-		if(afnNew){
+		if (afnNew) {
 			AccionFileNode_Destruir(afnNew);
 		}
 	}
 }
 
-void AccionFileNode_CheckPair(
-	FileNode *fnIzq,FileNode *fnDer,AccionFileNode **afnCola)
-{
-	AccionFileNode *afnNew=AccionFileNode_CrearNormal(fnIzq,fnDer);
+void AccionFileNode_CheckPair(FileNode *fnIzq, FileNode *fnDer,
+		AccionFileNode **afnCola) {
+	AccionFileNode *afnNew = AccionFileNode_CrearNormal(fnIzq, fnDer);
 
-	if(!fnIzq && !fnDer){
+	if (!fnIzq && !fnDer) {
 		AccionFileNode_Destruir(afnNew);
 		return;
 	}
-	if(!fnIzq && fnDer){
-		if(fnDer->flags&FileFlag_Directorio){
+	if (!fnIzq && fnDer) {
+		if (fnDer->flags & FileFlag_Directorio) {
 			// Directory
-			if(fnDer->estado==EstadoFichero_Borrado){
-				afnNew->accion=AccionFileCmp_Nada;
+			if (fnDer->estado == EstadoFichero_Borrado) {
+				afnNew->accion = AccionFileCmp_Nada;
 
 				// Anhadir a la lista de acciones
-				(*afnCola)->sig=afnNew;
-				(*afnCola)=afnNew;
+				(*afnCola)->sig = afnNew;
+				(*afnCola) = afnNew;
 
-			}else{
-				afnNew->accion=AccionFileCmp_CrearDirIzquierda;
+			} else {
+				afnNew->accion = AccionFileCmp_CrearDirIzquierda;
 
 				// Anhadir a la lista de acciones
-				(*afnCola)->sig=afnNew;
-				(*afnCola)=afnNew;
+				(*afnCola)->sig = afnNew;
+				(*afnCola) = afnNew;
 
 				// Iterar hijos
-				AccionFileNode_CompareChilds(afnNew,afnCola,
-					AccionFileNode_CheckPair);
+				AccionFileNode_CompareChilds(afnNew, afnCola,
+						AccionFileNode_CheckPair);
 
 				// Crear nueva accion para copiar la fecha
-				afnNew=AccionFileNode_CrearNormal(fnIzq,fnDer);
-				afnNew->accion=AccionFileCmp_FechaDerechaAIzquierda;
-				(*afnCola)->sig=afnNew;
-				(*afnCola)=afnNew;
+				afnNew = AccionFileNode_CrearNormal(fnIzq, fnDer);
+				afnNew->accion = AccionFileCmp_FechaDerechaAIzquierda;
+				(*afnCola)->sig = afnNew;
+				(*afnCola) = afnNew;
 			}
-		}else{
+		} else {
 			// File
-			if(fnDer->estado==EstadoFichero_Borrado){
-				afnNew->accion=AccionFileCmp_Nada;
-			}else{
-				afnNew->accion=AccionFileCmp_DerechaAIzquierda;
+			if (fnDer->estado == EstadoFichero_Borrado) {
+				afnNew->accion = AccionFileCmp_Nada;
+			} else {
+				afnNew->accion = AccionFileCmp_DerechaAIzquierda;
 			}
-			(*afnCola)->sig=afnNew;
-			(*afnCola)=afnNew;
+			(*afnCola)->sig = afnNew;
+			(*afnCola) = afnNew;
 		}
 	}
-	if(fnIzq && !fnDer){
-		if(fnIzq->flags&FileFlag_Directorio){
+	if (fnIzq && !fnDer) {
+		if (fnIzq->flags & FileFlag_Directorio) {
 			// Directory
-			if(fnIzq->estado==EstadoFichero_Borrado){
-				afnNew->accion=AccionFileCmp_Nada;
+			if (fnIzq->estado == EstadoFichero_Borrado) {
+				afnNew->accion = AccionFileCmp_Nada;
 
 				// Anhadir a la lista de acciones
-				(*afnCola)->sig=afnNew;
-				(*afnCola)=afnNew;
+				(*afnCola)->sig = afnNew;
+				(*afnCola) = afnNew;
 
-			}else{
-				afnNew->accion=AccionFileCmp_CrearDirDerecha;
+			} else {
+				afnNew->accion = AccionFileCmp_CrearDirDerecha;
 
 				// Anhadir a la lista de acciones
-				(*afnCola)->sig=afnNew;
-				(*afnCola)=afnNew;
+				(*afnCola)->sig = afnNew;
+				(*afnCola) = afnNew;
 
 				// Iterar hijos
-				AccionFileNode_CompareChilds(afnNew,afnCola,
-					AccionFileNode_CheckPair);
+				AccionFileNode_CompareChilds(afnNew, afnCola,
+						AccionFileNode_CheckPair);
 
 				// Crear nueva accion para copiar la fecha
-				afnNew=AccionFileNode_CrearNormal(fnIzq,fnDer);
-				afnNew->accion=AccionFileCmp_FechaIzquierdaADerecha;
-				(*afnCola)->sig=afnNew;
-				(*afnCola)=afnNew;
+				afnNew = AccionFileNode_CrearNormal(fnIzq, fnDer);
+				afnNew->accion = AccionFileCmp_FechaIzquierdaADerecha;
+				(*afnCola)->sig = afnNew;
+				(*afnCola) = afnNew;
 			}
-		}else{
+		} else {
 			// File
-			if(fnIzq->estado==EstadoFichero_Borrado){
-				afnNew->accion=AccionFileCmp_Nada;
-			}else{
-				afnNew->accion=AccionFileCmp_IzquierdaADerecha;
+			if (fnIzq->estado == EstadoFichero_Borrado) {
+				afnNew->accion = AccionFileCmp_Nada;
+			} else {
+				afnNew->accion = AccionFileCmp_IzquierdaADerecha;
 			}
-			(*afnCola)->sig=afnNew;
-			(*afnCola)=afnNew;
+			(*afnCola)->sig = afnNew;
+			(*afnCola) = afnNew;
 		}
 	}
-	if(fnIzq && fnDer){
-		if(fnIzq->flags&FileFlag_Directorio &&
-			fnDer->flags&FileFlag_Directorio)
-		{
+	if (fnIzq && fnDer) {
+		if ((fnIzq->flags & FileFlag_Directorio)
+				&& (fnDer->flags & FileFlag_Directorio)) {
 			// Directorios
 
 			// Preparar accion para el par de directorios
-			if(abs(fnIzq->ft-fnDer->ft)<=1){ // appoximadamente iguales
-				if(fnDer->estado==EstadoFichero_Borrado &&
-					fnIzq->estado==EstadoFichero_Borrado)
-				{
-					afnNew->accion=AccionFileCmp_Nada;
-				}else
-				if(fnDer->estado==EstadoFichero_Borrado){
-					afnNew->accion=AccionFileCmp_BorrarIzquierda;
-					if(fnIzq->estado==EstadoFichero_Borrado){
-						afnNew->accion=AccionFileCmp_Nada;
+			if (abs(fnIzq->ft - fnDer->ft) <= 1) { // appoximadamente iguales
+				if (fnDer->estado == EstadoFichero_Borrado
+						&& fnIzq->estado == EstadoFichero_Borrado) {
+					afnNew->accion = AccionFileCmp_Nada;
+				} else if (fnDer->estado == EstadoFichero_Borrado) {
+					afnNew->accion = AccionFileCmp_BorrarIzquierda;
+					if (fnIzq->estado == EstadoFichero_Borrado) {
+						afnNew->accion = AccionFileCmp_Nada;
 					}
-				}else
-				if(fnIzq->estado==EstadoFichero_Borrado){
-					afnNew->accion=AccionFileCmp_BorrarDerecha;
-					if(fnDer->estado==EstadoFichero_Borrado){
-						afnNew->accion=AccionFileCmp_Nada;
+				} else if (fnIzq->estado == EstadoFichero_Borrado) {
+					afnNew->accion = AccionFileCmp_BorrarDerecha;
+					if (fnDer->estado == EstadoFichero_Borrado) {
+						afnNew->accion = AccionFileCmp_Nada;
 					}
-				}else{
-					afnNew->accion=AccionFileCmp_Nada;
+				} else {
+					afnNew->accion = AccionFileCmp_Nada;
 				}
-			}else
-			if(fnIzq->ft<fnDer->ft){
-				afnNew->accion=AccionFileCmp_FechaDerechaAIzquierda;
-				if(fnDer->estado==EstadoFichero_Borrado){
-					afnNew->accion=AccionFileCmp_BorrarIzquierda;
-					if(fnIzq->estado==EstadoFichero_Borrado){
-						afnNew->accion=AccionFileCmp_Nada;
+			} else if (fnIzq->ft < fnDer->ft) {
+				afnNew->accion = AccionFileCmp_FechaDerechaAIzquierda;
+				if (fnDer->estado == EstadoFichero_Borrado) {
+					afnNew->accion = AccionFileCmp_BorrarIzquierda;
+					if (fnIzq->estado == EstadoFichero_Borrado) {
+						afnNew->accion = AccionFileCmp_Nada;
 					}
 				}
-			}else
-			if(fnIzq->ft>fnDer->ft){
-				afnNew->accion=AccionFileCmp_FechaIzquierdaADerecha;
-				if(fnIzq->estado==EstadoFichero_Borrado){
-					afnNew->accion=AccionFileCmp_BorrarDerecha;
-					if(fnDer->estado==EstadoFichero_Borrado){
-						afnNew->accion=AccionFileCmp_Nada;
+			} else if (fnIzq->ft > fnDer->ft) {
+				afnNew->accion = AccionFileCmp_FechaIzquierdaADerecha;
+				if (fnIzq->estado == EstadoFichero_Borrado) {
+					afnNew->accion = AccionFileCmp_BorrarDerecha;
+					if (fnDer->estado == EstadoFichero_Borrado) {
+						afnNew->accion = AccionFileCmp_Nada;
 					}
 				}
 			}
 
 			// Procesar nodos hijos
-			if(afnNew->accion==AccionFileCmp_BorrarDerecha ||
-				afnNew->accion==AccionFileCmp_BorrarIzquierda ||
-				(fnIzq->estado==EstadoFichero_Borrado &&
-				 fnDer->estado==EstadoFichero_Borrado))
-			{
+			if (afnNew->accion == AccionFileCmp_BorrarDerecha
+					|| afnNew->accion == AccionFileCmp_BorrarIzquierda
+					|| (fnIzq->estado == EstadoFichero_Borrado
+							&& fnDer->estado == EstadoFichero_Borrado)) {
 				// Iterar nodos hijos para borrarlos
-				AccionFileNode_CompareChilds(afnNew,afnCola,
-					AccionFileNode_DeletePair);
-			}else{
-				AccionFileNode_CompareChilds(afnNew,afnCola,
-					AccionFileNode_CheckPair);
+				AccionFileNode_CompareChilds(afnNew, afnCola,
+						AccionFileNode_DeletePair);
+			} else {
+				AccionFileNode_CompareChilds(afnNew, afnCola,
+						AccionFileNode_CheckPair);
 			}
 
 			// Encolar accion para el directorio padre
-			(*afnCola)->sig=afnNew;
-			(*afnCola)=afnNew;
+			(*afnCola)->sig = afnNew;
+			(*afnCola) = afnNew;
 
-		}else
-		if(fnIzq->flags&FileFlag_Normal &&
-			fnDer->flags&FileFlag_Normal)
-		{
+		} else if ((fnIzq->flags & FileFlag_Normal)
+				&& (fnDer->flags & FileFlag_Normal)) {
 			// Ficheros
 
-
 			// Preparar accion para el par de ficheros
-			if(abs(fnIzq->ft-fnDer->ft)<=1){ // appoximadamente iguales
-				if(fnDer->estado==EstadoFichero_Borrado &&
-					fnIzq->estado==EstadoFichero_Borrado)
-				{
-					afnNew->accion=AccionFileCmp_Nada;
-				}else
-				if(fnDer->estado==EstadoFichero_Borrado){
-					afnNew->accion=AccionFileCmp_BorrarIzquierda;
-					if(fnIzq->estado==EstadoFichero_Borrado){
-						afnNew->accion=AccionFileCmp_Nada;
+			if (abs(fnIzq->ft - fnDer->ft) <= 1) { // appoximadamente iguales
+				if (fnDer->estado == EstadoFichero_Borrado
+						&& fnIzq->estado == EstadoFichero_Borrado) {
+					afnNew->accion = AccionFileCmp_Nada;
+				} else if (fnDer->estado == EstadoFichero_Borrado) {
+					afnNew->accion = AccionFileCmp_BorrarIzquierda;
+					if (fnIzq->estado == EstadoFichero_Borrado) {
+						afnNew->accion = AccionFileCmp_Nada;
 					}
-				}else
-				if(fnIzq->estado==EstadoFichero_Borrado){
-					afnNew->accion=AccionFileCmp_BorrarDerecha;
-					if(fnDer->estado==EstadoFichero_Borrado){
-						afnNew->accion=AccionFileCmp_Nada;
+				} else if (fnIzq->estado == EstadoFichero_Borrado) {
+					afnNew->accion = AccionFileCmp_BorrarDerecha;
+					if (fnDer->estado == EstadoFichero_Borrado) {
+						afnNew->accion = AccionFileCmp_Nada;
 					}
-				}else{
-					afnNew->accion=AccionFileCmp_Nada;
+				} else {
+					afnNew->accion = AccionFileCmp_Nada;
 				}
-			}else
-			if(fnIzq->ft<fnDer->ft){
-				afnNew->accion=AccionFileCmp_DerechaAIzquierda;
-				if(fnDer->estado==EstadoFichero_Borrado){
-					afnNew->accion=AccionFileCmp_BorrarIzquierda;
-					if(fnIzq->estado==EstadoFichero_Borrado){
-						afnNew->accion=AccionFileCmp_Nada;
+			} else if (fnIzq->ft < fnDer->ft) {
+				afnNew->accion = AccionFileCmp_DerechaAIzquierda;
+				if (fnDer->estado == EstadoFichero_Borrado) {
+					afnNew->accion = AccionFileCmp_BorrarIzquierda;
+					if (fnIzq->estado == EstadoFichero_Borrado) {
+						afnNew->accion = AccionFileCmp_Nada;
 					}
 				}
-			}else
-			if(fnIzq->ft>fnDer->ft){
-				afnNew->accion=AccionFileCmp_IzquierdaADerecha;
-				if(fnIzq->estado==EstadoFichero_Borrado){
-					afnNew->accion=AccionFileCmp_BorrarDerecha;
-					if(fnDer->estado==EstadoFichero_Borrado){
-						afnNew->accion=AccionFileCmp_Nada;
+			} else if (fnIzq->ft > fnDer->ft) {
+				afnNew->accion = AccionFileCmp_IzquierdaADerecha;
+				if (fnIzq->estado == EstadoFichero_Borrado) {
+					afnNew->accion = AccionFileCmp_BorrarDerecha;
+					if (fnDer->estado == EstadoFichero_Borrado) {
+						afnNew->accion = AccionFileCmp_Nada;
 					}
 				}
 			}
 
 			// Encolar accion para el fichero
-			(*afnCola)->sig=afnNew;
-			(*afnCola)=afnNew;
+			(*afnCola)->sig = afnNew;
+			(*afnCola) = afnNew;
 
-		}else{
+		} else {
 			// FIXME: !!!!!
 			// Directory vs File
 
@@ -422,244 +401,225 @@ void AccionFileNode_CheckPair(
 	}
 }
 
+AccionFileNode *AccionFileNode_BuildSync(FileNode *izquierda, FileNode *derecha) {
+	AccionFileNode *afnRaiz = AccionFileNode_CrearNormal(izquierda, derecha);
+	AccionFileNode *afnCola = afnRaiz;
 
-AccionFileNode *AccionFileNode_BuildSync(
-	FileNode *izquierda,FileNode *derecha)
-{
-	AccionFileNode *afnRaiz=AccionFileNode_CrearNormal(izquierda,derecha);
-	AccionFileNode *afnCola=afnRaiz;
-
-	AccionFileNode_CompareChilds(afnRaiz,&afnCola,
-		AccionFileNode_CheckPair);
+	AccionFileNode_CompareChilds(afnRaiz, &afnCola, AccionFileNode_CheckPair);
 
 	return afnRaiz;
 }
 
+void AccionFileNode_Copy(FileNode *fnIzq, FileNode *fnDer,
+		AccionFileNode **afnCola) {
+	AccionFileNode *afnNew = AccionFileNode_CrearNormal(fnIzq, fnDer);
 
-
-
-
-
-
-
-void AccionFileNode_Copy(
-	FileNode *fnIzq,FileNode *fnDer,AccionFileNode **afnCola)
-{
-	AccionFileNode *afnNew=AccionFileNode_CrearNormal(fnIzq,fnDer);
-
-	if(!fnIzq && !fnDer){
+	if (!fnIzq && !fnDer) {
 		AccionFileNode_Destruir(afnNew);
 		return;
 	}
-	if(!fnIzq && fnDer){
-		if(fnDer->flags&FileFlag_Directorio){
-			AccionFileNode_CompareChilds(afnNew,afnCola,
-				AccionFileNode_DeletePair);
+	if (!fnIzq && fnDer) {
+		if (fnDer->flags & FileFlag_Directorio) {
+			AccionFileNode_CompareChilds(afnNew, afnCola,
+					AccionFileNode_DeletePair);
 		}
 
-		if(fnDer->estado!=EstadoFichero_Borrado){
-			afnNew->accion=AccionFileCmp_BorrarDerecha;
-		}else{
-			afnNew->accion=AccionFileCmp_Nada;
+		if (fnDer->estado != EstadoFichero_Borrado) {
+			afnNew->accion = AccionFileCmp_BorrarDerecha;
+		} else {
+			afnNew->accion = AccionFileCmp_Nada;
 		}
-		(*afnCola)->sig=afnNew;
-		(*afnCola)=afnNew;
+		(*afnCola)->sig = afnNew;
+		(*afnCola) = afnNew;
 	}
-	if(fnIzq && !fnDer){
-		if(fnIzq->estado!=EstadoFichero_Borrado){
-			if(fnIzq->flags&FileFlag_Directorio){
-				afnNew->accion=AccionFileCmp_CrearDirDerecha;
-				(*afnCola)->sig=afnNew;
-				(*afnCola)=afnNew;
-				AccionFileNode_CompareChilds(afnNew,afnCola,
-					AccionFileNode_Copy);
-				afnNew=AccionFileNode_CrearNormal(fnIzq,fnDer);
-				afnNew->accion=AccionFileCmp_FechaIzquierdaADerecha;
-			}else{
-				afnNew->accion=AccionFileCmp_IzquierdaADerecha;
+	if (fnIzq && !fnDer) {
+		if (fnIzq->estado != EstadoFichero_Borrado) {
+			if (fnIzq->flags & FileFlag_Directorio) {
+				afnNew->accion = AccionFileCmp_CrearDirDerecha;
+				(*afnCola)->sig = afnNew;
+				(*afnCola) = afnNew;
+				AccionFileNode_CompareChilds(afnNew, afnCola,
+						AccionFileNode_Copy);
+				afnNew = AccionFileNode_CrearNormal(fnIzq, fnDer);
+				afnNew->accion = AccionFileCmp_FechaIzquierdaADerecha;
+			} else {
+				afnNew->accion = AccionFileCmp_IzquierdaADerecha;
 			}
-		}else{
-			afnNew->accion=AccionFileCmp_Nada;
+		} else {
+			afnNew->accion = AccionFileCmp_Nada;
 		}
-		(*afnCola)->sig=afnNew;
-		(*afnCola)=afnNew;
+		(*afnCola)->sig = afnNew;
+		(*afnCola) = afnNew;
 	}
-	if(fnIzq && fnDer){
-		if(fnIzq->flags&FileFlag_Directorio ||
-			fnDer->flags&FileFlag_Directorio)
-		{
-			if(fnIzq->estado!=EstadoFichero_Borrado){
-				AccionFileNode_CompareChilds(afnNew,afnCola,
-					AccionFileNode_Copy);
-				if(abs(fnIzq->ft-fnDer->ft)<=1){ // appox. equal
-					afnNew->accion=AccionFileCmp_Nada;
-				}else{
-					afnNew->accion=AccionFileCmp_FechaIzquierdaADerecha;
+	if (fnIzq && fnDer) {
+		if ((fnIzq->flags & FileFlag_Directorio)
+				|| (fnDer->flags & FileFlag_Directorio)) {
+			if (fnIzq->estado != EstadoFichero_Borrado) {
+				AccionFileNode_CompareChilds(afnNew, afnCola,
+						AccionFileNode_Copy);
+				if (abs(fnIzq->ft - fnDer->ft) <= 1) { // appox. equal
+					afnNew->accion = AccionFileCmp_Nada;
+				} else {
+					afnNew->accion = AccionFileCmp_FechaIzquierdaADerecha;
 				}
-			}else{
-				AccionFileNode_CompareChilds(afnNew,afnCola,
-					AccionFileNode_DeletePair);
-				afnNew->accion=AccionFileCmp_BorrarDerecha;
+			} else {
+				AccionFileNode_CompareChilds(afnNew, afnCola,
+						AccionFileNode_DeletePair);
+				afnNew->accion = AccionFileCmp_BorrarDerecha;
 			}
-		}else{
-			if(fnIzq->estado!=EstadoFichero_Borrado){
-				if(abs(fnIzq->ft-fnDer->ft)<=1){ // appox. equal
-					afnNew->accion=AccionFileCmp_Nada;
-				}else{
-					afnNew->accion=AccionFileCmp_IzquierdaADerecha;
+		} else {
+			if (fnIzq->estado != EstadoFichero_Borrado) {
+				if (abs(fnIzq->ft - fnDer->ft) <= 1) { // appox. equal
+					afnNew->accion = AccionFileCmp_Nada;
+				} else {
+					afnNew->accion = AccionFileCmp_IzquierdaADerecha;
 				}
-			}else{
-				if(fnDer->estado!=EstadoFichero_Borrado){
-					afnNew->accion=AccionFileCmp_BorrarDerecha;
+			} else {
+				if (fnDer->estado != EstadoFichero_Borrado) {
+					afnNew->accion = AccionFileCmp_BorrarDerecha;
 				}
 			}
 		}
-		(*afnCola)->sig=afnNew;
-		(*afnCola)=afnNew;
+		(*afnCola)->sig = afnNew;
+		(*afnCola) = afnNew;
 	}
 }
 
+AccionFileNode *AccionFileNode_BuildCopy(FileNode *izquierda, FileNode *derecha) {
+	AccionFileNode *afnRaiz = AccionFileNode_CrearNormal(izquierda, derecha);
+	AccionFileNode *afnCola = afnRaiz;
 
-
-
-
-
-
-AccionFileNode *AccionFileNode_BuildCopy(
-	FileNode *izquierda,FileNode *derecha)
-{
-	AccionFileNode *afnRaiz=AccionFileNode_CrearNormal(izquierda,derecha);
-	AccionFileNode *afnCola=afnRaiz;
-
-	AccionFileNode_CompareChilds(afnRaiz,&afnCola,
-		AccionFileNode_Copy);
+	AccionFileNode_CompareChilds(afnRaiz, &afnCola, AccionFileNode_Copy);
 
 	return afnRaiz;
 }
 
-
-void AccionFileNode_Print(AccionFileNode *afn){
+void AccionFileNode_Print(AccionFileNode *afn) {
 	char showPath[MaxPath];
-	while(afn!=NULL){
-		if(afn->izquierda){
-			FileNode_GetFullPath(afn->izquierda,"",showPath);
-		}else{
-			FileNode_GetFullPath(afn->derecha,"",showPath);
+	while (afn != NULL ) {
+		if (afn->izquierda) {
+			FileNode_GetFullPath(afn->izquierda, "", showPath);
+		} else {
+			FileNode_GetFullPath(afn->derecha, "", showPath);
 		}
 
-		switch(afn->accion){
-			case AccionFileCmp_Nada:
-				//printf("%s == %s\n",pathIzq,pathDer);
-				break;
-			case AccionFileCmp_IzquierdaADerecha:
-				printf(" => %s\n",showPath);break;
-			case AccionFileCmp_DerechaAIzquierda:
-				printf(" <= %s\n",showPath);break;
-			case AccionFileCmp_BorrarIzquierda:
-				printf(" *- %s\n",showPath);break;
-			case AccionFileCmp_BorrarDerecha:
-				printf(" -* %s\n",showPath);break;
-			case AccionFileCmp_FechaIzquierdaADerecha:
-				printf(" -> %s\n",showPath);break;
-			case AccionFileCmp_FechaDerechaAIzquierda:
-				printf(" <- %s\n",showPath);break;
-			case AccionFileCmp_CrearDirDerecha:
-				printf(" -D %s\n",showPath);break;
-			case AccionFileCmp_CrearDirIzquierda:
-				printf(" D- %s\n",showPath);break;
+		switch (afn->accion) {
+		case AccionFileCmp_Nada:
+			//printf("%s == %s\n",pathIzq,pathDer);
+			break;
+		case AccionFileCmp_IzquierdaADerecha:
+			printf(" => %s\n", showPath);
+			break;
+		case AccionFileCmp_DerechaAIzquierda:
+			printf(" <= %s\n", showPath);
+			break;
+		case AccionFileCmp_BorrarIzquierda:
+			printf(" *- %s\n", showPath);
+			break;
+		case AccionFileCmp_BorrarDerecha:
+			printf(" -* %s\n", showPath);
+			break;
+		case AccionFileCmp_FechaIzquierdaADerecha:
+			printf(" -> %s\n", showPath);
+			break;
+		case AccionFileCmp_FechaDerechaAIzquierda:
+			printf(" <- %s\n", showPath);
+			break;
+		case AccionFileCmp_CrearDirDerecha:
+			printf(" -D %s\n", showPath);
+			break;
+		case AccionFileCmp_CrearDirIzquierda:
+			printf(" D- %s\n", showPath);
+			break;
 		}
 
-		afn=afn->sig;
+		afn = afn->sig;
 	}
 	printf("End\n");
 }
 
-
-
-
-
-void AccionFileNodeAux_CopyDate(char *pathOrig,char *pathDest){
-	FileTime ft=FileTime_Get(pathOrig);
-	FileTime_Set(pathDest,ft);
+void AccionFileNodeAux_CopyDate(char *pathOrig, char *pathDest) {
+	FileTime ft = FileTime_Get(pathOrig);
+	FileTime_Set(pathDest, ft);
 }
 
-void AccionFileNodeAux_Copy(char *pathOrig,char *pathDest){
-	if(File_Copiar(pathOrig,pathDest)){
-		AccionFileNodeAux_CopyDate(pathOrig,pathDest);
-	}else{
+void AccionFileNodeAux_Copy(char *pathOrig, char *pathDest) {
+	if (File_Copiar(pathOrig, pathDest)) {
+		AccionFileNodeAux_CopyDate(pathOrig, pathDest);
+	} else {
 		File_Borrar(pathDest);
 	}
 }
-void AccionFileNodeAux_Delete(char *pathOrig,char *pathDest){
-	if(File_EsDirectorio(pathDest)){
+void AccionFileNodeAux_Delete(char *pathOrig, char *pathDest) {
+	if (File_EsDirectorio(pathDest)) {
 		File_BorrarDirectorio(pathDest);
-	}else{
+	} else {
 		File_Borrar(pathDest);
 	}
 }
-void AccionFileNodeAux_MakeDir(char *pathOrig,char *pathDest){
+void AccionFileNodeAux_MakeDir(char *pathOrig, char *pathDest) {
 	File_CrearDir(pathDest);
 }
 
-void AccionFileNode_RunList(AccionFileNode *afn,char *pathIzquierda,char *pathDerecha){
-	char pathIzq[MaxPath],pathDer[MaxPath],showPath[MaxPath];
-	while(afn!=NULL){
-		if(afn->izquierda){
-			FileNode_GetFullPath(afn->izquierda,pathIzquierda,pathIzq);
-		}else{
-			FileNode_GetFullPath(afn->derecha,pathIzquierda,pathIzq);
+void AccionFileNode_RunList(AccionFileNode *afn, char *pathIzquierda,
+		char *pathDerecha) {
+	char pathIzq[MaxPath], pathDer[MaxPath], showPath[MaxPath];
+	while (afn != NULL ) {
+		if (afn->izquierda) {
+			FileNode_GetFullPath(afn->izquierda, pathIzquierda, pathIzq);
+		} else {
+			FileNode_GetFullPath(afn->derecha, pathIzquierda, pathIzq);
 		}
-		if(afn->derecha){
-			FileNode_GetFullPath(afn->derecha,pathDerecha,pathDer);
-		}else{
-			FileNode_GetFullPath(afn->izquierda,pathDerecha,pathDer);
+		if (afn->derecha) {
+			FileNode_GetFullPath(afn->derecha, pathDerecha, pathDer);
+		} else {
+			FileNode_GetFullPath(afn->izquierda, pathDerecha, pathDer);
 		}
-		if(afn->izquierda){
-			FileNode_GetFullPath(afn->izquierda,"",showPath);
-		}else{
-			FileNode_GetFullPath(afn->derecha,"",showPath);
+		if (afn->izquierda) {
+			FileNode_GetFullPath(afn->izquierda, "", showPath);
+		} else {
+			FileNode_GetFullPath(afn->derecha, "", showPath);
 		}
 
-
-		switch(afn->accion){
-			case AccionFileCmp_Nada:
-				//printf("%s == %s\n",pathIzq,pathDer);
-				break;
-			case AccionFileCmp_IzquierdaADerecha:
-				printf(" => %s\n",showPath);
-				AccionFileNodeAux_Copy(pathIzq,pathDer);
-				break;
-			case AccionFileCmp_DerechaAIzquierda:
-				printf(" <= %s\n",showPath);
-				AccionFileNodeAux_Copy(pathDer,pathIzq);
-				break;
-			case AccionFileCmp_BorrarIzquierda:
-				printf(" *- %s\n",showPath);
-				AccionFileNodeAux_Delete(pathDer,pathIzq);
-				break;
-			case AccionFileCmp_BorrarDerecha:
-				printf(" -* %s\n",showPath);
-				AccionFileNodeAux_Delete(pathIzq,pathDer);
-				break;
-			case AccionFileCmp_FechaIzquierdaADerecha:
-				printf(" -> %s\n",showPath);
-				AccionFileNodeAux_CopyDate(pathIzq,pathDer);
-				break;
-			case AccionFileCmp_FechaDerechaAIzquierda:
-				printf(" <- %s\n",showPath);
-				AccionFileNodeAux_CopyDate(pathDer,pathIzq);
-				break;
-			case AccionFileCmp_CrearDirDerecha:
-				printf(" -D %s\n",showPath);
-				AccionFileNodeAux_MakeDir(pathIzq,pathDer);
-				break;
-			case AccionFileCmp_CrearDirIzquierda:
-				printf(" D- %s\n",showPath);
-				AccionFileNodeAux_MakeDir(pathDer,pathIzq);
-				break;
+		switch (afn->accion) {
+		case AccionFileCmp_Nada:
+			//printf("%s == %s\n",pathIzq,pathDer);
+			break;
+		case AccionFileCmp_IzquierdaADerecha:
+			printf(" => %s\n", showPath);
+			AccionFileNodeAux_Copy(pathIzq, pathDer);
+			break;
+		case AccionFileCmp_DerechaAIzquierda:
+			printf(" <= %s\n", showPath);
+			AccionFileNodeAux_Copy(pathDer, pathIzq);
+			break;
+		case AccionFileCmp_BorrarIzquierda:
+			printf(" *- %s\n", showPath);
+			AccionFileNodeAux_Delete(pathDer, pathIzq);
+			break;
+		case AccionFileCmp_BorrarDerecha:
+			printf(" -* %s\n", showPath);
+			AccionFileNodeAux_Delete(pathIzq, pathDer);
+			break;
+		case AccionFileCmp_FechaIzquierdaADerecha:
+			printf(" -> %s\n", showPath);
+			AccionFileNodeAux_CopyDate(pathIzq, pathDer);
+			break;
+		case AccionFileCmp_FechaDerechaAIzquierda:
+			printf(" <- %s\n", showPath);
+			AccionFileNodeAux_CopyDate(pathDer, pathIzq);
+			break;
+		case AccionFileCmp_CrearDirDerecha:
+			printf(" -D %s\n", showPath);
+			AccionFileNodeAux_MakeDir(pathIzq, pathDer);
+			break;
+		case AccionFileCmp_CrearDirIzquierda:
+			printf(" D- %s\n", showPath);
+			AccionFileNodeAux_MakeDir(pathDer, pathIzq);
+			break;
 		}
 
-		afn=afn->sig;
+		afn = afn->sig;
 	}
 	printf("End\n");
 }
diff --git a/filenodecmp.h b/filenodecmp.h
index ee8f41e..eaa083b 100644
--- a/filenodecmp.h
+++ b/filenodecmp.h
@@ -3,7 +3,6 @@
 
 #include "filenode.h"
 
-
 typedef enum {
 	AccionFileCmp_Nada,
 	AccionFileCmp_IzquierdaADerecha,
@@ -16,7 +15,6 @@ typedef enum {
 	AccionFileCmp_CrearDirIzquierda
 } AccionFileCmp;
 
-
 typedef struct Tag_AccionFileNode {
 	AccionFileCmp accion;
 	FileNode *izquierda;
@@ -24,17 +22,18 @@ typedef struct Tag_AccionFileNode {
 	struct Tag_AccionFileNode *sig;
 } AccionFileNode;
 
-
 AccionFileNode *AccionFileNode_Crear();
 void AccionFileNode_Destruir(AccionFileNode *afn);
-AccionFileNode *AccionFileNode_CrearNormal(FileNode *fnIzq,FileNode *fnDer);
+AccionFileNode *AccionFileNode_CrearNormal(FileNode *fnIzq, FileNode *fnDer);
 
-AccionFileNode *AccionFileNode_BuildSync(FileNode *izquierda,FileNode *derecha);
-AccionFileNode *AccionFileNode_BuildCopy(FileNode *izquierda,FileNode *derecha);
+AccionFileNode *AccionFileNode_BuildSync(FileNode *izquierda,
+		FileNode *derecha);
+AccionFileNode *AccionFileNode_BuildCopy(FileNode *izquierda,
+		FileNode *derecha);
 
 void AccionFileNode_Print(AccionFileNode *afn);
 
-void AccionFileNode_RunList(AccionFileNode *afn,
-	char *pathIzquierda,char *pathDerecha);
+void AccionFileNode_RunList(AccionFileNode *afn, char *pathIzquierda,
+		char *pathDerecha);
 
 #endif
diff --git a/fileutil.c b/fileutil.c
index d0c66c0..20e27f5 100644
--- a/fileutil.c
+++ b/fileutil.c
@@ -7,19 +7,19 @@
 #include <utime.h>
 #include <time.h>
 #ifdef WIN32
-	#define _WIN32_WINNT 0x0501
-	#include <signal.h>
-	#include <windows.h>
-	#include <fcntl.h>
-	#include <io.h>
+#define _WIN32_WINNT 0x0501
+#include <signal.h>
+#include <windows.h>
+#include <fcntl.h>
+#include <io.h>
 #else
-	#include <unistd.h>
+#include <unistd.h>
 #endif
 
 #include "fileutil.h"
 
 #ifdef WIN32
-long long FileTime_to_POSIX(FILETIME ft){
+long long FileTime_to_POSIX(FILETIME ft) {
 	LARGE_INTEGER date, adjust;
 
 	// takes the last modified date
@@ -36,7 +36,7 @@ long long FileTime_to_POSIX(FILETIME ft){
 	return date.QuadPart / 10000000ll;
 }
 
-FILETIME POSIX_to_FileTime(FileTime ft){
+FILETIME POSIX_to_FileTime(FileTime ft) {
 	LARGE_INTEGER date, adjust;
 	FILETIME filetime;
 
@@ -55,7 +55,7 @@ FILETIME POSIX_to_FileTime(FileTime ft){
 	return filetime;
 }
 
-FileTime FileTime_Get(char *filename){
+FileTime FileTime_Get(char *filename) {
 	HANDLE hFile;
 	FILETIME ftCreate, ftAccess, ftWrite;
 	hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
@@ -65,11 +65,11 @@ FileTime FileTime_Get(char *filename){
 	return(FileTime_to_POSIX(ftWrite));
 }
 
-void FileTime_Set(char *filename,FileTime t){
+void FileTime_Set(char *filename,FileTime t) {
 	HANDLE hFile;
 	FILETIME ftWrite;
 	hFile = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_WRITE,
-		NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+			NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
 	ftWrite=POSIX_to_FileTime(t);
 	SetFileTime(hFile, NULL, NULL, &ftWrite);
 	CloseHandle(hFile);
@@ -77,169 +77,152 @@ void FileTime_Set(char *filename,FileTime t){
 
 #else
 
-FileTime FileTime_Get(char *filename){
+FileTime FileTime_Get(char *filename) {
 	struct stat fs;
-	lstat(filename,&fs);
-	return(fs.st_mtime);
+	lstat(filename, &fs);
+	return (fs.st_mtime);
 }
 
-void FileTime_Set(char *filename,FileTime t){
+void FileTime_Set(char *filename, FileTime t) {
 	struct utimbuf utb;
 
-	utb.actime=t;
-	utb.modtime=t;
-	utime(filename,&utb);
+	utb.actime = t;
+	utb.modtime = t;
+	utime(filename, &utb);
 }
 
 #endif
 
-
-void FileTime_Print(FileTime t){
+void FileTime_Print(FileTime t) {
 	struct tm *tms;
 
-	tms=localtime((time_t *)&t);
-	printf("%04d-%02d-%02d %02d:%02d:%02d",
-		tms->tm_year+1900,
-		tms->tm_mon+1,
-		tms->tm_mday,
-		tms->tm_hour,
-		tms->tm_min,
-		tms->tm_sec);
+	tms = localtime((time_t *) &t);
+	printf("%04d-%02d-%02d %02d:%02d:%02d", tms->tm_year + 1900,
+			tms->tm_mon + 1, tms->tm_mday, tms->tm_hour, tms->tm_min,
+			tms->tm_sec);
 }
 
+void File_GetName(char *path, char *name) {
+	int i, j;
 
-
-
-
-void File_GetName(char *path,char *name){
-	int i,j;
-
-	i=strlen(path)-1;
-	while(i>=0 ){
-		if(path[i]=='/' || path[i]=='\\'){
+	i = strlen(path) - 1;
+	while (i >= 0) {
+		if (path[i] == '/' || path[i] == '\\') {
 			i++;
 			break;
-		}else{
+		} else {
 			i--;
 		}
 	}
-	if(i<0)
+	if (i < 0)
 		i++;
 
-	j=0;
-	while(path[i]){
-		name[j]=path[i];
-		i++;j++;
+	j = 0;
+	while (path[i]) {
+		name[j] = path[i];
+		i++;
+		j++;
 	}
-	name[j]=0;
+	name[j] = 0;
 }
 
-
-
-
 #ifdef WIN32
 
-int File_ExistePath(char *path){
+int File_ExistePath(char *path) {
 	unsigned rc;
 	rc=GetFileAttributes(path);
 
-	if(rc==INVALID_FILE_ATTRIBUTES){
+	if(rc==INVALID_FILE_ATTRIBUTES) {
 		return(0);
 	}
 	return(1);
 }
-int File_EsDirectorio(char *dir){
+int File_EsDirectorio(char *dir) {
 	unsigned rc;
 	rc=GetFileAttributes(dir);
 
-	if(rc==INVALID_FILE_ATTRIBUTES){
+	if(rc==INVALID_FILE_ATTRIBUTES) {
 		return(0);
 	}
-	if(rc&FILE_ATTRIBUTE_DIRECTORY){
+	if(rc&FILE_ATTRIBUTE_DIRECTORY) {
 		return(1);
 	}
 	return(0);
 }
-int File_EsFichero(char *fichero){
+int File_EsFichero(char *fichero) {
 	unsigned rc;
 	rc=GetFileAttributes(fichero);
 
-	if(rc==INVALID_FILE_ATTRIBUTES){
+	if(rc==INVALID_FILE_ATTRIBUTES) {
 		return(0);
 	}
-	if(rc&FILE_ATTRIBUTE_DIRECTORY){
+	if(rc&FILE_ATTRIBUTE_DIRECTORY) {
 		return(0);
 	}
 	return(1);
 }
 
 #else
-int File_ExistePath(char *path){
+int File_ExistePath(char *path) {
 	struct stat info;
 
-	if(lstat(path,&info)==-1){
-		return(0);
+	if (lstat(path, &info) == -1) {
+		return (0);
 	}
-	return(1);
+	return (1);
 }
-int File_EsDirectorio(char *dir){
+int File_EsDirectorio(char *dir) {
 	struct stat info;
 
-	if(lstat(dir,&info)==-1){
-		return(0);
+	if (lstat(dir, &info) == -1) {
+		return (0);
 	}
-	if(S_ISDIR(info.st_mode)){
-		return(1);
+	if (S_ISDIR(info.st_mode)) {
+		return (1);
 	}
-	return(0);
+	return (0);
 }
-int File_EsFichero(char *fichero){
+int File_EsFichero(char *fichero) {
 	struct stat info;
 
-	if(lstat(fichero,&info)==-1){
-		return(0);
+	if (lstat(fichero, &info) == -1) {
+		return (0);
 	}
-	if(S_ISDIR(info.st_mode)){
-		return(0);
+	if (S_ISDIR(info.st_mode)) {
+		return (0);
 	}
-	return(1);
+	return (1);
 }
 #endif
 
-
-
-long long File_TamanhoFichero(char *fichero){
+long long File_TamanhoFichero(char *fichero) {
 	FILE *f;
 	long long tamanho;
 
-	f=fopen(fichero,"rb");
-	if(!f)
-		return(-1);
+	f = fopen(fichero, "rb");
+	if (!f)
+		return (-1);
 
-	fseek(f,0,SEEK_END);
-	tamanho=ftell(f);
+	fseek(f, 0, SEEK_END);
+	tamanho = ftell(f);
 	fclose(f);
-	return(tamanho);
+	return (tamanho);
 }
 
-
 #ifdef WIN32
-int File_CrearDir(char *path){
+int File_CrearDir(char *path) {
 	return(_mkdir(path));
 }
 #else
-int File_CrearDir(char *path){
-	return(mkdir(path,0777));
+int File_CrearDir(char *path) {
+	return (mkdir(path, 0777));
 }
 #endif
 
-
-
-
 #ifdef WIN32
 
 void File_IterateDir(char *path,
-	int (*func)(char *path,char *name,void *data),void *data)
+		int (*func)(char *path,char *name,void *data),void *data)
 {
 	int handle;
 	struct _finddata_t fileinfo;
@@ -250,20 +233,20 @@ void File_IterateDir(char *path,
 	char *ptr;
 
 	snprintf(path_aux,MaxPath,
-	   "%s/*",path);
+			"%s/*",path);
 	handle=_findfirst(path_aux,&fileinfo);
 	if(handle==-1)
-		return;
+	return;
 
 	// Recorrer el directorio
-	do{
+	do {
 		if(strcmp(fileinfo.name,".") &&
-		   strcmp(fileinfo.name,".."))
+				strcmp(fileinfo.name,".."))
 		{
 			// A partir de aqui hay un fichero
 			// (o directorio)
 			snprintf(f_path,512,
-			   "%s/%s",path,fileinfo.name);
+					"%s/%s",path,fileinfo.name);
 			fin=func(f_path,fileinfo.name,data);
 		}
 		findnext_rc=_findnext(handle,&fileinfo);
@@ -274,80 +257,72 @@ void File_IterateDir(char *path,
 #else
 
 void File_IterateDir(char *path,
-	int (*func)(char *path,char *name,void *data),void *data)
-{
+		int (*func)(char *path, char *name, void *data), void *data) {
 	DIR *directorio;
 	struct dirent *entidad_dir;
 	char f_path[MaxPath];
-	int fin=0;
+	int fin = 0;
 	char *ptr;
 
-	directorio=opendir(path);
-	if(directorio==NULL)
+	directorio = opendir(path);
+	if (directorio == NULL )
 		return;
 
 	// Recorrer el directorio
-	do{
-		entidad_dir=readdir(directorio);
-		if(entidad_dir!=NULL){
-			if(strcmp(entidad_dir->d_name,".") &&
-			   strcmp(entidad_dir->d_name,".."))
-			{
+	do {
+		entidad_dir = readdir(directorio);
+		if (entidad_dir != NULL ) {
+			if (strcmp(entidad_dir->d_name, ".")
+					&& strcmp(entidad_dir->d_name, "..")) {
 				// A partir de aqui hay un fichero
 				// (o directorio)
-				snprintf(f_path,MaxPath,
-				   "%s/%s",path,entidad_dir->d_name);
-				fin=func(f_path,
-				   entidad_dir->d_name,
-				   data);
+				snprintf(f_path, MaxPath, "%s/%s", path, entidad_dir->d_name);
+				fin = func(f_path, entidad_dir->d_name, data);
 			}
 		}
-	}while(entidad_dir!=NULL && !fin);
+	} while (entidad_dir != NULL && !fin);
 	closedir(directorio);
 }
 #endif
 
-
-
-void File_Borrar(char *path){
+void File_Borrar(char *path) {
 	unlink(path);
 }
 
-void File_BorrarDirectorio(char *path){
+void File_BorrarDirectorio(char *path) {
 	rmdir(path);
 }
 
-
 #define MaxBuffer 16384
-int File_Copiar( const char *pathOrig,const char *pathDest){
-	FILE *fOrig,*fDest;
-    char buffer[MaxBuffer];
-	int readLen=0;
-	int writeLen=0;
-	int ok=0;
+int File_Copiar(const char *pathOrig, const char *pathDest) {
+	FILE *fOrig, *fDest;
+	char buffer[MaxBuffer];
+	int readLen = 0;
+	int writeLen = 0;
+	int ok = 0;
 
-	if((fOrig=fopen(pathOrig,"rb"))==NULL){
+	if ((fOrig = fopen(pathOrig, "rb")) == NULL ) {
 		return 0;
 	}
-	if((fDest=fopen(pathDest,"wb"))==NULL){
+	if ((fDest = fopen(pathDest, "wb")) == NULL ) {
 		return 0;
 	}
 
-	do{
-		readLen=fread(&buffer,1,MaxBuffer,fOrig);
-		if(readLen>0){
-			writeLen=fwrite(&buffer,1,readLen,fDest);
-			if(writeLen!=readLen){
+	do {
+		readLen = fread(&buffer, 1, MaxBuffer, fOrig);
+		if (readLen > 0) {
+			writeLen = fwrite(&buffer, 1, readLen, fDest);
+			if (writeLen != readLen) {
 				// Error
 				fclose(fOrig);
 				fclose(fDest);
 				return 0;
 			}
 		}
-	}while(readLen==MaxBuffer);
+	} while (readLen == MaxBuffer);
 
-	if(feof(fOrig)){
-		ok=1;
+	if (feof(fOrig)) {
+		ok = 1;
 	}
 
 	fclose(fOrig);
diff --git a/fileutil.h b/fileutil.h
index dce30b3..84d7b76 100644
--- a/fileutil.h
+++ b/fileutil.h
@@ -1,24 +1,21 @@
 #ifndef _FILEUTIL_
 #define _FILEUTIL_
 
-
 ////////////////////////////////////////////////
 // FileTime
 
 typedef long long FileTime;
 
 FileTime FileTime_Get(char *filename);
-void FileTime_Set(char *filename,FileTime t);
+void FileTime_Set(char *filename, FileTime t);
 void FileTime_Print(FileTime t);
 
-
-
 ///////////////////////////////////////////////
 // File
 #define MaxPath 4096
 #define MaxFilename 512
 
-void File_GetName(char *path,char *name);
+void File_GetName(char *path, char *name);
 
 int File_ExistePath(char *path);
 
@@ -31,10 +28,9 @@ long long File_TamanhoFichero(char *ficheros);
 int File_CrearDir(char *path);
 
 void File_IterateDir(char *path,
-	int (*func)(char *path,char *name,void *data),void *data);
+		int (*func)(char *path, char *name, void *data), void *data);
 
 void File_Borrar(char *path);
 void File_BorrarDirectorio(char *path);
 
-
 #endif
diff --git a/main.c b/main.c
index 32209ba..948fdae 100644
--- a/main.c
+++ b/main.c
@@ -8,246 +8,236 @@
 #include "filenode.h"
 #include "filenodecmp.h"
 
-void help(char *exe){
+void help(char *exe) {
 	char exeFilename[MaxPath];
-	File_GetName(exe,exeFilename);
+	File_GetName(exe, exeFilename);
 	printf("Modo de uso:\n");
-	printf("    %s info [file] {[file] {..}}\n",exeFilename);
-	printf("    %s scan [dir] [tree] \n",exeFilename);
-	printf("    %s rescan [dir] [tree] \n",exeFilename);
-	printf("    %s read [file] [tree]\n",exeFilename);
-	printf("    %s dir [dir]\n",exeFilename);
+	printf("    %s info [file] {[file] {..}}\n", exeFilename);
+	printf("    %s scan [dir] [tree] \n", exeFilename);
+	printf("    %s rescan [dir] [tree] \n", exeFilename);
+	printf("    %s read [file] [tree]\n", exeFilename);
+	printf("    %s dir [dir]\n", exeFilename);
 	printf("\n");
-	printf("    %s sync [dirIzquierda] [dirDerecha]\n",exeFilename);
-	printf("    %s resync [dirIzquierda] [dirDerecha]\n",exeFilename);
-	printf("    %s synctest [dirIzquierda] [dirDerecha]\n",exeFilename);
-	printf("    %s resynctest [dirIzquierda] [dirDerecha]\n",exeFilename);
+	printf("    %s sync [dirIzquierda] [dirDerecha]\n", exeFilename);
+	printf("    %s resync [dirIzquierda] [dirDerecha]\n", exeFilename);
+	printf("    %s synctest [dirIzquierda] [dirDerecha]\n", exeFilename);
+	printf("    %s resynctest [dirIzquierda] [dirDerecha]\n", exeFilename);
 	printf("\n");
-	printf("    %s copy [dirIzquierda] [dirDerecha]\n",exeFilename);
-	printf("    %s recopy [dirIzquierda] [dirDerecha]\n",exeFilename);
-	printf("    %s copytest [dirIzquierda] [dirDerecha]\n",exeFilename);
-	printf("    %s recopytest [dirIzquierda] [dirDerecha]\n",exeFilename);
+	printf("    %s copy [dirIzquierda] [dirDerecha]\n", exeFilename);
+	printf("    %s recopy [dirIzquierda] [dirDerecha]\n", exeFilename);
+	printf("    %s copytest [dirIzquierda] [dirDerecha]\n", exeFilename);
+	printf("    %s recopytest [dirIzquierda] [dirDerecha]\n", exeFilename);
 }
 
+FileNode *checkDir(char *path, int recheck);
+int sync(char *pathIzquierda, char *pathDerecha, int recheck, int dryrun);
 
-FileNode *checkDir(char *path,int recheck);
-int sync(char *pathIzquierda,char *pathDerecha,int recheck,int dryrun);
-
-
-int main(int argc,char *argv[]){
+int main(int argc, char *argv[]) {
 	FILE *f;
-	unsigned long crc=0;
+	unsigned long crc = 0;
 	FileTime ft;
 	int i;
 
-	if(argc<2){
+	if (argc < 2) {
 		help(argv[0]);
 		return 0;
 	}
 
-	if(!strcmp(argv[1],"info") && argc>=3){
+	if (!strcmp(argv[1], "info") && argc >= 3) {
 		// Informacion de ficheros
-		for(i=2;i<argc;i++){
-			if(File_ExistePath(argv[i])){
-				f=fopen(argv[i],"rb");
-				if(f){
-					crc=CRC_File(f);
+		for (i = 2; i < argc; i++) {
+			if (File_ExistePath(argv[i])) {
+				f = fopen(argv[i], "rb");
+				if (f) {
+					crc = CRC_File(f);
 					fclose(f);
 				}
-				ft=FileTime_Get(argv[i]);
-				printf("%s:\t[%08X]\t",argv[i],crc);
-				FileTime_Print(ft);printf("\n");
+				ft = FileTime_Get(argv[i]);
+				printf("%s:\t[%08X]\t", argv[i], crc);
+				FileTime_Print(ft);
+				printf("\n");
 			}
 		}
-	}else
-	if(!strcmp(argv[1],"scan") && argc==4){
+	} else if (!strcmp(argv[1], "scan") && argc == 4) {
 		// Scanear informacion de directorio y guardar arbol
 		FileNode *fn;
 		printf("Building FileNode..\n");
-		fn=FileNode_Build(argv[2]);
-		FileNode_Save(fn,argv[3]);
-	}else
-	if(!strcmp(argv[1],"rescan") && argc==4){
+		fn = FileNode_Build(argv[2]);
+		FileNode_Save(fn, argv[3]);
+	} else if (!strcmp(argv[1], "rescan") && argc == 4) {
 		// Scanear informacion de directorio y guardar arbol
 		FileNode *fn;
 		printf("Loading FileNode..\n");
-		fn=FileNode_Load(argv[3]);
-		if(fn){
+		fn = FileNode_Load(argv[3]);
+		if (fn) {
 			printf("Rebuilding FileNode..\n");
-			fn=FileNode_Refresh(fn,argv[2]);
-			FileNode_Save(fn,argv[3]);
+			fn = FileNode_Refresh(fn, argv[2]);
+			FileNode_Save(fn, argv[3]);
 		}
-	}else
-	if(!strcmp(argv[1],"read") && argc==3){
+	} else if (!strcmp(argv[1], "read") && argc == 3) {
 		// Leer informacion de arbol
 		FileNode *fn;
-		fn=FileNode_Load(argv[2]);
-		if(fn)FileNode_Print(fn);
-	}else
-	if(!strcmp(argv[1],"dir") && argc==3){
+		fn = FileNode_Load(argv[2]);
+		if (fn)
+			FileNode_Print(fn);
+	} else if (!strcmp(argv[1], "dir") && argc == 3) {
 		// Leer informacion de dir
-		char *path=argv[2];
+		char *path = argv[2];
 		char dirNodesFile[MaxPath];
 		FileNode *fn;
 
-		fn=checkDir(path,1);
-		if(fn){
+		fn = checkDir(path, 1);
+		if (fn) {
 			FileNode_Print(fn);
 		}
-	}else
-	if(!strcmp(argv[1],"sync") && argc==4){
+	} else if (!strcmp(argv[1], "sync") && argc == 4) {
 		// Sincronizar dos directorios
-		char *pathIzquierda=argv[2];
-		char *pathDerecha=argv[3];
-		sync(pathIzquierda,pathDerecha,1,0);
-	}else
-	if(!strcmp(argv[1],"resync") && argc==4){
+		char *pathIzquierda = argv[2];
+		char *pathDerecha = argv[3];
+		sync(pathIzquierda, pathDerecha, 1, 0);
+	} else if (!strcmp(argv[1], "resync") && argc == 4) {
 		// Sincronizar dos directorios
-		char *pathIzquierda=argv[2];
-		char *pathDerecha=argv[3];
-		sync(pathIzquierda,pathDerecha,0,0);
-	}else
-	if(!strcmp(argv[1],"synctest") && argc==4){
+		char *pathIzquierda = argv[2];
+		char *pathDerecha = argv[3];
+		sync(pathIzquierda, pathDerecha, 0, 0);
+	} else if (!strcmp(argv[1], "synctest") && argc == 4) {
 		// Sincronizar dos directorios
-		char *pathIzquierda=argv[2];
-		char *pathDerecha=argv[3];
-		sync(pathIzquierda,pathDerecha,1,1);
-	}else
-	if(!strcmp(argv[1],"resynctest") && argc==4){
+		char *pathIzquierda = argv[2];
+		char *pathDerecha = argv[3];
+		sync(pathIzquierda, pathDerecha, 1, 1);
+	} else if (!strcmp(argv[1], "resynctest") && argc == 4) {
 		// Sincronizar dos directorios
-		char *pathIzquierda=argv[2];
-		char *pathDerecha=argv[3];
-		sync(pathIzquierda,pathDerecha,0,1);
+		char *pathIzquierda = argv[2];
+		char *pathDerecha = argv[3];
+		sync(pathIzquierda, pathDerecha, 0, 1);
 
+	} else if (!strcmp(argv[1], "copy") && argc == 4) {
+		// Sincronizar dos directorios
+		char *pathIzquierda = argv[2];
+		char *pathDerecha = argv[3];
+		copy(pathIzquierda, pathDerecha, 1, 0);
+	} else if (!strcmp(argv[1], "recopy") && argc == 4) {
+		// Sincronizar dos directorios
+		char *pathIzquierda = argv[2];
+		char *pathDerecha = argv[3];
+		copy(pathIzquierda, pathDerecha, 0, 0);
+	} else if (!strcmp(argv[1], "copytest") && argc == 4) {
+		// Sincronizar dos directorios
+		char *pathIzquierda = argv[2];
+		char *pathDerecha = argv[3];
+		copy(pathIzquierda, pathDerecha, 1, 1);
+	} else if (!strcmp(argv[1], "recopytest") && argc == 4) {
+		// Sincronizar dos directorios
+		char *pathIzquierda = argv[2];
+		char *pathDerecha = argv[3];
+		copy(pathIzquierda, pathDerecha, 0, 1);
 
-	}else
-	if(!strcmp(argv[1],"copy") && argc==4){
-		// Sincronizar dos directorios
-		char *pathIzquierda=argv[2];
-		char *pathDerecha=argv[3];
-		copy(pathIzquierda,pathDerecha,1,0);
-	}else
-	if(!strcmp(argv[1],"recopy") && argc==4){
-		// Sincronizar dos directorios
-		char *pathIzquierda=argv[2];
-		char *pathDerecha=argv[3];
-		copy(pathIzquierda,pathDerecha,0,0);
-	}else
-	if(!strcmp(argv[1],"copytest") && argc==4){
-		// Sincronizar dos directorios
-		char *pathIzquierda=argv[2];
-		char *pathDerecha=argv[3];
-		copy(pathIzquierda,pathDerecha,1,1);
-	}else
-	if(!strcmp(argv[1],"recopytest") && argc==4){
-		// Sincronizar dos directorios
-		char *pathIzquierda=argv[2];
-		char *pathDerecha=argv[3];
-		copy(pathIzquierda,pathDerecha,0,1);
-
-
-	}else{
+	} else {
 		help(argv[0]);
 	}
 
-	return(0);
+	return (0);
 }
 
-
-
-FileNode *checkDir(char *path,int recheck){
+FileNode *checkDir(char *path, int recheck) {
 	char dirNodesFile[MaxPath];
 	FileNode *fn;
 	// Comprobar directorio
-	snprintf(dirNodesFile,MaxPath,"%s/"FileNode_Filename,path);
-	if(recheck){
-		printf("Checking Directory.. %s\n",path);
-		fn=FileNode_Load(dirNodesFile);
-		if(fn){
-			fn=FileNode_Refresh(fn,path);
-		}else{
-			fn=FileNode_Build(path);
+	snprintf(dirNodesFile, MaxPath, "%s/"FileNode_Filename, path);
+	if (recheck) {
+		printf("Checking Directory.. %s\n", path);
+		fn = FileNode_Load(dirNodesFile);
+		if (fn) {
+			fn = FileNode_Refresh(fn, path);
+		} else {
+			fn = FileNode_Build(path);
 		}
-		FileNode_Save(fn,dirNodesFile);
-	}else{
-		printf("Loading Directory.. %s\n",path);
-		fn=FileNode_Load(dirNodesFile);
-		if(!fn){
+		FileNode_Save(fn, dirNodesFile);
+	} else {
+		printf("Loading Directory.. %s\n", path);
+		fn = FileNode_Load(dirNodesFile);
+		if (!fn) {
 			printf("Error, no nodesFile.fs\n");
-			return NULL;
+			return NULL ;
 		}
 	}
 	return fn;
 }
 
-int sync(char *pathIzquierda,char *pathDerecha,int recheck,int dryrun){
+int sync(char *pathIzquierda, char *pathDerecha, int recheck, int dryrun) {
 	char dirNodesFileIzq[MaxPath];
 	char dirNodesFileDer[MaxPath];
-	FileNode *fnIzquierda,*fnDerecha;
+	FileNode *fnIzquierda, *fnDerecha;
 
 	// Comprobar y cargar directorios
-	if(!File_ExistePath(pathIzquierda) || !File_EsDirectorio(pathIzquierda)){
-		printf("Error, directory does not exist: %s\n",pathIzquierda);
+	if (!File_ExistePath(pathIzquierda) || !File_EsDirectorio(pathIzquierda)) {
+		printf("Error, directory does not exist: %s\n", pathIzquierda);
 		return 0;
 	}
-	if(!File_ExistePath(pathDerecha) || !File_EsDirectorio(pathDerecha)){
-		printf("Error, directory does not exist: %s\n",pathDerecha);
+	if (!File_ExistePath(pathDerecha) || !File_EsDirectorio(pathDerecha)) {
+		printf("Error, directory does not exist: %s\n", pathDerecha);
+		return 0;
+	}
+	fnIzquierda = checkDir(pathIzquierda, recheck);
+	if (!fnIzquierda) {
+		return 0;
+	}
+	fnDerecha = checkDir(pathDerecha, recheck);
+	if (!fnDerecha) {
 		return 0;
 	}
-	fnIzquierda=checkDir(pathIzquierda,recheck);
-	if(!fnIzquierda){return 0;}
-	fnDerecha=checkDir(pathDerecha,recheck);
-	if(!fnDerecha){return 0;}
-
 
 	// Construir acciones
 	printf("Building action list.. \n");
-	AccionFileNode *afn=NULL;
-	afn=AccionFileNode_BuildSync(fnIzquierda,fnDerecha);
+	AccionFileNode *afn = NULL;
+	afn = AccionFileNode_BuildSync(fnIzquierda, fnDerecha);
 
-	if(dryrun){
+	if (dryrun) {
 		// Mostrar lista de acciones
 		AccionFileNode_Print(afn);
-	}else{
+	} else {
 		// Ejecutar lista de acciones
-		AccionFileNode_RunList(afn,pathIzquierda,pathDerecha);
+		AccionFileNode_RunList(afn, pathIzquierda, pathDerecha);
 	}
 
-	return(1);
+	return (1);
 }
 
-int copy(char *pathIzquierda,char *pathDerecha,int recheck,int dryrun){
+int copy(char *pathIzquierda, char *pathDerecha, int recheck, int dryrun) {
 	char dirNodesFileIzq[MaxPath];
 	char dirNodesFileDer[MaxPath];
-	FileNode *fnIzquierda,*fnDerecha;
+	FileNode *fnIzquierda, *fnDerecha;
 
 	// Comprobar y cargar directorios
-	if(!File_ExistePath(pathIzquierda) || !File_EsDirectorio(pathIzquierda)){
-		printf("Error, directory does not exist: %s\n",pathIzquierda);
+	if (!File_ExistePath(pathIzquierda) || !File_EsDirectorio(pathIzquierda)) {
+		printf("Error, directory does not exist: %s\n", pathIzquierda);
 		return 0;
 	}
-	if(!File_ExistePath(pathDerecha) || !File_EsDirectorio(pathDerecha)){
-		printf("Error, directory does not exist: %s\n",pathDerecha);
+	if (!File_ExistePath(pathDerecha) || !File_EsDirectorio(pathDerecha)) {
+		printf("Error, directory does not exist: %s\n", pathDerecha);
+		return 0;
+	}
+	fnIzquierda = checkDir(pathIzquierda, recheck);
+	if (!fnIzquierda) {
+		return 0;
+	}
+	fnDerecha = checkDir(pathDerecha, recheck);
+	if (!fnDerecha) {
 		return 0;
 	}
-	fnIzquierda=checkDir(pathIzquierda,recheck);
-	if(!fnIzquierda){return 0;}
-	fnDerecha=checkDir(pathDerecha,recheck);
-	if(!fnDerecha){return 0;}
-
 
 	// Construir acciones
 	printf("Building action list.. \n");
-	AccionFileNode *afn=NULL;
-	afn=AccionFileNode_BuildCopy(fnIzquierda,fnDerecha);
+	AccionFileNode *afn = NULL;
+	afn = AccionFileNode_BuildCopy(fnIzquierda, fnDerecha);
 
-	if(dryrun){
+	if (dryrun) {
 		// Mostrar lista de acciones
 		AccionFileNode_Print(afn);
-	}else{
+	} else {
 		// Ejecutar lista de acciones
-		AccionFileNode_RunList(afn,pathIzquierda,pathDerecha);
+		AccionFileNode_RunList(afn, pathIzquierda, pathDerecha);
 	}
 
-	return(1);
+	return (1);
 }
diff --git a/util.c b/util.c
index 8baf119..e18bb57 100644
--- a/util.c
+++ b/util.c
@@ -4,12 +4,12 @@
 
 #include "util.h"
 
-char *String_Copy(char *str){
+char *String_Copy(char *str) {
 	char *strnew;
 	int len;
-	len=strlen(str);
-	strnew=malloc(len+1);
-	strcpy(strnew,str);
-	return(strnew);
+	len = strlen(str);
+	strnew = malloc(len + 1);
+	strcpy(strnew, str);
+	return (strnew);
 }