diff --git a/cycle1.png b/cycle1.png
new file mode 100644
index 0000000..cde4dbe
Binary files /dev/null and b/cycle1.png differ
diff --git a/cycle2.png b/cycle2.png
new file mode 100644
index 0000000..3517699
Binary files /dev/null and b/cycle2.png differ
diff --git a/cycle3.png b/cycle3.png
new file mode 100644
index 0000000..65d1818
Binary files /dev/null and b/cycle3.png differ
diff --git a/presentation.md b/presentation.md
index a3e1bd6..b19e90a 100644
--- a/presentation.md
+++ b/presentation.md
@@ -44,6 +44,7 @@ header-includes:
 - \setbeamercolor{subsection in sidebar shaded}{fg=grey}
 - \setbeamercolor{title}{fg=ori}
 - \setbeamercolor{titlelike}{fg=brown}
+classoption: "aspectratio=43"
 ---
 
 # Programme
@@ -54,6 +55,15 @@ Dans quel sens un "programme" ?
 
 ## Neovim
 
+```sh
+$ fd --extension c . 'neovim/' | wc -l
+174
+```
+
+# Exemple d'un programme
+
+## Neovim
+
 ```sh
 $ fd --extension c . 'neovim/' | wc -l
 174
@@ -62,4 +72,68 @@ $ wc `fd --extension c . 'neovim/'` -l
  ...
  300347 total
 ```
+# Parsing
 
+## Regex
+```
+^(\**\w+\s+?\ ?){1,}\([^!@#$+%^]+?\)\s+
+
+([a-zA-Z_0-9]+)\(.*\)
+```
+
+# Recherche des CC
+
+Un algo ?
+
+# Recherche des CC
+
+* call
+* vu
+
+# Recherche des cycles
+
+# Recherche des cycles
+
+\tiny
+## Exemple d'un cycle
+
+```c
+void bar(void)
+{
+	toto(1, 1);
+}
+
+int foo(void)
+{
+	hello();
+	bar();
+	return 1;
+}
+
+int toto(int a, int b)
+{
+	if (a != 1)
+		foo();
+	else
+		aurevoir();
+	return a + b;
+}
+```
+\normalsize
+
+# Recherche des cycles
+
+![](cycle1.png)
+
+# Recherche des cycles
+
+![](cycle2.png)
+
+# Recherche des cycles
+
+![](cycle3.png)
+
+# Fin
+
+|**Demo**|
+|:------:|
diff --git a/prez.md b/prez.md
index cef8d31..507f6df 100644
--- a/prez.md
+++ b/prez.md
@@ -8,4 +8,49 @@ interpreté sous forme d'un graphe orienté avec un vecteur de successeur et un
 graphe a matrice compacte. 
 
 Pour exemple, voici un programme avec plusieur fichiers (174) et plusieurs
-milliers de lignes de code (300347)
+milliers de lignes de code (300347).
+
+Le code est parsé ligne par ligne contre 2 regex. Le premier pour les
+definitions des fonctions et le deuxieme pour les appels des fonctions.
+
+Apres la construction des graphes, une des taches etait de cherches des
+composantes connex dans ces graphes.
+
+Une CC dans un code est une fonction qui appele plusieurs autres fonctions. Par
+exemple la fonction main est une composante connexe. Et une fonction qui n'est
+pas appelé par main ou ses successeurs est consideré comme une autre CC.
+
+Pour ce faire, je pensais d'abord faire un algo de recherche, car sur internet
+si on cherche des info sur le sujet, ils parlent de faire un algo. Comme c'est
+moi qui construit le graphe, je peux deduire qui est une CC et qui n'en est
+pas. 
+
+J'ai donc introduit une variable call dans mes stucture pour dire si une
+fonction (noeud) a été appelé ou pas. Puis, j'ai une variable vu, qui dis si
+lors de print d'un noeud (main), on a vu cette fontion. Et donc toute fonction
+qui etait pas vu peut etre une CC.
+
+L'etape suivante etait de trouver des cycles des appels de fonctions. Voici un
+exemple de cycle. On voit que la fonction bar appele la fonction toto qui appel
+la fonction foo qui reappel la fonction bar. 
+
+Pour la recherche de cycles, j'ai utilisé l'algo DFS (Deep First Search /
+recherche en profondeur).
+
+J'ai trouvé un pseudo-code sur internet que j'ai utilisé et adapté pour mes
+structures. Dans le pseudo-code il y a 3 algorithmes. 
+
+Dans le premier on parcour le graph, pour chaque noeud on crée une pile vide,
+on push le noeud courrant dans la pile, on dis que le noeud est dans la stack
+et on fait un DFS dedans.
+
+Deuxieme algo est le DFS. Pour chaque successeur dans le noeud on regarde s'il
+est visité ou dans la pile. Si le successeur est dans la pile, ca veut dire
+qu'on a trouvé un cycle. Donc on affiche le cycle. Si le successeur est pas
+encore visité, on le push dans la stack en indiquant qu'il est desormais dans
+la stack, et on appele recursivement DFS pous ce successeur.
+
+A la fin on indique qu'on a fini avec le noeud et on pop la derniere valeur de
+la pile.
+
+Dans le troisieme algo on print le cycle. 
diff --git a/src/cparse.c b/src/cparse.c
index 43c000f..ac55198 100644
--- a/src/cparse.c
+++ b/src/cparse.c
@@ -18,7 +18,7 @@ void find_funcs(const char *path, graph_vec *gv, graph_mco *gmc, double *tv, dou
 	regmatch_t rm[2];
 	bool in;
 
-	const char *re_func_decl = "^(\\**\\w+\\s+?\\ ?\\ ?){1,}\\([^!@#$+%^]+?\\)\\s+";
+	const char *re_func_decl = "^(\\**\\w+\\s+?){1,}\\([^!@#$+%^]+?\\)\\s+";
 	const char *re_func_call = "([a-zA-Z_0-9]+)\\(.*\\)";
 
 	token = malloc(1024 * sizeof(char));