LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tap3edit[P]tap3xml/nrt2xml.cpp
// Function: get_specfilename[abi:cxx11](NrtInfo*)
string get_specfilename(NrtInfo *nrtinfo)
{
    ostringstream    spec_filename;

    spec_filename << nrtinfo->type();
    spec_filename << setw(2) << setfill('0') << nrtinfo->version();
    spec_filename << setw(2) << setfill('0') << nrtinfo->release();
    spec_filename << ".asn";

    return get_specdir(spec_filename.str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x4540
movq -0x10(%rbp), %rsi
leaq -0x1a8(%rbp), %rdi
callq 0xa980
jmp 0x6e52
leaq -0x188(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x42e0
jmp 0x6e67
leaq -0x1a8(%rbp), %rdi
callq 0x41e0
movl $0x2, %edi
callq 0x7920
movl %eax, -0x1fc(%rbp)
jmp 0x6e85
movl -0x1fc(%rbp), %eax
movl %eax, -0x1b8(%rbp)
movl -0x1b8(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x4410
movq %rax, -0x208(%rbp)
jmp 0x6eac
movl $0x30, %edi
callq 0x7940
movb %al, -0x209(%rbp)
jmp 0x6ebe
movq -0x208(%rbp), %rdi
movb -0x209(%rbp), %al
movb %al, -0x1b9(%rbp)
movzbl -0x1b9(%rbp), %esi
callq 0x4620
movq %rax, -0x218(%rbp)
jmp 0x6ee6
movq -0x10(%rbp), %rdi
callq 0xa940
movl %eax, -0x21c(%rbp)
jmp 0x6ef7
movl -0x21c(%rbp), %esi
movq -0x218(%rbp), %rdi
callq 0x46a0
jmp 0x6f0b
movl $0x2, %edi
callq 0x7920
movl %eax, -0x220(%rbp)
jmp 0x6f1d
movl -0x220(%rbp), %eax
movl %eax, -0x1c0(%rbp)
movl -0x1c0(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x4410
movq %rax, -0x228(%rbp)
jmp 0x6f44
movl $0x30, %edi
callq 0x7940
movb %al, -0x229(%rbp)
jmp 0x6f56
movq -0x228(%rbp), %rdi
movb -0x229(%rbp), %al
movb %al, -0x1c1(%rbp)
movzbl -0x1c1(%rbp), %esi
callq 0x4620
movq %rax, -0x238(%rbp)
jmp 0x6f7e
movq -0x10(%rbp), %rdi
callq 0xa960
movl %eax, -0x23c(%rbp)
jmp 0x6f8f
movl -0x23c(%rbp), %esi
movq -0x238(%rbp), %rdi
callq 0x46a0
jmp 0x6fa3
leaq 0x1d0cf(%rip), %rsi     # 0x24079
leaq -0x188(%rbp), %rdi
callq 0x4340
jmp 0x6fb8
leaq -0x1e8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x4380
jmp 0x6fcd
movq -0x1f8(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x7080
jmp 0x6fe2
leaq -0x1e8(%rbp), %rdi
callq 0x41e0
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1f0(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x705c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x41e0
jmp 0x705c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x41e0
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1b0(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: tap3edit[P]tap3xml/nrt2xml.cpp
// Function: get_specdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string get_specdir(const string &filename)
{

    vector<string>::iterator    vii;
    FILE *tmp;

    for (vii=specdir_list.begin();vii!=specdir_list.end();vii++)
    {
        if ((tmp=fopen(((*vii)+"/"+filename).c_str(),"rb")) != NULL)
        {
            fclose(tmp);
            return ((*vii)+"/"+filename);
        }
    }

    return string (filename);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x7960
leaq 0x2a3bc(%rip), %rdi     # 0x31470
callq 0x7980
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x2a3a4(%rip), %rdi     # 0x31470
callq 0x79f0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x79b0
testb $0x1, %al
jne 0x70eb
jmp 0x722a
leaq -0x18(%rbp), %rdi
callq 0x7a70
movq %rax, %rsi
leaq 0x1f1cb(%rip), %rdx     # 0x262c9
leaq -0x70(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x7770
movq -0xc0(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x7a20
jmp 0x7124
leaq -0x50(%rbp), %rdi
callq 0x4160
movq %rax, %rdi
leaq 0x1d10f(%rip), %rsi     # 0x24246
callq 0x4440
movq %rax, -0xc8(%rbp)
jmp 0x7145
movq -0xc8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x41e0
leaq -0x70(%rbp), %rdi
callq 0x41e0
movq -0xc8(%rbp), %rax
cmpq $0x0, %rax
je 0x7211
movq -0x20(%rbp), %rdi
callq 0x4350
leaq -0x18(%rbp), %rdi
callq 0x7a70
movq %rax, %rsi
leaq 0x1f13a(%rip), %rdx     # 0x262c9
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x7770
movq -0xb8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x7a20
jmp 0x71bb
leaq -0xa0(%rbp), %rdi
callq 0x41e0
jmp 0x723a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x71ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x41e0
leaq -0x70(%rbp), %rdi
callq 0x41e0
jmp 0x724a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x41e0
jmp 0x724a
jmp 0x7213
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x7a90
movq %rax, -0xa8(%rbp)
jmp 0x70c5
movq -0xb8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4170
movq -0xb0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tap3edit[P]tap3xml/asn1_parser.cpp
// Function: yy_symbol_print(_IO_FILE*, int, YYSTYPE const*)
static void
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
{
  YYFPRINTF (yyoutput, "%s %s (",
             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);

  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
  YYFPRINTF (yyoutput, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x16, -0xc(%rbp)
jge 0xe90e
leaq 0x16933(%rip), %rax     # 0x2523b
movq %rax, -0x28(%rbp)
jmp 0xe91b
leaq 0x1692c(%rip), %rax     # 0x25241
movq %rax, -0x28(%rbp)
jmp 0xe91b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movslq -0xc(%rbp), %rcx
leaq 0x22222(%rip), %rax     # 0x30b50
movq (%rax,%rcx,8), %rcx
leaq 0x168fa(%rip), %rsi     # 0x25233
movb $0x0, %al
callq 0x45a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xef80
movq -0x8(%rbp), %rdi
leaq 0x16435(%rip), %rsi     # 0x24d90
movb $0x0, %al
callq 0x45a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tap3edit[P]tap3xml/asn1_parser.cpp
// Function: yy_reduce_print(short*, YYSTYPE*, int)
static void
yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
{
  unsigned long int yylno = yyrline[yyrule];
  int yynrhs = yyr2[yyrule];
  int yyi;
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
             yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr,
                       yystos[yyssp[yyi + 1 - yynrhs]],
                       &(yyvsp[(yyi + 1) - (yynrhs)])
                                              );
      YYFPRINTF (stderr, "\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x16762(%rip), %rax     # 0x250f0
movzwl (%rax,%rcx,2), %eax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x1668f(%rip), %rax     # 0x25030
movzbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movq 0x22619(%rip), %rax     # 0x30fc8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
subl $0x1, %edx
movq -0x20(%rbp), %rcx
leaq 0x169ad(%rip), %rsi     # 0x25370
movb $0x0, %al
callq 0x45a0
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xea66
movq 0x225e4(%rip), %rax     # 0x30fc8
movq (%rax), %rdi
movl -0x28(%rbp), %edx
addl $0x1, %edx
leaq 0x169a3(%rip), %rsi     # 0x25397
movb $0x0, %al
callq 0x45a0
movq 0x225c6(%rip), %rax     # 0x30fc8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
subl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movswq (%rax,%rcx,2), %rcx
leaq 0x1668f(%rip), %rax     # 0x250b0
movzbl (%rax,%rcx), %esi
movq -0x10(%rbp), %rdx
movl -0x28(%rbp), %eax
addl $0x1, %eax
subl -0x24(%rbp), %eax
cltq
shlq $0x9, %rax
addq %rax, %rdx
callq 0xe8e0
movq 0x22581(%rip), %rax     # 0x30fc8
movq (%rax), %rdi
leaq 0x1709c(%rip), %rsi     # 0x25aed
movb $0x0, %al
callq 0x45a0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xe9d1
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: tap3edit[P]tap3xml/asn1_parser.cpp
// Function: yy_stack_print(short*, short*)
static void
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x22541(%rip), %rax     # 0x30fc8
movq (%rax), %rdi
leaq 0x16910(%rip), %rsi     # 0x253a1
movb $0x0, %al
callq 0x45a0
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0xead5
movq -0x8(%rbp), %rax
movswl (%rax), %eax
movl %eax, -0x14(%rbp)
movq 0x22515(%rip), %rax     # 0x30fc8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x168eb(%rip), %rsi     # 0x253ab
movb $0x0, %al
callq 0x45a0
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0xea98
movq 0x224ec(%rip), %rax     # 0x30fc8
movq (%rax), %rdi
leaq 0x17007(%rip), %rsi     # 0x25aed
movb $0x0, %al
callq 0x45a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tap3edit[P]tap3xml/asn1_parser.cpp
// Function: yytnamerr(char*, char const*)
static YYSIZE_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      YYSIZE_T yyn = 0;
      char const *yyp = yystr;

      for (;;)
        switch (*++yyp)
          {
          case '\'':
          case ',':
            goto do_not_strip_quotes;

          case '\\':
            if (*++yyp != '\\')
              goto do_not_strip_quotes;
            /* Fall through.  */
          default:
            if (yyres)
              yyres[yyn] = *yyp;
            yyn++;
            break;

          case '"':
            if (yyres)
              yyres[yyn] = '\0';
            return yyn;
          }
    do_not_strip_quotes: ;
    }

  if (! yyres)
    return yystrlen (yystr);

  return yystpcpy (yyres, yystr) - yyres;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0xf082
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x28(%rbp)
movsbl 0x1(%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x22, %eax
je 0xf05e
jmp 0xeffc
movl -0x2c(%rbp), %eax
subl $0x27, %eax
je 0xf01a
jmp 0xf006
movl -0x2c(%rbp), %eax
subl $0x2c, %eax
je 0xf01a
jmp 0xf010
movl -0x2c(%rbp), %eax
subl $0x5c, %eax
je 0xf01c
jmp 0xf038
jmp 0xf080
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl 0x1(%rax), %eax
cmpl $0x5c, %eax
je 0xf036
jmp 0xf080
jmp 0xf038
cmpq $0x0, -0x10(%rbp)
je 0xf050
movq -0x28(%rbp), %rax
movb (%rax), %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xf07b
cmpq $0x0, -0x10(%rbp)
je 0xf071
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf0b0
jmp 0xefe0
jmp 0xf082
cmpq $0x0, -0x10(%rbp)
jne 0xf098
movq -0x18(%rbp), %rdi
callq 0xf0c0
movq %rax, -0x8(%rbp)
jmp 0xf0b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf100
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tap3edit[P]tap3xml/asn1_parser.cpp
// Function: yystrlen(char const*)
static YYSIZE_T
yystrlen (const char *yystr)
{
  YYSIZE_T yylen;
  for (yylen = 0; yystr[yylen]; yylen++)
    continue;
  return yylen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xf0ee
jmp 0xf0e0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xf0d0
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tap3edit[P]tap3xml/asn1_parser.cpp
// Function: yystpcpy(char*, char const*)
static char *
yystpcpy (char *yydest, const char *yysrc)
{
  char *yyd = yydest;
  const char *yys = yysrc;

  while ((*yyd++ = *yys++) != '\0')
    continue;

  return yyd - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0xf148
jmp 0xf11c
movq -0x18(%rbp), %rax
addq $-0x1, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tap3edit[P]tap3xml/global.cpp
// Function: bcd2dec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string bcd2dec(const string &str)
{
    ostringstream value_str;
    unsigned long long value=0;
    /* int sign; */

    string::const_iterator cii;

    /* sign=str.at(0)>>7 ? -1 : 1; */

    for (cii=str.begin();cii!=str.end();cii++)
    {
        value<<=8;
        value+=(int)(uchar)*cii;
        
    }

    /* We'll skip there's no sign on TAP/NRT
    if (sign == -1)
        value-=(int)(0x01<<(8*str.size()));

    */

    value_str << value;

    return value_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x4540
movq $0x0, -0x190(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x16930
movq -0x10(%rbp), %rdi
callq 0x4320
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4750
movq %rax, -0x1a8(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x16950
testb $0x1, %al
jne 0x1464e
jmp 0x14696
movq -0x190(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x190(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x16990
movzbl (%rax), %eax
cltq
addq -0x190(%rbp), %rax
movq %rax, -0x190(%rbp)
leaq -0x198(%rbp), %rdi
xorl %esi, %esi
callq 0x169b0
movq %rax, -0x1b0(%rbp)
jmp 0x14625
movq -0x190(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x42f0
jmp 0x146ab
movq -0x1d0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x4380
jmp 0x146c0
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1c8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1b8(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: tap3edit[P]tap3xml/global.cpp
// Function: bcd2hexa(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string bcd2hexa(const string &str)
{

    ostringstream value;


    string::const_iterator cii;
    for (cii=str.begin();cii!=str.end();cii++)
    {
        value << hex << setw(2) << setfill('0') << (int)(uchar)*cii;
    }


    return value.str();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x4540
leaq -0x190(%rbp), %rdi
callq 0x16930
movq -0x10(%rbp), %rdi
callq 0x4320
movq %rax, -0x198(%rbp)
movq -0x198(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4750
movq %rax, -0x1a0(%rbp)
leaq -0x190(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x16950
testb $0x1, %al
jne 0x14a26
jmp 0x14b0e
leaq 0x2043(%rip), %rsi      # 0x16a70
leaq -0x188(%rbp), %rdi
callq 0x4110
movq %rax, -0x1d8(%rbp)
jmp 0x14a42
movl $0x2, %edi
callq 0x7920
movl %eax, -0x1dc(%rbp)
jmp 0x14a54
movq -0x1d8(%rbp), %rdi
movl -0x1dc(%rbp), %eax
movl %eax, -0x1b0(%rbp)
movl -0x1b0(%rbp), %esi
callq 0x4410
movq %rax, -0x1e8(%rbp)
jmp 0x14a7b
movl $0x30, %edi
callq 0x7940
movb %al, -0x1e9(%rbp)
jmp 0x14a8d
movq -0x1e8(%rbp), %rdi
movb -0x1e9(%rbp), %al
movb %al, -0x1b1(%rbp)
movzbl -0x1b1(%rbp), %esi
callq 0x4620
movq %rax, -0x1f8(%rbp)
jmp 0x14ab5
leaq -0x190(%rbp), %rdi
callq 0x16990
movq -0x1f8(%rbp), %rdi
movzbl (%rax), %esi
callq 0x46a0
jmp 0x14ad2
jmp 0x14ad4
leaq -0x190(%rbp), %rdi
xorl %esi, %esi
callq 0x169b0
movq %rax, -0x1c0(%rbp)
jmp 0x149fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x40c0
jmp 0x14b3f
movq -0x1d0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x4380
jmp 0x14b23
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1c8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x46d0
nopl (%rax,%rax)
// File: tap3edit[P]tap3xml/global.cpp
// Function: hexa2bcd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string hexa2bcd(const string &str)
{
    ostringstream bcd;
    int i;

    for (i=0; i<(int)str.size();i+=2)
        bcd << (uchar)strtol((str.substr(i,2).size()==1 ? str.substr(i,2)+"F" : str.substr(i,2)).c_str(),NULL, 16);

    return bcd.str();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x218(%rbp)
movq %rdi, %rax
movq %rax, -0x210(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x4540
movl $0x0, -0x18c(%rbp)
movl -0x18c(%rbp), %eax
movl %eax, -0x21c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4250
movq %rax, %rcx
movl -0x21c(%rbp), %eax
cmpl %ecx, %eax
jge 0x14d3f
movq -0x10(%rbp), %rsi
movslq -0x18c(%rbp), %rdx
movb $0x0, -0x201(%rbp)
leaq -0x1d0(%rbp), %rdi
movl $0x2, %ecx
callq 0x4390
jmp 0x14bd5
leaq -0x1d0(%rbp), %rdi
callq 0x4250
cmpq $0x1, %rax
jne 0x14c2a
movq -0x10(%rbp), %rsi
movslq -0x18c(%rbp), %rdx
leaq -0x200(%rbp), %rdi
movl $0x2, %ecx
callq 0x4390
jmp 0x14c05
movb $0x1, -0x201(%rbp)
leaq 0x1067c(%rip), %rdx     # 0x2528f
leaq -0x1b0(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0x7720
jmp 0x14c28
jmp 0x14c4a
movq -0x10(%rbp), %rsi
movslq -0x18c(%rbp), %rdx
leaq -0x1b0(%rbp), %rdi
movl $0x2, %ecx
callq 0x4390
jmp 0x14c48
jmp 0x14c4a
leaq -0x1b0(%rbp), %rdi
callq 0x4160
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x4580
movzbl %al, %esi
leaq -0x188(%rbp), %rdi
callq 0x45f0
jmp 0x14c78
leaq -0x1b0(%rbp), %rdi
callq 0x41e0
testb $0x1, -0x201(%rbp)
jne 0x14c8f
jmp 0x14c9b
leaq -0x200(%rbp), %rdi
callq 0x41e0
leaq -0x1d0(%rbp), %rdi
callq 0x41e0
movl -0x18c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18c(%rbp)
jmp 0x14b8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
jmp 0x14d70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
jmp 0x14d31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
jmp 0x14d18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x41e0
testb $0x1, -0x201(%rbp)
jne 0x14d23
jmp 0x14d2f
leaq -0x200(%rbp), %rdi
callq 0x41e0
jmp 0x14d31
leaq -0x1d0(%rbp), %rdi
callq 0x41e0
jmp 0x14d70
movq -0x218(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x4380
jmp 0x14d54
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x210(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1d8(%rbp), %rdi
callq 0x46d0
nopl (%rax,%rax)
// File: tap3edit[P]tap3xml/global.cpp
// Function: treenode::_tree_dump(treenode*, int)
void treenode::_tree_dump(treenode *tree, int depth)
{
    vector<treenode *>::iterator    vii;
    (void)depth;

    if (tree!=NULL)
    {
        cout << "tagname:   " << tree->tagname << endl;
        cout << "cl:        " << tree->cl << endl;
        if (tree->value!=NULL)
        {
            cout << "value:     " <<  tree->value << endl;
        }
        cout << endl;

        if (tree->children!=NULL)
        {
            for (vii=tree->children->begin();vii!=tree->children->end();vii++)
            {
                _tree_dump(*vii, 0);
            }

        }

    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xacf0
cmpq $0x0, -0x10(%rbp)
je 0x151ba
movq 0x1bf2a(%rip), %rdi     # 0x30fc0
leaq 0x10a1c(%rip), %rsi     # 0x25ab9
callq 0x4340
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x42e0
movq %rax, %rdi
movq 0x1bef0(%rip), %rsi     # 0x30fa8
callq 0x43b0
movq 0x1befc(%rip), %rdi     # 0x30fc0
leaq 0x109fa(%rip), %rsi     # 0x25ac5
callq 0x4340
movq %rax, %rdi
movq -0x10(%rbp), %rax
movw 0x20(%rax), %ax
andw $0x3, %ax
movzwl %ax, %esi
callq 0x4670
movq %rax, %rdi
movq 0x1beb7(%rip), %rsi     # 0x30fa8
callq 0x43b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x15133
movq 0x1beb8(%rip), %rdi     # 0x30fc0
leaq 0x109c2(%rip), %rsi     # 0x25ad1
callq 0x4340
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x4280
movq %rax, %rdi
movq 0x1be7a(%rip), %rsi     # 0x30fa8
callq 0x43b0
movq 0x1be86(%rip), %rdi     # 0x30fc0
movq 0x1be67(%rip), %rsi     # 0x30fa8
callq 0x43b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x151b8
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xaef0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xaf60
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xaf20
testb $0x1, %al
jne 0x1518e
jmp 0x151b6
leaq -0x20(%rbp), %rdi
callq 0xaf90
movq -0x40(%rbp), %rdi
movq (%rax), %rsi
xorl %edx, %edx
callq 0x15060
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xafb0
movq %rax, -0x38(%rbp)
jmp 0x1516a
jmp 0x151b8
jmp 0x151ba
addq $0x40, %rsp
popq %rbp
retq
// File: tap3edit[P]tap3xml/global.cpp
// Function: bcd2int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string bcd2int(const string &str)
{
    ostringstream value_str;

    int value=0;
    string::const_iterator cii;

    for (cii=str.begin();cii!=str.end();cii++)
    {
        value+=(int)(uchar)*cii;
    }

    value_str << value;

    return value_str.str();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x4540
movl $0x0, -0x18c(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x16930
movq -0x10(%rbp), %rdi
callq 0x4320
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4750
movq %rax, -0x1a8(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x16950
testb $0x1, %al
jne 0x152bd
jmp 0x152ef
leaq -0x198(%rbp), %rdi
callq 0x16990
movzbl (%rax), %eax
addl -0x18c(%rbp), %eax
movl %eax, -0x18c(%rbp)
leaq -0x198(%rbp), %rdi
xorl %esi, %esi
callq 0x169b0
movq %rax, -0x1b0(%rbp)
jmp 0x15294
movl -0x18c(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x46a0
jmp 0x15303
movq -0x1d0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x4380
jmp 0x15318
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1c8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1b8(%rbp), %rdi
callq 0x46d0
nop
// File: tap3edit[P]tap3xml/global.cpp
// Function: int2bcd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string int2bcd(const string &str)
{

    ostringstream bcd;
    int intstr;


    intstr=atoi(str.c_str());


    while (intstr>0)
    {
        intstr>255 
            ? bcd << (uchar)255
            : bcd << (uchar)(intstr&0xFF);
        intstr-=255;
    }

    return bcd.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x1b0(%rbp)
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x4540
movq -0x10(%rbp), %rdi
callq 0x4160
movq %rax, %rdi
callq 0x4610
movl %eax, -0x18c(%rbp)
cmpl $0x0, -0x18c(%rbp)
jle 0x1541b
cmpl $0xff, -0x18c(%rbp)
jle 0x153d1
leaq -0x188(%rbp), %rdi
movl $0xff, %esi
callq 0x45f0
jmp 0x153cf
jmp 0x153e8
movzbl -0x18c(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x45f0
jmp 0x153e6
jmp 0x153e8
movl -0x18c(%rbp), %eax
subl $0xff, %eax
movl %eax, -0x18c(%rbp)
jmp 0x153a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x40c0
jmp 0x1544c
movq -0x1b0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x4380
jmp 0x15430
leaq -0x188(%rbp), %rdi
callq 0x40c0
movq -0x1a8(%rbp), %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x46d0
nopl (%rax,%rax)
// File: tap3edit[P]tap3xml/global.cpp
// Function: free_treenode(treenode*)
void free_treenode(treenode *tree)
{
    vector<treenode *>::iterator    vii;

    if (tree!=NULL)
    {
        if (tree->value!=NULL)
        {
            delete tree->value;
        }

        if (tree->children!=NULL)
        {
            for (vii=tree->children->begin();vii!=tree->children->end();vii++)
            {
                free_treenode(*vii);
            }

            delete tree->children;
        }

        delete tree;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xacf0
cmpq $0x0, -0x8(%rbp)
je 0x168a6
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x167e6
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x167e4
movq -0x30(%rbp), %rdi
callq 0x41e0
movq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0x4370
jmp 0x167e6
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x1687f
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xaef0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xaf60
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xaf20
testb $0x1, %al
jne 0x16832
jmp 0x16854
leaq -0x10(%rbp), %rdi
callq 0xaf90
movq (%rax), %rdi
callq 0x16790
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xafb0
movq %rax, -0x28(%rbp)
jmp 0x1680e
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1687d
movq -0x38(%rbp), %rdi
callq 0x16b40
movq -0x38(%rbp), %rdi
movl $0x18, %esi
callq 0x4370
jmp 0x1687f
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x168a4
movq -0x40(%rbp), %rdi
callq 0x12bb0
movq -0x40(%rbp), %rdi
movl $0x58, %esi
callq 0x4370
jmp 0x168a6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: tap3edit[P]tap3xml/Buffin.cpp
// Function: Buffin::set_pos(long const&)
void  Buffin::set_pos(const long &pos)
{
    if (pos > this->get_end())
    {
        cerr << "Trying to read beyond the end of file. Pos: " << pos << " End: " << this->get_end() << endl;
        err_trace(__FILE__, __LINE__);
    }

    _pos=pos;
    if (!_mode)
    {
        _file_in.seekg(pos);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
callq 0x17a60
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jle 0x179ff
movq 0x196b6(%rip), %rdi     # 0x30fe8
leaq 0xe283(%rip), %rsi      # 0x25bbc
callq 0x4340
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x4720
movq %rax, %rdi
leaq 0xe292(%rip), %rsi      # 0x25be9
callq 0x4340
movq -0x68(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x17a60
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x4720
movq %rax, %rdi
movq 0x19629(%rip), %rsi     # 0x30fa8
callq 0x43b0
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x46e0
movq -0x70(%rbp), %rdx
leaq 0xe1fb(%rip), %rsi      # 0x25b97
leaq -0x30(%rbp), %rdi
callq 0x7670
jmp 0x179a7
movl $0x92, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x151c0
jmp 0x179bd
leaq -0x30(%rbp), %rdi
callq 0x41e0
leaq -0x31(%rbp), %rdi
callq 0x43d0
jmp 0x179ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x179f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x41e0
leaq -0x31(%rbp), %rdi
callq 0x43d0
jmp 0x17a50
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x220(%rax)
cmpl $0x0, 0x230(%rax)
jne 0x17a47
movq -0x68(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x58(%rbp), %rdi
callq 0x17f10
movq -0x80(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x44c0
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x46d0
nopl (%rax)
// File: tap3edit[P]tap3xml/Buffin.cpp
// Function: Buffin::read(long)
void  Buffin::read(const long len)
{

    /* 1. Allocation of memory */

    if (_curbuf != NULL)
        delete [] _curbuf;
    
    _curbuf=new uchar[len];


    /* 2. Reading into current buffer */

    if(_mode)
    {
        ;
    } 
    else 
    {
        if (this->get_pos() + len <= this->get_end())
            memcpy(_curbuf, _buffin+this->get_pos(), len);
        else
        {
            cerr << "Trying to read " << len << " bytes beyond end of file from position "<<this->get_pos();
            cerr << ". File might be corrupted." << endl;
            err_trace( __FILE__, __LINE__) ;
        }

    }

    _curbuf_len=len;


    /* 3. Update position */

    this->set_pos(this->get_pos()+len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x17abf
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x17abd
movq -0x60(%rbp), %rdi
callq 0x44e0
jmp 0x17abf
movq -0x10(%rbp), %rdi
callq 0x4030
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpl $0x0, 0x230(%rax)
je 0x17ae1
jmp 0x17c2b
movq -0x58(%rbp), %rdi
callq 0x178d0
movq -0x58(%rbp), %rdi
addq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x17a60
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jg 0x17b38
movq -0x58(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, -0x70(%rbp)
movq (%rdi), %rax
movq %rax, -0x78(%rbp)
callq 0x178d0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x42b0
jmp 0x17c29
movq 0x194a9(%rip), %rdi     # 0x30fe8
movq %rdi, -0x88(%rbp)
leaq 0xe0a3(%rip), %rsi      # 0x25bf0
callq 0x4340
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4720
movq %rax, %rdi
leaq 0xe098(%rip), %rsi      # 0x25c00
callq 0x4340
movq -0x58(%rbp), %rdi
movq %rax, -0x90(%rbp)
callq 0x178d0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x4720
movq -0x88(%rbp), %rdi
leaq 0xe08f(%rip), %rsi      # 0x25c29
callq 0x4340
movq %rax, %rdi
movq 0x193ff(%rip), %rsi     # 0x30fa8
callq 0x43b0
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x46e0
movq -0x80(%rbp), %rdx
leaq 0xdfd1(%rip), %rsi      # 0x25b97
leaq -0x30(%rbp), %rdi
callq 0x7670
jmp 0x17bd1
movl $0xba, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x151c0
jmp 0x17be7
leaq -0x30(%rbp), %rdi
callq 0x41e0
leaq -0x31(%rbp), %rdi
callq 0x43d0
jmp 0x17c29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x17c1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x41e0
leaq -0x31(%rbp), %rdi
callq 0x43d0
jmp 0x17c5a
jmp 0x17c2b
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rdi)
callq 0x178d0
movq -0x58(%rbp), %rdi
addq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x178f0
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: tap3edit[P]tap3xml/Buffin.cpp
// Function: Buffin::~Buffin()
Buffin::~Buffin()
{
    if (_mode)
        _file_in.close();
    if (_buffin != NULL)
        delete [] _buffin ;
    if (_curbuf != NULL)
        delete [] _curbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x230(%rax)
je 0x17e5e
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x40b0
jmp 0x17e5c
jmp 0x17e5e
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x17e84
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x17e82
movq -0x18(%rbp), %rdi
callq 0x44e0
jmp 0x17e84
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x17eac
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x17eaa
movq -0x20(%rbp), %rdi
callq 0x44e0
jmp 0x17eac
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x40d0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7de0
nopw (%rax,%rax)
// File: tap3edit[P]tap3xml/Buffout.cpp
// Function: Buffout::Buffout(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Buffout::Buffout(const string filename) :
    _curbuf(NULL)
{

    /* 1. Open file */

    _file_out.open(filename.c_str(), ios::binary | ios::out);

    if (!_file_out.good())
    {
        cerr << "Unable to open file: " << filename ;
        err_trace(__FILE__, __LINE__);
    }

    _strm_out = new ostream(_file_out.rdbuf());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq $0x0, 0x8(%rdi)
addq $0x18, %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x4690
movq -0x60(%rbp), %rdi
callq 0x4160
movq %rax, -0x58(%rbp)
movl $0x4, %edi
movl $0x10, %esi
callq 0x17ed0
movl %eax, -0x4c(%rbp)
jmp 0x1806c
movl -0x4c(%rbp), %edx
movq -0x58(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x4070
jmp 0x1807e
movq -0x78(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rcx), %rcx
leaq 0x18(%rax,%rcx), %rdi
callq 0x4680
movb %al, -0x79(%rbp)
jmp 0x18099
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x18166
jmp 0x180a6
movq 0x18f3b(%rip), %rdi     # 0x30fe8
leaq 0xdacd(%rip), %rsi      # 0x25b81
callq 0x4340
movq %rax, -0x88(%rbp)
jmp 0x180c2
movq -0x60(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x42e0
jmp 0x180d4
leaq -0x41(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x46e0
movq -0x90(%rbp), %rdx
leaq 0xdb52(%rip), %rsi      # 0x25c44
leaq -0x40(%rbp), %rdi
callq 0x7670
jmp 0x180fd
movl $0x3f, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x151c0
jmp 0x18113
leaq -0x40(%rbp), %rdi
callq 0x41e0
leaq -0x41(%rbp), %rdi
callq 0x43d0
jmp 0x18166
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x181dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1815b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41e0
leaq -0x41(%rbp), %rdi
callq 0x43d0
jmp 0x181dc
movl $0x110, %edi            # imm = 0x110
callq 0x4360
movq %rax, -0x98(%rbp)
jmp 0x18179
movq -0x78(%rbp), %rdi
addq $0x18, %rdi
callq 0x4730
movq %rax, -0xa0(%rbp)
jmp 0x1818f
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdi
callq 0x4140
jmp 0x181a4
movq -0x78(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, 0x218(%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x110, %esi            # imm = 0x110
callq 0x4370
movq -0x68(%rbp), %rdi
callq 0x45c0
movq -0x18(%rbp), %rdi
callq 0x46d0
nop
// File: tap3edit[P]tap3xml/Buffout.cpp
// Function: Buffout::~Buffout()
Buffout::~Buffout() 
{
    _file_out.close();
    if (_strm_out != NULL)
        delete _strm_out;

    if (_curbuf != NULL)
        delete [] _curbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
callq 0x4590
jmp 0x1828f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x218(%rax)
je 0x182be
movq -0x10(%rbp), %rax
movq 0x218(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x182bc
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x182be
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x182e6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x182e4
movq -0x20(%rbp), %rdi
callq 0x44e0
jmp 0x182e6
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x45c0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7de0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tap3edit[P]tap3xml/Asn.cpp
// Function: Asn::_decode_spec()
void Asn::_decode_spec()
{

    /* 1. Parse Specification */

    if (_specfile==NULL)
    {
        cerr << "Error. Specification File must be specified with method \"specfile\"";
        err_trace(__FILE__, __LINE__);
    }

    extern  int run_asn1parser(FILE *_specfile, FILE *_specsuplfile, map<string,tagtype_s *> *spec_tree);

    if (run_asn1parser(_specfile, _specsuplfile, &_spec_tree))
    {
        cerr << "Error decoding ASN input file\n";
        err_trace(__FILE__, __LINE__);
    }


    /* 2. Compile */

    _compile_spec(&_spec_tree);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, 0x30(%rax)
jne 0x18513
movq 0x18b5f(%rip), %rdi     # 0x30fe8
leaq 0xd7c0(%rip), %rsi      # 0x25c50
callq 0x4340
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x46e0
movq -0x78(%rbp), %rdx
leaq 0xd7e6(%rip), %rsi      # 0x25c93
leaq -0x28(%rbp), %rdi
callq 0x7670
jmp 0x184b8
movl $0x9f, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x151c0
jmp 0x184ce
leaq -0x28(%rbp), %rdi
callq 0x41e0
leaq -0x29(%rbp), %rdi
callq 0x43d0
jmp 0x18513
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x18505
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x41e0
leaq -0x29(%rbp), %rdi
callq 0x43d0
jmp 0x185d8
movq -0x70(%rbp), %rdx
movq 0x30(%rdx), %rdi
movq 0x38(%rdx), %rsi
addq $0x60, %rdx
callq 0xcdf0
cmpl $0x0, %eax
je 0x185bf
movq 0x18ab0(%rip), %rdi     # 0x30fe8
leaq 0xd75c(%rip), %rsi      # 0x25c9b
callq 0x4340
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x46e0
movq -0x80(%rbp), %rdx
leaq 0xd737(%rip), %rsi      # 0x25c93
leaq -0x60(%rbp), %rdi
callq 0x7670
jmp 0x18567
movl $0xa7, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x151c0
jmp 0x1857d
leaq -0x60(%rbp), %rdi
callq 0x41e0
leaq -0x61(%rbp), %rdi
callq 0x43d0
jmp 0x185bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x185b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x41e0
leaq -0x61(%rbp), %rdi
callq 0x43d0
jmp 0x185d8
movq -0x70(%rbp), %rdi
movq %rdi, %rsi
addq $0x60, %rsi
callq 0x185f0
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: tap3edit[P]tap3xml/Asn.cpp
// Function: Asn::encode()
void Asn::encode()
{

    /* 1. Decode Specification */

    _decode_spec();


    /* 2. Match our Tree with the specification */

    if (!_spec_rootnode.size())
    {
        cerr << "Error. The root node should be specified with the method \"specroot\"";
        err_trace(__FILE__, __LINE__);
    }

    _compile_tree(_spec_tree[_spec_rootnode],_tree);

    if (!_tree->tag_d)
    {
        _tree->tag_d=_spec_tree[_spec_rootnode]->tagid;
    }

    /* 3. Encode */

    TreeParser *tparser=new TreeParser;
    tparser->handler(_asnitem);
    tparser->buffout(_bfout);
    tparser->tree(_tree);
    tparser->process();
    delete tparser; 
    tparser = NULL;

    _bfout->flush();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x18460
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
callq 0x4250
cmpq $0x0, %rax
jne 0x1e0b1
movq 0x12fc1(%rip), %rdi     # 0x30fe8
leaq 0x7cbe(%rip), %rsi      # 0x25cec
callq 0x4340
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x46e0
movq -0x58(%rbp), %rdx
leaq 0x7c48(%rip), %rsi      # 0x25c93
leaq -0x28(%rbp), %rdi
callq 0x7670
jmp 0x1e056
movl $0x596, -0x40(%rbp)     # imm = 0x596
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x151c0
jmp 0x1e06c
leaq -0x28(%rbp), %rdi
callq 0x41e0
leaq -0x29(%rbp), %rdi
callq 0x43d0
jmp 0x1e0b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1e0a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x41e0
leaq -0x29(%rbp), %rdi
callq 0x43d0
jmp 0x1e1c4
movq -0x50(%rbp), %rsi
movq %rsi, %rdi
addq $0x60, %rdi
addq $0x40, %rsi
callq 0xf160
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
movq 0x18(%rdi), %rdx
callq 0x1c3c0
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x24(%rax)
jne 0x1e10b
movq -0x50(%rbp), %rsi
movq %rsi, %rdi
addq $0x60, %rdi
addq $0x40, %rsi
callq 0xf160
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq (%rcx), %rcx
movl 0x40(%rcx), %ecx
movq 0x18(%rax), %rax
movl %ecx, 0x24(%rax)
movl $0x18, %edi
callq 0x4360
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x224a0
jmp 0x1e126
movq -0x50(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x224d0
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x22550
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq 0x18(%rax), %rsi
callq 0x22510
movq -0x48(%rbp), %rdi
callq 0x225a0
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x1e18f
movq -0x68(%rbp), %rdi
callq 0x22790
movq -0x68(%rbp), %rdi
movl $0x18, %esi
callq 0x4370
movq -0x50(%rbp), %rax
movq $0x0, -0x48(%rbp)
movq 0x8(%rax), %rdi
callq 0x18240
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x18, %esi
callq 0x4370
movq -0x38(%rbp), %rdi
callq 0x46d0
nopl (%rax)
// File: tap3edit[P]tap3xml/Asn.cpp
// Function: Asn::specfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Asn::specfile(const string &filename)
{

    if (!(_specfile=fopen(filename.c_str(), "rb")))
    {
        cerr << "Error trying to open or not found specification file: " << filename;
        if (getenv(TAP3XML_SPEC_VAR) == NULL)
            cerr << "\nYou can set the variable " << TAP3XML_SPEC_VAR << " to point to the directory of the specifications";
        err_trace(__FILE__, __LINE__);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4160
movq %rax, %rdi
leaq 0x604b(%rip), %rsi      # 0x24246
callq 0x4440
movq -0x50(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0x1e2ef
movq 0x12dcf(%rip), %rdi     # 0x30fe8
leaq 0x7e21(%rip), %rsi      # 0x26041
callq 0x4340
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x42e0
leaq 0x5e17(%rip), %rdi      # 0x2404f
callq 0x4480
cmpq $0x0, %rax
jne 0x1e274
movq 0x12d9e(%rip), %rdi     # 0x30fe8
leaq 0x7e27(%rip), %rsi      # 0x26078
callq 0x4340
movq %rax, %rdi
leaq 0x5def(%rip), %rsi      # 0x2404f
callq 0x4340
movq %rax, %rdi
leaq 0x7e24(%rip), %rsi      # 0x26093
callq 0x4340
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x46e0
movq -0x58(%rbp), %rdx
leaq 0x7a07(%rip), %rsi      # 0x25c93
leaq -0x30(%rbp), %rdi
callq 0x7670
jmp 0x1e297
movl $0x5ca, -0x48(%rbp)     # imm = 0x5CA
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x151c0
jmp 0x1e2ad
leaq -0x30(%rbp), %rdi
callq 0x41e0
leaq -0x31(%rbp), %rdi
callq 0x43d0
jmp 0x1e2ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1e2e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x41e0
leaq -0x31(%rbp), %rdi
callq 0x43d0
jmp 0x1e2f5
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x46d0
nop
// File: tap3edit[P]tap3xml/Asn.cpp
// Function: Asn::_dump_asn_tree(treenode*, int)
void Asn::_dump_asn_tree(
        treenode *tree,
        int depth
        )
{

    vector<treenode *>::iterator    vii;

    cout << string(depth*4, ' ') << tree->tagname << " (" << tree->tag_d << ")";
    if (tree->value)
        cout << " \"" << *(tree->value) << "\"";
    cout << "\n";

    if (tree->children!=NULL)
    {

        for (vii=tree->children->begin();vii!=tree->children->end();vii++)
        {
            _dump_asn_tree(*vii, depth +1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xacf0
movl -0x14(%rbp), %eax
shll $0x2, %eax
cltq
movq %rax, -0x80(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x46e0
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movl $0x20, %edx
callq 0x1f2f0
jmp 0x1eaeb
movq 0x124ce(%rip), %rdi     # 0x30fc0
leaq -0x40(%rbp), %rsi
callq 0x42e0
movq %rax, -0x90(%rbp)
jmp 0x1eb04
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42e0
movq %rax, -0x98(%rbp)
jmp 0x1eb1d
movq -0x98(%rbp), %rdi
leaq 0x670d(%rip), %rsi      # 0x25238
callq 0x4340
movq %rax, -0xa0(%rbp)
jmp 0x1eb39
movq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x46a0
movq %rax, -0xa8(%rbp)
jmp 0x1eb55
movq -0xa8(%rbp), %rdi
leaq 0x622d(%rip), %rsi      # 0x24d90
callq 0x4340
jmp 0x1eb6a
leaq -0x40(%rbp), %rdi
callq 0x41e0
leaq -0x41(%rbp), %rdi
callq 0x43d0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x1ebec
movq 0x12432(%rip), %rdi     # 0x30fc0
leaq 0x735d(%rip), %rsi      # 0x25ef2
callq 0x4340
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x42e0
movq %rax, %rdi
leaq 0x733f(%rip), %rsi      # 0x25ef3
callq 0x4340
jmp 0x1ebec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1ebde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41e0
leaq -0x41(%rbp), %rdi
callq 0x43d0
jmp 0x1ec81
movq 0x123cd(%rip), %rdi     # 0x30fc0
leaq 0x6ef3(%rip), %rsi      # 0x25aed
callq 0x4340
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x1ec78
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xaef0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xaf60
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xaf20
testb $0x1, %al
jne 0x1ec47
jmp 0x1ec76
leaq -0x20(%rbp), %rdi
callq 0xaf90
movq -0x88(%rbp), %rdi
movq (%rax), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x1ea90
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xafb0
movq %rax, -0x70(%rbp)
jmp 0x1ec23
jmp 0x1ec78
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x46d0
nopw (%rax,%rax)
// File: tap3edit[P]tap3xml/Asn.cpp
// Function: Asn::~Asn()
Asn::~Asn() 
{
    _free_spec_tree(_spec_tree);

    if (_asnitem)
    {
        delete _asnitem; 
        _asnitem = NULL;
    }

    if (_specfile!=NULL)
    {
        fclose(_specfile);
    }

    if (_specsuplfile!=NULL)
    {
        fclose(_specsuplfile);
    }

    if (_bfout!=NULL)
    {
        delete _bfout; 
        _bfout = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq %rdi, %rsi
addq $0x60, %rsi
callq 0x1e8a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1ece3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1ecd7
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1ecff
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x4350
jmp 0x1ecfd
jmp 0x1ecff
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1ed1b
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x4350
jmp 0x1ed19
jmp 0x1ed1b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1ed5b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1ed4f
movq -0x20(%rbp), %rdi
callq 0x18270
movq -0x20(%rbp), %rdi
movl $0x220, %esi            # imm = 0x220
callq 0x4370
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x1edb0
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x41e0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7de0
nopw %cs:(%rax,%rax)
nopl (%rax)