diff --git a/calculadora/calculadora.c b/calculadora/calculadora.c
index 818b7bd585ba1ce573d3b16a51f521ae9919fde0..b286d17c3204dd9a92153e191af867de2835c92b 100644
--- a/calculadora/calculadora.c
+++ b/calculadora/calculadora.c
@@ -31,22 +31,22 @@ typedef double t_operador;
    Retorna 1 se o caracter c representa um operador valido e 0 caso
    contrario. */
 int converte_operador(t_operador *op, char c) {
-	switch(c) {
-		case '+': *op = SOM; break;
-		case '-': *op = SUB; break;
-		case '*': *op = MUL; break;
-		case '/': *op = DIV; break;
-		case '^': *op = EXP; break;
-		default : return 0;
-	}
-	return 1;
+    switch(c) {
+        case '+': *op = SOM; break;
+        case '-': *op = SUB; break;
+        case '*': *op = MUL; break;
+        case '/': *op = DIV; break;
+        case '^': *op = EXP; break;
+        default : return 0;
+    }
+    return 1;
 }
 
 
 /* Retorna 1 se o operador op1 tem precedencia sobre o operador op2.
    Retorna 0 caso contrario. */
 int precedencia_maior_ou_igual(t_operador op1, t_operador op2) {
-	return floor(op1) >= floor(op2);
+    return floor(op1) >= floor(op2);
 }
 
 
