size_t total_len = 0;
    VecForeach(vec, str) {
    total_len += ZstrLen(str.data);
    }
    (void)total_len; // Suppress unused variable warning

    size_t total_len = 0;
    VecForeachReverse(vec, str) {
    total_len += ZstrLen(str.data);
    }
    (void)total_len; // Suppress unused variable warning

    size_t total_len = 0;
    VecForeachReverseIdx(vec, str, idx) {
    total_len += ZstrLen(str.data) + idx;
    }
    (void)total_len; // Suppress unused variable warning

    size_t total_len = 0;
    VecForeachPtrReverse(vec, str_ptr) {
    total_len += ZstrLen(str_ptr->data);
    }
    (void)total_len; // Suppress unused variable warning

    size_t total_len = 0;
    VecForeachPtrReverseIdx(vec, str_ptr, idx) {
    total_len += ZstrLen(str_ptr->data) + idx;
    }
    (void)total_len; // Suppress unused variable warning

    size_t total_len = 0;
    VecForeachInRange(vec, str, start, end) {
    total_len += ZstrLen(str.data);
    }
    (void)total_len; // Suppress unused variable warning

    size_t total_len = 0;
    VecForeachInRangeIdx(vec, str, idx, start, end) {
    total_len += ZstrLen(str.data) + idx;
    }
    (void)total_len; // Suppress unused variable warning

    size_t total_len = 0;
    VecForeachPtrInRange(vec, str_ptr, start, end) {
    total_len += ZstrLen(str_ptr->data);
    }
    (void)total_len; // Suppress unused variable warning

    size_t total_len = 0;
    VecForeachPtrInRangeIdx(vec, str_ptr, idx, start, end) {
    total_len += ZstrLen(str_ptr->data) + idx;
    }
    (void)total_len; // Suppress unused variable warning

    }
    
    size ZstrLen(const char *str) {
    if (!str) {
    LOG_FATAL("Invalid arguments");

    
    char *ZstrDup(const char *src) {
    return ZstrDupN(src, ZstrLen(src));
    }

    
    // Calculate haystack length
    size haystack_len = ZstrLen(haystack);
    
    // if needle is longer than haystack, is it really a needle?

    const char *p         = fmtstr;
    const char *in        = input;
    u64         rem_p     = ZstrLen(fmtstr);
    u64         rem_in    = ZstrLen(in);
    u64         arg_index = 0; // Current argument index

    const char *in        = input;
    u64         rem_p     = ZstrLen(fmtstr);
    u64         rem_in    = ZstrLen(in);
    u64         arg_index = 0; // Current argument index

    dot = strchr(body, '.');
    if (!dot) {
    StrPushBackCstr(&result, body, ZstrLen(body));
    
    if (precision > 0) {

    
    prefix = (u64)(dot - body);
    frac   = (u64)ZstrLen(dot + 1);
    
    StrPushBackCstr(&result, body, prefix);

    } else {
    // Get string length
    size len = ZstrLen(xs);
    
    // If precision is specified, use it as max length

    
    StrIters sv     = VecInit();
    size     keylen = ZstrLen(key);
    
    const char *prev = s->data;

    
    Strs sv     = VecInitWithDeepCopy(NULL, StrDeinit);
    size keylen = ZstrLen(key);
    
    const char *prev = s->data;

    bool StrStartsWithZstr(const Str *s, const char *prefix) {
    ValidateStr(s);
    return starts_with(s->data, s->length, prefix, ZstrLen(prefix));
    }

    bool StrEndsWithZstr(const Str *s, const char *suffix) {
    ValidateStr(s);
    return ends_with(s->data, s->length, suffix, ZstrLen(suffix));
    }

    void StrReplaceZstr(Str *s, const char *match, const char *replacement, size count) {
    ValidateStr(s);
    str_replace(s, match, ZstrLen(match), replacement, ZstrLen(replacement), count);
    }

    // Copy name
    if (src->name) {
    size name_len = ZstrLen(src->name);
    dst->name     = malloc(name_len + 1);
    if (!dst->name)