// File: /workspace/github_cpp_makefile_star2_O3/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
movl %r8d, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movq %rdx, %rbx
movq %rdi, %r13
movb (%rsi), %r12b
testb %r12b, %r12b
je 0x4169
leaq 0x1(%rsi), %rax
leaq 0x1bf6a(%rip), %rcx     # 0x200c0
movl %r12d, %edx
movzbl %dl, %edx
movb $0x1, (%rdx,%rcx)
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0x4159
movq 0x70(%rsp), %r15
testq %r9, %r9
je 0x41e0
movb (%r9), %al
testb %al, %al
je 0x4195
leaq 0x1(%r9), %rcx
leaq 0x1c03b(%rip), %rdx     # 0x201c0
movzbl %al, %eax
movb $0x1, (%rax,%rdx)
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x4185
testq %r15, %r15
je 0x41e0
movb (%r15), %al
testb %al, %al
je 0x41e0
leaq 0x1(%r15), %rcx
leaq 0x1c014(%rip), %rdx     # 0x201c0
movl %eax, %edi
movzbl %dil, %edi
movb $0x1, (%rdi,%rdx)
movb (%rcx), %dil
incq %rcx
testb %dil, %dil
jne 0x41ae
testb %al, %al
je 0x41e0
leaq 0x1(%r15), %rcx
leaq 0x1c0f0(%rip), %rdx     # 0x202c0
movzbl %al, %eax
movb $0x1, (%rax,%rdx)
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x41d0
movq %rsi, 0x20(%rsp)
movq %r9, 0x30(%rsp)
movb $0x1, 0x1bfcf(%rip)     # 0x201c0
movb (%r13), %bpl
testb %bpl, %bpl
je 0x4310
xorl %r14d, %r14d
leaq 0x1beb8(%rip), %rax     # 0x200c0
leaq 0x1bfb1(%rip), %rcx     # 0x201c0
leaq 0x1c0aa(%rip), %rdx     # 0x202c0
movq %r13, %rdi
xorl %esi, %esi
cmpl $0x0, 0xc(%rsp)
jne 0x4244
movb $0x0, 0x1be97(%rip)     # 0x200c0
decq %rdi
movzbl 0x1(%rdi), %r8d
incq %rdi
cmpb $0x0, (%r8,%rax)
jne 0x422c
testb %r8b, %r8b
je 0x430b
movb $0x1, 0x1be75(%rip)     # 0x200c0
cmpl $0x2, 0x8(%rsp)
jne 0x42ad
movzbl (%rdi), %r8d
cmpb $0x0, (%r8,%rax)
jne 0x42ed
leaq 0x1(%rdi), %r9
cmpb $0x22, %r8b
jne 0x42a8
movb (%r9), %r8b
cmpb $0x22, %r8b
jne 0x427a
addq $0x2, %rdi
jmp 0x4252
cmpb $0x22, %r8b
je 0x4290
movzbl %r8b, %r8d
movl $0x1, %edi
testl %r8d, %r8d
jne 0x429c
jmp 0x42a8
movl $0x2, %edi
cmpb $0x22, 0x1(%r9)
jne 0x42a5
movb (%r9,%rdi), %r8b
addq %rdi, %r9
jmp 0x427a
incq %r9
movq %r9, %rdi
jmp 0x4252
movb (%rdi), %r8b
movzbl %r8b, %r9d
testl %esi, %esi
jne 0x42bf
cmpb $0x0, (%r9,%rax)
jne 0x42eb
cmpb $0x0, (%r9,%rcx)
je 0x42e1
testb %r8b, %r8b
je 0x42e6
testq %r15, %r15
je 0x42db
cmpb $0x0, (%r9,%rdx)
je 0x42df
decl %esi
jmp 0x42e1
testl %esi, %esi
jne 0x42d7
incl %esi
incq %rdi
jmp 0x42ad
xorl %r8d, %r8d
jmp 0x42ed
xorl %esi, %esi
cmpl $0x0, 0xc(%rsp)
je 0x42ff
cmpb $0x1, %r8b
sbbq $-0x1, %rdi
movb (%rdi), %r8b
incl %r14d
testb %r8b, %r8b
jne 0x421b
incl %r14d
jmp 0x4319
movl $0x1, %r14d
movq %r13, %rdi
leaq (,%r14,8), %rax
subq %r13, %rax
addq %rax, %rdi
incq %rdi
callq 0x2250
testq %rax, %rax
je 0x464d
movq %rax, 0x10(%rsp)
testb %bpl, %bpl
je 0x457c
movq %rbx, 0x28(%rsp)
movq 0x10(%rsp), %rax
leaq (%rax,%r14,8), %r14
xorl %r12d, %r12d
leaq 0x1bd62(%rip), %rbp     # 0x200c0
xorl %r15d, %r15d
cmpl $0x0, 0xc(%rsp)
je 0x438b
cmpl $0x0, 0x8(%rsp)
je 0x43c2
callq 0x23b0
movq (%rax), %rax
decq %r13
movzbl 0x1(%r13), %ebx
incq %r13
testb $0x20, 0x1(%rax,%rbx,2)
jne 0x437a
jmp 0x43f9
movb $0x0, 0x1bd2e(%rip)     # 0x200c0
cmpl $0x0, 0x8(%rsp)
je 0x43e8
movq %r12, 0x18(%rsp)
movb (%r13), %bl
movzbl %bl, %r12d
cmpb $0x0, (%r12,%rbp)
jne 0x43bd
callq 0x23b0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r12,2)
je 0x43e1
incq %r13
jmp 0x439e
movq 0x10(%rsp), %rax
movq %r14, (%rax,%r12,8)
incq %r12
movb $0x1, 0x1bceb(%rip)     # 0x200c0
leaq -0x1(%r14), %rbp
movq %r12, %rcx
jmp 0x44cc
movq 0x18(%rsp), %r12
jmp 0x43f9
decq %r13
movzbl 0x1(%r13), %ebx
incq %r13
cmpb $0x0, (%rbx,%rbp)
jne 0x43eb
testb %bl, %bl
je 0x4586
leaq 0x1(%r12), %rcx
leaq -0x1(%r14), %rbp
movq 0x10(%rsp), %rax
movq %r14, (%rax,%r12,8)
movb $0x1, 0x1bca6(%rip)     # 0x200c0
cmpl $0x2, 0x8(%rsp)
jne 0x44cc
movq %rcx, 0x18(%rsp)
movb (%r13), %bl
movzbl %bl, %r12d
leaq 0x1bc87(%rip), %rax     # 0x200c0
cmpb $0x0, (%r12,%rax)
jne 0x4541
cmpb $0x22, %bl
jne 0x4472
movb 0x1(%r13), %al
cmpb $0x22, %al
jne 0x4492
callq 0x23b0
movq (%rax), %rax
movzwl 0x44(%rax), %eax
btl $0xd, %eax
cmovaeq %r14, %rbp
addq $0x2, %r13
movb $0x22, (%r14)
incq %r14
jmp 0x442a
callq 0x23b0
movq (%rax), %rax
movzwl (%rax,%r12,2), %eax
btl $0xd, %eax
cmovaeq %r14, %rbp
incq %r13
movb %bl, (%r14)
incq %r14
jmp 0x442a
incq %r13
cmpb $0x22, %al
je 0x44a8
movzbl %al, %ecx
testl %ecx, %ecx
je 0x44c3
incq %r13
movb %al, (%r14)
jmp 0x44b7
cmpb $0x22, 0x1(%r13)
jne 0x44c0
movb $0x22, (%r14)
addq $0x2, %r13
incq %r14
movb (%r13), %al
jmp 0x4495
incq %r13
leaq -0x1(%r14), %rbp
jmp 0x442a
movq %rcx, 0x18(%rsp)
movb (%r13), %bl
movzbl %bl, %r12d
testl %r15d, %r15d
jne 0x44ec
leaq 0x1bbdb(%rip), %rax     # 0x200c0
cmpb $0x0, (%r12,%rax)
jne 0x453e
callq 0x23b0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r12,2)
cmoveq %r14, %rbp
leaq 0x1bcbb(%rip), %rax     # 0x201c0
cmpb $0x0, (%r12,%rax)
je 0x4533
testb %bl, %bl
je 0x4541
cmpq $0x0, 0x70(%rsp)
je 0x452b
leaq 0x1bda1(%rip), %rax     # 0x202c0
cmpb $0x0, (%r12,%rax)
je 0x4530
decl %r15d
jmp 0x4533
testl %r15d, %r15d
jne 0x4526
incl %r15d
incq %r13
movb %bl, (%r14)
incq %r14
jmp 0x44d1
xorl %r15d, %r15d
incq %rbp
cmpl $0x0, 0x8(%rsp)
cmoveq %r14, %rbp
movb $0x0, (%rbp)
incq %rbp
cmpb $0x1, (%r13)
sbbq $-0x1, %r13
cmpb $0x0, (%r13)
movq 0x18(%rsp), %r8
movq %r8, %r12
movq %rbp, %r14
leaq 0x1bb4c(%rip), %rbp     # 0x200c0
jne 0x4361
jmp 0x4589
xorl %r8d, %r8d
movq 0x20(%rsp), %rsi
jmp 0x459b
movq %r12, %r8
movq 0x20(%rsp), %rsi
movb (%rsi), %r12b
movq 0x28(%rsp), %rbx
movq 0x70(%rsp), %r15
testb %r12b, %r12b
movq 0x30(%rsp), %rdx
movq 0x10(%rsp), %rdi
je 0x45c7
incq %rsi
leaq 0x1bb0c(%rip), %rax     # 0x200c0
movzbl %r12b, %ecx
movb $0x0, (%rcx,%rax)
movb (%rsi), %r12b
incq %rsi
testb %r12b, %r12b
jne 0x45b4
testq %rdx, %rdx
je 0x4637
movb (%rdx), %al
testb %al, %al
je 0x45ec
incq %rdx
leaq 0x1bbe4(%rip), %rcx     # 0x201c0
movzbl %al, %eax
movb $0x1, (%rax,%rcx)
movb (%rdx), %al
incq %rdx
testb %al, %al
jne 0x45dc
testq %r15, %r15
je 0x4637
movb (%r15), %al
testb %al, %al
je 0x4637
leaq 0x1(%r15), %rcx
leaq 0x1bbbd(%rip), %rdx     # 0x201c0
movl %eax, %esi
movzbl %sil, %esi
movb $0x1, (%rsi,%rdx)
movb (%rcx), %sil
incq %rcx
testb %sil, %sil
jne 0x4605
testb %al, %al
je 0x4637
incq %r15
leaq 0x1bc9a(%rip), %rcx     # 0x202c0
movzbl %al, %eax
movb $0x1, (%rax,%rcx)
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x4626
testq %rbx, %rbx
je 0x463f
movl %r8d, (%rbx)
movl %r8d, %eax
movq $0x0, (%rdi,%rax,8)
movq %rdi, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq