LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: davmac314[P]dinit/src/dinitcheck.cc
// Function: process_dep_dir(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::list<prelim_dep, std::allocator<prelim_dep>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, dependency_type)
static void process_dep_dir(const char *servicename,
        const string &service_filename,
        std::list<prelim_dep> &deplist, const std::string &depdirpath,
        dependency_type dep_type)
{
    std::string depdir_fname = combine_paths(parent_path(service_filename), depdirpath.c_str());

    DIR *depdir = opendir(depdir_fname.c_str());
    if (depdir == nullptr) {
        report_dir_error(servicename, depdirpath);
        return;
    }

    errno = 0;
    dirent *dent = readdir(depdir);
    while (dent != nullptr) {
        char *name = dent->d_name;
        if (name[0] != '.') {
            deplist.emplace_back(name, dep_type);
        }
        dent = readdir(depdir);
    }

    if (errno != 0) {
        report_dir_error(servicename, depdirpath);
    }

    closedir(depdir);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x14fe0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x16cf0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x51b0
movq %rax, %rcx
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x16400
movq -0xa0(%rbp), %rdi
callq 0x51b0
movq %rax, %rdi
callq 0x5780
movq %rax, -0x98(%rbp)
jmp 0x12c42
movq -0x98(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
jne 0x12c89
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12d70
jmp 0x12c63
movl $0x1, -0x80(%rbp)
jmp 0x12d46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5320
jmp 0x12d58
callq 0x5070
movl $0x0, (%rax)
movq -0x70(%rbp), %rdi
callq 0x5790
movq %rax, -0xa8(%rbp)
jmp 0x12ca6
movq -0xa8(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x88(%rbp)
je 0x12d19
movq -0x88(%rbp), %rax
addq $0x13, %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x12cf7
movq -0x18(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x33380
jmp 0x12cf5
jmp 0x12cf7
movq -0x70(%rbp), %rdi
callq 0x5790
movq %rax, -0xb0(%rbp)
jmp 0x12d09
movq -0xb0(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x12cb4
callq 0x5070
cmpl $0x0, (%rax)
je 0x12d34
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12d70
jmp 0x12d32
jmp 0x12d34
movq -0x70(%rbp), %rdi
callq 0x57e0
jmp 0x12d3f
movl $0x0, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5320
addq $0xb0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x5870
nopw %cs:(%rax,%rax)
// File: davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::clear_no_inherit()
void clear_no_inherit()
    {
        keep_parent_env = false;
        import_from_parent.clear();
        undefine.clear();
        set_vars.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x0, (%rdi)
addq $0x8, %rdi
callq 0x19660
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x19660
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x19740
addq $0x10, %rsp
popq %rbp
retq
// File: davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::set_var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, bool)
void set_var(std::string &&var_and_val, bool notify = false)
    {
        string_view var_name = find_var_name(var_and_val);

        import_from_parent.erase(var_name);
        auto n_removed = undefine.erase(var_name);

        bool in_sysenv = false;
        if (notify && n_removed == 0) {
            // workaround to avoid an allocation; when notify is true,
            // we know for sure that the value is sanitized from before
            //
            // we don't check this when the variable was in undefine,
            // as that means we were undefining it explicitly
            auto name_size = var_name.size();
            var_and_val[name_size] = '\0';
            in_sysenv = !!bp_sys::getenv(var_and_val.c_str());
            var_and_val[name_size] = '=';
        }

        auto insert_result = set_vars.insert(std::move(var_and_val));
        // if the variable was in sys environment, it is always overridden
        bool overridden = in_sysenv;
        if (!insert_result.second) {
            *insert_result.first = var_and_val;
            overridden = true;
        }

        if (notify) {
            notify_listeners(*insert_result.first, overridden);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x14fe0
movq -0x80(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x21f00
movq -0x80(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x21f90
movq -0x80(%rbp), %rdi
addq $0x38, %rdi
leaq -0x28(%rbp), %rsi
callq 0x21f90
movq %rax, -0x40(%rbp)
movb $0x0, -0x41(%rbp)
testb $0x1, -0x11(%rbp)
je 0x1637d
cmpq $0x0, -0x40(%rbp)
jne 0x1637d
leaq -0x28(%rbp), %rdi
callq 0x22030
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x5930
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x51b0
movq %rax, %rdi
callq 0x55f0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x41(%rbp)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x5930
movb $0x3d, (%rax)
movq -0x80(%rbp), %rsi
addq $0x68, %rsi
movq -0x10(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x22050
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x71(%rbp)
testb $0x1, -0x58(%rbp)
jne 0x163c7
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x22080
movq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0x5060
movb $0x1, -0x71(%rbp)
testb $0x1, -0x11(%rbp)
je 0x163ea
leaq -0x70(%rbp), %rdi
callq 0x22080
movq -0x80(%rbp), %rdi
movq %rax, %rsi
movb -0x71(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x220a0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: davmac314[P]dinit/src/includes/dinit-util.h
// Function: dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::clear()
void clear() noexcept
    {
        for (auto &bucket : buckets) {
            bucket.clear();
        }
        current_size = 0;
        current_limit = 0;
        buckets.clear();
        try {
            buckets.shrink_to_fit();
        }
        catch (std::bad_alloc &) {
            // ignore any (unlikely) error
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19820
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19850
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x19880
testb $0x1, %al
jne 0x196a9
jmp 0x196ca
leaq -0x18(%rbp), %rdi
callq 0x198c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x198e0
leaq -0x18(%rbp), %rdi
callq 0x19910
jmp 0x19696
movq -0x48(%rbp), %rdi
movq $0x0, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x8, %rdi
movq %rdi, -0x50(%rbp)
callq 0x19930
movq -0x50(%rbp), %rdi
callq 0x19950
jmp 0x196f6
jmp 0x19726
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x19734
movq -0x30(%rbp), %rdi
callq 0x51a0
movq %rax, -0x40(%rbp)
callq 0x5810
jmp 0x19724
jmp 0x19726
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x138d0
movq -0x30(%rbp), %rdi
callq 0x138d0
nopl (%rax)
// File: davmac314[P]dinit/src/includes/dinit-util.h
// Function: dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::iterator::operator++()
iterator &operator++() noexcept
        {
            if (++list_it == (*buckets)[bucket_num].end()) {
                for (size_type i = bucket_num + 1; i < buckets->size(); ++i) {
                    if (!(*buckets)[i].empty()) {
                        list_it = (*buckets)[i].begin();
                        bucket_num = i;
                        return *this;
                    }
                }
                list_it = {};
                bucket_num = -1;
            }
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
callq 0x148e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq (%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x1dc50
movq %rax, %rdi
callq 0x14860
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x1f490
testb $0x1, %al
jne 0x1d476
jmp 0x1d52b
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq (%rax), %rdi
callq 0x19af0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x1d50e
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x1dc50
movq %rax, %rdi
callq 0x1f400
testb $0x1, %al
jne 0x1d4fb
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x1dc50
movq %rax, %rdi
callq 0x14830
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, -0x8(%rbp)
jmp 0x1d533
jmp 0x1d4fd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1d486
leaq -0x30(%rbp), %rdi
callq 0x1de00
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq $-0x1, 0x10(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: davmac314[P]dinit/src/includes/dinit-util.h
// Function: dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::iterator dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::find<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
iterator find(const V &value) noexcept
    {
        if (buckets.empty()) return end();
        size_t hashval = hash_f(value);
        size_t bucket_num = hashval % buckets.size();
        for (auto list_it = buckets[bucket_num].begin(); list_it != buckets[bucket_num].end(); ++list_it) {
            if (key_equal_f(*list_it, value)) {
                return { &buckets, list_it, bucket_num };
            }
        }
        return end();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
callq 0x1dbc0
testb $0x1, %al
jne 0x248c2
jmp 0x248d4
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x1dc00
jmp 0x249e2
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x14fe0
jmp 0x248e3
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1dc30
movq %rax, -0x68(%rbp)
jmp 0x248f6
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x8, %rdi
callq 0x19af0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq -0x70(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x30(%rbp)
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
callq 0x1dc50
movq %rax, %rdi
callq 0x14830
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
callq 0x1dc50
movq %rax, %rdi
callq 0x14860
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14890
testb $0x1, %al
jne 0x24970
jmp 0x249d5
movq -0x50(%rbp), %rax
incq %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x148c0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x24a00
movb %al, -0x71(%rbp)
jmp 0x24999
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x249a2
jmp 0x249c5
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x8, %rsi
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %rdx
callq 0x1dcb0
jmp 0x249e2
jmp 0x249c7
leaq -0x38(%rbp), %rdi
callq 0x148e0
jmp 0x24940
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x1dc00
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x138d0
nopw (%rax,%rax)
// File: davmac314[P]dinit/src/includes/dinit-util.h
// Function: hash(string_view const&)
inline size_t hash(const string_view &str)
{
    size_t end_pos = str.length();
    size_t hash_val = 0;
    for (size_t i = 0; i < end_pos; i += sizeof(size_t)) {
        // collect as many characters as will fit into size_t
        size_t hash_unit = 0;
        std::memcpy(&hash_unit, str.data() + i, std::min(sizeof(size_t), end_pos - i));
        // then incorporate the collected characters into the hash value
        hash_val *= 31;
        hash_val += hash_unit;
    }
    return hash_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b660
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1dec0
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ded0
addq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x8, -0x30(%rbp)
movq -0x10(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x18640
movq -0x40(%rbp), %rsi
movq (%rax), %rdx
leaq -0x28(%rbp), %rdi
callq 0x53f0
imulq $0x1f, -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x1de49
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: davmac314[P]dinit/src/includes/dinit-util.h
// Function: dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::begin()
iterator begin() noexcept
    {
        if (current_size == 0) return end();
        for (size_t i = 0; i < buckets.size(); ++i) {
            if (!buckets[i].empty()) {
                return { &buckets, buckets[i].begin(), i };
            }
        }
        return end(); // (should not be reachable)
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x20(%rax)
jne 0x1f345
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x1dc00
jmp 0x1f3ea
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0x19af0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f3dd
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x1dc50
movq %rax, %rdi
callq 0x1f400
testb $0x1, %al
jne 0x1f3ca
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x1dc50
movq %rax, %rdi
callq 0x14830
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
callq 0x1dcb0
jmp 0x1f3ea
jmp 0x1f3cc
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1f34d
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x1dc00
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::find_var_name(string_view)
string_view find_var_name(string_view var)
    {
        const char *var_ch;
        for (var_ch = var.data(); *var_ch != '='; ++var_ch) {
            if (*var_ch == '\0') break;
        }
        return {var.data(), (size_t)(var_ch - var.data())};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1ded0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x21f4b
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x21f3b
jmp 0x21f4b
jmp 0x21f3d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x21f21
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1ded0
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x1ded0
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
subq %rax, %rdx
leaq -0x10(%rbp), %rdi
callq 0x15030
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nop
// File: davmac314[P]dinit/src/includes/dinit-util.h
// Function: unsigned long dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::erase<string_view>(string_view const&)
size_type erase(const V &value) noexcept
    {
        auto it = find(value);
        if (it != end()) {
            buckets[it.bucket_num].erase(it.list_it);
            return 1;
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1da30
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1dc00
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1d390
testb $0x1, %al
jne 0x21fd5
jmp 0x22016
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x1dc50
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rsi
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
callq 0x22190
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x22140
movq %rax, -0x58(%rbp)
movq $0x1, -0x8(%rbp)
jmp 0x2201e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: davmac314[P]dinit/src/includes/dinit-util.h
// Function: dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_env_name, env_equal_name>::rehash(unsigned long)
void rehash(size_type new_bucket_count)
    {
        // calculate minimum bucket count, limited by maximum possible count.
        size_t max_buckets = buckets.max_size();
        size_t max_count = buckets_to_max(max_buckets);
        size_t min_buckets;
        if (current_size > max_count) {
            min_buckets = max_buckets;
        }
        else {
            size_t base = current_size / 3 * 4;
            size_t extra = (current_size % 3) * 4 / 3;
            min_buckets = base + extra;
        }

        new_bucket_count = std::max(new_bucket_count, min_buckets);

        if (new_bucket_count < buckets.size()) {
            // buckets vector will shrink: we need to reallocate entries into their new buckets first
            do_rehash(new_bucket_count);
            buckets.resize(new_bucket_count);
        }
        else {
            // grow the vector, then rehash
            buckets.resize(new_bucket_count);
            do_rehash(new_bucket_count);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
callq 0x22790
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x23220
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x20(%rax), %rax
cmpq -0x20(%rbp), %rax
jbe 0x22811
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x22861
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x40(%rbp), %rax
shlq $0x2, %rcx
movq %rcx, -0x30(%rbp)
movq 0x20(%rax), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
shlq $0x2, %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x18580
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
callq 0x19af0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x228b6
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23260
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x22650
jmp 0x228d4
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x22650
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23260
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: davmac314[P]dinit/src/includes/dinit-util.h
// Function: dinit_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hash_sv, dinit_equal_to>::do_rehash(unsigned long)
void do_rehash(size_t new_buckets) noexcept
    {
        // note, buckets vector is already at least new_buckets in size
        size_t old_buckets = buckets.size();

        // first splice all nodes from all buckets into a single list
        std::list<K> all_nodes;
        for (size_t i = 0; i < old_buckets; ++i) {
            all_nodes.splice(all_nodes.end(), buckets[i]);
        }

        // now put all nodes into the correct bucket
        auto node_i = all_nodes.begin();
        while (node_i != all_nodes.end()) {
            auto next_node_i = std::next(node_i);
            size_t hashval = hash_f(*node_i);
            size_t bucket_num = hashval % new_buckets;
            buckets[bucket_num].splice(buckets[bucket_num].end(), all_nodes, node_i);
            node_i = next_node_i;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
addq $0x8, %rdi
callq 0x19af0
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1ffe0
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x29ac2
leaq -0x30(%rbp), %rdi
callq 0x14860
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x22190
movq -0xa8(%rbp), %rdi
addq $0x8, %rdi
movq -0x38(%rbp), %rsi
callq 0x1dc50
movq %rax, %rdx
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x23420
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x29a6c
leaq -0x30(%rbp), %rdi
callq 0x14830
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x14860
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x14890
testb $0x1, %al
jne 0x29af2
jmp 0x29bfc
movq -0x50(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movl $0x1, %esi
callq 0x23460
movq %rax, -0xb0(%rbp)
jmp 0x29b11
movq -0xb0(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x148c0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x14fe0
jmp 0x29b33
movq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1dc30
movq %rax, -0xb8(%rbp)
jmp 0x29b4c
movq -0xa8(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x88(%rbp)
addq $0x8, %rdi
movq -0x88(%rbp), %rsi
callq 0x1dc50
movq -0xa8(%rbp), %rdi
movq %rax, -0xc0(%rbp)
addq $0x8, %rdi
movq -0x88(%rbp), %rsi
callq 0x1dc50
movq %rax, %rdi
callq 0x14860
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x22190
leaq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x22190
movq -0xc0(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rcx
leaq -0x30(%rbp), %rdx
callq 0x23490
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x29acf
leaq -0x30(%rbp), %rdi
callq 0x17c30
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x138d0
nopw %cs:(%rax,%rax)
// File: davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
string_view get(const std::string &name) const
    {
        auto it = set_vars.find(string_view(name));
        if (it != set_vars.end()) {
            return *it;
        }

        if (!keep_parent_env && !import_from_parent.contains(name)) {
            return {};
        }

        const char *val = bp_sys::getenv(name.c_str());
        if (val == nullptr) {
            return {};
        }
        const char *name_and_val = val - (name.length() + 1);
        size_t val_len = strlen(val);
        return {name_and_val, name.length() + 1 + val_len};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
addq $0x68, %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x14fe0
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x24560
movq -0x80(%rbp), %rsi
addq $0x68, %rsi
leaq -0x60(%rbp), %rdi
callq 0x1d580
leaq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1d5c0
testb $0x1, %al
jne 0x23f7b
jmp 0x23f95
leaq -0x38(%rbp), %rdi
callq 0x1d5f0
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
callq 0x14fe0
jmp 0x24072
movq -0x80(%rbp), %rax
testb $0x1, (%rax)
jne 0x23fd1
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x245b0
testb $0x1, %al
jne 0x23fd1
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5290
leaq -0x10(%rbp), %rdi
callq 0x24600
jmp 0x24072
movq -0x20(%rbp), %rdi
callq 0x51b0
movq %rax, %rdi
callq 0x55f0
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x24008
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x5290
leaq -0x10(%rbp), %rdi
callq 0x24600
jmp 0x24072
movq -0x68(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5770
movq %rax, %rdx
movq -0x98(%rbp), %rax
addq $0x1, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x51e0
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5770
movq -0x90(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
addq -0x78(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x15030
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: davmac314[P]dinit/src/includes/dinit-util.h
// Function: string_view::operator==(char const*) const
bool operator==(const char *other) const noexcept
    {
        // Note: we can't use strncmp, it might deduce equal strings if other is shorter and our
        // string contains a nul character.
        const char *sp = s;
        const char *op = other;
        while (*op != '\0') {
            if (*op != *sp) {
                return false;
            }
            ++op; ++sp;
        }

        return ((size_t)(op - other) == count);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x28081
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x28067
movb $0x0, -0x1(%rbp)
jmp 0x2809c
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x28043
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdx
subq %rdx, %rax
cmpq 0x8(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::undefine_var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, bool)
void undefine_var(std::string &&var_name, bool notify = false)
    {
        import_from_parent.erase(var_name);

        auto n_removed = set_vars.erase(string_view(var_name));
        bool was_set = n_removed > 0;
        if (notify && !was_set) {
            // also track if we're undefining it from system environment
            was_set = !!bp_sys::getenv(var_name.c_str());
        }
        if (keep_parent_env) {
            auto insert_result = undefine.insert(std::move(var_name));
            if (notify) {
                notify_listeners(*insert_result.first, was_set);
            }
        }
        else if (notify) {
            notify_listeners(var_name, was_set);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x29120
movq -0x68(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x14fe0
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x291c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
seta %al
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x11(%rbp)
je 0x28200
testb $0x1, -0x31(%rbp)
jne 0x28200
movq -0x10(%rbp), %rdi
callq 0x51b0
movq %rax, %rdi
callq 0x55f0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x68(%rbp), %rax
testb $0x1, (%rax)
je 0x28243
movq -0x68(%rbp), %rsi
addq $0x38, %rsi
movq -0x10(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x29260
testb $0x1, -0x11(%rbp)
je 0x28241
leaq -0x58(%rbp), %rdi
callq 0x29290
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x220a0
jmp 0x28260
testb $0x1, -0x11(%rbp)
je 0x2825e
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x220a0
jmp 0x28260
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::import_parent_var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
void import_parent_var(std::string &&var_name)
    {
        undefine.erase(var_name);
        set_vars.erase(string_view(var_name));
        if (!keep_parent_env) {
            import_from_parent.insert(std::move(var_name));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x29120
movq -0x48(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x14fe0
movq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x291c0
movq -0x48(%rbp), %rax
testb $0x1, (%rax)
jne 0x282f9
movq -0x48(%rbp), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x29260
addq $0x50, %rsp
popq %rbp
retq
nop
// File: davmac314[P]dinit/src/includes/dinit-env.h
// Function: environment::env_map::lookup(string_view) const
const char *lookup(string_view sv) const {
            auto it = var_map.find(sv);
            if (it != var_map.end()) {
                return env_list[it->second] + sv.size() + 1;
            }
            return nullptr;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
leaq -0x18(%rbp), %rsi
callq 0x2faf0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
callq 0x2fb20
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1d640
testb $0x1, %al
jne 0x2faa1
jmp 0x2fadc
leaq -0x28(%rbp), %rdi
callq 0x2fb70
movq -0x38(%rbp), %rdi
movl 0x10(%rax), %eax
movl %eax, %esi
callq 0x2fb50
movq (%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x22030
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2fae4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: davmac314[P]dinit/src/includes/load-service.h
// Function: dinit_load::parse_perms(file_pos_ref, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
inline int parse_perms(file_pos_ref input_pos, string &paramval, const std::string &servicename,
        const char * paramname)
{
    std::size_t ind = 0;
    try {
        int perms = std::stoi(paramval, &ind, 8);
        if (ind != paramval.length()) {
            throw std::logic_error("");
        }
        return perms;
    }
    catch (std::logic_error &exc) {
        throw service_description_exc(servicename, paramname,
                "badly-formed or out-of-range numeric value", input_pos);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x32fd0
movl %eax, -0x78(%rbp)
jmp 0x306ad
movl -0x78(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5770
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
je 0x307f3
movl $0x10, %edi
callq 0x5220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
leaq 0x8e87(%rip), %rsi      # 0x39579
callq 0x5740
jmp 0x306f9
movq -0x88(%rbp), %rdi
movq 0x208b9(%rip), %rsi     # 0x50fc0
movq 0x2085a(%rip), %rdx     # 0x50f68
callq 0x5840
jmp 0x30859
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3073e
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x53a0
movl -0x44(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x30848
movq -0x40(%rbp), %rdi
callq 0x51a0
movq %rax, -0x50(%rbp)
movb $0x1, -0x72(%rbp)
movl $0x70, %edi
callq 0x5220
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5880
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x13710
jmp 0x307af
movq -0xa0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
leaq 0x9ce4(%rip), %rcx      # 0x3a4a8
leaq -0x70(%rbp), %rdx
leaq -0x10(%rbp), %r8
callq 0x31690
jmp 0x307d3
movq -0xa8(%rbp), %rdi
movb $0x0, -0x72(%rbp)
leaq 0x2040b(%rip), %rsi     # 0x50bf0
leaq -0x2a9c(%rip), %rdx     # 0x2dd50
callq 0x5840
jmp 0x30859
movl -0x34(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x30822
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5320
leaq -0x71(%rbp), %rdi
callq 0x5520
testb $0x1, -0x72(%rbp)
jne 0x30833
jmp 0x3083f
movq -0xa8(%rbp), %rdi
callq 0x53a0
callq 0x5810
jmp 0x30846
jmp 0x30848
movq -0x40(%rbp), %rdi
callq 0x5870
movq %rax, %rdi
callq 0x138d0
nopl (%rax)
// File: davmac314[P]dinit/src/includes/dinit-util.h
// Function: starts_with(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
inline bool starts_with(const std::string &s, const char *prefix) noexcept
{
    const char *sp = s.c_str();
    while (*sp != 0 && *prefix != 0) {
        if (*sp != *prefix) return false;
        sp++; prefix++;
    }
    return *prefix == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x3217e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x32187
jmp 0x321b9
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x3219f
movb $0x0, -0x1(%rbp)
jmp 0x321cb
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3215d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davmac314[P]dinit/src/includes/load-service.h
// Function: dinit_load::find_rlimits(std::vector<service_rlimits, std::allocator<service_rlimits>>&, int)
inline service_rlimits &find_rlimits(std::vector<service_rlimits> &all_rlimits, int resource_id)
{
    for (service_rlimits &limits : all_rlimits) {
        if (limits.resource_id == resource_id) {
            return limits;
        }
    }

    all_rlimits.emplace_back(resource_id);
    return all_rlimits.back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x33710
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x33740
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x33770
testb $0x1, %al
jne 0x32224
jmp 0x32253
leaq -0x28(%rbp), %rdi
callq 0x337b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x32246
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3226d
jmp 0x32248
leaq -0x28(%rbp), %rdi
callq 0x337d0
jmp 0x32211
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x337f0
movq -0x10(%rbp), %rdi
callq 0x33870
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: davmac314[P]dinit/src/includes/dinit-util.h
// Function: ha_string::operator=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ha_string &operator=(const std::string &other)
    {
        char *new_str_data = new char[other.length() + 1];
        delete[] str_data;
        memcpy(new_str_data, other.data(), other.length() + 1);
        str_data = new_str_data;
        str_len = other.length();
        return *this;
    }

// 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)
movq -0x10(%rbp), %rdi
callq 0x5770
movq %rax, %rdi
addq $0x1, %rdi
callq 0x5030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x32d9e
movq -0x20(%rbp), %rdi
callq 0x5650
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5660
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5770
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x53f0
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x5770
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: josh0xA[P]bf/src/bf.cc
// Function: bf::Parser::get_loop_closer(bf::Environment&)
void Parser::get_loop_closer(Environment& env) {
    temp_value = 1;
    do {
      env.bf_instruction_pointer++;
      if (*env.bf_instruction_pointer == '[') temp_value++;
      else if (*env.bf_instruction_pointer == ']') temp_value--;
    } while (temp_value != BF_SUCCESS_CODE_STANDARD);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, 0x1c0(%rax)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x3230
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x3270
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x272f
movq -0x20(%rbp), %rax
movl 0x1c0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c0(%rax)
jmp 0x2759
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x3270
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x2757
movq -0x20(%rbp), %rax
movl 0x1c0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c0(%rax)
jmp 0x2759
jmp 0x275b
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1c0(%rax)
jne 0x26f2
addq $0x20, %rsp
popq %rbp
retq
nop
// File: josh0xA[P]bf/src/bf.cc
// Function: bf::Parser::get_loop_opener(bf::Environment&)
void Parser::get_loop_opener(Environment& env) {
    temp_value = BF_SUCCESS_CODE_STANDARD;
    do {
      if (*env.bf_instruction_pointer == '[') temp_value++;
      else if (*env.bf_instruction_pointer == ']') temp_value--;
      env.bf_instruction_pointer--;
    } while (temp_value != BF_SUCCESS_CODE_STANDARD);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, 0x1c0(%rax)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x3270
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x27bc
movq -0x20(%rbp), %rax
movl 0x1c0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c0(%rax)
jmp 0x27e6
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x3270
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x27e4
movq -0x20(%rbp), %rax
movl 0x1c0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c0(%rax)
jmp 0x27e6
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x3290
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1c0(%rax)
jne 0x2792
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: josh0xA[P]bf/src/bf.cc
// Function: bf::User::load_interactive_interpreter(bf::Environment&)
bool User::load_interactive_interpreter(Environment& env) {
    while (bf::bfuck_should_succeed<bool>(true, true)) {
      std::cout << ": ";
      std::getline(std::cin, interpreter_prompt);
      if (!std::cin) {
        std::cerr << "(error): broken input stream\n";
        break;
      }
      if (temp_bracks == BF_SUCCESS_CODE_STANDARD) { env.wipe_instruction_buffer(true);  }
      BF_SET_VALUE(temp_bracks, entry_point_line(env, interpreter_prompt, temp_bracks));
      if (temp_bracks == BF_SUCCESS_CODE_STANDARD) {
        interpret_bf_instructions(env);
        output_bf_stream(*env.bf_memory_pointer);
        BF_FLUSH(std::endl);
      } else {
          std::cout << "... ";
      }
    }
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %esi
movl %esi, %edi
callq 0x33a0
testb $0x1, %al
jne 0x2b7d
jmp 0x2c7f
movq 0x5444(%rip), %rdi      # 0x7fc8
leaq 0x254a(%rip), %rsi      # 0x50d5
callq 0x21c0
movq -0x18(%rbp), %rsi
addq $0x1c8, %rsi            # imm = 0x1C8
movq 0x5436(%rip), %rdi      # 0x7fd8
callq 0x2040
movq 0x542a(%rip), %rax      # 0x7fd8
movq (%rax), %rax
movq 0x5420(%rip), %rdi      # 0x7fd8
addq -0x18(%rax), %rdi
callq 0x20c0
testb $0x1, %al
jne 0x2bc7
jmp 0x2bdf
movq 0x5422(%rip), %rdi      # 0x7ff0
leaq 0x2503(%rip), %rsi      # 0x50d8
callq 0x21c0
jmp 0x2c7f
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1c4(%rax)
jne 0x2bfa
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x25d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rdi, %rdx
addq $0x1c8, %rdx            # imm = 0x1C8
movl 0x1c4(%rdi), %ecx
callq 0x33d0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c4(%rax)
cmpl $0x0, 0x1c4(%rax)
jne 0x2c67
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2810
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x3270
movq -0x18(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3340
movq 0x536f(%rip), %rdi      # 0x7fc8
movq 0x5350(%rip), %rsi      # 0x7fb0
callq 0x2210
jmp 0x2c7a
movq 0x535a(%rip), %rdi      # 0x7fc8
leaq 0x2481(%rip), %rsi      # 0x50f6
callq 0x21c0
jmp 0x2b68
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: hyp1231[P]FMSS/disk.cpp
// Function: Disk::Disk()
Disk::Disk() : disk_file("diskdata") {
	ifstream ifile(disk_file);
	BLKsize = 0;
	if(!ifile) { cout << "Disk initialization error! ！(◎_◎;)" << endl; return; }
	char tmp = 0;
	for(int i = 0; i < 2; ++i) {		// read the basic size of a block in the disk
		ifile.read((char*)&tmp, sizeof(tmp));
		BLKsize += (int)tmp << (8 * i);	// Little endian
	}
	ifile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x248(%rbp)
movq %rax, -0x250(%rbp)
leaq -0x9(%rbp), %rdi
movq %rdi, -0x240(%rbp)
callq 0x34a0
movq -0x248(%rbp), %rdi
movq -0x240(%rbp), %rdx
leaq 0xb8be(%rip), %rsi      # 0xf004
callq 0x3c50
jmp 0x374d
leaq -0x9(%rbp), %rdi
callq 0x32d0
movq -0x250(%rbp), %rsi
leaq -0x228(%rbp), %rdi
movl $0x8, %edx
callq 0x3450
jmp 0x3770
movq -0x250(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x228(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x228(%rbp,%rax), %rdi
callq 0x3120
movb %al, -0x251(%rbp)
jmp 0x379e
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x37ad
jmp 0x3835
movq 0x1181c(%rip), %rdi     # 0x14fd0
leaq 0xb852(%rip), %rsi      # 0xf00d
callq 0x3250
movq %rax, -0x260(%rbp)
jmp 0x37c9
movq -0x260(%rbp), %rdi
movq 0x117e9(%rip), %rsi     # 0x14fc0
callq 0x32a0
jmp 0x37de
movl $0x1, -0x22c(%rbp)
jmp 0x38b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x32d0
jmp 0x38d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x38c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x3090
jmp 0x38c8
movb $0x0, -0x22d(%rbp)
movl $0x0, -0x234(%rbp)
cmpl $0x2, -0x234(%rbp)
jge 0x389b
leaq -0x228(%rbp), %rdi
leaq -0x22d(%rbp), %rsi
movl $0x1, %edx
callq 0x3360
jmp 0x3869
movq -0x250(%rbp), %rax
movsbl -0x22d(%rbp), %edx
movl -0x234(%rbp), %ecx
shll $0x3, %ecx
shll %cl, %edx
movl %edx, %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movl -0x234(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x234(%rbp)
jmp 0x3846
leaq -0x228(%rbp), %rdi
callq 0x3080
jmp 0x38a9
movl $0x0, -0x22c(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x3090
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x248(%rbp), %rdi
callq 0x3160
movq -0x18(%rbp), %rdi
callq 0x3490
nopl (%rax)
// File: hyp1231[P]FMSS/disk.cpp
// Function: Disk::Getblk(char*, int)
bool Disk::Getblk(char buf[], int blk_num) {
	ifstream ifile(disk_file);
	if(!ifile) {	// cannot open file
		cout << "Diskfile not found... (´Д` )" << endl;
		return false;
	}
	ifile.seekg(ifile.beg + BLKsize * blk_num);
	for(int i = 0; i < BLKsize; ++i) {
		ifile.read((char*)&buf[i], sizeof(char));
	}
	ifile.close();
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x258(%rbp)
leaq -0x228(%rbp), %rdi
movl $0x8, %edx
callq 0x3450
movq -0x228(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x228(%rbp,%rax), %rdi
callq 0x3120
movb %al, -0x24d(%rbp)
jmp 0x3952
movb -0x24d(%rbp), %al
testb $0x1, %al
jne 0x395e
jmp 0x39c5
movq 0x1166b(%rip), %rdi     # 0x14fd0
leaq 0xb6ca(%rip), %rsi      # 0xf036
callq 0x3250
movq %rax, -0x260(%rbp)
jmp 0x397a
movq -0x260(%rbp), %rdi
movq 0x11638(%rip), %rsi     # 0x14fc0
callq 0x32a0
jmp 0x398f
movb $0x0, -0x1(%rbp)
movl $0x1, -0x238(%rbp)
jmp 0x3a6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x3090
jmp 0x3a88
movq -0x258(%rbp), %rax
movl 0x20(%rax), %eax
movl -0x1c(%rbp), %ecx
imull %ecx, %eax
movslq %eax, %rsi
leaq -0x248(%rbp), %rdi
callq 0x3d00
jmp 0x39e6
movq -0x248(%rbp), %rsi
movq -0x240(%rbp), %rdx
leaq -0x228(%rbp), %rdi
callq 0x3370
jmp 0x3a02
movl $0x0, -0x24c(%rbp)
movq -0x258(%rbp), %rcx
movl -0x24c(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x3a52
movq -0x18(%rbp), %rsi
movslq -0x24c(%rbp), %rax
addq %rax, %rsi
leaq -0x228(%rbp), %rdi
movl $0x1, %edx
callq 0x3360
jmp 0x3a3f
jmp 0x3a41
movl -0x24c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24c(%rbp)
jmp 0x3a0c
leaq -0x228(%rbp), %rdi
callq 0x3080
jmp 0x3a60
movb $0x1, -0x1(%rbp)
movl $0x1, -0x238(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x3090
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x230(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)