querysub 0.356.0 → 0.358.0

package/src/diagnostics/logs/IndexedLogs/BufferIndexWAT.wat

@@ -0,0 +1,1145 @@
+(module
+  ;; Import memory from JavaScript (with memory64 support for >4GB)
+  (import "env" "memory" (memory i64 1))
+  (global (export "__heap_base") i32 (i32.const 0))
+
+  ;; Helper: Hash unit to index
+  ;; Uses Fibonacci hashing for optimal distribution
+  ;; hashTableCapacity MUST be power of 2
+  (func $hashUnitToIndex (param $unit i32) (param $hashTableCapacity i32) (result i32)
+    (local $hash i32)
+    (local $shiftAmount i32)
+    ;; Multiply by 2654435761 (Knuth's golden ratio constant)
+    (local.set $hash (i32.mul (local.get $unit) (i32.const 2654435761)))
+    ;; Calculate shift amount: 32 - log2(capacity) = 1 + clz(capacity)
+    (local.set $shiftAmount (i32.add (i32.clz (local.get $hashTableCapacity)) (i32.const 1)))
+    ;; Fibonacci hashing: shift by calculated amount (auto-masks to correct bits)
+    ;; Then multiply by 16 (each slot is 16 bytes: 4 u32s)
+    (i32.mul
+      (i32.shr_u (local.get $hash) (local.get $shiftAmount))
+      (i32.const 16)))
+
+  ;; Helper: Get next probe index (linear probing with wraparound)
+  (func $getNextIndex (param $index i32) (param $hashTableSize i32) (result i32)
+    (local $nextIndex i32)
+    (local.set $nextIndex (i32.add (local.get $index) (i32.const 16)))
+    (if (i32.ge_u (local.get $nextIndex) (local.get $hashTableSize))
+      (then (local.set $nextIndex (i32.sub (local.get $nextIndex) (local.get $hashTableSize)))))
+    (local.get $nextIndex))
+
+  ;; Populate Units From Block (Loop Unrolled): Extract units from a concatenated block of buffers
+  ;; Block format: [count, length1, length2, ..., lengthN, buffer1_bytes, buffer2_bytes, ..., bufferN_bytes]
+  ;; Uses loop unrolling to process 4 units at a time with optimized fast path for non-zero units
+  (func (export "populate_units_from_block_simd")
+    (param $blockDataPtr i64)
+    (param $blockDataSize i32)
+    (param $blockIndex i32)
+    (param $unitsOutputPtr i64)
+    (param $bufferIndicesOutputPtr i64)
+    (param $blocksOutputPtr i64)
+    (param $startOffset i32)
+    (result i32)
+    
+    (local $bufferCount i32)
+    (local $bufferIndex i32)
+    (local $bufferLength i32)
+    (local $bufferDataStart i32)
+    (local $bufferOffset i32)
+    (local $totalUnitsWritten i32)
+    (local $i i32)
+    (local $mainLoopEnd i32)
+    (local $writePos i32)
+    (local $unit i32)
+    (local $readAddr i64)
+    (local $writeAddr i64)
+    
+    ;; Temps for unrolled loop
+    (local $unit0 i32)
+    (local $unit1 i32)
+    (local $unit2 i32)
+    (local $unit3 i32)
+    (local $j i32)
+    
+    (local.set $totalUnitsWritten (i32.const 0))
+    
+    ;; Read buffer count (first 4 bytes)
+    (local.set $bufferCount (i32.load align=0 (local.get $blockDataPtr)))
+    
+    ;; Calculate where buffer data starts (after count + all lengths)
+    (local.set $bufferDataStart (i32.add (i32.const 4) (i32.mul (local.get $bufferCount) (i32.const 4))))
+    (local.set $bufferOffset (local.get $bufferDataStart))
+    
+    ;; Loop through all buffers
+    (local.set $bufferIndex (i32.const 0))
+    (block $break_buffers
+      (loop $continue_buffers
+        (br_if $break_buffers (i32.ge_u (local.get $bufferIndex) (local.get $bufferCount)))
+        
+        ;; Read buffer length from header
+        (local.set $bufferLength
+          (i32.load align=0 (i64.add (local.get $blockDataPtr) (i64.extend_i32_u (i32.add (i32.const 4) (i32.mul (local.get $bufferIndex) (i32.const 4)))))))
+        
+        ;; Process this buffer - we need at least 4 bytes to create a unit
+        (if (i32.ge_u (local.get $bufferLength) (i32.const 4))
+          (then
+            ;; Calculate main loop end
+            ;; We need at least 7 bytes to extract 4 overlapping units (positions i, i+1, i+2, i+3 need bytes [i, i+7))
+            ;; mainLoopEnd is the last position where we can extract 4 units
+            (if (i32.ge_u (local.get $bufferLength) (i32.const 7))
+              (then
+                (local.set $mainLoopEnd (i32.sub (local.get $bufferLength) (i32.const 6)))) ;; i <= bufferLength-7, so i+6 < bufferLength
+              (else
+                (local.set $mainLoopEnd (i32.const 0)))) ;; Can't do SIMD, skip to tail
+            (local.set $i (i32.const 0))
+            
+            ;; Main unrolled loop - process 4 overlapping units per iteration
+            ;; Optimized for the common case where all units are non-zero
+            (block $break_simd
+              (loop $continue_simd
+                (br_if $break_simd (i32.ge_u (local.get $i) (local.get $mainLoopEnd)))
+                
+                ;; Calculate read address - we need to read at least 7 bytes [i, i+7)
+                (local.set $readAddr (i64.add (local.get $blockDataPtr) (i64.extend_i32_u (i32.add (local.get $bufferOffset) (local.get $i)))))
+                
+                ;; Load 4 overlapping units (unrolled, not SIMD)
+                ;; Unit 0: bytes [i+0, i+1, i+2, i+3]
+                (local.set $unit0 (i32.load align=0 (local.get $readAddr)))
+                ;; Unit 1: bytes [i+1, i+2, i+3, i+4]
+                (local.set $unit1 (i32.load align=0 (i64.add (local.get $readAddr) (i64.const 1))))
+                ;; Unit 2: bytes [i+2, i+3, i+4, i+5]
+                (local.set $unit2 (i32.load align=0 (i64.add (local.get $readAddr) (i64.const 2))))
+                ;; Unit 3: bytes [i+3, i+4, i+5, i+6]
+                (local.set $unit3 (i32.load align=0 (i64.add (local.get $readAddr) (i64.const 3))))
+                
+                ;; Check if all units are non-zero (common case)
+                (if (i32.and (i32.and (local.get $unit0) (local.get $unit1))
+                            (i32.and (local.get $unit2) (local.get $unit3)))
+                  (then
+                    ;; Fast path: all units are non-zero (common case)
+                    ;; Group similar operations for better instruction-level parallelism
+                    (local.set $writePos (i32.add (local.get $startOffset) (local.get $totalUnitsWritten)))
+                    
+                    ;; Calculate base write address
+                    (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                    
+                    ;; Write all units together
+                    (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (local.get $writeAddr)) (local.get $unit0))
+                    (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (i64.add (local.get $writeAddr) (i64.const 4))) (local.get $unit1))
+                    (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (i64.add (local.get $writeAddr) (i64.const 8))) (local.get $unit2))
+                    (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (i64.add (local.get $writeAddr) (i64.const 12))) (local.get $unit3))
+                    
+                    ;; Write all buffer indices together
+                    (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+                    (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (i64.add (local.get $writeAddr) (i64.const 4))) (local.get $bufferIndex))
+                    (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (i64.add (local.get $writeAddr) (i64.const 8))) (local.get $bufferIndex))
+                    (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (i64.add (local.get $writeAddr) (i64.const 12))) (local.get $bufferIndex))
+                    
+                    ;; Write all blocks together
+                    (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (local.get $writeAddr)) (local.get $blockIndex))
+                    (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (i64.add (local.get $writeAddr) (i64.const 4))) (local.get $blockIndex))
+                    (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (i64.add (local.get $writeAddr) (i64.const 8))) (local.get $blockIndex))
+                    (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (i64.add (local.get $writeAddr) (i64.const 12))) (local.get $blockIndex))
+                    
+                    ;; Increment total units written by 4
+                    (local.set $totalUnitsWritten (i32.add (local.get $totalUnitsWritten) (i32.const 4))))
+                  (else
+                    ;; Slow path: at least one unit is zero (rare), process with a loop
+                    ;; Re-read the 4 units and process one by one
+                    (local.set $readAddr (i64.add (local.get $blockDataPtr) (i64.extend_i32_u (i32.add (local.get $bufferOffset) (local.get $i)))))
+                    (local.set $j (i32.const 0))
+                    (block $break_zeros
+                      (loop $continue_zeros
+                        (br_if $break_zeros (i32.ge_u (local.get $j) (i32.const 4)))
+                        
+                        ;; Read unit at offset j
+                        (local.set $unit (i32.load align=0 (i64.add (local.get $readAddr) (i64.extend_i32_u (local.get $j)))))
+                        
+                        ;; Write if non-zero
+                        (if (local.get $unit)
+                          (then
+                            (local.set $writePos (i32.add (local.get $startOffset) (local.get $totalUnitsWritten)))
+                            (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                            (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (local.get $writeAddr)) (local.get $unit))
+                            (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+                            (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (local.get $writeAddr)) (local.get $blockIndex))
+                            (local.set $totalUnitsWritten (i32.add (local.get $totalUnitsWritten) (i32.const 1)))))
+                        
+                        ;; Move to next position
+                        (local.set $j (i32.add (local.get $j) (i32.const 1)))
+                        (br $continue_zeros)))))
+                
+                ;; Advance by 4 bytes (processed 4 overlapping units at positions i, i+1, i+2, i+3)
+                (local.set $i (i32.add (local.get $i) (i32.const 4)))
+                (br $continue_simd)))
+            
+            ;; Handle remaining units (scalar tail loop)
+            ;; Process positions from mainLoopEnd to bufferLength-4
+            (block $break_tail
+              (loop $continue_tail
+                ;; Check if we can read 4 more bytes
+                (br_if $break_tail (i32.gt_u (local.get $i) (i32.sub (local.get $bufferLength) (i32.const 4))))
+                
+                ;; Calculate read address
+                (local.set $readAddr (i64.add (local.get $blockDataPtr) (i64.extend_i32_u (i32.add (local.get $bufferOffset) (local.get $i)))))
+                
+                ;; Read unit as little-endian u32
+                (local.set $unit (i32.load align=0 (local.get $readAddr)))
+                
+                ;; Skip if unit is 0
+                (if (i32.eqz (local.get $unit))
+                  (then
+                    (local.set $i (i32.add (local.get $i) (i32.const 1)))
+                    (br $continue_tail)))
+                
+                ;; Calculate write position and address
+                (local.set $writePos (i32.add (local.get $startOffset) (local.get $totalUnitsWritten)))
+                (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                
+                ;; Write to output arrays
+                (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (local.get $writeAddr)) (local.get $unit))
+                (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+                (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (local.get $writeAddr)) (local.get $blockIndex))
+                
+                ;; Increment counters - advance by 1 byte for overlapping units
+                (local.set $totalUnitsWritten (i32.add (local.get $totalUnitsWritten) (i32.const 1)))
+                (local.set $i (i32.add (local.get $i) (i32.const 1)))
+                
+                (br $continue_tail)))))
+        
+        ;; Move to next buffer
+        (local.set $bufferOffset (i32.add (local.get $bufferOffset) (local.get $bufferLength)))
+        (local.set $bufferIndex (i32.add (local.get $bufferIndex) (i32.const 1)))
+        
+        (br $continue_buffers)))
+    
+    (local.get $totalUnitsWritten))
+
+  ;; Populate Units From Block: Extract units from a concatenated block of buffers
+  ;; Block format: [count, length1, length2, ..., lengthN, buffer1_bytes, buffer2_bytes, ..., bufferN_bytes]
+  ;; - count: u32 (4 bytes) - number of buffers
+  ;; - lengths: count * u32 (4 bytes each) - length of each buffer
+  ;; - buffers: concatenated buffer data
+  ;; Parameters:
+  ;;   - blockDataPtr: pointer to concatenated block data
+  ;;   - blockDataSize: total size of block data in bytes
+  ;;   - blockIndex: block index value to store
+  ;;   - unitsOutputPtr: pointer to units output array
+  ;;   - bufferIndicesOutputPtr: pointer to buffer indices output array
+  ;;   - blocksOutputPtr: pointer to blocks output array
+  ;;   - startOffset: starting write position in output arrays
+  ;; Returns: number of units written
+  (func (export "populate_units_from_block")
+    (param $blockDataPtr i64)
+    (param $blockDataSize i32)
+    (param $blockIndex i32)
+    (param $unitsOutputPtr i64)
+    (param $bufferIndicesOutputPtr i64)
+    (param $blocksOutputPtr i64)
+    (param $startOffset i32)
+    (result i32)
+    
+    (local $bufferCount i32)
+    (local $bufferIndex i32)
+    (local $bufferLength i32)
+    (local $bufferDataStart i32)
+    (local $bufferOffset i32)
+    (local $totalUnitsWritten i32)
+    (local $i i32)
+    (local $writePos i32)
+    (local $unit i32)
+    (local $readAddr i64)
+    (local $writeAddr i64)
+    
+    (local.set $totalUnitsWritten (i32.const 0))
+    
+    ;; Read buffer count (first 4 bytes)
+    (local.set $bufferCount (i32.load align=0 (local.get $blockDataPtr)))
+    
+    ;; Calculate where buffer data starts (after count + all lengths)
+    (local.set $bufferDataStart (i32.add (i32.const 4) (i32.mul (local.get $bufferCount) (i32.const 4))))
+    (local.set $bufferOffset (local.get $bufferDataStart))
+    
+    ;; Loop through all buffers
+    (local.set $bufferIndex (i32.const 0))
+    (block $break_buffers
+      (loop $continue_buffers
+        (br_if $break_buffers (i32.ge_u (local.get $bufferIndex) (local.get $bufferCount)))
+        
+        ;; Read buffer length from header (offset: 4 + bufferIndex * 4)
+        (local.set $bufferLength
+          (i32.load align=0 (i64.add (local.get $blockDataPtr) (i64.extend_i32_u (i32.add (i32.const 4) (i32.mul (local.get $bufferIndex) (i32.const 4)))))))
+        
+        ;; Process this buffer - we need at least 4 bytes to create a unit
+        (if (i32.ge_u (local.get $bufferLength) (i32.const 4))
+          (then
+            (local.set $i (i32.const 0))
+            
+            ;; Loop through buffer positions
+            (block $break_buffer
+              (loop $continue_buffer
+                ;; Check if we can read 4 more bytes
+                (br_if $break_buffer (i32.gt_u (local.get $i) (i32.sub (local.get $bufferLength) (i32.const 4))))
+                
+                ;; Calculate read address
+                (local.set $readAddr (i64.add (local.get $blockDataPtr) (i64.extend_i32_u (i32.add (local.get $bufferOffset) (local.get $i)))))
+                
+                ;; Read unit as little-endian u32
+                (local.set $unit (i32.load align=0 (local.get $readAddr)))
+                
+                ;; Skip if unit is 0
+                (if (i32.eqz (local.get $unit))
+                  (then
+                    (local.set $i (i32.add (local.get $i) (i32.const 1)))
+                    (br $continue_buffer)))
+                
+                ;; Calculate write position and address
+                (local.set $writePos (i32.add (local.get $startOffset) (local.get $totalUnitsWritten)))
+                (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                
+                ;; Write to output arrays
+                (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (local.get $writeAddr)) (local.get $unit))
+                (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+                (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (local.get $writeAddr)) (local.get $blockIndex))
+                
+                ;; Increment counters
+                (local.set $totalUnitsWritten (i32.add (local.get $totalUnitsWritten) (i32.const 1)))
+                (local.set $i (i32.add (local.get $i) (i32.const 1)))
+                
+                (br $continue_buffer)))))
+        
+        ;; Move to next buffer
+        (local.set $bufferOffset (i32.add (local.get $bufferOffset) (local.get $bufferLength)))
+        (local.set $bufferIndex (i32.add (local.get $bufferIndex) (i32.const 1)))
+        
+        (br $continue_buffers)))
+    
+    (local.get $totalUnitsWritten))
+
+  ;; Populate Units From Buffer: Extract units from a buffer into three parallel arrays
+  ;; Parameters:
+  ;;   - bufferPtr: pointer to source buffer bytes
+  ;;   - bufferLength: length of source buffer in bytes
+  ;;   - bufferIndex: buffer index value to store
+  ;;   - block: block value to store
+  ;;   - unitsOutputPtr: pointer to units output array
+  ;;   - bufferIndicesOutputPtr: pointer to buffer indices output array
+  ;;   - blocksOutputPtr: pointer to blocks output array
+  ;;   - startOffset: starting write position in output arrays
+  ;; Returns: number of units written
+  (func (export "populate_units_from_buffer")
+    (param $bufferPtr i64)
+    (param $bufferLength i32)
+    (param $bufferIndex i32)
+    (param $block i32)
+    (param $unitsOutputPtr i64)
+    (param $bufferIndicesOutputPtr i64)
+    (param $blocksOutputPtr i64)
+    (param $startOffset i32)
+    (result i32)
+    
+    (local $i i32)
+    (local $mainLoopEnd i32)
+    (local $count i32)
+    (local $unit i32)
+    (local $readAddr i64)
+    (local $writeAddr i64)
+    
+    ;; Temps for unrolled loop
+    (local $unit0 i32)
+    (local $unit1 i32)
+    (local $unit2 i32)
+    (local $unit3 i32)
+    (local $j i32)
+    
+    ;; We need at least 4 bytes to create a unit
+    (if (i32.lt_u (local.get $bufferLength) (i32.const 4))
+      (then (return (i32.const 0))))
+    
+    (local.set $count (i32.const 0))
+    (local.set $i (i32.const 0))
+    
+    ;; Calculate main loop end for unrolled loop
+    (if (i32.ge_u (local.get $bufferLength) (i32.const 7))
+      (then
+        (local.set $mainLoopEnd (i32.sub (local.get $bufferLength) (i32.const 6))))
+      (else
+        (local.set $mainLoopEnd (i32.const 0))))
+    
+    ;; Main unrolled loop - process 4 overlapping units per iteration
+    (block $break_main
+      (loop $continue_main
+        (br_if $break_main (i32.ge_u (local.get $i) (local.get $mainLoopEnd)))
+        
+        ;; Calculate read address
+        (local.set $readAddr (i64.add (local.get $bufferPtr) (i64.extend_i32_u (local.get $i))))
+        
+        ;; Load 4 overlapping units
+        (local.set $unit0 (i32.load align=0 (local.get $readAddr)))
+        (local.set $unit1 (i32.load align=0 (i64.add (local.get $readAddr) (i64.const 1))))
+        (local.set $unit2 (i32.load align=0 (i64.add (local.get $readAddr) (i64.const 2))))
+        (local.set $unit3 (i32.load align=0 (i64.add (local.get $readAddr) (i64.const 3))))
+        
+        ;; Check if all units are non-zero (common case)
+        (if (i32.and (i32.and (local.get $unit0) (local.get $unit1))
+                    (i32.and (local.get $unit2) (local.get $unit3)))
+          (then
+            ;; Fast path: all units are non-zero
+            (local.set $writeAddr (i64.extend_i32_u (i32.mul (i32.add (local.get $startOffset) (local.get $count)) (i32.const 4))))
+            
+            ;; Write all units together
+            (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (local.get $writeAddr)) (local.get $unit0))
+            (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (i64.add (local.get $writeAddr) (i64.const 4))) (local.get $unit1))
+            (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (i64.add (local.get $writeAddr) (i64.const 8))) (local.get $unit2))
+            (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (i64.add (local.get $writeAddr) (i64.const 12))) (local.get $unit3))
+            
+            ;; Write all buffer indices together
+            (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+            (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (i64.add (local.get $writeAddr) (i64.const 4))) (local.get $bufferIndex))
+            (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (i64.add (local.get $writeAddr) (i64.const 8))) (local.get $bufferIndex))
+            (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (i64.add (local.get $writeAddr) (i64.const 12))) (local.get $bufferIndex))
+            
+            ;; Write all blocks together
+            (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (local.get $writeAddr)) (local.get $block))
+            (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (i64.add (local.get $writeAddr) (i64.const 4))) (local.get $block))
+            (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (i64.add (local.get $writeAddr) (i64.const 8))) (local.get $block))
+            (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (i64.add (local.get $writeAddr) (i64.const 12))) (local.get $block))
+            
+            ;; Increment count by 4
+            (local.set $count (i32.add (local.get $count) (i32.const 4))))
+          (else
+            ;; Slow path: at least one unit is zero (rare)
+            (local.set $j (i32.const 0))
+            (block $break_zeros
+              (loop $continue_zeros
+                (br_if $break_zeros (i32.ge_u (local.get $j) (i32.const 4)))
+                
+                ;; Read unit at offset j
+                (local.set $unit (i32.load align=0 (i64.add (local.get $readAddr) (i64.extend_i32_u (local.get $j)))))
+                
+                ;; Write if non-zero
+                (if (local.get $unit)
+                  (then
+                    (local.set $writeAddr (i64.extend_i32_u (i32.mul (i32.add (local.get $startOffset) (local.get $count)) (i32.const 4))))
+                    (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (local.get $writeAddr)) (local.get $unit))
+                    (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+                    (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (local.get $writeAddr)) (local.get $block))
+                    (local.set $count (i32.add (local.get $count) (i32.const 1)))))
+                
+                (local.set $j (i32.add (local.get $j) (i32.const 1)))
+                (br $continue_zeros)))))
+        
+        ;; Advance by 4 bytes
+        (local.set $i (i32.add (local.get $i) (i32.const 4)))
+        (br $continue_main)))
+    
+    ;; Tail loop for remaining bytes
+    (block $break_tail
+      (loop $continue_tail
+        (br_if $break_tail (i32.gt_u (local.get $i) (i32.sub (local.get $bufferLength) (i32.const 4))))
+        
+        ;; Read unit
+        (local.set $readAddr (i64.add (local.get $bufferPtr) (i64.extend_i32_u (local.get $i))))
+        (local.set $unit (i32.load align=0 (local.get $readAddr)))
+        
+        ;; Skip if unit is 0
+        (if (i32.eqz (local.get $unit))
+          (then
+            (local.set $i (i32.add (local.get $i) (i32.const 1)))
+            (br $continue_tail)))
+        
+        ;; Write unit
+        (local.set $writeAddr (i64.extend_i32_u (i32.mul (i32.add (local.get $startOffset) (local.get $count)) (i32.const 4))))
+        (i32.store align=0 (i64.add (local.get $unitsOutputPtr) (local.get $writeAddr)) (local.get $unit))
+        (i32.store align=0 (i64.add (local.get $bufferIndicesOutputPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+        (i32.store align=0 (i64.add (local.get $blocksOutputPtr) (local.get $writeAddr)) (local.get $block))
+        
+        (local.set $count (i32.add (local.get $count) (i32.const 1)))
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br $continue_tail)))
+    
+    (local.get $count))
+
+  ;; Phase 1: Count & Deduplicate using hash table
+  ;; Parameters:
+  ;;   - unitsPtr: pointer to units array
+  ;;   - totalUnits: number of units
+  ;;   - hashTablePtr: pointer to hash table [Unit, Count, Offset, ItemsWritten, ...]
+  ;;   - hashTableCapacity: capacity of hash table
+  ;;   - uniqueUnitListPtr: pointer to store unique units
+  ;;   - maxUniqueCount: maximum fill threshold for unique units
+  ;; Returns: uniqueCount (or -1 if exceeded threshold)
+  (func (export "phase1_count_deduplicate")
+    (param $unitsPtr i64)
+    (param $totalUnits i32)
+    (param $hashTablePtr i64)
+    (param $hashTableCapacity i32)
+    (param $uniqueUnitListPtr i64)
+    (param $maxUniqueCount i32)
+    (result i32)
+    
+    (local $i i32)
+    (local $unit i32)
+    (local $index i32)
+    (local $hashTableSize i32)
+    (local $uniqueCount i32)
+    (local $hashValue i32)
+    (local $unitAddr i64)
+    
+    ;; hashTableSize = hashTableCapacity * 4 * 4 (4 entries per slot, 4 bytes per entry)
+    (local.set $hashTableSize
+      (i32.mul (local.get $hashTableCapacity) (i32.const 16)))
+    
+    (local.set $uniqueCount (i32.const 0))
+    (local.set $i (i32.const 0))
+    (local.set $unitAddr (local.get $unitsPtr))
+    
+    ;; Loop through all units
+    (block $break
+      (loop $continue
+        ;; Check if we've processed all units
+        (br_if $break (i32.ge_u (local.get $i) (local.get $totalUnits)))
+        
+        ;; Read unit from unitsArray[i]
+        (local.set $unit (i32.load (local.get $unitAddr)))
+        (local.set $unitAddr (i64.add (local.get $unitAddr) (i64.const 4)))
+        
+        ;; Calculate hash index using helper
+        (local.set $index (call $hashUnitToIndex (local.get $unit) (local.get $hashTableCapacity)))
+        
+        ;; Linear probing
+        (block $probe_break
+          (loop $probe_continue
+            ;; Read value at hashTable[index]
+            (local.set $hashValue
+              (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index)))))
+            
+            ;; Check if empty slot (value == 0)
+            (if (i32.eqz (local.get $hashValue))
+              (then
+                ;; Empty slot - store unit
+                (i32.store 
+                  (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index)))
+                  (local.get $unit))
+                
+                ;; Store count = 1 at hashTable[index + 4]
+                (i32.store
+                  (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $index) (i32.const 4))))
+                  (i32.const 1))
+                
+                ;; Add to unique unit list
+                (i32.store
+                  (i64.add (local.get $uniqueUnitListPtr) 
+                          (i64.extend_i32_u (i32.mul (local.get $uniqueCount) (i32.const 4))))
+                  (local.get $unit))
+                
+                ;; Increment unique count
+                (local.set $uniqueCount (i32.add (local.get $uniqueCount) (i32.const 1)))
+                
+                ;; Check if exceeded threshold
+                (if (i32.gt_u (local.get $uniqueCount) (local.get $maxUniqueCount))
+                  (then
+                    (return (i32.const -1))))
+                
+                (br $probe_break)))
+            
+            ;; Check if matching unit
+            (if (i32.eq (local.get $hashValue) (local.get $unit))
+              (then
+                ;; Increment count at hashTable[index + 4]
+                (i32.store
+                  (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $index) (i32.const 4))))
+                  (i32.add
+                    (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $index) (i32.const 4)))))
+                    (i32.const 1)))
+                (br $probe_break)))
+            
+            ;; Collision - probe next slot
+            (local.set $index (call $getNextIndex (local.get $index) (local.get $hashTableSize)))
+            
+            (br $probe_continue)))
+        
+        ;; Next unit
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br $continue)))
+    
+    ;; Return unique count
+    (local.get $uniqueCount))
+
+  ;; Phase 3: Calculate offsets
+  ;; Parameters:
+  ;;   - uniqueUnitListPtr: pointer to sorted unique units
+  ;;   - uniqueCount: number of unique units
+  ;;   - hashTablePtr: pointer to hash table
+  ;;   - hashTableCapacity: capacity of hash table
+  ;;   - maxPositionsPerUnit: max positions to store per unit (typically 1000)
+  ;; Returns: total offset (size of output arrays)
+  (func (export "phase3_calc_offsets")
+    (param $uniqueUnitListPtr i64)
+    (param $uniqueCount i32)
+    (param $hashTablePtr i64)
+    (param $hashTableCapacity i32)
+    (param $maxPositionsPerUnit i32)
+    (result i32)
+    
+    (local $i i32)
+    (local $unit i32)
+    (local $index i32)
+    (local $hashTableSize i32)
+    (local $globalOffset i32)
+    (local $totalCount i32)
+    (local $effectiveCount i32)
+    (local $hashValue i32)
+    
+    (local.set $hashTableSize
+      (i32.mul (local.get $hashTableCapacity) (i32.const 16)))
+    
+    (local.set $globalOffset (i32.const 0))
+    (local.set $i (i32.const 0))
+    
+    (block $break
+      (loop $continue
+        (br_if $break (i32.ge_u (local.get $i) (local.get $uniqueCount)))
+        
+        ;; Read unit from uniqueUnitList[i]
+        (local.set $unit
+          (i32.load (i64.add (local.get $uniqueUnitListPtr) 
+                            (i64.extend_i32_u (i32.mul (local.get $i) (i32.const 4))))))
+        
+        ;; Find unit in hash table using helper
+        (local.set $index (call $hashUnitToIndex (local.get $unit) (local.get $hashTableCapacity)))
+        
+        ;; Linear probing to find the unit
+        (block $probe_break
+          (loop $probe_continue
+            (local.set $hashValue
+              (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index)))))
+            
+            (if (i32.eq (local.get $hashValue) (local.get $unit))
+              (then (br $probe_break)))
+            
+            (local.set $index (call $getNextIndex (local.get $index) (local.get $hashTableSize)))
+            
+            (br $probe_continue)))
+        
+        ;; Read totalCount from hashTable[index + 4]
+        (local.set $totalCount
+          (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $index) (i32.const 4))))))
+        
+        ;; effectiveCount = min(totalCount, maxPositionsPerUnit)
+        (local.set $effectiveCount (local.get $totalCount))
+        (if (i32.gt_u (local.get $effectiveCount) (local.get $maxPositionsPerUnit))
+          (then (local.set $effectiveCount (local.get $maxPositionsPerUnit))))
+        
+        ;; Store offset at hashTable[index + 8]
+        (i32.store
+          (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $index) (i32.const 8))))
+          (local.get $globalOffset))
+        
+        ;; Increment global offset
+        (local.set $globalOffset (i32.add (local.get $globalOffset) (local.get $effectiveCount)))
+        
+        ;; Next unit
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br $continue)))
+    
+    (local.get $globalOffset))
+
+  ;; Phase 4: Fill & Filter
+  ;; Parameters:
+  ;;   - unitsPtr: pointer to units array
+  ;;   - bufferIndicesPtr: pointer to buffer indices array
+  ;;   - blocksPtr: pointer to blocks array
+  ;;   - totalUnits: number of units
+  ;;   - hashTablePtr: pointer to hash table
+  ;;   - hashTableCapacity: capacity of hash table
+  ;;   - maxPositionsPerUnit: max positions per unit
+  ;;   - filteredUnitsPtr: output array for units
+  ;;   - filteredBufferIndicesPtr: output array for buffer indices
+  ;;   - filteredBlocksPtr: output array for blocks
+  ;; Returns: void
+  (func (export "phase4_fill_filter")
+    (param $unitsPtr i64)
+    (param $bufferIndicesPtr i64)
+    (param $blocksPtr i64)
+    (param $totalUnits i32)
+    (param $hashTablePtr i64)
+    (param $hashTableCapacity i32)
+    (param $maxPositionsPerUnit i32)
+    (param $filteredUnitsPtr i64)
+    (param $filteredBufferIndicesPtr i64)
+    (param $filteredBlocksPtr i64)
+    
+    (local $i i32)
+    (local $unit i32)
+    (local $bufferIndex i32)
+    (local $block i32)
+    (local $index i32)
+    (local $hashTableSize i32)
+    (local $itemsWritten i32)
+    (local $offset i32)
+    (local $writePos i32)
+    (local $hashValue i32)
+    (local $unitAddr i64)
+    (local $bufferIndexAddr i64)
+    (local $blockAddr i64)
+    (local $hashAddr i64)
+    (local $writeAddr i64)
+    
+    (local.set $hashTableSize
+      (i32.mul (local.get $hashTableCapacity) (i32.const 16)))
+    
+    (local.set $i (i32.const 0))
+    (local.set $unitAddr (local.get $unitsPtr))
+    (local.set $bufferIndexAddr (local.get $bufferIndicesPtr))
+    (local.set $blockAddr (local.get $blocksPtr))
+    
+    (block $break
+      (loop $continue
+        (br_if $break (i32.ge_u (local.get $i) (local.get $totalUnits)))
+        
+        ;; Read unit, bufferIndex, block from separate arrays
+        (local.set $unit (i32.load (local.get $unitAddr)))
+        (local.set $bufferIndex (i32.load (local.get $bufferIndexAddr)))
+        (local.set $block (i32.load (local.get $blockAddr)))
+        
+        ;; Advance to next position (4 bytes each)
+        (local.set $unitAddr (i64.add (local.get $unitAddr) (i64.const 4)))
+        (local.set $bufferIndexAddr (i64.add (local.get $bufferIndexAddr) (i64.const 4)))
+        (local.set $blockAddr (i64.add (local.get $blockAddr) (i64.const 4)))
+        
+        ;; Find unit in hash table using helper
+        (local.set $index (call $hashUnitToIndex (local.get $unit) (local.get $hashTableCapacity)))
+        
+        ;; Linear probing to find matching unit
+        (local.set $hashAddr (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index))))
+        (block $probe_break
+          (loop $probe_continue
+            (local.set $hashValue (i32.load (local.get $hashAddr)))
+            
+            (if (i32.eq (local.get $hashValue) (local.get $unit))
+              (then (br $probe_break)))
+            
+            ;; Probe next using helper
+            (local.set $index (call $getNextIndex (local.get $index) (local.get $hashTableSize)))
+            (local.set $hashAddr (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index))))
+            (br $probe_continue)))
+        
+        ;; Read itemsWritten from hashTable[index + 12] using hashAddr
+        (local.set $itemsWritten (i32.load (i64.add (local.get $hashAddr) (i64.const 12))))
+        
+        ;; Skip if already at max
+        (if (i32.ge_u (local.get $itemsWritten) (local.get $maxPositionsPerUnit))
+          (then
+            (local.set $i (i32.add (local.get $i) (i32.const 1)))
+            (br $continue)))
+        
+        ;; Read offset from hashTable[index + 8]
+        (local.set $offset (i32.load (i64.add (local.get $hashAddr) (i64.const 8))))
+        
+        ;; Calculate write position
+        (local.set $writePos (i32.add (local.get $offset) (local.get $itemsWritten)))
+        
+        ;; Write to output arrays - use precomputed addresses
+        (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+        (i32.store (i64.add (local.get $filteredUnitsPtr) (local.get $writeAddr)) (local.get $unit))
+        (i32.store (i64.add (local.get $filteredBufferIndicesPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+        (i32.store (i64.add (local.get $filteredBlocksPtr) (local.get $writeAddr)) (local.get $block))
+        
+        ;; Increment itemsWritten at hashTable[index + 12]
+        (i32.store (i64.add (local.get $hashAddr) (i64.const 12)) (i32.add (local.get $itemsWritten) (i32.const 1)))
+        
+        ;; Next unit
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br $continue)))
+  )
+
+  ;; Phase 4 Fill Filter Vector: Fill with collision detection (SIMD vectorized)
+  ;; Parameters:
+  ;;   - unitsPtr: pointer to units array
+  ;;   - bufferIndicesPtr: pointer to buffer indices array
+  ;;   - blocksPtr: pointer to blocks array
+  ;;   - totalUnits: number of units
+  ;;   - hashTablePtr: pointer to hash table
+  ;;   - hashTableCapacity: capacity of hash table
+  ;;   - maxPositionsPerUnit: max positions per unit
+  ;;   - filteredUnitsPtr: output array for units
+  ;;   - filteredBufferIndicesPtr: output array for buffer indices
+  ;;   - filteredBlocksPtr: output array for blocks
+  ;; Returns: number of times slow path was taken (as f64)
+  (func (export "phase4_fill_filter_vector")
+    (param $unitsPtr i64)
+    (param $bufferIndicesPtr i64)
+    (param $blocksPtr i64)
+    (param $totalUnits i32)
+    (param $hashTablePtr i64)
+    (param $hashTableCapacity i32)
+    (param $maxPositionsPerUnit i32)
+    (param $filteredUnitsPtr i64)
+    (param $filteredBufferIndicesPtr i64)
+    (param $filteredBlocksPtr i64)
+    (result f64)
+    
+    (local $i i32)
+    (local $slowPathCount f64)
+    (local $unitAddr i64)
+    (local $bufferIndexAddr i64)
+    (local $blockAddr i64)
+    (local $mainLoopEnd i32)
+    (local $hashTableSize i32)
+    
+    ;; SIMD vectors
+    (local $unitsVec v128)
+    (local $bufferIndicesVec v128)
+    (local $blocksVec v128)
+    (local $hashesVec v128)
+    (local $indicesVec v128)
+    
+    ;; SIMD constants
+    (local $hashConstVec v128)
+    (local $mult16Vec v128)
+    (local $shiftAmount i32)
+    
+    ;; Scalar temps for collision checking
+    (local $idx0 i32)
+    (local $idx1 i32)
+    (local $idx2 i32)
+    (local $idx3 i32)
+    (local $unit0 i32)
+    (local $unit1 i32)
+    (local $unit2 i32)
+    (local $unit3 i32)
+    (local $bufferIndex0 i32)
+    (local $bufferIndex1 i32)
+    (local $bufferIndex2 i32)
+    (local $bufferIndex3 i32)
+    (local $block0 i32)
+    (local $block1 i32)
+    (local $block2 i32)
+    (local $block3 i32)
+    (local $hash0 i32)
+    (local $hash1 i32)
+    (local $hash2 i32)
+    (local $hash3 i32)
+    (local $allMatch i32)
+    
+    ;; Temps for slow path processing
+    (local $unit i32)
+    (local $bufferIndex i32)
+    (local $block i32)
+    (local $index i32)
+    (local $hashValue i32)
+    (local $itemsWritten i32)
+    (local $offset i32)
+    (local $writePos i32)
+    (local $writeAddr i64)
+    (local $hashAddr i64)
+    
+    (local.set $i (i32.const 0))
+    (local.set $unitAddr (local.get $unitsPtr))
+    (local.set $bufferIndexAddr (local.get $bufferIndicesPtr))
+    (local.set $blockAddr (local.get $blocksPtr))
+    (local.set $slowPathCount (f64.const 0))
+    
+    ;; Calculate hash table size
+    (local.set $hashTableSize (i32.mul (local.get $hashTableCapacity) (i32.const 16)))
+    
+    ;; Initialize SIMD constants
+    (local.set $hashConstVec (i32x4.splat (i32.const 2654435761)))
+    (local.set $mult16Vec (i32x4.splat (i32.const 16)))
+    
+    ;; Calculate optimal shift amount for Fibonacci hashing
+    ;; shift_amount = 32 - log2(capacity) = 32 - (31 - clz(capacity)) = 1 + clz(capacity)
+    (local.set $shiftAmount (i32.add (i32.clz (local.get $hashTableCapacity)) (i32.const 1)))
+    
+    ;; Calculate main loop end (rounded down to multiple of 4)
+    (local.set $mainLoopEnd (i32.sub (local.get $totalUnits) (i32.rem_u (local.get $totalUnits) (i32.const 4))))
+    
+    ;; Main SIMD loop - process 4 units per iteration
+    (block $break_main
+      (loop $continue_main
+        (br_if $break_main (i32.ge_u (local.get $i) (local.get $mainLoopEnd)))
+        
+        ;; Load 4 units, buffer indices, and blocks at once using SIMD
+        (local.set $unitsVec (v128.load (local.get $unitAddr)))
+        (local.set $unitAddr (i64.add (local.get $unitAddr) (i64.const 16)))
+        
+        (local.set $bufferIndicesVec (v128.load (local.get $bufferIndexAddr)))
+        (local.set $bufferIndexAddr (i64.add (local.get $bufferIndexAddr) (i64.const 16)))
+        
+        (local.set $blocksVec (v128.load (local.get $blockAddr)))
+        (local.set $blockAddr (i64.add (local.get $blockAddr) (i64.const 16)))
+        
+        ;; Hash all 4 units in parallel: hash = unit * 2654435761
+        (local.set $hashesVec (i32x4.mul (local.get $unitsVec) (local.get $hashConstVec)))
+        
+        ;; Fibonacci hashing: shift by (32 - log2(capacity))
+        ;; This automatically masks to the correct number of bits without needing AND
+        (local.set $hashesVec (i32x4.shr_u (local.get $hashesVec) (local.get $shiftAmount)))
+        
+        ;; Multiply by 16 - vectorized (each slot is 16 bytes: 4 u32s)
+        (local.set $indicesVec (i32x4.mul (local.get $hashesVec) (local.get $mult16Vec)))
+        
+        ;; Extract all 4 indices for collision checking
+        (local.set $idx0 (i32x4.extract_lane 0 (local.get $indicesVec)))
+        (local.set $idx1 (i32x4.extract_lane 1 (local.get $indicesVec)))
+        (local.set $idx2 (i32x4.extract_lane 2 (local.get $indicesVec)))
+        (local.set $idx3 (i32x4.extract_lane 3 (local.get $indicesVec)))
+        
+        ;; Extract all 4 units for collision checking
+        (local.set $unit0 (i32x4.extract_lane 0 (local.get $unitsVec)))
+        (local.set $unit1 (i32x4.extract_lane 1 (local.get $unitsVec)))
+        (local.set $unit2 (i32x4.extract_lane 2 (local.get $unitsVec)))
+        (local.set $unit3 (i32x4.extract_lane 3 (local.get $unitsVec)))
+        
+        ;; Extract buffer indices and blocks using SIMD
+        (local.set $bufferIndex0 (i32x4.extract_lane 0 (local.get $bufferIndicesVec)))
+        (local.set $bufferIndex1 (i32x4.extract_lane 1 (local.get $bufferIndicesVec)))
+        (local.set $bufferIndex2 (i32x4.extract_lane 2 (local.get $bufferIndicesVec)))
+        (local.set $bufferIndex3 (i32x4.extract_lane 3 (local.get $bufferIndicesVec)))
+        
+        (local.set $block0 (i32x4.extract_lane 0 (local.get $blocksVec)))
+        (local.set $block1 (i32x4.extract_lane 1 (local.get $blocksVec)))
+        (local.set $block2 (i32x4.extract_lane 2 (local.get $blocksVec)))
+        (local.set $block3 (i32x4.extract_lane 3 (local.get $blocksVec)))
+        
+        ;; Load hash values at initial indices to check for collisions
+        (local.set $hash0 (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $idx0)))))
+        (local.set $hash1 (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $idx1)))))
+        (local.set $hash2 (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $idx2)))))
+        (local.set $hash3 (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $idx3)))))
+        
+        ;; Check if all 4 match (no collisions on first probe)
+        (local.set $allMatch
+          (i32.and
+            (i32.and
+              (i32.eq (local.get $hash0) (local.get $unit0))
+              (i32.eq (local.get $hash1) (local.get $unit1)))
+            (i32.and
+              (i32.eq (local.get $hash2) (local.get $unit2))
+              (i32.eq (local.get $hash3) (local.get $unit3)))))
+        
+        (if (local.get $allMatch)
+          (then
+            ;; Fast path - no collisions, process all 4 units inline
+            ;; Process unit 0
+            (local.set $itemsWritten (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx0) (i32.const 12))))))
+            (if (i32.lt_u (local.get $itemsWritten) (local.get $maxPositionsPerUnit))
+              (then
+                (local.set $offset (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx0) (i32.const 8))))))
+                (local.set $writePos (i32.add (local.get $offset) (local.get $itemsWritten)))
+                (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                (i32.store (i64.add (local.get $filteredUnitsPtr) (local.get $writeAddr)) (local.get $unit0))
+                (i32.store (i64.add (local.get $filteredBufferIndicesPtr) (local.get $writeAddr)) (local.get $bufferIndex0))
+                (i32.store (i64.add (local.get $filteredBlocksPtr) (local.get $writeAddr)) (local.get $block0))
+                (i32.store (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx0) (i32.const 12)))) (i32.add (local.get $itemsWritten) (i32.const 1)))))
+            
+            ;; Process unit 1
+            (local.set $itemsWritten (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx1) (i32.const 12))))))
+            (if (i32.lt_u (local.get $itemsWritten) (local.get $maxPositionsPerUnit))
+              (then
+                (local.set $offset (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx1) (i32.const 8))))))
+                (local.set $writePos (i32.add (local.get $offset) (local.get $itemsWritten)))
+                (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                (i32.store (i64.add (local.get $filteredUnitsPtr) (local.get $writeAddr)) (local.get $unit1))
+                (i32.store (i64.add (local.get $filteredBufferIndicesPtr) (local.get $writeAddr)) (local.get $bufferIndex1))
+                (i32.store (i64.add (local.get $filteredBlocksPtr) (local.get $writeAddr)) (local.get $block1))
+                (i32.store (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx1) (i32.const 12)))) (i32.add (local.get $itemsWritten) (i32.const 1)))))
+            
+            ;; Process unit 2
+            (local.set $itemsWritten (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx2) (i32.const 12))))))
+            (if (i32.lt_u (local.get $itemsWritten) (local.get $maxPositionsPerUnit))
+              (then
+                (local.set $offset (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx2) (i32.const 8))))))
+                (local.set $writePos (i32.add (local.get $offset) (local.get $itemsWritten)))
+                (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                (i32.store (i64.add (local.get $filteredUnitsPtr) (local.get $writeAddr)) (local.get $unit2))
+                (i32.store (i64.add (local.get $filteredBufferIndicesPtr) (local.get $writeAddr)) (local.get $bufferIndex2))
+                (i32.store (i64.add (local.get $filteredBlocksPtr) (local.get $writeAddr)) (local.get $block2))
+                (i32.store (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx2) (i32.const 12)))) (i32.add (local.get $itemsWritten) (i32.const 1)))))
+            
+            ;; Process unit 3
+            (local.set $itemsWritten (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx3) (i32.const 12))))))
+            (if (i32.lt_u (local.get $itemsWritten) (local.get $maxPositionsPerUnit))
+              (then
+                (local.set $offset (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx3) (i32.const 8))))))
+                (local.set $writePos (i32.add (local.get $offset) (local.get $itemsWritten)))
+                (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                (i32.store (i64.add (local.get $filteredUnitsPtr) (local.get $writeAddr)) (local.get $unit3))
+                (i32.store (i64.add (local.get $filteredBufferIndicesPtr) (local.get $writeAddr)) (local.get $bufferIndex3))
+                (i32.store (i64.add (local.get $filteredBlocksPtr) (local.get $writeAddr)) (local.get $block3))
+                (i32.store (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (i32.add (local.get $idx3) (i32.const 12)))) (i32.add (local.get $itemsWritten) (i32.const 1))))))
+          (else
+            ;; Slow path - at least one collision, process each unit with linear probing
+            (local.set $slowPathCount (f64.add (local.get $slowPathCount) (f64.const 1)))
+            
+            ;; Process unit 0
+            (local.set $unit (local.get $unit0))
+            (local.set $bufferIndex (local.get $bufferIndex0))
+            (local.set $block (local.get $block0))
+            (local.set $index (local.get $idx0))
+            (block $probe_break0
+              (loop $probe_continue0
+                (local.set $hashValue (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index)))))
+                (if (i32.eq (local.get $hashValue) (local.get $unit))
+                  (then (br $probe_break0)))
+                (local.set $index (call $getNextIndex (local.get $index) (local.get $hashTableSize)))
+                (br $probe_continue0)))
+            (local.set $hashAddr (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index))))
+            (local.set $itemsWritten (i32.load (i64.add (local.get $hashAddr) (i64.const 12))))
+            (if (i32.lt_u (local.get $itemsWritten) (local.get $maxPositionsPerUnit))
+              (then
+                (local.set $offset (i32.load (i64.add (local.get $hashAddr) (i64.const 8))))
+                (local.set $writePos (i32.add (local.get $offset) (local.get $itemsWritten)))
+                (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                (i32.store (i64.add (local.get $filteredUnitsPtr) (local.get $writeAddr)) (local.get $unit))
+                (i32.store (i64.add (local.get $filteredBufferIndicesPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+                (i32.store (i64.add (local.get $filteredBlocksPtr) (local.get $writeAddr)) (local.get $block))
+                (i32.store (i64.add (local.get $hashAddr) (i64.const 12)) (i32.add (local.get $itemsWritten) (i32.const 1)))))
+            
+            ;; Process unit 1
+            (local.set $unit (local.get $unit1))
+            (local.set $bufferIndex (local.get $bufferIndex1))
+            (local.set $block (local.get $block1))
+            (local.set $index (local.get $idx1))
+            (block $probe_break1
+              (loop $probe_continue1
+                (local.set $hashValue (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index)))))
+                (if (i32.eq (local.get $hashValue) (local.get $unit))
+                  (then (br $probe_break1)))
+                (local.set $index (call $getNextIndex (local.get $index) (local.get $hashTableSize)))
+                (br $probe_continue1)))
+            (local.set $hashAddr (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index))))
+            (local.set $itemsWritten (i32.load (i64.add (local.get $hashAddr) (i64.const 12))))
+            (if (i32.lt_u (local.get $itemsWritten) (local.get $maxPositionsPerUnit))
+              (then
+                (local.set $offset (i32.load (i64.add (local.get $hashAddr) (i64.const 8))))
+                (local.set $writePos (i32.add (local.get $offset) (local.get $itemsWritten)))
+                (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                (i32.store (i64.add (local.get $filteredUnitsPtr) (local.get $writeAddr)) (local.get $unit))
+                (i32.store (i64.add (local.get $filteredBufferIndicesPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+                (i32.store (i64.add (local.get $filteredBlocksPtr) (local.get $writeAddr)) (local.get $block))
+                (i32.store (i64.add (local.get $hashAddr) (i64.const 12)) (i32.add (local.get $itemsWritten) (i32.const 1)))))
+            
+            ;; Process unit 2
+            (local.set $unit (local.get $unit2))
+            (local.set $bufferIndex (local.get $bufferIndex2))
+            (local.set $block (local.get $block2))
+            (local.set $index (local.get $idx2))
+            (block $probe_break2
+              (loop $probe_continue2
+                (local.set $hashValue (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index)))))
+                (if (i32.eq (local.get $hashValue) (local.get $unit))
+                  (then (br $probe_break2)))
+                (local.set $index (call $getNextIndex (local.get $index) (local.get $hashTableSize)))
+                (br $probe_continue2)))
+            (local.set $hashAddr (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index))))
+            (local.set $itemsWritten (i32.load (i64.add (local.get $hashAddr) (i64.const 12))))
+            (if (i32.lt_u (local.get $itemsWritten) (local.get $maxPositionsPerUnit))
+              (then
+                (local.set $offset (i32.load (i64.add (local.get $hashAddr) (i64.const 8))))
+                (local.set $writePos (i32.add (local.get $offset) (local.get $itemsWritten)))
+                (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                (i32.store (i64.add (local.get $filteredUnitsPtr) (local.get $writeAddr)) (local.get $unit))
+                (i32.store (i64.add (local.get $filteredBufferIndicesPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+                (i32.store (i64.add (local.get $filteredBlocksPtr) (local.get $writeAddr)) (local.get $block))
+                (i32.store (i64.add (local.get $hashAddr) (i64.const 12)) (i32.add (local.get $itemsWritten) (i32.const 1)))))
+            
+            ;; Process unit 3
+            (local.set $unit (local.get $unit3))
+            (local.set $bufferIndex (local.get $bufferIndex3))
+            (local.set $block (local.get $block3))
+            (local.set $index (local.get $idx3))
+            (block $probe_break3
+              (loop $probe_continue3
+                (local.set $hashValue (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index)))))
+                (if (i32.eq (local.get $hashValue) (local.get $unit))
+                  (then (br $probe_break3)))
+                (local.set $index (call $getNextIndex (local.get $index) (local.get $hashTableSize)))
+                (br $probe_continue3)))
+            (local.set $hashAddr (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index))))
+            (local.set $itemsWritten (i32.load (i64.add (local.get $hashAddr) (i64.const 12))))
+            (if (i32.lt_u (local.get $itemsWritten) (local.get $maxPositionsPerUnit))
+              (then
+                (local.set $offset (i32.load (i64.add (local.get $hashAddr) (i64.const 8))))
+                (local.set $writePos (i32.add (local.get $offset) (local.get $itemsWritten)))
+                (local.set $writeAddr (i64.extend_i32_u (i32.mul (local.get $writePos) (i32.const 4))))
+                (i32.store (i64.add (local.get $filteredUnitsPtr) (local.get $writeAddr)) (local.get $unit))
+                (i32.store (i64.add (local.get $filteredBufferIndicesPtr) (local.get $writeAddr)) (local.get $bufferIndex))
+                (i32.store (i64.add (local.get $filteredBlocksPtr) (local.get $writeAddr)) (local.get $block))
+                (i32.store (i64.add (local.get $hashAddr) (i64.const 12)) (i32.add (local.get $itemsWritten) (i32.const 1)))))))
+        
+        ;; Increment by 4
+        (local.set $i (i32.add (local.get $i) (i32.const 4)))
+        (br $continue_main)))
+    
+    ;; Return slow path count
+    (local.get $slowPathCount))
+
+  ;; Count Collisions: Calculate collision count for phase1
+  ;; Parameters:
+  ;;   - unitsPtr: pointer to units array
+  ;;   - totalUnits: number of units
+  ;;   - hashTablePtr: pointer to hash table
+  ;;   - hashTableCapacity: capacity of hash table
+  ;; Returns: total collision count
+  (func (export "count_collisions")
+    (param $unitsPtr i64)
+    (param $totalUnits i32)
+    (param $hashTablePtr i64)
+    (param $hashTableCapacity i32)
+    (result i32)
+    
+    (local $i i32)
+    (local $unit i32)
+    (local $index i32)
+    (local $hashTableSize i32)
+    (local $hashValue i32)
+    (local $unitAddr i64)
+    (local $collisions i32)
+    (local $probeCount i32)
+    
+    (local.set $hashTableSize (i32.mul (local.get $hashTableCapacity) (i32.const 16)))
+    (local.set $collisions (i32.const 0))
+    (local.set $i (i32.const 0))
+    (local.set $unitAddr (local.get $unitsPtr))
+    
+    ;; Loop through all units
+    (block $break
+      (loop $continue
+        (br_if $break (i32.ge_u (local.get $i) (local.get $totalUnits)))
+        
+        ;; Read unit
+        (local.set $unit (i32.load (local.get $unitAddr)))
+        (local.set $unitAddr (i64.add (local.get $unitAddr) (i64.const 4)))
+        
+        ;; Calculate hash index
+        (local.set $index (call $hashUnitToIndex (local.get $unit) (local.get $hashTableCapacity)))
+        (local.set $probeCount (i32.const 0))
+        
+        ;; Linear probing - count collisions
+        (block $probe_break
+          (loop $probe_continue
+            (local.set $hashValue
+              (i32.load (i64.add (local.get $hashTablePtr) (i64.extend_i32_u (local.get $index)))))
+            
+            ;; Check if empty slot or matching unit (we're done)
+            (if (i32.eqz (local.get $hashValue))
+              (then (br $probe_break)))
+            
+            (if (i32.eq (local.get $hashValue) (local.get $unit))
+              (then (br $probe_break)))
+            
+            ;; Collision - increment and probe next
+            (local.set $probeCount (i32.add (local.get $probeCount) (i32.const 1)))
+            (local.set $index (call $getNextIndex (local.get $index) (local.get $hashTableSize)))
+            (br $probe_continue)))
+        
+        ;; Add probe count to total collisions
+        (local.set $collisions (i32.add (local.get $collisions) (local.get $probeCount)))
+        
+        ;; Next unit
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br $continue)))
+    
+    (local.get $collisions))
+)