#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*/ die(char *, char *);
void splitargs(char *cmd, char **argv) {
  int idx, offset;
  char quote, replacement;
  idx = 0;
  argv[idx] = NULL;
  offset = 0;
  quote = 0;
  while (cmd[0] != '\0') {
    switch (cmd[0]) {
    case ' ':
    case '\t':
    case '\r':
    case '\n':
      if (argv[idx] == NULL) {
      } else if (quote == 0) {
        cmd[offset] = '\0';
        idx++;
        offset = 0;
      } else {
        cmd[offset] = cmd[0];
      }
      break;
    case '"':
    case '\'':
      if (argv[idx] == NULL) {
        argv[idx] = cmd + 1;
        argv[idx + 1] = NULL;
        quote = cmd[0];
      } else if (quote == cmd[0]) {
        quote = 0;
        offset--;
      } else if (quote == 0) {
        quote = cmd[0];
        offset--;
      } else {
        cmd[offset] = cmd[0];
      }
      break;
    case '\\':
      if (quote != '\'') {
        replacement = 0;
        switch (cmd[1]) {
        case 'a':
          replacement = '\a';
          break;
        case 'b':
          replacement = '\b';
          break;
        case 'f':
          replacement = '\f';
          break;
        case 'n':
          replacement = '\n';
          break;
        case 'r':
          replacement = '\r';
          break;
        case 't':
          replacement = '\t';
          break;
        case 'v':
          replacement = '\v';
          break;
        case '\\':
        case '\'':
        case '"':
          replacement = cmd[1];
          break;
        }
        if (replacement != 0) {
          cmd[offset] = replacement;
          offset--;
          cmd++;
          break;
        }
      }
    default:
      if (argv[idx] == NULL) {
        argv[idx] = cmd;
        argv[idx + 1] = NULL;
      }
      cmd[offset] = cmd[0];
    }
    cmd++;
    if (idx >= 100)
      die("splitargs", "arguments limit exceeded");
  }
  cmd[offset] = '\0';
  if (quote != 0)
    die("splitargs", "unbalanced quotes");
}


