#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ memcpy(char *, char const *, int);
void *ne_malloc(int);
char *ne_strdup(char *);
char *strchr(char const *, char const);
char **split_string_c(const char *str, const char separator, const char *quotes,
                      const char *whitespace, int *give_count) {
  char **comps;
  const char *pnt, *quot = NULL, *start, *end;
  int count, iswhite, issep, curr, length, leading_wspace;
  count = 1;
  for (pnt = str; *pnt != '\0'; pnt++) {
    if (quotes != NULL) {
      quot = strchr(quotes, *pnt);
    }
    if (quot != NULL) {
      for (pnt++; (*pnt != *quot) && (*pnt != '\0'); pnt++)
        ;
    } else if (*pnt == separator) {
      count++;
    }
  }
  if (give_count) {
    *give_count = count;
  }
  comps = ne_malloc(sizeof(char *) * (count + 1));
  comps[count] = NULL;
  quot = end = start = NULL;
  curr = 0;
  leading_wspace = 1;
  for (pnt = str; *pnt != '\0'; pnt++) {
    if (quotes != NULL) {
      quot = strchr(quotes, *pnt);
    }
    iswhite = (whitespace != NULL) && (strchr(whitespace, *pnt) != NULL);
    issep = (*pnt == separator);
    if (leading_wspace) {
      if (quot != NULL) {
        start = pnt;
        length = 1;
        leading_wspace = 0;
      } else if (issep) {
        comps[curr++] = ne_strdup("");
      } else if (!iswhite) {
        start = end = pnt;
        length = 1;
        leading_wspace = 0;
      }
    } else {
      if (quot != NULL) {
        length++;
      } else if (issep) {
        length = (end - start) + 1;
        comps[curr] = ne_malloc(length + 1);
        memcpy(comps[curr], start, length);
        comps[curr][length] = '\0';
        curr++;
        leading_wspace = 1;
      } else if (!iswhite) {
        end = pnt;
      }
    }
    if (quot != NULL) {
      for (pnt++; *pnt != *quot && *pnt != '\0'; ++pnt)
        ;
      end = pnt;
    }
  }
  if (leading_wspace) {
    comps[curr] = ne_strdup("");
  } else {
    length = (end - start) + 1;
    comps[curr] = ne_malloc(length + 1);
    memcpy(comps[curr], start, length);
    comps[curr][length] = '\0';
  }
  return comps;
}


x86 assembly (clang, -O0):
<split_string_c>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %sil,%al
mov    %rdi,-0x8(%rbp)
mov    %al,-0x9(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x0,-0x40(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1248 <split_string_c+0x108>
cmpq   $0x0,-0x18(%rbp)
je     11a4 <split_string_c+0x64>
mov    -0x18(%rbp),%rdi
mov    -0x38(%rbp),%rax
movsbl (%rax),%esi
call   1030 <strchr@plt>
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
je     1211 <split_string_c+0xd1>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
mov    -0x40(%rbp),%rax
movsbl (%rax),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x69(%rbp)
je     11e6 <split_string_c+0xa6>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x69(%rbp)
mov    -0x69(%rbp),%al
test   $0x1,%al
jne    11f6 <split_string_c+0xb6>
jmp    120c <split_string_c+0xcc>
jmp    11fb <split_string_c+0xbb>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    11bb <split_string_c+0x7b>
jmp    1232 <split_string_c+0xf2>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
movsbl -0x9(%rbp),%ecx
cmp    %ecx,%eax
jne    122d <split_string_c+0xed>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1232 <split_string_c+0xf2>
jmp    1237 <split_string_c+0xf7>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1175 <split_string_c+0x35>
cmpq   $0x0,-0x28(%rbp)
je     125c <split_string_c+0x11c>
mov    -0x54(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <ne_malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x40(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x1,-0x68(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     14fb <split_string_c+0x3bb>
cmpq   $0x0,-0x18(%rbp)
je     12e0 <split_string_c+0x1a0>
mov    -0x18(%rbp),%rdi
mov    -0x38(%rbp),%rax
movsbl (%rax),%esi
call   1030 <strchr@plt>
mov    %rax,-0x40(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x20(%rbp)
mov    %al,-0x6a(%rbp)
je     130a <split_string_c+0x1ca>
mov    -0x20(%rbp),%rdi
mov    -0x38(%rbp),%rax
movsbl (%rax),%esi
call   1030 <strchr@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x6a(%rbp)
mov    -0x6a(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
movsbl -0x9(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x68(%rbp)
je     13c4 <split_string_c+0x284>
cmpq   $0x0,-0x40(%rbp)
je     135d <split_string_c+0x21d>
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x64(%rbp)
movl   $0x0,-0x68(%rbp)
jmp    13bf <split_string_c+0x27f>
cmpl   $0x0,-0x5c(%rbp)
je     1391 <split_string_c+0x251>
lea    0xc92(%rip),%rdi
call   1060 <ne_strdup@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x60(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    13ba <split_string_c+0x27a>
cmpl   $0x0,-0x58(%rbp)
jne    13b5 <split_string_c+0x275>
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x64(%rbp)
movl   $0x0,-0x68(%rbp)
jmp    13ba <split_string_c+0x27a>
jmp    13bf <split_string_c+0x27f>
jmp    1475 <split_string_c+0x335>
cmpq   $0x0,-0x40(%rbp)
je     13dd <split_string_c+0x29d>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1470 <split_string_c+0x330>
cmpl   $0x0,-0x5c(%rbp)
je     1454 <split_string_c+0x314>
mov    -0x50(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%edi
add    $0x1,%edi
call   1050 <ne_malloc@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x64(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x64(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x1,-0x68(%rbp)
jmp    146b <split_string_c+0x32b>
cmpl   $0x0,-0x58(%rbp)
jne    1466 <split_string_c+0x326>
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    146b <split_string_c+0x32b>
jmp    1470 <split_string_c+0x330>
jmp    1475 <split_string_c+0x335>
cmpq   $0x0,-0x40(%rbp)
je     14e5 <split_string_c+0x3a5>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
mov    -0x40(%rbp),%rax
movsbl (%rax),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x6b(%rbp)
je     14b7 <split_string_c+0x377>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x6b(%rbp)
mov    -0x6b(%rbp),%al
test   $0x1,%al
jne    14c7 <split_string_c+0x387>
jmp    14dd <split_string_c+0x39d>
jmp    14cc <split_string_c+0x38c>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    148c <split_string_c+0x34c>
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    14ea <split_string_c+0x3aa>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    12b1 <split_string_c+0x171>
cmpl   $0x0,-0x68(%rbp)
je     1525 <split_string_c+0x3e5>
lea    0xaf4(%rip),%rdi
call   1060 <ne_strdup@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    157d <split_string_c+0x43d>
mov    -0x50(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%edi
add    $0x1,%edi
call   1050 <ne_malloc@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x64(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x64(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<split_string_c>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8,%r15
mov    %rcx,0x40(%rsp)
mov    %rdx,%r13
mov    %esi,0x14(%rsp)
mov    %rdi,%rbx
mov    (%rdi),%r12b
mov    $0x1,%r14d
test   %r12b,%r12b
je     11d2 <split_string_c+0x92>
xor    %eax,%eax
mov    %rbx,%rbp
jmp    119a <split_string_c+0x5a>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ecx,%ecx
cmp    0x14(%rsp),%r12b
sete   %cl
add    %ecx,%r14d
mov    0x1(%rbp),%r12b
add    $0x1,%rbp
test   %r12b,%r12b
je     11d2 <split_string_c+0x92>
test   %r13,%r13
je     11ab <split_string_c+0x6b>
movsbl %r12b,%esi
mov    %r13,%rdi
call   1030 <strchr@plt>
test   %rax,%rax
je     1180 <split_string_c+0x40>
mov    (%rax),%cl
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x1(%rbp),%edx
add    $0x1,%rbp
test   %dl,%dl
je     118d <split_string_c+0x4d>
cmp    %cl,%dl
jne    11c0 <split_string_c+0x80>
jmp    118d <split_string_c+0x4d>
test   %r15,%r15
je     11da <split_string_c+0x9a>
mov    %r14d,(%r15)
lea    0x8(,%r14,8),%edi
call   1050 <ne_malloc@plt>
mov    %rax,%r15
movslq %r14d,%rax
movq   $0x0,(%r15,%rax,8)
mov    (%rbx),%r12b
test   %r12b,%r12b
je     13dc <split_string_c+0x29c>
mov    %r15,0x28(%rsp)
mov    %r13,0x38(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    $0x1,%r15d
lea    0xde1(%rip),%rbp
xor    %r13d,%r13d
xor    %eax,%eax
mov    %rax,0x8(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
jmp    126c <split_string_c+0x12c>
mov    %rbp,%rdi
call   1060 <ne_strdup@plt>
mov    0x18(%rsp),%rdx
movslq %edx,%rcx
add    $0x1,%edx
mov    %rdx,0x18(%rsp)
mov    0x28(%rsp),%rdx
mov    %rax,(%rdx,%rcx,8)
mov    $0x1,%r15d
xor    %eax,%eax
mov    0x1(%rbx),%r12b
add    $0x1,%rbx
test   %r12b,%r12b
je     1397 <split_string_c+0x257>
movsbl %r12b,%r14d
mov    0x38(%rsp),%rdi
test   %rdi,%rdi
je     1285 <split_string_c+0x145>
mov    %r14d,%esi
call   1030 <strchr@plt>
mov    %rax,%r13
mov    0x40(%rsp),%rdi
test   %rdi,%rdi
je     12d0 <split_string_c+0x190>
mov    %r14d,%esi
call   1030 <strchr@plt>
test   %rax,%rax
setne  %al
test   %r15d,%r15d
je     12d7 <split_string_c+0x197>
mov    %rbx,%rsi
test   %r13,%r13
jne    12e1 <split_string_c+0x1a1>
cmp    0x14(%rsp),%r12b
je     1232 <split_string_c+0xf2>
xor    %r15d,%r15d
test   %al,%al
jne    1253 <split_string_c+0x113>
mov    $0x1,%al
mov    %rbx,%rcx
mov    %rbx,0x20(%rsp)
jmp    130d <split_string_c+0x1cd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %eax,%eax
test   %r15d,%r15d
jne    12a2 <split_string_c+0x162>
test   %r13,%r13
je     1317 <split_string_c+0x1d7>
mov    0x20(%rsp),%rsi
mov    0x0(%r13),%dl
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x1(%rbx),%ecx
add    $0x1,%rbx
xor    %r15d,%r15d
mov    $0x1,%al
test   %cl,%cl
je     1305 <split_string_c+0x1c5>
cmp    %dl,%cl
jne    12f0 <split_string_c+0x1b0>
mov    %rsi,0x20(%rsp)
mov    %rbx,%rcx
mov    %rbx,0x8(%rsp)
jmp    125b <split_string_c+0x11b>
cmp    0x14(%rsp),%r12b
jne    137d <split_string_c+0x23d>
mov    0x8(%rsp),%rdi
mov    0x20(%rsp),%r14
sub    %r14d,%edi
lea    0x1(%rdi),%eax
mov    %eax,0x34(%rsp)
add    $0x2,%edi
call   1050 <ne_malloc@plt>
mov    0x18(%rsp),%rbp
movslq %ebp,%r15
mov    0x28(%rsp),%r12
mov    %rax,(%r12,%r15,8)
mov    %rax,%rdi
mov    %r14,%rsi
mov    0x34(%rsp),%r14d
mov    %r14d,%edx
call   1040 <memcpy@plt>
mov    (%r12,%r15,8),%rax
movslq %r14d,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x1,%ebp
mov    %rbp,0x18(%rsp)
lea    0xc88(%rip),%rbp
jmp    1253 <split_string_c+0x113>
test   %al,%al
mov    0x8(%rsp),%rax
cmove  %rbx,%rax
mov    %rax,0x8(%rsp)
xor    %r15d,%r15d
mov    $0x1,%al
jmp    125b <split_string_c+0x11b>
test   %al,%al
je     13e0 <split_string_c+0x2a0>
mov    0x20(%rsp),%rbx
mov    0x8(%rsp),%rdi
sub    %ebx,%edi
lea    0x1(%rdi),%r14d
add    $0x2,%edi
call   1050 <ne_malloc@plt>
movslq 0x18(%rsp),%rbp
mov    0x28(%rsp),%r15
mov    %rax,(%r15,%rbp,8)
mov    %rax,%rdi
mov    %rbx,%rsi
mov    %r14d,%edx
call   1040 <memcpy@plt>
mov    (%r15,%rbp,8),%rax
movslq %r14d,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    13fd <split_string_c+0x2bd>
xor    %ebx,%ebx
jmp    13ea <split_string_c+0x2aa>
mov    0x28(%rsp),%r15
mov    0x18(%rsp),%rbx
lea    0xc0f(%rip),%rdi
call   1060 <ne_strdup@plt>
movslq %ebx,%rcx
mov    %rax,(%r15,%rcx,8)
mov    %r15,%rax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [1 x i8] zeroinitializer
define i8** @split_string_c(i8* %0, i8 signext %1, i8* %2, i8* %3, i32* %4) {
%6 = alloca i8*
%7 = alloca i8
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i32*
%11 = alloca i8**
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i8*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
store i8* %0, i8** %6
store i8 %1, i8* %7
store i8* %2, i8** %8
store i8* %3, i8** %9
store i32* %4, i32** %10
store i8* null, i8** %13
store i32 1, i32* %16
%22 = load i8*, i8** %6
store i8* %22, i8** %12
br label %23
23: ; preds = %74, %5
%24 = load i8*, i8** %12
%25 = load i8, i8* %24
%26 = sext i8 %25 to i32
%27 = icmp ne i32 %26, 0
br i1 %27, label %28, label %77
28: ; preds = %23
%29 = load i8*, i8** %8
%30 = icmp ne i8* %29, null
br i1 %30, label %31, label %36
31: ; preds = %28
%32 = load i8*, i8** %8
%33 = load i8*, i8** %12
%34 = load i8, i8* %33
%35 = call i8* @strchr(i8* %32, i8 signext %34)
store i8* %35, i8** %13
br label %36
36: ; preds = %31, %28
%37 = load i8*, i8** %13
%38 = icmp ne i8* %37, null
br i1 %38, label %39, label %62
39: ; preds = %36
%40 = load i8*, i8** %12
%41 = getelementptr inbounds i8, i8* %40, i32 1
store i8* %41, i8** %12
br label %42
42: ; preds = %58, %39
%43 = load i8*, i8** %12
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = load i8*, i8** %13
%47 = load i8, i8* %46
%48 = sext i8 %47 to i32
%49 = icmp ne i32 %45, %48
br i1 %49, label %50, label %55
50: ; preds = %42
%51 = load i8*, i8** %12
%52 = load i8, i8* %51
%53 = sext i8 %52 to i32
%54 = icmp ne i32 %53, 0
br label %55
55: ; preds = %50, %42
%56 = phi i1 [ false, %42 ], [ %54, %50 ]
br i1 %56, label %57, label %61
57: ; preds = %55
br label %58
58: ; preds = %57
%59 = load i8*, i8** %12
%60 = getelementptr inbounds i8, i8* %59, i32 1
store i8* %60, i8** %12
br label %42
61: ; preds = %55
br label %73
62: ; preds = %36
%63 = load i8*, i8** %12
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = load i8, i8* %7
%67 = sext i8 %66 to i32
%68 = icmp eq i32 %65, %67
br i1 %68, label %69, label %72
69: ; preds = %62
%70 = load i32, i32* %16
%71 = add nsw i32 %70, 1
store i32 %71, i32* %16
br label %72
72: ; preds = %69, %62
br label %73
73: ; preds = %72, %61
br label %74
74: ; preds = %73
%75 = load i8*, i8** %12
%76 = getelementptr inbounds i8, i8* %75, i32 1
store i8* %76, i8** %12
br label %23
77: ; preds = %23
%78 = load i32*, i32** %10
%79 = icmp ne i32* %78, null
br i1 %79, label %80, label %83
80: ; preds = %77
%81 = load i32, i32* %16
%82 = load i32*, i32** %10
store i32 %81, i32* %82
br label %83
83: ; preds = %80, %77
%84 = load i32, i32* %16
%85 = add nsw i32 %84, 1
%86 = sext i32 %85 to i64
%87 = mul i64 8, %86
%88 = trunc i64 %87 to i32
%89 = call i8* @ne_malloc(i32 %88)
%90 = bitcast i8* %89 to i8**
store i8** %90, i8*** %11
%91 = load i8**, i8*** %11
%92 = load i32, i32* %16
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i8*, i8** %91, i64 %93
store i8* null, i8** %94
store i8* null, i8** %14
store i8* null, i8** %15
store i8* null, i8** %13
store i32 0, i32* %19
store i32 1, i32* %21
%95 = load i8*, i8** %6
store i8* %95, i8** %12
br label %96
96: ; preds = %231, %83
%97 = load i8*, i8** %12
%98 = load i8, i8* %97
%99 = sext i8 %98 to i32
%100 = icmp ne i32 %99, 0
br i1 %100, label %101, label %234
101: ; preds = %96
%102 = load i8*, i8** %8
%103 = icmp ne i8* %102, null
br i1 %103, label %104, label %109
104: ; preds = %101
%105 = load i8*, i8** %8
%106 = load i8*, i8** %12
%107 = load i8, i8* %106
%108 = call i8* @strchr(i8* %105, i8 signext %107)
store i8* %108, i8** %13
br label %109
109: ; preds = %104, %101
%110 = load i8*, i8** %9
%111 = icmp ne i8* %110, null
br i1 %111, label %112, label %118
112: ; preds = %109
%113 = load i8*, i8** %9
%114 = load i8*, i8** %12
%115 = load i8, i8* %114
%116 = call i8* @strchr(i8* %113, i8 signext %115)
%117 = icmp ne i8* %116, null
br label %118
118: ; preds = %112, %109
%119 = phi i1 [ false, %109 ], [ %117, %112 ]
%120 = zext i1 %119 to i32
store i32 %120, i32* %17
%121 = load i8*, i8** %12
%122 = load i8, i8* %121
%123 = sext i8 %122 to i32
%124 = load i8, i8* %7
%125 = sext i8 %124 to i32
%126 = icmp eq i32 %123, %125
%127 = zext i1 %126 to i32
store i32 %127, i32* %18
%128 = load i32, i32* %21
%129 = icmp ne i32 %128, 0
br i1 %129, label %130, label %153
130: ; preds = %118
%131 = load i8*, i8** %13
%132 = icmp ne i8* %131, null
br i1 %132, label %133, label %135
133: ; preds = %130
%134 = load i8*, i8** %12
store i8* %134, i8** %14
store i32 1, i32* %20
store i32 0, i32* %21
br label %152
135: ; preds = %130
%136 = load i32, i32* %18
%137 = icmp ne i32 %136, 0
br i1 %137, label %138, label %145
138: ; preds = %135
%139 = call i8* @ne_strdup(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%140 = load i8**, i8*** %11
%141 = load i32, i32* %19
%142 = add nsw i32 %141, 1
store i32 %142, i32* %19
%143 = sext i32 %141 to i64
%144 = getelementptr inbounds i8*, i8** %140, i64 %143
store i8* %139, i8** %144
br label %151
145: ; preds = %135
%146 = load i32, i32* %17
%147 = icmp ne i32 %146, 0
br i1 %147, label %150, label %148
148: ; preds = %145
%149 = load i8*, i8** %12
store i8* %149, i8** %15
store i8* %149, i8** %14
store i32 1, i32* %20
store i32 0, i32* %21
br label %150
150: ; preds = %148, %145
br label %151
151: ; preds = %150, %138
br label %152
152: ; preds = %151, %133
br label %203
153: ; preds = %118
%154 = load i8*, i8** %13
%155 = icmp ne i8* %154, null
br i1 %155, label %156, label %159
156: ; preds = %153
%157 = load i32, i32* %20
%158 = add nsw i32 %157, 1
store i32 %158, i32* %20
br label %202
159: ; preds = %153
%160 = load i32, i32* %18
%161 = icmp ne i32 %160, 0
br i1 %161, label %162, label %195
162: ; preds = %159
%163 = load i8*, i8** %15
%164 = load i8*, i8** %14
%165 = ptrtoint i8* %163 to i64
%166 = ptrtoint i8* %164 to i64
%167 = sub i64 %165, %166
%168 = add nsw i64 %167, 1
%169 = trunc i64 %168 to i32
store i32 %169, i32* %20
%170 = load i32, i32* %20
%171 = add nsw i32 %170, 1
%172 = call i8* @ne_malloc(i32 %171)
%173 = load i8**, i8*** %11
%174 = load i32, i32* %19
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i8*, i8** %173, i64 %175
store i8* %172, i8** %176
%177 = load i8**, i8*** %11
%178 = load i32, i32* %19
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i8*, i8** %177, i64 %179
%181 = load i8*, i8** %180
%182 = load i8*, i8** %14
%183 = load i32, i32* %20
%184 = call i32 @memcpy(i8* %181, i8* %182, i32 %183)
%185 = load i8**, i8*** %11
%186 = load i32, i32* %19
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i8*, i8** %185, i64 %187
%189 = load i8*, i8** %188
%190 = load i32, i32* %20
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i8, i8* %189, i64 %191
store i8 0, i8* %192
%193 = load i32, i32* %19
%194 = add nsw i32 %193, 1
store i32 %194, i32* %19
store i32 1, i32* %21
br label %201
195: ; preds = %159
%196 = load i32, i32* %17
%197 = icmp ne i32 %196, 0
br i1 %197, label %200, label %198
198: ; preds = %195
%199 = load i8*, i8** %12
store i8* %199, i8** %15
br label %200
200: ; preds = %198, %195
br label %201
201: ; preds = %200, %162
br label %202
202: ; preds = %201, %156
br label %203
203: ; preds = %202, %152
%204 = load i8*, i8** %13
%205 = icmp ne i8* %204, null
br i1 %205, label %206, label %230
206: ; preds = %203
%207 = load i8*, i8** %12
%208 = getelementptr inbounds i8, i8* %207, i32 1
store i8* %208, i8** %12
br label %209
209: ; preds = %225, %206
%210 = load i8*, i8** %12
%211 = load i8, i8* %210
%212 = sext i8 %211 to i32
%213 = load i8*, i8** %13
%214 = load i8, i8* %213
%215 = sext i8 %214 to i32
%216 = icmp ne i32 %212, %215
br i1 %216, label %217, label %222
217: ; preds = %209
%218 = load i8*, i8** %12
%219 = load i8, i8* %218
%220 = sext i8 %219 to i32
%221 = icmp ne i32 %220, 0
br label %222
222: ; preds = %217, %209
%223 = phi i1 [ false, %209 ], [ %221, %217 ]
br i1 %223, label %224, label %228
224: ; preds = %222
br label %225
225: ; preds = %224
%226 = load i8*, i8** %12
%227 = getelementptr inbounds i8, i8* %226, i32 1
store i8* %227, i8** %12
br label %209
228: ; preds = %222
%229 = load i8*, i8** %12
store i8* %229, i8** %15
br label %230
230: ; preds = %228, %203
br label %231
231: ; preds = %230
%232 = load i8*, i8** %12
%233 = getelementptr inbounds i8, i8* %232, i32 1
store i8* %233, i8** %12
br label %96
234: ; preds = %96
%235 = load i32, i32* %21
%236 = icmp ne i32 %235, 0
br i1 %236, label %237, label %243
237: ; preds = %234
%238 = call i8* @ne_strdup(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%239 = load i8**, i8*** %11
%240 = load i32, i32* %19
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i8*, i8** %239, i64 %241
store i8* %238, i8** %242
br label %274
243: ; preds = %234
%244 = load i8*, i8** %15
%245 = load i8*, i8** %14
%246 = ptrtoint i8* %244 to i64
%247 = ptrtoint i8* %245 to i64
%248 = sub i64 %246, %247
%249 = add nsw i64 %248, 1
%250 = trunc i64 %249 to i32
store i32 %250, i32* %20
%251 = load i32, i32* %20
%252 = add nsw i32 %251, 1
%253 = call i8* @ne_malloc(i32 %252)
%254 = load i8**, i8*** %11
%255 = load i32, i32* %19
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds i8*, i8** %254, i64 %256
store i8* %253, i8** %257
%258 = load i8**, i8*** %11
%259 = load i32, i32* %19
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds i8*, i8** %258, i64 %260
%262 = load i8*, i8** %261
%263 = load i8*, i8** %14
%264 = load i32, i32* %20
%265 = call i32 @memcpy(i8* %262, i8* %263, i32 %264)
%266 = load i8**, i8*** %11
%267 = load i32, i32* %19
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds i8*, i8** %266, i64 %268
%270 = load i8*, i8** %269
%271 = load i32, i32* %20
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds i8, i8* %270, i64 %272
store i8 0, i8* %273
br label %274
274: ; preds = %243, %237
%275 = load i8**, i8*** %11
ret i8** %275
}

LLVM IR (-O2):
@.str = [1 x i8] zeroinitializer
define i8** @split_string_c(i8* %0, i8 signext %1, i8* %2, i8* %3, i32* writeonly %4) {
%6 = load i8, i8* %0
%7 = icmp eq i8 %6, 0
br i1 %7, label %39, label %8
8: ; preds = %5
%9 = icmp eq i8* %2, null
br label %10
10: ; preds = %8, %33
%11 = phi i8 [ %6, %8 ], [ %37, %33 ]
%12 = phi i8* [ %0, %8 ], [ %36, %33 ]
%13 = phi i8* [ null, %8 ], [ %18, %33 ]
%14 = phi i32 [ 1, %8 ], [ %34, %33 ]
br i1 %9, label %17, label %15
15: ; preds = %10
%16 = tail call i8* @strchr(i8* %2, i8 signext %11)
br label %17
17: ; preds = %15, %10
%18 = phi i8* [ %16, %15 ], [ %13, %10 ]
%19 = icmp eq i8* %18, null
br i1 %19, label %29, label %20
20: ; preds = %17
%21 = load i8, i8* %18
br label %22
22: ; preds = %20, %22
%23 = phi i8* [ %24, %22 ], [ %12, %20 ]
%24 = getelementptr inbounds i8, i8* %23, i64 1
%25 = load i8, i8* %24
%26 = icmp eq i8 %25, %21
%27 = icmp eq i8 %25, 0
%28 = or i1 %27, %26
br i1 %28, label %33, label %22
29: ; preds = %17
%30 = icmp eq i8 %11, %1
%31 = zext i1 %30 to i32
%32 = add nsw i32 %14, %31
br label %33
33: ; preds = %22, %29
%34 = phi i32 [ %32, %29 ], [ %14, %22 ]
%35 = phi i8* [ %12, %29 ], [ %24, %22 ]
%36 = getelementptr inbounds i8, i8* %35, i64 1
%37 = load i8, i8* %36
%38 = icmp eq i8 %37, 0
br i1 %38, label %39, label %10
39: ; preds = %33, %5
%40 = phi i32 [ 1, %5 ], [ %34, %33 ]
%41 = icmp eq i32* %4, null
br i1 %41, label %43, label %42
42: ; preds = %39
store i32 %40, i32* %4
br label %43
43: ; preds = %42, %39
%44 = shl i32 %40, 3
%45 = add i32 %44, 8
%46 = tail call i8* @ne_malloc(i32 %45)
%47 = bitcast i8* %46 to i8**
%48 = sext i32 %40 to i64
%49 = getelementptr inbounds i8*, i8** %47, i64 %48
store i8* null, i8** %49
%50 = load i8, i8* %0
%51 = icmp eq i8 %50, 0
br i1 %51, label %124, label %52
52: ; preds = %43
%53 = icmp eq i8* %2, null
%54 = icmp eq i8* %3, null
br label %55
55: ; preds = %52, %113
%56 = phi i8 [ %50, %52 ], [ %121, %113 ]
%57 = phi i32 [ 1, %52 ], [ %115, %113 ]
%58 = phi i32 [ 0, %52 ], [ %116, %113 ]
%59 = phi i8* [ %0, %52 ], [ %120, %113 ]
%60 = phi i8* [ null, %52 ], [ %66, %113 ]
%61 = phi i8* [ null, %52 ], [ %118, %113 ]
%62 = phi i8* [ null, %52 ], [ %117, %113 ]
br i1 %53, label %65, label %63
63: ; preds = %55
%64 = tail call i8* @strchr(i8* %2, i8 signext %56)
br label %65
65: ; preds = %63, %55
%66 = phi i8* [ %64, %63 ], [ %60, %55 ]
br i1 %54, label %70, label %67
67: ; preds = %65
%68 = tail call i8* @strchr(i8* %3, i8 signext %56)
%69 = icmp ne i8* %68, null
br label %70
70: ; preds = %67, %65
%71 = phi i1 [ false, %65 ], [ %69, %67 ]
%72 = icmp eq i8 %56, %1
%73 = icmp eq i32 %57, 0
%74 = icmp eq i8* %66, null
br i1 %73, label %84, label %75
75: ; preds = %70
br i1 %74, label %76, label %103
76: ; preds = %75
br i1 %72, label %77, label %82
77: ; preds = %76
%78 = tail call i8* @ne_strdup(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%79 = add nsw i32 %58, 1
%80 = sext i32 %58 to i64
%81 = getelementptr inbounds i8*, i8** %47, i64 %80
store i8* %78, i8** %81
br label %113
82: ; preds = %76
br i1 %71, label %113, label %83
83: ; preds = %82
br label %113
84: ; preds = %70
br i1 %74, label %85, label %103
85: ; preds = %84
br i1 %72, label %86, label %101
86: ; preds = %85
%87 = ptrtoint i8* %61 to i64
%88 = ptrtoint i8* %62 to i64
%89 = sub i64 %87, %88
%90 = trunc i64 %89 to i32
%91 = add i32 %90, 1
%92 = add i32 %90, 2
%93 = tail call i8* @ne_malloc(i32 %92)
%94 = sext i32 %58 to i64
%95 = getelementptr inbounds i8*, i8** %47, i64 %94
store i8* %93, i8** %95
%96 = tail call i32 @memcpy(i8* %93, i8* %62, i32 %91)
%97 = load i8*, i8** %95
%98 = sext i32 %91 to i64
%99 = getelementptr inbounds i8, i8* %97, i64 %98
store i8 0, i8* %99
%100 = add nsw i32 %58, 1
br label %113
101: ; preds = %85
%102 = select i1 %71, i8* %61, i8* %59
br label %113
103: ; preds = %84, %75
%104 = phi i8* [ %59, %75 ], [ %62, %84 ]
%105 = load i8, i8* %66
br label %106
106: ; preds = %103, %106
%107 = phi i8* [ %59, %103 ], [ %108, %106 ]
%108 = getelementptr inbounds i8, i8* %107, i64 1
%109 = load i8, i8* %108
%110 = icmp eq i8 %109, %105
%111 = icmp eq i8 %109, 0
%112 = or i1 %111, %110
br i1 %112, label %113, label %106
113: ; preds = %106, %77, %83, %82, %86, %101
%114 = phi i1 [ false, %77 ], [ true, %83 ], [ false, %82 ], [ false, %86 ], [ true, %101 ], [ true, %106 ]
%115 = phi i32 [ 1, %77 ], [ 0, %83 ], [ 1, %82 ], [ 1, %86 ], [ 0, %101 ], [ 0, %106 ]
%116 = phi i32 [ %79, %77 ], [ %58, %83 ], [ %58, %82 ], [ %100, %86 ], [ %58, %101 ], [ %58, %106 ]
%117 = phi i8* [ %62, %77 ], [ %59, %83 ], [ %62, %82 ], [ %62, %86 ], [ %62, %101 ], [ %104, %106 ]
%118 = phi i8* [ %61, %77 ], [ %59, %83 ], [ %61, %82 ], [ %61, %86 ], [ %102, %101 ], [ %108, %106 ]
%119 = phi i8* [ %59, %77 ], [ %59, %83 ], [ %59, %82 ], [ %59, %86 ], [ %59, %101 ], [ %108, %106 ]
%120 = getelementptr inbounds i8, i8* %119, i64 1
%121 = load i8, i8* %120
%122 = icmp eq i8 %121, 0
br i1 %122, label %123, label %55
123: ; preds = %113
br i1 %114, label %129, label %124
124: ; preds = %43, %123
%125 = phi i32 [ %116, %123 ], [ 0, %43 ]
%126 = tail call i8* @ne_strdup(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%127 = sext i32 %125 to i64
%128 = getelementptr inbounds i8*, i8** %47, i64 %127
store i8* %126, i8** %128
br label %143
129: ; preds = %123
%130 = ptrtoint i8* %118 to i64
%131 = ptrtoint i8* %117 to i64
%132 = sub i64 %130, %131
%133 = trunc i64 %132 to i32
%134 = add i32 %133, 1
%135 = add i32 %133, 2
%136 = tail call i8* @ne_malloc(i32 %135)
%137 = sext i32 %116 to i64
%138 = getelementptr inbounds i8*, i8** %47, i64 %137
store i8* %136, i8** %138
%139 = tail call i32 @memcpy(i8* %136, i8* %117, i32 %134)
%140 = load i8*, i8** %138
%141 = sext i32 %134 to i64
%142 = getelementptr inbounds i8, i8* %140, i64 %141
store i8 0, i8* %142
br label %143
143: ; preds = %129, %124
ret i8** %47
}