#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 */
scalar_t__ isspace(unsigned char);
scalar_t__ malloc(int);
char **stb_tokens_raw(char *src_, char *delimit, int *count, int stripwhite,
                      int allow_empty, char *start, char *end) {
  int nested = 0;
  unsigned char *src = (unsigned char *)src_;
  static char stb_tokentable[256];
  static char stable[256], etable[256];
  char *out;
  char **result;
  int num = 0;
  unsigned char *s;
  s = (unsigned char *)delimit;
  while (*s)
    stb_tokentable[*s++] = 1;
  if (start) {
    s = (unsigned char *)start;
    while (*s)
      stable[*s++] = 1;
    s = (unsigned char *)end;
    if (s)
      while (*s)
        stable[*s++] = 1;
    s = (unsigned char *)end;
    if (s)
      while (*s)
        etable[*s++] = 1;
  }
  stable[0] = 1;
  s = (unsigned char *)src;
  while (*s) {
    if (!allow_empty) {
      stb_tokentable[0] = 0;
      while (stb_tokentable[*s])
        ++s;
      if (!*s)
        break;
    }
    ++num;
    stb_tokentable[0] = 1;
    if (stripwhite == 2) {
      while (!stb_tokentable[*s]) {
        if (*s != '"')
          ++s;
        else {
          ++s;
          if (*s == '"')
            ++s;
          else {
            while (*s) {
              if (s[0] == '"') {
                if (s[1] == '"')
                  s += 2;
                else {
                  ++s;
                  break;
                }
              } else
                ++s;
            }
          }
        }
      }
    } else
      while (nested || !stb_tokentable[*s]) {
        if (stable[*s]) {
          if (!*s)
            break;
          if (end ? etable[*s] : nested)
            --nested;
          else
            ++nested;
        }
        ++s;
      }
    if (allow_empty) {
      if (*s)
        ++s;
    }
  }
  result = (char **)malloc(sizeof(*result) * (num + 1) + (s - src + 1));
  if (result == NULL)
    return result;
  out = (char *)(result + (num + 1));
  s = (unsigned char *)src;
  num = 0;
  nested = 0;
  while (*s) {
    char *last_nonwhite;
    if (!allow_empty) {
      stb_tokentable[0] = 0;
      if (stripwhite)
        while (stb_tokentable[*s] || isspace(*s))
          ++s;
      else
        while (stb_tokentable[*s])
          ++s;
    } else if (stripwhite) {
      while (isspace(*s))
        ++s;
    }
    if (!*s)
      break;
    result[num] = out;
    ++num;
    stb_tokentable[0] = 1;
    last_nonwhite = out - 1;
    if (stripwhite == 2) {
      while (!stb_tokentable[*s]) {
        if (*s != '"') {
          if (!isspace(*s))
            last_nonwhite = out;
          *out++ = *s++;
        } else {
          ++s;
          if (*s == '"') {
            if (!isspace(*s))
              last_nonwhite = out;
            *out++ = *s++;
          } else {
            while (*s) {
              if (s[0] == '"') {
                if (s[1] == '"') {
                  *out++ = *s;
                  s += 2;
                } else {
                  ++s;
                  break;
                }
              } else
                *out++ = *s++;
            }
            last_nonwhite = out - 1;
          }
        }
      }
    } else {
      while (nested || !stb_tokentable[*s]) {
        if (!isspace(*s))
          last_nonwhite = out;
        if (stable[*s]) {
          if (!*s)
            break;
          if (end ? etable[*s] : nested)
            --nested;
          else
            ++nested;
        }
        *out++ = *s++;
      }
    }
    if (stripwhite)
      out = last_nonwhite + 1;
    *out++ = '\0';
    if (*s)
      ++s;
  }
  s = (unsigned char *)delimit;
  while (*s)
    stb_tokentable[*s++] = 0;
  if (start) {
    s = (unsigned char *)start;
    while (*s)
      stable[*s++] = 1;
    s = (unsigned char *)end;
    if (s)
      while (*s)
        stable[*s++] = 1;
    s = (unsigned char *)end;
    if (s)
      while (*s)
        etable[*s++] = 1;
  }
  if (count != NULL)
    *count = num;
  result[num] = 0;
  return result;
}


