diff --git a/42sh/src/parser/add_case.c b/42sh/src/parser/add_case.c
index 4455a273..a46337da 100644
--- a/42sh/src/parser/add_case.c
+++ b/42sh/src/parser/add_case.c
@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/03/04 20:42:13 by ariard            #+#    #+#             */
-/*   Updated: 2017/03/10 17:34:11 by ariard           ###   ########.fr       */
+/*   Updated: 2017/03/10 18:10:47 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
diff --git a/42sh/src/parser/add_condition.c b/42sh/src/parser/add_condition.c
index 3d438238..b7c47762 100644
--- a/42sh/src/parser/add_condition.c
+++ b/42sh/src/parser/add_condition.c
@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/03/10 17:06:16 by ariard            #+#    #+#             */
-/*   Updated: 2017/03/10 18:06:27 by ariard           ###   ########.fr       */
+/*   Updated: 2017/03/10 18:10:42 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
diff --git a/42sh/src/parser/add_sep.c b/42sh/src/parser/add_sep.c
index 43e2a4e0..b791581b 100644
--- a/42sh/src/parser/add_sep.c
+++ b/42sh/src/parser/add_sep.c
@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/02/15 19:12:07 by ariard            #+#    #+#             */
-/*   Updated: 2017/03/10 18:05:35 by ariard           ###   ########.fr       */
+/*   Updated: 2017/03/10 18:10:55 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
diff --git a/42sh/src/parser/aggregate_sym.c b/42sh/src/parser/aggregate_sym.c
index eac0d0a7..57fd12b8 100644
--- a/42sh/src/parser/aggregate_sym.c
+++ b/42sh/src/parser/aggregate_sym.c
@@ -1,4 +1,4 @@
-/* ************************************************************************** */ /*                                                                            */
+/* ************************************************************************** */
 /*                                                        :::      ::::::::   */
 /*   aggregate_sym.c                                    :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
@@ -11,6 +11,11 @@
 
 #include "minishell.h"
 
+/*
+ * In case of grammar error, manange it
+ * 
+*/
+
 t_aggrematch		g_aggrematch[] =
 {
 	{TK_WORD, CMD_SUFFIX, CMD_SUFFIX, 0},
@@ -134,8 +139,6 @@ t_aggrematch		g_aggrematch[] =
 	{IO_REDIRECT, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE},
 	{IO_REDIRECT, PIPE_CLOSE_SEQUENCE, PIPE_CLOSE_SEQUENCE, PIPE_CLOSE_SEQUENCE},
 	{IO_REDIRECT, COMPOUND_COMMAND, REDIRECT_LIST, REDIRECT_LIST},
-
-//to check 
 	{IO_REDIRECT, CMD_SUFFIX, CMD_SUFFIX, CMD_SUFFIX},
 	{IO_REDIRECT, CMD_NAME, CMD_SUFFIX, 0},
 	{IO_REDIRECT, CMD_WORD, CMD_SUFFIX, 0},
@@ -147,6 +150,15 @@ t_aggrematch		g_aggrematch[] =
 	{IO_REDIRECT, TK_BANG, CMD_PREFIX, TK_BANG},
 	{IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, 0},
 	{IO_REDIRECT, NEWLINE_LIST, CMD_PREFIX, 0},
+	{IO_REDIRECT, TK_WHILE, CMD_PREFIX, 0},
+	{IO_REDIRECT, TK_UNTIL, CMD_PREFIX, 0},
+	{IO_REDIRECT, TK_DO, CMD_PREFIX, 0},
+	{IO_REDIRECT, TK_THEN, CMD_PREFIX, TK_BANG},
+	{IO_REDIRECT, TK_IF, CMD_PREFIX, 0},
+	{IO_REDIRECT, TK_ELIF, CMD_PREFIX, 0},
+	{IO_REDIRECT, TK_ELSE, CMD_PREFIX, 0},
+	{IO_REDIRECT, TK_PAREN_CLOSE, CMD_PREFIX, 0},
+
 	{REDIRECT_LIST, COMPOUND_COMMAND, COMPOUND_COMMAND, COMPOUND_COMMAND},
 	{CMD_SUFFIX, CMD_WORD, SIMPLE_COMMAND, CMD_PREFIX},
 	{CMD_SUFFIX, CMD_NAME, SIMPLE_COMMAND, CMD_NAME},
@@ -161,6 +173,19 @@ t_aggrematch		g_aggrematch[] =
 	{CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, TK_BANG},
 	{CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, 0},
 	{CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, TK_WHILE, SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, TK_UNTIL,SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, TK_DO, SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, TK_THEN, SIMPLE_COMMAND, TK_BANG},
+	{CMD_PREFIX, TK_IF, SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, TK_ELIF, SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, TK_ELSE, SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, TK_PAREN_CLOSE, SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, COMPLETE_CONDITION, SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, CONDITION, SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, TK_PIPE, SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, SEQUENCE, SIMPLE_COMMAND, 0},
+	{CMD_PREFIX, COMPOUND_LIST, SIMPLE_COMMAND, 0},
 
 	{CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, CMD_PREFIX},
 //to check	
@@ -182,6 +207,7 @@ t_aggrematch		g_aggrematch[] =
 	{CMD_NAME, COMPOUND_LIST, CMD_SUPERIOR, 0},
 	{CMD_NAME, CASE_LIST_NS, CMD_SUPERIOR, 0},
 	{CMD_NAME, COMPLETE_CONDITION, CMD_SUPERIOR, 0},
+	{CMD_NAME, CONDITION, CMD_SUPERIOR, 0},
 	{CMD_NAME, TK_PIPE, CMD_SUPERIOR, 0},
 	{CMD_NAME, SEQUENCE, CMD_SUPERIOR, 0},
 	{CMD_NAME, AND_OR_MAJOR, CMD_SUPERIOR, 0},
@@ -199,18 +225,15 @@ t_aggrematch		g_aggrematch[] =
 	{LOOP, TK_UNTIL, UNTIL_CLAUSE, TK_UNTIL},
 	{UNTIL_CLAUSE, ALL, COMPOUND_COMMAND, 0},
 	{WHILE_CLAUSE, ALL, COMPOUND_COMMAND, 0},
-//	{ELSE_PART, COMPOUND_LIST, ELSE_PART, TK_ELIF},
-//	{ELSE_PART, COMPLETE_CONDITION, IF_CLAUSE, COMPLETE_CONDITION},
 	{IF_CLAUSE, ALL, COMPOUND_COMMAND, 0},
 	{CASE_LIST_NS, TK_IN, TK_IN, TK_IN},
 	{CASE_CLAUSE, ALL, COMPOUND_COMMAND, 0},
 	{FOR_CLAUSE, ALL, COMPOUND_COMMAND, 0},
-//	{COMPOUND_LIST, TK_ELSE, ELSE_PART, TK_ELSE},
 	{COMPOUND_LIST, TK_IF, CONDITION, TK_IF},
 	{COMPOUND_LIST, TK_THEN, CONDITION, TK_THEN},
 	{COMPOUND_LIST, TK_PAREN_CLOSE, CLOSE_LIST, TK_PAREN_CLOSE},
 	{COMPOUND_LIST, COMPLETE_CONDITION, COMPLETE_CONDITION, COMPLETE_CONDITION},
-//	{COMPOUND_LIST, TK_THEN, ELSE_PART, TK_ELIF},
+	{COMPOUND_LIST, CONDITION, CONDITION, CONDITION},
 	{COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
 	{COMPOUND_LIST, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
 	{CLOSE_LIST, PATTERN, CASE_LIST_NS, PATTERN_CASE},
@@ -249,6 +272,7 @@ t_aggrematch		g_aggrematch[] =
 	{COMMAND, COMPLETE_COMMANDS, PIPE_SEMI_SEQUENCE, 0},
 	{COMMAND, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE, 0},
 	{COMMAND, COMPLETE_CONDITION, PIPE_SEMI_SEQUENCE, 0},
+	{COMMAND, CONDITION, PIPE_SEMI_SEQUENCE, 0},
 	{COMPOUND_COMMAND, SEQUENCE, PIPE_CLOSE_SEQUENCE, 0},
 	{COMPOUND_COMMAND, COMPOUND_LIST, PIPE_CLOSE_SEQUENCE, 0},
 	{COMPOUND_COMMAND, CASE_LIST_NS, PIPE_CLOSE_SEQUENCE, 0}, 
@@ -270,6 +294,7 @@ t_aggrematch		g_aggrematch[] =
 	{COMPOUND_COMMAND, COMPLETE_COMMANDS, PIPE_CLOSE_SEQUENCE, 0},
 	{COMPOUND_COMMAND, AND_OR_MAJOR, PIPE_CLOSE_SEQUENCE, 0},
 	{COMPOUND_COMMAND, COMPLETE_CONDITION, PIPE_CLOSE_SEQUENCE, 0},
+	{COMPOUND_COMMAND, CONDITION, PIPE_CLOSE_SEQUENCE, 0},
 	{END_COMMAND, SEQUENCE, PIPE_SEQUENCE, SEQUENCE},
 	{END_COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
 	{END_COMMAND, AND_OR_MAJOR, LIST, AND_OR_MAJOR},
@@ -288,6 +313,7 @@ t_aggrematch		g_aggrematch[] =
 	{END_COMMAND, TK_THEN, PIPE_SEQUENCE, 0},
 	{END_COMMAND, TK_ELSE, PIPE_SEQUENCE, 0},
 	{END_COMMAND, COMPLETE_CONDITION, PIPE_SEQUENCE, 0},
+	{END_COMMAND, CONDITION, PIPE_SEQUENCE, 0},
 	{END_COMMAND, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
 	{END_COMMAND, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
 	{PIPE_SEMI_SEQUENCE, SEQUENCE, PIPE_SEMI_SEQUENCE, SEQUENCE},
@@ -311,6 +337,7 @@ t_aggrematch		g_aggrematch[] =
 	{PIPE_SEQUENCE, COMPOUND_LIST, PIPELINE, 0},
 	{PIPE_SEQUENCE, CASE_LIST_NS, PIPELINE, 0},
 	{PIPE_SEQUENCE, COMPLETE_CONDITION, PIPELINE, 0},
+	{PIPE_SEQUENCE, CONDITION, PIPELINE, 0},
 	{PIPELINE, TK_WHILE, AND_OR, 0},
 	{PIPELINE, TK_UNTIL, AND_OR, 0},
 	{PIPELINE, TK_DO, AND_OR, 0},
@@ -330,6 +357,7 @@ t_aggrematch		g_aggrematch[] =
 //	{PIPELINE, LINEBREAK, AND_OR, AND_OR},
 	{PIPELINE, SEPARATOR_OP, AND_OR, 0},
 	{PIPELINE, COMPLETE_CONDITION, AND_OR, 0},
+	{PIPELINE, CONDITION, AND_OR, 0},
 	{PIPELINE, AND_OR_MAJOR, AND_OR, AND_OR_MAJOR},
 	{AND_OR_MAJOR, AND_OR_MAJOR, AND_OR_MAJOR, AND_OR_MAJOR},
 	{AND_OR, TK_DO, COMPOUND_LIST, 0},
@@ -345,6 +373,7 @@ t_aggrematch		g_aggrematch[] =
 	{AND_OR, TK_LBRACE, COMPOUND_LIST, 0},
 	{AND_OR, CASE_LIST_NS, CASE_LIST_NS, 0},
 	{AND_OR, COMPLETE_CONDITION, COMPOUND_LIST, 0},
+	{AND_OR, CONDITION, COMPOUND_LIST, 0},
 	{AND_OR, SEPARATOR_OP, LIST, LIST},
 	{AND_OR, NEWLINE_LIST, LIST, 0},
 	{AND_OR, LINEBREAK, LIST, 0},
@@ -370,21 +399,21 @@ int			aggregate_sym(t_list **stack, t_sym *new_sym, t_parstate *state)
 		return (1);
 	i = 0;
 	head = (*stack)->content;
-//	DG("aggregate head %s && sym %s",
-//	read_state(*head), read_state(*new_sym));
+	DG("aggregate head %s && sym %s",
+	read_state(*head), read_state(*new_sym));
 	while (g_aggrematch[i].top)
 	{
 		if (*new_sym == g_aggrematch[i].top
 			&& MATCH_STACK(*head, g_aggrematch[i].under))
 	
 		{
-//			DG("MATCH : %s", read_state(g_aggrematch[i].new_sym));
+			DG("MATCH : %s", read_state(g_aggrematch[i].new_sym));
 			*new_sym = g_aggrematch[i].new_sym;
 			if (g_aggrematch[i].erase_sym)
 			{
 				pop_stack(stack, g_aggrematch[i].erase_sym);
 				head = (*stack)->content;
-//				DG("stack after pop: %s", read_state(*head));
+				DG("stack after pop: %s", read_state(*head));
 			}
 			if (eval_sym(stack, *new_sym))
 			{
diff --git a/42sh/src/parser/eval_sym.c b/42sh/src/parser/eval_sym.c
index 0c95ec1e..130e15bc 100644
--- a/42sh/src/parser/eval_sym.c
+++ b/42sh/src/parser/eval_sym.c
@@ -10,7 +10,7 @@
 /* ************************************************************************** */
 
 #include "minishell.h"
-
+	
 t_stackmatch	g_stackmatch[] =
 {
 	{TK_WORD, CMD_SUFFIX},
@@ -41,15 +41,26 @@ t_stackmatch	g_stackmatch[] =
 	{TK_IO_NUMBER, PIPE_SEMI_SEQUENCE},
 	{TK_IO_NUMBER, PIPE_CLOSE_SEQUENCE},
 	{TK_IO_NUMBER, SEQUENCE},
-//	watch!
 	{TK_IO_NUMBER, CMD_SUPERIOR},
 	{TK_IO_NUMBER, AND_OR_MAJOR},
+	{TK_IO_NUMBER, TK_WHILE},
+	{TK_IO_NUMBER, TK_UNTIL},
+	{TK_IO_NUMBER, TK_IF},
+	{TK_IO_NUMBER, TK_DO},
+	{TK_IO_NUMBER, TK_ELIF},
+	{TK_IO_NUMBER, TK_THEN},
+	{TK_IO_NUMBER, TK_PAREN_CLOSE},
+	{TK_IO_NUMBER, COMPLETE_CONDITION},
+	{TK_IO_NUMBER, CONDITION},
+	{TK_IO_NUMBER, COMPOUND_LIST},
 	{TK_AND_IF, AND_OR},
 	{TK_AND_IF, CMD_SUPERIOR},
 	{TK_AND_IF, PIPE_SEMI_SEQUENCE},
+	{TK_AND_IF, COMPOUND_LIST},
 	{TK_OR_IF, AND_OR},
 	{TK_OR_IF, CMD_SUPERIOR},
 	{TK_OR_IF, PIPE_SEMI_SEQUENCE},
+	{TK_OR_IF, COMPOUND_LIST},
 	{TK_DSEMI, LINEBREAK},
 	{TK_DSEMI, TK_BANG},
 	{TK_DSEMI, COMPLETE_COMMANDS},
@@ -76,6 +87,18 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LESS, PIPE_SEMI_SEQUENCE},
 	{TK_LESS, PIPE_CLOSE_SEQUENCE},
 	{TK_LESS, SEQUENCE},
+	{TK_LESS, CMD_SUPERIOR},
+	{TK_LESS, AND_OR_MAJOR},
+	{TK_LESS, TK_WHILE},
+	{TK_LESS, TK_UNTIL},
+	{TK_LESS, TK_IF},
+	{TK_LESS, TK_DO},
+	{TK_LESS, TK_ELIF},
+	{TK_LESS, TK_THEN},
+	{TK_LESS, TK_PAREN_CLOSE},
+	{TK_LESS, COMPLETE_CONDITION},
+	{TK_LESS, CONDITION},
+	{TK_LESS, COMPOUND_LIST},
 //	watch !
 	{TK_LESS, CMD_SUPERIOR},
 	{TK_LESS, AND_OR_MAJOR},
@@ -95,6 +118,18 @@ t_stackmatch	g_stackmatch[] =
 	{TK_GREAT, PIPE_SEMI_SEQUENCE},
 	{TK_GREAT, PIPE_CLOSE_SEQUENCE},
 	{TK_GREAT, SEQUENCE},
+	{TK_GREAT, CMD_SUPERIOR},
+	{TK_GREAT, AND_OR_MAJOR},
+	{TK_GREAT, TK_WHILE},
+	{TK_GREAT, TK_UNTIL},
+	{TK_GREAT, TK_IF},
+	{TK_GREAT, TK_DO},
+	{TK_GREAT, TK_ELIF},
+	{TK_GREAT, TK_THEN},
+	{TK_GREAT, TK_PAREN_CLOSE},
+	{TK_GREAT, COMPLETE_CONDITION},
+	{TK_GREAT, CONDITION},
+	{TK_GREAT, COMPOUND_LIST},
 //	watch !
 //duplicate and extend
 	{TK_GREAT, CMD_SUPERIOR},
@@ -116,6 +151,18 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DLESS, PIPE_SEMI_SEQUENCE},
 	{TK_DLESS, PIPE_CLOSE_SEQUENCE},
 	{TK_DLESS, SEQUENCE},
+	{TK_DLESS, CMD_SUPERIOR},
+	{TK_DLESS, AND_OR_MAJOR},
+	{TK_DLESS, TK_WHILE},
+	{TK_DLESS, TK_UNTIL},
+	{TK_DLESS, TK_IF},
+	{TK_DLESS, TK_DO},
+	{TK_DLESS, TK_ELIF},
+	{TK_DLESS, TK_THEN},
+	{TK_DLESS, TK_PAREN_CLOSE},
+	{TK_DLESS, COMPLETE_CONDITION},
+	{TK_DLESS, CONDITION},
+	{TK_DLESS, COMPOUND_LIST},
 //	watch !
 	{TK_DLESS, CMD_SUPERIOR},
 	{TK_DLESS, AND_OR_MAJOR},
@@ -136,6 +183,18 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DGREAT, PIPE_SEMI_SEQUENCE},
 	{TK_DGREAT, PIPE_CLOSE_SEQUENCE},
 	{TK_DGREAT, SEQUENCE},
+	{TK_DGREAT, CMD_SUPERIOR},
+	{TK_DGREAT, AND_OR_MAJOR},
+	{TK_DGREAT, TK_WHILE},
+	{TK_DGREAT, TK_UNTIL},
+	{TK_DGREAT, TK_IF},
+	{TK_DGREAT, TK_DO},
+	{TK_DGREAT, TK_ELIF},
+	{TK_DGREAT, TK_THEN},
+	{TK_DGREAT, TK_PAREN_CLOSE},
+	{TK_DGREAT, COMPLETE_CONDITION},
+	{TK_DGREAT, CONDITION},
+	{TK_DGREAT, COMPOUND_LIST},
 //	watch !
 	{TK_DGREAT, CMD_SUPERIOR},
 	{TK_DGREAT, AND_OR_MAJOR},
@@ -156,6 +215,18 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LESSAND, PIPE_SEMI_SEQUENCE},
 	{TK_LESSAND, PIPE_CLOSE_SEQUENCE},
 	{TK_LESSAND, SEQUENCE},
+	{TK_LESSAND, CMD_SUPERIOR},
+	{TK_LESSAND, AND_OR_MAJOR},
+	{TK_LESSAND, TK_WHILE},
+	{TK_LESSAND, TK_UNTIL},
+	{TK_LESSAND, TK_IF},
+	{TK_LESSAND, TK_DO},
+	{TK_LESSAND, TK_ELIF},
+	{TK_LESSAND, TK_THEN},
+	{TK_LESSAND, TK_PAREN_CLOSE},
+	{TK_LESSAND, COMPLETE_CONDITION},
+	{TK_LESSAND, CONDITION},
+	{TK_LESSAND, COMPOUND_LIST},
 //	watch !
 	{TK_LESSAND, CMD_SUPERIOR},
 	{TK_LESSAND, AND_OR_MAJOR},
@@ -176,6 +247,18 @@ t_stackmatch	g_stackmatch[] =
 	{TK_GREATAND, PIPE_SEMI_SEQUENCE},
 	{TK_GREATAND, PIPE_CLOSE_SEQUENCE},
 	{TK_GREATAND, SEQUENCE},
+	{TK_GREATAND, CMD_SUPERIOR},
+	{TK_GREATAND, AND_OR_MAJOR},
+	{TK_GREATAND, TK_WHILE},
+	{TK_GREATAND, TK_UNTIL},
+	{TK_GREATAND, TK_IF},
+	{TK_GREATAND, TK_DO},
+	{TK_GREATAND, TK_ELIF},
+	{TK_GREATAND, TK_THEN},
+	{TK_GREATAND, TK_PAREN_CLOSE},
+	{TK_GREATAND, COMPLETE_CONDITION},
+	{TK_GREATAND, CONDITION},
+	{TK_GREATAND, COMPOUND_LIST},
 //	watch ! 
 	{TK_GREATAND, CMD_SUPERIOR},
 	{TK_GREATAND, AND_OR_MAJOR},
@@ -200,6 +283,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_IF, TK_THEN},
 	{TK_IF, TK_PAREN_CLOSE},
 	{TK_IF, COMPLETE_CONDITION},
+	{TK_IF, CONDITION},
 	{TK_IF, COMPOUND_LIST},
 	{TK_IF, CASE_LIST_NS},
 	{TK_THEN, CONDITION},
@@ -238,6 +322,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_CASE, TK_ELIF},
 	{TK_CASE, TK_ELSE},
 	{TK_CASE, COMPLETE_CONDITION},
+	{TK_CASE, CONDITION},
 	{TK_CASE, CASE_LIST_NS},
 	{TK_CASE, COMPOUND_LIST},
 	{TK_CASE, NEWLINE_LIST},
@@ -270,6 +355,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_WHILE, TK_PAREN_CLOSE},
 	{TK_WHILE, TK_THEN},
 	{TK_WHILE, COMPLETE_CONDITION},
+	{TK_WHILE, CONDITION},
 	{TK_UNTIL, LINEBREAK},
 	{TK_UNTIL, TK_PAREN_OPEN},
 	{TK_UNTIL, TK_LBRACE},
@@ -291,6 +377,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_UNTIL, TK_THEN},
 	{TK_UNTIL, TK_PAREN_CLOSE},
 	{TK_UNTIL, COMPLETE_CONDITION},
+	{TK_UNTIL, CONDITION},
 	{TK_FOR, LINEBREAK},
 	{TK_FOR, TK_BANG},
 	{TK_FOR, TK_PAREN_OPEN},
@@ -312,6 +399,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_FOR, TK_ELSE},
 	{TK_FOR, TK_PAREN_CLOSE},
 	{TK_FOR, COMPLETE_CONDITION},
+	{TK_FOR, CONDITION},
 	{TK_LBRACE, COMPLETE_COMMANDS},
 	{TK_LBRACE, LINEBREAK},
 	{TK_LBRACE, TK_BANG},
@@ -334,6 +422,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LBRACE, COMPOUND_LIST},
 	{TK_LBRACE, CASE_LIST_NS},
 	{TK_LBRACE, COMPLETE_CONDITION},
