diff --git a/C/watl.v0.llvm.lottes_hybrid.c b/C/watl.v0.llvm.lottes_hybrid.c
index 561e666..ff3a08b 100644
--- a/C/watl.v0.llvm.lottes_hybrid.c
+++ b/C/watl.v0.llvm.lottes_hybrid.c
@@ -570,10 +570,9 @@ def_struct(tmpl(KT1CX_Cell,type)) {    \
 	tmpl(KT1CX_Slot,type)  slots[depth]; \
 	tmpl(KT1CX_Slot,type)* next;         \
 }
-#define def_KT1CX(type)                  \
-def_struct(tmpl(KT1CX,type)) {           \
-	tmpl(Slice_KT1CX_Cell,type) cell_pool; \
-	tmpl(Slice_KT1CX_Cell,type) table;     \
+#define def_KT1CX(type)              \
+def_struct(tmpl(KT1CX,type)) {       \
+	tmpl(Slice_KT1CX_Cell,type) table; \
 }
 typedef def_struct(KT1CX_Byte_Slot) {
 	U8   key;
@@ -584,7 +583,6 @@ typedef def_struct(KT1CX_Byte_Cell) {
 	U8 next;
 };
 typedef def_struct(KT1CX_Byte) {
-	Slice_Mem cell_pool;
 	Slice_Mem table;
 };
 typedef def_struct(KT1CX_ByteMeta) {
@@ -617,11 +615,10 @@ finline U8   kt1cx_slot_id(KT1CX_Byte kt,  U8 key, KT1CX_ByteMeta meta);
         U8   kt1cx_get    (KT1CX_Byte kt,  U8 key, KT1CX_ByteMeta meta);
         U8   kt1cx_set    (KT1CX_Byte kt,  U8 key, Slice_Mem value, AllocatorInfo backing_cells, KT1CX_ByteMeta meta);
 
-#define kt1cx_assert(kt) do {   \
-	slice_assert(kt.cell_pool); \
+#define kt1cx_assert(kt) do { \
 	slice_assert(kt.table);     \
 } while(0)
-#define kt1cx_byte(kt) (KT1CX_Byte){slice_mem_s(kt.cell_pool), (Slice_Mem){u8_(kt.table.ptr), kt.table.len} }
+#define kt1cx_byte(kt) (KT1CX_Byte){ (Slice_Mem){u8_(kt.table.ptr), kt.table.len} }
 #pragma endregion KT1CX
 
 #pragma region String Operations
@@ -1484,8 +1481,7 @@ void kt1cx_init(KT1CX_Info info, KT1CX_InfoMeta m, KT1CX_Byte*R_ result) {
 	assert(m.cell_pool_size >= kilo(4));
 	assert(m.table_size     >= kilo(4));
 	assert(m.type_width     >  0);
-	result->table     = mem_alloc(info.backing_table, m.table_size * m.cell_size);      slice_assert(result->table);
-	result->cell_pool = mem_alloc(info.backing_cells, m.cell_size  * m.cell_pool_size); slice_assert(result->cell_pool);
+	result->table     = mem_alloc(info.backing_table, m.table_size * m.cell_size); slice_assert(result->table);
 	result->table.len = m.table_size; // Setting to the table number of elements instead of byte length.
 }
 inline
diff --git a/C/watl.v0.msvc.c b/C/watl.v0.msvc.c
index b5c0e67..5334545 100644
--- a/C/watl.v0.msvc.c
+++ b/C/watl.v0.msvc.c
@@ -464,10 +464,9 @@ def_struct(tmpl(KT1CX_Cell,type)) {    \
 	tmpl(KT1CX_Slot,type)  slots[depth]; \
 	tmpl(KT1CX_Cell,type)* next;         \
 }
-#define def_KT1CX(type)                  \
-def_struct(tmpl(KT1CX,type)) {           \
-	tmpl(Slice_KT1CX_Cell,type) cell_pool; \
-	tmpl(Slice_KT1CX_Cell,type) table;     \
+#define def_KT1CX(type)              \
+def_struct(tmpl(KT1CX,type)) {       \
+	tmpl(Slice_KT1CX_Cell,type) table; \
 }
 typedef def_struct(KT1CX_Byte_Slot) {
 	U64   key;
@@ -478,7 +477,6 @@ typedef def_struct(KT1CX_Byte_Cell) {
 	Byte* next;
 };
 typedef def_struct(KT1CX_Byte) {
-	Slice_Byte cell_pool;
 	Slice_Byte table;
 };
 typedef def_struct(KT1CX_ByteMeta) {
@@ -511,11 +509,10 @@ U64   kt1cx_slot_id(KT1CX_Byte kt,  U64 key, KT1CX_ByteMeta meta);
 Byte* kt1cx_get    (KT1CX_Byte kt,  U64 key, KT1CX_ByteMeta meta);
 Byte* kt1cx_set    (KT1CX_Byte kt,  U64 key, Slice_Byte value, AllocatorInfo backing_cells, KT1CX_ByteMeta meta);
 
-#define kt1cx_assert(kt) do {   \
-	slice_assert(kt.cell_pool); \
+#define kt1cx_assert(kt) do { \
 	slice_assert(kt.table);     \
 } while(0)
-#define kt1cx_byte(kt) (KT1CX_Byte){slice_byte(kt.cell_pool), { cast(Byte*, kt.table.ptr), kt.table.len } }
+#define kt1cx_byte(kt) (KT1CX_Byte){ { cast(Byte*, kt.table.ptr), kt.table.len } }
 #pragma endregion KT1CX
 
 #pragma region String Operations
@@ -1389,8 +1386,7 @@ void kt1cx_init(KT1CX_Info info, KT1CX_InfoMeta m, KT1CX_Byte* result) {
 	assert(m.cell_pool_size >= kilo(4));
 	assert(m.table_size     >= kilo(4));
 	assert(m.type_width     >  0);
-	result->table     = mem_alloc(info.backing_table, m.table_size * m.cell_size);      slice_assert(result->table);
-	result->cell_pool = mem_alloc(info.backing_cells, m.cell_size  * m.cell_pool_size); slice_assert(result->cell_pool);
+	result->table     = mem_alloc(info.backing_table, m.table_size * m.cell_size); slice_assert(result->table);
 	result->table.len = m.table_size; // Setting to the table number of elements instead of byte length.
 }
 void kt1cx_clear(KT1CX_Byte kt, KT1CX_ByteMeta m) {
diff --git a/Odin/watl.v0.win32.odin b/Odin/watl.v0.win32.odin
index 06029e1..c3f0794 100644
--- a/Odin/watl.v0.win32.odin
+++ b/Odin/watl.v0.win32.odin
@@ -95,25 +95,25 @@ Tera :: Giga * 1024
 
 ptr_cursor :: #force_inline proc "contextless" (ptr: ^$Type) -> [^]Type { return transmute([^]Type) ptr }
 
-align_pow2 :: proc(x: int, b: int) -> int {
+align_pow2 :: #force_inline proc(x: int, b: int) -> int {
     assert(b != 0)
     assert((b & (b - 1)) == 0) // Check power of 2
     return ((x + b - 1) & ~(b - 1))
 }
-memory_zero :: proc "contextless" (data: rawptr, len: int) -> rawptr {
+memory_zero :: #force_inline proc "contextless" (data: rawptr, len: int) -> rawptr {
 	intrinsics.mem_zero(data, len)
 	return data
 }
-memory_zero_explicit :: proc "contextless" (data: rawptr, len: int) -> rawptr {
+memory_zero_explicit :: #force_inline proc "contextless" (data: rawptr, len: int) -> rawptr {
 	intrinsics.mem_zero_volatile(data, len) // Use the volatile mem_zero
 	intrinsics.atomic_thread_fence(.Seq_Cst) // Prevent reordering
 	return data
 }
-memory_copy_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
+memory_copy_overlapping :: #force_inline proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
 	intrinsics.mem_copy(dst, src, len)
 	return dst
 }
-memory_copy :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
+memory_copy :: #force_inline proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
 	intrinsics.mem_copy_non_overlapping(dst, src, len)
 	return dst
 }
@@ -155,15 +155,15 @@ slice_end :: #force_inline proc "contextless" (s : $SliceType / []$Type) -> ^Typ
 @(require_results) slice_to_bytes :: proc "contextless" (s: []$Type) -> []byte         { return ([^]byte)(raw_data(s))[:len(s) * size_of(Type)] }
 @(require_results) slice_raw      :: proc "contextless" (s: []$Type) -> SliceRaw(Type) { return transmute(SliceRaw(Type)) s }
 
-slice_zero :: proc "contextless" (data: $SliceType / []$Type) { memory_zero(raw_data(data), size_of(Type) * len(data)) }
-slice_copy :: proc "contextless" (dst, src: $SliceType / []$Type) -> int {
+slice_zero :: #force_inline proc "contextless" (data: $SliceType / []$Type) { memory_zero(raw_data(data), size_of(Type) * len(data)) }
+slice_copy :: #force_inline proc "contextless" (dst, src: $SliceType / []$Type) -> int {
 	n := max(0, min(len(dst), len(src)))
 	if n > 0 {
 		intrinsics.mem_copy_non_overlapping(raw_data(dst), raw_data(src), n * size_of(Type))
 	}
 	return n
 }
-slice_copy_overlapping :: proc "contextless" (dst, src: $SliceType / []$Type) -> int {
+slice_copy_overlapping :: #force_inline proc "contextless" (dst, src: $SliceType / []$Type) -> int {
 	n := max(0, min(len(dst), len(src)))
 	if n > 0 {
 		intrinsics.mem_copy(raw_data(dst), raw_data(src), n * size_of(Type))
@@ -975,8 +975,7 @@ KT1CX_Cell :: struct($type: typeid, $depth: int) {
 	next:  ^KT1CX_Cell(type, depth),
 }
 KT1CX :: struct($cell: typeid / KT1CX_Cell($type, $depth)) {
-	cell_pool: []cell,
-	table:     []cell,
+	table: []cell,
 }
 KT1CX_Byte_Slot :: struct {
 	key:      u64,
@@ -986,8 +985,7 @@ KT1CX_Byte_Cell :: struct {
 	next: ^byte,
 }
 KT1CX_Byte :: struct {
-	cell_pool: []byte,
-	table:     []byte,
+	table: []byte,
 }
 KT1CX_ByteMeta :: struct {
 	slot_size:        int,
@@ -1021,10 +1019,8 @@ kt1cx_init :: proc(info: KT1CX_Info, m: KT1CX_InfoMeta, result: ^KT1CX_Byte) {
 	assert(m.cell_pool_size >= 4 * Kilo)
 	assert(m.table_size     >= 4 * Kilo)
 	assert(m.type_width     >  0)
-	table_raw       := transmute(SliceByte) mem_alloc(info.backing_table, m.table_size * m.cell_size)
+	table_raw := transmute(SliceByte) mem_alloc(info.backing_table, m.table_size * m.cell_size)
 	slice_assert(transmute([]byte) table_raw)
-	result.cell_pool = mem_alloc(info.backing_cells, m.cell_size * m.cell_pool_size)
-	slice_assert(result.cell_pool)
 	table_raw.len = m.table_size
 	result.table  = transmute([]byte) table_raw
 }
@@ -1126,10 +1122,11 @@ kt1cx_set :: proc(kt: KT1CX_Byte, key: u64, value: []byte, backing_cells: Alloca
 	}
 }
 kt1cx_assert :: proc(kt: $type / KT1CX) {
-	slice_assert(kt.cell_pool)
 	slice_assert(kt.table)
 }
-kt1cx_byte :: proc(kt: $type / KT1CX) -> KT1CX_Byte { return { slice_to_bytes(kt.cell_pool), slice( transmute([^]byte) cursor(kt.table), len(kt.table)) } }
+kt1cx_byte :: proc(kt: $type / KT1CX) -> KT1CX_Byte { return { 
+	slice( transmute([^]byte) cursor(kt.table), len(kt.table)) 
+} }
 //endregion Key Table 1-Layer Chained-Chunked-Cells (KT1CX)
 
 //region String Operations
diff --git a/scripts/build.odin.odin b/scripts/build.odin.odin
index f31c1d1..de46695 100644
--- a/scripts/build.odin.odin
+++ b/scripts/build.odin.odin
@@ -106,6 +106,8 @@ main :: proc() {
 		flag_file,
 		join_str(flag_output_path, file_exe),
 		flag_optimize_none,
+		// flag_optimize_minimal,
+		// flag_optimize_speed,
 		// falg_optimize_aggressive,
 		flag_default_allocator_nil,
 		flag_debug,