From a931d6df9fd873607442a70351fbb7e0f32590d0 Mon Sep 17 00:00:00 2001
From: Dominik Kaiser <dkaiser@2-F-4.42heilbronn.de>
Date: Wed, 24 Apr 2024 11:08:34 +0200
Subject: [PATCH] Norminette formatting

---
 cmd_optimization.c   | 132 ++++++++++++-------------
 command_handling.c   |   6 +-
 input_handling.c     |  20 ++--
 main.c               |  14 +--
 push_swap.h          |  40 ++++----
 sorting.c            | 225 +++++++++++++++++++++----------------------
 stack_optimization.c |  33 +++----
 stack_utils.c        |  28 +++---
 8 files changed, 246 insertions(+), 252 deletions(-)

diff --git a/cmd_optimization.c b/cmd_optimization.c
index 9fcf876..41d1c08 100644
--- a/cmd_optimization.c
+++ b/cmd_optimization.c
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/13 16:42:34 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/17 12:15:41 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/24 10:58:14 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,80 +14,82 @@
 #include "libft/libft.h"
 #include "push_swap.h"
 
-static enum e_pscmd get_cmd(t_list *cmd)
+static enum e_pscmd	get_cmd(t_list *cmd)
 {
-    if (cmd)
-        return (*(enum e_pscmd*)cmd->content);
-    else
-        return NO_CMD;
+	if (cmd)
+		return (*(enum e_pscmd *)cmd->content);
+	else
+		return (NO_CMD);
 }
 
-static void optimize_redundant(t_psdata *data, enum e_pscmd cmd1, enum e_pscmd cmd2)
+static void	optimize_redundant(t_psdata *data, enum e_pscmd cmd1,
+		enum e_pscmd cmd2)
 {
-    t_list *cur;
-    t_list *last;
-    int optimizations;
+	t_list	*cur;
+	t_list	*last;
+	int		optimizations;
 
-    cur = data->cmds;
-    last = cur;
-    optimizations = 0;
-
-    if (!cur)
-        return ;
-    while (cur && cur->next)
-    {
-        if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2) || (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
-        {
-            last->next = cur->next->next;
-            ft_lstdelone(cur->next, free);
-            ft_lstdelone(cur, free);
-            optimizations++;
-        }
-        last = last->next;
-        if (last)
-            cur = last->next;
-        else
-            cur = NULL;
-    }
-    if (optimizations)
-        optimize_redundant(data, cmd1, cmd2);
+	cur = data->cmds;
+	last = cur;
+	optimizations = 0;
+	if (!cur)
+		return ;
+	while (cur && cur->next)
+	{
+		if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2)
+			|| (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
+		{
+			last->next = cur->next->next;
+			ft_lstdelone(cur->next, free);
+			ft_lstdelone(cur, free);
+			optimizations++;
+		}
+		last = last->next;
+		if (last)
+			cur = last->next;
+		else
+			cur = NULL;
+	}
+	if (optimizations)
+		optimize_redundant(data, cmd1, cmd2);
 }
 
-static void optimize_two_stack_ops(t_psdata *data, enum e_pscmd cmd1, enum e_pscmd cmd2, enum e_pscmd new_cmd)
+static void	optimize_two_stack_ops(t_psdata *data, enum e_pscmd cmd1,
+		enum e_pscmd cmd2, enum e_pscmd new_cmd)
 {
-    t_list *cur;
-    t_list *last;
-    int optimizations;
-
-    cur = data->cmds;
-    last = cur;
-    optimizations = 0;
+	t_list	*cur;
+	t_list	*last;
+	int		optimizations;
 
-    if (!cur)
-        return ;
-    while (cur && cur->next)
-    {
-        if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2) || (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
-        {
-            last->next = cur->next;
-            *(enum e_pscmd*)cur->next->content = new_cmd;
-            ft_lstdelone(cur, free);
-            optimizations++;
-        }
-        last = last->next;
-        if (last)
-            cur = last->next;
-        else
-            cur = NULL;
-    }
-    if (optimizations)
-        optimize_two_stack_ops(data, cmd1, cmd2, new_cmd);
+	cur = data->cmds;
+	last = cur;
+	optimizations = 0;
+	if (!cur)
+		return ;
+	while (cur && cur->next)
+	{
+		if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2)
+			|| (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
+		{
+			last->next = cur->next;
+			*(enum e_pscmd *)cur->next->content = new_cmd;
+			ft_lstdelone(cur, free);
+			optimizations++;
+		}
+		last = last->next;
+		if (last)
+			cur = last->next;
+		else
+			cur = NULL;
+	}
+	if (optimizations)
+		optimize_two_stack_ops(data, cmd1, cmd2, new_cmd);
 }
 