x86 assembly (clang, -O0):
<splitargs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
movl   $0x0,-0x18(%rbp)
movb   $0x0,-0x19(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1414 <splitargs+0x304>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x20(%rbp)
add    $0xfffffff7,%eax
sub    $0x2,%eax
jb     11c2 <splitargs+0xb2>
jmp    116d <splitargs+0x5d>
mov    -0x20(%rbp),%eax
sub    $0xd,%eax
je     11c2 <splitargs+0xb2>
jmp    117e <splitargs+0x6e>
mov    -0x20(%rbp),%eax
sub    $0x20,%eax
je     11c2 <splitargs+0xb2>
jmp    118f <splitargs+0x7f>
mov    -0x20(%rbp),%eax
sub    $0x22,%eax
je     1223 <splitargs+0x113>
jmp    11a0 <splitargs+0x90>
mov    -0x20(%rbp),%eax
sub    $0x27,%eax
je     1223 <splitargs+0x113>
jmp    11b1 <splitargs+0xa1>
mov    -0x20(%rbp),%eax
sub    $0x5c,%eax
je     12d6 <splitargs+0x1c6>
jmp    139d <splitargs+0x28d>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    11da <splitargs+0xca>
jmp    121e <splitargs+0x10e>
movsbl -0x19(%rbp),%eax
cmp    $0x0,%eax
jne    1208 <splitargs+0xf8>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
jmp    1219 <splitargs+0x109>
mov    -0x8(%rbp),%rax
mov    (%rax),%dl
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    121e <splitargs+0x10e>
jmp    13e6 <splitargs+0x2d6>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    126d <splitargs+0x15d>
mov    -0x8(%rbp),%rdx
add    $0x1,%rdx
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x19(%rbp)
jmp    12d1 <splitargs+0x1c1>
movsbl -0x19(%rbp),%eax
mov    -0x8(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jne    1292 <splitargs+0x182>
movb   $0x0,-0x19(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    12cc <splitargs+0x1bc>
movsbl -0x19(%rbp),%eax
cmp    $0x0,%eax
jne    12b6 <splitargs+0x1a6>
mov    -0x8(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x19(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    12c7 <splitargs+0x1b7>
mov    -0x8(%rbp),%rax
mov    (%rax),%dl
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    12cc <splitargs+0x1bc>
jmp    12d1 <splitargs+0x1c1>
jmp    13e6 <splitargs+0x2d6>
movsbl -0x19(%rbp),%eax
cmp    $0x27,%eax
je     1398 <splitargs+0x288>
movb   $0x0,-0x1a(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0x1(%rax),%eax
add    $0xffffffde,%eax
mov    %eax,%ecx
mov    %rcx,-0x28(%rbp)
sub    $0x54,%eax
ja     135e <splitargs+0x24e>
mov    -0x28(%rbp),%rax
lea    0xcf4(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movb   $0x7,-0x1a(%rbp)
jmp    135e <splitargs+0x24e>
movb   $0x8,-0x1a(%rbp)
jmp    135e <splitargs+0x24e>
movb   $0xc,-0x1a(%rbp)
jmp    135e <splitargs+0x24e>
movb   $0xa,-0x1a(%rbp)
jmp    135e <splitargs+0x24e>
movb   $0xd,-0x1a(%rbp)
jmp    135e <splitargs+0x24e>
movb   $0x9,-0x1a(%rbp)
jmp    135e <splitargs+0x24e>
movb   $0xb,-0x1a(%rbp)
jmp    135e <splitargs+0x24e>
mov    -0x8(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0x1a(%rbp)
movsbl -0x1a(%rbp),%eax
cmp    $0x0,%eax
je     1393 <splitargs+0x283>
mov    -0x1a(%rbp),%dl
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    13e6 <splitargs+0x2d6>
jmp    1398 <splitargs+0x288>
jmp    139d <splitargs+0x28d>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    13d5 <splitargs+0x2c5>
mov    -0x8(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    (%rax),%dl
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
cmpl   $0x64,-0x14(%rbp)
jl     140f <splitargs+0x2ff>
lea    0xd51(%rip),%rdi
lea    0xd54(%rip),%rsi
call   1030 <die@plt>
jmp    1142 <splitargs+0x32>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movsbl -0x19(%rbp),%eax
cmp    $0x0,%eax
je     1440 <splitargs+0x330>
lea    0xd20(%rip),%rdi
lea    0xd3c(%rip),%rsi
call   1030 <die@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<splitargs>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%rbx
movq   $0x0,(%rsi)
mov    (%rdi),%al
test   %al,%al
je     12d2 <splitargs+0x1c2>
mov    %rsi,%r14
xor    %r12d,%r12d
movabs $0x100002600,%rbp
xor    %r15d,%r15d
xor    %r13d,%r13d
jmp    115b <splitargs+0x4b>
nopw   0x0(%rax,%rax,1)
movzbl (%rbx),%eax
test   %al,%al
je     12a5 <splitargs+0x195>
movsbl %al,%ecx
cmp    $0x27,%ecx
ja     11d0 <splitargs+0xc0>
bt     %rcx,%rbp
jae    11a0 <splitargs+0x90>
movslq %r13d,%rcx
cmpq   $0x0,(%r14,%rcx,8)
je     1226 <splitargs+0x116>
movslq %r15d,%rcx
test   %r12b,%r12b
jne    1223 <splitargs+0x113>
movb   $0x0,(%rbx,%rcx,1)
add    $0x1,%r13d
xor    %r15d,%r15d
xor    %r12d,%r12d
jmp    1226 <splitargs+0x116>
cs nopw 0x0(%rax,%rax,1)
movabs $0x8400000000,%rdx
bt     %rcx,%rdx
jae    11d0 <splitargs+0xc0>
movslq %r13d,%rcx
cmpq   $0x0,(%r14,%rcx,8)
je     11f7 <splitargs+0xe7>
cmp    %al,%r12b
jne    120e <splitargs+0xfe>
add    $0xffffffff,%r15d
xor    %r12d,%r12d
jmp    1226 <splitargs+0x116>
nopl   0x0(%rax,%rax,1)
cmp    $0x5c,%ecx
jne    11db <splitargs+0xcb>
cmp    $0x27,%r12b
jne    124c <splitargs+0x13c>
movslq %r13d,%rcx
cmpq   $0x0,(%r14,%rcx,8)
jne    1220 <splitargs+0x110>
mov    %rbx,(%r14,%rcx,8)
movq   $0x0,0x8(%r14,%rcx,8)
movzbl (%rbx),%eax
jmp    1220 <splitargs+0x110>
lea    0x1(%rbx),%rax
mov    %rax,(%r14,%rcx,8)
movq   $0x0,0x8(%r14,%rcx,8)
movzbl (%rbx),%r12d
jmp    1226 <splitargs+0x116>
test   %r12b,%r12b
je     1275 <splitargs+0x165>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %r15d,%rcx
mov    %al,(%rbx,%rcx,1)
add    $0x1,%rbx
cmp    $0x64,%r13d
jl     1150 <splitargs+0x40>
lea    0xf19(%rip),%rdi
lea    0xf1c(%rip),%rsi
call   1030 <die@plt>
jmp    1150 <splitargs+0x40>
movsbl 0x1(%rbx),%edx
lea    -0x22(%rdx),%esi
cmp    $0x54,%esi
ja     11db <splitargs+0xcb>
mov    $0x7,%cl
lea    0xd9f(%rip),%rdi
movslq (%rdi,%rsi,4),%rsi
add    %rdi,%rsi
jmp    *%rsi
mov    %edx,%ecx
test   %dl,%dl
jne    1294 <splitargs+0x184>
jmp    11db <splitargs+0xcb>
add    $0xffffffff,%r15d
mov    %eax,%r12d
jmp    1226 <splitargs+0x116>
mov    $0x8,%cl
jmp    1294 <splitargs+0x184>
mov    $0xc,%cl
jmp    1294 <splitargs+0x184>
mov    $0xa,%cl
jmp    1294 <splitargs+0x184>
mov    $0xd,%cl
jmp    1294 <splitargs+0x184>
mov    $0x9,%cl
jmp    1294 <splitargs+0x184>
mov    $0xb,%cl
movslq %r15d,%r15
mov    %cl,(%rbx,%r15,1)
add    $0x1,%rbx
add    $0xffffffff,%r15d
jmp    1226 <splitargs+0x116>
movslq %r15d,%rax
movb   $0x0,(%rbx,%rax,1)
test   %r12b,%r12b
je     12d5 <splitargs+0x1c5>
lea    0xe9c(%rip),%rdi
lea    0xeb8(%rip),%rsi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <die@plt>
movb   $0x0,(%rbx)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [10 x i8] c"splitargs\00"
@.str.1 = [25 x i8] c"arguments limit exceeded\00"
@.str.2 = [18 x i8] c"unbalanced quotes\00"
define void @splitargs(i8* %0, i8** nocapture %1) {
store i8* null, i8** %1
%3 = load i8, i8* %0
%4 = icmp eq i8 %3, 0
br i1 %4, label %5, label %6
5: ; preds = %2
store i8 0, i8* %0
br label %98
6: ; preds = %2, %89
%7 = phi i8 [ %90, %89 ], [ %3, %2 ]
%8 = phi i8 [ %84, %89 ], [ 0, %2 ]
%9 = phi i32 [ %83, %89 ], [ 0, %2 ]
%10 = phi i32 [ %82, %89 ], [ 0, %2 ]
%11 = phi i8* [ %85, %89 ], [ %0, %2 ]
%12 = sext i8 %7 to i32
switch i32 %12, label %66 [
i32 32, label %13
i32 9, label %13
i32 13, label %13
i32 10, label %13
i32 34, label %25
i32 39, label %25
i32 92, label %47
]
13: ; preds = %6, %6, %6, %6
%14 = sext i32 %10 to i64
%15 = getelementptr inbounds i8*, i8** %1, i64 %14
%16 = load i8*, i8** %15
%17 = icmp eq i8* %16, null
br i1 %17, label %80, label %18
18: ; preds = %13
%19 = icmp eq i8 %8, 0
%20 = sext i32 %9 to i64
%21 = getelementptr inbounds i8, i8* %11, i64 %20
br i1 %19, label %22, label %24
22: ; preds = %18
store i8 0, i8* %21
%23 = add nsw i32 %10, 1
br label %80
24: ; preds = %18
store i8 %7, i8* %21
br label %80
25: ; preds = %6, %6
%26 = sext i32 %10 to i64
%27 = getelementptr inbounds i8*, i8** %1, i64 %26
%28 = load i8*, i8** %27
%29 = icmp eq i8* %28, null
br i1 %29, label %30, label %36
30: ; preds = %25
%31 = getelementptr inbounds i8, i8* %11, i64 1
store i8* %31, i8** %27
%32 = add nsw i32 %10, 1
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8*, i8** %1, i64 %33
store i8* null, i8** %34
%35 = load i8, i8* %11
br label %80
36: ; preds = %25
%37 = icmp eq i8 %8, %7
br i1 %37, label %38, label %40
38: ; preds = %36
%39 = add nsw i32 %9, -1
br label %80
40: ; preds = %36
%41 = icmp eq i8 %8, 0
br i1 %41, label %42, label %44
42: ; preds = %40
%43 = add nsw i32 %9, -1
br label %80
44: ; preds = %40
%45 = sext i32 %9 to i64
%46 = getelementptr inbounds i8, i8* %11, i64 %45
store i8 %7, i8* %46
br label %80
47: ; preds = %6
%48 = icmp eq i8 %8, 39
br i1 %48, label %66, label %49
49: ; preds = %47
%50 = getelementptr inbounds i8, i8* %11, i64 1
%51 = load i8, i8* %50
%52 = sext i8 %51 to i32
switch i32 %52, label %66 [
i32 97, label %61
i32 98, label %53
i32 102, label %54
i32 110, label %55
i32 114, label %56
i32 116, label %57
i32 118, label %58
i32 92, label %59
i32 39, label %59
i32 34, label %59
]
53: ; preds = %49
br label %61
54: ; preds = %49
br label %61
55: ; preds = %49
br label %61
56: ; preds = %49
br label %61
57: ; preds = %49
br label %61
58: ; preds = %49
br label %61
59: ; preds = %49, %49, %49
%60 = icmp eq i8 %51, 0
br i1 %60, label %66, label %61
61: ; preds = %49, %53, %54, %55, %56, %57, %58, %59
%62 = phi i8 [ %51, %59 ], [ 8, %53 ], [ 12, %54 ], [ 10, %55 ], [ 13, %56 ], [ 9, %57 ], [ 11, %58 ], [ 7, %49 ]
%63 = sext i32 %9 to i64
%64 = getelementptr inbounds i8, i8* %11, i64 %63
store i8 %62, i8* %64
%65 = add nsw i32 %9, -1
br label %80
66: ; preds = %49, %47, %59, %6
%67 = sext i32 %10 to i64
%68 = getelementptr inbounds i8*, i8** %1, i64 %67
%69 = load i8*, i8** %68
%70 = icmp eq i8* %69, null
br i1 %70, label %71, label %76
71: ; preds = %66
store i8* %11, i8** %68
%72 = add nsw i32 %10, 1
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i8*, i8** %1, i64 %73
store i8* null, i8** %74
%75 = load i8, i8* %11
br label %76
76: ; preds = %71, %66
%77 = phi i8 [ %75, %71 ], [ %7, %66 ]
%78 = sext i32 %9 to i64
%79 = getelementptr inbounds i8, i8* %11, i64 %78
store i8 %77, i8* %79
br label %80
80: ; preds = %30, %42, %44, %38, %13, %24, %22, %76, %61
%81 = phi i8* [ %11, %76 ], [ %50, %61 ], [ %11, %30 ], [ %11, %38 ], [ %11, %42 ], [ %11, %44 ], [ %11, %13 ], [ %11, %22 ], [ %11, %24 ]
%82 = phi i32 [ %10, %76 ], [ %10, %61 ], [ %10, %30 ], [ %10, %38 ], [ %10, %42 ], [ %10, %44 ], [ %10, %13 ], [ %23, %22 ], [ %10, %24 ]
%83 = phi i32 [ %9, %76 ], [ %65, %61 ], [ %9, %30 ], [ %39, %38 ], [ %43, %42 ], [ %9, %44 ], [ %9, %13 ], [ 0, %22 ], [ %9, %24 ]
%84 = phi i8 [ %8, %76 ], [ %8, %61 ], [ %35, %30 ], [ 0, %38 ], [ %7, %42 ], [ %8, %44 ], [ %8, %13 ], [ 0, %22 ], [ %8, %24 ]
%85 = getelementptr inbounds i8, i8* %81, i64 1
%86 = icmp sgt i32 %82, 99
br i1 %86, label %87, label %89
87: ; preds = %80
%88 = tail call i32 @die(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0))
br label %89
89: ; preds = %87, %80
%90 = load i8, i8* %85
%91 = icmp eq i8 %90, 0
br i1 %91, label %92, label %6
92: ; preds = %89
%93 = sext i32 %83 to i64
%94 = getelementptr inbounds i8, i8* %85, i64 %93
store i8 0, i8* %94
%95 = icmp eq i8 %84, 0
br i1 %95, label %98, label %96
96: ; preds = %92
%97 = tail call i32 @die(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0))
br label %98
98: ; preds = %5, %96, %92
ret void
}