+	{TK_LBRACE, CONDITION},
 	{TK_LBRACE, TK_IN},
 	{TK_LBRACE, TK_PIPE},
 	{TK_RBRACE, TK_SEMI},
@@ -402,6 +491,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_PAREN_OPEN, COMPOUND_LIST},
 	{TK_PAREN_OPEN, CASE_LIST_NS},
 	{TK_PAREN_OPEN, COMPLETE_CONDITION},
+	{TK_PAREN_OPEN, CONDITION},
 	{TK_PAREN_OPEN, TK_IN},
 	{TK_PAREN_OPEN, CMD_SUPERIOR},
 	{OPEN_FUNC, CMD_SUPERIOR},
@@ -429,6 +519,7 @@ t_stackmatch	g_stackmatch[] =
 	{END_COMMAND, COMPOUND_LIST},
 	{END_COMMAND, CASE_LIST_NS},
 	{END_COMMAND, COMPLETE_CONDITION},
+	{END_COMMAND, CONDITION},
 	{SEPARATOR, MATH_SUP},
 	{SEPARATOR, CMD_SUPERIOR},
 	{SEPARATOR, TERM},
@@ -560,6 +651,18 @@ t_stackmatch	g_stackmatch[] =
 	{IO_HERE, PIPE_SEMI_SEQUENCE},
 	{IO_HERE, PIPE_CLOSE_SEQUENCE},
 	{IO_HERE, SEQUENCE},