-void optimize_commands(t_psdata *data)
+void	optimize_commands(t_psdata *data)
 {
-    optimize_redundant(data, PA, PB);
-    optimize_redundant(data, RB, RRB);
-    optimize_redundant(data, RA, RRA);
-    optimize_two_stack_ops(data, RA, RB, RR);
+	optimize_redundant(data, PA, PB);
+	optimize_redundant(data, RB, RRB);
+	optimize_redundant(data, RA, RRA);
+	optimize_two_stack_ops(data, RA, RB, RR);
 }
diff --git a/command_handling.c b/command_handling.c
index 0b5f335..a9bb9b0 100644
--- a/command_handling.c
+++ b/command_handling.c
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/13 14:38:47 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/16 09:27:41 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/24 10:59:39 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,7 +20,7 @@ static int	add_cmd_to_queue(t_list **cmds, enum e_pscmd cmd)
 	ptr_cmd = malloc(sizeof(enum e_pscmd));
 	if (!ptr_cmd)
 		return (1);
-    *ptr_cmd = cmd;
+	*ptr_cmd = cmd;
 	new_elem = ft_lstnew(ptr_cmd);
 	if (!new_elem)
 	{
@@ -96,5 +96,5 @@ static void	print_cmd(void *ptr_cmd)
 
 void	print_commands(t_list *cmds)
 {
-    ft_lstiter(cmds, print_cmd);
+	ft_lstiter(cmds, print_cmd);
 }
diff --git a/input_handling.c b/input_handling.c
index 078ab7f..2f987cb 100644
--- a/input_handling.c
+++ b/input_handling.c
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/12 17:31:49 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/15 16:24:51 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/24 10:59:24 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -39,8 +39,8 @@ static int	is_input_only_nbrs(int argc, char *argv[])
 
 static int	are_numbers_unique(int *stack, int size)
 {
-	int i;
-	int k;
+	int	i;
+	int	k;
 
 	i = 0;
 	while (i < size - 1)
@@ -54,36 +54,33 @@ static int	are_numbers_unique(int *stack, int size)
 		}
 		i++;
 	}
-
 	return (1);
 }
 
 static int	*get_array_from_input(int argc, char *argv[])
 {
-	int *stack;
-	int i;
+	int	*stack;
+	int	i;
 
 	stack = malloc(sizeof(int) * (argc - 1));
 	if (!stack)
-		return NULL;
-
+		return (NULL);
 	i = 0;
 	while (i < argc - 1)
 	{
 		stack[i] = ft_atoi(argv[i + 1]);
 		i++;
 	}
-
 	return (stack);
 }
 
 t_stack	*create_stack(int argc, char *argv[])
 {
-	t_stack *result;
+	t_stack	*result;
 
 	result = malloc(sizeof(t_stack));
 	if (!result)
-		return NULL;
+		return (NULL);
 	if (!is_input_only_nbrs(argc, argv))
 		return (free(result), NULL);
 	result->stack = get_array_from_input(argc, argv);
@@ -96,6 +93,5 @@ t_stack	*create_stack(int argc, char *argv[])
 		return (NULL);
 	}
 	result->size = argc - 1;
-
 	return (result);
 }
diff --git a/main.c b/main.c
index 3881df0..6406ffc 100644
--- a/main.c
+++ b/main.c
@@ -6,14 +6,14 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/12 17:03:30 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/17 09:42:43 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/24 10:58:59 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "libft/ft_printf.h"
 #include "push_swap.h"
 
-static void free_data(t_psdata *data)
+static void	free_data(t_psdata *data)
 {
 	if (data)
 	{
@@ -33,9 +33,9 @@ static void free_data(t_psdata *data)
 	}
 }
 
-static t_psdata *initialize_data(int argc, char *argv[])
+static t_psdata	*initialize_data(int argc, char *argv[])
 {
-	t_psdata *result;
+	t_psdata	*result;
 
 	result = malloc(sizeof(t_psdata));
 	if (result)
@@ -50,18 +50,18 @@ static t_psdata *initialize_data(int argc, char *argv[])
 				if (result->b->stack)
 				{
 					result->b->size = 0;
-					return result;
+					return (result);
 				}
 			}
 		}
 	}
 	free_data(result);
