// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %rbp
movslq %ecx, %r12
leaq 0x11265(%rip), %r14     # 0x19b60
movq (%r14,%r12,8), %r13
xorl %r15d, %r15d
xorl %edi, %edi
movq %r13, %rsi
callq 0x8b82
movq %rax, (%rsp)
leaq 0x981e(%rip), %rax      # 0x12135
cmpl $-0x2, %r12d
jne 0x8925
movq %rax, %rbx
jmp 0x89fd
movabsq $0x36dd5a89b59390c, %rax # imm = 0x36DD5A89B59390C
movswq (%rbx), %rcx
leaq 0x9486(%rip), %rdx      # 0x11dc0
movsbl (%rcx,%rdx), %edx
movq %r13, 0x20(%rsp)
leaq 0x99c3(%rip), %rbx      # 0x1230d
btq %rcx, %rax
jb 0x89f9
movq %rbp, 0x8(%rsp)
movslq %edx, %rsi
addq $0x91, %rax
xorl %edx, %edx
btq %rcx, %rax
sbbq %rdx, %rdx
movq %rsi, %r13
negq %r13
pushq $0x30
popq %rax
movq %rsi, 0x18(%rsp)
subl %esi, %eax
cmpl $0x16, %eax
pushq $0x16
popq %rcx
cmovll %eax, %ecx
andq %rdx, %r13
movslq %ecx, %rbp
leaq (%r14,%r13,8), %r12
pushq $0x1
popq %rax
movl %eax, %r15d
movq (%rsp), %r14
cmpq %rbp, %r13
jge 0x8a9c
cmpq $0x1, %r13
je 0x89ea
movq 0x18(%rsp), %rax
addq %r13, %rax
leaq 0x956a(%rip), %rcx      # 0x11f20
movzbl (%rcx,%rax), %eax
cmpq %rax, %r13
jne 0x89ea
cmpl $0x5, %r15d
je 0x8aca
movq (%r12), %rsi
movslq %r15d, %rax
movq %rsi, 0x20(%rsp,%rax,8)
xorl %edi, %edi
callq 0x8b82
addq %r14, %rax
jb 0x8ada
incl %r15d
jmp 0x89ed
movq %r14, %rax
incq %r13
addq $0x8, %r12
movq %rax, %r14
jmp 0x8998
pushq $0x1
popq %r15
pushq $0x2
popq %r12
movq (%rsp), %r14
movq %rbx, %rdi
callq 0x8be7
addq %r14, %rax
jb 0x8ade
cmpq %rax, (%rbp)
jae 0x8a35
leaq (%rax,%rax), %rcx
testq %rax, %rax
pushq $-0x1
popq %rax
cmovnsq %rcx, %rax
movq %rax, (%rbp)
pushq $0x1
jmp 0x8adc
movq 0x10(%rsp), %rax
movq (%rax), %r14
xorl %ebp, %ebp
pushq $0x1
popq %r12
pushq $0x2
popq %r13
movzbl (%rbx), %edx
movb %dl, (%r14)
cmpl $0x25, %edx
je 0x8a5e
movq %r12, %rax
movq %r12, %rcx
testl %edx, %edx
jne 0x8a8f
jmp 0x8a97
cmpb $0x73, 0x1(%rbx)
sete %al
cmpl %r15d, %ebp
setl %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8a89
movslq %ebp, %rax
incl %ebp
movq 0x20(%rsp,%rax,8), %rsi
movq %r14, %rdi
callq 0x8b82
movq %r13, %rcx
jmp 0x8a8f
movq %r12, %rax
movq %r12, %rcx
addq %rax, %r14
addq %rcx, %rbx
jmp 0x8a47
xorl %r12d, %r12d
jmp 0x8ade
cmpl $0x5, %r15d
ja 0x8b20
movl %r15d, %eax
leaq 0x92f4(%rip), %rcx      # 0x11da0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
movq 0x8(%rsp), %rbp
pushq $0x2
popq %r12
jmpq *%rax
leaq 0x9670(%rip), %rbx      # 0x12135
jmp 0x8a05
pushq $0x1
popq %rax
movl %eax, %r15d
movq 0x8(%rsp), %rbp
jmp 0x89fd
pushq $0x2
popq %r12
movl %r12d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x988c(%rip), %rbx      # 0x12383
jmp 0x8a05
leaq 0x9826(%rip), %rbx      # 0x12329
jmp 0x8a05
leaq 0x9844(%rip), %rbx      # 0x12353
jmp 0x8a05
leaq 0x989e(%rip), %rbx      # 0x123b9
jmp 0x8a05
xorl %ebx, %ebx
movq 0x8(%rsp), %rbp
pushq $0x2
popq %r12
jmp 0x8a05