+	{IO_HERE, CMD_SUPERIOR},
+	{IO_HERE, AND_OR_MAJOR},
+	{IO_HERE, TK_WHILE},
+	{IO_HERE, TK_UNTIL},
+	{IO_HERE, TK_IF},
+	{IO_HERE, TK_DO},
+	{IO_HERE, TK_ELIF},
+	{IO_HERE, TK_THEN},
+	{IO_HERE, TK_PAREN_CLOSE},
+	{IO_HERE, COMPLETE_CONDITION},
+	{IO_HERE, CONDITION},
+	{IO_HERE, COMPOUND_LIST},
 //	watch !
 	{FILENAME, TK_LESS},
 	{FILENAME, TK_LESSAND},
@@ -583,6 +686,18 @@ t_stackmatch	g_stackmatch[] =
 	{IO_FILE, PIPE_SEMI_SEQUENCE},
 	{IO_FILE, PIPE_CLOSE_SEQUENCE},
 	{IO_FILE, SEQUENCE},
+	{IO_FILE, CMD_SUPERIOR},
+	{IO_FILE, AND_OR_MAJOR},
+	{IO_FILE, TK_WHILE},
+	{IO_FILE, TK_UNTIL},
+	{IO_FILE, TK_IF},
+	{IO_FILE, TK_DO},
+	{IO_FILE, TK_ELIF},
+	{IO_FILE, TK_THEN},
+	{IO_FILE, TK_PAREN_CLOSE},
+	{IO_FILE, COMPLETE_CONDITION},
+	{IO_FILE, CONDITION},
+	{IO_FILE, COMPOUND_LIST},
 //	watch !
 	{IO_REDIRECT, REDIRECT_LIST},
 	{IO_REDIRECT, CMD_SUPERIOR},
