LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::newmacro(char const*, int, int)
void newmacro(const char *s, int len, int hasspecs) {
            if (nmacros == nalloced) {
                nalloced = 2 * nalloced + 1;
                macros = XX realloc(macros, nalloced * sizeof *macros);
                if (macros == nullptr )
                    bug("out of memory");
            }
            macros[nmacros].username = XX malloc(len + 1);
            strncpy(macros[nmacros].username, s, len + 1);
            macros[nmacros].username[len] = 0;
            macros[nmacros].argnames = nullptr;
            macros[nmacros].nnamedargs = 0;
            macros[nmacros].defined_in_comment = 0;
            if (hasspecs)
                macros[nmacros].define_specs = clone_specs(S);
            else
                macros[nmacros].define_specs = nullptr;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r13d
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
cmpl 0x14(%rdi), %r15d
movq %rsi, (%rsp)
jne 0x66cc
movslq %r15d, %rax
leaq 0x1(,%rax,2), %rax
movl %eax, 0x14(%rbx)
movq 0x8(%rbx), %rdi
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
callq 0x2230
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x674c
movq %rax, %r12
movl 0x10(%rbx), %r15d
jmp 0x66d0
movq 0x8(%rbx), %r12
leal 0x1(%r13), %eax
movq %r13, %r14
movslq %eax, %r13
movq %r13, %rdi
callq 0x2190
movq %rax, %rbp
movslq %r15d, %rax
leaq (%rax,%rax,2), %r15
shlq $0x4, %r15
movq %rbp, (%r12,%r15)
movq %rbp, %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0x20a0
movslq %r14d, %rax
movb $0x0, (%rbp,%rax)
movq $0x0, 0x10(%r12,%r15)
xorl %eax, %eax
movl %eax, 0x1c(%r12,%r15)
movl %eax, 0x28(%r12,%r15)
movq (%rbx), %rdi
callq 0x6bc2
movq 0x8(%rbx), %rcx
movslq 0x10(%rbx), %rdx
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
movq %rax, 0x20(%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f1f(%rip), %rdi      # 0x8672
callq 0x2fa0
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::remove_comments(int, int, int)
char *remove_comments(int start, int end, int cmtmode) {
            char *s, *t;

            t = s = XX malloc(end - start + 1);
            while (start < end) {
                skip_possible_comments(&start, cmtmode, 1);
                if (start < end) {
                    *t = get_char(start++);
                    if ((*t == S->user.quotechar) && (start < end)) {
                        *(++t) = get_char(start++);
                    }
                    t++;
                }
            }
            *t = 0;
            return s;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
movl %esi, 0x4(%rsp)
movl %edx, %eax
subl %esi, %eax
incl %eax
movslq %eax, %rdi
callq 0x2190
movq %rax, %r15
movq %rax, %r13
cmpl %r12d, %ebp
jle 0x67fa
leaq 0x4(%rsp), %r12
movq %r15, %r13
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x6f00
movl 0x4(%rsp), %esi
cmpl %ebp, %esi
jge 0x67f6
leal 0x1(%rsi), %eax
movl %eax, 0x4(%rsp)
movq %r14, %rdi
callq 0x60f8
movb %al, (%r13)
movq (%r14), %rcx
cmpb 0x30(%rcx), %al
sete %al
movl 0x4(%rsp), %esi
cmpl %ebp, %esi
setl %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x67f3
movl %esi, %eax
incl %eax
movl %eax, 0x4(%rsp)
movq %r14, %rdi
callq 0x60f8
movb %al, 0x1(%r13)
incq %r13
movl 0x4(%rsp), %esi
incq %r13
cmpl %ebp, %esi
jl 0x6792
movb $0x0, (%r13)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::lookup_arg_refs(int)
void lookup_arg_refs(int n) {
            int i, l;
            char *p;

            if (macros[n].argnames != nullptr )
                return; // don't mess with those
            macros[n].nnamedargs = -1;
            l = strlen(S->user.macro_arg_ref);
            for (i = 0, p = macros[n].macrotext; i < macros[n].macrolen; i++, p++) {
                if ((*p != 0) && (*p == S->user.quotechar)) {
                    i++;
                    p++;
                } else if (!strncmp(p, S->user.macro_arg_ref, l))
                    if ((p[l] >= '1') && (p[l] <= '9')) {
                        macros[n].nnamedargs = 0;
                        return;
                    }
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movslq %edx, %rax
leaq (%rax,%rax,2), %rbp
shlq $0x4, %rbp
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsi,%rbp)
jne 0x68ca
movq 0x8(%rsp), %rcx
leaq (%rcx,%rbp), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movl 0x18(%rcx,%rbp), %ebx
testl %ebx, %ebx
jle 0x68ca
movq 0x10(%rsp), %rax
movq 0x28(%rax), %r15
movq 0x8(%rsp), %rax
movq 0x8(%rax,%rbp), %r12
movq %r15, %rdi
callq 0x2070
movslq %eax, %r13
xorl %r14d, %r14d
movb (%r12), %al
testb %al, %al
je 0x6894
movq 0x10(%rsp), %rcx
cmpb 0x30(%rcx), %al
jne 0x6894
incl %r14d
incq %r12
jmp 0x68b0
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2080
testl %eax, %eax
jne 0x68b0
movb (%r12,%r13), %al
addb $-0x31, %al
cmpb $0x8, %al
jbe 0x68bd
incl %r14d
incq %r12
cmpl %ebx, %r14d
jl 0x687a
jmp 0x68ca
movq 0x8(%rsp), %rax
movl $0x0, 0x1c(%rax,%rbp)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::nowhite_strcmp(char*, char*)
int nowhite_strcmp(char *s, char *t) {
        char *p;

        while (is_white(*s))
            s++;
        while (is_white(*t))
            t++;
        if ((*s == 0) || (*t == 0))
            return strcmp(s, t);
        p = s + strlen(s) - 1;
        while (is_white(*p))
            *(p--) = 0;
        p = t + strlen(t) - 1;
        while (is_white(*p))
            *(p--) = 0;
        return strcmp(s, t);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x100000600, %r15      # imm = 0x100000600
movzbl (%r14), %eax
cmpq $0x20, %rax
ja 0x690c
btq %rax, %r15
jae 0x690c
incq %r14
jmp 0x68ee
btq %rcx, %r15
jae 0x6915
incq %rbx
movzbl (%rbx), %ecx
cmpq $0x20, %rcx
jbe 0x6903
testb %al, %al
sete %al
testb %cl, %cl
sete %cl
orb %al, %cl
je 0x6933
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x21c0
movq %r14, %rdi
callq 0x2070
addq %r14, %rax
decq %rax
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x6958
btq %rcx, %r15
jae 0x6958
movb $0x0, (%rax)
decq %rax
jmp 0x6941
movq %rbx, %rdi
callq 0x2070
addq %rbx, %rax
decq %rax
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x6923
btq %rcx, %r15
jae 0x6923
movb $0x0, (%rax)
decq %rax
jmp 0x6966
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::pop_specs()
void pop_specs() {
            Specs *P;

            P = S;
            S = P->stack_next;
            free_comments(P);
            free(P);
            if (S == nullptr )
                bug("#mode restore without #mode save");
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x98(%r14), %rax
movq %rax, (%rdi)
movq %r14, %rdi
callq 0x6fc0
movq %r14, %rdi
callq 0x2180
cmpq $0x0, (%rbx)
je 0x6bb6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2168(%rip), %rdi      # 0x8d25
callq 0x2fa0
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::clone_specs((anonymous namespace)::Specs const*)
Specs *clone_specs(const Specs *Q) {
        Specs *P;
        Comment *x, *y;

        P = XX malloc(sizeof *P);
        if (P == nullptr )
            bug("out of memory.");
        memcpy(P, Q, sizeof(Specs));
        P->stack_next = nullptr;
        if (Q->comments != nullptr )
            P->comments = XX malloc(sizeof *(P->comments));
        for (x = Q->comments, y = P->comments; x != nullptr ;
                x = x->next, y = y->next) {
            memcpy(y, x, sizeof(Comment));
            y->start = my_strdup(x->start);
            y->end = my_strdup(x->end);
            if (x->next != nullptr )
                y->next = XX malloc(sizeof *(y->next));
        }
        return P;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0xb8, %edi
callq 0x2190
testq %rax, %rax
je 0x6c82
movq %rax, %rbx
movl $0xb8, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
movq $0x0, 0x98(%rbx)
movq 0x90(%r14), %r14
testq %r14, %r14
je 0x6c79
movl $0x28, %edi
callq 0x2190
movq %rbx, %r15
addq $0x90, %r15
movq %rax, 0x90(%rbx)
movq (%r15), %r15
movq 0x20(%r14), %rax
movq %rax, 0x20(%r15)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq (%r14), %rdi
callq 0x2f64
movq %rax, (%r15)
movq 0x8(%r14), %rdi
callq 0x2f64
movq %rax, 0x8(%r15)
cmpq $0x0, 0x20(%r14)
je 0x6c79
movl $0x28, %edi
callq 0x2190
movq %rax, 0x20(%r15)
addq $0x20, %r15
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x6c22
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1e18(%rip), %rdi      # 0x8aa1
callq 0x2fa0
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::skip_possible_comments(int*, int, int)
void skip_possible_comments(int *pos, int cmtmode, int silentonly) {
            int found;
            Comment *c;

            if (C->in_comment)
                return;
            do {
                found = 0;
                if (get_char(*pos) == 0)
                    return; // EOF
                for (c = S->comments; c != nullptr ; c = c->next)
                    if (!(c->flags[cmtmode] & FLAG_IGNORE))
                        if (!silentonly || (c->flags[cmtmode] == FLAG_COMMENT))
                            if (match_start_sequence(c->start, pos)) {
                                *pos = find_comment_end(c->end, c->quote, c->warn, *pos,
                                        c->flags[cmtmode]);
                                match_end_sequence(c->end, pos);
                                found = 1;
                                break;
                            }
            } while (found);
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rax
cmpl $0x0, 0x44(%rax)
je 0x6f24
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %esi
callq 0x60f8
testb %al, %al
je 0x6f15
movl %ebp, %r12d
movq (%r15), %rax
movq 0x90(%rax), %r13
testq %r13, %r13
je 0x6f15
testl %ebx, %ebx
sete %al
movl 0x14(%r13,%r12,4), %edx
testl %edx, %edx
sete %cl
testb $0x40, %dl
jne 0x6f76
orb %cl, %al
je 0x6f76
movq (%r13), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x59ba
testl %eax, %eax
jne 0x6f7c
movq 0x20(%r13), %r13
jmp 0x6f46
movq 0x8(%r13), %rsi
movsbl 0x10(%r13), %edx
movsbl 0x11(%r13), %ecx
movl (%r14), %r8d
movl 0x14(%r13,%r12,4), %r9d
movq %r15, %rdi
callq 0x5b08
movl %eax, (%r14)
movq 0x8(%r13), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x5bdc
movl (%r14), %esi
movq %r15, %rdi
callq 0x60f8
testb %al, %al
jne 0x6f3c
jmp 0x6f15
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::free_comments((anonymous namespace)::Specs*)
void free_comments(Specs *Q) {
        Comment *p;

        while (Q && Q->comments != nullptr ) {
            p = Q->comments;
            Q->comments = p->next;
            free(p->start);
            free(p->end);
            free(p);
        }
    }

// Assembly:
testq %rdi, %rdi
je 0x7005
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x90(%rbx), %r14
testq %r14, %r14
je 0x6ffe
movq 0x20(%r14), %rax
movq %rax, 0x90(%rbx)
movq (%r14), %rdi
callq 0x2180
movq 0x8(%r14), %rdi
callq 0x2180
movq %r14, %rdi
callq 0x2180
jmp 0x6fcc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::splice_infix(char const*, int, int, char const*, int*, int*)
int splice_infix(const char *buf, int pos1, int pos2, char const* sep, int *spl1, int *spl2) {
        int pos, numpar, l;
        const char *p;

        numpar = 0;
        l = strlen(sep);
        for (pos = pos2 - 1, p = buf + pos; pos >= pos1; pos--, p--) {
            if (*p == ')')
                numpar++;
            if (*p == '(')
                numpar--;
            if (numpar < 0)
                return 0;
            if ((numpar == 0) && (pos2 - pos >= l) && !strncmp(p, sep, l)) {
                *spl1 = pos;
                *spl2 = pos + l;
                return 1;
            }
        }
        return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %rbx
movq %rcx, 0x20(%rsp)
movq %rcx, %rdi
callq 0x2070
movq %rax, %rdx
xorl %eax, %eax
cmpl %r13d, %ebp
jle 0x7d4e
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movslq %ebp, %rax
leaq (%rax,%rbx), %r14
decq %r14
movslq %edx, %rax
movq %rax, 0x18(%rsp)
movl $0x1, %r15d
movl $0x1, %ebx
subl %ebp, %ebx
xorl %r12d, %r12d
movl %r13d, 0x4(%rsp)
movb (%r14), %al
xorl %ecx, %ecx
cmpb $0x29, %al
sete %cl
addl %ecx, %r12d
xorl %ecx, %ecx
cmpb $0x28, %al
sete %cl
subl %ecx, %r12d
js 0x7d4c
setne %al
cmpl %edx, %r15d
setl %cl
orb %al, %cl
jne 0x7d3d
movq %r14, %rdi
movq 0x20(%rsp), %rsi
movq %rdx, %r13
movq 0x18(%rsp), %rdx
callq 0x2080
movq %r13, %rdx
movl 0x4(%rsp), %r13d
testl %eax, %eax
je 0x7d5d
decq %r14
incl %ebx
decl %ebp
incl %r15d
cmpl %r13d, %ebp
jg 0x7cf6
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
subl %ebx, %edx
negl %ebx
movq 0x8(%rsp), %rax
movl %ebx, (%rax)
movq 0x10(%rsp), %rax
movl %edx, (%rax)
movl $0x1, %eax
jmp 0x7d4e
// File: /workspace/github_cpp_makefile_star2_O3/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::my_strcasecmp(char const*, char const*)
int my_strcasecmp(const char *s, const char *s2) {
        do {
            char c1 = tolower(*s);
            char c2 = tolower(*s2);
            if (c1 > c2)
                return 1;
            if (c1 < c2)
                return -1;
        } while (*s++ && *s2++);
        return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %r14
xorl %r15d, %r15d
movb (%r14,%r15), %r13b
movsbl %r13b, %edi
callq 0x21f0
movl %eax, %ebp
movq (%rsp), %rax
movb (%rax,%r15), %bl
movsbl %bl, %edi
callq 0x21f0
movsbl %bpl, %ecx
movsbl %al, %eax
cmpl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovll %eax, %r12d
movl $0x1, %eax
cmovgl %eax, %r12d
jne 0x7dd7
xorl %eax, %eax
testb %r13b, %r13b
je 0x7dda
incq %r15
testb %bl, %bl
jne 0x7d8b
jmp 0x7dda
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DivyanshuSaxena[P]green-vrp/Vehicle.cpp
// Function: Vehicle::Vehicle()
Vehicle::Vehicle() {
    // Add depot at both ends of the route
    type = 1;
    currentNodeId = 0;
    Node start;
    start.id = 0;
    start.arrival_time = -1;
    start.departure_time = startTime;
    Node end;
    end.id = 0;
    end.arrival_time = 0;
    end.departure_time = -1;
    this->route.push_back(start);
    this->route.push_back(end);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movl $0x1, (%rdi)
movl %eax, 0x70(%rdi)
leaq 0x18(%rsp), %rdx
movl %eax, (%rdx)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x8(%rdx)
leaq 0x6cfa(%rip), %rsi      # 0x9288
movsd (%rsi), %xmm0
movsd %xmm0, 0x10(%rdx)
movl %eax, (%rsp)
movq %rax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x36e6
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x25cf
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x18, 0x10(%rbx)
jmp 0x25da
movq %rsp, %rdx
movq %r14, %rdi
callq 0x36e6
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x25fb
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x2160
movq %r15, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/DivyanshuSaxena[P]green-vrp/Vehicle.cpp
// Function: Vehicle::feasible(int)
bool Vehicle::feasible(int customerid) {
	bool timingbool=timingCondition(customers.at(customerid));
	bool chargingbool=chargingCondition(customers.at(customerid));
	bool capacitybool=capacityCondition(customers.at(customerid));
	bool feasiblebool= timingbool && chargingbool && capacitybool ;
	return feasiblebool;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movslq %esi, %r14
leaq 0x6bdc(%rip), %r15      # 0x91f8
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %r13 # imm = 0x6DB6DB6DB6DB6DB7
imulq %r13, %rdx
cmpq %r14, %rdx
jbe 0x274f
movq %rdi, %rbx
imulq $0x38, %r14, %r12
movq 0x30(%rax,%r12), %rcx
movq %rcx, 0x30(%rsp)
movups (%rax,%r12), %xmm0
movups 0x10(%rax,%r12), %xmm1
movups 0x20(%rax,%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2760
movl %eax, %ebp
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %r14, %rdx
jbe 0x274f
movq 0x30(%rax,%r12), %rcx
movq %rcx, 0x30(%rsp)
movups (%rax,%r12), %xmm0
movups 0x10(%rax,%r12), %xmm1
movups 0x20(%rax,%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2854
movq (%r15), %rcx
movq 0x8(%r15), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %r14, %rdx
jbe 0x274f
movdqu (%rbx), %xmm0
leaq 0x6b42(%rip), %rdx      # 0x9228
leaq 0x6b43(%rip), %rsi      # 0x9230
movupd 0x8(%rcx,%r12), %xmm1
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pcmpeqd 0x390f(%rip), %xmm0     # 0x6010
movq (%rdx), %xmm2
punpcklqdq %xmm2, %xmm2    # xmm2 = xmm2[0,0]
movq (%rsi), %xmm3
punpcklqdq %xmm3, %xmm3    # xmm3 = xmm3[0,0]
pand %xmm0, %xmm2
pandn %xmm3, %xmm0
por %xmm2, %xmm0
movupd 0x40(%rbx), %xmm2
addpd %xmm1, %xmm2
cmplepd %xmm0, %xmm2
movmskpd %xmm2, %ecx
andb %al, %bpl
andb %cl, %bpl
movl %ecx, %eax
andb $0x2, %al
shrb %al
andb %al, %bpl
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38ee(%rip), %rdi      # 0x6044
movq %r14, %rsi
xorl %eax, %eax
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/DivyanshuSaxena[P]green-vrp/Vehicle.cpp
// Function: Vehicle::timingCondition(Customer)
bool Vehicle::timingCondition(Customer customer) {
    time_type currDeptTime = this->route.at(this->route.size()-2).departure_time;
    time_type expectedTime = travelTimes.at(this->currentNodeId).at(customer.id) + currDeptTime;
    time_type timeToEnd = travelTimes.at(0).at(customer.id);
    this->route.back().arrival_time = expectedTime + serviceTime + timeToEnd;
    return (expectedTime < customer.timeWindowEnds && this->route.back().arrival_time < endTime);
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %rcx
movq %rcx, %rdx
subq %r8, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %r10 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r10, %rdx
leaq -0x2(%rdx), %rsi
cmpq $0x1, %rdx
jbe 0x2846
movslq 0x70(%rdi), %rax
leaq 0x6a2e(%rip), %rdx      # 0x91c8
movq (%rdx), %r9
movq 0x8(%rdx), %rdx
subq %r9, %rdx
sarq $0x3, %rdx
imulq %r10, %rdx
cmpq %rax, %rdx
jbe 0x283a
leaq 0x10(%rsp), %rdi
leaq (%rax,%rax,2), %rdx
movslq (%rdi), %rax
movq (%r9,%rdx,8), %r10
movq 0x8(%r9,%rdx,8), %rdx
subq %r10, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x283a
movq (%r9), %r11
movq 0x8(%r9), %rdx
subq %r11, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x283a
leaq (%rsi,%rsi,2), %rdx
movsd 0x10(%r8,%rdx,8), %xmm0
addsd (%r10,%rax,8), %xmm0
leaq 0x695f(%rip), %rdx      # 0x9160
movsd (%rdx), %xmm1
addsd %xmm0, %xmm1
addsd (%r11,%rax,8), %xmm1
movsd %xmm1, -0x10(%rcx)
leaq 0x6a75(%rip), %rax      # 0x9290
movsd (%rax), %xmm2
movsd 0x30(%rdi), %xmm3
cmpltpd %xmm3, %xmm0
cmpltpd %xmm2, %xmm1
andpd %xmm0, %xmm1
movd %xmm1, %eax
andb $0x1, %al
popq %rcx
retq
leaq 0x3803(%rip), %rdi      # 0x6044
movq %rax, %rsi
jmp 0x284d
leaq 0x37f7(%rip), %rdi      # 0x6044
xorl %eax, %eax
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/DivyanshuSaxena[P]green-vrp/Vehicle.cpp
// Function: Vehicle::chargingCondition(Customer)
bool Vehicle::chargingCondition(Customer customer) {
    // Distance till Depot check must be thought of
    // Find the nearest charging station to the customer
    double distance = travelCosts.at(this->currentNodeId).at(customer.id) + travelCosts.at(0).at(customer.id) - travelCosts.at(this->currentNodeId).at(0);
    return (this->distanceRemaining > distance);
}

// Assembly:
pushq %rax
movslq 0x70(%rdi), %rsi
leaq 0x6938(%rip), %rcx      # 0x9198
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x28d2
leaq 0x10(%rsp), %rcx
leaq (%rsi,%rsi,2), %rdx
movslq (%rcx), %rsi
movq (%rax,%rdx,8), %rcx
movq 0x8(%rax,%rdx,8), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x28d2
movq (%rax), %r8
movq 0x8(%rax), %rdx
subq %r8, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x28d2
movsd (%rcx,%rsi,8), %xmm0
addsd (%r8,%rsi,8), %xmm0
subsd (%rcx), %xmm0
movsd 0x68(%rdi), %xmm1
ucomisd %xmm0, %xmm1
seta %al
popq %rcx
retq
leaq 0x376b(%rip), %rdi      # 0x6044
xorl %eax, %eax
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/DivyanshuSaxena[P]green-vrp/Vehicle.cpp
// Function: Vehicle::capacityCondition(Customer)
bool Vehicle::capacityCondition(Customer customer) {
    double volumeCap = this->type==1 ? capVolType1 : capVolType2;
    double weightCap = this->type==2 ? capVolType1 : capVolType2;
    bool volume = (this->currentCapVol + customer.demandVol) <= volumeCap;
    bool weight = (this->currentCapWeight + customer.demandWeight) <= weightCap;
    return (volume && weight);
}

// Assembly:
movdqu (%rdi), %xmm0
leaq 0x693d(%rip), %rax      # 0x9228
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pcmpeqd 0x3718(%rip), %xmm0     # 0x6010
leaq 0x6931(%rip), %rcx      # 0x9230
movq (%rax), %xmm1
punpcklqdq %xmm1, %xmm1    # xmm1 = xmm1[0,0]
movq (%rcx), %xmm2
punpcklqdq %xmm2, %xmm2    # xmm2 = xmm2[0,0]
pand %xmm0, %xmm1
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movupd 0x40(%rdi), %xmm1
movupd 0x10(%rsp), %xmm2
addpd %xmm1, %xmm2
cmplepd %xmm0, %xmm2
movmskpd %xmm2, %eax
cmpl $0x3, %eax
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/DivyanshuSaxena[P]green-vrp/Vehicle.cpp
// Function: Vehicle::costAddCustomerCS(Customer, int)
double Vehicle::costAddCustomerCS(Customer customer, int chargingStation) {
    double costNodeCS = travelCosts.at(this->currentNodeId).at(chargingStation);
    double costCustomerCS = travelCosts.at(customer.id).at(chargingStation);
    double endCost = travelCosts.at(customer.id).at(0);
    double additionCost = costNodeCS + costCustomerCS + endCost - travelCosts.at(this->currentNodeId).at(0);
    return additionCost;
}

// Assembly:
pushq %rax
movl %esi, %eax
movslq 0x70(%rdi), %rsi
leaq 0x6822(%rip), %rdx      # 0x9198
movq (%rdx), %rcx
movq 0x8(%rdx), %rdi
subq %rcx, %rdi
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rdx
cmpq %rsi, %rdx
jbe 0x29ed
leaq (%rsi,%rsi,2), %r8
movslq %eax, %rsi
movq (%rcx,%r8,8), %rdi
movq 0x8(%rcx,%r8,8), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rsi, %rax
jbe 0x29f6
leaq 0x10(%rsp), %rax
movslq (%rax), %rax
cmpq %rax, %rdx
jbe 0x2a02
leaq (%rax,%rax,2), %rdx
movq (%rcx,%rdx,8), %rax
movq 0x8(%rcx,%rdx,8), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x29ed
movsd (%rdi,%rsi,8), %xmm0
addsd (%rax,%rsi,8), %xmm0
addsd (%rax), %xmm0
subsd (%rdi), %xmm0
popq %rax
retq
leaq 0x3650(%rip), %rdi      # 0x6044
jmp 0x2a0c
leaq 0x3647(%rip), %rdi      # 0x6044
movq %rax, %rdx
jmp 0x2a0c
leaq 0x363b(%rip), %rdi      # 0x6044
movq %rax, %rsi
xorl %eax, %eax
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/DivyanshuSaxena[P]green-vrp/./Classes.h
// Function: Customer::findNearestCS()
int findNearestCS() {
		double minCost = -1;
		int nearestCS = -1;
		for(int id = csStartId; id <= csEndId; id++) {
			double cost = travelCosts.at(id).at(this->id);
			if ((minCost > cost) || nearestCS == -1) {
				nearestCS = id;
				minCost = cost;
			} 
		}
		return nearestCS;
	}

// Assembly:
pushq %rax
leaq 0x5b7a(%rip), %rax      # 0x9184
movslq (%rax), %rsi
leaq 0x5b74(%rip), %rax      # 0x9188
movl (%rax), %r8d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %r8d, %esi
jg 0x36bf
leaq 0x5b6c(%rip), %rax      # 0x9198
movq (%rax), %r9
movq 0x8(%rax), %rax
subq %r9, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
movslq (%rdi), %rcx
incl %r8d
leaq (%rsi,%rsi,2), %rax
leaq (%r9,%rax,8), %rdi
addq $0x8, %rdi
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movsd 0x29c0(%rip), %xmm0     # 0x6028
movq %rsi, %r9
cmpq %r9, %rdx
jbe 0x36d0
movq -0x8(%rdi), %r11
movq (%rdi), %rax
subq %r11, %rax
sarq $0x3, %rax
cmpq %rcx, %rax
jbe 0x36c1
movsd (%r11,%rcx,8), %xmm1
ucomisd %xmm1, %xmm0
seta %al
cmpl $-0x1, %r10d
sete %r11b
orb %al, %r11b
movl %r9d, %eax
testb %r11b, %r11b
jne 0x36a6
movl %r10d, %eax
jne 0x36ac
movapd %xmm0, %xmm1
incq %r9
addq $0x18, %rdi
movapd %xmm1, %xmm0
movl %eax, %r10d
cmpl %r9d, %r8d
jne 0x366b
popq %rcx
retq
leaq 0x297c(%rip), %rdi      # 0x6044
movq %rcx, %rsi
movq %rax, %rdx
jmp 0x36de
cmpq %rsi, %rdx
cmovaq %rdx, %rsi
leaq 0x2966(%rip), %rdi      # 0x6044
xorl %eax, %eax
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/DivyanshuSaxena[P]green-vrp/Main.cpp
// Function: checknewCustomerCost(int, int)
double checknewCustomerCost(int id1,int id2){
	double waitingcostid12,travellingcostid12; //id1--id2
    double factor = vehicles.at(currentvehicle).type == 1? unitTransCost1 : unitTransCost2;	
	travellingcostid12=travelDistance[id1][id2] * factor;

	time_type currDeptTime = vehicles.at(currentvehicle).route.at(vehicles.at(currentvehicle).route.size()-2).departure_time;
	if((travelTimes.at(id1).at(id2) + currDeptTime) < customers.at(id2).timeWindowStarts){
		waitingcostid12=(customers.at(id2).timeWindowStarts - (travelTimes.at(id1).at(id2) + currDeptTime)) * 24; //no varible here just value check agan
	}
	else{
		waitingcostid12= 0; 	
	}

	double totalcostid12=waitingcostid12+travellingcostid12;
	return totalcostid12;
}

// Assembly:
pushq %rbx
movl %esi, %eax
movslq 0x3e95(%rip), %rsi      # 0x92c0
movq 0x3de6(%rip), %rcx      # 0x9218
movq 0x3dd7(%rip), %r8       # 0x9210
subq %r8, %rcx
sarq $0x3, %rcx
movabsq $-0x1111111111111111, %rdx # imm = 0xEEEEEEEEEEEEEEEF
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x555b
imulq $0x78, %rsi, %r9
movq 0x10(%r8,%r9), %rdx
movq 0x8(%r8,%r9), %r10
subq %r10, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %r11 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r11, %rdx
leaq -0x2(%rdx), %rsi
cmpq $0x1, %rdx
jbe 0x555b
movslq %edi, %rcx
movq 0x3d3e(%rip), %rdx      # 0x91d0
movq 0x3d2f(%rip), %rbx      # 0x91c8
subq %rbx, %rdx
sarq $0x3, %rdx
imulq %r11, %rdx
cmpq %rcx, %rdx
jbe 0x5570
leaq (%rcx,%rcx,2), %rdi
cltq
movq (%rbx,%rdi,8), %rcx
movq 0x8(%rbx,%rdi,8), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x5564
movq 0x3d2d(%rip), %rbx      # 0x9200
movq 0x3d1e(%rip), %r11      # 0x91f8
subq %r11, %rbx
sarq $0x3, %rbx
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rbx, %rdx
cmpq %rax, %rdx
jbe 0x5564
movq 0x3cb5(%rip), %rdx      # 0x91b0
movq (%rdx,%rdi,8), %rdx
movsd (%rdx,%rax,8), %xmm1
leaq (%rsi,%rsi,2), %rdx
movsd 0x10(%r10,%rdx,8), %xmm2
addsd (%rcx,%rax,8), %xmm2
imulq $0x38, %rax, %rax
movsd 0x28(%r11,%rax), %xmm0
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
mulsd 0xb81(%rip), %xmm3      # 0x60b0
cmpltsd %xmm0, %xmm2
andpd %xmm3, %xmm2
cmpl $0x1, (%r8,%r9)
je 0x5549
movsd 0x3d29(%rip), %xmm0     # 0x9270
jmp 0x5551
movsd 0x3d17(%rip), %xmm0     # 0x9268
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
popq %rbx
retq
leaq 0xae2(%rip), %rdi       # 0x6044
jmp 0x557a
leaq 0xad9(%rip), %rdi       # 0x6044
movq %rax, %rsi
jmp 0x557a
leaq 0xacd(%rip), %rdi       # 0x6044
movq %rcx, %rsi
xorl %eax, %eax
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: bool pugi::impl::(anonymous namespace)::set_value_integer<char*, unsigned long, int>(char*&, unsigned long&, unsigned long, int)
PUGI__FN char_t* integer_to_string(char_t* begin, char_t* end, T value)
	{
		typedef typename make_unsigned<T>::type U;

		bool negative = value < 0;

		char_t* result = end - 1;
		U rest = negative ? 0 - U(value) : U(value);

		do
		{
			*result-- = static_cast<char_t>('0' + (rest % 10));
			rest /= 10;
		}
		while (rest);

		assert(result >= begin);
		(void)begin;

		*result = '-';

		return result + !negative;
	}

// Assembly:
pushq %rbx
subq $0x40, %rsp
leaq 0x3f(%rsp), %rcx
movl %edx, %eax
negl %eax
cmovsl %edx, %eax
movl $0x1, %r8d
movl $0xcccccccd, %r9d       # imm = 0xCCCCCCCD
movl %eax, %r10d
imulq %r9, %r10
shrq $0x23, %r10
leal (%r10,%r10), %r11d
leal (%r11,%r11,4), %r11d
movl %eax, %ebx
subl %r11d, %ebx
orb $0x30, %bl
movb %bl, (%rcx)
decq %rcx
incq %r8
cmpl $0x9, %eax
movl %r10d, %eax
ja 0x67e3
movq %rsp, %rax
cmpq %rax, %rcx
jb 0x6836
xorl %eax, %eax
testl %edx, %edx
setns %al
movb $0x2d, (%rcx)
addq %rax, %rcx
subq %rax, %r8
movl $0x10, %edx
callq 0x655a
addq $0x40, %rsp
popq %rbx
retq
leaq 0x2920e(%rip), %rdi     # 0x2fa4b
leaq 0x25fb1(%rip), %rsi     # 0x2c7f5
leaq 0x29210(%rip), %rcx     # 0x2fa5b
movl $0x11fa, %edx           # imm = 0x11FA
callq 0x4270
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: bool pugi::impl::(anonymous namespace)::set_value_integer<char*, unsigned long, long>(char*&, unsigned long&, unsigned long, long)
PUGI__FN bool set_value_integer(String& dest, Header& header, uintptr_t header_mask, Integer value)
	{
		char_t buf[64];
		char_t* end = buf + sizeof(buf) / sizeof(buf[0]);
		char_t* begin = integer_to_string(buf, end, value);

		return strcpy_insitu(dest, header, header_mask, begin, end - begin);
	}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r9
leaq 0x3f(%rsp), %rcx
movq %rdx, %r10
negq %r10
cmovsq %rdx, %r10
movl $0x1, %r8d
movabsq $-0x3333333333333333, %r11 # imm = 0xCCCCCCCCCCCCCCCD
movq %r10, %rax
mulq %r11
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %r10d, %ebx
subl %eax, %ebx
orb $0x30, %bl
movb %bl, (%rcx)
decq %rcx
incq %r8
cmpq $0x9, %r10
movq %rdx, %r10
ja 0x68fb
movq %rsp, %rax
cmpq %rax, %rcx
jb 0x694c
movb $0x2d, (%rcx)
notq %r9
shrq $0x3f, %r9
addq %r9, %rcx
subq %r9, %r8
movl $0x10, %edx
callq 0x655a
addq $0x40, %rsp
popq %rbx
retq
leaq 0x290f8(%rip), %rdi     # 0x2fa4b
leaq 0x25e9b(%rip), %rsi     # 0x2c7f5
leaq 0x291bf(%rip), %rcx     # 0x2fb20
movl $0x11fa, %edx           # imm = 0x11FA
callq 0x4270
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xml_node::append_buffer(void const*, unsigned long, unsigned int, pugi::xml_encoding)
PUGI__FN xml_parse_result xml_node::append_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding)
	{
		// append_buffer is only valid for elements/documents
		if (!impl::allow_insert_child(type(), node_element)) return impl::make_parse_result(status_append_invalid_root);

		// get document node
		impl::xml_document_struct* doc = &impl::get_document(_root);

		// disable document_buffer_order optimization since in a document with multiple buffers comparing buffer pointers does not make sense
		doc->header |= impl::xml_memory_page_contents_shared_mask;

		// get extra buffer element (we'll store the document fragment buffer there so that we can deallocate it later)
		impl::xml_memory_page* page = 0;
		impl::xml_extra_buffer* extra = static_cast<impl::xml_extra_buffer*>(doc->allocate_memory(sizeof(impl::xml_extra_buffer), page));
		(void)page;

		if (!extra) return impl::make_parse_result(status_out_of_memory);

		// add extra buffer to the list
		extra->buffer = 0;
		extra->next = doc->extra_buffers;
		doc->extra_buffers = extra;

		// name of the root has to be NULL before parsing - otherwise closing node mismatches will not be detected at the top level
		impl::name_null_sentry sentry(_root);

		return impl::load_buffer_impl(doc, _root, const_cast<void*>(contents), size, options, encoding, false, false, &extra->buffer);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
je 0x8c32
movq %rcx, %r12
movq (%r15), %rax
movl %eax, %ecx
andl $0xf, %ecx
addl $-0x3, %ecx
cmpl $-0x3, %ecx
ja 0x8c49
movl $0x0, 0x10(%rbx)
movl $0xf, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x8cc2
movl %r9d, %r11d
movl %r8d, %r9d
movq %rdx, %r13
shrq $0x8, %rax
movq %r15, %rcx
subq %rax, %rcx
movq (%rcx), %rbp
orq $0x40, -0x40(%rbp)
movq 0x8(%rbp), %rax
leaq 0x10(%rax), %rcx
cmpq $0x7fd8, %rcx           # imm = 0x7FD8
ja 0x8cd4
movq (%rbp), %rdx
addq %rdx, %rax
addq $0x28, %rax
movq %rcx, 0x8(%rbp)
leaq -0x40(%rbp), %rsi
xorl %r10d, %r10d
movq %r10, (%rax)
movq 0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x18(%rbp)
movq 0x8(%r15), %r14
movq %r10, 0x8(%r15)
movq %rbx, %rdi
movq %r15, %rdx
movq %r13, %rcx
movq %r12, %r8
pushq %rax
pushq %r10
pushq %r10
pushq %r11
callq 0x8d28
addq $0x20, %rsp
movq %r14, 0x8(%r15)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movl %r9d, 0x4(%rsp)
movq %r11, 0x8(%rsp)
leaq 0x10(%rsp), %rdx
movl $0x10, %esi
movq %rbp, %rdi
callq 0x107ee
testq %rax, %rax
je 0x8d0a
movq (%r14), %r15
movq 0x8(%rsp), %r11
movl 0x4(%rsp), %r9d
jmp 0x8c84
movl $0x0, 0x10(%rbx)
movl $0x3, (%rbx)
jmp 0x8c3f
movq %r14, 0x8(%r15)
movq %rax, %rdi
callq 0x4700
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xml_node::traverse(pugi::xml_tree_walker&)
PUGI__FN bool xml_node::traverse(xml_tree_walker& walker)
	{
		walker._depth = -1;

		xml_node arg_begin = *this;
		if (!walker.begin(arg_begin)) return false;

		xml_node cur = first_child();

		if (cur)
		{
			++walker._depth;

			do
			{
				xml_node arg_for_each = cur;
				if (!walker.for_each(arg_for_each))
					return false;

				if (cur.first_child())
				{
					++walker._depth;
					cur = cur.first_child();
				}
				else if (cur.next_sibling())
					cur = cur.next_sibling();
				else
				{
					// Borland C++ workaround
					while (!cur.next_sibling() && cur != *this && !cur.parent().empty())
					{
						--walker._depth;
						cur = cur.parent();
					}

					if (cur != *this)
						cur = cur.next_sibling();
				}
			}
			while (cur && cur != *this);
		}

		assert(walker._depth == -1);

		xml_node arg_end = *this;
		return walker.end(arg_end);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffffff, 0x8(%rsi)  # imm = 0xFFFFFFFF
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xaa2d
movq (%r14), %rax
testq %rax, %rax
je 0xaa31
movq 0x20(%rax), %r12
testq %r12, %r12
je 0xaa31
incl 0x8(%rbx)
leaq 0x8(%rsp), %r15
movq %r12, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x18(%rax)
testb %al, %al
je 0xaa2d
movq 0x20(%r12), %rcx
testq %rcx, %rcx
je 0xa9bb
incl 0x8(%rbx)
jmp 0xa9c5
movq 0x30(%r12), %rcx
testq %rcx, %rcx
je 0xa9d7
movq (%r14), %rax
movq %rcx, %r12
testq %r12, %r12
je 0xaa31
cmpq %rax, %r12
jne 0xa993
jmp 0xaa31
cmpq $0x0, 0x30(%r12)
sete %cl
movq (%r14), %rax
cmpq %rax, %r12
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xaa15
movq %r12, %rcx
movq 0x18(%r12), %r12
testq %r12, %r12
je 0xaa18
decl 0x8(%rbx)
cmpq $0x0, 0x30(%r12)
movq (%r14), %rax
jne 0xaa15
movq %r12, %rcx
cmpq %rax, %r12
jne 0xa9f0
jmp 0xaa18
movq %r12, %rcx
movl $0x0, %r12d
cmpq %rax, %rcx
cmoveq %rcx, %r12
je 0xa9cb
movq 0x30(%rcx), %r12
jmp 0xa9cb
xorl %eax, %eax
jmp 0xaa48
cmpl $-0x1, 0x8(%rbx)
jne 0xaa54
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x21eca(%rip), %rdi     # 0x2c925
leaq 0x21d93(%rip), %rsi     # 0x2c7f5
leaq 0x21ed0(%rip), %rcx     # 0x2c939
movl $0x1856, %edx           # imm = 0x1856
callq 0x4270
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xml_node::offset_debug() const
PUGI__FN ptrdiff_t xml_node::offset_debug() const
	{
		if (!_root) return -1;

		impl::xml_document_struct& doc = impl::get_document(_root);

		// we can determine the offset reliably only if there is exactly once parse buffer
		if (!doc.buffer || doc.extra_buffers) return -1;

		switch (type())
		{
		case node_document:
			return 0;

		case node_element:
		case node_declaration:
		case node_pi:
			return _root->name && (_root->header & impl::xml_memory_page_name_allocated_or_shared_mask) == 0 ? _root->name - doc.buffer : -1;

		case node_pcdata:
		case node_cdata:
		case node_comment:
		case node_doctype:
			return _root->value && (_root->header & impl::xml_memory_page_value_allocated_or_shared_mask) == 0 ? _root->value - doc.buffer : -1;

		default:
			return -1;
		}
	}

// Assembly:
movq (%rdi), %rsi
movq $-0x1, %rax
testq %rsi, %rsi
je 0xafc0
movq (%rsi), %rdx
movq %rdx, %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rsi,%rcx), %rdi
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0xafc0
cmpq $0x0, 0x18(%rdi)
jne 0xafc0
movl %edx, %edi
andl $0xf, %edi
cmpl $0x8, %edi
ja 0xafc0
movl $0x138, %r8d            # imm = 0x138
btl %edi, %r8d
jb 0xafa4
movl $0xc4, %r8d
btl %edi, %r8d
jae 0xafc1
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
sete %dil
testb $0x60, %dl
jmp 0xafb2
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
sete %dil
testb $0x50, %dl
setne %dl
orb %dil, %dl
jne 0xafc0
subq %rcx, %rsi
movq %rsi, %rax
retq
cmpl $0x1, %edi
jne 0xafc0
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_node_set::operator=(pugi::xpath_node_set&&)
PUGI__FN xpath_node_set& xpath_node_set::operator=(xpath_node_set&& rhs)
	{
		if (this == &rhs) return *this;

		if (_begin != &_storage)
			impl::xml_memory::deallocate(_begin);

		_move(rhs);

		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xd336
movq %rsi, %r14
movq 0x18(%rbx), %rdi
leaq 0x8(%rbx), %r15
cmpq %r15, %rdi
je 0xd2f7
callq *0x320e9(%rip)          # 0x3f3e0
movl (%r14), %eax
movl %eax, (%rbx)
leaq 0x8(%r14), %rax
movups 0x8(%r14), %xmm0
movups %xmm0, (%r15)
movq 0x18(%r14), %rcx
cmpq %rax, %rcx
cmoveq %r15, %rcx
movq %rcx, 0x18(%rbx)
movq 0x20(%r14), %rdx
subq 0x18(%r14), %rdx
addq %rcx, %rdx
movq %rdx, 0x20(%rbx)
movl $0x0, (%r14)
movq %rax, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_variable_set::_destroy(pugi::xpath_variable*)
PUGI__FN void xpath_variable_set::_destroy(xpath_variable* var)
	{
		while (var)
		{
			xpath_variable* next = var->_next;

			impl::delete_xpath_variable(var->_type, var);

			var = next;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd74b
movq %rdi, %rbx
leaq 0x1e980(%rip), %r15     # 0x2c080
movl (%rbx), %eax
decl %eax
cmpl $0x3, %eax
ja 0xd751
movq %rbx, %r14
movq 0x8(%rbx), %rbx
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x28(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0xd73d
callq *0x31cb4(%rip)          # 0x3f3e0
jmp 0xd73d
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xd73d
callq *0x31ca3(%rip)          # 0x3f3e0
movq %r14, %rdi
callq *0x31c9a(%rip)          # 0x3f3e0
testq %rbx, %rbx
jne 0xd700
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1f925(%rip), %rdi     # 0x2d07d
leaq 0x1f096(%rip), %rsi     # 0x2c7f5
leaq 0x20b88(%rip), %rcx     # 0x2e2ee
movl $0x2183, %edx           # imm = 0x2183
callq 0x4270
jmp 0xd772
movq %rax, %rdi
callq 0x18b87
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_variable_set::_assign(pugi::xpath_variable_set const&)
PUGI__FN void xpath_variable_set::_assign(const xpath_variable_set& rhs)
	{
		xpath_variable_set temp;

		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
			if (rhs._data[i] && !_clone(rhs._data[i], &temp._data[i]))
				return;

		_swap(temp);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
xorl %r15d, %r15d
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x4240
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0xd7dc
leaq (%rsp,%r15), %rsi
callq 0xd89a
testb %al, %al
je 0xd805
addq $0x8, %r15
cmpq $0x200, %r15            # imm = 0x200
jne 0xd7c6
xorl %eax, %eax
movups (%rbx,%rax,8), %xmm0
movups (%rsp,%rax,8), %xmm1
movups %xmm1, (%rbx,%rax,8)
movups %xmm0, (%rsp,%rax,8)
addq $0x2, %rax
cmpq $0x40, %rax
jne 0xd7eb
movq %rsp, %rdi
callq 0xd6c0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd6c0
movq %rbx, %rdi
callq 0x4700
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_variable_set::operator=(pugi::xpath_variable_set&&)
PUGI__FN xpath_variable_set& xpath_variable_set::operator=(xpath_variable_set&& rhs)
	{
		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
		{
			_destroy(_data[i]);

			_data[i] = rhs._data[i];
			rhs._data[i] = 0;
		}

		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0xd6ec
movq (%r14,%r15,8), %rax
movq %rax, (%rbx,%r15,8)
movq $0x0, (%r14,%r15,8)
incq %r15
cmpq $0x40, %r15
jne 0xd86e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_variable_set::_clone(pugi::xpath_variable*, pugi::xpath_variable**)
PUGI__FN bool xpath_variable_set::_clone(xpath_variable* var, xpath_variable** out_result)
	{
		xpath_variable* last = 0;

		while (var)
		{
			// allocate storage for new variable
			xpath_variable* nvar = impl::new_xpath_variable(var->_type, var->name());
			if (!nvar) return false;

			// link the variable to the result immediately to handle failures gracefully
			if (last)
				last->_next = nvar;
			else
				*out_result = nvar;

			last = nvar;

			// copy the value; this can fail due to out-of-memory conditions
			if (!impl::copy_xpath_variable(nvar, var)) return false;

			var = var->_next;
		}

		return true;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %bl
testq %rdi, %rdi
je 0xd953
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
leaq 0x1e7d1(%rip), %r13     # 0x2c090
movq %rbp, %r12
movl (%r15), %ebp
movq %r15, %rdi
callq 0xd56c
movl %ebp, %edi
movq %rax, %rsi
callq 0xda14
testq %rax, %rax
je 0xd951
movq %rax, %rbp
leaq 0x8(%r12), %rax
testq %r12, %r12
cmoveq %r14, %rax
movq %rbp, (%rax)
movl (%r15), %eax
decl %eax
cmpl $0x3, %eax
ja 0xd964
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
leaq 0x10(%r15), %rsi
movq %rbp, %rdi
callq 0xd688
jmp 0xd91c
movq 0x10(%r15), %rsi
movq %rbp, %rdi
callq 0xd620
testb %al, %al
jne 0xd942
jmp 0xd951
cmpl $0x4, (%rbp)
jne 0xd951
movb 0x10(%r15), %al
movb %al, 0x10(%rbp)
jmp 0xd942
cmpl $0x2, (%rbp)
jne 0xd951
movsd 0x10(%r15), %xmm0
movsd %xmm0, 0x10(%rbp)
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xd8bf
jmp 0xd953
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f712(%rip), %rdi     # 0x2d07d
leaq 0x1ee83(%rip), %rsi     # 0x2c7f5
leaq 0x2090f(%rip), %rcx     # 0x2e288
movl $0x2198, %edx           # imm = 0x2198
callq 0x4270
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_variable_set::_swap(pugi::xpath_variable_set&)
PUGI__FN void xpath_variable_set::_swap(xpath_variable_set& rhs)
	{
		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
		{
			xpath_variable* chain = _data[i];

			_data[i] = rhs._data[i];
			rhs._data[i] = chain;
		}
	}

// Assembly:
xorl %eax, %eax
movq (%rdi,%rax,8), %rcx
movq (%rsi,%rax,8), %rdx
movq %rdx, (%rdi,%rax,8)
movq %rcx, (%rsi,%rax,8)
incq %rax
cmpq $0x40, %rax
jne 0xd986
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_variable_set::_find(char const*) const
PUGI__FN xpath_variable* xpath_variable_set::_find(const char_t* name) const
	{
		const size_t hash_size = sizeof(_data) / sizeof(_data[0]);
		size_t hash = impl::hash_string(name) % hash_size;

		// look for existing variable
		for (xpath_variable* var = _data[hash]; var; var = var->_next)
			if (impl::strequal(var->name(), name))
				return var;

		return 0;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb (%rsi), %dl
testb %dl, %dl
je 0xd9d4
leaq 0x1(%rbx), %rax
xorl %ecx, %ecx
movsbl %dl, %edx
addl %ecx, %edx
movl %edx, %esi
shll $0xa, %esi
addl %edx, %esi
movl %esi, %ecx
shrl $0x6, %ecx
xorl %esi, %ecx
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0xd9b3
leal (%rcx,%rcx,8), %eax
jmp 0xd9d6
xorl %eax, %eax
movl %eax, %ecx
shrl $0xb, %ecx
xorl %eax, %ecx
andl $0x3f, %ecx
movq (%rdi,%rcx,8), %r14
testq %r14, %r14
je 0xda06
movq %r14, %rdi
callq 0xd56c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6d79
testb %al, %al
jne 0xda09
movq 0x8(%r14), %r14
jmp 0xd9e4
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_query::operator=(pugi::xpath_query&&)
PUGI__FN xpath_query& xpath_query::operator=(xpath_query&& rhs)
	{
		if (this == &rhs) return *this;

		if (_impl)
			impl::xpath_query_impl::destroy(static_cast<impl::xpath_query_impl*>(_impl));

		_impl = rhs._impl;
		_result = rhs._result;
		rhs._impl = 0;
		rhs._result = xpath_parse_result();

		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xe283
movq %rsi, %r14
movq (%rbx), %r15
testq %r15, %r15
je 0xe260
movq 0x8(%r15), %rdi
callq 0x12a16
movq %r15, %rdi
callq *0x31180(%rip)          # 0x3f3e0
movq (%r14), %rax
movq %rax, (%rbx)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x8(%rbx)
xorl %eax, %eax
movq %rax, (%r14)
leaq 0x1edf3(%rip), %rcx     # 0x2d06e
movq %rcx, 0x8(%r14)
movq %rax, 0x10(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_query::evaluate_boolean(pugi::xpath_node const&) const
PUGI__FN bool xpath_query::evaluate_boolean(const xpath_node& n) const
	{
		if (!_impl) return false;

		impl::xpath_context c(n, 1, 1);
		impl::xpath_stack_data sd;

	#ifdef PUGIXML_NO_EXCEPTIONS
		if (setjmp(sd.error_handler)) return false;
	#endif

		return static_cast<impl::xpath_query_impl*>(_impl)->root->eval_boolean(c, sd.stack);
	}

// Assembly:
pushq %rbx
subq $0x2070, %rsp           # imm = 0x2070
movq (%rdi), %rax
testq %rax, %rax
je 0xe32b
movups (%rsi), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x1, %ecx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
leaq 0x2040(%rsp), %rcx
leaq 0x20(%rsp), %rdx
movq %rdx, (%rcx)
xorl %edi, %edi
movq %rdi, 0x8(%rcx)
leaq 0x2050(%rsp), %r8
leaq 0x1030(%rsp), %r9
movq %r9, (%r8)
movq %rdi, 0x8(%r8)
movq %rdi, (%r9)
movq %rdi, (%rdx)
movl $0x1000, %edi           # imm = 0x1000
movq %rdi, 0x8(%r9)
movq %rdi, 0x8(%rdx)
leaq 0x2060(%rsp), %rdx
movq %rcx, (%rdx)
movq %r8, 0x8(%rdx)
movq (%rax), %rdi
callq 0xe34e
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0xf0ae
jmp 0xe32d
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x2070, %rsp           # imm = 0x2070
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf0ae
movq %rbx, %rdi
callq 0x4700
nop