diff --git a/lib/card.c b/lib/card.c
index 06a41ef..84a624b 100644
--- a/lib/card.c
+++ b/lib/card.c
@@ -30,8 +30,8 @@ struct card *duplicate_card(struct card *card) {
            card->value,
            card->suit,
            card->face,
-           card->frame->start_y,
-           card->frame->start_x);
+           card->frame->begin_y,
+           card->frame->begin_x);
 
   return(new_card);
 }
@@ -47,9 +47,9 @@ void set_card(struct card *card,
               enum value value,
               enum suit suit,
               enum face face,
-              int start_y,
-              int start_x) {
-  set_frame(card->frame, start_y, start_x);
+              int begin_y,
+              int begin_x) {
+  set_frame(card->frame, begin_y, begin_x);
   card->value = value;
   card->suit = suit;
   card->face = face;
diff --git a/lib/cursor.c b/lib/cursor.c
index 10620cd..081f88c 100644
--- a/lib/cursor.c
+++ b/lib/cursor.c
@@ -17,17 +17,17 @@ void allocate_cursor(struct cursor **cursor) {
 }
 
 void initialize_cursor(struct cursor *cursor) {
-  cursor->x = CURSOR_STARTING_X;
-  cursor->y = CURSOR_STARTING_Y;
+  cursor->x = CURSOR_BEGIN_X;
+  cursor->y = CURSOR_BEGIN_Y;
 }
 
 void move_cursor(struct cursor *cursor, enum movement movement) {
   switch (movement) {
   case LEFT:
-    if (cursor->x > CURSOR_STARTING_X) {
+    if (cursor->x > CURSOR_BEGIN_X) {
       erase_cursor(cursor);
       cursor->x = cursor->x - 8;
-      if (cursor->y > CURSOR_STARTING_Y) {
+      if (cursor->y > CURSOR_BEGIN_Y) {
         move_cursor(cursor, UP);
         move_cursor(cursor, DOWN);
       }
@@ -35,28 +35,28 @@ void move_cursor(struct cursor *cursor, enum movement movement) {
     }
     break;
   case DOWN:
-    if (cursor->y == CURSOR_STARTING_Y) {
+    if (cursor->y == CURSOR_BEGIN_Y) {
       erase_cursor(cursor);
       switch (cursor->x - 3) {
-      case MANEUVRE_0_STARTING_X:
+      case MANEUVRE_0_BEGIN_X:
         cursor->y = cursor->y + 7 + length(deck->maneuvre_0);
         break;
-      case MANEUVRE_1_STARTING_X:
+      case MANEUVRE_1_BEGIN_X:
         cursor->y = cursor->y + 7 + length(deck->maneuvre_1);
         break;
-      case MANEUVRE_2_STARTING_X:
+      case MANEUVRE_2_BEGIN_X:
         cursor->y = cursor->y + 7 + length(deck->maneuvre_2);
         break;
-      case MANEUVRE_3_STARTING_X:
+      case MANEUVRE_3_BEGIN_X:
         cursor->y = cursor->y + 7 + length(deck->maneuvre_3);
         break;
-      case MANEUVRE_4_STARTING_X:
+      case MANEUVRE_4_BEGIN_X:
         cursor->y = cursor->y + 7 + length(deck->maneuvre_4);
         break;
-      case MANEUVRE_5_STARTING_X:
+      case MANEUVRE_5_BEGIN_X:
         cursor->y = cursor->y + 7 + length(deck->maneuvre_5);
         break;
-      case MANEUVRE_6_STARTING_X:
+      case MANEUVRE_6_BEGIN_X:
         cursor->y = cursor->y + 7 + length(deck->maneuvre_6);
         break;
       }
@@ -67,7 +67,7 @@ void move_cursor(struct cursor *cursor, enum movement movement) {
     if (cursor->x < 49) {
       erase_cursor(cursor);
       cursor->x = cursor->x + 8;
-      if (cursor->y > CURSOR_STARTING_Y) {
+      if (cursor->y > CURSOR_BEGIN_Y) {
         move_cursor(cursor, UP);
         move_cursor(cursor, DOWN);
       }
@@ -77,7 +77,7 @@ void move_cursor(struct cursor *cursor, enum movement movement) {
   case UP:
     if (cursor->y > 1) {
       erase_cursor(cursor);
-      cursor->y = CURSOR_STARTING_Y;
+      cursor->y = CURSOR_BEGIN_Y;
       draw_cursor(cursor);
     }
     break;
diff --git a/lib/cursor.h b/lib/cursor.h
index 3d0c499..58208b5 100644
--- a/lib/cursor.h
+++ b/lib/cursor.h
@@ -4,8 +4,8 @@
 #include <stdbool.h>
 #include "deck.h"
 
-#define CURSOR_STARTING_X 4
-#define CURSOR_STARTING_Y 7
+#define CURSOR_BEGIN_X 4
+#define CURSOR_BEGIN_Y 7
 
 #define CURSOR_INVALID_SPOT_X 20
 #define CURSOR_INVALID_SPOT_Y 7
diff --git a/lib/display.c b/lib/display.c
index fa97ddb..73a6863 100644
--- a/lib/display.c
+++ b/lib/display.c
@@ -62,8 +62,8 @@ void erase_stack(struct stack *stack) {
   wrefresh(stack->card->frame->shape);
   empty_stack = newwin(FRAME_HEIGHT,
                        FRAME_WIDTH,
-                       stack->card->frame->start_y,
-                       stack->card->frame->start_x);
+                       stack->card->frame->begin_y,
+                       stack->card->frame->begin_x);
   box(empty_stack, 0, 0);
   wrefresh(empty_stack);
   delwin(empty_stack);
@@ -105,7 +105,7 @@ void draw_back(struct card *card) {
 }
 
 void draw_card(struct card *card) {
-  mvwin(card->frame->shape, card->frame->start_y, card->frame->start_x);
+  mvwin(card->frame->shape, card->frame->begin_y, card->frame->begin_x);
   if (card->face == EXPOSED) {
     draw_front(card);
   } else {
@@ -119,8 +119,8 @@ void draw_stack(struct stack *stack) {
   if (empty(stack)) {
     WINDOW *empty_stack = newwin(FRAME_HEIGHT,
                                  FRAME_WIDTH,
-                                 stack->card->frame->start_y,
-                                 stack->card->frame->start_x);
+                                 stack->card->frame->begin_y,
+                                 stack->card->frame->begin_x);
     box(empty_stack, 0, 0);
     wrefresh(empty_stack);
     delwin(empty_stack);
diff --git a/lib/frame.c b/lib/frame.c
index fd52903..041f15c 100644
--- a/lib/frame.c
+++ b/lib/frame.c
@@ -15,15 +15,15 @@ void allocate_frame(struct frame **frame) {
 
 void initialize_frame(struct frame *frame) {
   frame->shape   = NULL;
-  frame->start_y = 0;
-  frame->start_x = 0;
+  frame->begin_y = 0;
+  frame->begin_x = 0;
 }
 
 struct frame *duplicate_frame(struct frame *frame) {
   struct frame *new_frame;
 
   allocate_frame(&new_frame);
-  set_frame(new_frame, frame->start_y, frame->start_x);
+  set_frame(new_frame, frame->begin_y, frame->begin_x);
 
   return(new_frame);
 }
@@ -35,11 +35,11 @@ void free_frame(struct frame *frame) {
   free(frame);
 }
 
-void set_frame(struct frame *frame, int start_y, int start_x) {
-  frame->start_y = start_y;
-  frame->start_x = start_x;
+void set_frame(struct frame *frame, int begin_y, int begin_x) {
+  frame->begin_y = begin_y;
+  frame->begin_x = begin_x;
   frame->shape = newwin(FRAME_HEIGHT,
                         FRAME_WIDTH,
-                        frame->start_y,
-                        frame->start_x);
+                        frame->begin_y,
+                        frame->begin_x);
 }
diff --git a/lib/frame.h b/lib/frame.h
index c519400..bfbce89 100644
--- a/lib/frame.h
+++ b/lib/frame.h
@@ -8,8 +8,8 @@
 
 struct frame {
   WINDOW *shape;
-  int    start_y;
-  int    start_x;
+  int    begin_y;
+  int    begin_x;
 };
 
 void allocate_frame(struct frame **);
diff --git a/lib/game.c b/lib/game.c
index 427e253..0c76873 100644
--- a/lib/game.c
+++ b/lib/game.c
@@ -11,35 +11,35 @@
 
 bool stock_stack(struct stack *stack) {
   return(stack && stack->card && stack->card->frame &&
-         (stack->card->frame->start_y == STOCK_STARTING_Y) &&
-         (stack->card->frame->start_x == STOCK_STARTING_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->start_y == WASTE_PILE_STARTING_Y) &&
-         (stack->card->frame->start_x == WASTE_PILE_STARTING_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->start_y == FOUNDATION_STARTING_Y &&
-         (stack->card->frame->start_x == FOUNDATION_0_STARTING_X ||
-          stack->card->frame->start_x == FOUNDATION_1_STARTING_X ||
-          stack->card->frame->start_x == FOUNDATION_2_STARTING_X ||
-          stack->card->frame->start_x == FOUNDATION_3_STARTING_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->start_y >= MANEUVRE_STACKS_STARTING_Y &&
-         (stack->card->frame->start_x == MANEUVRE_0_STARTING_X ||
-          stack->card->frame->start_x == MANEUVRE_1_STARTING_X ||
-          stack->card->frame->start_x == MANEUVRE_2_STARTING_X ||
-          stack->card->frame->start_x == MANEUVRE_3_STARTING_X ||
-          stack->card->frame->start_x == MANEUVRE_4_STARTING_X ||
-          stack->card->frame->start_x == MANEUVRE_5_STARTING_X ||
-          stack->card->frame->start_x == MANEUVRE_6_STARTING_X));
+         stack->card->frame->begin_y >= MANEUVRE_STACKS_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) {
@@ -76,11 +76,11 @@ void move_card(struct stack **origin, struct stack **destination) {
   struct stack *stack;
 
   if (!empty(*origin)) {
-    (*origin)->card->frame->start_x = (*destination)->card->frame->start_x;
-    (*origin)->card->frame->start_y = (*destination)->card->frame->start_y;
+    (*origin)->card->frame->begin_x = (*destination)->card->frame->begin_x;
+    (*origin)->card->frame->begin_y = (*destination)->card->frame->begin_y;
   }
   if (!empty(*destination) && maneuvre_stack(*destination)) {
-    (*origin)->card->frame->start_y++;
+    (*origin)->card->frame->begin_y++;
   }
   if ((stack = pop(origin))) {
     push(destination, stack->card);
@@ -89,44 +89,44 @@ 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_STARTING_Y,
-            STOCK_STARTING_X);
+            STOCK_BEGIN_Y,
+            STOCK_BEGIN_X);
   set_frame(deck->waste_pile->card->frame,
-            WASTE_PILE_STARTING_Y,
-            WASTE_PILE_STARTING_X);
+            WASTE_PILE_BEGIN_Y,
+            WASTE_PILE_BEGIN_X);
   set_frame(deck->foundation_0->card->frame,
-            FOUNDATION_STARTING_Y,
-            FOUNDATION_0_STARTING_X);
+            FOUNDATION_BEGIN_Y,
+            FOUNDATION_0_BEGIN_X);
   set_frame(deck->foundation_1->card->frame,
-            FOUNDATION_STARTING_Y,
-            FOUNDATION_1_STARTING_X);
+            FOUNDATION_BEGIN_Y,
+            FOUNDATION_1_BEGIN_X);
   set_frame(deck->foundation_2->card->frame,
-            FOUNDATION_STARTING_Y,
-            FOUNDATION_2_STARTING_X);
+            FOUNDATION_BEGIN_Y,
+            FOUNDATION_2_BEGIN_X);
   set_frame(deck->foundation_3->card->frame,
-            FOUNDATION_STARTING_Y,
-            FOUNDATION_3_STARTING_X);
+            FOUNDATION_BEGIN_Y,
+            FOUNDATION_3_BEGIN_X);
   set_frame(deck->maneuvre_0->card->frame,
-            MANEUVRE_STARTING_Y,
-            MANEUVRE_0_STARTING_X);
+            MANEUVRE_BEGIN_Y,
+            MANEUVRE_0_BEGIN_X);
   set_frame(deck->maneuvre_1->card->frame,
-            MANEUVRE_STARTING_Y,
-            MANEUVRE_1_STARTING_X);
+            MANEUVRE_BEGIN_Y,
+            MANEUVRE_1_BEGIN_X);
   set_frame(deck->maneuvre_2->card->frame,
-            MANEUVRE_STARTING_Y,
-            MANEUVRE_2_STARTING_X);
+            MANEUVRE_BEGIN_Y,
+            MANEUVRE_2_BEGIN_X);
   set_frame(deck->maneuvre_3->card->frame,
-            MANEUVRE_STARTING_Y,
-            MANEUVRE_3_STARTING_X);
+            MANEUVRE_BEGIN_Y,
+            MANEUVRE_3_BEGIN_X);
   set_frame(deck->maneuvre_4->card->frame,
-            MANEUVRE_STARTING_Y,
-            MANEUVRE_4_STARTING_X);
+            MANEUVRE_BEGIN_Y,
+            MANEUVRE_4_BEGIN_X);
   set_frame(deck->maneuvre_5->card->frame,
-            MANEUVRE_STARTING_Y,
-            MANEUVRE_5_STARTING_X);
+            MANEUVRE_BEGIN_Y,
+            MANEUVRE_5_BEGIN_X);
   set_frame(deck->maneuvre_6->card->frame,
-            MANEUVRE_STARTING_Y,
-            MANEUVRE_6_STARTING_X);
+            MANEUVRE_BEGIN_Y,
+            MANEUVRE_6_BEGIN_X);
 }
 
 static void fill_deck(struct deck *deck) {
diff --git a/lib/game.h b/lib/game.h
index e1b307c..eed008f 100644
--- a/lib/game.h
+++ b/lib/game.h
@@ -7,28 +7,28 @@
 
 #define NUMBER_OF_CARDS 52
 
-#define MANEUVRE_STACKS_STARTING_Y 7
+#define MANEUVRE_STACKS_BEGIN_Y 7
 
-#define STOCK_STARTING_X        1
-#define STOCK_STARTING_Y        1
+#define STOCK_BEGIN_X        1
+#define STOCK_BEGIN_Y        1
 
-#define WASTE_PILE_STARTING_X   9
-#define WASTE_PILE_STARTING_Y   1
+#define WASTE_PILE_BEGIN_X   9
+#define WASTE_PILE_BEGIN_Y   1
 
-#define FOUNDATION_STARTING_Y   1
-#define FOUNDATION_0_STARTING_X 25
-#define FOUNDATION_1_STARTING_X 33
-#define FOUNDATION_2_STARTING_X 41
-#define FOUNDATION_3_STARTING_X 49
+#define FOUNDATION_BEGIN_Y   1
+#define FOUNDATION_0_BEGIN_X 25
+#define FOUNDATION_1_BEGIN_X 33
+#define FOUNDATION_2_BEGIN_X 41
+#define FOUNDATION_3_BEGIN_X 49
 
-#define MANEUVRE_STARTING_Y     9
-#define MANEUVRE_0_STARTING_X   1
-#define MANEUVRE_1_STARTING_X   9
-#define MANEUVRE_2_STARTING_X   17
-#define MANEUVRE_3_STARTING_X   25
-#define MANEUVRE_4_STARTING_X   33
-#define MANEUVRE_5_STARTING_X   41
-#define MANEUVRE_6_STARTING_X   49
+#define MANEUVRE_BEGIN_Y     9
+#define MANEUVRE_0_BEGIN_X   1
+#define MANEUVRE_1_BEGIN_X   9
+#define MANEUVRE_2_BEGIN_X   17
+#define MANEUVRE_3_BEGIN_X   25
+#define MANEUVRE_4_BEGIN_X   33
+#define MANEUVRE_5_BEGIN_X   41
+#define MANEUVRE_6_BEGIN_X   49
 
 struct deck *deck;
 struct cursor *cursor;
diff --git a/lib/keyboard.c b/lib/keyboard.c
index 382e909..f8ae58e 100644
--- a/lib/keyboard.c
+++ b/lib/keyboard.c
@@ -6,13 +6,13 @@
 #include "keyboard.h"
 
 static bool cursor_on_stock(struct cursor *cursor) {
-  return((cursor->x == CURSOR_STARTING_X) && (cursor->y == CURSOR_STARTING_Y));
+  return((cursor->x == CURSOR_BEGIN_X) && (cursor->y == CURSOR_BEGIN_Y));
 }
 
 static struct stack *cursor_stack(struct cursor *cursor) {
   struct stack *cursor_stack = NULL;
 
-  if (cursor->y == CURSOR_STARTING_Y) {
+  if (cursor->y == CURSOR_BEGIN_Y) {
     switch (cursor->x) {
     case CURSOR_STOCK_X:        cursor_stack = deck->stock;        break;
     case CURSOR_WASTE_PILE_X:   cursor_stack = deck->waste_pile;   break;
diff --git a/lib/stack.c b/lib/stack.c
index 9d26f1b..5ba657e 100644
--- a/lib/stack.c
+++ b/lib/stack.c
@@ -98,8 +98,8 @@ struct stack *pop(struct stack **stack) {
                NO_VALUE,
                NO_SUIT,
                NO_FACE,
-               (*stack)->card->frame->start_y,
-               (*stack)->card->frame->start_x);
+               (*stack)->card->frame->begin_y,
+               (*stack)->card->frame->begin_x);
       (*stack)->next = NULL;
     } else {
       *stack = (*stack)->next;
diff --git a/test/card_test.c b/test/card_test.c
index e8977ba..7dc72ca 100644
--- a/test/card_test.c
+++ b/test/card_test.c
@@ -17,10 +17,10 @@ void test_initialize_card() {
 
 void test_duplicate_card() {
   struct card *card_0, *card_1;
-  const int start_y = 5, start_x = 10;
+  const int begin_y = 5, begin_x = 10;
 
   allocate_card(&card_0);
-  set_card(card_0, ACE, SPADES, EXPOSED, start_y, start_x);
+  set_card(card_0, ACE, SPADES, EXPOSED, begin_y, begin_x);
   card_1 = duplicate_card(card_0);
 
   assert(card_0 != card_1);
@@ -29,18 +29,18 @@ void test_duplicate_card() {
 
 void test_set_card() {
   struct card *card;
-  int start_y = 5;
-  int start_x = 10;
+  int begin_y = 5;
+  int begin_x = 10;
 
   allocate_card(&card);
   initialize_card(card);
-  set_card(card, ACE, SPADES, EXPOSED, start_y, start_x);
+  set_card(card, ACE, SPADES, EXPOSED, begin_y, begin_x);
 
   assert(card->value == ACE);
   assert(card->suit == SPADES);
   assert(card->face == EXPOSED);
-  assert(card->frame->start_y == start_y);
-  assert(card->frame->start_x == start_x);
+  assert(card->frame->begin_y == begin_y);
+  assert(card->frame->begin_x == begin_x);
 
   free_card(card);
 }
diff --git a/test/frame_test.c b/test/frame_test.c
index 8dc6054..a56107e 100644
--- a/test/frame_test.c
+++ b/test/frame_test.c
@@ -9,18 +9,18 @@ void test_initialize_frame() {
   initialize_frame(frame);
 
   assert(frame->shape == NULL);
-  assert(frame->start_y == 0);
-  assert(frame->start_x == 0);
+  assert(frame->begin_y == 0);
+  assert(frame->begin_x == 0);
 
   free_frame(frame);
 }
 
 void test_duplicate_frame() {
   struct frame *frame_0, *frame_1;
-  const int start_y = 5, start_x = 10;
+  const int begin_y = 5, begin_x = 10;
 
   allocate_frame(&frame_0);
-  set_frame(frame_0, start_y, start_x);
+  set_frame(frame_0, begin_y, begin_x);
   frame_1 = duplicate_frame(frame_0);
 
   assert(frame_0 != frame_1);
@@ -29,15 +29,15 @@ void test_duplicate_frame() {
 
 void test_set_frame() {
   struct frame *frame;
-  int start_y = 5;
-  int start_x = 10;
+  int begin_y = 5;
+  int begin_x = 10;
 
   allocate_frame(&frame);
   initialize_frame(frame);
-  set_frame(frame, start_y, start_x);
+  set_frame(frame, begin_y, begin_x);
 
-  assert(frame->start_y == start_y);
-  assert(frame->start_x == start_x);
+  assert(frame->begin_y == begin_y);
+  assert(frame->begin_x == begin_x);
 
   free_frame(frame);
 }
diff --git a/test/game_test.c b/test/game_test.c
index 8d8f983..61a991c 100644
--- a/test/game_test.c
+++ b/test/game_test.c
@@ -115,8 +115,8 @@ void test_valid_move_from_stock_to_stock() {
   allocate_stack(&stock_1);
   initialize_stack(stock_0);
   initialize_stack(stock_1);
-  set_card(stock_0->card, ACE, SPADES, EXPOSED, STOCK_STARTING_Y, STOCK_STARTING_X);
-  set_card(stock_1->card, KING, HEARTS, EXPOSED, STOCK_STARTING_Y, STOCK_STARTING_X);
+  set_card(stock_0->card, ACE, SPADES, EXPOSED, STOCK_BEGIN_Y, STOCK_BEGIN_X);
+  set_card(stock_1->card, KING, HEARTS, EXPOSED, STOCK_BEGIN_Y, STOCK_BEGIN_X);
   assert(!valid_move(stock_0, stock_0));
   assert(!valid_move(stock_0, stock_1));
   assert(!valid_move(stock_1, stock_0));
@@ -132,8 +132,8 @@ void test_valid_move_from_stock_to_waste_pile() {
   allocate_stack(&waste_pile);
   initialize_stack(stock);
   initialize_stack(waste_pile);
-  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_STARTING_Y, STOCK_STARTING_X);
-  set_card(waste_pile->card, KING, HEARTS, EXPOSED, WASTE_PILE_STARTING_Y, WASTE_PILE_STARTING_X);
+  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_BEGIN_Y, STOCK_BEGIN_X);
+  set_card(waste_pile->card, KING, HEARTS, EXPOSED, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);
   assert(valid_move(stock, waste_pile));
   free_stack(stock);
   free_stack(waste_pile);
@@ -144,15 +144,15 @@ void test_valid_move_from_stock_to_foundation_stacks() {
 
   allocate_stack(&stock);
   initialize_stack(stock);
-  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_STARTING_Y, STOCK_STARTING_X);
+  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_BEGIN_Y, STOCK_BEGIN_X);
   for (int i = 0; i < 4; i++) {
     allocate_stack(&foundation_stacks[i]);
     initialize_stack(foundation_stacks[i]);
   }
-  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_0_STARTING_X);
-  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_1_STARTING_X);
-  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_2_STARTING_X);
-  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_3_STARTING_X);
+  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_0_BEGIN_X);
+  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_1_BEGIN_X);
+  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_2_BEGIN_X);
+  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_3_BEGIN_X);
   for (int i = 0; i < 4; i++) {
     assert(!valid_move(stock, foundation_stacks[i]));
   }
@@ -167,18 +167,18 @@ void test_valid_move_from_stock_to_maneuvre_stacks() {
 
   allocate_stack(&stock);
   initialize_stack(stock);
-  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_STARTING_Y, STOCK_STARTING_X);
+  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_BEGIN_Y, STOCK_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     allocate_stack(&maneuvre_stacks[i]);
     initialize_stack(maneuvre_stacks[i]);
   }
-  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_0_STARTING_X);
-  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_1_STARTING_X);
-  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_2_STARTING_X);
-  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_3_STARTING_X);
-  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_4_STARTING_X);
-  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_5_STARTING_X);
-  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_6_STARTING_X);
+  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);
+  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);
+  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);
+  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);
+  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);
+  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);
+  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     assert(!valid_move(stock, maneuvre_stacks[i]));
   }