@@ -600,6 +715,18 @@ t_stackmatch	g_stackmatch[] =
 	{IO_REDIRECT, PIPE_SEMI_SEQUENCE},
 	{IO_REDIRECT, PIPE_CLOSE_SEQUENCE},
 	{IO_REDIRECT, SEQUENCE},
+	{IO_REDIRECT, CMD_SUPERIOR},
+	{IO_REDIRECT, AND_OR_MAJOR},
+	{IO_REDIRECT, TK_WHILE},
+	{IO_REDIRECT, TK_UNTIL},
+	{IO_REDIRECT, TK_IF},
+	{IO_REDIRECT, TK_DO},
+	{IO_REDIRECT, TK_ELIF},
+	{IO_REDIRECT, TK_THEN},
+	{IO_REDIRECT, TK_PAREN_CLOSE},
+	{IO_REDIRECT, COMPLETE_CONDITION},
+	{IO_REDIRECT, CONDITION},
+	{IO_REDIRECT, COMPOUND_LIST},
 //	watch !/
 	{REDIRECT_LIST, COMPOUND_COMMAND},
 	{CMD_SUFFIX, CMD_WORD},
@@ -615,6 +742,18 @@ t_stackmatch	g_stackmatch[] =
 	{CMD_PREFIX, SEPARATOR_OP},
 	{CMD_PREFIX, NEWLINE_LIST},
 	{CMD_PREFIX, SEQUENCE},
