// File: /workspace/github_cpp_makefile_star2_O1/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, 0x78(%rsp)
movq %rdx, 0x48(%rsp)
movq %rsi, %r13
movq %rdi, 0x40(%rsp)
movq %rsi, %rdi
movl $0x24, %esi
xorl %edx, %edx
callq 0x44b0
cmpq $-0x1, %rax
je 0xbbb6
movq %rax, %r12
movq 0x8(%r13), %rax
shrq $0x1f, %rax
jne 0xc138
movq 0x48(%rsp), %rcx
movq (%rcx), %rbp
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq $0x0, 0x30(%rsp)
cmpq %rcx, %rbp
je 0xbb76
movl $0x0, 0x4(%rsp)
movq %r13, 0xa0(%rsp)
movl 0x4(%rsp), %eax
addl %eax, 0x10(%rbp)
movl 0x14(%rbp), %eax
cmpq %rax, %r12
jae 0xbb07
leaq 0x14(%rbp), %r15
movl $0x0, 0x3c(%rsp)
xorl %r14d, %r14d
movq 0x30(%rsp), %rcx
movl %ecx, %edx
movq %r12, %rcx
subq %rdx, %rcx
leaq 0x58(%rsp), %rdi
movq %r13, %rsi
callq 0x4500
movq (%r13), %rax
movb 0x1(%rax,%r12), %bl
cmpb $0x24, %bl
jne 0xb609
leaq 0x58(%rsp), %rdi
movl $0x24, %esi
callq 0x4330
addl $0x2, %r12d
decl 0x4(%rsp)
jmp 0xbada
leaq 0x1(%r12), %rcx
movl (%r15), %r14d
addq %rax, %r14
leaq 0x2(%r12), %rdx
cmpb $0x2f, %bl
cmovneq %rcx, %rdx
leaq (%rax,%rdx), %rcx
movb (%rax,%rdx), %r15b
xorl %eax, %eax
cmpb $0x7b, %r15b
sete %al
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x3(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
movl $0x1, %ecx
leaq 0x3(%rsp), %r8
callq 0x16b16
cmpq $0x0, 0xb0(%rsp)
je 0xbc8a
cmpb $0x1, 0x3(%rsp)
jne 0xb68f
leaq 0xa8(%rsp), %rdi
leaq 0x11faa(%rip), %rsi     # 0x1d62c
callq 0x4110
testl %eax, %eax
jne 0xbd52
movq 0x28(%rsp), %rdx
cmpb $0x7b, %r15b
jne 0xb73d
movq 0x28(%rsp), %rax
cmpb $0x3a, (%rax)
sete %r15b
jne 0xb6c7
leaq 0x1(%rax), %rcx
movq %rcx, 0x28(%rsp)
movzbl 0x1(%rax), %eax
cmpl $0x2b, %eax
je 0xb6c7
cmpl $0x2d, %eax
jne 0xbfad
movq 0x28(%rsp), %rax
movzbl (%rax), %ecx
cmpl $0x2d, %ecx
je 0xb6e4
movl $0x0, 0x50(%rsp)
movq %rdx, %rsi
cmpl $0x2b, %ecx
jne 0xb715
incq %rax
movq %rax, 0x28(%rsp)
movq %rax, %rdx
cmpq %r14, %rax
je 0xb706
cmpb $0x7d, (%rdx)
je 0xb706
incq %rdx
movq %rdx, 0x28(%rsp)
cmpq %r14, %rdx
jne 0xb6f4
movsbl %cl, %ecx
movl %ecx, 0x50(%rsp)
movq 0x28(%rsp), %rdx
movq %rax, %rsi
movq 0x28(%rsp), %rax
cmpb $0x7d, (%rax)
jne 0xbdb6
movq %rsi, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
incq %rax
movq %rax, 0x28(%rsp)
jmp 0xb758
movl $0x0, 0x50(%rsp)
movq %rdx, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
xorl %r15d, %r15d
movq 0x60(%rsp), %rax
movq %rax, 0x90(%rsp)
cmpb $0x0, 0x3(%rsp)
movq 0x98(%rsp), %r13
jne 0xb82b
movl %ebx, %r14d
cmpb $0x0, 0x1b066(%rip)     # 0x267e8
jne 0xb7e4
movq 0x78(%rsp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0xb7e4
movl $0x15, %edx
movq 0x1a853(%rip), %rdi     # 0x25ff0
leaq 0x117ee(%rip), %rsi     # 0x1cf92
callq 0x4410
movl $0x94, %edx
movq 0x1a83b(%rip), %rdi     # 0x25ff0
leaq 0x11741(%rip), %rsi     # 0x1cefd
callq 0x4410
movl $0x1, %edx
movq 0x1a823(%rip), %rdi     # 0x25ff0
leaq 0x10d97(%rip), %rsi     # 0x1c56b
callq 0x4410
movq 0x78(%rsp), %rax
movq (%rax), %rax
movb $0x1, (%rax)
movq 0x78(%rsp), %rax
movq 0x8(%rax), %rbx
movups 0xa8(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
leaq 0x18(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x171ca
testq %rax, %rax
je 0xb825
movl 0x18(%rax), %eax
movq (%rbx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x10(%rsp), %rcx
leaq (%rax,%rcx), %r13
incq %r13
jmp 0xb828
xorl %r13d, %r13d
movl %r14d, %ebx
movl %r15d, 0x30(%rsp)
testq %r13, %r13
je 0xb845
movq %r13, %rdi
callq 0x4190
movq %rax, %r14
movq %r13, %r15
jmp 0xb84b
xorl %r14d, %r14d
xorl %r15d, %r15d
movl 0x50(%rsp), %eax
cmpl $0x2b, %eax
je 0xb86e
cmpl $0x2d, %eax
jne 0xb896
testq %r13, %r13
je 0xb881
cmpb $0x0, 0x30(%rsp)
je 0xb8ac
cmpb $0x0, (%r13)
jne 0xb8ac
jmp 0xb881
testq %r13, %r13
je 0xb8ac
cmpb $0x0, 0x30(%rsp)
je 0xb881
cmpb $0x0, (%r13)
je 0xb8ac
movq 0x88(%rsp), %r14
movq 0x80(%rsp), %r15
subq %r15, %r14
jmp 0xb8ac
cmpq $0x0, 0x98(%rsp)
jne 0xb8ac
cmpb $0x0, 0x3(%rsp)
jne 0xbe1a
movl 0x28(%rsp), %eax
movq 0xa0(%rsp), %r13
subl (%r13), %eax
movq %rax, 0x30(%rsp)
subl %eax, %r12d
addl %r12d, 0x4(%rsp)
cmpb $0x2f, %bl
jne 0xba34
leaq (%r15,%r14), %r12
movq %r15, %r13
testq %r14, %r14
je 0xb909
movq %r15, %r13
movzbl (%r13), %ebx
callq 0x44f0
movq %rax, %rdi
callq 0x4180
movq 0x30(%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
jne 0xb909
incq %r13
decq %r14
jne 0xb8e1
movq %r12, %r13
cmpq %r12, %r13
je 0xba5e
movl 0x3c(%rsp), %r14d
movq %r13, %rdx
subq %r15, %rdx
je 0xb92c
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0x4090
movl 0x10(%rbp), %eax
movq 0x60(%rsp), %r15
cmpq %rax, %r15
setne %al
orb %r14b, %al
testb $0x1, %al
je 0xb9c6
movl 0x14(%rbp), %ebx
movl %r15d, 0x14(%rbp)
leaq 0x58(%rsp), %rdi
movl $0x20, %esi
callq 0x4330
incq %r15
testq $-0x80000000, %r15      # imm = 0x80000000
jne 0xbbc8
movq (%rbp), %rax
movq %rax, 0x50(%rsp)
movl 0x60(%rsp), %r14d
movl $0x18, %edi
callq 0x4390
movq %rax, %rbp
shlq $0x20, %rbx
orq %r14, %rbx
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq 0x50(%rsp), %rsi
callq 0x4070
movq 0x48(%rsp), %rax
incq 0x10(%rax)
movl 0x4(%rsp), %eax
subl 0x90(%rsp), %eax
addl %r15d, %eax
movl %eax, 0x4(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x90(%rsp)
movzbl (%r13), %ebx
callq 0x44f0
movq %rax, %rdi
callq 0x4180
movq 0x30(%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
je 0xb9f3
incq %r13
cmpq %r12, %r13
jne 0xb9c6
movq %r12, %r15
movq %r12, %r13
jmp 0xb9f6
movq %r13, %r15
cmpq %r12, %r15
je 0xba26
movq %r15, %r13
movzbl (%r13), %ebx
callq 0x44f0
movq %rax, %rdi
callq 0x4180
movq 0x30(%rax), %rax
testb $0x20, 0x1(%rax,%rbx,2)
jne 0xba26
incq %r13
cmpq %r12, %r13
jne 0xb9fe
movq %r12, %r13
xorl %r14d, %r14d
cmpq %r12, %r13
jne 0xb917
jmp 0xba63
movb $0x1, %al
movl %eax, 0x3c(%rsp)
testq %r14, %r14
je 0xba59
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4090
movq 0x30(%rsp), %r12
xorl %r14d, %r14d
jmp 0xba91
xorl %r14d, %r14d
jmp 0xba8c
movl 0x3c(%rsp), %r14d
cmpq %r12, %r15
movq 0xa0(%rsp), %r13
je 0xba83
subq %r15, %r12
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4090
movl %r14d, 0x3c(%rsp)
xorb $0x1, %r14b
movq 0x30(%rsp), %r12
movq 0x60(%rsp), %r15
testq $-0x80000000, %r15      # imm = 0x80000000
jne 0xbcee
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0xbac8
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x43a0
movl 0x4(%rsp), %eax
subl 0x90(%rsp), %eax
addl %r15d, %eax
movl %eax, 0x4(%rsp)
movl %r12d, %edx
movq %r13, %rdi
movl $0x24, %esi
callq 0x44b0
movq %r12, %rcx
movq %rax, %r12
leaq 0x14(%rbp), %r15
movl 0x14(%rbp), %eax
cmpq %rax, %r12
jb 0xb5ca
movq %rcx, 0x30(%rsp)
jmp 0xbb0a
xorl %r14d, %r14d
addl 0x4(%rsp), %eax
movl %eax, 0x14(%rbp)
testb $0x1, %r14b
je 0xbb5c
cmpl %eax, 0x10(%rbp)
jne 0xbb5c
movq (%rbp), %rbx
movq 0x48(%rsp), %rax
decq 0x10(%rax)
movq %rbp, %rdi
callq 0x45f0
movl $0x18, %esi
movq %rbp, %rdi
callq 0x43a0
movq %rbx, %rbp
cmpq 0x48(%rsp), %rbp
je 0xbb62
movl 0x14(%rbp), %eax
cmpq %rax, %r12
jbe 0xbb62
movl 0x4(%rsp), %ecx
addl %ecx, 0x10(%rbp)
addl %ecx, %eax
movl %eax, 0x14(%rbp)
movq (%rbp), %rbp
jmp 0xbb41
cmpq 0x48(%rsp), %rbp
jne 0xb5a3
movq 0x30(%rsp), %rdx
movl %edx, %edx
jmp 0xbb78
xorl %edx, %edx
leaq 0x58(%rsp), %rdi
movq %r13, %rsi
movq $-0x1, %rcx
callq 0x4500
leaq 0x58(%rsp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4480
movq (%rbx), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0xbbb6
movq 0x68(%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 0x112f4(%rip), %rsi     # 0x1ced9
leaq 0x11310(%rip), %rdx     # 0x1cefc
leaq 0x8(%rsp), %rdi
callq 0x127a8
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 0xbc25
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xbc32
movq %rcx, 0x20(%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%r14)
movq 0x40(%rsp), %rdx
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 %rdx, 0x68(%r14)
leaq 0x19faa(%rip), %rsi     # 0x25c20
leaq 0xae4b(%rip), %rdx      # 0x16ac8
movq %r14, %rdi
callq 0x4620
jmp 0xc138
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1116b(%rip), %rsi     # 0x1ce12
leaq 0x1118b(%rip), %rdx     # 0x1ce39
leaq 0x8(%rsp), %rdi
callq 0x127a8
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 0xbe7e
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xbe8b
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x111ce(%rip), %rsi     # 0x1ced9
leaq 0x111ea(%rip), %rdx     # 0x1cefc
leaq 0x8(%rsp), %rdi
callq 0x127a8
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 0xbee3
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xbef0
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x110cb(%rip), %rsi     # 0x1ce3a
leaq 0x110ec(%rip), %rdx     # 0x1ce62
leaq 0x8(%rsp), %rdi
callq 0x127a8
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 0xbf48
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xbf55
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x110b8(%rip), %rsi     # 0x1ce8b
leaq 0x110d7(%rip), %rdx     # 0x1ceb1
leaq 0x8(%rsp), %rdi
callq 0x127a8
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 0xc011
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xc01e
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1107b(%rip), %rsi     # 0x1ceb2
leaq 0x1109a(%rip), %rdx     # 0x1ced8
leaq 0x8(%rsp), %rdi
callq 0x127a8
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
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 0x19d51(%rip), %rsi     # 0x25c20
leaq 0xabf2(%rip), %rdx      # 0x16ac8
movq %r14, %rdi
callq 0x4620
jmp 0xc138
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 0x19cec(%rip), %rsi     # 0x25c20
leaq 0xab8d(%rip), %rdx      # 0x16ac8
movq %r14, %rdi
callq 0x4620
jmp 0xc138
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 0x19c87(%rip), %rsi     # 0x25c20
leaq 0xab28(%rip), %rdx      # 0x16ac8
movq %r14, %rdi
callq 0x4620
jmp 0xc138
movl $0x70, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10e99(%rip), %rsi     # 0x1ce63
leaq 0x10eb9(%rip), %rdx     # 0x1ce8a
leaq 0x8(%rsp), %rdi
callq 0x127a8
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 0xc0d8
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0xc0e5
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 0x19bbe(%rip), %rsi     # 0x25c20
leaq 0xaa5f(%rip), %rdx      # 0x16ac8
movq %r14, %rdi
callq 0x4620
jmp 0xc138
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 0xa9fa(%rip), %rdx      # 0x16ac8
movq %r14, %rdi
callq 0x4620
jmp 0xc138
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 0x19af7(%rip), %rsi     # 0x25c20
leaq 0xa998(%rip), %rdx      # 0x16ac8
movq %r14, %rdi
callq 0x4620
movl $0x10, %edi
callq 0x41c0
movq %rax, %r14
leaq 0x10cb6(%rip), %rsi     # 0x1ce02
movq %rax, %rdi
callq 0x4430
movq 0x19e55(%rip), %rsi     # 0x25fb0
movq 0x19e0e(%rip), %rdx     # 0x25f70
movq %r14, %rdi
callq 0x4620
movq %rax, %rbx
movq %r14, %rdi
callq 0x42d0
jmp 0xc218
jmp 0xc1cb
jmp 0xc19a
jmp 0xc1b8
jmp 0xc19a
jmp 0xc1b8
jmp 0xc19a
jmp 0xc1b8
jmp 0xc19a
jmp 0xc1b8
jmp 0xc1d4
jmp 0xc1d4
jmp 0xc19a
jmp 0xc1b8
jmp 0xc19a
jmp 0xc1b8
jmp 0xc1d4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xc1b4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x43a0
xorl %eax, %eax
jmp 0xc1bd
movq %rax, %rbx
movb $0x1, %al
testb %al, %al
je 0xc1d7
movq %r14, %rdi
callq 0x42d0
jmp 0xc1d7
movq %rax, %rbx
jmp 0xc1fc
jmp 0xc1d4
jmp 0xc1d4
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0xc1fc
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x43a0
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0xc218
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x43a0
movq %rbx, %rdi
callq 0x4630
jmp 0xc224
jmp 0xc224
movq %rax, %rdi
callq 0xfd03