@@ -195,8 +195,8 @@ void test_valid_move_from_waste_pile_to_stock() {
   allocate_stack(&waste_pile);
   initialize_stack(stock);
   initialize_stack(waste_pile);
-  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_STARTING_Y, STOCK_STARTING_X);
-  set_card(waste_pile->card, KING, HEARTS, EXPOSED, WASTE_PILE_STARTING_Y, WASTE_PILE_STARTING_X);
+  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_BEGIN_Y, STOCK_BEGIN_X);
+  set_card(waste_pile->card, KING, HEARTS, EXPOSED, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);
   assert(!valid_move(waste_pile, stock));
   free_stack(stock);
   free_stack(waste_pile);
@@ -209,8 +209,8 @@ void test_valid_move_from_waste_pile_to_waste_pile() {
   allocate_stack(&waste_pile_1);
   initialize_stack(waste_pile_0);
   initialize_stack(waste_pile_1);
-  set_card(waste_pile_0->card, ACE, SPADES, EXPOSED, WASTE_PILE_STARTING_Y, WASTE_PILE_STARTING_X);
-  set_card(waste_pile_1->card, KING, HEARTS, EXPOSED, WASTE_PILE_STARTING_Y, WASTE_PILE_STARTING_X);
+  set_card(waste_pile_0->card, ACE, SPADES, EXPOSED, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);
+  set_card(waste_pile_1->card, KING, HEARTS, EXPOSED, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);
   assert(!valid_move(waste_pile_0, waste_pile_0));
   assert(!valid_move(waste_pile_0, waste_pile_1));
   assert(!valid_move(waste_pile_1, waste_pile_0));
@@ -224,15 +224,15 @@ void test_valid_move_from_waste_pile_to_foundation_stacks() {
 
   allocate_stack(&waste_pile);
   initialize_stack(waste_pile);
-  set_card(waste_pile->card, ACE, SPADES, EXPOSED, WASTE_PILE_STARTING_Y, WASTE_PILE_STARTING_X);
+  set_card(waste_pile->card, ACE, SPADES, EXPOSED, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);
   for (int i = 0; i < 4; i++) {
     allocate_stack(&foundation_stacks[i]);
     initialize_stack(foundation_stacks[i]);
   }
-  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_0_STARTING_X);
-  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_1_STARTING_X);
-  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_2_STARTING_X);
-  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_3_STARTING_X);
+  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_0_BEGIN_X);
+  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_1_BEGIN_X);
+  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_2_BEGIN_X);
+  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_3_BEGIN_X);
   for (int i = 0; i < 4; i++) {
     assert(valid_move(waste_pile, foundation_stacks[i]));
   }
