// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_tokens_raw
static 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]; // rely on static initializion to 0
   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;

   // two passes through: the first time, counting how many
   s = (unsigned char *) src;
   while (*s) {
      // state: just found delimiter
      // skip further delimiters
      if (!allow_empty) {
         stb_tokentable[0] = 0;
         while (stb_tokentable[*s])
            ++s;
         if (!*s) break;
      }
      ++num;
      // skip further non-delimiters
      stb_tokentable[0] = 1;
      if (stripwhite == 2) { // quoted strings
         while (!stb_tokentable[*s]) {
            if (*s != '"')
               ++s;
            else {
               ++s;
               if (*s == '"')
                  ++s;   // "" -> ", not start a string
               else {
                  // begin a string
                  while (*s) {
                     if (s[0] == '"') {
                        if (s[1] == '"') s += 2; // "" -> "
                        else { ++s; break; } // terminating "
                     } 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;
      }
   }
   // now num has the actual count... malloc our output structure
   // need space for all the strings: strings won't be any longer than
   // original input, since for every '\0' there's at least one delimiter
   result = (char **) malloc(sizeof(*result) * (num+1) + (s-src+1));
   if (result == NULL) return result;
   out = (char *) (result + (num+1));
   // second pass: copy out the data
   s = (unsigned char *) src;
   num = 0;
   nested = 0;
   while (*s) {
      char *last_nonwhite;
      // state: just found delimiter
      // skip further delimiters
      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;
      // we're past any leading delimiters and whitespace
      result[num] = out;
      ++num;
      // copy non-delimiters
      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++; // "" -> ", not start string
               } else {
                  // begin a quoted string
                  while (*s) {
                     if (s[0] == '"') {
                        if (s[1] == '"') { *out++ = *s; s += 2; }
                        else { ++s; break; } // terminating "
                     } else
                        *out++ = *s++;
                  }
                  last_nonwhite = out-1; // all in quotes counts as non-white
               }
            }
         }
      } 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) // rewind to last non-whitespace char
         out = last_nonwhite+1;
      *out++ = '\0';

      if (*s) ++s; // skip delimiter
   }
   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;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r15
