diff --git a/2023206/main.cpp b/2023206/main.cpp
index aa34e27..302ae6d 100644
--- a/2023206/main.cpp
+++ b/2023206/main.cpp
@@ -1,15 +1,18 @@
 #include <stdio.h>
 #define TREE_SIZE 65536
+#define NOTHING 65535
 struct TreeNode {
-    int val;
-    int left;
-    int right;
+    // int val;
+    unsigned short size;
+    unsigned short left;
+    unsigned short right;
 };
 
 TreeNode tree[TREE_SIZE] = {0};
+int vals[TREE_SIZE] = {0};
 int num_in_tree[TREE_SIZE] = {0};
 int num_in_tree_head = 0, num_in_tree_tail = 0;
-int tree_root = -1;
+int tree_root = NOTHING;
 // int new_tree_node = 0;
 int M, K, H;
 long long total = 0;
@@ -28,18 +31,20 @@ int dequeue() {
 }
 
 int insert_node(int num, int pos) {
-    if (pos < 0) {
+    if (pos == NOTHING) {
         // The tree_root is -1!
-        tree[l % K] = TreeNode{num, 1, -1, -1};
+        tree[l % K] = TreeNode{1, NOTHING, NOTHING};
         tree_root = l % K;
+        vals[l % K] = num;
         // new_tree_node = (new_tree_node + 1) % TREE_SIZE;
         return 0;
     }
-    // tree[pos].size++;
-    if (tree[pos].val > num) {
-        if (tree[pos].left < 0) {
+    tree[pos].size++;
+    if (vals[pos] > num) {
+        if (tree[pos].left == NOTHING) {
             tree[pos].left = l % K;
-            tree[l % K] = TreeNode{num, 1, -1, -1};
+            tree[l % K] = TreeNode{1, NOTHING, NOTHING};
+            vals[l % K] = num;
             // new_tree_node = (new_tree_node + 1) % TREE_SIZE;
             return 0;
         }
@@ -49,9 +54,10 @@ int insert_node(int num, int pos) {
         }
     }
     else {
-        if (tree[pos].right < 0) {
+        if (tree[pos].right == NOTHING) {
             tree[pos].right = l % K;
-            tree[l % K] = TreeNode{num, 1, -1, -1};
+            tree[l % K] = TreeNode{1, NOTHING, NOTHING};
+            vals[l % K] = num;
             // new_tree_node = (new_tree_node + 1) % TREE_SIZE;
             return 0;
         }
@@ -63,30 +69,30 @@ int insert_node(int num, int pos) {
 }
 
 int delete_node(int num, int pos) {
-    if (pos < 0) {
-        return -1;
+    if (pos == NOTHING) {
+        return NOTHING;
     }
 
-    if (tree[pos].val < num) {
-        // tree[pos].size--;
+    if (vals[pos] < num) {
+        tree[pos].size--;
         tree[pos].right = delete_node(num, tree[pos].right);
         return pos;
     }
 
-    if (tree[pos].val > num) {
-        // tree[pos].size--;
+    if (vals[pos] > num) {
+        tree[pos].size--;
         tree[pos].left = delete_node(num, tree[pos].left);
         return pos;
     }
 
     // If reached here, tree[pos].val == num, so we are going to delete tree[pos]
-    if (tree[pos].left < 0) {
+    if (tree[pos].left == NOTHING) {
         // The case when left is null, right is something
         // and also the case when both left and right is null
         return tree[pos].right;
     }
 
-    if (tree[pos].right < 0) {
+    if (tree[pos].right == NOTHING) {
         // The case when left is something while right is null
         return tree[pos].left;
     }
@@ -94,8 +100,8 @@ int delete_node(int num, int pos) {
     // Here, we deal with the case that both children exist.
     int parent = pos;
     int child = tree[parent].right;
-    // tree[parent].size--;
-    while (tree[child].left >= 0) {
+    tree[parent].size--;
+    while (tree[child].left < NOTHING) {
         parent = child;
         child = tree[child].left;
         // tree[parent].size--;
@@ -117,16 +123,16 @@ int delete_node(int num, int pos) {
 }
 
 int traverse(int pos) {
-    if (pos < 0) {
+    if (pos == NOTHING) {
         return 0;
     }
-    printf("%d(", tree[pos].val);
-    if (tree[pos].left >= 0) {
-        printf("l%d:", tree[pos].val);
+    printf("%d(", vals[pos]);
+    if (tree[pos].left < NOTHING) {
+        printf("l%d:", vals[pos]);
         traverse(tree[pos].left);
     }
-    if (tree[pos].right >= 0) {
-        printf("r%d:", tree[pos].val);
+    if (tree[pos].right < NOTHING) {
+        printf("r%d:", vals[pos]);
         traverse(tree[pos].right);
     }
     printf(")");
@@ -140,35 +146,27 @@ int traverse(int pos) {
     return 0;
 }
 
-int get_size(int pos) {
-    if (pos < 0) {
-        return 0;
-    }
-    return 1 + get_size(tree[pos].left) + get_size(tree[pos].right);
-}
-
 int count_less_than(long long target, int pos) {
-    if (pos < 0) {
+    if (pos == NOTHING) {
         return 0;
     }
 
-    if (tree[pos].val < target) {
-        // if (tree[pos].left < 0) {
-        //     return 1 + count_less_than(target, tree[pos].right);
-        // }
-        // return tree[tree[pos].left].size + 1 + count_less_than(target, tree[pos].right);
-        return get_size(tree[pos].left) + 1 + count_less_than(target, tree[pos].right);
+    if (vals[pos] < target) {
+        if (tree[pos].left == NOTHING) {
+            return 1 + count_less_than(target, tree[pos].right);
+        }
+        return tree[tree[pos].left].size + 1 + count_less_than(target, tree[pos].right);
     }
-    if (tree[pos].val > target) {
+    if (vals[pos] > target) {
         return count_less_than(target, tree[pos].left);
     }
 
     // tree[pos].val == target
 
-    // if (tree[pos].left < 0) {
-    //     return 1;
-    // }
-    return 1 + get_size(tree[pos].left);
+    if (tree[pos].left == NOTHING) {
+        return 1;
+    }
+    return 1 + tree[tree[pos].left].size;
 }
 
 int main() {