LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: void bench<void (*)(std::vector<unsigned long, std::allocator<unsigned long>>&)>(void (*)(std::vector<unsigned long, std::allocator<unsigned long>>&))
void bench(Function sort_function){
    std::array<std::vector<std::size_t>, REPEAT> vec;

    for(std::size_t i = 0; i < REPEAT; ++i){
        fill_random(vec[i], SIZE);
    }

    Clock::time_point t0 = Clock::now();

    for(std::size_t i = 0; i < REPEAT; ++i){
        sort_function(vec[i]);
    }

    Clock::time_point t1 = Clock::now();
    milliseconds ms = std::chrono::duration_cast<milliseconds>(t1 - t0);

    std::cout << ms.count() << "ms" << std::endl;

    if(DISPLAY){
        display_vec(vec[0]);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x260, %rsp            # imm = 0x260
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x258, %edx            # imm = 0x258
xorl %esi, %esi
xorl %r14d, %r14d
callq 0x1090
cmpq $0x258, %r14            # imm = 0x258
je 0x188e
leaq 0x8(%rsp,%r14), %rdi
movl $0x4c4b40, %esi         # imm = 0x4C4B40
callq 0x126c
addq $0x18, %r14
jmp 0x1870
xorl %r15d, %r15d
callq 0x1030
movq %rax, %r14
cmpq $0x258, %r15            # imm = 0x258
je 0x18af
leaq 0x8(%rsp,%r15), %rdi
callq *%rbx
addq $0x18, %r15
jmp 0x1899
callq 0x1030
subq %r14, %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq 0x3710(%rip), %rdi      # 0x4fd8
movq %rax, %rsi
callq 0x10e0
leaq 0x17b5(%rip), %rsi      # 0x308c
movq %rax, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq 0x8(%rsp), %rdi
callq 0x236a
addq $0x260, %rsp            # imm = 0x260
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1902
jmp 0x1902
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x236a
movq %rbx, %rdi
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_srv.c
// Function: cmd_handler
scdcint_t cmd_handler(void *data, const char *cmd, const char *params, scdcint_t params_size)
{
  printf(PREFIX "cmd_handler: cmd: '%s', data: %p\n", cmd, data);

  if (strcmp(cmd, "quit") == 0)
  {
    printf(PREFIX "quiting server\n");
    sighandler(0);

  } else
  {
    printf(PREFIX "unkown server command: '%s'\n", cmd);
  }

  return SCDC_SUCCESS;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rdx
leaq 0x37df1(%rip), %rdi     # 0x44023
xorl %eax, %eax
callq 0xb070
leaq 0x37e0f(%rip), %rsi     # 0x4404f
movq %rbx, %rdi
callq 0xb7a0
testl %eax, %eax
je 0xc25f
leaq 0x37e01(%rip), %rdi     # 0x44054
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb070
jmp 0xc272
leaq 0x37e4e(%rip), %rdi     # 0x440b4
callq 0xb880
xorl %edi, %edi
callq 0xc1fc
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_srv.c
// Function: main
int main(int argc, char *argv[])
{
  scdc_dataprov_t dp_hook = SCDC_DATAPROV_NULL;


  printf(PREFIX "start hook demo server\n");

  signal(SIGABRT, &sighandler);
  signal(SIGTERM, &sighandler);
  signal(SIGINT, &sighandler);

  scdc_init(SCDC_INIT_DEFAULT);

  dp_hook = scdc_dataprov_open("hookdemo", "hook:id", &hook, 0x2501);

#if NODEPORT_TCP
  np_tcp = scdc_nodeport_open("tcp:max_connections", 2);
#endif
#if NODEPORT_UDS
  np_uds = scdc_nodeport_open("uds:max_connections", 2);
#endif
#if NODEPORT_STREAM
  np_stream = scdc_nodeport_open("stream:cmd_handler", cmd_handler, NULL);
#endif

#if NODEPORT_TCP
  scdc_nodeport_start(np_tcp, NODEPORT_TCP);
#endif
#if NODEPORT_UDS
  scdc_nodeport_start(np_uds, NODEPORT_UDS);
#endif
#if NODEPORT_STREAM
  scdc_nodeport_start(np_stream, NODEPORT_STREAM);
#endif

  printf(PREFIX "Press <ENTER> to quit!\n");
  getchar();

#if NODEPORT_STREAM
  scdc_nodeport_stop(np_stream);
#endif
#if NODEPORT_UDS
  scdc_nodeport_stop(np_uds);
#endif
#if NODEPORT_TCP
  scdc_nodeport_stop(np_tcp);
#endif

#if NODEPORT_STREAM
  scdc_nodeport_close(np_stream);
#endif
#if NODEPORT_UDS
  scdc_nodeport_close(np_uds);
#endif
#if NODEPORT_TCP
  scdc_nodeport_close(np_tcp);
#endif

  scdc_dataprov_close(dp_hook);

  scdc_release();

  printf(PREFIX "quit hook demo server\n");

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x37e4b(%rip), %rdi     # 0x440cd
callq 0xb880
leaq -0x92(%rip), %rbx       # 0xc1fc
pushq $0x6
popq %rdi
movq %rbx, %rsi
callq 0xb660
pushq $0xf
popq %rdi
movq %rbx, %rsi
callq 0xb660
pushq $0x2
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0xb660
leaq 0x396fa(%rip), %rdi     # 0x459b2
xorl %eax, %eax
callq 0xca59
leaq 0x37db5(%rip), %rdi     # 0x4407b
leaq 0x37db7(%rip), %rsi     # 0x44084
leaq 0x5485c(%rip), %rdx     # 0x60b30
movl $0x2501, %ecx           # imm = 0x2501
xorl %eax, %eax
callq 0xcdb4
movq %rax, %rbx
leaq 0x37da2(%rip), %rdi     # 0x4408c
movl %ebp, %esi
xorl %eax, %eax
callq 0xcf52
movq %rax, 0x572ae(%rip)     # 0x635a8
leaq 0x37d9f(%rip), %rdi     # 0x440a0
movl %ebp, %esi
xorl %eax, %eax
callq 0xcf52
movq %rax, 0x5729f(%rip)     # 0x635b0
movq 0x57290(%rip), %rdi     # 0x635a8
pushq $0x4
popq %r14
movq %r14, %rsi
callq 0xd02c
movq 0x57285(%rip), %rdi     # 0x635b0
movq %r14, %rsi
callq 0xd02c
leaq 0x37db4(%rip), %rdi     # 0x440ee
callq 0xb880
callq 0xb780
movq 0x57265(%rip), %rdi     # 0x635b0
callq 0xd05b
movq 0x57251(%rip), %rdi     # 0x635a8
callq 0xd05b
movq 0x5724d(%rip), %rdi     # 0x635b0
callq 0xd00a
movq 0x57239(%rip), %rdi     # 0x635a8
callq 0xd00a
movq %rbx, %rdi
callq 0xce72
callq 0xcb6e
leaq 0x37d87(%rip), %rdi     # 0x4410f
callq 0xb880
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/eschwabe[P]interview-practice/src/parenthesization.cpp
// Function: BuildString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void BuildString(const string current, int left_rem, int right_rem, vector<string>* list) {
    if(left_rem == 0 && right_rem == 0) {
        list->push_back(current);
    } else {
        if(left_rem > 0) {
            BuildString(current+"(", left_rem-1, right_rem, list);
        }
        if(right_rem > left_rem) {
            BuildString(current+")", left_rem, right_rem-1, list);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdi, %r12
movl %edx, %eax
orl %esi, %eax
je 0x1350
movl %edx, %ebp
movl %esi, %r14d
testl %esi, %esi
jle 0x130f
leaq 0xd20(%rip), %rdx       # 0x2004
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x147c
leal -0x1(%r14), %esi
movq %r15, %rdi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x12bc
leaq 0x20(%rsp), %rdi
callq 0x1070
cmpl %r14d, %ebp
jle 0x1343
leaq 0xceb(%rip), %rdx       # 0x2006
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x147c
decl %ebp
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x12bc
movq %rsp, %rdi
callq 0x1070
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r12, %rsi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1450
jmp 0x1369
movq %rax, %rbx
movq %r15, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/eschwabe[P]interview-practice/src/parenthesization.cpp
// Function: main
int main(int argc, char *argv[])
{
    const int count = 4;
    vector<string> tmp;
    BuildString("", count, count, &tmp);

    for(auto s : tmp) {
        cout << s << endl;
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0xc6a(%rip), %rsi       # 0x2005
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x14b4
leaq 0x18(%rsp), %rdi
pushq $0x4
popq %rdx
movq %rsp, %rcx
movl %edx, %esi
callq 0x12bc
leaq 0x18(%rsp), %rdi
callq 0x1070
movq (%rsp), %rbx
movq 0x8(%rsp), %r12
leaq 0x38(%rsp), %r14
movq 0x2bfd(%rip), %r15      # 0x3fd8
cmpq %r12, %rbx
je 0x140c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1120
movq %r15, %rdi
movq %r14, %rsi
callq 0x10e0
movq %rax, %rdi
callq 0x1080
movq %r14, %rdi
callq 0x1070
addq $0x20, %rbx
jmp 0x13db
movq %rsp, %rdi
callq 0x14f0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x143b
jmp 0x142e
movq %rax, %rbx
jmp 0x1440
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1070
movq %rsp, %rdi
callq 0x14f0
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc4.cc
// Function: Interpreter::expression()
long Interpreter::expression() {
    long result = factor();

    while (_current_token.type == TOKENTYPE::MUL ||
    _current_token.type == TOKENTYPE::DIV ||
    _current_token.type == TOKENTYPE::PLUS ||
    _current_token.type == TOKENTYPE::MINUS) {
        Token token = _current_token;
        if (token.type == TOKENTYPE::MUL) {
            eat(TOKENTYPE::MUL);
            result *= factor();
        } else if (token.type == TOKENTYPE::DIV) {
            eat(TOKENTYPE::DIV);
            long rhs = factor();
            if (rhs == 0) {
                throw("Division by zero");
            }
            result /= rhs;
        } else if (token.type == TOKENTYPE::PLUS) {
            eat(TOKENTYPE::PLUS);
            result += factor();
        } else if (token.type == TOKENTYPE::MINUS) {
            eat(TOKENTYPE::MINUS);
            result -= factor();
        }
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x274e
movq %rax, %r14
leaq 0x999(%rip), %rbp       # 0x301c
pushq $0x3
popq %r15
pushq $0x4
popq %r12
pushq $0x5
popq %r13
movl 0x8(%rbx), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x2718
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movq %rbx, %rdi
pushq $0x2
popq %rsi
callq 0x2760
movq %rbx, %rdi
callq 0x274e
addq %rax, %r14
jmp 0x268f
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2760
movq %rbx, %rdi
callq 0x274e
imulq %rax, %r14
jmp 0x268f
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2760
movq %rbx, %rdi
callq 0x274e
testq %rax, %rax
je 0x272a
movq %rax, %rcx
movq %r14, %rax
cqto
idivq %rcx
movq %rax, %r14
jmp 0x268f
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2760
movq %rbx, %rdi
callq 0x274e
subq %rax, %r14
jmp 0x268f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x20b0
leaq 0x956(%rip), %rcx       # 0x308f
movq %rcx, (%rax)
movq 0x286d(%rip), %rsi      # 0x4fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/m1c0l[P]TCP/server.cpp
// Function: printSend(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned short, int, int, bool)
void printSend(string pktType, uint16_t seq, int cwnd, int ssThresh, bool isRetransmit) {
	cout << "Sending packet " << seq << " " << cwnd << " " << ssThresh;
	if (isRetransmit) {
		cout << " Retransmission";
	}
	if (pktType != "data") {
		// SYN or FIN
		cout << " " << pktType;
	}
	cout << '\n';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x54f2(%rip), %rdi      # 0x7fc8
leaq 0x259d(%rip), %rsi      # 0x507a
callq 0x21d0
movq %rax, %rdi
movl %r12d, %esi
callq 0x22d0
leaq 0x25b1(%rip), %r12      # 0x50a5
movq %rax, %rdi
movq %r12, %rsi
callq 0x21d0
movq %rax, %rdi
movl %r15d, %esi
callq 0x22e0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21d0
movq %rax, %rdi
movl %r14d, %esi
callq 0x22e0
testl %ebp, %ebp
je 0x2b37
movq 0x549d(%rip), %rdi      # 0x7fc8
leaq 0x2558(%rip), %rsi      # 0x508a
callq 0x21d0
leaq 0x255c(%rip), %rsi      # 0x509a
movq %rbx, %rdi
callq 0x3bdb
testb %al, %al
je 0x2b68
movq 0x5477(%rip), %rdi      # 0x7fc8
leaq 0x254d(%rip), %rsi      # 0x50a5
callq 0x21d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21a0
movq 0x5459(%rip), %rdi      # 0x7fc8
pushq $0xa
popq %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/m1c0l[P]TCP/server.cpp
// Function: getAcks(int, sockaddr_in*, unsigned int)
int getAcks(int sockfd, sockaddr_in *si_other, socklen_t len) {
	// find the oldest ACK we are waiting for
	uint16_t oldestSeq = BAD_SEQ_NUM;
	timeval oldestTimeval = now();
	for (auto i : packetsInWindow) {
		uint16_t currSeq = i.first;
		// this packet is older
		if (timeval_cmp(timestamps[currSeq], oldestTimeval)) {
			oldestSeq = currSeq;
			oldestTimeval = timestamps[currSeq];
		}
	}
	// cerr << "oldest seq = " << oldestSeq << endl;

	// if this packet already timed out, just return
	timeval remaining = timeRemaining(oldestTimeval);
	if (remaining.tv_sec == 0 && remaining.tv_usec == 0) {
		timedOutSeq = oldestSeq;
		return RECV_TIMED_OUT_ALREADY;
	}

	// try to recv until this packet times out
	setSocketTimeout(sockfd, timeRemaining(oldestTimeval));

	TcpMessage ack;
	int r = ack.recvfrom(sockfd, si_other, len);
	if (r == RECV_SUCCESS) {
		printRecv(ack.ackNum);
		ack.dump();
		lastAckRecvd = ack.ackNum;
		clientRecvWindow = ack.recvWindow;
		return RECV_SUCCESS;
	}
	else { // RECV_TIMEOUT
		timedOutSeq = oldestSeq;
		return RECV_TIMEOUT;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movl %edi, 0x8(%rsp)
callq 0x29ec
movq %rax, %r15
movq %rdx, %r12
movw $0xd903, %r13w          # imm = 0xD903
leaq 0x5637(%rip), %rbx      # 0x81e8
leaq 0x5658(%rip), %r14      # 0x8210
leaq 0x6(%rsp), %rbp
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2c22
leaq 0x8(%rbx), %rsi
leaq 0x18(%rsp), %rdi
callq 0x3bf2
movzwl 0x18(%rsp), %eax
movw %ax, 0x6(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3eb0
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2a77
testb %al, %al
je 0x2c16
movzwl 0x6(%rsp), %r13d
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3eb0
movq (%rax), %r15
movq 0x8(%rax), %r12
leaq 0x28(%rsp), %rdi
callq 0x20f0
jmp 0x2bbd
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a0b
orq %rax, %rdx
jne 0x2c42
movw %r13w, 0x560e(%rip)     # 0x8248
pushq $0x3
popq %rbx
jmp 0x2cc5
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a0b
movl 0x8(%rsp), %ebp
movl %ebp, %edi
movq %rax, %rsi
callq 0x29af
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x2642
movq %rbx, %rdi
movl %ebp, %esi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x27a0
cmpl $0x1, %eax
jne 0x2cb0
movzwl 0x1a(%rsp), %edi
callq 0x2a8c
leaq 0x18(%rsp), %rdi
callq 0x280e
movzwl 0x1a(%rsp), %eax
movzwl 0x1c(%rsp), %ecx
movw %ax, 0x5525(%rip)       # 0x81ca
movw %cx, 0x5520(%rip)       # 0x81cc
pushq $0x1
jmp 0x2cba
movw %r13w, 0x5590(%rip)     # 0x8248
pushq $0x2
popq %rbx
leaq 0x20(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x2ce8
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day03/ex04/SuperTrap.cpp
// Function: SuperTrap::SuperTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
SuperTrap::SuperTrap(std::string name) : ClapTrap(name), NinjaTrap(name), FragTrap(name)
{
	this->hitPoints = FragTrap::hitPoints;
	this->maxHit = FragTrap::maxHit;
	this->energyPoints = NinjaTrap::energyPoints;
	this->maxEnergyPoints = NinjaTrap::maxEnergyPoints;
	this->level = 1.0;
	this->meleeAttackDamage = NinjaTrap::meleeAttackDamage;
	this->rangedAttackDamage = FragTrap::rangedAttackDamage;
	this->armorDamageReduction = FragTrap::armorDamageReduction;
	std::cout << this->name << ": I'm a SuperTrap!" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x2130
leaq 0x8(%r13), %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2cdc
leaq -0x68(%rbp), %rdi
callq 0x2070
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x2130
leaq 0x8(%rbx), %r15
leaq 0x18(%r13), %r12
leaq -0x48(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2798
leaq -0x48(%rbp), %rdi
callq 0x2070
movq (%r13), %rax
movq %rax, (%rbx)
movq 0x28(%r13), %rcx
movq -0x18(%rax), %rax
movq %rcx, (%rbx,%rax)
movq 0x30(%r13), %rax
movq %rax, 0x8(%rbx)
movq -0x18(%rax), %rcx
movl 0x10(%rbx,%rcx), %ecx
movq (%rbx), %rdx
movq -0x18(%rdx), %rsi
movl %ecx, 0x8(%rbx,%rsi)
movq -0x18(%rax), %rcx
movl 0x14(%rbx,%rcx), %ecx
movq -0x18(%rdx), %rsi
movl %ecx, 0xc(%rbx,%rsi)
movq -0x18(%rdx), %rcx
movl $0x3f800000, 0x18(%rbx,%rcx) # imm = 0x3F800000
movq -0x18(%rdx), %rcx
movq -0x18(%rax), %rsi
movl 0x4c(%rbx,%rsi), %esi
movl %esi, 0x44(%rbx,%rcx)
movq -0x18(%rax), %rax
movl 0x50(%rbx,%rax), %eax
movq -0x18(%rdx), %rcx
movl %eax, 0x48(%rbx,%rcx)
movq -0x18(%rdx), %rax
leaq (%rbx,%rax), %rsi
addq $0x20, %rsi
movq 0x4833(%rip), %rdi      # 0x7fd8
callq 0x20e0
leaq 0x1cab(%rip), %rsi      # 0x545c
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x2080
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
leaq -0x48(%rbp), %rdi
callq 0x2070
jmp 0x37ff
movq %rax, %r13
jmp 0x37ff
movq %rax, %r13
leaq -0x68(%rbp), %rdi
callq 0x2070
jmp 0x380a
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x29f4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f3e
movq %r13, %rdi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day03/ex04/main.cpp
// Function: main
int main(void)
{
	SuperTrap	alpha("Alpha");
	ScavTrap	lucie("Lucie");

	srand(time(0));
	alpha.meleeAttack("John");
	alpha.rangedAttack("Rose");
	alpha.vaulthunter_dot_exe("Micheal");
	alpha.ninjaShoebox(lucie);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
leaq 0x16bb(%rip), %rsi      # 0x5492
leaq -0x70(%rbp), %rdi
leaq -0x120(%rbp), %rdx
callq 0x3f5a
leaq -0xd0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3812
leaq -0x70(%rbp), %rdi
callq 0x2070
leaq 0x1691(%rip), %rsi      # 0x5498
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3f5a
leaq -0x120(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3388
leaq -0x50(%rbp), %rdi
callq 0x2070
xorl %edi, %edi
callq 0x20f0
movl %eax, %edi
callq 0x2100
leaq 0x165c(%rip), %rsi      # 0x549e
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3f5a
leaq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3d98
leaq -0x30(%rbp), %rdi
callq 0x2070
leaq 0x1634(%rip), %rsi      # 0x54a3
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3f5a
leaq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3d68
leaq -0x30(%rbp), %rdi
callq 0x2070
leaq 0x160c(%rip), %rsi      # 0x54a8
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3f5a
leaq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2ab2
leaq -0x30(%rbp), %rdi
callq 0x2070
leaq -0xd0(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x3092
leaq -0x120(%rbp), %rdi
callq 0x34ce
leaq -0xd0(%rbp), %rdi
callq 0x3ce0
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %rbp
retq
jmp 0x3f11
jmp 0x3f03
jmp 0x3f11
jmp 0x3f03
jmp 0x3f11
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2070
jmp 0x3f14
movq %rax, %rbx
leaq -0x120(%rbp), %rdi
callq 0x34ce
leaq -0xd0(%rbp), %rdi
callq 0x3ce0
movq %rbx, %rdi
callq 0x2160
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2070
jmp 0x3f20
movq %rax, %rbx
jmp 0x3f20
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2070
jmp 0x3f2c
movq %rax, %rbx
jmp 0x3f2c
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/scope_levels.cc
// Function: main
int main()
{
	int unique = 0; // unique has block scope

	// output #1: uses global reused; prints 42 0
	std::cout << reused << " " << unique << std::endl;   

	int reused = 0; // new, local object named reused hides global reused

	// output #2: uses local reused; prints 0 0
	std::cout << reused << " " <<  unique << std::endl;  

	// output #3: explicitly requests the global reused; prints 42 0
	std::cout << ::reused << " " <<  unique << std::endl;  

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x2e87(%rip), %esi      # 0x4050
movq 0x2e08(%rip), %rbx      # 0x3fd8
movq %rbx, %rdi
callq 0x1070
leaq 0xe25(%rip), %r14       # 0x2004
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
movl 0x2e27(%rip), %esi      # 0x4050
movq %rbx, %rdi
callq 0x1070
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nightmeng[P]net/examples/http/httptest.cpp
// Function: handle_read(int, int, socket&)
void handle_read(int ec, int transfered, socket &sock){
	std::cout << buff << std::endl;
	bzero(buff, 2048);
	sock.async_read(buff, 2048, std::bind(handle_read, std::placeholders::_1,
				std::placeholders::_2, std::ref(sock)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq 0xaabd(%rip), %rdi      # 0xdfd0
leaq 0xacb6(%rip), %r14      # 0xe1d0
movq %r14, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x3110
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
callq 0x32d0
leaq -0x42(%rip), %rax       # 0x34fc
leaq -0x48(%rbp), %rsi
movq %rax, (%rsi)
movq %rbx, 0x8(%rsi)
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x37a4
movl $0x800, %edx            # imm = 0x800
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x48e8
leaq -0x38(%rbp), %rdi
callq 0x37ec
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x37ec
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O2/nightmeng[P]net/examples/http/httptest.cpp
// Function: main
int main(){
	socket sock;

#if 1
	if(!sock.connect("www.baidu.com", 80)){
		std::cout << "connected failed" << std::endl;
		return -1;
	}
	std::cout << "connected successfully" << std::endl;
	
	std::string get = "GET / HTTP/1.1\r\n"
		"Host: www.baidu.com\r\n"
		"Connection: keep-alive\r\n\r\n";

	char buff[2049] = {0};
	sock.async_write(get.c_str(), get.size(), [&sock, &buff](int ec, int t){
		sock.async_read(buff, 2048, std::bind(handle_read, std::placeholders::_1,
				std::placeholders::_2, std::ref(sock)));
	});
#else
	char buff[2049] = {0};
	sock.async_connect("www.baidu.com", 80, [&sock, &buff](int ec){
		if(ec == 0){
			std::cout << "connect successfully" << std::endl;

			std::string get = "GET / HTTP/1.1\r\n"
				"Host: www.baidu.com\r\n"
				"Connection: keep-alive\r\n\r\n";

			sock.async_write(get.c_str(), get.size(), [&sock, &buff](int ec, int t){
				std::cout << "write ec = " << ec << ", t = " << t << std::endl;
				sock.async_read(buff, 2048, std::bind(handle_read, std::placeholders::_1,
					std::placeholders::_2, std::ref(sock)));
			});
		}
		else{
			std::cout << "connect failed" << std::endl;
		}
	});
#endif

	char c;
	std::cin >> c;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa80, %rsp            # imm = 0xA80
leaq -0x280(%rbp), %rdi
callq 0x38f8
leaq 0x4a63(%rip), %rsi      # 0x8014
leaq -0xa90(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x30c0
leaq -0x280(%rbp), %rbx
leaq -0xa90(%rbp), %rsi
pushq $0x50
popq %rdx
movq %rbx, %rdi
callq 0x3f08
movl %eax, %r14d
leaq -0xa90(%rbp), %rdi
callq 0x30e0
testb %r14b, %r14b
je 0x368d
movq 0xa9d7(%rip), %rdi      # 0xdfd0
leaq 0x4a33(%rip), %rsi      # 0x8033
callq 0x31d0
movq %rax, %rdi
callq 0x3110
leaq 0x4a36(%rip), %rsi      # 0x804a
leaq -0x38(%rbp), %rdi
leaq -0xa90(%rbp), %r14
movq %r14, %rdx
callq 0x30c0
movl $0x801, %edx            # imm = 0x801
movq %r14, %rdi
xorl %esi, %esi
callq 0x3130
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rcx
movq %rbx, (%rcx)
movq %r14, 0x8(%rcx)
leaq 0xb8(%rip), %rax        # 0x3708
movq %rax, 0x18(%rcx)
leaq 0x11b(%rip), %rax       # 0x3776
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
callq 0x4722
leaq -0x58(%rbp), %rdi
callq 0x37ec
movq 0xa969(%rip), %rdi      # 0xdfe0
leaq -0x11(%rbp), %rsi
callq 0x3200
leaq -0x38(%rbp), %rdi
callq 0x30e0
xorl %ebx, %ebx
jmp 0x36ab
movq 0xa93c(%rip), %rdi      # 0xdfd0
leaq 0x4987(%rip), %rsi      # 0x8022
callq 0x31d0
movq %rax, %rdi
callq 0x3110
pushq $-0x1
popq %rbx
leaq -0x280(%rbp), %rdi
callq 0x3dd8
movl %ebx, %eax
addq $0xa80, %rsp            # imm = 0xA80
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
jmp 0x36d6
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x37ec
leaq -0x38(%rbp), %rdi
jmp 0x36e8
jmp 0x36f1
movq %rax, %rbx
leaq -0xa90(%rbp), %rdi
callq 0x30e0
jmp 0x36f4
jmp 0x36f1
movq %rax, %rbx
leaq -0x280(%rbp), %rdi
callq 0x3dd8
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]cxx-invert-file-tree/generator.cpp
// Function: main
int main(int argc, char **argv)
{
    if (argc < 2) {
        usage(std::cerr);
        std::cerr << "ERROR: folder path is not provided" << std::endl;
        return 1;
    }

    srand(time(nullptr));

    fs::path folder_path(argv[1]);
    fs::create_directory(folder_path);
    std::cout << "Created Folder: " << folder_path << std::endl;
    generate_tree(folder_path);

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %edi
jg 0x32a8
movq 0x3d6c(%rip), %rbx      # 0x6ff0
movq %rbx, %rdi
callq 0x2fdc
leaq 0xdb4(%rip), %rsi       # 0x4047
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20e0
pushq $0x1
popq %rbx
jmp 0x3310
movq %rsi, %rbx
xorl %edi, %edi
callq 0x2160
movl %eax, %edi
callq 0x2170
addq $0x8, %rbx
movq %rsp, %r14
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34fe
movq %r14, %rdi
callq 0x20b0
movq 0x3cf3(%rip), %rdi      # 0x6fd0
leaq 0xd43(%rip), %rsi       # 0x4027
callq 0x2180
movq %rsp, %rsi
movq %rax, %rdi
callq 0x34a2
movq %rax, %rdi
callq 0x20e0
xorl %ebx, %ebx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3010
movq %rsp, %rdi
callq 0x348c
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x348c
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/engine.cpp
// Function: Engine::Engine(Goban*)
Engine::Engine(Goban *goban):tree(DEF_TREESIZE, goban), amaf(goban->get_size())
{
  main_goban = goban;
  max_playouts = DEF_PLAYOUTS;
  max_time = 10*CLOCKS_PER_SEC;
  max_time = INFINITE;
  tree_size = DEF_TREESIZE;
  rand_movs = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movw $0x1, (%rdi)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
movl $0x4c4b40, %esi         # imm = 0x4C4B40
movq %r15, %rdx
callq 0x930c
leaq 0x50(%rbx), %rdi
movl 0x8(%r15), %esi
callq 0x3d3c
movq %r15, 0x8(%rbx)
movq $0x7fffffff, 0x608(%rbx) # imm = 0x7FFFFFFF
movabsq $0xbb8004c4b40, %rax    # imm = 0xBB8004C4B40
movq %rax, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x9384
movq %rbx, %rdi
callq 0x3340
nop
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/engine.cpp
// Function: Engine::set_times(int, int, int)
void Engine::set_times(int main_time, int byo_time, int stones)
{
  max_playouts = INFINITE;
  this->byo_time = byo_time;
  if (stones) {
    max_time = (main_time/10 + byo_time/stones)*CLOCKS_PER_SEC;
  } else {
    max_time = (0.9*byo_time + main_time/60)*CLOCKS_PER_SEC;
  }
}

// Assembly:
movl %edx, %r8d
movl %esi, %eax
movl $0x7fffffff, 0x14(%rdi) # imm = 0x7FFFFFFF
movslq %edx, %rdx
movq %rdx, 0x610(%rdi)
testl %ecx, %ecx
je 0x3715
pushq $0xa
popq %rsi
cltd
idivl %esi
movl %eax, %esi
movl %r8d, %eax
cltd
idivl %ecx
addl %esi, %eax
cltq
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
jmp 0x373d
cvtsi2sd %r8d, %xmm0
pushq $0x3c
popq %rcx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm1
mulsd 0x68dc(%rip), %xmm0     # 0xa008
addsd %xmm1, %xmm0
mulsd 0x68d8(%rip), %xmm0     # 0xa010
cvttsd2si %xmm0, %rax
movq %rax, 0x608(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/engine.cpp
// Function: Engine::set_times(int, int)
void Engine::set_times(int time_left, int stones)
{
  max_playouts = INFINITE;
  if (stones) max_time = (0.9*time_left/stones)*CLOCKS_PER_SEC;
  else max_time = (0.9*time_left + byo_time)*CLOCKS_PER_SEC;
  std::cerr << max_time << "\n";
}

// Assembly:
movl $0x7fffffff, 0x14(%rdi) # imm = 0x7FFFFFFF
cvtsi2sd %esi, %xmm0
testl %edx, %edx
je 0x3767
mulsd 0x68ab(%rip), %xmm0     # 0xa008
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
jmp 0x377c
cvtsi2sdq 0x610(%rdi), %xmm1
mulsd 0x6890(%rip), %xmm0     # 0xa008
addsd %xmm1, %xmm0
pushq %rax
mulsd 0x688b(%rip), %xmm0     # 0xa010
cvttsd2si %xmm0, %rsi
movq %rsi, 0x608(%rdi)
movq 0xb858(%rip), %rdi      # 0xeff0
callq 0x31d0
leaq 0x6e80(%rip), %rsi      # 0xa624
movq %rax, %rdi
popq %rax
jmp 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/engine.cpp
// Function: Engine::play_random_game(bool)
int Engine::play_random_game(bool heavy)
{
  int pass = 0;
  main_goban->shuffle_empty();
  while (pass < 2) {
    int move = heavy ? main_goban->play_heavy() : main_goban->play_random();
    amaf.play(move, ++simul_len);
    rand_movs++;
    if (move == Goban::PASS) pass++;
    else pass = 0;
#ifdef DEBUG_INFO
      main_goban->print_goban();
#endif
    int mercy = main_goban->mercy();    
    if (mercy != -1) {
      return 1-mercy;
    }
//#ifdef DEBUG_INFO
    if (simul_len > 2*main_goban->get_size2()) {
      std::cerr << "WARNING: Simulation exceeded max length.\n";
      discarded++;
      return -1;
    }
//#endif
  }
    return (main_goban->chinese_count() > 0) ? 1:0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0xfc120, %edi          # imm = 0xFC120
addq 0x8(%rbx), %rdi
callq 0x3e28
leaq 0x50(%rbx), %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rdi
cmpl $0x1, %r13d
jg 0x384a
testb %bpl, %bpl
je 0x37ec
callq 0x78da
jmp 0x37f1
callq 0x78b6
movl %eax, %r15d
movl 0x1c(%rbx), %edx
incl %edx
movl %edx, 0x1c(%rbx)
movq %r14, %rdi
movl %eax, %esi
callq 0x3d6a
incl 0x18(%rbx)
movq 0x8(%rbx), %rdi
callq 0x5542
cmpl $-0x1, %eax
jne 0x385c
incl %r13d
testl %r15d, %r15d
cmovnel %r12d, %r13d
movq 0x8(%rbx), %rax
movl 0xc(%rax), %eax
addl %eax, %eax
cmpl %eax, 0x1c(%rbx)
jle 0x37d6
movq 0xb7ba(%rip), %rdi      # 0xeff0
leaq 0x67f7(%rip), %rsi      # 0xa034
callq 0x31e0
incl 0x20(%rbx)
pushq $-0x1
popq %rax
jmp 0x3863
callq 0x5420
xorps %xmm1, %xmm1
xorl %eax, %eax
ucomiss %xmm1, %xmm0
seta %al
jmp 0x3863
movl %eax, %ecx
pushq $0x1
popq %rax
subl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/engine.cpp
// Function: Engine::back_up_results(int, Node**, int, bool)
void Engine::back_up_results(int result, Node *node_history[], int nnodes, bool side)
{
  for (int i = 0; i < nnodes; i++) {
    node_history[i]->set_results(1-result); //Because root node belongs to opponent.
    node_history[i]->set_amaf(result, amaf, side, i+1);
    side = !side;
    result = 1-result;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %r12d
addq $0x50, %rdi
movq %rdi, (%rsp)
xorl %r13d, %r13d
testl %ecx, %ecx
cmovlel %r13d, %r14d
cmpq %r13, %r14
je 0x3af6
movq (%r15,%r13,8), %rdi
pushq $0x1
popq %rbp
subl %r12d, %ebp
movl %ebp, %esi
callq 0x8dea
movq (%r15,%r13,8), %rdi
incq %r13
movzbl %bl, %ebx
movl %ebx, %ecx
andl $0x1, %ecx
movl %r12d, %esi
movq (%rsp), %rdx
movl %r13d, %r8d
callq 0x8e0a
xorb $0x1, %bl
movl %ebp, %r12d
jmp 0x3aba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/engine.cpp
// Function: Engine::print_PV() const
void Engine::print_PV() const
{
  fin_clock = clock() - fin_clock;
  tree.print();
  int nplayouts = tree.get_root()->get_visits();
  std::cerr << "#Playouts: " << nplayouts
            << ", average length: " << rand_movs/nplayouts
            << ", discarded: " << discarded << ", playouts/sec: "
            << (float)nplayouts/fin_clock*CLOCKS_PER_SEC << "\n";
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x3110
subq 0x600(%rbx), %rax
movq %rax, 0x600(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x976a
movslq 0x44(%rbx), %rax
movq 0x28(%rbx,%rax,8), %rax
movsd 0x8(%rax), %xmm0
movapd %xmm0, (%rsp)
cvttsd2si %xmm0, %ebp
movq 0xb4a7(%rip), %rdi      # 0xeff0
leaq 0x650e(%rip), %rsi      # 0xa05e
callq 0x31e0
movq %rax, %rdi
movl %ebp, %esi
callq 0x3330
leaq 0x6504(%rip), %rsi      # 0xa06a
movq %rax, %rdi
callq 0x31e0
movq %rax, %rdi
movl 0x18(%rbx), %eax
cltd
idivl %ebp
movl %eax, %esi
callq 0x3330
leaq 0x64f8(%rip), %rsi      # 0xa07d
movq %rax, %rdi
callq 0x31e0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3330
leaq 0x64ec(%rip), %rsi      # 0xa08b
movq %rax, %rdi
callq 0x31e0
cvttpd2dq (%rsp), %xmm0
cvtsi2ssq 0x600(%rbx), %xmm1
cvtdq2ps %xmm0, %xmm0
divss %xmm1, %xmm0
mulss 0x646c(%rip), %xmm0     # 0xa030
movq %rax, %rdi
callq 0x3150
leaq 0x6a51(%rip), %rsi      # 0xa624
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/engine.cpp
// Function: Engine::score(std::vector<int, std::allocator<int>>*)
float Engine::score(std::vector<int> *dead)
{
  const int PLAYOUTS = 5000;
  int score = 0;
  int score_table[MAXSIZE2+1] = {0};
  for (int i = 0; i < PLAYOUTS; i++) {
    simul_len = 0;
    play_random_game(LIGHT);
    main_goban->score_area(score_table);
    main_goban->restore();
  }
  for (int i = 1; i <= main_goban->get_size2(); i++) {
    if (score_table[i] > PLAYOUTS/2) score_table[i] = 1;
    else if (score_table[i] < -PLAYOUTS/2) score_table[i] = -1;
    else score_table[i] = 0;
    
    if (dead && main_goban->get_value(i)
        && score_table[i] !=  main_goban->get_value(i)) {
      dead->insert(dead->end(), i);
    }
  }

  for (int i = 1; i <= main_goban->get_size2(); i++) {
    score += score_table[i];
  }
  return score - main_goban->get_komi();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x5c0, %rsp            # imm = 0x5C0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movl $0x5a8, %edx            # imm = 0x5A8
movq %r15, %rdi
xorl %esi, %esi
callq 0x30f0
movl $0x1388, %ebp           # imm = 0x1388
subl $0x1, %ebp
jb 0x3c3e
andl $0x0, 0x1c(%r14)
movzbl 0x1(%r14), %esi
movq %r14, %rdi
callq 0x37ae
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x54c0
movq 0x8(%r14), %rdi
callq 0x4656
jmp 0x3c10
pushq $0x1
popq %rbp
leaq 0xc(%rsp), %r15
movl %ebp, %esi
movl %esi, 0xc(%rsp)
movq 0x8(%r14), %rdi
movl 0xc(%rdi), %eax
cmpl %eax, %esi
jg 0x3cb5
movslq %esi, %rax
movl 0x10(%rsp,%rax,4), %ecx
xorl %edx, %edx
cmpl $0xfffff63c, %ecx       # imm = 0xFFFFF63C
setl %dl
negl %edx
cmpl $0x9c5, %ecx            # imm = 0x9C5
cmovgel %ebp, %edx
movl %edx, 0x10(%rsp,%rax,4)
testq %rbx, %rbx
je 0x3cad
callq 0x5406
testl %eax, %eax
je 0x3cad
movslq 0xc(%rsp), %rsi
movl 0x10(%rsp,%rsi,4), %r12d
movq 0x8(%r14), %rdi
callq 0x5406
cmpl %eax, %r12d
je 0x3cad
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3da4
movl 0xc(%rsp), %esi
incl %esi
jmp 0x3c48
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rcx, %rax
je 0x3ccc
addl 0x14(%rsp,%rcx,4), %edx
incq %rcx
jmp 0x3cbe
cvtsi2ss %edx, %xmm0
subss 0x10(%rdi), %xmm0
addq $0x5c0, %rsp            # imm = 0x5C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/engine.cpp
// Function: Engine::perft(int)
void Engine::perft(int max)
{
  for (int i = 0; i < max; i++) {
    simul_len = 0;
    play_random_game(LIGHT);
    std::cerr << "restoring\n";
    main_goban->restore();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
testl %esi, %esi
cmovgl %esi, %ebp
movq 0xb2f2(%rip), %r14      # 0xeff0
leaq 0x6397(%rip), %r15      # 0xa09c
subl $0x1, %ebp
jb 0x3d30
andl $0x0, 0x1c(%rbx)
movzbl 0x1(%rbx), %esi
movq %rbx, %rdi
callq 0x37ae
movq %r14, %rdi
movq %r15, %rsi
callq 0x31e0
movq 0x8(%rbx), %rdi
callq 0x4656
jmp 0x3d05
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/./amaf.h
// Function: AmafBoard::play(int, int)
int play(int coord, int depth)  //only for coord <= size2
  {
    if (board[coord] == 0) {
      board[coord] = side ? -depth : depth;
      side = !side;
      return 0;
    } else {
      side = !side; //Careful!
      return -1;
    }
  }

// Assembly:
movslq %esi, %rax
cmpl $0x0, (%rdi,%rax,4)
movb 0x5ac(%rdi), %cl
je 0x3d7e
pushq $-0x1
popq %rax
jmp 0x3d8c
movl %edx, %esi
negl %esi
testb %cl, %cl
cmovel %edx, %esi
movl %esi, (%rdi,%rax,4)
xorl %eax, %eax
xorb $0x1, %cl
movb %cl, 0x5ac(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/goban.cpp
// Function: Goban::Goban(int)
Goban::Goban(int newsize)
{
  size = (newsize <= MAXSIZE) ? newsize : size;
  size2 = size*size;
  komi = 0.5;
  clear();
  init_adjacent();
  init_diagonals();
  init_vicinity();
  init_distance();
  init_manhattan();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0xb68, %r14d           # imm = 0xB68
leaq (%rbx,%r14), %rdi
callq 0x58e8
addq $0x970, %r14            # imm = 0x970
cmpq $0xd63c8, %r14          # imm = 0xD63C8
jne 0x4047
leaq 0xac01(%rip), %rax      # 0xec68
movq %rax, 0xfc120(%rbx)
andl $0x0, 0xfc6d0(%rbx)
andl $0x0, 0xfc128(%rbx)
leaq 0xac2d(%rip), %rax      # 0xecb0
movq %rax, 0xfc6d8(%rbx)
andl $0x0, 0xfd7cc(%rbx)
andl $0x0, 0xfc6e0(%rbx)
leaq 0xfd7d0(%rbx), %rdi
callq 0x991c
cmpl $0x14, %ebp
jl 0x40ac
movl 0x8(%rbx), %ebp
movl %ebp, 0x8(%rbx)
imull %ebp, %ebp
movl %ebp, 0xc(%rbx)
movl $0x3f000000, 0x10(%rbx) # imm = 0x3F000000
movq %rbx, %rdi
callq 0x40f0
movq %rbx, %rdi
callq 0x410e
movq %rbx, %rdi
callq 0x41a6
movq %rbx, %rdi
callq 0x4258
movq %rbx, %rdi
callq 0x438e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x43d0
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_adjacent()
void Goban::init_adjacent()
{
  for (int k = 1; k <= size2; k++) {
    int nadj = 0;
    if (k <= size*(size-1)) {  //N
      adjacent[k][nadj++] =  k + size;
    }
    if (k % size) {  //E
      adjacent[k][nadj++] =  k + 1;
    }
    if (k > size) {  //S
      adjacent[k][nadj++] = k - size;
    }
    if (k % size != 1) {  //W
      adjacent[k][nadj++] = k -1;
    }
    adjacent[k][nadj] = 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movslq 0xc(%rdi), %rcx
movslq 0x8(%rdi), %rsi
movl %esi, %r8d
leal -0x1(%rsi), %eax
imull %esi, %eax
movslq %eax, %r9
movl $0x1, %r10d
movl %r10d, %r11d
subl %esi, %r11d
addq $0xd63fc, %rdi          # imm = 0xD63FC
xorl %r14d, %r14d
leaq 0x1(%r14), %rbx
cmpq %rcx, %rbx
jg 0x419e
xorl %ebp, %ebp
cmpq %r9, %rbx
jg 0x4159
leal (%r8,%r14), %eax
incl %eax
movl %eax, (%rdi)
movl %r10d, %ebp
leal 0x1(%r14), %eax
cltd
idivl %r8d
testl %edx, %edx
je 0x4171
movl %ebp, %eax
incl %ebp
leal 0x2(%r14), %r15d
movl %r15d, (%rdi,%rax,4)
cmpq %rsi, %rbx
jle 0x4182
movl %ebp, %eax
incl %ebp
leal (%r11,%r14), %r15d
movl %r15d, (%rdi,%rax,4)
cmpl $0x1, %edx
je 0x418f
movl %ebp, %eax
incl %ebp
movl %r14d, (%rdi,%rax,4)
movl %ebp, %eax
andl $0x0, (%rdi,%rax,4)
addq $0x14, %rdi
movq %rbx, %r14
jmp 0x413e
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_diagonals()
void Goban::init_diagonals()
{

  for (int k = 1; k <= size2; k++) {
    int ndiag = 0;
    if (k <= size*(size-1) && k % size != 1) {  //NW
      diagonals[k][ndiag++] =  k + size - 1;
    }  
    if (k <= size*(size-1) && k % size) {  //NE
      diagonals[k][ndiag++] =  k + size + 1;
    }
    if (k > size && k % size) {  //SE
      diagonals[k][ndiag++] = k - size +1;
    }
    if (k > size && k % size != 1) {  //SW
      diagonals[k][ndiag++] = k - size -1;
    }
    diagonals[k][ndiag] = 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl 0xc(%rdi), %ecx
movslq 0x8(%rdi), %rsi
movl %esi, %r8d
leal -0x1(%rsi), %eax
imull %esi, %eax
movslq %eax, %r9
xorl %ebx, %ebx
testl %ecx, %ecx
cmovlel %ebx, %ecx
movl %esi, %r10d
negl %r10d
addq $0xd8044, %rdi          # imm = 0xD8044
movl $0x1, %r11d
cmpq %rbx, %rcx
je 0x4250
leaq 0x1(%rbx), %r14
xorl %ebp, %ebp
cmpq %r9, %r14
jg 0x4212
leal 0x1(%rbx), %eax
cltd
idivl %r8d
xorl %ebp, %ebp
cmpl $0x1, %edx
je 0x4204
leal (%r8,%rbx), %eax
movl %eax, (%rdi)
movl %r11d, %ebp
testl %edx, %edx
je 0x4212
leal (%r8,%rbx), %eax
addl $0x2, %eax
movl %ebp, %edx
incl %ebp
movl %eax, (%rdi,%rdx,4)
cmpq %rsi, %r14
jle 0x4241
leal 0x1(%rbx), %eax
cltd
idivl %r8d
testl %edx, %edx
je 0x4237
leal (%r10,%rbx), %eax
addl $0x2, %eax
movl %ebp, %r15d
incl %ebp
movl %eax, (%rdi,%r15,4)
cmpl $0x1, %edx
je 0x4241
addl %r10d, %ebx
movl %ebp, %eax
incl %ebp
movl %ebx, (%rdi,%rax,4)
movl %ebp, %eax
andl $0x0, (%rdi,%rax,4)
addq $0x14, %rdi
movq %r14, %rbx
jmp 0x41d9
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_vicinity()
void Goban::init_vicinity()
{  
  for (int i = 0; i <= size2; i++) {
    for (int j = 0; j < 16; j++) {
      vicinity[i][j] = 0;
    }
  }
  //Duplicate to calculate rotations,avoiding run-time modulo division:
  for (int i = 0; i < 2; i++) {
    for (int k = 1; k <= size2; k++) {
      if (k <= size*(size-1)) {
        if (k % size != 1) {  //NW
          vicinity[k][0+8*i] =  k + size - 1;
        }
        vicinity[k][1+8*i] =  k + size;  //N
      }
      if (k % size ) {
        if (k <= size*(size-1)) {  //NE
          vicinity[k][2+8*i] =  k + size + 1;
        }
        vicinity[k][3+8*i] =  k + 1;  //E
      }
      if (k > size) {
        if (k % size) {  //SE
          vicinity[k][4+8*i] = k - size +1;
        }
        vicinity[k][5+8*i] = k - size;  //S
      }
      if (k % size != 1) {
        if (k > size) {  //SW
          vicinity[k][6+8*i] = k - size -1;
        }
        vicinity[k][7+8*i] = k - 1;  //W
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0xc(%rdi), %rcx
leaq 0xd9c78(%rdi), %rax
xorl %edx, %edx
cmpq %rcx, %rdx
jg 0x428e
xorl %esi, %esi
cmpq $0x10, %rsi
je 0x4285
andl $0x0, (%rax,%rsi,4)
incq %rsi
jmp 0x4276
incq %rdx
addq $0x40, %rax
jmp 0x426f
movslq 0x8(%rdi), %rsi
movl %esi, %r8d
leal -0x1(%rsi), %eax
imull %esi, %eax
movslq %eax, %r9
xorl %r10d, %r10d
testl %ecx, %ecx
cmovlel %r10d, %ecx
movl %esi, %r11d
negl %r11d
addq $0xd9cd4, %rdi          # imm = 0xD9CD4
movabsq $0x1, %rbx
cmpq $0x2, %r10
je 0x4383
movq %rdi, %r14
xorl %r12d, %r12d
movq %rbx, %r15
cmpq %r12, %rcx
je 0x4377
leaq 0x1(%r12), %r13
leal 0x1(%r12), %eax
cltd
idivl %r8d
cmpq %r9, %r13
jle 0x42f8
testl %edx, %edx
je 0x4347
leal 0x2(%r12), %eax
jmp 0x4322
cmpl $0x1, %edx
je 0x4305
leal (%r8,%r12), %eax
movl %eax, -0x1c(%r14)
leal (%r8,%r12), %eax
incl %eax
movl %eax, -0x18(%r14)
testl %edx, %edx
je 0x4347
leal 0x1(%r15), %eax
leal (%r8,%r12), %ebp
addl $0x2, %ebp
movl %ebp, -0x14(%r14)
movl %eax, -0x10(%r14)
cmpq %rsi, %r13
jle 0x4360
leal (%r11,%r12), %eax
addl $0x2, %eax
movl %eax, -0xc(%r14)
leal (%r11,%r12), %eax
incl %eax
movl %eax, -0x8(%r14)
cmpl $0x1, %edx
jne 0x4356
jmp 0x4368
cmpq %rsi, %r13
jle 0x4365
leal (%r11,%r12), %eax
incl %eax
movl %eax, -0x8(%r14)
leal (%r11,%r12), %eax
movl %eax, -0x4(%r14)
jmp 0x4365
cmpl $0x1, %edx
je 0x4368
movl %r12d, (%r14)
incq %r15
addq $0x40, %r14
movq %r13, %r12
jmp 0x42d1
incq %r10
addq $0x20, %rdi
jmp 0x42be
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_distance()
void Goban::init_distance()
{
  for (int p = 0; p <= size2; p++) {
    int d = (p-1)%size < (p-1)/size ? (p-1)%size : (p-1)/size;
    if (size - (p-1)%size - 1 < d) {
      d = size - (p-1)%size - 1;
    }
    if (size - (p-1)/size - 1 < d) {
      d = size - (p-1)/size - 1;
    }
    distance_to_edge[p] = d;
  }
}

// Assembly:
movslq 0xc(%rdi), %rcx
movl 0x8(%rdi), %esi
xorl %r8d, %r8d
cmpq %rcx, %r8
jg 0x43ce
leal -0x1(%r8), %eax
cltd
idivl %esi
cmpl %eax, %edx
movl %eax, %r9d
cmovll %edx, %r9d
notl %edx
addl %esi, %edx
cmpl %r9d, %edx
cmovgel %r9d, %edx
notl %eax
addl %esi, %eax
cmpl %edx, %eax
cmovgel %edx, %eax
movl %eax, 0xdf6f8(%rdi,%r8,4)
incq %r8
jmp 0x4398
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/goban.cpp
// Function: Goban::reset()
void Goban::reset()
{
  side = BLACK;
  ko_point = 0;
#ifdef ZOBRIST
  zobrist.reset();
#endif
  stones_on_board[BLACK] = 0, stones_on_board[WHITE] = 0;
  last_atari[BLACK] = 0, last_atari[WHITE] = 0;
  last_point = 0, last_point2 = 0;
  
  for (int i = 0; i <= size2; i++) {
    if (Group *point = points[i]) {
      point->clear();
    }
    points[i] = 0;
  }
  empty_points.clear();
  for (int j = 0; j < size2; j++) {
    empty_points.add(j+1);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, (%rdi)
andl $0x0, 0x4(%rdi)
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
callq 0x9b52
xorps %xmm0, %xmm0
movups %xmm0, 0xd63d8(%rbx)
movups %xmm0, 0xd63c8(%rbx)
xorl %r14d, %r14d
movslq 0xc(%rbx), %rcx
cmpq %rcx, %r14
jg 0x4605
movq 0x18(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x45fa
callq 0x5a1c
andq $0x0, 0x18(%rbx,%r14,8)
incq %r14
jmp 0x45e2
andl $0x0, 0xfc6d0(%rbx)
andl $0x0, 0xfc128(%rbx)
xorl %eax, %eax
movslq 0xfc6d0(%rbx), %rdx
cmpl %ecx, %eax
jge 0x464e
incl %eax
cmpl $0x16a, %edx            # imm = 0x16A
je 0x461c
leal 0x1(%rdx), %ecx
movl %ecx, 0xfc6d0(%rbx)
movl %eax, 0xfc128(%rbx,%rdx,4)
movslq 0xfc6d0(%rbx), %rcx
andl $0x0, 0xfc128(%rbx,%rcx,4)
movl 0xc(%rbx), %ecx
jmp 0x4615
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/antoniogarro[P]Hara/goban.cpp
// Function: Goban::restore()
void Goban::restore()
{
  reset();
  set_fixed_handicap(handicap);
  for (int i = 0; i < game_history.length(); i++) {
    if (game_history[i]) {
      drop_stone(game_history[i], side);
      side = !side;
    } else {
      side = !side;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x45b4
movl 0x14(%rbx), %esi
movq %rbx, %rdi
callq 0x46ac
xorl %r14d, %r14d
movslq 0xfd7cc(%rbx), %rax
cmpq %rax, %r14
jge 0x46a3
movl 0xfc6e0(%rbx,%r14,4), %esi
movb (%rbx), %al
testl %esi, %esi
je 0x469a
movzbl %al, %edx
andl $0x1, %edx
movq %rbx, %rdi
callq 0x46fe
movb (%rbx), %al
xorb $0x1, %al
movb %al, (%rbx)
incq %r14
jmp 0x4670
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop