LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/tools.cpp
// Function: sigterm_caught()
bool sigterm_caught ()
{
    if (!sigterm_installed)
    {
        sigterm_caught_flag = false;
        sigterm_installed = true;
        signal (SIGTERM, sigterm_handler);
    }

    return sigterm_caught_flag;
}

// Assembly:
cmpb $0x0, 0x214edb(%rip)    # 0x6557b8
jne 0x440903
pushq %rax
movb $0x0, 0x214ed2(%rip)    # 0x6557b9
movb $0x1, 0x214eca(%rip)    # 0x6557b8
leaq 0x15(%rip), %rsi        # 0x44090a
movl $0xf, %edi
callq 0x512660
addq $0x8, %rsp
movb 0x214eb0(%rip), %al     # 0x6557b9
retq
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/tools.cpp
// Function: remove_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
bool remove_file (string_ref path, bool ignore_failure)
{
    if (::unlink (path.c_str ()) != 0 && !ignore_failure)
    {
        rt_error ("unlink failed for " + path);
        return false;
    }
    else
    {
        return true;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x57eec0
testl %eax, %eax
sete %al
orb %bpl, %al
je 0x440b9b
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1904e3(%rip), %rsi    # 0x5d1085
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x407ce4
movq %r14, %rdi
callq 0x440975
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x440bd6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/tools.cpp
// Function: hostname[abi:cxx11]()
string hostname ()
{
    char buf[HOST_NAME_MAX+1];
    gethostname (buf, HOST_NAME_MAX);
    buf[HOST_NAME_MAX] = 0;
    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0x40, %esi
movq %r14, %rdi
callq 0x57f5b0
movb $0x0, 0x40(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x401130
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40843e
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/tools.cpp
// Function: buffer_cerr()
void buffer_cerr ()
{
    // save the original stream buffer in case we need to restore it
    original_cerr_stream.rdbuf (std::cerr.rdbuf ());
    // redirect cerr to cerr_buffer
    std::cerr.rdbuf (cerr_buffer.rdbuf ());
}

// Assembly:
pushq %rbx
movq 0x214e63(%rip), %rax    # 0x655b38
leaq 0x214e5c(%rip), %rdi    # 0x655b38
addq -0x18(%rax), %rdi
movq $0x656aa0, %rbx         # imm = 0x656AA0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rbx,%rax), %rsi
callq 0x492460
movq (%rbx), %rax
addq -0x18(%rax), %rbx
leaq 0x214abf(%rip), %rsi    # 0x6557c8
movq %rbx, %rdi
popq %rbx
jmp 0x492460
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/tools.cpp
// Function: redirect_cerr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void redirect_cerr (string_ref filename, bool append)
{
    std::ios::openmode mode = std::ios::out;
    if (append)
        mode |= std::ios::app;
    cerr_logfile.open (filename, mode);
    if (!cerr_logfile)
        std::cerr << "cannot open log file " << filename << ABORT;

    // OK, assume the log is open. flush the buffer to the log
    std::cerr.flush ();
    cerr_logfile << cerr_buffer.str ();
    cerr_buffer.str ("");
    // redirect cerr to the log file
    std::cerr.rdbuf (cerr_logfile.rdbuf ());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leal 0x10(%rsi), %edx
leaq 0x214c12(%rip), %r14    # 0x655938
movq %r14, %rdi
movq %rbx, %rsi
callq 0x48d730
movq 0x214c00(%rip), %rax    # 0x655938
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rax,%r14)
jne 0x440df6
movq $0x656aa0, %rbx         # imm = 0x656AA0
movq %rbx, %rdi
callq 0x4b05a0
leaq 0x214a6a(%rip), %rsi    # 0x6557c8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4b79f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x214bbf(%rip), %rdi    # 0x655938
callq 0x4b14d0
leaq 0x18(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x440d99
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x1b22aa(%rip), %rdx    # 0x5f3052
movq %rdx, %rsi
callq 0x40843e
leaq 0x214a11(%rip), %rdi    # 0x6557c8
leaq 0x8(%rsp), %rsi
callq 0x4b7e60
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x440dd8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
leaq 0x214b5a(%rip), %rsi    # 0x655940
movq %rbx, %rdi
callq 0x492460
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq $0x656aa0, %rdi         # imm = 0x656AA0
leaq 0x190297(%rip), %rsi    # 0x5d109b
callq 0x4b1a00
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4c4460
movq %rax, %rdi
callq 0x440cc2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0x440e41
jmp 0x440e4e
movq %rax, %rbx
jmp 0x440e4e
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x440e4e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/tools.cpp
// Function: dont_redirect_cerr()
void dont_redirect_cerr ()
{
    // all in vain.
    std::cerr.flush ();
    original_cerr_stream << cerr_buffer.str ();
    cerr_buffer.str ("");
    // redirect cerr to the log file
    std::cerr.rdbuf (original_cerr_stream.rdbuf ());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq $0x656aa0, %rbx         # imm = 0x656AA0
movq %rbx, %rdi
callq 0x4b05a0
leaq 0x214953(%rip), %rsi    # 0x6557c8
movq %rsp, %r14
movq %r14, %rdi
callq 0x4b79f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x214caa(%rip), %r14    # 0x655b38
movq %r14, %rdi
callq 0x4b14d0
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x440eb1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1b2194(%rip), %rdx    # 0x5f3052
movq %rdx, %rsi
callq 0x40843e
leaq 0x2148fb(%rip), %rdi    # 0x6557c8
movq %rsp, %rsi
callq 0x4b7e60
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x440eeb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq 0x214c3f(%rip), %rax    # 0x655b38
movq -0x18(%rax), %rax
movq 0xe8(%rax,%r14), %rsi
movq %rbx, %rdi
callq 0x492460
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x440f3b
jmp 0x440f48
movq %rax, %rbx
jmp 0x440f48
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x440f48
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/tools.cpp
// Function: int_pop_arg[abi:cxx11](char const**)
static
std::pair <string, string> int_pop_arg (const char **argv)
{
    assert (*argv);
    string kw = *argv++;
    if (!*argv)
        rt_error ("missing argument for kw " + kw);
    return std::make_pair (kw, string (*argv));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x4410e7
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x407a6e
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x441106
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x407a6e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x408340
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
leaq 0x18(%rsp), %rcx
movq -0x10(%rcx), %rdx
cmpq %rcx, %rdx
je 0x4410b2
movq %rdx, 0x20(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rbx)
jmp 0x4410b8
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rbx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4410dc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x190108(%rip), %rdi    # 0x5d11f6
leaq 0x18ffeb(%rip), %rsi    # 0x5d10e0
leaq 0x190100(%rip), %rcx    # 0x5d11fc
movl $0x9a, %edx
callq 0x50c400
leaq 0x190124(%rip), %rsi    # 0x5d1231
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x407ce4
leaq 0x8(%rsp), %rdi
callq 0x440975
jmp 0x44112a
jmp 0x44114a
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x44114d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
jmp 0x44114d
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x441168
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/tools.cpp
// Function: RandomContext::refill_exp_buffer_()
void RandomContext::refill_exp_buffer_ ()
{
    for (int i = 0; i != RANDOM_EXPONENTIAL_BUFFER_SIZE; ++i)
        exp_buffer_[i] = real ();
    for (int i = 0; i != RANDOM_EXPONENTIAL_BUFFER_SIZE; ++i)
        exp_buffer_[i] = -std::log (1-exp_buffer_[i]);
    num_exp_used_ = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x139, %r14d           # imm = 0x139
movq %rbx, %rdi
callq 0x443b40
addsd 0x1897d3(%rip), %xmm0   # 0x5cafe8
movsd %xmm0, (%rbx,%r14,8)
incq %r14
cmpq $0x179, %r14            # imm = 0x179
jne 0x441805
xorl %r14d, %r14d
movsd 0x1887e6(%rip), %xmm0   # 0x5ca018
subsd 0x9c8(%rbx,%r14,8), %xmm0
callq 0x4ee2b0
xorpd 0x189887(%rip), %xmm0   # 0x5cb0d0
movlpd %xmm0, 0x9c8(%rbx,%r14,8)
incq %r14
cmpq $0x40, %r14
jne 0x44182a
movl $0x0, 0xbc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/tools.cpp
// Function: RandomContext::pareto(double, double)
double RandomContext::pareto (double paralpha, double minimum)
{
    assert (paralpha > 0.);
    assert (minimum > 0.);
    double u = 1 - real ();
    return pow (u, -1/paralpha) * minimum;
}

// Assembly:
subq $0x18, %rsp
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x4418c5
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
ucomisd %xmm2, %xmm1
jbe 0x4418e4
callq 0x443b40
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x188775(%rip), %xmm0   # 0x5ca018
subsd %xmm1, %xmm0
movsd 0x189749(%rip), %xmm1   # 0x5caff8
divsd 0x8(%rsp), %xmm1
callq 0x4ee2f0
mulsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
leaq 0x18f849(%rip), %rdi    # 0x5d1115
leaq 0x18f80d(%rip), %rsi    # 0x5d10e0
leaq 0x18f849(%rip), %rcx    # 0x5d1123
movl $0x103, %edx            # imm = 0x103
callq 0x50c400
leaq 0x18f865(%rip), %rdi    # 0x5d1150
leaq 0x18f7ee(%rip), %rsi    # 0x5d10e0
leaq 0x18f82a(%rip), %rcx    # 0x5d1123
movl $0x104, %edx            # imm = 0x104
callq 0x50c400
nop
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/tools.cpp
// Function: std::array<double, 3ul> RandomContext::fromsphere<3ul>(double)
vector <3> RandomContext::fromsphere <3> (double r)
{
    double x = real (-1, 1);
    double y = real (-1, 1);
    double z = real (-1, 1);
    double s = pow (x*x + y*y + z*z, -0.5) * r;
    return {{ s*x, s*y, s*z }};
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x443b40
addsd %xmm0, %xmm0
addsd 0x1895e7(%rip), %xmm0   # 0x5caff8
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0x443b40
addsd %xmm0, %xmm0
addsd 0x1895cd(%rip), %xmm0   # 0x5caff8
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x443b40
addsd %xmm0, %xmm0
addsd 0x1895b3(%rip), %xmm0   # 0x5caff8
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x1895ed(%rip), %xmm1   # 0x5cb060
callq 0x4ee2f0
mulsd 0x20(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/tools.cpp
// Function: std::array<double, 2ul> RandomContext::fromshell<2ul>(double, double)
vector <DIM> RandomContext::fromshell (double rmin, double rmax)
{
    assert (rmin >= 0.);
    assert (rmax > rmin);
    double dDIM = DIM;
    double u = real (pow (rmin, dDIM), pow (rmax, dDIM));
    return fromsphere <DIM> (pow (u, 1/dDIM));
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x442008
ucomisd %xmm0, %xmm1
jbe 0x442027
movq %rdi, %rbx
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
callq 0x441756
movsd 0x189003(%rip), %xmm1   # 0x5cafb0
callq 0x4ee2f0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x443b40
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm0
mulsd 0x189010(%rip), %xmm0   # 0x5cafe0
movsd %xmm0, 0x10(%rsp)
callq 0x4010f0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x401098
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
leaq 0x18f14e(%rip), %rdi    # 0x5d115d
leaq 0x18f0ca(%rip), %rsi    # 0x5d10e0
leaq 0x18f14b(%rip), %rcx    # 0x5d1168
movl $0x138, %edx            # imm = 0x138
callq 0x50c400
leaq 0x18f17b(%rip), %rdi    # 0x5d11a9
leaq 0x18f0ab(%rip), %rsi    # 0x5d10e0
leaq 0x18f12c(%rip), %rcx    # 0x5d1168
movl $0x139, %edx            # imm = 0x139
callq 0x50c400
// File: /workspace/github_cpp_makefile_star2_O1/codebrainz[P]libutfxx/utf/utf.cxx
// Function: ConvertUTF32toUTF16
ConversionResult ConvertUTF32toUTF16 (
	const UTF32** sourceStart, const UTF32* sourceEnd,
	UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
	ConversionResult result = conversionOK;
	const UTF32* source = *sourceStart;
	UTF16* target = *targetStart;
	while (source < sourceEnd) {
	UTF32 ch;
	if (target >= targetEnd) {
		result = targetExhausted; break;
	}
	ch = *source++;
	if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
		/* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
		if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
		if (flags == strictConversion) {
			--source; /* return to the illegal value itself */
			result = sourceIllegal;
			break;
		} else {
			*target++ = UNI_REPLACEMENT_CHAR;
		}
		} else {
		*target++ = (UTF16)ch; /* normal case */
		}
	} else if (ch > UNI_MAX_LEGAL_UTF32) {
		if (flags == strictConversion) {
		result = sourceIllegal;
		} else {
		*target++ = UNI_REPLACEMENT_CHAR;
		}
	} else {
		/* target is a character in range 0xFFFF - 0x10FFFF. */
		if (target + 1 >= targetEnd) {
		--source; /* Back up source pointer! */
		result = targetExhausted; break;
		}
		ch -= halfBase;
		*target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
		*target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
	}
	}
	*sourceStart = source;
	*targetStart = target;
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r10
movq (%rdx), %r9
xorl %r11d, %r11d
cmpq %rsi, %r10
jae 0x34df
movl $0x2, %eax
cmpq %rcx, %r9
jae 0x34c8
leaq 0x4(%r10), %rbx
movl (%r10), %r14d
cmpl $0xffff, %r14d          # imm = 0xFFFF
ja 0x345e
movl %r14d, %eax
andl $0xf800, %eax           # imm = 0xF800
cmpl $0xd800, %eax           # imm = 0xD800
jne 0x347b
testl %r8d, %r8d
je 0x34c3
movw $0xfffd, (%r9)          # imm = 0xFFFD
jmp 0x347f
cmpl $0x110000, %r14d        # imm = 0x110000
jb 0x3485
movb $0x1, %bpl
testl %r8d, %r8d
je 0x34d8
movw $0xfffd, (%r9)          # imm = 0xFFFD
addq $0x2, %r9
jmp 0x34bb
movw %r14w, (%r9)
addq $0x2, %r9
jmp 0x34b8
leaq 0x2(%r9), %r15
cmpq %rcx, %r15
jae 0x34c8
leal 0x3ff0000(%r14), %eax
shrl $0xa, %eax
addl $0xffffd800, %eax       # imm = 0xFFFFD800
movw %ax, (%r9)
andl $0x3ff, %r14d           # imm = 0x3FF
orl $0xdc00, %r14d          # imm = 0xDC00
movw %r14w, 0x2(%r9)
addq $0x4, %r9
movb $0x1, %bpl
movl %r11d, %eax
movq %rbx, %r10
jmp 0x34ca
movl $0x3, %eax
xorl %ebp, %ebp
movl %eax, %r11d
testb %bpl, %bpl
jne 0x341b
jmp 0x34e2
movl $0x3, %eax
jmp 0x34be
movl %r11d, %eax
movq %r10, (%rdi)
movq %r9, (%rdx)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/codebrainz[P]libutfxx/utf/utf.cxx
// Function: ConvertUTF16toUTF32
ConversionResult ConvertUTF16toUTF32 (
	const UTF16** sourceStart, const UTF16* sourceEnd,
	UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
	ConversionResult result = conversionOK;
	const UTF16* source = *sourceStart;
	UTF32* target = *targetStart;
	UTF32 ch, ch2;
	while (source < sourceEnd) {
	const UTF16* oldSource = source; /*  In case we have to back up because of target overflow. */
	ch = *source++;
	/* If we have a surrogate pair, convert to UTF32 first. */
	if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
		/* If the 16 bits following the high surrogate are in the source buffer... */
		if (source < sourceEnd) {
		ch2 = *source;
		/* If it's a low surrogate, convert to UTF32. */
		if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
			ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
			+ (ch2 - UNI_SUR_LOW_START) + halfBase;
			++source;
		} else if (flags == strictConversion) { /* it's an unpaired high surrogate */
			--source; /* return to the illegal value itself */
			result = sourceIllegal;
			break;
		}
		} else { /* We don't have the 16 bits following the high surrogate. */
		--source; /* return to the high surrogate */
		result = sourceExhausted;
		break;
		}
	} else if (flags == strictConversion) {
		/* UTF-16 surrogate values are illegal in UTF-32 */
		if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
		--source; /* return to the illegal value itself */
		result = sourceIllegal;
		break;
		}
	}
	if (target >= targetEnd) {
		source = oldSource; /* Back up source pointer! */
		result = targetExhausted; break;
	}
	*target++ = ch;
	}
	*sourceStart = source;
	*targetStart = target;
#ifdef CVTUTF_DEBUG
if (result == sourceIllegal) {
	fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
	fflush(stderr);
}
#endif
	return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r10
movq (%rdx), %r9
xorl %eax, %eax
cmpq %rsi, %r10
jae 0x359f
leaq 0x2(%r10), %rbx
movzwl (%r10), %r11d
movl %r11d, %ebp
andl $0xfc00, %ebp           # imm = 0xFC00
cmpl $0xd800, %ebp           # imm = 0xD800
jne 0x354b
cmpq %rsi, %rbx
jae 0x3565
movzwl (%rbx), %r14d
movl %r14d, %ebp
andl $0xfc00, %ebp           # imm = 0xFC00
cmpl $0xdc00, %ebp           # imm = 0xDC00
jne 0x356c
shll $0xa, %r11d
addl %r14d, %r11d
addl $0xfca02400, %r11d      # imm = 0xFCA02400
leaq 0x4(%r10), %rbx
jmp 0x3571
testl %r8d, %r8d
jne 0x3571
movzwl %bp, %ebp
cmpl $0xdc00, %ebp           # imm = 0xDC00
jne 0x3571
xorl %r11d, %r11d
movl $0x3, %eax
jmp 0x358d
movl $0x1, %eax
jmp 0x358a
testl %r8d, %r8d
je 0x3598
cmpq %rcx, %r9
jae 0x3585
movl %r11d, (%r9)
addq $0x4, %r9
movb $0x1, %r11b
movq %rbx, %r10
jmp 0x358d
movl $0x2, %eax
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x34fb
jmp 0x359f
movl $0x3, %eax
jmp 0x358a
movq %r10, (%rdi)
movq %r9, (%rdx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/codebrainz[P]libutfxx/utf/utf.cxx
// Function: isLegalUTF8Sequence
Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
	int length = trailingBytesForUTF8[*source]+1;
	if (source+length > sourceEnd) {
	return false;
	}
	return isLegalUTF8(source, length);
}

// Assembly:
movsbq (%rdi), %rax
leaq 0x291a(%rip), %rcx      # 0x6060
movsbq (%rax,%rcx), %rcx
leaq (%rdi,%rcx), %rdx
incq %rdx
cmpq %rsi, %rdx
ja 0x3770
movzbl %cl, %ecx
testl %ecx, %ecx
je 0x3773
cmpl $0x1, %ecx
jne 0x3770
cmpb $-0xc, %al
sete %cl
cmpb $-0x13, %al
sete %al
orb %cl, %al
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/codebrainz[P]libutfxx/utf/utf.cxx
// Function: void utf::convert_ptr_<char, char16_t, ConversionResult (*)(char const**, char const*, char16_t**, char16_t*, ConversionFlags), 32ul>(char const*, unsigned long, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>&, ConversionResult (*)(char const**, char const*, char16_t**, char16_t*, ConversionFlags))
void convert_ptr_(const InCharT* in, size_t in_size, std::basic_string<OutCharT>& out, FuncT cvt_func)
{
	OutCharT buf[BufSize] = {0};
	const InCharT* ss = in;
	const InCharT* se = ss + in_size;
	OutCharT* ts = &buf[0];
	OutCharT* te = ts + BufSize;

	while (true)
	{
		ConversionResult r = cvt_func(&ss, se, &ts, te, conv_flags);
		size_t len = ts - &buf[0];
		switch (r)
		{
			case conversionOK:
				out.append(buf, len);
				return;
			case sourceExhausted:
				throw source_exhausted();
			case targetExhausted:
				out.append(buf, len);
				ts = &buf[0];
				continue;
			case sourceIllegal:
				throw illegal_input();
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
addq %rdi, %r15
movq %rsp, %rax
movq %r12, (%rax)
leaq 0x21d2(%rip), %rbp      # 0x6178
xorl %r13d, %r13d
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rsp, %rdx
leaq 0x50(%rsp), %rcx
xorl %r8d, %r8d
callq *%rbx
cmpl $0x3, %eax
ja 0x4001
movq (%rsp), %rdx
subq %r12, %rdx
sarq %rdx
movl %eax, %eax
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movq %r14, %rdi
movq %r12, %rsi
callq 0x31a0
movl $0x1, %r13d
jmp 0x4001
movq %r14, %rdi
movq %r12, %rsi
callq 0x31a0
movq %r12, (%rsp)
movl $0x2, %r13d
testb $0x1, %r13b
je 0x3fa6
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %edi
callq 0x3090
movq %rax, %rbx
movq %rax, %rdi
callq 0x30c0
movq 0x4f4e(%rip), %rsi      # 0x8f80
jmp 0x4050
movl $0x18, %edi
callq 0x3090
movq %rax, %rbx
movq %rax, %rdi
callq 0x32b0
movq 0x4f80(%rip), %rsi      # 0x8fd0
movq 0x4f51(%rip), %rdx      # 0x8fa8
movq %rbx, %rdi
callq 0x32a0
jmp 0x4061
movq %rax, %r14
movq %rbx, %rdi
callq 0x3100
movq %r14, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/gliktaras[P]skyperole/skyperole.cpp
// Function: getStringProperty[abi:cxx11](unsigned long, unsigned long)
std::vector<std::string> getStringProperty(Window window, Atom property) {
    Atom actualType;
    int actualFormat;
    unsigned long itemCount;
    unsigned long bytesLeft;
    char *data;

    if (XGetWindowProperty(display, window, property, 0, INFINITY, False,
            AnyPropertyType, &actualType, &actualFormat, &itemCount, &bytesLeft,
            reinterpret_cast<unsigned char**>(&data)) == Success) {
        
        if (itemCount > 0) {
            std::vector<std::string> propertyStrings;
            propertyStrings.push_back(data);

            for (size_t i = 0; i < itemCount - 1; ++i) {
                if (data[i] == 0) {
                    propertyStrings.push_back(data + i + 1);
                }
            }    
            return propertyStrings;
        }
    }

    return std::vector<std::string>();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x39de(%rip), %rdi      # 0x6380
leaq 0x28(%rsp), %rax
leaq 0x40(%rsp), %r10
leaq 0x30(%rsp), %r14
leaq 0x3c(%rsp), %r11
leaq 0x48(%rsp), %r12
xorl %r15d, %r15d
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %r14
pushq %r11
pushq %r12
pushq %r15
callq 0x2040
addq $0x30, %rsp
movq (%r14), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %r15, 0x10(%rbx)
testl %eax, %eax
jne 0x2aad
testq %rcx, %rcx
je 0x2aad
movq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2fe4
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x32e4
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x2a38
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
cmpq $0x1, 0x30(%rsp)
je 0x2aad
movl $0x1, %r13d
leaq 0x8(%rsp), %r14
movq 0x28(%rsp), %r15
cmpb $0x0, -0x1(%r15,%r13)
jne 0x2a99
addq %r13, %r15
movq %r12, 0x8(%rsp)
movq %r15, %rdi
callq 0x2080
leaq (%rax,%r15), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x310e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32e4
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2a99
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x30(%rsp), %rax
decq %rax
leaq 0x1(%r13), %rcx
cmpq %rax, %r13
movq %rcx, %r13
jb 0x2a4b
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x2ae5
jmp 0x2af2
jmp 0x2ad3
movq %rax, %r14
jmp 0x2af2
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2af2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x3022
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/gliktaras[P]skyperole/skyperole.cpp
// Function: isSkypeWindow(unsigned long)
bool isSkypeWindow(Window window) {
    std::vector<std::string> classNames = getStringProperty(window, WM_CLASS_ATOM);
    for (size_t i = 0; i < classNames.size(); ++i) {
        if (classNames[i] == SKYPE_WINDOW_CLASS) {
            return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
movq 0x383c(%rip), %rdx      # 0x6388
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x298b
movq (%rbx), %r15
movq 0x8(%rbx), %r12
subq %r15, %r12
setne %bl
je 0x2bcb
sarq $0x5, %r12
movq 0x35ed(%rip), %r13      # 0x6160
movq 0x35de(%rip), %rax      # 0x6158
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
cmpq $0x1, %r12
sbbq %r12, %rbp
addq $0x8, %r15
movl $0x1, %r14d
movq (%r15), %rdx
cmpq %r13, %rdx
jne 0x2bb1
testq %rdx, %rdx
je 0x2bcb
movq -0x8(%r15), %rdi
movq 0x8(%rsp), %rsi
callq 0x21a0
testl %eax, %eax
je 0x2bcb
cmpq %r12, %r14
setb %bl
leaq (%r14,%rbp), %rax
incq %rax
incq %r14
addq $0x20, %r15
cmpq $0x1, %rax
jne 0x2b92
leaq 0x10(%rsp), %rdi
callq 0x3022
andb $0x1, %bl
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gliktaras[P]skyperole/skyperole.cpp
// Function: initialize(int, char**)
void initialize(int argc, char **argv) {
    parseArgs(argc, argv);

    display = XOpenDisplay(NULL);
    if (!display) {
        std::cerr << "Could not open a connection to the X server." << std::endl;
        exit(EXIT_FAILURE);
    }

    WM_CLASS_ATOM = XInternAtom(display, "WM_CLASS", false);
    WM_NAME_ATOM = XInternAtom(display, "_NET_WM_NAME", false);
    WM_WINDOW_ROLE_ATOM = XInternAtom(display, "WM_WINDOW_ROLE", false);

    int screenCount = XScreenCount(display);
    for (int i = 0; i < screenCount; ++i) {
        Window rootWindow = XRootWindow(display, i);
        XSelectInput(display, rootWindow, SubstructureNotifyMask);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x21e0
movq %rax, 0x356b(%rip)      # 0x6380
testq %rax, %rax
je 0x2eb1
leaq 0x1347(%rip), %rsi      # 0x416c
xorl %ebx, %ebx
movq %rax, %rdi
xorl %edx, %edx
callq 0x20f0
movq %rax, 0x3550(%rip)      # 0x6388
movq 0x3541(%rip), %rdi      # 0x6380
leaq 0x132f(%rip), %rsi      # 0x4175
xorl %edx, %edx
callq 0x20f0
movq %rax, 0x353c(%rip)      # 0x6390
movq 0x3525(%rip), %rdi      # 0x6380
leaq 0x1320(%rip), %rsi      # 0x4182
xorl %edx, %edx
callq 0x20f0
movq %rax, 0x3528(%rip)      # 0x6398
movq 0x3509(%rip), %rdi      # 0x6380
callq 0x2100
testl %eax, %eax
jle 0x2eaa
movl %eax, %ebp
movq 0x34f7(%rip), %rdi      # 0x6380
movl %ebx, %esi
callq 0x2210
movq 0x34e9(%rip), %rdi      # 0x6380
movl $0x80000, %edx          # imm = 0x80000
movq %rax, %rsi
callq 0x20b0
incl %ebx
cmpl %ebx, %ebp
jne 0x2e82
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x3138(%rip), %rdi      # 0x5ff0
leaq 0x1280(%rip), %rsi      # 0x413f
callq 0x2170
movq %rax, %rdi
callq 0x2090
movl $0x1, %edi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/gliktaras[P]skyperole/skyperole.cpp
// Function: scanWindowTree()
void scanWindowTree() {
    Window rootReturn;
    Window parentReturn;
    Window *children;
    unsigned int childCount;

    int screenCount = XScreenCount(display);
    for (int i = 0; i < screenCount; ++i) {
        Window rootWindow = XRootWindow(display, i);
        XQueryTree(display, rootWindow, &rootReturn, &parentReturn, &children, &childCount);

        for (unsigned int j = 0; j < childCount; ++j) {
            setWindowRole(children[j]);
        }
        XFree(children);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x3495(%rip), %rdi      # 0x6380
callq 0x2100
testl %eax, %eax
jle 0x2f6a
movl %eax, %ebx
xorl %r14d, %r14d
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0xc(%rsp), %rbp
movq 0x3471(%rip), %rdi      # 0x6380
movl %r14d, %esi
callq 0x2210
movq 0x3462(%rip), %rdi      # 0x6380
movq %rax, %rsi
leaq 0x20(%rsp), %rdx
movq %r12, %rcx
movq %r13, %r8
movq %rbp, %r9
callq 0x2070
cmpl $0x0, 0xc(%rsp)
je 0x2f58
xorl %r15d, %r15d
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %rdi
callq 0x2be9
incq %r15
movl 0xc(%rsp), %eax
cmpq %rax, %r15
jb 0x2f3e
movq 0x10(%rsp), %rdi
callq 0x21d0
incl %r14d
cmpl %ebx, %r14d
jne 0x2f08
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gliktaras[P]skyperole/skyperole.cpp
// Function: eventLoop()
void eventLoop() {
    timespec sleep_timespec = { 0, SLEEP_TIME_NS };
    XEvent event;

    while (true) {
        while (XPending(display)) {
            XNextEvent(display, &event);

            switch (event.type) {
            case CreateNotify :
                setWindowRole(event.xcreatewindow.window);
                break;

            default :
                break;
            }
        }

        nanosleep(&sleep_timespec, NULL);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movups 0x124e(%rip), %xmm0     # 0x41d8
movq %rsp, %rbx
movaps %xmm0, (%rbx)
leaq 0x18(%rsp), %r14
movq 0x33e4(%rip), %rdi      # 0x6380
callq 0x2150
testl %eax, %eax
je 0x2fc7
movq 0x33d4(%rip), %rdi      # 0x6380
movq %r14, %rsi
callq 0x21f0
cmpl $0x10, 0x18(%rsp)
jne 0x2f95
movq 0x40(%rsp), %rdi
callq 0x2be9
jmp 0x2f95
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2050
jmp 0x2f95
// File: /workspace/github_cpp_makefile_star2_O1/gprateek93[P]LaTeX_to_HTML/main.cpp
// Function: main
int main(int argc, char *argv[]) {
	if(argc<2){
		cout<<"error in entering arguments. Correct Format: ./compiler <input.txt>";
	}
	yyin = fopen(argv[1], "r");
	init_content_children();
	init_list_children();
	init_section_children();
	init_subsection_children();
	init_rows_children();
	init_r_content_children();
	init_cell_children();
	init_figure_children();
	init_math_children();
	// parse through the input until there is no more:
	do {
		yyparse();
	} while (!feof(yyin));
	converter C;
	string s = C.traversal(root);
	C.printHTML(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
cmpl $0x1, %edi
jg 0x3c10
movq 0xd3d1(%rip), %rdi      # 0x10fd0
leaq 0x7415(%rip), %rsi      # 0xb01b
movl $0x43, %edx
callq 0x3250
movq 0x8(%rbx), %rdi
leaq 0x9e54(%rip), %rsi      # 0xda6f
callq 0x3260
leaq 0xd611(%rip), %rbx      # 0x11238
movq %rax, (%rbx)
callq 0x6840
callq 0x6908
callq 0x69e8
callq 0x6a68
callq 0x6aa8
callq 0x6bcf
callq 0x6ae8
callq 0x6c97
callq 0x6a28
callq 0x5408
movq (%rbx), %rdi
callq 0x3310
testl %eax, %eax
je 0x3c57
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x720a
movq 0xd5ad(%rip), %rdx      # 0x11228
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x9ba6
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rdi
callq 0x3ddc
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9f00
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3cc5
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3200
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3cde
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3200
leaq -0x80(%rbp), %rdi
callq 0x3d3e
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3d0f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x3d0f
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d2d
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x3d2d
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3d3e
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O1/gprateek93[P]LaTeX_to_HTML/ast.cpp
// Function: adopt_content_children(ast_node*)
void adopt_content_children(ast_node* current){
	current->children = *content_children;
	if(!content_stack.empty()){
		*content_children = content_stack.top();
		content_stack.pop();

	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xaa63(%rip), %rbx      # 0x112d8
movq (%rbx), %rsi
addq $0x48, %rdi
callq 0x6cd8
leaq 0xaa80(%rip), %rax      # 0x11308
movq 0x30(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x68c3
cmpq 0x38(%rax), %rsi
jne 0x68a5
movq 0x48(%rax), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq (%rbx), %rdi
callq 0x6cd8
leaq 0xaa50(%rip), %rdi      # 0x11308
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6db8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gprateek93[P]LaTeX_to_HTML/ast.cpp
// Function: adopt_list_children(ast_node*)
void adopt_list_children(ast_node* current){
	current->children = *list_children;
	if(!list_stack.empty()){
		*list_children = list_stack.top();
		list_stack.pop();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xa993(%rip), %rbx      # 0x112d0
movq (%rbx), %rsi
addq $0x48, %rdi
callq 0x6cd8
leaq 0xaa58(%rip), %rax      # 0x113a8
movq 0x30(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x698b
cmpq 0x38(%rax), %rsi
jne 0x696d
movq 0x48(%rax), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq (%rbx), %rdi
callq 0x6cd8
leaq 0xaa28(%rip), %rdi      # 0x113a8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6db8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gprateek93[P]LaTeX_to_HTML/ast.cpp
// Function: print(ast_node*, int)
void print(ast_node* root, int tabs){
	if(root == NULL){
		return;
	}
	for(int i=0; i<tabs; i++){
		cout<<"  ";
	}
	cout<<root->node_type<<endl;
	for(int i=0; i<root->children.size(); i++){
		print(root->children.at(i), tabs+1);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x6bce
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x6b56
movq 0xa499(%rip), %r15      # 0x10fd0
leaq 0x6df2(%rip), %r12      # 0xd930
movl %ebx, %r13d
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3250
decl %r13d
jne 0x6b41
movl (%r14), %esi
movq 0xa470(%rip), %rdi      # 0x10fd0
callq 0x3370
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3130
movq 0x48(%r14), %rax
cmpq %rax, 0x50(%r14)
je 0x6bc0
incl %ebx
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x6b10
incq %r15
movq 0x48(%r14), %rax
movq 0x50(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x6b9e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gprateek93[P]LaTeX_to_HTML/ast.cpp
// Function: adopt_r_content_children(ast_node*)
void adopt_r_content_children(ast_node* current){
	current->children = *r_content_children;
	if(!r_content_stack.empty()){
		*r_content_children = r_content_stack.top();
		r_content_stack.pop();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xa6dc(%rip), %rbx      # 0x112e0
movq (%rbx), %rsi
addq $0x48, %rdi
callq 0x6cd8
leaq 0xa741(%rip), %rax      # 0x11358
movq 0x30(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x6c52
cmpq 0x38(%rax), %rsi
jne 0x6c34
movq 0x48(%rax), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq (%rbx), %rdi
callq 0x6cd8
leaq 0xa711(%rip), %rdi      # 0x11358
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6db8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gprateek93[P]LaTeX_to_HTML/converter.cpp
// Function: converter::traverseChildren[abi:cxx11](ast_node*)
string converter :: traverseChildren(ast_node * root){
    string s = "";
    for(int i = 0; i<root->children.size(); i++){
        s+=traversal(root->children[i]);
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x48(%rdx), %rax
cmpq %rax, 0x50(%rdx)
je 0x7c27
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
leaq -0x50(%rbp), %r12
movq (%rax,%r13,8), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x9ba6
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x30b0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x7c10
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3200
incq %r13
movq 0x48(%r14), %rax
movq 0x50(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x7bd8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x7c5a
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x7c5a
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3200
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x7c72
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3200
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O1/gprateek93[P]LaTeX_to_HTML/converter.cpp
// Function: converter::traversePara[abi:cxx11](ast_node*, int)
string converter :: traversePara(ast_node * root, int type){
    string s = "";
    s+="<"+getMapping(type)+">";
    s+="&nbsp;&nbsp;&nbsp;&nbsp;";
    s+=traverseChildren(root);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq -0x94(%rbp), %rsi
movl %ecx, (%rsi)
movq %r12, %rdi
callq 0xa0f0
leaq -0x60(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0x3ddc
leaq 0x52e6(%rip), %rcx      # 0xdaae
leaq -0x70(%rbp), %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3240
leaq -0x80(%rbp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x8805
movq %rsi, %r15
movq %rdx, -0x90(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x80(%rbp)
jmp 0x880e
movups (%rcx), %xmm0
movq %rsi, %r15
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq -0x90(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x52b5(%rip), %rsi      # 0xdae8
callq 0x33d0
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x885c
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x8863
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x30b0
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x889f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3200
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x88b7
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x3200
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x88d0
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x3200
leaq 0x51de(%rip), %rsi      # 0xdab5
movq %rbx, %rdi
callq 0x33d0
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x7b96
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x30b0
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x8913
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x8993
movq -0x38(%rbp), %rsi
jmp 0x8986
jmp 0x8990
jmp 0x8990
movq %rax, %r13
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x8958
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x8958
movq %rax, %r13
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x8975
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x8975
movq %rax, %r13
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x8993
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x8993
movq %rax, %r13
movq (%rbx), %rdi
cmpq -0x50(%rbp), %rdi
je 0x89ab
movq -0x50(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3200
movq %r13, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O1/gprateek93[P]LaTeX_to_HTML/converter.cpp
// Function: converter::printHTML(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void converter :: printHTML(string s){
    ofstream cout("output.html");
    cout<<"<!DOCTYPE html>\n";
    cout<<"<html>\n";
    cout<<headTitle;
    cout<<s;
    cout<<"\n</html>";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %rbx
leaq 0x3c13(%rip), %rsi      # 0xdb2b
leaq -0x210(%rbp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x3230
leaq 0x3c04(%rip), %rsi      # 0xdb37
movl $0x10, %edx
movq %r14, %rdi
callq 0x3250
leaq 0x3c01(%rip), %rsi      # 0xdb48
leaq -0x210(%rbp), %rdi
movl $0x7, %edx
callq 0x3250
movq 0x74c1(%rip), %rsi      # 0x11420
movq 0x74c2(%rip), %rdx      # 0x11428
leaq -0x210(%rbp), %rdi
callq 0x3250
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq -0x210(%rbp), %rdi
callq 0x3250
leaq 0x3bc4(%rip), %rsi      # 0xdb50
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x3250
movq 0x701c(%rip), %rax      # 0x10fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x208(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x210(%rbp,%rcx)
callq 0x31a0
leaq -0x118(%rbp), %rdi
callq 0x30c0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x32d0
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/string_io.cc
// Function: main
int main()
{
    string s;          // empty string
    cin >> s;          // read a whitespace-separated string into s
    cout << s << endl; // write s to the output
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x2dbe(%rip), %rdi      # 0x3fe0
leaq -0x30(%rbp), %rsi
callq 0x1090
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x2d96(%rip), %rdi      # 0x3fd0
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x127e
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1070
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x12a1
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1070
movq %rbx, %rdi
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/imrosan[P]sql-format/demo.cpp
// Function: complex_logic_support()
void complex_logic_support() // 复杂逻辑 
{
    bool searchRemark = false; // 是否是搜索备注
    bool paging = true; // 是否分页

    std::string sql = "SELECT * FROM t_order WHERE uid=? ";
    SqlFormat::Formatter formatter(uid);

    if (searchRemark)
    {
        sql += "AND remark=? ";
        formatter.append(remark);
    }

    if (paging)
    {
        sql += "LIMIT ?,? ";
        formatter.append(startIndex, pageSize);
    }

    std::cout << formatter.format(mysql, sql) << std::endl; // SELECT * FROM t_order WHERE uid=1024 LIMIT 10,10
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x179f(%rip), %rsi      # 0x40a7
leaq 0x17ba(%rip), %rdx      # 0x40c9
leaq -0x48(%rbp), %rdi
callq 0x300c
leaq 0x4839(%rip), %rsi      # 0x7158
leaq -0x28(%rbp), %rdi
callq 0x2c2c
leaq 0x179b(%rip), %rsi      # 0x40ca
leaq -0x48(%rbp), %rdi
callq 0x2280
leaq 0x4829(%rip), %rsi      # 0x7168
leaq 0x4826(%rip), %rdx      # 0x716c
leaq -0x28(%rbp), %rdi
callq 0x2c66
leaq 0x482b(%rip), %rdx      # 0x7181
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rcx
callq 0x2d0e
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq 0x465a(%rip), %rdi      # 0x6fd0
callq 0x21b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29b7
callq 0x2160
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x29c5
callq 0x2160
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x29d3
callq 0x2160
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x29e3
movq %rax, %rbx
jmp 0x2a0b
movq %rax, %rbx
jmp 0x29fd
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29fd
callq 0x2160
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x2a0b
callq 0x2160
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x2a19
callq 0x2160
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/imrosan[P]sql-format/demo.cpp
// Function: main
int main()
{
    basic_usage();
    like_support();
    in_range_support();
    complex_logic_support();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x242c
callq 0x2521
callq 0x2694
callq 0x28ee
xorl %eax, %eax
popq %rbp
retq