LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x189885(%rip), %xmm0   # 0x5bf130
movsd 0x188765(%rip), %xmm1   # 0x5be018
movq %rsi, %rdi
callq 0x435606
movaps %xmm0, 0x20(%rsp)
movq %r14, %rdi
movsd 0x189865(%rip), %xmm0   # 0x5bf130
movsd 0x188745(%rip), %xmm1   # 0x5be018
callq 0x435606
movaps %xmm0, 0x10(%rsp)
movq %r14, %rdi
movsd 0x189848(%rip), %xmm0   # 0x5bf130
movsd 0x188728(%rip), %xmm1   # 0x5be018
callq 0x435606
movsd %xmm0, (%rsp)
movapd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm2
movapd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x189876(%rip), %xmm1   # 0x5bf198
callq 0x4e1d70
mulsd 0x8(%rsp), %xmm0
movapd 0x20(%rsp), %xmm1
unpcklpd 0x10(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
movupd %xmm0, (%rbx)
movsd %xmm2, 0x10(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/tools.cpp
// Function: std::array<double, 3ul> RandomContext::fromshell<3ul>(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 %r14
pushq %rbx
subq $0x18, %rsp
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x435dcb
movsd %xmm1, 0x10(%rsp)
ucomisd %xmm0, %xmm1
jbe 0x435dea
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x1893cf(%rip), %xmm1   # 0x5bf148
callq 0x4e1d70
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x1893b6(%rip), %xmm1   # 0x5bf148
callq 0x4e1d70
movaps %xmm0, %xmm1
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x435606
movsd 0x189440(%rip), %xmm1   # 0x5bf1f0
callq 0x4e1d70
movq %rbx, %rdi
movq %r14, %rsi
callq 0x435890
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x18fb9f(%rip), %rdi    # 0x5c5971
leaq 0x18fb1b(%rip), %rsi    # 0x5c58f4
leaq 0x18fbe9(%rip), %rcx    # 0x5c59c9
movl $0x138, %edx            # imm = 0x138
callq 0x4ffe80
leaq 0x18fbcc(%rip), %rdi    # 0x5c59bd
leaq 0x18fafc(%rip), %rsi    # 0x5c58f4
leaq 0x18fbca(%rip), %rcx    # 0x5c59c9
movl $0x139, %edx            # imm = 0x139
callq 0x4ffe80
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq (%rdi), %rbx
movq (%rdx), %r9
xorl %eax, %eax
movl $0x2, %r10d
movl $0x3, %r11d
cmpq %rsi, %rbx
jae 0x4600
cmpq %rcx, %r9
jae 0x45fd
leaq 0x4(%rbx), %r14
movl (%rbx), %r15d
cmpl $0xffff, %r15d          # imm = 0xFFFF
ja 0x4592
movl %r15d, %ebp
andl $0xf800, %ebp           # imm = 0xF800
cmpl $0xd800, %ebp           # imm = 0xD800
jne 0x45a8
testl %r8d, %r8d
jne 0x45a0
jmp 0x460f
cmpl $0x110000, %r15d        # imm = 0x110000
jb 0x45b5
testl %r8d, %r8d
je 0x45f1
movw $0xfffd, (%r9)          # imm = 0xFFFD
jmp 0x45ac
movw %r15w, (%r9)
addq $0x2, %r9
movq %r14, %rbx
jmp 0x4558
leaq 0x2(%r9), %r12
cmpq %rcx, %r12
jae 0x45fd
leal 0x3ff0000(%r15), %ebx
shrl $0xa, %ebx
addl $0xffffd800, %ebx       # imm = 0xFFFFD800
movw %bx, (%r9)
andl $0x3ff, %r15d           # imm = 0x3FF
orl $0xdc00, %r15d          # imm = 0xDC00
movw %r15w, 0x2(%r9)
addq $0x4, %r9
movq %r14, %rbx
jmp 0x4558
addq $0x4, %rbx
movl %r11d, %eax
jmp 0x4558
movl %r10d, %eax
movq %rbx, (%rdi)
movq %r9, (%rdx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r11d, %eax
jmp 0x4600
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r10
movq (%rdx), %r9
movl $0x1, %r11d
movl $0x3, %eax
movl $0x2, %ebx
cmpq %rsi, %r10
jae 0x46a0
leaq 0x2(%r10), %r15
movzwl (%r10), %r14d
movl %r14d, %ebp
andl $0xfc00, %ebp           # imm = 0xFC00
cmpw $0xd800, %bp            # imm = 0xD800
jne 0x467c
cmpq %rsi, %r15
jae 0x46a8
movzwl (%r15), %r12d
movl %r12d, %ebp
andl $0xfc00, %ebp           # imm = 0xFC00
cmpw $0xdc00, %bp            # imm = 0xDC00
jne 0x468a
shll $0xa, %r14d
addl %r12d, %r14d
addl $0xfca02400, %r14d      # imm = 0xFCA02400
leaq 0x4(%r10), %r15
jmp 0x468f
testl %r8d, %r8d
jne 0x468f
cmpw $0xdc00, %bp            # imm = 0xDC00
jne 0x468f
jmp 0x46ab
testl %r8d, %r8d
je 0x46ab
cmpq %rcx, %r9
jae 0x46a4
movl %r14d, (%r9)
addq $0x4, %r9
movq %r15, %r10
jmp 0x4632
xorl %eax, %eax
jmp 0x46ab
movl %ebx, %eax
jmp 0x46ab
movl %r11d, %eax
movq %r10, (%rdi)
movq %r9, (%rdx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rsi, %rax
movsbq (%rdi), %rcx
leaq 0x283e(%rip), %rdx      # 0x7060
movsbq (%rcx,%rdx), %rsi
leaq (%rdi,%rsi), %rcx
incq %rcx
cmpq %rax, %rcx
jbe 0x4836
xorl %eax, %eax
retq
incq %rsi
jmp 0x483b
// File: /workspace/github_cpp_makefile_star2_O2/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 0x52d2
movq 0x10(%rsp), %rdx
subq %r15, %rdx
movl %eax, %eax
leaq 0x1e92(%rip), %rcx      # 0x7198
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x4030
movq %r12, %rcx
movq %rbx, %rdx
movq %rbp, %r8
movq %r15, 0x10(%rsp)
jmp 0x52d2
leaq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x4030
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x18
popq %rdi
callq 0x40c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x43b0
movq 0x4c6c(%rip), %rsi      # 0x9fd0
jmp 0x5380
pushq $0x18
popq %rdi
callq 0x40c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x4100
movq 0x4c00(%rip), %rsi      # 0x9f80
movq 0x4c21(%rip), %rdx      # 0x9fa8
movq %rbx, %rdi
callq 0x43a0
jmp 0x5391
movq %rax, %r14
movq %rbx, %rdi
callq 0x4150
movq %r14, %rdi
callq 0x43c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0x2d1d(%rip), %rdi      # 0x5380
leaq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %r14
movq %r14, 0x18(%rsp)
leaq 0x54(%rsp), %rax
movq %rax, 0x10(%rsp)
andq $0x0, (%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x2040
andq $0x0, 0x10(%rbx)
movq (%r14), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
testl %eax, %eax
jne 0x273d
testq %rcx, %rcx
je 0x273d
movq 0x40(%rsp), %rsi
leaq 0x58(%rsp), %rdi
leaq 0x3f(%rsp), %rdx
callq 0x2b50
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0x2dee
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x2248
xorl %r12d, %r12d
leaq 0x3f(%rsp), %r15
movq 0x48(%rsp), %rax
decq %rax
cmpq %rax, %r12
jae 0x273d
movq 0x40(%rsp), %rax
cmpb $0x0, (%rax,%r12)
jne 0x2738
leaq (%rax,%r12), %rsi
incq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2b50
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2dee
movq %r14, %rdi
callq 0x2248
incq %r12
jmp 0x26fa
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2753
jmp 0x2762
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x2248
jmp 0x2765
movq %rax, %r14
movq %rbx, %rdi
callq 0x2b8c
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rsi
movq 0x2bd2(%rip), %rdx      # 0x5388
movq %rsp, %rdi
callq 0x264b
pushq $-0x1
popq %r14
xorl %r15d, %r15d
leaq 0x298c(%rip), %rbx      # 0x5158
movq (%rsp), %rdi
movq 0x8(%rsp), %r12
subq %rdi, %r12
sarq $0x5, %r12
incq %r14
cmpq %r12, %r14
jae 0x27f7
addq %r15, %rdi
addq $0x20, %r15
movq %rbx, %rsi
callq 0x2bad
testb %al, %al
je 0x27cc
cmpq %r12, %r14
setb %bl
movq %rsp, %rdi
callq 0x2b8c
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27a1
testb %al, %al
je 0x28dc
movq 0x2b58(%rip), %rdx      # 0x5390
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x264b
xorl %r15d, %r15d
leaq 0x2933(%rip), %r12      # 0x5180
movq 0x8(%rsp), %rax
subq (%rsp), %rax
sarq $0x5, %rax
cmpq %rax, %r15
jae 0x28eb
movq %r15, %rbp
shlq $0x5, %rbp
movq %r12, %r14
xorl %r13d, %r13d
addq $-0x40, %r13
cmpq $-0x240, %r13           # imm = 0xFDC0
je 0x2896
movq (%rsp), %rsi
addq %rbp, %rsi
movq %r14, %rdi
callq 0x261c
addq $0x40, %r14
testb %al, %al
je 0x2870
jmp 0x289b
incq %r15
jmp 0x284d
movq 0x2af6(%rip), %r14      # 0x5398
leaq 0x28d7(%rip), %rsi      # 0x5180
subq %r13, %rsi
addq $-0x20, %rsi
leaq 0x18(%rsp), %rdi
callq 0x21e0
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2775
leaq 0x18(%rsp), %rdi
callq 0x2248
movq %rsp, %rdi
callq 0x2b8c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, 0x2aae(%rip)      # 0x53a0
jne 0x28d4
movq 0x26f5(%rip), %rdi      # 0x4ff0
leaq 0x802(%rip), %rsi       # 0x3104
callq 0x2170
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20e0
leaq 0x7ef(%rip), %rsi       # 0x311d
movq %rax, %rdi
callq 0x2170
leaq 0x7e3(%rip), %rsi       # 0x3120
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20b0
jmp 0x28d4
jmp 0x2962
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2248
jmp 0x2965
jmp 0x2962
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2b8c
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 %ebx, %ebx
xorl %edi, %edi
callq 0x21d0
movq %rax, 0x29f7(%rip)      # 0x5380
testq %rax, %rax
je 0x2a26
leaq 0x7d3(%rip), %rsi       # 0x316c
movq %rax, %rdi
xorl %edx, %edx
callq 0x2100
movq %rax, 0x29de(%rip)      # 0x5388
movq 0x29cf(%rip), %rdi      # 0x5380
leaq 0x7bd(%rip), %rsi       # 0x3175
xorl %edx, %edx
callq 0x2100
movq %rax, 0x29ca(%rip)      # 0x5390
movq 0x29b3(%rip), %rdi      # 0x5380
leaq 0x7ae(%rip), %rsi       # 0x3182
xorl %edx, %edx
callq 0x2100
movq %rax, 0x29b6(%rip)      # 0x5398
movq 0x2997(%rip), %rdi      # 0x5380
callq 0x2110
movl %eax, %ebp
testl %eax, %eax
cmovlel %ebx, %ebp
cmpl %ebx, %ebp
je 0x2a1f
movq 0x2980(%rip), %rdi      # 0x5380
movl %ebx, %esi
callq 0x2210
movq 0x2972(%rip), %rdi      # 0x5380
movl $0x80000, %edx          # imm = 0x80000
movq %rax, %rsi
callq 0x20d0
incl %ebx
jmp 0x29f5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x25c3(%rip), %rdi      # 0x4ff0
leaq 0x70b(%rip), %rsi       # 0x313f
callq 0x2170
movq %rax, %rdi
callq 0x20b0
pushq $0x1
popq %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2922(%rip), %rdi      # 0x5380
callq 0x2110
movl %eax, %ebx
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %ebx
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0xc(%rsp), %rbp
cmpl %ebx, %r14d
je 0x2ad7
movq 0x28f7(%rip), %rdi      # 0x5380
movl %r14d, %esi
callq 0x2210
movq 0x28e8(%rip), %rdi      # 0x5380
movq %rax, %rsi
leaq 0x20(%rsp), %rdx
movq %r12, %rcx
movq %r13, %r8
movq %rbp, %r9
callq 0x2070
xorl %r15d, %r15d
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rdi
cmpq %rax, %r15
jae 0x2acd
movq (%rdi,%r15,8), %rdi
callq 0x2813
incq %r15
jmp 0x2ab1
callq 0x21b0
incl %r14d
jmp 0x2a7d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6e1(%rip), %xmm0      # 0x31d8
movq %rsp, %rbx
movaps %xmm0, (%rbx)
leaq 0x18(%rsp), %r14
movq 0x2877(%rip), %rdi      # 0x5380
callq 0x2160
testl %eax, %eax
je 0x2b34
movq 0x2867(%rip), %rdi      # 0x5380
movq %r14, %rsi
callq 0x21f0
cmpl $0x10, 0x18(%rsp)
jne 0x2b02
movq 0x40(%rsp), %rdi
callq 0x2813
jmp 0x2b02
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2050
jmp 0x2b02
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x78, %rsp
movq %rsi, %rbx
cmpl $0x1, %edi
jg 0x36f7
movq 0xc8e5(%rip), %rdi      # 0xffd0
leaq 0x5929(%rip), %rsi      # 0x901b
callq 0x31a0
movq 0x8(%rbx), %rdi
leaq 0x83b1(%rip), %rsi      # 0xbab3
callq 0x3200
leaq 0xcb22(%rip), %rbx      # 0x10230
movq %rax, (%rbx)
callq 0x6072
callq 0x6117
callq 0x61d4
callq 0x624a
callq 0x6285
callq 0x6383
callq 0x62c0
callq 0x6428
callq 0x620f
callq 0x4b38
movq (%rbx), %rdi
callq 0x32d0
testl %eax, %eax
je 0x373e
leaq -0x78(%rbp), %rbx
movq %rbx, %rdi
callq 0x697c
movq 0xcabe(%rip), %rdx      # 0x10220
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0x7c3c
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3260
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7eb0
leaq -0x28(%rbp), %rdi
callq 0x33e8
leaq -0x48(%rbp), %rdi
callq 0x33e8
leaq -0x78(%rbp), %rdi
callq 0x37dc
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x33e8
jmp 0x37bd
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x33e8
jmp 0x37cb
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x37dc
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa22e(%rip), %rbx      # 0x102d0
movq (%rbx), %rsi
addq $0x48, %rdi
callq 0x6464
leaq 0xa24b(%rip), %rax      # 0x10300
movq 0x30(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x60f0
cmpq 0x38(%rax), %rsi
jne 0x60d2
movq 0x48(%rax), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq (%rbx), %rdi
callq 0x6464
leaq 0xa21b(%rip), %rdi      # 0x10300
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6566
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa181(%rip), %rbx      # 0x102c8
movq (%rbx), %rsi
addq $0x48, %rdi
callq 0x6464
leaq 0xa246(%rip), %rax      # 0x103a0
movq 0x30(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x6195
cmpq 0x38(%rax), %rsi
jne 0x6177
movq 0x48(%rax), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq (%rbx), %rdi
callq 0x6464
leaq 0xa216(%rip), %rdi      # 0x103a0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6566
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6382
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r13d, %r13d
testl %esi, %esi
cmovgl %esi, %r13d
movq 0x9cc1(%rip), %r15      # 0xffd0
leaq 0x565e(%rip), %r12      # 0xb974
subl $0x1, %r13d
jb 0x6329
movq %r15, %rdi
movq %r12, %rsi
callq 0x31a0
jmp 0x6316
movl (%r14), %esi
movq 0x9c9d(%rip), %rdi      # 0xffd0
callq 0x3340
movq %rax, %rdi
callq 0x30e0
leaq 0x48(%r14), %r15
incl %ebx
xorl %r12d, %r12d
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x6374
movq %r15, %rdi
movq %r12, %rsi
callq 0x58f4
movq (%rax), %rdi
movl %ebx, %esi
callq 0x62e3
incq %r12
jmp 0x6349
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9f25(%rip), %rbx      # 0x102d8
movq (%rbx), %rsi
addq $0x48, %rdi
callq 0x6464
leaq 0x9f8a(%rip), %rax      # 0x10350
movq 0x30(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x6401
cmpq 0x38(%rax), %rsi
jne 0x63e3
movq 0x48(%rax), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq (%rbx), %rdi
callq 0x6464
leaq 0x9f5a(%rip), %rdi      # 0x10350
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6566
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gprateek93[P]LaTeX_to_HTML/converter.cpp
// Function: converter::traverseSection[abi:cxx11](ast_node*, int)
string converter :: traverseSection(ast_node * root, int type){
    section_no++;
    subsection_no = 0;
    string s = "";
    s+="<"+getMapping(type)+">";
    s+=myString(section_no)+" "+root->data;
    s+="</"+getMapping(type)+">";
    s+=traverseChildren (root);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
incl 0x96ee(%rip)            # 0x1040c
movq %rdi, %rbx
andl $0x0, 0x96e8(%rip)      # 0x10410
leaq 0x4837(%rip), %rsi      # 0xb566
leaq -0x40(%rbp), %rdx
callq 0x5916
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x6edc
leaq 0x4da4(%rip), %rsi      # 0xbaf2
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x7fda
leaq 0x4dca(%rip), %rdx      # 0xbb2c
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7fb1
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
leaq -0x80(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
callq 0x33e8
movl 0x9670(%rip), %esi      # 0x1040c
leaq -0x60(%rbp), %rdi
callq 0x690c
leaq 0x4bc9(%rip), %rdx      # 0xb975
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7fb1
leaq 0x8(%r14), %rdx
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x8008
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
leaq -0x80(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x6edc
leaq 0x4ced(%rip), %rsi      # 0xbaf4
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x7fda
leaq 0x4d11(%rip), %rdx      # 0xbb2c
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7fb1
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
leaq -0x80(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
callq 0x33e8
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6f0c
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
jmp 0x6ec1
jmp 0x6ec8
jmp 0x6e9e
jmp 0x6eac
jmp 0x6eba
jmp 0x6ec8
jmp 0x6e9e
jmp 0x6eac
jmp 0x6eba
jmp 0x6ec8
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x33e8
jmp 0x6eaf
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x33e8
jmp 0x6ebd
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x33e8
jmp 0x6ecb
movq %rax, %r14
movq %rbx, %rdi
callq 0x33e8
movq %r14, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4639(%rip), %rsi      # 0xb566
leaq -0x48(%rbp), %r12
movq %r12, %rdx
callq 0x5916
xorl %r13d, %r13d
movq 0x48(%r14), %rax
movq 0x50(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x6f77
movq (%rax,%r13,8), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x7c3c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x33d0
movq %r12, %rdi
callq 0x33e8
incq %r13
jmp 0x6f3c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x33e8
jmp 0x6f9a
movq %rax, %r14
movq %rbx, %rdi
callq 0x33e8
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/gprateek93[P]LaTeX_to_HTML/converter.cpp
// Function: converter::traverseDefault[abi:cxx11](ast_node*, int)
string converter :: traverseDefault(ast_node * root, int type){
    string s = "";
    s+="<"+getMapping(type)+">";
    s+=traverseChildren(root);
    s+="</"+getMapping(type)+">";
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x42e2(%rip), %rsi      # 0xb566
leaq -0x40(%rbp), %rdx
callq 0x5916
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x6edc
leaq 0x484f(%rip), %rsi      # 0xbaf2
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x7fda
leaq 0x4875(%rip), %rdx      # 0xbb2c
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7fb1
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
leaq -0x80(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
callq 0x33e8
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6f0c
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x6edc
leaq 0x47cf(%rip), %rsi      # 0xbaf4
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x7fda
leaq 0x47f3(%rip), %rdx      # 0xbb2c
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7fb1
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
leaq -0x80(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
callq 0x33e8
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7390
jmp 0x739e
jmp 0x73ac
jmp 0x73ba
movq %rax, %r14
leaq -0x40(%rbp), %rdi
jmp 0x73b3
jmp 0x73ba
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x33e8
jmp 0x73a1
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x33e8
jmp 0x73af
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x33e8
jmp 0x73bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x33e8
movq %r14, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x415e(%rip), %rsi      # 0xb566
leaq -0x40(%rbp), %rdx
callq 0x5916
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x6edc
leaq 0x46cb(%rip), %rsi      # 0xbaf2
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x7fda
leaq 0x46f1(%rip), %rdx      # 0xbb2c
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7fb1
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
leaq -0x80(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
callq 0x33e8
leaq 0x4683(%rip), %rsi      # 0xbaf9
movq %rbx, %rdi
callq 0x33a0
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6f0c
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
jmp 0x74e2
jmp 0x74e9
jmp 0x74e9
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x33e8
jmp 0x74d0
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x33e8
jmp 0x74de
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x33e8
jmp 0x74ec
movq %rax, %r14
movq %rbx, %rdi
callq 0x33e8
movq %r14, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/gprateek93[P]LaTeX_to_HTML/converter.cpp
// Function: converter::traverseAnchor[abi:cxx11](ast_node*, int)
string converter :: traverseAnchor(ast_node * root, int type){
    string s = "";
    if(type == 9){
        //label
        s += "<a name=\"" + root->data + "\"/>";
    }
    else{
        //ref
        s += "<a href=\"#" + root->data + "\">" + root->data + "</a>";
    }
    s += traverseChildren(root);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4045(%rip), %rsi      # 0xb566
leaq -0x40(%rbp), %rdx
callq 0x5916
cmpl $0x9, %r12d
jne 0x7576
leaq 0x8(%r14), %rdx
leaq 0x45d7(%rip), %rsi      # 0xbb12
leaq -0x60(%rbp), %rdi
callq 0x80a2
leaq 0x45d1(%rip), %rdx      # 0xbb1c
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7fb1
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
jmp 0x75f9
leaq 0x8(%r14), %r12
leaq 0x459f(%rip), %rsi      # 0xbb20
leaq -0x80(%rbp), %rdi
movq %r12, %rdx
callq 0x80a2
leaq 0x4597(%rip), %rdx      # 0xbb2b
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7fb1
leaq -0x60(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movq %r12, %rdx
callq 0x8008
leaq 0x4570(%rip), %rdx      # 0xbb2e
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7fb1
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
callq 0x33e8
leaq -0xa0(%rbp), %rdi
callq 0x33e8
leaq -0x80(%rbp), %rdi
callq 0x33e8
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6f0c
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x33e8
jmp 0x7646
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x33e8
jmp 0x7654
movq %rax, %r14
leaq -0xa0(%rbp), %rdi
callq 0x33e8
jmp 0x7673
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x33e8
jmp 0x767c
movq %rax, %r14
leaq -0x80(%rbp), %rdi
jmp 0x768d
movq %rax, %r14
leaq -0x60(%rbp), %rdi
jmp 0x768d
jmp 0x7694
jmp 0x7694
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x33e8
jmp 0x7697
movq %rax, %r14
movq %rbx, %rdi
callq 0x33e8
movq %r14, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O2/gprateek93[P]LaTeX_to_HTML/converter.cpp
// Function: converter::traverseImage[abi:cxx11](ast_node*, int)
string converter :: traverseImage(ast_node * root, int type){
    string s = "";
    if(type == 13){
        s+="<"+ getMapping(type)+" src = "+"\""+root->data+"\" alt = \"Image Here\" "+root->attributes+">";
        s+=traverseChildren(root);
    }
    else{
        s+=traverseDefault(root,type);
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3e81(%rip), %rsi      # 0xb566
leaq -0x40(%rbp), %rdx
callq 0x5916
cmpl $0xd, %r12d
jne 0x782b
leaq -0x60(%rbp), %rdi
pushq $0xd
popq %rdx
movq %r15, %rsi
callq 0x6edc
leaq 0x43e4(%rip), %rsi      # 0xbaf2
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x7fda
leaq 0x4411(%rip), %rdx      # 0xbb33
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7fb1
leaq 0x43e1(%rip), %rdx      # 0xbb1a
leaq -0xc0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x7fb1
leaq 0x8(%r14), %rdx
leaq -0xe0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x8008
leaq 0x43d1(%rip), %rdx      # 0xbb3b
leaq -0x100(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x7fb1
leaq 0x28(%r14), %rdx
leaq -0x120(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x8008
leaq 0x4391(%rip), %rdx      # 0xbb2c
leaq -0x40(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x7fb1
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
leaq -0x120(%rbp), %rdi
callq 0x33e8
leaq -0x100(%rbp), %rdi
callq 0x33e8
leaq -0xe0(%rbp), %rdi
callq 0x33e8
leaq -0xc0(%rbp), %rdi
callq 0x33e8
leaq -0xa0(%rbp), %rdi
callq 0x33e8
leaq -0x80(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
callq 0x33e8
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6f0c
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
jmp 0x7849
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %r12d, %ecx
callq 0x7262
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d0
leaq -0x40(%rbp), %rdi
callq 0x33e8
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x78e6
jmp 0x78f6
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x33e8
jmp 0x787d
movq %rax, %r14
leaq -0x120(%rbp), %rdi
callq 0x33e8
jmp 0x788e
movq %rax, %r14
leaq -0x100(%rbp), %rdi
callq 0x33e8
jmp 0x789f
movq %rax, %r14
leaq -0xe0(%rbp), %rdi
callq 0x33e8
jmp 0x78b0
movq %rax, %r14
leaq -0xc0(%rbp), %rdi
callq 0x33e8
leaq -0xa0(%rbp), %rdi
callq 0x33e8
leaq -0x80(%rbp), %rdi
callq 0x33e8
leaq -0x60(%rbp), %rdi
callq 0x33e8
jmp 0x78f9
movq %rax, %r14
jmp 0x78bc
movq %rax, %r14
jmp 0x78c8
movq %rax, %r14
leaq -0x40(%rbp), %rdi
jmp 0x78d5
movq %rax, %r14
jmp 0x78d1
jmp 0x78f6
movq %rax, %r14
movq %rbx, %rdi
callq 0x33e8
movq %r14, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3ca7(%rip), %rsi      # 0xbb6f
leaq -0x210(%rbp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x31f0
leaq 0x3c9a(%rip), %rsi      # 0xbb7b
movq %r14, %rdi
callq 0x31a0
leaq 0x3c9c(%rip), %rsi      # 0xbb8c
leaq -0x210(%rbp), %rdi
callq 0x31a0
leaq 0x8515(%rip), %rsi      # 0x10418
leaq -0x210(%rbp), %rdi
callq 0x3180
leaq -0x210(%rbp), %rdi
movq %rbx, %rsi
callq 0x3180
leaq 0x3c6f(%rip), %rsi      # 0xbb94
leaq -0x210(%rbp), %rdi
callq 0x31a0
leaq -0x210(%rbp), %rdi
callq 0x3290
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x3290
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2de4(%rip), %rdi      # 0x3fe0
leaq -0x28(%rbp), %rsi
callq 0x1070
movq 0x2dc4(%rip), %rdi      # 0x3fd0
leaq -0x28(%rbp), %rsi
callq 0x1060
movq %rax, %rdi
callq 0x1040
leaq -0x28(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
leaq 0x19b4(%rip), %rsi      # 0x40a7
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x2080
leaq 0x4a29(%rip), %rsi      # 0x7130
leaq -0x20(%rbp), %rdi
callq 0x29c6
leaq 0x19b3(%rip), %rsi      # 0x40ca
leaq -0x60(%rbp), %rdi
callq 0x2210
leaq 0x4a19(%rip), %rsi      # 0x7140
leaq 0x4a16(%rip), %rdx      # 0x7144
leaq -0x20(%rbp), %rdi
callq 0x29f8
leaq 0x4a1b(%rip), %rdx      # 0x7159
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x60(%rbp), %rcx
callq 0x2a44
movq 0x487a(%rip), %rdi      # 0x6fd0
leaq -0x40(%rbp), %rsi
callq 0x2120
movq %rax, %rdi
callq 0x20a0
leaq -0x40(%rbp), %rdi
callq 0x2248
leaq -0x20(%rbp), %rdi
callq 0x2c66
leaq -0x60(%rbp), %rdi
callq 0x2248
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
jmp 0x279e
movq %rax, %rbx
jmp 0x27aa
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2248
jmp 0x27a1
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x2c66
leaq -0x60(%rbp), %rdi
callq 0x2248
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23bc
callq 0x2460
callq 0x2549
callq 0x26e3
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4738(%rip), %al       # 0x71a0
testb %al, %al
je 0x2b2c
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2170
xorl %r12d, %r12d
leaq -0x58(%rbp), %r13
xorl %ebx, %ebx
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rbx
jae 0x2af1
movq (%rax,%rbx,8), %r14
movq -0x30(%rbp), %rdi
leaq 0x46d6(%rip), %rsi      # 0x7180
movq %r12, %rdx
callq 0x2230
cmpq $-0x1, %rax
je 0x2b04
movq %rax, %r12
movq (%r14), %rax
movq %r13, %rdi
movq %r14, %rsi
movq -0x38(%rbp), %rdx
callq *(%rax)
movq 0x46b7(%rip), %rdx      # 0x7188
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rcx
callq 0x2070
addq -0x50(%rbp), %r12
movq %r13, %rdi
callq 0x2248
incq %rbx
jmp 0x2a88
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x20b0
leaq 0x427d(%rip), %rcx      # 0x6d90
movq %rcx, (%rax)
leaq 0x424b(%rip), %rsi      # 0x6d68
movq 0x44bc(%rip), %rdx      # 0x6fe0
movq %rax, %rdi
callq 0x21d0
leaq 0x466d(%rip), %rdi      # 0x71a0
callq 0x2200
testl %eax, %eax
je 0x2a70
leaq 0x4639(%rip), %rdi      # 0x7180
leaq 0x1523(%rip), %rsi      # 0x4071
leaq -0x58(%rbp), %rdx
callq 0x2080
movq 0x4462(%rip), %rdi      # 0x6fc0
leaq 0x461b(%rip), %rsi      # 0x7180
leaq 0x45bc(%rip), %rdx      # 0x7128
callq 0x2110
leaq 0x4628(%rip), %rdi      # 0x71a0
callq 0x20e0
jmp 0x2a70
movq %rax, %r14
leaq 0x4614(%rip), %rdi      # 0x71a0
callq 0x20d0
jmp 0x2baf
jmp 0x2ba3
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x2248
jmp 0x2ba6
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x2248
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq %rsi, %rdi
callq 0x2d3d
leaq -0x30(%rbp), %r13
movq %rax, (%r13)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2d8c
movq %r12, %rdi
callq 0x2d57
movq %rax, (%r13)
leaq -0x30(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2d8c
movq %r15, %rdi
callq 0x2d71
movq %rax, (%r12)
leaq -0x30(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d8c
movq %r14, %rdi
callq 0x2d71
movq %rax, (%r15)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2d8c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x110d(%rip), %rsi      # 0x40ef
leaq -0x38(%rbp), %rdx
callq 0x2080
movq 0x8(%r14), %rsi
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x2080
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2170
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x2220
leaq -0x38(%rbp), %rdi
callq 0x2248
leaq -0x58(%rbp), %rdi
callq 0x2248
leaq 0x10c1(%rip), %rsi      # 0x40ef
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3060
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x2248
jmp 0x3055
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x2248
jmp 0x3063
movq %rax, %r14
movq %rbx, %rdi
callq 0x2248
movq %r14, %rdi
callq 0x21f0
nop