// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/includes/load-service.h
// Function: void dinit_load::value_var_subst<load_service(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, service_record*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, service_record*>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<dir_entry, std::allocator<dir_entry>> const&)::$_0>(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::list<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&, load_service(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, service_record*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, service_record*>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<dir_entry, std::allocator<dir_entry>> const&)::$_0 const&, char const*)
static void value_var_subst(const char *setting_name, std::string &line,
        std::list<std::pair<unsigned,unsigned>> &offsets, const T &var_resolve, const char *argval)
{
    auto dindx = line.find('$');
    if (dindx == string::npos) {
        return;
    }

    if (line.length() > (size_t)std::numeric_limits<int>::max()) {
        // (avoid potential for overflow later)
        throw std::length_error("string too long");
    }

    auto i = offsets.begin();
    unsigned xpos = 0; // position to copy from in original line
    std::string r_line;
    int offadj = 0;

    while (i != offsets.end()) {

        i->first += offadj; // don't adjust end yet

        // inhibit_collapse is set if we process anything which may be empty but shouldn't collapse
        // to "no argument"
        bool inhibit_collapse = false;
        bool do_collapse = false;

        while (i->second > dindx) {
            r_line.append(line, xpos, dindx - xpos); // copy unmatched part
            if (line[dindx + 1] == '$') {
                // double dollar, collapse to single
                r_line += '$';
                xpos = dindx + 2;
                --offadj;
            }
            else {
                // variable
                auto token_end = std::next(line.begin(), i->second);
                auto spos = dindx + 1;
                bool wsplit = line[spos] == '/';
                if (wsplit) ++spos;
                bool brace = line[spos] == '{';
                if (brace) ++spos;
                auto j = std::next(line.begin(), spos);
                // may be a service argument
                bool is_arg = false;
                // read environment variable name
                string name = read_config_name(j, token_end, true, &is_arg);
                if (name.empty()) {
                    throw service_description_exc(setting_name, "invalid/missing variable name after '$'");
                }
                else if (is_arg && name != "1") {
                    // only one arg is supported
                    throw service_description_exc(setting_name, "only one service argument may be present");
                }
                char altmode = '\0';
                bool colon = false;
                auto altbeg = j, altend = j;
                if (brace) {
                    /* ${foo+val}, ${foo-val}, ${foo:+val}, ${foo:-val} */
                    if (*j == ':') {
                        colon = true;
                        ++j;
                        if (*j != '+' && *j != '-') {
                            throw service_description_exc(setting_name,
                                    "invalid syntax in variable substitution");
                        }
                    }
                    if (*j == '+' || *j == '-') {
                        altmode = *j;
                        altbeg = ++j;
                        while (j != token_end && *j != '}') {
                            ++j;
                        }
                        altend = j;
                    }
                    if (*j != '}') {
                        throw service_description_exc(setting_name,
                                "unmatched '{' in variable substitution");
                    }
                    ++j;
                }
                size_t line_len_before = r_line.size();
                string_view resolved_vw;
                auto *resolved = is_arg ? argval : var_resolve(name);
                if (resolved) {
                    resolved_vw = resolved;
                }
                /* apply shell-like substitutions */
                if (altmode == '-') {
                    if (!resolved || (colon && !*resolved)) {
                        resolved_vw = {line.c_str() + (altbeg - line.begin()), (size_t)(altend - altbeg)};
                    }
                }
                else if (altmode == '+') {
                    if (resolved && (!colon || *resolved)) {
                        resolved_vw = {line.c_str() + (altbeg - line.begin()), (size_t)(altend - altbeg)};
                    }
                }
                else if (is_arg && !argval) {
                    // $1 and ${1} is special in that it must be set or it is an error
                    // however, we want the more complex syntaxes for conditional substitution
                    throw service_description_exc(setting_name, "missing value in argument substitution");
                }

                xpos = j - line.begin();
                int name_len = xpos - dindx;
                offadj -= name_len;

                if (!wsplit) {
                    inhibit_collapse = true;
                    do_collapse = false;
                    if (!resolved_vw.empty()) {
                        r_line.append(resolved_vw.data(), resolved_vw.length());
                    }
                }
                else {
                    // Must perform word splitting. Find first whitespace:
                    auto r_vw_beg = resolved_vw.data();
                    auto r_vw_end = r_vw_beg + resolved_vw.length();
                    const char *wsp = findws(r_vw_beg, r_vw_end);

                    // If we have whitespace, append up to that whitespace and then split:
                    while (wsp != r_vw_end) {
                        if (wsp != r_vw_beg) {
                            r_line.append(r_vw_beg, wsp - r_vw_beg);
                        }

                        auto orig_i_second = i->second;

                        size_t line_len_after = r_line.size();
                        if (i->first == line_len_after && !inhibit_collapse) {
                            // whitespace at the start of the word; just trim it
                            goto next_section;
                        }

                        // Break here:
                        i->second = r_line.length();

                        r_line += ' ';
                        ++line_len_after;

                        if (line_len_after > (size_t)std::numeric_limits<int>::max()) {
                            // (avoid potential overflow)
                            throw service_description_exc(setting_name,
                                    "value too long (after substitution)");
                        }

                        // Create new argument from split:
                        i = offsets.insert(std::next(i), {r_line.length(), orig_i_second});
                        offadj += (int)line_len_after - (int)line_len_before;
                        line_len_before = r_line.size();

                        // Find the next break, if any:
                        next_section:
                        r_vw_beg = skipws(wsp, r_vw_end);
                        wsp = findws(r_vw_beg, r_vw_end);
                        inhibit_collapse = false;
                    }

                    if (r_vw_beg != r_vw_end) {
                        r_line.append(r_vw_beg, r_vw_end - r_vw_beg);
                    }

                    do_collapse = !inhibit_collapse;
                }

                size_t line_len_after = r_line.size();

                if (line_len_after > (size_t)std::numeric_limits<int>::max()) {
                    // (avoid potential overflow)
                    throw service_description_exc(setting_name, "value too long (after substitution)");
                }

                offadj += (int)line_len_after - (int)line_len_before;
            }

            dindx = line.find('$', xpos);
        }

        i->second += offadj;

        if (do_collapse && i->first == i->second) {
            i = offsets.erase(i);
        }
        else {
            ++i;
        }

        while (i != offsets.end() && i->second < dindx) {
            i->first += offadj;
            i->second += offadj;
            ++i;
        }
    }

    r_line.append(line, xpos); // copy final unmatched part
    line = std::move(r_line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, 0x98(%rsp)
movq %rcx, 0x70(%rsp)
movq %rdx, 0x58(%rsp)
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
movq %rsi, %rdi
movl $0x24, %esi
xorl %edx, %edx
callq 0x44b0
cmpq $-0x1, %rax
je 0xbf38
movq %rax, 0x38(%rsp)
movq 0x8(%r14), %rax
shrq $0x1f, %rax
jne 0xc4c1
movq 0x58(%rsp), %rcx
movq (%rcx), %r12
leaq 0x88(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq $0x0, 0x30(%rsp)
cmpq %rcx, %r12
je 0xbef2
leaq 0x78(%rsp), %rbx
xorl %r13d, %r13d
movq %r14, 0xa0(%rsp)
addl %r13d, 0x10(%r12)
leaq 0x14(%r12), %r15
movl 0x14(%r12), %eax
cmpq %rax, 0x38(%rsp)
jae 0xbea9
movq %r12, 0x48(%rsp)
movl $0x0, 0x2c(%rsp)
xorl %ebp, %ebp
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %rcx
movl %ecx, %edx
movq %r12, %rcx
subq %rdx, %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4500
movq (%r14), %rax
movb 0x1(%rax,%r12), %sil
cmpb $0x24, %sil
jne 0xb93d
movq %rbx, %rdi
movl $0x24, %esi
callq 0x4330
addl $0x2, %r12d
decl %r13d
jmp 0xbe30
leaq 0x1(%r12), %rcx
movl (%r15), %r15d
addq %rax, %r15
leaq 0x2(%r12), %rdx
movb %sil, 0x30(%rsp)
cmpb $0x2f, %sil
cmovneq %rcx, %rdx
leaq (%rax,%rdx), %rcx
movb (%rax,%rdx), %bpl
xorl %eax, %eax
cmpb $0x7b, %bpl
sete %al
addq %rcx, %rax
movq %rax, 0x50(%rsp)
movb $0x0, 0x7(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %r15, %rdx
movl $0x1, %ecx
leaq 0x7(%rsp), %r8
callq 0x16bf4
cmpq $0x0, 0xb0(%rsp)
je 0xbfae
movq %r12, 0x38(%rsp)
movl %r13d, 0x28(%rsp)
cmpb $0x1, 0x7(%rsp)
jne 0xb9d3
leaq 0xa8(%rsp), %rdi
leaq 0x11c64(%rip), %rsi     # 0x1d62a
callq 0x4110
testl %eax, %eax
jne 0xc0db
xorl %r13d, %r13d
movq 0x50(%rsp), %r12
cmpb $0x7b, %bpl
jne 0xba75
movb (%r12), %al
movq %r12, %rcx
cmpb $0x3a, %al
sete %r14b
jne 0xba12
leaq 0x1(%r12), %rcx
movq %rcx, 0x50(%rsp)
movzbl 0x1(%r12), %eax
cmpl $0x2b, %eax
je 0xba12
cmpl $0x2d, %eax
jne 0xc2d1
cmpb $0x2d, %al
je 0xba21
movzbl %al, %edx
xorl %r13d, %r13d
cmpl $0x2b, %edx
jne 0xba7f
leaq 0x1(%rcx), %rdi
movq %rdi, 0x50(%rsp)
movq %rdi, %rdx
movq %rdi, %r12
cmpq %r15, %rdi
je 0xba65
cmpb $0x7d, (%rdi)
movq %rdi, %rdx
movq %rdi, %r12
je 0xba65
addq $0x2, %rcx
movq %rcx, %rsi
movq %rsi, %rdx
movq %rcx, %r12
movq %rsi, 0x50(%rsp)
cmpq %r15, %rsi
je 0xba65
leaq 0x1(%rdx), %rsi
leaq 0x1(%r12), %rcx
cmpb $0x7d, (%rdx)
jne 0xba47
movq %rdi, 0x68(%rsp)
movsbl %al, %r13d
movb (%rdx), %al
movq %rdx, %rcx
jmp 0xba84
movq %r12, 0x68(%rsp)
xorl %r14d, %r14d
jmp 0xba94
movq %r12, 0x68(%rsp)
cmpb $0x7d, %al
jne 0xc13f
incq %rcx
movq %rcx, 0x50(%rsp)
movq 0x80(%rsp), %rbp
cmpb $0x0, 0x7(%rsp)
movq 0x98(%rsp), %r15
jne 0xbb66
movl %r14d, 0x60(%rsp)
cmpb $0x0, 0x1ad2d(%rip)     # 0x267e8
jne 0xbb1d
movq 0x70(%rsp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0xbb1d
movl $0x15, %edx
movq 0x1a51a(%rip), %rdi     # 0x25ff0
leaq 0x114b3(%rip), %rsi     # 0x1cf90
callq 0x4410
movl $0x94, %edx
movq 0x1a502(%rip), %rdi     # 0x25ff0
leaq 0x11406(%rip), %rsi     # 0x1cefb
callq 0x4410
movl $0x1, %edx
movq 0x1a4ea(%rip), %rdi     # 0x25ff0
leaq 0x10a5c(%rip), %rsi     # 0x1c569
callq 0x4410
movq 0x70(%rsp), %rax
movq (%rax), %rax
movb $0x1, (%rax)
movq 0x70(%rsp), %rax
movq 0x8(%rax), %r14
movups 0xa8(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
leaq 0x18(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x17292
testq %rax, %rax
je 0xbb5e
movl 0x18(%rax), %eax
movq (%r14), %rcx
movq (%rcx,%rax,8), %rax
movq 0x10(%rsp), %rcx
leaq (%rax,%rcx), %r15
incq %r15
jmp 0xbb61
xorl %r15d, %r15d
movl 0x60(%rsp), %r14d
movq %rbp, 0x60(%rsp)
testq %r15, %r15
je 0xbb7d
movq %r15, %rdi
callq 0x4190
movq %rax, %rbp
jmp 0xbb7f
xorl %ebp, %ebp
movb 0x30(%rsp), %cl
cmpl $0x2b, %r13d
je 0xbba6
cmpl $0x2d, %r13d
jne 0xbbc8
testq %r15, %r15
movl 0x28(%rsp), %r13d
je 0xbbbb
testb %r14b, %r14b
je 0xbbe7
cmpb $0x0, (%r15)
jne 0xbbe7
jmp 0xbbbb
testq %r15, %r15
movl 0x28(%rsp), %r13d
je 0xbbe4
testb %r14b, %r14b
je 0xbbbb
cmpb $0x0, (%r15)
je 0xbbe7
movq 0x68(%rsp), %r15
subq %r15, %r12
movq %r12, %rbp
jmp 0xbbe7
cmpq $0x0, 0x98(%rsp)
movl 0x28(%rsp), %r13d
jne 0xbbe7
cmpb $0x0, 0x7(%rsp)
je 0xbbe7
jmp 0xc1a3
xorl %r15d, %r15d
movl 0x50(%rsp), %r12d
movq 0xa0(%rsp), %r14
subl (%r14), %r12d
movq 0x38(%rsp), %rax
subl %r12d, %eax
addl %eax, %r13d
cmpb $0x2f, %cl
jne 0xbc4b
movq %r12, 0x30(%rsp)
movl %r13d, 0x28(%rsp)
leaq (%r15,%rbp), %r12
movq %r15, %r13
testq %rbp, %rbp
je 0xbc6e
xorl %r13d, %r13d
movzbl (%r15,%r13), %r14d
callq 0x44f0
movq %rax, %rdi
callq 0x4180
movq 0x30(%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
jne 0xbc6b
incq %r13
cmpq %r13, %rbp
jne 0xbc20
jmp 0xbdab
movb $0x1, %al
movl %eax, 0x2c(%rsp)
testq %rbp, %rbp
je 0xbc64
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x4090
xorl %ebp, %ebp
jmp 0xbdee
addq %r15, %r13
cmpq %r12, %r13
je 0xbdab
movq 0x48(%rsp), %rbp
movl 0x2c(%rsp), %r14d
movq %r13, %rdx
subq %r15, %rdx
je 0xbc94
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4090
movl 0x10(%rbp), %eax
movq 0x80(%rsp), %r15
cmpq %rax, %r15
setne %al
orb %r14b, %al
testb $0x1, %al
je 0xbd3b
movq %rbp, %rax
movl 0x14(%rbp), %ebp
movq %rax, %r14
movl %r15d, 0x14(%rax)
movq %rbx, %rdi
movl $0x20, %esi
callq 0x4330
incq %r15
cmpq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
ja 0xbf4a
movq (%r14), %rax
movq %rax, 0x38(%rsp)
movl 0x80(%rsp), %ebx
movl $0x18, %edi
callq 0x4390
movq %rax, %r14
shlq $0x20, %rbp
orq %rbx, %rbp
movq %rbp, 0x10(%rax)
movq %rax, %rdi
movq 0x38(%rsp), %rsi
callq 0x4070
movq 0x58(%rsp), %rax
incq 0x10(%rax)
movl 0x28(%rsp), %eax
subl 0x60(%rsp), %eax
addl %r15d, %eax
movl %eax, 0x28(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x78(%rsp), %rbx
movq %r14, %rbp
movzbl (%r13), %r14d
callq 0x44f0
movq %rax, %rdi
callq 0x4180
movq 0x30(%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
je 0xbd69
incq %r13
cmpq %r12, %r13
jne 0xbd3b
movq %r12, %r15
movq %r12, %r13
jmp 0xbd6c
movq %r13, %r15
cmpq %r12, %r15
je 0xbd9d
movq %r15, %r13
movzbl (%r13), %r14d
callq 0x44f0
movq %rax, %rdi
callq 0x4180
movq 0x30(%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
jne 0xbd9d
incq %r13
cmpq %r12, %r13
jne 0xbd74
movq %r12, %r13
xorl %r14d, %r14d
cmpq %r12, %r13
jne 0xbc81
jmp 0xbdb5
movq 0x48(%rsp), %rbp
movl 0x2c(%rsp), %r14d
movq %rbp, 0x48(%rsp)
cmpq %r12, %r15
movl 0x28(%rsp), %r13d
je 0xbdd5
subq %r15, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4090
movl %r14d, 0x2c(%rsp)
movl %r14d, %ebp
xorb $0x1, %bpl
movq 0xa0(%rsp), %r14
movq 0x30(%rsp), %r12
movq 0x80(%rsp), %r15
testq $-0x80000000, %r15      # imm = 0x80000000
jne 0xc012
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0xbe28
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x43a0
subl 0x60(%rsp), %r13d
addl %r15d, %r13d
movl %r12d, %edx
movq %r14, %rdi
movl $0x24, %esi
callq 0x44b0
movq %r12, %rcx
movq %rax, %r12
movq 0x48(%rsp), %rax
leaq 0x14(%rax), %r15
movl 0x14(%rax), %eax
cmpq %rax, %r12
jb 0xb903
movq %rcx, 0x30(%rsp)
movq %r12, 0x38(%rsp)
addl %r13d, %eax
movl %eax, (%r15)
testb $0x1, %bpl
je 0xbeb1
movq 0x48(%rsp), %r12
cmpl %eax, 0x10(%r12)
jne 0xbed8
movq (%r12), %rbx
movq 0x58(%rsp), %rax
decq 0x10(%rax)
movq %r12, %rdi
callq 0x45f0
movl $0x18, %esi
movq %r12, %rdi
callq 0x43a0
movq %rbx, %r12
leaq 0x78(%rsp), %rbx
jmp 0xbeb8
addl %r13d, %eax
movl %eax, (%r15)
jmp 0xbed8
movq 0x48(%rsp), %r12
jmp 0xbed8
cmpq 0x58(%rsp), %r12
je 0xbede
movl 0x14(%r12), %eax
cmpq %rax, 0x38(%rsp)
jbe 0xbede
addl %r13d, 0x10(%r12)
addl %r13d, %eax
movl %eax, 0x14(%r12)
movq (%r12), %r12
jmp 0xbeb8
cmpq 0x58(%rsp), %r12
jne 0xb8d0
movq 0x30(%rsp), %rdx
movl %edx, %edx
jmp 0xbef4
xorl %edx, %edx
leaq 0x78(%rsp), %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x4500
leaq 0x78(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4480
movq (%rbx), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0xbf38
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x43a0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10f70(%rip), %rsi     # 0x1ced7
leaq 0x10f8c(%rip), %rdx     # 0x1cefa
leaq 0x8(%rsp), %rdi
callq 0x129da
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x30(%r14), %rax
movq %rax, 0x20(%r14)
movq 0x8(%rsp), %rcx
cmpq %r15, %rcx
jne 0xc076
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xc083
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10e45(%rip), %rsi     # 0x1ce10
leaq 0x10e65(%rip), %rdx     # 0x1ce37
leaq 0x8(%rsp), %rdi
callq 0x129da
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x30(%r14), %rax
movq %rax, 0x20(%r14)
movq 0x8(%rsp), %rcx
cmpq %r15, %rcx
jne 0xc207
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xc214
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10ea8(%rip), %rsi     # 0x1ced7
leaq 0x10ec4(%rip), %rdx     # 0x1cefa
leaq 0x8(%rsp), %rdi
callq 0x129da
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x30(%r14), %rax
movq %rax, 0x20(%r14)
movq 0x8(%rsp), %rcx
cmpq %r15, %rcx
jne 0xc26c
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xc279
movq %rcx, 0x20(%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%r14)
movq %r15, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movb %al, 0x18(%rsp)
movl $0xffffffff, 0x40(%r14) # imm = 0xFFFFFFFF
movq %r14, %rcx
addq $0x58, %rcx
movq %rcx, 0x48(%r14)
movq %rax, 0x50(%r14)
movb %al, 0x58(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x68(%r14)
leaq 0x19b59(%rip), %rsi     # 0x25c20
leaq 0xaad8(%rip), %rdx      # 0x16ba6
movq %r14, %rdi
callq 0x4620
jmp 0xc4c1
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10d40(%rip), %rsi     # 0x1ce38
leaq 0x10d61(%rip), %rdx     # 0x1ce60
leaq 0x8(%rsp), %rdi
callq 0x129da
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x30(%r14), %rax
movq %rax, 0x20(%r14)
movq 0x8(%rsp), %rcx
cmpq %r15, %rcx
jne 0xc335
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xc342
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10d2d(%rip), %rsi     # 0x1ce89
leaq 0x10d4c(%rip), %rdx     # 0x1ceaf
leaq 0x8(%rsp), %rdi
callq 0x129da
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x30(%r14), %rax
movq %rax, 0x20(%r14)
movq 0x8(%rsp), %rcx
cmpq %r15, %rcx
jne 0xc39a
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xc3a7
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10cf0(%rip), %rsi     # 0x1ceb0
leaq 0x10d0f(%rip), %rdx     # 0x1ced6
leaq 0x8(%rsp), %rdi
callq 0x129da
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x30(%r14), %rax
movq %rax, 0x20(%r14)
movq 0x8(%rsp), %rcx
cmpq %r15, %rcx
jne 0xc3ff
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xc40c
movq %rcx, 0x20(%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%r14)
movq %r15, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movb %al, 0x18(%rsp)
movl $0xffffffff, 0x40(%r14) # imm = 0xFFFFFFFF
movq %r14, %rcx
addq $0x58, %rcx
movq %rcx, 0x48(%r14)
movq %rax, 0x50(%r14)
movb %al, 0x58(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x68(%r14)
leaq 0x199c8(%rip), %rsi     # 0x25c20
leaq 0xa947(%rip), %rdx      # 0x16ba6
movq %r14, %rdi
callq 0x4620
jmp 0xc4c1
movq %rcx, 0x20(%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%r14)
movq %r15, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movb %al, 0x18(%rsp)
movl $0xffffffff, 0x40(%r14) # imm = 0xFFFFFFFF
movq %r14, %rcx
addq $0x58, %rcx
movq %rcx, 0x48(%r14)
movq %rax, 0x50(%r14)
movb %al, 0x58(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x68(%r14)
leaq 0x19963(%rip), %rsi     # 0x25c20
leaq 0xa8e2(%rip), %rdx      # 0x16ba6
movq %r14, %rdi
callq 0x4620
jmp 0xc4c1
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10b73(%rip), %rsi     # 0x1ce61
leaq 0x10b93(%rip), %rdx     # 0x1ce88
leaq 0x8(%rsp), %rdi
callq 0x129da
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x30(%r14), %rax
movq %rax, 0x20(%r14)
movq 0x8(%rsp), %rcx
cmpq %r15, %rcx
jne 0xc461
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xc46e
movq %rcx, 0x20(%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%r14)
movq %r15, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movb %al, 0x18(%rsp)
movl $0xffffffff, 0x40(%r14) # imm = 0xFFFFFFFF
movq %r14, %rcx
addq $0x58, %rcx
movq %rcx, 0x48(%r14)
movq %rax, 0x50(%r14)
movb %al, 0x58(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x68(%r14)
leaq 0x1989a(%rip), %rsi     # 0x25c20
leaq 0xa819(%rip), %rdx      # 0x16ba6
movq %r14, %rdi
callq 0x4620
jmp 0xc4c1
movq %rcx, 0x20(%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%r14)
movq %r15, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movb %al, 0x18(%rsp)
movl $0xffffffff, 0x40(%r14) # imm = 0xFFFFFFFF
movq %r14, %rcx
addq $0x58, %rcx
movq %rcx, 0x48(%r14)
movq %rax, 0x50(%r14)
movb %al, 0x58(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x68(%r14)
leaq 0x19835(%rip), %rsi     # 0x25c20
leaq 0xa7b4(%rip), %rdx      # 0x16ba6
movq %r14, %rdi
callq 0x4620
jmp 0xc4c1
movq %rcx, 0x20(%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%r14)
movq %r15, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movb %al, 0x18(%rsp)
movl $0xffffffff, 0x40(%r14) # imm = 0xFFFFFFFF
movq %r14, %rcx
addq $0x58, %rcx
movq %rcx, 0x48(%r14)
movq %rax, 0x50(%r14)
movb %al, 0x58(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x68(%r14)
leaq 0x197d0(%rip), %rsi     # 0x25c20
leaq 0xa74f(%rip), %rdx      # 0x16ba6
movq %r14, %rdi
callq 0x4620
jmp 0xc4c1
movq %rcx, 0x20(%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%r14)
movq %r15, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movb %al, 0x18(%rsp)
movl $0xffffffff, 0x40(%r14) # imm = 0xFFFFFFFF
movq %r14, %rcx
addq $0x58, %rcx
movq %rcx, 0x48(%r14)
movq %rax, 0x50(%r14)
movb %al, 0x58(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x68(%r14)
leaq 0x1976e(%rip), %rsi     # 0x25c20
leaq 0xa6ed(%rip), %rdx      # 0x16ba6
movq %r14, %rdi
callq 0x4620
movl $0x10, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x1092b(%rip), %rsi     # 0x1ce00
movq %rax, %rdi
callq 0x4430
movq 0x19acc(%rip), %rsi     # 0x25fb0
movq 0x19a85(%rip), %rdx     # 0x25f70
movq %r14, %rdi
callq 0x4620
movq %rax, %rbx
movq %r14, %rdi
callq 0x42d0
jmp 0xc59f
jmp 0xc54c
jmp 0xc523
jmp 0xc53f
jmp 0xc523
jmp 0xc53f
jmp 0xc523
jmp 0xc53f
jmp 0xc523
jmp 0xc53f
jmp 0xc555
jmp 0xc555
jmp 0xc523
jmp 0xc53f
jmp 0xc523
jmp 0xc53f
jmp 0xc555
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xc558
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x43a0
jmp 0xc558
movq %rax, %rbx
movq %r14, %rdi
callq 0x42d0
jmp 0xc558
movq %rax, %rbx
jmp 0xc57d
jmp 0xc555
jmp 0xc555
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0xc57d
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x43a0
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0xc59f
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x43a0
movq %rbx, %rdi
callq 0x4630
jmp 0xc5ab
jmp 0xc5ab
movq %rax, %rdi
callq 0x1002f