diff --git a/codegen/dbl_list/make_dbl_list.py b/codegen/dbl_list/make_dbl_list.py
index 9534da0..c6b3409 100644
--- a/codegen/dbl_list/make_dbl_list.py
+++ b/codegen/dbl_list/make_dbl_list.py
@@ -50,7 +50,9 @@ def make_dbl_list(user_datatypes: dict[CDataType, DblListData] = {}):
     common_local_include_files = [
         (WAPP_SRC_ROOT / "common" / "aliases" / "aliases.h")
     ]
-    common_includes: list[CInclude] = []
+    common_includes: list[CInclude] = [
+        CInclude(header="stdbool.h")
+    ]
     for local_file in common_local_include_files:
         common_includes.append(
             CInclude(
@@ -70,6 +72,27 @@ def make_dbl_list(user_datatypes: dict[CDataType, DblListData] = {}):
             ],
         ),
     }
+
+    for _type in CType:
+        if _type == CType.VOID:
+            datatypes["void *"] = DblListData(
+                node_typename="VoidPNode",
+                list_typename="VoidPList",
+            )
+            continue
+        elif _type == CType.BOOL:
+            datatypes[_type.value] = DblListData(
+                node_typename="BoolNode",
+                list_typename="BoolList",
+            )
+            continue
+
+        type_title = _type.value.title()
+        datatypes[_type.value] = DblListData(
+            node_typename=f"{type_title}Node",
+            list_typename=f"{type_title}List",
+        )
+
     datatypes.update(user_datatypes)
 
     snippets_dir = Path(__file__).parent / "snippets"
diff --git a/src/containers/dbl_list/dbl_list.c b/src/containers/dbl_list/dbl_list.c
index 95ac0c2..f59ee2c 100644
--- a/src/containers/dbl_list/dbl_list.c
+++ b/src/containers/dbl_list/dbl_list.c
@@ -5,8 +5,28 @@
 #include "./dbl_list.h"
 #include "../../common/aliases/aliases.h"
 #include <stddef.h>
+#include <stdbool.h>
 
 internal Str8List str8_node_to_list(Str8Node *node);
+internal VoidPList void_ptr_node_to_list(VoidPNode *node);
+internal BoolList bool_node_to_list(BoolNode *node);
+internal CharList char_node_to_list(CharNode *node);
+internal C8List c8_node_to_list(C8Node *node);
+internal C16List c16_node_to_list(C16Node *node);
+internal C32List c32_node_to_list(C32Node *node);
+internal I8List i8_node_to_list(I8Node *node);
+internal I16List i16_node_to_list(I16Node *node);
+internal I32List i32_node_to_list(I32Node *node);
+internal I64List i64_node_to_list(I64Node *node);
+internal U8List u8_node_to_list(U8Node *node);
+internal U16List u16_node_to_list(U16Node *node);
+internal U32List u32_node_to_list(U32Node *node);
+internal U64List u64_node_to_list(U64Node *node);
+internal F32List f32_node_to_list(F32Node *node);
+internal F64List f64_node_to_list(F64Node *node);
+internal F128List f128_node_to_list(F128Node *node);
+internal IptrList iptr_node_to_list(IptrNode *node);
+internal UptrList uptr_node_to_list(UptrNode *node);
 
 Str8Node *wapp_str8_list_get(const Str8List *list, u64 index) {
   if (index >= list->node_count) {
@@ -188,6 +208,3426 @@ void wapp_str8_list_empty(Str8List *list) {
   }
 }
 
+VoidPNode *wapp_void_ptr_list_get(const VoidPList *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  VoidPNode *output  = NULL;
+  VoidPNode *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_void_ptr_list_push_front(VoidPList *list, VoidPNode *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  VoidPList node_list = void_ptr_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  VoidPNode *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_void_ptr_list_push_back(VoidPList *list, VoidPNode *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  VoidPList node_list = void_ptr_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  VoidPNode *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_void_ptr_list_insert(VoidPList *list, VoidPNode *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_void_ptr_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_void_ptr_list_push_back(list, node);
+    return;
+  }
+
+  VoidPNode *dst_node = wapp_void_ptr_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  VoidPList node_list = void_ptr_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  VoidPNode *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+VoidPNode *wapp_void_ptr_list_pop_front(VoidPList *list) {
+  VoidPNode *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_VOID_PTR_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (VoidPList){0};
+    goto RETURN_VOID_PTR_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_VOID_PTR_LIST_POP_FRONT:
+  return output;
+}
+
+VoidPNode *wapp_void_ptr_list_pop_back(VoidPList *list) {
+  VoidPNode *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_VOID_PTR_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (VoidPList){0};
+    goto RETURN_VOID_PTR_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_VOID_PTR_LIST_POP_BACK:
+  return output;
+}
+
+VoidPNode *wapp_void_ptr_list_remove(VoidPList *list, u64 index) {
+  VoidPNode *output = NULL;
+  if (!list) {
+    goto RETURN_VOID_PTR_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_void_ptr_list_pop_front(list);
+    goto RETURN_VOID_PTR_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_void_ptr_list_pop_back(list);
+    goto RETURN_VOID_PTR_LIST_REMOVE;
+  }
+
+  output = wapp_void_ptr_list_get(list, index);
+  if (!output) {
+    goto RETURN_VOID_PTR_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_VOID_PTR_LIST_REMOVE:
+  return output;
+}
+
+void wapp_void_ptr_list_empty(VoidPList *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_void_ptr_list_pop_back(list);
+  }
+}
+
+BoolNode *wapp_bool_list_get(const BoolList *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  BoolNode *output  = NULL;
+  BoolNode *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_bool_list_push_front(BoolList *list, BoolNode *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  BoolList node_list = bool_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  BoolNode *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_bool_list_push_back(BoolList *list, BoolNode *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  BoolList node_list = bool_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  BoolNode *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_bool_list_insert(BoolList *list, BoolNode *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_bool_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_bool_list_push_back(list, node);
+    return;
+  }
+
+  BoolNode *dst_node = wapp_bool_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  BoolList node_list = bool_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  BoolNode *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+BoolNode *wapp_bool_list_pop_front(BoolList *list) {
+  BoolNode *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_BOOL_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (BoolList){0};
+    goto RETURN_BOOL_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_BOOL_LIST_POP_FRONT:
+  return output;
+}
+
+BoolNode *wapp_bool_list_pop_back(BoolList *list) {
+  BoolNode *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_BOOL_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (BoolList){0};
+    goto RETURN_BOOL_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_BOOL_LIST_POP_BACK:
+  return output;
+}
+
+BoolNode *wapp_bool_list_remove(BoolList *list, u64 index) {
+  BoolNode *output = NULL;
+  if (!list) {
+    goto RETURN_BOOL_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_bool_list_pop_front(list);
+    goto RETURN_BOOL_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_bool_list_pop_back(list);
+    goto RETURN_BOOL_LIST_REMOVE;
+  }
+
+  output = wapp_bool_list_get(list, index);
+  if (!output) {
+    goto RETURN_BOOL_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_BOOL_LIST_REMOVE:
+  return output;
+}
+
+void wapp_bool_list_empty(BoolList *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_bool_list_pop_back(list);
+  }
+}
+
+CharNode *wapp_char_list_get(const CharList *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  CharNode *output  = NULL;
+  CharNode *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_char_list_push_front(CharList *list, CharNode *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  CharList node_list = char_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  CharNode *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_char_list_push_back(CharList *list, CharNode *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  CharList node_list = char_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  CharNode *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_char_list_insert(CharList *list, CharNode *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_char_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_char_list_push_back(list, node);
+    return;
+  }
+
+  CharNode *dst_node = wapp_char_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  CharList node_list = char_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  CharNode *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+CharNode *wapp_char_list_pop_front(CharList *list) {
+  CharNode *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_CHAR_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (CharList){0};
+    goto RETURN_CHAR_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_CHAR_LIST_POP_FRONT:
+  return output;
+}
+
+CharNode *wapp_char_list_pop_back(CharList *list) {
+  CharNode *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_CHAR_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (CharList){0};
+    goto RETURN_CHAR_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_CHAR_LIST_POP_BACK:
+  return output;
+}
+
+CharNode *wapp_char_list_remove(CharList *list, u64 index) {
+  CharNode *output = NULL;
+  if (!list) {
+    goto RETURN_CHAR_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_char_list_pop_front(list);
+    goto RETURN_CHAR_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_char_list_pop_back(list);
+    goto RETURN_CHAR_LIST_REMOVE;
+  }
+
+  output = wapp_char_list_get(list, index);
+  if (!output) {
+    goto RETURN_CHAR_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_CHAR_LIST_REMOVE:
+  return output;
+}
+
+void wapp_char_list_empty(CharList *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_char_list_pop_back(list);
+  }
+}
+
+C8Node *wapp_c8_list_get(const C8List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  C8Node *output  = NULL;
+  C8Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_c8_list_push_front(C8List *list, C8Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  C8List node_list = c8_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  C8Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_c8_list_push_back(C8List *list, C8Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  C8List node_list = c8_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  C8Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_c8_list_insert(C8List *list, C8Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_c8_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_c8_list_push_back(list, node);
+    return;
+  }
+
+  C8Node *dst_node = wapp_c8_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  C8List node_list = c8_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  C8Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+C8Node *wapp_c8_list_pop_front(C8List *list) {
+  C8Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_C8_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (C8List){0};
+    goto RETURN_C8_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_C8_LIST_POP_FRONT:
+  return output;
+}
+
+C8Node *wapp_c8_list_pop_back(C8List *list) {
+  C8Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_C8_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (C8List){0};
+    goto RETURN_C8_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_C8_LIST_POP_BACK:
+  return output;
+}
+
+C8Node *wapp_c8_list_remove(C8List *list, u64 index) {
+  C8Node *output = NULL;
+  if (!list) {
+    goto RETURN_C8_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_c8_list_pop_front(list);
+    goto RETURN_C8_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_c8_list_pop_back(list);
+    goto RETURN_C8_LIST_REMOVE;
+  }
+
+  output = wapp_c8_list_get(list, index);
+  if (!output) {
+    goto RETURN_C8_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_C8_LIST_REMOVE:
+  return output;
+}
+
+void wapp_c8_list_empty(C8List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_c8_list_pop_back(list);
+  }
+}
+
+C16Node *wapp_c16_list_get(const C16List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  C16Node *output  = NULL;
+  C16Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_c16_list_push_front(C16List *list, C16Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  C16List node_list = c16_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  C16Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_c16_list_push_back(C16List *list, C16Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  C16List node_list = c16_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  C16Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_c16_list_insert(C16List *list, C16Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_c16_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_c16_list_push_back(list, node);
+    return;
+  }
+
+  C16Node *dst_node = wapp_c16_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  C16List node_list = c16_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  C16Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+C16Node *wapp_c16_list_pop_front(C16List *list) {
+  C16Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_C16_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (C16List){0};
+    goto RETURN_C16_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_C16_LIST_POP_FRONT:
+  return output;
+}
+
+C16Node *wapp_c16_list_pop_back(C16List *list) {
+  C16Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_C16_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (C16List){0};
+    goto RETURN_C16_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_C16_LIST_POP_BACK:
+  return output;
+}
+
+C16Node *wapp_c16_list_remove(C16List *list, u64 index) {
+  C16Node *output = NULL;
+  if (!list) {
+    goto RETURN_C16_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_c16_list_pop_front(list);
+    goto RETURN_C16_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_c16_list_pop_back(list);
+    goto RETURN_C16_LIST_REMOVE;
+  }
+
+  output = wapp_c16_list_get(list, index);
+  if (!output) {
+    goto RETURN_C16_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_C16_LIST_REMOVE:
+  return output;
+}
+
+void wapp_c16_list_empty(C16List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_c16_list_pop_back(list);
+  }
+}
+
+C32Node *wapp_c32_list_get(const C32List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  C32Node *output  = NULL;
+  C32Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_c32_list_push_front(C32List *list, C32Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  C32List node_list = c32_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  C32Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_c32_list_push_back(C32List *list, C32Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  C32List node_list = c32_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  C32Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_c32_list_insert(C32List *list, C32Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_c32_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_c32_list_push_back(list, node);
+    return;
+  }
+
+  C32Node *dst_node = wapp_c32_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  C32List node_list = c32_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  C32Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+C32Node *wapp_c32_list_pop_front(C32List *list) {
+  C32Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_C32_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (C32List){0};
+    goto RETURN_C32_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_C32_LIST_POP_FRONT:
+  return output;
+}
+
+C32Node *wapp_c32_list_pop_back(C32List *list) {
+  C32Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_C32_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (C32List){0};
+    goto RETURN_C32_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_C32_LIST_POP_BACK:
+  return output;
+}
+
+C32Node *wapp_c32_list_remove(C32List *list, u64 index) {
+  C32Node *output = NULL;
+  if (!list) {
+    goto RETURN_C32_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_c32_list_pop_front(list);
+    goto RETURN_C32_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_c32_list_pop_back(list);
+    goto RETURN_C32_LIST_REMOVE;
+  }
+
+  output = wapp_c32_list_get(list, index);
+  if (!output) {
+    goto RETURN_C32_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_C32_LIST_REMOVE:
+  return output;
+}
+
+void wapp_c32_list_empty(C32List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_c32_list_pop_back(list);
+  }
+}
+
+I8Node *wapp_i8_list_get(const I8List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  I8Node *output  = NULL;
+  I8Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_i8_list_push_front(I8List *list, I8Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  I8List node_list = i8_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  I8Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_i8_list_push_back(I8List *list, I8Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  I8List node_list = i8_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  I8Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_i8_list_insert(I8List *list, I8Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_i8_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_i8_list_push_back(list, node);
+    return;
+  }
+
+  I8Node *dst_node = wapp_i8_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  I8List node_list = i8_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  I8Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+I8Node *wapp_i8_list_pop_front(I8List *list) {
+  I8Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_I8_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (I8List){0};
+    goto RETURN_I8_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_I8_LIST_POP_FRONT:
+  return output;
+}
+
+I8Node *wapp_i8_list_pop_back(I8List *list) {
+  I8Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_I8_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (I8List){0};
+    goto RETURN_I8_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_I8_LIST_POP_BACK:
+  return output;
+}
+
+I8Node *wapp_i8_list_remove(I8List *list, u64 index) {
+  I8Node *output = NULL;
+  if (!list) {
+    goto RETURN_I8_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_i8_list_pop_front(list);
+    goto RETURN_I8_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_i8_list_pop_back(list);
+    goto RETURN_I8_LIST_REMOVE;
+  }
+
+  output = wapp_i8_list_get(list, index);
+  if (!output) {
+    goto RETURN_I8_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_I8_LIST_REMOVE:
+  return output;
+}
+
+void wapp_i8_list_empty(I8List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_i8_list_pop_back(list);
+  }
+}
+
+I16Node *wapp_i16_list_get(const I16List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  I16Node *output  = NULL;
+  I16Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_i16_list_push_front(I16List *list, I16Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  I16List node_list = i16_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  I16Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_i16_list_push_back(I16List *list, I16Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  I16List node_list = i16_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  I16Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_i16_list_insert(I16List *list, I16Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_i16_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_i16_list_push_back(list, node);
+    return;
+  }
+
+  I16Node *dst_node = wapp_i16_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  I16List node_list = i16_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  I16Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+I16Node *wapp_i16_list_pop_front(I16List *list) {
+  I16Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_I16_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (I16List){0};
+    goto RETURN_I16_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_I16_LIST_POP_FRONT:
+  return output;
+}
+
+I16Node *wapp_i16_list_pop_back(I16List *list) {
+  I16Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_I16_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (I16List){0};
+    goto RETURN_I16_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_I16_LIST_POP_BACK:
+  return output;
+}
+
+I16Node *wapp_i16_list_remove(I16List *list, u64 index) {
+  I16Node *output = NULL;
+  if (!list) {
+    goto RETURN_I16_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_i16_list_pop_front(list);
+    goto RETURN_I16_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_i16_list_pop_back(list);
+    goto RETURN_I16_LIST_REMOVE;
+  }
+
+  output = wapp_i16_list_get(list, index);
+  if (!output) {
+    goto RETURN_I16_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_I16_LIST_REMOVE:
+  return output;
+}
+
+void wapp_i16_list_empty(I16List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_i16_list_pop_back(list);
+  }
+}
+
+I32Node *wapp_i32_list_get(const I32List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  I32Node *output  = NULL;
+  I32Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_i32_list_push_front(I32List *list, I32Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  I32List node_list = i32_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  I32Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_i32_list_push_back(I32List *list, I32Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  I32List node_list = i32_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  I32Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_i32_list_insert(I32List *list, I32Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_i32_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_i32_list_push_back(list, node);
+    return;
+  }
+
+  I32Node *dst_node = wapp_i32_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  I32List node_list = i32_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  I32Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+I32Node *wapp_i32_list_pop_front(I32List *list) {
+  I32Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_I32_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (I32List){0};
+    goto RETURN_I32_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_I32_LIST_POP_FRONT:
+  return output;
+}
+
+I32Node *wapp_i32_list_pop_back(I32List *list) {
+  I32Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_I32_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (I32List){0};
+    goto RETURN_I32_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_I32_LIST_POP_BACK:
+  return output;
+}
+
+I32Node *wapp_i32_list_remove(I32List *list, u64 index) {
+  I32Node *output = NULL;
+  if (!list) {
+    goto RETURN_I32_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_i32_list_pop_front(list);
+    goto RETURN_I32_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_i32_list_pop_back(list);
+    goto RETURN_I32_LIST_REMOVE;
+  }
+
+  output = wapp_i32_list_get(list, index);
+  if (!output) {
+    goto RETURN_I32_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_I32_LIST_REMOVE:
+  return output;
+}
+
+void wapp_i32_list_empty(I32List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_i32_list_pop_back(list);
+  }
+}
+
+I64Node *wapp_i64_list_get(const I64List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  I64Node *output  = NULL;
+  I64Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_i64_list_push_front(I64List *list, I64Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  I64List node_list = i64_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  I64Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_i64_list_push_back(I64List *list, I64Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  I64List node_list = i64_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  I64Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_i64_list_insert(I64List *list, I64Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_i64_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_i64_list_push_back(list, node);
+    return;
+  }
+
+  I64Node *dst_node = wapp_i64_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  I64List node_list = i64_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  I64Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+I64Node *wapp_i64_list_pop_front(I64List *list) {
+  I64Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_I64_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (I64List){0};
+    goto RETURN_I64_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_I64_LIST_POP_FRONT:
+  return output;
+}
+
+I64Node *wapp_i64_list_pop_back(I64List *list) {
+  I64Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_I64_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (I64List){0};
+    goto RETURN_I64_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_I64_LIST_POP_BACK:
+  return output;
+}
+
+I64Node *wapp_i64_list_remove(I64List *list, u64 index) {
+  I64Node *output = NULL;
+  if (!list) {
+    goto RETURN_I64_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_i64_list_pop_front(list);
+    goto RETURN_I64_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_i64_list_pop_back(list);
+    goto RETURN_I64_LIST_REMOVE;
+  }
+
+  output = wapp_i64_list_get(list, index);
+  if (!output) {
+    goto RETURN_I64_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_I64_LIST_REMOVE:
+  return output;
+}
+
+void wapp_i64_list_empty(I64List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_i64_list_pop_back(list);
+  }
+}
+
+U8Node *wapp_u8_list_get(const U8List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  U8Node *output  = NULL;
+  U8Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_u8_list_push_front(U8List *list, U8Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  U8List node_list = u8_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  U8Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_u8_list_push_back(U8List *list, U8Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  U8List node_list = u8_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  U8Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_u8_list_insert(U8List *list, U8Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_u8_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_u8_list_push_back(list, node);
+    return;
+  }
+
+  U8Node *dst_node = wapp_u8_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  U8List node_list = u8_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  U8Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+U8Node *wapp_u8_list_pop_front(U8List *list) {
+  U8Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_U8_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (U8List){0};
+    goto RETURN_U8_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_U8_LIST_POP_FRONT:
+  return output;
+}
+
+U8Node *wapp_u8_list_pop_back(U8List *list) {
+  U8Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_U8_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (U8List){0};
+    goto RETURN_U8_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_U8_LIST_POP_BACK:
+  return output;
+}
+
+U8Node *wapp_u8_list_remove(U8List *list, u64 index) {
+  U8Node *output = NULL;
+  if (!list) {
+    goto RETURN_U8_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_u8_list_pop_front(list);
+    goto RETURN_U8_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_u8_list_pop_back(list);
+    goto RETURN_U8_LIST_REMOVE;
+  }
+
+  output = wapp_u8_list_get(list, index);
+  if (!output) {
+    goto RETURN_U8_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_U8_LIST_REMOVE:
+  return output;
+}
+
+void wapp_u8_list_empty(U8List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_u8_list_pop_back(list);
+  }
+}
+
+U16Node *wapp_u16_list_get(const U16List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  U16Node *output  = NULL;
+  U16Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_u16_list_push_front(U16List *list, U16Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  U16List node_list = u16_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  U16Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_u16_list_push_back(U16List *list, U16Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  U16List node_list = u16_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  U16Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_u16_list_insert(U16List *list, U16Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_u16_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_u16_list_push_back(list, node);
+    return;
+  }
+
+  U16Node *dst_node = wapp_u16_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  U16List node_list = u16_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  U16Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+U16Node *wapp_u16_list_pop_front(U16List *list) {
+  U16Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_U16_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (U16List){0};
+    goto RETURN_U16_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_U16_LIST_POP_FRONT:
+  return output;
+}
+
+U16Node *wapp_u16_list_pop_back(U16List *list) {
+  U16Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_U16_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (U16List){0};
+    goto RETURN_U16_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_U16_LIST_POP_BACK:
+  return output;
+}
+
+U16Node *wapp_u16_list_remove(U16List *list, u64 index) {
+  U16Node *output = NULL;
+  if (!list) {
+    goto RETURN_U16_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_u16_list_pop_front(list);
+    goto RETURN_U16_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_u16_list_pop_back(list);
+    goto RETURN_U16_LIST_REMOVE;
+  }
+
+  output = wapp_u16_list_get(list, index);
+  if (!output) {
+    goto RETURN_U16_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_U16_LIST_REMOVE:
+  return output;
+}
+
+void wapp_u16_list_empty(U16List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_u16_list_pop_back(list);
+  }
+}
+
+U32Node *wapp_u32_list_get(const U32List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  U32Node *output  = NULL;
+  U32Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_u32_list_push_front(U32List *list, U32Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  U32List node_list = u32_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  U32Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_u32_list_push_back(U32List *list, U32Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  U32List node_list = u32_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  U32Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_u32_list_insert(U32List *list, U32Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_u32_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_u32_list_push_back(list, node);
+    return;
+  }
+
+  U32Node *dst_node = wapp_u32_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  U32List node_list = u32_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  U32Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+U32Node *wapp_u32_list_pop_front(U32List *list) {
+  U32Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_U32_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (U32List){0};
+    goto RETURN_U32_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_U32_LIST_POP_FRONT:
+  return output;
+}
+
+U32Node *wapp_u32_list_pop_back(U32List *list) {
+  U32Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_U32_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (U32List){0};
+    goto RETURN_U32_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_U32_LIST_POP_BACK:
+  return output;
+}
+
+U32Node *wapp_u32_list_remove(U32List *list, u64 index) {
+  U32Node *output = NULL;
+  if (!list) {
+    goto RETURN_U32_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_u32_list_pop_front(list);
+    goto RETURN_U32_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_u32_list_pop_back(list);
+    goto RETURN_U32_LIST_REMOVE;
+  }
+
+  output = wapp_u32_list_get(list, index);
+  if (!output) {
+    goto RETURN_U32_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_U32_LIST_REMOVE:
+  return output;
+}
+
+void wapp_u32_list_empty(U32List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_u32_list_pop_back(list);
+  }
+}
+
+U64Node *wapp_u64_list_get(const U64List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  U64Node *output  = NULL;
+  U64Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_u64_list_push_front(U64List *list, U64Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  U64List node_list = u64_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  U64Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_u64_list_push_back(U64List *list, U64Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  U64List node_list = u64_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  U64Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_u64_list_insert(U64List *list, U64Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_u64_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_u64_list_push_back(list, node);
+    return;
+  }
+
+  U64Node *dst_node = wapp_u64_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  U64List node_list = u64_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  U64Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+U64Node *wapp_u64_list_pop_front(U64List *list) {
+  U64Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_U64_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (U64List){0};
+    goto RETURN_U64_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_U64_LIST_POP_FRONT:
+  return output;
+}
+
+U64Node *wapp_u64_list_pop_back(U64List *list) {
+  U64Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_U64_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (U64List){0};
+    goto RETURN_U64_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_U64_LIST_POP_BACK:
+  return output;
+}
+
+U64Node *wapp_u64_list_remove(U64List *list, u64 index) {
+  U64Node *output = NULL;
+  if (!list) {
+    goto RETURN_U64_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_u64_list_pop_front(list);
+    goto RETURN_U64_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_u64_list_pop_back(list);
+    goto RETURN_U64_LIST_REMOVE;
+  }
+
+  output = wapp_u64_list_get(list, index);
+  if (!output) {
+    goto RETURN_U64_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_U64_LIST_REMOVE:
+  return output;
+}
+
+void wapp_u64_list_empty(U64List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_u64_list_pop_back(list);
+  }
+}
+
+F32Node *wapp_f32_list_get(const F32List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  F32Node *output  = NULL;
+  F32Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_f32_list_push_front(F32List *list, F32Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  F32List node_list = f32_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  F32Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_f32_list_push_back(F32List *list, F32Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  F32List node_list = f32_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  F32Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_f32_list_insert(F32List *list, F32Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_f32_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_f32_list_push_back(list, node);
+    return;
+  }
+
+  F32Node *dst_node = wapp_f32_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  F32List node_list = f32_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  F32Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+F32Node *wapp_f32_list_pop_front(F32List *list) {
+  F32Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_F32_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (F32List){0};
+    goto RETURN_F32_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_F32_LIST_POP_FRONT:
+  return output;
+}
+
+F32Node *wapp_f32_list_pop_back(F32List *list) {
+  F32Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_F32_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (F32List){0};
+    goto RETURN_F32_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_F32_LIST_POP_BACK:
+  return output;
+}
+
+F32Node *wapp_f32_list_remove(F32List *list, u64 index) {
+  F32Node *output = NULL;
+  if (!list) {
+    goto RETURN_F32_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_f32_list_pop_front(list);
+    goto RETURN_F32_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_f32_list_pop_back(list);
+    goto RETURN_F32_LIST_REMOVE;
+  }
+
+  output = wapp_f32_list_get(list, index);
+  if (!output) {
+    goto RETURN_F32_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_F32_LIST_REMOVE:
+  return output;
+}
+
+void wapp_f32_list_empty(F32List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_f32_list_pop_back(list);
+  }
+}
+
+F64Node *wapp_f64_list_get(const F64List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  F64Node *output  = NULL;
+  F64Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_f64_list_push_front(F64List *list, F64Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  F64List node_list = f64_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  F64Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_f64_list_push_back(F64List *list, F64Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  F64List node_list = f64_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  F64Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_f64_list_insert(F64List *list, F64Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_f64_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_f64_list_push_back(list, node);
+    return;
+  }
+
+  F64Node *dst_node = wapp_f64_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  F64List node_list = f64_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  F64Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+F64Node *wapp_f64_list_pop_front(F64List *list) {
+  F64Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_F64_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (F64List){0};
+    goto RETURN_F64_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_F64_LIST_POP_FRONT:
+  return output;
+}
+
+F64Node *wapp_f64_list_pop_back(F64List *list) {
+  F64Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_F64_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (F64List){0};
+    goto RETURN_F64_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_F64_LIST_POP_BACK:
+  return output;
+}
+
+F64Node *wapp_f64_list_remove(F64List *list, u64 index) {
+  F64Node *output = NULL;
+  if (!list) {
+    goto RETURN_F64_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_f64_list_pop_front(list);
+    goto RETURN_F64_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_f64_list_pop_back(list);
+    goto RETURN_F64_LIST_REMOVE;
+  }
+
+  output = wapp_f64_list_get(list, index);
+  if (!output) {
+    goto RETURN_F64_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_F64_LIST_REMOVE:
+  return output;
+}
+
+void wapp_f64_list_empty(F64List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_f64_list_pop_back(list);
+  }
+}
+
+F128Node *wapp_f128_list_get(const F128List *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  F128Node *output  = NULL;
+  F128Node *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_f128_list_push_front(F128List *list, F128Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  F128List node_list = f128_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  F128Node *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_f128_list_push_back(F128List *list, F128Node *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  F128List node_list = f128_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  F128Node *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_f128_list_insert(F128List *list, F128Node *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_f128_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_f128_list_push_back(list, node);
+    return;
+  }
+
+  F128Node *dst_node = wapp_f128_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  F128List node_list = f128_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  F128Node *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+F128Node *wapp_f128_list_pop_front(F128List *list) {
+  F128Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_F128_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (F128List){0};
+    goto RETURN_F128_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_F128_LIST_POP_FRONT:
+  return output;
+}
+
+F128Node *wapp_f128_list_pop_back(F128List *list) {
+  F128Node *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_F128_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (F128List){0};
+    goto RETURN_F128_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_F128_LIST_POP_BACK:
+  return output;
+}
+
+F128Node *wapp_f128_list_remove(F128List *list, u64 index) {
+  F128Node *output = NULL;
+  if (!list) {
+    goto RETURN_F128_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_f128_list_pop_front(list);
+    goto RETURN_F128_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_f128_list_pop_back(list);
+    goto RETURN_F128_LIST_REMOVE;
+  }
+
+  output = wapp_f128_list_get(list, index);
+  if (!output) {
+    goto RETURN_F128_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_F128_LIST_REMOVE:
+  return output;
+}
+
+void wapp_f128_list_empty(F128List *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_f128_list_pop_back(list);
+  }
+}
+
+IptrNode *wapp_iptr_list_get(const IptrList *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  IptrNode *output  = NULL;
+  IptrNode *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_iptr_list_push_front(IptrList *list, IptrNode *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  IptrList node_list = iptr_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  IptrNode *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_iptr_list_push_back(IptrList *list, IptrNode *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  IptrList node_list = iptr_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  IptrNode *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_iptr_list_insert(IptrList *list, IptrNode *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_iptr_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_iptr_list_push_back(list, node);
+    return;
+  }
+
+  IptrNode *dst_node = wapp_iptr_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  IptrList node_list = iptr_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  IptrNode *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+IptrNode *wapp_iptr_list_pop_front(IptrList *list) {
+  IptrNode *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_IPTR_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (IptrList){0};
+    goto RETURN_IPTR_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_IPTR_LIST_POP_FRONT:
+  return output;
+}
+
+IptrNode *wapp_iptr_list_pop_back(IptrList *list) {
+  IptrNode *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_IPTR_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (IptrList){0};
+    goto RETURN_IPTR_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_IPTR_LIST_POP_BACK:
+  return output;
+}
+
+IptrNode *wapp_iptr_list_remove(IptrList *list, u64 index) {
+  IptrNode *output = NULL;
+  if (!list) {
+    goto RETURN_IPTR_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_iptr_list_pop_front(list);
+    goto RETURN_IPTR_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_iptr_list_pop_back(list);
+    goto RETURN_IPTR_LIST_REMOVE;
+  }
+
+  output = wapp_iptr_list_get(list, index);
+  if (!output) {
+    goto RETURN_IPTR_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_IPTR_LIST_REMOVE:
+  return output;
+}
+
+void wapp_iptr_list_empty(IptrList *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_iptr_list_pop_back(list);
+  }
+}
+
+UptrNode *wapp_uptr_list_get(const UptrList *list, u64 index) {
+  if (index >= list->node_count) {
+    return NULL;
+  }
+
+  UptrNode *output  = NULL;
+  UptrNode *current = list->first;
+  for (u64 i = 1; i <= index; ++i) {
+    current = current->next;
+  }
+
+  output = current;
+
+  return output;
+}
+
+void wapp_uptr_list_push_front(UptrList *list, UptrNode *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  UptrList node_list = uptr_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  UptrNode *first = list->first;
+  if (first) {
+    first->prev = node_list.last;
+  }
+
+  list->first          = node_list.first;
+  node_list.last->next = first;
+}
+
+void wapp_uptr_list_push_back(UptrList *list, UptrNode *node) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  UptrList node_list = uptr_node_to_list(node);
+
+  if (list->node_count == 0) {
+    *list = node_list;
+    return;
+  }
+
+  list->node_count += node_list.node_count;
+
+  UptrNode *last = list->last;
+  if (last) {
+    last->next = node_list.first;
+  }
+
+  list->last            = node_list.last;
+  node_list.first->prev = last;
+}
+
+void wapp_uptr_list_insert(UptrList *list, UptrNode *node, u64 index) {
+  if (!list || !node || !(node->item)) {
+    return;
+  }
+
+  if (index == 0) {
+    wapp_uptr_list_push_front(list, node);
+    return;
+  } else if (index == list->node_count) {
+    wapp_uptr_list_push_back(list, node);
+    return;
+  }
+
+  UptrNode *dst_node = wapp_uptr_list_get(list, index);
+  if (!dst_node) {
+    return;
+  }
+
+  UptrList node_list = uptr_node_to_list(node);
+
+  list->node_count += node_list.node_count;
+
+  UptrNode *prev = dst_node->prev;
+
+  dst_node->prev = node_list.last;
+  prev->next     = node_list.first;
+
+  node_list.first->prev = prev;
+  node_list.last->next  = dst_node;
+}
+
+UptrNode *wapp_uptr_list_pop_front(UptrList *list) {
+  UptrNode *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_UPTR_LIST_POP_FRONT;
+  }
+
+  output = list->first;
+
+  if (list->node_count == 1) {
+    *list = (UptrList){0};
+    goto RETURN_UPTR_LIST_POP_FRONT;
+  }
+
+  --(list->node_count);
+  list->first       = output->next;
+
+  output->prev = output->next = NULL;
+
+RETURN_UPTR_LIST_POP_FRONT:
+  return output;
+}
+
+UptrNode *wapp_uptr_list_pop_back(UptrList *list) {
+  UptrNode *output = NULL;
+
+  if (!list || list->node_count == 0) {
+    goto RETURN_UPTR_LIST_POP_BACK;
+  }
+
+  output = list->last;
+
+  if (list->node_count == 1) {
+    *list = (UptrList){0};
+    goto RETURN_UPTR_LIST_POP_BACK;
+  }
+
+  --(list->node_count);
+  list->last        = output->prev;
+
+  output->prev = output->next = NULL;
+
+RETURN_UPTR_LIST_POP_BACK:
+  return output;
+}
+
+UptrNode *wapp_uptr_list_remove(UptrList *list, u64 index) {
+  UptrNode *output = NULL;
+  if (!list) {
+    goto RETURN_UPTR_LIST_REMOVE;
+  }
+
+  if (index == 0) {
+    output = wapp_uptr_list_pop_front(list);
+    goto RETURN_UPTR_LIST_REMOVE;
+  } else if (index == list->node_count) {
+    output = wapp_uptr_list_pop_back(list);
+    goto RETURN_UPTR_LIST_REMOVE;
+  }
+
+  output = wapp_uptr_list_get(list, index);
+  if (!output) {
+    goto RETURN_UPTR_LIST_REMOVE;
+  }
+
+  output->prev->next = output->next;
+  output->next->prev = output->prev;
+
+  --(list->node_count);
+
+  output->prev = output->next = NULL;
+
+RETURN_UPTR_LIST_REMOVE:
+  return output;
+}
+
+void wapp_uptr_list_empty(UptrList *list) {
+  if (!list) {
+    return;
+  }
+
+  u64 count = list->node_count;
+  for (u64 i = 0; i < count; ++i) {
+    wapp_uptr_list_pop_back(list);
+  }
+}
+
 internal Str8List str8_node_to_list(Str8Node *node) {
   Str8List output = {.first = node, .last = node, .node_count = 1};
 
@@ -204,3 +3644,307 @@ internal Str8List str8_node_to_list(Str8Node *node) {
   return output;
 }
 
+internal VoidPList void_ptr_node_to_list(VoidPNode *node) {
+  VoidPList output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal BoolList bool_node_to_list(BoolNode *node) {
+  BoolList output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal CharList char_node_to_list(CharNode *node) {
+  CharList output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal C8List c8_node_to_list(C8Node *node) {
+  C8List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal C16List c16_node_to_list(C16Node *node) {
+  C16List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal C32List c32_node_to_list(C32Node *node) {
+  C32List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal I8List i8_node_to_list(I8Node *node) {
+  I8List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal I16List i16_node_to_list(I16Node *node) {
+  I16List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal I32List i32_node_to_list(I32Node *node) {
+  I32List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal I64List i64_node_to_list(I64Node *node) {
+  I64List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal U8List u8_node_to_list(U8Node *node) {
+  U8List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal U16List u16_node_to_list(U16Node *node) {
+  U16List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal U32List u32_node_to_list(U32Node *node) {
+  U32List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal U64List u64_node_to_list(U64Node *node) {
+  U64List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal F32List f32_node_to_list(F32Node *node) {
+  F32List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal F64List f64_node_to_list(F64Node *node) {
+  F64List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal F128List f128_node_to_list(F128Node *node) {
+  F128List output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal IptrList iptr_node_to_list(IptrNode *node) {
+  IptrList output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
+internal UptrList uptr_node_to_list(UptrNode *node) {
+  UptrList output = {.first = node, .last = node, .node_count = 1};
+
+  while (output.first->prev != NULL) {
+    output.first = output.first->prev;
+    ++(output.node_count);
+  }
+
+  while (output.last->next != NULL) {
+    output.last = output.last->next;
+    ++(output.node_count);
+  }
+
+  return output;
+}
+
diff --git a/src/containers/dbl_list/dbl_list.h b/src/containers/dbl_list/dbl_list.h
index a99121e..5859683 100644
--- a/src/containers/dbl_list/dbl_list.h
+++ b/src/containers/dbl_list/dbl_list.h
@@ -6,12 +6,32 @@
 #define DBL_LIST_H
 
 #include "../../common/aliases/aliases.h"
+#include <stdbool.h>
 
 #ifdef __cplusplus
 BEGIN_C_LINKAGE
 #endif // !__cplusplus
 
 #define wapp_str8_list_node(ITEM_PTR) ((Str8Node){.item = ITEM_PTR})
+#define wapp_void_ptr_list_node(ITEM_PTR) ((VoidPNode){.item = ITEM_PTR})
+#define wapp_bool_list_node(ITEM_PTR) ((BoolNode){.item = ITEM_PTR})
+#define wapp_char_list_node(ITEM_PTR) ((CharNode){.item = ITEM_PTR})
+#define wapp_c8_list_node(ITEM_PTR) ((C8Node){.item = ITEM_PTR})
+#define wapp_c16_list_node(ITEM_PTR) ((C16Node){.item = ITEM_PTR})
+#define wapp_c32_list_node(ITEM_PTR) ((C32Node){.item = ITEM_PTR})
+#define wapp_i8_list_node(ITEM_PTR) ((I8Node){.item = ITEM_PTR})
+#define wapp_i16_list_node(ITEM_PTR) ((I16Node){.item = ITEM_PTR})
+#define wapp_i32_list_node(ITEM_PTR) ((I32Node){.item = ITEM_PTR})
+#define wapp_i64_list_node(ITEM_PTR) ((I64Node){.item = ITEM_PTR})
+#define wapp_u8_list_node(ITEM_PTR) ((U8Node){.item = ITEM_PTR})
+#define wapp_u16_list_node(ITEM_PTR) ((U16Node){.item = ITEM_PTR})
+#define wapp_u32_list_node(ITEM_PTR) ((U32Node){.item = ITEM_PTR})
+#define wapp_u64_list_node(ITEM_PTR) ((U64Node){.item = ITEM_PTR})
+#define wapp_f32_list_node(ITEM_PTR) ((F32Node){.item = ITEM_PTR})
+#define wapp_f64_list_node(ITEM_PTR) ((F64Node){.item = ITEM_PTR})
+#define wapp_f128_list_node(ITEM_PTR) ((F128Node){.item = ITEM_PTR})
+#define wapp_iptr_list_node(ITEM_PTR) ((IptrNode){.item = ITEM_PTR})
+#define wapp_uptr_list_node(ITEM_PTR) ((UptrNode){.item = ITEM_PTR})
 
 typedef struct str8 Str8;
 
@@ -29,6 +49,272 @@ struct Str8List {
   u64 node_count;
 };
 
+typedef struct VoidPNode VoidPNode;
+struct VoidPNode {
+  void * *item;
+  VoidPNode *prev;
+  VoidPNode *next;
+};
+
+typedef struct VoidPList VoidPList;
+struct VoidPList {
+  VoidPNode *first;
+  VoidPNode *last;
+  u64 node_count;
+};
+
+typedef struct BoolNode BoolNode;
+struct BoolNode {
+  bool *item;
+  BoolNode *prev;
+  BoolNode *next;
+};
+
+typedef struct BoolList BoolList;
+struct BoolList {
+  BoolNode *first;
+  BoolNode *last;
+  u64 node_count;
+};
+
+typedef struct CharNode CharNode;
+struct CharNode {
+  char *item;
+  CharNode *prev;
+  CharNode *next;
+};
+
+typedef struct CharList CharList;
+struct CharList {
+  CharNode *first;
+  CharNode *last;
+  u64 node_count;
+};
+
+typedef struct C8Node C8Node;
+struct C8Node {
+  c8 *item;
+  C8Node *prev;
+  C8Node *next;
+};
+
+typedef struct C8List C8List;
+struct C8List {
+  C8Node *first;
+  C8Node *last;
+  u64 node_count;
+};
+
+typedef struct C16Node C16Node;
+struct C16Node {
+  c16 *item;
+  C16Node *prev;
+  C16Node *next;
+};
+
+typedef struct C16List C16List;
+struct C16List {
+  C16Node *first;
+  C16Node *last;
+  u64 node_count;
+};
+
+typedef struct C32Node C32Node;
+struct C32Node {
+  c32 *item;
+  C32Node *prev;
+  C32Node *next;
+};
+
+typedef struct C32List C32List;
+struct C32List {
+  C32Node *first;
+  C32Node *last;
+  u64 node_count;
+};
+
+typedef struct I8Node I8Node;
+struct I8Node {
+  i8 *item;
+  I8Node *prev;
+  I8Node *next;
+};
+
+typedef struct I8List I8List;
+struct I8List {
+  I8Node *first;
+  I8Node *last;
+  u64 node_count;
+};
+
+typedef struct I16Node I16Node;
+struct I16Node {
+  i16 *item;
+  I16Node *prev;
+  I16Node *next;
+};
+
+typedef struct I16List I16List;
+struct I16List {
+  I16Node *first;
+  I16Node *last;
+  u64 node_count;
+};
+
+typedef struct I32Node I32Node;
+struct I32Node {
+  i32 *item;
+  I32Node *prev;
+  I32Node *next;
+};
+
+typedef struct I32List I32List;
+struct I32List {
+  I32Node *first;
+  I32Node *last;
+  u64 node_count;
+};
+
+typedef struct I64Node I64Node;
+struct I64Node {
+  i64 *item;
+  I64Node *prev;
+  I64Node *next;
+};
+
+typedef struct I64List I64List;
+struct I64List {
+  I64Node *first;
+  I64Node *last;
+  u64 node_count;
+};
+
+typedef struct U8Node U8Node;
+struct U8Node {
+  u8 *item;
+  U8Node *prev;
+  U8Node *next;
+};
+
+typedef struct U8List U8List;
+struct U8List {
+  U8Node *first;
+  U8Node *last;
+  u64 node_count;
+};
+
+typedef struct U16Node U16Node;
+struct U16Node {
+  u16 *item;
+  U16Node *prev;
+  U16Node *next;
+};
+
+typedef struct U16List U16List;
+struct U16List {
+  U16Node *first;
+  U16Node *last;
+  u64 node_count;
+};
+
+typedef struct U32Node U32Node;
+struct U32Node {
+  u32 *item;
+  U32Node *prev;
+  U32Node *next;
+};
+
+typedef struct U32List U32List;
+struct U32List {
+  U32Node *first;
+  U32Node *last;
+  u64 node_count;
+};
+
+typedef struct U64Node U64Node;
+struct U64Node {
+  u64 *item;
+  U64Node *prev;
+  U64Node *next;
+};
+
+typedef struct U64List U64List;
+struct U64List {
+  U64Node *first;
+  U64Node *last;
+  u64 node_count;
+};
+
+typedef struct F32Node F32Node;
+struct F32Node {
+  f32 *item;
+  F32Node *prev;
+  F32Node *next;
+};
+
+typedef struct F32List F32List;
+struct F32List {
+  F32Node *first;
+  F32Node *last;
+  u64 node_count;
+};
+
+typedef struct F64Node F64Node;
+struct F64Node {
+  f64 *item;
+  F64Node *prev;
+  F64Node *next;
+};
+
+typedef struct F64List F64List;
+struct F64List {
+  F64Node *first;
+  F64Node *last;
+  u64 node_count;
+};
+
+typedef struct F128Node F128Node;
+struct F128Node {
+  f128 *item;
+  F128Node *prev;
+  F128Node *next;
+};
+
+typedef struct F128List F128List;
+struct F128List {
+  F128Node *first;
+  F128Node *last;
+  u64 node_count;
+};
+
+typedef struct IptrNode IptrNode;
+struct IptrNode {
+  iptr *item;
+  IptrNode *prev;
+  IptrNode *next;
+};
+
+typedef struct IptrList IptrList;
+struct IptrList {
+  IptrNode *first;
+  IptrNode *last;
+  u64 node_count;
+};
+
+typedef struct UptrNode UptrNode;
+struct UptrNode {
+  uptr *item;
+  UptrNode *prev;
+  UptrNode *next;
+};
+
+typedef struct UptrList UptrList;
+struct UptrList {
+  UptrNode *first;
+  UptrNode *last;
+  u64 node_count;
+};
+
 Str8Node *wapp_str8_list_get(const Str8List *list, u64 index);
 void wapp_str8_list_push_front(Str8List *list, Str8Node *node);
 void wapp_str8_list_push_back(Str8List *list, Str8Node *node);
@@ -37,6 +323,158 @@ Str8Node *wapp_str8_list_pop_front(Str8List *list);
 Str8Node *wapp_str8_list_pop_back(Str8List *list);
 Str8Node *wapp_str8_list_remove(Str8List *list, u64 index);
 void wapp_str8_list_empty(Str8List *list);
+VoidPNode *wapp_void_ptr_list_get(const VoidPList *list, u64 index);
+void wapp_void_ptr_list_push_front(VoidPList *list, VoidPNode *node);
+void wapp_void_ptr_list_push_back(VoidPList *list, VoidPNode *node);
+void wapp_void_ptr_list_insert(VoidPList *list, VoidPNode *node, u64 index);
+VoidPNode *wapp_void_ptr_list_pop_front(VoidPList *list);
+VoidPNode *wapp_void_ptr_list_pop_back(VoidPList *list);
+VoidPNode *wapp_void_ptr_list_remove(VoidPList *list, u64 index);
+void wapp_void_ptr_list_empty(VoidPList *list);
+BoolNode *wapp_bool_list_get(const BoolList *list, u64 index);
+void wapp_bool_list_push_front(BoolList *list, BoolNode *node);
+void wapp_bool_list_push_back(BoolList *list, BoolNode *node);
+void wapp_bool_list_insert(BoolList *list, BoolNode *node, u64 index);
+BoolNode *wapp_bool_list_pop_front(BoolList *list);
+BoolNode *wapp_bool_list_pop_back(BoolList *list);
+BoolNode *wapp_bool_list_remove(BoolList *list, u64 index);
+void wapp_bool_list_empty(BoolList *list);
+CharNode *wapp_char_list_get(const CharList *list, u64 index);
+void wapp_char_list_push_front(CharList *list, CharNode *node);
+void wapp_char_list_push_back(CharList *list, CharNode *node);
+void wapp_char_list_insert(CharList *list, CharNode *node, u64 index);
+CharNode *wapp_char_list_pop_front(CharList *list);
+CharNode *wapp_char_list_pop_back(CharList *list);
+CharNode *wapp_char_list_remove(CharList *list, u64 index);
+void wapp_char_list_empty(CharList *list);
+C8Node *wapp_c8_list_get(const C8List *list, u64 index);
+void wapp_c8_list_push_front(C8List *list, C8Node *node);
+void wapp_c8_list_push_back(C8List *list, C8Node *node);
+void wapp_c8_list_insert(C8List *list, C8Node *node, u64 index);
+C8Node *wapp_c8_list_pop_front(C8List *list);
+C8Node *wapp_c8_list_pop_back(C8List *list);
+C8Node *wapp_c8_list_remove(C8List *list, u64 index);
+void wapp_c8_list_empty(C8List *list);
+C16Node *wapp_c16_list_get(const C16List *list, u64 index);
+void wapp_c16_list_push_front(C16List *list, C16Node *node);
+void wapp_c16_list_push_back(C16List *list, C16Node *node);
+void wapp_c16_list_insert(C16List *list, C16Node *node, u64 index);
+C16Node *wapp_c16_list_pop_front(C16List *list);
+C16Node *wapp_c16_list_pop_back(C16List *list);
+C16Node *wapp_c16_list_remove(C16List *list, u64 index);
+void wapp_c16_list_empty(C16List *list);
+C32Node *wapp_c32_list_get(const C32List *list, u64 index);
+void wapp_c32_list_push_front(C32List *list, C32Node *node);
+void wapp_c32_list_push_back(C32List *list, C32Node *node);
+void wapp_c32_list_insert(C32List *list, C32Node *node, u64 index);
+C32Node *wapp_c32_list_pop_front(C32List *list);
+C32Node *wapp_c32_list_pop_back(C32List *list);
+C32Node *wapp_c32_list_remove(C32List *list, u64 index);
+void wapp_c32_list_empty(C32List *list);
+I8Node *wapp_i8_list_get(const I8List *list, u64 index);
+void wapp_i8_list_push_front(I8List *list, I8Node *node);
+void wapp_i8_list_push_back(I8List *list, I8Node *node);
+void wapp_i8_list_insert(I8List *list, I8Node *node, u64 index);
+I8Node *wapp_i8_list_pop_front(I8List *list);
+I8Node *wapp_i8_list_pop_back(I8List *list);
+I8Node *wapp_i8_list_remove(I8List *list, u64 index);
+void wapp_i8_list_empty(I8List *list);
+I16Node *wapp_i16_list_get(const I16List *list, u64 index);
+void wapp_i16_list_push_front(I16List *list, I16Node *node);
+void wapp_i16_list_push_back(I16List *list, I16Node *node);
+void wapp_i16_list_insert(I16List *list, I16Node *node, u64 index);
+I16Node *wapp_i16_list_pop_front(I16List *list);
+I16Node *wapp_i16_list_pop_back(I16List *list);
+I16Node *wapp_i16_list_remove(I16List *list, u64 index);
+void wapp_i16_list_empty(I16List *list);
+I32Node *wapp_i32_list_get(const I32List *list, u64 index);
+void wapp_i32_list_push_front(I32List *list, I32Node *node);
+void wapp_i32_list_push_back(I32List *list, I32Node *node);
+void wapp_i32_list_insert(I32List *list, I32Node *node, u64 index);
+I32Node *wapp_i32_list_pop_front(I32List *list);
+I32Node *wapp_i32_list_pop_back(I32List *list);
+I32Node *wapp_i32_list_remove(I32List *list, u64 index);
+void wapp_i32_list_empty(I32List *list);
+I64Node *wapp_i64_list_get(const I64List *list, u64 index);
+void wapp_i64_list_push_front(I64List *list, I64Node *node);
+void wapp_i64_list_push_back(I64List *list, I64Node *node);
+void wapp_i64_list_insert(I64List *list, I64Node *node, u64 index);
+I64Node *wapp_i64_list_pop_front(I64List *list);
+I64Node *wapp_i64_list_pop_back(I64List *list);
+I64Node *wapp_i64_list_remove(I64List *list, u64 index);
+void wapp_i64_list_empty(I64List *list);
+U8Node *wapp_u8_list_get(const U8List *list, u64 index);
+void wapp_u8_list_push_front(U8List *list, U8Node *node);
+void wapp_u8_list_push_back(U8List *list, U8Node *node);
+void wapp_u8_list_insert(U8List *list, U8Node *node, u64 index);
+U8Node *wapp_u8_list_pop_front(U8List *list);
+U8Node *wapp_u8_list_pop_back(U8List *list);
+U8Node *wapp_u8_list_remove(U8List *list, u64 index);
+void wapp_u8_list_empty(U8List *list);
+U16Node *wapp_u16_list_get(const U16List *list, u64 index);
+void wapp_u16_list_push_front(U16List *list, U16Node *node);
+void wapp_u16_list_push_back(U16List *list, U16Node *node);
+void wapp_u16_list_insert(U16List *list, U16Node *node, u64 index);
+U16Node *wapp_u16_list_pop_front(U16List *list);
+U16Node *wapp_u16_list_pop_back(U16List *list);
+U16Node *wapp_u16_list_remove(U16List *list, u64 index);
+void wapp_u16_list_empty(U16List *list);
+U32Node *wapp_u32_list_get(const U32List *list, u64 index);
+void wapp_u32_list_push_front(U32List *list, U32Node *node);
+void wapp_u32_list_push_back(U32List *list, U32Node *node);
+void wapp_u32_list_insert(U32List *list, U32Node *node, u64 index);
+U32Node *wapp_u32_list_pop_front(U32List *list);
+U32Node *wapp_u32_list_pop_back(U32List *list);
+U32Node *wapp_u32_list_remove(U32List *list, u64 index);
+void wapp_u32_list_empty(U32List *list);
+U64Node *wapp_u64_list_get(const U64List *list, u64 index);
+void wapp_u64_list_push_front(U64List *list, U64Node *node);
+void wapp_u64_list_push_back(U64List *list, U64Node *node);
+void wapp_u64_list_insert(U64List *list, U64Node *node, u64 index);
+U64Node *wapp_u64_list_pop_front(U64List *list);
+U64Node *wapp_u64_list_pop_back(U64List *list);
+U64Node *wapp_u64_list_remove(U64List *list, u64 index);
+void wapp_u64_list_empty(U64List *list);
+F32Node *wapp_f32_list_get(const F32List *list, u64 index);
+void wapp_f32_list_push_front(F32List *list, F32Node *node);
+void wapp_f32_list_push_back(F32List *list, F32Node *node);
+void wapp_f32_list_insert(F32List *list, F32Node *node, u64 index);
+F32Node *wapp_f32_list_pop_front(F32List *list);
+F32Node *wapp_f32_list_pop_back(F32List *list);
+F32Node *wapp_f32_list_remove(F32List *list, u64 index);
+void wapp_f32_list_empty(F32List *list);
+F64Node *wapp_f64_list_get(const F64List *list, u64 index);
+void wapp_f64_list_push_front(F64List *list, F64Node *node);
+void wapp_f64_list_push_back(F64List *list, F64Node *node);
+void wapp_f64_list_insert(F64List *list, F64Node *node, u64 index);
+F64Node *wapp_f64_list_pop_front(F64List *list);
+F64Node *wapp_f64_list_pop_back(F64List *list);
+F64Node *wapp_f64_list_remove(F64List *list, u64 index);
+void wapp_f64_list_empty(F64List *list);
+F128Node *wapp_f128_list_get(const F128List *list, u64 index);
+void wapp_f128_list_push_front(F128List *list, F128Node *node);
+void wapp_f128_list_push_back(F128List *list, F128Node *node);
+void wapp_f128_list_insert(F128List *list, F128Node *node, u64 index);
+F128Node *wapp_f128_list_pop_front(F128List *list);
+F128Node *wapp_f128_list_pop_back(F128List *list);
+F128Node *wapp_f128_list_remove(F128List *list, u64 index);
+void wapp_f128_list_empty(F128List *list);
+IptrNode *wapp_iptr_list_get(const IptrList *list, u64 index);
+void wapp_iptr_list_push_front(IptrList *list, IptrNode *node);
+void wapp_iptr_list_push_back(IptrList *list, IptrNode *node);
+void wapp_iptr_list_insert(IptrList *list, IptrNode *node, u64 index);
+IptrNode *wapp_iptr_list_pop_front(IptrList *list);
+IptrNode *wapp_iptr_list_pop_back(IptrList *list);
+IptrNode *wapp_iptr_list_remove(IptrList *list, u64 index);
+void wapp_iptr_list_empty(IptrList *list);
+UptrNode *wapp_uptr_list_get(const UptrList *list, u64 index);
+void wapp_uptr_list_push_front(UptrList *list, UptrNode *node);
+void wapp_uptr_list_push_back(UptrList *list, UptrNode *node);
+void wapp_uptr_list_insert(UptrList *list, UptrNode *node, u64 index);
+UptrNode *wapp_uptr_list_pop_front(UptrList *list);
+UptrNode *wapp_uptr_list_pop_back(UptrList *list);
+UptrNode *wapp_uptr_list_remove(UptrList *list, u64 index);
+void wapp_uptr_list_empty(UptrList *list);
 
 #ifdef __cplusplus
 END_C_LINKAGE