-	return NULL;
+	return (NULL);
 }
 
 int	main(int argc, char *argv[])
 {
-	t_psdata *data;
+	t_psdata	*data;
 
 	data = initialize_data(argc, argv);
 	if (!data)
diff --git a/push_swap.h b/push_swap.h
index fc7b51a..d3dcbaa 100644
--- a/push_swap.h
+++ b/push_swap.h
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/12 16:59:09 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/16 17:57:33 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/24 10:59:05 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,7 +15,7 @@
 # include "libft/libft.h"
 # include <stdlib.h>
 
-enum	e_pscmd
+enum		e_pscmd
 {
 	SA,
 	SB,
@@ -33,31 +33,31 @@ enum	e_pscmd
 
 typedef struct s_stack
 {
-	int *stack;
-	int size;
-} t_stack;
+	int		*stack;
+	int		size;
+}			t_stack;
 
 typedef struct s_psdata
 {
-	t_stack *a;
-	t_stack *b;
-	t_list *cmds;
-} t_psdata;
+	t_stack	*a;
+	t_stack	*b;
+	t_list	*cmds;
+}			t_psdata;
 
-t_stack	*create_stack(int argc, char *argv[]);
+t_stack		*create_stack(int argc, char *argv[]);
 
-void	stack_swap(t_stack *stack);
-void	stack_push(t_stack *dst_stack, t_stack *src_stack);
-void	stack_rotate(t_stack *stack);
-void	stack_rrotate(t_stack *stack);
-void stack_print(t_stack *stack);
+void		stack_swap(t_stack *stack);
+void		stack_push(t_stack *dst_stack, t_stack *src_stack);
+void		stack_rotate(t_stack *stack);
+void		stack_rrotate(t_stack *stack);
+void		stack_print(t_stack *stack);
 
-void	run_command(t_psdata *data, enum e_pscmd cmd);
-void	print_commands(t_list *cmds);
+void		run_command(t_psdata *data, enum e_pscmd cmd);
+void		print_commands(t_list *cmds);
 
-int	stack_optimize(t_stack *stack);
-void	optimize_commands(t_psdata *data);
+int			stack_optimize(t_stack *stack);
+void		optimize_commands(t_psdata *data);
 
-void	stack_sort(t_psdata *data);
+void		stack_sort(t_psdata *data);
 
 #endif // PUSH_SWAP_H
diff --git a/sorting.c b/sorting.c
index d6c3ada..c7522eb 100644
--- a/sorting.c
+++ b/sorting.c
@@ -6,144 +6,141 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/13 15:04:19 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/17 15:48:53 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/24 10:58:02 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "libft/ft_printf.h"
 #include "push_swap.h"
 
-static void presort(t_psdata *data)
+static void	presort(t_psdata *data)
 {
-    int size;
-    int pivot;
-    int max;
+	int	size;
+	int	pivot;
+	int	max;
 
-    size = data->a->size;
-    pivot = size / 2;
-    max = data->a->stack[0];
-    while (size--)
-    {
-        if (data->a->stack[0] < max)
-        {
-            run_command(data, PB);
-            if (data->b->stack[0] < pivot)
-                run_command(data, RB);
-        }
-        else
-        {
-            max = data->a->stack[0];
-            run_command(data, RA);
-        }
-    }
+	size = data->a->size;
+	pivot = size / 2;
+	max = data->a->stack[0];
+	while (size--)
+	{
+		if (data->a->stack[0] < max)
+		{
+			run_command(data, PB);
+			if (data->b->stack[0] < pivot)
+				run_command(data, RB);
+		}
+		else
+		{
+			max = data->a->stack[0];
+			run_command(data, RA);
+		}
+	}
 }
 
-static int calculate_score(t_psdata *data, int pos)
+static int	calculate_score(t_psdata *data, int pos)
 {
-    int moves_to_top;
-    int moves_to_spot;
-    int i;
+	int	moves_to_top;
+	int	moves_to_spot;
+	int	i;
 
-    if (pos < (data->b->size + 1) / 2)
-        moves_to_top = pos;
-    else
-        moves_to_top = data->b->size - pos;
-    i = 0;
-    while (i < data->a->size && data->a->stack[i] > data->b->stack[pos])
-        i++;
-    if (i < (data->a->size + 1) / 2)
-        moves_to_spot = 2 * i + 1;
-    else
-        moves_to_spot = 2 * ((data->a->size - i) + 1);
-    return moves_to_top + moves_to_spot;
+	if (pos < (data->b->size + 1) / 2)
+		moves_to_top = pos;
+	else
+		moves_to_top = data->b->size - pos;
+	i = 0;
+	while (i < data->a->size && data->a->stack[i] > data->b->stack[pos])
+		i++;
+	if (i < (data->a->size + 1) / 2)
+		moves_to_spot = 2 * i + 1;
+	else
+		moves_to_spot = 2 * ((data->a->size - i) + 1);
+	return (moves_to_top + moves_to_spot);
 }
 
