diff --git a/cli/main.c b/cli/main.c
index a140f0b..00662e5 100644
--- a/cli/main.c
+++ b/cli/main.c
@@ -5,6 +5,12 @@
 #include <ncursesw/ncurses.h>
 
 #include "cursetree.h"
+#include "surface.h"
+
+#define nprintsfdims(nout, i, label, nin)                                      \
+  (mvwprintw((nout)->surface->win, (i), 0, "%s@(%d,%d) %dx%d", (label),        \
+             (nin)->surface->dims->x, (nin)->surface->dims->y,                 \
+             (nin)->surface->dims->width, (nin)->surface->dims->height))
 
 int main(int argc, char **argv) {
   struct ct_tree *tree;
@@ -13,37 +19,47 @@ int main(int argc, char **argv) {
   init_pair(1, COLOR_BLACK, COLOR_CYAN);
   init_pair(2, COLOR_BLACK, COLOR_RED);
   init_pair(3, COLOR_BLACK, COLOR_GREEN);
-
-
-  // wbkgd(tree->root->surface->win, COLOR_PAIR(1));
-  // wrefresh(tree->root->surface->win);
+  init_pair(4, COLOR_BLACK, COLOR_MAGENTA);
+  init_pair(5, COLOR_BLACK, COLOR_YELLOW);
 
   struct ct_node *const child1 = new_node(bounds_none(), tree->root);
   struct ct_node *const child2 = new_node(bounds_none(), tree->root);
   struct ct_node *const child3 = new_node(bounds_none(), tree->root);
+  struct ct_node *const child4 = new_node(bounds_none(), tree->root);
+  struct ct_node *const child5 = new_node(bounds_none(), tree->root);
   append_child_node(tree->root, child1);
   append_child_node(tree->root, child2);
   append_child_node(tree->root, child3);
+  append_child_node(tree->root, child4);
+  append_child_node(tree->root, child5);
 
   wbkgd(child1->surface->win, COLOR_PAIR(1));
   wbkgd(child2->surface->win, COLOR_PAIR(2));
   wbkgd(child3->surface->win, COLOR_PAIR(3));
+  wbkgd(child4->surface->win, COLOR_PAIR(4));
+  wbkgd(child5->surface->win, COLOR_PAIR(5));
 
-  // wrefresh(child1->surface->win);
-
-  mvwprintw(child2->surface->win, 0, 0, "1@(%d,%d) %dx%d\n",
-            child1->surface->dims->x, child1->surface->dims->y,
-            child1->surface->dims->width, child1->surface->dims->height);
-  mvwprintw(child2->surface->win, 1, 0, "2@(%d,%d) %dx%d\n",
-            child2->surface->dims->x, child2->surface->dims->y,
-            child2->surface->dims->width, child2->surface->dims->height);
-  mvwprintw(child2->surface->win, 1, 0, "2@(%d,%d) %dx%d\n",
-            child3->surface->dims->x, child3->surface->dims->y,
-            child3->surface->dims->width, child3->surface->dims->height);
+  child3->axis = AXIS_Y;
+  struct ct_node *const child3_1 = new_node(bounds_none(), child3);
+  struct ct_node *const child3_2 = new_node(bounds_none(), child3);
+  append_child_node(child3, child3_1);
+  append_child_node(child3, child3_2);
+  wbkgd(child3_1->surface->win, COLOR_PAIR(1));
+  wbkgd(child3_2->surface->win, COLOR_PAIR(5));
 
   while (1) {
+    nprintsfdims(child2, 0, "R", tree->root);
+    nprintsfdims(child2, 1, "1", child1);
+    nprintsfdims(child2, 2, "2", child2);
+    nprintsfdims(child2, 3, "3", child3);
+    nprintsfdims(child2, 4, "4", child4);
+    nprintsfdims(child2, 5, "5", child5);
+    
+    nprintsfdims(child2, 7, "3_1", child3_1);
+    nprintsfdims(child2, 8, "3_2", child3_2);
+    
+
     ct_update(tree);
-    // napms(100);
   }
 
   destroy_tree(tree);
diff --git a/cursetree/dims.c b/cursetree/dims.c
index f0bb0ef..771c68a 100644
--- a/cursetree/dims.c
+++ b/cursetree/dims.c
@@ -86,37 +86,3 @@ struct ct_bounds *dup_bounds(const struct ct_bounds *const bounds) {
 
   return dup;
 }
-
-/* Calculate the dimensions for nodes resulting from a bifurcation.
- * Returns 0 on success, and 1 on failure if any width/height are 0 characters.
- * WARNING: This function does not guarantee the x,y positions returned
- * WARNING: are valid screen coordinates.
- */
-// int bifurcate_dims(const struct ct_dims *const parent_dims,
-//                    const enum ct_axis axis, const float ratio,
-//                    struct ct_dims **const dims0, struct ct_dims **const
-//                    dims1) {
-//   assert(0 < ratio && ratio < 1);
-//   struct ct_dims *_dims0, *_dims1;
-
-//   _dims0 = dup_dims(parent_dims);
-//   _dims1 = dup_dims(parent_dims);
-
-//   if (axis == AXIS_X) {
-//     _dims0->width *= ratio;
-//     _dims1->width -= _dims0->width;
-//     _dims1->x += _dims0->width;
-//   } else {
-//     _dims0->height *= ratio;
-//     _dims1->height -= _dims0->height;
-//     _dims1->y += _dims0->height;
-//   }
-
-//   if (!_dims0->width || !_dims0->height || !_dims1->width || !_dims1->height)
-//     return 1;
-
-//   // propagate bifurcated dimensions
-//   *dims0 = _dims0;
-//   *dims1 = _dims1;
-//   return 0;
-// }
diff --git a/cursetree/node.c b/cursetree/node.c
index 9fbcfeb..d3c4422 100644
--- a/cursetree/node.c
+++ b/cursetree/node.c
@@ -103,42 +103,36 @@ int resize_node(struct ct_node *const node, struct ct_dims *dims) {
   }
 
   int axm_size, axm_free;
-  /* DEBUG: WARNING :DEBUG */
-  // size_t bounds_axm_min_offset, bounds_axm_max_offset;
-  // size_t dims_axm_pos_offset, dims_axm_size_offset;
+  size_t bounds_axm_min_offset, bounds_axm_max_offset;
+  size_t dims_axm_pos_offset, dims_axm_size_offset;
 
   if (node->axis == AXIS_X) {
     axm_free = dims->width;
     axm_size = dims->width;
 
-    /* DEBUG: WARNING :DEBUG */
-    // dims_axm_pos_offset = offsetof(struct ct_dims, x);
-    // dims_axm_size_offset = offsetof(struct ct_dims, width);
-    // bounds_axm_min_offset = offsetof(struct ct_bounds, wmin);
-    // bounds_axm_max_offset = offsetof(struct ct_bounds, wmax);
+    dims_axm_pos_offset = offsetof(struct ct_dims, x);
+    dims_axm_size_offset = offsetof(struct ct_dims, width);
+    bounds_axm_min_offset = offsetof(struct ct_bounds, wmin);
+    bounds_axm_max_offset = offsetof(struct ct_bounds, wmax);
   } else {
     assert(node->axis == AXIS_Y);
     axm_free = dims->height;
     axm_size = dims->height;
 
-    /* DEBUG: WARNING :DEBUG */
-    // dims_axm_pos_offset = offsetof(struct ct_dims, y);
-    // dims_axm_size_offset = offsetof(struct ct_dims, height);
-    // bounds_axm_min_offset = offsetof(struct ct_bounds, hmin);
-    // bounds_axm_max_offset = offsetof(struct ct_bounds, hmax);
+    dims_axm_pos_offset = offsetof(struct ct_dims, y);
+    dims_axm_size_offset = offsetof(struct ct_dims, height);
+    bounds_axm_min_offset = offsetof(struct ct_bounds, hmin);
+    bounds_axm_max_offset = offsetof(struct ct_bounds, hmax);
   }
 
   struct ct_spdims cspdims[node->cindex];
   cindex parts_n = node->cindex;
   memset(cspdims, 0, sizeof(struct ct_spdims) * node->cindex);
   for (int i = 0; i < node->cindex; i++) {
-    /* DEBUG: WARNING :DEBUG */
-    // cspdims[i].min =
-    //     *(int *)(node->child[i]->surface->bounds + bounds_axm_min_offset);
-    // cspdims[i].max =
-    //     *(int *)(node->child[i]->surface->bounds + bounds_axm_max_offset);
-    cspdims[i].min = node->child[i]->surface->bounds->wmin;
-    cspdims[i].max = node->child[i]->surface->bounds->wmax;
+    cspdims[i].min = *(int *)((char *)node->child[i]->surface->bounds +
+                              bounds_axm_min_offset);
+    cspdims[i].max = *(int *)((char *)node->child[i]->surface->bounds +
+                              bounds_axm_max_offset);
 
     if (node->child[i]->surface->bounds->type == BOUND_RELATIVE) {
       cspdims[i].min *= axm_size;
@@ -149,14 +143,15 @@ int resize_node(struct ct_node *const node, struct ct_dims *dims) {
   }
 
   int split, new_size;
-  while (parts_n) {
-    split = axm_free / parts_n;
+  while (axm_free && parts_n) {
+    split = (axm_free > parts_n) ? (axm_free / parts_n) : 1;
     for (int i = 0; i < node->cindex; i++) {
       if (cspdims[i].fixed)
         continue;
 
       new_size =
           clampi(cspdims[i].axm_size + split, cspdims[i].min, cspdims[i].max);
+
       if (new_size == cspdims[i].axm_size) {
         cspdims[i].fixed = true;
         parts_n--;
@@ -165,22 +160,23 @@ int resize_node(struct ct_node *const node, struct ct_dims *dims) {
 
       axm_free -= (new_size - cspdims[i].axm_size);
       cspdims[i].axm_size = new_size;
+
+      if (axm_free == 0)
+        break;
     }
   }
 
   struct ct_dims *cdims = dup_dims(dims);
   /* NOTE: the statements below are done implicitly by dup_dims */
-  // *(int*)(cdims + dims_axm_pos_offset) = *(int*)(dims + dims_axm_pos_offset);
-  // *(int*)(cdims + dims_axo_pos_offset) = *(int*)(dims + dims_axo_pos_offset);
+  // *(int*)(cdims + dims_axm_pos_offset) = *(int*)(dims +
+  // dims_axm_pos_offset);
+  // *(int*)(cdims + dims_axo_pos_offset) = *(int*)(dims +
+  // dims_axo_pos_offset);
   // *(int*)(cdims + dims_axo_size_offset) = axo_size;
   for (int i = 0; i < node->cindex; i++) {
-    /* DEBUG: WARNING :DEBUG */
-    // *(int *)(cdims + dims_axm_size_offset) = cspdims[i].axm_size;
-    cdims->width = cspdims[i].axm_size;
+    *(int *)((char *)cdims + dims_axm_size_offset) = cspdims[i].axm_size;
     resize_node(node->child[i], dup_dims(cdims));
-    /* DEBUG: WARNING :DEBUG */
-    // *(int *)(cdims + dims_axm_pos_offset) += cspdims[i].axm_size;
-    cdims->x += cspdims[i].axm_size;
+    *(int *)((char *)cdims + dims_axm_pos_offset) += cspdims[i].axm_size;
   }
   free(cdims);