LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/adhipradhana[P]sliding-window-protocol/src/packet.cpp
// Function: read_packet(char*, unsigned int*, unsigned long*, char*, bool*, bool*)
void read_packet(char* packet, unsigned int* seq_num, size_t* data_length, char* data, bool* is_check_sum_valid, bool* eot) {
	// convert data
	unsigned int network_seq_num;
	unsigned int network_data_length;

	// byte copy
	memcpy(&network_seq_num, packet+1, 4);
	memcpy(&network_data_length, packet+5, 4);

	*seq_num = ntohl(network_seq_num);
	*data_length = ntohl(network_data_length);

	memcpy(data, packet+9, *data_length);

	char sender_check_sum = packet[9 + *data_length];
	char checksum = count_checksum(*data_length, data);

	*is_check_sum_valid = sender_check_sum == checksum;

	*eot = packet[0] == 0x0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
movl 0x1(%rdi), %eax
movl 0x5(%rdi), %edx
bswapl %eax
movl %eax, (%rsi)
bswapl %edx
movq %rdx, (%r13)
leaq 0x9(%rdi), %rsi
movq %rcx, %rdi
callq 0x10d0
movq (%r13), %rcx
movb 0x9(%r15,%rcx), %al
testq %rcx, %rcx
je 0x1449
xorl %esi, %esi
xorl %edx, %edx
movsbq (%r12,%rsi), %rdi
addq %rdx, %rdi
movzbl %dil, %edx
incq %rdx
testl $0xff00, %edi           # imm = 0xFF00
cmoveq %rdi, %rdx
incq %rsi
cmpq %rsi, %rcx
jne 0x1424
notb %dl
jmp 0x144b
movb $-0x1, %dl
cmpb %dl, %al
sete (%r14)
cmpb $0x0, (%r15)
sete (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/adhipradhana[P]sliding-window-protocol/src/ack.cpp
// Function: create_ack(char*, unsigned int, bool)
void create_ack(char *ack, unsigned int seq_num, bool is_check_sum_valid){
	
	if(is_check_sum_valid)
		ack[0] = 0x0;
	else
		ack[0] = 0x1;

	uint32_t net_seq_num = htonl(seq_num);
	memcpy(ack + 1, &net_seq_num, 4);
	ack[5] = count_checksum((size_t)4, (char *) &seq_num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0xc(%rbp), %rax
movl %esi, (%rax)
xorb $0x1, %dl
movb %dl, (%rdi)
bswapl %esi
movl %esi, 0x1(%rdi)
movl $0x4, %edi
movq %rax, %rsi
callq 0x13a4
movb %al, 0x5(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/adhipradhana[P]sliding-window-protocol/src/ack.cpp
// Function: read_ack(char*, bool*, unsigned int*, bool*)
void read_ack(char *ack, bool* is_nak, unsigned int *seq_num, bool *is_check_sum_valid){
	
	if(ack[0] == 0x0)
		*is_nak = false;
	else
		*is_nak = true;

	uint32_t net_seq_num;
	memcpy(&net_seq_num, ack + 1, 4);
	*seq_num = ntohl(net_seq_num);

	*is_check_sum_valid = ack[5] == count_checksum((size_t)4, (char *) seq_num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
cmpb $0x0, (%rdi)
setne (%rsi)
movl 0x1(%rdi), %eax
bswapl %eax
movl %eax, (%rdx)
movb 0x5(%rdi), %r14b
movl $0x4, %edi
movq %rdx, %rsi
callq 0x13a4
cmpb %al, %r14b
sete (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/porzell[P]PTest/examples/unit_test.cpp
// Function: CanReserveVector22()
P_TEST(CanReserveVector) {
    std::vector<int> vec;
    vec.reserve(10);
    
    P_ASSERT(vec.capacity() >= 10);
    P_ASSERT(vec.size() == 0);
    
    for(int i = 0; i < 11; ++i) {
        vec.push_back(3);
    }
    
    P_ASSERT(vec.capacity() > 10);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0xa, %esi
callq 0x4378
movq -0x30(%rbp), %r15
subq -0x40(%rbp), %r15
xorl %r14d, %r14d
cmpq $0x25, %r15
setae %r14b
callq 0x2c5e
movq %rax, %rbx
leaq 0x283e(%rip), %rdx      # 0x50f3
leaq 0x2937(%rip), %r8       # 0x51f3
leaq -0x198(%rbp), %rdi
movl %r14d, %esi
movl $0x1a, %ecx
xorl %r9d, %r9d
callq 0x3cfc
leaq -0x198(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3bc2
leaq -0x198(%rbp), %rdi
callq 0x3976
cmpq $0x24, %r15
jbe 0x29fb
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r12
xorl %r14d, %r14d
cmpq %r15, %r12
sete %r14b
callq 0x2c5e
movq %rax, %rbx
leaq 0x27d8(%rip), %rdx      # 0x50f3
leaq 0x28e6(%rip), %r8       # 0x5208
leaq -0x128(%rbp), %rdi
movl %r14d, %esi
movl $0x1b, %ecx
xorl %r9d, %r9d
callq 0x3cfc
leaq -0x128(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3bc2
leaq -0x128(%rbp), %rdi
callq 0x3976
cmpq %r15, %r12
jne 0x29fb
movl $0xb, %r15d
leaq -0x40(%rbp), %rbx
leaq -0x44(%rbp), %r14
movl $0x3, -0x44(%rbp)
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x298e
movl $0x3, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x2999
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3dc4
decl %r15d
jne 0x296d
movq -0x30(%rbp), %rax
subq -0x40(%rbp), %rax
xorl %r14d, %r14d
cmpq $0x29, %rax
setae %r14b
callq 0x2c5e
movq %rax, %rbx
leaq 0x2733(%rip), %rdx      # 0x50f3
leaq 0x2851(%rip), %r8       # 0x5218
leaq -0xb8(%rbp), %rdi
movl %r14d, %esi
movl $0x21, %ecx
xorl %r9d, %r9d
callq 0x3cfc
leaq -0xb8(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3bc2
leaq -0xb8(%rbp), %rdi
callq 0x3976
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2a09
callq 0x2140
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
jmp 0x2a3f
jmp 0x2a4a
movq %rax, %rbx
leaq -0x128(%rbp), %rdi
jmp 0x2a3f
jmp 0x2a4a
movq %rax, %rbx
leaq -0x198(%rbp), %rdi
callq 0x3976
jmp 0x2a4d
jmp 0x2a4a
jmp 0x2a4a
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2a5b
callq 0x2140
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/porzell[P]PTest/examples/unit_test.cpp
// Function: CanInsertVector36()
P_TEST(CanInsertVector) {
    std::vector<int> vec;
    
    for(int i = 0; i < 10; ++i) {
        vec.push_back(i);
    }
    
    for(int i = 0; i < 10; ++i) {
        P_ASSERT(vec[i] == i);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x2c(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x2aac
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x2ab7
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4410
movl -0x2c(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x9, %ecx
jl 0x2a96
xorl %ebx, %ebx
leaq -0xc0(%rbp), %r15
movq -0x50(%rbp), %rax
movl (%rax,%rbx,4), %r14d
xorl %r13d, %r13d
cmpq %r14, %rbx
sete %r13b
callq 0x2c5e
movq %rax, %r12
movq %r15, %rdi
movl %r13d, %esi
leaq 0x25fe(%rip), %rdx      # 0x50f3
movl $0x2c, %ecx
leaq 0x273b(%rip), %r8       # 0x523c
xorl %r9d, %r9d
callq 0x3cfc
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3bc2
movq %r15, %rdi
callq 0x3976
cmpq %r14, %rbx
jne 0x2b30
leaq 0x1(%rbx), %rax
cmpq $0x9, %rbx
movq %rax, %rbx
jne 0x2ace
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2b3e
callq 0x2140
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b52
movq %rax, %rbx
jmp 0x2b66
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x3976
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2b74
callq 0x2140
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/jaxonwang[P]suffixtree/main.cc
// Function: rand_str[abi:cxx11](unsigned long)
string rand_str(size_t length) {
  stringstream ss;
  for (size_t i = 0; i < length; i++) {
    ss << static_cast<char>('a' + rand() % 26);
  }
  return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x2110
testq %r14, %r14
je 0x24cf
leaq -0x1a0(%rbp), %r15
leaq -0x21(%rbp), %r12
callq 0x2050
cltq
imulq $0x4ec4ec4f, %rax, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x23, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %edx
leal (%rdx,%rdx,4), %edx
addl %ecx, %edx
subl %edx, %eax
addb $0x61, %al
movb %al, -0x21(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
decq %r14
jne 0x2490
leaq -0x198(%rbp), %rsi
movq %rbx, %rdi
callq 0x2240
movq 0x5ac3(%rip), %rsi      # 0x7fa8
leaq -0x1b0(%rbp), %rdi
callq 0x2140
leaq -0x130(%rbp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2512
movq %rax, %rbx
movq 0x5a8c(%rip), %rsi      # 0x7fa8
leaq -0x1b0(%rbp), %rdi
callq 0x2140
leaq -0x130(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/jaxonwang[P]suffixtree/main.cc
// Function: SuffixTreeNaive::build()
void build() {
    for (size_t i = 0; i <= textlen; i++) {
      int j = i;
      internal_node_ptr current_node = root;

      while (true) { // will eventually create a leaf
        CharT current_char = text[j];

        auto &nextedge_ptr = current_node->next_edge(current_char);
        if (!nextedge_ptr) {
          new_leaf(current_node, j, textlen);
          goto end_insert_i;
        }

        size_t start = nextedge_ptr->start_position();
        size_t end = nextedge_ptr->end_position();
        for (; start <= end; start++, j++) {
          if (text[start] != text[j]) {
            auto new_node = break_edge(current_node, current_char, start - 1);
            new_leaf(new_node, j, textlen); // include the term symbol
            goto end_insert_i;
          }
        }
        current_node = dynamic_cast<internal_node_ptr>(
            current_node->next_node(current_char));
        if (!current_node)
          throw std::logic_error("Goes to Leaf!");
      }

    end_insert_i:;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, -0x40(%rbp)
xorl %ecx, %ecx
movq 0x28(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rcx, -0x48(%rbp)
movl %ecx, %r15d
movslq %r15d, %r12
movq (%rbx), %rax
movq -0x30(%rbp), %rdi
movsbl (%rax,%r12), %r13d
movl %r13d, %esi
callq 0x303c
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2921
movq %rax, %r14
movl %r15d, -0x34(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r15
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpq %rax, %r15
ja 0x28f6
movq (%rbx), %rcx
movb (%rcx,%r15), %dl
cmpb (%rcx,%r12), %dl
jne 0x294b
incq %r15
incq %r12
cmpq %rax, %r15
jbe 0x28dd
movl %r12d, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movl %r13d, %esi
callq 0x3394
testq %rax, %rax
je 0x2938
movq %rax, %rdi
leaq 0x532f(%rip), %rsi      # 0x7c40
leaq 0x5350(%rip), %rdx      # 0x7c68
xorl %ecx, %ecx
callq 0x21b0
jmp 0x293a
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
movq %r12, %rdx
movq -0x40(%rbp), %rcx
callq 0x308c
xorl %ecx, %ecx
jmp 0x297c
xorl %eax, %eax
movq %rax, -0x30(%rbp)
movb $0x1, %cl
testq %rax, %rax
movl -0x34(%rbp), %r15d
jne 0x297c
jmp 0x29a7
decq %r15
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
movl %r13d, %edx
movq %r15, %rcx
callq 0x318e
movq %rax, -0x50(%rbp)
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
movq %r12, %rdx
movq -0x40(%rbp), %rcx
callq 0x308c
xorl %ecx, %ecx
movl %r12d, %r15d
testb %cl, %cl
jne 0x289d
movq -0x48(%rbp), %rcx
incq %rcx
movq -0x40(%rbp), %rax
cmpq (%rax), %rcx
jbe 0x288e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x26e8(%rip), %rsi      # 0x50a3
movq %rax, %rdi
callq 0x2200
movq 0x5616(%rip), %rsi      # 0x7fe0
movq 0x55f7(%rip), %rdx      # 0x7fc8
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/jaxonwang[P]suffixtree/main.cc
// Function: SuffixTreeImpl::build()
void build() { // S[j,i)
    internal_node_ptr longest_node = root;
    internal_node_ptr node_to_start = longest_node;

    size_type j_start_with = 0;
    size_type start_depth = 0;

    for (size_type i = 0; i <= textlen; i++) {
      leaf_end_pos = i;
      internal_node_ptr node_to_update_suffix_link = nullptr;

      // find the depth of the longest_node

      for (size_type j = j_start_with; j <= i; j++) {

        internal_node_ptr stop_node;
        internal_node_ptr suffix_link_node;
        size_type travel_depth;
        auto ret =
            travel_down_and_extend(node_to_start, j + start_depth, i, stop_node,
                                   suffix_link_node, travel_depth);

        if (node_to_update_suffix_link) {
          // set suffix link
          node_to_update_suffix_link->set_suffix_link(suffix_link_node);
        }

        if (ret == ExtensionType::newnode) { // need to specify suffix link must
                                             // be updated
          node_to_update_suffix_link = suffix_link_node;
        } else {
          node_to_update_suffix_link = nullptr;
        }

        if (ret != ExtensionType::extendleaf) { // new leaf is created
          j_start_with = j + 1;
          node_to_start = stop_node->get_suffix_link(); // next to start
          start_depth += (stop_node == root) ? 0 : travel_depth - 1;
        } else { // no need for the future extend , since they must be extesion
                 // type 3
          break;
        }
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
leaq -0x40(%rbp), %rcx
movq %rax, (%rcx)
xorl %r14d, %r14d
xorl %r13d, %r13d
xorl %r15d, %r15d
movq %r13, 0x48(%rbx)
cmpq %r13, %r14
movq %r14, -0x30(%rbp)
ja 0x2aa0
xorl %r12d, %r12d
leaq (%r15,%r14), %rdx
leaq -0x48(%rbp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
movq %r13, %rcx
leaq -0x50(%rbp), %r8
leaq -0x38(%rbp), %r9
callq 0x3c96
testq %r12, %r12
je 0x2a55
movq -0x38(%rbp), %rcx
movq %rcx, 0x78(%r12)
cmpl $0x1, %eax
jne 0x2a60
movq -0x38(%rbp), %r12
jmp 0x2a63
xorl %r12d, %r12d
cmpl $0x2, %eax
je 0x2a93
leaq 0x1(%r14), %rcx
movq %rcx, -0x30(%rbp)
movq -0x50(%rbp), %rcx
movq 0x78(%rcx), %rdx
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rdx
decq %rdx
cmpq 0x28(%rbx), %rcx
movl $0x0, %ecx
cmovneq %rdx, %rcx
addq %rcx, %r15
cmpl $0x2, %eax
je 0x2aa0
incq %r14
cmpq %r13, %r14
jbe 0x2a24
incq %r13
cmpq 0x20(%rbx), %r13
movq -0x30(%rbp), %r14
jbe 0x2a14
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jaxonwang[P]suffixtree/main.cc
// Function: NonLeaf::next_edge(char)
edge_ptr &next_edge(const CharT c) {
    static edge_ptr empty_edge{};
    if (adj_edges.count(c))
      return adj_edges[c];
    return empty_edge;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
movb 0x5139(%rip), %al       # 0x8188
testb %al, %al
je 0x3084
addq $0x40, %rbx
leaq -0x9(%rbp), %rsi
movq %rbx, %rdi
callq 0x33d2
testq %rax, %rax
je 0x3076
leaq -0x9(%rbp), %rsi
movq %rbx, %rdi
callq 0x345e
jmp 0x307d
leaq 0x5103(%rip), %rax      # 0x8180
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x22e4
jmp 0x3053
nop
// File: /workspace/github_cpp_makefile_star2_O1/jaxonwang[P]suffixtree/main.cc
// Function: SuffixTreeBase::new_leaf(InternalNode*&, unsigned long, unsigned long const&)
void new_leaf(internal_node_ptr &current_node, const size_type start_pos,
                const size_type &end_pos) {
    const CharT c = text[start_pos];
    current_node->adj_edges[c] =
        std::unique_ptr<Edge>{new LeafEdge{start_pos, end_pos}};

    std::unique_ptr<Leaf> newleaf_ptr{new Leaf{}};
    current_node->children[c] = newleaf_ptr.get();
    node_holder.push_back(move(newleaf_ptr));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movb (%rax,%rdx), %al
leaq -0x29(%rbp), %rcx
movb %al, (%rcx)
movl $0x18, %edi
callq 0x21a0
movq %rax, %r15
leaq 0x4be7(%rip), %rax      # 0x7cb0
movq %rax, (%r15)
movq %r13, 0x8(%r15)
movq %r12, 0x10(%r15)
movq (%r14), %rdi
addq $0x40, %rdi
leaq -0x29(%rbp), %rsi
callq 0x345e
movq (%rax), %rdi
movq %r15, (%rax)
testq %rdi, %rdi
je 0x30f5
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x10, %edi
callq 0x21a0
movq %rax, %r15
leaq 0x4c67(%rip), %rax      # 0x7d70
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
movq (%r14), %rdi
addq $0x8, %rdi
leaq -0x29(%rbp), %rsi
callq 0x3980
movq %r15, (%rax)
addq $0x30, %rbx
leaq -0x38(%rbp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x2ec0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x3149
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x316a
movq (%rdi), %rax
callq *0x8(%rax)
xorl %r15d, %r15d
jmp 0x3172
movq %rax, %rbx
testq %r15, %r15
jne 0x317c
jmp 0x3185
movq %rax, %rbx
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O1/jaxonwang[P]suffixtree/main.cc
// Function: LeafEdge::break_edge(unsigned long) const
virtual std::pair<edge_ptr, edge_ptr>
  break_edge(const size_type pos) const override {
    if (pos < start_pos || pos >= end_pos)
      throw std::logic_error("bad pos");
    auto new_first = edge_ptr{new InternalEdge(start_pos, pos)};
    auto new_second = edge_ptr{new LeafEdge(pos + 1, end_pos)};
    return make_pair(move(new_first), move(new_second));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r13
cmpq %rdx, %r13
ja 0x382a
movq %rdx, %r14
movq 0x10(%rsi), %r12
cmpq %rdx, (%r12)
jbe 0x382a
movq %rdi, %rbx
movl $0x18, %edi
callq 0x21a0
movq %rax, %r15
leaq 0x4531(%rip), %rax      # 0x7d18
movq %rax, (%r15)
movq %r13, 0x8(%r15)
movq %r14, 0x10(%r15)
movl $0x18, %edi
callq 0x21a0
incq %r14
leaq 0x44aa(%rip), %rcx      # 0x7cb0
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x1873(%rip), %rsi      # 0x50b1
movq %rax, %rdi
callq 0x2200
movq 0x4793(%rip), %rsi      # 0x7fe0
movq 0x4774(%rip), %rdx      # 0x7fc8
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %r15, %rdi
callq 0x2180
jmp 0x3874
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/solver/hca.h
// Function: HCA::logStr[abi:cxx11]()
std::string logStr() {
    std::string str;
    str += "[solver] type:HCA\n";
    str += Solver::logStr();
    return str;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x3ce96(%rip), %rsi     # 0x4856f
callq 0x6690
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3f790
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb715
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb747
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
jmp 0xb747
jmp 0xb744
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xb75a
movq (%r15), %rsi
incq %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/agent/agent.cpp
// Function: Agent::Agent()
Agent::Agent() : id(cntId) {
  ++cntId;
  g = nullptr;
  tau = nullptr;
  updated = false;
  beforeNode = nullptr;
}

// Assembly:
movl 0x4969a(%rip), %eax     # 0x627bc
movl %eax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x30(%rdi)
incl %eax
movl %eax, 0x49683(%rip)     # 0x627bc
movb $0x0, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movups %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/agent/agent.cpp
// Function: Agent::Agent(Node*)
Agent::Agent(Node* _v) : id(cntId) {
  ++cntId;
  g = nullptr;
  tau = nullptr;
  v = nullptr;
  setNode(_v);
  updated = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x49668(%rip), %eax     # 0x627bc
movl %eax, (%rdi)
leaq 0x20(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x30(%rdi)
incl %eax
movl %eax, 0x4964d(%rip)     # 0x627bc
movq %rcx, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
callq 0x191a6
movb $0x0, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1919d
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/agent/agent.cpp
// Function: Agent::setNode(Node*)
void Agent::setNode(Node* _v) {
  // error check
  if (v != nullptr) {
    auto neigh = v->getNeighbor();
    if (!(_v == v || inArray(_v, neigh))) {
      std::cout << "error@Agent, set invalid node, from "
                << v->getId() << " to " << _v->getId() << std::endl;
      std::exit(1);
    }
  }

  beforeNode = v;
  v = _v;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x19205
addq $0x8, %rsi
leaq 0x8(%rsp), %rdi
callq 0x19a68
cmpq %rbx, 0x8(%r14)
je 0x191ee
leaq 0x20(%rsp), %rdx
movq %rbx, (%rdx)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x19ae8
cmpq 0x10(%rsp), %rax
je 0x19219
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19205
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x8(%r14), %rax
movq %rax, 0x40(%r14)
movq %rbx, 0x8(%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x48d88(%rip), %rdi     # 0x61fa8
leaq 0x3026a(%rip), %rsi     # 0x49491
movl $0x24, %edx
callq 0x63f0
movq 0x8(%r14), %rax
movl (%rax), %esi
movq 0x48d6a(%rip), %rdi     # 0x61fa8
callq 0x6610
movq %rax, %r14
leaq 0x32564(%rip), %rsi     # 0x4b7b1
movl $0x4, %edx
movq %rax, %rdi
callq 0x63f0
movl (%rbx), %esi
movq %r14, %rdi
callq 0x6610
movq %rax, %rdi
callq 0x61c0
movl $0x1, %edi
callq 0x6440
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19290
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/agent/agent.cpp
// Function: Agent::updateHist()
void Agent::updateHist() {
  AgentStatus* s = new AgentStatus;
  s->v = v;
  if (hasGoal()) {
    s->g = g;
  } else {
    s->g = nullptr;
  }
  if (hasTask()) {
    s->tau = tau;
  } else {
    s->tau = nullptr;
  }
  hist.push_back(s);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x18, %edi
callq 0x6370
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x19332
movq %rax, (%rsi)
addq $0x8, 0x28(%rbx)
jmp 0x19343
addq $0x20, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x19b88
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/graph/graph.cpp
// Function: Graph::~Graph()
Graph::~Graph() {
  for (auto v : nodes) delete v;
  nodes.clear();
  for (auto p : knownPaths) delete p.second;
  knownPaths.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x476f5(%rip), %rax     # 0x61590
movq %rax, (%rdi)
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
cmpq %r12, %r15
je 0x19edb
movq (%r15), %r14
testq %r14, %r14
je 0x19ed5
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x19ec8
movq 0x18(%r14), %rsi
subq %rdi, %rsi
callq 0x6380
movl $0x28, %esi
movq %r14, %rdi
callq 0x6380
addq $0x8, %r15
jmp 0x19ea6
movq 0x10(%rbx), %rax
cmpq %rax, 0x18(%rbx)
je 0x19ee9
movq %rax, 0x18(%rbx)
movq 0x38(%rbx), %r12
testq %r12, %r12
je 0x19f67
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
movq %r13, 0x8(%rsp)
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xb7d0
movq 0x28(%r12), %r15
movq %r15, 0x28(%rsp)
testq %r15, %r15
je 0x19f47
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x19f3a
movq 0x20(%r15), %rsi
subq %rdi, %rsi
callq 0x6380
movl $0x28, %esi
movq %r15, %rdi
callq 0x6380
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x19f5e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6380
movq (%r12), %r12
testq %r12, %r12
jne 0x19efc
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x1b852
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x19f8e
movq 0x90(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x19fa3
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq %r14, %rdi
callq 0x1b82c
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x19fc0
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0xb6a4
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/graph/graph.cpp
// Function: Graph::getNode(int)
Node* Graph::getNode(int id) {
  auto itr = std::find_if(nodes.begin(), nodes.end(),
                          [id](Node* v){ return v->getId() == id; });
  // error check
  if (itr == nodes.end()) {
    std::cout << "error@Graph::getNode, "
              << "node index is over, " << id << "\n";
    std::exit(1);
  }

  return *itr;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rax
movq %rax, %rsi
subq %rcx, %rsi
movq %rsi, %rdi
sarq $0x5, %rdi
testq %rdi, %rdi
jle 0x1a033
andq $-0x20, %rsi
addq %rcx, %rsi
incq %rdi
addq $0x10, %rcx
movq %rcx, %rdx
movq -0x10(%rdx), %rcx
cmpl %ebx, (%rcx)
je 0x1a076
movq -0x8(%rdx), %rcx
cmpl %ebx, (%rcx)
je 0x1a07c
movq (%rdx), %rcx
cmpl %ebx, (%rcx)
je 0x1a086
movq 0x8(%rdx), %rcx
cmpl %ebx, (%rcx)
je 0x1a082
decq %rdi
addq $0x20, %rdx
cmpq $0x1, %rdi
jg 0x1a004
movq %rsi, %rcx
movq %rax, %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
cmpq $0x1, %rsi
je 0x1a068
cmpq $0x2, %rsi
je 0x1a05d
movq %rax, %rdx
cmpq $0x3, %rsi
jne 0x1a086
movq (%rcx), %rdx
cmpl %ebx, (%rdx)
je 0x1a071
addq $0x8, %rcx
movq (%rcx), %rdx
cmpl %ebx, (%rdx)
je 0x1a071
addq $0x8, %rcx
movq (%rcx), %rdx
cmpl %ebx, (%rdx)
cmovneq %rax, %rcx
movq %rcx, %rdx
jmp 0x1a086
addq $-0x10, %rdx
jmp 0x1a086
addq $-0x8, %rdx
jmp 0x1a086
addq $0x8, %rdx
cmpq %rax, %rdx
je 0x1a090
movq (%rdx), %rax
popq %rbx
retq
movq 0x47f11(%rip), %rdi     # 0x61fa8
leaq 0x2f434(%rip), %rsi     # 0x494d2
callq 0x6360
leaq 0x2f43f(%rip), %rsi     # 0x494e9
movq %rax, %rdi
callq 0x6360
movq %rax, %rdi
movl %ebx, %esi
callq 0x6610
leaq 0x2e4a0(%rip), %rsi     # 0x48563
movq %rax, %rdi
callq 0x6360
movl $0x1, %edi
callq 0x6440
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/graph/graph.cpp
// Function: Graph::getKey[abi:cxx11](Node*, Node*)
std::string Graph::getKey(Node* s, Node* g) {
  int sIndex = getNodeIndex(s);
  int gIndex = getNodeIndex(g);
  std::string key = "";
  key += std::to_string(sIndex);
  key += "-";
  key += std::to_string(gIndex);
  return key;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x4(%rdx), %r15d
movl 0x4(%rcx), %r14d
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
leaq 0x2d8a6(%rip), %rdx     # 0x48564
movq %rdx, %rsi
callq 0xb860
movl %r15d, %ebp
negl %ebp
cmovsl %r15d, %ebp
movl $0x1, %r12d
cmpl $0xa, %ebp
jb 0x1ad23
movl $0x4, %r12d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x1ad1a
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x1ad20
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x1ad23
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x1ace7
addl $-0x3, %r12d
jmp 0x1ad23
addl $-0x2, %r12d
jmp 0x1ad23
decl %r12d
shrl $0x1f, %r15d
leal (%r12,%r15), %esi
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsp, %rdi
movl $0x2d, %edx
callq 0x6410
addq (%rsp), %r15
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0xb762
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ad79
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
leaq 0x31077(%rip), %rsi     # 0x4bdf7
movq %rbx, %rdi
callq 0x6690
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x1ade5
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x1addc
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x1ade2
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x1ade5
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x1ada9
addl $-0x3, %r15d
jmp 0x1ade5
addl $-0x2, %r15d
jmp 0x1ade5
decl %r15d
shrl $0x1f, %r14d
leal (%r15,%r14), %esi
movq %rsp, %rdi
movq %r13, (%rdi)
movl $0x2d, %edx
callq 0x6410
addq (%rsp), %r14
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0xb762
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ae35
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ae4d
jmp 0x1ae68
jmp 0x1ae68
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ae6b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
jmp 0x1ae6b
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x1ae85
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/graph/pd.cpp
// Function: PD::setStartGoal()
void PD::setStartGoal() {
  // initialization
  starts.clear();
  goals.clear();

  // update starts
  starts = endpoints;
}

// Assembly:
movq %rdi, %rsi
movq 0x68(%rdi), %rax
cmpq %rax, 0x70(%rdi)
je 0x1dcd7
movq %rax, 0x70(%rsi)
leaq 0x68(%rsi), %rdi
movq 0x80(%rsi), %rax
cmpq %rax, 0x88(%rsi)
je 0x1dcf2
movq %rax, 0x88(%rsi)
addq $0xf0, %rsi
jmp 0x1b2e2
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/graph/pd.cpp
// Function: PD::getRandomStartGoal(int)
Paths PD::getRandomStartGoal(int num) {
  if (num > nodes.size()) {
    std::cout << "error@PD::getStartGoal, over node size, "
              << num << "\n";
    std::exit(1);
  }

  Paths points;
  Nodes ends(starts.size());
  std::copy(starts.begin(), starts.end(), ends.begin());
  std::shuffle(ends.begin(), ends.end(), *MT);
  for (int i = 0; i < num; ++i) points.push_back({ ends[i] });

  return points;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movslq %edx, %rax
movq 0x18(%rsi), %rcx
subq 0x10(%rsi), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jb 0x1de0b
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x70(%rsi), %rsi
subq 0x68(%r14), %rsi
sarq $0x3, %rsi
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x1b584
movq 0x68(%r14), %rsi
movq 0x70(%r14), %rdx
subq %rsi, %rdx
je 0x1dd6c
movq 0x10(%rsp), %rdi
callq 0x65b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x60(%r14), %rdx
callq 0x1b60e
testl %ebp, %ebp
jle 0x1dde2
movl %ebp, %r13d
xorl %ebp, %ebp
leaq 0x30(%rsp), %r14
leaq 0x28(%rsp), %r15
leaq 0xf(%rsp), %r12
movq 0x10(%rsp), %rax
movq (%rax,%rbp,8), %rax
movq %rax, 0x28(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0xb44a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18be6
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1ddda
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
incq %rbp
cmpq %rbp, %r13
jne 0x1dd97
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ddf9
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x44196(%rip), %rdi     # 0x61fa8
leaq 0x2c1b3(%rip), %rsi     # 0x49fcc
callq 0x6360
movq %rax, %rdi
movl %ebp, %esi
callq 0x6610
leaq 0x2a734(%rip), %rsi     # 0x48563
movq %rax, %rdi
callq 0x6360
movl $0x1, %edi
callq 0x6440
jmp 0x1de48
movq %rax, %r14
jmp 0x1de7e
movq %rax, %r14
jmp 0x1de67
movq %rax, %r14
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1de67
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1de7e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0xb4ce
movq %r14, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/graph/simplegrid.cpp
// Function: SimpleGrid::init()
void SimpleGrid::init() {
  setBasicParams();  // read w, h
  createNodes();     // create nodes, not edges
  createEdges();     // set neighbor
  setStartGoal();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1e90e
movq %rbx, %rdi
callq 0x1ee7e
movq %rbx, %rdi
callq 0x1f284
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x68(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/graph/simplegrid.cpp
// Function: SimpleGrid::getNewGoal(Node*)
Node* SimpleGrid::getNewGoal(Node* v) {
  Node* u;
  do {
    u = randomChoose(goals, MT);
  } while (u == v);
  return u;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq 0x60(%r14), %rsi
movq 0x88(%r14), %rax
subq 0x80(%r14), %rax
shrq $0x3, %rax
decl %eax
movl $0x0, 0x8(%rsp)
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %r15, %rdx
callq 0x1fd2e
cltq
movq 0x80(%r14), %rcx
movq (%rcx,%rax,8), %rax
cmpq %rbx, %rax
je 0x1faa4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/graph/station.cpp
// Function: Station::setStartGoal()
void Station::setStartGoal() {
  // initialization
  starts.clear();
  goals.clear();

  // update starts
  for (auto st : stations) {
    for (auto v : st) {
      starts.push_back(v);
      goals.push_back(v);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %rax
cmpq %rax, 0x70(%rdi)
je 0x20623
movq %rax, 0x70(%rbx)
movq 0x80(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0x2063a
movq %rax, 0x88(%rbx)
movq 0xc8(%rbx), %r14
movq 0xd0(%rbx), %rax
movq %rax, 0x28(%rsp)
cmpq %rax, %r14
je 0x2070a
leaq 0x68(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq 0x80(%rbx), %r12
leaq 0x8(%rsp), %rbp
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x19a68
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %r15
cmpq %r15, %r13
je 0x206e4
movq (%r13), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x206a4
movq %rax, (%rsi)
addq $0x8, 0x70(%rbx)
jmp 0x206b1
movq 0x30(%rsp), %rdi
movq %rbp, %rdx
callq 0x1c69a
movq 0x88(%rbx), %rsi
cmpq 0x90(%rbx), %rsi
je 0x206d3
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x88(%rbx)
jmp 0x206de
movq %r12, %rdi
movq %rbp, %rdx
callq 0x1c69a
addq $0x8, %r13
jmp 0x20682
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x206fb
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
addq $0x18, %r14
cmpq 0x28(%rsp), %r14
jne 0x2066b
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x20733
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/graph/station.cpp
// Function: Station::getNewGoal(Node*)
Node* Station::getNewGoal(Node* v) {
  int vIn = -1;
  std::vector<int> cands;
  for (int i = 0; i < stations.size(); ++i) {
    cands.push_back(i);
    if (inArray(v, stations[i])) vIn = i;
  }

  int newSt;
  do {
    newSt = randomChoose(cands, MT);
  } while (newSt == vIn);

  return randomChoose(stations[newSt], MT);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x4(%rsp)
movq 0xd0(%rdi), %rax
cmpq 0xc8(%rdi), %rax
je 0x20e62
movq %rsi, %r14
xorl %eax, %eax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x20df3
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x20e02
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x2171e
movslq 0x4(%rsp), %rax
movq 0xc8(%rbx), %r12
leaq (%rax,%rax,2), %r13
movq %r14, 0x8(%rsp)
movq (%r12,%r13,8), %rdi
movq 0x8(%r12,%r13,8), %rsi
leaq 0x8(%rsp), %rdx
callq 0x19ae8
leaq (%r12,%r13,8), %rcx
cmpq 0x8(%rcx), %rax
movslq 0x4(%rsp), %rax
cmovnel %eax, %ebp
incq %rax
movl %eax, 0x4(%rsp)
movq 0xd0(%rbx), %rcx
subq 0xc8(%rbx), %rcx
sarq $0x3, %rcx
imulq %r15, %rcx
cmpq %rax, %rcx
ja 0x20dda
jmp 0x20e67
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x8(%rsp), %r14
movq 0x60(%rbx), %rsi
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
shrq $0x2, %rax
decl %eax
movl $0x0, 0x8(%rsp)
movl %eax, 0xc(%rsp)
movq %r14, %rdi
movq %r14, %rdx
callq 0x1fd2e
cltq
movq 0x10(%rsp), %rcx
movslq (%rcx,%rax,4), %rax
cmpl %ebp, %eax
je 0x20e6c
movq 0x60(%rbx), %rsi
movq 0xc8(%rbx), %rbx
leaq (%rax,%rax,2), %r14
movq 0x8(%rbx,%r14,8), %rax
subq (%rbx,%r14,8), %rax
shrq $0x3, %rax
decl %eax
leaq 0x8(%rsp), %rdi
movl $0x0, (%rdi)
movl %eax, 0x4(%rdi)
movq %rdi, %rdx
callq 0x1fd2e
leaq (%rbx,%r14,8), %rcx
cltq
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x20efe
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20f14
jmp 0x20f14
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x20f2e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/problem/imapf.cpp
// Function: IMAPF::init()
void IMAPF::init() {
  taskSum = 0;
  taskSumStr = "0,";
  nodes = G->getNodes();

  // initial allocation
  for (auto a : A) {
    allocate(a);
    a->updateHist();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x0, 0x90(%rdi)
addq $0xb0, %rdi
movq 0xb8(%rbx), %rdx
leaq 0x285bb(%rip), %rcx     # 0x4a1d2
movl $0x2, %r8d
xorl %esi, %esi
callq 0x6560
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x19a68
leaq 0x98(%rbx), %rdi
movq %r14, %rsi
callq 0x21552
movq (%r14), %rdi
testq %rdi, %rdi
je 0x21c5b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
cmpq %r12, %r15
je 0x21c84
movq (%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21dec
movq %r14, %rdi
callq 0x192f0
addq $0x8, %r15
jmp 0x21c63
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/problem/imapf.cpp
// Function: IMAPF::allocate(Agent*)
void IMAPF::allocate(Agent* a) {
  Node* v = G->getNewGoal(a->getNode());
  Task* tau = new Task(v, timestep);
  a->setTask(tau);
  a->setGoal(a->getTask()->getG()[0]);
  T_OPEN.push_back(tau);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x8(%rsi), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, %r12
movl $0x40, %edi
callq 0x6370
movq %rax, %r15
movl 0x8(%rbx), %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x473e8
movq %r15, 0x8(%rsp)
movq %r15, 0x18(%r14)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x19a68
movq (%r12), %rdi
movq (%rdi), %rax
movq %rax, 0x10(%r14)
movq 0x10(%r12), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x21e73
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x38(%rbx)
jmp 0x21e84
addq $0x30, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x18ffc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/problem/imapf.cpp
// Function: IMAPF::isSolved()
bool IMAPF::isSolved() {
  if (taskSum < taskLimit) return false;
  // check all tasks are completed or not
  for (int i = 0; i < taskLimit; ++i) {
    auto itr = std::find_if(T_CLOSE.begin(), T_CLOSE.end(),
                            [i] (Task* tau) { return tau->getId() == i; });
    if (itr == T_CLOSE.end()) return false;
  }
  return true;;
}

// Assembly:
movl 0x94(%rdi), %ecx
cmpl %ecx, 0x90(%rdi)
jge 0x21ebd
xorl %eax, %eax
jmp 0x21fab
testl %ecx, %ecx
setle %al
jle 0x21fab
pushq %r15
pushq %r14
pushq %rbx
movq 0x48(%rdi), %rdx
movq 0x50(%rdi), %rsi
movq %rsi, %rdi
subq %rdx, %rdi
movq %rdi, %r8
sarq $0x5, %r8
andq $-0x20, %rdi
addq %rdx, %rdi
leaq 0x1(%r8), %r9
leaq 0x10(%rdx), %r10
xorl %r11d, %r11d
movq %rdx, %r14
testq %r8, %r8
jle 0x21f39
movq %r10, %rbx
movq %r9, %r14
movq -0x10(%rbx), %r15
cmpl %r11d, 0x30(%r15)
je 0x21f82
movq -0x8(%rbx), %r15
cmpl %r11d, 0x30(%r15)
je 0x21f88
movq (%rbx), %r15
cmpl %r11d, 0x30(%r15)
je 0x21f92
movq 0x8(%rbx), %r15
cmpl %r11d, 0x30(%r15)
je 0x21f8e
decq %r14
addq $0x20, %rbx
cmpq $0x1, %r14
jg 0x21f02
movq %rdi, %r14
movq %rsi, %r15
subq %r14, %r15
sarq $0x3, %r15
cmpq $0x1, %r15
je 0x21f72
cmpq $0x2, %r15
je 0x21f65
movq %rsi, %rbx
cmpq $0x3, %r15
jne 0x21f92
movq (%r14), %rbx
cmpl %r11d, 0x30(%rbx)
je 0x21f7d
addq $0x8, %r14
movq (%r14), %rbx
cmpl %r11d, 0x30(%rbx)
je 0x21f7d
addq $0x8, %r14
movq (%r14), %rbx
cmpl %r11d, 0x30(%rbx)
cmovneq %rsi, %r14
movq %r14, %rbx
jmp 0x21f92
addq $-0x10, %rbx
jmp 0x21f92
addq $-0x8, %rbx
jmp 0x21f92
addq $0x8, %rbx
cmpq %rsi, %rbx
je 0x21fa6
incl %r11d
cmpl %ecx, %r11d
setge %al
jne 0x21ef4
popq %rbx
popq %r14
popq %r15
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/problem/imapf_fair.cpp
// Function: IMAPF_FAIR::init()
void IMAPF_FAIR::init() {
  taskSum = 0;

  // initial allocation
  for (auto a : A) {
    goalCounts.push_back(0);
    allocate(a);
    a->updateHist();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x0, 0x94(%rdi)
movq 0x18(%rdi), %r13
movq 0x20(%rdi), %rbp
cmpq %rbp, %r13
je 0x22acb
movq %rdi, %rbx
leaq 0x98(%rdi), %r14
leaq 0x4(%rsp), %r15
movq (%r13), %r12
movl $0x0, 0x4(%rsp)
movq 0xa0(%rbx), %rsi
cmpq 0xa8(%rbx), %rsi
je 0x22aa4
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xa0(%rbx)
jmp 0x22aaf
movq %r14, %rdi
movq %r15, %rdx
callq 0x233f8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22bfa
movq %r12, %rdi
callq 0x192f0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x22a75
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/problem/imapf_fair.cpp
// Function: IMAPF_FAIR::update()
void IMAPF_FAIR::update() {
  ++timestep;
  Agent* a;

  for (int i = 0; i < A.size(); ++i) {
    a = A[i];
    auto tau = a->getTask();
    if (tau) {
      tau->update(a->getNode());

      if (tau->completed()) {
        ++taskSum;
        goalCounts[i] += 1;
        tau->setEndTime(timestep);
        a->releaseTask();
        openToClose(tau, T_OPEN, T_CLOSE);
        allocate(a);
        a->goalUpdated(true);
      } else {
        a->goalUpdated(false);
      }
    } else {
      allocate(a);
    }
    a->updateHist();
  }
}

// Assembly:
incl 0x8(%rdi)
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0x22df1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %rcx
movq %rcx, 0x8(%rsp)
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq (%rax,%r14,8), %r12
movq 0x18(%r12), %r13
testq %r13, %r13
je 0x22d6d
movq 0x8(%r12), %rsi
movq %r13, %rdi
callq 0x4756c
movq %r13, %rdi
callq 0x475e6
testb %al, %al
je 0x22d7a
incl 0x94(%rbx)
movq 0x98(%rbx), %rax
incl (%rax,%r14,4)
movl 0x8(%rbx), %esi
movq %r13, %rdi
callq 0x475f2
movq %r12, %rdi
callq 0x1934a
movq %r13, 0x10(%rsp)
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq %r15, %rdx
callq 0x228dc
cmpq 0x38(%rbx), %rax
je 0x22daf
movq %rax, %r13
movq %rax, %rbp
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x22d82
movq (%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0x22d8f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22bfa
jmp 0x22dc0
movb $0x0, 0x38(%r12)
jmp 0x22dc0
movq 0x8(%rsp), %rdi
movq %rbp, %rdx
callq 0x18ffc
addq $0x8, %r13
movq 0x38(%rbx), %rdx
cmpq %rdx, %r13
je 0x22daa
subq %r13, %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x65b0
addq $-0x8, 0x38(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22bfa
movb $0x1, 0x38(%r12)
movq %r12, %rdi
callq 0x192f0
incq %r14
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x22ce9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/problem/imapf_fair.cpp
// Function: IMAPF_FAIR::isSolved()
bool IMAPF_FAIR::isSolved() {
  if (taskSum < taskLimit * A.size()) return false;
  // check all tasks are completed or not
  auto itr = std::find_if(goalCounts.begin(), goalCounts.end(),
                          [&] (int i) { return i < taskLimit; });
  if (itr != goalCounts.end()) return false;
  return true;
}

// Assembly:
movslq 0x94(%rdi), %rax
movq 0x20(%rdi), %rdx
subq 0x18(%rdi), %rdx
movslq 0x90(%rdi), %rcx
sarq $0x3, %rdx
imulq %rcx, %rdx
cmpq %rax, %rdx
jbe 0x22e18
xorl %eax, %eax
retq
movq 0x98(%rdi), %rdx
movq 0xa0(%rdi), %rax
movq %rax, %rdi
subq %rdx, %rdi
movq %rdi, %r8
sarq $0x4, %r8
testq %r8, %r8
jle 0x22e6c
andq $-0x10, %rdi
addq %rdx, %rdi
incq %r8
addq $0x8, %rdx
movq %rdx, %rsi
cmpl -0x8(%rsi), %ecx
jg 0x22ea6
cmpl -0x4(%rsi), %ecx
jg 0x22eac
cmpl (%rsi), %ecx
jg 0x22eb6
cmpl 0x4(%rsi), %ecx
jg 0x22eb2
decq %r8
addq $0x10, %rsi
cmpq $0x1, %r8
jg 0x22e49
movq %rdi, %rdx
movq %rax, %rdi
subq %rdx, %rdi
sarq $0x2, %rdi
cmpq $0x1, %rdi
je 0x22e9b
cmpq $0x2, %rdi
je 0x22e93
movq %rax, %rsi
cmpq $0x3, %rdi
jne 0x22eb6
cmpl (%rdx), %ecx
jg 0x22ea1
addq $0x4, %rdx
cmpl (%rdx), %ecx
jg 0x22ea1
addq $0x4, %rdx
cmpl (%rdx), %ecx
cmovleq %rax, %rdx
movq %rdx, %rsi
jmp 0x22eb6
addq $-0x8, %rsi
jmp 0x22eb6
addq $-0x4, %rsi
jmp 0x22eb6
addq $0x4, %rsi
cmpq %rax, %rsi
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/problem/mapd.cpp
// Function: MAPD::init()
void MAPD::init() {
  taskCnt = 0;
  autoAssignment = true;
  --timestep;
  update();
}

// Assembly:
movl $0x0, 0xc0(%rdi)
movb $0x1, 0xcc(%rdi)
decl 0x8(%rdi)
movq (%rdi), %rax
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/problem/mapd.cpp
// Function: MAPD::isSolved()
bool MAPD::isSolved() {
  if (taskCnt >= taskNum && T_OPEN.empty()) {
    if (std::all_of(A.begin(), A.end(),
                    [](Agent* a) { return !a->hasTask(); })) {
      return true;
    }
  }
  return false;
}

// Assembly:
movl 0xc0(%rdi), %eax
cmpl 0xc4(%rdi), %eax
jl 0x23bef
movq 0x30(%rdi), %rax
cmpq 0x38(%rdi), %rax
jne 0x23bef
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
movq %rax, %rsi
subq %rcx, %rsi
movq %rsi, %rdi
sarq $0x5, %rdi
testq %rdi, %rdi
jle 0x23b8e
andq $-0x20, %rsi
addq %rcx, %rsi
incq %rdi
addq $0x10, %rcx
movq %rcx, %rdx
movq -0x10(%rdx), %rcx
cmpq $0x0, 0x18(%rcx)
jne 0x23bda
movq -0x8(%rdx), %rcx
cmpq $0x0, 0x18(%rcx)
jne 0x23be0
movq (%rdx), %rcx
cmpq $0x0, 0x18(%rcx)
jne 0x23bea
movq 0x8(%rdx), %rcx
cmpq $0x0, 0x18(%rcx)
jne 0x23be6
decq %rdi
addq $0x20, %rdx
cmpq $0x1, %rdi
jg 0x23b53
movq %rsi, %rcx
movq %rax, %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
cmpq $0x1, %rsi
je 0x23bc9
cmpq $0x2, %rsi
je 0x23bbb
movq %rax, %rdx
cmpq $0x3, %rsi
jne 0x23bea
movq (%rcx), %rdx
cmpq $0x0, 0x18(%rdx)
jne 0x23bd5
addq $0x8, %rcx
movq (%rcx), %rdx
cmpq $0x0, 0x18(%rdx)
jne 0x23bd5
addq $0x8, %rcx
movq (%rcx), %rdx
cmpq $0x0, 0x18(%rdx)
cmoveq %rax, %rcx
movq %rcx, %rdx
jmp 0x23bea
addq $-0x10, %rdx
jmp 0x23bea
addq $-0x8, %rdx
jmp 0x23bea
addq $0x8, %rdx
cmpq %rax, %rdx
je 0x23bf2
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/problem/mapd.cpp
// Function: MAPD::update()
void MAPD::update() {
  ++timestep;
  updateStatus();
  createTask();
  if (autoAssignment) autoAssign();
  for (auto a : A) a->updateHist();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0x8(%rdi)
callq 0x23c42
movq %rbx, %rdi
callq 0x23ce0
cmpb $0x1, 0xcc(%rbx)
jne 0x23c1e
movq %rbx, %rdi
callq 0x23e76
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %rbx
cmpq %rbx, %r14
je 0x23c39
movq (%r14), %rdi
callq 0x192f0
addq $0x8, %r14
jmp 0x23c26
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop