// File: tap3edit[P]tap3xml/asn1_parser.cpp
// Function: yysyntax_error(unsigned long*, char**, short*, int)
static int
yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                yytype_int16 *yyssp, int yytoken)
{
  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
  YYSIZE_T yysize = yysize0;
  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
  /* Internationalized format string. */
  const char *yyformat = YY_NULLPTR;
  /* Arguments of yyformat. */
  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
  /* Number of reported tokens (one for the "unexpected", one per
     "expected"). */
  int yycount = 0;

  /* There are many possibilities here to consider:
     - If this state is a consistent state with a default action, then
       the only way this function was invoked is if the default action
       is an error action.  In that case, don't check for expected
       tokens because there are none.
     - The only way there can be no lookahead present (in yychar) is if
       this state is a consistent state with a default action.  Thus,
       detecting the absence of a lookahead is sufficient to determine
       that there is no unexpected or expected token to report.  In that
       case, just report a simple "syntax error".
     - Don't assume there isn't a lookahead just because this state is a
       consistent state with a default action.  There might have been a
       previous inconsistent state, consistent state with a non-default
       action, or user semantic action that manipulated yychar.
     - Of course, the expected token list depends on states to have
       correct lookahead information, and it depends on the parser not
       to perform extra reductions after fetching a lookahead from the
       scanner and before detecting a syntax error.  Thus, state merging
       (from LALR or IELR) and default reductions corrupt the expected
       token list.  However, the list is correct for canonical LR with
       one exception: it will still contain any token that will not be
       accepted due to an error action in a later state.
  */
  if (yytoken != YYEMPTY)
    {
      int yyn = yypact[*yyssp];
      yyarg[yycount++] = yytname[yytoken];
      if (!yypact_value_is_default (yyn))
        {
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  In other words, skip the first -YYN actions for
             this state because they are default actions.  */
          int yyxbegin = yyn < 0 ? -yyn : 0;
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn + 1;
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          int yyx;

          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
                && !yytable_value_is_error (yytable[yyx + yyn]))
              {
                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
                  {
                    yycount = 1;
                    yysize = yysize0;
                    break;
                  }
                yyarg[yycount++] = yytname[yyx];
                {
                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
                  if (! (yysize <= yysize1
                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
                    return 2;
                  yysize = yysize1;
                }
              }
        }
    }

  switch (yycount)
    {
# define YYCASE_(N, S)                      \
      case N:                               \
        yyformat = S;                       \
      break
      YYCASE_(0, YY_("syntax error"));
      YYCASE_(1, YY_("syntax error, unexpected %s"));
      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
# undef YYCASE_
    }

  {
    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
      return 2;
    yysize = yysize1;
  }

  if (*yymsg_alloc < yysize)
    {
      *yymsg_alloc = 2 * yysize;
      if (! (yysize <= *yymsg_alloc
             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
      return 1;
    }

  /* Avoid sprintf, as that infringes on the user's name space.
     Don't have undefined behavior even if the translation
     produced a string with the wrong number of "%s"s.  */
  {
    char *yyp = *yymsg;
    int yyi = 0;
    while ((*yyp = *yyformat) != '\0')
      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
        {
          yyp += yytnamerr (yyp, yyarg[yyi++]);
          yyformat += 2;
        }
      else
        {
          yyp++;
          yyformat++;
        }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x2202b(%rip), %rax     # 0x30b50
movq (%rax,%rcx,8), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xefb0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x74(%rbp)
cmpl $-0x2, -0x24(%rbp)
je 0xed01
movq -0x20(%rbp), %rax
movswq (%rax), %rcx
leaq 0x162ca(%rip), %rax     # 0x24e30
movsbl (%rax,%rcx), %eax
movl %eax, -0x78(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x21fd8(%rip), %rax     # 0x30b50
movq (%rax,%rcx,8), %rcx
movl -0x74(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x74(%rbp)
cltq
movq %rcx, -0x70(%rbp,%rax,8)
cmpl $-0x15, -0x78(%rbp)
je 0xecff
cmpl $0x0, -0x78(%rbp)
jge 0xebab
xorl %eax, %eax
subl -0x78(%rbp), %eax
movl %eax, -0xa8(%rbp)
jmp 0xebb5
xorl %eax, %eax
movl %eax, -0xa8(%rbp)
jmp 0xebb5
movl -0xa8(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl $0x2f, %eax
subl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x80(%rbp)
cmpl $0x16, -0x80(%rbp)
jge 0xebdd
movl -0x80(%rbp), %eax
movl %eax, -0xac(%rbp)
jmp 0xebea
movl $0x16, %eax
movl %eax, -0xac(%rbp)
jmp 0xebea
movl -0xac(%rbp), %eax
movl %eax, -0x84(%rbp)
movl -0x7c(%rbp), %eax
movl %eax, -0x88(%rbp)
movl -0x88(%rbp), %eax
cmpl -0x84(%rbp), %eax
jge 0xecfd
movl -0x88(%rbp), %eax
addl -0x78(%rbp), %eax
movslq %eax, %rcx
leaq 0x1636c(%rip), %rax     # 0x24f90
movzbl (%rax,%rcx), %eax
cmpl -0x88(%rbp), %eax
jne 0xece7
cmpl $0x1, -0x88(%rbp)
je 0xece7
cmpl $0x5, -0x74(%rbp)
jne 0xec5b
movl $0x1, -0x74(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xecfd
movslq -0x88(%rbp), %rcx
leaq 0x21ee7(%rip), %rax     # 0x30b50
movq (%rax,%rcx,8), %rcx
movl -0x74(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x74(%rbp)
cltq
movq %rcx, -0x70(%rbp,%rax,8)
movq -0x38(%rbp), %rax
movq %rax, -0xb8(%rbp)
movslq -0x88(%rbp), %rcx
leaq 0x21eb8(%rip), %rax     # 0x30b50
movq (%rax,%rcx,8), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xefb0
movq %rax, %rcx
movq -0xb8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x90(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x90(%rbp), %rax
ja 0xecd0
cmpq $-0x1, -0x90(%rbp)
jbe 0xecdc
movl $0x2, -0x4(%rbp)
jmp 0xeed7
movq -0x90(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xece9
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0xebff
jmp 0xecff
jmp 0xed01
movl -0x74(%rbp), %eax
movq %rax, -0xc0(%rbp)
subq $0x5, %rax
ja 0xed74
movq -0xc0(%rbp), %rax
leaq 0x160f1(%rip), %rcx     # 0x24e10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x16496(%rip), %rax     # 0x251c5
movq %rax, -0x40(%rbp)
jmp 0xed74
leaq 0x16673(%rip), %rax     # 0x253af
movq %rax, -0x40(%rbp)
jmp 0xed74
leaq 0x16682(%rip), %rax     # 0x253cb
movq %rax, -0x40(%rbp)
jmp 0xed74
leaq 0x1669f(%rip), %rax     # 0x253f5
movq %rax, -0x40(%rbp)
jmp 0xed74
leaq 0x166c2(%rip), %rax     # 0x25425
movq %rax, -0x40(%rbp)
jmp 0xed74
leaq 0x166eb(%rip), %rax     # 0x2545b
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x40(%rbp), %rdi
callq 0xf0c0
movq %rax, %rcx
movq -0xc8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x98(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x98(%rbp), %rax
ja 0xedb3
cmpq $-0x1, -0x98(%rbp)
jbe 0xedbf
movl $0x2, -0x4(%rbp)
jmp 0xeed7
movq -0x98(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x38(%rbp), %rax
jae 0xee13
movq -0x38(%rbp), %rcx
shlq %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
ja 0xedfc
movq -0x10(%rbp), %rax
cmpq $-0x1, (%rax)
jbe 0xee07
movq -0x10(%rbp), %rax
movq $-0x1, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xeed7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movl $0x0, -0xa4(%rbp)
movq -0x40(%rbp), %rax
movb (%rax), %al
movq -0xa0(%rbp), %rcx
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0xeed0
movq -0xa0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0xeead
movq -0x40(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x73, %eax
jne 0xeead
movl -0xa4(%rbp), %eax
cmpl -0x74(%rbp), %eax
jge 0xeead
movq -0xa0(%rbp), %rdi
movl -0xa4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xa4(%rbp)
cltq
movq -0x70(%rbp,%rax,8), %rsi
callq 0xefb0
addq -0xa0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x40(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x40(%rbp)
jmp 0xeecb
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xee2b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)