+	{CMD_PREFIX, CMD_SUPERIOR},
+	{CMD_PREFIX, AND_OR_MAJOR},
+	{CMD_PREFIX, TK_WHILE},
+	{CMD_PREFIX, TK_UNTIL},
+	{CMD_PREFIX, TK_IF},
+	{CMD_PREFIX, TK_DO},
+	{CMD_PREFIX, TK_ELIF},
+	{CMD_PREFIX, TK_THEN},
+	{CMD_PREFIX, TK_PAREN_CLOSE},
+	{CMD_PREFIX, COMPLETE_CONDITION},
+	{CMD_PREFIX, CONDITION},
+	{CMD_PREFIX, COMPOUND_LIST},
 //	watch !
 	{CMD_WORD, CMD_PREFIX},
 	{CMD_NAME, COMPLETE_COMMANDS},
@@ -625,6 +764,10 @@ t_stackmatch	g_stackmatch[] =
 	{CMD_NAME, SEPARATOR_OP},
 	{CMD_NAME, NEWLINE_LIST},
 	{CMD_NAME, SEQUENCE},
+	{CMD_NAME, CMD_SUPERIOR},
+	{CMD_NAME, AND_OR_MAJOR},
+	{CMD_NAME, CONDITION},
+	{CMD_NAME, COMPOUND_LIST},
 //	watch !
 	{CMD_NAME, AND_OR_MAJOR},
 	{CMD_NAME, TK_WHILE},
