int next_token(char **to, char const **scan, int sep) {
  char *p;
  char const *q;
  int quote;
  assert(scan);
  assert(*scan);
  assert(to);
  assert(*to);
  p = *to;
  q = *scan;
  while (isspace(*q)) {
    q++;
  }
  switch (q[0]) {
  case '\"':
  case '\\':
    if (q[1] != '\0')
      break;
    q++;
  case '\0':
    *p = '\0';
    *to = p + 1;
    *scan = q;
    return 0;
  default:
    break;
  }
  quote = (*q == '\"') ? q++, 1 : 0;
  while (*q) {
    if (!quote && isspace(*q)) {
      *p++ = sep;
      q++;
      break;
    } else if (*q == '\\') {
      *p++ = *++q;
      if (*q == '\0') {
        break;
      }
    } else if (*q == '\"') {
      quote = !quote;
    } else {
      *p++ = *q;
    }
    if (*++q == '\0') {
      *p++ = '\0';
    }
  }
  *to = p;
  *scan = q;
  return 1;
}


x86 assembly (clang, -O0):
<next_token>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   1040 <assert@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    $0x0,%al
call   1040 <assert@plt>
mov    -0x10(%rbp),%rdi
mov    $0x0,%al
call   1040 <assert@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    $0x0,%al
call   1040 <assert@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%eax
je     11a1 <next_token+0x81>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    117b <next_token+0x5b>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x38(%rbp)
test   %eax,%eax
je     11fc <next_token+0xdc>
jmp    11b8 <next_token+0x98>
mov    -0x38(%rbp),%eax
sub    $0x22,%eax
je     11da <next_token+0xba>
jmp    11c9 <next_token+0xa9>
mov    -0x38(%rbp),%eax
sub    $0x5c,%eax
jne    1229 <next_token+0x109>
jmp    11da <next_token+0xba>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x0,%eax
je     11f0 <next_token+0xd0>
jmp    122e <next_token+0x10e>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x28(%rbp),%rcx
add    $0x1,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    139e <next_token+0x27e>
jmp    122e <next_token+0x10e>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x22,%eax
jne    1257 <next_token+0x137>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1261 <next_token+0x141>
xor    %eax,%eax
mov    %eax,-0x3c(%rbp)
jmp    1261 <next_token+0x141>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
cmpb   $0x0,(%rax)
je     1381 <next_token+0x261>
cmpl   $0x0,-0x34(%rbp)
jne    12ba <next_token+0x19a>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%eax
je     12ba <next_token+0x19a>
mov    -0x1c(%rbp),%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1381 <next_token+0x261>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
jne    1307 <next_token+0x1e7>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    0x1(%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    1302 <next_token+0x1e2>
jmp    1381 <next_token+0x261>
jmp    1349 <next_token+0x229>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x22,%eax
jne    132d <next_token+0x20d>
cmpl   $0x0,-0x34(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x34(%rbp)
jmp    1344 <next_token+0x224>
mov    -0x30(%rbp),%rax
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    1349 <next_token+0x229>
jmp    134e <next_token+0x22e>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbl 0x1(%rax),%eax
cmp    $0x0,%eax
jne    137c <next_token+0x25c>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x0,(%rax)
jmp    1267 <next_token+0x147>
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<next_token>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %edx,%r15d
mov    %rsi,%r12
mov    %rdi,%r14
mov    %rsi,%rdi
xor    %eax,%eax
call   1040 <assert@plt>
mov    (%r12),%rdi
xor    %eax,%eax
call   1040 <assert@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <assert@plt>
mov    (%r14),%rdi
xor    %eax,%eax
call   1040 <assert@plt>
mov    (%r14),%r13
mov    (%r12),%rbx
add    $0xffffffffffffffff,%rbx
nopl   0x0(%rax,%rax,1)
movsbl 0x1(%rbx),%ebp
add    $0x1,%rbx
mov    %ebp,%edi
call   1030 <isspace@plt>
test   %eax,%eax
jne    1170 <next_token+0x50>
cmp    $0x5c,%ebp
je     1199 <next_token+0x79>
cmp    $0x22,%ebp
je     1199 <next_token+0x79>
test   %ebp,%ebp
jne    11a6 <next_token+0x86>
mov    %rbx,%rdx
jmp    126e <next_token+0x14e>
lea    0x1(%rbx),%rdx
cmpb   $0x0,(%rdx)
je     126e <next_token+0x14e>
mov    %r15d,0x14(%rsp)
mov    %r14,0x8(%rsp)
xor    %eax,%eax
cmp    $0x22,%bpl
sete   %al
lea    (%rbx,%rax,1),%r15
mov    (%rbx,%rax,1),%r14b
mov    $0x1,%eax
test   %r14b,%r14b
je     127b <next_token+0x15b>
mov    %r12,%rbx
xor    %r12d,%r12d
cmp    $0x22,%bpl
sete   %r12b
jmp    11e9 <next_token+0xc9>
nop
test   %r14b,%r14b
je     1295 <next_token+0x175>
test   %r12d,%r12d
jne    11ff <next_token+0xdf>
movsbl %r14b,%edi
call   1030 <isspace@plt>
test   %eax,%eax
jne    1285 <next_token+0x165>
cmp    $0x22,%r14b
je     1230 <next_token+0x110>
cmp    $0x5c,%r14b
jne    1240 <next_token+0x120>
lea    0x1(%r15),%rdx
movzbl 0x1(%r15),%ecx
mov    %cl,0x0(%r13)
add    $0x1,%r13
cmpb   $0x0,0x1(%r15)
jne    124b <next_token+0x12b>
jmp    1298 <next_token+0x178>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ecx,%ecx
test   %r12d,%r12d
sete   %cl
mov    %r15,%rdx
mov    %ecx,%r12d
jmp    124b <next_token+0x12b>
mov    %r14b,0x0(%r13)
add    $0x1,%r13
mov    %r15,%rdx
movzbl 0x1(%rdx),%r14d
mov    %rdx,%r15
add    $0x1,%r15
test   %r14b,%r14b
jne    11e0 <next_token+0xc0>
movb   $0x0,0x0(%r13)
add    $0x1,%r13
movzbl (%r15),%r14d
jmp    11e0 <next_token+0xc0>
movb   $0x0,0x0(%r13)
add    $0x1,%r13
xor    %eax,%eax
jmp    12a5 <next_token+0x185>
mov    %r15,%rdx
mov    0x8(%rsp),%r14
jmp    12a5 <next_token+0x185>
mov    0x14(%rsp),%eax
mov    %al,0x0(%r13)
add    $0x1,%r13
add    $0x1,%r15
mov    %r15,%rdx
mov    %rbx,%r12
mov    0x8(%rsp),%r14
mov    $0x1,%eax
mov    %r13,(%r14)
mov    %rdx,(%r12)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @next_token(i8** %0, i8** %1, i32 %2) {
%4 = tail call i32 (i8**, ...) bitcast (i32 (...)* @assert to i32 (i8**, ...)*)(i8** %1)
%5 = load i8*, i8** %1
%6 = tail call i32 (i8*, ...) bitcast (i32 (...)* @assert to i32 (i8*, ...)*)(i8* %5)
%7 = tail call i32 (i8**, ...) bitcast (i32 (...)* @assert to i32 (i8**, ...)*)(i8** %0)
%8 = load i8*, i8** %0
%9 = tail call i32 (i8*, ...) bitcast (i32 (...)* @assert to i32 (i8*, ...)*)(i8* %8)
%10 = load i8*, i8** %0
%11 = load i8*, i8** %1
br label %12
12: ; preds = %12, %3
%13 = phi i8* [ %11, %3 ], [ %18, %12 ]
%14 = load i8, i8* %13
%15 = sext i8 %14 to i32
%16 = tail call i32 @isspace(i32 %15)
%17 = icmp eq i32 %16, 0
%18 = getelementptr inbounds i8, i8* %13, i64 1
br i1 %17, label %19, label %12
19: ; preds = %12
%20 = sext i8 %14 to i32
switch i32 %20, label %27 [
i32 34, label %21
i32 92, label %21
i32 0, label %24
]
21: ; preds = %19, %19
%22 = load i8, i8* %18
%23 = icmp eq i8 %22, 0
br i1 %23, label %24, label %27
24: ; preds = %21, %19
%25 = phi i8* [ %13, %19 ], [ %18, %21 ]
store i8 0, i8* %10
%26 = getelementptr inbounds i8, i8* %10, i64 1
br label %74
27: ; preds = %19, %21
%28 = icmp eq i8 %14, 34
%29 = zext i1 %28 to i64
%30 = getelementptr i8, i8* %13, i64 %29
%31 = load i8, i8* %30
%32 = icmp eq i8 %31, 0
br i1 %32, label %74, label %33
33: ; preds = %27
%34 = zext i1 %28 to i32
br label %35
35: ; preds = %33, %70
%36 = phi i8 [ %71, %70 ], [ %31, %33 ]
%37 = phi i32 [ %63, %70 ], [ %34, %33 ]
%38 = phi i8* [ %64, %70 ], [ %30, %33 ]
%39 = phi i8* [ %72, %70 ], [ %10, %33 ]
%40 = icmp eq i32 %37, 0
br i1 %40, label %41, label %49
41: ; preds = %35
%42 = sext i8 %36 to i32
%43 = tail call i32 @isspace(i32 %42)
%44 = icmp eq i32 %43, 0
br i1 %44, label %49, label %45
45: ; preds = %41
%46 = trunc i32 %2 to i8
%47 = getelementptr inbounds i8, i8* %39, i64 1
store i8 %46, i8* %39
%48 = getelementptr inbounds i8, i8* %38, i64 1
br label %74
49: ; preds = %41, %35
switch i8 %36, label %58 [
i8 92, label %50
i8 34, label %56
]
50: ; preds = %49
%51 = getelementptr inbounds i8, i8* %38, i64 1
%52 = load i8, i8* %51
%53 = getelementptr inbounds i8, i8* %39, i64 1
store i8 %52, i8* %39
%54 = load i8, i8* %51
%55 = icmp eq i8 %54, 0
br i1 %55, label %74, label %60
56: ; preds = %49
%57 = zext i1 %40 to i32
br label %60
58: ; preds = %49
%59 = getelementptr inbounds i8, i8* %39, i64 1
store i8 %36, i8* %39
br label %60
60: ; preds = %50, %58, %56
%61 = phi i8* [ %53, %50 ], [ %39, %56 ], [ %59, %58 ]
%62 = phi i8* [ %51, %50 ], [ %38, %56 ], [ %38, %58 ]
%63 = phi i32 [ %37, %50 ], [ %57, %56 ], [ %37, %58 ]
%64 = getelementptr inbounds i8, i8* %62, i64 1
%65 = load i8, i8* %64
%66 = icmp eq i8 %65, 0
br i1 %66, label %67, label %70
67: ; preds = %60
%68 = getelementptr inbounds i8, i8* %61, i64 1
store i8 0, i8* %61
%69 = load i8, i8* %64
br label %70
70: ; preds = %67, %60
%71 = phi i8 [ %69, %67 ], [ %65, %60 ]
%72 = phi i8* [ %68, %67 ], [ %61, %60 ]
%73 = icmp eq i8 %71, 0
br i1 %73, label %74, label %35
74: ; preds = %50, %70, %27, %45, %24
%75 = phi i8* [ %26, %24 ], [ %47, %45 ], [ %10, %27 ], [ %53, %50 ], [ %72, %70 ]
%76 = phi i8* [ %25, %24 ], [ %48, %45 ], [ %30, %27 ], [ %51, %50 ], [ %64, %70 ]
%77 = phi i32 [ 0, %24 ], [ 1, %45 ], [ 1, %27 ], [ 1, %70 ], [ 1, %50 ]
store i8* %75, i8** %0
store i8* %76, i8** %1
ret i32 %77
}