@@ -247,18 +247,18 @@ void test_valid_move_from_waste_pile_to_maneuvre_stacks() {
 
   allocate_stack(&waste_pile);
   initialize_stack(waste_pile);
-  set_card(waste_pile->card, ACE, SPADES, EXPOSED, WASTE_PILE_STARTING_Y, WASTE_PILE_STARTING_X);
+  set_card(waste_pile->card, ACE, SPADES, EXPOSED, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     allocate_stack(&maneuvre_stacks[i]);
     initialize_stack(maneuvre_stacks[i]);
   }
-  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_0_STARTING_X);
-  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_1_STARTING_X);
-  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_2_STARTING_X);
-  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_3_STARTING_X);
-  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_4_STARTING_X);
-  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_5_STARTING_X);
-  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_6_STARTING_X);
+  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);
+  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);
+  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);
+  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);
+  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);
+  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);
+  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     assert(valid_move(waste_pile, maneuvre_stacks[i]));
   }
@@ -273,15 +273,15 @@ void test_valid_move_from_foundation_stack_to_stock() {
 
   allocate_stack(&stock);
   initialize_stack(stock);
-  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_STARTING_Y, STOCK_STARTING_X);
+  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_BEGIN_Y, STOCK_BEGIN_X);
   for (int i = 0; i < 4; i++) {
     allocate_stack(&foundation_stacks[i]);
     initialize_stack(foundation_stacks[i]);
   }
