diff --git a/lib/cursor.c b/lib/cursor.c
index d04bbef..77e0817 100644
--- a/lib/cursor.c
+++ b/lib/cursor.c
@@ -48,25 +48,25 @@ void move_cursor(struct cursor *cursor, enum movement movement) {
       erase_cursor(cursor);
       switch (cursor->x - 3) {
       case MANEUVRE_0_BEGIN_X:
-        cursor->y = cursor->y + 7 + length(deck->maneuvre_0);
+        cursor->y = cursor->y + 7 + length(deck->maneuvre[0]);
         break;
       case MANEUVRE_1_BEGIN_X:
-        cursor->y = cursor->y + 7 + length(deck->maneuvre_1);
+        cursor->y = cursor->y + 7 + length(deck->maneuvre[1]);
         break;
       case MANEUVRE_2_BEGIN_X:
-        cursor->y = cursor->y + 7 + length(deck->maneuvre_2);
+        cursor->y = cursor->y + 7 + length(deck->maneuvre[2]);
         break;
       case MANEUVRE_3_BEGIN_X:
-        cursor->y = cursor->y + 7 + length(deck->maneuvre_3);
+        cursor->y = cursor->y + 7 + length(deck->maneuvre[3]);
         break;
       case MANEUVRE_4_BEGIN_X:
-        cursor->y = cursor->y + 7 + length(deck->maneuvre_4);
+        cursor->y = cursor->y + 7 + length(deck->maneuvre[4]);
         break;
       case MANEUVRE_5_BEGIN_X:
-        cursor->y = cursor->y + 7 + length(deck->maneuvre_5);
+        cursor->y = cursor->y + 7 + length(deck->maneuvre[5]);
         break;
       case MANEUVRE_6_BEGIN_X:
-        cursor->y = cursor->y + 7 + length(deck->maneuvre_6);
+        cursor->y = cursor->y + 7 + length(deck->maneuvre[6]);
         break;
       }
     }
diff --git a/lib/deck.c b/lib/deck.c
index 5639b17..61ed3f8 100644
--- a/lib/deck.c
+++ b/lib/deck.c
@@ -14,55 +14,35 @@ void allocate_deck(struct deck **deck) {
 
   allocate_stack(&((*deck)->stock));
   allocate_stack(&((*deck)->waste_pile));
-
-  allocate_stack(&((*deck)->foundation_0));
-  allocate_stack(&((*deck)->foundation_1));
-  allocate_stack(&((*deck)->foundation_2));
-  allocate_stack(&((*deck)->foundation_3));
-
-  allocate_stack(&((*deck)->maneuvre_0));
-  allocate_stack(&((*deck)->maneuvre_1));
-  allocate_stack(&((*deck)->maneuvre_2));
-  allocate_stack(&((*deck)->maneuvre_3));
-  allocate_stack(&((*deck)->maneuvre_4));
-  allocate_stack(&((*deck)->maneuvre_5));
-  allocate_stack(&((*deck)->maneuvre_6));
+  for (int i = 0; i < 4; i++) {
+    allocate_stack(&((*deck)->foundation[i]));
+  }
+  for (int i = 0; i < 7; i++) {
+    allocate_stack(&((*deck)->maneuvre[i]));
+  }
 }
 
 void initialize_deck(struct deck *deck) {
   initialize_stack(deck->stock);
   initialize_stack(deck->waste_pile);
-
-  initialize_stack(deck->foundation_0);
-  initialize_stack(deck->foundation_1);
-  initialize_stack(deck->foundation_2);
-  initialize_stack(deck->foundation_3);
-
-  initialize_stack(deck->maneuvre_0);
-  initialize_stack(deck->maneuvre_1);
-  initialize_stack(deck->maneuvre_2);
-  initialize_stack(deck->maneuvre_3);
-  initialize_stack(deck->maneuvre_4);
-  initialize_stack(deck->maneuvre_5);
-  initialize_stack(deck->maneuvre_6);
+  for (int i = 0; i < 4; i++) {
+    initialize_stack(deck->foundation[i]);
+  }
+  for (int i = 0; i < 7; i++) {
+    initialize_stack(deck->maneuvre[i]);
+  }
 }
 
 void free_deck(struct deck *deck) {
   if (deck) {
+    free_stack(deck->stock);
     free_stack(deck->waste_pile);
-
-    free_stack(deck->foundation_0);
-    free_stack(deck->foundation_1);
-    free_stack(deck->foundation_2);
-    free_stack(deck->foundation_3);
-
-    free_stack(deck->maneuvre_0);
-    free_stack(deck->maneuvre_1);
-    free_stack(deck->maneuvre_2);
-    free_stack(deck->maneuvre_3);
-    free_stack(deck->maneuvre_4);
-    free_stack(deck->maneuvre_5);
-    free_stack(deck->maneuvre_6);
+    for (int i = 0; i < 4; i++) {
+      free_stack(deck->foundation[i]);
+    }
+    for (int i = 0; i < 7; i++) {
+      free_stack(deck->maneuvre[i]);
+    }
   }
   free(deck);
 }