x86 assembly (clang, -O0):
<stb_tokens_raw>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     1192 <stb_tokens_raw+0x72>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2eb7(%rip),%rax
movb   $0x1,(%rax,%rcx,1)
jmp    1161 <stb_tokens_raw+0x41>
cmpq   $0x0,-0x30(%rbp)
je     1277 <stb_tokens_raw+0x157>
mov    -0x30(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     11d6 <stb_tokens_raw+0xb6>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2f73(%rip),%rax
movb   $0x1,(%rax,%rcx,1)
jmp    11a5 <stb_tokens_raw+0x85>
mov    0x10(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x60(%rbp)
je     1224 <stb_tokens_raw+0x104>
jmp    11ee <stb_tokens_raw+0xce>
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     121f <stb_tokens_raw+0xff>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2f2a(%rip),%rax
movb   $0x1,(%rax,%rcx,1)
jmp    11ee <stb_tokens_raw+0xce>
jmp    1224 <stb_tokens_raw+0x104>
mov    0x10(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x60(%rbp)
je     1272 <stb_tokens_raw+0x152>
jmp    123c <stb_tokens_raw+0x11c>
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     126d <stb_tokens_raw+0x14d>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2fdc(%rip),%rax
movb   $0x1,(%rax,%rcx,1)
jmp    123c <stb_tokens_raw+0x11c>
jmp    1272 <stb_tokens_raw+0x152>
jmp    1277 <stb_tokens_raw+0x157>
movb   $0x1,0x2ec2(%rip)
mov    -0x40(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     14fa <stb_tokens_raw+0x3da>
cmpl   $0x0,-0x28(%rbp)
jne    12e6 <stb_tokens_raw+0x1c6>
movb   $0x0,0x2d9c(%rip)
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2d8c(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     12cf <stb_tokens_raw+0x1af>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    12a4 <stb_tokens_raw+0x184>
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
jne    12e1 <stb_tokens_raw+0x1c1>
jmp    14fa <stb_tokens_raw+0x3da>
jmp    12e6 <stb_tokens_raw+0x1c6>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movb   $0x1,0x2d4a(%rip)
cmpl   $0x2,-0x24(%rbp)
jne    13f8 <stb_tokens_raw+0x2d8>
jmp    1305 <stb_tokens_raw+0x1e5>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2d2b(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    132b <stb_tokens_raw+0x20b>
jmp    13f3 <stb_tokens_raw+0x2d3>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x22,%eax
je     134c <stb_tokens_raw+0x22c>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    13ee <stb_tokens_raw+0x2ce>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x22,%eax
jne    1379 <stb_tokens_raw+0x259>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    13e9 <stb_tokens_raw+0x2c9>
jmp    137e <stb_tokens_raw+0x25e>
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     13e4 <stb_tokens_raw+0x2c4>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x22,%eax
jne    13d3 <stb_tokens_raw+0x2b3>
mov    -0x60(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x22,%eax
jne    13bd <stb_tokens_raw+0x29d>
mov    -0x60(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x60(%rbp)
jmp    13ce <stb_tokens_raw+0x2ae>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    13e4 <stb_tokens_raw+0x2c4>
jmp    13df <stb_tokens_raw+0x2bf>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    137e <stb_tokens_raw+0x25e>
jmp    13e9 <stb_tokens_raw+0x2c9>
jmp    13ee <stb_tokens_raw+0x2ce>
jmp    1305 <stb_tokens_raw+0x1e5>
jmp    14cd <stb_tokens_raw+0x3ad>
jmp    13fd <stb_tokens_raw+0x2dd>
mov    $0x1,%al
cmpl   $0x0,-0x34(%rbp)
mov    %al,-0x69(%rbp)
jne    1428 <stb_tokens_raw+0x308>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2c24(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
setne  %al
xor    $0xff,%al
mov    %al,-0x69(%rbp)
mov    -0x69(%rbp),%al
test   $0x1,%al
jne    1438 <stb_tokens_raw+0x318>
jmp    14c8 <stb_tokens_raw+0x3a8>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2cf8(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     14b7 <stb_tokens_raw+0x397>
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1464 <stb_tokens_raw+0x344>
jmp    14c8 <stb_tokens_raw+0x3a8>
cmpq   $0x0,0x10(%rbp)
je     1491 <stb_tokens_raw+0x371>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2dc1(%rip),%rax
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    149b <stb_tokens_raw+0x37b>
jmp    14a9 <stb_tokens_raw+0x389>
cmpl   $0x0,-0x34(%rbp)
je     14a9 <stb_tokens_raw+0x389>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    14b2 <stb_tokens_raw+0x392>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14b7 <stb_tokens_raw+0x397>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    13fd <stb_tokens_raw+0x2dd>
jmp    14cd <stb_tokens_raw+0x3ad>
cmpl   $0x0,-0x28(%rbp)
je     14f5 <stb_tokens_raw+0x3d5>
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     14f0 <stb_tokens_raw+0x3d0>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    14f5 <stb_tokens_raw+0x3d5>
jmp    1286 <stb_tokens_raw+0x166>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    -0x60(%rbp),%rcx
mov    -0x40(%rbp),%rdx
sub    %rdx,%rcx
add    $0x1,%rcx
add    %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
jne    153b <stb_tokens_raw+0x41b>
mov    -0x50(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1ae3 <stb_tokens_raw+0x9c3>
mov    -0x50(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     1999 <stb_tokens_raw+0x879>
cmpl   $0x0,-0x28(%rbp)
jne    162e <stb_tokens_raw+0x50e>
movb   $0x0,0x2ab9(%rip)
cmpl   $0x0,-0x24(%rbp)
je     15f4 <stb_tokens_raw+0x4d4>
jmp    1596 <stb_tokens_raw+0x476>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2a9a(%rip),%rax
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x0,%ecx
mov    %al,-0x6a(%rbp)
jne    15ce <stb_tokens_raw+0x4ae>
mov    -0x60(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x6a(%rbp)
mov    -0x6a(%rbp),%al
test   $0x1,%al
jne    15de <stb_tokens_raw+0x4be>
jmp    15ef <stb_tokens_raw+0x4cf>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1596 <stb_tokens_raw+0x476>
jmp    1629 <stb_tokens_raw+0x509>
jmp    15f9 <stb_tokens_raw+0x4d9>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2a37(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     1624 <stb_tokens_raw+0x504>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    15f9 <stb_tokens_raw+0x4d9>
jmp    1629 <stb_tokens_raw+0x509>
jmp    166e <stb_tokens_raw+0x54e>
cmpl   $0x0,-0x24(%rbp)
je     1669 <stb_tokens_raw+0x549>
jmp    163d <stb_tokens_raw+0x51d>
mov    -0x60(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
je     1664 <stb_tokens_raw+0x544>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    163d <stb_tokens_raw+0x51d>
jmp    1669 <stb_tokens_raw+0x549>
jmp    166e <stb_tokens_raw+0x54e>
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1680 <stb_tokens_raw+0x560>
jmp    1999 <stb_tokens_raw+0x879>
mov    -0x48(%rbp),%rdx
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movb   $0x1,0x29a0(%rip)
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x68(%rbp)
cmpl   $0x2,-0x24(%rbp)
jne    184a <stb_tokens_raw+0x72a>
jmp    16bb <stb_tokens_raw+0x59b>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2975(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    16e1 <stb_tokens_raw+0x5c1>
jmp    1845 <stb_tokens_raw+0x725>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x22,%eax
je     1736 <stb_tokens_raw+0x616>
mov    -0x60(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
jne    170f <stb_tokens_raw+0x5ef>
mov    -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    1840 <stb_tokens_raw+0x720>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x22,%eax
jne    1797 <stb_tokens_raw+0x677>
mov    -0x60(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
jne    1770 <stb_tokens_raw+0x650>
mov    -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    183b <stb_tokens_raw+0x71b>
jmp    179c <stb_tokens_raw+0x67c>
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     182f <stb_tokens_raw+0x70f>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x22,%eax
jne    1808 <stb_tokens_raw+0x6e8>
mov    -0x60(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x22,%eax
jne    17f2 <stb_tokens_raw+0x6d2>
mov    -0x60(%rbp),%rax
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x60(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x60(%rbp)
jmp    1803 <stb_tokens_raw+0x6e3>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    182f <stb_tokens_raw+0x70f>
jmp    182a <stb_tokens_raw+0x70a>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    179c <stb_tokens_raw+0x67c>
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x68(%rbp)
jmp    1840 <stb_tokens_raw+0x720>
jmp    16bb <stb_tokens_raw+0x59b>
jmp    1953 <stb_tokens_raw+0x833>
jmp    184f <stb_tokens_raw+0x72f>
mov    $0x1,%al
cmpl   $0x0,-0x34(%rbp)
mov    %al,-0x6b(%rbp)
jne    187a <stb_tokens_raw+0x75a>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x27d2(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
setne  %al
xor    $0xff,%al
mov    %al,-0x6b(%rbp)
mov    -0x6b(%rbp),%al
test   $0x1,%al
jne    188a <stb_tokens_raw+0x76a>
jmp    194e <stb_tokens_raw+0x82e>
mov    -0x60(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
jne    18a8 <stb_tokens_raw+0x788>
mov    -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2888(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     1927 <stb_tokens_raw+0x807>
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
jne    18d4 <stb_tokens_raw+0x7b4>
jmp    194e <stb_tokens_raw+0x82e>
cmpq   $0x0,0x10(%rbp)
je     1901 <stb_tokens_raw+0x7e1>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2951(%rip),%rax
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    190b <stb_tokens_raw+0x7eb>
jmp    1919 <stb_tokens_raw+0x7f9>
cmpl   $0x0,-0x34(%rbp)
je     1919 <stb_tokens_raw+0x7f9>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1922 <stb_tokens_raw+0x802>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1927 <stb_tokens_raw+0x807>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    184f <stb_tokens_raw+0x72f>
jmp    1953 <stb_tokens_raw+0x833>
cmpl   $0x0,-0x24(%rbp)
je     1969 <stb_tokens_raw+0x849>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
movb   $0x0,(%rax)
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     1994 <stb_tokens_raw+0x874>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1569 <stb_tokens_raw+0x449>
mov    -0x18(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     19d2 <stb_tokens_raw+0x8b2>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2677(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
jmp    19a1 <stb_tokens_raw+0x881>
cmpq   $0x0,-0x30(%rbp)
je     1ab7 <stb_tokens_raw+0x997>
mov    -0x30(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     1a16 <stb_tokens_raw+0x8f6>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x2733(%rip),%rax
movb   $0x1,(%rax,%rcx,1)
jmp    19e5 <stb_tokens_raw+0x8c5>
mov    0x10(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x60(%rbp)
je     1a64 <stb_tokens_raw+0x944>
jmp    1a2e <stb_tokens_raw+0x90e>
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     1a5f <stb_tokens_raw+0x93f>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x26ea(%rip),%rax
movb   $0x1,(%rax,%rcx,1)
jmp    1a2e <stb_tokens_raw+0x90e>
jmp    1a64 <stb_tokens_raw+0x944>
mov    0x10(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x60(%rbp)
je     1ab2 <stb_tokens_raw+0x992>
jmp    1a7c <stb_tokens_raw+0x95c>
mov    -0x60(%rbp),%rax
cmpb   $0x0,(%rax)
je     1aad <stb_tokens_raw+0x98d>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
lea    0x279c(%rip),%rax
movb   $0x1,(%rax,%rcx,1)
jmp    1a7c <stb_tokens_raw+0x95c>
jmp    1ab2 <stb_tokens_raw+0x992>
jmp    1ab7 <stb_tokens_raw+0x997>
cmpq   $0x0,-0x20(%rbp)
je     1acb <stb_tokens_raw+0x9ab>
mov    -0x54(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stb_tokens_raw>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,%r13
mov    %r8d,0x4(%rsp)
mov    %ecx,(%rsp)
mov    %rdx,%r15
mov    %rdi,%r14
mov    (%rsi),%al
test   %al,%al
je     1162 <stb_tokens_raw+0x42>
lea    0x1(%rsi),%rcx
lea    0x2ef0(%rip),%rdx
movzbl %al,%eax
movb   $0x1,(%rax,%rdx,1)
movzbl (%rcx),%eax
add    $0x1,%rcx
test   %al,%al
jne    1150 <stb_tokens_raw+0x30>
mov    %rsi,0x8(%rsp)
mov    0x60(%rsp),%r12
test   %r13,%r13
je     1202 <stb_tokens_raw+0xe2>
mov    0x0(%r13),%al
test   %al,%al
je     11a2 <stb_tokens_raw+0x82>
lea    0x1(%r13),%rcx
lea    0x2fb8(%rip),%rdx
nopl   0x0(%rax,%rax,1)
movzbl %al,%eax
movb   $0x1,(%rax,%rdx,1)
movzbl (%rcx),%eax
add    $0x1,%rcx
test   %al,%al
jne    1190 <stb_tokens_raw+0x70>
test   %r12,%r12
je     1202 <stb_tokens_raw+0xe2>
mov    (%r12),%bl
test   %bl,%bl
je     1202 <stb_tokens_raw+0xe2>
lea    0x1(%r12),%rcx
lea    0x2f85(%rip),%rdx
mov    %ebx,%eax
nopl   (%rax)
movzbl %al,%eax
movb   $0x1,(%rax,%rdx,1)
movzbl (%rcx),%eax
add    $0x1,%rcx
test   %al,%al
jne    11c0 <stb_tokens_raw+0xa0>
test   %bl,%bl
je     1202 <stb_tokens_raw+0xe2>
lea    0x1(%r12),%rcx
lea    0x305e(%rip),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl %bl,%eax
movb   $0x1,(%rax,%rdx,1)
movzbl (%rcx),%ebx
add    $0x1,%rcx
test   %bl,%bl
jne    11f0 <stb_tokens_raw+0xd0>
movb   $0x1,0x2f37(%rip)
cmpb   $0x0,(%r14)
je     136a <stb_tokens_raw+0x24a>
xor    %ebx,%ebx
lea    0x2e24(%rip),%rax
lea    0x2f1d(%rip),%rcx
lea    0x3016(%rip),%r8
mov    %r14,%rbp
xor    %esi,%esi
jmp    124b <stb_tokens_raw+0x12b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebx
test   %dl,%dl
je     136f <stb_tokens_raw+0x24f>
cmpl   $0x0,0x4(%rsp)
jne    1276 <stb_tokens_raw+0x156>
movb   $0x0,0x2de7(%rip)
add    $0xffffffffffffffff,%rbp
nopl   (%rax)
movzbl 0x1(%rbp),%edx
add    $0x1,%rbp
cmpb   $0x0,(%rdx,%rax,1)
jne    1260 <stb_tokens_raw+0x140>
test   %dl,%dl
je     136f <stb_tokens_raw+0x24f>
movb   $0x1,0x2dc3(%rip)
cmpl   $0x2,(%rsp)
jne    129b <stb_tokens_raw+0x17b>
jmp    12e3 <stb_tokens_raw+0x1c3>
cs nopw 0x0(%rax,%rax,1)
nop
test   %esi,%esi
je     12ca <stb_tokens_raw+0x1aa>
add    $0xffffffff,%esi
add    $0x1,%rbp
movzbl 0x0(%rbp),%edx
movzbl %dl,%edi
test   %esi,%esi
jne    12b0 <stb_tokens_raw+0x190>
cmpb   $0x0,(%rdi,%rax,1)
jne    135c <stb_tokens_raw+0x23c>
cmpb   $0x0,(%rdi,%rcx,1)
je     1297 <stb_tokens_raw+0x177>
test   %dl,%dl
je     1340 <stb_tokens_raw+0x220>
test   %r12,%r12
je     1290 <stb_tokens_raw+0x170>
cmpb   $0x0,(%rdi,%r8,1)
jne    1294 <stb_tokens_raw+0x174>
add    $0x1,%esi
add    $0x1,%rbp
jmp    129b <stb_tokens_raw+0x17b>
add    $0x1,%rdi
nopw   0x0(%rax,%rax,1)
mov    %rdi,%rbp
movzbl 0x0(%rbp),%edx
cmpb   $0x0,(%rdx,%rax,1)
jne    1342 <stb_tokens_raw+0x222>
lea    0x1(%rbp),%rdi
cmp    $0x22,%dl
jne    12e0 <stb_tokens_raw+0x1c0>
mov    (%rdi),%dl
cmp    $0x22,%dl
jne    1322 <stb_tokens_raw+0x202>
add    $0x2,%rbp
jmp    12e3 <stb_tokens_raw+0x1c3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x2,%ebp
cmpb   $0x22,0x1(%rdi)
jne    12d3 <stb_tokens_raw+0x1b3>
movzbl (%rdi,%rbp,1),%edx
add    %rbp,%rdi
cmp    $0x22,%dl
je     1310 <stb_tokens_raw+0x1f0>
mov    $0x1,%ebp
test   %dl,%dl
jne    131b <stb_tokens_raw+0x1fb>
jmp    12e0 <stb_tokens_raw+0x1c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %edx,%edx
cmpl   $0x0,0x4(%rsp)
je     1240 <stb_tokens_raw+0x120>
cmp    $0x1,%dl
sbb    $0xffffffffffffffff,%rbp
mov    0x0(%rbp),%dl
jmp    1240 <stb_tokens_raw+0x120>
xor    %esi,%esi
cmpl   $0x0,0x4(%rsp)
jne    134d <stb_tokens_raw+0x22d>
jmp    1240 <stb_tokens_raw+0x120>
xor    %ebx,%ebx
mov    %r14,%rbp
lea    0x8(,%rbx,8),%eax
sub    %r14d,%eax
lea    (%rax,%rbp,1),%edi
add    $0x1,%edi
call   1040 <malloc@plt>
test   %rax,%rax
je     16c6 <stb_tokens_raw+0x5a6>
mov    (%r14),%cl
test   %cl,%cl
je     15f3 <stb_tokens_raw+0x4d3>
mov    %r13,0x18(%rsp)
mov    %r15,0x20(%rsp)
add    $0x1,%ebx
mov    %rax,0x10(%rsp)
lea    (%rax,%rbx,8),%r12
xor    %ebp,%ebp
lea    0x2c89(%rip),%r13
xor    %ebx,%ebx
jmp    13ee <stb_tokens_raw+0x2ce>
xor    %ebx,%ebx
nopl   (%rax)
add    $0x1,%rbp
add    $0x1,%r15
cmpl   $0x0,(%rsp)
cmove  %r12,%r15
movb   $0x0,(%r15)
add    $0x1,%r15
cmpb   $0x1,(%r14)
sbb    $0xffffffffffffffff,%r14
mov    (%r14),%cl
mov    %r15,%r12
test   %cl,%cl
je     15d8 <stb_tokens_raw+0x4b8>
cmpl   $0x0,0x4(%rsp)
je     1430 <stb_tokens_raw+0x310>
cmpl   $0x0,(%rsp)
je     148c <stb_tokens_raw+0x36c>
movzbl %cl,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
call   1030 <isspace@plt>
test   %rax,%rax
je     148c <stb_tokens_raw+0x36c>
movzbl 0x1(%r14),%edi
add    $0x1,%r14
jmp    1410 <stb_tokens_raw+0x2f0>
cs nopw 0x0(%rax,%rax,1)
nop
movb   $0x0,0x2c09(%rip)
cmpl   $0x0,(%rsp)
jne    1474 <stb_tokens_raw+0x354>
add    $0xffffffffffffffff,%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x1(%r14),%eax
add    $0x1,%r14
cmpb   $0x0,(%rax,%r13,1)
jne    1450 <stb_tokens_raw+0x330>
test   %al,%al
jne    1497 <stb_tokens_raw+0x377>
jmp    15d8 <stb_tokens_raw+0x4b8>
nopl   0x0(%rax)
add    $0x1,%r14
movzbl (%r14),%eax
cmpb   $0x0,(%rax,%r13,1)
jne    1470 <stb_tokens_raw+0x350>
movzbl %al,%edi
call   1030 <isspace@plt>
test   %rax,%rax
jne    1470 <stb_tokens_raw+0x350>
mov    (%r14),%al
test   %al,%al
je     15d8 <stb_tokens_raw+0x4b8>
lea    -0x1(%r12),%r15
mov    0x10(%rsp),%rax
mov    %r12,(%rax,%rbp,8)
movb   $0x1,0x2b94(%rip)
cmpl   $0x2,(%rsp)
jne    14d3 <stb_tokens_raw+0x3b3>
jmp    154e <stb_tokens_raw+0x42e>
nopw   0x0(%rax,%rax,1)
test   %ebx,%ebx
je     1523 <stb_tokens_raw+0x403>
add    $0xffffffff,%ebx
add    $0x1,%r14
mov    %al,(%r12)
add    $0x1,%r12
movzbl (%r14),%edi
test   %ebx,%ebx
jne    14e6 <stb_tokens_raw+0x3c6>
cmpb   $0x0,(%rdi,%r13,1)
jne    13bb <stb_tokens_raw+0x29b>
call   1030 <isspace@plt>
test   %rax,%rax
cmove  %r12,%r15
movzbl (%r14),%eax
movzbl %al,%ecx
lea    0x2c40(%rip),%rdx
cmpb   $0x0,(%rcx,%rdx,1)
je     14c7 <stb_tokens_raw+0x3a7>
test   %al,%al
je     13c0 <stb_tokens_raw+0x2a0>
cmpq   $0x0,0x60(%rsp)
je     14c0 <stb_tokens_raw+0x3a0>
lea    0x2d23(%rip),%rdx
cmpb   $0x0,(%rcx,%rdx,1)
jne    14c4 <stb_tokens_raw+0x3a4>
add    $0x1,%ebx
jmp    14c7 <stb_tokens_raw+0x3a7>
nopl   0x0(%rax,%rax,1)
movzbl %al,%edi
call   1030 <isspace@plt>
test   %rax,%rax
cmove  %r12,%r15
mov    (%r14),%al
add    $0x1,%r14
mov    %al,(%r12)
add    $0x1,%r12
movzbl (%r14),%eax
cmpb   $0x0,(%rax,%r13,1)
jne    13c0 <stb_tokens_raw+0x2a0>
cmp    $0x22,%al
jne    1530 <stb_tokens_raw+0x410>
mov    0x1(%r14),%al
cmp    $0x22,%al
jne    1590 <stb_tokens_raw+0x470>
mov    $0x22,%edi
call   1030 <isspace@plt>
test   %rax,%rax
cmove  %r12,%r15
mov    0x1(%r14),%al
add    $0x2,%r14
jmp    1546 <stb_tokens_raw+0x426>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14
jmp    15b8 <stb_tokens_raw+0x498>
cs nopw 0x0(%rax,%rax,1)
cmpb   $0x22,0x1(%r14)
jne    15ca <stb_tokens_raw+0x4aa>
movb   $0x22,(%r12)
add    $0x2,%r14
add    $0x1,%r12
movzbl (%r14),%eax
cmp    $0x22,%al
je     15a0 <stb_tokens_raw+0x480>
test   %al,%al
je     15ce <stb_tokens_raw+0x4ae>
add    $0x1,%r14
mov    %al,(%r12)
jmp    15b0 <stb_tokens_raw+0x490>
add    $0x1,%r14
lea    -0x1(%r12),%r15
jmp    154e <stb_tokens_raw+0x42e>
mov    0x20(%rsp),%r15
mov    0x60(%rsp),%r12
mov    0x18(%rsp),%r13
mov    0x8(%rsp),%rdx
mov    0x10(%rsp),%rax
jmp    15fa <stb_tokens_raw+0x4da>
xor    %ebp,%ebp
mov    0x8(%rsp),%rdx
mov    (%rdx),%bl
test   %bl,%bl
je     1622 <stb_tokens_raw+0x502>
add    $0x1,%rdx
lea    0x2a35(%rip),%rcx
nopl   0x0(%rax,%rax,1)
movzbl %bl,%esi
movb   $0x0,(%rsi,%rcx,1)
movzbl (%rdx),%ebx
add    $0x1,%rdx
test   %bl,%bl
jne    1610 <stb_tokens_raw+0x4f0>
test   %r13,%r13
je     16b4 <stb_tokens_raw+0x594>
mov    0x0(%r13),%dl
test   %dl,%dl
je     1654 <stb_tokens_raw+0x534>
add    $0x1,%r13
lea    0x2b02(%rip),%rcx
xchg   %ax,%ax
movzbl %dl,%edx
movb   $0x1,(%rdx,%rcx,1)
movzbl 0x0(%r13),%edx
add    $0x1,%r13
test   %dl,%dl
jne    1640 <stb_tokens_raw+0x520>
test   %r12,%r12
je     16b4 <stb_tokens_raw+0x594>
mov    (%r12),%dl
test   %dl,%dl
je     16b4 <stb_tokens_raw+0x594>
lea    0x1(%r12),%rcx
lea    0x2ad3(%rip),%rsi
mov    %edx,%ebx
nop
movzbl %bl,%edi
movb   $0x1,(%rdi,%rsi,1)
movzbl (%rcx),%ebx
add    $0x1,%rcx
test   %bl,%bl
jne    1670 <stb_tokens_raw+0x550>
test   %dl,%dl
je     16b4 <stb_tokens_raw+0x594>
add    $0x1,%r12
lea    0x2baf(%rip),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl %dl,%edx
movb   $0x1,(%rdx,%rcx,1)
movzbl (%r12),%edx
add    $0x1,%r12
test   %dl,%dl
jne    16a0 <stb_tokens_raw+0x580>
test   %r15,%r15
je     16bc <stb_tokens_raw+0x59c>
mov    %ebp,(%r15)
mov    %ebp,%ecx
movq   $0x0,(%rax,%rcx,8)
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@stb_tokens_raw.stb_tokentable = internal global [256 x i8] zeroinitializer
@stb_tokens_raw.stable = internal global [256 x i8] zeroinitializer
@stb_tokens_raw.etable = internal global [256 x i8] zeroinitializer
define i8** @stb_tokens_raw(i8* %0, i8* %1, i32* %2, i32 %3, i32 %4, i8* %5, i8* %6) {
%8 = alloca i8**
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i32*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i8*
%15 = alloca i8*
%16 = alloca i32
%17 = alloca i8*
%18 = alloca i8*
%19 = alloca i8**
%20 = alloca i32
%21 = alloca i8*
%22 = alloca i8*
store i8* %0, i8** %9
store i8* %1, i8** %10
store i32* %2, i32** %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store i8* %5, i8** %14
store i8* %6, i8** %15
store i32 0, i32* %16
%23 = load i8*, i8** %9
store i8* %23, i8** %17
store i32 0, i32* %20
%24 = load i8*, i8** %10
store i8* %24, i8** %21
br label %25
25: ; preds = %29, %7
%26 = load i8*, i8** %21
%27 = load i8, i8* %26
%28 = icmp ne i8 %27, 0
br i1 %28, label %29, label %35
29: ; preds = %25
%30 = load i8*, i8** %21
%31 = getelementptr inbounds i8, i8* %30, i32 1
store i8* %31, i8** %21
%32 = load i8, i8* %30
%33 = zext i8 %32 to i64
%34 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %33
store i8 1, i8* %34
br label %25
35: ; preds = %25
%36 = load i8*, i8** %14
%37 = icmp ne i8* %36, null
br i1 %37, label %38, label %83
38: ; preds = %35
%39 = load i8*, i8** %14
store i8* %39, i8** %21
br label %40
40: ; preds = %44, %38
%41 = load i8*, i8** %21
%42 = load i8, i8* %41
%43 = icmp ne i8 %42, 0
br i1 %43, label %44, label %50
44: ; preds = %40
%45 = load i8*, i8** %21
%46 = getelementptr inbounds i8, i8* %45, i32 1
store i8* %46, i8** %21
%47 = load i8, i8* %45
%48 = zext i8 %47 to i64
%49 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %48
store i8 1, i8* %49
br label %40
50: ; preds = %40
%51 = load i8*, i8** %15
store i8* %51, i8** %21
%52 = load i8*, i8** %21
%53 = icmp ne i8* %52, null
br i1 %53, label %54, label %66
54: ; preds = %50
br label %55
55: ; preds = %59, %54
%56 = load i8*, i8** %21
%57 = load i8, i8* %56
%58 = icmp ne i8 %57, 0
br i1 %58, label %59, label %65
59: ; preds = %55
%60 = load i8*, i8** %21
%61 = getelementptr inbounds i8, i8* %60, i32 1
store i8* %61, i8** %21
%62 = load i8, i8* %60
%63 = zext i8 %62 to i64
%64 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %63
store i8 1, i8* %64
br label %55
65: ; preds = %55
br label %66
66: ; preds = %65, %50
%67 = load i8*, i8** %15
store i8* %67, i8** %21
%68 = load i8*, i8** %21
%69 = icmp ne i8* %68, null
br i1 %69, label %70, label %82
70: ; preds = %66
br label %71
71: ; preds = %75, %70
%72 = load i8*, i8** %21
%73 = load i8, i8* %72
%74 = icmp ne i8 %73, 0
br i1 %74, label %75, label %81
75: ; preds = %71
%76 = load i8*, i8** %21
%77 = getelementptr inbounds i8, i8* %76, i32 1
store i8* %77, i8** %21
%78 = load i8, i8* %76
%79 = zext i8 %78 to i64
%80 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.etable, i64 0, i64 %79
store i8 1, i8* %80
br label %71
81: ; preds = %71
br label %82
82: ; preds = %81, %66
br label %83
83: ; preds = %82, %35
store i8 1, i8* getelementptr inbounds ([256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 0)
%84 = load i8*, i8** %17
store i8* %84, i8** %21
br label %85
85: ; preds = %235, %83
%86 = load i8*, i8** %21
%87 = load i8, i8* %86
%88 = icmp ne i8 %87, 0
br i1 %88, label %89, label %236
89: ; preds = %85
%90 = load i32, i32* %13
%91 = icmp ne i32 %90, 0
br i1 %91, label %109, label %92
92: ; preds = %89
store i8 0, i8* getelementptr inbounds ([256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 0)
br label %93
93: ; preds = %100, %92
%94 = load i8*, i8** %21
%95 = load i8, i8* %94
%96 = zext i8 %95 to i64
%97 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %96
%98 = load i8, i8* %97
%99 = icmp ne i8 %98, 0
br i1 %99, label %100, label %103
100: ; preds = %93
%101 = load i8*, i8** %21
%102 = getelementptr inbounds i8, i8* %101, i32 1
store i8* %102, i8** %21
br label %93
103: ; preds = %93
%104 = load i8*, i8** %21
%105 = load i8, i8* %104
%106 = icmp ne i8 %105, 0
br i1 %106, label %108, label %107
107: ; preds = %103
br label %236
108: ; preds = %103
br label %109
109: ; preds = %108, %89
%110 = load i32, i32* %20
%111 = add nsw i32 %110, 1
store i32 %111, i32* %20
store i8 1, i8* getelementptr inbounds ([256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 0)
%112 = load i32, i32* %12
%113 = icmp eq i32 %112, 2
br i1 %113, label %114, label %173
114: ; preds = %109
br label %115
115: ; preds = %171, %114
%116 = load i8*, i8** %21
%117 = load i8, i8* %116
%118 = zext i8 %117 to i64
%119 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %118
%120 = load i8, i8* %119
%121 = icmp ne i8 %120, 0
%122 = xor i1 %121, true
br i1 %122, label %123, label %172
123: ; preds = %115
%124 = load i8*, i8** %21
%125 = load i8, i8* %124
%126 = zext i8 %125 to i32
%127 = icmp ne i32 %126, 34
br i1 %127, label %128, label %131
128: ; preds = %123
%129 = load i8*, i8** %21
%130 = getelementptr inbounds i8, i8* %129, i32 1
store i8* %130, i8** %21
br label %171
131: ; preds = %123
%132 = load i8*, i8** %21
%133 = getelementptr inbounds i8, i8* %132, i32 1
store i8* %133, i8** %21
%134 = load i8*, i8** %21
%135 = load i8, i8* %134
%136 = zext i8 %135 to i32
%137 = icmp eq i32 %136, 34
br i1 %137, label %138, label %141
138: ; preds = %131
%139 = load i8*, i8** %21
%140 = getelementptr inbounds i8, i8* %139, i32 1
store i8* %140, i8** %21
br label %170
141: ; preds = %131
br label %142
142: ; preds = %168, %141
%143 = load i8*, i8** %21
%144 = load i8, i8* %143
%145 = icmp ne i8 %144, 0
br i1 %145, label %146, label %169
146: ; preds = %142
%147 = load i8*, i8** %21
%148 = getelementptr inbounds i8, i8* %147, i64 0
%149 = load i8, i8* %148
%150 = zext i8 %149 to i32
%151 = icmp eq i32 %150, 34
br i1 %151, label %152, label %165
152: ; preds = %146
%153 = load i8*, i8** %21
%154 = getelementptr inbounds i8, i8* %153, i64 1
%155 = load i8, i8* %154
%156 = zext i8 %155 to i32
%157 = icmp eq i32 %156, 34
br i1 %157, label %158, label %161
158: ; preds = %152
%159 = load i8*, i8** %21
%160 = getelementptr inbounds i8, i8* %159, i64 2
store i8* %160, i8** %21
br label %164
161: ; preds = %152
%162 = load i8*, i8** %21
%163 = getelementptr inbounds i8, i8* %162, i32 1
store i8* %163, i8** %21
br label %169
164: ; preds = %158
br label %168
165: ; preds = %146
%166 = load i8*, i8** %21
%167 = getelementptr inbounds i8, i8* %166, i32 1
store i8* %167, i8** %21
br label %168
168: ; preds = %165, %164
br label %142
169: ; preds = %161, %142
br label %170
170: ; preds = %169, %138
br label %171
171: ; preds = %170, %128
br label %115
172: ; preds = %115
br label %224
173: ; preds = %109
br label %174
174: ; preds = %220, %173
%175 = load i32, i32* %16
%176 = icmp ne i32 %175, 0
br i1 %176, label %185, label %177
177: ; preds = %174
%178 = load i8*, i8** %21
%179 = load i8, i8* %178
%180 = zext i8 %179 to i64
%181 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %180
%182 = load i8, i8* %181
%183 = icmp ne i8 %182, 0
%184 = xor i1 %183, true
br label %185
185: ; preds = %177, %174
%186 = phi i1 [ true, %174 ], [ %184, %177 ]
br i1 %186, label %187, label %223
187: ; preds = %185
%188 = load i8*, i8** %21
%189 = load i8, i8* %188
%190 = zext i8 %189 to i64
%191 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %190
%192 = load i8, i8* %191
%193 = icmp ne i8 %192, 0
br i1 %193, label %194, label %220
194: ; preds = %187
%195 = load i8*, i8** %21
%196 = load i8, i8* %195
%197 = icmp ne i8 %196, 0
br i1 %197, label %199, label %198
198: ; preds = %194
br label %223
199: ; preds = %194
%200 = load i8*, i8** %15
%201 = icmp ne i8* %200, null
br i1 %201, label %202, label %210
202: ; preds = %199
%203 = load i8*, i8** %21
%204 = load i8, i8* %203
%205 = zext i8 %204 to i64
%206 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.etable, i64 0, i64 %205
%207 = load i8, i8* %206
%208 = sext i8 %207 to i32
%209 = icmp ne i32 %208, 0
br i1 %209, label %213, label %216
210: ; preds = %199
%211 = load i32, i32* %16
%212 = icmp ne i32 %211, 0
br i1 %212, label %213, label %216
213: ; preds = %210, %202
%214 = load i32, i32* %16
%215 = add nsw i32 %214, -1
store i32 %215, i32* %16
br label %219
216: ; preds = %210, %202
%217 = load i32, i32* %16
%218 = add nsw i32 %217, 1
store i32 %218, i32* %16
br label %219
219: ; preds = %216, %213
br label %220
220: ; preds = %219, %187
%221 = load i8*, i8** %21
%222 = getelementptr inbounds i8, i8* %221, i32 1
store i8* %222, i8** %21
br label %174
223: ; preds = %198, %185
br label %224
224: ; preds = %223, %172
%225 = load i32, i32* %13
%226 = icmp ne i32 %225, 0
br i1 %226, label %227, label %235
227: ; preds = %224
%228 = load i8*, i8** %21
%229 = load i8, i8* %228
%230 = icmp ne i8 %229, 0
br i1 %230, label %231, label %234
231: ; preds = %227
%232 = load i8*, i8** %21
%233 = getelementptr inbounds i8, i8* %232, i32 1
store i8* %233, i8** %21
br label %234
234: ; preds = %231, %227
br label %235
235: ; preds = %234, %224
br label %85
236: ; preds = %107, %85
%237 = load i32, i32* %20
%238 = add nsw i32 %237, 1
%239 = sext i32 %238 to i64
%240 = mul i64 8, %239
%241 = load i8*, i8** %21
%242 = load i8*, i8** %17
%243 = ptrtoint i8* %241 to i64
%244 = ptrtoint i8* %242 to i64
%245 = sub i64 %243, %244
%246 = add nsw i64 %245, 1
%247 = add i64 %240, %246
%248 = trunc i64 %247 to i32
%249 = call i64 @malloc(i32 %248)
%250 = inttoptr i64 %249 to i8**
store i8** %250, i8*** %19
%251 = load i8**, i8*** %19
%252 = icmp eq i8** %251, null
br i1 %252, label %253, label %255
253: ; preds = %236
%254 = load i8**, i8*** %19
store i8** %254, i8*** %8
br label %574
255: ; preds = %236
%256 = load i8**, i8*** %19
%257 = load i32, i32* %20
%258 = add nsw i32 %257, 1
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i8*, i8** %256, i64 %259
%261 = bitcast i8** %260 to i8*
store i8* %261, i8** %18
%262 = load i8*, i8** %17
store i8* %262, i8** %21
store i32 0, i32* %20
store i32 0, i32* %16
br label %263
263: ; preds = %501, %255
%264 = load i8*, i8** %21
%265 = load i8, i8* %264
%266 = icmp ne i8 %265, 0
br i1 %266, label %267, label %502
267: ; preds = %263
%268 = load i32, i32* %13
%269 = icmp ne i32 %268, 0
br i1 %269, label %306, label %270
270: ; preds = %267
store i8 0, i8* getelementptr inbounds ([256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 0)
%271 = load i32, i32* %12
%272 = icmp ne i32 %271, 0
br i1 %272, label %273, label %293
273: ; preds = %270
br label %274
274: ; preds = %289, %273
%275 = load i8*, i8** %21
%276 = load i8, i8* %275
%277 = zext i8 %276 to i64
%278 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %277
%279 = load i8, i8* %278
%280 = sext i8 %279 to i32
%281 = icmp ne i32 %280, 0
br i1 %281, label %287, label %282
282: ; preds = %274
%283 = load i8*, i8** %21
%284 = load i8, i8* %283
%285 = call i64 @isspace(i8 zeroext %284)
%286 = icmp ne i64 %285, 0
br label %287
287: ; preds = %282, %274
%288 = phi i1 [ true, %274 ], [ %286, %282 ]
br i1 %288, label %289, label %292
289: ; preds = %287
%290 = load i8*, i8** %21
%291 = getelementptr inbounds i8, i8* %290, i32 1
store i8* %291, i8** %21
br label %274
292: ; preds = %287
br label %305
293: ; preds = %270
br label %294
294: ; preds = %301, %293
%295 = load i8*, i8** %21
%296 = load i8, i8* %295
%297 = zext i8 %296 to i64
%298 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %297
%299 = load i8, i8* %298
%300 = icmp ne i8 %299, 0
br i1 %300, label %301, label %304
301: ; preds = %294
%302 = load i8*, i8** %21
%303 = getelementptr inbounds i8, i8* %302, i32 1
store i8* %303, i8** %21
br label %294
304: ; preds = %294
br label %305
305: ; preds = %304, %292
br label %320
306: ; preds = %267
%307 = load i32, i32* %12
%308 = icmp ne i32 %307, 0
br i1 %308, label %309, label %319
309: ; preds = %306
br label %310
310: ; preds = %315, %309
%311 = load i8*, i8** %21
%312 = load i8, i8* %311
%313 = call i64 @isspace(i8 zeroext %312)
%314 = icmp ne i64 %313, 0
br i1 %314, label %315, label %318
315: ; preds = %310
%316 = load i8*, i8** %21
%317 = getelementptr inbounds i8, i8* %316, i32 1
store i8* %317, i8** %21
br label %310
318: ; preds = %310
br label %319
319: ; preds = %318, %306
br label %320
320: ; preds = %319, %305
%321 = load i8*, i8** %21
%322 = load i8, i8* %321
%323 = icmp ne i8 %322, 0
br i1 %323, label %325, label %324
324: ; preds = %320
br label %502
325: ; preds = %320
%326 = load i8*, i8** %18
%327 = load i8**, i8*** %19
%328 = load i32, i32* %20
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i8*, i8** %327, i64 %329
store i8* %326, i8** %330
%331 = load i32, i32* %20
%332 = add nsw i32 %331, 1
store i32 %332, i32* %20
store i8 1, i8* getelementptr inbounds ([256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 0)
%333 = load i8*, i8** %18
%334 = getelementptr inbounds i8, i8* %333, i64 -1
store i8* %334, i8** %22
%335 = load i32, i32* %12
%336 = icmp eq i32 %335, 2
br i1 %336, label %337, label %425
337: ; preds = %325
br label %338
338: ; preds = %423, %337
%339 = load i8*, i8** %21
%340 = load i8, i8* %339
%341 = zext i8 %340 to i64
%342 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %341
%343 = load i8, i8* %342
%344 = icmp ne i8 %343, 0
%345 = xor i1 %344, true
br i1 %345, label %346, label %424
346: ; preds = %338
%347 = load i8*, i8** %21
%348 = load i8, i8* %347
%349 = zext i8 %348 to i32
%350 = icmp ne i32 %349, 34
br i1 %350, label %351, label %364
351: ; preds = %346
%352 = load i8*, i8** %21
%353 = load i8, i8* %352
%354 = call i64 @isspace(i8 zeroext %353)
%355 = icmp ne i64 %354, 0
br i1 %355, label %358, label %356
356: ; preds = %351
%357 = load i8*, i8** %18
store i8* %357, i8** %22
br label %358
358: ; preds = %356, %351
%359 = load i8*, i8** %21
%360 = getelementptr inbounds i8, i8* %359, i32 1
store i8* %360, i8** %21
%361 = load i8, i8* %359
%362 = load i8*, i8** %18
%363 = getelementptr inbounds i8, i8* %362, i32 1
store i8* %363, i8** %18
store i8 %361, i8* %362
br label %423
364: ; preds = %346
%365 = load i8*, i8** %21
%366 = getelementptr inbounds i8, i8* %365, i32 1
store i8* %366, i8** %21
%367 = load i8*, i8** %21
%368 = load i8, i8* %367
%369 = zext i8 %368 to i32
%370 = icmp eq i32 %369, 34
br i1 %370, label %371, label %384
371: ; preds = %364
%372 = load i8*, i8** %21
%373 = load i8, i8* %372
%374 = call i64 @isspace(i8 zeroext %373)
%375 = icmp ne i64 %374, 0
br i1 %375, label %378, label %376
376: ; preds = %371
%377 = load i8*, i8** %18
store i8* %377, i8** %22
br label %378
378: ; preds = %376, %371
%379 = load i8*, i8** %21
%380 = getelementptr inbounds i8, i8* %379, i32 1
store i8* %380, i8** %21
%381 = load i8, i8* %379
%382 = load i8*, i8** %18
%383 = getelementptr inbounds i8, i8* %382, i32 1
store i8* %383, i8** %18
store i8 %381, i8* %382
br label %422
384: ; preds = %364
br label %385
385: ; preds = %418, %384
%386 = load i8*, i8** %21
%387 = load i8, i8* %386
%388 = icmp ne i8 %387, 0
br i1 %388, label %389, label %419
389: ; preds = %385
%390 = load i8*, i8** %21
%391 = getelementptr inbounds i8, i8* %390, i64 0
%392 = load i8, i8* %391
%393 = zext i8 %392 to i32
%394 = icmp eq i32 %393, 34
br i1 %394, label %395, label %412
395: ; preds = %389
%396 = load i8*, i8** %21
%397 = getelementptr inbounds i8, i8* %396, i64 1
%398 = load i8, i8* %397
%399 = zext i8 %398 to i32
%400 = icmp eq i32 %399, 34
br i1 %400, label %401, label %408
401: ; preds = %395
%402 = load i8*, i8** %21
%403 = load i8, i8* %402
%404 = load i8*, i8** %18
%405 = getelementptr inbounds i8, i8* %404, i32 1
store i8* %405, i8** %18
store i8 %403, i8* %404
%406 = load i8*, i8** %21
%407 = getelementptr inbounds i8, i8* %406, i64 2
store i8* %407, i8** %21
br label %411
408: ; preds = %395
%409 = load i8*, i8** %21
%410 = getelementptr inbounds i8, i8* %409, i32 1
store i8* %410, i8** %21
br label %419
411: ; preds = %401
br label %418
412: ; preds = %389
%413 = load i8*, i8** %21
%414 = getelementptr inbounds i8, i8* %413, i32 1
store i8* %414, i8** %21
%415 = load i8, i8* %413
%416 = load i8*, i8** %18
%417 = getelementptr inbounds i8, i8* %416, i32 1
store i8* %417, i8** %18
store i8 %415, i8* %416
br label %418
418: ; preds = %412, %411
br label %385
419: ; preds = %408, %385
%420 = load i8*, i8** %18
%421 = getelementptr inbounds i8, i8* %420, i64 -1
store i8* %421, i8** %22
br label %422
422: ; preds = %419, %378
br label %423
423: ; preds = %422, %358
br label %338
424: ; preds = %338
br label %486
425: ; preds = %325
br label %426
426: ; preds = %479, %425
%427 = load i32, i32* %16
%428 = icmp ne i32 %427, 0
br i1 %428, label %437, label %429
429: ; preds = %426
%430 = load i8*, i8** %21
%431 = load i8, i8* %430
%432 = zext i8 %431 to i64
%433 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %432
%434 = load i8, i8* %433
%435 = icmp ne i8 %434, 0
%436 = xor i1 %435, true
br label %437
437: ; preds = %429, %426
%438 = phi i1 [ true, %426 ], [ %436, %429 ]
br i1 %438, label %439, label %485
439: ; preds = %437
%440 = load i8*, i8** %21
%441 = load i8, i8* %440
%442 = call i64 @isspace(i8 zeroext %441)
%443 = icmp ne i64 %442, 0
br i1 %443, label %446, label %444
444: ; preds = %439
%445 = load i8*, i8** %18
store i8* %445, i8** %22
br label %446
446: ; preds = %444, %439
%447 = load i8*, i8** %21
%448 = load i8, i8* %447
%449 = zext i8 %448 to i64
%450 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %449
%451 = load i8, i8* %450
%452 = icmp ne i8 %451, 0
br i1 %452, label %453, label %479
453: ; preds = %446
%454 = load i8*, i8** %21
%455 = load i8, i8* %454
%456 = icmp ne i8 %455, 0
br i1 %456, label %458, label %457
457: ; preds = %453
br label %485
458: ; preds = %453
%459 = load i8*, i8** %15
%460 = icmp ne i8* %459, null
br i1 %460, label %461, label %469
461: ; preds = %458
%462 = load i8*, i8** %21
%463 = load i8, i8* %462
%464 = zext i8 %463 to i64
%465 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.etable, i64 0, i64 %464
%466 = load i8, i8* %465
%467 = sext i8 %466 to i32
%468 = icmp ne i32 %467, 0
br i1 %468, label %472, label %475
469: ; preds = %458
%470 = load i32, i32* %16
%471 = icmp ne i32 %470, 0
br i1 %471, label %472, label %475
472: ; preds = %469, %461
%473 = load i32, i32* %16
%474 = add nsw i32 %473, -1
store i32 %474, i32* %16
br label %478
475: ; preds = %469, %461
%476 = load i32, i32* %16
%477 = add nsw i32 %476, 1
store i32 %477, i32* %16
br label %478
478: ; preds = %475, %472
br label %479
479: ; preds = %478, %446
%480 = load i8*, i8** %21
%481 = getelementptr inbounds i8, i8* %480, i32 1
store i8* %481, i8** %21
%482 = load i8, i8* %480
%483 = load i8*, i8** %18
%484 = getelementptr inbounds i8, i8* %483, i32 1
store i8* %484, i8** %18
store i8 %482, i8* %483
br label %426
485: ; preds = %457, %437
br label %486
486: ; preds = %485, %424
%487 = load i32, i32* %12
%488 = icmp ne i32 %487, 0
br i1 %488, label %489, label %492
489: ; preds = %486
%490 = load i8*, i8** %22
%491 = getelementptr inbounds i8, i8* %490, i64 1
store i8* %491, i8** %18
br label %492
492: ; preds = %489, %486
%493 = load i8*, i8** %18
%494 = getelementptr inbounds i8, i8* %493, i32 1
store i8* %494, i8** %18
store i8 0, i8* %493
%495 = load i8*, i8** %21
%496 = load i8, i8* %495
%497 = icmp ne i8 %496, 0
br i1 %497, label %498, label %501
498: ; preds = %492
%499 = load i8*, i8** %21
%500 = getelementptr inbounds i8, i8* %499, i32 1
store i8* %500, i8** %21
br label %501
501: ; preds = %498, %492
br label %263
502: ; preds = %324, %263
%503 = load i8*, i8** %10
store i8* %503, i8** %21
br label %504
504: ; preds = %508, %502
%505 = load i8*, i8** %21
%506 = load i8, i8* %505
%507 = icmp ne i8 %506, 0
br i1 %507, label %508, label %514
508: ; preds = %504
%509 = load i8*, i8** %21
%510 = getelementptr inbounds i8, i8* %509, i32 1
store i8* %510, i8** %21
%511 = load i8, i8* %509
%512 = zext i8 %511 to i64
%513 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %512
store i8 0, i8* %513
br label %504
514: ; preds = %504
%515 = load i8*, i8** %14
%516 = icmp ne i8* %515, null
br i1 %516, label %517, label %562
517: ; preds = %514
%518 = load i8*, i8** %14
store i8* %518, i8** %21
br label %519
519: ; preds = %523, %517
%520 = load i8*, i8** %21
%521 = load i8, i8* %520
%522 = icmp ne i8 %521, 0
br i1 %522, label %523, label %529
523: ; preds = %519
%524 = load i8*, i8** %21
%525 = getelementptr inbounds i8, i8* %524, i32 1
store i8* %525, i8** %21
%526 = load i8, i8* %524
%527 = zext i8 %526 to i64
%528 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %527
store i8 1, i8* %528
br label %519
529: ; preds = %519
%530 = load i8*, i8** %15
store i8* %530, i8** %21
%531 = load i8*, i8** %21
%532 = icmp ne i8* %531, null
br i1 %532, label %533, label %545
533: ; preds = %529
br label %534
534: ; preds = %538, %533
%535 = load i8*, i8** %21
%536 = load i8, i8* %535
%537 = icmp ne i8 %536, 0
br i1 %537, label %538, label %544
538: ; preds = %534
%539 = load i8*, i8** %21
%540 = getelementptr inbounds i8, i8* %539, i32 1
store i8* %540, i8** %21
%541 = load i8, i8* %539
%542 = zext i8 %541 to i64
%543 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %542
store i8 1, i8* %543
br label %534
544: ; preds = %534
br label %545
545: ; preds = %544, %529
%546 = load i8*, i8** %15
store i8* %546, i8** %21
%547 = load i8*, i8** %21
%548 = icmp ne i8* %547, null
br i1 %548, label %549, label %561
549: ; preds = %545
br label %550
550: ; preds = %554, %549
%551 = load i8*, i8** %21
%552 = load i8, i8* %551
%553 = icmp ne i8 %552, 0
br i1 %553, label %554, label %560
554: ; preds = %550
%555 = load i8*, i8** %21
%556 = getelementptr inbounds i8, i8* %555, i32 1
store i8* %556, i8** %21
%557 = load i8, i8* %555
%558 = zext i8 %557 to i64
%559 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.etable, i64 0, i64 %558
store i8 1, i8* %559
br label %550
560: ; preds = %550
br label %561
561: ; preds = %560, %545
br label %562
562: ; preds = %561, %514
%563 = load i32*, i32** %11
%564 = icmp ne i32* %563, null
br i1 %564, label %565, label %568
565: ; preds = %562
%566 = load i32, i32* %20
%567 = load i32*, i32** %11
store i32 %566, i32* %567
br label %568
568: ; preds = %565, %562
%569 = load i8**, i8*** %19
%570 = load i32, i32* %20
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds i8*, i8** %569, i64 %571
store i8* null, i8** %572
%573 = load i8**, i8*** %19
store i8** %573, i8*** %8
br label %574
574: ; preds = %568, %253
%575 = load i8**, i8*** %8
ret i8** %575
}

LLVM IR (-O2):
@stb_tokens_raw.stb_tokentable = internal unnamed_addr global [256 x i8] zeroinitializer
@stb_tokens_raw.stable = internal unnamed_addr global [256 x i8] zeroinitializer
@stb_tokens_raw.etable = internal unnamed_addr global [256 x i8] zeroinitializer
define i8** @stb_tokens_raw(i8* %0, i8* nocapture %1, i32* writeonly %2, i32 %3, i32 %4, i8* %5, i8* %6) {
%8 = load i8, i8* %1
%9 = icmp eq i8 %8, 0
br i1 %9, label %18, label %10
10: ; preds = %7, %10
%11 = phi i8 [ %16, %10 ], [ %8, %7 ]
%12 = phi i8* [ %13, %10 ], [ %1, %7 ]
%13 = getelementptr inbounds i8, i8* %12, i64 1
%14 = zext i8 %11 to i64
%15 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %14
store i8 1, i8* %15
%16 = load i8, i8* %13
%17 = icmp eq i8 %16, 0
br i1 %17, label %18, label %10
18: ; preds = %10, %7
%19 = icmp eq i8* %5, null
br i1 %19, label %53, label %20
20: ; preds = %18
%21 = load i8, i8* %5
%22 = icmp eq i8 %21, 0
br i1 %22, label %31, label %23
23: ; preds = %20, %23
%24 = phi i8 [ %29, %23 ], [ %21, %20 ]
%25 = phi i8* [ %26, %23 ], [ %5, %20 ]
%26 = getelementptr inbounds i8, i8* %25, i64 1
%27 = zext i8 %24 to i64
%28 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %27
store i8 1, i8* %28
%29 = load i8, i8* %26
%30 = icmp eq i8 %29, 0
br i1 %30, label %31, label %23
31: ; preds = %23, %20
%32 = icmp eq i8* %6, null
br i1 %32, label %53, label %33
33: ; preds = %31
%34 = load i8, i8* %6
%35 = icmp eq i8 %34, 0
br i1 %35, label %53, label %36
36: ; preds = %33, %36
%37 = phi i8 [ %42, %36 ], [ %34, %33 ]
%38 = phi i8* [ %39, %36 ], [ %6, %33 ]
%39 = getelementptr inbounds i8, i8* %38, i64 1
%40 = zext i8 %37 to i64
%41 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %40
store i8 1, i8* %41
%42 = load i8, i8* %39
%43 = icmp eq i8 %42, 0
br i1 %43, label %44, label %36
44: ; preds = %36
br i1 %35, label %53, label %45
45: ; preds = %44, %45
%46 = phi i8 [ %51, %45 ], [ %34, %44 ]
%47 = phi i8* [ %48, %45 ], [ %6, %44 ]
%48 = getelementptr inbounds i8, i8* %47, i64 1
%49 = zext i8 %46 to i64
%50 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.etable, i64 0, i64 %49
store i8 1, i8* %50
%51 = load i8, i8* %48
%52 = icmp eq i8 %51, 0
br i1 %52, label %53, label %45
53: ; preds = %45, %33, %44, %31, %18
store i8 1, i8* getelementptr inbounds ([256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 0)
%54 = load i8, i8* %0
%55 = icmp eq i8 %54, 0
br i1 %55, label %156, label %56
56: ; preds = %53
%57 = icmp eq i32 %4, 0
%58 = icmp eq i32 %3, 2
%59 = icmp eq i8* %6, null
br label %60
60: ; preds = %56, %152
%61 = phi i8* [ %0, %56 ], [ %154, %152 ]
%62 = phi i32 [ 0, %56 ], [ %77, %152 ]
%63 = phi i32 [ 0, %56 ], [ %145, %152 ]
br i1 %57, label %64, label %75
64: ; preds = %60
store i8 0, i8* getelementptr inbounds ([256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 0)
br label %65
65: ; preds = %65, %64
%66 = phi i8* [ %61, %64 ], [ %72, %65 ]
%67 = load i8, i8* %66
%68 = zext i8 %67 to i64
%69 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %68
%70 = load i8, i8* %69
%71 = icmp eq i8 %70, 0
%72 = getelementptr inbounds i8, i8* %66, i64 1
br i1 %71, label %73, label %65
73: ; preds = %65
%74 = icmp eq i8 %67, 0
br i1 %74, label %156, label %75
75: ; preds = %73, %60
%76 = phi i8* [ %61, %60 ], [ %66, %73 ]
%77 = add nuw nsw i32 %62, 1
store i8 1, i8* getelementptr inbounds ([256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 0)
br i1 %58, label %78, label %114
78: ; preds = %75
%79 = load i8, i8* %76
%80 = zext i8 %79 to i64
%81 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %80
%82 = load i8, i8* %81
%83 = icmp eq i8 %82, 0
br i1 %83, label %84, label %143
84: ; preds = %78, %107
%85 = phi i8 [ %109, %107 ], [ %79, %78 ]
%86 = phi i8* [ %108, %107 ], [ %76, %78 ]
%87 = icmp eq i8 %85, 34
%88 = getelementptr inbounds i8, i8* %86, i64 1
br i1 %87, label %89, label %107
89: ; preds = %84
%90 = load i8, i8* %88
%91 = icmp eq i8 %90, 34
br i1 %91, label %92, label %94
92: ; preds = %89
%93 = getelementptr inbounds i8, i8* %86, i64 2
br label %107
94: ; preds = %89, %101
%95 = phi i8 [ %104, %101 ], [ %90, %89 ]
%96 = phi i8* [ %103, %101 ], [ %88, %89 ]
switch i8 %95, label %101 [
i8 0, label %107
i8 34, label %97
]
97: ; preds = %94
%98 = getelementptr inbounds i8, i8* %96, i64 1
%99 = load i8, i8* %98
%100 = icmp eq i8 %99, 34
br i1 %100, label %101, label %105
101: ; preds = %94, %97
%102 = phi i64 [ 2, %97 ], [ 1, %94 ]
%103 = getelementptr inbounds i8, i8* %96, i64 %102
%104 = load i8, i8* %103
br label %94
105: ; preds = %97
%106 = getelementptr inbounds i8, i8* %96, i64 1
br label %107
107: ; preds = %94, %105, %84, %92
%108 = phi i8* [ %93, %92 ], [ %88, %84 ], [ %106, %105 ], [ %96, %94 ]
%109 = load i8, i8* %108
%110 = zext i8 %109 to i64
%111 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %110
%112 = load i8, i8* %111
%113 = icmp eq i8 %112, 0
br i1 %113, label %84, label %143
114: ; preds = %75, %140
%115 = phi i32 [ %141, %140 ], [ %63, %75 ]
%116 = phi i8* [ %142, %140 ], [ %76, %75 ]
%117 = icmp eq i32 %115, 0
%118 = load i8, i8* %116
%119 = zext i8 %118 to i64
br i1 %117, label %120, label %124
120: ; preds = %114
%121 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %119
%122 = load i8, i8* %121
%123 = icmp eq i8 %122, 0
br i1 %123, label %124, label %143
124: ; preds = %114, %120
%125 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %119
%126 = load i8, i8* %125
%127 = icmp eq i8 %126, 0
br i1 %127, label %140, label %128
128: ; preds = %124
%129 = icmp eq i8 %118, 0
br i1 %129, label %143, label %130
130: ; preds = %128
br i1 %59, label %135, label %131
131: ; preds = %130
%132 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.etable, i64 0, i64 %119
%133 = load i8, i8* %132
%134 = icmp eq i8 %133, 0
br i1 %134, label %138, label %136
135: ; preds = %130
br i1 %117, label %138, label %136
136: ; preds = %135, %131
%137 = add nsw i32 %115, -1
br label %140
138: ; preds = %135, %131
%139 = add nsw i32 %115, 1
br label %140
140: ; preds = %136, %138, %124
%141 = phi i32 [ %137, %136 ], [ %139, %138 ], [ %115, %124 ]
%142 = getelementptr inbounds i8, i8* %116, i64 1
br label %114
143: ; preds = %120, %128, %107, %78
%144 = phi i8 [ %79, %78 ], [ %109, %107 ], [ %118, %120 ], [ 0, %128 ]
%145 = phi i32 [ %63, %78 ], [ %63, %107 ], [ 0, %120 ], [ %115, %128 ]
%146 = phi i8* [ %76, %78 ], [ %108, %107 ], [ %116, %128 ], [ %116, %120 ]
br i1 %57, label %152, label %147
147: ; preds = %143
%148 = icmp ne i8 %144, 0
%149 = zext i1 %148 to i64
%150 = getelementptr i8, i8* %146, i64 %149
%151 = load i8, i8* %150
br label %152
152: ; preds = %147, %143
%153 = phi i8 [ %144, %143 ], [ %151, %147 ]
%154 = phi i8* [ %146, %143 ], [ %150, %147 ]
%155 = icmp eq i8 %153, 0
br i1 %155, label %156, label %60
156: ; preds = %152, %73, %53
%157 = phi i32 [ 0, %53 ], [ %62, %73 ], [ %77, %152 ]
%158 = phi i8* [ %0, %53 ], [ %66, %73 ], [ %154, %152 ]
%159 = add nuw nsw i32 %157, 1
%160 = zext i32 %159 to i64
%161 = shl nuw nsw i64 %160, 3
%162 = ptrtoint i8* %158 to i64
%163 = ptrtoint i8* %0 to i64
%164 = sub i64 1, %163
%165 = add i64 %164, %161
%166 = add i64 %165, %162
%167 = trunc i64 %166 to i32
%168 = tail call i64 @malloc(i32 %167)
%169 = inttoptr i64 %168 to i8**
%170 = icmp eq i64 %168, 0
br i1 %170, label %395, label %171
171: ; preds = %156
%172 = load i8, i8* %0
%173 = icmp eq i8 %172, 0
br i1 %173, label %343, label %174
174: ; preds = %171
%175 = getelementptr inbounds i8*, i8** %169, i64 %160
%176 = bitcast i8** %175 to i8*
%177 = icmp eq i32 %4, 0
%178 = icmp eq i32 %3, 0
%179 = icmp eq i32 %3, 2
%180 = icmp eq i8* %6, null
br label %181
181: ; preds = %174, %326
%182 = phi i8 [ %172, %174 ], [ %338, %326 ]
%183 = phi i64 [ 0, %174 ], [ %227, %326 ]
%184 = phi i8* [ %0, %174 ], [ %337, %326 ]
%185 = phi i8* [ %176, %174 ], [ %333, %326 ]
%186 = phi i32 [ 0, %174 ], [ %327, %326 ]
br i1 %177, label %187, label %208
187: ; preds = %181
store i8 0, i8* getelementptr inbounds ([256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 0)
br i1 %178, label %200, label %188
188: ; preds = %187, %198
%189 = phi i8* [ %199, %198 ], [ %184, %187 ]
%190 = load i8, i8* %189
%191 = zext i8 %190 to i64
%192 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %191
%193 = load i8, i8* %192
%194 = icmp eq i8 %193, 0
br i1 %194, label %195, label %198
195: ; preds = %188
%196 = tail call i64 @isspace(i8 zeroext %190)
%197 = icmp eq i64 %196, 0
br i1 %197, label %218, label %198
198: ; preds = %188, %195
%199 = getelementptr inbounds i8, i8* %189, i64 1
br label %188
200: ; preds = %187, %200
%201 = phi i8* [ %207, %200 ], [ %184, %187 ]
%202 = load i8, i8* %201
%203 = zext i8 %202 to i64
%204 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %203
%205 = load i8, i8* %204
%206 = icmp eq i8 %205, 0
%207 = getelementptr inbounds i8, i8* %201, i64 1
br i1 %206, label %221, label %200
208: ; preds = %181
br i1 %178, label %218, label %209
209: ; preds = %208
%210 = tail call i64 @isspace(i8 zeroext %182)
%211 = icmp eq i64 %210, 0
br i1 %211, label %218, label %212
212: ; preds = %209, %212
%213 = phi i8* [ %214, %212 ], [ %184, %209 ]
%214 = getelementptr inbounds i8, i8* %213, i64 1
%215 = load i8, i8* %214
%216 = tail call i64 @isspace(i8 zeroext %215)
%217 = icmp eq i64 %216, 0
br i1 %217, label %218, label %212
218: ; preds = %212, %195, %209, %208
%219 = phi i8* [ %184, %208 ], [ %184, %209 ], [ %189, %195 ], [ %214, %212 ]
%220 = load i8, i8* %219
br label %221
221: ; preds = %200, %218
%222 = phi i8 [ %220, %218 ], [ %202, %200 ]
%223 = phi i8* [ %219, %218 ], [ %201, %200 ]
%224 = icmp eq i8 %222, 0
br i1 %224, label %340, label %225
225: ; preds = %221
%226 = getelementptr inbounds i8*, i8** %169, i64 %183
store i8* %185, i8** %226
%227 = add nuw i64 %183, 1
store i8 1, i8* getelementptr inbounds ([256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 0)
%228 = getelementptr inbounds i8, i8* %185, i64 -1
br i1 %179, label %229, label %289
229: ; preds = %225
%230 = load i8, i8* %223
%231 = zext i8 %230 to i64
%232 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %231
%233 = load i8, i8* %232
%234 = icmp eq i8 %233, 0
br i1 %234, label %235, label %326
235: ; preds = %229, %280
%236 = phi i8 [ %284, %280 ], [ %230, %229 ]
%237 = phi i8* [ %283, %280 ], [ %228, %229 ]
%238 = phi i8* [ %282, %280 ], [ %223, %229 ]
%239 = phi i8* [ %281, %280 ], [ %185, %229 ]
%240 = icmp eq i8 %236, 34
br i1 %240, label %248, label %241
241: ; preds = %235
%242 = tail call i64 @isspace(i8 zeroext %236)
%243 = icmp eq i64 %242, 0
%244 = select i1 %243, i8* %239, i8* %237
%245 = getelementptr inbounds i8, i8* %238, i64 1
%246 = load i8, i8* %238
%247 = getelementptr inbounds i8, i8* %239, i64 1
store i8 %246, i8* %239
br label %280
248: ; preds = %235
%249 = getelementptr inbounds i8, i8* %238, i64 1
%250 = load i8, i8* %249
%251 = icmp eq i8 %250, 34
br i1 %251, label %252, label %259
252: ; preds = %248
%253 = tail call i64 @isspace(i8 zeroext 34)
%254 = icmp eq i64 %253, 0
%255 = select i1 %254, i8* %239, i8* %237
%256 = getelementptr inbounds i8, i8* %238, i64 2
%257 = load i8, i8* %249
%258 = getelementptr inbounds i8, i8* %239, i64 1
store i8 %257, i8* %239
br label %280
259: ; preds = %248, %271
%260 = phi i8 [ %274, %271 ], [ %250, %248 ]
%261 = phi i8* [ %273, %271 ], [ %239, %248 ]
%262 = phi i8* [ %272, %271 ], [ %249, %248 ]
switch i8 %260, label %269 [
i8 0, label %277
i8 34, label %263
]
263: ; preds = %259
%264 = getelementptr inbounds i8, i8* %262, i64 1
%265 = load i8, i8* %264
%266 = icmp eq i8 %265, 34
br i1 %266, label %267, label %275
267: ; preds = %263
store i8 34, i8* %261
%268 = getelementptr inbounds i8, i8* %262, i64 2
br label %271
269: ; preds = %259
%270 = getelementptr inbounds i8, i8* %262, i64 1
store i8 %260, i8* %261
br label %271
271: ; preds = %269, %267
%272 = phi i8* [ %268, %267 ], [ %270, %269 ]
%273 = getelementptr inbounds i8, i8* %261, i64 1
%274 = load i8, i8* %272
br label %259
275: ; preds = %263
%276 = getelementptr inbounds i8, i8* %262, i64 1
br label %277
277: ; preds = %259, %275
%278 = phi i8* [ %276, %275 ], [ %262, %259 ]
%279 = getelementptr inbounds i8, i8* %261, i64 -1
br label %280
280: ; preds = %252, %277, %241
%281 = phi i8* [ %247, %241 ], [ %258, %252 ], [ %261, %277 ]
%282 = phi i8* [ %245, %241 ], [ %256, %252 ], [ %278, %277 ]
%283 = phi i8* [ %244, %241 ], [ %255, %252 ], [ %279, %277 ]
%284 = load i8, i8* %282
%285 = zext i8 %284 to i64
%286 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %285
%287 = load i8, i8* %286
%288 = icmp eq i8 %287, 0
br i1 %288, label %235, label %326
289: ; preds = %225, %322
%290 = phi i32 [ %323, %322 ], [ %186, %225 ]
%291 = phi i8* [ %325, %322 ], [ %185, %225 ]
%292 = phi i8* [ %324, %322 ], [ %223, %225 ]
%293 = phi i8* [ %304, %322 ], [ %228, %225 ]
%294 = icmp eq i32 %290, 0
%295 = load i8, i8* %292
br i1 %294, label %296, label %301
296: ; preds = %289
%297 = zext i8 %295 to i64
%298 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %297
%299 = load i8, i8* %298
%300 = icmp eq i8 %299, 0
br i1 %300, label %301, label %326
301: ; preds = %289, %296
%302 = tail call i64 @isspace(i8 zeroext %295)
%303 = icmp eq i64 %302, 0
%304 = select i1 %303, i8* %291, i8* %293
%305 = load i8, i8* %292
%306 = zext i8 %305 to i64
%307 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %306
%308 = load i8, i8* %307
%309 = icmp eq i8 %308, 0
br i1 %309, label %322, label %310
310: ; preds = %301
%311 = icmp eq i8 %305, 0
br i1 %311, label %326, label %312
312: ; preds = %310
br i1 %180, label %317, label %313
313: ; preds = %312
%314 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.etable, i64 0, i64 %306
%315 = load i8, i8* %314
%316 = icmp eq i8 %315, 0
br i1 %316, label %320, label %318
317: ; preds = %312
br i1 %294, label %320, label %318
318: ; preds = %317, %313
%319 = add nsw i32 %290, -1
br label %322
320: ; preds = %317, %313
%321 = add nsw i32 %290, 1
br label %322
322: ; preds = %318, %320, %301
%323 = phi i32 [ %319, %318 ], [ %321, %320 ], [ %290, %301 ]
%324 = getelementptr inbounds i8, i8* %292, i64 1
%325 = getelementptr inbounds i8, i8* %291, i64 1
store i8 %305, i8* %291
br label %289
326: ; preds = %310, %296, %280, %229
%327 = phi i32 [ %186, %229 ], [ %186, %280 ], [ 0, %296 ], [ %290, %310 ]
%328 = phi i8* [ %185, %229 ], [ %281, %280 ], [ %291, %296 ], [ %291, %310 ]
%329 = phi i8* [ %223, %229 ], [ %282, %280 ], [ %292, %296 ], [ %292, %310 ]
%330 = phi i8* [ %228, %229 ], [ %283, %280 ], [ %293, %296 ], [ %304, %310 ]
%331 = getelementptr inbounds i8, i8* %330, i64 1
%332 = select i1 %178, i8* %328, i8* %331
%333 = getelementptr inbounds i8, i8* %332, i64 1
store i8 0, i8* %332
%334 = load i8, i8* %329
%335 = icmp ne i8 %334, 0
%336 = zext i1 %335 to i64
%337 = getelementptr i8, i8* %329, i64 %336
%338 = load i8, i8* %337
%339 = icmp eq i8 %338, 0
br i1 %339, label %340, label %181
340: ; preds = %221, %326
%341 = phi i64 [ %227, %326 ], [ %183, %221 ]
%342 = trunc i64 %341 to i32
br label %343
343: ; preds = %340, %171
%344 = phi i32 [ 0, %171 ], [ %342, %340 ]
%345 = load i8, i8* %1
%346 = icmp eq i8 %345, 0
br i1 %346, label %355, label %347
347: ; preds = %343, %347
%348 = phi i8 [ %353, %347 ], [ %345, %343 ]
%349 = phi i8* [ %350, %347 ], [ %1, %343 ]
%350 = getelementptr inbounds i8, i8* %349, i64 1
%351 = zext i8 %348 to i64
%352 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stb_tokentable, i64 0, i64 %351
store i8 0, i8* %352
%353 = load i8, i8* %350
%354 = icmp eq i8 %353, 0
br i1 %354, label %355, label %347
355: ; preds = %347, %343
br i1 %19, label %389, label %356
356: ; preds = %355
%357 = load i8, i8* %5
%358 = icmp eq i8 %357, 0
br i1 %358, label %367, label %359
359: ; preds = %356, %359
%360 = phi i8 [ %365, %359 ], [ %357, %356 ]
%361 = phi i8* [ %362, %359 ], [ %5, %356 ]
%362 = getelementptr inbounds i8, i8* %361, i64 1
%363 = zext i8 %360 to i64
%364 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %363
store i8 1, i8* %364
%365 = load i8, i8* %362
%366 = icmp eq i8 %365, 0
br i1 %366, label %367, label %359
367: ; preds = %359, %356
%368 = icmp eq i8* %6, null
br i1 %368, label %389, label %369
369: ; preds = %367
%370 = load i8, i8* %6
%371 = icmp eq i8 %370, 0
br i1 %371, label %389, label %372
372: ; preds = %369, %372
%373 = phi i8 [ %378, %372 ], [ %370, %369 ]
%374 = phi i8* [ %375, %372 ], [ %6, %369 ]
%375 = getelementptr inbounds i8, i8* %374, i64 1
%376 = zext i8 %373 to i64
%377 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.stable, i64 0, i64 %376
store i8 1, i8* %377
%378 = load i8, i8* %375
%379 = icmp eq i8 %378, 0
br i1 %379, label %380, label %372
380: ; preds = %372
br i1 %371, label %389, label %381
381: ; preds = %380, %381
%382 = phi i8 [ %387, %381 ], [ %370, %380 ]
%383 = phi i8* [ %384, %381 ], [ %6, %380 ]
%384 = getelementptr inbounds i8, i8* %383, i64 1
%385 = zext i8 %382 to i64
%386 = getelementptr inbounds [256 x i8], [256 x i8]* @stb_tokens_raw.etable, i64 0, i64 %385
store i8 1, i8* %386
%387 = load i8, i8* %384
%388 = icmp eq i8 %387, 0
br i1 %388, label %389, label %381
389: ; preds = %381, %369, %380, %367, %355
%390 = icmp eq i32* %2, null
br i1 %390, label %392, label %391
391: ; preds = %389
store i32 %344, i32* %2
br label %392
392: ; preds = %391, %389
%393 = zext i32 %344 to i64
%394 = getelementptr inbounds i8*, i8** %169, i64 %393
store i8* null, i8** %394
br label %395
395: ; preds = %156, %392
ret i8** %169
}