-  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_0_STARTING_X);
-  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_1_STARTING_X);
-  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_2_STARTING_X);
-  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_3_STARTING_X);
+  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_0_BEGIN_X);
+  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_1_BEGIN_X);
+  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_2_BEGIN_X);
+  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_3_BEGIN_X);
   for (int i = 0; i < 4; i++) {
     assert(!valid_move(foundation_stacks[i], stock));
   }
@@ -296,15 +296,15 @@ void test_valid_move_from_foundation_stack_to_waste_pile() {
 
   allocate_stack(&waste_pile);
   initialize_stack(waste_pile);
-  set_card(waste_pile->card, ACE, SPADES, EXPOSED, WASTE_PILE_STARTING_Y, WASTE_PILE_STARTING_X);
+  set_card(waste_pile->card, ACE, SPADES, EXPOSED, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);
   for (int i = 0; i < 4; i++) {
     allocate_stack(&foundation_stacks[i]);
     initialize_stack(foundation_stacks[i]);
   }
-  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_0_STARTING_X);
-  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_1_STARTING_X);
-  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_2_STARTING_X);
-  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_3_STARTING_X);
+  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_0_BEGIN_X);
+  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_1_BEGIN_X);
+  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_2_BEGIN_X);
+  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_3_BEGIN_X);
   for (int i = 0; i < 4; i++) {
     assert(!valid_move(foundation_stacks[i], waste_pile));
   }
