LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::resize(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void
		resize(size_type n, value_type val = value_type())
		{
			// Reduced content to its first n elements
			if (n < _size)
			{
				// We also need to destroy items beyond size
				// Destroy doesn't deallocate item so we don't need to
				// change _capacity (or destroy beyond _size)
				for (size_type i = n; i < _size; i++)
					_allocator.destroy(&_start[i]);
				_size = n;
			}
			else if (n > _size)
			{
				if (n > _capacity)
					reserve(get_new_capacity(n));
				for (size_type i = _size; i < n; i++)
					_allocator.construct(&_start[i], val);
				_size = n;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jbe 0x293b7
cmpq %rbx, 0x18(%r14)
jbe 0x2941b
movq %rbx, %r15
shlq $0x5, %r15
orq $0x10, %r15
movq %rbx, %r12
movq 0x8(%r14), %rax
movq -0x10(%rax,%r15), %rdi
addq %r15, %rax
cmpq %rdi, %rax
je 0x293a8
callq 0x5190
incq %r12
addq $0x20, %r15
cmpq 0x18(%r14), %r12
jb 0x29392
jmp 0x2941b
jae 0x2941f
movq %rdx, %r15
movq 0x20(%r14), %rax
cmpq %rbx, %rax
jae 0x293e0
movq %rbx, %rsi
testq %rax, %rax
je 0x293d8
movq %rax, %rsi
addq %rax, %rax
cmpq %rbx, %rsi
jb 0x293cd
movq %r14, %rdi
callq 0x28258
movq 0x18(%r14), %r12
movq %rbx, %r13
subq %r12, %r13
jbe 0x2941b
shlq $0x5, %r12
movq 0x8(%r14), %rdi
leaq (%rdi,%r12), %rax
addq $0x10, %rax
addq %r12, %rdi
movq %rax, -0x10(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x728c
addq $0x20, %r12
decq %r13
jne 0x293f0
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::vector<ft::random_access_iterator<int>>(ft::random_access_iterator<int>, ft::random_access_iterator<int>, std::allocator<int> const&, ft::enable_if<!ft::is_integral<ft::random_access_iterator<int>>::value, ft::random_access_iterator<int>>::type*)
vector(InputIterator first,
				InputIterator last,
				allocator_type const& alloc = allocator_type(),
				typename ft::enable_if<!ft::is_integral<InputIterator>::value,
										InputIterator>::type* = NULL) :
			_start(NULL),
			_allocator(alloc),
			_size(0),
			_capacity(0)
		{
			reserve(ft::distance(first, last));

			for (iterator it_arg = first; it_arg != last; it_arg++)
			{
				_allocator.construct(_start + _size, *it_arg);
				_size++;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1f796(%rip), %rax     # 0x4a370
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq (%rdx), %rsi
subq (%r15), %rsi
sarq $0x2, %rsi
callq 0x12ef6
movq (%r15), %rax
movq (%r14), %rcx
cmpq %rcx, %rax
je 0x2ac28
leaq 0x18(%rbx), %rdx
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rsi
movl (%rax), %r8d
movl %r8d, (%rdi,%rsi,4)
incq %rsi
addq $0x4, %rax
cmpq %rcx, %rax
jne 0x2ac12
movq %rsi, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<int, std::allocator<int>>::assign(unsigned long, int const&)
void
		assign(size_type n, value_type const& val)
		{
			// Destroy existing elements
			clear();

			// Make sure there is enough or just enough space for the new data
			reserve(n);

			// Setting new elements
			insert(begin(), n, val);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x18(%rdi)
je 0x3115e
movq $0x0, 0x18(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x12ef6
movq 0x8(%r15), %rax
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x315c2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::erase(ft::random_access_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
iterator
		erase(iterator position)
		{
			// Destroy the element at position
			_allocator.destroy(&*position);

			// Offset all the elements by one to fill the gap
			for (iterator it = position; it + 1 != end(); it++)
			{
				_allocator.construct(&*it, *(it + 1));
				_allocator.destroy(&*(it + 1));
			}

			_size--;

			return position;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdx), %rax
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x31afc
callq 0x5190
movq (%rbx), %r12
addq $0x20, %r12
movq 0x18(%r15), %rax
movq %rax, %rcx
shlq $0x5, %rcx
addq 0x8(%r15), %rcx
cmpq %rcx, %r12
je 0x31b4c
leaq -0x20(%r12), %rdi
leaq -0x10(%r12), %rax
movq %rax, -0x20(%r12)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x728c
movq (%r12), %rdi
leaq 0x10(%r12), %rax
cmpq %rdi, %rax
je 0x31aff
callq 0x5190
jmp 0x31aff
decq %rax
movq %rax, 0x18(%r15)
movq (%rbx), %rax
movq %rax, (%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DimitriDaSilva[P]42_ft_containers/containers/vector.hpp
// Function: ft::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::erase(ft::random_access_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ft::random_access_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
iterator
		erase(iterator first, iterator last)
		{
			difference_type	distance = ft::distance(first, last);
			iterator save_first = first;

			// Destroy the range of elements
			while (first != last)
				_allocator.destroy(&*first++);

			// Offset all the elements by distance to fill the gap
			for (iterator it = save_first; it + distance != end(); it++)
			{
				_allocator.construct(&*it, *(it + distance));
				_allocator.destroy(&*(it + distance));
			}

			_size -= distance;

			return save_first;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rdx), %r15
movq (%rcx), %r14
movq %r14, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
movq %r15, (%rdi)
subq %r15, %r14
je 0x31bbc
movq %rcx, %r12
movq %rdx, %r13
movq %r15, %rax
leaq 0x20(%rax), %rcx
movq %rcx, (%r13)
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x31bb2
callq 0x5190
movq (%r13), %rax
cmpq (%r12), %rax
jne 0x31b99
movq 0x18(%rbx), %rax
movq %rax, %rcx
shlq $0x5, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, -0x30(%rbp)
je 0x31c20
leaq 0x10(%r15), %rax
movq %rax, (%r15)
leaq (%r15,%r14), %r12
addq $0x10, %r12
movq -0x10(%r12), %rsi
movq -0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x728c
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x31c04
callq 0x5190
addq $0x20, %r15
movq 0x18(%rbx), %rax
movq %rax, %rcx
shlq $0x5, %rcx
addq 0x8(%rbx), %rcx
addq $0x10, %r12
cmpq %rcx, %r12
jne 0x31bd1
sarq $0x5, %r14
subq %r14, %rax
movq %rax, 0x18(%rbx)
movq -0x38(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/pokorj54[P]Pathfinder-utilities/src/arithmancy.cpp
// Function: SumDigits(int)
int SumDigits(int n)
{
    while(n > 9)
    {
        int tmp = 0;
        while(n > 0)
        {
            tmp += n % 10;
            n /= 10;
        }
        n = tmp;
    }
    return n;
}

// Assembly:
cmpl $0xa, %edi
jl 0x2abd
xorl %edx, %edx
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
movl %edi, %esi
imulq %rcx, %rsi
shrq $0x23, %rsi
leal (%rsi,%rsi), %eax
leal (%rax,%rax,4), %eax
movl %edi, %r8d
subl %eax, %r8d
movl %edx, %eax
addl %r8d, %eax
movl %eax, %edx
cmpl $0xa, %edi
movl %esi, %edi
jae 0x2a8c
movl $0x0, %edx
movl %eax, %edi
cmpl $0xa, %eax
jae 0x2a8c
retq
movl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/pokorj54[P]Pathfinder-utilities/src/dices.cpp
// Function: DiceRoller::RollDices(std::__cxx11::list<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&)
RollResult DiceRoller::RollDices(const list<pair<int, int>> & dices)
{
    RollResult rollResult;
    for(pair<int, int> group : dices)
    {
        for(int i = 0; i < group.first; ++i)
        {
            rollResult.AddDiceResult(RollDice(group.second));
        }
    }
    return rollResult;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
movq (%rdx), %rax
movq %rdx, 0x10(%rsp)
cmpq %rdx, %rax
je 0x2e25
movq %rsi, %r15
leaq 0x8(%rsp), %r12
movq %rax, (%rsp)
movl 0x10(%rax), %r14d
testl %r14d, %r14d
jle 0x2e17
movq (%rsp), %rax
movl 0x14(%rax), %ebp
movl $0x1, 0x8(%rsp)
movl %ebp, 0xc(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3120
movl %eax, %r13d
movl $0x18, %edi
callq 0x2180
movq %r13, %rcx
shlq $0x20, %rcx
orq %rbp, %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2050
incq 0x10(%rbx)
addl %r13d, 0x18(%rbx)
decl %r14d
jne 0x2dca
movq (%rsp), %rax
movq (%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x2db6
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x2e52
movq (%rdi), %r15
callq 0x2160
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x2e42
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/pokorj54[P]Pathfinder-utilities/src/dices.cpp
// Function: DiceRoller::ParseDiceString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
RollResult DiceRoller::ParseDiceString(const std::string & diceString)
{
    RollResult rollResult;
    stringstream ss(diceString);
    int amount, sides;
    ss >> amount;
    while(!ss.fail())
    {
        char c = 0;
        ss >> c;
        if(c == 'd')
        {
            ss >> sides;
            for(int i = 0; i < amount; ++i)
            {
                rollResult.AddDiceResult(RollDice(sides));
            }
            ss >> c;
        }
        else
        {
            rollResult.AddModifier(amount);
        }
        ss >> amount;
    }
    return rollResult;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
movl $0x18, %edx
callq 0x2220
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x20e0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x2f9c
leaq 0x20(%rsp), %r15
leaq 0xf(%rsp), %r12
leaq 0x18(%rsp), %rbp
leaq 0x10(%rsp), %r13
movb $0x0, 0xf(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
cmpb $0x64, 0xf(%rsp)
jne 0x2f76
movq %r15, %rdi
leaq 0x14(%rsp), %rsi
callq 0x20e0
cmpl $0x0, 0x10(%rsp)
jle 0x2f5a
xorl %r12d, %r12d
movl 0x14(%rsp), %r15d
movl $0x1, 0x18(%rsp)
movl %r15d, 0x1c(%rsp)
movq %rbp, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x3120
movl %eax, %r13d
movl $0x18, %edi
callq 0x2180
movq %r13, %rcx
shlq $0x20, %rcx
orq %r15, %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2050
incq 0x10(%rbx)
addl %r13d, 0x18(%rbx)
incl %r12d
cmpl 0x10(%rsp), %r12d
jl 0x2f02
leaq 0x20(%rsp), %r15
movq %r15, %rdi
leaq 0xf(%rsp), %r12
movq %r12, %rsi
callq 0x21d0
leaq 0x10(%rsp), %r13
jmp 0x2f7d
movl 0x10(%rsp), %eax
addl %eax, 0x18(%rbx)
movq %r15, %rdi
movq %r13, %rsi
callq 0x20e0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
je 0x2ed0
movq 0x601d(%rip), %rsi      # 0x8fc0
leaq 0x20(%rsp), %rdi
callq 0x2120
leaq 0xa0(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2fd8
movq %rax, %r14
jmp 0x2ff9
jmp 0x2fd8
movq %rax, %r14
movq 0x5fde(%rip), %rsi      # 0x8fc0
leaq 0x20(%rsp), %rdi
callq 0x2120
leaq 0xa0(%rsp), %rdi
callq 0x20a0
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x3011
movq (%rdi), %r15
callq 0x2160
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x3001
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18967(%rip), %r12     # 0x1cfd0
movq (%r12), %rcx
leaq 0x11c85(%rip), %rdi     # 0x162f9
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x45e0
cmpq %rbx, %r14
ja 0x46a6
leaq 0x11c78(%rip), %r15     # 0x16303
movswl (%r14), %edx
movq (%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4470
addq $0x2, %r14
cmpq %rbx, %r14
jbe 0x468b
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x43b0
// File: /workspace/github_cpp_makefile_star2_O1/tap3edit[P]tap3xml/nrt2xml.cpp
// Function: help()
void help()
{
    cerr << "Copyright (C) 2005-2018 Javier Gutierrez <https://github.com/tap3edit>\n";
    cerr << "Usage: nrt2xml -x|-a inputfile [outputfile]\n";
    cerr << "  -x: ASN -> XML\n";
    cerr << "  -a: XML -> ASN\n";
    exit(1);
}

// Assembly:
pushq %rbx
movq 0x16894(%rip), %rbx     # 0x1cff0
leaq 0xea4a(%rip), %rsi      # 0x151ad
movq %rbx, %rdi
callq 0x42b0
leaq 0xea83(%rip), %rsi      # 0x151f5
movq %rbx, %rdi
callq 0x42b0
leaq 0xeaa1(%rip), %rsi      # 0x15222
movq %rbx, %rdi
callq 0x42b0
leaq 0xeaa4(%rip), %rsi      # 0x15234
movq %rbx, %rdi
callq 0x42b0
movl $0x1, %edi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4420
movq %rsp, %rdi
movq %r14, %rsi
callq 0x7cb0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x4340
leaq 0x10(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x67fa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x30(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r15
addq $0x20, %r15
cmpb $0x0, 0xe1(%r15)
jne 0x683e
movq %r15, %rdi
movl $0x20, %esi
callq 0x42a0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %r14, %rdi
callq 0x7ca8
leaq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x4560
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x30(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r15
addq $0x20, %r15
cmpb $0x0, 0xe1(%r15)
jne 0x689e
movq %r15, %rdi
movl $0x20, %esi
callq 0x42a0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq %r14, %rdi
callq 0x7cac
leaq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x4560
leaq 0xe7b8(%rip), %rsi      # 0x15079
leaq 0x20(%rsp), %rdi
movl $0x4, %edx
callq 0x4340
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x44e0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6989
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x68fe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x166bb(%rip), %rsi     # 0x1cfc0
leaq 0x20(%rsp), %rdi
callq 0x4170
leaq 0x90(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
jne 0x694f
jmp 0x6963
jmp 0x6960
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6963
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x6963
jmp 0x6960
movq %rax, %rbx
movq 0x16656(%rip), %rsi     # 0x1cfc0
leaq 0x20(%rsp), %rdi
callq 0x4170
leaq 0x90(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
movq 0x169da(%rip), %r12     # 0x1d380
cmpq 0x169db(%rip), %r12     # 0x1d388
je 0x6a8e
leaq 0x38(%rsp), %r13
leaq 0x10(%rsp), %rbx
leaq 0x28(%rsp), %r15
movq %r13, 0x28(%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x6dac
movq %r15, %rdi
leaq 0x10806(%rip), %rsi     # 0x171eb
callq 0x45d0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x40f0
movq %rbx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6a1a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6a20
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
leaq 0xe803(%rip), %rsi      # 0x15246
callq 0x4360
movq %rax, %rbp
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x6a61
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x6a78
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
testq %rbp, %rbp
jne 0x6ab1
addq $0x20, %r12
cmpq 0x16900(%rip), %r12     # 0x1d388
jne 0x69c2
movq 0x20(%rsp), %r15
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x6dac
jmp 0x6b4b
movq %rbp, %rdi
callq 0x42c0
movq %rsp, %r15
movq %rbx, (%r15)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x6dac
leaq 0x10711(%rip), %rsi     # 0x171eb
movq %r15, %rdi
callq 0x45d0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rsp, %rdi
callq 0x40f0
movq 0x20(%rsp), %r15
leaq 0x10(%r15), %rdx
movq %rdx, (%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x6b18
movq %rsi, (%r15)
movq (%rcx), %rdx
movq %rdx, 0x10(%r15)
jmp 0x6b1e
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x6b4b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6b5f
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x6b8e
movq 0x10(%rsp), %rsi
jmp 0x6b86
jmp 0x6b74
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x6b8e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpb $0x22, (%rsi)
jne 0xa2c7
xorl %eax, %eax
movq %rsi, %rdx
leaq 0x1(%rdx), %rcx
movzbl 0x1(%rdx), %r8d
cmpl $0x5b, %r8d
jle 0xa2a3
cmpl $0x5c, %r8d
jne 0xa2b5
cmpb $0x5c, 0x2(%rdx)
jne 0xa2c7
addq $0x2, %rdx
movq %rdx, %rcx
jmp 0xa2b5
cmpl $0x22, %r8d
je 0xa2fa
cmpl $0x27, %r8d
je 0xa2c7
cmpl $0x2c, %r8d
je 0xa2c7
testq %rdi, %rdi
je 0xa2bf
movb (%rcx), %dl
movb %dl, (%rdi,%rax)
incq %rax
movq %rcx, %rdx
jmp 0xa27f
testq %rdi, %rdi
je 0xa2e4
movq $-0x1, %rax
movb 0x1(%rsi,%rax), %cl
movb %cl, 0x1(%rdi,%rax)
incq %rax
testb %cl, %cl
jne 0xa2d3
jmp 0xa2f9
movq $-0x1, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rsi,%rcx)
movq %rax, %rcx
jne 0xa2eb
retq
testq %rdi, %rdi
je 0xa2f9
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x4420
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xc885
movq (%r14), %rcx
xorl %edx, %edx
xorl %esi, %esi
shlq $0x8, %rsi
movzbl (%rcx,%rdx), %edi
orq %rdi, %rsi
incq %rdx
cmpq %rdx, %rax
jne 0xc870
jmp 0xc887
xorl %esi, %esi
movq %rsp, %rdi
callq 0x41c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x1071d(%rip), %rsi     # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x106f3(%rip), %rsi     # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/tap3edit[P]tap3xml/global.cpp
// Function: dec2bcd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string dec2bcd(const string &str)
{
    ostringstream bcd, rbcd;
    unsigned long long intstr, msb;
    string bcd_str;


    /* Note: For the moment we will not support numbers bigger than 2**31 */

    intstr=atoll(str.c_str());

    do
    {

        bcd << (uchar)(intstr&0xFF);
        msb=intstr&0x80;
        intstr>>=8;
        
    } while (intstr>0);

    if (msb && ( atoll(str.c_str()) > 0))
        bcd << (uchar)0x00;

    if (!msb && ( atoll(str.c_str()) < 0))
        bcd << (uchar)0xFF;

    bcd_str=bcd.str();
    
    string::reverse_iterator rii=bcd_str.rbegin();
    while (rii!=bcd_str.rend())
    {
        rbcd << *rii++;
    }

    return rbcd.str();
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x338, %rsp            # imm = 0x338
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4420
leaq 0x1c0(%rsp), %rdi
callq 0x4420
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq (%r14), %rdi
callq 0x4230
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rax, %rbp
movb %bpl, 0x8(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x4340
movq %rbp, %rax
shrq $0x8, %rax
cmpq $0xff, %rbp
ja 0xc93d
movq (%r14), %rdi
callq 0x4230
cmpq $0x80, %rbp
jae 0xc994
testq %rax, %rax
jns 0xc9b0
leaq 0x8(%rsp), %rsi
movb $-0x1, (%rsi)
leaq 0x48(%rsp), %rdi
movl $0x1, %edx
callq 0x4340
jmp 0xc9b0
testq %rax, %rax
jle 0xc9b0
leaq 0x8(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x48(%rsp), %rdi
movl $0x1, %edx
callq 0x4340
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x44e0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x43a0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc9eb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x30(%rsp), %r12
testq %r12, %r12
je 0xca2a
addq 0x28(%rsp), %r12
leaq 0x1c0(%rsp), %r14
leaq 0x8(%rsp), %r15
movb -0x1(%r12), %al
movb %al, 0x8(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4340
decq %r12
cmpq 0x28(%rsp), %r12
jne 0xca07
leaq 0x1c8(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xca51
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x10568(%rip), %r14     # 0x1cfc0
leaq 0x1c0(%rsp), %rdi
movq %r14, %rsi
callq 0x4170
leaq 0x230(%rsp), %rdi
callq 0x4100
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x4170
leaq 0xb8(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x338, %rsp            # imm = 0x338
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcab1
jmp 0xcab1
jmp 0xcab1
movq %rax, %rbx
jmp 0xcaec
jmp 0xcab1
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xcacb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x104ee(%rip), %rsi     # 0x1cfc0
leaq 0x1c0(%rsp), %rdi
callq 0x4170
leaq 0x230(%rsp), %rdi
callq 0x4100
movq 0x104cd(%rip), %rsi     # 0x1cfc0
leaq 0x48(%rsp), %rdi
callq 0x4170
leaq 0xb8(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4420
cmpq $0x0, 0x8(%r14)
je 0xcbc3
movq (%r14), %r13
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rcx
movl 0x20(%rsp,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x20(%rsp,%rcx)
movq -0x18(%rax), %rcx
movq $0x2, 0x18(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r12
addq $0x8, %r12
cmpb $0x0, 0xe1(%r12)
jne 0xcb9e
movq %r12, %rdi
movl $0x20, %esi
callq 0x42a0
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
movzbl (%r13), %esi
movq %r15, %rdi
callq 0x4560
incq %r13
movq (%r14), %rax
addq 0x8(%r14), %rax
cmpq %rax, %r13
jne 0xcb45
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x103e9(%rip), %rsi     # 0x1cfc0
leaq 0x8(%rsp), %rdi
callq 0x4170
leaq 0x78(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xcc01
movq %rax, %rbx
movq 0x103b5(%rip), %rsi     # 0x1cfc0
leaq 0x8(%rsp), %rdi
callq 0x4170
leaq 0x78(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4420
cmpl $0x0, 0x8(%r14)
jle 0xcd92
leaq 0x18(%rsp), %r13
xorl %r15d, %r15d
leaq 0x50(%rsp), %r12
movl $0x2, %ecx
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4300
movq 0x38(%rsp), %rbx
cmpq $0x1, %rbx
sete 0x6(%rsp)
jne 0xcccf
movl $0x2, %ecx
movq %r12, %rbp
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4300
movq %rbp, %rdi
leaq 0x9540(%rip), %rsi      # 0x161e7
callq 0x45d0
movq %r13, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xcce6
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xccee
movl $0x2, %ecx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4300
jmp 0xcd06
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x4450
movb %al, 0x7(%rsp)
movl $0x1, %edx
leaq 0x70(%rsp), %rdi
leaq 0x7(%rsp), %rsi
callq 0x4340
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xcd46
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpq $0x1, %rbx
jne 0xcd68
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0xcd68
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0xcd84
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x2, %r15
cmpl 0x8(%r14), %r15d
jl 0xcc62
leaq 0x78(%rsp), %rsi
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x44e0
movq 0x10215(%rip), %rsi     # 0x1cfc0
leaq 0x70(%rsp), %rdi
callq 0x4170
leaq 0xe0(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcde3
movq %rax, %r14
movb $0x1, 0x6(%rsp)
jmp 0xce2e
movq %rax, %r14
jmp 0xce4f
movq %rax, %r14
jmp 0xce07
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xce07
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpq $0x1, %rbx
jne 0xce2e
movq 0x50(%rsp), %rdi
movb $0x1, 0x6(%rsp)
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0xce2e
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpb $0x0, 0x6(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0xce4f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x1016a(%rip), %rsi     # 0x1cfc0
leaq 0x70(%rsp), %rdi
callq 0x4170
leaq 0xe0(%rsp), %rdi
callq 0x4100
movq %r14, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/tap3edit[P]tap3xml/global.cpp
// Function: bcd2hexa_no_f(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string bcd2hexa_no_f(const string &str)
{

    ostringstream value;


    string::const_iterator cii;
    for (cii=str.begin();cii!=str.end();cii++)
    {
        if (cii+1 == str.end() && (int)(uchar)(*cii & 0x0F) == 15) /* 15 = ascii of 'f' */
        {
            value << hex << setw(1) << (int)(uchar)((*cii >> 4) & 0x0F); /* Remove the last byte */
        } 
        else
        {
            value << hex << setw(2) << setfill('0') << (int)(uchar)*cii;
        }
    }


    return value.str();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x4420
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xcf65
movq (%r14), %rbp
addq %rbp, %rax
movq %rsp, %r15
leaq 0x1(%rbp), %r13
cmpq %rax, %r13
jne 0xcee7
movb (%rbp), %al
notb %al
testb $0xf, %al
jne 0xcee7
movq (%rsp), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rsp,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rsp,%rcx)
movq -0x18(%rax), %rax
movq $0x1, 0x10(%rsp,%rax)
movb (%rbp), %al
shrb $0x4, %al
jmp 0xcf47
movq (%rsp), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rsp,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rsp,%rcx)
movq -0x18(%rax), %rcx
movq $0x2, 0x10(%rsp,%rcx)
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r12
cmpb $0x0, 0xe1(%r12)
jne 0xcf3b
movq %r12, %rdi
movl $0x20, %esi
callq 0x42a0
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
movb (%rbp), %al
movzbl %al, %esi
movq %r15, %rdi
callq 0x4560
movq (%r14), %rax
addq 0x8(%r14), %rax
movq %r13, %rbp
cmpq %rax, %r13
jne 0xceaa
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0x10047(%rip), %rsi     # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcfa2
movq %rax, %rbx
movq 0x10014(%rip), %rsi     # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rsi, %rsi
je 0xd137
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xffdc(%rip), %r15      # 0x1cfc8
leaq 0x99e8(%rip), %rsi      # 0x169db
movl $0xb, %edx
movq %r15, %rdi
callq 0x4340
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x4340
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
leaq 0x99a7(%rip), %rsi      # 0x169e7
movl $0xb, %edx
movq %r15, %rdi
callq 0x4340
movzwl 0x20(%rbx), %esi
andl $0x3, %esi
movq %r15, %rdi
callq 0x41d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
cmpq $0x0, 0x48(%rbx)
je 0xd0de
movq 0xff34(%rip), %r12      # 0x1cfc8
leaq 0x9958(%rip), %rsi      # 0x169f3
movl $0xb, %edx
movq %r12, %rdi
callq 0x4340
movq 0x48(%rbx), %rsi
movq %r12, %rdi
callq 0x4210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0xd12c
movq (%rax), %r15
movq 0x50(%rbx), %rax
cmpq 0x8(%rax), %r15
je 0xd12c
movq (%r15), %rsi
movq %r14, %rdi
callq 0xcfce
addq $0x8, %r15
jmp 0xd111
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x4420
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xd1c3
movq (%r14), %rcx
xorl %edx, %edx
xorl %esi, %esi
movzbl (%rcx,%rdx), %edi
addl %edi, %esi
incq %rdx
cmpq %rdx, %rax
jne 0xd1b3
jmp 0xd1c5
xorl %esi, %esi
movq %rsp, %rdi
callq 0x4560
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0xfddf(%rip), %rsi      # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0xfdb5(%rip), %rsi      # 0x1cfc0
movq %rsp, %rdi
callq 0x4170
leaq 0x70(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4420
movq (%r14), %rdi
callq 0x44d0
testl %eax, %eax
jle 0xd2a4
movl %eax, %r14d
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %r12
cmpl $0x100, %r14d           # imm = 0x100
jl 0xd27c
movb $-0x1, 0xf(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x4340
jmp 0xd291
movb %r14b, 0xf(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x4340
leal -0xff(%r14), %eax
cmpl $0xff, %r14d
movl %eax, %r14d
jg 0xd25c
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x44e0
movq 0xfd08(%rip), %rsi      # 0x1cfc0
leaq 0x10(%rsp), %rdi
callq 0x4170
leaq 0x80(%rsp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xd2e3
movq %rax, %rbx
movq 0xfcd3(%rip), %rsi      # 0x1cfc0
leaq 0x10(%rsp), %rdi
callq 0x4170
leaq 0x80(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xde87
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %r14
testq %r14, %r14
je 0xde14
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0xde07
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movl $0x20, %esi
movq %r14, %rdi
callq 0x42e0
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0xde5e
movq (%rax), %r15
movq 0x50(%rbx), %r14
cmpq 0x8(%r14), %r15
je 0xde38
movq (%r15), %rdi
callq 0xddd6
addq $0x8, %r15
jmp 0xde20
testq %r14, %r14
je 0xde5e
movq (%r14), %rdi
testq %rdi, %rdi
je 0xde51
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x42e0
movl $0x18, %esi
movq %r14, %rdi
callq 0x42e0
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0xde75
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movl $0x58, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x42e0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x228(%rdi), %rax
jle 0xe438
movq 0xec76(%rip), %r15      # 0x1cff0
leaq 0x875d(%rip), %rsi      # 0x16ade
movl $0x2c, %edx
movq %r15, %rdi
callq 0x4340
movq (%r14), %rsi
movq %r15, %rdi
callq 0x4290
movq %rax, %r15
leaq 0x8768(%rip), %rsi      # 0x16b0b
movl $0x6, %edx
movq %rax, %rdi
callq 0x4340
movq 0x228(%rbx), %rsi
movq %r15, %rdi
callq 0x4290
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x86bf(%rip), %rsi      # 0x16ab9
leaq 0x86c2(%rip), %rdx      # 0x16ac3
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6e3c
leaq 0x4(%rsp), %rsi
movl $0x92, (%rsi)
movq %r15, %rdi
callq 0xd138
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe438
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq (%r14), %rax
movq %rax, 0x220(%rbx)
cmpl $0x0, 0x230(%rbx)
jne 0xe45c
addq $0x18, %rbx
movq (%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x43d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe482
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe4b1
callq 0x43e0
movq %r14, %rdi
callq 0x4030
movq %rax, 0x8(%rbx)
cmpl $0x0, 0x230(%rbx)
jne 0xe5c8
movq 0x220(%rbx), %rsi
leaq (%rsi,%r14), %rcx
cmpq 0x228(%rbx), %rcx
jle 0xe5ba
movq 0xeb07(%rip), %r15      # 0x1cff0
leaq 0x8622(%rip), %rsi      # 0x16b12
movl $0xf, %edx
movq %r15, %rdi
callq 0x4340
movq %r15, %rdi
movq %r14, %rsi
callq 0x4290
movq %rax, %r12
leaq 0x8610(%rip), %rsi      # 0x16b22
movl $0x28, %edx
movq %rax, %rdi
callq 0x4340
movq 0x220(%rbx), %rsi
movq %r12, %rdi
callq 0x4290
leaq 0x8616(%rip), %rsi      # 0x16b4b
movl $0x1a, %edx
movq %r15, %rdi
callq 0x4340
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41e0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x853f(%rip), %rsi      # 0x16ab9
leaq 0x8542(%rip), %rdx      # 0x16ac3
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6e3c
leaq 0x4(%rsp), %rsi
movl $0xba, (%rsi)
movq %r15, %rdi
callq 0xd138
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe5c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0xe5c8
addq (%rbx), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x4240
movq %r14, 0x10(%rbx)
addq 0x220(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xe352
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe609
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
cmpl $0x0, 0x230(%rdi)
je 0xe70a
leaq 0x18(%rbx), %rdi
callq 0x40a0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xe717
callq 0x43e0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xe725
callq 0x43e0
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x40b0
movq %rax, %rdi
callq 0x6da0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq $0x0, 0x8(%rdi)
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x4550
movq (%r15), %rsi
movq %rbx, %rdi
movl $0x14, %edx
callq 0x4070
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
je 0xe86f
movq 0xe7f2(%rip), %rdi      # 0x1cff0
leaq 0x829e(%rip), %rsi      # 0x16aa3
movl $0x15, %edx
callq 0x4340
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0xe7d3(%rip), %rdi      # 0x1cff0
callq 0x4340
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8334(%rip), %rsi      # 0x16b66
leaq 0x8338(%rip), %rdx      # 0x16b71
leaq 0x10(%rsp), %rdi
callq 0x6e3c
leaq 0xc(%rsp), %rsi
movl $0x3f, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0xd138
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0xe86f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movl $0x110, %edi            # imm = 0x110
callq 0x42d0
movq %rax, %r15
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x4120
movq %r15, 0x218(%r14)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0xe8c7
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0xe8bd
jmp 0xe8c4
movq %rax, %r14
movl $0x110, %esi            # imm = 0x110
movq %r15, %rdi
callq 0x42e0
jmp 0xe8c7
movq %rax, %r14
movq %rbx, %rdi
callq 0x4490
movq %r14, %rdi
callq 0x4590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x4460
movq 0x218(%rbx), %rdi
testq %rdi, %rdi
je 0xe919
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xe927
callq 0x43e0
movq 0xe682(%rip), %rax      # 0x1cfb0
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, 0x18(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x18(%rbx,%rcx)
leaq 0x20(%rbx), %rdi
callq 0x4250
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %rdi
popq %rbx
jmp 0x4100
movq %rax, %rdi
callq 0x6da0
nop