// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__matcher_dfa
static int stb__matcher_dfa(stb_matcher *m, char *str_c, int *len)
{
   stb_uint8 *str = (stb_uint8 *) str_c;
   stb_int16 node,prevnode;
   stb_dfa *trans;
   int match_length = 0;
   stb_int16 match_result=0;

   if (m->dfa_start == STB__DFA_UNDEF) {
      stb_uint16 *list;

      m->num_words_per_dfa = (stb_arr_len(m->nodes)+31) >> 5;
      stb__optimize(m);

      list = stb__add_if_inactive(m, NULL, m->start_node);
      list = stb__eps_closure(m,list);
      if (m->does_lex) {
         m->dfa_start = stb__get_dfa_node(m,list);
         stb__clear(m, list);
         // DON'T allow start state to be a goal state!
         // this allows people to specify regexes that can match 0
         // characters without them actually matching (also we don't
         // check _before_ advancing anyway
         if (m->dfa_start <= STB__DFA_MGOAL)
            m->dfa_start = -(m->dfa_start - STB__DFA_MGOAL);
      } else {
         if (stb__clear_goalcheck(m, list))
            m->dfa_start = STB__DFA_GOAL;
         else
            m->dfa_start = stb__get_dfa_node(m,list);
      }
      stb_arr_free(list);
   }

   prevnode = STB__DFA_UNDEF;
   node = m->dfa_start;
   trans = m->dfa;

   if (m->dfa_start == STB__DFA_GOAL)
      return 1;

   for(;;) {
      assert(node >= STB__DFA_VALID);

      // fast inner DFA loop; especially if STB__DFA_VALID is 0

      do {
         prevnode = node;
         node = trans[node].transition[*str++];
      } while (node >= STB__DFA_VALID);

      assert(node >= STB__DFA_MGOAL - stb_arr_len(m->dfa));
      assert(node < stb_arr_len(m->dfa));

      // special case for lex: need _longest_ match, so notice goal
      // state without stopping
      if (node <= STB__DFA_MGOAL) {
         match_length = str - (stb_uint8 *) str_c;
         node = -(node - STB__DFA_MGOAL);
         match_result = node;
         continue;
      }

      // slow NFA->DFA conversion

      // or we hit the goal or the end of the string, but those
      // can only happen once per search...

      if (node == STB__DFA_UNDEF) {
         // build a list  -- @TODO special case <= 32 states
         // heck, use a more compact data structure for <= 16 and <= 8 ?!

         // @TODO keep states/newstates around instead of reallocating them
         stb_uint16 *states = NULL;
         stb_uint16 *newstates = NULL;
         int i,j,y,z;
         stb_uint32 *flags = &m->dfa_mapping[prevnode * m->num_words_per_dfa];
         assert(prevnode != STB__DFA_UNDEF);
         stb_arr_setsize(states, 4);
         stb_arr_setsize(newstates,4);
         for (j=0; j < m->num_words_per_dfa; ++j) {
            for (i=0; i < 32; ++i) {
               if (*flags & (1 << i))
                  stb_arr_push(states, j*32+i);
            }
            ++flags;
         }
         // states is now the states we were in in the previous node;
         // so now we can compute what node it transitions to on str[-1]

         y = stb_arr_len(states);
         for (i=0; i < y; ++i) {
            stb_nfa_node *n = &m->nodes[(int) states[i]];
            z = stb_arr_len(n->out);
            for (j=0; j < z; ++j) {
               if (n->out[j].match >= 0) {
                  if (n->out[j].match == str[-1] || (str[-1] == 0 && n->out[j].match == '\n'))
                     newstates = stb__add_if_inactive(m, newstates, n->out[j].node);
               } else if (n->out[j].match == -1) {
                  if (str[-1] != '\n' && str[-1])
                     newstates = stb__add_if_inactive(m, newstates, n->out[j].node);
               } else if (n->out[j].match < -1) {
                  int z = -n->out[j].match - 2;
                  if (m->charset[str[-1]] & (1 << z))
                     newstates = stb__add_if_inactive(m, newstates, n->out[j].node);
               }
            }
         }
         // AND add in the start state!
         if (!m->match_start || (str[-1] == '\n' && !m->does_lex))
            newstates = stb__add_if_inactive(m, newstates, m->start_node);
         // AND epsilon close it
         newstates = stb__eps_closure(m, newstates);
         // if it's a goal state, then that's all there is to it
         if (stb__clear_goalcheck(m, newstates)) {
            if (m->does_lex) {
               match_length = str - (stb_uint8 *) str_c;
               node = stb__get_dfa_node(m,newstates);
               match_result = node;
               node = -node + STB__DFA_MGOAL;
               trans = m->dfa; // could have gotten realloc()ed
            } else
               node = STB__DFA_GOAL;
         } else if (str[-1] == 0 || stb_arr_len(newstates) == 0) {
            node = STB__DFA_END;
         } else {
            node = stb__get_dfa_node(m,newstates);
            trans = m->dfa; // could have gotten realloc()ed
         }
         trans[prevnode].transition[str[-1]] = node;
         if (node <= STB__DFA_MGOAL)
            node = -(node - STB__DFA_MGOAL);
         stb_arr_free(newstates);
         stb_arr_free(states);
      }

      if (node == STB__DFA_GOAL) {
         return 1;
      }
      if (node == STB__DFA_END) {
         if (m->does_lex) {
            if (match_result) {
               if (len) *len = match_length;
               return m->dfa_result[(int) match_result];
            }
         }
         return 0;
      }

      assert(node != STB__DFA_UNDEF);
   }
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x90(%rsp)
movl $0x0, 0x7c(%rsp)
movw $0x0, 0x7a(%rsp)
movq 0xa8(%rsp), %rax
movswl 0x2(%rax), %eax
cmpl $-0x1, %eax
jne 0x187a3
movq 0xa8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x18677
movq 0xa8(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x38(%rsp)
jmp 0x1867f
xorl %eax, %eax
movl %eax, 0x38(%rsp)
jmp 0x1867f
movl 0x38(%rsp), %ecx
addl $0x1f, %ecx
sarl $0x5, %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x40(%rax)
movq 0xa8(%rsp), %rdi
callq 0x1e660
movq 0xa8(%rsp), %rdi
movq 0xa8(%rsp), %rax
movzwl (%rax), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x17ca0
movq %rax, 0x70(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x17dc0
movq %rax, 0x70(%rsp)
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x20(%rax)
je 0x1874f
movq 0xa8(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x17f70
movw %ax, %cx
movq 0xa8(%rsp), %rax
movw %cx, 0x2(%rax)
movq 0xa8(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x17ef0
movq 0xa8(%rsp), %rax
movswl 0x2(%rax), %eax
cmpl $-0x4, %eax
jg 0x1874d
movq 0xa8(%rsp), %rax
movswl 0x2(%rax), %ecx
subl $-0x4, %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, %cx
movq 0xa8(%rsp), %rax
movw %cx, 0x2(%rax)
jmp 0x18799
movq 0xa8(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x1e800
cmpl $0x0, %eax
je 0x18776
movq 0xa8(%rsp), %rax
movw $0xfffe, 0x2(%rax)      # imm = 0xFFFE
jmp 0x18797
movq 0xa8(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x17f70
movw %ax, %cx
movq 0xa8(%rsp), %rax
movw %cx, 0x2(%rax)
jmp 0x18799
leaq 0x70(%rsp), %rdi
callq 0x7d20
movw $0xffff, 0x8c(%rsp)     # imm = 0xFFFF
movq 0xa8(%rsp), %rax
movw 0x2(%rax), %ax
movw %ax, 0x8e(%rsp)
movq 0xa8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0xa8(%rsp), %rax
movswl 0x2(%rax), %eax
cmpl $-0x2, %eax
jne 0x187f6
movl $0x1, 0xb4(%rsp)
jmp 0x19080
jmp 0x187f8
movswl 0x8e(%rsp), %eax
cmpl $0x0, %eax
jl 0x18807
jmp 0x18826
leaq 0x7978(%rip), %rdi      # 0x20186
leaq 0x6b74(%rip), %rsi      # 0x1f389
movl $0x25e8, %edx           # imm = 0x25E8
leaq 0x797c(%rip), %rcx      # 0x2019d
callq 0x2140
jmp 0x18828
movw 0x8e(%rsp), %ax
movw %ax, 0x8c(%rsp)
movq 0x80(%rsp), %rax
movswq 0x8e(%rsp), %rcx
shlq $0x9, %rcx
addq %rcx, %rax
movq 0x90(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x90(%rsp)
movzbl (%rcx), %ecx
movw (%rax,%rcx,2), %ax
movw %ax, 0x8e(%rsp)
movswl 0x8e(%rsp), %eax
cmpl $0x0, %eax
jge 0x18828
movswl 0x8e(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0xa8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x188b3
movq 0xa8(%rsp), %rax
movq 0x28(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x30(%rsp)
jmp 0x188bb
xorl %eax, %eax
movl %eax, 0x30(%rsp)
jmp 0x188bb
movl 0x34(%rsp), %eax
movl 0x30(%rsp), %edx
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
subl %edx, %ecx
cmpl %ecx, %eax
jl 0x188d0
jmp 0x188ef
leaq 0x78f9(%rip), %rdi      # 0x201d0
leaq 0x6aab(%rip), %rsi      # 0x1f389
movl $0x25f1, %edx           # imm = 0x25F1
leaq 0x78b3(%rip), %rcx      # 0x2019d
callq 0x2140
movswl 0x8e(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0xa8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1891f
movq 0xa8(%rsp), %rax
movq 0x28(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x28(%rsp)
jmp 0x18927
xorl %eax, %eax
movl %eax, 0x28(%rsp)
jmp 0x18927
movl 0x2c(%rsp), %eax
movl 0x28(%rsp), %ecx
cmpl %ecx, %eax
jge 0x18935
jmp 0x18954
leaq 0x78c1(%rip), %rdi      # 0x201fd
leaq 0x6a46(%rip), %rsi      # 0x1f389
movl $0x25f2, %edx           # imm = 0x25F2
leaq 0x784e(%rip), %rcx      # 0x2019d
callq 0x2140
movswl 0x8e(%rsp), %eax
cmpl $-0x4, %eax
jg 0x189a1
movq 0x90(%rsp), %rax
movq 0xa0(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x7c(%rsp)
movswl 0x8e(%rsp), %ecx
subl $-0x4, %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, 0x8e(%rsp)
movw 0x8e(%rsp), %ax
movw %ax, 0x7a(%rsp)
jmp 0x187f8
movswl 0x8e(%rsp), %eax
cmpl $-0x1, %eax
jne 0x18fc4
movq $0x0, 0x68(%rsp)
movq $0x0, 0x60(%rsp)
movq 0xa8(%rsp), %rax
movq 0x30(%rax), %rax
movswl 0x8c(%rsp), %ecx
movq 0xa8(%rsp), %rdx
imull 0x40(%rdx), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x48(%rsp)
movswl 0x8c(%rsp), %eax
cmpl $-0x1, %eax
je 0x18a02
jmp 0x18a21
leaq 0x780f(%rip), %rdi      # 0x20218
leaq 0x6979(%rip), %rsi      # 0x1f389
movl $0x260b, %edx           # imm = 0x260B
leaq 0x7781(%rip), %rcx      # 0x2019d
callq 0x2140
leaq 0x68(%rsp), %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x7d80
leaq 0x60(%rsp), %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x7d80
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
movq 0xa8(%rsp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x18b8d
movl $0x0, 0x5c(%rsp)
cmpl $0x20, 0x5c(%rsp)
jge 0x18b6f
movq 0x48(%rsp), %rax
movl (%rax), %eax
movl 0x5c(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x18b5d
movl 0x58(%rsp), %eax
shll $0x5, %eax
addl 0x5c(%rsp), %eax
movw %ax, 0x26(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x18abe
movq 0x68(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0x20(%rsp)
jmp 0x18ac6
xorl %eax, %eax
movl %eax, 0x20(%rsp)
jmp 0x18ac6
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x18ae7
movq 0x68(%rsp), %rax
movl -0xc(%rax), %eax
movl %eax, 0x18(%rsp)
jmp 0x18aef
xorl %eax, %eax
movl %eax, 0x18(%rsp)
jmp 0x18aef
movl 0x1c(%rsp), %eax
movl 0x18(%rsp), %ecx
cmpl %ecx, %eax
jle 0x18b11
leaq 0x68(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x8030
jmp 0x18b1f
movq 0x68(%rsp), %rax
movl -0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x18b3f
movq 0x68(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x18b47
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x18b47
movq 0x10(%rsp), %rax
movw 0x26(%rsp), %dx
movl 0xc(%rsp), %ecx
movslq %ecx, %rcx
movw %dx, -0x2(%rax,%rcx,2)
jmp 0x18b5f
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x18a6e
movq 0x48(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x48(%rsp)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x18a51
cmpq $0x0, 0x68(%rsp)
je 0x18ba3
movq 0x68(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x18bab
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x18bab
movl 0x8(%rsp), %eax
movl %eax, 0x54(%rsp)
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
cmpl 0x54(%rsp), %eax
jge 0x18de5
movq 0xa8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x68(%rsp), %rcx
movslq 0x5c(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x18c10
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x18c18
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x18c18
movl 0x4(%rsp), %eax
movl %eax, 0x50(%rsp)
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x50(%rsp), %eax
jge 0x18dd3
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x58(%rsp), %rcx
movswl (%rax,%rcx,4), %eax
cmpl $0x0, %eax
jl 0x18cc6
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x58(%rsp), %rcx
movswl (%rax,%rcx,4), %eax
movq 0x90(%rsp), %rcx
movzbl -0x1(%rcx), %ecx
cmpl %ecx, %eax
je 0x18c97
movq 0x90(%rsp), %rax
movzbl -0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x18cc1
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x58(%rsp), %rcx
movswl (%rax,%rcx,4), %eax
cmpl $0xa, %eax
jne 0x18cc1
movq 0xa8(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x58(%rsp), %rcx
movzwl 0x2(%rax,%rcx,4), %edx
callq 0x17ca0
movq %rax, 0x60(%rsp)
jmp 0x18dc1
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x58(%rsp), %rcx
movswl (%rax,%rcx,4), %eax
cmpl $-0x1, %eax
jne 0x18d2e
movq 0x90(%rsp), %rax
movzbl -0x1(%rax), %eax
cmpl $0xa, %eax
je 0x18d29
movq 0x90(%rsp), %rax
movzbl -0x1(%rax), %eax
cmpl $0x0, %eax
je 0x18d29
movq 0xa8(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x58(%rsp), %rcx
movzwl 0x2(%rax,%rcx,4), %edx
callq 0x17ca0
movq %rax, 0x60(%rsp)
jmp 0x18dbf
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x58(%rsp), %rcx
movswl (%rax,%rcx,4), %eax
cmpl $-0x1, %eax
jge 0x18dbd
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x58(%rsp), %rcx
movswl (%rax,%rcx,4), %ecx
xorl %eax, %eax
subl %ecx, %eax
subl $0x2, %eax
movl %eax, 0x3c(%rsp)
movq 0xa8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x90(%rsp), %rcx
movzbl -0x1(%rcx), %ecx
movl (%rax,%rcx,4), %eax
movl 0x3c(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x18dbb
movq 0xa8(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x58(%rsp), %rcx
movzwl 0x2(%rax,%rcx,4), %edx
callq 0x17ca0
movq %rax, 0x60(%rsp)
jmp 0x18dbd
jmp 0x18dbf
jmp 0x18dc1
jmp 0x18dc3
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x18c28
jmp 0x18dd5
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x18bbb
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x14(%rax)
je 0x18e12
movq 0x90(%rsp), %rax
movzbl -0x1(%rax), %eax
cmpl $0xa, %eax
jne 0x18e34
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x18e34
movq 0xa8(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0xa8(%rsp), %rax
movzwl (%rax), %edx
callq 0x17ca0
movq %rax, 0x60(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x17dc0
movq %rax, 0x60(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x1e800
cmpl $0x0, %eax
je 0x18eeb
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x20(%rax)
je 0x18edf
movq 0x90(%rsp), %rax
movq 0xa0(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x7c(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x17f70
movw %ax, 0x8e(%rsp)
movw 0x8e(%rsp), %ax
movw %ax, 0x7a(%rsp)
movswl 0x8e(%rsp), %ecx
xorl %eax, %eax
subl %ecx, %eax
addl $-0x4, %eax
movw %ax, 0x8e(%rsp)
movq 0xa8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x80(%rsp)
jmp 0x18ee9
movw $0xfffe, 0x8e(%rsp)     # imm = 0xFFFE
jmp 0x18f5c
movq 0x90(%rsp), %rax
movzbl -0x1(%rax), %eax
cmpl $0x0, %eax
je 0x18f20
cmpq $0x0, 0x60(%rsp)
je 0x18f11
movq 0x60(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, (%rsp)
jmp 0x18f18
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x18f18
movl (%rsp), %eax
cmpl $0x0, %eax
jne 0x18f2c
movw $0xfffd, 0x8e(%rsp)     # imm = 0xFFFD
jmp 0x18f5a
movq 0xa8(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x17f70
movw %ax, 0x8e(%rsp)
movq 0xa8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x80(%rsp)
jmp 0x18f5c
movw 0x8e(%rsp), %dx
movq 0x80(%rsp), %rax
movswq 0x8c(%rsp), %rcx
shlq $0x9, %rcx
addq %rcx, %rax
movq 0x90(%rsp), %rcx
movzbl -0x1(%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movswl 0x8e(%rsp), %eax
cmpl $-0x4, %eax
jg 0x18fb0
movswl 0x8e(%rsp), %ecx
subl $-0x4, %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, 0x8e(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x7d20
leaq 0x68(%rsp), %rdi
callq 0x7d20
movswl 0x8e(%rsp), %eax
cmpl $-0x2, %eax
jne 0x18fe1
movl $0x1, 0xb4(%rsp)
jmp 0x19080
movswl 0x8e(%rsp), %eax
cmpl $-0x3, %eax
jne 0x1904d
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x20(%rax)
je 0x19040
cmpw $0x0, 0x7a(%rsp)
je 0x1903e
cmpq $0x0, 0x98(%rsp)
je 0x1901d
movl 0x7c(%rsp), %ecx
movq 0x98(%rsp), %rax
movl %ecx, (%rax)
movq 0xa8(%rsp), %rax
movq 0x38(%rax), %rax
movswl 0x7a(%rsp), %ecx
movslq %ecx, %rcx
movswl (%rax,%rcx,2), %eax
movl %eax, 0xb4(%rsp)
jmp 0x19080
jmp 0x19040
movl $0x0, 0xb4(%rsp)
jmp 0x19080
movswl 0x8e(%rsp), %eax
cmpl $-0x1, %eax
je 0x1905c
jmp 0x1907b
leaq 0x71b9(%rip), %rdi      # 0x2021c
leaq 0x631f(%rip), %rsi      # 0x1f389
movl $0x2653, %edx           # imm = 0x2653
leaq 0x7127(%rip), %rcx      # 0x2019d
callq 0x2140
jmp 0x187f8
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nop