@@ -321,10 +321,10 @@ void test_valid_move_from_foundation_stack_to_foundation_stacks() {
     allocate_stack(&foundation_stacks[i]);
     initialize_stack(foundation_stacks[i]);
   }
-  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_0_STARTING_X);
-  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_1_STARTING_X);
-  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_2_STARTING_X);
-  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_3_STARTING_X);
+  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_0_BEGIN_X);
+  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_1_BEGIN_X);
+  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_2_BEGIN_X);
+  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_3_BEGIN_X);
   for (int i = 0; i < 4; i++) {
     for (int j = 0; j < 4; j++) {
       if (i == j) {
@@ -347,21 +347,21 @@ void test_valid_move_from_foundation_stack_to_maneuvre_stacks() {
     allocate_stack(&foundation_stacks[i]);
     initialize_stack(foundation_stacks[i]);
   }
-  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_0_STARTING_X);
-  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_1_STARTING_X);
-  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_2_STARTING_X);
-  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_3_STARTING_X);
+  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_0_BEGIN_X);
+  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_1_BEGIN_X);
+  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_2_BEGIN_X);
+  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_3_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     allocate_stack(&maneuvre_stacks[i]);
     initialize_stack(maneuvre_stacks[i]);
   }
-  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_0_STARTING_X);
-  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_1_STARTING_X);
-  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_2_STARTING_X);
-  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_3_STARTING_X);
-  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_4_STARTING_X);
-  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_5_STARTING_X);
-  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_6_STARTING_X);
+  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);
+  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);
+  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);
+  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);
+  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);
+  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);
+  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);
   for (int i = 0; i < 4; i++) {
     for (int j = 0; j < 7; j++) {
       assert(valid_move(foundation_stacks[i], maneuvre_stacks[j]));
@@ -380,18 +380,18 @@ void test_valid_move_from_maneuvre_stack_to_stock() {
 
   allocate_stack(&stock);
   initialize_stack(stock);
-  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_STARTING_Y, STOCK_STARTING_X);
+  set_card(stock->card, ACE, SPADES, EXPOSED, STOCK_BEGIN_Y, STOCK_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     allocate_stack(&maneuvre_stacks[i]);
     initialize_stack(maneuvre_stacks[i]);
   }
-  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_0_STARTING_X);
-  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_1_STARTING_X);
-  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_2_STARTING_X);
-  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_3_STARTING_X);
-  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_4_STARTING_X);
-  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_5_STARTING_X);
-  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_6_STARTING_X);
+  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);
+  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);
+  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);
+  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);
+  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);
+  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);
+  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     assert(!valid_move(maneuvre_stacks[i], stock));
   }
@@ -406,18 +406,18 @@ void test_valid_move_from_maneuvre_stack_to_waste_pile() {
 
   allocate_stack(&waste_pile);
   initialize_stack(waste_pile);
-  set_card(waste_pile->card, ACE, SPADES, EXPOSED, WASTE_PILE_STARTING_Y, WASTE_PILE_STARTING_X);
+  set_card(waste_pile->card, ACE, SPADES, EXPOSED, WASTE_PILE_BEGIN_Y, WASTE_PILE_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     allocate_stack(&maneuvre_stacks[i]);
     initialize_stack(maneuvre_stacks[i]);
   }
-  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_0_STARTING_X);
-  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_1_STARTING_X);
-  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_2_STARTING_X);
-  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_3_STARTING_X);
-  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_4_STARTING_X);
-  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_5_STARTING_X);
-  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_6_STARTING_X);
+  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);
+  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);
+  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);
+  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);
+  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);
+  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);
+  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     assert(!valid_move(maneuvre_stacks[i], waste_pile));
   }
@@ -435,21 +435,21 @@ void test_valid_move_from_maneuvre_stack_to_foundation_stacks() {
     allocate_stack(&foundation_stacks[i]);
     initialize_stack(foundation_stacks[i]);
   }
-  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_0_STARTING_X);
-  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_1_STARTING_X);
-  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_2_STARTING_X);
-  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_STARTING_Y, FOUNDATION_3_STARTING_X);
+  set_card(foundation_stacks[0]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_0_BEGIN_X);
+  set_card(foundation_stacks[1]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_1_BEGIN_X);
+  set_card(foundation_stacks[2]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_2_BEGIN_X);
+  set_card(foundation_stacks[3]->card, ACE, SPADES, EXPOSED, FOUNDATION_BEGIN_Y, FOUNDATION_3_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     allocate_stack(&maneuvre_stacks[i]);
     initialize_stack(maneuvre_stacks[i]);
   }