diff --git a/lib/deck.h b/lib/deck.h
index 2107cfe..ff6789d 100644
--- a/lib/deck.h
+++ b/lib/deck.h
@@ -6,19 +6,8 @@
 struct deck {
   struct stack *stock;
   struct stack *waste_pile;
-
-  struct stack *foundation_0;
-  struct stack *foundation_1;
-  struct stack *foundation_2;
-  struct stack *foundation_3;
-
-  struct stack *maneuvre_0;
-  struct stack *maneuvre_1;
-  struct stack *maneuvre_2;
-  struct stack *maneuvre_3;
-  struct stack *maneuvre_4;
-  struct stack *maneuvre_5;
-  struct stack *maneuvre_6;
+  struct stack *foundation[4];
+  struct stack *maneuvre[7];
 };
 
 void allocate_deck(struct deck **);
diff --git a/lib/display.c b/lib/display.c
index 8852d36..41a50e3 100644
--- a/lib/display.c
+++ b/lib/display.c
@@ -135,19 +135,12 @@ void draw_stack(struct stack *stack) {
 void draw_deck(struct deck *deck) {
   draw_stack(deck->stock);
   draw_stack(deck->waste_pile);
-
-  draw_stack(deck->foundation_0);
-  draw_stack(deck->foundation_1);
-  draw_stack(deck->foundation_2);
-  draw_stack(deck->foundation_3);
-
-  draw_stack(deck->maneuvre_0);
-  draw_stack(deck->maneuvre_1);
-  draw_stack(deck->maneuvre_2);
-  draw_stack(deck->maneuvre_3);
-  draw_stack(deck->maneuvre_4);
-  draw_stack(deck->maneuvre_5);
-  draw_stack(deck->maneuvre_6);
+  for (int i = 0; i < 4; i++) {
+    draw_stack(deck->foundation[i]);
+  }
+  for (int i = 0; i < 7; i++) {
+    draw_stack(deck->maneuvre[i]);
+  }
 }
 
 void draw_cursor(struct cursor *cursor) {
diff --git a/lib/game.c b/lib/game.c
index e8f35f8..c79d6ad 100644
--- a/lib/game.c
+++ b/lib/game.c
@@ -4,42 +4,67 @@
 #include <string.h>
 #include <errno.h>
 #include <time.h>
+#include <assert.h>
+
 #include "display.h"
 #include "curses.h"
 #include "common.h"
 #include "game.h"
 
+int foundation_begin_x(int x) {
+  switch (x) {
+  case 0: return(FOUNDATION_0_BEGIN_X); break;
+  case 1: return(FOUNDATION_1_BEGIN_X); break;
+  case 2: return(FOUNDATION_2_BEGIN_X); break;
+  case 3: return(FOUNDATION_3_BEGIN_X); break;
+  default: assert(false && "foundation_begin_x called x < 0 || x > 3");
+  }
+}
+
+int maneuvre_begin_x(int x) {
+  switch (x) {
+  case 0: return(MANEUVRE_0_BEGIN_X); break;
+  case 1: return(MANEUVRE_1_BEGIN_X); break;
+  case 2: return(MANEUVRE_2_BEGIN_X); break;
+  case 3: return(MANEUVRE_3_BEGIN_X); break;
+  case 4: return(MANEUVRE_4_BEGIN_X); break;
+  case 5: return(MANEUVRE_5_BEGIN_X); break;
+  case 6: return(MANEUVRE_6_BEGIN_X); break;
+  default: assert(false && "maneuvre_begin_x called x < 0 || x > 6");
+  }
+}
+
 bool stock_stack(struct stack *stack) {
   return(stack && stack->card && stack->card->frame &&
-         (stack->card->frame->begin_y == STOCK_BEGIN_Y) &&
-         (stack->card->frame->begin_x == STOCK_BEGIN_X));
+           (stack->card->frame->begin_y == STOCK_BEGIN_Y) &&
+           (stack->card->frame->begin_x == STOCK_BEGIN_X));
 }
 
 bool waste_pile_stack(struct stack *stack) {
   return(stack && stack->card && stack->card->frame &&
-         (stack->card->frame->begin_y == WASTE_PILE_BEGIN_Y) &&
-         (stack->card->frame->begin_x == WASTE_PILE_BEGIN_X));
+           (stack->card->frame->begin_y == WASTE_PILE_BEGIN_Y) &&
+           (stack->card->frame->begin_x == WASTE_PILE_BEGIN_X));
 }
 
 bool foundation_stack(struct stack *stack) {
   return(stack && stack->card && stack->card->frame &&
-         stack->card->frame->begin_y == FOUNDATION_BEGIN_Y &&
-         (stack->card->frame->begin_x == FOUNDATION_0_BEGIN_X ||
-          stack->card->frame->begin_x == FOUNDATION_1_BEGIN_X ||
-          stack->card->frame->begin_x == FOUNDATION_2_BEGIN_X ||
-          stack->card->frame->begin_x == FOUNDATION_3_BEGIN_X));
+           stack->card->frame->begin_y == FOUNDATION_BEGIN_Y &&
+           (stack->card->frame->begin_x == FOUNDATION_0_BEGIN_X ||
+              stack->card->frame->begin_x == FOUNDATION_1_BEGIN_X ||
+              stack->card->frame->begin_x == FOUNDATION_2_BEGIN_X ||
+              stack->card->frame->begin_x == FOUNDATION_3_BEGIN_X));
 }
 
 bool maneuvre_stack(struct stack *stack) {
   return(stack && stack->card && stack->card->frame &&
-         stack->card->frame->begin_y >= MANEUVRE_BEGIN_Y &&
-         (stack->card->frame->begin_x == MANEUVRE_0_BEGIN_X ||
-          stack->card->frame->begin_x == MANEUVRE_1_BEGIN_X ||
-          stack->card->frame->begin_x == MANEUVRE_2_BEGIN_X ||
-          stack->card->frame->begin_x == MANEUVRE_3_BEGIN_X ||
-          stack->card->frame->begin_x == MANEUVRE_4_BEGIN_X ||
-          stack->card->frame->begin_x == MANEUVRE_5_BEGIN_X ||
-          stack->card->frame->begin_x == MANEUVRE_6_BEGIN_X));
+           stack->card->frame->begin_y >= MANEUVRE_BEGIN_Y &&
+           (stack->card->frame->begin_x == MANEUVRE_0_BEGIN_X ||
+              stack->card->frame->begin_x == MANEUVRE_1_BEGIN_X ||
+              stack->card->frame->begin_x == MANEUVRE_2_BEGIN_X ||
+              stack->card->frame->begin_x == MANEUVRE_3_BEGIN_X ||
+              stack->card->frame->begin_x == MANEUVRE_4_BEGIN_X ||
+              stack->card->frame->begin_x == MANEUVRE_5_BEGIN_X ||
+              stack->card->frame->begin_x == MANEUVRE_6_BEGIN_X));
 }
 
 bool valid_move(struct stack *origin, struct stack *destination) {
@@ -88,80 +113,24 @@ void move_card(struct stack **origin, struct stack **destination) {
 static void set_stacks_initial_coordinates(struct deck *deck) {
   set_frame(deck->stock->card->frame, STOCK_BEGIN_Y, STOCK_BEGIN_X);
   set_frame(deck->waste_pile->card->frame, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);
-  set_frame(deck->foundation_0->card->frame, FOUNDATION_BEGIN_Y, FOUNDATION_0_BEGIN_X);
-  set_frame(deck->foundation_1->card->frame, FOUNDATION_BEGIN_Y, FOUNDATION_1_BEGIN_X);
-  set_frame(deck->foundation_2->card->frame, FOUNDATION_BEGIN_Y, FOUNDATION_2_BEGIN_X);
-  set_frame(deck->foundation_3->card->frame, FOUNDATION_BEGIN_Y, FOUNDATION_3_BEGIN_X);
-  set_frame(deck->maneuvre_0->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);
-  set_frame(deck->maneuvre_1->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);
-  set_frame(deck->maneuvre_2->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);
-  set_frame(deck->maneuvre_3->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);
-  set_frame(deck->maneuvre_4->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);
-  set_frame(deck->maneuvre_5->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);
-  set_frame(deck->maneuvre_6->card->frame, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);
+  for (int i = 0; i < 4; i++) {
+    set_frame(deck->foundation[i]->card->frame, FOUNDATION_BEGIN_Y, foundation_begin_x(i));
+  }
+  for (int i = 0; i < 7; i++) {
+    set_frame(deck->maneuvre[i]->card->frame, MANEUVRE_BEGIN_Y, maneuvre_begin_x(i));
+  }
 }
 
 static void fill_deck(struct deck *deck) {
   struct card *card[NUMBER_OF_CARDS];
 
-  for (int i = 0; i < NUMBER_OF_CARDS; i++) {
-    allocate_card(&(card[i]));
-  }
-  set_card(card[0], TWO, DIAMONDS, COVERED, 1, 1);
-  set_card(card[1], TWO, SPADES, COVERED, 1, 1);
-  set_card(card[2], TWO, HEARTS, COVERED, 1, 1);
-  set_card(card[3], TWO, CLUBS, COVERED, 1, 1);
-  set_card(card[4], THREE, DIAMONDS, COVERED, 1, 1);
-  set_card(card[5], THREE, SPADES, COVERED, 1, 1);
-  set_card(card[6], THREE, HEARTS, COVERED, 1, 1);
-  set_card(card[7], THREE, CLUBS, COVERED, 1, 1);
-  set_card(card[8], FOUR, DIAMONDS, COVERED, 1, 1);
-  set_card(card[9], FOUR, SPADES, COVERED, 1, 1);
-  set_card(card[10], FOUR, HEARTS, COVERED, 1, 1);
-  set_card(card[11], FOUR, CLUBS, COVERED, 1, 1);
-  set_card(card[12], FIVE, DIAMONDS, COVERED, 1, 1);
-  set_card(card[13], FIVE, SPADES, COVERED, 1, 1);
-  set_card(card[14], FIVE, HEARTS, COVERED, 1, 1);
-  set_card(card[15], FIVE, CLUBS, COVERED, 1, 1);
-  set_card(card[16], SIX, DIAMONDS, COVERED, 1, 1);
-  set_card(card[17], SIX, SPADES, COVERED, 1, 1);
-  set_card(card[18], SIX, HEARTS, COVERED, 1, 1);
-  set_card(card[19], SIX, CLUBS, COVERED, 1, 1);
-  set_card(card[20], SEVEN, DIAMONDS, COVERED, 1, 1);
-  set_card(card[21], SEVEN, SPADES, COVERED, 1, 1);
-  set_card(card[22], SEVEN, HEARTS, COVERED, 1, 1);
-  set_card(card[23], SEVEN, CLUBS, COVERED, 1, 1);
-  set_card(card[24], EIGHT, DIAMONDS, COVERED, 1, 1);
-  set_card(card[25], EIGHT, SPADES, COVERED, 1, 1);
-  set_card(card[26], EIGHT, HEARTS, COVERED, 1, 1);
-  set_card(card[27], EIGHT, CLUBS, COVERED, 1, 1);
-  set_card(card[28], NINE, DIAMONDS, COVERED, 1, 1);
-  set_card(card[29], NINE, SPADES, COVERED, 1, 1);
-  set_card(card[30], NINE, HEARTS, COVERED, 1, 1);
-  set_card(card[31], NINE, CLUBS, COVERED, 1, 1);
-  set_card(card[32], TEN, DIAMONDS, COVERED, 1, 1);
-  set_card(card[33], TEN, SPADES, COVERED, 1, 1);
-  set_card(card[34], TEN, HEARTS, COVERED, 1, 1);
-  set_card(card[35], TEN, CLUBS, COVERED, 1, 1);
-  set_card(card[36], JACK, DIAMONDS, COVERED, 1, 1);
-  set_card(card[37], JACK, SPADES, COVERED, 1, 1);
-  set_card(card[38], JACK, HEARTS, COVERED, 1, 1);
-  set_card(card[39], JACK, CLUBS, COVERED, 1, 1);
-  set_card(card[40], QUEEN, DIAMONDS, COVERED, 1, 1);
-  set_card(card[41], QUEEN, SPADES, COVERED, 1, 1);
-  set_card(card[42], QUEEN, HEARTS, COVERED, 1, 1);
-  set_card(card[43], QUEEN, CLUBS, COVERED, 1, 1);
-  set_card(card[44], KING, DIAMONDS, COVERED, 1, 1);
-  set_card(card[45], KING, SPADES, COVERED, 1, 1);
-  set_card(card[46], KING, HEARTS, COVERED, 1, 1);
-  set_card(card[47], KING, CLUBS, COVERED, 1, 1);
-  set_card(card[48], ACE, DIAMONDS, COVERED, 1, 1);
-  set_card(card[49], ACE, SPADES, COVERED, 1, 1);
-  set_card(card[50], ACE, HEARTS, COVERED, 1, 1);
-  set_card(card[51], ACE, CLUBS, COVERED, 1, 1);
-
-  for (int i = 0; i < NUMBER_OF_CARDS; i++) {
-    push(&(deck->stock), card[i]);
+  for (int i = TWO; i <= ACE; i++) {
+    for (int j = DIAMONDS; j <= CLUBS; j++) {
+      int index = 4 * (i - TWO) + j;
+      allocate_card(&(card[index]));
+      set_card(card[index], i, j, COVERED, 1, 1);
+      push(&(deck->stock), card[index]);
+    }
   }
 }
 
@@ -193,47 +162,13 @@ static void shuffle_deck(struct deck *deck) {
 }
 
 static void deal_cards(struct deck *deck) {
-  move_card(&(deck->stock), &(deck->maneuvre_0));
-  expose_card(deck->maneuvre_0->card);
-  move_card(&(deck->stock), &(deck->maneuvre_1));
-  move_card(&(deck->stock), &(deck->maneuvre_2));
-  move_card(&(deck->stock), &(deck->maneuvre_3));
-  move_card(&(deck->stock), &(deck->maneuvre_4));
-  move_card(&(deck->stock), &(deck->maneuvre_5));
-  move_card(&(deck->stock), &(deck->maneuvre_6));
-
-  move_card(&(deck->stock), &(deck->maneuvre_1));
-  expose_card(deck->maneuvre_1->card);
-  move_card(&(deck->stock), &(deck->maneuvre_2));
-  move_card(&(deck->stock), &(deck->maneuvre_3));
-  move_card(&(deck->stock), &(deck->maneuvre_4));
-  move_card(&(deck->stock), &(deck->maneuvre_5));
-  move_card(&(deck->stock), &(deck->maneuvre_6));
-
-  move_card(&(deck->stock), &(deck->maneuvre_2));
-  expose_card(deck->maneuvre_2->card);
-  move_card(&(deck->stock), &(deck->maneuvre_3));
-  move_card(&(deck->stock), &(deck->maneuvre_4));
-  move_card(&(deck->stock), &(deck->maneuvre_5));
-  move_card(&(deck->stock), &(deck->maneuvre_6));
-
-  move_card(&(deck->stock), &(deck->maneuvre_3));
-  expose_card(deck->maneuvre_3->card);
-  move_card(&(deck->stock), &(deck->maneuvre_4));
-  move_card(&(deck->stock), &(deck->maneuvre_5));
-  move_card(&(deck->stock), &(deck->maneuvre_6));
-
-  move_card(&(deck->stock), &(deck->maneuvre_4));
-  expose_card(deck->maneuvre_4->card);
-  move_card(&(deck->stock), &(deck->maneuvre_5));
-  move_card(&(deck->stock), &(deck->maneuvre_6));
-
-  move_card(&(deck->stock), &(deck->maneuvre_5));
-  expose_card(deck->maneuvre_5->card);
-  move_card(&(deck->stock), &(deck->maneuvre_6));
-
-  move_card(&(deck->stock), &(deck->maneuvre_6));
-  expose_card(deck->maneuvre_6->card);
+  for (int i = 0; i < 7; i++) {
+    move_card(&(deck->stock), &(deck->maneuvre[i]));
+    expose_card(deck->maneuvre[i]->card);
+    for (int j = i + 1; j < 7; j++) {
+      move_card(&(deck->stock), &(deck->maneuvre[j]));
+    }
+  }
 }
 
 void greet_player() {
diff --git a/lib/game.h b/lib/game.h
index a10e1b0..fd714bf 100644
--- a/lib/game.h
+++ b/lib/game.h
@@ -31,6 +31,8 @@
 struct deck *deck;
 struct cursor *cursor;
 
+int foundation_begin_x(int);
+int maneuvre_begin_x(int);
 bool valid_move(struct stack *, struct stack *);
 bool maneuvre_stack(struct stack *);
 void move_card(struct stack **, struct stack **);
diff --git a/lib/keyboard.c b/lib/keyboard.c
index 5cfc3f0..01c03dc 100644
--- a/lib/keyboard.c
+++ b/lib/keyboard.c
@@ -16,20 +16,20 @@ static struct stack *cursor_stack(struct cursor *cursor) {
     switch (cursor->x) {
     case CURSOR_STOCK_X:        cursor_stack = deck->stock;        break;
     case CURSOR_WASTE_PILE_X:   cursor_stack = deck->waste_pile;   break;
-    case CURSOR_FOUNDATION_0_X: cursor_stack = deck->foundation_0; break;
-    case CURSOR_FOUNDATION_1_X: cursor_stack = deck->foundation_1; break;
-    case CURSOR_FOUNDATION_2_X: cursor_stack = deck->foundation_2; break;
-    case CURSOR_FOUNDATION_3_X: cursor_stack = deck->foundation_3; break;
+    case CURSOR_FOUNDATION_0_X: cursor_stack = deck->foundation[0]; break;
+    case CURSOR_FOUNDATION_1_X: cursor_stack = deck->foundation[1]; break;
+    case CURSOR_FOUNDATION_2_X: cursor_stack = deck->foundation[2]; break;
+    case CURSOR_FOUNDATION_3_X: cursor_stack = deck->foundation[3]; break;
     }
   } else {
     switch (cursor->x) {
-    case CURSOR_MANEUVRE_0_X: cursor_stack = deck->maneuvre_0; break;
-    case CURSOR_MANEUVRE_1_X: cursor_stack = deck->maneuvre_1; break;
-    case CURSOR_MANEUVRE_2_X: cursor_stack = deck->maneuvre_2; break;
-    case CURSOR_MANEUVRE_3_X: cursor_stack = deck->maneuvre_3; break;
-    case CURSOR_MANEUVRE_4_X: cursor_stack = deck->maneuvre_4; break;
-    case CURSOR_MANEUVRE_5_X: cursor_stack = deck->maneuvre_5; break;
-    case CURSOR_MANEUVRE_6_X: cursor_stack = deck->maneuvre_6; break;
+    case CURSOR_MANEUVRE_0_X: cursor_stack = deck->maneuvre[0]; break;
+    case CURSOR_MANEUVRE_1_X: cursor_stack = deck->maneuvre[1]; break;
+    case CURSOR_MANEUVRE_2_X: cursor_stack = deck->maneuvre[2]; break;
+    case CURSOR_MANEUVRE_3_X: cursor_stack = deck->maneuvre[3]; break;
+    case CURSOR_MANEUVRE_4_X: cursor_stack = deck->maneuvre[4]; break;
+    case CURSOR_MANEUVRE_5_X: cursor_stack = deck->maneuvre[5]; break;
+    case CURSOR_MANEUVRE_6_X: cursor_stack = deck->maneuvre[6]; break;
     }
   }