@@ -639,6 +782,7 @@ t_stackmatch	g_stackmatch[] =
 	{CMD_NAME, COMPOUND_LIST},
 	{CMD_NAME, CASE_LIST_NS},
 	{CMD_NAME, COMPLETE_CONDITION},
+	{CMD_NAME, CONDITION},
 
 	{CMD_SUPERIOR, TK_WHILE},
 	{CMD_SUPERIOR, FUNC_NAME},
@@ -652,6 +796,7 @@ t_stackmatch	g_stackmatch[] =
 	{CMD_SUPERIOR, COMPOUND_LIST},
 	{CMD_SUPERIOR, CASE_LIST_NS},
 	{CMD_SUPERIOR, COMPLETE_CONDITION},
+	{CMD_SUPERIOR, CONDITION},
 	{CMD_SUPERIOR, LINEBREAK},
 	{CMD_SUPERIOR, TK_PAREN_OPEN},
 	{CMD_SUPERIOR, TK_LBRACE},
@@ -690,6 +835,7 @@ t_stackmatch	g_stackmatch[] =
 	{SIMPLE_COMMAND, COMPOUND_LIST},
 	{SIMPLE_COMMAND, CASE_LIST_NS},
 	{SIMPLE_COMMAND, COMPLETE_CONDITION},
+	{SIMPLE_COMMAND, CONDITION},
 	{SIMPLE_COMMAND, LINEBREAK},
 	{SIMPLE_COMMAND, TK_PAREN_OPEN},
 	{SIMPLE_COMMAND, TK_LBRACE},
@@ -768,6 +914,7 @@ t_stackmatch	g_stackmatch[] =
 	{UNTIL_CLAUSE, COMPOUND_LIST},
 	{UNTIL_CLAUSE, CASE_LIST_NS},
 	{UNTIL_CLAUSE, COMPLETE_CONDITION},
+	{UNTIL_CLAUSE, CONDITION},
 	{UNTIL_CLAUSE, AND_OR_MAJOR},
 	{WHILE_CLAUSE, LINEBREAK},
 	{WHILE_CLAUSE, COMPLETE_COMMANDS},
@@ -789,9 +936,8 @@ t_stackmatch	g_stackmatch[] =
 	{WHILE_CLAUSE, COMPOUND_LIST},
 	{WHILE_CLAUSE, CASE_LIST_NS},
 	{WHILE_CLAUSE, COMPLETE_CONDITION},
+	{WHILE_CLAUSE, CONDITION},
 	{WHILE_CLAUSE, AND_OR_MAJOR},
-//	{ELSE_PART, COMPOUND_LIST},
-//	{ELSE_PART, COMPLETE_CONDITION},
 	{IF_CLAUSE, LINEBREAK},
 	{IF_CLAUSE, TK_BANG},
 	{IF_CLAUSE, TK_PAREN_OPEN},
@@ -814,6 +960,7 @@ t_stackmatch	g_stackmatch[] =
 	{IF_CLAUSE, CASE_LIST_NS},
 	{IF_CLAUSE, COMPLETE_COMMAND},
 	{IF_CLAUSE, COMPLETE_CONDITION},
+	{IF_CLAUSE, CONDITION},
 	{IF_CLAUSE, AND_OR_MAJOR},
 	{BRACE_CLAUSE, LINEBREAK},
 	{BRACE_CLAUSE, TK_PAREN_OPEN},
@@ -837,6 +984,7 @@ t_stackmatch	g_stackmatch[] =
 	{BRACE_CLAUSE, CASE_LIST_NS},
 	{BRACE_CLAUSE, COMPLETE_COMMAND},
 	{BRACE_CLAUSE, COMPLETE_CONDITION},
+	{BRACE_CLAUSE, CONDITION},
 	{BRACE_CLAUSE, AND_OR_MAJOR},
 	{PATTERN, PATTERN_CASE},
 	{PATTERN, CASE_LIST},
@@ -865,6 +1013,7 @@ t_stackmatch	g_stackmatch[] =
 	{CASE_CLAUSE, COMPOUND_LIST},
 	{CASE_CLAUSE, CASE_LIST_NS},
 	{CASE_CLAUSE, COMPLETE_CONDITION},
+	{CASE_CLAUSE, CONDITION},
 	{CASE_CLAUSE, AND_OR_MAJOR},
 	
 	{WORDLIST, IN},
@@ -892,6 +1041,7 @@ t_stackmatch	g_stackmatch[] =
 	{FOR_CLAUSE, COMPOUND_LIST},
 	{FOR_CLAUSE, CASE_LIST_NS},
 	{FOR_CLAUSE, COMPLETE_CONDITION},
+	{FOR_CLAUSE, CONDITION},
 	{FOR_CLAUSE, AND_OR_MAJOR},
 	{COMPOUND_LIST, TK_DO},
 	{COMPOUND_LIST, TK_PAREN_CLOSE},
@@ -906,6 +1056,7 @@ t_stackmatch	g_stackmatch[] =
 	{COMPOUND_LIST, TK_ELSE},
 	{COMPOUND_LIST, COMPOUND_LIST},
 	{COMPOUND_LIST, COMPLETE_CONDITION},
+	{COMPOUND_LIST, CONDITION},
 	{CLOSE_LIST, PATTERN},
 	{CLOSE_LIST, FUNC_NAME},
 	{SUBSHELL, LINEBREAK},
@@ -930,6 +1081,7 @@ t_stackmatch	g_stackmatch[] =
 	{SUBSHELL, COMPOUND_LIST},
 	{SUBSHELL, CASE_LIST_NS},
 	{SUBSHELL, COMPLETE_CONDITION},
+	{SUBSHELL, CONDITION},
 	{SUBSHELL, AND_OR_MAJOR},
 	{COMPOUND_COMMAND, LINEBREAK},
 	{COMPOUND_COMMAND, TK_PAREN_OPEN},
@@ -953,6 +1105,7 @@ t_stackmatch	g_stackmatch[] =
 	{COMPOUND_COMMAND, COMPOUND_LIST},
 	{COMPOUND_COMMAND, CASE_LIST_NS},
 	{COMPOUND_COMMAND, COMPLETE_CONDITION},
+	{COMPOUND_COMMAND, CONDITION},
 	{COMPOUND_COMMAND, AND_OR_MAJOR},
 	{COMMAND, TK_WHILE},
 	{COMMAND, TK_UNTIL},
@@ -970,6 +1123,7 @@ t_stackmatch	g_stackmatch[] =
 	{COMMAND, COMPOUND_LIST},
 	{COMMAND, CASE_LIST_NS},
 	{COMMAND, COMPLETE_CONDITION},
+	{COMMAND, CONDITION},
 	{COMMAND, SEPARATOR_OP},
 	{COMMAND, NEWLINE_LIST},
 	{COMMAND, SEQUENCE},
@@ -994,6 +1148,7 @@ t_stackmatch	g_stackmatch[] =
 	{PIPE_SEQUENCE, COMPOUND_LIST},
 	{PIPE_SEQUENCE, CASE_LIST_NS},
 	{PIPE_SEQUENCE, COMPLETE_CONDITION},
+	{PIPE_SEQUENCE, CONDITION},
 	{PIPE_SEQUENCE, LINEBREAK},
 	{PIPE_SEQUENCE, TK_BANG},
 	{PIPE_SEQUENCE, TK_PAREN_OPEN},
@@ -1013,6 +1168,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_BANG, COMPOUND_LIST},
 	{TK_BANG, CASE_LIST_NS},
 	{TK_BANG, COMPLETE_CONDITION},
+	{TK_BANG, CONDITION},
 	{TK_BANG, LINEBREAK},
 	{TK_BANG, TK_PAREN_OPEN},
 	{TK_BANG, TK_LBRACE},
@@ -1031,6 +1187,7 @@ t_stackmatch	g_stackmatch[] =
 	{PIPE_SEMI_SEQUENCE, COMPOUND_LIST},
 	{PIPE_SEMI_SEQUENCE, CASE_LIST_NS},
 	{PIPE_SEMI_SEQUENCE, COMPLETE_CONDITION},
+	{PIPE_SEMI_SEQUENCE, CONDITION},
 	{PIPE_SEMI_SEQUENCE, LINEBREAK},
 	{PIPE_SEMI_SEQUENCE, TK_BANG},
 	{PIPE_SEMI_SEQUENCE, TK_PAREN_OPEN},
@@ -1051,6 +1208,7 @@ t_stackmatch	g_stackmatch[] =
 	{PIPE_CLOSE_SEQUENCE, COMPOUND_LIST},
 	{PIPE_CLOSE_SEQUENCE, CASE_LIST_NS},
 	{PIPE_CLOSE_SEQUENCE, COMPLETE_CONDITION},
+	{PIPE_CLOSE_SEQUENCE, CONDITION},
 	{PIPE_CLOSE_SEQUENCE, LINEBREAK},
 	{PIPE_CLOSE_SEQUENCE, TK_BANG},
 	{PIPE_CLOSE_SEQUENCE, TK_PAREN_OPEN},