@@ -54,32 +54,32 @@ int precedencia_maior_ou_igual(t_operador op1, t_operador op2) {
    operador sobre esses valores e empilha o resultado na pilha de 
    valores. */
 int opera(t_operador op, t_pilha *valores) {
-	double val_esq, val_dir;
-
-	if(!desempilha(&val_dir, valores))
-		return 0;
-	if(!desempilha(&val_esq, valores))
-		return 0;
-	if(op == SOM)
-		return empilha(val_esq + val_dir, valores);
-	if(op == SUB)
-		return empilha(val_esq - val_dir, valores);
-	if(op == MUL)
-		return empilha(val_esq * val_dir, valores);
-	if(op == DIV && val_dir != 0.0)
-		return empilha(val_esq / val_dir, valores);
-	if(op == EXP)
-		return empilha(pow(val_esq, val_dir), valores);
-
-	return 0;
+    double val_esq, val_dir;
+
+    if(!desempilha(&val_dir, valores))
+        return 0;
+    if(!desempilha(&val_esq, valores))
+        return 0;
+    if(op == SOM)
+        return empilha(val_esq + val_dir, valores);
+    if(op == SUB)
+        return empilha(val_esq - val_dir, valores);
+    if(op == MUL)
+        return empilha(val_esq * val_dir, valores);
+    if(op == DIV && val_dir != 0.0)
+        return empilha(val_esq / val_dir, valores);
+    if(op == EXP)
+        return empilha(pow(val_esq, val_dir), valores);
+
+    return 0;
 }
 
 
 /* Imprime na saida de erro (stderr) a mensagem de erro e a linha e 
    a coluna da entrada onde o erro foi detectado. */
 void erro(char *msg, int col, int *flag_erro) {
-	fprintf(stderr, "ERRO: %s (coluna %d)\n", msg, col);
-	*flag_erro = 1;
+    fprintf(stderr, "ERRO: %s (coluna %d)\n", msg, col);
+    *flag_erro = 1;
 }
 
 
@@ -90,32 +90,32 @@ void erro(char *msg, int col, int *flag_erro) {
    ne leitura ou ne alocação de memoria. */
 /*
 char* le_entrada() {
-	char *ent, *ret_realloc, *ret_fgets;
-	int tam, pos;
-
-	ent = NULL;
-	tam = 0;
-	pos = 0;
-	
-	do {
-		tam += TAM_ENTRADA;
-		ret_realloc = (char*) realloc(ent, sizeof(char) * tam);
-		if(!ret_realloc) {
-			free(ent);
-			return NULL;
-		}
-		ent = ret_realloc;
-		ent[tam - 1] = ' ';
-		ret_fgets = fgets(ent + pos, tam - pos, stdin);
-		pos = tam - 1;	
-	} while(ret_fgets && ent[tam - 1] == '\0' && ent[tam - 2] != '\n');
-	
-	if(!ret_fgets && tam == TAM_ENTRADA) {
-		free(ent);
-		return NULL;
-	}
-	
-	return ent;
+    char *ent, *ret_realloc, *ret_fgets;
+    int tam, pos;
+
+    ent = NULL;
+    tam = 0;
+    pos = 0;
+    
+    do {
+        tam += TAM_ENTRADA;
+        ret_realloc = (char*) realloc(ent, sizeof(char) * tam);
+        if(!ret_realloc) {
+            free(ent);
+            return NULL;
+        }
+        ent = ret_realloc;
+        ent[tam - 1] = ' ';
+        ret_fgets = fgets(ent + pos, tam - pos, stdin);
+        pos = tam - 1;    
+    } while(ret_fgets && ent[tam - 1] == '\0' && ent[tam - 2] != '\n');
+    
+    if(!ret_fgets && tam == TAM_ENTRADA) {
+        free(ent);
+        return NULL;
+    }
+    
+    return ent;
 }
 */
 
@@ -125,176 +125,176 @@ char* le_entrada() {
    ne leitura ou na alocação de memoria. Se o tamanho da entrada for 
    maior que o vetor de leitura, retorna NULL. */
 char* le_entrada() {
-	char *ent, *ret_fgets;
-	int tam;
-	
-	tam = TAM_ENTRADA;
-	ent = (char*) malloc(sizeof(char) * tam);
-	if(!ent)
-		return NULL;
-	ent[tam - 1] = ' ';
-	ret_fgets = fgets(ent, tam, stdin);
-	if(!ret_fgets || (ent[tam - 1] == '\0' && ent[tam - 2] != '\n')) {
-		free(ent);
-		return NULL;
-	}
-	return ent;
+    char *ent, *ret_fgets;
+    int tam;
+    
+    tam = TAM_ENTRADA;
+    ent = (char*) malloc(sizeof(char) * tam);
+    if(!ent)
+        return NULL;
+    ent[tam - 1] = ' ';
+    ret_fgets = fgets(ent, tam, stdin);
+    if(!ret_fgets || (ent[tam - 1] == '\0' && ent[tam - 2] != '\n')) {
+        free(ent);
+        return NULL;
+    }
+    return ent;
 }
 
 int main() {
-	t_pilha *pilha_valores, *pilha_operadores;
-	t_operador operador, op_topo;
-	double operando, resultado, memoria = 0.0;
-	char *entrada, *c, *prox;
-	int flag_erro = 0;
-
-	entrada = le_entrada();
-	if(!entrada) {
-		erro("erro de leitura", 0, &flag_erro);
-		return 1;
-	}
-
-	c = entrada;
-	/* Loop principal, le valores e realiza operacoes ate ler uma linha
-	   que contém "q" na primeira posição */
-	while(*c != 'q') {
-
-		pilha_valores = cria_pilha(TAM_PILHA);
-		if(!pilha_valores) {
-			erro("erro ao criar pilha de valores", 0, &flag_erro);
-			return 1;
-		}
-
-		pilha_operadores = cria_pilha(TAM_PILHA);
-		if(!pilha_operadores) {
-			erro("erro ao criar pilha de operadores", 0, &flag_erro);
-			return 1;
-		}
-
-		if( !(isdigit(*c) || *c == '('))
-			/* Se o primeiro caracter não for nem um dígito nem um abre parênteses,
-			   o formato está errado. */
-			erro("formato incorreto", c - entrada + 1, &flag_erro);
-
-		while(*c != 'q' && *c != '\n' && !flag_erro) {
-			/* Percorre o ponteiro c pela entrada até achar um q, o final da linha ou um erro. */
-
-			/* Caso 1: separadores */
-			if(*c == ' ' || *c == '\t')
-				/* Se for separador, passa para o proximo caracter. */
-				c++;
-
-			/* Caso 2: operando */
-			else if(isdigit(*c)) {
-				/* Se for [1..9] le um valor e empilha na pilha de valores. */
-				operando = strtod(c, &prox);
-				if(c == prox)
-					erro("operando incorreto", c - entrada + 1, &flag_erro);
-				else if(!empilha(operando, pilha_valores))
-					erro("pilha de valores cheia", c - entrada + 1, &flag_erro);
-				else 
-					c = prox;
-			}
-
-			/* Caso 3: abre parenteses */
-			else if(*c == '(') {
-				/* Se for abre parenteses, empilha PAR na pilha de operadores. */
-				if(!empilha(PAR, pilha_operadores))
-					erro("pilha de operadores cheia", c - entrada + 1, &flag_erro);
-				else
-					c++;
-			}
-
-			/* Caso 4: fecha parenteses */
-			else if(*c == ')') {
-				/* Se for fecha parenteses, processa a pilha de operadores até 
-				   encontar um PAR. */ 
-				while(topo(&op_topo, pilha_operadores) && op_topo != PAR && !flag_erro) {
-					desempilha(&op_topo, pilha_operadores);
-					if(!opera(op_topo, pilha_valores))
-						erro("formato incorreto", c - entrada + 1, &flag_erro);
-				}
-				if(pilha_vazia(pilha_operadores) ||
-				   (desempilha(&op_topo, pilha_operadores) && op_topo != PAR))
-					erro("formato incorreto", c - entrada + 1, &flag_erro);
-				else
-					c++;
-			}
-
-			/* Caso 5: operador */
-			else if(converte_operador(&operador, *c)) {
-				/* Se for um operador valido, verifica a precedencia em relacao
-				   ao topo da pilha de operadores. */
-				while(topo(&op_topo, pilha_operadores) &&
-					  op_topo != PAR &&
-					  precedencia_maior_ou_igual(op_topo, operador) &&
-					  !flag_erro) {
-					/* Enquando o topo da pilha tiver precedencia, desempilha e
-					   processa o operador do topo da pilha. */
-					desempilha(&op_topo, pilha_operadores);
-					if(!opera(op_topo, pilha_valores))
-						erro("formato incorreto", c - entrada + 1, &flag_erro);
-				}
-				if(!empilha(operador, pilha_operadores))
-					/* Empilha o novo operador na pilha de operadores. */
-					erro("pilha de operadores cheia", c - entrada + 1, &flag_erro);
-				else
-					c++;
-			}
-
-			/* Caso 6: memória */
-			else if(*c == 'm') {
-				/* Se for m, empilha o valor guardado na memória na pilha de valores */
-				if(!empilha(memoria, pilha_valores))
-					erro("pilha de valores cheia", c - entrada + 1, &flag_erro);
-				else
-					c++;
-			}
-
-			/* Caso 7: caracter invalido na entrada */
-			else
-				erro("caracter desconhecido", c - entrada + 1, &flag_erro);
-		}
-
-		/* Sai da leitura se encontrar um q em qualquer posição da entrada */
-		if(*c == 'q') break;
-
-		if(!flag_erro) {
-			/* Nesse ponto o processamento da entrada terminou (por enquanto sem erros)
-			   e pode ser o caso da pilha de operadores nao estar vazia. */
-			while(desempilha(&op_topo, pilha_operadores) && !flag_erro) {
-				/* Processa os operadores que restaram na pilha. */
-				if(!opera(op_topo, pilha_valores))
-					erro("formato incorreto", c - entrada + 1, &flag_erro);
-			}
-
-			/* Após o processamento, o resultado final da expressao esta no topo da 
-			   pilha de valores. A pilha deve conter apenas esse valor. */
-			if(!flag_erro) {
-				if(!desempilha(&resultado, pilha_valores) || !pilha_vazia(pilha_valores))
-					erro("formato incorreto", c - entrada + 1, &flag_erro);
-				else {
-					memoria = resultado;
-					printf("%.16g\n", resultado);
-				}
-			}
-		}
-		/* Libera a entrada e lê uma nova entrada. */
-
-		destroi_pilha(pilha_valores);
-		destroi_pilha(pilha_operadores);
-		free(entrada);
-
-		entrada = le_entrada();
-		if(!entrada)
-			erro("erro de leitura", 0, &flag_erro);
-
-		c = entrada;
-
-		flag_erro = 0;
-	}
-
-	free(entrada);
-
-	return 0;
+    t_pilha *pilha_valores, *pilha_operadores;
+    t_operador operador, op_topo;
+    double operando, resultado, memoria = 0.0;
+    char *entrada, *c, *prox;
+    int flag_erro = 0;
+
+    entrada = le_entrada();
+    if(!entrada) {
+        erro("erro de leitura", 0, &flag_erro);
+        return 1;
+    }
+
+    c = entrada;
+    /* Loop principal, le valores e realiza operacoes ate ler uma linha
+       que contém "q" na primeira posição */
+    while(*c != 'q') {
+
+        pilha_valores = cria_pilha(TAM_PILHA);
+        if(!pilha_valores) {
+            erro("erro ao criar pilha de valores", 0, &flag_erro);
+            return 1;
+        }
+
+        pilha_operadores = cria_pilha(TAM_PILHA);
+        if(!pilha_operadores) {
+            erro("erro ao criar pilha de operadores", 0, &flag_erro);
+            return 1;
+        }
+
+        if( !(isdigit(*c) || *c == '('))
+            /* Se o primeiro caracter não for nem um dígito nem um abre parênteses,
+               o formato está errado. */
+            erro("formato incorreto", c - entrada + 1, &flag_erro);
+
+        while(*c != 'q' && *c != '\n' && !flag_erro) {
+            /* Percorre o ponteiro c pela entrada até achar um q, o final da linha ou um erro. */
+
+            /* Caso 1: separadores */
+            if(*c == ' ' || *c == '\t')
+                /* Se for separador, passa para o proximo caracter. */
+                c++;
+
+            /* Caso 2: operando */
+            else if(isdigit(*c)) {
+                /* Se for [1..9] le um valor e empilha na pilha de valores. */
+                operando = strtod(c, &prox);
+                if(c == prox)
+                    erro("operando incorreto", c - entrada + 1, &flag_erro);
+                else if(!empilha(operando, pilha_valores))
+                    erro("pilha de valores cheia", c - entrada + 1, &flag_erro);
+                else 
+                    c = prox;
+            }
+
+            /* Caso 3: abre parenteses */
+            else if(*c == '(') {
+                /* Se for abre parenteses, empilha PAR na pilha de operadores. */
+                if(!empilha(PAR, pilha_operadores))
+                    erro("pilha de operadores cheia", c - entrada + 1, &flag_erro);
+                else
+                    c++;
+            }
+
+            /* Caso 4: fecha parenteses */
+            else if(*c == ')') {
+                /* Se for fecha parenteses, processa a pilha de operadores até 
+                   encontar um PAR. */ 
+                while(topo(&op_topo, pilha_operadores) && op_topo != PAR && !flag_erro) {
+                    desempilha(&op_topo, pilha_operadores);
+                    if(!opera(op_topo, pilha_valores))
+                        erro("formato incorreto", c - entrada + 1, &flag_erro);
+                }
+                if(pilha_vazia(pilha_operadores) ||
+                   (desempilha(&op_topo, pilha_operadores) && op_topo != PAR))
+                    erro("formato incorreto", c - entrada + 1, &flag_erro);
+                else
+                    c++;
+            }
+
+            /* Caso 5: operador */
+            else if(converte_operador(&operador, *c)) {
+                /* Se for um operador valido, verifica a precedencia em relacao
+                   ao topo da pilha de operadores. */
+                while(topo(&op_topo, pilha_operadores) &&
+                      op_topo != PAR &&
+                      precedencia_maior_ou_igual(op_topo, operador) &&
+                      !flag_erro) {
+                    /* Enquando o topo da pilha tiver precedencia, desempilha e
+                       processa o operador do topo da pilha. */
+                    desempilha(&op_topo, pilha_operadores);
+                    if(!opera(op_topo, pilha_valores))
+                        erro("formato incorreto", c - entrada + 1, &flag_erro);
+                }
+                if(!empilha(operador, pilha_operadores))
+                    /* Empilha o novo operador na pilha de operadores. */
+                    erro("pilha de operadores cheia", c - entrada + 1, &flag_erro);
+                else
+                    c++;
+            }
+
+            /* Caso 6: memória */
+            else if(*c == 'm') {
+                /* Se for m, empilha o valor guardado na memória na pilha de valores */
+                if(!empilha(memoria, pilha_valores))
+                    erro("pilha de valores cheia", c - entrada + 1, &flag_erro);
+                else
+                    c++;
+            }
+
+            /* Caso 7: caracter invalido na entrada */
+            else
+                erro("caracter desconhecido", c - entrada + 1, &flag_erro);
+        }
+
+        /* Sai da leitura se encontrar um q em qualquer posição da entrada */
+        if(*c == 'q') break;
+
+        if(!flag_erro) {
+            /* Nesse ponto o processamento da entrada terminou (por enquanto sem erros)
+               e pode ser o caso da pilha de operadores nao estar vazia. */
+            while(desempilha(&op_topo, pilha_operadores) && !flag_erro) {
+                /* Processa os operadores que restaram na pilha. */
+                if(!opera(op_topo, pilha_valores))
+                    erro("formato incorreto", c - entrada + 1, &flag_erro);
+            }
+
+            /* Após o processamento, o resultado final da expressao esta no topo da 
+               pilha de valores. A pilha deve conter apenas esse valor. */
+            if(!flag_erro) {
+                if(!desempilha(&resultado, pilha_valores) || !pilha_vazia(pilha_valores))
+                    erro("formato incorreto", c - entrada + 1, &flag_erro);
+                else {
+                    memoria = resultado;
+                    printf("%.16g\n", resultado);
+                }
+            }
+        }
+        /* Libera a entrada e lê uma nova entrada. */
+
+        destroi_pilha(pilha_valores);
+        destroi_pilha(pilha_operadores);
+        free(entrada);
+
+        entrada = le_entrada();
+        if(!entrada)
+            erro("erro de leitura", 0, &flag_erro);
+
+        c = entrada;
+
+        flag_erro = 0;
+    }
+
+    free(entrada);
+
+    return 0;
 }
diff --git a/calculadora/libpilha.c b/calculadora/libpilha.c
index 9a4384276a3728ac24e2c819daf60be2b33b76b9..b744eca1a657e6068cef7863e40939d79fb3572a 100644
--- a/calculadora/libpilha.c
+++ b/calculadora/libpilha.c
@@ -2,48 +2,48 @@
 #include "libpilha.h"
 
 t_pilha* cria_pilha(int n) {
-	t_pilha *p;
-	if ( !(p = malloc(sizeof(t_pilha) * n)) )
-		return NULL;
-
-	p->tam = n;
-	p->topo = -1;
-	
-	if ( !(p->v = malloc(sizeof(double) * n)) )
-		return NULL;
-	return p;
+    t_pilha *p;
+    if ( !(p = malloc(sizeof(t_pilha) * n)) )
+        return NULL;
+
+    p->tam = n;
+    p->topo = -1;
+    
+    if ( !(p->v = malloc(sizeof(double) * n)) )
+        return NULL;
+    return p;
 }
 
 t_pilha* destroi_pilha(t_pilha *p) {
-	free(p->v);
-	free(p);
-	return NULL;
+    free(p->v);
+    free(p);
+    return NULL;
 }
 
 int pilha_vazia(t_pilha *p) {
-	return p->topo == -1;
+    return p->topo == -1;
 }
 
 int empilha(double x, t_pilha *p) {
-	if (p->topo == p->tam)
-		return 0;
-	p->topo++;
-	p->v[p->topo] = x;
+    if (p->topo == p->tam)
+        return 0;
+    p->topo++;
+    p->v[p->topo] = x;
 
-	return 1;
+    return 1;
 }
 
 int desempilha(double *t, t_pilha *p) {
-	if (pilha_vazia(p))
-		return 0;
-	*t = p->v[p->topo];
-	p->topo--;
-	return 1;
+    if (pilha_vazia(p))
+        return 0;
+    *t = p->v[p->topo];
+    p->topo--;
+    return 1;
 }
 
 int topo(double *t, t_pilha *p) {
-	if (pilha_vazia(p))
-		return 0;
-	*t = p->v[p->topo];
-	return 1;
+    if (pilha_vazia(p))
+        return 0;
+    *t = p->v[p->topo];
+    return 1;
 }
diff --git a/t1/libconjunto.c b/t1/libconjunto.c
index daf98e3bbf5a0691a0a1511dd493cfe0b326543c..833129e3aa38fddfcf3a0be98cbc6646569661ff 100644
--- a/t1/libconjunto.c
+++ b/t1/libconjunto.c
@@ -6,231 +6,231 @@
  * como estamos trabalhando com conjuntos ordenados, eh uma busca binaria.
  * se o elemento nao esta no conjunto, retorna -1. */
 int busca_cjt(conjunto_t *c, int elemento) {
-	int inicio = 0;
-	int fim = cardinalidade_cjt(c) - 1;
-	int meio = fim / 2;
+    int inicio = 0;
+    int fim = cardinalidade_cjt(c) - 1;
+    int meio = fim / 2;
 
-	while (inicio <= fim && c->v[meio] != elemento) {
-		if (elemento > c->v[meio]) {
-			inicio = meio + 1;
-		} else {
-			fim = meio - 1;
-		}
-		meio = (inicio + fim) / 2;
-	}
+    while (inicio <= fim && c->v[meio] != elemento) {
+        if (elemento > c->v[meio]) {
+            inicio = meio + 1;
+        } else {
+            fim = meio - 1;
+        }
+        meio = (inicio + fim) / 2;
+    }
 
-	return inicio > fim ? -1 : meio;
+    return inicio > fim ? -1 : meio;
 }
 
 conjunto_t *cria_cjt(int max) {
-	conjunto_t *c;
-	if ( !(c = malloc(sizeof(conjunto_t))) )
-		return NULL;
-	c->max = max;
-	c->card = 0;
-	c->ptr = 0;
-	if ( !(c->v = malloc(sizeof(int) * max)) ) {
-		free(c);
-		return NULL;
-	}
-	return c;
+    conjunto_t *c;
+    if ( !(c = malloc(sizeof(conjunto_t))) )
+        return NULL;
+    c->max = max;
+    c->card = 0;
+    c->ptr = 0;
+    if ( !(c->v = malloc(sizeof(int) * max)) ) {
+        free(c);
+        return NULL;
+    }
+    return c;
 }
 
 conjunto_t *destroi_cjt(conjunto_t *c) {
-	free(c->v);
-	c->v = NULL;
-	free(c);
-	return NULL;
+    free(c->v);
+    c->v = NULL;
+    free(c);
+    return NULL;
 }
 
 int vazio_cjt(conjunto_t *c) {
-	return cardinalidade_cjt(c) == 0;	
+    return cardinalidade_cjt(c) == 0;    
 }
 
 int cardinalidade_cjt(conjunto_t *c) {
-	return c->card;
+    return c->card;
 }
 
 int insere_cjt(conjunto_t *c, int elemento) {
-	if (cardinalidade_cjt(c) == c->max)
-		return 0;
+    if (cardinalidade_cjt(c) == c->max)
+        return 0;
 
-	if (pertence_cjt(c, elemento))
-		return 1;
+    if (pertence_cjt(c, elemento))
+        return 1;
 
-	int i = cardinalidade_cjt(c);
-	while (i > 0 && c->v[i - 1] > elemento) {
-		c->v[i] = c->v[i - 1];
-		i--;
-	}
-	
-	c->v[i] = elemento;
-	c->card++;
-	return 1;
+    int i = cardinalidade_cjt(c);
+    while (i > 0 && c->v[i - 1] > elemento) {
+        c->v[i] = c->v[i - 1];
+        i--;
+    }
+    
+    c->v[i] = elemento;
+    c->card++;
+    return 1;
 }
 
 int retira_cjt(conjunto_t *c, int elemento) {
-	if (!(pertence_cjt(c, elemento)))
-		return 0;
+    if (!(pertence_cjt(c, elemento)))
+        return 0;
 
-	int i;
-	for(i = busca_cjt(c, elemento); i < cardinalidade_cjt(c)-1; i++) {
-		c->v[i] = c->v[i + 1];
-	}
+    int i;
+    for(i = busca_cjt(c, elemento); i < cardinalidade_cjt(c)-1; i++) {
+        c->v[i] = c->v[i + 1];
+    }
 
-	c->card--;
-	return 1;
+    c->card--;
+    return 1;
 }
 
 int pertence_cjt(conjunto_t *c, int elemento) {
-	return busca_cjt(c, elemento) != -1;
+    return busca_cjt(c, elemento) != -1;
 }
 
 int contido_cjt(conjunto_t *c1, conjunto_t *c2) {
-	int i;
-	for (i = 0; i < cardinalidade_cjt(c1); i++) {
-		if (!(pertence_cjt(c2, c1->v[i])))
-			return 0;
-	}
-	return 1;
+    int i;
+    for (i = 0; i < cardinalidade_cjt(c1); i++) {
+        if (!(pertence_cjt(c2, c1->v[i])))
+            return 0;
+    }
+    return 1;
 }
 
 int sao_iguais_cjt(conjunto_t *c1, conjunto_t *c2) {
-	return cardinalidade_cjt(c1) == cardinalidade_cjt(c2) && contido_cjt(c1, c2);
+    return cardinalidade_cjt(c1) == cardinalidade_cjt(c2) && contido_cjt(c1, c2);
 }
 
 conjunto_t *diferenca_cjt(conjunto_t *c1, conjunto_t *c2) {
-	conjunto_t *dif;
-	if ( !(dif = cria_cjt(c1->max)) )
-		return NULL;
+    conjunto_t *dif;
+    if ( !(dif = cria_cjt(c1->max)) )
+        return NULL;
 
-	int i;
-	for (i = 0; i < cardinalidade_cjt(c1); i++) {
-		if (!(pertence_cjt(c2, c1->v[i])))
-			insere_cjt(dif, c1->v[i]);
-	}
+    int i;
+    for (i = 0; i < cardinalidade_cjt(c1); i++) {
+        if (!(pertence_cjt(c2, c1->v[i])))
+            insere_cjt(dif, c1->v[i]);
+    }
 
-	return dif;
+    return dif;
 }
 
 conjunto_t *interseccao_cjt(conjunto_t *c1, conjunto_t *c2) {
-	conjunto_t *inter;
-	if ( !(inter = cria_cjt(c1->max)) )
-		return NULL;
-	
-	conjunto_t **menor_cjt = cardinalidade_cjt(c1) < cardinalidade_cjt(c2) ? &c1 : &c2;
-	conjunto_t **maior_cjt = cardinalidade_cjt(c1) > cardinalidade_cjt(c2) ? &c1 : &c2;
+    conjunto_t *inter;
+    if ( !(inter = cria_cjt(c1->max)) )
+        return NULL;
+    
+    conjunto_t **menor_cjt = cardinalidade_cjt(c1) < cardinalidade_cjt(c2) ? &c1 : &c2;
+    conjunto_t **maior_cjt = cardinalidade_cjt(c1) > cardinalidade_cjt(c2) ? &c1 : &c2;
 
-	int i;
-	for (i = 0; i < cardinalidade_cjt(*menor_cjt); i++) {
-		if (pertence_cjt(*maior_cjt, (*menor_cjt)->v[i]))
-			insere_cjt(inter, (*menor_cjt)->v[i]);
-	}
+    int i;
+    for (i = 0; i < cardinalidade_cjt(*menor_cjt); i++) {
+        if (pertence_cjt(*maior_cjt, (*menor_cjt)->v[i]))
+            insere_cjt(inter, (*menor_cjt)->v[i]);
+    }
 
-	return inter;
+    return inter;
 }
 
 conjunto_t *uniao_cjt(conjunto_t *c1, conjunto_t *c2) {
-	conjunto_t *uniao;
-	if ( !(uniao = cria_cjt(c1->max)) )
-		return NULL;
+    conjunto_t *uniao;
+    if ( !(uniao = cria_cjt(c1->max)) )
+        return NULL;
 
-	inicia_iterador_cjt(c1);
-	inicia_iterador_cjt(c2);
+    inicia_iterador_cjt(c1);
+    inicia_iterador_cjt(c2);
 
-	while (c1->ptr < cardinalidade_cjt(c1) && c2->ptr < cardinalidade_cjt(c2)) {
-		if (c1->v[c1->ptr] < c2->v[c2->ptr]) {
-			insere_cjt(uniao, c1->v[c1->ptr]);
-			c1->ptr++;
-		} else {
-			insere_cjt(uniao, c2->v[c2->ptr]);
-			c2->ptr++;
-		}
-	}
+    while (c1->ptr < cardinalidade_cjt(c1) && c2->ptr < cardinalidade_cjt(c2)) {
+        if (c1->v[c1->ptr] < c2->v[c2->ptr]) {
+            insere_cjt(uniao, c1->v[c1->ptr]);
+            c1->ptr++;
+        } else {
+            insere_cjt(uniao, c2->v[c2->ptr]);
+            c2->ptr++;
+        }
+    }
 
-	conjunto_t **ainda_falta = c1->ptr == cardinalidade_cjt(c1) ? &c2 : &c1;
+    conjunto_t **ainda_falta = c1->ptr == cardinalidade_cjt(c1) ? &c2 : &c1;
 
-	int i;
-	for (i = (*ainda_falta)->ptr; i < cardinalidade_cjt(*ainda_falta); i++) {
-		insere_cjt(uniao, (*ainda_falta)->v[i]);
-	}
+    int i;
+    for (i = (*ainda_falta)->ptr; i < cardinalidade_cjt(*ainda_falta); i++) {
+        insere_cjt(uniao, (*ainda_falta)->v[i]);
+    }
 
-	inicia_iterador_cjt(c1);
-	inicia_iterador_cjt(c2);
+    inicia_iterador_cjt(c1);
+    inicia_iterador_cjt(c2);
 
-	return uniao;
+    return uniao;
 }
 
 conjunto_t *copia_cjt(conjunto_t *c) {
-	conjunto_t *copia;
-	if ( !(copia = cria_cjt(c->max)) )
-		return NULL;
+    conjunto_t *copia;
+    if ( !(copia = cria_cjt(c->max)) )
+        return NULL;
 
-	int i;
-	for (i = 0; i < cardinalidade_cjt(c); i++) {
-		insere_cjt(copia, c->v[i]);
-	}
+    int i;
+    for (i = 0; i < cardinalidade_cjt(c); i++) {
+        insere_cjt(copia, c->v[i]);
+    }
 
-	return copia;
+    return copia;
 }
 
 conjunto_t *cria_subcjt_cjt(conjunto_t *c, int n) {
-	if (n >= cardinalidade_cjt(c))
-		return copia_cjt(c);
-
-	conjunto_t *sub;
-	if ( !(sub = cria_cjt(c->max)) )
-		return NULL;
-
-	conjunto_t *disponiveis;
-	if ( !(disponiveis = copia_cjt(c)) ) {
-		free(sub);
-		return NULL;
-	}
-
-	int i;
-	int aleat;
-	for (i = 0; i < n; i++) {
-		aleat = rand() % cardinalidade_cjt(disponiveis);
-		insere_cjt(sub, disponiveis->v[aleat]);
-		retira_cjt(disponiveis, disponiveis->v[aleat]);
-	}
-	
-	destroi_cjt(disponiveis);
-	return sub;
+    if (n >= cardinalidade_cjt(c))
+        return copia_cjt(c);
+
+    conjunto_t *sub;
+    if ( !(sub = cria_cjt(c->max)) )
+        return NULL;
+
+    conjunto_t *disponiveis;
+    if ( !(disponiveis = copia_cjt(c)) ) {
+        free(sub);
+        return NULL;
+    }
+
+    int i;
+    int aleat;
+    for (i = 0; i < n; i++) {
+        aleat = rand() % cardinalidade_cjt(disponiveis);
+        insere_cjt(sub, disponiveis->v[aleat]);
+        retira_cjt(disponiveis, disponiveis->v[aleat]);
+    }
+    
+    destroi_cjt(disponiveis);
+    return sub;
 }
 
 void imprime_cjt(conjunto_t *c) {
-	if (vazio_cjt(c)) {
-		printf("Conjunto vazio.\n");
-		return;
-	}
+    if (vazio_cjt(c)) {
+        printf("Conjunto vazio.\n");
+        return;
+    }
 
-	int i;
-	printf("%d", c->v[0]);
-	for (i = 1; i < cardinalidade_cjt(c); i++)
-		printf(" %d", c->v[i]);
-	printf("\n");
+    int i;
+    printf("%d", c->v[0]);
+    for (i = 1; i < cardinalidade_cjt(c); i++)
+        printf(" %d", c->v[i]);
+    printf("\n");
 }
 
 void inicia_iterador_cjt(conjunto_t *c) {
-	c->ptr = 0;
+    c->ptr = 0;
 }
 
 int incrementa_iterador_cjt(conjunto_t *c, int *ret_iterador) {
-	*ret_iterador = c->v[c->ptr];
-	c->ptr++;
-	if (c->ptr > cardinalidade_cjt(c))
-		return 0;
-	return 1;
+    *ret_iterador = c->v[c->ptr];
+    c->ptr++;
+    if (c->ptr > cardinalidade_cjt(c))
+        return 0;
+    return 1;
 }
 
 int retira_um_elemento_cjt(conjunto_t *c) {
-	int aleat = rand() % cardinalidade_cjt(c);
-	int retirar = c->v[aleat];
-	int i;
-	for (i = aleat; i < cardinalidade_cjt(c)-1; i++)
-		c->v[i] = c->v[i + 1];
-	c->card--;
-	return retirar;
+    int aleat = rand() % cardinalidade_cjt(c);
+    int retirar = c->v[aleat];
+    int i;
+    for (i = aleat; i < cardinalidade_cjt(c)-1; i++)
+        c->v[i] = c->v[i + 1];
+    c->card--;
+    return retirar;
 }
diff --git a/t1/libfila.c b/t1/libfila.c
index f6a067a788c802c56824ab630df75aa40425b8e1..4a82b64ff9988655eb55eb2ba39a2a8ba7e3d1b5 100644
--- a/t1/libfila.c
+++ b/t1/libfila.c
@@ -3,79 +3,79 @@
 #include "libfila.h"
 
 fila_t *cria_fila() {
-	fila_t *f;
-	if ( !(f = malloc(sizeof(fila_t))) )
-		return NULL;
-	
-	f->tamanho = 0;
-	f->ini = NULL;
-	f->fim = NULL;
-	return f;
+    fila_t *f;
+    if ( !(f = malloc(sizeof(fila_t))) )
+        return NULL;
+    
+    f->tamanho = 0;
+    f->ini = NULL;
+    f->fim = NULL;
+    return f;
 }
 
 fila_t *destroi_fila(fila_t *f) {
-	int e = 0;
+    int e = 0;
 
-	while (f->ini != NULL) {
-		retira_fila(f, &e);
-	}
+    while (f->ini != NULL) {
+        retira_fila(f, &e);
+    }
 
-	free(f);
-	return NULL;
+    free(f);
+    return NULL;
 }
 
 int vazia_fila(fila_t *f) {
-	return f->tamanho == 0;
+    return f->tamanho == 0;
 }
 
 int tamanho_fila(fila_t *f) {
-	return f->tamanho;
+    return f->tamanho;
 }
 
 int insere_fila(fila_t *f, int elemento) {
-	nodo_f_t *novo;
-	if ( !(novo = malloc(sizeof(nodo_f_t))) )
-		return 0;
-	novo->elem = elemento;
-	novo->prox = NULL;
+    nodo_f_t *novo;
+    if ( !(novo = malloc(sizeof(nodo_f_t))) )
+        return 0;
+    novo->elem = elemento;
+    novo->prox = NULL;
 
-	(f->tamanho)++;
+    (f->tamanho)++;
 
-	if (tamanho_fila(f) == 1) {
-		f->ini = novo;
-		f->fim = novo;
-		return 1;
-	}
+    if (tamanho_fila(f) == 1) {
+        f->ini = novo;
+        f->fim = novo;
+        return 1;
+    }
 
-	f->fim->prox = novo;
-	f->fim = novo;
-	return 1;
+    f->fim->prox = novo;
+    f->fim = novo;
+    return 1;
 }
 
 int retira_fila(fila_t *f, int *elemento) {
-	if (vazia_fila(f))
-		return 0;
-	
-	*elemento = f->ini->elem;
-	nodo_f_t *temp = f->ini->prox;
-	free(f->ini);
-	f->ini = temp;
-	(f->tamanho)--;
-	return 1;
+    if (vazia_fila(f))
+        return 0;
+    
+    *elemento = f->ini->elem;
+    nodo_f_t *temp = f->ini->prox;
+    free(f->ini);
+    f->ini = temp;
+    (f->tamanho)--;
+    return 1;
 }
 
 void imprime_fila(fila_t *f) {
-	if (vazia_fila(f))
-		return;
+    if (vazia_fila(f))
+        return;
 
-	nodo_f_t *atual = f->ini;
-	printf("%d", atual->elem);
+    nodo_f_t *atual = f->ini;
+    printf("%d", atual->elem);
 
-	int i;
-	for (i = 1; i < tamanho_fila(f); i++) {
-		atual = atual->prox;
-		printf(" %d", atual->elem);
-	}
-	
-	printf("\n");
+    int i;
+    for (i = 1; i < tamanho_fila(f); i++) {
+        atual = atual->prox;
+        printf(" %d", atual->elem);
+    }
+    
+    printf("\n");
 }
diff --git a/t1/liblef.c b/t1/liblef.c
index aaaf468035e828cccdb7e128e39d78d8f58a9dd3..06335008b119b69c367a5ee724a8c44b718413a7 100644
--- a/t1/liblef.c
+++ b/t1/liblef.c
@@ -3,93 +3,93 @@
 #include "liblef.h"
 
 lef_t *cria_lef() {
-	lef_t *l;
-	if ( !(l = malloc(sizeof(lef_t))) )
-		return NULL;
+    lef_t *l;
+    if ( !(l = malloc(sizeof(lef_t))) )
+        return NULL;
 
-	l->Primeiro = NULL;
-	
-	return l;
+    l->Primeiro = NULL;
+    
+    return l;
 }
 
 lef_t *destroi_lef(lef_t *l) {
-	nodo_lef_t *aux;
-	while (l->Primeiro != NULL) {
-		aux = l->Primeiro;
-		l->Primeiro = l->Primeiro->prox;
-		free(aux->evento);
-		free(aux);
-	}
+    nodo_lef_t *aux;
+    while (l->Primeiro != NULL) {
+        aux = l->Primeiro;
+        l->Primeiro = l->Primeiro->prox;
+        free(aux->evento);
+        free(aux);
+    }
 
-	free(l);
+    free(l);
 
-	return NULL;
+    return NULL;
 }
 
 int adiciona_inicio_lef(lef_t *l, evento_t *evento) {
-	nodo_lef_t *novo_nodo;
-	if ( !(novo_nodo = malloc(sizeof(nodo_lef_t))) )
-		return 0;
-	
-	evento_t *novo_evento;
-	if ( !(novo_evento = malloc(sizeof(evento_t))) ) {
-		free(novo_nodo);
-		return 0;
-	}
+    nodo_lef_t *novo_nodo;
+    if ( !(novo_nodo = malloc(sizeof(nodo_lef_t))) )
+        return 0;
+    
+    evento_t *novo_evento;
+    if ( !(novo_evento = malloc(sizeof(evento_t))) ) {
+        free(novo_nodo);
+        return 0;
+    }
 
-	memcpy(novo_evento, evento, sizeof(evento_t));
+    memcpy(novo_evento, evento, sizeof(evento_t));
 
-	novo_nodo->evento = novo_evento;
+    novo_nodo->evento = novo_evento;
 
-	novo_nodo->prox = l->Primeiro;
-	l->Primeiro = novo_nodo;
+    novo_nodo->prox = l->Primeiro;
+    l->Primeiro = novo_nodo;
 
-	return 1;
+    return 1;
 }
 
 int adiciona_ordem_lef(lef_t *l, evento_t *evento) {
-	nodo_lef_t *novo_nodo;
-	if ( !(novo_nodo = malloc(sizeof(nodo_lef_t))) )
-		return 0;
-	
-	evento_t *novo_evento;
-	if ( !(novo_evento = malloc(sizeof(evento_t))) ) {
-		free(novo_nodo);
-		return 0;
-	}
-
-	memcpy(novo_evento, evento, sizeof(evento_t));
-	
-	novo_nodo->prox = l->Primeiro;
-	novo_nodo->evento = novo_evento;
-
-	if (l->Primeiro == NULL || l->Primeiro->evento->tempo > novo_nodo->evento->tempo) {
-		l->Primeiro = novo_nodo;
-		return 1;
-	}
-
-	nodo_lef_t *atual = l->Primeiro;
-	
-	while (atual->prox && atual->prox->evento->tempo < novo_nodo->evento->tempo)
-		atual = atual->prox;
-
-	novo_nodo->prox = atual->prox;
-	atual->prox = novo_nodo;
-
-	return 1;
+    nodo_lef_t *novo_nodo;
+    if ( !(novo_nodo = malloc(sizeof(nodo_lef_t))) )
+        return 0;
+    
+    evento_t *novo_evento;
+    if ( !(novo_evento = malloc(sizeof(evento_t))) ) {
+        free(novo_nodo);
+        return 0;
+    }
+
+    memcpy(novo_evento, evento, sizeof(evento_t));
+    
+    novo_nodo->prox = l->Primeiro;
+    novo_nodo->evento = novo_evento;
+
+    if (l->Primeiro == NULL || l->Primeiro->evento->tempo > novo_nodo->evento->tempo) {
+        l->Primeiro = novo_nodo;
+        return 1;
+    }
+
+    nodo_lef_t *atual = l->Primeiro;
+    
+    while (atual->prox && atual->prox->evento->tempo < novo_nodo->evento->tempo)
+        atual = atual->prox;
+
+    novo_nodo->prox = atual->prox;
+    atual->prox = novo_nodo;
+
+    return 1;
 }
 
 evento_t *obtem_primeiro_lef(lef_t *l) {
-	if (l->Primeiro == NULL)
-		return NULL;
-	
-	nodo_lef_t *aux = l->Primeiro;
-	
-	evento_t *e = l->Primeiro->evento;
-	
-	l->Primeiro = l->Primeiro->prox;
-
-	free(aux);
-
-	return e;
+    if (l->Primeiro == NULL)
+        return NULL;
+    
+    nodo_lef_t *aux = l->Primeiro;
+    
+    evento_t *e = l->Primeiro->evento;
+    
+    l->Primeiro = l->Primeiro->prox;
+
+    free(aux);
+
+    return e;
 }
diff --git a/t1/mundo.c b/t1/mundo.c
index 850765ab85d3abb25ccc133f3b5c4ad0c3932949..29d5062de9652c84046622d89663d7febd690215 100644
--- a/t1/mundo.c
+++ b/t1/mundo.c
@@ -6,11 +6,11 @@
 #include "libfila.h"
 #include "liblef.h"
 
-#define MEM_ERROR_EXIT												\
-	do {															\
-		fprintf(stderr, "Erro: não foi possível alocar memória.");	\
-		exit(1);													\
-	} while(0)
+#define MEM_ERROR_EXIT                                                \
+    do {                                                            \
+        fprintf(stderr, "Erro: não foi possível alocar memória.");    \
+        exit(1);                                                    \
+    } while(0)
 
 #define CHEGADA 0
 #define SAIDA 1
@@ -18,335 +18,335 @@
 #define FIM 3
 
 typedef struct {
-	int id;
-	int paciencia;
-	int idade;
-	int exp;
-	conjunto_t *habilidades_do_heroi;
+    int id;
+    int paciencia;
+    int idade;
+    int exp;
+    conjunto_t *habilidades_do_heroi;
 } heroi_t;
 
 typedef struct {
-	int id;
-	int lotacao_max;
-	conjunto_t *publico;
-	fila_t *fila;
-	int posx;
-	int posy;
+    int id;
+    int lotacao_max;
+    conjunto_t *publico;
+    fila_t *fila;
+    int posx;
+    int posy;
 } local_t;
 
 typedef struct {
-	int tempo_atual;
-	int tamanho_mundo; /* o mundo é um quadrado */
-	int fim_do_mundo;
-	int n_missoes;
-	conjunto_t *cj_habilidades;
-	int n_herois;
-	int n_locais;
-	heroi_t *herois;
-	local_t *locais;
+    int tempo_atual;
+    int tamanho_mundo; /* o mundo é um quadrado */
+    int fim_do_mundo;
+    int n_missoes;
+    conjunto_t *cj_habilidades;
+    int n_herois;
+    int n_locais;
+    heroi_t *herois;
+    local_t *locais;
 } mundo_t;
 
 /* retorna um inteiro aleatório entre a e b (inclusive) */
 int aleat(int a, int b) {
-	return rand() % b + 1 + a;
+    return rand() % b + 1 + a;
 }
 
 /* retorna a distancia euclidiana entre dois locais em double */
 double distancia(local_t loc1, local_t loc2) {
-	int deltax = loc2.posx - loc1.posx;
-	int deltay = loc2.posy - loc1.posy;
-	int quadrado_da_distancia = deltax * deltax + deltay * deltay;
-	return sqrt((double)quadrado_da_distancia);
+    int deltax = loc2.posx - loc1.posx;
+    int deltay = loc2.posy - loc1.posy;
+    int quadrado_da_distancia = deltax * deltax + deltay * deltay;
+    return sqrt((double)quadrado_da_distancia);
 }
 
 int max(int a, int b) {
-	return a > b ? a : b; 
+    return a > b ? a : b; 
 }
 
 int vazia_lef(lef_t *l) {
-	return l->Primeiro == NULL;
+    return l->Primeiro == NULL;
 }
 
 heroi_t inicializa_heroi(int id, conjunto_t *conjunto_de_habilidades) {
-	heroi_t h;
-	
-	h.id = id;
-	h.paciencia = aleat(0, 100);
-	h.idade = aleat(18, 100);
-	h.exp = 0;
+    heroi_t h;
+    
+    h.id = id;
+    h.paciencia = aleat(0, 100);
+    h.idade = aleat(18, 100);
+    h.exp = 0;
 
-	if ( !(h.habilidades_do_heroi = cria_subcjt_cjt(conjunto_de_habilidades, aleat(2, 5))) )
-		MEM_ERROR_EXIT;
+    if ( !(h.habilidades_do_heroi = cria_subcjt_cjt(conjunto_de_habilidades, aleat(2, 5))) )
+        MEM_ERROR_EXIT;
 
-	return h;
+    return h;
 }
 
 local_t inicializa_local(int id, int tamanho_mundo) {
-	local_t l;
-	
-	l.id = id;
-	l.lotacao_max = aleat(5, 30);
+    local_t l;
+    
+    l.id = id;
+    l.lotacao_max = aleat(5, 30);
 
-	if ( !(l.publico = cria_cjt(l.lotacao_max)) )
-		MEM_ERROR_EXIT;
+    if ( !(l.publico = cria_cjt(l.lotacao_max)) )
+        MEM_ERROR_EXIT;
 
-	if ( !(l.fila = cria_fila()) )
-		MEM_ERROR_EXIT;
+    if ( !(l.fila = cria_fila()) )
+        MEM_ERROR_EXIT;
 
-	l.posx = aleat(0, tamanho_mundo-1);
-	l.posy = aleat(0, tamanho_mundo-1);
+    l.posx = aleat(0, tamanho_mundo-1);
+    l.posy = aleat(0, tamanho_mundo-1);
 
-	return l;
+    return l;
 }
 
 mundo_t *cria_mundo(lef_t *lista_de_eventos) {
-	mundo_t *m;
-	if ( !(m = malloc(sizeof(mundo_t))) )
-		MEM_ERROR_EXIT;
-	
-	m->tempo_atual = 0;
-	m->tamanho_mundo = 20000;
-	m->fim_do_mundo = 34944;
-	m->n_missoes = m->fim_do_mundo / 100;
-
-	const int n_habilidades = 10;
-	if ( !(m->cj_habilidades = cria_cjt(n_habilidades)) )
-		MEM_ERROR_EXIT;
-	int i;
-	for (i = 0; i < n_habilidades; i++)
-		insere_cjt(m->cj_habilidades, i);
-
-	m->n_herois = n_habilidades * 5;
-	m->n_locais = m->n_herois / 6;
-
-	/* cria vetor de heróis e preenche */
-	if ( !(m->herois = malloc(m->n_herois * sizeof(heroi_t))) )
-		MEM_ERROR_EXIT;
-	for (i = 0; i < m->n_herois; i++)
-		m->herois[i] = inicializa_heroi(i, m->cj_habilidades);
-
-	/* cria vetor de locais e preenche */
-	if ( !(m->locais = malloc(m->n_locais * sizeof(local_t))) )
-		MEM_ERROR_EXIT;
-	for (i = 0; i < m->n_locais; i++)
-		m->locais[i] = inicializa_local(i, m->tamanho_mundo);
-
-	/* para cada herói, cria evento de chegada e insere na lef */
-	/* evento_t *evento_chegada_heroi; */
-	for (i = 0; i < m->n_herois; i++) {
-		evento_t evento_chegada_heroi = { aleat(0, 96*7), CHEGADA, m->herois[i].id, aleat(0, m->n_locais-1) };
-		adiciona_ordem_lef(lista_de_eventos, &evento_chegada_heroi);
-	}
-
-	/* para cada missao, cria evento e insere na lef */
-	for (i = 0; i < m->n_missoes; i++) {
-		evento_t evento_missao = { aleat(0, m->fim_do_mundo), MISSAO, i, 0 };
-		adiciona_ordem_lef(lista_de_eventos, &evento_missao);
-	}
-
-	/* cria evento de fim e insere na lef */
-	evento_t fim = { m->fim_do_mundo, FIM, 0, 0 };
-	adiciona_ordem_lef(lista_de_eventos, &fim);
-
-	return m;
+    mundo_t *m;
+    if ( !(m = malloc(sizeof(mundo_t))) )
+        MEM_ERROR_EXIT;
+    
+    m->tempo_atual = 0;
+    m->tamanho_mundo = 20000;
+    m->fim_do_mundo = 34944;
+    m->n_missoes = m->fim_do_mundo / 100;
+
+    const int n_habilidades = 10;
+    if ( !(m->cj_habilidades = cria_cjt(n_habilidades)) )
+        MEM_ERROR_EXIT;
+    int i;
+    for (i = 0; i < n_habilidades; i++)
+        insere_cjt(m->cj_habilidades, i);
+
+    m->n_herois = n_habilidades * 5;
+    m->n_locais = m->n_herois / 6;
+
+    /* cria vetor de heróis e preenche */
+    if ( !(m->herois = malloc(m->n_herois * sizeof(heroi_t))) )
+        MEM_ERROR_EXIT;
+    for (i = 0; i < m->n_herois; i++)
+        m->herois[i] = inicializa_heroi(i, m->cj_habilidades);
+
+    /* cria vetor de locais e preenche */
+    if ( !(m->locais = malloc(m->n_locais * sizeof(local_t))) )
+        MEM_ERROR_EXIT;
+    for (i = 0; i < m->n_locais; i++)
+        m->locais[i] = inicializa_local(i, m->tamanho_mundo);
+
+    /* para cada herói, cria evento de chegada e insere na lef */
+    /* evento_t *evento_chegada_heroi; */
+    for (i = 0; i < m->n_herois; i++) {
+        evento_t evento_chegada_heroi = { aleat(0, 96*7), CHEGADA, m->herois[i].id, aleat(0, m->n_locais-1) };
+        adiciona_ordem_lef(lista_de_eventos, &evento_chegada_heroi);
+    }
+
+    /* para cada missao, cria evento e insere na lef */
+    for (i = 0; i < m->n_missoes; i++) {
+        evento_t evento_missao = { aleat(0, m->fim_do_mundo), MISSAO, i, 0 };
+        adiciona_ordem_lef(lista_de_eventos, &evento_missao);
+    }
+
+    /* cria evento de fim e insere na lef */
+    evento_t fim = { m->fim_do_mundo, FIM, 0, 0 };
+    adiciona_ordem_lef(lista_de_eventos, &fim);
+
+    return m;
 }
 
 int local_lotado(int id_local, mundo_t *m) {
-	return cardinalidade_cjt(m->locais[id_local].publico) >= m->locais[id_local].lotacao_max;
+    return cardinalidade_cjt(m->locais[id_local].publico) >= m->locais[id_local].lotacao_max;
 }
 
 int heroi_tem_paciencia(int id_heroi, int id_local, mundo_t *m) {
-	return m->herois[id_heroi].paciencia/4 > tamanho_fila(m->locais[id_local].fila);
+    return m->herois[id_heroi].paciencia/4 > tamanho_fila(m->locais[id_local].fila);
 }
 
 int velocidade_heroi(heroi_t heroi) {
-	return 100 - max(0, heroi.idade - 40);
+    return 100 - max(0, heroi.idade - 40);
 }
 
 conjunto_t *escolhe_menor_equipe(conjunto_t *missao, int id_missao, mundo_t *m, local_t *local_encontrado) {
-	conjunto_t *menor;
-	if ( !(menor = cria_cjt(cardinalidade_cjt(m->cj_habilidades))) )
-		MEM_ERROR_EXIT;
-	conjunto_t *uniao_old;
-	conjunto_t *uniao;
-	int i, j, id_heroi_atual;
-	
-	for (i = 0; i < m->n_locais; i++) {
-		if (vazio_cjt(m->locais[i].publico)) continue;
-
-		/* copia o conjunto de habilidades do primeiro herói do local atual */
-		inicia_iterador_cjt(m->locais[i].publico);
-		incrementa_iterador_cjt(m->locais[i].publico, &id_heroi_atual);
-		if ( !(uniao = copia_cjt(m->herois[id_heroi_atual].habilidades_do_heroi)) )
-			MEM_ERROR_EXIT;
-
-		/* faz a união entre os conjuntos de habilidades de todos os heróis do local atual */
-		for (j = 1; j < cardinalidade_cjt(m->locais[i].publico); j++) {
-			uniao_old = uniao;
-			incrementa_iterador_cjt(m->locais[i].publico, &id_heroi_atual);
-			uniao = uniao_cjt(uniao, m->herois[id_heroi_atual].habilidades_do_heroi);
-			uniao_old = destroi_cjt(uniao_old);
-		}
-
-		printf("%6d:MISSAO %3d HAB_EQL %d:", m->tempo_atual, id_missao, m->locais[i].id);
-		imprime_cjt(uniao);
-
-		/* compara se o conjunto construído contém a missao e é menor que o achado anteriormente */
-		if (contido_cjt(missao, uniao)) {
-			if (vazio_cjt(menor) || cardinalidade_cjt(uniao) < cardinalidade_cjt(menor)) {
-				menor = destroi_cjt(menor);
-				if ( !(menor = copia_cjt(uniao)) )
-					MEM_ERROR_EXIT;
-				*local_encontrado = m->locais[i];
-			}
-		}
-		uniao = destroi_cjt(uniao);
-	}
-	
-	return menor;
+    conjunto_t *menor;
+    if ( !(menor = cria_cjt(cardinalidade_cjt(m->cj_habilidades))) )
+        MEM_ERROR_EXIT;
+    conjunto_t *uniao_old;
+    conjunto_t *uniao;
+    int i, j, id_heroi_atual;
+    
+    for (i = 0; i < m->n_locais; i++) {
+        if (vazio_cjt(m->locais[i].publico)) continue;
+
+        /* copia o conjunto de habilidades do primeiro herói do local atual */
+        inicia_iterador_cjt(m->locais[i].publico);
+        incrementa_iterador_cjt(m->locais[i].publico, &id_heroi_atual);
+        if ( !(uniao = copia_cjt(m->herois[id_heroi_atual].habilidades_do_heroi)) )
+            MEM_ERROR_EXIT;
+
+        /* faz a união entre os conjuntos de habilidades de todos os heróis do local atual */
+        for (j = 1; j < cardinalidade_cjt(m->locais[i].publico); j++) {
+            uniao_old = uniao;
+            incrementa_iterador_cjt(m->locais[i].publico, &id_heroi_atual);
+            uniao = uniao_cjt(uniao, m->herois[id_heroi_atual].habilidades_do_heroi);
+            uniao_old = destroi_cjt(uniao_old);
+        }
+
+        printf("%6d:MISSAO %3d HAB_EQL %d:", m->tempo_atual, id_missao, m->locais[i].id);
+        imprime_cjt(uniao);
+
+        /* compara se o conjunto construído contém a missao e é menor que o achado anteriormente */
+        if (contido_cjt(missao, uniao)) {
+            if (vazio_cjt(menor) || cardinalidade_cjt(uniao) < cardinalidade_cjt(menor)) {
+                menor = destroi_cjt(menor);
+                if ( !(menor = copia_cjt(uniao)) )
+                    MEM_ERROR_EXIT;
+                *local_encontrado = m->locais[i];
+            }
+        }
+        uniao = destroi_cjt(uniao);
+    }
+    
+    return menor;
 }
 
 void trata_evento_chegada(int id_heroi, int id_local, mundo_t *m, lef_t *lista_de_eventos) {
-	printf("%6d:CHEGA HEROI %2d Local %d (%2d/%2d), ",
-			m->tempo_atual,
-			id_heroi,
-			id_local,
-			cardinalidade_cjt(m->locais[id_local].publico),
-			m->locais[id_local].lotacao_max);
-
-	if (local_lotado(id_local, m)) {
-		if (heroi_tem_paciencia(id_heroi, id_local, m)) {
-			insere_fila(m->locais[id_local].fila, id_heroi);
-			printf("FILA %d\n", tamanho_fila(m->locais[id_local].fila));
-			return;
-		}
-
-		printf("DESISTE\n");
-		evento_t saida = { m->tempo_atual, SAIDA, id_heroi, id_local };
-		adiciona_ordem_lef(lista_de_eventos, &saida);
-		return;
-	}
-
-	printf("ENTRA\n");
-	insere_cjt(m->locais[id_local].publico, id_heroi);
-	int t_permanencia_local = max(1, m->herois[id_heroi].paciencia/10 + aleat(-2,6));
-	evento_t saida = { m->tempo_atual + t_permanencia_local, SAIDA, id_heroi, id_local };
-	adiciona_ordem_lef(lista_de_eventos, &saida);
+    printf("%6d:CHEGA HEROI %2d Local %d (%2d/%2d), ",
+            m->tempo_atual,
+            id_heroi,
+            id_local,
+            cardinalidade_cjt(m->locais[id_local].publico),
+            m->locais[id_local].lotacao_max);
+
+    if (local_lotado(id_local, m)) {
+        if (heroi_tem_paciencia(id_heroi, id_local, m)) {
+            insere_fila(m->locais[id_local].fila, id_heroi);
+            printf("FILA %d\n", tamanho_fila(m->locais[id_local].fila));
+            return;
+        }
+
+        printf("DESISTE\n");
+        evento_t saida = { m->tempo_atual, SAIDA, id_heroi, id_local };
+        adiciona_ordem_lef(lista_de_eventos, &saida);
+        return;
+    }
+
+    printf("ENTRA\n");
+    insere_cjt(m->locais[id_local].publico, id_heroi);
+    int t_permanencia_local = max(1, m->herois[id_heroi].paciencia/10 + aleat(-2,6));
+    evento_t saida = { m->tempo_atual + t_permanencia_local, SAIDA, id_heroi, id_local };
+    adiciona_ordem_lef(lista_de_eventos, &saida);
 }
 
 void trata_evento_saida(int id_heroi, int id_local, mundo_t *m, lef_t *lista_de_eventos) {
-	printf("%6d:SAIDA HEROI %2d Local %d (%2d/%2d)",
-			m->tempo_atual,
-			id_heroi,
-			id_local,
-			cardinalidade_cjt(m->locais[id_local].publico),
-			m->locais[id_local].lotacao_max);
-
-	if (pertence_cjt(m->locais[id_local].publico, id_heroi)) {
-		retira_cjt(m->locais[id_local].publico, id_heroi);
-		if (!vazia_fila(m->locais[id_local].fila)) {
-			int id_heroi_fila;
-			retira_fila(m->locais[id_local].fila, &id_heroi_fila);
-			printf(", REMOVE FILA HEROI %d", id_heroi_fila);
-			evento_t chegada_heroi_fila = { m->tempo_atual, CHEGADA, id_heroi_fila, id_local };
-			adiciona_inicio_lef(lista_de_eventos, &chegada_heroi_fila);
-		}
-	}
-	printf("\n");
-
-	int id_local_destino = aleat(0, m->n_locais-1);
-	int t_deslocamento = distancia(m->locais[id_local], m->locais[id_local_destino]) / velocidade_heroi(m->herois[id_heroi]);
-	evento_t chegada_heroi = { m->tempo_atual + t_deslocamento/15, CHEGADA, id_heroi, id_local_destino };
-	adiciona_ordem_lef(lista_de_eventos, &chegada_heroi);
+    printf("%6d:SAIDA HEROI %2d Local %d (%2d/%2d)",
+            m->tempo_atual,
+            id_heroi,
+            id_local,
+            cardinalidade_cjt(m->locais[id_local].publico),
+            m->locais[id_local].lotacao_max);
+
+    if (pertence_cjt(m->locais[id_local].publico, id_heroi)) {
+        retira_cjt(m->locais[id_local].publico, id_heroi);
+        if (!vazia_fila(m->locais[id_local].fila)) {
+            int id_heroi_fila;
+            retira_fila(m->locais[id_local].fila, &id_heroi_fila);
+            printf(", REMOVE FILA HEROI %d", id_heroi_fila);
+            evento_t chegada_heroi_fila = { m->tempo_atual, CHEGADA, id_heroi_fila, id_local };
+            adiciona_inicio_lef(lista_de_eventos, &chegada_heroi_fila);
+        }
+    }
+    printf("\n");
+
+    int id_local_destino = aleat(0, m->n_locais-1);
+    int t_deslocamento = distancia(m->locais[id_local], m->locais[id_local_destino]) / velocidade_heroi(m->herois[id_heroi]);
+    evento_t chegada_heroi = { m->tempo_atual + t_deslocamento/15, CHEGADA, id_heroi, id_local_destino };
+    adiciona_ordem_lef(lista_de_eventos, &chegada_heroi);
 }
 
 void trata_evento_missao(int id_missao, mundo_t *m, lef_t *lista_de_eventos) {
-	conjunto_t *missao;
-	if ( !(missao = cria_subcjt_cjt(m->cj_habilidades, aleat(3, 6))) )
-		MEM_ERROR_EXIT;
-
-	printf("%6d:MISSAO %3d HAB_REQ ", m->tempo_atual, id_missao);
-	imprime_cjt(missao);
-
-	local_t local_encontrado;
-	conjunto_t *equipe_escolhida = escolhe_menor_equipe(missao, id_missao, m, &local_encontrado);
-
-	printf("%6d:MISSAO %3d ", m->tempo_atual, id_missao);
-	if (vazio_cjt(equipe_escolhida)) {
-		printf("IMPOSSIVEL\n");
-		evento_t nova_tentativa = { aleat(m->tempo_atual, m->fim_do_mundo), MISSAO, id_missao, 0 };
-		adiciona_ordem_lef(lista_de_eventos, &nova_tentativa);
-	} else {
-		printf("HER_EQS %d:", local_encontrado.id);
-		imprime_cjt(local_encontrado.publico);
-
-		int id_heroi_encontrado;
-		inicia_iterador_cjt(local_encontrado.publico);
-		int i;
-		for (i = 0; i < cardinalidade_cjt(local_encontrado.publico); i++) {
-			incrementa_iterador_cjt(local_encontrado.publico, &id_heroi_encontrado);
-			(m->herois[id_heroi_encontrado].exp)++;
-		}
-	}
-	missao = destroi_cjt(missao);
-	equipe_escolhida = destroi_cjt(equipe_escolhida);
+    conjunto_t *missao;
+    if ( !(missao = cria_subcjt_cjt(m->cj_habilidades, aleat(3, 6))) )
+        MEM_ERROR_EXIT;
+
+    printf("%6d:MISSAO %3d HAB_REQ ", m->tempo_atual, id_missao);
+    imprime_cjt(missao);
+
+    local_t local_encontrado;
+    conjunto_t *equipe_escolhida = escolhe_menor_equipe(missao, id_missao, m, &local_encontrado);
+
+    printf("%6d:MISSAO %3d ", m->tempo_atual, id_missao);
+    if (vazio_cjt(equipe_escolhida)) {
+        printf("IMPOSSIVEL\n");
+        evento_t nova_tentativa = { aleat(m->tempo_atual, m->fim_do_mundo), MISSAO, id_missao, 0 };
+        adiciona_ordem_lef(lista_de_eventos, &nova_tentativa);
+    } else {
+        printf("HER_EQS %d:", local_encontrado.id);
+        imprime_cjt(local_encontrado.publico);
+
+        int id_heroi_encontrado;
+        inicia_iterador_cjt(local_encontrado.publico);
+        int i;
+        for (i = 0; i < cardinalidade_cjt(local_encontrado.publico); i++) {
+            incrementa_iterador_cjt(local_encontrado.publico, &id_heroi_encontrado);
+            (m->herois[id_heroi_encontrado].exp)++;
+        }
+    }
+    missao = destroi_cjt(missao);
+    equipe_escolhida = destroi_cjt(equipe_escolhida);
 }
 
 void trata_evento_fim(mundo_t *m, lef_t **lista_de_eventos) {
-	printf("%6d:FIM\n", m->tempo_atual);
-	int i;
-	for (i = 0; i < m->n_herois; i++) {
-		printf("HEROI %2d EXPERIENCIA %2d\n", m->herois[i].id, m->herois[i].exp);
-		m->herois[i].habilidades_do_heroi = destroi_cjt(m->herois[i].habilidades_do_heroi);
-	}
-
-	for (i = 0; i < m->n_locais; i++) {
-		m->locais[i].publico = destroi_cjt(m->locais[i].publico);
-		m->locais[i].fila = destroi_fila(m->locais[i].fila);
-	}
-
-	free(m->herois);
-	free(m->locais);
-	m->cj_habilidades = destroi_cjt(m->cj_habilidades);
-	free(m);
-	*lista_de_eventos = destroi_lef(*lista_de_eventos);
+    printf("%6d:FIM\n", m->tempo_atual);
+    int i;
+    for (i = 0; i < m->n_herois; i++) {
+        printf("HEROI %2d EXPERIENCIA %2d\n", m->herois[i].id, m->herois[i].exp);
+        m->herois[i].habilidades_do_heroi = destroi_cjt(m->herois[i].habilidades_do_heroi);
+    }
+
+    for (i = 0; i < m->n_locais; i++) {
+        m->locais[i].publico = destroi_cjt(m->locais[i].publico);
+        m->locais[i].fila = destroi_fila(m->locais[i].fila);
+    }
+
+    free(m->herois);
+    free(m->locais);
+    m->cj_habilidades = destroi_cjt(m->cj_habilidades);
+    free(m);
+    *lista_de_eventos = destroi_lef(*lista_de_eventos);
 }
 
 int main() {
-	srand(time(0));
-
-	lef_t *lista_de_eventos;
-	if ( !(lista_de_eventos = cria_lef()) )
-		MEM_ERROR_EXIT;
-
-	mundo_t *mundo = cria_mundo(lista_de_eventos);
-	
-	evento_t *evento_atual;
-	/* ciclo da simulação */
-	while ( lista_de_eventos && (evento_atual = obtem_primeiro_lef(lista_de_eventos)) ) {
-		mundo->tempo_atual = evento_atual->tempo;
-
-		/* trata o evento e atualiza estado do sistema */
-		switch (evento_atual->tipo) {
-			case CHEGADA:
-				trata_evento_chegada(evento_atual->dado1, evento_atual->dado2, mundo, lista_de_eventos);
-				break;
-
-			case SAIDA:
-				trata_evento_saida(evento_atual->dado1, evento_atual->dado2, mundo, lista_de_eventos);
-				break;
-
-			case MISSAO:
-				trata_evento_missao(evento_atual->dado1, mundo, lista_de_eventos);
-				break;
-
-			case FIM:
-				trata_evento_fim(mundo, &lista_de_eventos);
-				break;
-		}
-
-		free(evento_atual);
-	}
-
-	return 0;
+    srand(time(0));
+
+    lef_t *lista_de_eventos;
+    if ( !(lista_de_eventos = cria_lef()) )
+        MEM_ERROR_EXIT;
+
+    mundo_t *mundo = cria_mundo(lista_de_eventos);
+    
+    evento_t *evento_atual;
+    /* ciclo da simulação */
+    while ( lista_de_eventos && (evento_atual = obtem_primeiro_lef(lista_de_eventos)) ) {
+        mundo->tempo_atual = evento_atual->tempo;
+
+        /* trata o evento e atualiza estado do sistema */
+        switch (evento_atual->tipo) {
+            case CHEGADA:
+                trata_evento_chegada(evento_atual->dado1, evento_atual->dado2, mundo, lista_de_eventos);
+                break;
+
+            case SAIDA:
+                trata_evento_saida(evento_atual->dado1, evento_atual->dado2, mundo, lista_de_eventos);
+                break;
+
+            case MISSAO:
+                trata_evento_missao(evento_atual->dado1, mundo, lista_de_eventos);
+                break;
+
+            case FIM:
+                trata_evento_fim(mundo, &lista_de_eventos);
+                break;
+        }
+
+        free(evento_atual);
+    }
+
+    return 0;
 }
diff --git a/tp1/racionais b/tp1/racionais
deleted file mode 100755
index fade14e44c4c6ed2ce5398a66f99b87aa28bff97..0000000000000000000000000000000000000000
Binary files a/tp1/racionais and /dev/null differ
diff --git a/tp1/racionais.c b/tp1/racionais.c
index 8b097f174ad3fa89ef700c3ba8a2c3d9845c05be..a9de61e5f4eadcd082ff7ac93b21b0f7df796ff0 100644
--- a/tp1/racionais.c
+++ b/tp1/racionais.c
@@ -1,106 +1,106 @@
 #include <stdio.h>
 
 typedef struct rac {
-	int num;
-	int den;
+    int num;
+    int den;
 } racional;
 
 int mdc(int a, int b) {
-	int resto;
-	if (a != 0 && b != 0) {
-		resto = a % b;
-		while (resto) {
-			a = b;
-			b = resto;
-			resto = a % b;
-		}
-		return b;
-	}
-	return 0;
+    int resto;
+    if (a != 0 && b != 0) {
+        resto = a % b;
+        while (resto) {
+            a = b;
+            b = resto;
+            resto = a % b;
+        }
+        return b;
+    }
+    return 0;
 }
 
 racional le_racional() {
-	racional r;
-	scanf("%d %d", &r.num, &r.den);
-	
-	return r;
+    racional r;
+    scanf("%d %d", &r.num, &r.den);
+    
+    return r;
 }
 
 racional multiplica_rs(racional r, racional s) {
-	racional p;
-	p.num = r.num * s.num;
-	p.den = r.den * s.den;
+    racional p;
+    p.num = r.num * s.num;
+    p.den = r.den * s.den;
 
-	return p;
+    return p;
 }
 
 racional divide_rs(racional r, racional s) {
-	racional p;
-	p.num = r.num * s.den;
-	p.den = r.den * s.num;
+    racional p;
+    p.num = r.num * s.den;
+    p.den = r.den * s.num;
 
-	return p;
+    return p;
 }
 
 racional soma_rs(racional r, racional s) {
-	racional p;
-	p.den = r.den * s.den;
-	p.num = r.num * s.den + s.num * r.den;
+    racional p;
+    p.den = r.den * s.den;
+    p.num = r.num * s.den + s.num * r.den;
 
-	return p;
+    return p;
 }
 
 racional subtrai_rs(racional r, racional s) {
-	racional p;
-	p.den = r.den * s.den;
-	p.num = r.num * s.den - s.num * r.den;
-	
-	return p;
+    racional p;
+    p.den = r.den * s.den;
+    p.num = r.num * s.den - s.num * r.den;
+    
+    return p;
 }
 
 void formata_racional(racional r) {
-	int fator = mdc(r.num, r.den);
-	
-	if (fator) {
-		r.num /= fator;
-		r.den /= fator;
-	}
-
-	if (!r.num) {
-		printf("0\n");
-	} else {
-		if (r.den == 1) {
-			printf("%d\n", r.num);
-		} else {
-			printf("%d/%d\n", r.num, r.den);
-		}
-	}
-	return;
+    int fator = mdc(r.num, r.den);
+    
+    if (fator) {
+        r.num /= fator;
+        r.den /= fator;
+    }
+
+    if (!r.num) {
+        printf("0\n");
+    } else {
+        if (r.den == 1) {
+            printf("%d\n", r.num);
+        } else {
+            printf("%d/%d\n", r.num, r.den);
+        }
+    }
+    return;
 }
 
 int valida_racional(racional r) {
-	if (!r.den) return 0;
-	return 1;
+    if (!r.den) return 0;
+    return 1;
 }
 
 int main() {
-	racional r = le_racional();
-	racional s = le_racional();
-	while(valida_racional(s) && valida_racional(r)) {
-		racional soma = soma_rs(r, s);
-		formata_racional(soma);
-
-		racional subtracao = subtrai_rs(r, s);
-		formata_racional(subtracao);
-
-		racional multiplicacao = multiplica_rs(r, s);
-		formata_racional(multiplicacao);
-
-		racional divisao = divide_rs(r, s);
-		formata_racional(divisao);
-		
-		r = le_racional();
-		if (r.den) { s = le_racional(); }
-	}
-	return 0;
+    racional r = le_racional();
+    racional s = le_racional();
+    while(valida_racional(s) && valida_racional(r)) {
+        racional soma = soma_rs(r, s);
+        formata_racional(soma);
+
+        racional subtracao = subtrai_rs(r, s);
+        formata_racional(subtracao);
+
+        racional multiplicacao = multiplica_rs(r, s);
+        formata_racional(multiplicacao);
+
+        racional divisao = divide_rs(r, s);
+        formata_racional(divisao);
+        
+        r = le_racional();
+        if (r.den) { s = le_racional(); }
+    }
+    return 0;
 }
diff --git a/tp2/lib_racionais.c b/tp2/lib_racionais.c
index c963f12cd10c752475ba04b846593cc979301c4c..01aeefadd7184bc558aa50763472efd0faed4142 100644
--- a/tp2/lib_racionais.c
+++ b/tp2/lib_racionais.c
@@ -2,82 +2,82 @@
 #include "lib_racionais.h"
 
 int mdc(int a, int b) {
-	int resto;
-	if (a != 0 && b != 0) { resto = a % b;
-		while (resto) {
-			a = b;
-			b = resto;
-			resto = a % b;
-		}
-		return b;
-	}
-	return 0;
+    int resto;
+    if (a != 0 && b != 0) { resto = a % b;
+        while (resto) {
+            a = b;
+            b = resto;
+            resto = a % b;
+        }
+        return b;
+    }
+    return 0;
 }
 
 racional le_racional() {
-	racional r;
-	scanf("%d %d", &r.num, &r.den);
-	
-	return r;
+    racional r;
+    scanf("%d %d", &r.num, &r.den);
+    
+    return r;
 }
 
 racional multiplica_rs(racional r, racional s) {
-	racional p;
-	p.num = r.num * s.num;
-	p.den = r.den * s.den;
+    racional p;
+    p.num = r.num * s.num;
+    p.den = r.den * s.den;
 
-	return p;
+    return p;
 }
 
 racional divide_rs(racional r, racional s) {
-	racional p;
-	p.num = r.num * s.den;
-	p.den = r.den * s.num;
+    racional p;
+    p.num = r.num * s.den;
+    p.den = r.den * s.num;
 
-	return p;
+    return p;
 }
 
 racional soma_rs(racional r, racional s) {
-	racional p;
-	p.den = r.den * s.den;
-	p.num = r.num * s.den + s.num * r.den;
+    racional p;
+    p.den = r.den * s.den;
+    p.num = r.num * s.den + s.num * r.den;
 
-	return p;
+    return p;
 }
 
 racional subtrai_rs(racional r, racional s) {
-	racional p;
-	p.den = r.den * s.den;
-	p.num = r.num * s.den - s.num * r.den;
-	
-	return p;
+    racional p;
+    p.den = r.den * s.den;
+    p.num = r.num * s.den - s.num * r.den;
+    
+    return p;
 }
 
 void formata_racional(racional r) {
-	int fator = mdc(r.num, r.den);
-	
-	if (fator) {
-		r.num /= fator;
-		r.den /= fator;
-	}
-	
-	if (!r.den) {
-		printf("Erro: divisao por 0\n");
-	} else {
-		if (!r.num) {
-			printf("0\n");
-		} else {
-			if (r.den == 1) {
-				printf("%d\n", r.num);
-			} else {
-				printf("%d/%d\n", r.num, r.den);
-			}
-		}
-	}
-	return;
+    int fator = mdc(r.num, r.den);
+    
+    if (fator) {
+        r.num /= fator;
+        r.den /= fator;
+    }
+    
+    if (!r.den) {
+        printf("Erro: divisao por 0\n");
+    } else {
+        if (!r.num) {
+            printf("0\n");
+        } else {
+            if (r.den == 1) {
+                printf("%d\n", r.num);
+            } else {
+                printf("%d/%d\n", r.num, r.den);
+            }
+        }
+    }
+    return;
 }
 
 int valida_racional(racional r) {
-	if (!r.den) return 0;
-	return 1;
+    if (!r.den) return 0;
+    return 1;
 }
diff --git a/tp2/lib_racionais.h b/tp2/lib_racionais.h
index 25a5008784fb10909dd86fb211361975f563a135..d9d952dc92bb4c8d25cdd04bac0854a137c44adc 100644
--- a/tp2/lib_racionais.h
+++ b/tp2/lib_racionais.h
@@ -1,6 +1,6 @@
 typedef struct {
-	int num;
-	int den;
+    int num;
+    int den;
 } racional;
 
 /* le um numero racional (dois inteiros) */
diff --git a/tp2/makefile b/tp2/makefile
index 469a707df35d08f6672cad3d6837c76dabf85f14..0ef8fa4d7717774e52b69b2c7e5d9bc0a7778d0d 100644
--- a/tp2/makefile
+++ b/tp2/makefile
@@ -13,4 +13,4 @@ lib_racionais.o: lib_racionais.c
 	$(CC) -c $(OPCOES) lib_racionais.c
 
 clean:
-		rm -f ./*.o
+	rm -f ./*.o tp2
diff --git a/tp2/tp2 b/tp2/tp2
deleted file mode 100755
index a4ec5df262670455c83caa0ee4715d1f517c43b0..0000000000000000000000000000000000000000
Binary files a/tp2/tp2 and /dev/null differ
diff --git a/tp2/tp2.c b/tp2/tp2.c
index f9206db02781d0e91f4dd2dfe5157253f96e9e69..8e204fefb019165f80af8a0460017dae77fcfe81 100644
--- a/tp2/tp2.c
+++ b/tp2/tp2.c
@@ -2,26 +2,26 @@
 #include "lib_racionais.h"
 
 int main() {
-	racional r, s;
-	r = le_racional();
-	if (r.den) { s = le_racional(); }
-	while(valida_racional(s) && valida_racional(r)) {
-		racional soma = soma_rs(r, s);
-		formata_racional(soma);
+    racional r, s;
+    r = le_racional();
+    if (r.den) { s = le_racional(); }
+    while(valida_racional(s) && valida_racional(r)) {
+        racional soma = soma_rs(r, s);
+        formata_racional(soma);
 
-		racional subtracao = subtrai_rs(r, s);
-		formata_racional(subtracao);
+        racional subtracao = subtrai_rs(r, s);
+        formata_racional(subtracao);
 
-		racional multiplicacao = multiplica_rs(r, s);
-		formata_racional(multiplicacao);
+        racional multiplicacao = multiplica_rs(r, s);
+        formata_racional(multiplicacao);
 
-		racional divisao = divide_rs(r, s);
-		formata_racional(divisao);
-		
-		printf("\n");
+        racional divisao = divide_rs(r, s);
+        formata_racional(divisao);
+        
+        printf("\n");
 
-		r = le_racional();
-		if (r.den) { s = le_racional(); }
-	}
-	return 0;
+        r = le_racional();
+        if (r.den) { s = le_racional(); }
+    }
+    return 0;
 }
diff --git a/tp3/lib_racionais.c b/tp3/lib_racionais.c
index 256f18dfff2d44439e1d2e3bcfa6df30728137cb..cac1700676472e84f74ea61974d8346d4e6787b1 100644
--- a/tp3/lib_racionais.c
+++ b/tp3/lib_racionais.c
@@ -3,134 +3,134 @@
 #include "lib_racionais.h"
 
 int aleat(int min, int max) {
-	return (rand() % (max - min + 1) + min);
+    return (rand() % (max - min + 1) + min);
 }
 
 racional *criar_r() {
-	racional *r;
-	if ( !(r = malloc(sizeof(racional))) )
-		return NULL;
-	return r;
+    racional *r;
+    if ( !(r = malloc(sizeof(racional))) )
+        return NULL;
+    return r;
 }
 
 racional *liberar_r(racional *r) {
-	free(r);
-	r = NULL;
-	return r;
+    free(r);
+    r = NULL;
+    return r;
 }
 
 racional *sortear_r() {
-	racional *r;
-	r = criar_r();
-	r->num = aleat(0, 100);
-	r->den = aleat(1, 100);
-	simplifica_r(r);
-	return r;
+    racional *r;
+    r = criar_r();
+    r->num = aleat(0, 100);
+    r->den = aleat(1, 100);
+    simplifica_r(r);
+    return r;
 }
 
 int ler_r(racional *r) {
-	if (!scanf("%d %d", &r->num, &r->den))
-		return 0;
-	if (!r->den)
-		return 0;
-	return 1;	
+    if (!scanf("%d %d", &r->num, &r->den))
+        return 0;
+    if (!r->den)
+        return 0;
+    return 1;    
 }
 
 void imprimir_r(racional *r) {
-	if (!r->num) {
-		printf("0");
-		return;
-	}
-	if (r->den == 1) {
-		printf("%d", r->num);
-		return;
-	}
-	printf("%d/%d", r->num, r->den);
-	return;
+    if (!r->num) {
+        printf("0");
+        return;
+    }
+    if (r->den == 1) {
+        printf("%d", r->num);
+        return;
+    }
+    printf("%d/%d", r->num, r->den);
+    return;
 }
  
 int mdc(int a, int b) {
-	int r;
-	while (b) {
-		r = a % b;
-		a = b;
-		b = r;
-	}
-	return a;
+    int r;
+    while (b) {
+        r = a % b;
+        a = b;
+        b = r;
+    }
+    return a;
 }
 
 int mmc(int a, int b) {
-	if (a && b)
-		return ((a * b) / mdc(a, b));
-	return 0;
+    if (a && b)
+        return ((a * b) / mdc(a, b));
+    return 0;
 }
 
 int valido_r(racional *r) {
-	if (r->den)
-		return 1;
-	return 0;
+    if (r->den)
+        return 1;
+    return 0;
 }
 
 void simplifica_r(racional *r) {
-	int fator = mdc(r->num, r->den);
-	if (fator) {
-		r->num /= fator;
-		r->den /= fator;
-	}
+    int fator = mdc(r->num, r->den);
+    if (fator) {
+        r->num /= fator;
+        r->den /= fator;
+    }
 }
 
 int menor_r(racional *r1, racional *r2) {
-	int a = r1->num * r2->den;
-	int b = r1->den * r2->num;
-	if (a < b)
-		return 1;
-	return 0;
+    int a = r1->num * r2->den;
+    int b = r1->den * r2->num;
+    if (a < b)
+        return 1;
+    return 0;
 }
 
 int iguais_r(racional *r1, racional *r2) {
-	int a = r1->num * r2->den;
-	int b = r1->den * r2->num;
-	if (a == b)
-		return 1;
-	return 0;
+    int a = r1->num * r2->den;
+    int b = r1->den * r2->num;
+    if (a == b)
+        return 1;
+    return 0;
 }
 
 racional *somar_r(racional *r1, racional *r2) {
-	racional *soma;
-	soma = criar_r();
+    racional *soma;
+    soma = criar_r();
 
-	soma->den = r1->den * r2->den;
-	soma->num = r1->num * r2->den + r2->num * r1->den;
-	simplifica_r(soma);
-	return soma;
+    soma->den = r1->den * r2->den;
+    soma->num = r1->num * r2->den + r2->num * r1->den;
+    simplifica_r(soma);
+    return soma;
 }
 
 racional *subtrair_r(racional *r1, racional *r2) {
-	racional *dif;
-	dif = criar_r();
+    racional *dif;
+    dif = criar_r();
 
-	dif->den = r1->den * r2->den;
-	dif->num = r1->num * r2->den - r2->num * r1->den;
-	simplifica_r(dif);
-	return dif;
+    dif->den = r1->den * r2->den;
+    dif->num = r1->num * r2->den - r2->num * r1->den;
+    simplifica_r(dif);
+    return dif;
 }
 
 racional *multiplicar_r(racional *r1, racional *r2) {
-	racional *mult;
-	mult = criar_r();
+    racional *mult;
+    mult = criar_r();
 
-	mult->den = r1->den * r2->den;
-	mult->num = r1->num * r2->num;
-	simplifica_r(mult);
-	return mult;
+    mult->den = r1->den * r2->den;
+    mult->num = r1->num * r2->num;
+    simplifica_r(mult);
+    return mult;
 }
 
 racional *dividir_r(racional *r1, racional *r2) {
-	racional *div;
-	div = criar_r();
+    racional *div;
+    div = criar_r();
 
-	div->den = r1->den * r2->num;
-	div->num = r1->num * r2->den;
-	simplifica_r(div);
-	return div;
+    div->den = r1->den * r2->num;
+    div->num = r1->num * r2->den;
+    simplifica_r(div);
+    return div;
 }
diff --git a/tp3/makefile b/tp3/makefile
index 15fd51f5434d4fc387f77322b78da3a4fea647cf..cf6df46afc6a6c6bf57638b8707f3782b26a4776 100644
--- a/tp3/makefile
+++ b/tp3/makefile
@@ -13,4 +13,4 @@ tp3.o: tp3.c
 	$(CC) -c $(CFLAGS) tp3.c
 
 clean:
-	rm -f *.o
+	rm -f *.o tp3
diff --git a/tp3/tp3 b/tp3/tp3
deleted file mode 100755
index fc1b47b817382d93324d309d114179727e25dc02..0000000000000000000000000000000000000000
Binary files a/tp3/tp3 and /dev/null differ
diff --git a/tp3/tp3.c b/tp3/tp3.c
index da2d13f8fd3c35714706ba9465cdaf949861bf0e..c50baab144d4fc12cca9ce3c55b3bcef9d55aea9 100644
--- a/tp3/tp3.c
+++ b/tp3/tp3.c
@@ -6,88 +6,88 @@
 
 /* le um inteiro na faixa [0..MAX-1] */
 int ler_tamanho() {
-	printf("Insira o tamanho do vetor (entre 0 e %d):\n", MAX-1);
-	int n;
-	scanf("%d", &n);
-	while (n < 0 || n > MAX-1) {
-		printf("Por favor, insira um inteiro entre 0 e %d:\n", MAX-1);
-		scanf("%d", &n);
-	}
-	return n;
+    printf("Insira o tamanho do vetor (entre 0 e %d):\n", MAX-1);
+    int n;
+    scanf("%d", &n);
+    while (n < 0 || n > MAX-1) {
+        printf("Por favor, insira um inteiro entre 0 e %d:\n", MAX-1);
+        scanf("%d", &n);
+    }
+    return n;
 }
 
 /* imprime os racionais apontados pelo vetor de ponteiros para racionais */
 void imprimir_vetor_racional(racional **vet, int tam) {
-	int i;
-	for (i = 0; i < tam-1; i++) {
-		imprimir_r(*(vet + i));
-		printf(" ");
-	}
-	imprimir_r(*(vet + tam-1));     /* por motivos de formatacao da saida, */
-	printf("\n");				    /* imprime o ultimo numero separadamente */
+    int i;
+    for (i = 0; i < tam-1; i++) {
+        imprimir_r(*(vet + i));
+        printf(" ");
+    }
+    imprimir_r(*(vet + tam-1));     /* por motivos de formatacao da saida, */
+    printf("\n");                    /* imprime o ultimo numero separadamente */
 }
 
 /* retorna um vetor de tam ponteiros para numeros racionais validos gerados aleatoriamente */
 /* retorna NULL em caso de falha */
 racional **aleatorio_vetor_racional(int tam) {
-	racional **vet;
-	if ( !(vet = malloc(tam * sizeof(racional*))) )
-		return NULL;
-	int i;
-	for (i = 0; i < tam; i++)
-		*(vet + i) = sortear_r();
-	return vet;
+    racional **vet;
+    if ( !(vet = malloc(tam * sizeof(racional*))) )
+        return NULL;
+    int i;
+    for (i = 0; i < tam; i++)
+        *(vet + i) = sortear_r();
+    return vet;
 }
 
 /* inverte dois ponteiros para racional */
 void inverte_ponteiros(racional **r1, racional **r2) {
-	racional *temp = *r1;
-	*r1 = *r2;
-	*r2 = temp;
+    racional *temp = *r1;
+    *r1 = *r2;
+    *r2 = temp;
 }
 
 /* retorna um vetor de tam ponteiros para numeros racionais que apontam em ordem crescente para os 
  * racionais apontados pelo vetor recebido no parametro. */
 /* essa funcao eh uma implementacao do bubble sort */
 racional **ordenar_vetor_racional(racional **vet, int tam) {
-	racional **ord;
-	if ( !(ord = malloc(tam * sizeof(racional*))) )
-		return NULL;
-	int i;
-	for (i = 0; i < tam; i++) {
-		*(ord + i) = *(vet + i);
-	}
+    racional **ord;
+    if ( !(ord = malloc(tam * sizeof(racional*))) )
+        return NULL;
+    int i;
+    for (i = 0; i < tam; i++) {
+        *(ord + i) = *(vet + i);
+    }
 
-	int swaps = 1;
-	while (swaps) {
-		swaps = 0;
-		for (i = 0; i < tam-1; i++) {
-			if (menor_r(*(ord + i+1), *(ord + i))) {
-				inverte_ponteiros((ord + i+1), (ord + i));
-				swaps++;
-			}
-		}
-		tam--;
-	}
-	return ord;
+    int swaps = 1;
+    while (swaps) {
+        swaps = 0;
+        for (i = 0; i < tam-1; i++) {
+            if (menor_r(*(ord + i+1), *(ord + i))) {
+                inverte_ponteiros((ord + i+1), (ord + i));
+                swaps++;
+            }
+        }
+        tam--;
+    }
+    return ord;
 }
 
 /* libera a memoria alocada em um vetor vet de tam ponteiros para numeros racionais,
  * e libera todos os ponteiros dentro dele */
 racional **liberar_vetor_racional(racional **vet, int tam) {
-	int i;
-	for (i = 0; i < tam; i++) {
-		free(*(vet + i));
-		*(vet + i) = NULL;
-	}
-	free(vet);
-	vet = NULL;
-	return vet;
+    int i;
+    for (i = 0; i < tam; i++) {
+        free(*(vet + i));
+        *(vet + i) = NULL;
+    }
+    free(vet);
+    vet = NULL;
+    return vet;
 }
 
 int main() {
-	/* inicializa semente randomica */
-	srand(time(0));
+    /* inicializa semente randomica */
+    srand(time(0));
 
     racional **v, **w;
     /* v e w são vetores de ponteiros para racionais (racional *) */
@@ -95,8 +95,8 @@ int main() {
     int tam;
     /* ler o tamanho do vetor de racionais */
     if (!(tam = ler_tamanho()))
-		return 0;  /* impede de passar 0 como um parametro para malloc */
-	
+        return 0;  /* impede de passar 0 como um parametro para malloc */
+    
     /* aloca v com tam ponteiros para racional */
     v = aleatorio_vetor_racional(tam);
     /* a funcao acima retorna NULL em caso de falha */
@@ -109,9 +109,9 @@ int main() {
     imprimir_vetor_racional(w, tam);
 
     /* libera toda memoria alocada dinamicamente */
-	v = liberar_vetor_racional(v, tam);
-	free(w);   /* o vetor w pode ser liberado normalmente, porque os ponteiros que apontam para numeros */
-	w = NULL;  /* racionais ja foram liberados na chamada de liberar_vetor_racional para v. */
+    v = liberar_vetor_racional(v, tam);
+    free(w);   /* o vetor w pode ser liberado normalmente, porque os ponteiros que apontam para numeros */
+    w = NULL;  /* racionais ja foram liberados na chamada de liberar_vetor_racional para v. */
 
     return 0;
 }
diff --git a/tp4/lib_conjunto.c b/tp4/lib_conjunto.c
index b88f1db8df951d6566ca3341c568d9d21dcc8c38..9b3b8e5b4dabf736213910590fcc641202fc44eb 100644
--- a/tp4/lib_conjunto.c
+++ b/tp4/lib_conjunto.c
@@ -6,228 +6,228 @@
  * como estamos trabalhando com conjuntos ordenados, eh uma busca binaria.
  * se o elemento nao esta no conjunto, retorna -1. */
 int busca_cjt(conjunto_t *c, int elemento) {
-	int inicio = 0;
-	int fim = cardinalidade_cjt(c) - 1;
-	int meio = fim / 2;
+    int inicio = 0;
+    int fim = cardinalidade_cjt(c) - 1;
+    int meio = fim / 2;
 
-	while (inicio <= fim && c->v[meio] != elemento) {
-		if (elemento > c->v[meio]) {
-			inicio = meio + 1;
-		} else {
-			fim = meio - 1;
-		}
-		meio = (inicio + fim) / 2;
-	}
+    while (inicio <= fim && c->v[meio] != elemento) {
+        if (elemento > c->v[meio]) {
+            inicio = meio + 1;
+        } else {
+            fim = meio - 1;
+        }
+        meio = (inicio + fim) / 2;
+    }
 
-	return inicio > fim ? -1 : meio;
+    return inicio > fim ? -1 : meio;
 }
 
 conjunto_t *cria_cjt(int max) {
-	conjunto_t *c;
-	if ( !(c = malloc(sizeof(conjunto_t))) )
-		return NULL;
-	c->max = max;
-	c->card = 0;
-	c->ptr = 0;
-	if ( !(c->v = malloc(sizeof(int) * max)) ) {
-		free(c);
-		return NULL;
-	}
-	return c;
+    conjunto_t *c;
+    if ( !(c = malloc(sizeof(conjunto_t))) )
+        return NULL;
+    c->max = max;
+    c->card = 0;
+    c->ptr = 0;
+    if ( !(c->v = malloc(sizeof(int) * max)) ) {
+        free(c);
+        return NULL;
+    }
+    return c;
 }
 
 conjunto_t *destroi_cjt(conjunto_t *c) {
-	free(c->v);
-	c->v = NULL;
-	free(c);
-	return NULL;
+    free(c->v);
+    c->v = NULL;
+    free(c);
+    return NULL;
 }
 
 int vazio_cjt(conjunto_t *c) {
-	return cardinalidade_cjt(c) == 0;	
+    return cardinalidade_cjt(c) == 0;    
 }
 
 int cardinalidade_cjt(conjunto_t *c) {
-	return c->card;
+    return c->card;
 }
 
 int insere_cjt(conjunto_t *c, int elemento) {
-	if (cardinalidade_cjt(c) == c->max)
-		return 0;
+    if (cardinalidade_cjt(c) == c->max)
+        return 0;
 
-	if (pertence_cjt(c, elemento))
-		return 1;
+    if (pertence_cjt(c, elemento))
+        return 1;
 
-	int i = cardinalidade_cjt(c);
-	while (i > 0 && c->v[i - 1] > elemento) {
-		c->v[i] = c->v[i - 1];
-		i--;
-	}
-	
-	c->v[i] = elemento;
-	c->card++;
-	return 1;
+    int i = cardinalidade_cjt(c);
+    while (i > 0 && c->v[i - 1] > elemento) {
+        c->v[i] = c->v[i - 1];
+        i--;
+    }
+    
+    c->v[i] = elemento;
+    c->card++;
+    return 1;
 }
 
 int retira_cjt(conjunto_t *c, int elemento) {
-	if (!(pertence_cjt(c, elemento)))
-		return 0;
+    if (!(pertence_cjt(c, elemento)))
+        return 0;
 
-	int i;
-	for(i = busca_cjt(c, elemento); i < cardinalidade_cjt(c)-1; i++) {
-		c->v[i] = c->v[i + 1];
-	}
+    int i;
+    for(i = busca_cjt(c, elemento); i < cardinalidade_cjt(c)-1; i++) {
+        c->v[i] = c->v[i + 1];
+    }
 
-	c->card--;
-	return 1;
+    c->card--;
+    return 1;
 }
 
 int pertence_cjt(conjunto_t *c, int elemento) {
-	return busca_cjt(c, elemento) != -1;
+    return busca_cjt(c, elemento) != -1;
 }
 
 int contido_cjt(conjunto_t *c1, conjunto_t *c2) {
-	int i;
-	for (i = 0; i < cardinalidade_cjt(c1); i++) {
-		if (!(pertence_cjt(c2, c1->v[i])))
-			return 0;
-	}
-	return 1;
+    int i;
+    for (i = 0; i < cardinalidade_cjt(c1); i++) {
+        if (!(pertence_cjt(c2, c1->v[i])))
+            return 0;
+    }
+    return 1;
 }
 
 int sao_iguais_cjt(conjunto_t *c1, conjunto_t *c2) {
-	return cardinalidade_cjt(c1) == cardinalidade_cjt(c2) && contido_cjt(c1, c2);
+    return cardinalidade_cjt(c1) == cardinalidade_cjt(c2) && contido_cjt(c1, c2);
 }
 
 conjunto_t *diferenca_cjt(conjunto_t *c1, conjunto_t *c2) {
-	conjunto_t *dif;
-	if ( !(dif = cria_cjt(c1->max)) )
-		return NULL;
+    conjunto_t *dif;
+    if ( !(dif = cria_cjt(c1->max)) )
+        return NULL;
 
-	int i;
-	for (i = 0; i < cardinalidade_cjt(c1); i++) {
-		if (!(pertence_cjt(c2, c1->v[i])))
-			insere_cjt(dif, c1->v[i]);
-	}
+    int i;
+    for (i = 0; i < cardinalidade_cjt(c1); i++) {
+        if (!(pertence_cjt(c2, c1->v[i])))
+            insere_cjt(dif, c1->v[i]);
+    }
 
-	return dif;
+    return dif;
 }
 
 conjunto_t *interseccao_cjt(conjunto_t *c1, conjunto_t *c2) {
-	conjunto_t *inter;
-	if ( !(inter = cria_cjt(c1->max)) )
-		return NULL;
-	
-	conjunto_t **menor_cjt = cardinalidade_cjt(c1) < cardinalidade_cjt(c2) ? &c1 : &c2;
-	conjunto_t **maior_cjt = cardinalidade_cjt(c1) > cardinalidade_cjt(c2) ? &c1 : &c2;
+    conjunto_t *inter;
+    if ( !(inter = cria_cjt(c1->max)) )
+        return NULL;
+    
+    conjunto_t **menor_cjt = cardinalidade_cjt(c1) < cardinalidade_cjt(c2) ? &c1 : &c2;
+    conjunto_t **maior_cjt = cardinalidade_cjt(c1) > cardinalidade_cjt(c2) ? &c1 : &c2;
 
-	int i;
-	for (i = 0; i < cardinalidade_cjt(*menor_cjt); i++) {
-		if (pertence_cjt(*maior_cjt, (*menor_cjt)->v[i]))
-			insere_cjt(inter, (*menor_cjt)->v[i]);
-	}
+    int i;
+    for (i = 0; i < cardinalidade_cjt(*menor_cjt); i++) {
+        if (pertence_cjt(*maior_cjt, (*menor_cjt)->v[i]))
+            insere_cjt(inter, (*menor_cjt)->v[i]);
+    }
 
-	return inter;
+    return inter;
 }
 
 conjunto_t *uniao_cjt(conjunto_t *c1, conjunto_t *c2) {
-	conjunto_t *uniao;
-	if ( !(uniao = cria_cjt(c1->max)) )
-		return NULL;
+    conjunto_t *uniao;
+    if ( !(uniao = cria_cjt(c1->max)) )
+        return NULL;
 
-	inicia_iterador_cjt(c1);
-	inicia_iterador_cjt(c2);
+    inicia_iterador_cjt(c1);
+    inicia_iterador_cjt(c2);
 
-	while (c1->ptr < cardinalidade_cjt(c1) && c2->ptr < cardinalidade_cjt(c2)) {
-		if (c1->v[c1->ptr] < c2->v[c2->ptr]) {
-			insere_cjt(uniao, c1->v[c1->ptr]);
-			c1->ptr++;
-		} else {
-			insere_cjt(uniao, c2->v[c2->ptr]);
-			c2->ptr++;
-		}
-	}
+    while (c1->ptr < cardinalidade_cjt(c1) && c2->ptr < cardinalidade_cjt(c2)) {
+        if (c1->v[c1->ptr] < c2->v[c2->ptr]) {
+            insere_cjt(uniao, c1->v[c1->ptr]);
+            c1->ptr++;
+        } else {
+            insere_cjt(uniao, c2->v[c2->ptr]);
+            c2->ptr++;
+        }
+    }
 
-	conjunto_t **ainda_falta = c1->ptr == cardinalidade_cjt(c1) ? &c2 : &c1;
+    conjunto_t **ainda_falta = c1->ptr == cardinalidade_cjt(c1) ? &c2 : &c1;
 
-	int i;
-	for (i = (*ainda_falta)->ptr; i < cardinalidade_cjt(*ainda_falta); i++) {
-		insere_cjt(uniao, (*ainda_falta)->v[i]);
-	}
+    int i;
+    for (i = (*ainda_falta)->ptr; i < cardinalidade_cjt(*ainda_falta); i++) {
+        insere_cjt(uniao, (*ainda_falta)->v[i]);
+    }
 
-	inicia_iterador_cjt(c1);
-	inicia_iterador_cjt(c2);
+    inicia_iterador_cjt(c1);
+    inicia_iterador_cjt(c2);
 
-	return uniao;
+    return uniao;
 }
 
 conjunto_t *copia_cjt(conjunto_t *c) {
-	conjunto_t *copia;
-	if ( !(copia = cria_cjt(c->max)) )
-		return NULL;
+    conjunto_t *copia;
+    if ( !(copia = cria_cjt(c->max)) )
+        return NULL;
 
-	int i;
-	for (i = 0; i < cardinalidade_cjt(c); i++) {
-		insere_cjt(copia, c->v[i]);
-	}
+    int i;
+    for (i = 0; i < cardinalidade_cjt(c); i++) {
+        insere_cjt(copia, c->v[i]);
+    }
 
-	return copia;
+    return copia;
 }
 
 conjunto_t *cria_subcjt_cjt(conjunto_t *c, int n) {
-	if (n >= cardinalidade_cjt(c))
-		return copia_cjt(c);
+    if (n >= cardinalidade_cjt(c))
+        return copia_cjt(c);
 
-	conjunto_t *sub;
-	if ( !(sub = cria_cjt(c->max)) )
-		return NULL;
+    conjunto_t *sub;
+    if ( !(sub = cria_cjt(c->max)) )
+        return NULL;
 
-	conjunto_t *disponiveis;
-	if ( !(disponiveis = copia_cjt(c)) )
-		return NULL;
+    conjunto_t *disponiveis;
+    if ( !(disponiveis = copia_cjt(c)) )
+        return NULL;
 
-	int i;
-	int aleat;
-	for (i = 0; i < n; i++) {
-		aleat = rand() % cardinalidade_cjt(disponiveis);
-		insere_cjt(sub, disponiveis->v[aleat]);
-		retira_cjt(disponiveis, disponiveis->v[aleat]);
-	}
-	
-	destroi_cjt(disponiveis);
-	return sub;
+    int i;
+    int aleat;
+    for (i = 0; i < n; i++) {
+        aleat = rand() % cardinalidade_cjt(disponiveis);
+        insere_cjt(sub, disponiveis->v[aleat]);
+        retira_cjt(disponiveis, disponiveis->v[aleat]);
+    }
+    
+    destroi_cjt(disponiveis);
+    return sub;
 }
 
 void imprime_cjt(conjunto_t *c) {
-	if (vazio_cjt(c)) {
-		printf("Conjunto vazio.\n");
-		return;
-	}
+    if (vazio_cjt(c)) {
+        printf("Conjunto vazio.\n");
+        return;
+    }
 
-	int i;
-	for (i = 0; i < cardinalidade_cjt(c)-1; i++)
-		printf("%d ", c->v[i]);
-	printf("%d\n", c->v[cardinalidade_cjt(c)-1]);
+    int i;
+    for (i = 0; i < cardinalidade_cjt(c)-1; i++)
+        printf("%d ", c->v[i]);
+    printf("%d\n", c->v[cardinalidade_cjt(c)-1]);
 }
 
 void inicia_iterador_cjt(conjunto_t *c) {
-	c->ptr = 0;
+    c->ptr = 0;
 }
 
 int incrementa_iterador_cjt(conjunto_t *c, int *ret_iterador) {
-	*ret_iterador = c->v[c->ptr];
-	c->ptr++;
-	if (c->ptr > cardinalidade_cjt(c))
-		return 0;
-	return 1;
+    *ret_iterador = c->v[c->ptr];
+    c->ptr++;
+    if (c->ptr > cardinalidade_cjt(c))
+        return 0;
+    return 1;
 }
 
 int retira_um_elemento_cjt(conjunto_t *c) {
-	int aleat = rand() % cardinalidade_cjt(c);
-	int retirar = c->v[aleat];
-	int i;
-	for (i = aleat; i < cardinalidade_cjt(c)-1; i++)
-		c->v[i] = c->v[i + 1];
-	c->card--;
-	return retirar;
+    int aleat = rand() % cardinalidade_cjt(c);
+    int retirar = c->v[aleat];
+    int i;
+    for (i = aleat; i < cardinalidade_cjt(c)-1; i++)
+        c->v[i] = c->v[i + 1];
+    c->card--;
+    return retirar;
 }
diff --git a/tp4/makefile b/tp4/makefile
index e8d1210da29d2ceaaf4823832b5b1d0442535a43..9ea2d6798872d1b37ea6a1ae903887ae7d9d409b 100644
--- a/tp4/makefile
+++ b/tp4/makefile
@@ -18,4 +18,4 @@ tp4.o: tp4.c
 	$(CC) -c $(CFLAGS) tp4.c
 
 clean:
-	rm -f $(objects)
+	rm -f $(objects) tp4
diff --git a/tp4/tp4 b/tp4/tp4
deleted file mode 100755
index 20a040c28befaad663997ebf45fbef3595571709..0000000000000000000000000000000000000000
Binary files a/tp4/tp4 and /dev/null differ
diff --git a/tp4/tp4.c b/tp4/tp4.c
index 9f4e3ec54f31e1416c2a7ce6719baa9283020406..83470ddf7f4f58ee2b875a5e3b0e9e9366391b74 100644
--- a/tp4/tp4.c
+++ b/tp4/tp4.c
@@ -4,105 +4,105 @@
 #define MAX 100
 
 conjunto_t *le_conjunto_simples(int max) {
-	conjunto_t *leitura;
-	if ( !(leitura = cria_cjt(max)) )
-		return NULL;
-	int n;
-	scanf("%d", &n);
-	while (n) {
-		insere_cjt(leitura, n);
-		scanf("%d", &n);
-	}
-	return leitura;
+    conjunto_t *leitura;
+    if ( !(leitura = cria_cjt(max)) )
+        return NULL;
+    int n;
+    scanf("%d", &n);
+    while (n) {
+        insere_cjt(leitura, n);
+        scanf("%d", &n);
+    }
+    return leitura;
 }
 
 conjunto_t **le_vetor_conjuntos(int *tam, int max) {
-	conjunto_t **vetor_c;
-	if ( !(vetor_c = malloc(sizeof(conjunto_t *) * max)) )
-		return NULL;
-	int n, m;
-	scanf("%d", &n);
-	while (n) {
-		if ( !(vetor_c[*tam] = cria_cjt(15)) )
-			return NULL;
-		insere_cjt(vetor_c[*tam], n);
-		scanf("%d", &m);
-		while (m) {
-			insere_cjt(vetor_c[*tam], m);
-			scanf("%d", &m);
-		}
-		*tam = *tam + 1;
-		scanf("%d", &n);
-	}
-	return vetor_c;
+    conjunto_t **vetor_c;
+    if ( !(vetor_c = malloc(sizeof(conjunto_t *) * max)) )
+        return NULL;
+    int n, m;
+    scanf("%d", &n);
+    while (n) {
+        if ( !(vetor_c[*tam] = cria_cjt(15)) )
+            return NULL;
+        insere_cjt(vetor_c[*tam], n);
+        scanf("%d", &m);
+        while (m) {
+            insere_cjt(vetor_c[*tam], m);
+            scanf("%d", &m);
+        }
+        *tam = *tam + 1;
+        scanf("%d", &n);
+    }
+    return vetor_c;
 }
 
 conjunto_t **libera_vetor_conjuntos(conjunto_t **vetor_c, int tam) {
-	int i;
-	for (i = 0; i < tam; i++)
-		vetor_c[i] = destroi_cjt(vetor_c[i]);
-	free(vetor_c);
-	return NULL;
+    int i;
+    for (i = 0; i < tam; i++)
+        vetor_c[i] = destroi_cjt(vetor_c[i]);
+    free(vetor_c);
+    return NULL;
 }
 
 conjunto_t *acha_solucao(conjunto_t **herois, conjunto_t *missao, conjunto_t **equipes, int tam_equipes) {
-	conjunto_t *menor;
-	menor = cria_cjt(15);
-	conjunto_t *uniao_old;
-	conjunto_t *uniao;
-	int i, j;
-	
-	for (i = 0; i < tam_equipes; i++) {
-		uniao = copia_cjt(herois[equipes[i]->v[0] - 1]);
-		/* copia o conjunto de habilidades de heroi	correspondente ao primeiro elemento do conjunto equipe da posicao atual do vetor de equipes. ex: se a equipe atual é [5 6 7], copia o quinto conjunto de habilidades de heroi (de indice 4). */
-		for (j = 1; j < cardinalidade_cjt(equipes[i]); j++) {
-			uniao_old = uniao;
-			uniao = uniao_cjt(uniao, herois[equipes[i]->v[j] - 1]);
-			uniao_old = destroi_cjt(uniao_old);
-			/* realiza a uniao de todos os conjuntos de habilidades de heroi referenciados no conjunto equipe da posicao atual do vetor de equipes. */
-		}
-		if (contido_cjt(missao, uniao)) {
-			if (vazio_cjt(menor) || cardinalidade_cjt(equipes[i]) < cardinalidade_cjt(menor)) {
-				menor = destroi_cjt(menor);
-				menor = copia_cjt(equipes[i]);
-			}
-		}
-		uniao = destroi_cjt(uniao);
-	}
-	
-	return menor;
+    conjunto_t *menor;
+    menor = cria_cjt(15);
+    conjunto_t *uniao_old;
+    conjunto_t *uniao;
+    int i, j;
+    
+    for (i = 0; i < tam_equipes; i++) {
+        uniao = copia_cjt(herois[equipes[i]->v[0] - 1]);
+        /* copia o conjunto de habilidades de heroi    correspondente ao primeiro elemento do conjunto equipe da posicao atual do vetor de equipes. ex: se a equipe atual é [5 6 7], copia o quinto conjunto de habilidades de heroi (de indice 4). */
+        for (j = 1; j < cardinalidade_cjt(equipes[i]); j++) {
+            uniao_old = uniao;
+            uniao = uniao_cjt(uniao, herois[equipes[i]->v[j] - 1]);
+            uniao_old = destroi_cjt(uniao_old);
+            /* realiza a uniao de todos os conjuntos de habilidades de heroi referenciados no conjunto equipe da posicao atual do vetor de equipes. */
+        }
+        if (contido_cjt(missao, uniao)) {
+            if (vazio_cjt(menor) || cardinalidade_cjt(equipes[i]) < cardinalidade_cjt(menor)) {
+                menor = destroi_cjt(menor);
+                menor = copia_cjt(equipes[i]);
+            }
+        }
+        uniao = destroi_cjt(uniao);
+    }
+    
+    return menor;
 }
 
 int main() {
     /* ler os herois e suas habilidades */
-	int tam_herois = 0;
-	conjunto_t **vetor_herois;
-	vetor_herois = le_vetor_conjuntos(&tam_herois, MAX);
-	
+    int tam_herois = 0;
+    conjunto_t **vetor_herois;
+    vetor_herois = le_vetor_conjuntos(&tam_herois, MAX);
+    
     /* ler a missao */
-	conjunto_t *missao;
-	missao = le_conjunto_simples(20);
-	
+    conjunto_t *missao;
+    missao = le_conjunto_simples(20);
+    
     /* ler as equipes de herois */
-	int tam_equipes = 0;
-	conjunto_t **vetor_equipes;
-	vetor_equipes = le_vetor_conjuntos(&tam_equipes, MAX);
+    int tam_equipes = 0;
+    conjunto_t **vetor_equipes;
+    vetor_equipes = le_vetor_conjuntos(&tam_equipes, MAX);
 
     /* a solucao eh encontrada se a missao esta contido na uniao das 
      * habilidades de uma equipe, mas tomando-se aquela de menor tamanho. */
-	conjunto_t *solucao;
-	solucao = acha_solucao(vetor_herois, missao, vetor_equipes, tam_equipes);
-	if (vazio_cjt(solucao)) {
-		printf("NENHUMA\n");
-	} else {
-		imprime_cjt(solucao);
-	}
+    conjunto_t *solucao;
+    solucao = acha_solucao(vetor_herois, missao, vetor_equipes, tam_equipes);
+    if (vazio_cjt(solucao)) {
+        printf("NENHUMA\n");
+    } else {
+        imprime_cjt(solucao);
+    }
 
     /* libera toda a memoria alocada dinamicamente */
-	vetor_herois = libera_vetor_conjuntos(vetor_herois, tam_herois);
-	missao = destroi_cjt(missao);
-	vetor_equipes = libera_vetor_conjuntos(vetor_equipes, tam_equipes);
-	solucao = destroi_cjt(solucao);
+    vetor_herois = libera_vetor_conjuntos(vetor_herois, tam_herois);
+    missao = destroi_cjt(missao);
+    vetor_equipes = libera_vetor_conjuntos(vetor_equipes, tam_equipes);
+    solucao = destroi_cjt(solucao);
 
     return 0;
 }