VecDeleteRange

    /// TAGS: Str, Delete, Range
    ///
    #define StrDeleteRange(str, start, count) VecDeleteRange((str), (start), (count))
    
    ///

                uint64_t len = VecLen(vec);
                if (len > 0 && start < len && count > 0 && start + count <= len) {
                    VecDeleteRange(vec, start, count);
                }
                break;

                    size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
                    size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
                    VecDeleteRange(vec, index, count);
                }
                break;

                    size_t index = extract_u32(data, offset, data_size) % VecLen(vec);
                    size_t count = extract_u32(data, offset, data_size) % (VecLen(vec) - index + 1);
                    VecDeleteRange(vec, index, count);
                }
                break;

    
        // Test VecDeleteRange (regular delete range)
        VecDeleteRange(&vec, 0, 2); // Delete 10 and 20
    
        // Check vector length after range deletion

    // Test VecDeleteRange function
    bool test_vec_delete_range(void) {
        WriteFmtLn("Testing VecDeleteRange");
    
        // Create a vector of integers

    
        // Delete range from index 2 to 4 (values 30, 40, 50)
        VecDeleteRange(&vec, 2, 3);
    
        // Check new length

        int start_index = 2;
        int count       = 3;
        VecDeleteRange(&vec, start_index, count); // Delete 30, 40, 50
    
        // Check vector after L-value range deletion

    
        // Test R-value delete range operation
        VecDeleteRange(&vec, 2, 3); // Delete 30, 40, 50
    
        // Check vector after R-value range deletion

        // start large, count small: real move = N - start - 2; mutant move adds
        // 2*start ~= 40000 elements (~160 KB) of over-read/over-write past the end.
        VecDeleteRange(&vec, 20000, 2);
    
        bool result = (VecLen(&vec) == (u64)(N - 2)) && (VecAt(&vec, 0) == 0) && (VecAt(&vec, 19999) == 19999) &&

        // 2*K ~= 40000 elements (~160 KB) of over-read/over-write past the end.
        const u64 K = 20000;
        VecDeleteRange(&vec, 0, K);
    
        bool result = (VecLen(&vec) == (u64)N - K) && (VecAt(&vec, 0) == (int)K) && (VecAt(&vec, 19999) == (int)(N - 1));

        }
    
        VecDeleteRange(&vec, 1, 2); // real move ~ (N-3)*4 bytes; mutant ~ (N-3)*42 (~1.5 MB)
    
        bool result = (VecLen(&vec) == (u64)(N - 2)) && (VecAt(&vec, 0) == 0) && (VecAt(&vec, 1) == 3) &&

        }
    
        VecDeleteRange(&vec, 3, 2); // length becomes 8
    
        // Dead slot 9 (previously a duplicate of 9) must be zeroed.

        }
    
        VecDeleteRange(&vec, 3, 2); // length becomes 8
    
        // Dead slot 9 must be zeroed, not left as a stale duplicate.

        // from vec_ptr_at(length-count), running well past the end of the buffer.
        const u64 K = 30000;
        VecDeleteRange(&vec, 0, K); // length becomes N-K
    
        bool result = (VecLen(&vec) == (u64)N - K) && (VecAt(&vec, 0) == (int)K);

        // Remove the final element. Real move size = length - (length-1) - 1 = 0.
        // Mutant size = length + (length-1) - 1 = 2*length - 2 elements -> overrun.
        VecDeleteRange(&vec, old_len - 1, 1);
    
        bool result = (VecLen(&vec) == old_len - 1);

        // length - 0 - (length-1) = 1. Mutant size = length - 0 + (length-1) =
        // 2*length - 1 elements -> overrun far past the buffer.
        VecDeleteRange(&vec, 0, old_len - 1);
    
        bool result = (VecLen(&vec) == 1);

            // When we reach idx=3, delete several elements
            if (idx == 3) {
                VecDeleteRange(&vec, 0, 6); // Remove first 6 elements
                WriteFmt("Deleted first 6 elements, new length={}, idx = {}\n", VecLen(&vec), original_length, idx);
            }