LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: establishment[P]sandman/src/cgroups.hpp
// Function: CGroups::memoryKB()
size_t memoryKB() {
        // Memory usage statistics
        size_t mem = 0, memsw = 0;
        if (readStat(cgMemory, "memory.max_usage_in_bytes", true)) {
            mem = atoll(buffer);
        } else {
            Base::Msg("Failed to read memory from cgroup");
        }

        if (readStat(cgMemory, "memory.memsw.max_usage_in_bytes", true)) {
            memsw = atoll(buffer);
            if (memsw > mem) {
                mem = memsw;
            }
        } else {
            Base::Msg("Failed to read swap memory from cgroup");
        }

        return mem >> 10;
    }

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0xe8(%rsp)
movq $0x0, 0xe0(%rsp)
leaq 0x7309d(%rip), %rsi     # 0x11eaf8
leaq 0xb8(%rsp), %rdi
callq 0xa2a40
leaq 0x97(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x8ca50
movq 0x28(%rsp), %rdx
leaq 0x4a5aa(%rip), %rsi     # 0xf6030
leaq 0x98(%rsp), %rdi
callq 0xa0a90
jmp 0xaba95
movq 0x20(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
leaq 0x98(%rsp), %rdx
movl $0x1, %ecx
callq 0xaa9c0
movl %eax, 0x1c(%rsp)
jmp 0xababa
leaq 0x98(%rsp), %rdi
callq 0x8cbd8
leaq 0x97(%rsp), %rdi
callq 0x8c630
leaq 0xb8(%rsp), %rdi
callq 0xa2a30
movl 0x1c(%rsp), %eax
cmpl $0x0, %eax
je 0xabb58
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
callq 0x8c450
movq %rax, 0xe8(%rsp)
jmp 0xabb66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xabb39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x8cbd8
leaq 0x97(%rsp), %rdi
callq 0x8c630
leaq 0xb8(%rsp), %rdi
callq 0xa2a30
jmp 0xabc90
leaq 0x4a4eb(%rip), %rdi     # 0xf604a
movb $0x0, %al
callq 0x94e30
leaq 0x72f8b(%rip), %rsi     # 0x11eaf8
leaq 0x58(%rsp), %rdi
callq 0xa2a40
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x8ca50
movq 0x10(%rsp), %rdx
leaq 0x4a4da(%rip), %rsi     # 0xf606c
leaq 0x38(%rsp), %rdi
callq 0xa0a90
jmp 0xabb9e
movq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movl $0x1, %ecx
callq 0xaa9c0
movl %eax, 0xc(%rsp)
jmp 0xabbbd
leaq 0x38(%rsp), %rdi
callq 0x8cbd8
leaq 0x37(%rsp), %rdi
callq 0x8c630
leaq 0x58(%rsp), %rdi
callq 0xa2a30
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
je 0xabc6e
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
callq 0x8c450
movq %rax, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
cmpq 0xe8(%rsp), %rax
jbe 0xabc6c
movq 0xe0(%rsp), %rax
movq %rax, 0xe8(%rsp)
jmp 0xabc6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xabc56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x8cbd8
leaq 0x37(%rsp), %rdi
callq 0x8c630
leaq 0x58(%rsp), %rdi
callq 0xa2a30
jmp 0xabc90
jmp 0xabc7c
leaq 0x4a417(%rip), %rdi     # 0xf608c
movb $0x0, %al
callq 0x94e30
movq 0xe8(%rsp), %rax
shrq $0xa, %rax
addq $0xf8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x8ca40
nopl (%rax)
// File: establishment[P]sandman/src/lib.hpp
// Function: ProcessKeeper::startStatusCheck(unsigned long long)
void startStatusCheck(unsigned long long checkIntervalMs) {
        /// setup callback for SIGALRM signal
        struct sigaction sa;
        bzero(&sa, sizeof(sa));
        sa.sa_handler = ProcessKeeper::alarmSignalHandler;
        sigaction(SIGALRM, &sa, NULL);

        /// setup initial time and interval time for signal triggering
        itimerval timer;

        timer.it_interval.tv_sec = checkIntervalMs / 1000;
        timer.it_interval.tv_usec = (checkIntervalMs % 1000) * 1000;
        timer.it_value = timer.it_interval;

        if (setitimer(ITIMER_REAL, &timer, NULL) != 0) {
            Die("ERROR: setitimer failed");
            exit(-1);
        }
    }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x98, %esi
callq 0x8ca20
leaq -0x154cd(%rip), %rax    # 0x96890
movq %rax, 0x20(%rsp)
movl $0xe, %edi
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movq 0xb8(%rsp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movq %rax, (%rsp)
movq 0xb8(%rsp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
imulq $0x3e8, %rdx, %rax      # imm = 0x3E8
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
xorl %edi, %edi
movq %rsp, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c8f0
cmpl $0x0, %eax
je 0xabddd
leaq 0x4a2dd(%rip), %rdi     # 0xf60b3
movb $0x0, %al
callq 0x94bf0
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: establishment[P]sandman/src/cgroups.hpp
// Function: CGroups::getFullTime()
RunStats::TimeStat getFullTime() {
        RunStats::TimeStat timeStat;
        timeStat.wallTimeMs = 0;
        timeStat.cpuTimeMs = cpuTimeMs();

        /// http://stackoverflow.com/questions/3875801/convert-jiffies-to-seconds/6786757#6786757
        /// returns in jiffies. jiffies/sec = 100. num_juffies / 100 * 1000 to ms
        readStat(cgCpuacct, "cpuacct.stat");
        timeStat.userTimeMs = 10 * atoll(strstr(buffer, "user ") + strlen("user "));
        timeStat.systemTimeMs = 10 * atoll(strstr(buffer, "system ") + strlen("system "));

        return timeStat;
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rax, %rdi
movq %rdi, (%rsp)
movq %rsi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, (%rax)
callq 0xaa8b0
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rdi)
leaq 0x72ce9(%rip), %rsi     # 0x11eb20
leaq 0x58(%rsp), %rdi
callq 0xa2a40
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8ca50
movq 0x18(%rsp), %rdx
leaq 0x4a26f(%rip), %rsi     # 0xf60cb
leaq 0x38(%rsp), %rdi
callq 0xa0a90
jmp 0xabe68
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
xorl %ecx, %ecx
callq 0xaa9c0
jmp 0xabe80
leaq 0x38(%rsp), %rdi
callq 0x8cbd8
leaq 0x37(%rsp), %rdi
callq 0x8c630
leaq 0x58(%rsp), %rdi
callq 0xa2a30
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
leaq 0x4a22a(%rip), %rsi     # 0xf60d8
callq 0x8c0f0
movq %rax, %rdi
addq $0x5, %rdi
callq 0x8c450
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
imulq $0xa, %rcx, %rcx
movq %rcx, 0x10(%rax)
addq $0x28, %rdi
leaq 0x4a1ff(%rip), %rsi     # 0xf60de
callq 0x8c0f0
movq %rax, %rdi
addq $0x7, %rdi
callq 0x8c450
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq (%rsp), %rax
imulq $0xa, %rdx, %rdx
movq %rdx, 0x18(%rcx)
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xabf34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x8cbd8
leaq 0x37(%rsp), %rdi
callq 0x8c630
leaq 0x58(%rsp), %rdi
callq 0xa2a30
movq 0x28(%rsp), %rdi
callq 0x8ca40
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: establishment[P]sandman/src/lib.hpp
// Function: ProcessInitialiser::setupRlimits()
void setupRlimits() {
        /// max file limit
        if (config.fileSizeLimitKB) {
            setRlimit(RLIMIT_FSIZE, (rlim_t)config.fileSizeLimitKB * 1024);
        }

        /// stack limit
        if (config.stackLimitKB) {
            setRlimit(RLIMIT_STACK, (rlim_t)config.stackLimitKB * 1024);
        } else {
            setRlimit(RLIMIT_STACK, RLIM_INFINITY);
        }

        /// max opened files at once
        setRlimit(RLIMIT_NOFILE, (rlim_t)64);

        /// prevents the process from locking memory into RAM - preventing
        /// the os to move the memory to swap space
        setRlimit(RLIMIT_MEMLOCK, (rlim_t)0);

        /// max num of processes/threads that can be created
        if (config.maxProcesses) {
            setRlimit(RLIMIT_NPROC, (rlim_t)config.maxProcesses);
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xd8(%rax)
je 0xacb16
movq 0x8(%rsp), %rdi
movslq 0xd8(%rdi), %rdx
shlq $0xa, %rdx
movl $0x1, %esi
callq 0xb19a0
movq 0x8(%rsp), %rax
cmpl $0x0, 0x54(%rax)
je 0xacb3a
movq 0x8(%rsp), %rdi
movslq 0x54(%rdi), %rdx
shlq $0xa, %rdx
movl $0x3, %esi
callq 0xb19a0
jmp 0xacb50
movq 0x8(%rsp), %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0xb19a0
movq 0x8(%rsp), %rdi
movl $0x7, %esi
movl $0x40, %edx
callq 0xb19a0
movq 0x8(%rsp), %rdi
movl $0x8, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb19a0
movq 0x8(%rsp), %rax
cmpl $0x0, 0xdc(%rax)
je 0xacb9b
movq 0x8(%rsp), %rdi
movslq 0xdc(%rdi), %rdx
movl $0x6, %esi
callq 0xb19a0
addq $0x18, %rsp
retq
// File: establishment[P]sandman/src/lib.hpp
// Function: ProcessInitialiser::setupCredentials()
void setupCredentials() {
        if (setresgid(gid, gid, gid) < 0) {
            Die("setresgid: %m");
        }

        if (setgroups(0, NULL) < 0) {
            Die("setgroups: %m");
        }

        if (setresuid(uid, uid, uid) < 0) {
            Die("setresuid: %m");
        }

        setpgrp();
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x16c(%rax), %edi
movl 0x16c(%rax), %esi
movl 0x16c(%rax), %edx
callq 0x8c190
cmpl $0x0, %eax
jge 0xacbdd
leaq 0x49881(%rip), %rdi     # 0xf6457
movb $0x0, %al
callq 0x94bf0
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x8c950
cmpl $0x0, %eax
jge 0xacbfc
leaq 0x49870(%rip), %rdi     # 0xf6465
movb $0x0, %al
callq 0x94bf0
movq 0x8(%rsp), %rax
movl 0x168(%rax), %edi
movl 0x168(%rax), %esi
movl 0x168(%rax), %edx
callq 0x8c0d0
cmpl $0x0, %eax
jge 0xacc2b
leaq 0x4984f(%rip), %rdi     # 0xf6473
movb $0x0, %al
callq 0x94bf0
callq 0x8c6d0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: establishment[P]sandman/src/rules.hpp
// Function: Rules::DirRules::DirRules(ProcessConfig::DirRules const&)
DirRules(const ProcessConfig::DirRules& config) {
            /// add default rules before any other rule can be added.
            /// in this way the default rules can be overwitten
            addDefaultRules();
            for (auto itr : config.rules) {
                if (itr.localPath != "") {
                    add(itr.boxPath, itr.localPath, itr.flags);
                } else {
                    add(itr.boxPath, itr.flags);
                }
            }
        }

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0xad770
movq 0x10(%rsp), %rdi
callq 0xad780
jmp 0xacfcd
movq 0xe8(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
callq 0xa9bd0
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rdi
callq 0xa9c00
movq %rax, 0xc0(%rsp)
leaq 0xc8(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0xaa040
testb $0x1, %al
jne 0xad025
jmp 0xad1b2
leaq 0xc8(%rsp), %rdi
callq 0xaa0b0
movq %rax, %rsi
leaq 0x78(%rsp), %rdi
callq 0xaa0f0
jmp 0xad041
leaq 0x98(%rsp), %rdi
leaq 0x4815c(%rip), %rsi     # 0xf51ac
callq 0xadd30
movb %al, 0x7(%rsp)
jmp 0xad05b
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xad068
jmp 0xad135
leaq 0x58(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x8c220
jmp 0xad079
leaq 0x98(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x8c220
jmp 0xad08d
movq 0x8(%rsp), %rdi
movl 0xb8(%rsp), %ecx
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xadd60
jmp 0xad0aa
leaq 0x38(%rsp), %rdi
callq 0x8cbd8
leaq 0x58(%rsp), %rdi
callq 0x8cbd8
jmp 0xad18a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
jmp 0xad1ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
jmp 0xad1a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
jmp 0xad129
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x8cbd8
leaq 0x58(%rsp), %rdi
callq 0x8cbd8
jmp 0xad1a6
leaq 0x18(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x8c220
jmp 0xad146
movq 0x8(%rsp), %rdi
movl 0xb8(%rsp), %edx
leaq 0x18(%rsp), %rsi
callq 0xae0f0
jmp 0xad15e
leaq 0x18(%rsp), %rdi
callq 0x8cbd8
jmp 0xad18a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x8cbd8
jmp 0xad1a6
leaq 0x78(%rsp), %rdi
callq 0xa7ec0
leaq 0xc8(%rsp), %rdi
callq 0xaa0c0
jmp 0xad007
leaq 0x78(%rsp), %rdi
callq 0xa7ec0
jmp 0xad1ba
addq $0xf8, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0xae1c0
movq 0xe0(%rsp), %rdi
callq 0x8ca40
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: establishment[P]sandman/src/rules.hpp
// Function: Rules::FilePermissions::addRule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void addRule(std::string path, std::string mode) {
            Permission p;
            p.path = path;
            p.mode = modeFromString(mode);
            allPermissions.push_back(p);
        }

// Assembly:
subq $0xb8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xafc20
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x8c060
jmp 0xaf8b6
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0xafc50
jmp 0xaf8cc
leaq 0x80(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x8c720
movq 0x8(%rsp), %rdi
callq 0x8cbd8
movq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xafed0
jmp 0xaf8fe
leaq 0x60(%rsp), %rdi
callq 0xaff40
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xaff40
movq 0x58(%rsp), %rdi
callq 0x8ca40
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: establishment[P]sandman/src/rules.hpp
// Function: Rules::FilePermissions::addRule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void addRule(std::string rule) {
            auto colonLocation = rule.find(":");
            if (colonLocation == std::string::npos) {
                addRule(rule, "");
            } else {
                addRule(rule.substr(0, colonLocation), rule.substr(colonLocation + 1, rule.size()));
            }
        }

// Assembly:
subq $0xd8, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rax, 0xd0(%rsp)
movq %rdi, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x45aa3(%rip), %rsi     # 0xf5420
xorl %eax, %eax
movl %eax, %edx
callq 0x8cba0
movq %rax, 0xc0(%rsp)
cmpq $-0x1, 0xc0(%rsp)
jne 0xafa65
movq 0x18(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x8c220
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x8ca50
movq 0x8(%rsp), %rdx
leaq 0x457e2(%rip), %rsi     # 0xf51ac
leaq 0x80(%rsp), %rdi
callq 0xa0a90
jmp 0xaf9d9
movq 0x20(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0xaf860
jmp 0xaf9f5
leaq 0x80(%rsp), %rdi
callq 0x8cbd8
leaq 0x7f(%rsp), %rdi
callq 0x8c630
leaq 0xa0(%rsp), %rdi
callq 0x8cbd8
jmp 0xafb11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xafa49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x8cbd8
leaq 0x7f(%rsp), %rdi
callq 0x8c630
leaq 0xa0(%rsp), %rdi
callq 0x8cbd8
jmp 0xafb19
movq 0x18(%rsp), %rsi
movq 0xc0(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq 0x48(%rsp), %rdi
callq 0x8c5e0
movq 0x18(%rsp), %rdi
movq 0xc0(%rsp), %rax
incq %rax
movq %rax, (%rsp)
callq 0x8c3f0
movq 0x18(%rsp), %rsi
movq (%rsp), %rdx
movq %rax, %rcx
leaq 0x28(%rsp), %rdi
callq 0x8c5e0
jmp 0xafab1
movq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xaf860
jmp 0xafac7
leaq 0x28(%rsp), %rdi
callq 0x8cbd8
leaq 0x48(%rsp), %rdi
callq 0x8cbd8
jmp 0xafb11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xafb05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x8cbd8
leaq 0x48(%rsp), %rdi
callq 0x8cbd8
jmp 0xafb19
addq $0xd8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x8ca40
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: establishment[P]sandman/src/lib.hpp
// Function: ProcessInitialiser::setRlimit(int, unsigned long)
void setRlimit(int resource, rlim_t limit) {
        struct rlimit rl;
        bzero(&rl, sizeof(rl));
        rl.rlim_cur = limit;
        rl.rlim_max = limit;

        if (setrlimit(resource, &rl) < 0) {
            Die("setrlimit(%s, %jd)", getRlimitName(resource).c_str(), (intmax_t)limit);
        }
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
movl $0x10, %esi
callq 0x8ca20
movq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0x5c(%rsp), %edi
leaq 0x40(%rsp), %rsi
callq 0x8c520
cmpl $0x0, %eax
jge 0xb1a4b
movq 0x8(%rsp), %rsi
movl 0x5c(%rsp), %edx
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xb1a60
movq (%rsp), %rdi
callq 0x8c1f0
movq %rax, %rsi
movq 0x50(%rsp), %rax
testq %rax, %rax
setne %al
movzbl %al, %edx
leaq 0x449c7(%rip), %rdi     # 0xf63f1
callq 0x94580
jmp 0xb1a31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8cbd8
jmp 0xb1a50
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x8ca40
nopw (%rax,%rax)
// File: establishment[P]sandman/src/rules.hpp
// Function: Rules::Environment::getRule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::pair<std::string, std::string> getRule(const std::string& commandLineRule) {
            // search for "="
            std::size_t equalPosition = commandLineRule.find("=");

            if (equalPosition == std::string::npos) {
                // equal not found, inherit from global environment.
                return {commandLineRule, allRules[commandLineRule]};
            } else {
                return {commandLineRule.substr(0, equalPosition),
                                 commandLineRule.substr(equalPosition + 1)};
            }
        }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x80(%rsp), %rdi
leaq 0x42a80(%rip), %rsi     # 0xf6638
xorl %eax, %eax
movl %eax, %edx
callq 0x8cba0
movq %rax, 0x78(%rsp)
cmpq $-0x1, 0x78(%rsp)
jne 0xb3c08
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
movq 0x80(%rsp), %rsi
callq 0xb3cc0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xb5170
jmp 0xb3ca6
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq 0x58(%rsp), %rdi
callq 0x8c5e0
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
incq %rdx
leaq 0x38(%rsp), %rdi
movq $-0x1, %rcx
callq 0x8c5e0
jmp 0xb3c46
movq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xb51e0
jmp 0xb3c5c
leaq 0x38(%rsp), %rdi
callq 0x8cbd8
leaq 0x58(%rsp), %rdi
callq 0x8cbd8
jmp 0xb3ca6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xb3c9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x8cbd8
leaq 0x58(%rsp), %rdi
callq 0x8cbd8
jmp 0xb3cb3
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x8ca40
nopl (%rax)
// File: establishment[P]sandman/src/rules.hpp
// Function: Rules::Environment::addRule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int addRule(const std::string& commandLineRule) {
            std::pair<std::string, std::string> rule = getRule(commandLineRule);
            if (rule.first == "") {
                return 0;
            }

            allRules[rule.first] = rule.second;
            return 1;
        }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq 0x80(%rsp), %rdx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xb3b70
movq 0x20(%rsp), %rdi
leaq 0x412e5(%rip), %rsi     # 0xf51ac
callq 0xa11e0
movb %al, 0x2f(%rsp)
jmp 0xb3ed2
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0xb3edc
jmp 0xb3f0b
movl $0x0, 0x94(%rsp)
movl $0x1, 0x30(%rsp)
jmp 0xb3f53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xb3db0
jmp 0xb3f6c
movq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
leaq 0x40(%rsp), %rsi
callq 0xb3cc0
movq %rax, 0x10(%rsp)
jmp 0xb3f2f
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x8c060
jmp 0xb3f40
movl $0x1, 0x94(%rsp)
movl $0x1, 0x30(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xb3db0
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x8ca40
nopw %cs:(%rax,%rax)
// File: establishment[P]sandman/src/lib.hpp
// Function: Jailer::BoxInit()
void BoxInit() {
        if (config.metaFile.size()) {
            meta_fd = open(config.metaFile.c_str(), O_WRONLY | O_TRUNC | O_CREAT, 0777);
        }

        umask(0027);  // new files will be created with 0750

        Base::MakeDir(boxDir.c_str());
        if (chdir(boxDir.c_str()) < 0) {
            Die("chdir(%s): %m", boxDir.c_str());
        }

        cg.init(cgid);
        cg.cgMemoryLimitKB = config.memoryLimitKB;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
callq 0x8c3f0
cmpq $0x0, %rax
je 0xc7a51
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x8c1f0
movq %rax, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1ff, %edx            # imm = 0x1FF
movb $0x0, %al
callq 0x8c430
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x19c(%rax)
movl $0x17, %edi
callq 0x8ca70
movq 0x10(%rsp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x8c1f0
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x8ca50
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0xa0a90
jmp 0xc7a94
leaq 0x30(%rsp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x95000
jmp 0xc7aa5
leaq 0x30(%rsp), %rdi
callq 0x8cbd8
leaq 0x2f(%rsp), %rdi
callq 0x8c630
movq 0x10(%rsp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x8c1f0
movq %rax, %rdi
callq 0x8c8d0
cmpl $0x0, %eax
jge 0xc7b2d
movq 0x10(%rsp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x8c1f0
movq %rax, %rsi
leaq 0x2ebb3(%rip), %rdi     # 0xf66a5
movb $0x0, %al
callq 0x94bf0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0xc7b21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x8cbd8
leaq 0x2f(%rsp), %rdi
callq 0x8c630
jmp 0xc7b57
movq 0x10(%rsp), %rax
movl 0x198(%rax), %esi
leaq 0x570c9(%rip), %rdi     # 0x11ec08
callq 0xc8190
movq 0x10(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, 0x570d6(%rip)     # 0x11ec28
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x8ca40
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: establishment[P]sandman/src/lib.hpp
// Function: Jailer::Init()
void Init() {
        Msg("Preparing sandbox directory\n");
        Base::RMTree("box");
        Base::MakeDir("box", 0750);

        cg.prepare();

        Rules::DiskQuota diskQuota(config.diskQuota, uid);
        diskQuota.applyQuota();
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2eb46(%rip), %rdi     # 0xf66d0
xorl %eax, %eax
callq 0x94e30
leaq 0x2e6d0(%rip), %rdi     # 0xf6268
movq %rdi, 0x10(%rsp)
callq 0x95380
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8ca50
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0xa0a90
jmp 0xc7bc7
leaq 0x40(%rsp), %rdi
movl $0x1e8, %esi            # imm = 0x1E8
callq 0x95000
jmp 0xc7bd8
leaq 0x40(%rsp), %rdi
callq 0x8cbd8
leaq 0x3f(%rsp), %rdi
callq 0x8c630
leaq 0x57015(%rip), %rdi     # 0x11ec08
callq 0xc8200
movq 0x8(%rsp), %rax
movq %rax, %rsi
addq $0x140, %rsi            # imm = 0x140
movl 0x190(%rax), %edx
leaq 0x20(%rsp), %rdi
callq 0xc8990
leaq 0x20(%rsp), %rdi
callq 0xc89c0
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xc7c4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8cbd8
leaq 0x3f(%rsp), %rdi
callq 0x8c630
movq 0x30(%rsp), %rdi
callq 0x8ca40
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: establishment[P]sandman/src/lib.hpp
// Function: Jailer::Cleanup()
void Cleanup() {
        if (!Base::DirExists("box")) {
            Msg("Box directory not found, there isn't anything to clean up");
        } else {
            Msg("Deleting sandbox directory\n");
            Base::RMTree(boxDir.c_str());
        }

        cg.cleanup();
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x8ca50
movq 0x10(%rsp), %rdx
leaq 0x2e18a(%rip), %rsi     # 0xf6268
leaq 0x30(%rsp), %rdi
callq 0xa0a90
jmp 0xc80ea
leaq 0x30(%rsp), %rdi
callq 0x94f30
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, 0x7(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x8cbd8
leaq 0x2f(%rsp), %rdi
callq 0x8c630
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xc811e
jmp 0xc8148
leaq 0x2e967(%rip), %rdi     # 0xf6a8c
movb $0x0, %al
callq 0x94e30
jmp 0xc816f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x8c630
jmp 0xc8180
leaq 0x2e977(%rip), %rdi     # 0xf6ac6
movb $0x0, %al
callq 0x94e30
movq 0x8(%rsp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x8c1f0
movq %rax, %rdi
callq 0x95380
leaq 0x56a92(%rip), %rdi     # 0x11ec08
callq 0xc9550
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x8ca40
nopw (%rax,%rax)
// File: establishment[P]sandman/src/lib.hpp
// Function: ProcessInitialiser::ProcessInitialiser(ProcessConfig, int, int, int*)
ProcessInitialiser(ProcessConfig config, int uid, int gid, int errorPipes[2]) {
        this->config = config;
        this->uid = uid;
        this->gid = gid;
        this->errorPipes[0] = errorPipes[0];
        this->errorPipes[1] = errorPipes[1];
    }

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
callq 0xa1ff0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa2db0
jmp 0xc8f77
movq (%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x168(%rax)
movl 0x30(%rsp), %ecx
movl %ecx, 0x16c(%rax)
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x170(%rax)
movq 0x28(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x174(%rax)
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xa2450
movq 0x20(%rsp), %rdi
callq 0x8ca40
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: establishment[P]sandman/src/lib.hpp
// Function: ProcessKeeper::mockSignals()
void mockSignals() {
        struct sigaction sa;
        bzero(&sa, sizeof(sa));
        sa.sa_handler = ProcessKeeper::dummySignalHandler;
        sigaction(SIGHUP, &sa, NULL);
        sigaction(SIGINT, &sa, NULL);
        sigaction(SIGQUIT, &sa, NULL);
        sigaction(SIGILL, &sa, NULL);
        sigaction(SIGABRT, &sa, NULL);
        sigaction(SIGFPE, &sa, NULL);
        sigaction(SIGSEGV, &sa, NULL);
        sigaction(SIGPIPE, &sa, NULL);
        sigaction(SIGTERM, &sa, NULL);
        sigaction(SIGUSR1, &sa, NULL);
        sigaction(SIGUSR2, &sa, NULL);

        /// mock alert sig as well since it can be overwriteSize
        sigaction(SIGALRM, &sa, NULL);
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
leaq 0x8(%rsp), %rdi
movl $0x98, %esi
callq 0x8ca20
leaq -0x32aa5(%rip), %rax    # 0x96960
movq %rax, 0x8(%rsp)
movl $0x1, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movl $0x2, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movl $0x3, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movl $0x4, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movl $0x6, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movl $0x8, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movl $0xb, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movl $0xd, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movl $0xf, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movl $0xa, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movl $0xc, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
movl $0xe, %edi
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c740
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: UltiRTS[P]gameLauncher/launcher.cpp
// Function: getPath[abi:cxx11](int, char**)
string getPath(int argc, char *passedargv[]) {
	// Get the last position of '/'
	string aux(passedargv[0]);
	// get '/' or '\\' depending on unix/mac or windows.
#if defined(_WIN32) || defined(WIN32)
	int pos = aux.rfind('\\');
#else
	int pos = aux.rfind('/');
#endif
	// Get the path and the name
	string path = aux.substr(0,pos+1);
	string name = aux.substr(pos+1);
	// show results
	return (path);
	//cout << "Name: " << name << std::endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3440
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x4f00
jmp 0x3928
leaq -0x39(%rbp), %rdi
callq 0x3300
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x3490
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movl %eax, -0x50(%rbp)
movb $0x0, -0x51(%rbp)
movl -0x50(%rbp), %eax
incl %eax
movslq %eax, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x32d0
jmp 0x3975
movl -0x50(%rbp), %eax
incl %eax
movslq %eax, %rdx
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq $-0x1, %rcx
callq 0x32d0
jmp 0x3993
movb $0x1, -0x51(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3180
testb $0x1, -0x51(%rbp)
jne 0x39f3
jmp 0x39e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x3300
jmp 0x3a15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3a0c
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3180
jmp 0x3a0c
movq -0x98(%rbp), %rdi
callq 0x3180
leaq -0x38(%rbp), %rdi
callq 0x3180
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x3180
movq -0x48(%rbp), %rdi
callq 0x3430
nop
// File: UltiRTS[P]gameLauncher/launcher.cpp
// Function: exec[abi:cxx11](char const*)
string exec(const char* cmd) {
	array<char, 128> buffer;
	string result;
	unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd, "r"), pclose);
	if (!pipe) {
		throw std::runtime_error("popen() failed!");
	}
	while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
		result += buffer.data();
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x91(%rbp)
callq 0x3380
movq -0x10(%rbp), %rdi
leaq 0x472c(%rip), %rsi      # 0x8217
callq 0x30c0
movq %rax, -0xc8(%rbp)
jmp 0x3af9
movq -0xc8(%rbp), %rsi
movq 0x84c9(%rip), %rax      # 0xbfd0
movq %rax, -0xc0(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xc0(%rbp), %rdx
callq 0x4fb0
leaq -0xa8(%rbp), %rdi
callq 0x4ff0
testb $0x1, %al
jne 0x3bca
movl $0x10, %edi
callq 0x3140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
leaq 0x44c5(%rip), %rsi      # 0x8018
callq 0x30e0
jmp 0x3b5a
movq -0xe0(%rbp), %rdi
movq 0x8488(%rip), %rsi      # 0xbff0
movq 0x8451(%rip), %rdx      # 0xbfc0
callq 0x3420
jmp 0x3cb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x3c99
movq -0xe0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
callq 0x31d0
jmp 0x3c6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x3c6f
jmp 0x3bcc
leaq -0x90(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x5020
movq -0x100(%rbp), %rdi
movq %rax, -0xf8(%rbp)
callq 0x5040
movl %eax, -0xec(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5050
movq -0xf8(%rbp), %rdi
movl -0xec(%rbp), %esi
movq %rax, %rdx
callq 0x33d0
movq %rax, -0xe8(%rbp)
jmp 0x3c22
movq -0xe8(%rbp), %rax
cmpq $0x0, %rax
je 0x3c51
leaq -0x90(%rbp), %rdi
callq 0x5020
movq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0x3290
jmp 0x3c4c
jmp 0x3bcc
movb $0x1, -0x91(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5080
testb $0x1, -0x91(%rbp)
jne 0x3c89
jmp 0x3c7d
leaq -0xa8(%rbp), %rdi
callq 0x5080
jmp 0x3c99
movq -0xd8(%rbp), %rdi
callq 0x3180
movq -0xd0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x3180
movq -0xb0(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: std::_List_const_iterator<std::pair<unsigned int, unsigned int>> tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int, unsigned int>, tsl::hopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::hopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::__cxx11::list<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>>::find_in_overflow<unsigned int, std::__cxx11::list<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>, (void*)0>(unsigned int const&) const
const_iterator_overflow find_in_overflow(const K& key) const {
        return std::find_if(m_overflow_elements.cbegin(), m_overflow_elements.cend(), 
                            [&](const value_type& value) { 
                                return compare_keys(key, KeySelect()(value)); 
                            });
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x20, %rdi
callq 0x3c60
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x20, %rdi
callq 0x3c90
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x3be0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/tsl_hopscotch_map/./hopscotch_hash.h
// Function: std::_List_iterator<std::pair<unsigned int, unsigned int>> tsl::detail_hopscotch_hash::hopscotch_hash<std::pair<unsigned int, unsigned int>, tsl::hopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::KeySelect, tsl::hopscotch_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>>::ValueSelect, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, 62u, false, tsl::hh::power_of_two_growth_policy<2ul>, std::__cxx11::list<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>>::insert_in_overflow<std::piecewise_construct_t const&, std::tuple<unsigned int&&>, std::tuple<>, std::__cxx11::list<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>, (void*)0>(unsigned long, std::piecewise_construct_t const&, std::tuple<unsigned int&&>&&, std::tuple<>&&)
iterator_overflow insert_in_overflow(std::size_t ibucket_for_hash, Args&&... value_type_args) {
        auto it = m_overflow_elements.emplace(m_overflow_elements.end(), std::forward<Args>(value_type_args)...);
        
        m_buckets[ibucket_for_hash].set_overflow(true);
        m_nb_elements++;
            
        return it;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
callq 0x4e90
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x5960
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %rsi
callq 0x6310
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq 0x38(%rax), %rdi
movq 0x40(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x4f00
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
// File: adhipradhana[P]sliding-window-protocol/src/packet.cpp
// Function: create_packet(char*, unsigned int, unsigned long, char*, bool)
size_t create_packet(char* packet, unsigned int seq_num, size_t data_length, char* data, bool eot) {
	// convert data into network type (big endian/little endian)
	unsigned int network_seq_num = htonl(seq_num);
	unsigned int network_data_length = htonl(data_length);

	// copy data into frame
	if (eot) {
		packet[0] = 0x0;
	} else {
		packet[0] = 0x1;
	}

	memcpy(packet+1, &network_seq_num, 4);
	memcpy(packet+5, &network_data_length, 4);
	memcpy(packet+9, data, data_length);

	packet[9 + data_length] = count_checksum(data_length, data);

	return data_length + (size_t)10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movl -0xc(%rbp), %edi
callq 0x1090
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0x1090
movl %eax, -0x2c(%rbp)
testb $0x1, -0x21(%rbp)
je 0x1387
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x138e
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, 0x1(%rax)
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0x5(%rax)
movq -0x8(%rbp), %rdi
addq $0x9, %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10b0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13f0
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x9, %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0xa, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adhipradhana[P]sliding-window-protocol/src/packet.cpp
// Function: count_checksum(unsigned long, char*)
char count_checksum(size_t data_length, char* data) {
	unsigned long sum = 0;
	for (size_t i = 0; i < data_length; i++) {
		sum += *data++;
		if (sum & 0xFF00) {
			sum &= 0xFF;
			sum++;
		}
	}
	return (char)(~(sum & 0xFF));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x146b
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbq (%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0xff00, %rax           # imm = 0xFF00
cmpq $0x0, %rax
je 0x145b
movq -0x18(%rbp), %rax
andq $0xff, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x145d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x140c
movq -0x18(%rbp), %rax
andq $0xff, %rax
xorq $-0x1, %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: adhipradhana[P]sliding-window-protocol/src/packet.cpp
// Function: read_packet(char*, unsigned int*, unsigned long*, char*, bool*, bool*)
void read_packet(char* packet, unsigned int* seq_num, size_t* data_length, char* data, bool* is_check_sum_valid, bool* eot) {
	// convert data
	unsigned int network_seq_num;
	unsigned int network_data_length;

	// byte copy
	memcpy(&network_seq_num, packet+1, 4);
	memcpy(&network_data_length, packet+5, 4);

	*seq_num = ntohl(network_seq_num);
	*data_length = ntohl(network_data_length);

	memcpy(data, packet+9, *data_length);

	char sender_check_sum = packet[9 + *data_length];
	char checksum = count_checksum(*data_length, data);

	*is_check_sum_valid = sender_check_sum == checksum;

	*eot = packet[0] == 0x0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x1(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl 0x5(%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %edi
callq 0x1120
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x38(%rbp), %edi
callq 0x1120
movl %eax, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x9, %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x10b0
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
addq $0x9, %rcx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x13f0
movb %al, -0x3a(%rbp)
movsbl -0x39(%rbp), %eax
movsbl -0x3a(%rbp), %ecx
cmpl %ecx, %eax
sete %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: adhipradhana[P]sliding-window-protocol/src/ack.cpp
// Function: create_ack(char*, unsigned int, bool)
void create_ack(char *ack, unsigned int seq_num, bool is_check_sum_valid){
	
	if(is_check_sum_valid)
		ack[0] = 0x0;
	else
		ack[0] = 0x1;

	uint32_t net_seq_num = htonl(seq_num);
	memcpy(ack + 1, &net_seq_num, 4);
	ack[5] = count_checksum((size_t)4, (char *) &seq_num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
je 0x1575
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x157c
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
movl -0xc(%rbp), %edi
callq 0x1090
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x1(%rax)
movl $0x4, %edi
leaq -0xc(%rbp), %rsi
callq 0x13f0
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: adhipradhana[P]sliding-window-protocol/src/ack.cpp
// Function: read_ack(char*, bool*, unsigned int*, bool*)
void read_ack(char *ack, bool* is_nak, unsigned int *seq_num, bool *is_check_sum_valid){
	
	if(ack[0] == 0x0)
		*is_nak = false;
	else
		*is_nak = true;

	uint32_t net_seq_num;
	memcpy(&net_seq_num, ack + 1, 4);
	*seq_num = ntohl(net_seq_num);

	*is_check_sum_valid = ack[5] == count_checksum((size_t)4, (char *) seq_num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x15dd
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x15e4
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rax
movl 0x1(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x1120
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movsbl 0x5(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movl $0x4, %edi
callq 0x13f0
movb %al, %cl
movl -0x28(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
sete %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: porzell[P]PTest/examples/unit_test.cpp
// Function: CanReserveVector22()
P_TEST(CanReserveVector) {
    std::vector<int> vec;
    vec.reserve(10);
    
    P_ASSERT(vec.capacity() >= 10);
    P_ASSERT(vec.size() == 0);
    
    for(int i = 0; i < 11; ++i) {
        vec.push_back(3);
    }
    
    P_ASSERT(vec.capacity() > 10);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
leaq -0x18(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x62d0
movq -0x198(%rbp), %rdi
movl $0xa, %esi
callq 0x7950
jmp 0x295e
leaq -0x18(%rbp), %rdi
callq 0x7a50
subq $0xa, %rax
setae -0x25(%rbp)
callq 0x2e00
movq %rax, -0x1a0(%rbp)
jmp 0x297d
movzbl -0x25(%rbp), %esi
andl $0x1, %esi
leaq 0x673e(%rip), %rdx      # 0x90c9
leaq 0x684e(%rip), %r8       # 0x91e0
xorl %eax, %eax
movl %eax, %r9d
leaq -0x98(%rbp), %rdi
movl $0x1a, %ecx
callq 0x6480
jmp 0x29aa
movq -0x1a0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
xorl %edx, %edx
callq 0x6340
jmp 0x29c1
leaq -0x98(%rbp), %rdi
callq 0x5790
testb $0x1, -0x25(%rbp)
jne 0x2a10
movl $0x1, -0x9c(%rbp)
jmp 0x2ba9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2bbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x5790
jmp 0x2bbb
leaq -0x18(%rbp), %rdi
callq 0x6320
testq %rax, %rax
sete -0x9d(%rbp)
callq 0x2e00
movq %rax, -0x1a8(%rbp)
jmp 0x2a31
movzbl -0x9d(%rbp), %esi
andl $0x1, %esi
leaq 0x6687(%rip), %rdx      # 0x90c9
leaq 0x67ac(%rip), %r8       # 0x91f5
xorl %eax, %eax
movl %eax, %r9d
leaq -0x110(%rbp), %rdi
movl $0x1b, %ecx
callq 0x6480
jmp 0x2a61
movq -0x1a8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
xorl %edx, %edx
callq 0x6340
jmp 0x2a78
leaq -0x110(%rbp), %rdi
callq 0x5790
testb $0x1, -0x9d(%rbp)
jne 0x2ab9
movl $0x1, -0x9c(%rbp)
jmp 0x2ba9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x5790
jmp 0x2bbb
movl $0x0, -0x114(%rbp)
cmpl $0xb, -0x114(%rbp)
jge 0x2afb
movl $0x3, -0x118(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x62f0
jmp 0x2ae8
jmp 0x2aea
movl -0x114(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x114(%rbp)
jmp 0x2ac3
leaq -0x18(%rbp), %rdi
callq 0x7a50
subq $0xb, %rax
setae -0x119(%rbp)
callq 0x2e00
movq %rax, -0x1b0(%rbp)
jmp 0x2b1d
movzbl -0x119(%rbp), %esi
andl $0x1, %esi
leaq 0x659b(%rip), %rdx      # 0x90c9
leaq 0x66d0(%rip), %r8       # 0x9205
xorl %eax, %eax
movl %eax, %r9d
leaq -0x190(%rbp), %rdi
movl $0x21, %ecx
callq 0x6480
jmp 0x2b4d
movq -0x1b0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
xorl %edx, %edx
callq 0x6340
jmp 0x2b64
leaq -0x190(%rbp), %rdi
callq 0x5790
testb $0x1, -0x119(%rbp)
jne 0x2b9f
movl $0x1, -0x9c(%rbp)
jmp 0x2ba9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x5790
jmp 0x2bbb
movl $0x0, -0x9c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x65f0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x65f0
movq -0x20(%rbp), %rdi
callq 0x2240
nopl (%rax)
// File: porzell[P]PTest/examples/unit_test.cpp
// Function: CanInsertVector36()
P_TEST(CanInsertVector) {
    std::vector<int> vec;
    
    for(int i = 0; i < 10; ++i) {
        vec.push_back(i);
    }
    
    for(int i = 0; i < 10; ++i) {
        P_ASSERT(vec[i] == i);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x18(%rbp), %rdi
callq 0x62d0
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x2c1e
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x7a70
jmp 0x2c00
jmp 0x2c02
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2beb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2cfd
movl $0x0, -0x30(%rbp)
cmpl $0xa, -0x30(%rbp)
jge 0x2ce1
movslq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x7ae0
movl (%rax), %eax
movl -0x30(%rbp), %ecx
subl %ecx, %eax
sete -0x31(%rbp)
callq 0x2e00
movq %rax, -0xb8(%rbp)
jmp 0x2c55
movzbl -0x31(%rbp), %esi
andl $0x1, %esi
leaq 0x6466(%rip), %rdx      # 0x90c9
leaq 0x65bf(%rip), %r8       # 0x9229
xorl %eax, %eax
movl %eax, %r9d
leaq -0xa8(%rbp), %rdi
movl $0x2c, %ecx
callq 0x6480
jmp 0x2c82
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
xorl %edx, %edx
callq 0x6340
jmp 0x2c99
leaq -0xa8(%rbp), %rdi
callq 0x5790
testb $0x1, -0x31(%rbp)
jne 0x2cd1
movl $0x1, -0xac(%rbp)
jmp 0x2ceb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5790
jmp 0x2cfd
jmp 0x2cd3
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2c25
movl $0x0, -0xac(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x65f0
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x65f0
movq -0x28(%rbp), %rdi
callq 0x2240
nop