혹시 이 코드 어떤 부분에서 segmentation falut가 떴는지 알려주실 수 있으실까요?

    size_t  ft_count_words(const char *s, char c)
    {
        size_t  i;
        size_t  count;
        size_t  ibool;
 
        i = 0;
        count = 0;
        ibool = 1;
        while (s[i])
        {
            while (s[i] == c && s[i])
                i++;
            while (s[i] != c && s[i])
            {
                if (ibool == 1)
                    count++;
                ibool = 0;
                i++;
            }
            ibool = 1;
        }
        return (count);
    }
 
    size_t  ft_splitlen(const char *str, char c)
    {
        size_t  i;
 
        i = 0;
        while (str[i] != c && str[i])
            i++;
        return (i);
    }
 
    char    *ft_splitdup(const char *str, char c)
    {
        char    *word;
        size_t  i;
 
        i = 0;
        if (!(word = (char *)malloc((ft_splitlen(str, c) + 1) * sizeof(char))))
            return (NULL);
        while (str[i] != c && str[i])
        {
            word[i] = str[i];
            i++;
        }
        word[i] = '\0';
        return (word);
    }
 
    char    **ft_splitfree(char **base_split)
    {
        size_t  i;
 
        i = 0;
        while (base_split[i])
        {
            free(base_split[i]);
            i++;
        }
        free(base_split);
        return (NULL);
    }
 
    char    **ft_split(const char *s, char c)
    {
        char    **best_split;
        size_t  i;
        size_t  j;
 
        if (!s || !c)
            return (NULL);
        i = 0;
        j = 0;
        if (!(best_split = (char **)malloc((ft_count_words(s, c) + 1)\
                        * sizeof(char *))))
            return (NULL);
        while (s[i])
        {
            while (s[i] == c && s[i])
                i++;
            while (s[i] != c && s[i])
            {
                if (!(best_split[j] = ft_splitdup(s + i, c)))
                    return (ft_splitfree(best_split));
                i += ft_splitlen(s + i, c);
                j++;
            }
        }
        best_split[j] = NULL;
        return (best_split);
    }
 
    int                 main()
    {
        char **test;
        test = ft_split("lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non risus. Suspendisse", ' ');
    }

==348== Memcheck, a memory error detector
==348== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==348== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==348== Command: ./test
==348== 
==348== 
==348== HEAP SUMMARY:
==348==     in use at exit: 188 bytes in 13 blocks
==348==   total heap usage: 13 allocs, 0 frees, 188 bytes allocated
==348== 
==348== 188 (104 direct, 84 indirect) bytes in 1 blocks are definitely lost in loss record 2 of 2
==348==    at 0x483B7F3: malloc (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==348==    by 0x1093D8: ft_split (ft_split.c:91)
==348==    by 0x109506: main (ft_split.c:113)
==348== 
==348== LEAK SUMMARY:
==348==    definitely lost: 104 bytes in 1 blocks
==348==    indirectly lost: 84 bytes in 12 blocks
==348==      possibly lost: 0 bytes in 0 blocks
==348==    still reachable: 0 bytes in 0 blocks
==348==         suppressed: 0 bytes in 0 blocks
==348== 
==348== For lists of detected and suppressed errors, rerun with: -s
==348== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)