// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movslq %ecx, %rbx
leaq 0x12d9a(%rip), %r15     # 0x1cb50
movq (%r15,%rbx,8), %r13
xorl %ebp, %ebp
xorl %edi, %edi
movq %r13, %rsi
callq 0x9ff0
movq %rax, %r8
leaq 0xc365(%rip), %rax      # 0x16135
cmpl $-0x2, %ebx
jne 0x9ddd
movq %rax, %r12
jmp 0x9f1b
movabsq $0x36dd5a89b59390c, %rcx # imm = 0x36DD5A89B59390C
movswq (%r12), %rdx
leaq 0xbfcd(%rip), %rax      # 0x15dc0
movsbl (%rdx,%rax), %eax
movq %r13, 0x20(%rsp)
leaq 0xc50a(%rip), %r12      # 0x1630d
movl $0x1, %ebp
btq %rdx, %rcx
jb 0x9f1b
addq $0x91, %rcx
movl %eax, %edi
negl %edi
xorl %esi, %esi
btq %rdx, %rcx
cmovbl %edi, %esi
movl $0x30, %edx
subl %eax, %edx
cmpl $0x16, %edx
movl $0x16, %ecx
cmovll %edx, %ecx
cmpl %ecx, %esi
jge 0x9f1b
movq %r14, (%rsp)
movslq %esi, %r14
cltq
movq %rax, 0x10(%rsp)
movslq %ecx, %r13
leaq (%r15,%r14,8), %r15
movl $0x1, %ebp
movq %r8, %rdx
cmpq $0x1, %r14
je 0x9ea9
movq 0x10(%rsp), %rax
addq %r14, %rax
leaq 0xc0ae(%rip), %rsi      # 0x15f20
movzbl (%rsi,%rax), %eax
cmpq %rax, %r14
jne 0x9ea9
cmpl $0x5, %ebp
je 0x9edc
movq %r8, %rbx
movq (%r15), %rsi
movslq %ebp, %rax
movq %rsi, 0x20(%rsp,%rax,8)
xorl %edi, %edi
movq %rdx, 0x18(%rsp)
callq 0x9ff0
movq 0x18(%rsp), %rdx
addq %rax, %rdx
jb 0x9ee7
incl %ebp
movq %rbx, %r8
incq %r14
addq $0x8, %r15
cmpq %r14, %r13
jne 0x9e5d
cmpl $0x5, %ebp
movq (%rsp), %r14
ja 0x9f15
movl %ebp, %eax
leaq 0xbed9(%rip), %rcx      # 0x15da0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdx, %r8
leaq 0xc25b(%rip), %r12      # 0x16135
jmp 0x9f1b
movl $0x1, %ebp
movq (%rsp), %r14
jmp 0x9f1b
movl $0x2, %eax
jmp 0x9fcc
leaq 0xc48b(%rip), %r12      # 0x16383
jmp 0x9f18
leaq 0xc428(%rip), %r12      # 0x16329
jmp 0x9f18
leaq 0xc449(%rip), %r12      # 0x16353
jmp 0x9f18
leaq 0xc4a6(%rip), %r12      # 0x163b9
jmp 0x9f18
xorl %r12d, %r12d
movq %rdx, %r8
leaq -0x2(,%r8,2), %rcx
xorl %eax, %eax
addq $0x2, %rcx
cmpb $0x0, (%r12,%rax)
leaq 0x1(%rax), %rax
jne 0x9f25
leaq (%r8,%rax), %rdx
decq %rdx
movl $0x2, %eax
cmpq %rdx, %r8
ja 0x9fcc
cmpq %rdx, (%r14)
jae 0x9f66
testq %rdx, %rdx
movq $-0x1, %rax
cmovnsq %rcx, %rax
movq %rax, (%r14)
movl $0x1, %eax
jmp 0x9fcc
movq 0x8(%rsp), %rax
movq (%rax), %rbx
xorl %r14d, %r14d
movzbl (%r12), %edx
movb %dl, (%rbx)
movl $0x1, %eax
cmpl $0x25, %edx
je 0x9f8d
movl $0x1, %ecx
testl %edx, %edx
jne 0x9fc2
jmp 0x9fca
cmpb $0x73, 0x1(%r12)
sete %cl
cmpl %ebp, %r14d
setl %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x9fbd
movslq %r14d, %rax
incl %r14d
movq 0x20(%rsp,%rax,8), %rsi
movq %rbx, %rdi
callq 0x9ff0
movl $0x2, %ecx
jmp 0x9fc2
movl $0x1, %ecx
addq %rax, %rbx
addq %rcx, %r12
jmp 0x9f71
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq