LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Cell-veto[P]postlhc/tools.cpp
// Function: int_pop_arg[abi:cxx11](char const**)
static
std::pair <string, string> int_pop_arg (const char **argv)
{
    assert (*argv);
    string kw = *argv++;
    if (!*argv)
        rt_error ("missing argument for kw " + kw);
    return std::make_pair (kw, string (*argv));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x46db80
jmp 0x46db9f
leaq 0x195e83(%rip), %rdi    # 0x603a0a
leaq 0x195d66(%rip), %rsi    # 0x6038f4
movl $0x9a, %edx
leaq 0x195e76(%rip), %rcx    # 0x603a10
callq 0x53d020
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4771f0
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x407bd0
jmp 0x46dbe1
leaq -0x31(%rbp), %rdi
callq 0x477210
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x46dc5a
leaq 0x195e4a(%rip), %rsi    # 0x603a45
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x407fd0
jmp 0x46dc0a
leaq -0x68(%rbp), %rdi
callq 0x46d330
jmp 0x46dc15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x477210
jmp 0x46dd1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x46dd13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4f1e40
jmp 0x46dd13
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4771f0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x407bd0
jmp 0x46dc97
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x46f180
jmp 0x46dcb0
leaq -0x88(%rbp), %rdi
callq 0x4f1e40
leaq -0x89(%rbp), %rdi
callq 0x477210
leaq -0x30(%rbp), %rdi
callq 0x4f1e40
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x46dd07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4f1e40
leaq -0x89(%rbp), %rdi
callq 0x477210
leaq -0x30(%rbp), %rdi
callq 0x4f1e40
movq -0x40(%rbp), %rdi
callq 0x5283c0
nopw %cs:(%rax,%rax)
// File: Cell-veto[P]postlhc/tools.cpp
// Function: unsigned long read_arg<unsigned long>(char const**)
unsigned long read_arg (const char **argv)
{
    string kw, value;
    std::tie (kw, value) = int_pop_arg (argv);
    try
    {
        return std::stoul (value);
    }
    catch (...)
    {
        rt_error ("cannot convert value " + value + " for keyword " + kw);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4f1d30
leaq -0x48(%rbp), %rdi
callq 0x4f1d30
movq -0x8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x46db50
jmp 0x46dd63
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x128(%rbp)
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %rdx, -0x118(%rbp)
callq 0x46ec40
movq -0x128(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movq %rsi, -0x120(%rbp)
callq 0x46ec80
movq -0x120(%rbp), %rdi
callq 0x46ecf0
movq -0x118(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x46ed20
movq %rax, -0x110(%rbp)
jmp 0x46ddc9
leaq -0x48(%rbp), %rdi
callq 0x4f1e40
leaq -0x28(%rbp), %rdi
callq 0x4f1e40
movq -0x110(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x46def7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
movq -0x90(%rbp), %rdi
callq 0x4751c0
leaq 0x195a9e(%rip), %rsi    # 0x6038c5
leaq -0x108(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x407fd0
jmp 0x46de39
leaq 0x195a9b(%rip), %rdx    # 0x6038db
leaq -0xe8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x409770
jmp 0x46de55
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x45fb40
jmp 0x46de6e
leaq -0xc8(%rbp), %rdi
callq 0x46d330
jmp 0x46de7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x46deee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x46dee2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x46ded6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x4f1e40
leaq -0xe8(%rbp), %rdi
callq 0x4f1e40
leaq -0x108(%rbp), %rdi
callq 0x4f1e40
callq 0x475230
jmp 0x46def5
jmp 0x46def7
leaq -0x48(%rbp), %rdi
callq 0x4f1e40
leaq -0x28(%rbp), %rdi
callq 0x4f1e40
movq -0x90(%rbp), %rdi
callq 0x5283c0
movq %rax, %rdi
callq 0x4082e0
nopl (%rax)
// File: Cell-veto[P]postlhc/tools.cpp
// Function: double read_arg<double>(char const**)
double read_arg (const char **argv)
{
    string kw, value;
    std::tie (kw, value) = int_pop_arg (argv);
    try
    {
        return std::stod (value);
    }
    catch (...)
    {
        rt_error ("cannot convert value " + value + " for keyword " + kw);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4f1d30
leaq -0x48(%rbp), %rdi
callq 0x4f1d30
movq -0x8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x46db50
jmp 0x46df53
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x128(%rbp)
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %rdx, -0x118(%rbp)
callq 0x46ec40
movq -0x128(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movq %rsi, -0x120(%rbp)
callq 0x46ec80
movq -0x120(%rbp), %rdi
callq 0x46ecf0
movq -0x118(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x465330
movsd %xmm0, -0x110(%rbp)
jmp 0x46dfb5
leaq -0x48(%rbp), %rdi
callq 0x4f1e40
leaq -0x28(%rbp), %rdi
callq 0x4f1e40
movsd -0x110(%rbp), %xmm0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x46e0e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
movq -0x90(%rbp), %rdi
callq 0x4751c0
leaq 0x1958b1(%rip), %rsi    # 0x6038c5
leaq -0x108(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x407fd0
jmp 0x46e026
leaq 0x1958ae(%rip), %rdx    # 0x6038db
leaq -0xe8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x409770
jmp 0x46e042
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x45fb40
jmp 0x46e05b
leaq -0xc8(%rbp), %rdi
callq 0x46d330
jmp 0x46e069
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x46e0db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x46e0cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x46e0c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x4f1e40
leaq -0xe8(%rbp), %rdi
callq 0x4f1e40
leaq -0x108(%rbp), %rdi
callq 0x4f1e40
callq 0x475230
jmp 0x46e0e2
jmp 0x46e0e4
leaq -0x48(%rbp), %rdi
callq 0x4f1e40
leaq -0x28(%rbp), %rdi
callq 0x4f1e40
movq -0x90(%rbp), %rdi
callq 0x5283c0
movq %rax, %rdi
callq 0x4082e0
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/tools.cpp
// Function: RandomContext::refill_exp_buffer_()
void RandomContext::refill_exp_buffer_ ()
{
    for (int i = 0; i != RANDOM_EXPONENTIAL_BUFFER_SIZE; ++i)
        exp_buffer_[i] = real ();
    for (int i = 0; i != RANDOM_EXPONENTIAL_BUFFER_SIZE; ++i)
        exp_buffer_[i] = -std::log (1-exp_buffer_[i]);
    num_exp_used_ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
je 0x46e346
movq -0x18(%rbp), %rdi
callq 0x46e170
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsd %xmm0, 0x9c8(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x46e31b
movl $0x0, -0x10(%rbp)
cmpl $0x40, -0x10(%rbp)
je 0x46e3a4
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd 0x18ccb5(%rip), %xmm0   # 0x5fb018
subsd 0x9c8(%rax,%rcx,8), %xmm0
callq 0x51eed0
movq -0x18(%rbp), %rax
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movslq -0x10(%rbp), %rcx
movsd %xmm0, 0x9c8(%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x46e34d
movq -0x18(%rbp), %rax
movl $0x0, 0xbc8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x46e3ee
jmp 0x46e40d
leaq 0x195534(%rip), %rdi    # 0x603929
leaq 0x1954f8(%rip), %rsi    # 0x6038f4
movl $0x103, %edx            # imm = 0x103
leaq 0x19552f(%rip), %rcx    # 0x603937
callq 0x53d020
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x46e41d
jmp 0x46e43c
leaq 0x195540(%rip), %rdi    # 0x603964
leaq 0x1954c9(%rip), %rsi    # 0x6038f4
movl $0x104, %edx            # imm = 0x104
leaq 0x195500(%rip), %rcx    # 0x603937
callq 0x53d020
movq -0x28(%rbp), %rdi
callq 0x46e170
movaps %xmm0, %xmm1
movsd 0x18cbc8(%rip), %xmm0   # 0x5fb018
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x18de92(%rip), %xmm1   # 0x5fc2f8
divsd -0x10(%rbp), %xmm1
callq 0x51ef10
mulsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movsd 0x18dcbf(%rip), %xmm0   # 0x5fc2f8
movsd 0x18c9d7(%rip), %xmm1   # 0x5fb018
callq 0x46e1f0
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x18(%rbp)
movsd 0x18dca1(%rip), %xmm0   # 0x5fc2f8
movsd 0x18c9b9(%rip), %xmm1   # 0x5fb018
callq 0x46e1f0
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
movsd 0x18dc83(%rip), %xmm0   # 0x5fc2f8
movsd 0x18c99b(%rip), %xmm1   # 0x5fb018
callq 0x46e1f0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x18dca3(%rip), %xmm1   # 0x5fc360
callq 0x51ef10
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rdi)
movsd -0x30(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd -0x30(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x10(%rdi)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x46ef2e
jmp 0x46ef4d
leaq 0x194a3c(%rip), %rdi    # 0x603971
leaq 0x1949b8(%rip), %rsi    # 0x6038f4
movl $0x138, %edx            # imm = 0x138
leaq 0x194a34(%rip), %rcx    # 0x60397c
callq 0x53d020
movsd -0x28(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x46ef5b
jmp 0x46ef7a
leaq 0x194a5b(%rip), %rdi    # 0x6039bd
leaq 0x19498b(%rip), %rsi    # 0x6038f4
movl $0x139, %edx            # imm = 0x139
leaq 0x194a07(%rip), %rcx    # 0x60397c
callq 0x53d020
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
callq 0x51ef10
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
callq 0x51ef10
movq -0x40(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
callq 0x46e1f0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
movsd 0x18c045(%rip), %xmm1   # 0x5fb018
divsd %xmm2, %xmm1
callq 0x51ef10
movq -0x40(%rbp), %rdi
callq 0x46e580
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbq (%rax), %rcx
leaq 0x4f71(%rip), %rax      # 0xc0c0
movsbl (%rax,%rcx), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jbe 0x7170
movb $0x0, -0x1(%rbp)
jmp 0x717f
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x7190
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: codebrainz[P]libutfxx/utf/utf.cxx
// Function: isLegalUTF8(char const*, int)
static Boolean isLegalUTF8(const UTF8 *source, int length) {
	UTF8 a;
	const UTF8 *srcptr = source+length;
	switch (length) {
	default: return false;
	/* Everything else falls through when "true"... */
	case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
	case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
	case 2: if ((a = (*--srcptr)) > 0xBF) return false;

	switch ((unsigned char) *source) {
		/* no fall-through in this inner switch */
		case 0xE0: if (a < 0xA0) return false; break;
		case 0xED: if (a > 0x9F) return false; break;
		case 0xF0: if (a < 0x90) return false; break;
		case 0xF4: if (a > 0x8F) return false; break;
		default:   if (a < 0x80) return false;
	}

	case 1: if (*source >= 0x80 && *source < 0xC2) return false;
	}
	if (*source > 0xF4) return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x71ce
movq -0x28(%rbp), %rax
leaq 0x4e4b(%rip), %rcx      # 0xc010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x1(%rbp)
jmp 0x7334
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
movb -0x1(%rax), %al
movb %al, -0x15(%rbp)
movsbl %al, %eax
cmpl $0x80, %eax
jl 0x7201
movsbl -0x15(%rbp), %eax
cmpl $0xbf, %eax
jle 0x720a
movb $0x0, -0x1(%rbp)
jmp 0x7334
jmp 0x720c
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
movb -0x1(%rax), %al
movb %al, -0x15(%rbp)
movsbl %al, %eax
cmpl $0x80, %eax
jl 0x7236
movsbl -0x15(%rbp), %eax
cmpl $0xbf, %eax
jle 0x723f
movb $0x0, -0x1(%rbp)
jmp 0x7334
jmp 0x7241
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
movb -0x1(%rax), %al
movb %al, -0x15(%rbp)
movsbl %al, %eax
cmpl $0xbf, %eax
jle 0x7269
movb $0x0, -0x1(%rbp)
jmp 0x7334
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
addl $0xffffff20, %eax       # imm = 0xFFFFFF20
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x14, %eax
ja 0x72e3
movq -0x30(%rbp), %rax
leaq 0x4d95(%rip), %rcx      # 0xc020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl -0x15(%rbp), %eax
cmpl $0xa0, %eax
jge 0x72a8
movb $0x0, -0x1(%rbp)
jmp 0x7334
jmp 0x72f6
movsbl -0x15(%rbp), %eax
cmpl $0x9f, %eax
jle 0x72bb
movb $0x0, -0x1(%rbp)
jmp 0x7334
jmp 0x72f6
movsbl -0x15(%rbp), %eax
cmpl $0x90, %eax
jge 0x72ce
movb $0x0, -0x1(%rbp)
jmp 0x7334
jmp 0x72f6
movsbl -0x15(%rbp), %eax
cmpl $0x8f, %eax
jle 0x72e1
movb $0x0, -0x1(%rbp)
jmp 0x7334
jmp 0x72f6
movsbl -0x15(%rbp), %eax
cmpl $0x80, %eax
jge 0x72f4
movb $0x0, -0x1(%rbp)
jmp 0x7334
jmp 0x72f6
jmp 0x72f8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x80, %eax
jl 0x731a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xc2, %eax
jge 0x731a
movb $0x0, -0x1(%rbp)
jmp 0x7334
jmp 0x731c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xf4, %eax
jle 0x7330
movb $0x0, -0x1(%rbp)
jmp 0x7334
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: codebrainz[P]libutfxx/utf/utf.cxx
// Function: unsigned long utf::measure_nulterm<char>(char const*)
static size_t measure_nulterm(const T* p)
{
	const T* iter = p;
	size_t length = 0;
	while (*iter++)
		length++;
	return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpb $0x0, (%rax)
je 0x7cea
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7cc8
movq -0x18(%rbp), %rax
popq %rbp
retq
// File: codebrainz[P]libutfxx/utf/utf.cxx
// Function: void utf::convert_ptr_<char, char16_t, ConversionResult (*)(char const**, char const*, char16_t**, char16_t*, ConversionFlags), 32ul>(char const*, unsigned long, std::__cxx11::basic_string<char16_t, std::char_traits<char16_t>, std::allocator<char16_t>>&, ConversionResult (*)(char const**, char const*, char16_t**, char16_t*, ConversionFlags))
void convert_ptr_(const InCharT* in, size_t in_size, std::basic_string<OutCharT>& out, FuncT cvt_func)
{
	OutCharT buf[BufSize] = {0};
	const InCharT* ss = in;
	const InCharT* se = ss + in_size;
	OutCharT* ts = &buf[0];
	OutCharT* te = ts + BufSize;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x62b0
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rcx
movl 0x8292(%rip), %r8d      # 0x10508
leaq -0x68(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq *%rax
movl %eax, -0x84(%rbp)
movq -0x78(%rbp), %rax
leaq -0x60(%rbp), %rcx
subq %rcx, %rax
sarq %rax
movq %rax, -0x90(%rbp)
movl -0x84(%rbp), %eax
movq %rax, -0xa8(%rbp)
subq $0x3, %rax
ja 0x83b7
movq -0xa8(%rbp), %rax
leaq 0x3f18(%rip), %rcx      # 0xc1d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq -0x90(%rbp), %rdx
callq 0x6570
addq $0xc0, %rsp
popq %rbp
retq
movl $0x18, %edi
callq 0x6240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
callq 0x6330
jmp 0x8304
movq -0xb0(%rbp), %rdi
movq 0x7c66(%rip), %rsi      # 0xff78
movq 0x7c97(%rip), %rdx      # 0xffb0
callq 0x68a0
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
callq 0x63a0
jmp 0x83bc
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq -0x90(%rbp), %rdx
callq 0x6570
leaq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x8263
movl $0x18, %edi
callq 0x6240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
callq 0x68b0
jmp 0x837d
movq -0xb8(%rbp), %rdi
movq 0x7c45(%rip), %rsi      # 0xffd0
movq 0x7c0e(%rip), %rdx      # 0xffa0
callq 0x68a0
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
callq 0x63a0
jmp 0x83bc
jmp 0x8263
movq -0x98(%rbp), %rdi
callq 0x68c0
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rsi
movq 0x5e33(%rip), %rdx      # 0x9418
leaq 0x20(%rsp), %rdi
callq 0x3240
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3dd0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x365e
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3e90
movq %rax, %rdi
leaq 0x5bb6(%rip), %rsi      # 0x91e8
callq 0x3df0
testb $0x1, %al
jne 0x363d
jmp 0x364c
movb $0x1, 0x47(%rsp)
movl $0x1, 0x14(%rsp)
jmp 0x366b
jmp 0x364e
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x35f8
movb $0x0, 0x47(%rsp)
movl $0x1, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3d70
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x35d0
testb $0x1, %al
jne 0x36a5
jmp 0x38e4
movq 0xb0(%rsp), %rsi
movq 0x5d6c(%rip), %rdx      # 0x9420
leaq 0x98(%rsp), %rdi
callq 0x3240
movq $0x0, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x3dd0
movq %rax, %rcx
movq 0x48(%rsp), %rax
cmpq %rcx, %rax
jae 0x3834
movl $0x0, 0x8c(%rsp)
cmpl $0x8, 0x8c(%rsp)
jge 0x3819
movslq 0x8c(%rsp), %rcx
shlq $0x6, %rcx
leaq 0x5aec(%rip), %rax      # 0x9210
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x90(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x3e90
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x31b0
movb %al, 0x47(%rsp)
jmp 0x3754
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0x3761
jmp 0x3801
movq 0xb0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x5cb3(%rip), %rax      # 0x9428
movq %rax, 0x30(%rsp)
movslq 0x8c(%rsp), %rax
shlq $0x6, %rax
leaq 0x5a83(%rip), %rcx      # 0x9210
leaq 0x20(%rax,%rcx), %rsi
leaq 0x58(%rsp), %rdi
callq 0x20d0
jmp 0x379e
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x3530
jmp 0x37b4
leaq 0x58(%rsp), %rdi
callq 0x2378
movl $0x1, 0x54(%rsp)
jmp 0x38d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x38ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2378
jmp 0x38ec
jmp 0x3803
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x3703
jmp 0x381b
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
jmp 0x36cd
testb $0x1, 0x5bf5(%rip)      # 0x9430
je 0x38cf
movq 0x57a8(%rip), %rdi      # 0x8ff0
leaq 0x28c5(%rip), %rsi      # 0x6114
callq 0x2200
movq %rax, 0x20(%rsp)
jmp 0x385b
movq 0x20(%rsp), %rdi
leaq 0x649(%rip), %rsi       # 0x3eb0
callq 0x2080
movq %rax, 0x18(%rsp)
jmp 0x3873
movq 0x18(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x2040
movq %rax, 0x10(%rsp)
jmp 0x388c
movq 0x10(%rsp), %rdi
leaq 0x2895(%rip), %rsi      # 0x612d
callq 0x2200
movq %rax, 0x8(%rsp)
jmp 0x38a4
movq 0x8(%rsp), %rdi
leaq 0x2880(%rip), %rsi      # 0x6130
callq 0x2200
movq %rax, (%rsp)
jmp 0x38bb
movq (%rsp), %rdi
movq 0x56fa(%rip), %rsi      # 0x8fc0
callq 0x2230
jmp 0x38cd
jmp 0x38cf
movl $0x0, 0x54(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x3d70
addq $0xb8, %rsp
retq
leaq 0x98(%rsp), %rdi
callq 0x3d70
movq 0x80(%rsp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x3910
xorl %eax, %eax
movl %eax, %edi
callq 0x22c0
movq %rax, 0x5ac5(%rip)      # 0x9410
cmpq $0x0, 0x5abd(%rip)      # 0x9410
jne 0x3981
movq 0x5694(%rip), %rdi      # 0x8ff0
leaq 0x27ec(%rip), %rsi      # 0x614f
callq 0x2200
movq %rax, %rdi
movq 0x564e(%rip), %rsi      # 0x8fc0
callq 0x2230
movl $0x1, %edi
callq 0x2280
movq 0x5a88(%rip), %rdi      # 0x9410
leaq 0x27ed(%rip), %rsi      # 0x617c
xorl %edx, %edx
callq 0x2170
movq %rax, 0x5a7b(%rip)      # 0x9418
movq 0x5a6c(%rip), %rdi      # 0x9410
leaq 0x27da(%rip), %rsi      # 0x6185
xorl %edx, %edx
callq 0x2170
movq %rax, 0x5a67(%rip)      # 0x9420
movq 0x5a50(%rip), %rdi      # 0x9410
leaq 0x27cb(%rip), %rsi      # 0x6192
xorl %edx, %edx
callq 0x2170
movq %rax, 0x5a53(%rip)      # 0x9428
movq 0x5a34(%rip), %rdi      # 0x9410
callq 0x2180
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x3a2f
movq 0x5a12(%rip), %rdi      # 0x9410
movl 0x10(%rsp), %esi
callq 0x2300
movq %rax, 0x8(%rsp)
movq 0x59fd(%rip), %rdi      # 0x9410
movq 0x8(%rsp), %rsi
movl $0x80000, %edx          # imm = 0x80000
callq 0x2130
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x39ed
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq 0x59c5(%rip), %rdi      # 0x9410
callq 0x2180
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x3aef
movq 0x599f(%rip), %rdi      # 0x9410
movl 0x14(%rsp), %esi
callq 0x2300
movq %rax, 0x8(%rsp)
movq 0x598a(%rip), %rdi      # 0x9410
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x1c(%rsp), %r9
callq 0x20a0
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x3ad5
movq 0x20(%rsp), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x3680
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3aac
movq 0x20(%rsp), %rdi
callq 0x22a0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3a5c
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xd8, %rsp
movq 0x26da(%rip), %rax      # 0x61e8
movq %rax, 0xc8(%rsp)
movq 0x26d3(%rip), %rax      # 0x61f0
movq %rax, 0xd0(%rsp)
jmp 0x3b27
movq 0x58e2(%rip), %rdi      # 0x9410
callq 0x21e0
cmpl $0x0, %eax
je 0x3b64
movq 0x58d1(%rip), %rdi      # 0x9410
leaq 0x8(%rsp), %rsi
callq 0x22d0
movl 0x8(%rsp), %eax
subl $0x10, %eax
jne 0x3b60
jmp 0x3b54
movq 0x30(%rsp), %rdi
callq 0x3680
jmp 0x3b62
jmp 0x3b62
jmp 0x3b27
leaq 0xc8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2070
jmp 0x3b25
nopw (%rax,%rax)
// File: gliktaras[P]skyperole/skyperole.cpp
// Function: main
int main(int argc, char **argv) {
    initialize(argc, argv);
    scanWindowTree();
    eventLoop();

    return EXIT_SUCCESS;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x3920
callq 0x3a40
callq 0x3b00
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x3932
movq 0x156a2(%rip), %rdi     # 0x18fc8
leaq 0xc6ee(%rip), %rsi      # 0x1001b
callq 0x3270
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xf186(%rip), %rsi      # 0x12ac7
callq 0x3320
movq %rax, %rcx
leaq 0x15980(%rip), %rax     # 0x192d0
movq %rcx, (%rax)
callq 0x98a0
callq 0x9990
callq 0x9ab0
callq 0x9bb0
callq 0x9c30
callq 0x9dd0
callq 0x9cb0
callq 0x9ec0
callq 0x9b30
callq 0x5d20
leaq 0x15944(%rip), %rax     # 0x192d0
movq (%rax), %rdi
callq 0x3400
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3980
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xb910
movq -0x98(%rbp), %rsi
movq 0x15902(%rip), %rdx     # 0x192c0
leaq -0x60(%rbp), %rdi
callq 0xd990
jmp 0x39c9
leaq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3120
jmp 0x39db
leaq -0x40(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xdf20
jmp 0x39ed
leaq -0x90(%rbp), %rdi
callq 0x3528
leaq -0x60(%rbp), %rdi
callq 0x3528
leaq -0x40(%rbp), %rdi
callq 0x3a70
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x3a54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x3a4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3528
leaq -0x60(%rbp), %rdi
callq 0x3528
leaq -0x40(%rbp), %rdi
callq 0x3a70
movq -0x68(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: gprateek93[P]LaTeX_to_HTML/lex.yy.c
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 494 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 493);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x14702(%rip), %rax     # 0x19310
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xb62f(%rip), %rax      # 0x10250
cmpw $0x0, (%rax,%rcx,2)
je 0x4c3c
movl -0x4(%rbp), %eax
movl %eax, 0x146eb(%rip)     # 0x1931c
movq -0x10(%rbp), %rax
movq %rax, 0x146e4(%rip)     # 0x19320
jmp 0x4c3e
movslq -0x4(%rbp), %rcx
leaq 0xbf97(%rip), %rax      # 0x10be0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0xb9d3(%rip), %rax      # 0x10630
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x4c96
movslq -0x4(%rbp), %rcx
leaq 0xc35f(%rip), %rax      # 0x10fd0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x1ee, -0x4(%rbp)      # imm = 0x1EE
jl 0x4c94
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0xc732(%rip), %rax      # 0x113c0
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x4c3e
movslq -0x4(%rbp), %rcx
leaq 0xbf3f(%rip), %rax      # 0x10be0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0xc73b(%rip), %rax      # 0x113f0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x1ed, -0x4(%rbp)      # imm = 0x1ED
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x4cdb
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x4ce1
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xfa6d(%rip), %rax      # 0x19370
movq (%rax), %rsi
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x9fa0
leaq 0xfa86(%rip), %rdi      # 0x193a0
callq 0xa1f0
testb $0x1, %al
jne 0x994d
leaq 0xfa76(%rip), %rdi      # 0x193a0
callq 0xa210
movq %rax, %rsi
leaq 0xfa37(%rip), %rax      # 0x19370
movq (%rax), %rdi
callq 0x9fa0
leaq 0xfa58(%rip), %rdi      # 0x193a0
callq 0xa230
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xf975(%rip), %rax      # 0x19368
movq (%rax), %rsi
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x9fa0
leaq 0xfa36(%rip), %rdi      # 0x19440
callq 0xa1f0
testb $0x1, %al
jne 0x9a3d
leaq 0xfa26(%rip), %rdi      # 0x19440
callq 0xa210
movq %rax, %rsi
leaq 0xf93f(%rip), %rax      # 0x19368
movq (%rax), %rdi
callq 0x9fa0
leaq 0xfa08(%rip), %rdi      # 0x19440
callq 0xa230
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9d1b
jmp 0x9dbb
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9d48
movq 0xf297(%rip), %rdi      # 0x18fc8
leaq 0x8c4e(%rip), %rsi      # 0x12986
callq 0x3270
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9d22
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq 0xf273(%rip), %rdi      # 0x18fc8
callq 0x3470
movq %rax, %rdi
movq 0xf244(%rip), %rsi      # 0x18fa8
callq 0x32b0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x7b20
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x9dbb
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movslq -0x14(%rbp), %rsi
callq 0x7b40
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x9d00
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9d70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xf545(%rip), %rax      # 0x19378
movq (%rax), %rsi
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x9fa0
leaq 0xf5a6(%rip), %rdi      # 0x193f0
callq 0xa1f0
testb $0x1, %al
jne 0x9e7d
leaq 0xf596(%rip), %rdi      # 0x193f0
callq 0xa210
movq %rax, %rsi
leaq 0xf50f(%rip), %rax      # 0x19378
movq (%rax), %rdi
callq 0x9fa0
leaq 0xf578(%rip), %rdi      # 0x193f0
callq 0xa230
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34a0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x62ac(%rip), %rsi      # 0x12566
callq 0x7b80
jmp 0xc2c1
leaq -0x1a(%rbp), %rdi
callq 0x32e0
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0x7b20
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0xc378
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movslq -0x30(%rbp), %rsi
callq 0x9570
movq -0x68(%rbp), %rsi
movq (%rax), %rdx
leaq -0x50(%rbp), %rdi
callq 0xd990
jmp 0xc319
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3360
jmp 0xc328
leaq -0x50(%rbp), %rdi
callq 0x3528
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xc2d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x32e0
jmp 0xc3a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xc398
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3528
jmp 0xc398
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xc38b
movq -0x60(%rbp), %rdi
callq 0x3528
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3528
movq -0x28(%rbp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movb $0x0, -0x1d(%rbp)
leaq -0x1e(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x34a0
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rdx
leaq 0x5987(%rip), %rsi      # 0x12566
callq 0x7b80
jmp 0xcbe6
leaq -0x1e(%rbp), %rdi
callq 0x32e0
movq -0xc8(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x90(%rbp), %rdi
callq 0xc220
jmp 0xcc07
leaq 0x5ef8(%rip), %rsi      # 0x12b06
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0xe160
jmp 0xcc20
leaq 0x5f19(%rip), %rdx      # 0x12b40
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xe110
jmp 0xcc36
movq -0xc0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3360
jmp 0xcc48
leaq -0x50(%rbp), %rdi
callq 0x3528
leaq -0x70(%rbp), %rdi
callq 0x3528
leaq -0x90(%rbp), %rdi
callq 0x3528
movq -0xc0(%rbp), %rdi
leaq 0x5e99(%rip), %rsi      # 0x12b0d
callq 0x3250
jmp 0xcc7b
movq -0xc8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
callq 0xc270
jmp 0xcc94
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x3360
jmp 0xcca9
leaq -0xb0(%rbp), %rdi
callq 0x3528
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0xcd5e
jmp 0xcd52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x32e0
jmp 0xcd7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xcd6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xcd2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xcd21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3528
leaq -0x70(%rbp), %rdi
callq 0x3528
leaq -0x90(%rbp), %rdi
callq 0x3528
jmp 0xcd6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3528
jmp 0xcd6e
movq -0xc0(%rbp), %rdi
callq 0x3528
movq -0xd0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x3528
movq -0x28(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: 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
subq $0x230, %rsp            # imm = 0x230
movq %rsi, -0x230(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x4c42(%rip), %rsi      # 0x12b83
leaq -0x210(%rbp), %rdi
movq %rdi, -0x228(%rbp)
movl $0x10, %edx
callq 0x32f0
movq -0x228(%rbp), %rdi
leaq 0x4c28(%rip), %rsi      # 0x12b8f
callq 0x3270
jmp 0xdf6e
leaq 0x4c2b(%rip), %rsi      # 0x12ba0
leaq -0x210(%rbp), %rdi
callq 0x3270
jmp 0xdf83
leaq 0xb52e(%rip), %rsi      # 0x194b8
leaq -0x210(%rbp), %rdi
callq 0x3230
jmp 0xdf98
movq -0x230(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x3230
jmp 0xdfad
leaq 0x4bf4(%rip), %rsi      # 0x12ba8
leaq -0x210(%rbp), %rdi
callq 0x3270
jmp 0xdfc2
leaq -0x210(%rbp), %rdi
callq 0x33c0
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x33c0
movq -0x218(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1080
movq -0x40(%rbp), %rsi
movq 0x2dc9(%rip), %rdi      # 0x3fe0
callq 0x1070
jmp 0x121e
movq 0x2dab(%rip), %rdi      # 0x3fd0
leaq -0x28(%rbp), %rsi
callq 0x1050
movq %rax, -0x48(%rbp)
jmp 0x1234
movq -0x48(%rbp), %rdi
movq 0x2d81(%rip), %rsi      # 0x3fc0
callq 0x1060
jmp 0x1246
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1030
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
callq 0x10a0
// File: 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
subq $0x90, %rsp
movb $0x0, -0x1(%rbp)
movb $0x1, -0x2(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2240
movq -0x80(%rbp), %rdx
leaq 0x455c(%rip), %rsi      # 0x70a7
leaq -0x28(%rbp), %rdi
callq 0x21c0
jmp 0x2b56
leaq -0x29(%rbp), %rdi
callq 0x2190
leaq 0x95f2(%rip), %rsi      # 0xc158
leaq -0x58(%rbp), %rdi
callq 0x30c0
jmp 0x2b71
testb $0x1, -0x1(%rbp)
je 0x2bd9
leaq 0x454c(%rip), %rsi      # 0x70ca
leaq -0x28(%rbp), %rdi
callq 0x2150
jmp 0x2b89
leaq 0x95d0(%rip), %rsi      # 0xc160
leaq -0x58(%rbp), %rdi
callq 0x3110
jmp 0x2b9b
jmp 0x2bd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x2190
jmp 0x2c9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2c96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2c8d
testb $0x1, -0x2(%rbp)
je 0x2c0c
leaq 0x44f2(%rip), %rsi      # 0x70d8
leaq -0x28(%rbp), %rdi
callq 0x2150
jmp 0x2bf1
leaq 0x9570(%rip), %rsi      # 0xc168
leaq 0x956d(%rip), %rdx      # 0xc16c
leaq -0x58(%rbp), %rdi
callq 0x3150
jmp 0x2c0a
jmp 0x2c0c
leaq 0x956e(%rip), %rdx      # 0xc181
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x28(%rbp), %rcx
callq 0x31b0
jmp 0x2c26
movq 0x93ab(%rip), %rdi      # 0xbfd8
leaq -0x78(%rbp), %rsi
callq 0x2130
movq %rax, -0x88(%rbp)
jmp 0x2c3f
movq -0x88(%rbp), %rdi
movq 0x936b(%rip), %rsi      # 0xbfb8
callq 0x2180
jmp 0x2c54
leaq -0x78(%rbp), %rdi
callq 0x2298
leaq -0x58(%rbp), %rdi
callq 0x3450
leaq -0x28(%rbp), %rdi
callq 0x2298
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2298
leaq -0x58(%rbp), %rdi
callq 0x3450
leaq -0x28(%rbp), %rdi
callq 0x2298
movq -0x38(%rbp), %rdi
callq 0x2230
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x2450
callq 0x2550
callq 0x26f0
callq 0x2b20
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d60
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x3d30
movq -0x18(%rbp), %rdi
callq 0x3d80
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x3d30
movq -0x20(%rbp), %rdi
callq 0x3da0
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x3d30
movq -0x28(%rbp), %rdi
callq 0x3da0
movq -0x50(%rbp), %rdi
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x3d30
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)