diff --git a/stdme/output/include/me/vec/vec_buf_str.h b/stdme/output/include/me/vec/vec_buf_str.h
index bb7e7718..db2aedb8 100644
--- a/stdme/output/include/me/vec/vec_buf_str.h
+++ b/stdme/output/include/me/vec/vec_buf_str.h
@@ -1,123 +1,140 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   vec_buf_str.h                                  :+:      :+:    :+:   */
+/*   vec_buf_str.h                                      :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/12/04 18:46:53 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/09 17:53:00 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:33:44 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #ifndef VEC_BUF_STR_H
-#define VEC_BUF_STR_H
+# define VEC_BUF_STR_H
 
-#include "me/string/string.h"
-#include "me/types.h"
+# include "me/string/string.h"
+# include "me/types.h"
 
 /// @brief A function that takes two t_string and compare them
-typedef bool (*t_vec_buf_str_sort_fn)(t_string *, t_string *);
+typedef bool			(*t_vec_buf_str_sort_fn)(t_string *, t_string *);
 /// @brief A function that free an t_string
-typedef void (*t_free_buf_str_item)(t_string);
+typedef void			(*t_free_buf_str_item)(t_string);
 
 /// @brief A dynamic array of t_string
 typedef struct s_vec_buf_str
 {
-	t_free_buf_str_item free_func;
-	t_usize					len;
-	t_usize					capacity;
-	t_string		   *buffer;
-} t_vec_buf_str;
+	t_free_buf_str_item	free_func;
+	t_usize				len;
+	t_usize				capacity;
+	t_string			*buffer;
+}						t_vec_buf_str;
 
 /// @brief Create a new vec_buf_str with a given capacity
 /// @param capacity The capacity of the new vec_buf_str (in terms of elements)
-/// @param free_function The function that will be used to free the elements of the vec_buf_str
-t_vec_buf_str vec_buf_str_new(t_usize capacity, t_free_buf_str_item free_function);
+/// @param free_function The function that will be used to free the elements of 
+/// 	the vec_buf_str
+t_vec_buf_str			vec_buf_str_new(t_usize capacity,
+							t_free_buf_str_item free_function);
 /// @brief Push an element to the last position of the vec_buf_str
 /// @param vec The vec_buf_str to push the element to
 /// @param element The element to push
-t_error vec_buf_str_push(t_vec_buf_str *vec, t_string element);
+t_error					vec_buf_str_push(t_vec_buf_str *vec, t_string element);
 
 /// @brief Push an element to the first position of the vec_buf_str
 /// @param vec The vec_buf_str to push the element to
 /// @param element The element to push
 /// @note This operation is O(n)
-t_error vec_buf_str_push_front(t_vec_buf_str *vec, t_string	  element);
+t_error					vec_buf_str_push_front(t_vec_buf_str *vec,
+							t_string element);
 
-/// @brief Get the last element from the vec_buf_str, and remove it from the vec_buf_str
+/// @brief Get the last element from the vec_buf_str,
+///		and remove it from the vec_buf_str
 /// @param vec The vec_buf_str to get the element from
 /// @param[out] out The last element of the vec_buf_str
 /// @return true if the operation failed, false otherwise
-t_error vec_buf_str_pop(t_vec_buf_str *vec, t_string *value);
+t_error					vec_buf_str_pop(t_vec_buf_str *vec, t_string *value);
 
-
-/// @brief Get the first element from the vec_buf_str, and remove it from the vec_buf_str
+/// @brief Get the first element from the vec_buf_str,
+///		and remove it from the vec_buf_str
 /// @param vec The vec_buf_str to get the element from
 /// @param[out] out The first element of the vec_buf_str
 /// @return true if the operation failed, false otherwise
 /// @note This operation is O(n)
-t_error vec_buf_str_pop_front(t_vec_buf_str *vec, t_string *value);
+t_error					vec_buf_str_pop_front(t_vec_buf_str *vec,
+							t_string *value);
 
 /// @brief Free the vector and all its elements
 /// @param vec The vec_buf_str to free
-void	vec_buf_str_free(t_vec_buf_str vec);
+void					vec_buf_str_free(t_vec_buf_str vec);
 
 /// @brief Make the vec_buf_str at least the given capacity
 /// @param vec The vec_buf_str to reserve
 /// @param wanted_capacity The minimum capacity to reserve
 /// @return true if the operation failed, false otherwise
-t_error vec_buf_str_reserve(t_vec_buf_str *vec, t_usize wanted_capacity);
+t_error					vec_buf_str_reserve(t_vec_buf_str *vec,
+							t_usize wanted_capacity);
 
-/// @brief Run the function and returns the index of the first element that returns true
+/// @brief Run the function and returns the index of the first element that 
+/// 	returns true
 /// @param vec The vec_buf_str to search in
 /// @param fn The function to run on each element
 /// @param[out] index The index of the first element that returns true
-t_error vec_buf_str_find(t_vec_buf_str *vec, bool (*fn)(const t_string *), t_usize *index);
+t_error					vec_buf_str_find(t_vec_buf_str *vec,
+							bool (*fn)(const t_string *), t_usize *index);
 
-
-/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
+/// @brief Run the function and returns the index of the first element that 
+/// 	returns true, but starting at index starting_index
 /// @param vec The vec_buf_str to search in
 /// @param fn The function to run on each element
 /// @param starting_index The index to start the search from
 /// @param[out] index The index of the first element that returns true
-t_error vec_buf_str_find_starting(t_vec_buf_str *vec, bool (*fn)(const t_string *), t_usize starting_index, t_usize *index);
+t_error					vec_buf_str_find_starting(t_vec_buf_str *vec,
+							bool (*fn)(const t_string *),
+							t_usize starting_index, t_usize *index);
 
-/// @brief Run the function on every element of the vec_buf_str and returns if all elements returned true
+/// @brief Run the function on every element of the vec_buf_str and returns if 
+/// 	all elements returned true
 /// @param vec The vec_buf_str to search in
 /// @param fn The function to run on each element
 /// @param[out] result The result of the operation
 /// @return true if the operation failed, false otherwise
 /// @note If the vec_buf_str is empty, result will be true
-t_error vec_buf_str_all(t_vec_buf_str *vec, bool (*fn)(const t_string *), bool *result);
+t_error					vec_buf_str_all(t_vec_buf_str *vec,
+							bool (*fn)(const t_string *), bool *result);
 
-/// @brief Run the function on every element of the vec_buf_str and returns if any element returned true
+/// @brief Run the function on every element of the vec_buf_str and returns if 
+/// 	any element returned true
 /// @param vec The vec_buf_str to search in
 /// @param fn The function to run on each element
 /// @param[out] result The result of the operation
 /// @return true if the operation failed, false otherwise
 /// @note If the vec_buf_str is empty, result will be false
-t_error vec_buf_str_any(t_vec_buf_str *vec, bool (*fn)(const t_string *), bool *result);
+t_error					vec_buf_str_any(t_vec_buf_str *vec,
+							bool (*fn)(const t_string *), bool *result);
 
 /// @brief Run the function on every element of the vec_buf_str
 /// @param vec The vec_buf_str to iterate over
 /// @param fn The function to run on each element
 /// @param state The state to pass to the function
-void	vec_buf_str_iter(t_vec_buf_str *vec, void (*fn)(t_usize index, t_string *value, void *state), void *state);
+void					vec_buf_str_iter(t_vec_buf_str *vec,
+							void (*fn)(t_usize index, t_string *value,
+								void *state), void *state);
 
 /// @brief Reverse the order of the elements in the vec_buf_str
 /// @param vec The vec_buf_str to reverse
-void	vec_buf_str_reverse(t_vec_buf_str *vec);
+void					vec_buf_str_reverse(t_vec_buf_str *vec);
 
 /// @brief Sort the elements of the vec_buf_str
 /// @param vec The vec_buf_str to sort
 /// @param is_sorted The function to use to compare the elements
-void	vec_buf_str_sort(t_vec_buf_str		  *vec, t_vec_buf_str_sort_fn is_sorted);
+void					vec_buf_str_sort(t_vec_buf_str *vec,
+							t_vec_buf_str_sort_fn is_sorted);
 
 /// @brief Get a pointer to the last element of the vec_buf_str
 /// @param vec The vec_buf_str to get the element from
 /// @param[out] out A pointer to the last element of the vec_buf_str
 /// @return true if the operation failed, false otherwise
-t_error vec_buf_str_back(t_vec_buf_str *vec, t_string **out);
+t_error					vec_buf_str_back(t_vec_buf_str *vec, t_string **out);
 
 #endif
diff --git a/stdme/output/include/me/vec/vec_str.h b/stdme/output/include/me/vec/vec_str.h
index e45d83c0..ee8afbc4 100644
--- a/stdme/output/include/me/vec/vec_str.h
+++ b/stdme/output/include/me/vec/vec_str.h
@@ -1,123 +1,133 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   vec_str.h                                  :+:      :+:    :+:   */
+/*   vec_str.h                                          :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/12/04 18:46:53 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/09 17:53:00 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:34:19 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #ifndef VEC_STR_H
-#define VEC_STR_H
+# define VEC_STR_H
 
-
-#include "me/types.h"
+# include "me/types.h"
 
 /// @brief A function that takes two t_str and compare them
-typedef bool (*t_vec_str_sort_fn)(t_str *, t_str *);
+typedef bool		(*t_vec_str_sort_fn)(t_str *, t_str *);
 /// @brief A function that free an t_str
-typedef void (*t_free_str_item)(t_str);
+typedef void		(*t_free_str_item)(t_str);
 
 /// @brief A dynamic array of t_str
 typedef struct s_vec_str
 {
-	t_free_str_item free_func;
-	t_usize					len;
-	t_usize					capacity;
-	t_str		   *buffer;
-} t_vec_str;
+	t_free_str_item	free_func;
+	t_usize			len;
+	t_usize			capacity;
+	t_str			*buffer;
+}					t_vec_str;
 
 /// @brief Create a new vec_str with a given capacity
 /// @param capacity The capacity of the new vec_str (in terms of elements)
-/// @param free_function The function that will be used to free the elements of the vec_str
-t_vec_str vec_str_new(t_usize capacity, t_free_str_item free_function);
+/// @param free_function The function that will be used to free the elements of
+/// 	the vec_str
+t_vec_str			vec_str_new(t_usize capacity,
+						t_free_str_item free_function);
 /// @brief Push an element to the last position of the vec_str
 /// @param vec The vec_str to push the element to
 /// @param element The element to push
-t_error vec_str_push(t_vec_str *vec, t_str element);
+t_error				vec_str_push(t_vec_str *vec, t_str element);
 
 /// @brief Push an element to the first position of the vec_str
 /// @param vec The vec_str to push the element to
 /// @param element The element to push
 /// @note This operation is O(n)
-t_error vec_str_push_front(t_vec_str *vec, t_str	  element);
+t_error				vec_str_push_front(t_vec_str *vec, t_str element);
 
 /// @brief Get the last element from the vec_str, and remove it from the vec_str
 /// @param vec The vec_str to get the element from
 /// @param[out] out The last element of the vec_str
 /// @return true if the operation failed, false otherwise
-t_error vec_str_pop(t_vec_str *vec, t_str *value);
+t_error				vec_str_pop(t_vec_str *vec, t_str *value);
 
-
-/// @brief Get the first element from the vec_str, and remove it from the vec_str
+/// @brief Get the first element from the vec_str,
+///		and remove it from the vec_str
 /// @param vec The vec_str to get the element from
 /// @param[out] out The first element of the vec_str
 /// @return true if the operation failed, false otherwise
 /// @note This operation is O(n)
-t_error vec_str_pop_front(t_vec_str *vec, t_str *value);
+t_error				vec_str_pop_front(t_vec_str *vec, t_str *value);
 
 /// @brief Free the vector and all its elements
 /// @param vec The vec_str to free
-void	vec_str_free(t_vec_str vec);
+void				vec_str_free(t_vec_str vec);
 
 /// @brief Make the vec_str at least the given capacity
 /// @param vec The vec_str to reserve
 /// @param wanted_capacity The minimum capacity to reserve
 /// @return true if the operation failed, false otherwise
-t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity);
+t_error				vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity);
 
-/// @brief Run the function and returns the index of the first element that returns true
+/// @brief Run the function and returns the index of the first element that 
+/// 	returns true
 /// @param vec The vec_str to search in
 /// @param fn The function to run on each element
 /// @param[out] index The index of the first element that returns true
-t_error vec_str_find(t_vec_str *vec, bool (*fn)(const t_str *), t_usize *index);
+t_error				vec_str_find(t_vec_str *vec, bool (*fn)(const t_str *),
+						t_usize *index);
 
-
-/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
+/// @brief Run the function and returns the index of the first element that 
+/// 	returns true, but starting at index starting_index
 /// @param vec The vec_str to search in
 /// @param fn The function to run on each element
 /// @param starting_index The index to start the search from
 /// @param[out] index The index of the first element that returns true
-t_error vec_str_find_starting(t_vec_str *vec, bool (*fn)(const t_str *), t_usize starting_index, t_usize *index);
+t_error				vec_str_find_starting(t_vec_str *vec,
+						bool (*fn)(const t_str *), t_usize starting_index,
+						t_usize *index);
 
-/// @brief Run the function on every element of the vec_str and returns if all elements returned true
+/// @brief Run the function on every element of the vec_str and returns if all 
+/// 	elements returned true
 /// @param vec The vec_str to search in
 /// @param fn The function to run on each element
 /// @param[out] result The result of the operation
 /// @return true if the operation failed, false otherwise
 /// @note If the vec_str is empty, result will be true
-t_error vec_str_all(t_vec_str *vec, bool (*fn)(const t_str *), bool *result);
+t_error				vec_str_all(t_vec_str *vec, bool (*fn)(const t_str *),
+						bool *result);
 
-/// @brief Run the function on every element of the vec_str and returns if any element returned true
+/// @brief Run the function on every element of the vec_str and returns if any 
+/// 	element returned true
 /// @param vec The vec_str to search in
 /// @param fn The function to run on each element
 /// @param[out] result The result of the operation
 /// @return true if the operation failed, false otherwise
 /// @note If the vec_str is empty, result will be false
-t_error vec_str_any(t_vec_str *vec, bool (*fn)(const t_str *), bool *result);
+t_error				vec_str_any(t_vec_str *vec, bool (*fn)(const t_str *),
+						bool *result);
 
 /// @brief Run the function on every element of the vec_str
 /// @param vec The vec_str to iterate over
 /// @param fn The function to run on each element
 /// @param state The state to pass to the function
-void	vec_str_iter(t_vec_str *vec, void (*fn)(t_usize index, t_str *value, void *state), void *state);
+void				vec_str_iter(t_vec_str *vec, void (*fn)(t_usize index,
+							t_str *value, void *state), void *state);
 
 /// @brief Reverse the order of the elements in the vec_str
 /// @param vec The vec_str to reverse
-void	vec_str_reverse(t_vec_str *vec);
+void				vec_str_reverse(t_vec_str *vec);
 
 /// @brief Sort the elements of the vec_str
 /// @param vec The vec_str to sort
 /// @param is_sorted The function to use to compare the elements
-void	vec_str_sort(t_vec_str		  *vec, t_vec_str_sort_fn is_sorted);
+void				vec_str_sort(t_vec_str *vec, t_vec_str_sort_fn is_sorted);
 
 /// @brief Get a pointer to the last element of the vec_str
 /// @param vec The vec_str to get the element from
 /// @param[out] out A pointer to the last element of the vec_str
 /// @return true if the operation failed, false otherwise
-t_error vec_str_back(t_vec_str *vec, t_str **out);
+t_error				vec_str_back(t_vec_str *vec, t_str **out);
 
 #endif
diff --git a/stdme/output/include/me/vec/vec_u8.h b/stdme/output/include/me/vec/vec_u8.h
index 9cd76b29..f19dc2b2 100644
--- a/stdme/output/include/me/vec/vec_u8.h
+++ b/stdme/output/include/me/vec/vec_u8.h
@@ -1,123 +1,131 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   vec_u8.h                                  :+:      :+:    :+:   */
+/*   vec_u8.h                                           :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/12/04 18:46:53 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/09 17:53:00 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:33:13 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #ifndef VEC_U8_H
-#define VEC_U8_H
+# define VEC_U8_H
 
-
-#include "me/types.h"
+# include "me/types.h"
 
 /// @brief A function that takes two t_u8 and compare them
-typedef bool (*t_vec_u8_sort_fn)(t_u8 *, t_u8 *);
+typedef bool		(*t_vec_u8_sort_fn)(t_u8 *, t_u8 *);
 /// @brief A function that free an t_u8
-typedef void (*t_free_u8_item)(t_u8);
+typedef void		(*t_free_u8_item)(t_u8);
 
 /// @brief A dynamic array of t_u8
 typedef struct s_vec_u8
 {
-	t_free_u8_item free_func;
-	t_usize					len;
-	t_usize					capacity;
-	t_u8		   *buffer;
-} t_vec_u8;
+	t_free_u8_item	free_func;
+	t_usize			len;
+	t_usize			capacity;
+	t_u8			*buffer;
+}					t_vec_u8;
 
 /// @brief Create a new vec_u8 with a given capacity
 /// @param capacity The capacity of the new vec_u8 (in terms of elements)
-/// @param free_function The function that will be used to free the elements of the vec_u8
-t_vec_u8 vec_u8_new(t_usize capacity, t_free_u8_item free_function);
+/// @param free_function The function that will be used to free the elements of 
+/// 	the vec_u8
+t_vec_u8			vec_u8_new(t_usize capacity, t_free_u8_item free_function);
 /// @brief Push an element to the last position of the vec_u8
 /// @param vec The vec_u8 to push the element to
 /// @param element The element to push
-t_error vec_u8_push(t_vec_u8 *vec, t_u8 element);
+t_error				vec_u8_push(t_vec_u8 *vec, t_u8 element);
 
 /// @brief Push an element to the first position of the vec_u8
 /// @param vec The vec_u8 to push the element to
 /// @param element The element to push
 /// @note This operation is O(n)
-t_error vec_u8_push_front(t_vec_u8 *vec, t_u8	  element);
+t_error				vec_u8_push_front(t_vec_u8 *vec, t_u8 element);
 
 /// @brief Get the last element from the vec_u8, and remove it from the vec_u8
 /// @param vec The vec_u8 to get the element from
 /// @param[out] out The last element of the vec_u8
 /// @return true if the operation failed, false otherwise
-t_error vec_u8_pop(t_vec_u8 *vec, t_u8 *value);
-
+t_error				vec_u8_pop(t_vec_u8 *vec, t_u8 *value);
 
 /// @brief Get the first element from the vec_u8, and remove it from the vec_u8
 /// @param vec The vec_u8 to get the element from
 /// @param[out] out The first element of the vec_u8
 /// @return true if the operation failed, false otherwise
 /// @note This operation is O(n)
-t_error vec_u8_pop_front(t_vec_u8 *vec, t_u8 *value);
+t_error				vec_u8_pop_front(t_vec_u8 *vec, t_u8 *value);
 
 /// @brief Free the vector and all its elements
 /// @param vec The vec_u8 to free
-void	vec_u8_free(t_vec_u8 vec);
+void				vec_u8_free(t_vec_u8 vec);
 
 /// @brief Make the vec_u8 at least the given capacity
 /// @param vec The vec_u8 to reserve
 /// @param wanted_capacity The minimum capacity to reserve
 /// @return true if the operation failed, false otherwise
-t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity);
+t_error				vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity);
 
-/// @brief Run the function and returns the index of the first element that returns true
+/// @brief Run the function and returns the index of the first element that 
+/// 	returns true
 /// @param vec The vec_u8 to search in
 /// @param fn The function to run on each element
 /// @param[out] index The index of the first element that returns true
-t_error vec_u8_find(t_vec_u8 *vec, bool (*fn)(const t_u8 *), t_usize *index);
+t_error				vec_u8_find(t_vec_u8 *vec, bool (*fn)(const t_u8 *),
+						t_usize *index);
 
-
-/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
+/// @brief Run the function and returns the index of the first element that 
+/// 	returns true, but starting at index starting_index
 /// @param vec The vec_u8 to search in
 /// @param fn The function to run on each element
 /// @param starting_index The index to start the search from
 /// @param[out] index The index of the first element that returns true
-t_error vec_u8_find_starting(t_vec_u8 *vec, bool (*fn)(const t_u8 *), t_usize starting_index, t_usize *index);
+t_error				vec_u8_find_starting(t_vec_u8 *vec,
+						bool (*fn)(const t_u8 *), t_usize starting_index,
+						t_usize *index);
 
-/// @brief Run the function on every element of the vec_u8 and returns if all elements returned true
+/// @brief Run the function on every element of the vec_u8 and returns if all 
+/// 	elements returned true
 /// @param vec The vec_u8 to search in
 /// @param fn The function to run on each element
 /// @param[out] result The result of the operation
 /// @return true if the operation failed, false otherwise
 /// @note If the vec_u8 is empty, result will be true
-t_error vec_u8_all(t_vec_u8 *vec, bool (*fn)(const t_u8 *), bool *result);
+t_error				vec_u8_all(t_vec_u8 *vec, bool (*fn)(const t_u8 *),
+						bool *result);
 
-/// @brief Run the function on every element of the vec_u8 and returns if any element returned true
+/// @brief Run the function on every element of the vec_u8 and returns if any 
+/// 	element returned true
 /// @param vec The vec_u8 to search in
 /// @param fn The function to run on each element
 /// @param[out] result The result of the operation
 /// @return true if the operation failed, false otherwise
 /// @note If the vec_u8 is empty, result will be false
-t_error vec_u8_any(t_vec_u8 *vec, bool (*fn)(const t_u8 *), bool *result);
+t_error				vec_u8_any(t_vec_u8 *vec, bool (*fn)(const t_u8 *),
+						bool *result);
 
 /// @brief Run the function on every element of the vec_u8
 /// @param vec The vec_u8 to iterate over
 /// @param fn The function to run on each element
 /// @param state The state to pass to the function
-void	vec_u8_iter(t_vec_u8 *vec, void (*fn)(t_usize index, t_u8 *value, void *state), void *state);
+void				vec_u8_iter(t_vec_u8 *vec, void (*fn)(t_usize index,
+							t_u8 *value, void *state), void *state);
 
 /// @brief Reverse the order of the elements in the vec_u8
 /// @param vec The vec_u8 to reverse
-void	vec_u8_reverse(t_vec_u8 *vec);
+void				vec_u8_reverse(t_vec_u8 *vec);
 
 /// @brief Sort the elements of the vec_u8
 /// @param vec The vec_u8 to sort
 /// @param is_sorted The function to use to compare the elements
-void	vec_u8_sort(t_vec_u8		  *vec, t_vec_u8_sort_fn is_sorted);
+void				vec_u8_sort(t_vec_u8 *vec, t_vec_u8_sort_fn is_sorted);
 
 /// @brief Get a pointer to the last element of the vec_u8
 /// @param vec The vec_u8 to get the element from
 /// @param[out] out A pointer to the last element of the vec_u8
 /// @return true if the operation failed, false otherwise
-t_error vec_u8_back(t_vec_u8 *vec, t_u8 **out);
+t_error				vec_u8_back(t_vec_u8 *vec, t_u8 **out);
 
 #endif
diff --git a/stdme/output/src/convert/i16_to_str.c b/stdme/output/src/convert/i16_to_str.c
index f332d519..e5d0bc1e 100644
--- a/stdme/output/src/convert/i16_to_str.c
+++ b/stdme/output/src/convert/i16_to_str.c
@@ -6,7 +6,7 @@
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/01 21:15:19 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/07/30 16:32:22 by rparodi          ###   ########.fr       */
+/*   Updated: 2024/08/01 07:30:38 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
diff --git a/stdme/output/src/convert/str_to_i16_utils.c b/stdme/output/src/convert/str_to_i16_utils.c
index 6f8c7448..f59b79d6 100644
--- a/stdme/output/src/convert/str_to_i16_utils.c
+++ b/stdme/output/src/convert/str_to_i16_utils.c
@@ -1,12 +1,12 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   str_to_i64.c                                       :+:      :+:    :+:   */
+/*   str_to_i16_utils.c                                 :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/01 21:15:19 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/02/01 23:18:52 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:28:38 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -26,7 +26,7 @@ t_error	checked_add_i16(t_i16 lhs, t_i16 rhs, t_i16 *out)
 
 t_error	checked_sub_i16(t_i16 lhs, t_i16 rhs, t_i16 *out)
 {
-	if ((((rhs & (1 << (sizeof(t_i16) - 1)) || rhs == 0) || !true) && (lhs <
+	if ((((rhs & (1 << (sizeof(t_i16) - 1)) || rhs == 0) || !true) && (lhs < \
 				-32768 + rhs)))
 		return (ERROR);
 	*out = (t_i16)(lhs - rhs);
diff --git a/stdme/output/src/convert/str_to_i32_utils.c b/stdme/output/src/convert/str_to_i32_utils.c
index 650bc12c..0953dcb9 100644
--- a/stdme/output/src/convert/str_to_i32_utils.c
+++ b/stdme/output/src/convert/str_to_i32_utils.c
@@ -1,12 +1,12 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   str_to_i64.c                                       :+:      :+:    :+:   */
+/*   str_to_i32_utils.c                                 :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/01 21:15:19 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/02/01 23:18:52 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:28:53 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -26,7 +26,7 @@ t_error	checked_add_i32(t_i32 lhs, t_i32 rhs, t_i32 *out)
 
 t_error	checked_sub_i32(t_i32 lhs, t_i32 rhs, t_i32 *out)
 {
-	if ((((rhs & (1 << (sizeof(t_i32) - 1)) || rhs == 0) || !true) && (lhs <
+	if ((((rhs & (1 << (sizeof(t_i32) - 1)) || rhs == 0) || !true) && (lhs < \
 				-2147483648 + rhs)))
 		return (ERROR);
 	*out = (t_i32)(lhs - rhs);
diff --git a/stdme/output/src/convert/str_to_i64_utils.c b/stdme/output/src/convert/str_to_i64_utils.c
index f17182a8..ba112a78 100644
--- a/stdme/output/src/convert/str_to_i64_utils.c
+++ b/stdme/output/src/convert/str_to_i64_utils.c
@@ -1,12 +1,12 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   str_to_i64.c                                       :+:      :+:    :+:   */
+/*   str_to_i64_utils.c                                 :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/01 21:15:19 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/02/01 23:18:52 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:29:00 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -26,7 +26,7 @@ t_error	checked_add_i64(t_i64 lhs, t_i64 rhs, t_i64 *out)
 
 t_error	checked_sub_i64(t_i64 lhs, t_i64 rhs, t_i64 *out)
 {
-	if ((((rhs & (1 << (sizeof(t_i64) - 1)) || rhs == 0) || !true) && (lhs <
+	if ((((rhs & (1 << (sizeof(t_i64) - 1)) || rhs == 0) || !true) && (lhs < \
 				-(~9223372036854775807ll + 1) + rhs)))
 		return (ERROR);
 	*out = (t_i64)(lhs - rhs);
diff --git a/stdme/output/src/convert/str_to_i8_utils.c b/stdme/output/src/convert/str_to_i8_utils.c
index 07ef5ad0..16f0adc4 100644
--- a/stdme/output/src/convert/str_to_i8_utils.c
+++ b/stdme/output/src/convert/str_to_i8_utils.c
@@ -1,7 +1,7 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   str_to_i64.c                                       :+:      :+:    :+:   */
+/*   str_to_i8_utils.c                                  :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
diff --git a/stdme/output/src/convert/u16_to_str.c b/stdme/output/src/convert/u16_to_str.c
index 17236410..42437448 100644
--- a/stdme/output/src/convert/u16_to_str.c
+++ b/stdme/output/src/convert/u16_to_str.c
@@ -1,12 +1,12 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   str_to_i64.c                                       :+:      :+:    :+:   */
+/*   u16_to_str.c                                       :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/01 21:15:19 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/02/01 23:18:52 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:30:13 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -29,7 +29,7 @@ t_error	u16_to_str_base_prefix(t_u16 val, t_str base, t_str prefix, t_str *out)
 	if (is_nonnegative)
 		value.u16 = ~value.u16 + 1;
 	return (_format_u64((t_num_str){.value = value.u64,
-			.is_nonnegative = is_nonnegative, .base = base, .prefix = prefix},
+			.is_nonnegative = is_nonnegative, .base = base, .prefix = prefix}, \
 			out));
 }
 
diff --git a/stdme/output/src/convert/u32_to_str.c b/stdme/output/src/convert/u32_to_str.c
index 68153a9d..6c2c0f0e 100644
--- a/stdme/output/src/convert/u32_to_str.c
+++ b/stdme/output/src/convert/u32_to_str.c
@@ -1,12 +1,12 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   str_to_i64.c                                       :+:      :+:    :+:   */
+/*   u32_to_str.c                                       :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/01 21:15:19 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/02/01 23:18:52 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:30:18 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -29,7 +29,7 @@ t_error	u32_to_str_base_prefix(t_u32 val, t_str base, t_str prefix, t_str *out)
 	if (is_nonnegative)
 		value.u32 = ~value.u32 + 1;
 	return (_format_u64((t_num_str){.value = value.u64,
-			.is_nonnegative = is_nonnegative, .base = base, .prefix = prefix},
+			.is_nonnegative = is_nonnegative, .base = base, .prefix = prefix}, \
 			out));
 }
 
diff --git a/stdme/output/src/convert/u64_to_str.c b/stdme/output/src/convert/u64_to_str.c
index e8d5d813..d5d4b24c 100644
--- a/stdme/output/src/convert/u64_to_str.c
+++ b/stdme/output/src/convert/u64_to_str.c
@@ -1,12 +1,12 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   str_to_i64.c                                       :+:      :+:    :+:   */
+/*   u64_to_str.c                                       :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/01 21:15:19 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/02/01 23:18:52 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:30:22 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -29,7 +29,7 @@ t_error	u64_to_str_base_prefix(t_u64 val, t_str base, t_str prefix, t_str *out)
 	if (is_nonnegative)
 		value.u64 = ~value.u64 + 1;
 	return (_format_u64((t_num_str){.value = value.u64,
-			.is_nonnegative = is_nonnegative, .base = base, .prefix = prefix},
+			.is_nonnegative = is_nonnegative, .base = base, .prefix = prefix}, \
 			out));
 }
 
diff --git a/stdme/output/src/convert/u8_to_str.c b/stdme/output/src/convert/u8_to_str.c
index c1dab2b5..022068c6 100644
--- a/stdme/output/src/convert/u8_to_str.c
+++ b/stdme/output/src/convert/u8_to_str.c
@@ -1,12 +1,12 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   str_to_i64.c                                       :+:      :+:    :+:   */
+/*   u8_to_str.c                                        :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/01 21:15:19 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/02/01 23:18:52 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:30:25 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -29,7 +29,7 @@ t_error	u8_to_str_base_prefix(t_u8 val, t_str base, t_str prefix, t_str *out)
 	if (is_nonnegative)
 		value.u8 = ~value.u8 + 1;
 	return (_format_u64((t_num_str){.value = value.u64,
-			.is_nonnegative = is_nonnegative, .base = base, .prefix = prefix},
+			.is_nonnegative = is_nonnegative, .base = base, .prefix = prefix}, \
 			out));
 }
 
diff --git a/stdme/output/src/vec/buf_str/buf_str.c b/stdme/output/src/vec/buf_str/buf_str.c
index a58a43a4..6ce8f817 100644
--- a/stdme/output/src/vec/buf_str/buf_str.c
+++ b/stdme/output/src/vec/buf_str/buf_str.c
@@ -1,12 +1,12 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   vec_buf_str.c                                  :+:      :+:    :+:   */
+/*   buf_str.c                                          :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/12/05 18:46:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/09 17:54:11 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:31:27 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,10 +15,10 @@
 #include "me/vec/vec_buf_str.h"
 #include <stdlib.h>
 
-t_vec_buf_str vec_buf_str_new(t_usize				  capacity,
-									  t_free_buf_str_item free_function)
+t_vec_buf_str	vec_buf_str_new(t_usize capacity,
+		t_free_buf_str_item free_function)
 {
-	t_vec_buf_str out;
+	t_vec_buf_str	out;
 
 	out = (t_vec_buf_str){0};
 	out.free_func = free_function;
@@ -29,7 +29,7 @@ t_vec_buf_str vec_buf_str_new(t_usize				  capacity,
 }
 
 /// Return true in case of an error
-t_error vec_buf_str_push(t_vec_buf_str *vec, t_string element)
+t_error	vec_buf_str_push(t_vec_buf_str *vec, t_string element)
 {
 	if (vec == NULL)
 		return (ERROR);
@@ -40,9 +40,9 @@ t_error vec_buf_str_push(t_vec_buf_str *vec, t_string element)
 }
 
 /// Return true in case of an error
-t_error vec_buf_str_reserve(t_vec_buf_str *vec, t_usize wanted_capacity)
+t_error	vec_buf_str_reserve(t_vec_buf_str *vec, t_usize wanted_capacity)
 {
-	size_t new_capacity;
+	size_t	new_capacity;
 
 	if (vec == NULL)
 		return (ERROR);
@@ -51,8 +51,8 @@ t_error vec_buf_str_reserve(t_vec_buf_str *vec, t_usize wanted_capacity)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (wanted_capacity > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		vec->buffer =
-			mem_realloc_array(vec->buffer, new_capacity, sizeof(t_string));
+		vec->buffer = mem_realloc_array(vec->buffer, new_capacity, \
+			sizeof(t_string));
 		vec->capacity = new_capacity;
 	}
 	return (NO_ERROR);
@@ -60,10 +60,10 @@ t_error vec_buf_str_reserve(t_vec_buf_str *vec, t_usize wanted_capacity)
 
 /// Return true if the vector is empty
 /// This function is safe to call with value being NULL
-t_error vec_buf_str_pop(t_vec_buf_str *vec, t_string *value)
+t_error	vec_buf_str_pop(t_vec_buf_str *vec, t_string *value)
 {
-	t_string  temp_value;
-	t_string *ptr;
+	t_string	temp_value;
+	t_string	*ptr;
 
 	if (vec == NULL)
 		return (ERROR);
@@ -79,10 +79,10 @@ t_error vec_buf_str_pop(t_vec_buf_str *vec, t_string *value)
 }
 
 /// This function is safe to call with `free_elem` being NULL
-void vec_buf_str_free(t_vec_buf_str vec)
+void	vec_buf_str_free(t_vec_buf_str vec)
 {
 	if (vec.buffer == NULL)
-		return;
+		return ;
 	if (vec.free_func)
 	{
 		while (vec.len)
diff --git a/stdme/output/src/vec/buf_str/buf_str_functions2.c b/stdme/output/src/vec/buf_str/buf_str_functions2.c
index fd4c6100..0190acb0 100644
--- a/stdme/output/src/vec/buf_str/buf_str_functions2.c
+++ b/stdme/output/src/vec/buf_str/buf_str_functions2.c
@@ -10,17 +10,15 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem.h"
-#include "me/mem/mem.h"
 #include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_buf_str.h"
 #include <stdlib.h>
 
-t_error vec_buf_str_find(t_vec_buf_str *vec,
-							 bool (*fn)(const t_string *), t_usize *index)
+t_error	vec_buf_str_find(t_vec_buf_str *vec, bool (*fn)(const t_string *),
+		t_usize *index)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || index == NULL)
 		return (ERROR);
@@ -37,11 +35,10 @@ t_error vec_buf_str_find(t_vec_buf_str *vec,
 	return (ERROR);
 }
 
-t_error vec_buf_str_find_starting(t_vec_buf_str *vec,
-									  bool (*fn)(const t_string *),
-									  t_usize starting_index, t_usize *index)
+t_error	vec_buf_str_find_starting(t_vec_buf_str *vec,
+		bool (*fn)(const t_string *), t_usize starting_index, t_usize *index)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || index == NULL)
 		return (ERROR);
@@ -58,10 +55,10 @@ t_error vec_buf_str_find_starting(t_vec_buf_str *vec,
 	return (ERROR);
 }
 
-t_error vec_buf_str_all(t_vec_buf_str *vec,
-							bool (*fn)(const t_string *), bool *result)
+t_error	vec_buf_str_all(t_vec_buf_str *vec, bool (*fn)(const t_string *),
+		bool *result)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || result == NULL)
 		return (ERROR);
@@ -76,10 +73,10 @@ t_error vec_buf_str_all(t_vec_buf_str *vec,
 	return (ERROR);
 }
 
-t_error vec_buf_str_any(t_vec_buf_str *vec,
-							bool (*fn)(const t_string *), bool *result)
+t_error	vec_buf_str_any(t_vec_buf_str *vec, bool (*fn)(const t_string *),
+		bool *result)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || result == NULL)
 		return (ERROR);
@@ -94,15 +91,13 @@ t_error vec_buf_str_any(t_vec_buf_str *vec,
 	return (ERROR);
 }
 
-void vec_buf_str_iter(t_vec_buf_str *vec,
-						  void (*fn)(t_usize index, t_string *value,
-									 void *state),
-						  void *state)
+void	vec_buf_str_iter(t_vec_buf_str *vec, void (*fn)(t_usize index,
+			t_string *value, void *state), void *state)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL)
-		return;
+		return ;
 	idx = 0;
 	while (idx < vec->len)
 	{
diff --git a/stdme/output/src/vec/buf_str/buf_str_functions3.c b/stdme/output/src/vec/buf_str/buf_str_functions3.c
index 4ec2c20a..69803760 100644
--- a/stdme/output/src/vec/buf_str/buf_str_functions3.c
+++ b/stdme/output/src/vec/buf_str/buf_str_functions3.c
@@ -10,23 +10,20 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem.h"
-#include "me/mem/mem.h"
 #include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_buf_str.h"
 #include <stdlib.h>
 
-t_error vec_buf_str_push_front(t_vec_buf_str *vec,
-								   t_string	  element)
+t_error	vec_buf_str_push_front(t_vec_buf_str *vec, t_string element)
 {
-	t_usize i;
+	t_usize	i;
 
 	if (vec->len == 0)
 		return (vec_buf_str_push(vec, element));
 	i = vec->len - 1;
-	if (vec->capacity < vec->len + 1 &&
-		vec_buf_str_reserve(vec, 3 * vec->len / 2 + 1))
+	if (vec->capacity < vec->len + 1 && vec_buf_str_reserve(vec, 3 * vec->len
+			/ 2 + 1))
 		return (ERROR);
 	while (i > 0)
 	{
@@ -39,9 +36,9 @@ t_error vec_buf_str_push_front(t_vec_buf_str *vec,
 	return (NO_ERROR);
 }
 
-t_error vec_buf_str_pop_front(t_vec_buf_str *vec, t_string *value)
+t_error	vec_buf_str_pop_front(t_vec_buf_str *vec, t_string *value)
 {
-	t_usize i;
+	t_usize	i;
 
 	if (vec->len <= 1)
 		return (vec_buf_str_pop(vec, value));
@@ -57,10 +54,10 @@ t_error vec_buf_str_pop_front(t_vec_buf_str *vec, t_string *value)
 	return (NO_ERROR);
 }
 
-void vec_buf_str_reverse(t_vec_buf_str *vec)
+void	vec_buf_str_reverse(t_vec_buf_str *vec)
 {
-	t_string temporary;
-	t_usize		  i;
+	t_string	temporary;
+	t_usize		i;
 
 	i = 0;
 	while (i < vec->len / 2)
@@ -72,9 +69,9 @@ void vec_buf_str_reverse(t_vec_buf_str *vec)
 	}
 }
 
-t_error vec_buf_str_back(t_vec_buf_str *vec, t_string **out)
+t_error	vec_buf_str_back(t_vec_buf_str *vec, t_string **out)
 {
-	t_string *temporary;
+	t_string	*temporary;
 
 	if (out == NULL)
 		out = &temporary;
diff --git a/stdme/output/src/vec/str/str.c b/stdme/output/src/vec/str/str.c
index 0c2daa9f..e20b1df8 100644
--- a/stdme/output/src/vec/str/str.c
+++ b/stdme/output/src/vec/str/str.c
@@ -1,12 +1,12 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   vec_str.c                                  :+:      :+:    :+:   */
+/*   str.c                                              :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/12/05 18:46:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/09 17:54:11 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:31:20 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,10 +15,9 @@
 #include "me/vec/vec_str.h"
 #include <stdlib.h>
 
-t_vec_str vec_str_new(t_usize				  capacity,
-									  t_free_str_item free_function)
+t_vec_str	vec_str_new(t_usize capacity, t_free_str_item free_function)
 {
-	t_vec_str out;
+	t_vec_str	out;
 
 	out = (t_vec_str){0};
 	out.free_func = free_function;
@@ -29,7 +28,7 @@ t_vec_str vec_str_new(t_usize				  capacity,
 }
 
 /// Return true in case of an error
-t_error vec_str_push(t_vec_str *vec, t_str element)
+t_error	vec_str_push(t_vec_str *vec, t_str element)
 {
 	if (vec == NULL)
 		return (ERROR);
@@ -40,9 +39,9 @@ t_error vec_str_push(t_vec_str *vec, t_str element)
 }
 
 /// Return true in case of an error
-t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity)
+t_error	vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity)
 {
-	size_t new_capacity;
+	size_t	new_capacity;
 
 	if (vec == NULL)
 		return (ERROR);
@@ -51,8 +50,8 @@ t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (wanted_capacity > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		vec->buffer =
-			mem_realloc_array(vec->buffer, new_capacity, sizeof(t_str));
+		vec->buffer = mem_realloc_array(vec->buffer, new_capacity, \
+			sizeof(t_str));
 		vec->capacity = new_capacity;
 	}
 	return (NO_ERROR);
@@ -60,10 +59,10 @@ t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity)
 
 /// Return true if the vector is empty
 /// This function is safe to call with value being NULL
-t_error vec_str_pop(t_vec_str *vec, t_str *value)
+t_error	vec_str_pop(t_vec_str *vec, t_str *value)
 {
-	t_str  temp_value;
-	t_str *ptr;
+	t_str	temp_value;
+	t_str	*ptr;
 
 	if (vec == NULL)
 		return (ERROR);
@@ -79,10 +78,10 @@ t_error vec_str_pop(t_vec_str *vec, t_str *value)
 }
 
 /// This function is safe to call with `free_elem` being NULL
-void vec_str_free(t_vec_str vec)
+void	vec_str_free(t_vec_str vec)
 {
 	if (vec.buffer == NULL)
-		return;
+		return ;
 	if (vec.free_func)
 	{
 		while (vec.len)
diff --git a/stdme/output/src/vec/str/str_functions2.c b/stdme/output/src/vec/str/str_functions2.c
index af61b8e1..8a88ee3a 100644
--- a/stdme/output/src/vec/str/str_functions2.c
+++ b/stdme/output/src/vec/str/str_functions2.c
@@ -10,17 +10,14 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem.h"
-#include "me/mem/mem.h"
 #include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_str.h"
 #include <stdlib.h>
 
-t_error vec_str_find(t_vec_str *vec,
-							 bool (*fn)(const t_str *), t_usize *index)
+t_error	vec_str_find(t_vec_str *vec, bool (*fn)(const t_str *), t_usize *index)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || index == NULL)
 		return (ERROR);
@@ -37,11 +34,10 @@ t_error vec_str_find(t_vec_str *vec,
 	return (ERROR);
 }
 
-t_error vec_str_find_starting(t_vec_str *vec,
-									  bool (*fn)(const t_str *),
-									  t_usize starting_index, t_usize *index)
+t_error	vec_str_find_starting(t_vec_str *vec, bool (*fn)(const t_str *),
+		t_usize starting_index, t_usize *index)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || index == NULL)
 		return (ERROR);
@@ -58,10 +54,9 @@ t_error vec_str_find_starting(t_vec_str *vec,
 	return (ERROR);
 }
 
-t_error vec_str_all(t_vec_str *vec,
-							bool (*fn)(const t_str *), bool *result)
+t_error	vec_str_all(t_vec_str *vec, bool (*fn)(const t_str *), bool *result)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || result == NULL)
 		return (ERROR);
@@ -76,10 +71,9 @@ t_error vec_str_all(t_vec_str *vec,
 	return (ERROR);
 }
 
-t_error vec_str_any(t_vec_str *vec,
-							bool (*fn)(const t_str *), bool *result)
+t_error	vec_str_any(t_vec_str *vec, bool (*fn)(const t_str *), bool *result)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || result == NULL)
 		return (ERROR);
@@ -94,15 +88,13 @@ t_error vec_str_any(t_vec_str *vec,
 	return (ERROR);
 }
 
-void vec_str_iter(t_vec_str *vec,
-						  void (*fn)(t_usize index, t_str *value,
-									 void *state),
-						  void *state)
+void	vec_str_iter(t_vec_str *vec, void (*fn)(t_usize index, t_str *value,
+			void *state), void *state)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL)
-		return;
+		return ;
 	idx = 0;
 	while (idx < vec->len)
 	{
diff --git a/stdme/output/src/vec/str/str_functions3.c b/stdme/output/src/vec/str/str_functions3.c
index 6b9704a5..dcd88550 100644
--- a/stdme/output/src/vec/str/str_functions3.c
+++ b/stdme/output/src/vec/str/str_functions3.c
@@ -10,23 +10,20 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem.h"
-#include "me/mem/mem.h"
 #include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_str.h"
 #include <stdlib.h>
 
-t_error vec_str_push_front(t_vec_str *vec,
-								   t_str	  element)
+t_error	vec_str_push_front(t_vec_str *vec, t_str element)
 {
-	t_usize i;
+	t_usize	i;
 
 	if (vec->len == 0)
 		return (vec_str_push(vec, element));
 	i = vec->len - 1;
-	if (vec->capacity < vec->len + 1 &&
-		vec_str_reserve(vec, 3 * vec->len / 2 + 1))
+	if (vec->capacity < vec->len + 1 && vec_str_reserve(vec, 3 * vec->len / 2
+			+ 1))
 		return (ERROR);
 	while (i > 0)
 	{
@@ -39,9 +36,9 @@ t_error vec_str_push_front(t_vec_str *vec,
 	return (NO_ERROR);
 }
 
-t_error vec_str_pop_front(t_vec_str *vec, t_str *value)
+t_error	vec_str_pop_front(t_vec_str *vec, t_str *value)
 {
-	t_usize i;
+	t_usize	i;
 
 	if (vec->len <= 1)
 		return (vec_str_pop(vec, value));
@@ -57,10 +54,10 @@ t_error vec_str_pop_front(t_vec_str *vec, t_str *value)
 	return (NO_ERROR);
 }
 
-void vec_str_reverse(t_vec_str *vec)
+void	vec_str_reverse(t_vec_str *vec)
 {
-	t_str temporary;
-	t_usize		  i;
+	t_str	temporary;
+	t_usize	i;
 
 	i = 0;
 	while (i < vec->len / 2)
@@ -72,9 +69,9 @@ void vec_str_reverse(t_vec_str *vec)
 	}
 }
 
-t_error vec_str_back(t_vec_str *vec, t_str **out)
+t_error	vec_str_back(t_vec_str *vec, t_str **out)
 {
-	t_str *temporary;
+	t_str	*temporary;
 
 	if (out == NULL)
 		out = &temporary;
diff --git a/stdme/output/src/vec/u8/u8.c b/stdme/output/src/vec/u8/u8.c
index 1d5529fc..f0f698b2 100644
--- a/stdme/output/src/vec/u8/u8.c
+++ b/stdme/output/src/vec/u8/u8.c
@@ -1,12 +1,12 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   vec_u8.c                                  :+:      :+:    :+:   */
+/*   u8.c                                               :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2023/12/05 18:46:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/09 17:54:11 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/08/01 07:31:34 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,10 +15,9 @@
 #include "me/vec/vec_u8.h"
 #include <stdlib.h>
 
-t_vec_u8 vec_u8_new(t_usize				  capacity,
-									  t_free_u8_item free_function)
+t_vec_u8	vec_u8_new(t_usize capacity, t_free_u8_item free_function)
 {
-	t_vec_u8 out;
+	t_vec_u8	out;
 
 	out = (t_vec_u8){0};
 	out.free_func = free_function;
@@ -29,7 +28,7 @@ t_vec_u8 vec_u8_new(t_usize				  capacity,
 }
 
 /// Return true in case of an error
-t_error vec_u8_push(t_vec_u8 *vec, t_u8 element)
+t_error	vec_u8_push(t_vec_u8 *vec, t_u8 element)
 {
 	if (vec == NULL)
 		return (ERROR);
@@ -40,9 +39,9 @@ t_error vec_u8_push(t_vec_u8 *vec, t_u8 element)
 }
 
 /// Return true in case of an error
-t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity)
+t_error	vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity)
 {
-	size_t new_capacity;
+	size_t	new_capacity;
 
 	if (vec == NULL)
 		return (ERROR);
@@ -51,8 +50,8 @@ t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (wanted_capacity > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		vec->buffer =
-			mem_realloc_array(vec->buffer, new_capacity, sizeof(t_u8));
+		vec->buffer = mem_realloc_array(vec->buffer, new_capacity, \
+			sizeof(t_u8));
 		vec->capacity = new_capacity;
 	}
 	return (NO_ERROR);
@@ -60,10 +59,10 @@ t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity)
 
 /// Return true if the vector is empty
 /// This function is safe to call with value being NULL
-t_error vec_u8_pop(t_vec_u8 *vec, t_u8 *value)
+t_error	vec_u8_pop(t_vec_u8 *vec, t_u8 *value)
 {
-	t_u8  temp_value;
-	t_u8 *ptr;
+	t_u8	temp_value;
+	t_u8	*ptr;
 
 	if (vec == NULL)
 		return (ERROR);
@@ -79,10 +78,10 @@ t_error vec_u8_pop(t_vec_u8 *vec, t_u8 *value)
 }
 
 /// This function is safe to call with `free_elem` being NULL
-void vec_u8_free(t_vec_u8 vec)
+void	vec_u8_free(t_vec_u8 vec)
 {
 	if (vec.buffer == NULL)
-		return;
+		return ;
 	if (vec.free_func)
 	{
 		while (vec.len)
diff --git a/stdme/output/src/vec/u8/u8_functions2.c b/stdme/output/src/vec/u8/u8_functions2.c
index e5efdd0c..82bb1ac1 100644
--- a/stdme/output/src/vec/u8/u8_functions2.c
+++ b/stdme/output/src/vec/u8/u8_functions2.c
@@ -10,17 +10,14 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem.h"
-#include "me/mem/mem.h"
 #include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_u8.h"
 #include <stdlib.h>
 
-t_error vec_u8_find(t_vec_u8 *vec,
-							 bool (*fn)(const t_u8 *), t_usize *index)
+t_error	vec_u8_find(t_vec_u8 *vec, bool (*fn)(const t_u8 *), t_usize *index)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || index == NULL)
 		return (ERROR);
@@ -37,11 +34,10 @@ t_error vec_u8_find(t_vec_u8 *vec,
 	return (ERROR);
 }
 
-t_error vec_u8_find_starting(t_vec_u8 *vec,
-									  bool (*fn)(const t_u8 *),
-									  t_usize starting_index, t_usize *index)
+t_error	vec_u8_find_starting(t_vec_u8 *vec, bool (*fn)(const t_u8 *),
+		t_usize starting_index, t_usize *index)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || index == NULL)
 		return (ERROR);
@@ -58,10 +54,9 @@ t_error vec_u8_find_starting(t_vec_u8 *vec,
 	return (ERROR);
 }
 
-t_error vec_u8_all(t_vec_u8 *vec,
-							bool (*fn)(const t_u8 *), bool *result)
+t_error	vec_u8_all(t_vec_u8 *vec, bool (*fn)(const t_u8 *), bool *result)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || result == NULL)
 		return (ERROR);
@@ -76,10 +71,9 @@ t_error vec_u8_all(t_vec_u8 *vec,
 	return (ERROR);
 }
 
-t_error vec_u8_any(t_vec_u8 *vec,
-							bool (*fn)(const t_u8 *), bool *result)
+t_error	vec_u8_any(t_vec_u8 *vec, bool (*fn)(const t_u8 *), bool *result)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL || result == NULL)
 		return (ERROR);
@@ -94,15 +88,13 @@ t_error vec_u8_any(t_vec_u8 *vec,
 	return (ERROR);
 }
 
-void vec_u8_iter(t_vec_u8 *vec,
-						  void (*fn)(t_usize index, t_u8 *value,
-									 void *state),
-						  void *state)
+void	vec_u8_iter(t_vec_u8 *vec, void (*fn)(t_usize index, t_u8 *value,
+			void *state), void *state)
 {
-	t_usize idx;
+	t_usize	idx;
 
 	if (vec == NULL || fn == NULL)
-		return;
+		return ;
 	idx = 0;
 	while (idx < vec->len)
 	{
diff --git a/stdme/output/src/vec/u8/u8_functions3.c b/stdme/output/src/vec/u8/u8_functions3.c
index 921200fc..9f341310 100644
--- a/stdme/output/src/vec/u8/u8_functions3.c
+++ b/stdme/output/src/vec/u8/u8_functions3.c
@@ -10,23 +10,20 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem.h"
-#include "me/mem/mem.h"
 #include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_u8.h"
 #include <stdlib.h>
 
-t_error vec_u8_push_front(t_vec_u8 *vec,
-								   t_u8	  element)
+t_error	vec_u8_push_front(t_vec_u8 *vec, t_u8 element)
 {
-	t_usize i;
+	t_usize	i;
 
 	if (vec->len == 0)
 		return (vec_u8_push(vec, element));
 	i = vec->len - 1;
-	if (vec->capacity < vec->len + 1 &&
-		vec_u8_reserve(vec, 3 * vec->len / 2 + 1))
+	if (vec->capacity < vec->len + 1 && vec_u8_reserve(vec, 3 * vec->len / 2
+			+ 1))
 		return (ERROR);
 	while (i > 0)
 	{
@@ -39,9 +36,9 @@ t_error vec_u8_push_front(t_vec_u8 *vec,
 	return (NO_ERROR);
 }
 
-t_error vec_u8_pop_front(t_vec_u8 *vec, t_u8 *value)
+t_error	vec_u8_pop_front(t_vec_u8 *vec, t_u8 *value)
 {
-	t_usize i;
+	t_usize	i;
 
 	if (vec->len <= 1)
 		return (vec_u8_pop(vec, value));
@@ -57,10 +54,10 @@ t_error vec_u8_pop_front(t_vec_u8 *vec, t_u8 *value)
 	return (NO_ERROR);
 }
 
-void vec_u8_reverse(t_vec_u8 *vec)
+void	vec_u8_reverse(t_vec_u8 *vec)
 {
-	t_u8 temporary;
-	t_usize		  i;
+	t_u8	temporary;
+	t_usize	i;
 
 	i = 0;
 	while (i < vec->len / 2)
@@ -72,9 +69,9 @@ void vec_u8_reverse(t_vec_u8 *vec)
 	}
 }
 
-t_error vec_u8_back(t_vec_u8 *vec, t_u8 **out)
+t_error	vec_u8_back(t_vec_u8 *vec, t_u8 **out)
 {
-	t_u8 *temporary;
+	t_u8	*temporary;
 
 	if (out == NULL)
 		out = &temporary;