LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_constructor<helper, helper&>(int, helper&, bool, std::initializer_list<helper::method>)
void test_constructor(int line, U&& src, bool is_init, method_list ml) {
  where(line, __func__);
  helper::mark_call_stack();
  const delayed_init<T> d(std::forward<U>(src));
  helper::check_call_stack(ml);
  assert(static_cast<bool>(d) == is_init);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r12
leaq 0x2dec(%rip), %rsi      # 0x51d1
callq 0x1318
callq 0x221a
movq %rsp, %rdi
movq %r12, %rsi
callq 0x3bd0
movq %r15, %rdi
movq %r14, %rsi
callq 0x2232
cmpb %bl, (%rsp)
jne 0x241e
movq %rsp, %rdi
callq 0x421e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2c2b(%rip), %rdi      # 0x5050
leaq 0x2bfb(%rip), %rsi      # 0x5027
leaq 0x2daf(%rip), %rcx      # 0x51e2
movl $0xba, %edx
callq 0x1090
movq %rax, %rbx
movq %rsp, %rdi
callq 0x421e
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_destructor<overload::delayed_init<helper>>(int, overload::delayed_init<helper> const&, std::initializer_list<helper::method>)
void test_destructor(int line, const U& src, method_list ml) {
  where(line, __func__);
  {
    const delayed_init<const helper> d(src);
    helper::mark_call_stack();
  }
  helper::check_call_stack(ml);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x2ba5(%rip), %rsi      # 0x57e2
callq 0x1318
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x3856
callq 0x221a
leaq 0x8(%rsp), %rdi
callq 0x4112
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2232
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4112
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_assignment<overload::delayed_init<helper>, helper&>(int, helper&, overload::delayed_init<helper> const&, bool, std::initializer_list<helper::method>)
void test_assignment(int line, U&& from, const T& to, bool is_init,
  method_list ml) {
  
  where(line, __func__);
  delayed_init<helper> d(to);
  helper::mark_call_stack();
  d = std::forward<U>(from);
  helper::check_call_stack(ml);
  assert(static_cast<bool>(d) == is_init);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r14
movq %r8, %r15
movl %ecx, %ebx
movq %rdx, %r13
movq %rsi, %r12
leaq 0x2b48(%rip), %rsi      # 0x57f2
callq 0x1318
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x4248
callq 0x221a
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x42c6
movq %r15, %rdi
movq %r14, %rsi
callq 0x2232
cmpb %bl, 0x8(%rsp)
jne 0x2cf7
leaq 0x8(%rsp), %rdi
callq 0x421e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2352(%rip), %rdi      # 0x5050
leaq 0x2322(%rip), %rsi      # 0x5027
leaq 0x2af6(%rip), %rcx      # 0x5802
movl $0xd8, %edx
callq 0x1090
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x421e
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_indirection_uninitialised<overload::delayed_init<helper>>(int)
void test_indirection_uninitialised(int line) {

  where(line, __func__);
  D d;
  helper::mark_call_stack();
  try {
    (*d).get();
    assert(false);
  }
  catch (std::logic_error&) {
  }
  catch (...) {
    assert(false);
  }
  helper::check_call_stack({});
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x2a4e(%rip), %rsi      # 0x5bfa
callq 0x1318
movb $0x0, 0x8(%rsp)
callq 0x221a
leaq 0x8(%rsp), %rdi
callq 0x44d4
movq %rax, %rdi
callq 0x4530
leaq 0x1efe(%rip), %rdi      # 0x50d2
leaq 0x1e4c(%rip), %rsi      # 0x5027
leaq 0x2a37(%rip), %rcx      # 0x5c19
movl $0xe7, %edx
callq 0x1090
movq %rdx, %rbx
movq %rax, %rdi
callq 0x1050
cmpl $0x2, %ebx
jne 0x321a
callq 0x1140
xorl %edi, %edi
xorl %esi, %esi
callq 0x2232
leaq 0x8(%rsp), %rdi
callq 0x421e
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1eb1(%rip), %rdi      # 0x50d2
leaq 0x1dff(%rip), %rsi      # 0x5027
leaq 0x29ea(%rip), %rcx      # 0x5c19
movl $0xec, %edx
callq 0x1090
jmp 0x323b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x421e
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_indirection_initialised<overload::delayed_init<helper>>(int, std::initializer_list<helper::method>)
void test_indirection_initialised(int line, method_list ml) {
  where(line, __func__);
  D d(helper(1));
  helper::mark_call_stack();
  (*d).get();
  helper::check_call_stack(ml);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x29c9(%rip), %rsi      # 0x5cdf
callq 0x1318
leaq 0xc(%rsp), %r15
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x2300
leaq 0x4(%rsp), %rdi
movq %r15, %rsi
callq 0x27f4
movq %r15, %rdi
callq 0x232c
callq 0x221a
leaq 0x4(%rsp), %rdi
callq 0x44d4
movq %rax, %rdi
callq 0x4530
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2232
leaq 0x4(%rsp), %rdi
callq 0x421e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x421e
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_getter<overload::delayed_init<helper>>(int, overload::delayed_init<helper> const&, bool, bool)
void test_getter(int line, const delayed_init<helper>& src, bool is_const,
  bool is_init) {
  
  where(line, __func__);
  D d(src);
  const auto p = d.get();
  assert(is_pointer_to_const(p) == is_const);
  assert(static_cast<bool>(p) == is_init);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
leaq 0x28d0(%rip), %rsi      # 0x5cfc
callq 0x1318
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4248
testl %ebp, %ebp
jne 0x345b
cmpb %bl, 0x8(%rsp)
jne 0x347a
leaq 0x8(%rsp), %rdi
callq 0x421e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28a6(%rip), %rdi      # 0x5d08
leaq 0x1bbe(%rip), %rsi      # 0x5027
leaq 0x28bb(%rip), %rcx      # 0x5d2b
movl $0x109, %edx            # imm = 0x109
callq 0x1090
leaq 0x290f(%rip), %rdi      # 0x5d90
leaq 0x1b9f(%rip), %rsi      # 0x5027
leaq 0x289c(%rip), %rcx      # 0x5d2b
movl $0x10a, %edx            # imm = 0x10A
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_dereference<overload::delayed_init<helper>>(int, std::initializer_list<helper::method>)
void test_dereference(int line, method_list ml) {
  where(line, __func__);
  D d(helper(1));
  helper::mark_call_stack();
  d->get();
  helper::check_call_stack(ml);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x28bf(%rip), %rsi      # 0x5ef7
callq 0x1318
leaq 0xc(%rsp), %r15
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x2300
leaq 0x4(%rsp), %rdi
movq %r15, %rsi
callq 0x27f4
movq %r15, %rdi
callq 0x232c
callq 0x221a
leaq 0x8(%rsp), %rax
xorl %edi, %edi
cmpb $0x0, -0x4(%rax)
cmovneq %rax, %rdi
callq 0x4530
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2232
leaq 0x4(%rsp), %rdi
callq 0x421e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x421e
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_init_uninitialised<int>(int, std::initializer_list<helper::method>, int&&)
void test_init_uninitialised(int line, method_list ml, Args&&... args) {
  where(line, __func__);
  delayed_init<const helper> d;
  helper::mark_call_stack();
  d.init(std::forward<Args>(args)...);
  helper::check_call_stack(ml);
  assert(d);
  assert(d.get());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x2687(%rip), %rsi      # 0x5f08
callq 0x1318
movb $0x0, 0x8(%rsp)
callq 0x221a
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x234e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2232
cmpb $0x0, 0x8(%rsp)
je 0x38c3
leaq 0x8(%rsp), %rdi
callq 0x4112
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2430(%rip), %rdi      # 0x5cfa
leaq 0x1756(%rip), %rsi      # 0x5027
leaq 0x2648(%rip), %rcx      # 0x5f20
movl $0x131, %edx            # imm = 0x131
callq 0x1090
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4112
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_swap_member<overload::delayed_init<helper>, overload::delayed_init<helper>>(int, overload::delayed_init<helper>&, overload::delayed_init<helper>&, std::initializer_list<helper::method>)
void test_swap_member(int line, D1& d1, D2& d2, method_list ml) {
  where(line, __func__);
  const bool is_init1 = static_cast<bool>(d1);
  const bool is_init2 = static_cast<bool>(d2);
  helper::mark_call_stack();
  d1.swap(d2);
  helper::check_call_stack(ml);
  assert(static_cast<bool>(d2) == is_init1);
  assert(static_cast<bool>(d1) == is_init2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
leaq 0x255d(%rip), %rsi      # 0x60ae
callq 0x1318
movb (%rbx), %r13b
movb (%r12), %bpl
callq 0x221a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x474c
movq %r15, %rdi
movq %r14, %rsi
callq 0x2232
cmpb %r13b, (%r12)
jne 0x3b92
cmpb %bpl, (%rbx)
jne 0x3bb1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2526(%rip), %rdi      # 0x60bf
leaq 0x1487(%rip), %rsi      # 0x5027
leaq 0x253a(%rip), %rcx      # 0x60e1
movl $0x155, %edx            # imm = 0x155
callq 0x1090
leaq 0x25a8(%rip), %rdi      # 0x6160
leaq 0x1468(%rip), %rsi      # 0x5027
leaq 0x251b(%rip), %rcx      # 0x60e1
movl $0x156, %edx            # imm = 0x156
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/delayed_init.cpp
// Function: void test_swap_non_member<overload::delayed_init<helper>, overload::delayed_init<helper>>(int, overload::delayed_init<helper>&, overload::delayed_init<helper>&, std::initializer_list<helper::method>)
void test_swap_non_member(int line, D1& d1, D2& d2, method_list ml) {
  where(line, __func__);
  const bool is_init1 = static_cast<bool>(d1);
  const bool is_init2 = static_cast<bool>(d2);
  helper::mark_call_stack();
  swap(d1, d2);
  helper::check_call_stack(ml);
  assert(static_cast<bool>(d2) == is_init1);
  assert(static_cast<bool>(d1) == is_init2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
leaq 0x258c(%rip), %rsi      # 0x6182
callq 0x1318
movb (%rbx), %r13b
movb (%r12), %bpl
callq 0x221a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x474c
movq %r15, %rdi
movq %r14, %rsi
callq 0x2232
cmpb %r13b, (%r12)
jne 0x3c37
cmpb %bpl, (%rbx)
jne 0x3c56
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2481(%rip), %rdi      # 0x60bf
leaq 0x13e2(%rip), %rsi      # 0x5027
leaq 0x254b(%rip), %rcx      # 0x6197
movl $0x165, %edx            # imm = 0x165
callq 0x1090
leaq 0x2503(%rip), %rdi      # 0x6160
leaq 0x13c3(%rip), %rsi      # 0x5027
leaq 0x252c(%rip), %rcx      # 0x6197
movl $0x166, %edx            # imm = 0x166
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/./delayed_init.h
// Function: void overload::delayed_init<helper>::assign<helper&>(bool, helper&)
void assign(bool src_is_init, U&& src_obj) {
    if (!is_init_)
      init_me(src_is_init, std::forward<U>(src_obj));
    else if (src_is_init)
      obj_ = std::forward<U>(src_obj);
    else
      destroy();
  }

// Assembly:
cmpb $0x0, (%rdi)
je 0x42fa
testb %sil, %sil
je 0x4307
addq $0x4, %rdi
movq %rdx, %rsi
jmp 0x430e
testb %sil, %sil
je 0x430c
movq %rdx, %rsi
jmp 0x4348
jmp 0x421e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cassioneri[P]delayed_init/./delayed_init.h
// Function: overload::delayed_init<helper>::swap(overload::delayed_init<helper>&)
void swap(delayed_init& src)
    noexcept(
      std::is_nothrow_copy_constructible<T>::value &&
      std::is_nothrow_move_constructible<T>::value &&
      traits::is_nothrow_swappable<T>::value
    ) {
    if (is_init_) {
      if (src.is_init_) {
        
        using std::swap;
        swap(obj_, src.obj_);
      }
      else {
        src.init_obj(std::move(obj_));
        destroy();
      }
    }
    else if (src.is_init_) {
      init_obj(std::move(src.obj_));
      src.destroy();
    }
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb (%rsi), %al
cmpb $0x1, (%rdi)
jne 0x477b
leaq 0x4(%r14), %rsi
testb %al, %al
je 0x4790
addq $0x4, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12dc
testb %al, %al
je 0x47a7
leaq 0x4(%rbx), %rsi
movq %r14, %rdi
callq 0x4236
movq %rbx, %rdi
jmp 0x479b
movq %rbx, %rdi
callq 0x4236
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x421e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Gydo194[P]server/server/Server.cpp
// Function: Server::setup(int)
void Server::setup(int port)
{
    mastersocket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (mastersocket_fd < 0) {
        perror("Socket creation failed");
    }

    FD_ZERO(&masterfds);
    FD_ZERO(&tempfds);

    memset(&servaddr, 0, sizeof (servaddr)); //bzero
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htons(INADDR_ANY);
    servaddr.sin_port = htons(port);

    bzero(input_buffer,INPUT_BUFFER_SIZE); //zero the input buffer before use to avoid random data appearing in first receives
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2070
movl %eax, 0x10c(%rbx)
testl %eax, %eax
js 0x264a
xorl %eax, %eax
cmpq $0x10, %rax
je 0x25d6
andq $0x0, 0x8(%rbx,%rax,8)
incq %rax
jmp 0x25c5
xorl %eax, %eax
cmpq $0x10, %rax
je 0x25ec
andq $0x0, 0x88(%rbx,%rax,8)
incq %rax
jmp 0x25d8
andq $0x0, 0x1a0(%rbx)
movw $0x2, 0x198(%rbx)
andl $0x0, 0x19c(%rbx)
rolw $0x8, %bp
movw %bp, 0x19a(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1a8(%rbx)
movups %xmm0, 0x1b8(%rbx)
movups %xmm0, 0x1c8(%rbx)
movups %xmm0, 0x1d8(%rbx)
movups %xmm0, 0x1e8(%rbx)
movups %xmm0, 0x1f8(%rbx)
andl $0x0, 0x208(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x19b3(%rip), %rdi      # 0x4004
callq 0x2180
jmp 0x25c3
nop
// File: /workspace/github_cpp_makefile_star2_O2/Gydo194[P]server/server/Server.cpp
// Function: Server::initializeSocket()
void Server::initializeSocket()
{
	#ifdef SERVER_DEBUG
	std::cout << "[SERVER] initializing socket\n";
	#endif
	int opt_value = 1;
	int ret_test = setsockopt(mastersocket_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &opt_value, sizeof (int));
	#ifdef SERVER_DEBUG
	printf("[SERVER] setsockopt() ret %d\n", ret_test);
    	#endif
	if (ret_test < 0) {
        	perror("[SERVER] [ERROR] setsockopt() failed");
		shutdown();
    	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movl 0x10c(%rdi), %edi
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
pushq $0x4
popq %r8
callq 0x22f0
testl %eax, %eax
js 0x26e2
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1932(%rip), %rdi      # 0x401b
callq 0x2180
movq %rbx, %rdi
callq 0x26f8
jmp 0x26dc
// File: /workspace/github_cpp_makefile_star2_O2/Gydo194[P]server/server/Server.cpp
// Function: Server::bindSocket()
void Server::bindSocket()
{
	#ifdef SERVER_DEBUG
	std::cout << "[SERVER] binding...\n";
	#endif
	int bind_ret = bind(mastersocket_fd, (struct sockaddr*) &servaddr, sizeof (servaddr));
	#ifdef SERVER_DEBUG
	printf("[SERVER] bind() ret %d\n", bind_ret);
	#endif
	if (bind_ret < 0) {
		perror("[SERVER] [ERROR] bind() failed");
	}
	FD_SET(mastersocket_fd, &masterfds); //insert the master socket file-descriptor into the master fd-set
	maxfd = mastersocket_fd; //set the current known maximum file descriptor count
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x10c(%rdi), %edi
leaq 0x198(%rbx), %rsi
pushq $0x10
popq %rdx
callq 0x2050
testl %eax, %eax
js 0x274d
movl 0x10c(%rbx), %esi
pushq $0x40
popq %rcx
movl %esi, %eax
cltd
idivl %ecx
movslq %eax, %rdx
shll $0x6, %eax
movl %esi, %ecx
subl %eax, %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
orq %rax, 0x8(%rbx,%rdx,8)
movw %si, 0x108(%rbx)
popq %rbx
retq
leaq 0x18ec(%rip), %rdi      # 0x4040
callq 0x2180
jmp 0x2721
nop
// File: /workspace/github_cpp_makefile_star2_O2/Gydo194[P]server/server/Server.cpp
// Function: Server::handleNewConnection()
void Server::handleNewConnection()
{
	#ifdef SERVER_DEBUG
  	 std::cout << "[SERVER] [CONNECTION] handling new connection\n";
    	#endif
    	socklen_t addrlen = sizeof (client_addr);
    	tempsocket_fd = accept(mastersocket_fd, (struct sockaddr*) &client_addr, &addrlen);
    	
	if (tempsocket_fd < 0) {
        	perror("[SERVER] [ERROR] accept() failed");
	} else {
        	FD_SET(tempsocket_fd, &masterfds);
		//increment the maximum known file descriptor (select() needs it)
        	if (tempsocket_fd > maxfd) {
            		maxfd = tempsocket_fd;
			#ifdef SERVER_DEBUG
            		std::cout << "[SERVER] incrementing maxfd to " << maxfd << std::endl;
			#endif
        	}
        	#ifdef SERVER_DEBUG
        	printf("[SERVER] [CONNECTION] New connection on socket fd '%d'.\n",tempsocket_fd);
		#endif
    }
    newConnectionCallback(tempsocket_fd); //call the callback
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x80, (%rdx)
movl 0x10c(%rdi), %edi
leaq 0x118(%rbx), %rsi
callq 0x2090
movl %eax, 0x110(%rbx)
testl %eax, %eax
js 0x27e0
pushq $0x1
popq %rdx
movl %eax, %ecx
shlq %cl, %rdx
movl %eax, %ecx
shrl $0x6, %ecx
orq %rdx, 0x8(%rbx,%rcx,8)
movzwl 0x108(%rbx), %ecx
cmpl %ecx, %eax
jbe 0x27d1
movw %ax, 0x108(%rbx)
movzwl %ax, %edi
callq *0x240(%rbx)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1899(%rip), %rdi      # 0x4080
callq 0x2180
movl 0x110(%rbx), %eax
jmp 0x27d1
// File: /workspace/github_cpp_makefile_star2_O2/Gydo194[P]server/server/Server.cpp
// Function: Server::recvInputFromExisting(int)
void Server::recvInputFromExisting(int fd)
{
    int nbytesrecv = recv(fd, input_buffer, INPUT_BUFFER_SIZE, 0);
    if (nbytesrecv <= 0)
    {
        //problem
        if (0 == nbytesrecv)
	{
        	disconnectCallback((uint16_t)fd);
		close(fd); //well then, bye bye.
        	FD_CLR(fd, &masterfds);
        	return;
        } else 
	{
        	perror("[SERVER] [ERROR] recv() failed");
        }
        close(fd); //close connection to client
        FD_CLR(fd, &masterfds); //clear the client fd from fd set
        return;
    }
    #ifdef SERVER_DEBUG
    printf("[SERVER] [RECV] Received '%s' from client!\n", input_buffer);
    #endif
    receiveCallback(fd,input_buffer);
    //memset(&input_buffer, 0, INPUT_BUFFER_SIZE); //zero buffer //bzero
    bzero(&input_buffer,INPUT_BUFFER_SIZE); //clear input buffer
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x1a8(%rdi), %r14
pushq $0x64
popq %rdx
movl %esi, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x20a0
testl %eax, %eax
jle 0x284a
movzwl %bp, %edi
movq %r14, %rsi
callq *0x248(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
andl $0x0, 0x60(%r14)
jmp 0x2873
jne 0x2878
movzwl %bp, %edi
callq *0x250(%rbx)
movl %ebp, %edi
callq 0x2310
pushq $-0x2
popq %rsi
movl %ebp, %ecx
rolq %cl, %rsi
pushq $0x40
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
cltq
andq %rsi, 0x8(%rbx,%rax,8)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1822(%rip), %rdi      # 0x40a1
callq 0x2180
jmp 0x2855
// File: /workspace/github_cpp_makefile_star2_O2/Gydo194[P]server/server/Server.cpp
// Function: Server::loop()
void Server::loop()
{
    tempfds = masterfds; //copy fd_set for select()
    #ifdef SERVER_DEBUG
    printf("[SERVER] [MISC] max fd = '%hu' \n", maxfd);
    std::cout << "[SERVER] [MISC] calling select()\n";
    #endif
    int sel = select(maxfd + 1, &tempfds, NULL, NULL, NULL); //blocks until activity
    //printf("[SERVER] [MISC] select() ret %d, processing...\n", sel);
    if (sel < 0) {
        perror("[SERVER] [ERROR] select() failed");
        shutdown();
    }

    //no problems, we're all set

    //loop the fd_set and check which socket has interactions available
    for (int i = 0; i <= maxfd; i++) {
        if (FD_ISSET(i, &tempfds)) { //if the socket has activity pending
            if (mastersocket_fd == i) {
                //new connection on master socket
                handleNewConnection();
            } else {
                //exisiting connection has new data
                recvInputFromExisting(i);
            }
        } //loop on to see if there is more
    }


}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
leaq 0x88(%rdi), %r14
pushq $0x10
popq %rcx
movq %r14, %rdi
rep  movsq (%rsi), %es:(%rdi)
movzwl 0x108(%rbx), %edi
incl %edi
xorl %r15d, %r15d
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x21b0
testl %eax, %eax
jns 0x2908
leaq 0x17f8(%rip), %rdi      # 0x40c0
callq 0x2180
movq %rbx, %rdi
callq 0x26f8
jmp 0x2908
movl %r15d, %eax
shrl $0x6, %eax
movq (%r14,%rax,8), %rax
btq %r15, %rax
jae 0x2905
cmpl 0x10c(%rbx), %r15d
jne 0x28fa
movq %rbx, %rdi
callq 0x277e
jmp 0x2905
movq %rbx, %rdi
movl %r15d, %esi
callq 0x27f4
incl %r15d
movzwl 0x108(%rbx), %eax
cmpl %eax, %r15d
jbe 0x28d7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Gydo194[P]server/controller/actions.cpp
// Function: Actions::testAction(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 Actions::testAction(vector<string> *vals)
{
	cout << "TestAction: argument count: " << vals->size() << endl;
	uint8_t n = 0;
	for(string i : *vals)
	{
		printf("TestAction: argument no '%hu' = '%s'\n", n, i.c_str());
		++n;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0x4612(%rip), %rdi      # 0x6fd0
leaq 0x1724(%rip), %rsi      # 0x40e9
callq 0x21c0
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x5, %rsi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2100
movq (%r14), %rbx
movq 0x8(%r14), %r12
xorl %ebp, %ebp
movq %rsp, %r14
leaq 0x170e(%rip), %r15      # 0x4106
cmpq %r12, %rbx
je 0x2a2d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2240
movzbl %bpl, %ebp
movq (%rsp), %rdx
movq %r15, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x2040
incb %bpl
movq %r14, %rdi
callq 0x20e0
addq $0x20, %rbx
jmp 0x29f8
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Gydo194[P]server/controller/../misc/map_get.hpp
// Function: bool map_get<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void (*)(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>>>>*)>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void (*)(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>>>>*), std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, void (*)(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>>>>*)>>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void (**)(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>>>>*))
bool map_get(map<K,V> *src_map, const K key_source, V *dest_var) {
    try {
        *dest_var = src_map->at(key_source);
        return true;
    } catch(out_of_range oor) {
        return false;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
callq 0x2ee0
movq (%rax), %rax
movq %rax, (%rbx)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rax, %rdi
callq 0x2210
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2d6c
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2250
callq 0x22a0
xorl %eax, %eax
jmp 0x2d9c
// File: /workspace/github_cpp_makefile_star2_O2/Gydo194[P]server/main.cpp
// Function: main
int main(int argc, char **argv)
{
	//add controller actions
	attachActions();
	//set server callbacks
	server.onConnect(&Controller::handleServerConnection);
	server.onDisconnect(&Controller::handleServerDisconnect);
	server.onInput(&Controller::handleServerInput);
	server.init();
	
	//actual main loop
	while(true)
	{
		server.loop();
	}
}

// Assembly:
pushq %rbx
callq 0x31a0
leaq 0x4011(%rip), %rbx      # 0x7210
leaq -0x7ca(%rip), %rsi      # 0x2a3c
movq %rbx, %rdi
callq 0x293c
leaq -0x7b0(%rip), %rsi      # 0x2a65
movq %rbx, %rdi
callq 0x2944
leaq -0x796(%rip), %rsi      # 0x2a8e
movq %rbx, %rdi
callq 0x2934
movq %rbx, %rdi
callq 0x291a
movq %rbx, %rdi
callq 0x2886
jmp 0x3234
// File: /workspace/github_cpp_makefile_star2_O2/Gydo194[P]server/parser/parser.cpp
// Function: Parser::parse(char const*)
void Parser::parse(const char *buffer)
{
	string in = buffer;
	istringstream iss(in);

	string sub;
	while(iss >> sub)
	{
		values.push_back(sub);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
callq 0x323e
leaq 0x40(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x22d0
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x40(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3386
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33dc
jmp 0x3360
movq %rsp, %rdi
callq 0x20e0
leaq 0x40(%rsp), %rdi
callq 0x20f0
leaq 0x20(%rsp), %rdi
callq 0x20e0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x33c9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20e0
leaq 0x40(%rsp), %rdi
callq 0x20f0
leaq 0x20(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]cxx-invert-file-tree/inverter.cpp
// Function: free_file_name(std::filesystem::__cxx11::path const&)
fs::path free_file_name(const fs::path &root)
{
    std::string prefix = "_";
    int counter = 0;

    while (fs::exists(root / (prefix + std::to_string(counter)))) {
        counter++;
    }

    return root / (prefix + std::to_string(counter));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x1c1c(%rip), %rsi      # 0x4040
leaq 0x38(%rsp), %rdi
leaq 0x80(%rsp), %r12
movq %r12, %rdx
callq 0x28b8
xorl %ebp, %ebp
leaq 0xa8(%rsp), %r13
leaq 0x18(%rsp), %rbx
leaq 0x58(%rsp), %r15
movq %r13, %rdi
movl %ebp, %esi
callq 0x296a
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
movq %r13, %rdx
callq 0x2946
movq %r15, %rdi
movq %rbx, %rsi
pushq $0x2
popq %rdx
callq 0x29c4
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x290e
movq %r12, %rdi
callq 0x28f3
movl %eax, %r14d
movq %r12, %rdi
callq 0x2a0c
movq %r15, %rdi
callq 0x2a0c
movq %rbx, %rdi
callq 0x20d0
movq %r13, %rdi
callq 0x20d0
testb %r14b, %r14b
je 0x24b9
incl %ebp
jmp 0x244d
leaq 0x18(%rsp), %rdi
movl %ebp, %esi
callq 0x296a
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x2946
movq 0x10(%rsp), %rbx
leaq 0x80(%rsp), %rdi
leaq 0x58(%rsp), %rsi
pushq $0x2
popq %rdx
callq 0x29c4
leaq 0x80(%rsp), %rdx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x290e
leaq 0x80(%rsp), %rdi
callq 0x2a0c
leaq 0x58(%rsp), %rdi
callq 0x20d0
leaq 0x18(%rsp), %rdi
callq 0x20d0
leaq 0x38(%rsp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x2a0c
jmp 0x255d
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x20d0
jmp 0x256c
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x25b5
jmp 0x2575
movq %rax, %rbx
jmp 0x25ba
movq %rax, %rbx
jmp 0x25ad
movq %rax, %rbx
jmp 0x25a3
movq %rax, %rbx
jmp 0x2599
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x2a0c
leaq 0x58(%rsp), %rdi
callq 0x2a0c
leaq 0x18(%rsp), %rdi
callq 0x20d0
leaq 0xa8(%rsp), %rdi
callq 0x20d0
leaq 0x38(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]cxx-invert-file-tree/inverter.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;
    }

    fs::path folder_path(argv[1]);
    invert_folder(folder_path);

    return 0;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpl $0x1, %edi
jg 0x2874
movq 0x47a0(%rip), %rbx      # 0x6ff0
movq %rbx, %rdi
callq 0x23ec
leaq 0x17e9(%rip), %rsi      # 0x4048
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
pushq $0x1
popq %rax
jmp 0x289c
addq $0x8, %rsi
leaq 0x8(%rsp), %rbx
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x2b1e
movq %rbx, %rdi
callq 0x25cc
leaq 0x8(%rsp), %rdi
callq 0x2a0c
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2a0c
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/config_json_impl.hpp
// Function: AutoJson::Json::operator ProcessConfig::DiskQuota<ProcessConfig::DiskQuota>()
AutoJson::Json::operator ::ProcessConfig::DiskQuota() {
	::ProcessConfig::DiskQuota obj;
	obj.blockQuota = (*this)["blockQuota"].Get<int>();
	obj.inodeQuota = (*this)["inodeQuota"].Get<int>();
	return obj;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2174c(%rip), %rsi     # 0x5b21d
callq 0x3995e
movq %rax, %rdi
callq 0x39600
movl %eax, %ebp
leaq 0x21741(%rip), %rsi     # 0x5b228
movq %rbx, %rdi
callq 0x3995e
movq %rax, %rdi
callq 0x39600
shlq $0x20, %rax
movl %ebp, %ecx
orq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/config_json_impl.hpp
// Function: AutoJson::Json::operator ProcessConfig::Environment<ProcessConfig::Environment>()
AutoJson::Json::operator ::ProcessConfig::Environment() {
	::ProcessConfig::Environment obj;
	obj.useDefaultRules = (*this)["useDefaultRules"].Get<int>();
	obj.passEnvironment = (*this)["passEnvironment"].Get<int>();
	obj.rules = (*this)["rules"].Get<vector<string>>();
	return obj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
movq $0x1, (%rdi)
leaq 0x215f0(%rip), %rsi     # 0x5b233
movq %r15, %rdi
callq 0x3995e
movq %rax, %rdi
callq 0x39600
movl %eax, (%r14)
leaq 0x215e6(%rip), %rsi     # 0x5b243
movq %r15, %rdi
callq 0x3995e
movq %rax, %rdi
callq 0x39600
movl %eax, 0x4(%r14)
leaq 0x215db(%rip), %rsi     # 0x5b253
movq %r15, %rdi
callq 0x3995e
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4f1c4
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f3f0
movq %r15, %rdi
callq 0x41050
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x39cb4
movq %rax, %r14
movq %rbx, %rdi
callq 0x41050
movq %r14, %rdi
callq 0x377f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/config_json_impl.hpp
// Function: AutoJson::Json::operator ProcessConfig::FilePermissions<ProcessConfig::FilePermissions>()
AutoJson::Json::operator ::ProcessConfig::FilePermissions() {
	::ProcessConfig::FilePermissions obj;
	obj.rules = (*this)["rules"].Get<vector<string>>();
	obj.fullPermissionsOverFolder = (*this)["fullPermissionsOverFolder"].Get<int>();
	return obj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movl $0x1, 0x18(%rdi)
leaq 0x21495(%rip), %rsi     # 0x5b253
movq %r14, %rdi
callq 0x3995e
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4f1c4
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f3f0
movq %r15, %rdi
callq 0x41050
leaq 0x21467(%rip), %rsi     # 0x5b259
movq %r14, %rdi
callq 0x3995e
movq %rax, %rdi
callq 0x39600
movl %eax, 0x18(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x39e14
movq %rax, %r14
movq %rbx, %rdi
callq 0x41050
movq %r14, %rdi
callq 0x377f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/runstats_json_impl.hpp
// Function: AutoJson::Json::Json<RunStats::TimeStat>(RunStats::TimeStat const&)
AutoJson::Json::Json(const ::RunStats::TimeStat& rhs) : type(JsonType::OBJECT), content(new std::map<std::string, Json>()) {
	(*this)["wallTimeMs"] = rhs.wallTimeMs;
	(*this)["cpuTimeMs"] = rhs.cpuTimeMs;
	(*this)["userTimeMs"] = rhs.userTimeMs;
	(*this)["systemTimeMs"] = rhs.systemTimeMs;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x4, (%rdi)
pushq $0x30
popq %rdi
callq 0x37460
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq %rax, 0x8(%rbx)
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x410ba
leaq 0x1fab6(%rip), %rsi     # 0x5b528
movq %rbx, %rdi
callq 0x3995e
leaq 0x8(%rsp), %rdi
movl (%rdi), %ecx
movl %ecx, (%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x8(%rdi)
andl $0x0, (%rdi)
callq 0x38480
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x410ba
leaq 0x1fa86(%rip), %rsi     # 0x5b533
movq %rbx, %rdi
callq 0x3995e
leaq 0x8(%rsp), %rdi
movl (%rdi), %ecx
movl %ecx, (%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x8(%rdi)
andl $0x0, (%rdi)
callq 0x38480
movq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x410ba
leaq 0x1fa55(%rip), %rsi     # 0x5b53d
movq %rbx, %rdi
callq 0x3995e
leaq 0x8(%rsp), %rdi
movl (%rdi), %ecx
movl %ecx, (%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x8(%rdi)
andl $0x0, (%rdi)
callq 0x38480
movq 0x18(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x410ba
leaq 0x1fa25(%rip), %rsi     # 0x5b548
movq %rbx, %rdi
callq 0x3995e
leaq 0x8(%rsp), %rdi
movl (%rdi), %ecx
movl %ecx, (%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x8(%rdi)
andl $0x0, (%rdi)
callq 0x38480
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x3bb57
jmp 0x3bb57
jmp 0x3bb57
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x38480
movq %rbx, %rdi
callq 0x377f0
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/runstats_json_impl.hpp
// Function: AutoJson::Json::operator RunStats::TimeStat<RunStats::TimeStat>()
AutoJson::Json::operator ::RunStats::TimeStat() {
	::RunStats::TimeStat obj;
	obj.wallTimeMs = (*this)["wallTimeMs"].Get<unsigned long long>();
	obj.cpuTimeMs = (*this)["cpuTimeMs"].Get<unsigned long long>();
	obj.userTimeMs = (*this)["userTimeMs"].Get<unsigned long long>();
	obj.systemTimeMs = (*this)["systemTimeMs"].Get<unsigned long long>();
	return obj;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1f9ab(%rip), %rsi     # 0x5b528
movq %r14, %rdi
callq 0x3995e
movq %rax, %rdi
callq 0x396e0
movq %rax, (%rbx)
leaq 0x1f99c(%rip), %rsi     # 0x5b533
movq %r14, %rdi
callq 0x3995e
movq %rax, %rdi
callq 0x396e0
movq %rax, 0x8(%rbx)
leaq 0x1f98b(%rip), %rsi     # 0x5b53d
movq %r14, %rdi
callq 0x3995e
movq %rax, %rdi
callq 0x396e0
movq %rax, 0x10(%rbx)
leaq 0x1f97b(%rip), %rsi     # 0x5b548
movq %r14, %rdi
callq 0x3995e
movq %rax, %rdi
callq 0x396e0
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/lib.hpp
// Function: ProcessKeeper::ProcessKeeper(ProcessConfig, int, int*)
ProcessKeeper::ProcessKeeper(ProcessConfig config, int processPid, int errorPipes[2]) : processStats() {
    this->config = config;
    this->processPid = processPid;
    this->errorPipes[0] = errorPipes[0];
    this->errorPipes[1] = errorPipes[1];
    processKeeper = this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x41164
leaq 0x178(%rbx), %rdi
xorl %esi, %esi
callq 0x4162e
leaq 0x198(%rbx), %rdi
callq 0x41574
movq %rbx, %rdi
movq %r15, %rsi
callq 0x41668
movl %ebp, 0x168(%rbx)
movl (%r14), %eax
movl %eax, 0x16c(%rbx)
movl 0x4(%r14), %eax
movl %eax, 0x170(%rbx)
movq %rbx, 0x398de(%rip)     # 0x75af0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x200(%rbx), %rdi
callq 0x37958
jmp 0x3c231
movq %rax, %r14
movq %rbx, %rdi
callq 0x42d14
movq %r14, %rdi
callq 0x377f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/lib.hpp
// Function: ProcessKeeper::alarmSignalHandler(int)
void ProcessKeeper::alarmSignalHandler(int UNUSED signum) {
    /// signal callback must be static method / function
    /// it calls the processKeeper pointer which is set up in
    /// initProcessKeeper function
    RunStats::ResultCode status = processKeeper->checkLimits();
    if (status != RunStats::OK) {
        processKeeper->killProcess(status);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq 0x3989e(%rip), %rdi     # 0x75af0
callq 0x41758
cmpl $0x1, %eax
je 0x3c295
movl %eax, %ebx
movq 0x3988b(%rip), %r14     # 0x75af0
leaq 0x1eedc(%rip), %rsi     # 0x5b148
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x40b24
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x417c0
leaq 0x10(%rsp), %rdi
callq 0x37958
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x37958
movq %rbx, %rdi
callq 0x377f0
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/lib.hpp
// Function: ProcessInitialiser::ASyncStart(void*)
int ProcessInitialiser::ASyncStart(void* args) {
    ProcessInitialiser* initialiser = (ProcessInitialiser*)args;
    initialiser->setupSystem();

    Msg("Provided run command:%s\n", initialiser->config.runCommand.c_str());

    char** processArgs = Base::StringToCharSS(Base::ParseCommandLine(initialiser->config.runCommand));
    auto environment = Rules::Environment(initialiser->config.environment);
    char** env = environment.getEnvironment();

    /// child process inherits everything from parent
    /// * opened std{in,out,err}
    /// * cpu, mem, disk, network limits
    /// * cgroup id (associated with limits)
    /// * pwd, relative root
    /// all these limitations can't be enlarged, only reduced/shrinked

    char** c = processArgs;
    while (*c != nullptr) {
        Msg("Run command:\t%s\n", *c);
        c++;
    }

    execvpe(processArgs[0], processArgs, env);
    Die("execvpe(%s): %m", processArgs[0]);

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
callq 0x418c6
leaq 0xe8(%r14), %rbx
movq 0xe8(%r14), %rsi
leaq 0x1f2f2(%rip), %rdi     # 0x5b628
xorl %eax, %eax
callq 0x3b443
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3a9bf
movq %r15, %rdi
callq 0x3ab48
movq %rax, %rbx
movq %r15, %rdi
callq 0x41050
addq $0x108, %r14            # imm = 0x108
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x41940
movq %r15, %rdi
callq 0x41a4e
movq %rax, %r14
leaq 0x1f2bc(%rip), %r15     # 0x5b641
movq %rbx, %r12
movq (%r12), %rsi
testq %rsi, %rsi
je 0x3c3a1
movq %r15, %rdi
xorl %eax, %eax
callq 0x3b443
addq $0x8, %r12
jmp 0x3c388
movq (%rbx), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x37900
movq (%rbx), %rsi
leaq 0x1f299(%rip), %rdi     # 0x5b652
xorl %eax, %eax
callq 0x3b2a4
jmp 0x3c3c4
jmp 0x3c3c4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x47c8a
movq %rbx, %rdi
callq 0x377f0
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/bin.cpp
// Function: CopyArguments(int, char**)
char** CopyArguments(int argc, char** argv) {
    char** new_argv = (char**)malloc((argc + 1) * sizeof(char*));
    new_argv[argc] = nullptr;
    for (int i = 0; i < argc; i += 1) {
        int len = strlen(argv[i]);
        char* txt = (char*)malloc(len * sizeof(char));
        for (int j = 0; j < len; j += 1) {
            txt[j] = argv[i][j];
        }
        txt[len] = '\0';
        new_argv[i] = txt;
    }

    return new_argv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq %edi, %r13
leaq 0x8(,%r13,8), %rdi
callq 0x37620
movq %rax, %r14
andq $0x0, (%rax,%r13,8)
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
cmpq %r13, %rbp
je 0x3c452
movq (%rbx,%rbp,8), %r15
movq %r15, %rdi
callq 0x371b0
movslq %eax, %r12
movq %r12, %rdi
callq 0x37620
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %r12d, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x3c444
movb (%r15,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
jmp 0x3c432
movb $0x0, (%rax,%r12)
movq %rax, (%r14,%rbp,8)
incq %rbp
jmp 0x3c408
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/bin.cpp
// Function: DeleteArgumentsCopy(char**)
void DeleteArgumentsCopy(char** argv) {
    char** start = argv;
    while (*argv != nullptr) {
        delete *argv;
        argv++;
    }

    delete start;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
movq %rdi, %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3c489
movq %r14, %rsi
callq 0x37470
addq $0x8, %r15
jmp 0x3c473
pushq $0x8
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x37470
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/bin.cpp
// Function: LevenshteinDistance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int LevenshteinDistance(const string& a, const string& b) {
    vector<vector<int>> d(a.size() + 1, vector<int>(b.size() + 1, 0));
    for (int i = 1; i <= (int)a.size(); i += 1) {
        d[i][0] = i;
    }

    for (int i = 1; i <= (int)b.size(); i += 1) {
        d[0][i] = i;
    }

    for (int i = 1; i <= (int)a.size(); i += 1) {
        for (int j = 1; j <= (int)b.size(); j += 1) {
            d[i][j] = min({d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (a[i - 1] == b[j - 1] ? 0 : 1)});
        }
    }

    return d[a.size()][b.size()];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x8(%rsi), %rsi
incq %rsi
leaq 0x44(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x41c7a
incq %r15
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0xe(%rsp), %rcx
movq %r15, %rsi
callq 0x41cd0
leaq 0x10(%rsp), %rdi
callq 0x58574
movq 0x8(%r14), %rax
movq 0x28(%rsp), %rcx
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
imulq $0x18, %rsi, %rsi
pushq $0x1
popq %rdi
cmpq %rdx, %rsi
je 0x3c524
movq 0x18(%rcx,%rdx), %r8
movl %edi, (%r8)
addq $0x18, %rdx
incl %edi
jmp 0x3c50f
movq 0x8(%rbx), %rcx
movq 0x28(%rsp), %rdx
xorl %esi, %esi
testl %ecx, %ecx
cmovgl %ecx, %esi
negq %rsi
pushq $0x1
popq %rdi
leaq (%rsi,%rdi), %r8
cmpq $0x1, %r8
je 0x3c550
movq (%rdx), %r8
movl %edi, (%r8,%rdi,4)
incq %rdi
jmp 0x3c53a
pushq $0x1
popq %rbp
movslq %eax, %rdx
cmpq %rdx, %rbp
jg 0x3c5e6
leaq -0x1(%rbp), %rax
imulq $0x18, %rax, %r13
imulq $0x18, %rbp, %r15
pushq $0x1
popq %r12
movslq %ecx, %rax
cmpq %rax, %r12
jg 0x3c5da
movq 0x28(%rsp), %rax
movq (%rax,%r13), %rcx
movl (%rcx,%r12,4), %edx
incl %edx
movl %edx, 0x10(%rsp)
movq (%rax,%r15), %rax
movl -0x4(%rax,%r12,4), %eax
incl %eax
movl %eax, 0x14(%rsp)
movq (%r14), %rax
movb -0x1(%rax,%rbp), %al
movq (%rbx), %rdx
xorl %esi, %esi
cmpb -0x1(%rdx,%r12), %al
setne %sil
addl -0x4(%rcx,%r12,4), %esi
movl %esi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
pushq $0x3
popq %rsi
callq 0x41d26
movq 0x28(%rsp), %rcx
movq (%rcx,%r15), %rcx
movl %eax, (%rcx,%r12,4)
incq %r12
movq 0x8(%rbx), %rcx
jmp 0x3c56f
incq %rbp
movq 0x8(%r14), %rax
jmp 0x3c553
leaq 0x28(%rsp), %rdi
movq (%rdi), %rdx
imulq $0x18, %rax, %rax
movq (%rdx,%rax), %rax
movl (%rax,%rcx,4), %ebx
callq 0x41d34
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x58574
jmp 0x3c630
movq %rax, %rbx
jmp 0x3c630
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x41d34
movq %rbx, %rdi
callq 0x377f0
// File: /workspace/github_cpp_makefile_star2_O2/establishment[P]sandman/src/bin.cpp
// Function: main
int main(int argc, char** argv) {
    DieLogToFile("/eval/isolate.log");

    auto config = ParseCommandLineArguments(argc, argv);

    if (config.mode == ProcessConfig::kUnspecified) {
        Die("Please specify an isolate command (e.g. --init, --run).");
    }

    if (geteuid()) {
        Die("Must be started as root");
    }

    if (config.mode == ProcessConfig::kRun) {
        if (config.runCommand == "") {
            Die("--run mode requires a command to run");
        }
    }
    if (config.mode != ProcessConfig::kInit && config.mode != ProcessConfig::kRun &&
        config.mode != ProcessConfig::kCleanup) {
        Die("Internal error: mode mismatch");
    }

    Jailer jailer(config, argv + optind);  /// share the stack size with the isolated process.);
    jailer.Start();

    exit(0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x310, %rsp            # imm = 0x310
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1b483(%rip), %rsi     # 0x5be8f
leaq 0x170(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x40b24
leaq 0x170(%rsp), %rdi
callq 0x3b356
leaq 0x170(%rsp), %rdi
callq 0x37958
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x3ffba
cmpl $0x0, (%r14)
jne 0x40a59
leaq 0x1b44a(%rip), %rdi     # 0x5bea1
jmp 0x40aa8
callq 0x37290
testl %eax, %eax
jne 0x40a8c
movl 0x8(%rsp), %eax
cmpl $0x2, %eax
jne 0x40a99
leaq 0xf0(%rsp), %rdi
leaq 0x1a6ce(%rip), %rsi     # 0x5b148
callq 0x40cd9
testb %al, %al
je 0x40a95
leaq 0x1b467(%rip), %rdi     # 0x5bef1
jmp 0x40aa8
leaq 0x1b446(%rip), %rdi     # 0x5bed9
jmp 0x40aa8
movl 0x8(%rsp), %eax
addl $-0x4, %eax
cmpl $-0x4, %eax
ja 0x40aaf
leaq 0x1b46e(%rip), %rdi     # 0x5bf16
xorl %eax, %eax
callq 0x3b2a4
movq 0x334ca(%rip), %rax     # 0x73f80
movslq (%rax), %rax
leaq (%rbx,%rax,8), %rdx
leaq 0x170(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x42d80
leaq 0x170(%rsp), %rdi
callq 0x42eb4
xorl %edi, %edi
callq 0x37570
movq %rax, %rbx
leaq 0x170(%rsp), %rdi
callq 0x42f10
jmp 0x40afa
jmp 0x40af7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x42d14
jmp 0x40b1b
movq %rax, %rbx
leaq 0x170(%rsp), %rdi
callq 0x37958
jmp 0x40b1b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x377f0
nop