// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdx, 0x30(%rsp)
movq %rsi, %r12
movq %rdi, %r13
movq 0x70(%rsp), %r10
leaq 0x1a22a(%rip), %rbp     # 0x1e0c0
movq %rsi, %rax
movzbl (%rax), %edx
testq %rdx, %rdx
je 0x3eaa
incq %rax
movb $0x1, (%rdx,%rbp)
jmp 0x3e99
testq %r15, %r15
je 0x3efe
leaq 0x1a30a(%rip), %rax     # 0x1e1c0
movq %r15, %rsi
movzbl (%rsi), %edx
testq %rdx, %rdx
je 0x3eca
incq %rsi
movb $0x1, (%rdx,%rax)
jmp 0x3eb9
testq %r10, %r10
je 0x3efe
movq %r10, %rsi
movzbl (%rsi), %edx
testq %rdx, %rdx
je 0x3ee3
incq %rsi
movb $0x1, (%rdx,%rax)
jmp 0x3ed2
leaq 0x1a3d6(%rip), %rax     # 0x1e2c0
movq %r10, %rsi
movzbl (%rsi), %edx
testq %rdx, %rdx
je 0x3efe
incq %rsi
movb $0x1, (%rdx,%rax)
jmp 0x3eed
movb $0x1, 0x1a2bb(%rip)     # 0x1e1c0
xorl %edx, %edx
pushq $0x1
popq %rbx
pushq $0x2
popq %rsi
xorl %eax, %eax
movq %r13, %rdi
leaq 0x1a2a7(%rip), %r14     # 0x1e1c0
cmpb $0x0, (%rdi)
je 0x4019
testl %r8d, %r8d
jne 0x3f49
movb $0x0, 0x1a192(%rip)     # 0x1e0c0
decq %rdi
movzbl 0x1(%rdi), %r9d
incq %rdi
cmpb $0x0, (%r9,%rbp)
jne 0x3f31
testb %r9b, %r9b
je 0x4019
movb $0x1, 0x1a170(%rip)     # 0x1e0c0
cmpl $0x2, %ecx
jne 0x3fae
movq %rdi, %r9
movzbl (%rdi), %r11d
cmpb $0x0, (%r11,%rbp)
jne 0x3fee
leaq 0x1(%r9), %rdi
cmpb $0x22, %r11b
jne 0x3f55
movb (%rdi), %r11b
cmpb $0x22, %r11b
jne 0x3f83
addq $0x2, %r9
movq %r9, %rdi
jmp 0x3f55
cmpb $0x22, %r11b
je 0x3f97
movzbl %r11b, %r11d
movq %rbx, %r9
testl %r11d, %r11d
jne 0x3fa0
jmp 0x3f55
cmpb $0x22, 0x1(%rdi)
movq %rsi, %r9
jne 0x3fa9
movb (%rdi,%r9), %r11b
addq %r9, %rdi
jmp 0x3f83
incq %rdi
jmp 0x3f55
movb (%rdi), %r11b
movzbl %r11b, %r9d
testl %edx, %edx
jne 0x3fc0
cmpb $0x0, (%r9,%rbp)
jne 0x3ff8
cmpb $0x0, (%r9,%r14)
je 0x3fe9
testb %r11b, %r11b
je 0x3ff3
testq %r10, %r10
je 0x3fe3
leaq 0x1a2e8(%rip), %r11     # 0x1e2c0
cmpb $0x0, (%r9,%r11)
je 0x3fe7
decl %edx
jmp 0x3fe9
testl %edx, %edx
jne 0x3fdf
incl %edx
incq %rdi
jmp 0x3fae
movq %r9, %rdi
jmp 0x3ffa
xorl %r11d, %r11d
jmp 0x3ffa
xorl %edx, %edx
incl %eax
testl %r8d, %r8d
setne %r9b
testb %r11b, %r11b
setne %r11b
andb %r9b, %r11b
movzbl %r11b, %r9d
addq %r9, %rdi
jmp 0x3f19
movl %ecx, 0x4(%rsp)
movl %r8d, 0x14(%rsp)
movl %eax, %ebx
leaq 0x8(,%rbx,8), %rax
subq %r13, %rax
addq %rax, %rdi
incq %rdi
callq 0x2250
testq %rax, %rax
je 0x4316
movq %r12, 0x20(%rsp)
movq %r15, 0x28(%rsp)
incq %rbx
movq %rax, 0x18(%rsp)
leaq (%rax,%rbx,8), %r12
xorl %r14d, %r14d
xorl %r15d, %r15d
movl 0x14(%rsp), %eax
movl 0x4(%rsp), %ecx
cmpb $0x0, (%r13)
je 0x4284
testl %eax, %eax
je 0x4096
testl %ecx, %ecx
je 0x40ca
callq 0x23b0
movq (%rax), %rax
decq %r13
movzbl 0x1(%r13), %ebx
incq %r13
testb $0x20, 0x1(%rax,%rbx,2)
jne 0x4085
jmp 0x4104
movb $0x0, 0x1a023(%rip)     # 0x1e0c0
testl %ecx, %ecx
je 0x40f3
movq %r14, 0x8(%rsp)
movb (%r13), %bl
movzbl %bl, %r14d
cmpb $0x0, (%r14,%rbp)
jne 0x40c5
callq 0x23b0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
je 0x40ec
incq %r13
jmp 0x40a6
movq 0x18(%rsp), %rax
movq %r12, (%rax,%r14,8)
incq %r14
movb $0x1, 0x19fe3(%rip)     # 0x1e0c0
leaq -0x1(%r12), %rbp
movq %r14, 0x8(%rsp)
jmp 0x420b
movq 0x8(%rsp), %r14
jmp 0x4104
decq %r13
movzbl 0x1(%r13), %ebx
incq %r13
cmpb $0x0, (%rbx,%rbp)
jne 0x40f6
testb %bl, %bl
movl 0x4(%rsp), %eax
je 0x4284
leaq 0x1(%r14), %rcx
movq %rcx, 0x8(%rsp)
leaq -0x1(%r12), %rbp
movq 0x18(%rsp), %rcx
movq %r12, (%rcx,%r14,8)
movb $0x1, 0x19f92(%rip)     # 0x1e0c0
cmpl $0x2, %eax
jne 0x420b
movb (%r13), %bl
movzbl %bl, %r14d
leaq 0x19f7a(%rip), %rax     # 0x1e0c0
cmpb $0x0, (%r14,%rax)
jne 0x424f
cmpb $0x22, %bl
jne 0x4180
movb 0x1(%r13), %al
cmpb $0x22, %al
jne 0x41a1
callq 0x23b0
movq (%rax), %rax
movzwl 0x44(%rax), %eax
btl $0xd, %eax
cmovaeq %r12, %rbp
addq $0x2, %r13
movb $0x22, (%r12)
incq %r12
jmp 0x4137
callq 0x23b0
movq (%rax), %rax
movzwl (%rax,%r14,2), %eax
btl $0xd, %eax
cmovaeq %r12, %rbp
incq %r13
movb %bl, (%r12)
incq %r12
jmp 0x4137
incq %r13
cmpb $0x22, %al
je 0x41b8
movzbl %al, %ecx
testl %ecx, %ecx
je 0x41d4
incq %r13
movb %al, (%r12)
jmp 0x41c8
cmpb $0x22, 0x1(%r13)
jne 0x41d1
movb $0x22, (%r12)
addq $0x2, %r13
incq %r12
movb (%r13), %al
jmp 0x41a4
incq %r13
leaq -0x1(%r12), %rbp
jmp 0x4137
cmpq $0x0, 0x70(%rsp)
je 0x41f9
leaq 0x1a0d3(%rip), %rax     # 0x1e2c0
cmpb $0x0, (%r14,%rax)
je 0x41fe
decl %r15d
jmp 0x4201
testl %r15d, %r15d
jne 0x41f4
incl %r15d
incq %r13
movb %bl, (%r12)
incq %r12
movb (%r13), %bl
movzbl %bl, %r14d
testl %r15d, %r15d
jne 0x4226
leaq 0x19ea1(%rip), %rax     # 0x1e0c0
cmpb $0x0, (%r14,%rax)
jne 0x424c
callq 0x23b0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
cmoveq %r12, %rbp
leaq 0x19f81(%rip), %rax     # 0x1e1c0
cmpb $0x0, (%r14,%rax)
je 0x4201
testb %bl, %bl
jne 0x41de
jmp 0x424f
xorl %r15d, %r15d
movq 0x8(%rsp), %r14
incq %rbp
movl 0x4(%rsp), %ecx
testl %ecx, %ecx
cmoveq %r12, %rbp
movb $0x0, (%rbp)
incq %rbp
cmpb $0x1, (%r13)
sbbq $-0x1, %r13
movq %rbp, %r12
leaq 0x19e45(%rip), %rbp     # 0x1e0c0
movl 0x14(%rsp), %eax
jmp 0x4067
movq 0x30(%rsp), %rdx
movq 0x70(%rsp), %rsi
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %r8
movzbl (%rdi), %eax
testq %rax, %rax
je 0x42ae
incq %rdi
movb $0x0, (%rax,%rbp)
jmp 0x429d
testq %rcx, %rcx
je 0x4303
leaq 0x19f06(%rip), %rdi     # 0x1e1c0
movzbl (%rcx), %eax
testq %rax, %rax
je 0x42cb
incq %rcx
movb $0x1, (%rax,%rdi)
jmp 0x42ba
testq %rsi, %rsi
je 0x4303
movq %rsi, %rax
leaq 0x19ee6(%rip), %rdi     # 0x1e1c0
movzbl (%rax), %ecx
testq %rcx, %rcx
je 0x42eb
incq %rax
movb $0x1, (%rcx,%rdi)
jmp 0x42da
leaq 0x19fce(%rip), %rcx     # 0x1e2c0
movzbl (%rsi), %eax
testq %rax, %rax
je 0x4303
incq %rsi
movb $0x1, (%rax,%rcx)
jmp 0x42f2
testq %rdx, %rdx
je 0x430b
movl %r14d, (%rdx)
movl %r14d, %eax
andq $0x0, (%r8,%rax,8)
movq %r8, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq