LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4404cd
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
ucomisd %xmm2, %xmm1
jbe 0x4404ec
callq 0x442772
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x188b6d(%rip), %xmm0   # 0x5c9018
subsd %xmm1, %xmm0
movsd 0x189c81(%rip), %xmm1   # 0x5ca138
divsd 0x8(%rsp), %xmm1
callq 0x4ecf40
mulsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
leaq 0x18fdc1(%rip), %rdi    # 0x5d0295
leaq 0x18fd85(%rip), %rsi    # 0x5d0260
leaq 0x18fdc1(%rip), %rcx    # 0x5d02a3
movl $0x103, %edx            # imm = 0x103
callq 0x50b050
leaq 0x18fddd(%rip), %rdi    # 0x5d02d0
leaq 0x18fd66(%rip), %rsi    # 0x5d0260
leaq 0x18fda2(%rip), %rcx    # 0x5d02a3
movl $0x104, %edx            # imm = 0x104
callq 0x50b050
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movsd %xmm0, 0x18(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x442772
movapd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x442772
movapd %xmm0, 0x20(%rsp)
movq %r14, %rdi
callq 0x442772
addsd %xmm0, %xmm0
addsd 0x189b00(%rip), %xmm0   # 0x5ca138
movapd %xmm0, %xmm2
movsd %xmm0, 0x10(%rsp)
movapd (%rsp), %xmm1
unpcklpd 0x20(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
addpd %xmm1, %xmm1
addpd 0x189937(%rip), %xmm1   # 0x5c9f90
movapd %xmm1, (%rsp)
movapd %xmm1, %xmm0
mulpd %xmm1, %xmm0
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x189b1a(%rip), %xmm1   # 0x5ca1a0
callq 0x4ecf40
mulsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd (%rsp), %xmm0
movupd %xmm0, (%rbx)
movsd %xmm1, 0x10(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x440c0e
ucomisd %xmm0, %xmm1
jbe 0x440c2d
movq %rdi, %rbx
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
callq 0x44035e
movsd 0x18953d(%rip), %xmm1   # 0x5ca0f0
callq 0x4ecf40
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x442772
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm0
mulsd 0x18954a(%rip), %xmm0   # 0x5ca120
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 0x18f6c8(%rip), %rdi    # 0x5d02dd
leaq 0x18f644(%rip), %rsi    # 0x5d0260
leaq 0x18f6c5(%rip), %rcx    # 0x5d02e8
movl $0x138, %edx            # imm = 0x138
callq 0x50b050
leaq 0x18f6f5(%rip), %rdi    # 0x5d0329
leaq 0x18f625(%rip), %rsi    # 0x5d0260
leaq 0x18f6a6(%rip), %rcx    # 0x5d02e8
movl $0x139, %edx            # imm = 0x139
callq 0x50b050
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %r10
movq (%rdx), %r9
xorl %eax, %eax
cmpq %rsi, %r10
jae 0x34bd
pushq %rbx
xorl %eax, %eax
cmpq %rcx, %r9
jae 0x34b7
movl (%r10), %r11d
cmpl $0xffff, %r11d          # imm = 0xFFFF
ja 0x344d
movl %r11d, %ebx
andl $0xf800, %ebx           # imm = 0xF800
cmpl $0xd800, %ebx           # imm = 0xD800
jne 0x3463
testl %r8d, %r8d
jne 0x345b
jmp 0x34c4
cmpl $0x110000, %r11d        # imm = 0x110000
jb 0x346d
testl %r8d, %r8d
je 0x34a3
movw $0xfffd, (%r9)          # imm = 0xFFFD
jmp 0x3467
movw %r11w, (%r9)
addq $0x2, %r9
jmp 0x34a8
leaq 0x2(%r9), %rbx
cmpq %rcx, %rbx
jae 0x34b7
leal 0x3ff0000(%r11), %ebx
shrl $0xa, %ebx
addl $0xffffd800, %ebx       # imm = 0xFFFFD800
movw %bx, (%r9)
andl $0x3ff, %r11d           # imm = 0x3FF
orl $0xdc00, %r11d          # imm = 0xDC00
movw %r11w, 0x2(%r9)
addq $0x4, %r9
jmp 0x34a8
movl $0x3, %eax
addq $0x4, %r10
cmpq %rsi, %r10
jb 0x3420
jmp 0x34bc
movl $0x2, %eax
popq %rbx
movq %r10, (%rdi)
movq %r9, (%rdx)
retq
movl $0x3, %eax
jmp 0x34bc
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %r10
movq (%rdx), %r9
xorl %eax, %eax
cmpq %rsi, %r10
jae 0x356b
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x2(%r10), %r11
movzwl (%r10), %ebx
movl %ebx, %ebp
andl $0xfc00, %ebp           # imm = 0xFC00
cmpl $0xd800, %ebp           # imm = 0xD800
jne 0x3524
cmpq %rsi, %r11
jae 0x3562
movzwl (%r11), %r14d
movl %r14d, %ebp
andl $0xfc00, %ebp           # imm = 0xFC00
cmpl $0xdc00, %ebp           # imm = 0xDC00
jne 0x3536
shll $0xa, %ebx
addl %r14d, %ebx
addl $0xfca02400, %ebx       # imm = 0xFCA02400
leaq 0x4(%r10), %r11
jmp 0x353b
testl %r8d, %r8d
jne 0x353b
movzwl %bp, %ebp
cmpl $0xdc00, %ebp           # imm = 0xDC00
jne 0x353b
jmp 0x355b
testl %r8d, %r8d
je 0x355b
cmpq %rcx, %r9
jae 0x3554
movl %ebx, (%r9)
addq $0x4, %r9
movq %r11, %r10
cmpq %rsi, %r11
jb 0x34e0
movq %r11, %r10
jmp 0x3567
movl $0x2, %eax
jmp 0x3567
movl $0x3, %eax
jmp 0x3567
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
movq %r10, (%rdi)
movq %r9, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2962(%rip), %rcx      # 0x6030
movsbq (%rax,%rcx), %rcx
leaq (%rdi,%rcx), %rdx
incq %rdx
cmpq %rsi, %rdx
ja 0x36f8
movzbl %cl, %ecx
testl %ecx, %ecx
je 0x36fb
cmpl $0x1, %ecx
jne 0x36f8
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_O3/codebrainz[P]libutfxx/utf/utf.cxx
// Function: void utf::convert_ptr_<char16_t, char, ConversionResult (*)(char16_t const**, char16_t const*, char**, char*, ConversionFlags), 32ul>(char16_t const*, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, ConversionResult (*)(char16_t const**, char16_t const*, char**, char*, 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 $0x48, %rsp
movq %rcx, %r14
movq %rdx, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x18(%rsp), %r8
movq %rdi, (%r8)
leaq (%rdi,%rsi,2), %r13
leaq 0x10(%rsp), %rdx
movq %r15, (%rdx)
leaq 0x40(%rsp), %rcx
movq %r8, %rdi
movq %r13, %rsi
movq %r8, %rbp
movq %rdx, %rbx
movq %rcx, %r12
xorl %r8d, %r8d
callq *%r14
movq %r12, %rcx
movq %rbx, %rdx
movq %rbp, %r8
cmpl $0x3, %eax
ja 0x40cc
movq 0x10(%rsp), %rdx
subq %r15, %rdx
movl %eax, %eax
leaq 0x2068(%rip), %rcx      # 0x6168
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x3030
movq %r12, %rcx
movq %rbx, %rdx
movq %rbp, %r8
movq %r15, 0x10(%rsp)
jmp 0x40cc
leaq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x3030
addq $0x48, %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 0x32b0
movq 0x4e70(%rip), %rsi      # 0x8fd0
jmp 0x417e
movl $0x18, %edi
callq 0x3090
movq %rax, %rbx
movq %rax, %rdi
callq 0x30c0
movq 0x4e02(%rip), %rsi      # 0x8f80
movq 0x4e23(%rip), %rdx      # 0x8fa8
movq %rbx, %rdi
callq 0x32a0
jmp 0x418f
movq %rax, %r14
movq %rbx, %rdi
callq 0x3100
movq %r14, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3a1e(%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 0x2a71
testq %rcx, %rcx
je 0x2a71
movq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2f94
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x327c
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x29f8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x30(%rsp), %rax
cmpq $0x1, %rax
je 0x2a71
movl $0x1, %r13d
leaq 0x8(%rsp), %r14
movq 0x28(%rsp), %r15
cmpb $0x0, -0x1(%r15,%r13)
jne 0x2a61
addq %r13, %r15
movq %r12, 0x8(%rsp)
movq %r15, %rdi
callq 0x2080
leaq (%rax,%r15), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x30c6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x327c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2a5c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x30(%rsp), %rax
leaq -0x1(%rax), %rcx
leaq 0x1(%r13), %rdx
cmpq %rcx, %r13
movq %rdx, %r13
jb 0x2a0e
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 0x2aa9
jmp 0x2ab6
jmp 0x2a97
movq %rax, %r14
jmp 0x2ab6
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ab6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2fd2
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3878(%rip), %rdx      # 0x6388
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x294b
movq (%rbx), %r12
movq 0x8(%rbx), %r13
subq %r12, %r13
je 0x2b92
sarq $0x5, %r13
movq 0x362c(%rip), %r14      # 0x6160
xorl %ebp, %ebp
cmpq $0x1, %r13
sbbq %r13, %rbp
movq 0x3614(%rip), %rax      # 0x6158
movq %rax, 0x8(%rsp)
addq $0x8, %r12
movb $0x1, %bl
movl $0x1, %r15d
cmpq %r14, (%r12)
jne 0x2b76
testq %r14, %r14
je 0x2b94
movq -0x8(%r12), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x21a0
testl %eax, %eax
je 0x2b94
cmpq %r13, %r15
setb %bl
leaq (%r15,%rbp), %rax
incq %rax
incq %r15
addq $0x20, %r12
cmpq $0x1, %rax
jne 0x2b55
jmp 0x2b94
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x2fd2
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_O3/gliktaras[P]skyperole/skyperole.cpp
// Function: setWindowRole(unsigned long)
void setWindowRole(Window window) {
    if (!isSkypeWindow(window)) {
        return;
    }

    std::vector<std::string> windowNames = getStringProperty(window, WM_NAME_ATOM);
    for (size_t i = 0; i < windowNames.size(); ++i) {
        for (int j = 0; j < SKYPE_WINDOW_TYPE_COUNT; ++j) {
            if (isSubstring(SKYPE_WINDOW_TYPES[j][0], windowNames[i])) {
                setStringProperty(window, WM_WINDOW_ROLE_ATOM, SKYPE_WINDOW_TYPES[j][1]);
                return;
            }
        }
    }

    if (verbose) {
        std::cerr << "Recognized Skype window " << std::hex << window << ", "
                  << "could not identify it further." << std::endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x2af8
testb %al, %al
je 0x2d70
movq 0x37b9(%rip), %rdx      # 0x6390
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x294b
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x2c5f
xorl %r14d, %r14d
leaq 0x3586(%rip), %r15      # 0x6180
movq %r14, %r12
shlq $0x5, %r12
xorl %r13d, %r13d
movq 0x20(%rsp), %rbp
movq (%rbp,%r12), %rdi
movq 0x8(%rbp,%r12), %rsi
addq %rdi, %rsi
movq (%r13,%r15), %rdx
movq 0x8(%r13,%r15), %rcx
addq %rdx, %rcx
callq 0x315b
addq %r12, %rbp
movq (%rbp), %rcx
addq 0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2cfd
addq $0x40, %r13
cmpq $0x200, %r13            # imm = 0x200
jne 0x2c04
incq %r14
movq 0x28(%rsp), %rax
subq 0x20(%rsp), %rax
sarq $0x5, %rax
cmpq %rax, %r14
jb 0x2bfa
cmpb $0x1, 0x373a(%rip)      # 0x63a0
jne 0x2d66
movq 0x337d(%rip), %r14      # 0x5ff0
leaq 0x148a(%rip), %rsi      # 0x4104
movl $0x18, %edx
movq %r14, %rdi
callq 0x21b0
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r14,%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20c0
movq %rax, %rbx
leaq 0x146a(%rip), %rsi      # 0x411d
movl $0x2, %edx
movq %rax, %rdi
callq 0x21b0
leaq 0x1459(%rip), %rsi      # 0x4120
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x21b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
jmp 0x2d66
movq 0x3694(%rip), %r14      # 0x6398
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r13,%r15), %rsi
movq 0x28(%r13,%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x3030
movq 0x3656(%rip), %rdi      # 0x6380
movl 0x8(%rsp), %eax
movl $0x1f, %ecx
movq %rbx, %rsi
movq %r14, %rdx
movl $0x8, %r8d
xorl %r9d, %r9d
pushq %rax
pushq 0x8(%rsp)
callq 0x2130
addq $0x10, %rsp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2d66
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
leaq 0x20(%rsp), %rdi
callq 0x2fd2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2da1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x2da1
jmp 0x2d9e
jmp 0x2d9e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2fd2
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x35bb(%rip)      # 0x6380
testq %rax, %rax
je 0x2e61
leaq 0x1397(%rip), %rsi      # 0x416c
xorl %ebx, %ebx
movq %rax, %rdi
xorl %edx, %edx
callq 0x20f0
movq %rax, 0x35a0(%rip)      # 0x6388
movq 0x3591(%rip), %rdi      # 0x6380
leaq 0x137f(%rip), %rsi      # 0x4175
xorl %edx, %edx
callq 0x20f0
movq %rax, 0x358c(%rip)      # 0x6390
movq 0x3575(%rip), %rdi      # 0x6380
leaq 0x1370(%rip), %rsi      # 0x4182
xorl %edx, %edx
callq 0x20f0
movq %rax, 0x3578(%rip)      # 0x6398
movq 0x3559(%rip), %rdi      # 0x6380
callq 0x2100
testl %eax, %eax
jle 0x2e5a
movl %eax, %ebp
movq 0x3547(%rip), %rdi      # 0x6380
movl %ebx, %esi
callq 0x2210
movq 0x3539(%rip), %rdi      # 0x6380
movl $0x80000, %edx          # imm = 0x80000
movq %rax, %rsi
callq 0x20b0
incl %ebx
cmpl %ebx, %ebp
jne 0x2e32
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x3188(%rip), %rdi      # 0x5ff0
leaq 0x12d0(%rip), %rsi      # 0x413f
callq 0x2170
movq %rax, %rdi
callq 0x2090
movl $0x1, %edi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x34e5(%rip), %rdi      # 0x6380
callq 0x2100
testl %eax, %eax
jle 0x2f1a
movl %eax, %ebx
xorl %r14d, %r14d
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0xc(%rsp), %rbp
movq 0x34c1(%rip), %rdi      # 0x6380
movl %r14d, %esi
callq 0x2210
movq 0x34b2(%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 0x2f08
xorl %r15d, %r15d
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %rdi
callq 0x2bb2
incq %r15
movl 0xc(%rsp), %eax
cmpq %rax, %r15
jb 0x2eee
movq 0x10(%rsp), %rdi
callq 0x21d0
incl %r14d
cmpl %ebx, %r14d
jne 0x2eb8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x129e(%rip), %xmm0     # 0x41d8
movq %rsp, %rbx
movaps %xmm0, (%rbx)
leaq 0x18(%rsp), %r14
movq 0x3434(%rip), %rdi      # 0x6380
callq 0x2150
testl %eax, %eax
je 0x2f77
movq 0x3424(%rip), %rdi      # 0x6380
movq %r14, %rsi
callq 0x21f0
cmpl $0x10, 0x18(%rsp)
jne 0x2f45
movq 0x40(%rsp), %rdi
callq 0x2bb2
jmp 0x2f45
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2050
jmp 0x2f45
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3ad0
movq 0xd511(%rip), %rdi      # 0x10fd0
leaq 0x7555(%rip), %rsi      # 0xb01b
movl $0x43, %edx
callq 0x3250
movq 0x8(%rbx), %rdi
leaq 0x9f94(%rip), %rsi      # 0xda6f
callq 0x3260
leaq 0xd751(%rip), %rbx      # 0x11238
movq %rax, (%rbx)
callq 0x6648
callq 0x6710
callq 0x67f0
callq 0x6870
callq 0x68b0
callq 0x69d7
callq 0x68f0
callq 0x6a9f
callq 0x6830
callq 0x5228
movq (%rbx), %rdi
callq 0x3310
testl %eax, %eax
je 0x3b17
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x701e
movq 0xd6ed(%rip), %rdx      # 0x11228
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x99b0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rdi
callq 0x3c9c
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9d0a
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3b85
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3200
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b9e
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3200
leaq -0x80(%rbp), %rdi
callq 0x3bfe
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3bcf
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x3bcf
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bed
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x3bed
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3bfe
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O3/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 0xac5b(%rip), %rbx      # 0x112d8
movq (%rbx), %rsi
addq $0x48, %rdi
callq 0x6ae0
leaq 0xac78(%rip), %rax      # 0x11308
movq 0x30(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x66cb
cmpq 0x38(%rax), %rsi
jne 0x66ad
movq 0x48(%rax), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq (%rbx), %rdi
callq 0x6ae0
leaq 0xac48(%rip), %rdi      # 0x11308
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6bce
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xab8b(%rip), %rbx      # 0x112d0
movq (%rbx), %rsi
addq $0x48, %rdi
callq 0x6ae0
leaq 0xac50(%rip), %rax      # 0x113a8
movq 0x30(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x6793
cmpq 0x38(%rax), %rsi
jne 0x6775
movq 0x48(%rax), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq (%rbx), %rdi
callq 0x6ae0
leaq 0xac20(%rip), %rdi      # 0x113a8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6bce
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x69d6
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 0x695e
movq 0xa691(%rip), %r15      # 0x10fd0
leaq 0x6fea(%rip), %r12      # 0xd930
movl %ebx, %r13d
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3250
decl %r13d
jne 0x6949
movl (%r14), %esi
movq 0xa668(%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 0x69c8
incl %ebx
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x6918
incq %r15
movq 0x48(%r14), %rax
movq 0x50(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x69a6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa8d4(%rip), %rbx      # 0x112e0
movq (%rbx), %rsi
addq $0x48, %rdi
callq 0x6ae0
leaq 0xa939(%rip), %rax      # 0x11358
movq 0x30(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x6a5a
cmpq 0x38(%rax), %rsi
jne 0x6a3c
movq 0x48(%rax), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq (%rbx), %rdi
callq 0x6ae0
leaq 0xa909(%rip), %rdi      # 0x11358
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6bce
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7a3d
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 0x99b0
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 0x7a26
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 0x79ee
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x7a70
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x7a70
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3200
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x7a88
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3200
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq -0x7c(%rbp), %rsi
movl %ecx, (%rsi)
movq %r15, %rdi
callq 0x9efa
leaq -0x90(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0xa0(%rbp), %rdi
callq 0x3c9c
leaq 0x54d3(%rip), %rcx      # 0xdaae
leaq -0xa0(%rbp), %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3240
leaq -0x68(%rbp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
movq %r15, -0x58(%rbp)
je 0x861c
movq %rsi, %r15
movq %rdx, -0x78(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x68(%rbp)
jmp 0x8625
movups (%rcx), %xmm0
movq %rsi, %r15
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq -0x78(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x54a1(%rip), %rsi      # 0xdae8
callq 0x33d0
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x8670
movq %rsi, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x867b
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq %r13, %rsi
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x30b0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x86af
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3200
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x86c4
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x3200
movq -0xa0(%rbp), %rdi
cmpq %r14, %rdi
je 0x86df
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x3200
leaq 0x53cf(%rip), %rsi      # 0xdab5
movq %rbx, %rdi
callq 0x33d0
leaq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %r12, %rdx
callq 0x79ac
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x30b0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8727
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, %r12
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x87aa
movq -0x38(%rbp), %rsi
jmp 0x879d
jmp 0x87a7
jmp 0x87a7
movq %rax, %r12
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8770
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x8770
movq %rax, %r12
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x878a
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x878a
movq %rax, %r12
movq -0xa0(%rbp), %rdi
cmpq %r14, %rdi
je 0x87aa
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x3200
jmp 0x87aa
movq %rax, %r12
movq (%rbx), %rdi
cmpq -0x50(%rbp), %rdi
je 0x87c2
movq -0x50(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3200
movq %r12, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3e09(%rip), %rsi      # 0xdb2b
leaq -0x210(%rbp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x3230
leaq 0x3dfa(%rip), %rsi      # 0xdb37
movl $0x10, %edx
movq %r14, %rdi
callq 0x3250
leaq 0x3df7(%rip), %rsi      # 0xdb48
leaq -0x210(%rbp), %rdi
movl $0x7, %edx
callq 0x3250
movq 0x76b7(%rip), %rsi      # 0x11420
movq 0x76b8(%rip), %rdx      # 0x11428
leaq -0x210(%rbp), %rdi
callq 0x3250
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq -0x210(%rbp), %rdi
callq 0x3250
leaq 0x3dba(%rip), %rsi      # 0xdb50
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x3250
movq 0x7212(%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_O3/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 0x17c3(%rip), %rsi      # 0x40a7
leaq 0x17de(%rip), %rdx      # 0x40c9
leaq -0x48(%rbp), %rdi
callq 0x2ff2
leaq 0x485d(%rip), %rsi      # 0x7158
leaq -0x28(%rbp), %rdi
callq 0x2c08
leaq 0x17bf(%rip), %rsi      # 0x40ca
leaq -0x48(%rbp), %rdi
callq 0x2280
leaq 0x484d(%rip), %rsi      # 0x7168
leaq 0x484a(%rip), %rdx      # 0x716c
leaq -0x28(%rbp), %rdi
callq 0x2c42
leaq 0x484f(%rip), %rdx      # 0x7181
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rcx
callq 0x2ce6
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq 0x467e(%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 0x2993
callq 0x2160
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x29a1
callq 0x2160
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x29af
callq 0x2160
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x29bf
movq %rax, %rbx
jmp 0x29e7
movq %rax, %rbx
jmp 0x29d9
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29d9
callq 0x2160
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x29e7
callq 0x2160
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x29f5
callq 0x2160
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28ca
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/imrosan[P]sql-format/./sql_format/sf_formatter.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> SqlFormat::Formatter::format<DefaultEscapeHandler>(DefaultEscapeHandler&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string format(EscapeHandler& escapeHandler, const std::string& sql)
    {
        static const std::string placeholder = "?";

        std::string result = sql;
        size_t pos = 0;

        for (size_t i = 0; i < dataList_.size(); ++i)
        {
            Detail::DataBase* d = dataList_[i]; 

            size_t p = result.find(placeholder, pos);
            if (p == std::string::npos)
                throw PlaceholderException();

            std::string formatted = d->format(escapeHandler);
            result.replace(p, placeholder.size(), formatted); 

            pos = p + formatted.size();
        }

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rdx, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, %rbx
movb 0x44be(%rip), %al       # 0x71c8
testb %al, %al
je 0x2dfd
leaq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2ea8
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x2dc1
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%rax,%r14,8), %r12
movq 0x4459(%rip), %rsi      # 0x71a8
movq 0x445a(%rip), %rcx      # 0x71b0
movq %rbx, %rdi
movq %r13, %rdx
callq 0x2240
cmpq $-0x1, %rax
je 0x2dd3
movq %rax, %r13
movq (%r12), %rax
leaq -0x58(%rbp), %rdi
movq %r12, %rsi
movq -0x38(%rbp), %rdx
callq *(%rax)
movq 0x442e(%rip), %rdx      # 0x71b0
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %r8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21a0
addq -0x50(%rbp), %r13
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2dab
callq 0x2160
incq %r14
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jb 0x2d44
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x20b0
leaq 0x3fa4(%rip), %rcx      # 0x6d88
movq %rcx, (%rax)
leaq 0x3f72(%rip), %rsi      # 0x6d60
movq 0x41eb(%rip), %rdx      # 0x6fe0
movq %rax, %rdi
callq 0x2220
leaq 0x43c4(%rip), %rdi      # 0x71c8
callq 0x2270
testl %eax, %eax
je 0x2d12
leaq 0x43a0(%rip), %rax      # 0x71b8
movq %rax, 0x4389(%rip)      # 0x71a8
leaq 0x4382(%rip), %rdi      # 0x71a8
leaq 0x1244(%rip), %rsi      # 0x4071
leaq 0x123e(%rip), %rdx      # 0x4072
callq 0x2ff2
movq 0x4178(%rip), %rdi      # 0x6fb8
leaq 0x4361(%rip), %rsi      # 0x71a8
leaq 0x4302(%rip), %rdx      # 0x7150
callq 0x2150
leaq 0x436e(%rip), %rdi      # 0x71c8
callq 0x20f0
jmp 0x2d12
movq %rax, %r14
leaq 0x435a(%rip), %rdi      # 0x71c8
callq 0x20e0
jmp 0x2e9f
jmp 0x2e8e
movq %rax, %r14
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2e91
callq 0x2160
jmp 0x2e91
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x2e9f
callq 0x2160
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/imrosan[P]sql-format/./sql_format/sf_formatter.h
// Function: void SqlFormat::Formatter::append<long, char const*, int, int>(long const&, char const* const&, int const&, int const&)
void append(const A0& a0, const A1& a1, const A2& a2, const A3& a3)
    {
        dataList_.push_back(NewData(a0));
        dataList_.push_back(NewData(a1));
        dataList_.push_back(NewData(a2));
        dataList_.push_back(NewData(a3));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl $0x10, %edi
callq 0x2190
movq (%r13), %rcx
movq %rcx, 0x8(%rax)
leaq 0x39b0(%rip), %rcx      # 0x6ab0
movq %rcx, (%rax)
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3122
movq %rax, (%rsi)
movq 0x8(%rbx), %r13
addq $0x8, %r13
movq %r13, 0x8(%rbx)
jmp 0x3132
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x320c
movq 0x8(%rbx), %r13
movl $0x10, %edi
callq 0x2190
movq (%r12), %rcx
movq %rcx, 0x8(%rax)
leaq 0x3a05(%rip), %rcx      # 0x6b50
movq %rcx, (%rax)
movq %rax, -0x30(%rbp)
cmpq 0x10(%rbx), %r13
je 0x316a
movq %rax, (%r13)
movq 0x8(%rbx), %r12
addq $0x8, %r12
movq %r12, 0x8(%rbx)
jmp 0x317d
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x320c
movq 0x8(%rbx), %r12
movl $0x10, %edi
callq 0x2190
movl (%r15), %ecx
movl %ecx, 0x8(%rax)
leaq 0x3a24(%rip), %r13      # 0x6bb8
movq %r13, (%rax)
movq %rax, -0x30(%rbp)
cmpq 0x10(%rbx), %r12
je 0x31b3
movq %rax, (%r12)
movq 0x8(%rbx), %r15
addq $0x8, %r15
movq %r15, 0x8(%rbx)
jmp 0x31c6
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x320c
movq 0x8(%rbx), %r15
movl $0x10, %edi
callq 0x2190
movl (%r14), %ecx
movl %ecx, 0x8(%rax)
movq %r13, (%rax)
movq %rax, -0x30(%rbp)
cmpq 0x10(%rbx), %r15
je 0x31ed
movq %rax, (%r15)
addq $0x8, 0x8(%rbx)
jmp 0x31fc
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x320c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/imrosan[P]sql-format/./sql_format/detail/sf_detail_data.h
// Function: SqlFormat::Detail::Data<char const*, false>::format[abi:cxx11](DefaultEscapeHandler&)
virtual std::string format(EscapeHandler& escapeHandler)
    {
        std::string result = "'";
        result += HandleEscape(escapeHandler, GetData());
        result += "'";

        return result; 
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0xd16(%rip), %rsi       # 0x4119
leaq 0xd10(%rip), %rdx       # 0x411a
callq 0x2ff2
movq 0x8(%r14), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x2090
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2ea8
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x2060
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x345b
callq 0x2160
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x346d
callq 0x2160
leaq 0xca5(%rip), %rsi       # 0x4119
movq %rbx, %rdi
callq 0x2280
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x34b8
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x34a4
callq 0x2160
jmp 0x34a4
movq %rax, %r14
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34bb
callq 0x2160
jmp 0x34bb
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x34c8
callq 0x2160
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/imrosan[P]sql-format/./sql_format/detail/sf_detail_data.h
// Function: SqlFormat::Detail::Data<SqlFormat::Detail::LikeData, false>::format[abi:cxx11](DefaultEscapeHandler&)
virtual std::string format(EscapeHandler& escapeHandler)
    {
        const LikeData& likeData = GetData();
        int likeMode = likeData.likeMode;

        std::string result = "'";

        if ((likeMode & LikeData::LIKE_MODE_LEFT) != 0)
        {
            result += '%';
        }

        result += HandleEscape(escapeHandler, likeData.s);

        if ((likeMode & LikeData::LIKE_MODE_RIGHT) != 0)
        {
            result += '%';
        }

        result += "'";

        return result; 
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x28(%rsi), %r12d
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0xaa4(%rip), %rsi       # 0x4119
leaq 0xa9e(%rip), %rdx       # 0x411a
callq 0x2ff2
testb $0x1, %r12b
je 0x3694
movq %rbx, %rdi
movl $0x25, %esi
callq 0x2140
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2ea8
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x2060
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x36ce
callq 0x2160
testb $0x2, %r12b
je 0x36e1
movq %rbx, %rdi
movl $0x25, %esi
callq 0x2140
leaq 0xa31(%rip), %rsi       # 0x4119
movq %rbx, %rdi
callq 0x2280
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x371a
callq 0x2160
jmp 0x371a
jmp 0x3717
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3727
callq 0x2160
movq %r14, %rdi
callq 0x2250
nop