-
-
-static void move_to_top(t_psdata *data, int idx)
+static void	move_to_top(t_psdata *data, int idx)
 {
-    if (idx < (data->b->size + 1) / 2)
-    {
-        while (--idx > 0)
-            run_command(data, RB);
-    }
-    else
-    {
-        idx = data->b->size - idx;
-        while (idx--)
-            run_command(data, RRB);
-    }
+	if (idx < (data->b->size + 1) / 2)
+	{
+		while (--idx > 0)
+			run_command(data, RB);
+	}
+	else
+	{
+		idx = data->b->size - idx;
+		while (idx--)
+			run_command(data, RRB);
+	}
 }
 
-static void move_to_spot(t_psdata *data, int idx)
+static void	move_to_spot(t_psdata *data, int idx)
 {
-    int pos;
-    int i;
+	int	pos;
+	int	i;
 
-    pos = 0;
-    while (pos < data->a->size && data->b->stack[0] > data->a->stack[pos])
-        pos++;
-    if (pos >= data->a->size)
-    {
-        move_to_top(data, idx);
-        run_command(data, PA);
-        run_command(data, RA);
-    }
-    else if (pos < (data->a->size + 1) / 2)
-    {
-        i = pos;
-        while (i--)
-            run_command(data, RA);
-        move_to_top(data, idx);
-        run_command(data, PA);
-        i = pos;
-        while (i--)
-            run_command(data, RRA);
-    }
-    else
-    {
-        i = data->a->size - pos;
-        while (i--)
-            run_command(data, RRA);
-        move_to_top(data, idx);
-        run_command(data, PA);
-        i = data->a->size - pos;
-        while (i--)
-            run_command(data, RA);
-    }
+	pos = 0;
+	while (pos < data->a->size && data->b->stack[0] > data->a->stack[pos])
+		pos++;
+	if (pos >= data->a->size)
+	{
+		move_to_top(data, idx);
+		run_command(data, PA);
+		run_command(data, RA);
+	}
+	else if (pos < (data->a->size + 1) / 2)
+	{
+		i = pos;
+		while (i--)
+			run_command(data, RA);
+		move_to_top(data, idx);
+		run_command(data, PA);
+		i = pos;
+		while (i--)
+			run_command(data, RRA);
+	}
+	else
+	{
+		i = data->a->size - pos;
+		while (i--)
+			run_command(data, RRA);
+		move_to_top(data, idx);
+		run_command(data, PA);
+		i = data->a->size - pos;
+		while (i--)
+			run_command(data, RA);
+	}
 }
 
-static void scoresort(t_psdata *data)
+static void	scoresort(t_psdata *data)
 {
-    int *scores;
-    int i;
-    int min_score;
-
-    scores = malloc(sizeof(int) * data->b->size);
-    // Error if allocation fails
-    i = 0;
-    while (i < data->b->size)
-    {
-        scores[i] = calculate_score(data, i);
-        i++;
-    }
-    i = 0;
-    min_score = 0;
-    while (i < data->b->size)
-    {
-        if (scores[i] < scores[min_score])
-            min_score = i;
-        i++;
-    }
-    move_to_spot(data, min_score);
+	int	*scores;
+	int	i;
+	int	min_score;
 
-    free(scores);
-    if (data->b->size > 0)
-        scoresort(data);
+	scores = malloc(sizeof(int) * data->b->size);
+	// Error if allocation fails
+	i = 0;
+	while (i < data->b->size)
+	{
+		scores[i] = calculate_score(data, i);
+		i++;
+	}
+	i = 0;
+	min_score = 0;
+	while (i < data->b->size)
+	{
+		if (scores[i] < scores[min_score])
+			min_score = i;
+		i++;
+	}
+	move_to_spot(data, min_score);
+	free(scores);
+	if (data->b->size > 0)
+		scoresort(data);
 }
 
-void stack_sort(t_psdata *data)
+void	stack_sort(t_psdata *data)
 {
-    presort(data);
-    scoresort(data);
+	presort(data);
+	scoresort(data);
 }
