// File: /workspace/github_cpp_makefile_star2_O1/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, 0x10(%rsp)
movq %rdi, %r14
movslq %ecx, %rbx
leaq 0x12ad9(%rip), %r15     # 0x1cb50
movq (%r15,%rbx,8), %r13
xorl %ebp, %ebp
xorl %edi, %edi
movq %r13, %rsi
callq 0xa275
movq %rax, %r8
cmpl $-0x2, %ebx
je 0xa197
movabsq $0x36dd5a89b59390c, %rcx # imm = 0x36DD5A89B59390C
movswq (%r12), %rdx
leaq 0xbcf7(%rip), %rax      # 0x15da0
movsbl (%rdx,%rax), %eax
movq %r13, 0x20(%rsp)
movb $0x1, %r9b
movl $0x1, %ebp
btq %rdx, %rcx
jb 0xa189
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 0xa189
movq %r14, 0x8(%rsp)
movslq %esi, %r13
cltq
movq %rax, 0x18(%rsp)
movslq %ecx, %rbx
leaq (%r15,%r13,8), %r12
movl $0x1, %ebp
movq %r8, %r15
cmpq $0x1, %r13
je 0xa161
movq 0x18(%rsp), %rax
addq %r13, %rax
leaq 0xbddb(%rip), %rcx      # 0x15f00
movzbl (%rcx,%rax), %eax
cmpq %rax, %r13
jne 0xa161
cmpl $0x5, %ebp
je 0xa172
movq %r8, %r14
movq (%r12), %rsi
movslq %ebp, %rax
incl %ebp
movq %rsi, 0x20(%rsp,%rax,8)
xorl %edi, %edi
callq 0xa275
leaq (%rax,%r15), %r8
cmpq %r8, %r15
cmovaq %r15, %r8
addq %r15, %rax
jb 0xa181
movq %r8, %r15
movq %r14, %r8
incq %r13
addq $0x8, %r12
cmpq %r13, %rbx
jne 0xa110
movq %r15, %r8
jmp 0xa177
movl $0x1, %ebp
movq 0x8(%rsp), %r14
movb $0x1, %r9b
jmp 0xa189
xorl %r9d, %r9d
movq 0x8(%rsp), %r14
movl $0x2, %eax
testb %r9b, %r9b
je 0xa251
cmpl $0x5, %ebp
ja 0xa1ae
movl %ebp, %eax
leaq 0xbee7(%rip), %rcx      # 0x1608c
movslq (%rcx,%rax,4), %r12
addq %rcx, %r12
jmp 0xa1b1
xorl %r12d, %r12d
xorl %eax, %eax
cmpb $0x0, (%r12,%rax)
leaq 0x1(%rax), %rax
jne 0xa1b3
leaq (%r8,%rax), %rcx
decq %rcx
movl $0x2, %eax
cmpq %rcx, %r8
cmovaq %r8, %rcx
ja 0xa251
cmpq %rcx, (%r14)
jae 0xa1f4
leaq (%rcx,%rcx), %rax
testq %rcx, %rcx
movq $-0x1, %rcx
cmovnsq %rax, %rcx
movq %rcx, (%r14)
movl $0x1, %eax
jmp 0xa251
movq 0x10(%rsp), %rax
movq (%rax), %rbx
xorl %r14d, %r14d
movzbl (%r12), %edx
movb %dl, (%rbx)
movl $0x1, %eax
cmpl $0x25, %edx
je 0xa21b
movl $0x1, %ecx
testl %edx, %edx
jne 0xa247
jmp 0xa24f
cmpb $0x73, 0x1(%r12)
jne 0xa242
cmpl %ebp, %r14d
jge 0xa242
movslq %r14d, %rax
incl %r14d
movq 0x20(%rsp,%rax,8), %rsi
movq %rbx, %rdi
callq 0xa275
movl $0x2, %ecx
jmp 0xa247
movl $0x1, %ecx
addq %rax, %rbx
addq %rcx, %r12
jmp 0xa1ff
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq