diff --git a/f_bonus_opti.c b/f_bonus_opti.c
new file mode 100644
index 0000000..66520d7
--- /dev/null
+++ b/f_bonus_opti.c
@@ -0,0 +1,100 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   bonus.c                                            :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: hulamy <marvin@42.fr>                      +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/05/24 14:42:46 by hulamy            #+#    #+#             */
+/*   Updated: 2019/06/01 14:11:32 by hulamy           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "fillit.h"
+
+/*
+** Test optimisation for not testing wrong maps when tetri are identical
+*/
+
+int			check_tetri_memory(t_fillist *list, int pos)
+{
+	t_fillist		*tetri;
+	unsigned int	mask;
+
+	tetri = list;
+	mask = 1 << ((pos % 32) - 1);
+	if (tetri->same)
+	{
+		if (!(tetri->same->memory[pos / 32] & mask))
+			return (tetri->same->memory[pos / 32] |= mask);
+	}
+	else
+	{
+		if (!(tetri->memory[pos / 32] & mask))
+			return (tetri->memory[pos / 32] |= mask);
+	}
+	return (0);
+}
+
+/*
+** Test optimisation for not testing wrong maps when tetri are identical
+*/
+
+int			compare_tetri(t_fillist *tetri_a, t_fillist *tetri_b)
+{
+	if (tetri_a->tetribit != tetri_b->tetribit)
+		return (0);
+	if (tetri_a->width != tetri_b->width)
+		return (0);
+	if (tetri_a->height != tetri_b->height)
+		return (0);
+	return (1);
+}
+
+/*
+** Function that free the list->memory each time it's malloc
+*/
+
+t_fillist	*clean_list_memory(t_fillist *list, t_fillist *tmp)
+{
+	while (tmp)
+	{
+		if (tmp->memory)
+			free(tmp->memory);
+		tmp = tmp->next;
+	}
+	return (list);
+}
+
+/*
+** Test optimisation for not testing wrong maps when tetri are identical
+*/
+
+int			check_same_tetri(t_fillist *list, int num)
+{
+	t_fillist	*curr_tetri;
+	t_fillist	*next_tetri;
+	int			i;
+
+	curr_tetri = clean_list_memory(list, list);
+	while (curr_tetri != NULL)
+	{
+		i = 0;
+		if (!(curr_tetri->memory =
+					(unsigned int *)malloc(sizeof(*curr_tetri->memory) * num)))
+			return (0);
+		while (i < num)
+			curr_tetri->memory[i++] = 0;
+		next_tetri = curr_tetri->next;
+		while (next_tetri != NULL)
+		{
+			if (compare_tetri(curr_tetri, next_tetri))
+				if (next_tetri->same == NULL)
+					next_tetri->same = curr_tetri;
+			next_tetri = next_tetri->next;
+		}
+		curr_tetri->total_num = num;
+		curr_tetri = curr_tetri->next;
+	}
+	return (0);
+}
diff --git a/f_bonus_print.c b/f_bonus_print.c
new file mode 100644
index 0000000..2ac8545
--- /dev/null
+++ b/f_bonus_print.c
@@ -0,0 +1,78 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   f_bonus_print.c                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: hulamy <marvin@42.fr>                      +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/05/27 13:46:29 by hulamy            #+#    #+#             */
+/*   Updated: 2019/06/01 15:00:01 by hulamy           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "fillit.h"
+
+/*
+** function that print the given tetris if flag p is present
+*/
+
+t_fillist	*print_tetri(t_fillist *list)
+{
+	unsigned int	print;
+	t_fillist		*tmp;
+
+	tmp = list;
+	if (list->dope[2])
+	{
+		while (tmp)
+		{
+			check_same_tetri(list, 1);
+			print = tmp->tetribit;
+			print <<= 16;
+			print_sized_map(&print, tmp->width, tmp->height, tmp->letter);
+			if (tmp->same && list->dope[1])
+			{
+				print = tmp->same->tetribit;
+				print <<= 16;
+				ft_putstr("same --> ");
+				ft_put_tetri_color(tmp->same->letter);
+				ft_putchar('\n');
+			}
+			ft_putchar('\n');
+			tmp = tmp->next;
+		}
+	}
+	return (list);
+}
+
+/*
+** function that print the map in binary if flag p is present
+** it returns anyway the size of the map for main to print it
+*/
+
+int			print_binary_map(unsigned int *map, int size, int *dope)
+{
+	size--;
+	if (dope[2])
+	{
+		ft_putendl("result in binary :");
+		print_sized_map(map, size, size, '#');
+		ft_putchar('\n');
+	}
+	free(map);
+	return (size);
+}
+
+/*
+** function that print the flags usage
+*/
+
+int			print_flags_usage(void)
+{
+	ft_putendl("flags usage :");
+	ft_putendl("d : debug print (print the map during the backtracking)");
+	ft_putendl("o : optimisation ultra fast but with some errors still");
+	ft_putendl("p : print the tetri and the map in different formats");
+	ft_putendl("e : error msgs more precise AND no error for too much tetri\n");
+	return (0);
+}
diff --git a/f_handle_errors.c b/f_handle_errors.c
new file mode 100644
index 0000000..93241fc
--- /dev/null
+++ b/f_handle_errors.c
@@ -0,0 +1,136 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   f_handle_errors.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: vmanzoni <vmanzoni@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/03/01 13:29:05 by vmanzoni          #+#    #+#             */
+/*   Updated: 2019/06/01 14:49:01 by hulamy           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "fillit.h"
+
+/*
+** Function that display error message *s on fd and exit program
+*/
+
+void	print_error(char *str)
+{
+	write(1, str, ft_strlen(str));
+	exit(0);
+}
+
+/*
+** Function that display error message *s on fd with more informations
+*/
+
+void	print_error_extended(int error, int *dope)
+{
+	if (!dope[3])
+		print_error("error\n");
+	if (error == 1)
+		print_error("error: File contains char other than '.','#' and '\\n'\n");
+	if (error == 2)
+		print_error("error: File contains two tetriminos not"
+					"separated by a '\\n'\n");
+	if (error == 3)
+		print_error("error: File contains more than 2 '\\n' in a row\n");
+	if (error == 4)
+		print_error("error: File contains less than 1 tetrimino\n");
+	if (error == 5)
+		print_error("error: File contains more than 26 tetriminos\n");
+	if (error == 6)
+		print_error("error: Tetrimino has more or less than 4 #\n");
+	if (error == 7)
+		print_error("error: Tetrimino # are not all connected\n");
+	print_error("error\n");
+}
+
+/*
+** Function to see if there if an error if the file
+** - less than 4 lines
+** - more than 104 (26 tetri) + 25 (\n) = 129 lines
+** - two \n in a row
+*/
+
+void	check_file_errors(char *file, int *dope)
+{
+	int		i;
+	int		line_nbr;
+
+	i = 0;
+	line_nbr = 0;
+	while (file[i])
+	{
+		if (file[i] != '.' && file[i] != '#' && file[i] != '\n')
+			print_error_extended(1, dope);
+		else if (file[i] == '\n')
+			line_nbr++;
+		if (file[i] == '\n' && line_nbr % 5 == 0 && file[i - 1] != '\n')
+			print_error_extended(2, dope);
+		if (file[i] == '\n' && file[i + 1] != '\0' && \
+			file[i + 2] != '.' && file[i + 2] != '#')
+			print_error_extended(3, dope);
+		i++;
+	}
+	if (line_nbr < 4)
+		print_error_extended(4, dope);
+	if (!dope[3] && line_nbr > 129)
+		print_error_extended(5, dope);
+}
+
+/*
+** Function that check if tetrimino square contains:
+** - 4 x #
+** - 12 x .
+*/
+
+int		check_tetri_errors(char *tetri)
+{
+	int		i;
+	int		htg;
+	int		dot;
+
+	i = 0;
+	htg = 0;
+	dot = 0;
+	while (tetri[i])
+	{
+		if (tetri[i] == '#')
+			htg++;
+		else if (tetri[i] == '.')
+			dot++;
+		i++;
+	}
+	if (htg != 4 || dot != 12 || check_tetri_errors_proxy(tetri))
+		return (6 + check_tetri_errors_proxy(tetri));
+	return (0);
+}
+
+/*
+** Function that check if 4 # (tetrimino parts) are linked
+*/
+
+int		check_tetri_errors_proxy(char *tetri)
+{
+	int		i;
+	int		j;
+
+	i = 0;
+	j = 0;
+	while (tetri[i])
+	{
+		if (i < 19 && tetri[i] == '#' && tetri[i + 1] == '#')
+			j++;
+		if (i > 0 && tetri[i] == '#' && tetri[i - 1] == '#')
+			j++;
+		if (i < 15 && tetri[i] == '#' && tetri[i + 5] == '#')
+			j++;
+		if (i > 4 && tetri[i] == '#' && tetri[i - 5] == '#')
+			j++;
+		i++;
+	}
+	return ((j < 6) ? 1 : 0);
+}
diff --git a/f_print_map_with_colors.c b/f_print_map_with_colors.c
new file mode 100644
index 0000000..8ea47cc
--- /dev/null
+++ b/f_print_map_with_colors.c
@@ -0,0 +1,51 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   print_map_with_colors.c                            :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: vmanzoni <vmanzoni@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/05/03 20:27:22 by vmanzoni          #+#    #+#             */
+/*   Updated: 2019/06/01 14:27:30 by hulamy           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "fillit.h"
+
+void	ft_putchar_color(char c, char color)
+{
+	if (color == 'R')
+		write(1, RED, 5);
+	else if (color == 'B')
+		write(1, BLU, 5);
+	else if (color == 'G')
+		write(1, GRN, 5);
+	else if (color == 'Y')
+		write(1, YEL, 5);
+	else if (color == 'M')
+		write(1, MAG, 5);
+	else if (color == 'C')
+		write(1, CYN, 5);
+	else if (color == 'W' || !c)
+		write(1, RESET, 5);
+	ft_putchar(c);
+	write(1, RESET, 5);
+}
+
+void	ft_put_tetri_color(char c)
+{
+	if (c == 'A' || c == 'G' || c == 'M' || c == 'S' || c == 'Y')
+		ft_putchar_color(c, 'R');
+	else if (c == 'B' || c == 'H' || c == 'N' || c == 'T' || c == 'Z')
+		ft_putchar_color(c, 'B');
+	else if (c == 'C' || c == 'I' || c == 'O' || c == 'U')
+		ft_putchar_color(c, 'G');
+	else if (c == 'D' || c == 'J' || c == 'P' || c == 'V')
+		ft_putchar_color(c, 'Y');
+	else if (c == 'E' || c == 'K' || c == 'Q' || c == 'W')
+		ft_putchar_color(c, 'M');
+	else if (c == 'F' || c == 'L' || c == 'R' || c == 'X')
+		ft_putchar_color(c, 'C');
+	else
+		ft_putchar(c);
+}
diff --git a/f_read_file.c b/f_read_file.c
new file mode 100644
index 0000000..eaa43bf
--- /dev/null
+++ b/f_read_file.c
@@ -0,0 +1,50 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   read_file.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: vmanzoni <vmanzoni@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/04/13 12:09:46 by vmanzoni          #+#    #+#             */
+/*   Updated: 2019/06/01 15:12:03 by hulamy           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "fillit.h"
+
+/*
+** Function that read and return a ptr to file content
+*/
+
+char	*read_file(char *file)
+{
+	char		buf[BUFF_SIZE];
+	int			fd;
+	int			rv;
+	int			i;
+	char		*result;
+
+	if (((fd = open(file, O_RDONLY)) < 0) \
+		|| ((rv = read(fd, &buf, BUFF_SIZE)) < 0) \
+			|| !(result = malloc(sizeof(char) * rv)))
+		return (NULL);
+	buf[rv - 1] = '\0';
+	i = -1;
+	while (buf[++i])
+		result[i] = buf[i];
+	result[i] = '\0';
+	close(fd);
+	return (result);
+}
+
+/*
+**	Function that init num and size for search_map
+*/
+
+void	init_num_and_size(int num, int *size, t_fillist *tmp)
+{
+	while ((tmp = tmp->next))
+		num++;
+	while (*size * *size < num * 4)
+		(*size)++;
+}
diff --git a/f_search_map.c b/f_search_map.c
new file mode 100644
index 0000000..2904444
--- /dev/null
+++ b/f_search_map.c
@@ -0,0 +1,167 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   f_search_map.c                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: hulamy <hulamy@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/04/27 20:47:22 by hulamy            #+#    #+#             */
+/*   Updated: 2019/06/01 15:12:08 by hulamy           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "fillit.h"
+
+/*
+** function that look if a tretri fit in a place
+*/
+
+unsigned int	fit_in_place(unsigned int *map, t_fillist *lst, int sze, int i)
+{
+	unsigned int	tmp;
+	unsigned int	mask;
+	unsigned int	tetri;
+	int				n;
+	int				r;
+
+	n = lst->num;
+	r = lst->rank;
+	i = lst->height;
+	tetri = lst->tetribit << 16 >> lst->width;
+	tmp = 0;
+	mask = ~0u << (32 - lst->width);
+	while (i--)
+	{
+		if (tmp & tetri)
+			return (0);
+		if (r >= 32 && ++n)
+			r -= 32;
+		tmp = (mask & (map[n] << r));
+		if (n + 1 < lst->total_num)
+			tmp |= (mask & (map[n + 1] >> (32 - r)));
+		tetri <<= lst->width;
+		r += sze;
+	}
+	return (!(tmp & tetri));
+}
+
+/*
+** function that look for the first place in the map for a tetri
+*/
+
+int				find_place(unsigned int *map, t_fillist *list, int size)
+{
+	int	limit;
+	int pos;
+
+	pos = list->position;
+	list->place = pos % size;
+	list->rank = pos % 32;
+	list->num = pos / 32;
+	limit = (size - list->height + 1) * size;
+	while (pos < limit)
+	{
+		if (list->rank >= 32 && ++list->num)
+			list->rank -= 32;
+		if (list->place > size - list->width)
+		{
+			list->place = -1;
+			pos += list->width - 2;
+			list->rank += list->width - 2;
+		}
+		else if (fit_in_place(map, list, size, 0))
+			return ((list->position = pos + 1));
+		pos++;
+		list->place++;
+		list->rank++;
+	}
+	return (0);
+}
+
+/*
+** function that add or remove a tetri on the map
+*/
+
+void			add_remove(unsigned int *map, t_fillist *list, int size)
+{
+	unsigned int	msk;
+	unsigned short	tetri;
+	int				i;
+	int				j;
+
+	tetri = list->tetribit;
+	msk = ~0u << (32 - list->width);
+	i = (list->height - 1) * list->width;
+	j = (list->height - 1) * size + list->position;
+	while (j >= list->position)
+	{
+		map[(j - 1) / 32] ^= (msk & tetri << (16 + i)) >> (j - 1);
+		if ((j - 1) / 32 + 1 < list->total_num)
+			map[(j - 1) / 32 + 1] ^= (msk & tetri << (16 + i)) << (32 - j) << 1;
+		j -= size;
+		i -= list->width;
+	}
+}
+
+/*
+** Function that recursively try to fill the map with the tetris
+*/
+
+int				fill_map(unsigned int *map, t_fillist *list, int size)
+{
+	if (!list)
+		return (1);
+	list->position = 0;
+	while (find_place(map, list, size))
+	{
+		add_remove(map, list, size);
+		list->test = 1;
+		if (list->dope[0])
+		{
+			print_letter_map(list->start, size, 1);
+			ft_putchar('\n');
+		}
+		if (list->dope[1])
+			if (check_tetri_memory(list, list->position))
+				if (fill_map(map, list->next, size))
+					return (1);
+		if (!list->dope[1])
+			if (fill_map(map, list->next, size))
+				return (1);
+		add_remove(map, list, size);
+		list->test = 0;
+	}
+	return (0);
+}
+
+/*
+** Function that send to "fill_map" a map of a certain size
+** and increment its size untill it's solved
+*/
+
+int				search_map(t_fillist *list)
+{
+	t_fillist		*tmp;
+	unsigned int	*map;
+	int				size;
+	int				num;
+	int				i;
+
+	size = 2;
+	tmp = print_tetri(list);
+	init_num_and_size(1, &size, tmp);
+	i = 0;
+	while (!i)
+	{
+		num = (size * size) / 32 + 1;
+		if (!(map = (unsigned int *)malloc(sizeof(*map) * num)))
+			return (0);
+		check_same_tetri(list, num);
+		while (num--)
+			map[num] = 0;
+		i = fill_map(map, list, size++);
+		if (!i)
+			free(map);
+	}
+	return (print_binary_map(map, size, list->dope));
+}
diff --git a/fillit.h b/fillit.h
new file mode 100644
index 0000000..1f61ed3
--- /dev/null
+++ b/fillit.h
@@ -0,0 +1,143 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   fillit.h                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: vmanzoni <vmanzoni@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/03/01 13:34:46 by vmanzoni          #+#    #+#             */
+/*   Updated: 2019/06/01 15:12:00 by hulamy           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef FILLIT_H
+# define FILLIT_H
+
+# include <stdlib.h>
+# include <unistd.h>
+# include <fcntl.h>
+# include <stdbool.h>
+
+# include "libft/includes/libft.h"
+
+/*
+** DEFINE
+*/
+
+# define BUFF_SIZE 1024
+
+# define RED   "\x1B[31m"
+# define GRN   "\x1B[32m"
+# define YEL   "\x1B[33m"
+# define BLU   "\x1B[34m"
+# define MAG   "\x1B[35m"
+# define CYN   "\x1B[36m"
+# define RESET "\x1B[0m"
+
+/*
+**	STRUCTURE
+** tetribit : tetri ecrit en binaire dans un short de 16 bits
+** width : largeur du tetri
+** height : hauteur du tetri
+** position : memorise la position d tetri bit a bit
+** place : position sur l'axe des abscisses de la map (position % size)
+** rank : position de 1 a 32 dans l'int du tableau d'int (position % 32)
+** num : memorise dans quel int du tableau on se trouve (position / 32)
+** test :
+** letter : letter of the tetrimino for printing final map
+** dope : flags for details, optimisation, printing and error
+** memory : positions already tested by a tetrimino in bitwise
+** same : pointer to previous identical tetrimino
+** next : pointer to next tetrimino
+** start : pointer to first tetrimino of input file
+*/
+typedef struct	s_fillist
+{
+	unsigned short		tetribit;
+	int					width;
+	int					height;
+	int					position;
+	int					place;
+	int					rank;
+	int					num;
+	int					total_num;
+	int					test;
+	char				letter;
+	int					*dope;
+	unsigned int		*memory;
+	struct s_fillist	*same;
+	struct s_fillist	*next;
+	struct s_fillist	*start;
+}				t_fillist;
+
+/*
+**	bonus_opti.c
+*/
+int				check_tetri_memory(t_fillist *list, int pos);
+int				compare_tetri(t_fillist *tetri_a, t_fillist *tetri_b);
+t_fillist		*clean_list_memory(t_fillist *list, t_fillist *tmp);
+int				check_same_tetri(t_fillist *list, int num);
+
+/*
+**	bonus_print.c
+*/
+t_fillist		*print_tetri(t_fillist *list);
+int				print_binary_map(unsigned int *map, int size, int *dope);
+int				print_flags_usage(void);
+
+/*
+**	main.c
+*/
+int				*create_dope(char *av, int mdp);
+int				is_mdp(int ac, char **av);
+void			clean_list(t_fillist *list, t_fillist *tmp);
+int				main(int argc, char **argv);
+
+/*
+**	read_file.c
+*/
+char			*read_file(char *file);
+void			init_num_and_size(int num, int *size, t_fillist *tmp);
+
+/*
+**	handle_errors.c
+*/
+void			print_error(char *s);
+void			print_error_extended(int error, int *dope);
+void			check_file_errors(char *file, int *dope);
+int				check_tetri_errors(char *tetri);
+int				check_tetri_errors_proxy(char *tetri);
+
+/*
+**	parse_input.c
+*/
+unsigned short	tab_to_bin(char line[]);
+unsigned short	reduce_tetri(unsigned short tetri, int width);
+void			fill_list(char line[], t_fillist *list);
+int				add_to_list(char *sqr, t_fillist **lst, char lett, int *dope);
+int				parse_input(char *input, t_fillist **list, int *dope);
+
+/*
+**	search_map.c
+*/
+unsigned int	fit_in_place(unsigned int *map, t_fillist *lst, int siz, int i);
+int				find_place(unsigned int *map, t_fillist *list, int size);
+void			add_remove(unsigned int *map, t_fillist *list, int size);
+int				fill_map(unsigned int *map, t_fillist *list, int size);
+int				search_map(t_fillist *list);
+
+/*
+**	print.c
+*/
+void			print_sized_map(unsigned int *tab, int wdth, int hgt, char ltr);
+char			*init_print_map(t_fillist *list, int size);
+void			print_letter_map(t_fillist *list, int size, int flag);
+void			print_final_map(t_fillist *list, int size);
+
+/*
+**	print_map_with_colors.c
+*/
+void			ft_putchar_color(char c, char color);
+void			ft_put_tetri_color(char c);
+
+#endif
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..3161953
--- /dev/null
+++ b/main.c
@@ -0,0 +1,114 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   main.c                                             :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: vmanzoni <vmanzoni@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/02/12 13:20:48 by vmanzoni          #+#    #+#             */
+/*   Updated: 2019/06/01 14:40:58 by hulamy           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "fillit.h"
+
+/*
+** Function that put the flags for bonus into a tab of int
+**
+** d : debug print (print the map during the backtracking)
+** o : optimisation ultra fast but with some errors still
+** p : print extended (print the tetri and the map in different formats)
+** e : error extended (message more precise AND no error if too much tetri)
+*/
+
+int		*create_dope(char *av, int mdp)
+{
+	char	*comp;
+	int		*dope;
+	int		i;
+	int		j;
+
+	comp = "dope";
+	if (!(dope = (int*)malloc(sizeof(*dope) * 4)))
+		return (NULL);
+	i = 0;
+	while (i < 4)
+		dope[i++] = 0;
+	if (!mdp)
+		return (dope);
+	i = -1;
+	while (++i < 4 && (j = -1))
+		while (av[++j])
+			if (comp[i] == av[j])
+				dope[i] = 1;
+	return (dope);
+}
+
+/*
+** Function that check if the password is good to unlock the flags
+*/
+
+int		is_mdp(int ac, char **av)
+{
+	char	*mdp;
+	int		i;
+
+	if (ac < 3 || ac > 4)
+		return (0);
+	mdp = "trompette";
+	i = 0;
+	while (av[2][i] && mdp[i] && mdp[i] == av[2][i])
+		i++;
+	if (av[2][i] || mdp[i])
+		return (0);
+	if (ac == 3)
+		return (print_flags_usage());
+	return (1);
+}
+
+/*
+** Function that free the list
+*/
+
+void	clean_list(t_fillist *list, t_fillist *tmp)
+{
+	tmp = list;
+	while (list)
+	{
+		list = tmp->next;
+		free(tmp->memory);
+		free(tmp);
+		tmp = list;
+	}
+}
+
+/*
+** Main function
+*/
+
+int		main(int ac, char **av)
+{
+	t_fillist	*list;
+	char		*input;
+	int			*dope;
+	int			size;
+	int			mdp;
+
+	list = NULL;
+	mdp = is_mdp(ac, av);
+	dope = create_dope(av[3], mdp);
+	if (ac == 2 || mdp)
+	{
+		if (!(input = read_file(av[1])))
+			print_error(dope[3] ? "error: Could not read file.\n" : "error\n");
+		check_file_errors(input, dope);
+		size = parse_input(input, &list, dope);
+		print_final_map(list, size);
+		free(input);
+		clean_list(list, list);
+	}
+	else
+		print_error("usage: Please submit a file.\n> ./fillit file.fillit\n");
+	free(dope);
+	return (0);
+}