char *nextword(string, word)
char *string;
char **word;
{
  char *word_start;
  int idx;
  char *dst;
  char *src;
  int length = 0;
  while (isspace((unsigned char)*string) || *string == '-') {
    if (*string == '-') {
      while (*string && *string != '\n')
        string++;
    } else {
      string++;
    }
  }
  if (!*string)
    return 0;
  word_start = string;
  if (*string == '"') {
    do {
      string++;
      length++;
      if (*string == '\\') {
        string += 2;
        length += 2;
      }
    } while (*string != '"');
  } else {
    while (!isspace((unsigned char)*string)) {
      string++;
      length++;
    }
  }
  *word = malloc(length + 1);
  dst = *word;
  src = word_start;
  for (idx = 0; idx < length; idx++) {
    if (src[idx] == '\\')
      switch (src[idx + 1]) {
      case 'n':
        *dst++ = '\n';
        idx++;
        break;
      case '"':
      case '\\':
        *dst++ = src[idx + 1];
        idx++;
        break;
      default:
        *dst++ = '\\';
        break;
      }
    else
      *dst++ = src[idx];
  }
  *dst++ = 0;
  if (*string)
    return string + 1;
  else
    return 0;
}


x86 assembly (clang, -O0):
<nextword>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isspace@plt>
mov    %eax,%ecx
mov    $0x1,%al
cmp    $0x0,%ecx
mov    %al,-0x3d(%rbp)
jne    1163 <nextword+0x43>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
sete   %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
test   $0x1,%al
jne    1173 <nextword+0x53>
jmp    11e4 <nextword+0xc4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    11d3 <nextword+0xb3>
jmp    1188 <nextword+0x68>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x3e(%rbp)
je     11ad <nextword+0x8d>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
setne  %al
mov    %al,-0x3e(%rbp)
mov    -0x3e(%rbp),%al
test   $0x1,%al
jne    11bd <nextword+0x9d>
jmp    11ce <nextword+0xae>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1188 <nextword+0x68>
jmp    11df <nextword+0xbf>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1137 <nextword+0x17>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
jne    11fe <nextword+0xde>
movq   $0x0,-0x8(%rbp)
jmp    1414 <nextword+0x2f4>
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x22,%eax
jne    126f <nextword+0x14f>
jmp    121b <nextword+0xfb>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
jne    1255 <nextword+0x135>
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x3c(%rbp)
jmp    125a <nextword+0x13a>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x22,%eax
jne    121b <nextword+0xfb>
jmp    12b4 <nextword+0x194>
jmp    1274 <nextword+0x154>
mov    -0x10(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1295 <nextword+0x175>
jmp    12af <nextword+0x18f>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1274 <nextword+0x154>
jmp    12b4 <nextword+0x194>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
call   1040 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    13dc <nextword+0x2bc>
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5c,%eax
jne    13ad <nextword+0x28d>
mov    -0x38(%rbp),%rcx
movslq -0x24(%rbp),%rax
movsbl 0x1(%rax,%rcx,1),%eax
mov    %eax,-0x44(%rbp)
sub    $0x22,%eax
je     1367 <nextword+0x247>
jmp    1325 <nextword+0x205>
mov    -0x44(%rbp),%eax
sub    $0x5c,%eax
je     1367 <nextword+0x247>
jmp    1336 <nextword+0x216>
mov    -0x44(%rbp),%eax
sub    $0x6e,%eax
jne    1396 <nextword+0x276>
jmp    1347 <nextword+0x227>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movb   $0xa,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13a8 <nextword+0x288>
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13a8 <nextword+0x288>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movb   $0x5c,(%rax)
jmp    13c9 <nextword+0x2a9>
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
jmp    13ce <nextword+0x2ae>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12e6 <nextword+0x1c6>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
je     140c <nextword+0x2ec>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1414 <nextword+0x2f4>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nextword>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
movzbl (%rdi),%ebp
cmp    $0x2d,%ebp
sete   %r15b
mov    %ebp,%edi
call   1030 <isspace@plt>
jmp    115c <nextword+0x3c>
mov    0x1(%rbx),%bpl
add    $0x1,%rbx
movzbl %bpl,%r15d
mov    %r15d,%edi
call   1030 <isspace@plt>
cmp    $0x2d,%r15b
sete   %r15b
test   %eax,%eax
jne    1166 <nextword+0x46>
cmp    $0x2d,%bpl
jne    118a <nextword+0x6a>
test   $0x1,%r15b
je     1140 <nextword+0x20>
nopl   0x0(%rax)
test   %bpl,%bpl
je     1148 <nextword+0x28>
cmp    $0xa,%bpl
je     1148 <nextword+0x28>
movzbl 0x1(%rbx),%ebp
add    $0x1,%rbx
test   %bpl,%bpl
jne    1175 <nextword+0x55>
jmp    1148 <nextword+0x28>
test   %bpl,%bpl
je     11c5 <nextword+0xa5>
cmp    $0x22,%bpl
jne    11cc <nextword+0xac>
xor    %ebp,%ebp
mov    %rbx,%rax
jmp    11b4 <nextword+0x94>
nopl   0x0(%rax)
lea    0x1(%rax),%r15
mov    %dl,%cl
lea    0x1(%rbp,%rcx,2),%ebp
cmpb   $0x22,0x1(%rax,%rcx,2)
mov    %r15,%rax
je     11f8 <nextword+0xd8>
xor    %ecx,%ecx
cmpb   $0x5c,0x1(%rax)
sete   %dl
jne    11a0 <nextword+0x80>
lea    0x3(%rax),%r15
jmp    11a4 <nextword+0x84>
xor    %eax,%eax
jmp    1261 <nextword+0x141>
movzbl %bpl,%edi
call   1030 <isspace@plt>
xor    %ebp,%ebp
mov    %rbx,%r15
test   %eax,%eax
jne    11f8 <nextword+0xd8>
xor    %ebp,%ebp
movzbl 0x1(%rbx,%rbp,1),%edi
call   1030 <isspace@plt>
add    $0x1,%rbp
test   %eax,%eax
je     11e0 <nextword+0xc0>
mov    %rbp,%r15
add    %rbx,%r15
lea    0x1(%rbp),%eax
movslq %eax,%rdi
call   1040 <malloc@plt>
mov    %rax,(%r14)
test   %ebp,%ebp
jle    1250 <nextword+0x130>
xor    %esi,%esi
jmp    1221 <nextword+0x101>
xchg   %ax,%ax
mov    %esi,%ecx
mov    %dl,(%rax)
add    $0x1,%rax
add    $0x1,%ecx
mov    %ecx,%esi
cmp    %ebp,%ecx
jge    1250 <nextword+0x130>
movslq %esi,%rcx
movzbl (%rbx,%rcx,1),%edx
cmp    $0x5c,%dl
jne    1210 <nextword+0xf0>
movzbl 0x1(%rbx,%rcx,1),%edx
add    $0x1,%rcx
movsbl %dl,%edi
cmp    $0x22,%edi
je     1212 <nextword+0xf2>
cmp    $0x6e,%edi
je     124c <nextword+0x12c>
cmp    $0x5c,%edi
je     1212 <nextword+0xf2>
mov    $0x5c,%dl
jmp    1210 <nextword+0xf0>
mov    $0xa,%dl
jmp    1212 <nextword+0xf2>
movb   $0x0,(%rax)
lea    0x1(%r15),%rcx
xor    %eax,%eax
cmpb   $0x0,(%r15)
cmovne %rcx,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i8* @nextword(i8* %0, i8** nocapture writeonly %1) {
%3 = load i8, i8* %0
%4 = zext i8 %3 to i32
%5 = tail call i32 @isspace(i32 %4)
%6 = icmp ne i32 %5, 0
%7 = icmp eq i8 %3, 45
%8 = select i1 %6, i1 true, i1 %7
br i1 %8, label %9, label %30
9: ; preds = %2, %22
%10 = phi i8 [ %23, %22 ], [ %3, %2 ]
%11 = phi i1 [ %28, %22 ], [ %7, %2 ]
%12 = phi i8* [ %24, %22 ], [ %0, %2 ]
br i1 %11, label %13, label %19
13: ; preds = %9, %16
%14 = phi i8 [ %18, %16 ], [ %10, %9 ]
%15 = phi i8* [ %17, %16 ], [ %12, %9 ]
switch i8 %14, label %16 [
i8 0, label %22
i8 10, label %22
]
16: ; preds = %13
%17 = getelementptr inbounds i8, i8* %15, i64 1
%18 = load i8, i8* %17
br label %13
19: ; preds = %9
%20 = getelementptr inbounds i8, i8* %12, i64 1
%21 = load i8, i8* %20
br label %22
22: ; preds = %13, %13, %19
%23 = phi i8 [ %21, %19 ], [ %14, %13 ], [ %14, %13 ]
%24 = phi i8* [ %20, %19 ], [ %15, %13 ], [ %15, %13 ]
%25 = zext i8 %23 to i32
%26 = tail call i32 @isspace(i32 %25)
%27 = icmp ne i32 %26, 0
%28 = icmp eq i8 %23, 45
%29 = select i1 %27, i1 true, i1 %28
br i1 %29, label %9, label %30
30: ; preds = %22, %2
%31 = phi i8* [ %0, %2 ], [ %24, %22 ]
%32 = phi i8 [ %3, %2 ], [ %23, %22 ]
switch i8 %32, label %33 [
i8 0, label %92
i8 34, label %37
]
33: ; preds = %30
%34 = zext i8 %32 to i32
%35 = tail call i32 @isspace(i32 %34)
%36 = icmp eq i32 %35, 0
br i1 %36, label %49, label %58
37: ; preds = %30, %37
%38 = phi i8* [ %44, %37 ], [ %31, %30 ]
%39 = phi i32 [ %46, %37 ], [ 0, %30 ]
%40 = getelementptr inbounds i8, i8* %38, i64 1
%41 = load i8, i8* %40
%42 = icmp eq i8 %41, 92
%43 = getelementptr inbounds i8, i8* %38, i64 3
%44 = select i1 %42, i8* %43, i8* %40
%45 = select i1 %42, i32 3, i32 1
%46 = add nuw nsw i32 %45, %39
%47 = load i8, i8* %44
%48 = icmp eq i8 %47, 34
br i1 %48, label %58, label %37
49: ; preds = %33, %49
%50 = phi i32 [ %53, %49 ], [ 0, %33 ]
%51 = phi i8* [ %52, %49 ], [ %31, %33 ]
%52 = getelementptr inbounds i8, i8* %51, i64 1
%53 = add nuw nsw i32 %50, 1
%54 = load i8, i8* %52
%55 = zext i8 %54 to i32
%56 = tail call i32 @isspace(i32 %55)
%57 = icmp eq i32 %56, 0
br i1 %57, label %49, label %58
58: ; preds = %37, %49, %33
%59 = phi i8* [ %31, %33 ], [ %52, %49 ], [ %44, %37 ]
%60 = phi i32 [ 0, %33 ], [ %53, %49 ], [ %46, %37 ]
%61 = add nsw i32 %60, 1
%62 = sext i32 %61 to i64
%63 = tail call i8* @malloc(i64 %62)
store i8* %63, i8** %1
%64 = icmp sgt i32 %60, 0
br i1 %64, label %65, label %86
65: ; preds = %58, %80
%66 = phi i8* [ %83, %80 ], [ %63, %58 ]
%67 = phi i32 [ %84, %80 ], [ 0, %58 ]
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i8, i8* %31, i64 %68
%70 = load i8, i8* %69
%71 = icmp eq i8 %70, 92
br i1 %71, label %72, label %80
72: ; preds = %65
%73 = add nsw i32 %67, 1
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8, i8* %31, i64 %74
%76 = load i8, i8* %75
%77 = sext i8 %76 to i32
switch i32 %77, label %79 [
i32 110, label %80
i32 34, label %78
i32 92, label %78
]
78: ; preds = %72, %72
br label %80
79: ; preds = %72
br label %80
80: ; preds = %65, %72, %79, %78
%81 = phi i8 [ 92, %79 ], [ %76, %78 ], [ 10, %72 ], [ %70, %65 ]
%82 = phi i32 [ %67, %79 ], [ %73, %78 ], [ %73, %72 ], [ %67, %65 ]
store i8 %81, i8* %66
%83 = getelementptr inbounds i8, i8* %66, i64 1
%84 = add nsw i32 %82, 1
%85 = icmp slt i32 %84, %60
br i1 %85, label %65, label %86
86: ; preds = %80, %58
%87 = phi i8* [ %63, %58 ], [ %83, %80 ]
store i8 0, i8* %87
%88 = load i8, i8* %59
%89 = icmp eq i8 %88, 0
%90 = getelementptr inbounds i8, i8* %59, i64 1
%91 = select i1 %89, i8* null, i8* %90
br label %92
92: ; preds = %86, %30
%93 = phi i8* [ null, %30 ], [ %91, %86 ]
ret i8* %93
}