movl %r8d, 0x14(%rsp)
movl %ecx, 0xc(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movb (%rsi), %al
testb %al, %al
je 0x42a4
leaq 0x1(%r12), %rcx
leaq 0x1be3c(%rip), %rdx     # 0x200d0
movzbl %al, %eax
movb $0x1, (%rax,%rdx)
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x4294
movq 0x70(%rsp), %rbp
testq %r15, %r15
je 0x431e
movb (%r15), %al
testb %al, %al
je 0x42d0
leaq 0x1(%r15), %rcx
leaq 0x1bf10(%rip), %rdx     # 0x201d0
movzbl %al, %eax
movb $0x1, (%rax,%rdx)
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x42c0
testq %rbp, %rbp
je 0x431e
movb (%rbp), %al
testb %al, %al
je 0x42f7
leaq 0x1(%rbp), %rcx
leaq 0x1bee9(%rip), %rdx     # 0x201d0
movzbl %al, %eax
movb $0x1, (%rax,%rdx)
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x42e7
testq %rbp, %rbp
je 0x431e
movb (%rbp), %al
testb %al, %al
je 0x431e
leaq 0x1(%rbp), %rcx
leaq 0x1bfc2(%rip), %rdx     # 0x202d0
movzbl %al, %eax
movb $0x1, (%rax,%rdx)
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x430e
movb $0x1, 0x1beab(%rip)     # 0x201d0
cmpb $0x0, (%r13)
je 0x4433
xorl %r14d, %r14d
leaq 0x1bd96(%rip), %rax     # 0x200d0
leaq 0x1be8f(%rip), %rcx     # 0x201d0
leaq 0x1bf88(%rip), %rdx     # 0x202d0
movq %r13, %rdi
xorl %esi, %esi
cmpl $0x0, 0x14(%rsp)
jne 0x4376
movb $0x0, 0x1bd75(%rip)     # 0x200d0
decq %rdi
movzbl 0x1(%rdi), %r8d
incq %rdi
cmpb $0x0, (%r8,%rax)
jne 0x435e
testb %r8b, %r8b
je 0x442e
movb $0x1, 0x1bd53(%rip)     # 0x200d0
cmpl $0x2, 0xc(%rsp)
jne 0x43d8
movzbl (%rdi), %r9d
cmpb $0x0, (%r9,%rax)
jne 0x4414
leaq 0x1(%rdi), %r8
cmpb $0x22, %r9b
jne 0x43d3
cmpb $0x22, (%r8)
jne 0x43a9
addq $0x2, %rdi
jmp 0x4384
movzbl (%r8), %r9d
cmpl $0x22, %r9d
je 0x43bf
movl $0x1, %edi
testl %r9d, %r9d
jne 0x43cb
jmp 0x43d3
movl $0x2, %edi
cmpb $0x22, 0x1(%r8)
jne 0x43d0
addq %rdi, %r8
jmp 0x43a9
incq %r8
movq %r8, %rdi
jmp 0x4384
testl %esi, %esi
jne 0x43e7
movzbl (%rdi), %r8d
cmpb $0x0, (%r8,%rax)
jne 0x4412
movzbl (%rdi), %r8d
cmpb $0x0, (%r8,%rcx)
je 0x440d
testq %r8, %r8
je 0x4414
testq %rbp, %rbp
je 0x4407
cmpb $0x0, (%r8,%rdx)
je 0x440b
decl %esi
jmp 0x440d
testl %esi, %esi
jne 0x4403
incl %esi
incq %rdi
jmp 0x43d8
xorl %esi, %esi
cmpl $0x0, 0x14(%rsp)
je 0x4422
cmpb $0x1, (%rdi)
sbbq $-0x1, %rdi
incl %r14d
cmpb $0x0, (%rdi)
jne 0x434d
incl %r14d
jmp 0x443c
movl $0x1, %r14d
movq %r13, %rdi
leaq (,%r14,8), %rax
subq %r13, %rax
addq %rax, %rdi
incq %rdi
callq 0x2250
testq %rax, %rax
je 0x473c
movq %r12, 0x20(%rsp)
movq %r15, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
leaq (%rax,%r14,8), %r12
xorl %r14d, %r14d
leaq 0x1bc58(%rip), %r15     # 0x200d0
movl $0x0, 0x10(%rsp)
movq %rax, %rbx
movq %rax, 0x18(%rsp)
cmpb $0x0, (%r13)
je 0x468c
cmpl $0x0, 0x14(%rsp)
je 0x44bd
cmpl $0x0, 0xc(%rsp)
je 0x4504
callq 0x23c0
movq (%rax), %rax
decq %r13
movzbl 0x1(%r13), %ecx
incq %r13
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x44ac
jmp 0x4504
movb $0x0, 0x1bc0c(%rip)     # 0x200d0
cmpl $0x0, 0xc(%rsp)
je 0x44f2
movzbl (%r13), %ebx
cmpb $0x0, (%rbx,%r15)
jne 0x44e6
callq 0x23c0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
je 0x44eb
incq %r13
jmp 0x44cb
movq 0x18(%rsp), %rbx
jmp 0x4504
decq %r13
movzbl 0x1(%r13), %eax
incq %r13
cmpb $0x0, (%rax,%r15)
jne 0x44f5
movb (%r13), %al
movb %al, 0xb(%rsp)
testb %al, %al
je 0x45d0
leaq -0x1(%r12), %r15
movslq 0x10(%rsp), %rax
movq %r12, (%rbx,%rax,8)
movb $0x1, 0x1bba7(%rip)     # 0x200d0
cmpl $0x2, 0xc(%rsp)
jne 0x45da
movb (%r13), %bl
movzbl %bl, %ebp
leaq 0x1bb8e(%rip), %rax     # 0x200d0
cmpb $0x0, (%rbp,%rax)
jne 0x4648
cmpb $0x22, %bl
jne 0x4575
movb 0x1(%r13), %bl
cmpb $0x22, %bl
jne 0x4595
callq 0x23c0
movq (%rax), %rax
movzwl 0x44(%rax), %eax
btl $0xd, %eax
cmovaeq %r12, %r15
addq $0x2, %r13
jmp 0x458c
callq 0x23c0
movq (%rax), %rax
movzwl (%rax,%rbp,2), %eax
btl $0xd, %eax
cmovaeq %r12, %r15
incq %r13
movb %bl, (%r12)
incq %r12
jmp 0x4534
incq %r13
movzbl (%r13), %eax
cmpl $0x22, %eax
je 0x45af
testl %eax, %eax
je 0x45c6
incq %r13
movb %al, (%r12)
jmp 0x45be
cmpb $0x22, 0x1(%r13)
jne 0x45c3
movb %al, (%r12)
addq $0x2, %r13
incq %r12
jmp 0x4598
incq %r13
leaq -0x1(%r12), %r15
jmp 0x4534
movq 0x70(%rsp), %rbp
jmp 0x4681
movq 0x70(%rsp), %rbp
testl %r14d, %r14d
jne 0x45f6
movzbl (%r13), %eax
leaq 0x1bae0(%rip), %rcx     # 0x200d0
cmpb $0x0, (%rax,%rcx)
jne 0x4654
callq 0x23c0
movq (%rax), %rcx
movzbl (%r13), %eax
testb $0x20, 0x1(%rcx,%rax,2)
cmoveq %r12, %r15
leaq 0x1bbbd(%rip), %rcx     # 0x201d0
cmpb $0x0, (%rax,%rcx)
je 0x463c
testb %al, %al
je 0x4657
testq %rbp, %rbp
je 0x4634
leaq 0x1bca7(%rip), %rcx     # 0x202d0
cmpb $0x0, (%rax,%rcx)
je 0x4639
decl %r14d
jmp 0x463c
testl %r14d, %r14d
jne 0x462f
incl %r14d
incq %r13
movb %al, (%r12)
incq %r12
jmp 0x45df
movq 0x70(%rsp), %rbp
movq 0x18(%rsp), %rbx
jmp 0x4657
xorl %r14d, %r14d
incl 0x10(%rsp)
incq %r15
cmpl $0x0, 0xc(%rsp)
cmoveq %r12, %r15
movb $0x0, (%r15)
incq %r15
cmpb $0x1, (%r13)
sbbq $-0x1, %r13
movq %r15, %r12
leaq 0x1ba4f(%rip), %r15     # 0x200d0
cmpb $0x0, 0xb(%rsp)
jne 0x4488
movq 0x20(%rsp), %rcx
movb (%rcx), %al
testb %al, %al
je 0x46ab
incq %rcx
movzbl %al, %eax
movb $0x0, (%rax,%r15)
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x469a
movq 0x28(%rsp), %rcx
testq %rcx, %rcx
movq 0x30(%rsp), %rdx
movl 0x10(%rsp), %esi
leaq 0x1bc0d(%rip), %rdi     # 0x202d0
leaq 0x1bb06(%rip), %r8      # 0x201d0
je 0x4727
movb (%rcx), %al
testb %al, %al
je 0x46e6
incq %rcx
movzbl %al, %eax
movb $0x1, (%rax,%r8)
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x46d5
testq %rbp, %rbp
je 0x4727
movb (%rbp), %al
testb %al, %al
je 0x4707
leaq 0x1(%rbp), %rcx
movzbl %al, %eax
movb $0x1, (%rax,%r8)
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x46f6
testq %rbp, %rbp
je 0x4727
movb (%rbp), %al
testb %al, %al
je 0x4727
incq %rbp
movzbl %al, %eax
movb $0x1, (%rax,%rdi)
movb (%rbp), %al
incq %rbp
testb %al, %al
jne 0x4716
testq %rdx, %rdx
je 0x472e
movl %esi, (%rdx)
movslq %esi, %rax
movq $0x0, (%rbx,%rax,8)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq