int tokenizeURLString(char *string, int size, char ***output) {
  char *start, *end;
  char *p, *q;
  int i;
  end = string + size;
  for (p = string; p < end && *p != '\0'; p++)
    ;
  for (p--; isspace(*p); p--)
    ;
  end = p + 1;
  for (p = string; p < end && isspace(*p); p++)
    ;
  start = p;
  if (start == end) {
    *output = ((char **)xmalloc((1) * sizeof(char *)));
    (*output)[0] = '\0';
    return 0;
  }
  for (p = end - 1, i = 0; p > start; p--) {
    if (*p == '&')
      i++;
  }
  i++;
  *output = ((char **)xmalloc((i + 1) * sizeof(char *)));
  (*output)[i] = '\0';
  for (i = 0, p = q = start; p < end && q < end; p = q, i++) {
    for (q = p; *q != '&' && q < end; q++)
      ;
    (*output)[i] = ((char *)xmalloc(((q - p + 1)) * sizeof(char)));
    strncpy((*output)[i], p, q - p);
    (*output)[i][q - p] = '\0';
    if (q < end)
      q++;
  }
  return 0;
}


x86 assembly (clang, -O0):
<tokenizeURLString>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rcx
xor    %eax,%eax
cmp    -0x30(%rbp),%rcx
mov    %al,-0x45(%rbp)
jae    117d <tokenizeURLString+0x4d>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x45(%rbp)
mov    -0x45(%rbp),%al
test   $0x1,%al
jne    118d <tokenizeURLString+0x5d>
jmp    11a3 <tokenizeURLString+0x73>
jmp    1192 <tokenizeURLString+0x62>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    115a <tokenizeURLString+0x2a>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%eax
je     11da <tokenizeURLString+0xaa>
jmp    11c9 <tokenizeURLString+0x99>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
jmp    11af <tokenizeURLString+0x7f>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rcx
xor    %eax,%eax
cmp    -0x30(%rbp),%rcx
mov    %al,-0x46(%rbp)
jae    1216 <tokenizeURLString+0xe6>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x46(%rbp)
mov    -0x46(%rbp),%al
test   $0x1,%al
jne    1226 <tokenizeURLString+0xf6>
jmp    123c <tokenizeURLString+0x10c>
jmp    122b <tokenizeURLString+0xfb>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    11ee <tokenizeURLString+0xbe>
mov    -0x38(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    1282 <tokenizeURLString+0x152>
mov    $0x8,%edi
mov    $0x0,%al
call   1040 <xmalloc@plt>
movslq %eax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movq   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    144a <tokenizeURLString+0x31a>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jbe    12d2 <tokenizeURLString+0x1a2>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x26,%eax
jne    12bc <tokenizeURLString+0x18c>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12c1 <tokenizeURLString+0x191>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
jmp    1295 <tokenizeURLString+0x165>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <xmalloc@plt>
movslq %eax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x44(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
movl   $0x0,-0x44(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rcx
xor    %eax,%eax
cmp    -0x30(%rbp),%rcx
mov    %al,-0x47(%rbp)
jae    1340 <tokenizeURLString+0x210>
mov    -0x40(%rbp),%rax
cmp    -0x30(%rbp),%rax
setb   %al
mov    %al,-0x47(%rbp)
mov    -0x47(%rbp),%al
test   $0x1,%al
jne    1350 <tokenizeURLString+0x220>
jmp    1443 <tokenizeURLString+0x313>
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x26,%ecx
mov    %al,-0x48(%rbp)
je     137b <tokenizeURLString+0x24b>
mov    -0x40(%rbp),%rax
cmp    -0x30(%rbp),%rax
setb   %al
mov    %al,-0x48(%rbp)
mov    -0x48(%rbp),%al
test   $0x1,%al
jne    138b <tokenizeURLString+0x25b>
jmp    13a1 <tokenizeURLString+0x271>
jmp    1390 <tokenizeURLString+0x260>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1358 <tokenizeURLString+0x228>
mov    -0x40(%rbp),%rdi
mov    -0x38(%rbp),%rax
sub    %rax,%rdi
add    $0x1,%rdi
shl    $0x0,%rdi
mov    $0x0,%al
call   1040 <xmalloc@plt>
movslq %eax,%rdx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x38(%rbp),%rax
sub    %rax,%rdx
call   1030 <strncpy@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    -0x38(%rbp),%rdx
sub    %rdx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    1428 <tokenizeURLString+0x2f8>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    142d <tokenizeURLString+0x2fd>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    131f <tokenizeURLString+0x1ef>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tokenizeURLString>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,0x10(%rsp)
mov    %rdi,%r15
mov    %rdi,%r12
test   %esi,%esi
jle    1170 <tokenizeURLString+0x40>
movslq %esi,%rax
add    %r15,%rax
mov    %r15,%r12
cs nopw 0x0(%rax,%rax,1)
cmpb   $0x0,(%r12)
je     1170 <tokenizeURLString+0x40>
add    $0x1,%r12
cmp    %rax,%r12
jb     1160 <tokenizeURLString+0x30>
lea    -0x1(%r12),%rbp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movzbl -0x1(%r12,%rbx,1),%r14d
movsbl %r14b,%edi
call   1050 <isspace@plt>
add    $0xffffffffffffffff,%rbx
add    $0xffffffffffffffff,%rbp
test   %eax,%eax
jne    1180 <tokenizeURLString+0x50>
lea    (%r12,%rbx,1),%r13
add    $0x1,%r13
cmp    %r15,%r13
jbe    11df <tokenizeURLString+0xaf>
mov    %r12,0x8(%rsp)
mov    %r12,%rax
sub    %r15,%rax
lea    (%rax,%rbx,1),%r12
add    $0x1,%r12
nopl   0x0(%rax,%rax,1)
movsbl (%r15),%edi
call   1050 <isspace@plt>
test   %eax,%eax
je     11da <tokenizeURLString+0xaa>
add    $0x1,%r15
add    $0xffffffffffffffff,%r12
jne    11c0 <tokenizeURLString+0x90>
mov    %r13,%r15
mov    0x8(%rsp),%r12
cmp    %r15,%r13
je     13c6 <tokenizeURLString+0x296>
lea    (%r12,%rbx,1),%rax
xor    %esi,%esi
cmp    %r15,%rax
jbe    1313 <tokenizeURLString+0x1e3>
xor    %esi,%esi
cmp    $0x26,%r14b
sete   %sil
lea    (%r12,%rbx,1),%rax
add    $0xffffffffffffffff,%rax
cmp    %r15,%rax
jbe    1313 <tokenizeURLString+0x1e3>
mov    %r15,%rdi
not    %rdi
lea    (%rdi,%r12,1),%rcx
add    %rbx,%rcx
cmp    $0x8,%rcx
jb     1300 <tokenizeURLString+0x1d0>
mov    %rcx,%rdx
and    $0xfffffffffffffff8,%rdx
lea    (%rdi,%rbp,1),%rax
add    $0x1,%rax
and    $0xfffffffffffffff8,%rax
mov    %r12,%rbp
sub    %rax,%rbp
lea    (%rbx,%rbp,1),%rax
add    $0xffffffffffffffff,%rax
movd   %esi,%xmm0
lea    (%r12,%rdi,1),%rsi
add    $0x1,%rsi
add    %rbx,%rsi
add    $0xffffffffffffffff,%rsi
and    $0xfffffffffffffff8,%rsi
neg    %rsi
pxor   %xmm1,%xmm1
xor    %edi,%edi
movdqa 0xd8e(%rip),%xmm2
movdqa 0xd96(%rip),%xmm3
nopw   0x0(%rax,%rax,1)
lea    (%r12,%rdi,1),%rbp
movd   -0x4(%rbx,%rbp,1),%xmm4
punpcklbw %xmm4,%xmm4
movd   -0x8(%rbx,%rbp,1),%xmm5
punpcklbw %xmm5,%xmm5
pshufd $0xc4,%xmm4,%xmm4
pshuflw $0xe7,%xmm4,%xmm4
pshufhw $0xc5,%xmm4,%xmm4
pcmpeqb %xmm2,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm4,%xmm0
pshufd $0xc4,%xmm5,%xmm4
pshuflw $0xe7,%xmm4,%xmm4
pshufhw $0xc5,%xmm4,%xmm4
pcmpeqb %xmm2,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm4,%xmm1
add    $0xfffffffffffffff8,%rdi
cmp    %rdi,%rsi
jne    1280 <tokenizeURLString+0x150>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%esi
cmp    %rdx,%rcx
je     1313 <tokenizeURLString+0x1e3>
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ecx
cmpb   $0x26,(%rax)
sete   %cl
add    %ecx,%esi
add    $0xffffffffffffffff,%rax
cmp    %r15,%rax
ja     1300 <tokenizeURLString+0x1d0>
mov    %esi,%ebx
lea    0x10(,%rbx,8),%rdi
xor    %eax,%eax
call   1040 <xmalloc@plt>
cltq
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx)
movq   $0x0,0x8(%rax,%rbx,8)
cmp    %r13,%r15
jae    13e3 <tokenizeURLString+0x2b3>
xor    %r14d,%r14d
mov    0x10(%rsp),%r12
jmp    13a6 <tokenizeURLString+0x276>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rbx),%rax
mov    %rax,0x8(%rsp)
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <xmalloc@plt>
cltq
mov    (%r12),%rcx
mov    %rax,(%rcx,%r14,8)
mov    (%r12),%rax
mov    (%rax,%r14,8),%rdi
mov    %r15,%rsi
mov    0x8(%rsp),%rdx
call   1030 <strncpy@plt>
cmp    %r13,%rbp
mov    (%r12),%rax
mov    (%rax,%r14,8),%rax
adc    $0x0,%r15
movb   $0x0,-0x1(%rax,%rbx,1)
add    %rbx,%r15
add    $0xffffffffffffffff,%r15
add    $0x1,%r14
cmp    %r13,%r15
jae    13e3 <tokenizeURLString+0x2b3>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    (%r15,%rbx,1),%rbp
cmpb   $0x26,(%r15,%rbx,1)
lea    0x1(%rbx),%rbx
je     1350 <tokenizeURLString+0x220>
cmp    %r13,%rbp
jb     13b0 <tokenizeURLString+0x280>
jmp    1350 <tokenizeURLString+0x220>
mov    $0x8,%edi
xor    %eax,%eax
call   1040 <xmalloc@plt>
cltq
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx)
movq   $0x0,(%rax)
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @tokenizeURLString(i8* %0, i32 %1, i8*** %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8***
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i32
store i8* %0, i8** %5
store i32 %1, i32* %6
store i8*** %2, i8**** %7
%13 = load i8*, i8** %5
%14 = load i32, i32* %6
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i8, i8* %13, i64 %15
store i8* %16, i8** %9
%17 = load i8*, i8** %5
store i8* %17, i8** %10
br label %18
18: ; preds = %30, %3
%19 = load i8*, i8** %10
%20 = load i8*, i8** %9
%21 = icmp ult i8* %19, %20
br i1 %21, label %22, label %27
22: ; preds = %18
%23 = load i8*, i8** %10
%24 = load i8, i8* %23
%25 = sext i8 %24 to i32
%26 = icmp ne i32 %25, 0
br label %27
27: ; preds = %22, %18
%28 = phi i1 [ false, %18 ], [ %26, %22 ]
br i1 %28, label %29, label %33
29: ; preds = %27
br label %30
30: ; preds = %29
%31 = load i8*, i8** %10
%32 = getelementptr inbounds i8, i8* %31, i32 1
store i8* %32, i8** %10
br label %18
33: ; preds = %27
%34 = load i8*, i8** %10
%35 = getelementptr inbounds i8, i8* %34, i32 -1
store i8* %35, i8** %10
br label %36
36: ; preds = %43, %33
%37 = load i8*, i8** %10
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = call i32 @isspace(i32 %39)
%41 = icmp ne i32 %40, 0
br i1 %41, label %42, label %46
42: ; preds = %36
br label %43
43: ; preds = %42
%44 = load i8*, i8** %10
%45 = getelementptr inbounds i8, i8* %44, i32 -1
store i8* %45, i8** %10
br label %36
46: ; preds = %36
%47 = load i8*, i8** %10
%48 = getelementptr inbounds i8, i8* %47, i64 1
store i8* %48, i8** %9
%49 = load i8*, i8** %5
store i8* %49, i8** %10
br label %50
50: ; preds = %63, %46
%51 = load i8*, i8** %10
%52 = load i8*, i8** %9
%53 = icmp ult i8* %51, %52
br i1 %53, label %54, label %60
54: ; preds = %50
%55 = load i8*, i8** %10
%56 = load i8, i8* %55
%57 = sext i8 %56 to i32
%58 = call i32 @isspace(i32 %57)
%59 = icmp ne i32 %58, 0
br label %60
60: ; preds = %54, %50
%61 = phi i1 [ false, %50 ], [ %59, %54 ]
br i1 %61, label %62, label %66
62: ; preds = %60
br label %63
63: ; preds = %62
%64 = load i8*, i8** %10
%65 = getelementptr inbounds i8, i8* %64, i32 1
store i8* %65, i8** %10
br label %50
66: ; preds = %60
%67 = load i8*, i8** %10
store i8* %67, i8** %8
%68 = load i8*, i8** %8
%69 = load i8*, i8** %9
%70 = icmp eq i8* %68, %69
br i1 %70, label %71, label %79
71: ; preds = %66
%72 = call i32 (i64, ...) bitcast (i32 (...)* @xmalloc to i32 (i64, ...)*)(i64 8)
%73 = sext i32 %72 to i64
%74 = inttoptr i64 %73 to i8**
%75 = load i8***, i8**** %7
store i8** %74, i8*** %75
%76 = load i8***, i8**** %7
%77 = load i8**, i8*** %76
%78 = getelementptr inbounds i8*, i8** %77, i64 0
store i8* null, i8** %78
store i32 0, i32* %4
br label %195
79: ; preds = %66
%80 = load i8*, i8** %9
%81 = getelementptr inbounds i8, i8* %80, i64 -1
store i8* %81, i8** %10
store i32 0, i32* %12
br label %82
82: ; preds = %95, %79
%83 = load i8*, i8** %10
%84 = load i8*, i8** %8
%85 = icmp ugt i8* %83, %84
br i1 %85, label %86, label %98
86: ; preds = %82
%87 = load i8*, i8** %10
%88 = load i8, i8* %87
%89 = sext i8 %88 to i32
%90 = icmp eq i32 %89, 38
br i1 %90, label %91, label %94
91: ; preds = %86
%92 = load i32, i32* %12
%93 = add nsw i32 %92, 1
store i32 %93, i32* %12
br label %94
94: ; preds = %91, %86
br label %95
95: ; preds = %94
%96 = load i8*, i8** %10
%97 = getelementptr inbounds i8, i8* %96, i32 -1
store i8* %97, i8** %10
br label %82
98: ; preds = %82
%99 = load i32, i32* %12
%100 = add nsw i32 %99, 1
store i32 %100, i32* %12
%101 = load i32, i32* %12
%102 = add nsw i32 %101, 1
%103 = sext i32 %102 to i64
%104 = mul i64 %103, 8
%105 = call i32 (i64, ...) bitcast (i32 (...)* @xmalloc to i32 (i64, ...)*)(i64 %104)
%106 = sext i32 %105 to i64
%107 = inttoptr i64 %106 to i8**
%108 = load i8***, i8**** %7
store i8** %107, i8*** %108
%109 = load i8***, i8**** %7
%110 = load i8**, i8*** %109
%111 = load i32, i32* %12
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i8*, i8** %110, i64 %112
store i8* null, i8** %113
store i32 0, i32* %12
%114 = load i8*, i8** %8
store i8* %114, i8** %11
store i8* %114, i8** %10
br label %115
115: ; preds = %190, %98
%116 = load i8*, i8** %10
%117 = load i8*, i8** %9
%118 = icmp ult i8* %116, %117
br i1 %118, label %119, label %123
119: ; preds = %115
%120 = load i8*, i8** %11
%121 = load i8*, i8** %9
%122 = icmp ult i8* %120, %121
br label %123
123: ; preds = %119, %115
%124 = phi i1 [ false, %115 ], [ %122, %119 ]
br i1 %124, label %125, label %194
125: ; preds = %123
%126 = load i8*, i8** %10
store i8* %126, i8** %11
br label %127
127: ; preds = %139, %125
%128 = load i8*, i8** %11
%129 = load i8, i8* %128
%130 = sext i8 %129 to i32
%131 = icmp ne i32 %130, 38
br i1 %131, label %132, label %136
132: ; preds = %127
%133 = load i8*, i8** %11
%134 = load i8*, i8** %9
%135 = icmp ult i8* %133, %134
br label %136
136: ; preds = %132, %127
%137 = phi i1 [ false, %127 ], [ %135, %132 ]
br i1 %137, label %138, label %142
138: ; preds = %136
br label %139
139: ; preds = %138
%140 = load i8*, i8** %11
%141 = getelementptr inbounds i8, i8* %140, i32 1
store i8* %141, i8** %11
br label %127
142: ; preds = %136
%143 = load i8*, i8** %11
%144 = load i8*, i8** %10
%145 = ptrtoint i8* %143 to i64
%146 = ptrtoint i8* %144 to i64
%147 = sub i64 %145, %146
%148 = add nsw i64 %147, 1
%149 = mul i64 %148, 1
%150 = call i32 (i64, ...) bitcast (i32 (...)* @xmalloc to i32 (i64, ...)*)(i64 %149)
%151 = sext i32 %150 to i64
%152 = inttoptr i64 %151 to i8*
%153 = load i8***, i8**** %7
%154 = load i8**, i8*** %153
%155 = load i32, i32* %12
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i8*, i8** %154, i64 %156
store i8* %152, i8** %157
%158 = load i8***, i8**** %7
%159 = load i8**, i8*** %158
%160 = load i32, i32* %12
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i8*, i8** %159, i64 %161
%163 = load i8*, i8** %162
%164 = load i8*, i8** %10
%165 = load i8*, i8** %11
%166 = load i8*, i8** %10
%167 = ptrtoint i8* %165 to i64
%168 = ptrtoint i8* %166 to i64
%169 = sub i64 %167, %168
%170 = call i8* @strncpy(i8* %163, i8* %164, i64 %169)
%171 = load i8***, i8**** %7
%172 = load i8**, i8*** %171
%173 = load i32, i32* %12
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i8*, i8** %172, i64 %174
%176 = load i8*, i8** %175
%177 = load i8*, i8** %11
%178 = load i8*, i8** %10
%179 = ptrtoint i8* %177 to i64
%180 = ptrtoint i8* %178 to i64
%181 = sub i64 %179, %180
%182 = getelementptr inbounds i8, i8* %176, i64 %181
store i8 0, i8* %182
%183 = load i8*, i8** %11
%184 = load i8*, i8** %9
%185 = icmp ult i8* %183, %184
br i1 %185, label %186, label %189
186: ; preds = %142
%187 = load i8*, i8** %11
%188 = getelementptr inbounds i8, i8* %187, i32 1
store i8* %188, i8** %11
br label %189
189: ; preds = %186, %142
br label %190
190: ; preds = %189
%191 = load i8*, i8** %11
store i8* %191, i8** %10
%192 = load i32, i32* %12
%193 = add nsw i32 %192, 1
store i32 %193, i32* %12
br label %115
194: ; preds = %123
store i32 0, i32* %4
br label %195
195: ; preds = %194, %71
%196 = load i32, i32* %4
ret i32 %196
}

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