-  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_0_STARTING_X);
-  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_1_STARTING_X);
-  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_2_STARTING_X);
-  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_3_STARTING_X);
-  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_4_STARTING_X);
-  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_5_STARTING_X);
-  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_6_STARTING_X);
+  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);
+  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);
+  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);
+  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);
+  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);
+  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);
+  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     for (int j = 0; j < 4; j++) {
       assert(valid_move(maneuvre_stacks[i], foundation_stacks[j]));
@@ -470,13 +470,13 @@ void test_valid_move_from_maneuvre_stack_to_maneuvre_stacks() {
     allocate_stack(&maneuvre_stacks[i]);
     initialize_stack(maneuvre_stacks[i]);
   }
-  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_0_STARTING_X);
-  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_1_STARTING_X);
-  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_2_STARTING_X);
-  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_3_STARTING_X);
-  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_4_STARTING_X);
-  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_5_STARTING_X);
-  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_STARTING_Y, MANEUVRE_6_STARTING_X);
+  set_card(maneuvre_stacks[0]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_0_BEGIN_X);
+  set_card(maneuvre_stacks[1]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_1_BEGIN_X);
+  set_card(maneuvre_stacks[2]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_2_BEGIN_X);
+  set_card(maneuvre_stacks[3]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_3_BEGIN_X);
+  set_card(maneuvre_stacks[4]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_4_BEGIN_X);
+  set_card(maneuvre_stacks[5]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_5_BEGIN_X);
+  set_card(maneuvre_stacks[6]->card, ACE, SPADES, EXPOSED, MANEUVRE_BEGIN_Y, MANEUVRE_6_BEGIN_X);
   for (int i = 0; i < 7; i++) {
     for (int j = 0; j < 7; j++) {
       if (i == j) {
diff --git a/test/stack_test.c b/test/stack_test.c
index ab37287..1839a50 100644
--- a/test/stack_test.c
+++ b/test/stack_test.c
@@ -17,13 +17,13 @@ void test_initialize_stack() {
 void test_duplicate_stack() {
   struct stack *stack_0, *stack_1;
   struct card *card[5];
-  const int start_y = 5, start_x = 10;
+  const int begin_y = 5, begin_x = 10;
 
   allocate_stack(&stack_0);
   initialize_stack(stack_0);
   for (int i = 0; i < 5; i++) {
     allocate_card(&card[i]);
-    set_card(card[i], i, SPADES, EXPOSED, start_y, start_x);
+    set_card(card[i], i, SPADES, EXPOSED, begin_y, begin_x);
     push(&stack_0, card[i]);
   }
   stack_1 = duplicate_stack(stack_0);
diff --git a/test/test_helper.c b/test/test_helper.c
index 62a22dc..e1546af 100644
--- a/test/test_helper.c
+++ b/test/test_helper.c
@@ -2,8 +2,8 @@
 
 bool frames_equal(struct frame *frame_0, struct frame *frame_1) {
   if (frame_0 && frame_1) {
-    return(frame_0->start_y == frame_1->start_y &&
-           frame_0->start_x == frame_1->start_x);
+    return(frame_0->begin_y == frame_1->begin_y &&
+           frame_0->begin_x == frame_1->begin_x);
   } else if ((frame_0 && !frame_1) || (!frame_0 && frame_1)) {
     return(false);
   } else {
diff --git a/test/test_helper_test.c b/test/test_helper_test.c
index 49c1190..cb72e29 100644
--- a/test/test_helper_test.c
+++ b/test/test_helper_test.c
@@ -15,12 +15,12 @@ void test_frames_equal_with_one_null() {
 
 void test_frames_equal_with_two_equivalent_frames() {
   struct frame *frame_0, *frame_1;
-  const int start_y = 5, start_x = 10;
+  const int begin_y = 5, begin_x = 10;
 
   allocate_frame(&frame_0);
   allocate_frame(&frame_1);
-  set_frame(frame_0, start_y, start_x);
-  set_frame(frame_1, start_y, start_x);
+  set_frame(frame_0, begin_y, begin_x);
+  set_frame(frame_1, begin_y, begin_x);
 
   assert(frames_equal(frame_0, frame_1));
 }
@@ -47,12 +47,12 @@ void test_cards_equal_with_one_null() {
 
 void test_cards_equal_with_two_equivalent_cards() {
   struct card *card_0, *card_1;
-  const int start_y = 5, start_x = 10;
+  const int begin_y = 5, begin_x = 10;
 
   allocate_card(&card_0);
   allocate_card(&card_1);
-  set_card(card_0, ACE, SPADES, EXPOSED, start_y, start_x);
-  set_card(card_1, ACE, SPADES, EXPOSED, start_y, start_x);
+  set_card(card_0, ACE, SPADES, EXPOSED, begin_y, begin_x);
+  set_card(card_1, ACE, SPADES, EXPOSED, begin_y, begin_x);
 
   assert(cards_equal(card_0, card_1));
 }
@@ -80,12 +80,12 @@ void test_stacks_equal_with_one_null() {
 void test_stacks_equal_with_two_equivalent_stacks() {
   struct stack *stack_0, *stack_1;
   struct card *card_0, *card_1;
-  const int start_y = 5, start_x = 10;
+  const int begin_y = 5, begin_x = 10;
 
   allocate_card(&card_0);
   allocate_card(&card_1);
-  set_card(card_0, ACE, SPADES, EXPOSED, start_y, start_x);
-  set_card(card_1, ACE, SPADES, EXPOSED, start_y, start_x);
+  set_card(card_0, ACE, SPADES, EXPOSED, begin_y, begin_x);
+  set_card(card_1, ACE, SPADES, EXPOSED, begin_y, begin_x);
   allocate_stack(&stack_0);
   allocate_stack(&stack_1);
   push(&stack_0, card_0);
@@ -97,12 +97,12 @@ void test_stacks_equal_with_two_equivalent_stacks() {
 void test_stacks_equal_with_two_different_stacks() {
   struct stack *stack_0, *stack_1;
   struct card *card_0, *card_1;
-  const int start_y = 5, start_x = 10;
+  const int begin_y = 5, begin_x = 10;
 
   allocate_card(&card_0);
   allocate_card(&card_1);
-  set_card(card_0, ACE, SPADES, EXPOSED, start_y, start_x);
-  set_card(card_1, KING, HEARTS, EXPOSED, start_y, start_x);
+  set_card(card_0, ACE, SPADES, EXPOSED, begin_y, begin_x);
+  set_card(card_1, KING, HEARTS, EXPOSED, begin_y, begin_x);
   allocate_stack(&stack_0);
   allocate_stack(&stack_1);
   push(&stack_0, card_0);