diff --git a/stack_optimization.c b/stack_optimization.c
index eabf04a..2ddd104 100644
--- a/stack_optimization.c
+++ b/stack_optimization.c
@@ -6,36 +6,35 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/13 15:25:05 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/15 16:20:51 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/24 10:58:36 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "push_swap.h"
 #include <stdlib.h>
 
-static int *copy_stack(int *stack, int size)
+static int	*copy_stack(int *stack, int size)
 {
-	int i;
-	int *cpy;
+	int	i;
+	int	*cpy;
 
 	cpy = malloc(sizeof(int) * size);
 	if (!cpy)
-		return NULL;
+		return (NULL);
 	i = 0;
 	while (i < size)
 	{
 		cpy[i] = stack[i];
 		i++;
 	}
-
-	return cpy;
+	return (cpy);
 }
 
-static void sort_stack(int *stack, int size)
+static void	sort_stack(int *stack, int size)
 {
-	int i;
-	int k;
-	int tmp;
+	int	i;
+	int	k;
+	int	tmp;
 
 	i = 0;
 	while (i < size - 1)
@@ -55,10 +54,10 @@ static void sort_stack(int *stack, int size)
 	}
 }
 
-static void override_stack(int *stack, int *tmp_stack, int size)
+static void	override_stack(int *stack, int *tmp_stack, int size)
 {
-	int i;
-	int k;
+	int	i;
+	int	k;
 
 	i = 0;
 	while (i < size)
@@ -73,13 +72,13 @@ static void override_stack(int *stack, int *tmp_stack, int size)
 
 int	stack_optimize(t_stack *stack)
 {
-	int *tmp_stack;
+	int	*tmp_stack;
 
 	tmp_stack = copy_stack(stack->stack, stack->size);
 	if (!tmp_stack)
-		return 1;
+		return (1);
 	sort_stack(tmp_stack, stack->size);
 	override_stack(stack->stack, tmp_stack, stack->size);
 	free(tmp_stack);
-	return 0;
+	return (0);
 }
diff --git a/stack_utils.c b/stack_utils.c
index f240395..4c0dd31 100644
--- a/stack_utils.c
+++ b/stack_utils.c
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/12 20:31:30 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/15 21:53:40 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/24 10:58:30 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,7 +14,7 @@
 
 void	stack_swap(t_stack *stack)
 {
-	int tmp;
+	int	tmp;
 
 	if (stack->size > 1)
 	{
@@ -26,12 +26,12 @@ void	stack_swap(t_stack *stack)
 
 void	stack_push(t_stack *dst_stack, t_stack *src_stack)
 {
-	int i;
+	int	i;
 
 	i = dst_stack->size;
 	while (i > 0)
 	{
-		dst_stack->stack[i] = dst_stack->stack[i-1];
+		dst_stack->stack[i] = dst_stack->stack[i - 1];
 		i--;
 	}
 	dst_stack->stack[0] = src_stack->stack[0];
@@ -39,7 +39,7 @@ void	stack_push(t_stack *dst_stack, t_stack *src_stack)
 	i = 1;
 	while (i < src_stack->size)
 	{
-		src_stack->stack[i-1] = src_stack->stack[i];
+		src_stack->stack[i - 1] = src_stack->stack[i];
 		i++;
 	}
 	src_stack->size--;
@@ -47,37 +47,37 @@ void	stack_push(t_stack *dst_stack, t_stack *src_stack)
 
 void	stack_rotate(t_stack *stack)
 {
-	int tmp;
-	int i;
+	int	tmp;
+	int	i;
 
 	tmp = stack->stack[0];
 	i = 1;
 	while (i < stack->size)
 	{
-		stack->stack[i-1] = stack->stack[i];
+		stack->stack[i - 1] = stack->stack[i];
 		i++;
 	}
-	stack->stack[i-1] = tmp;
+	stack->stack[i - 1] = tmp;
 }
 
 void	stack_rrotate(t_stack *stack)
 {
-	int tmp;
-	int i;
+	int	tmp;
+	int	i;
 
 	i = stack->size - 1;
 	tmp = stack->stack[i];
 	while (i > 0)
 	{
-		stack->stack[i] = stack->stack[i-1];
+		stack->stack[i] = stack->stack[i - 1];
 		i--;
 	}
 	stack->stack[0] = tmp;
 }
 
-void stack_print(t_stack *stack)
+void	stack_print(t_stack *stack)
 {
-	int i;
+	int	i;
 
 	i = 0;
 	while (i < stack->size)
-- 
2.47.2