LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2220
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x2220
movb %al, -0x1a(%rbp)
movsbl -0x19(%rbp), %eax
movsbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jle 0xa833
movl $0x1, -0x4(%rbp)
jmp 0xa88d
movsbl -0x19(%rbp), %eax
movsbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jge 0xa848
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa88d
jmp 0xa84a
movq -0x10(%rbp), %rcx
movq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x1b(%rbp)
je 0xa87b
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpb $0x0, (%rax)
setne %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
testb $0x1, %al
jne 0xa800
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::is_delim(unsigned char)
int is_delim(unsigned char c) {
        if (c >= 128)
            return 0;
        if ((c >= '0') && (c <= '9'))
            return 0;
        if ((c >= 'A') && (c <= 'Z'))
            return 0;
        if ((c >= 'a') && (c <= 'z'))
            return 0;
        if (c == '_')
            return 0;
        return 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
cmpl $0x80, %eax
jl 0xa8be
movl $0x0, -0x4(%rbp)
jmp 0xa928
movzbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0xa8d9
movzbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0xa8d9
movl $0x0, -0x4(%rbp)
jmp 0xa928
movzbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jl 0xa8f4
movzbl -0x5(%rbp), %eax
cmpl $0x5a, %eax
jg 0xa8f4
movl $0x0, -0x4(%rbp)
jmp 0xa928
movzbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0xa90f
movzbl -0x5(%rbp), %eax
cmpl $0x7a, %eax
jg 0xa90f
movl $0x0, -0x4(%rbp)
jmp 0xa928
movzbl -0x5(%rbp), %eax
cmpl $0x5f, %eax
jne 0xa921
movl $0x0, -0x4(%rbp)
jmp 0xa928
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::find_named_arg(char const*, int)
int find_named_arg(const char *b, int l) {
            char *s;
            int i;

            for (i = 0;; i++) {
                s = C->namedargs[i];
                if (s == nullptr )
                    return -1;
                if (id_equal(b, l, s))
                    return i;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xa97a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa9a4
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x7030
cmpl $0x0, %eax
je 0xa997
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa9a4
jmp 0xa999
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa952
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: cjxgm[P]libgpp/src/libgpp.cpp
// Function: (anonymous namespace)::Preprocessor::extend_buf(int)
void extend_buf(int pos) {
            char *p;
            if (C->bufsize <= pos) {
                C->bufsize += pos; // approx double
                p = XX malloc(C->bufsize);
                memcpy(p, C->buf, C->len);
                free(C->malloced_buf);
                C->malloced_buf = C->buf = p;
                if (C->buf == nullptr )
                    bug("out of memory");
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x20(%rax), %rax
movl 0x14(%rax), %eax
cmpl -0xc(%rbp), %eax
jg 0xaa71
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %edx
movq 0x20(%rax), %rcx
addl 0x14(%rcx), %edx
movl %edx, 0x14(%rcx)
movq 0x20(%rax), %rax
movslq 0x14(%rax), %rdi
callq 0x21a0
movq %rax, %rsi
leaq -0x21(%rbp), %rdi
callq 0x3060
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3730
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x20(%rax), %rcx
movq (%rcx), %rsi
movq 0x20(%rax), %rax
movslq 0x10(%rax), %rdx
callq 0x2100
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2170
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x20(%rax), %rcx
movq %rdx, (%rcx)
movq 0x20(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq 0x20(%rax), %rax
cmpq $0x0, (%rax)
jne 0xaa6f
leaq 0xd20(%rip), %rdi       # 0xb78a
callq 0x35e0
jmp 0xaa71
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
callq 0x3900
movq -0x50(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, 0x70(%rax)
leaq -0x20(%rbp), %rdi
callq 0x3920
jmp 0x262d
movl $0x0, -0x20(%rbp)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, -0x18(%rbp)
leaq 0xec8f(%rip), %rax      # 0x112d8
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3920
jmp 0x265d
movq -0x50(%rbp), %rdi
movl $0x0, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
leaq -0x20(%rbp), %rsi
callq 0x3950
jmp 0x268d
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
leaq -0x48(%rbp), %rsi
callq 0x3950
jmp 0x26a0
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x39c0
movq -0x28(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movslq -0xc(%rbp), %rsi
leaq 0xeb50(%rip), %rdi      # 0x11248
callq 0x3a20
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movl $0x38, %edx
callq 0x2150
movq -0xd8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups -0x28(%rbp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2850
andb $0x1, %al
movb %al, -0xd(%rbp)
movslq -0xc(%rbp), %rsi
leaq 0xeafc(%rip), %rdi      # 0x11248
callq 0x3a20
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
movl $0x38, %edx
callq 0x2150
movq -0xd8(%rbp), %rdi
movq -0x58(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups -0x88(%rbp), %xmm0
movups -0x78(%rbp), %xmm1
movups -0x68(%rbp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2980
andb $0x1, %al
movb %al, -0x49(%rbp)
movslq -0xc(%rbp), %rsi
leaq 0xeaa2(%rip), %rdi      # 0x11248
callq 0x3a20
movq %rax, %rsi
leaq -0xc8(%rbp), %rdi
movl $0x38, %edx
callq 0x2150
movq -0xd8(%rbp), %rdi
movq -0x98(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups -0xc8(%rbp), %xmm0
movups -0xb8(%rbp), %xmm1
movups -0xa8(%rbp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2a40
andb $0x1, %al
movb %al, -0x89(%rbp)
xorl %eax, %eax
testb $0x1, -0xd(%rbp)
movb %al, -0xca(%rbp)
je 0x2829
xorl %eax, %eax
testb $0x1, -0x49(%rbp)
movb %al, -0xca(%rbp)
je 0x2829
movb -0x89(%rbp), %al
movb %al, -0xca(%rbp)
movb -0xca(%rbp), %al
andb $0x1, %al
movb %al, -0xc9(%rbp)
movb -0xc9(%rbp), %al
andb $0x1, %al
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
callq 0x3aa0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
subq $0x2, %rsi
callq 0x3a60
movq %rax, %rcx
movq -0x40(%rbp), %rax
movsd 0x10(%rcx), %xmm0
movsd %xmm0, -0x10(%rbp)
movslq 0x70(%rax), %rsi
leaq 0xe96c(%rip), %rdi      # 0x11218
callq 0x3ad0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movslq (%rax), %rsi
callq 0x3b10
movsd (%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq 0xe943(%rip), %rdi      # 0x11218
xorl %eax, %eax
movl %eax, %esi
callq 0x3ad0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movslq (%rax), %rsi
callq 0x3b10
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
leaq 0xe8aa(%rip), %rax      # 0x111b0
addsd (%rax), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x8, %rdi
callq 0x3b50
movsd -0x38(%rbp), %xmm0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd %xmm0, 0x8(%rcx)
movsd -0x18(%rbp), %xmm1
movsd 0x30(%rax), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x21(%rbp)
jbe 0x296a
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x3b50
movsd 0x8(%rax), %xmm1
leaq 0xe984(%rip), %rax      # 0x112e0
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, (%rax)
jne 0x2a6f
leaq 0xe814(%rip), %rax      # 0x11278
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x2a7f
leaq 0xe80a(%rip), %rax      # 0x11280
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
cmpl $0x2, (%rax)
jne 0x2aa4
leaq 0xe7df(%rip), %rax      # 0x11278
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x2ab4
leaq 0xe7d5(%rip), %rax      # 0x11280
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x48(%rcx), %xmm1
addsd 0x10(%rax), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %dl
andb $0x1, %dl
movb %dl, -0x19(%rbp)
movsd 0x40(%rcx), %xmm1
addsd 0x8(%rax), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, -0x1a(%rbp)
xorl %eax, %eax
testb $0x1, -0x19(%rbp)
movb %al, -0x41(%rbp)
je 0x2b0e
movb -0x1a(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq 0x70(%rax), %rsi
leaq 0xe63e(%rip), %rdi      # 0x111e8
callq 0x3ad0
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3b10
movq %rax, %rcx
movq -0x48(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x18(%rbp)
movslq (%rax), %rsi
leaq 0xe613(%rip), %rdi      # 0x111e8
callq 0x3ad0
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3b10
movq %rax, %rcx
movq -0x48(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x20(%rbp)
movslq (%rax), %rsi
leaq 0xe5e8(%rip), %rdi      # 0x111e8
callq 0x3ad0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3b10
movq %rax, %rcx
movq -0x40(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movslq 0x70(%rax), %rsi
leaq 0xe5a8(%rip), %rdi      # 0x111e8
callq 0x3ad0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3b10
movsd -0x38(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd 0x717c(%rip), %xmm0     # 0xb018
movsd %xmm0, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
leaq 0xd325(%rip), %rax      # 0x111d4
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0xd31a(%rip), %rcx      # 0x111d8
cmpl (%rcx), %eax
jg 0x3f19
movslq -0x18(%rbp), %rsi
leaq 0xd31b(%rip), %rdi      # 0x111e8
callq 0x3ad0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movslq (%rax), %rsi
callq 0x3b10
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
ja 0x3efc
cmpl $-0x1, -0x14(%rbp)
jne 0x3f0c
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x3f0e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3eb4
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq 0xa91b(%rip), %rsi      # 0x11310
leaq 0xa864(%rip), %rdi      # 0x11260
callq 0x6df0
cmpl $0x1, (%rax)
jne 0x6a15
movsd 0xa8aa(%rip), %xmm0     # 0x112b8
movsd %xmm0, -0x38(%rbp)
jmp 0x6a22
movsd 0xa8a3(%rip), %xmm0     # 0x112c0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0xa7c9(%rip), %rdi      # 0x11200
callq 0x4040
movq %rax, %rdi
movslq -0x8(%rbp), %rsi
callq 0x40f0
movsd (%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movslq 0xa8b3(%rip), %rsi      # 0x11310
leaq 0xa7fc(%rip), %rdi      # 0x11260
callq 0x6df0
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movslq 0xa898(%rip), %rsi      # 0x11310
leaq 0xa7e1(%rip), %rdi      # 0x11260
callq 0x6df0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x3aa0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
subq $0x2, %rsi
callq 0x3a60
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0xa763(%rip), %rdi      # 0x11218
callq 0x3ad0
movq %rax, %rdi
movslq -0x8(%rbp), %rsi
callq 0x3b10
movsd (%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movslq -0x8(%rbp), %rsi
leaq 0xa769(%rip), %rdi      # 0x11248
callq 0x3a20
movsd -0x40(%rbp), %xmm1
movsd 0x28(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x6b4f
movslq -0x8(%rbp), %rsi
leaq 0xa749(%rip), %rdi      # 0x11248
callq 0x3a20
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0xa6ff(%rip), %rdi      # 0x11218
callq 0x3ad0
movq %rax, %rdi
movslq -0x8(%rbp), %rsi
callq 0x3b10
movsd -0x50(%rbp), %xmm0
movsd (%rax), %xmm1
addsd -0x28(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd 0x455c(%rip), %xmm1     # 0xb0a0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x6b57
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
jne 0xb6e7
movq $-0x1, -0x8(%rbp)
jmp 0xb81f
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x7f00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xb70d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0xb71a
movq $-0x1, -0x8(%rbp)
jmp 0xb81f
movq -0x20(%rbp), %rdi
callq 0x78e0
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $0x1, %eax
je 0xb760
jmp 0xb72f
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xb76d
jmp 0xb739
movl -0x24(%rbp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0xb7c2
jmp 0xb746
movl -0x24(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0xb76d
jmp 0xb753
movl -0x24(%rbp), %eax
subl $0x8, %eax
je 0xb7c2
jmp 0xb817
movq $0x0, -0x8(%rbp)
jmp 0xb81f
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0xb7ab
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
andq $0x60, %rax
cmpq $0x0, %rax
jne 0xb7ab
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x50(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0xb7b8
movq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xb7b8
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb81f
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xb800
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
andq $0x50, %rax
cmpq $0x0, %rax
jne 0xb800
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x50(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0xb80d
movq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xb80d
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb81f
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xml_document::create()
PUGI__FN void xml_document::create()
	{
		assert(!_root);

	#ifdef PUGIXML_COMPACT
		const size_t page_offset = sizeof(uint32_t);
	#else
		const size_t page_offset = 0;
	#endif

		// initialize sentinel page
		PUGI__STATIC_ASSERT(sizeof(impl::xml_memory_page) + sizeof(impl::xml_document_struct) + page_offset <= sizeof(_memory));

		// prepare page structure
		impl::xml_memory_page* page = impl::xml_memory_page::construct(_memory);
		assert(page);

		page->busy_size = impl::xml_memory_page_size;

		// setup first page marker
	#ifdef PUGIXML_COMPACT
		// round-trip through void* to avoid 'cast increases required alignment of target type' warning
		page->compact_page_marker = reinterpret_cast<uint32_t*>(static_cast<void*>(reinterpret_cast<char*>(page) + sizeof(impl::xml_memory_page)));
		*page->compact_page_marker = sizeof(impl::xml_memory_page);
	#endif

		// allocate new root
		_root = new (reinterpret_cast<char*>(page) + sizeof(impl::xml_memory_page) + page_offset) impl::xml_document_struct(page);
		_root->prev_sibling_c = _root;

		// setup sentinel page
		page->allocator = static_cast<impl::xml_document_struct*>(_root);

		// verify the document allocation
		assert(reinterpret_cast<char*>(_root) + sizeof(impl::xml_document_struct) <= _memory + sizeof(_memory));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xced3
jmp 0xced5
jmp 0xcef4
leaq 0x5226e(%rip), %rdi     # 0x5f14a
leaq 0x51c92(%rip), %rsi     # 0x5eb75
movl $0x1ab7, %edx           # imm = 0x1AB7
leaq 0x52262(%rip), %rcx     # 0x5f151
callq 0x5310
movq -0x20(%rbp), %rdi
movq $0x0, -0x10(%rbp)
addq $0x10, %rdi
callq 0xd260
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcf16
jmp 0xcf35
leaq 0x5296d(%rip), %rdi     # 0x5f88a
leaq 0x51c51(%rip), %rsi     # 0x5eb75
movl $0x1ac4, %edx           # imm = 0x1AC4
leaq 0x52221(%rip), %rcx     # 0x5f151
callq 0x5310
movq -0x18(%rbp), %rax
movq $0x7fd8, 0x18(%rax)     # imm = 0x7FD8
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0xd2c0
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdx
movq (%rax), %rcx
movq %rdx, 0x28(%rcx)
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x28(%rbp)
je 0xcf8a
movq -0x30(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq %rdx, (%rax)
movq (%rcx), %rax
addq $0x60, %rax
addq $0x10, %rcx
addq $0xc0, %rcx
cmpq %rcx, %rax
ja 0xcfb2
jmp 0xcfd1
leaq 0x521ba(%rip), %rdi     # 0x5f173
leaq 0x51bb5(%rip), %rsi     # 0x5eb75
movl $0x1ad7, %edx           # imm = 0x1AD7
leaq 0x52185(%rip), %rcx     # 0x5f151
callq 0x5310
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0xf108
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf13f
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rax
addq $0x8, %rcx
cmpq %rcx, %rax
je 0xf12a
movq -0x20(%rbp), %rcx
movq 0x7342c(%rip), %rax     # 0x82550
movq 0x18(%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xee00
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf918
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rsi
callq 0xff60
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf8ec
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x210(%rbp), %rdi
callq 0xf840
movq $0x0, -0x218(%rbp)
cmpq $0x40, -0x218(%rbp)
jae 0xfa4a
movq -0x10(%rbp), %rax
movq -0x218(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xfa31
movq -0x10(%rbp), %rcx
movq -0x218(%rbp), %rax
movq (%rcx,%rax,8), %rdi
leaq -0x210(%rbp,%rax,8), %rsi
callq 0xfbc0
movb %al, -0x231(%rbp)
jmp 0xf9f9
movb -0x231(%rbp), %al
testb $0x1, %al
jne 0xfa31
jmp 0xfa05
movl $0x1, -0x228(%rbp)
jmp 0xfa69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x210(%rbp), %rdi
callq 0xf880
jmp 0xfa7e
jmp 0xfa33
movq -0x218(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x218(%rbp)
jmp 0xf9b5
movq -0x230(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0xfc70
jmp 0xfa5f
movl $0x0, -0x228(%rbp)
leaq -0x210(%rbp), %rdi
callq 0xf880
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x5920
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x40, -0x18(%rbp)
jae 0xfbae
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xf8e0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xfb60
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xfc5d
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf4e0
movl -0x2c(%rbp), %edi
movq %rax, %rsi
callq 0xfe00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xfc0d
movb $0x0, -0x1(%rbp)
jmp 0xfc61
cmpq $0x0, -0x20(%rbp)
je 0xfc22
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xfc2d
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfe90
testb $0x1, %al
jne 0xfc4c
movb $0x0, -0x1(%rbp)
jmp 0xfc61
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xfbd8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x40, -0x18(%rbp)
jae 0xfcd5
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xfc8c
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x40, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xfd80
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
andq $0x3f, %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xfd61
movq -0x30(%rbp), %rdi
callq 0xf4e0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x7970
testb $0x1, %al
jne 0xfd47
jmp 0xfd51
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfd69
jmp 0xfd53
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xfd25
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_ast_node::optimize(pugi::impl::(anonymous namespace)::xpath_allocator*)
void optimize(xpath_allocator* alloc)
		{
			if (_left) _left->optimize(alloc);
			if (_right) _right->optimize(alloc);
			if (_next) _next->optimize(alloc);

			optimize_self(alloc);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x10510
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x104e0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1052c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x104e0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x10548
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x104e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21c90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_query::xpath_query(pugi::xpath_query&&)
PUGI__FN xpath_query::xpath_query(xpath_query&& rhs)
	{
		_impl = rhs._impl;
		_result = rhs._result;
		rhs._impl = 0;
		rhs._result = xpath_parse_result();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
callq 0xf440
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
leaq -0x20(%rbp), %rdi
callq 0xf440
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x106d8
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10740
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x106ee
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x10430
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
leaq -0x28(%rbp), %rdi
callq 0xf440
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movq -0x20(%rbp), %rdx
movq %rdx, 0x10(%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20b0, %rsp           # imm = 0x20B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20a0(%rbp)
cmpq $0x0, (%rax)
jne 0x107dd
movb $0x0, -0x1(%rbp)
jmp 0x10863
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x20b0(%rbp)
movl $0x1, %ecx
movq %rcx, %rdx
callq 0x10880
leaq -0x2088(%rbp), %rdi
callq 0x108c0
movq -0x20a0(%rbp), %rax
movq -0x20b0(%rbp), %rsi
movq (%rax), %rax
movq (%rax), %rdi
leaq -0x48(%rbp), %rdx
callq 0x10960
movb %al, -0x20a1(%rbp)
jmp 0x1082a
movb -0x20a1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x2088(%rbp), %rdi
callq 0x112c0
jmp 0x10863
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2090(%rbp)
movl %eax, -0x2094(%rbp)
leaq -0x2088(%rbp), %rdi
callq 0x112c0
jmp 0x10871
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20b0, %rsp           # imm = 0x20B0
popq %rbp
retq
movq -0x2090(%rbp), %rdi
callq 0x5920
nopl (%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::xpath_stack_data::xpath_stack_data()
xpath_stack_data(): result(blocks + 0), temp(blocks + 1)
		{
			blocks[0].next = blocks[1].next = 0;
			blocks[0].capacity = blocks[1].capacity = sizeof(blocks[0].data);

			stack.result = &result;
			stack.temp = &temp;

		#ifdef PUGIXML_NO_EXCEPTIONS
			result.error_handler = temp.error_handler = &error_handler;
		#endif
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x10(%rbp)
movq %rsi, %rdi
addq $0x2020, %rdi           # imm = 0x2020
xorl %eax, %eax
movl %eax, %edx
callq 0x1e600
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x2030, %rdi           # imm = 0x2030
addq $0x1010, %rsi           # imm = 0x1010
xorl %eax, %eax
movl %eax, %edx
callq 0x1e600
movq -0x10(%rbp), %rax
movq $0x0, 0x1010(%rax)
movq $0x0, (%rax)
movq $0x1000, 0x1018(%rax) # imm = 0x1000
movq $0x1000, 0x8(%rax)      # imm = 0x1000
movq %rax, %rcx
addq $0x2020, %rcx           # imm = 0x2020
movq %rcx, 0x2040(%rax)
movq %rax, %rcx
addq $0x2030, %rcx           # imm = 0x2030
movq %rcx, 0x2048(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_query::evaluate_number(pugi::xpath_node const&) const
PUGI__FN double xpath_query::evaluate_number(const xpath_node& n) const
	{
		if (!_impl) return impl::gen_nan();

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

	#ifdef PUGIXML_NO_EXCEPTIONS
		if (setjmp(sd.error_handler)) return impl::gen_nan();
	#endif

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20b0, %rsp           # imm = 0x20B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20a0(%rbp)
cmpq $0x0, (%rax)
jne 0x11343
callq 0xf600
movsd %xmm0, -0x8(%rbp)
jmp 0x113cd
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x20b0(%rbp)
movl $0x1, %ecx
movq %rcx, %rdx
callq 0x10880
leaq -0x2088(%rbp), %rdi
callq 0x108c0
movq -0x20a0(%rbp), %rax
movq -0x20b0(%rbp), %rsi
movq (%rax), %rax
movq (%rax), %rdi
leaq -0x48(%rbp), %rdx
callq 0x113f0
movsd %xmm0, -0x20a8(%rbp)
jmp 0x11392
movsd -0x20a8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
leaq -0x2088(%rbp), %rdi
callq 0x112c0
jmp 0x113cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2090(%rbp)
movl %eax, -0x2094(%rbp)
leaq -0x2088(%rbp), %rdi
callq 0x112c0
jmp 0x113db
movsd -0x8(%rbp), %xmm0
addq $0x20b0, %rsp           # imm = 0x20B0
popq %rbp
retq
movq -0x2090(%rbp), %rdi
callq 0x5920
nopw (%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::evaluate_string_impl(pugi::impl::(anonymous namespace)::xpath_query_impl*, pugi::xpath_node const&, pugi::impl::(anonymous namespace)::xpath_stack_data&)
PUGI__FN xpath_string evaluate_string_impl(xpath_query_impl* impl, const xpath_node& n, xpath_stack_data& sd)
	{
		if (!impl) return xpath_string();

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

		xpath_context c(n, 1, 1);

		return impl->root->eval_string(c, sd.stack);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11f5e
movq -0x48(%rbp), %rdi
callq 0x25fb0
jmp 0x11f92
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x1, %ecx
movq %rcx, %rdx
callq 0x10880
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rcx
addq $0x2040, %rcx           # imm = 0x2040
leaq -0x38(%rbp), %rdx
callq 0x24550
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_query::evaluate_string(char*, unsigned long, pugi::xpath_node const&) const
PUGI__FN size_t xpath_query::evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const
	{
		impl::xpath_stack_data sd;

		impl::xpath_string r = impl::evaluate_string_impl(static_cast<impl::xpath_query_impl*>(_impl), n, sd);

		size_t full_size = r.length() + 1;

		if (capacity > 0)
		{
			size_t size = (full_size < capacity) ? full_size : capacity;
			assert(size > 0);

			memcpy(buffer, r.c_str(), (size - 1) * sizeof(char_t));
			buffer[size - 1] = 0;
		}

		return full_size;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20e0, %rsp           # imm = 0x20E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20b8(%rbp)
leaq -0x2070(%rbp), %rdi
movq %rdi, -0x20b0(%rbp)
callq 0x108c0
movq -0x20b8(%rbp), %rax
movq -0x20b0(%rbp), %rcx
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
leaq -0x2088(%rbp), %rdi
callq 0x11f30
jmp 0x1206c
leaq -0x2088(%rbp), %rdi
callq 0x11fc0
movq %rax, -0x20c0(%rbp)
jmp 0x12081
movq -0x20c0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20a0(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x12174
movq -0x20a0(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x120bb
movq -0x20a0(%rbp), %rax
movq %rax, -0x20c8(%rbp)
jmp 0x120c6
movq -0x18(%rbp), %rax
movq %rax, -0x20c8(%rbp)
movq -0x20c8(%rbp), %rax
movq %rax, -0x20a8(%rbp)
cmpq $0x0, -0x20a8(%rbp)
jbe 0x120e0
jmp 0x1211f
leaq 0x4d3c8(%rip), %rdi     # 0x5f4af
leaq 0x4ca87(%rip), %rsi     # 0x5eb75
movl $0x309d, %edx           # imm = 0x309D
leaq 0x4d3be(%rip), %rcx     # 0x5f4b8
callq 0x5310
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2090(%rbp)
movl %eax, -0x2094(%rbp)
leaq -0x2070(%rbp), %rdi
callq 0x112c0
jmp 0x1219e
movq -0x10(%rbp), %rax
movq %rax, -0x20d8(%rbp)
leaq -0x2088(%rbp), %rdi
callq 0x11fa0
movq %rax, -0x20d0(%rbp)
jmp 0x1213f
movq -0x20d0(%rbp), %rsi
movq -0x20d8(%rbp), %rdi
movq -0x20a8(%rbp), %rdx
subq $0x1, %rdx
shlq $0x0, %rdx
callq 0x5400
movq -0x10(%rbp), %rax
movq -0x20a8(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20a0(%rbp), %rax
movq %rax, -0x20e0(%rbp)
leaq -0x2070(%rbp), %rdi
callq 0x112c0
movq -0x20e0(%rbp), %rax
addq $0x20e0, %rsp           # imm = 0x20E0
popq %rbp
retq
movq -0x2090(%rbp), %rdi
callq 0x5920
nopw (%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_query::evaluate_node_set(pugi::xpath_node const&) const
PUGI__FN xpath_node_set xpath_query::evaluate_node_set(const xpath_node& n) const
	{
		impl::xpath_ast_node* root = impl::evaluate_node_set_prepare(static_cast<impl::xpath_query_impl*>(_impl));
		if (!root) return xpath_node_set();

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

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

		impl::xpath_node_set_raw r = root->eval_node_set(c, sd.stack, impl::nodeset_eval_all);

		return xpath_node_set(r.begin(), r.end(), r.type());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20f0, %rsp           # imm = 0x20F0
movq %rdi, -0x20d0(%rbp)
movq %rdi, %rax
movq %rax, -0x20c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x12300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12200
movq -0x20d0(%rbp), %rdi
callq 0xeec0
jmp 0x122d6
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x20d8(%rbp)
movl $0x1, %ecx
movq %rcx, %rdx
callq 0x10880
leaq -0x2090(%rbp), %rdi
callq 0x108c0
movq -0x20d8(%rbp), %rdx
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rcx
leaq -0x20b0(%rbp), %rdi
xorl %r8d, %r8d
callq 0x123c0
jmp 0x12248
leaq -0x20b0(%rbp), %rdi
callq 0x12a30
movq %rax, -0x20e0(%rbp)
jmp 0x1225d
leaq -0x20b0(%rbp), %rdi
callq 0x12a50
movq %rax, -0x20e8(%rbp)
jmp 0x12272
leaq -0x20b0(%rbp), %rdi
callq 0x12a70
movl %eax, -0x20ec(%rbp)
jmp 0x12286
movl -0x20ec(%rbp), %ecx
movq -0x20e8(%rbp), %rdx
movq -0x20e0(%rbp), %rsi
movq -0x20d0(%rbp), %rdi
callq 0xef10
jmp 0x122a8
leaq -0x2090(%rbp), %rdi
callq 0x112c0
jmp 0x122d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20b8(%rbp)
movl %eax, -0x20bc(%rbp)
leaq -0x2090(%rbp), %rdi
callq 0x112c0
jmp 0x122e6
movq -0x20c8(%rbp), %rax
addq $0x20f0, %rsp           # imm = 0x20F0
popq %rbp
retq
movq -0x20b8(%rbp), %rdi
callq 0x5920
nopw %cs:(%rax,%rax)
// File: adamiaonr[P]rid-analytics/src/pugixml.cpp
// Function: pugi::xpath_query::evaluate_node(pugi::xpath_node const&) const
PUGI__FN xpath_node xpath_query::evaluate_node(const xpath_node& n) const
	{
		impl::xpath_ast_node* root = impl::evaluate_node_set_prepare(static_cast<impl::xpath_query_impl*>(_impl));
		if (!root) return xpath_node();

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

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

		impl::xpath_node_set_raw r = root->eval_node_set(c, sd.stack, impl::nodeset_eval_first);

		return r.first();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20e0, %rsp           # imm = 0x20E0
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x12300
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12ab8
leaq -0x10(%rbp), %rdi
callq 0xe990
jmp 0x12b63
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x20d0(%rbp)
movl $0x1, %ecx
movq %rcx, %rdx
callq 0x10880
leaq -0x2098(%rbp), %rdi
callq 0x108c0
movq -0x20d0(%rbp), %rdx
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rcx
leaq -0x20b8(%rbp), %rdi
movl $0x2, %r8d
callq 0x123c0
jmp 0x12b03
leaq -0x20b8(%rbp), %rdi
callq 0x12b80
movq %rdx, -0x20e0(%rbp)
movq %rax, -0x20d8(%rbp)
jmp 0x12b1f
movq -0x20e0(%rbp), %rax
movq -0x20d8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x2098(%rbp), %rdi
callq 0x112c0
jmp 0x12b63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20c0(%rbp)
movl %eax, -0x20c4(%rbp)
leaq -0x2098(%rbp), %rdi
callq 0x112c0
jmp 0x12b74
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20e0, %rsp           # imm = 0x20E0
popq %rbp
retq
movq -0x20c0(%rbp), %rdi
callq 0x5920