@@ -1073,6 +1231,7 @@ t_stackmatch	g_stackmatch[] =
 	{SEQUENCE, COMPOUND_LIST},
 	{SEQUENCE, CASE_LIST_NS},
 	{SEQUENCE, COMPLETE_CONDITION},
+	{SEQUENCE, CONDITION},
 	{SEQUENCE, LINEBREAK},
 	{SEQUENCE, TK_PAREN_OPEN},
 	{SEQUENCE, TK_LBRACE},
@@ -1093,6 +1252,7 @@ t_stackmatch	g_stackmatch[] =
 	{PIPELINE, COMPOUND_LIST},
 	{PIPELINE, CASE_LIST_NS},
 	{PIPELINE, COMPLETE_CONDITION},
+	{PIPELINE, CONDITION},
 	{PIPELINE, LINEBREAK},
 	{PIPELINE, TK_BANG},
 	{PIPELINE, TK_PAREN_OPEN},
@@ -1120,6 +1280,7 @@ t_stackmatch	g_stackmatch[] =
 	{AND_OR, COMPOUND_LIST},
 	{AND_OR, CASE_LIST_NS},
 	{AND_OR, COMPLETE_CONDITION},
+	{AND_OR, CONDITION},
 	{AND_OR, LINEBREAK},
 	{AND_OR, TK_BANG},
 	{AND_OR, TK_PAREN_OPEN},
@@ -1147,7 +1308,7 @@ int			eval_sym(t_list **stack, t_sym new_sym)
 	if (!*stack)
 		return (1);
 	head = (*stack)->content;
-//	DG("eval head %s && sym %s", read_state(*head), read_state(new_sym));
+	DG("eval head %s && sym %s", read_state(*head), read_state(new_sym));
 	i = 0;
 	while (g_stackmatch[i].top)
 	{
diff --git a/42sh/src/parser/ft_parse.c b/42sh/src/parser/ft_parse.c
index bc53467d..db759d57 100644
--- a/42sh/src/parser/ft_parse.c
+++ b/42sh/src/parser/ft_parse.c
@@ -55,7 +55,7 @@ int			ft_parse(t_btree **ast, t_list **token, t_parser *parser)
 		else
 			parser->state = UNDEFINED;
 		build_tree(ast, token);
-		btree_print(STDBUG, *ast, &ft_putast);
+//		btree_print(STDBUG, *ast, &ft_putast);
 		if ((end_instruction(&parser->stack) && !(*token)->next))
 			insert_linebreak(token);
 		else
diff --git a/42sh/src/parser/produce_sym.c b/42sh/src/parser/produce_sym.c
index 8d9b3e99..9f649ee4 100644
--- a/42sh/src/parser/produce_sym.c
+++ b/42sh/src/parser/produce_sym.c
@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/02/09 17:58:34 by ariard            #+#    #+#             */
-/*   Updated: 2017/03/09 18:14:07 by ariard           ###   ########.fr       */
+/*   Updated: 2017/03/10 18:46:59 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -44,6 +44,7 @@ t_prodmatch		g_prodmatch[] =
 	{TK_WORD, COMPOUND_LIST, CMD_NAME},
 	{TK_WORD, CASE_LIST_NS, CMD_NAME},
 	{TK_WORD, COMPLETE_CONDITION, CMD_NAME},
+	{TK_WORD, CONDITION, CMD_NAME},
 	{TK_WORD, NEWLINE_LIST, CMD_NAME},
 	{TK_WORD, TK_BANG, CMD_NAME},
 	{TK_WORD, SEQUENCE, CMD_NAME},
@@ -59,6 +60,13 @@ t_prodmatch		g_prodmatch[] =
 	{TK_ASSIGNEMENT_WORD, TK_LBRACE, CMD_PREFIX},
 	{TK_ASSIGNEMENT_WORD, TK_BANG, CMD_PREFIX},
 	{TK_ASSIGNEMENT_WORD, SEPARATOR_OP, CMD_PREFIX},
+	{TK_ASSIGNEMENT_WORD, TK_WHILE, CMD_PREFIX},
+	{TK_ASSIGNEMENT_WORD, TK_UNTIL, CMD_PREFIX},
+	{TK_ASSIGNEMENT_WORD, TK_FOR, CMD_PREFIX},
+	{TK_ASSIGNEMENT_WORD, TK_IF, CMD_PREFIX},
+	{TK_ASSIGNEMENT_WORD, TK_FI, CMD_PREFIX},
+	{TK_ASSIGNEMENT_WORD, TK_ELIF, CMD_PREFIX},
+	{TK_ASSIGNEMENT_WORD, TK_ELSE, CMD_PREFIX},
 	{TK_ASSIGNEMENT_WORD, NEWLINE_LIST, CMD_PREFIX},
 	{TK_NAME, TK_BANG, FNAME},
 	{TK_NAME, LINEBREAK, FNAME},
@@ -76,6 +84,7 @@ t_prodmatch		g_prodmatch[] =
 	{TK_NEWLINE, TK_IN, NEWLINE_LIST},
 	{TK_NEWLINE, TK_WHILE, NEWLINE_LIST},
 	{TK_NEWLINE, TK_UNTIL, NEWLINE_LIST},
+	{TK_NEWLINE, TK_FOR, NEWLINE_LIST},
 	{TK_NEWLINE, TK_IF, NEWLINE_LIST},
 	{TK_NEWLINE, TK_FI, NEWLINE_LIST},
 	{TK_NEWLINE, TK_ELIF, NEWLINE_LIST},