LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::delete_comment((anonymous namespace)::Specs*, char*)
void delete_comment(Specs *S, char *start) {
        Comment *p, *q;

        q = nullptr;
        for (p = S->comments; p != nullptr ; p = p->next) {
            if (!strcmp(p->start, start)) {
                if (q == nullptr )
                    S->comments = p->next;
                else
                    q->next = p->next;
                free(p->start);
                free(p->end);
                free(p);
                free(start);
                return;
            } else
                q = p;
        }
        free(start);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
addq $0x90, %r15
xorl %r13d, %r13d
movq %r15, %rax
movq (%rax), %r14
testq %r14, %r14
je 0x5bf7
movq (%r14), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x21a0
testl %eax, %eax
je 0x5bcc
leaq 0x20(%r14), %rax
movq %r14, %r13
jmp 0x5ba9
leaq 0x20(%r13), %rax
testq %r13, %r13
movq 0x20(%r14), %rcx
cmoveq %r15, %rax
movq %rcx, (%rax)
movq %r12, %rdi
callq 0x2160
movq 0x8(%r14), %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2160
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::comment_or_white(int, int, int)
int comment_or_white(int start, int end, int cmtmode) {
            char c;

            while (start < end) {
                skip_possible_comments(&start, cmtmode, 1);
                if (start < end) {
                    c = get_char(start++);
                    if ((c != ' ') && (c != '\n') && (c != '\t'))
                        return 0;
                }
            }
            return 1;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movl %esi, (%r15)
pushq $0x1
popq %rbp
movabsq $0x100000600, %r12      # imm = 0x100000600
cmpl %ebx, %esi
jge 0x5c9e
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x6614
movl 0x4(%rsp), %esi
cmpl %ebx, %esi
jge 0x5c5b
leal 0x1(%rsi), %r13d
movl %r13d, 0x4(%rsp)
movq %r14, %rdi
callq 0x5932
movl %eax, %ecx
xorl %eax, %eax
cmpb $0x20, %cl
ja 0x5ca0
movzbl %cl, %ecx
btq %rcx, %r12
movl %r13d, %esi
jb 0x5c5b
jmp 0x5ca0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::whiteout(int*, int*)
int whiteout(int *pos1, int *pos2) // remove whitespace on both sides
        {
            while ((*pos1 < *pos2) && is_white(get_char(*pos1)))
                (*pos1)++;
            while ((*pos1 < *pos2) && is_white(get_char(*pos2 - 1)))
                (*pos2)--;
            return (*pos1 < *pos2);
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
movabsq $0x100000600, %r12      # imm = 0x100000600
movl (%rbx), %esi
cmpl %esi, %eax
jge 0x5d15
movq %r15, %rdi
movl %eax, %esi
callq 0x5932
cmpb $0x20, %al
ja 0x5cf4
movzbl %al, %eax
btq %rax, %r12
jae 0x5cf4
movl (%r14), %eax
incl %eax
movl %eax, (%r14)
jmp 0x5ccd
movl (%rbx), %esi
jmp 0x5d15
decl %esi
movq %r15, %rdi
callq 0x5932
cmpb $0x20, %al
ja 0x5d1a
movzbl %al, %eax
btq %rax, %r12
jae 0x5d1a
movl (%rbx), %esi
decl %esi
movl %esi, (%rbx)
cmpl %esi, (%r14)
jl 0x5cf8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::find_ident(char const*, int)
int find_ident(const char *b, int l) {
            int i;

            for (i = 0; i < nmacros; i++)
                if (id_equal(b, l, macros[i].username))
                    return i;
            return -1;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl 0x10(%rdi), %r12d
movq 0x8(%rdi), %r13
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
pushq $-0x1
popq %rbp
cmpq %r15, %r12
je 0x5d6e
movq (%r13), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x5b2d
testl %eax, %eax
jne 0x5d6b
incq %r15
addq $0x30, %r13
jmp 0x5d4b
movl %r15d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::delete_macro(int)
void delete_macro(int i) {
            int j;
            nmacros--;
            free(macros[i].username);
            free(macros[i].macrotext);
            if (macros[i].argnames != nullptr ) {
                for (j = 0; j < macros[i].nnamedargs; j++)
                    free(macros[i].argnames[j]);
                free(macros[i].argnames);
                macros[i].argnames = nullptr;
            }
            free_comments(macros[i].define_specs);
            free(macros[i].define_specs);
            memcpy(macros + i, macros + nmacros, sizeof(Macro));
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
decl 0x10(%rdi)
movq 0x8(%rdi), %rax
movl %esi, %ecx
imulq $0x30, %rcx, %r14
movq (%rax,%r14), %rdi
callq 0x2160
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r14), %rdi
callq 0x2160
movq 0x8(%rbx), %rax
cmpq $0x0, 0x10(%rax,%r14)
je 0x5deb
xorl %r15d, %r15d
movslq 0x1c(%rax,%r14), %rcx
movq 0x10(%rax,%r14), %rdi
cmpq %rcx, %r15
jge 0x5ddc
movq (%rdi,%r15,8), %rdi
callq 0x2160
incq %r15
movq 0x8(%rbx), %rax
jmp 0x5dbb
callq 0x2160
movq 0x8(%rbx), %rax
andq $0x0, 0x10(%rax,%r14)
movq 0x20(%rax,%r14), %rdi
callq 0x66c8
movq 0x8(%rbx), %rax
movq 0x20(%rax,%r14), %rdi
callq 0x2160
movq 0x8(%rbx), %rax
movslq 0x10(%rbx), %rcx
imulq $0x30, %rcx, %rcx
movups (%rax,%rcx), %xmm0
movups 0x10(%rax,%rcx), %xmm1
movups 0x20(%rax,%rcx), %xmm2
movups %xmm2, 0x20(%rax,%r14)
movups %xmm1, 0x10(%rax,%r14)
movups %xmm0, (%rax,%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e80
movslq %r15d, %rax
leaq 0x1(,%rax,2), %rax
movl %eax, 0x14(%rbx)
movq 0x8(%rbx), %rdi
imulq $0x30, %rax, %rsi
callq 0x2210
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x5ef5
movq %rax, %r12
movl 0x10(%rbx), %r15d
jmp 0x5e84
movq 0x8(%rbx), %r12
leal 0x1(%r13), %eax
movq %r13, %r14
movslq %eax, %r13
movq %r13, %rdi
callq 0x2170
movq %rax, %rbp
movslq %r15d, %rax
imulq $0x30, %rax, %r15
movq %rbp, (%r12,%r15)
movq %rbp, %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0x20b0
movslq %r14d, %rax
movb $0x0, (%rbp,%rax)
andq $0x0, 0x10(%r12,%r15)
andl $0x0, 0x1c(%r12,%r15)
andl $0x0, 0x28(%r12,%r15)
movq (%rbx), %rdi
callq 0x62ca
movq 0x8(%rbx), %rcx
movslq 0x10(%rbx), %rdx
imulq $0x30, %rdx, %rdx
movq %rax, 0x20(%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26aa(%rip), %rdi      # 0x85a6
callq 0x2d13
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movl %esi, (%r15)
movl %edx, %eax
subl %esi, %eax
incl %eax
movslq %eax, %rdi
callq 0x2170
pushq $0x1
popq %r13
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
cmpl %ebp, %r12d
jge 0x5fc8
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
movl %r13d, %ecx
callq 0x6614
movl 0x4(%rsp), %r12d
cmpl %ebp, %r12d
jge 0x5f3e
leal 0x1(%r12), %eax
movl %eax, 0x4(%rsp)
movq %r14, %rdi
movl %r12d, %esi
callq 0x5932
movq 0x8(%rsp), %rdx
movb %al, (%rdx)
movq (%r14), %rcx
cmpb 0x30(%rcx), %al
sete %al
movl 0x4(%rsp), %r12d
cmpl %ebp, %r12d
setl %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x5fbb
movl %r12d, %eax
incl %eax
movl %eax, 0x4(%rsp)
movq %r14, %rdi
movl %r12d, %esi
callq 0x5932
movq 0x8(%rsp), %rdx
movb %al, 0x1(%rdx)
incq %rdx
movl 0x4(%rsp), %r12d
incq %rdx
movq %rdx, 0x8(%rsp)
jmp 0x5f3e
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8(%rdi), %rcx
movslq %esi, %rax
imulq $0x30, %rax, %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rcx,%rax)
je 0x601e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %r12
leaq (%r15,%r12), %rax
orl $-0x1, 0x1c(%rax)
movq (%rdi), %rbp
movq 0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x2080
movq 0x8(%r15,%r12), %r14
movl 0x18(%r15,%r12), %r12d
movslq %eax, %r15
xorl %r13d, %r13d
cmpl %r12d, %r13d
jge 0x600f
movb (%r14), %al
testb %al, %al
je 0x6068
cmpb 0x30(%rbp), %al
jne 0x6068
incl %r13d
incq %r14
jmp 0x6084
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2090
testl %eax, %eax
jne 0x6084
movb (%r14,%r15), %al
addb $-0x31, %al
cmpb $0x8, %al
jbe 0x608c
incl %r13d
incq %r14
jmp 0x604f
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
andl $0x0, 0x1c(%rax,%rcx)
jmp 0x600f
// File: /workspace/github_cpp_makefile_star2_O2/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 0x60d3
btq %rax, %r15
jae 0x60d3
incq %r14
jmp 0x60b5
btq %rcx, %r15
jae 0x60dc
incq %rbx
movzbl (%rbx), %ecx
cmpq $0x20, %rcx
jbe 0x60ca
testb %al, %al
sete %al
testb %cl, %cl
sete %cl
orb %al, %cl
je 0x60fa
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x21a0
movq %r14, %rdi
callq 0x2080
addq %r14, %rax
decq %rax
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x611f
btq %rcx, %r15
jae 0x611f
movb $0x0, (%rax)
decq %rax
jmp 0x6108
movq %rbx, %rdi
callq 0x2080
addq %rbx, %rax
decq %rax
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x60ea
btq %rcx, %r15
jae 0x60ea
movb $0x0, (%rax)
decq %rax
jmp 0x612d
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::arithm_eval(int, int)
char *arithm_eval(int pos1, int pos2) {
            // first define the defined(...) operator
            auto i = find_ident("defined", strlen("defined"));
            if (i >= 0)
                warning("the defined(...) macro is already defined");
            else {
                newmacro("defined", strlen("defined"), 1);
                macros[nmacros].macrolen = 0;
                macros[nmacros].macrotext = XX malloc(1);
                macros[nmacros].macrotext[0] = 0;
                macros[nmacros].nnamedargs = -2; // trademark of the defined(...) macro
                nmacros++;
            }
            // process the text in a usual way
            auto s = process_text(C->buf + pos1, pos2 - pos1, FLAG_META);
            // undefine the defined(...) operator
            if (i < 0) {
                i = find_ident("defined", strlen("defined"));
                if ((i < 0) || (macros[i].nnamedargs != -2))
                    warning("the defined(...) macro was redefined in expression");
                else
                    delete_macro(i);
            }

            if (!do_arithm_eval(s, 0, strlen(s), &i))
                return s; // couldn't compute

            free(s);
            auto result = std::to_string(i);
            return my_strdup(result.data());
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x2929(%rip), %rsi      # 0x8a8a
pushq $0x7
popq %rdx
callq 0x5d26
movl %eax, %r15d
movl %eax, (%rsp)
testl %eax, %eax
js 0x6181
leaq 0x28ee(%rip), %rdi      # 0x8a68
callq 0x5a8f
jmp 0x61cf
leaq 0x2902(%rip), %rsi      # 0x8a8a
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x5e34
movq 0x8(%rbx), %r12
movslq 0x10(%rbx), %r13
movl %r14d, 0x4(%rsp)
imulq $0x30, %r13, %r14
andl $0x0, 0x18(%r12,%r14)
pushq $0x1
popq %rdi
callq 0x2170
movq %rax, 0x8(%r12,%r14)
movb $0x0, (%rax)
movl $0xfffffffe, 0x1c(%r12,%r14) # imm = 0xFFFFFFFE
movl 0x4(%rsp), %r14d
leal 0x1(%r13), %eax
movl %eax, 0x10(%rbx)
movq 0x20(%rbx), %rax
movslq %r14d, %rcx
movq (%rax), %rsi
addq %rcx, %rsi
subl %ecx, %ebp
movq %rbx, %rdi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x54e6
movq %rax, %r14
testl %r15d, %r15d
jns 0x6234
leaq 0x2891(%rip), %rsi      # 0x8a8a
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x5d26
movl %eax, (%rsp)
testl %eax, %eax
js 0x6228
movq 0x8(%rbx), %rcx
movl %eax, %edx
imulq $0x30, %rdx, %rdx
cmpl $-0x2, 0x1c(%rcx,%rdx)
jne 0x6228
movq %rbx, %rdi
movl %eax, %esi
callq 0x5d80
jmp 0x6234
leaq 0x2863(%rip), %rdi      # 0x8a92
callq 0x5a8f
movq %r14, %rdi
callq 0x2080
movq %rsp, %rcx
movq %r14, %rdi
xorl %esi, %esi
movl %eax, %edx
callq 0x670e
testl %eax, %eax
je 0x627a
movq %r14, %rdi
callq 0x2160
movl (%rsp), %esi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x7546
movq (%rbx), %rdi
callq 0x2cd7
movq %rax, %r14
movq %rbx, %rdi
callq 0x2258
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x66c8
movq %r14, %rdi
callq 0x2160
cmpq $0x0, (%rbx)
je 0x62be
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2994(%rip), %rdi      # 0x8c59
callq 0x2d13
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xb8, %edi
callq 0x2170
testq %rax, %rax
je 0x639e
movq %rax, %rbx
movl $0xb8, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x20f0
andq $0x0, 0x98(%rbx)
movq 0x90(%r14), %r15
testq %r15, %r15
je 0x631e
pushq $0x28
popq %rdi
callq 0x2170
movq %rax, 0x90(%rbx)
movq %rbx, %r12
addq $0x90, %r12
pushq $0x28
popq %r14
testq %r15, %r15
je 0x638f
movq (%r12), %r12
movq 0x20(%r15), %rax
movq %rax, 0x20(%r12)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movq (%r15), %rdi
callq 0x2cd7
movq %rax, (%r12)
movq 0x8(%r15), %rdi
callq 0x2cd7
movq %rax, 0x8(%r12)
cmpq $0x0, 0x20(%r15)
je 0x6386
movq %r14, %rdi
callq 0x2170
movq %rax, 0x20(%r12)
movq 0x20(%r15), %r15
jmp 0x6389
xorl %r15d, %r15d
addq $0x20, %r12
jmp 0x632c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2630(%rip), %rdi      # 0x89d5
callq 0x2d13
// File: /workspace/github_cpp_makefile_star2_O2/cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::iter_identifier_end(int)
int iter_identifier_end(int start) {
            int x;
            while (1) {
                x = identifier_end(start);
                if (x == start)
                    return x;
                start = x;
            }
        }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x5a2e
cmpl %ebp, %eax
jne 0x65fa
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6638
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r12d
movl $0x90, %r13d
movl (%r14), %esi
movq %r15, %rdi
callq 0x5932
testb %al, %al
je 0x6629
movq (%r15), %rbp
addq %r13, %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x6629
testl %ebx, %ebx
sete %al
movl 0x14(%rbp,%r12,4), %edx
testl %edx, %edx
sete %cl
testb $0x40, %dl
jne 0x6692
orb %cl, %al
je 0x6692
movq (%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x5248
testl %eax, %eax
jne 0x6698
addq $0x20, %rbp
jmp 0x665e
movq 0x8(%rbp), %rsi
movsbl 0x10(%rbp), %edx
movsbl 0x11(%rbp), %ecx
movl (%r14), %r8d
movl 0x14(%rbp,%r12,4), %r9d
movq %r15, %rdi
callq 0x5392
movl %eax, (%r14)
movq 0x8(%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x5432
jmp 0x6649
// File: /workspace/github_cpp_makefile_star2_O2/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 0x670d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x90(%rbx), %r14
testq %r14, %r14
je 0x6706
movq 0x20(%r14), %rax
movq %rax, 0x90(%rbx)
movq (%r14), %rdi
callq 0x2160
movq 0x8(%r14), %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2160
jmp 0x66d4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r13
movq %rcx, 0x20(%rsp)
movq %rcx, %rdi
callq 0x2080
movq %rax, %r12
decl %ebx
movslq %ebx, %rbx
movslq %r12d, %rax
movq %rax, 0x18(%rsp)
pushq $0x1
popq %r15
xorl %r14d, %r14d
cmpl %ebp, %ebx
jl 0x7472
leaq (%rbx,%r13), %rdi
movb (%rdi), %al
xorl %ecx, %ecx
cmpb $0x29, %al
sete %cl
addl %ecx, %r14d
xorl %ecx, %ecx
cmpb $0x28, %al
sete %cl
subl %ecx, %r14d
js 0x7472
setne %al
cmpl %r12d, %r15d
setl %cl
orb %al, %cl
jne 0x746a
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2090
testl %eax, %eax
je 0x7483
decq %rbx
incl %r15d
jmp 0x742a
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movl %ebx, (%rax)
addl %r12d, %ebx
movq 0x10(%rsp), %rax
movl %ebx, (%rax)
pushq $0x1
popq %rax
jmp 0x7474
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21d0
movl %eax, %ebp
movq (%rsp), %rax
movb (%rax,%r15), %bl
movsbl %bl, %edi
callq 0x21d0
movsbl %bpl, %ecx
movsbl %al, %eax
cmpl %eax, %ecx
pushq $-0x1
popq %rax
cmovll %eax, %r12d
pushq $0x1
popq %rax
cmovgl %eax, %r12d
jne 0x74f6
xorl %eax, %eax
testb %r13b, %r13b
je 0x74f9
incq %r15
testb %bl, %bl
jne 0x74ae
jmp 0x74f9
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
movl $0x1, (%rdi)
andl $0x0, 0x70(%rdi)
leaq 0x20(%rsp), %rsi
andl $0x0, (%rsi)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x8(%rsi)
leaq 0x6d86(%rip), %rcx      # 0x9270
movsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rsi)
andl $0x0, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
callq 0x3096
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3096
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x32be
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movslq %esi, %r15
leaq 0x6c93(%rip), %r12      # 0x91e0
movq %r12, %rdi
movq %r15, %rsi
callq 0x30bc
movq 0x30(%rax), %rcx
movq %rcx, 0x30(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2636
movl %eax, %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0x30bc
movq 0x30(%rax), %rcx
movq %rcx, 0x30(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x26fe
movl %eax, %r14d
movq %r12, %rdi
movq %r15, %rsi
callq 0x30bc
movdqu (%rbx), %xmm0
leaq 0x6c3e(%rip), %rcx      # 0x9210
leaq 0x6c3f(%rip), %rdx      # 0x9218
movupd 0x8(%rax), %xmm1
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pcmpeqd 0x3a25(%rip), %xmm0     # 0x6010
movq (%rcx), %xmm2
punpcklqdq %xmm2, %xmm2    # xmm2 = xmm2[0,0]
movq (%rdx), %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, %eax
andb %bpl, %r14b
andb %al, %r14b
andb $0x2, %al
shrb %al
andb %al, %r14b
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq -0x2(%rax), %rsi
callq 0x30da
movsd 0x10(%rax), %xmm0
movaps %xmm0, (%rsp)
movslq 0x70(%rbx), %rsi
leaq 0x6b3d(%rip), %r14      # 0x91b0
movq %r14, %rdi
callq 0x30f8
movslq 0x30(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3116
movapd (%rsp), %xmm0
addsd (%rax), %xmm0
movapd %xmm0, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x30f8
movq %rax, %rdi
movq %r15, %rsi
callq 0x3116
leaq 0x6a93(%rip), %rcx      # 0x9148
movsd (%rcx), %xmm0
movapd (%rsp), %xmm3
addsd %xmm3, %xmm0
addsd (%rax), %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, -0x10(%rax)
leaq 0x6ba2(%rip), %rax      # 0x9278
movsd (%rax), %xmm1
movsd 0x60(%rsp), %xmm2
cmpltpd %xmm2, %xmm3
cmpltpd %xmm1, %xmm0
andpd %xmm3, %xmm0
movd %xmm0, %eax
andb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq 0x70(%rdi), %rsi
leaq 0x6a6b(%rip), %r14      # 0x9180
movq %r14, %rdi
callq 0x30f8
movslq 0x30(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3116
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x30f8
movq %rax, %rdi
movq %r15, %rsi
callq 0x3116
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x70(%rbx), %rsi
movq %r14, %rdi
callq 0x30f8
movq %rax, %rdi
xorl %esi, %esi
callq 0x3116
movsd 0x8(%rsp), %xmm1
subsd (%rax), %xmm1
movsd 0x68(%rbx), %xmm0
ucomisd %xmm1, %xmm0
seta %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6a73(%rip), %rax      # 0x9210
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pcmpeqd 0x3866(%rip), %xmm0     # 0x6010
leaq 0x6a67(%rip), %rcx      # 0x9218
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x70(%rdi), %rsi
leaq 0x694a(%rip), %r14      # 0x9180
movq %r14, %rdi
callq 0x30f8
movslq %ebp, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3116
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x40(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x30f8
movq %rax, %rdi
movq %r15, %rsi
callq 0x3116
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x30f8
movq %rax, %rdi
xorl %esi, %esi
callq 0x3116
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x70(%rbx), %rsi
movq %r14, %rdi
callq 0x30f8
movq %rax, %rdi
xorl %esi, %esi
callq 0x3116
movsd 0x8(%rsp), %xmm0
subsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DivyanshuSaxena[P]green-vrp/Vehicle.cpp
// Function: Vehicle::addCustomer(int)
void Vehicle::addCustomer(int customerId) {
    Customer customer = customers.at(customerId);
    Node node;
    node.id = customer.id;
    time_type timeTaken = travelTimes.at(this->currentNodeId).at(customer.id);
    double travelCost = travelCosts.at(this->currentNodeId).at(customer.id);
    
    node.arrival_time = this->route.at(this->route.size()-2).departure_time + timeTaken;
    node.departure_time = node.arrival_time + serviceTime;
    this->currentNodeId = customer.id;
    auto it = this->route.end();
    this->route.insert(--it, node);
    // Update costs
    double factor = this->type == 1 ? unitTransCost1 : unitTransCost2;
    this->travellingCost += (travelCost * factor);
    double waitCost = (customer.timeWindowStarts > node.arrival_time) ? (customer.timeWindowStarts - node.arrival_time)*waiting_factor : 0; 
    this->waitingCost += waitCost;
    updateTotalCost();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movslq %esi, %rsi
leaq 0x68ce(%rip), %rdi      # 0x91e0
callq 0x30bc
movslq (%rax), %r15
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x20(%rsp), %r14
movl %r15d, (%r14)
movslq 0x70(%rbx), %rsi
leaq 0x6878(%rip), %rdi      # 0x91b0
callq 0x30f8
movq %rax, %rdi
movq %r15, %rsi
callq 0x3116
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x70(%rbx), %rsi
leaq 0x6823(%rip), %rdi      # 0x9180
callq 0x30f8
movq %rax, %rdi
movq %r15, %rsi
callq 0x3116
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x8(%rbx), %r12
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq -0x2(%rax), %rsi
movq %r12, %rdi
callq 0x30da
movsd 0x8(%rsp), %xmm0
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x8(%r14)
leaq 0x6799(%rip), %rax      # 0x9148
addsd (%rax), %xmm0
movsd %xmm0, 0x10(%r14)
movl %r15d, 0x70(%rbx)
movq 0x10(%rbx), %rsi
addq $-0x18, %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x3138
cmpl $0x1, (%rbx)
jne 0x29de
leaq 0x6874(%rip), %rax      # 0x9250
jmp 0x29e5
leaq 0x6873(%rip), %rax      # 0x9258
movsd 0x10(%rsp), %xmm0
mulsd (%rax), %xmm0
addsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x30(%rbx)
movsd 0x28(%rsp), %xmm0
movsd 0x18(%rsp), %xmm3
movapd %xmm3, %xmm1
subsd %xmm0, %xmm1
leaq 0x687c(%rip), %rax      # 0x9290
cvtsi2sdl (%rax), %xmm2
mulsd %xmm1, %xmm2
cmpltsd %xmm3, %xmm0
andpd %xmm2, %xmm0
addsd 0x38(%rbx), %xmm0
movsd %xmm0, 0x38(%rbx)
movq %rbx, %rdi
callq 0x27ec
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x5f82(%rip), %rax      # 0x916c
movslq (%rax), %r14
movsd 0x2e33(%rip), %xmm0     # 0x6028
pushq $-0x1
popq %rbp
leaq 0x5f71(%rip), %r12      # 0x9170
leaq 0x5f7a(%rip), %r15      # 0x9180
movslq (%r12), %rax
cmpq %rax, %r14
jg 0x325a
movq %r15, %rdi
movq %r14, %rsi
movsd %xmm0, 0x8(%rsp)
callq 0x30f8
movslq (%rbx), %rsi
movq %rax, %rdi
callq 0x3116
movsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm1
seta %al
cmpl $-0x1, %ebp
sete %cl
orb %al, %cl
movl %r14d, %eax
testb %cl, %cl
jne 0x324d
movl %ebp, %eax
jne 0x3253
movapd %xmm1, %xmm0
incq %r14
movl %eax, %ebp
jmp 0x3206
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movl %edi, %ebp
movslq 0x4f21(%rip), %rsi      # 0x92a8
leaq 0x4e6a(%rip), %r15      # 0x91f8
movq %r15, %rdi
callq 0x455e
movl (%rax), %r13d
movsd 0x4eaf(%rip), %xmm0     # 0x9250
movsd %xmm0, 0x20(%rsp)
movsd 0x4ea9(%rip), %xmm0     # 0x9258
movsd %xmm0, 0x10(%rsp)
movslq %ebp, %r14
movq 0x4dd9(%rip), %rax      # 0x9198
imulq $0x18, %r14, %rcx
movslq %ebx, %rbx
movq (%rax,%rcx), %rax
movsd (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x18(%rsp)
movslq 0x4ecc(%rip), %rsi      # 0x92a8
movq %r15, %rdi
callq 0x455e
leaq 0x8(%rax), %r12
movslq 0x4eb9(%rip), %rsi      # 0x92a8
movq %r15, %rdi
callq 0x455e
movq 0x10(%rax), %rcx
subq 0x8(%rax), %rcx
pushq $0x18
popq %rsi
movq %rcx, %rax
cqto
idivq %rsi
leaq -0x2(%rax), %rsi
movq %r12, %rdi
callq 0x30da
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x4d88(%rip), %rdi      # 0x91b0
movq %r14, %rsi
callq 0x30f8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3116
movsd (%rax), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x4d8f(%rip), %rdi      # 0x91e0
movq %rbx, %rsi
callq 0x30bc
movsd 0x28(%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd (%rsp), %xmm0
jbe 0x44b7
leaq 0x4d70(%rip), %rdi      # 0x91e0
movq %rbx, %rsi
callq 0x30bc
movsd 0x28(%rax), %xmm0
movsd %xmm0, (%rsp)
leaq 0x4d27(%rip), %rdi      # 0x91b0
movq %r14, %rsi
callq 0x30f8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3116
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
subsd %xmm0, %xmm1
mulsd 0x1bf9(%rip), %xmm1     # 0x60b0
cmpl $0x1, %r13d
movsd 0x20(%rsp), %xmm0
je 0x44c9
movsd 0x10(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 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:
subq $0x48, %rsp
movl %edx, %r9d
leaq 0x3f(%rsp), %rcx
movl %edx, %r10d
negl %r10d
cmovsl %edx, %r10d
pushq $0x1
popq %r8
pushq $0xa
popq %r11
movl %r10d, %eax
xorl %edx, %edx
divl %r11d
orb $0x30, %dl
movb %dl, (%rcx)
decq %rcx
incq %r8
cmpl $0x9, %r10d
movl %eax, %r10d
ja 0x5141
movq %rsp, %rax
cmpq %rax, %rcx
jb 0x5183
xorl %eax, %eax
testl %r9d, %r9d
setns %al
movb $0x2d, (%rcx)
addq %rax, %rcx
subq %rax, %r8
pushq $0x10
popq %rdx
callq 0x4ee4
addq $0x48, %rsp
retq
leaq 0x24a09(%rip), %rdi     # 0x29b93
leaq 0x21664(%rip), %rsi     # 0x267f5
leaq 0x24a0b(%rip), %rcx     # 0x29ba3
movl $0x11fa, %edx           # imm = 0x11FA
callq 0x42a0
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdi
testq %rdi, %rdi
je 0x6aaa
movl (%rdi), %eax
andl $0xf, %eax
addl $-0x3, %eax
cmpl $-0x3, %eax
ja 0x6acb
andl $0x0, 0x10(%rbx)
movl $0xf, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %r9, 0x8(%rsp)
callq 0x587a
movq %rax, %r14
orb $0x40, (%rax)
leaq 0x40(%rax), %rdi
pushq $0x10
popq %rsi
leaq 0x10(%rsp), %rdx
callq 0x6b6e
testq %rax, %rax
je 0x6b4f
andq $0x0, (%rax)
movq 0x58(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x58(%r14)
movq (%r13), %r13
movq 0x8(%r13), %rcx
movq %rcx, (%rsp)
andq $0x0, 0x8(%r13)
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movl %ebp, %r9d
pushq %rax
pushq $0x0
pushq $0x0
pushq 0x20(%rsp)
callq 0x6b95
addq $0x20, %rsp
movq (%rsp), %rax
movq %rax, 0x8(%r13)
jmp 0x6ab9
andl $0x0, 0x10(%rbx)
movl $0x3, (%rbx)
jmp 0x6ab4
movq (%rsp), %rcx
movq %rcx, 0x8(%r13)
movq %rax, %rdi
callq 0x4700
// File: /workspace/github_cpp_makefile_star2_O2/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
orl $-0x1, 0x8(%rsi)
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x8739
movq (%r14), %rax
testq %rax, %rax
je 0x873d
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x873d
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 0x8739
movq 0x20(%r12), %rcx
testq %rcx, %rcx
je 0x86e8
incl 0x8(%rbx)
jmp 0x86f2
movq 0x30(%r12), %rcx
testq %rcx, %rcx
je 0x870a
movq (%r14), %rax
movq %rcx, %r12
testq %rcx, %rcx
je 0x873d
cmpq %rax, %r12
jne 0x86c4
jmp 0x873d
decl 0x8(%rbx)
movq %rcx, %r12
cmpq $0x0, 0x30(%r12)
movq (%r14), %rax
jne 0x8724
cmpq %rax, %r12
je 0x8724
movq 0x18(%r12), %rcx
testq %rcx, %rcx
jne 0x8704
movl $0x0, %ecx
cmpq %rax, %r12
cmoveq %r12, %rcx
je 0x86f5
movq 0x30(%r12), %rcx
jmp 0x86f5
xorl %eax, %eax
jmp 0x8754
cmpl $-0x1, 0x8(%rbx)
jne 0x8760
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 0x1e1be(%rip), %rdi     # 0x26925
leaq 0x1e087(%rip), %rsi     # 0x267f5
leaq 0x1e1c4(%rip), %rcx     # 0x26939
movl $0x1856, %edx           # imm = 0x1856
callq 0x42a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x1
popq %rax
testq %rsi, %rsi
je 0x8bd2
movq (%rsi), %rdx
movq %rdx, %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rsi,%rcx), %rdi
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x8bd2
cmpq $0x0, 0x18(%rdi)
jne 0x8bd2
movl %edx, %edi
andl $0xf, %edi
cmpl $0x8, %edi
ja 0x8bd2
movl $0x138, %r8d            # imm = 0x138
btl %edi, %r8d
jb 0x8bb6
movl $0xc4, %r8d
btl %edi, %r8d
jae 0x8bd3
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
sete %dil
testb $0x60, %dl
jmp 0x8bc4
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
sete %dil
testb $0x50, %dl
setne %dl
orb %dil, %dl
jne 0x8bd2
subq %rcx, %rsi
movq %rsi, %rax
retq
cmpl $0x1, %edi
jne 0x8bd2
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xad07
movq %rsi, %r14
movq 0x18(%rbx), %rdi
leaq 0x8(%rbx), %rax
cmpq %rax, %rdi
je 0xacfc
callq *0x306f4(%rip)          # 0x3b3f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xabde
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq