LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::make_node(char const*, scrambler::node*, scrambler::node*)
node *make_node(const char *s, node *n1, node *n2)
{
    node *ret = new node;
    ret->needs_parens = true;
    if (s) {
        ret->symbol = s;
    }
    ret->is_name = false;
    if (n1) {
        ret->children.push_back(n1);
    }
    if (n2) {
        ret->children.push_back(n2);
    }
    if (!ret->symbol.empty() && ret->children.empty()) {
        ret->needs_parens = false;
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x30, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x7310
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x28(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x3d9e
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x3380
movq -0x20(%rbp), %rax
movb $0x0, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x3dbe
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq -0x10(%rbp), %rsi
callq 0x7340
cmpq $0x0, -0x18(%rbp)
je 0x3dd6
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0x7340
movq -0x20(%rbp), %rdi
callq 0x34f0
testb $0x1, %al
jne 0x3dfe
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x73b0
testb $0x1, %al
jne 0x3df6
jmp 0x3dfe
movq -0x20(%rbp), %rax
movb $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::make_node(std::vector<scrambler::node*, std::allocator<scrambler::node*>> const*)
node *make_node(const std::vector<node *> *v)
{
    node *ret = new node;
    ret->needs_parens = true;
    ret->symbol = "";
    ret->is_name = false;
    ret->children.assign(v->begin(), v->end());
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x30, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
callq 0x7310
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x28(%rax)
movq -0x10(%rbp), %rdi
leaq 0x15b11(%rip), %rsi     # 0x1995e
callq 0x3380
movq -0x10(%rbp), %rax
movb $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7230
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7260
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x73f0
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::make_node(scrambler::node*, std::vector<scrambler::node*, std::allocator<scrambler::node*>> const*)
node *make_node(node *n, const std::vector<node *> *v)
{
    node *ret = new node;
    ret->needs_parens = true;
    ret->symbol = "";
    ret->is_name = false;
    ret->children.push_back(n);
    ret->children.insert(ret->children.end(), v->begin(), v->end());
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x30, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
callq 0x7310
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, 0x28(%rax)
movq -0x18(%rbp), %rdi
leaq 0x15a7d(%rip), %rsi     # 0x1995e
callq 0x3380
movq -0x18(%rbp), %rax
movb $0x0, 0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq -0x8(%rbp), %rsi
callq 0x7340
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x71c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x71f0
movq -0x10(%rbp), %rdi
callq 0x7230
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7260
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x7110
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::make_name_node(char const*, scrambler::node*)
node *make_name_node(const char* s, node *n1)
{
    node *ret = new node;
    assert(s);
    ret->symbol = s;
    ret->is_name = true;
    ret->needs_parens = false;
    if (n1) {
        ret->children.push_back(n1);
        ret->needs_parens = true;
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x30, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
callq 0x7310
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3fa7
jmp 0x3fc6
leaq 0x15161(%rip), %rdi     # 0x1910f
leaq 0x15060(%rip), %rsi     # 0x19015
movl $0x127, %edx            # imm = 0x127
leaq 0x150cb(%rip), %rcx     # 0x1908c
callq 0x31a0
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x3380
movq -0x18(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x28(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x4003
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq -0x10(%rbp), %rsi
callq 0x7340
movq -0x18(%rbp), %rax
movb $0x1, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::shuffle_list(std::vector<scrambler::node*, std::allocator<scrambler::node*>>*, unsigned long, unsigned long)
void shuffle_list(std::vector<scrambler::node *> *v, size_t start, size_t end)
{
    if (!no_scramble) {
        size_t n = end - start;
        for (size_t i = n-1; i > 0; --i) {
            std::swap((*v)[i+start], (*v)[next_rand_int(i+1)+start]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
testb $0x1, 0x22235(%rip)     # 0x262f0
jne 0x4132
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x4130
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq -0x10(%rbp), %rsi
callq 0x7450
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x37c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq -0x10(%rbp), %rsi
callq 0x7450
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x74a0
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x40d5
jmp 0x4132
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::set_logic(std::string const&)
void set_logic(const std::string &l)
{
    // each benchmark contains a single set-logic command
    if (!logic.empty()) {
        std::cerr << "ERROR logic is already set" << std::endl;
        exit(1);
    }

    logic = l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x221c5(%rip), %rdi     # 0x26358
callq 0x34f0
testb $0x1, %al
jne 0x41c8
movq 0x21e4d(%rip), %rdi     # 0x25ff0
leaq 0x14f18(%rip), %rsi     # 0x190c2
callq 0x3260
movq %rax, %rdi
movq 0x21de7(%rip), %rsi     # 0x25fa0
callq 0x3280
movl $0x1, %edi
callq 0x32f0
movq -0x8(%rbp), %rsi
leaq 0x22185(%rip), %rdi     # 0x26358
callq 0x31f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: logic_is_dl()
bool logic_is_dl()  // Difference Logic: IDL, RDL
{
    static int result = -1;
    if (result == -1) {
        if (logic.empty()) {
            std::cerr << "ERROR logic has not been set" << std::endl;
            exit(1);
        }

        if (logic.find("IDL") != std::string::npos || logic.find("RDL") != std::string::npos) {
            result = 1;
        } else {
            result = 0;
        }
    }

    return (result == 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x220b5(%rip)    # 0x262a0
jne 0x4281
leaq 0x22160(%rip), %rdi     # 0x26358
callq 0x34f0
testb $0x1, %al
jne 0x4203
jmp 0x422f
movq 0x21de6(%rip), %rdi     # 0x25ff0
leaq 0x14ecc(%rip), %rsi     # 0x190dd
callq 0x3260
movq %rax, %rdi
movq 0x21d80(%rip), %rsi     # 0x25fa0
callq 0x3280
movl $0x1, %edi
callq 0x32f0
leaq 0x22122(%rip), %rdi     # 0x26358
leaq 0x14ebd(%rip), %rsi     # 0x190fa
xorl %eax, %eax
movl %eax, %edx
callq 0x3140
cmpq $-0x1, %rax
jne 0x4269
leaq 0x22105(%rip), %rdi     # 0x26358
leaq 0x14ea4(%rip), %rsi     # 0x190fe
xorl %eax, %eax
movl %eax, %edx
callq 0x3140
cmpq $-0x1, %rax
je 0x4275
movl $0x1, 0x2202d(%rip)     # 0x262a0
jmp 0x427f
movl $0x0, 0x22021(%rip)     # 0x262a0
jmp 0x4281
cmpl $0x1, 0x22018(%rip)     # 0x262a0
sete %al
andb $0x1, %al
popq %rbp
retq
nop
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: logic_is_arith()
bool logic_is_arith()  // Arithmetic: IA, RA, IRA
{
    static int result = -1;
    if (result == -1) {
        if (logic.empty()) {
            std::cerr << "ERROR logic has not been set" << std::endl;
            exit(1);
        }

        if (logic.find("IA") != std::string::npos || logic.find("RA") != std::string::npos) {
            result = 1;
        } else {
            result = 0;
        }
    }

    return (result == 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x22009(%rip)    # 0x262a4
jne 0x4331
leaq 0x220b0(%rip), %rdi     # 0x26358
callq 0x34f0
testb $0x1, %al
jne 0x42b3
jmp 0x42df
movq 0x21d36(%rip), %rdi     # 0x25ff0
leaq 0x14e1c(%rip), %rsi     # 0x190dd
callq 0x3260
movq %rax, %rdi
movq 0x21cd0(%rip), %rsi     # 0x25fa0
callq 0x3280
movl $0x1, %edi
callq 0x32f0
leaq 0x22072(%rip), %rdi     # 0x26358
leaq 0x14e15(%rip), %rsi     # 0x19102
xorl %eax, %eax
movl %eax, %edx
callq 0x3140
cmpq $-0x1, %rax
jne 0x4319
leaq 0x22055(%rip), %rdi     # 0x26358
leaq 0x14dfb(%rip), %rsi     # 0x19105
xorl %eax, %eax
movl %eax, %edx
callq 0x3140
cmpq $-0x1, %rax
je 0x4325
movl $0x1, 0x21f81(%rip)     # 0x262a4
jmp 0x432f
movl $0x0, 0x21f75(%rip)     # 0x262a4
jmp 0x4331
cmpl $0x1, 0x21f6c(%rip)     # 0x262a4
sete %al
andb $0x1, %al
popq %rbp
retq
nop
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: logic_is_bv()
bool logic_is_bv()  // BitVectors (BV)
{
    static int result = -1;
    if (result == -1) {
        if (logic.empty()) {
            std::cerr << "ERROR logic has not been set" << std::endl;
            exit(1);
        }

        if (logic.find("BV") != std::string::npos) {
            result = 1;
        } else {
            result = 0;
        }
    }

    return result == 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x21f5d(%rip)    # 0x262a8
jne 0x43c0
leaq 0x22004(%rip), %rdi     # 0x26358
callq 0x34f0
testb $0x1, %al
jne 0x435f
jmp 0x438b
movq 0x21c8a(%rip), %rdi     # 0x25ff0
leaq 0x14d70(%rip), %rsi     # 0x190dd
callq 0x3260
movq %rax, %rdi
movq 0x21c24(%rip), %rsi     # 0x25fa0
callq 0x3280
movl $0x1, %edi
callq 0x32f0
leaq 0x21fc6(%rip), %rdi     # 0x26358
leaq 0x14d6f(%rip), %rsi     # 0x19108
xorl %eax, %eax
movl %eax, %edx
callq 0x3140
cmpq $-0x1, %rax
je 0x43b4
movl $0x1, 0x21ef6(%rip)     # 0x262a8
jmp 0x43be
movl $0x0, 0x21eea(%rip)     # 0x262a8
jmp 0x43c0
cmpl $0x1, 0x21ee1(%rip)     # 0x262a8
sete %al
andb $0x1, %al
popq %rbp
retq
nop
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: logic_is_fp()
bool logic_is_fp()  // FloatingPoint (FP)
{
    static int result = -1;
    if (result == -1) {
        if (logic.empty()) {
            std::cerr << "ERROR logic has not been set" << std::endl;
            exit(1);
        }

        if (logic.find("FP") != std::string::npos) {
            result = 1;
        } else {
            result = 0;
        }
    }

    return result == 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x21ed1(%rip)    # 0x262ac
jne 0x4450
leaq 0x21f74(%rip), %rdi     # 0x26358
callq 0x34f0
testb $0x1, %al
jne 0x43ef
jmp 0x441b
movq 0x21bfa(%rip), %rdi     # 0x25ff0
leaq 0x14ce0(%rip), %rsi     # 0x190dd
callq 0x3260
movq %rax, %rdi
movq 0x21b94(%rip), %rsi     # 0x25fa0
callq 0x3280
movl $0x1, %edi
callq 0x32f0
leaq 0x21f36(%rip), %rdi     # 0x26358
leaq 0x14ce2(%rip), %rsi     # 0x1910b
xorl %eax, %eax
movl %eax, %edx
callq 0x3140
cmpq $-0x1, %rax
je 0x4444
movl $0x1, 0x21e6a(%rip)     # 0x262ac
jmp 0x444e
movl $0x0, 0x21e5e(%rip)     # 0x262ac
jmp 0x4450
cmpl $0x1, 0x21e55(%rip)     # 0x262ac
sete %al
andb $0x1, %al
popq %rbp
retq
nop
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: make_annotation_name()
std::string make_annotation_name()
{
    static uint64_t n = 1;
    std::ostringstream tmp;
    tmp << "smtcomp" << n;
    ++n;
    return tmp.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x198(%rbp)
movq %rdi, %rax
movq %rax, -0x190(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x168(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0x3070
movq -0x188(%rbp), %rdi
leaq 0x14cd9(%rip), %rsi     # 0x199da
callq 0x3260
movq %rax, -0x180(%rbp)
jmp 0x4d0f
movq -0x180(%rbp), %rdi
movq 0x21593(%rip), %rsi     # 0x262b0
callq 0x3090
jmp 0x4d24
movq -0x198(%rbp), %rdi
movq 0x2157e(%rip), %rax     # 0x262b0
incq %rax
movq %rax, 0x21574(%rip)     # 0x262b0
leaq -0x168(%rbp), %rsi
callq 0x3430
jmp 0x4d4a
leaq -0x168(%rbp), %rdi
callq 0x34e0
movq -0x190(%rbp), %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x170(%rbp)
movl %eax, -0x174(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x34e0
movq -0x170(%rbp), %rdi
callq 0x3460
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: keep_annotation(scrambler::node const*, annotation_mode)
static bool keep_annotation(const scrambler::node *n, annotation_mode keep_annotations) {
    if (keep_annotations == none)
        return false;
    if (keep_annotations == all)
        return true;
    assert(keep_annotations == pattern);
    return n->children.size() == 2 && n->children[1]->symbol == ":pattern";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x51bb
movb $0x0, -0x1(%rbp)
jmp 0x5235
cmpl $0x2, -0x14(%rbp)
jne 0x51c7
movb $0x1, -0x1(%rbp)
jmp 0x5235
cmpl $0x1, -0x14(%rbp)
jne 0x51cf
jmp 0x51ee
leaq 0x14915(%rip), %rdi     # 0x19aeb
leaq 0x13e38(%rip), %rsi     # 0x19015
movl $0x261, %edx            # imm = 0x261
leaq 0x1491e(%rip), %rcx     # 0x19b07
callq 0x31a0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x7430
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x2, %rcx
movb %al, -0x15(%rbp)
jne 0x522d
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0x7510
movq (%rax), %rdi
leaq 0x14921(%rip), %rsi     # 0x19b46
callq 0x74e0
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: filter_named(std::unordered_set<std::string, std::hash<std::string>, std::equal_to<std::string>, std::allocator<std::string>> const&)
void filter_named(const StringSet &to_keep)
{
    size_t i, k;
    for (i = k = 0; i < commands.size(); ++i) {
        scrambler::node *cur = commands[i];
        bool keep = true;
        if (cur->symbol == "assert") {
            std::string name = get_named_annot(cur);
            if (!name.empty() && to_keep.find(name) == to_keep.end()) {
                keep = false;
            }
        }
        if (keep) {
            commands[k++] = cur;
        }
    }
    commands.resize(k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x20445(%rip), %rdi     # 0x26340
callq 0x7430
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x6010
movq -0x10(%rbp), %rsi
leaq 0x20425(%rip), %rdi     # 0x26340
callq 0x7450
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x152ea(%rip), %rsi     # 0x1b220
callq 0x74e0
testb $0x1, %al
jne 0x5f44
jmp 0x5fcd
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5b70
leaq -0x30(%rbp), %rdi
callq 0x34f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x59(%rbp)
jne 0x5f9e
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7bb0
movq %rax, -0x68(%rbp)
jmp 0x5f79
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7be0
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7b80
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x5fa7
jmp 0x5fc4
movb $0x0, -0x21(%rbp)
jmp 0x5fc4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3518
jmp 0x6026
leaq -0x30(%rbp), %rdi
callq 0x3518
testb $0x1, -0x21(%rbp)
je 0x5ffd
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
leaq 0x2034f(%rip), %rdi     # 0x26340
callq 0x7450
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x5fff
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5eec
movq -0x18(%rbp), %rsi
leaq 0x20325(%rip), %rdi     # 0x26340
callq 0x7c10
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3460
nop
// File: SMT-COMP[P]scrambler/scrambler.cpp
// Function: c_strdup(char const*)
char *c_strdup(const char *s)
{
    char *ret = (char *)malloc(strlen(s) + 1);
    if (ret == NULL) {
        exit(1);
    }

    strcpy(ret, s);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x3330
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6066
movl $0x1, %edi
callq 0x32f0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3230
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: SMT-COMP[P]scrambler/parser.cpp
// Function: yy_symbol_print(_IO_FILE*, yysymbol_kind_t, YYSTYPE const*, YYLTYPE const*)
static void
yy_symbol_print (FILE *yyo,
                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
{
  YYFPRINTF (yyo, "%s %s (",
             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));

  YYLOCATION_PRINT (yyo, yylocationp);
  YYFPRINTF (yyo, ": ");
  yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp);
  YYFPRINTF (yyo, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x2e, -0xc(%rbp)
jge 0x13f92
leaq 0x70a9(%rip), %rax      # 0x1b035
movq %rax, -0x30(%rbp)
jmp 0x13f9f
leaq 0x70a2(%rip), %rax      # 0x1b03b
movq %rax, -0x30(%rbp)
jmp 0x13f9f
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %edi
callq 0x14840
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x706c(%rip), %rsi      # 0x1b02d
movb $0x0, %al
callq 0x3370
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14860
movq -0x8(%rbp), %rdi
leaq 0x703c(%rip), %rsi      # 0x1b01c
movb $0x0, %al
callq 0x3370
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x14990
movq -0x8(%rbp), %rdi
leaq 0x525a(%rip), %rsi      # 0x19260
movb $0x0, %al
callq 0x3370
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: SMT-COMP[P]scrambler/parser.cpp
// Function: yy_reduce_print(unsigned char*, YYSTYPE*, YYLTYPE*, int)
static void
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp,
                 int yyrule)
{
  int yylno = yyrline[yyrule];
  int yynrhs = yyr2[yyrule];
  int yyi;
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
             yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr,
                       YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
                       &yyvsp[(yyi + 1) - (yynrhs)],
                       &(yylsp[(yyi + 1) - (yynrhs)]));
      YYFPRINTF (stderr, "\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x69ce(%rip), %rax      # 0x1aa10
movswl (%rax,%rcx,2), %eax
movl %eax, -0x20(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x670c(%rip), %rax      # 0x1a760
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movq 0x11f5e(%rip), %rax     # 0x25fc0
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
subl $0x1, %edx
movl -0x20(%rbp), %ecx
leaq 0x7428(%rip), %rsi      # 0x1b49d
movb $0x0, %al
callq 0x3370
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x14130
movq 0x11f2a(%rip), %rax     # 0x25fc0
movq (%rax), %rdi
movl -0x28(%rbp), %edx
addl $0x1, %edx
leaq 0x741d(%rip), %rsi      # 0x1b4c3
movb $0x0, %al
callq 0x3370
movq 0x11f0c(%rip), %rax     # 0x25fc0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
subl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x683b(%rip), %rax      # 0x1a910
movsbl (%rax,%rcx), %esi
movq -0x10(%rbp), %rdx
movl -0x28(%rbp), %eax
addl $0x1, %eax
subl -0x24(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
movq -0x18(%rbp), %rcx
movl -0x28(%rbp), %eax
addl $0x1, %eax
subl -0x24(%rbp), %eax
cltq
shlq $0x4, %rax
addq %rax, %rcx
callq 0x13f60
movq 0x11eaf(%rip), %rax     # 0x25fc0
movq (%rax), %rdi
leaq 0x5842(%rip), %rsi      # 0x1995d
movb $0x0, %al
callq 0x3370
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x14083
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day05/ex03/Bureaucrat.cpp
// Function: Bureaucrat::setGrade(int)
void Bureaucrat::setGrade(int grade)
{
	if (grade < 1)
		throw GradeTooHighException();
	if (grade > 150)
		throw GradeTooLowException();
	this->grade = grade;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x36e6
movl $0x8, %edi
callq 0x30a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x3c20
jmp 0x36b8
movq -0x30(%rbp), %rdi
leaq 0x64b5(%rip), %rsi      # 0x9b78
leaq 0x616(%rip), %rdx       # 0x3ce0
callq 0x3250
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x30e0
jmp 0x3748
cmpl $0x96, -0xc(%rbp)
jle 0x3738
movl $0x8, %edi
callq 0x30a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x3c60
jmp 0x370a
movq -0x38(%rbp), %rdi
leaq 0x647b(%rip), %rsi      # 0x9b90
leaq 0x5e4(%rip), %rdx       # 0x3d00
callq 0x3250
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x30e0
jmp 0x3748
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day05/ex03/Bureaucrat.cpp
// Function: Bureaucrat::signForm(Form&)
void Bureaucrat::signForm(Form &form)
{
	try
	{
		form.beSigned(*this);
	}
	catch(std::exception &e)
	{
		std::cout << this->name << " can't sign " << form.getName() << " because " << e.what() << "." << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41e0
jmp 0x38d6
jmp 0x39bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x39f2
movq -0x18(%rbp), %rdi
callq 0x3060
movq -0x50(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq 0x66c9(%rip), %rdi      # 0x9fd8
callq 0x3120
movq %rax, -0x58(%rbp)
jmp 0x391a
movq -0x58(%rbp), %rdi
leaq 0x36df(%rip), %rsi      # 0x7004
callq 0x3130
movq %rax, -0x60(%rbp)
jmp 0x3930
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x4050
jmp 0x393f
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3120
movq %rax, -0x68(%rbp)
jmp 0x3952
movq -0x68(%rbp), %rdi
leaq 0x36b4(%rip), %rsi      # 0x7011
callq 0x3130
movq %rax, -0x70(%rbp)
jmp 0x3968
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x3130
movq %rax, -0x78(%rbp)
jmp 0x3987
movq -0x78(%rbp), %rdi
leaq 0x38ad(%rip), %rsi      # 0x723f
callq 0x3130
movq %rax, -0x80(%rbp)
jmp 0x399d
movq -0x80(%rbp), %rdi
movq 0x6610(%rip), %rsi      # 0x9fb8
callq 0x3160
jmp 0x39af
leaq -0x48(%rbp), %rdi
callq 0x32e8
callq 0x3240
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x39e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x32e8
callq 0x3240
jmp 0x39f0
jmp 0x39f2
movq -0x18(%rbp), %rdi
callq 0x3270
movq %rax, %rdi
callq 0x3d20
nopw %cs:(%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day05/ex03/Bureaucrat.cpp
// Function: Bureaucrat::executeForm(Form&)
void Bureaucrat::executeForm(Form &form)
{
	try
	{
		form.execute(*this);
	}
	catch(std::exception &e)
	{
		std::cout << this->name << " can't execute " << form.getName() << " because " << e.what() << "." << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x3a3a
jmp 0x3b21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x3b56
movq -0x18(%rbp), %rdi
callq 0x3060
movq -0x50(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq 0x6565(%rip), %rdi      # 0x9fd8
callq 0x3120
movq %rax, -0x58(%rbp)
jmp 0x3a7e
movq -0x58(%rbp), %rdi
leaq 0x3592(%rip), %rsi      # 0x701b
callq 0x3130
movq %rax, -0x60(%rbp)
jmp 0x3a94
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x4050
jmp 0x3aa3
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3120
movq %rax, -0x68(%rbp)
jmp 0x3ab6
movq -0x68(%rbp), %rdi
leaq 0x3550(%rip), %rsi      # 0x7011
callq 0x3130
movq %rax, -0x70(%rbp)
jmp 0x3acc
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x3130
movq %rax, -0x78(%rbp)
jmp 0x3aeb
movq -0x78(%rbp), %rdi
leaq 0x3749(%rip), %rsi      # 0x723f
callq 0x3130
movq %rax, -0x80(%rbp)
jmp 0x3b01
movq -0x80(%rbp), %rdi
movq 0x64ac(%rip), %rsi      # 0x9fb8
callq 0x3160
jmp 0x3b13
leaq -0x48(%rbp), %rdi
callq 0x32e8
callq 0x3240
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3b4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x32e8
callq 0x3240
jmp 0x3b54
jmp 0x3b56
movq -0x18(%rbp), %rdi
callq 0x3270
movq %rax, %rdi
callq 0x3d20
nopw (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day05/ex03/Form.cpp
// Function: Form::Form(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
Form::Form(std::string name, int requiredSignatureGrade, int requiredExecutionGrade) : name(name), requiredSignatureGrade(requiredSignatureGrade), requiredExecutionGrade(requiredExecutionGrade)
{
	if (requiredExecutionGrade < 1 || requiredSignatureGrade < 1)
		throw GradeTooHighException();
	if (requiredExecutionGrade > 150 || requiredSignatureGrade > 150)
		throw GradeTooLowException();
	this->hasBeenSigned = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x5d8b(%rip), %rax      # 0x9c20
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3070
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x2c(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x30(%rax)
cmpl $0x1, -0x18(%rbp)
jl 0x3ec5
cmpl $0x1, -0x14(%rbp)
jge 0x3f21
movl $0x8, %edi
callq 0x30a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x3df0
jmp 0x3ee0
movq -0x40(%rbp), %rdi
leaq 0x5d8d(%rip), %rsi      # 0x9c78
leaq 0x5ee(%rip), %rdx       # 0x44e0
callq 0x3250
jmp 0x3f9e
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x30e0
jmp 0x3f8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3f8c
cmpl $0x96, -0x18(%rbp)
jg 0x3f33
cmpl $0x96, -0x14(%rbp)
jle 0x3f7e
movl $0x8, %edi
callq 0x30a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x3db0
jmp 0x3f4e
movq -0x48(%rbp), %rdi
leaq 0x5d07(%rip), %rsi      # 0x9c60
leaq 0x5a0(%rip), %rdx       # 0x4500
callq 0x3250
jmp 0x3f9e
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x30e0
jmp 0x3f8c
movq -0x30(%rbp), %rax
movb $0x0, 0x28(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x32e8
movq -0x20(%rbp), %rdi
callq 0x3270
nop
// File: t0mm4rx[P]piscine_cpp/day05/ex03/Form.cpp
// Function: Form::beSigned(Bureaucrat&)
void			Form::beSigned(Bureaucrat &bureaucrat)
{
	if (bureaucrat.getGrade() > this->getSigningGrade())
		throw GradeTooLowException();
	std::cout << bureaucrat.getName() << " signs " << this->getName() << "." << std::endl;
	this->hasBeenSigned = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37e0
movq -0x70(%rbp), %rdi
movl %eax, -0x64(%rbp)
callq 0x4080
movl %eax, %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jle 0x4265
movl $0x8, %edi
callq 0x30a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x3db0
jmp 0x4234
movq -0x78(%rbp), %rdi
leaq 0x5a21(%rip), %rsi      # 0x9c60
leaq 0x2ba(%rip), %rdx       # 0x4500
callq 0x3250
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x30e0
jmp 0x4353
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3820
movq -0x88(%rbp), %rsi
movq 0x5d51(%rip), %rdi      # 0x9fd8
callq 0x3120
movq %rax, -0x80(%rbp)
jmp 0x4292
movq -0x80(%rbp), %rdi
leaq 0x2e3f(%rip), %rsi      # 0x70dc
callq 0x3130
movq %rax, -0x90(%rbp)
jmp 0x42ab
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x4050
jmp 0x42ba
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3120
movq %rax, -0x98(%rbp)
jmp 0x42d3
movq -0x98(%rbp), %rdi
leaq 0x2f5e(%rip), %rsi      # 0x723f
callq 0x3130
movq %rax, -0xa0(%rbp)
jmp 0x42ef
movq -0xa0(%rbp), %rdi
movq 0x5cbb(%rip), %rsi      # 0x9fb8
callq 0x3160
jmp 0x4304
leaq -0x60(%rbp), %rdi
callq 0x32e8
leaq -0x40(%rbp), %rdi
callq 0x32e8
movq -0x70(%rbp), %rax
movb $0x1, 0x28(%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x434a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x32e8
leaq -0x40(%rbp), %rdi
callq 0x32e8
movq -0x18(%rbp), %rdi
callq 0x3270
nopl (%rax)
// File: t0mm4rx[P]piscine_cpp/day05/ex03/Form.cpp
// Function: Form::execute(Bureaucrat const&) const
void Form::execute(const Bureaucrat &executor) const
{
	if (!this->hasBeenSigned)
		throw NotSignedException();
	if (executor.getGrade() > this->requiredExecutionGrade)
		throw GradeTooLowException();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x28(%rax)
jne 0x4467
movl $0x8, %edi
callq 0x30a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x3e30
jmp 0x4439
movq -0x30(%rbp), %rdi
leaq 0x5804(%rip), %rsi      # 0x9c48
leaq 0xd5(%rip), %rdx        # 0x4520
callq 0x3250
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x30e0
jmp 0x44c8
movq -0x10(%rbp), %rdi
callq 0x37e0
movq -0x28(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jle 0x44c2
movl $0x8, %edi
callq 0x30a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x3db0
jmp 0x4494
movq -0x38(%rbp), %rdi
leaq 0x57c1(%rip), %rsi      # 0x9c60
leaq 0x5a(%rip), %rdx        # 0x4500
callq 0x3250
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x30e0
jmp 0x44c8
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day05/ex03/Intern.cpp
// Function: Intern::Intern()
Intern::Intern(void)
{
	this->constructors[0] = ShrubberyCreationForm::constructor;
	this->formNames[0] = "shrubbery";
	this->constructors[1] = RobotomyRequestForm::constructor;
	this->formNames[1] = "robotomy";
	this->constructors[2] = PresidentialPardonForm::constructor;
	this->formNames[2] = "presidential";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, %rcx
addq $0x60, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x31f0
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x20(%rbp)
jne 0x45f3
movq -0x30(%rbp), %rdi
leaq 0x1410(%rip), %rax      # 0x5a30
movq %rax, 0x60(%rdi)
leaq 0x2dc3(%rip), %rsi      # 0x73ee
callq 0x31e0
jmp 0x4632
movq -0x30(%rbp), %rdi
leaq 0xe43(%rip), %rax       # 0x5480
movq %rax, 0x68(%rdi)
addq $0x20, %rdi
leaq 0x2b11(%rip), %rsi      # 0x715d
callq 0x31e0
jmp 0x4653
movq -0x30(%rbp), %rdi
leaq 0x6c2(%rip), %rax       # 0x4d20
movq %rax, 0x70(%rdi)
addq $0x40, %rdi
leaq 0x2af9(%rip), %rsi      # 0x7166
callq 0x31e0
jmp 0x4674
addq $0x50, %rsp
popq %rbp
retq
movq %rdx, %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
addq $0x60, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x48(%rbp)
callq 0x32e8
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x40(%rbp)
jne 0x4693
jmp 0x46b7
movq -0x10(%rbp), %rdi
callq 0x3270
// File: t0mm4rx[P]piscine_cpp/day05/ex03/Intern.cpp
// Function: Intern::makeForm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Form *Intern::makeForm(std::string formName, std::string target)
{
	for (unsigned int i = 0; i < 3; i++)
	{
		if (this->formNames[i] == formName)
		{
			return ((this->constructors[i])(target));
		}
	}
	std::cout << "No form with name " << formName << "." << std::endl;
	return (nullptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jae 0x4846
movq -0x70(%rbp), %rsi
movq -0x60(%rbp), %rdi
movl -0x24(%rbp), %eax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x48b0
testb $0x1, %al
jne 0x47d5
jmp 0x4836
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rax
movl -0x24(%rbp), %ecx
movq 0x60(%rax,%rcx,8), %rax
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3070
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rax
callq *%rax
movq %rax, -0x78(%rbp)
jmp 0x480c
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x32e8
jmp 0x488b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x32e8
jmp 0x4898
jmp 0x4838
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x47ae
movq 0x578b(%rip), %rdi      # 0x9fd8
leaq 0x291f(%rip), %rsi      # 0x7173
callq 0x3130
movq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x3120
movq %rax, %rdi
leaq 0x29d0(%rip), %rsi      # 0x723f
callq 0x3130
movq %rax, %rdi
movq 0x573a(%rip), %rsi      # 0x9fb8
callq 0x3160
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day05/ex03/ShrubberyCreationForm.cpp
// Function: ShrubberyCreationForm::execute(Bureaucrat const&) const
void	ShrubberyCreationForm::execute(const Bureaucrat &bureaucrat) const
{
	std::string		filename = this->target + "_shrubbery";
	std::ofstream	file(filename);

	if (file.fail())
		throw FileErrorException();
	Form::execute(bureaucrat);
	std::cout << "Creating " << filename << "." << std::endl;
	file << this->tree;
	file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x250(%rbp)
addq $0x38, %rsi
leaq 0x1b84(%rip), %rdx      # 0x73ed
leaq -0x30(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x5ad0
movq -0x248(%rbp), %rsi
leaq -0x230(%rbp), %rdi
movl $0x10, %edx
callq 0x32c0
jmp 0x5893
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x230(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x251(%rbp)
jmp 0x58b3
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x58c2
jmp 0x5950
movl $0x8, %edi
callq 0x30a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x260(%rbp)
callq 0x57e0
jmp 0x58e0
movq -0x260(%rbp), %rdi
leaq 0x4482(%rip), %rsi      # 0x9d70
leaq 0x25b(%rip), %rdx       # 0x5b50
callq 0x3250
jmp 0x5a2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
jmp 0x5a15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
jmp 0x5a09
movq -0x260(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
callq 0x30e0
jmp 0x5a09
movq -0x250(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4400
jmp 0x5962
movq 0x466f(%rip), %rdi      # 0x9fd8
leaq 0x1a88(%rip), %rsi      # 0x73f8
callq 0x3130
movq %rax, -0x268(%rbp)
jmp 0x597e
movq -0x268(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3120
movq %rax, -0x270(%rbp)
jmp 0x5997
movq -0x270(%rbp), %rdi
leaq 0x189a(%rip), %rsi      # 0x723f
callq 0x3130
movq %rax, -0x278(%rbp)
jmp 0x59b3
movq -0x278(%rbp), %rdi
movq 0x45f7(%rip), %rsi      # 0x9fb8
callq 0x3160
jmp 0x59c8
leaq 0x47d1(%rip), %rsi      # 0xa1a0
leaq -0x230(%rbp), %rdi
callq 0x3120
jmp 0x59dd
leaq -0x230(%rbp), %rdi
callq 0x3200
jmp 0x59eb
leaq -0x230(%rbp), %rdi
callq 0x3220
leaq -0x30(%rbp), %rdi
callq 0x32e8
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x230(%rbp), %rdi
callq 0x3220
leaq -0x30(%rbp), %rdi
callq 0x32e8
movq -0x238(%rbp), %rdi
callq 0x3270
nopw (%rax,%rax)
// File: vividvilla[P]hackerrank/src/largest-sum-m.cpp
// Function: partitions(int)
int partitions(int Z) {
    vector<int> p = vector<int>(Z + 1, 0);
    p[0] = 1;

    for (int i = 1; i <= Z; i++) {
        for (int j = i; j <= Z; j++) {
            p[j] = (p[j] + p[j - i]) % MOD;
        }
    }

    return p[Z];
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movl 0x64(%rsp), %eax
incl %eax
cltq
movq %rax, 0x18(%rsp)
movl $0x0, 0x44(%rsp)
leaq 0x43(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1d60
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rcx
leaq 0x48(%rsp), %rdi
leaq 0x44(%rsp), %rdx
callq 0x1d70
jmp 0x17c7
leaq 0x43(%rsp), %rdi
callq 0x1df0
leaq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1cb0
movl $0x1, (%rax)
movl $0x1, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x64(%rsp), %eax
jg 0x189a
movl 0x30(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x64(%rsp), %eax
jg 0x1888
movslq 0x2c(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x1cb0
movl (%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
subl 0x30(%rsp), %eax
movslq %eax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x1cb0
movq %rax, %rcx
movl 0x10(%rsp), %eax
addl (%rcx), %eax
movl $0x3b9aca07, %ecx       # imm = 0x3B9ACA07
cltd
idivl %ecx
movl %edx, 0x14(%rsp)
movslq 0x2c(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x1cb0
movl 0x14(%rsp), %edx
movl %edx, (%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1803
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x43(%rsp), %rdi
callq 0x1df0
jmp 0x18c2
jmp 0x188a
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x17ed
movslq 0x64(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x1cb0
movl (%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1e00
movl 0xc(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x1140
nopl (%rax)
// File: vividvilla[P]hackerrank/src/largest-sum-m.cpp
// Function: main
int main() {
    int n, k, M, x;
    cin >> n >> k >> M;

    vector<int> d;
    for (int i = 0; i < n; i++) {
        cin >> x;
        d.push_back(x);
    }

    int Z = largestSum(k, d, M);
    cout << Z << endl;
    cout << partitions(Z) << endl;

    return 0;
}

// Assembly:
subq $0x88, %rsp
movl $0x0, 0x84(%rsp)
movq 0x66f7(%rip), %rdi      # 0x7fe0
leaq 0x80(%rsp), %rsi
callq 0x1080
movq %rax, %rdi
leaq 0x7c(%rsp), %rsi
callq 0x1080
movq %rax, %rdi
leaq 0x78(%rsp), %rsi
callq 0x1080
leaq 0x58(%rsp), %rdi
callq 0x1e60
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x80(%rsp), %eax
jge 0x1975
movq 0x66aa(%rip), %rdi      # 0x7fe0
leaq 0x74(%rsp), %rsi
callq 0x1080
jmp 0x1942
leaq 0x58(%rsp), %rdi
leaq 0x74(%rsp), %rsi
callq 0x1e70
jmp 0x1953
jmp 0x1955
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x1922
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1a57
movl 0x7c(%rsp), %eax
movl %eax, 0x24(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1ee0
jmp 0x198e
movl 0x24(%rsp), %edi
movl 0x78(%rsp), %edx
leaq 0x28(%rsp), %rsi
callq 0x1290
movl %eax, 0x20(%rsp)
jmp 0x19a6
leaq 0x28(%rsp), %rdi
callq 0x1e00
movl 0x20(%rsp), %eax
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %esi
movq 0x660d(%rip), %rdi      # 0x7fd0
callq 0x1130
movq %rax, 0x18(%rsp)
jmp 0x19cf
movq 0x18(%rsp), %rdi
movq 0x65e5(%rip), %rsi      # 0x7fc0
callq 0x10e0
jmp 0x19e2
movl 0x40(%rsp), %edi
callq 0x1780
movl %eax, 0x14(%rsp)
jmp 0x19f1
movl 0x14(%rsp), %esi
movq 0x65d4(%rip), %rdi      # 0x7fd0
callq 0x1130
movq %rax, 0x8(%rsp)
jmp 0x1a08
movq 0x8(%rsp), %rdi
movq 0x65ac(%rip), %rsi      # 0x7fc0
callq 0x10e0
jmp 0x1a1b
movl $0x0, 0x84(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1e00
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1e00
leaq 0x58(%rsp), %rdi
callq 0x1e00
movq 0x48(%rsp), %rdi
callq 0x1140
nopl (%rax,%rax)
// File: 6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/static_search_trees.cpp
// Function: co_static_search_tree::co_static_search_tree(int)
co_static_search_tree::co_static_search_tree(int n) {
    this->n = n;
    this->length = next_power_of_2(n);
    this->size = this->length * 2;
    this->height = log2(this->length) + 1;
    this->tree = (int *)malloc(sizeof(int) * this->size);
    for (int i = 0; i < this->size; ++i) {
        this->tree[i] = MINUS_INFINITY;
    }
    this->array = (int *)malloc(sizeof(int) * this->n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0xc(%rbp), %edi
callq 0x3140
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movl 0x14(%rax), %ecx
shll %ecx
movl %ecx, 0x18(%rax)
movl 0x14(%rax), %edi
callq 0x31a0
movq -0x18(%rbp), %rax
movsd 0x5c7e(%rip), %xmm1     # 0x7008
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x1c(%rax)
movslq 0x18(%rax), %rdi
shlq $0x2, %rdi
callq 0x1140
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x13dc
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13b3
movq -0x18(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
callq 0x1140
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/static_search_trees.cpp
// Function: co_static_search_tree::get(int)
int co_static_search_tree::get(int value) {
    if(value > this->tree[0]) {
        return NOT_FOUND_INDEX;
    }
    int result = this->get(0, this->height, 0, this->height, value);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jle 0x18ea
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x190b
movq -0x20(%rbp), %rdi
movl 0x1c(%rdi), %edx
movl 0x1c(%rdi), %r8d
movl -0x14(%rbp), %r9d
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x16e0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/static_search_trees.cpp
// Function: co_static_search_tree::get_tree_height_pwr_2(int, int, int, int, int)
int co_static_search_tree::get_tree_height_pwr_2(int block_index, int height, int range_left, int og_height, int value) {
    int inner_block_index = 0;
    int depth = 1;
    int path = 0;
    int length = (1 << (og_height - 2));
    while (depth != height)
    {
        this->block_index_memo[depth] = inner_block_index;
        int left_child_inner_block_index = this->left_child(inner_block_index, depth, path);
        if (value <= this->tree[block_index + left_child_inner_block_index])
        {
            path <<= 1;
            inner_block_index = left_child_inner_block_index;
        }
        else {
            inner_block_index = this->right_child(inner_block_index, depth, path);
            path = (path << 1) | 1;
            range_left += length;
        }
        length >>= 1;
        depth += 1;
    }
    return range_left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x18(%rbp), %ecx
subl $0x2, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x1e7d
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %ecx
movslq -0x24(%rbp), %rax
movl %ecx, 0x20(%rdi,%rax,4)
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x3f40
movq -0x38(%rbp), %rcx
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movq (%rcx), %rcx
movl -0xc(%rbp), %edx
addl -0x30(%rbp), %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jg 0x1e3e
movl -0x28(%rbp), %eax
shll %eax
movl %eax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x1e67
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x3fe0
movl %eax, -0x20(%rbp)
movl -0x28(%rbp), %eax
shll %eax
orl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x2c(%rbp), %eax
sarl %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1dea
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/static_search_trees.cpp
// Function: built_co_static_search_tree::built_co_static_search_tree(int)
built_co_static_search_tree::built_co_static_search_tree(int n) {
    this->n = n;
    this->length = next_power_of_2(n);
    this->size = this->length * 2;
    this->height = log2(this->length) + 1;
    this->tree = (int *)malloc(sizeof(int) * this->size * 3);
    this->temp_tree = (int *)malloc(sizeof(int) * this->size);
    this->van_emde_boas_build(0, this->height, this->height, 1);
    this->build(1, this->height);
    free(this->temp_tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0xc(%rbp), %edi
callq 0x3140
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movl 0x14(%rax), %ecx
shll %ecx
movl %ecx, 0x18(%rax)
movl 0x14(%rax), %edi
callq 0x31a0
movq -0x18(%rbp), %rax
movsd 0x512e(%rip), %xmm1     # 0x7008
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x1c(%rax)
movslq 0x18(%rax), %rax
shlq $0x2, %rax
imulq $0x3, %rax, %rdi
callq 0x1140
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq 0x18(%rax), %rdi
shlq $0x2, %rdi
callq 0x1140
movq -0x18(%rbp), %rdi
movq %rax, 0x8(%rdi)
movl 0x1c(%rdi), %edx
movl 0x1c(%rdi), %ecx
xorl %esi, %esi
movl $0x1, %r8d
callq 0x1f50
movq -0x18(%rbp), %rdi
movl 0x1c(%rdi), %edx
movl $0x1, %esi
callq 0x2050
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1120
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)