diff --git a/t1/enunciado.pdf b/t1/enunciado.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..056e1963fbf1ba00084ab40605e12ee17a1028fa
Binary files /dev/null and b/t1/enunciado.pdf differ
diff --git a/t1/libconjunto.h b/t1/libconjunto.h
new file mode 100644
index 0000000000000000000000000000000000000000..bae2d7af7b107a6652cba9e4315ea88826dfc912
--- /dev/null
+++ b/t1/libconjunto.h
@@ -0,0 +1,136 @@
+/*
+ * TAD conjunto
+ * Autores:
+ * Andre Ricardo Abed Gregio
+ * Fabiano Silva
+ * Luis Carlos Erpen de Bona
+ * Marcos Alexandre Castilho
+ *
+ * Versao 1.0.0 de 10/11/2021
+ * Versao 1.0.1 de 16/08/2022
+ * Versao 1.1.0 de 17/11/2022
+ */
+
+struct conjunto {
+ int max; /* tamanho maximo do vetor atualmente alocado */
+ int card; /* cardinalidade, isto eh, tamanho usado ate max */
+ int ptr; /* ponteiro para algum indice do vetor (iterador) */
+ int *v; /* vetor de inteiros com no maximo max elementos */
+};
+typedef struct conjunto conjunto_t;
+
+/*
+ * Cria um conjunto vazio e o retorna, se falhar retorna NULL.
+ * max eh o tamanho maximo do conjunto, isto eh, o tamanho maximo do vetor
+ */
+conjunto_t *cria_cjt (int max);
+
+/*
+ * Remove todos os elementos do conjunto, libera espaco e devolve NULL.
+ */
+conjunto_t *destroi_cjt (conjunto_t *c);
+
+/*
+ * Retorna 1 se o conjunto esta vazio e 0 caso contrario.
+ */
+int vazio_cjt (conjunto_t *c);
+
+/*
+ * Retorna a cardinalidade do conjunto, isto eh, o numero de elementos presentes nele.
+ */
+int cardinalidade_cjt (conjunto_t *c);
+
+/*
+ * Insere o elemento no conjunto, garante que nao existam repeticoes.
+ * Retorna 1 se a operacao foi bem sucedida. Se tentar inserir elemento existente,
+ * nao faz nada e retorna 1 tambem. Retorna 0 em caso de falha por falta de espaco.
+ */
+int insere_cjt (conjunto_t *c, int elemento);
+
+/*
+ * Remove o elemento 'elemento' do conjunto caso ele exista.
+ * Retorna 1 se a operacao foi bem sucedida e 0 se o elemento nao existe.
+ */
+int retira_cjt (conjunto_t *c, int elemento);
+
+/*
+ * Retorna 1 se o elemento pertence ao conjunto e 0 caso contrario.
+ */
+int pertence_cjt (conjunto_t *c, int elemento);
+
+/*
+ * Retorna 1 se o conjunto c1 esta contido no conjunto c2 e 0 caso contrario.
+ */
+int contido_cjt (conjunto_t *c1, conjunto_t *c2);
+
+/*
+ * Retorna 1 se o conjunto c1 eh igual ao conjunto c2 e 0 caso contrario.
+ */
+int sao_iguais_cjt (conjunto_t *c1, conjunto_t *c2);
+
+/*
+ * Cria e retorna o conjunto diferenca entre c1 e c2, nesta ordem.
+ * Retorna NULL se a operacao falhou.
+ */
+conjunto_t *diferenca_cjt (conjunto_t *c1, conjunto_t *c2);
+
+/*
+ * Cria e retorna o conjunto interseccao entre os conjuntos c1 e c2.
+ * Retorna NULL se a operacao falhou.
+ */
+conjunto_t *interseccao_cjt (conjunto_t *c1, conjunto_t *c2);
+
+/*
+ * Cria e retorna o conjunto uniao entre os conjunto c1 e c2.
+ * Retorna NULL se a operacao falhou.
+ */
+conjunto_t *uniao_cjt (conjunto_t *c1, conjunto_t *c2);
+
+/*
+ * Cria e retorna uma copia do conjunto c e NULL em caso de falha.
+ */
+conjunto_t *copia_cjt (conjunto_t *c);
+
+/*
+ * Cria e retorna um subconjunto com elementos aleatorios do conjunto c.
+ * Se o conjunto for vazio, retorna um subconjunto vazio.
+ * Se n >= cardinalidade (c) entao retorna o proprio conjunto c.
+ * Supoe que a funcao srand () tenha sido chamada antes.
+ */
+conjunto_t *cria_subcjt_cjt (conjunto_t *c, int n);
+
+/*
+ * Imprime os elementos do conjunto sempre em ordem crescente,
+ * mesmo que a estrutura interna nao garanta isso.
+ * Na impressao os elementos sao separados por um unico espaco
+ * em branco entre os elementos, sendo que apos o ultimo nao
+ * deve haver espacos em branco. Ao final imprime um \n.
+ */
+void imprime_cjt (conjunto_t *c);
+
+/*
+ * As funcoes abaixo implementam um iterador que vao permitir
+ * percorrer os elementos do conjunto.
+ * O ponteiro ptr da struct (iterador) pode ser inicializado para apontar
+ * para o primeiro elemento e incrementado ate' o ultimo elemento
+ * do conjunto.
+ */
+
+/*
+ * Inicializa ptr usado na funcao incrementa_iterador
+ */
+void inicia_iterador_cjt (conjunto_t *c);
+
+/*
+ * Devolve no parametro ret_iterador o elemento apontado e incrementa o iterador.
+ * A funcao retorna 0 caso o iterador ultrapasse o ultimo elemento, ou retorna
+ * 1 caso o iterador aponte para um elemento valido (dentro do conjunto).
+ */
+int incrementa_iterador_cjt (conjunto_t *c, int *ret_iterador);
+
+/*
+ * Escolhe um elemento qualquer do conjunto para ser removido, o remove e
+ * o retorna.
+ * Nao faz teste se conjunto eh vazio, deixa para main fazer isso
+ */
+int retira_um_elemento_cjt (conjunto_t *c);
diff --git a/t1/libfila.h b/t1/libfila.h
new file mode 100644
index 0000000000000000000000000000000000000000..74512a0acb21e39ed670646f26ea2873dabdb768
--- /dev/null
+++ b/t1/libfila.h
@@ -0,0 +1,48 @@
+/*
+ * TAD fila
+ * Autores:
+ * Marcos Alexandre Castilho
+ * Luis Carlos Erpen de Bona
+ *
+ * Primeira versão em 18/10/2019
+ * Versao 1.0.0 de 10/11/2021
+ * Versao 1.0.1 de 08/2022
+ * Versao 2.0.0 de 14/12/2022
+ */
+
+struct nodo_f {
+ int elem;
+ struct nodo_f *prox;
+};
+typedef struct nodo_f nodo_f_t;
+
+struct fila {
+ nodo_f_t *ini;
+ nodo_f_t *fim;
+ int tamanho; /* numero de elementos na fila */
+};
+typedef struct fila fila_t;
+
+/* Cria uma fila vazia e a retorna, se falhar retorna NULL. */
+fila_t *cria_fila ();
+
+/* Remove todos os elementos da fila, libera espaco e devolve NULL. */
+fila_t *destroi_fila (fila_t *f);
+
+/* Retorna 1 se a fila esta vazia e 0 caso contrario. */
+int vazia_fila (fila_t *f);
+
+/* Retorna o numero de elementos da fila. */
+int tamanho_fila (fila_t *f);
+
+/* Insere o elemento no final da fila (politica FIFO).
+ * Retorna 1 se a operacao foi bem sucedida e 0 caso contrario. */
+int insere_fila (fila_t *f, int elemento);
+
+/* Remove o elemento do inicio da fila (politica FIFO) e o retorna
+ * no parametro *elemento. Retorna 1 se a operacao foi bem sucedida
+ * e 0 caso contrario. */
+int retira_fila (fila_t *f, int *elemento);
+
+/* para depuracao */
+void imprime_fila (fila_t *f);
diff --git a/t1/liblef.h b/t1/liblef.h
new file mode 100644
index 0000000000000000000000000000000000000000..347c68d8832780a1f42cd582be8724d9ecb8853a
--- /dev/null
+++ b/t1/liblef.h
@@ -0,0 +1,70 @@
+/* Implementa o TAD Lista de Eventos Futuros (LEF)
+ * Feito em C para a disciplina CI1001 - Programacao 1
+ * Autor: Luis C. E. Bona
+ *
+ * Versao 1.0.0 10/11/2021
+ * Versao 1.0.1 16/08/2022
+ * Versao 2.0.0 14/12/2022
+ */
+
+/* A LEF é uma lista que armazena eventos ordenados pelo membro tempo
+ * do tipo evento_t. Cada evento pode ter um tipo e armazenar em dados
+ * diferentes estruturas de dados que permitem descrever cada evento. */
+
+/*
+ * evento_t possui os dados que descrevem os eventos
+ */
+typedef struct evento {
+ int tempo; /* tempo logico do evento */
+ int tipo; /* inteiro para diferenciar os diferentes tipos de evento */
+ int dado1; /* um inteiro para guardar dados do evento */
+ int dado2; /* um inteiro para guardar dados do evento */
+} evento_t;
+
+/*
+ * nodo_t eh uma estrutura interna que representa cada nodo da LEF.
+ * Externamente o usuario da biblioteca nao vai receber essa estrutura para
+ * evitar acesso direto ao ponteiro prox.
+ */
+typedef struct nodo_lef {
+ evento_t *evento;
+ struct nodo_lef *prox;
+} nodo_lef_t;
+
+/*
+ * Representacao da LEF
+ */
+typedef struct lef {
+ nodo_lef_t *Primeiro;
+} lef_t;
+
+/*
+ * Cria uma LEF vazia
+ */
+lef_t *cria_lef ();
+
+/*
+ * Destroi a LEF e retorna NULL.
+ */
+lef_t *destroi_lef (lef_t *l);
+
+/*
+ * Adiciona um evento na primeira posicao da LEF. Uma nova copia
+ * da estrutura evento sera feita.
+ * Retorna 1 em caso de sucesso, 0 caso contrario.
+ */
+int adiciona_inicio_lef (lef_t *l, evento_t *evento);
+
+/*
+ * Adiciona um evento de acordo com o valor evento->tempo na LEF.
+ * Uma nova copia da estrutura evento sera feita
+ * Retorna 1 em caso de sucesso, 0 caso contrario.
+ */
+int adiciona_ordem_lef (lef_t *l, evento_t *evento);
+
+/*
+ * Retorna e retira o primeiro evento da LEF.
+ * A responsabilidade por desalocar
+ * a memoria associada eh de quem chama essa funcao.
+ */
+evento_t *obtem_primeiro_lef (lef_t *l);
diff --git a/t1/makefile b/t1/makefile
new file mode 100644
index 0000000000000000000000000000000000000000..52c38d35a9c811657c10dddab2712d76106fdfdb
--- /dev/null
+++ b/t1/makefile
@@ -0,0 +1,29 @@
+# Makefile de exemplo (Manual do GNU Make)
+
+CFLAGS = -Wall -std=c90 -g # flags de compilacao
+LDFLAGS = -lm
+
+CC = gcc
+
+# arquivos-objeto
+ objects = mundo.o libconjunto.o liblef.o libfila.o
+
+mundo: mundo.o libconjunto.o liblef.o libfila.o
+ $(CC) -o mundo mundo.o libconjunto.o liblef.o libfila.o $(LDFLAGS)
+
+libconjunto.o: libconjunto.c
+ $(CC) -c $(CFLAGS) libconjunto.c
+
+liblef.o: liblef.c
+ $(CC) -c $(CFLAGS) liblef.c
+
+libfila.o: libfila.c
+ $(CC) -c $(CFLAGS) libfila.c
+
+mundo.o: mundo.c
+ $(CC) -c $(CFLAGS) mundo.c
+
+clean:
+ rm -f $(objects) mundo
+
+