LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nurseiit[P]cpp-server/./include/asio/impl/read.hpp
// Function: asio::detail::read_op<asio::basic_stream_socket<asio::ip::tcp, asio::executor>, asio::mutable_buffers_1, asio::mutable_buffer const*, asio::detail::transfer_all_t, Session::read_body(std::shared_ptr<Session>)::'lambda'(std::error_code const&, unsigned long)>::operator()(std::error_code const&, unsigned long, int)
void operator()(const asio::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      std::size_t max_size;
      switch (start_ = start)
      {
        case 1:
        max_size = this->check_for_completion(ec, buffers_.total_consumed());
        do
        {
          stream_.async_read_some(buffers_.prepare(max_size),
              ASIO_MOVE_CAST(read_op)(*this));
          return; default:
          buffers_.consume(bytes_transferred);
          if ((!ec && bytes_transferred == 0) || buffers_.empty())
            break;
          max_size = this->check_for_completion(ec, buffers_.total_consumed());
        } while (max_size > 0);

        handler_(ec, buffers_.total_consumed());
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, 0x20(%rcx)
subl $0x1, %eax
jne 0x1fbad
jmp 0x1fb4c
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
callq 0x1fd00
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x1d070
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x50(%rbp)
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
callq 0x1fd70
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq %rdx, %rax
movq -0x40(%rbp), %rdx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x1fd20
jmp 0x1fc47
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x1fdc0
movq -0x10(%rbp), %rdi
callq 0x9930
testb $0x1, %al
jne 0x1fbd2
cmpq $0x0, -0x18(%rbp)
je 0x1fbe5
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x1fde0
testb $0x1, %al
jne 0x1fbe5
jmp 0x1fbe7
jmp 0x1fc17
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x8, %rdi
callq 0x1fd00
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x1d070
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
ja 0x1fb71
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x8, %rdi
callq 0x1fd00
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x1fe20
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/buffer.hpp
// Function: asio::buffer(asio::mutable_buffer const&, unsigned long)
inline ASIO_MUTABLE_BUFFER buffer(const mutable_buffer& b,
    std::size_t max_size_in_bytes) ASIO_NOEXCEPT
{
  return ASIO_MUTABLE_BUFFER(
      mutable_buffer(b.data(),
        b.size() < max_size_in_bytes
        ? b.size() : max_size_in_bytes
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
        , b.get_debug_check()
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
        ));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x173d0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17390
cmpq -0x20(%rbp), %rax
jae 0x2119b
movq -0x18(%rbp), %rdi
callq 0x17390
movq %rax, -0x40(%rbp)
jmp 0x211a3
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x17bc0
movq -0x48(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x17bf0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/buffer.hpp
// Function: asio::operator+(asio::mutable_buffer const&, unsigned long)
inline mutable_buffer operator+(const mutable_buffer& b,
    std::size_t n) ASIO_NOEXCEPT
{
  std::size_t offset = n < b.size() ? n : b.size();
  char* new_data = static_cast<char*>(b.data()) + offset;
  std::size_t new_size = b.size() - offset;
  return mutable_buffer(new_data, new_size
#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
      , b.get_debug_check()
#endif // ASIO_ENABLE_BUFFER_DEBUGGING
      );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17390
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x21217
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x21224
movq -0x18(%rbp), %rdi
callq 0x17390
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x173d0
movq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17390
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x17bc0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_accept_op.hpp
// Function: asio::detail::reactive_socket_accept_op_base<asio::basic_socket<asio::ip::tcp, asio::executor>, asio::ip::tcp>::do_perform(asio::detail::reactor_op*)
static status do_perform(reactor_op* base)
  {
    reactive_socket_accept_op_base* o(
        static_cast<reactive_socket_accept_op_base*>(base));

    socket_type new_socket = invalid_socket;
    status result = socket_ops::non_blocking_accept(o->socket_,
        o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
        o->peer_endpoint_ ? &o->addrlen_ : 0, o->ec_, new_socket)
    ? done : not_done;
    o->new_socket_.reset(new_socket);

    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_accept", o->ec_));

    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb 0x3c(%rax), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x2135d
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x215a0
movq %rax, -0x28(%rbp)
jmp 0x21365
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x21365
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x21386
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x38(%rbp)
jmp 0x2138e
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x2138e
movq -0x30(%rbp), %rdx
movb -0x19(%rbp), %al
movl -0x20(%rbp), %edi
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %r8
addq $0x18, %r8
leaq -0x14(%rbp), %r9
movzbl %al, %esi
callq 0x21430
movb %al, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movl -0x14(%rbp), %esi
callq 0x215c0
movl -0x18(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nurseiit[P]cpp-server/./include/asio/detail/socket_holder.hpp
// Function: asio::detail::socket_holder::reset()
void reset()
  {
    if (socket_ != invalid_socket)
    {
      asio::error_code ec;
      socket_ops::state_type state = 0;
      socket_ops::close(socket_, state, true, ec);
      socket_ = invalid_socket;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, (%rax)
je 0x21778
leaq -0x18(%rbp), %rdi
callq 0xadf0
movq -0x28(%rbp), %rax
movb $0x0, -0x19(%rbp)
movl (%rax), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
leaq -0x18(%rbp), %rcx
callq 0x12370
movq -0x28(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbp
retq
nop
// File: nurseiit[P]cpp-server/./include/asio/detail/reactive_socket_service.hpp
// Function: std::error_code asio::detail::reactive_socket_service<asio::ip::tcp>::set_option<asio::detail::socket_option::boolean<1, 2>>(asio::detail::reactive_socket_service<asio::ip::tcp>::implementation_type&, asio::detail::socket_option::boolean<1, 2> const&, std::error_code&)
asio::error_code set_option(implementation_type& impl,
      const Option& option, asio::error_code& ec)
  {
    socket_ops::setsockopt(impl.socket_, impl.state_,
        option.level(impl.protocol_), option.name(impl.protocol_),
        option.data(impl.protocol_), option.size(impl.protocol_), ec);
    return ec;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rsi
movl (%rsi), %eax
movl %eax, -0x4c(%rbp)
movq %rsi, %rax
addq $0x4, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
addq $0x10, %rsi
callq 0x21e00
movl %eax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x21e20
movl %eax, -0x3c(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x21e40
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x21e60
movl -0x4c(%rbp), %edi
movq -0x48(%rbp), %rsi
movl -0x40(%rbp), %edx
movl -0x3c(%rbp), %ecx
movq -0x38(%rbp), %r8
movq %rax, %r9
movq -0x30(%rbp), %r10
movq %rsp, %rax
movq %r10, (%rax)
callq 0x126e0
movq -0x30(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: thunlp[P]KB2E/TransR/Test_TransR.cpp
// Function: vec_output(std::vector<double, std::allocator<double>>)
void vec_output(vector<double> a)
{
	for (int i=0; i<a.size(); i++)
	{
		cout<<a[i]<<"\t";
		if (i%5==4)
			cout<<endl;
	}
	cout<<"-------------------------"<<endl;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3e30
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x297b
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x3e50
movsd (%rax), %xmm0
movq 0x1d6a7(%rip), %rdi     # 0x1ffd8
callq 0x2370
movq %rax, %rdi
leaq 0x13705(%rip), %rsi     # 0x16045
callq 0x21c0
movl 0x1c(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x2969
movq 0x1d67b(%rip), %rdi     # 0x1ffd8
movq 0x1d65c(%rip), %rsi     # 0x1ffc0
callq 0x2210
jmp 0x296b
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x28f6
movq 0x1d656(%rip), %rdi     # 0x1ffd8
leaq 0x136be(%rip), %rsi     # 0x16047
callq 0x21c0
movq %rax, %rdi
movq 0x1d628(%rip), %rsi     # 0x1ffc0
callq 0x2210
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]succ/main.cpp
// Function: main
int main(int argc, char const * const * const argv)
{
	// yucky boilerplate I wish I didn't need
	// also, deliberately skip the first argument (process path)
	// though whether P1275 would do this is uncertain
	// https://twitter.com/slurpsmadrips/status/1205948788864507904
	for (int i = 1; i < argc; ++i) {
		std::arguments.push_back(argv[i]);
	}

	handleHelpFlag();
	handleVersionFlag();
	checkFilesActuallyExist();
	attemptToBeFunny();
	giveUpAndJustSayNo();
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x5826
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5440
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x6d40
jmp 0x57c9
leaq 0x47ea8(%rip), %rdi     # 0x4d678
leaq -0x38(%rbp), %rsi
callq 0x6d10
jmp 0x57db
leaq -0x38(%rbp), %rdi
callq 0x6df0
leaq -0x39(%rbp), %rdi
callq 0x5280
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x578d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x581b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6df0
leaq -0x39(%rbp), %rdi
callq 0x5280
jmp 0x584a
callq 0x5860
callq 0x5920
callq 0x5a00
callq 0x5b30
callq 0x5bc0
movl $0x1, %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5430
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]succ/main.cpp
// Function: handleHelpFlag()
static void handleHelpFlag()
{
	for (const auto& arg : std::arguments) {
		if (arg == "-help" || arg == "--help" || arg == "--help-hidden") {
			printf("You will find no help here.\n");
			exit(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x47e09(%rip), %rax     # 0x4d678
movq %rax, -0x8(%rbp)
leaq 0x47dfe(%rip), %rdi     # 0x4d678
callq 0x7360
movq %rax, -0x10(%rbp)
leaq 0x47dee(%rip), %rdi     # 0x4d678
callq 0x7390
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x73c0
xorb $-0x1, %al
testb $0x1, %al
jne 0x58a8
jmp 0x5918
leaq -0x10(%rbp), %rdi
callq 0x7400
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x2e8b5(%rip), %rsi     # 0x34175
callq 0x7420
testb $0x1, %al
jne 0x58f3
movq -0x20(%rbp), %rdi
leaq 0x2e8a0(%rip), %rsi     # 0x34174
callq 0x7420
testb $0x1, %al
jne 0x58f3
movq -0x20(%rbp), %rdi
leaq 0x2e893(%rip), %rsi     # 0x3417b
callq 0x7420
testb $0x1, %al
jne 0x58f3
jmp 0x5908
leaq 0x2e88f(%rip), %rdi     # 0x34189
movb $0x0, %al
callq 0x5050
xorl %edi, %edi
callq 0x52e0
jmp 0x590a
leaq -0x10(%rbp), %rdi
callq 0x7450
jmp 0x5893
addq $0x20, %rsp
popq %rbp
retq
nop
// File: lunasorcery[P]succ/main.cpp
// Function: handleVersionFlag()
static void handleVersionFlag()
{
	for (const auto& arg : std::arguments) {
		if (arg == "-v" || arg == "--version") {
			printf("SUCC version 0.0.1\n");
			printf("Target: at least a couple dozen retweets and maybe a 'luna why'\n");
			printf("Thread model: none\n");
			printf("InstalledDir: /dev/circles-of-hell/9\n");
			exit(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x47d49(%rip), %rax     # 0x4d678
movq %rax, -0x8(%rbp)
leaq 0x47d3e(%rip), %rdi     # 0x4d678
callq 0x7360
movq %rax, -0x10(%rbp)
leaq 0x47d2e(%rip), %rdi     # 0x4d678
callq 0x7390
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x73c0
xorb $-0x1, %al
testb $0x1, %al
jne 0x596b
jmp 0x59f1
leaq -0x10(%rbp), %rdi
callq 0x7400
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x2e823(%rip), %rsi     # 0x341a6
callq 0x7420
testb $0x1, %al
jne 0x59a2
movq -0x20(%rbp), %rdi
leaq 0x2e812(%rip), %rsi     # 0x341a9
callq 0x7420
testb $0x1, %al
jne 0x59a2
jmp 0x59e1
leaq 0x2e80a(%rip), %rdi     # 0x341b3
movb $0x0, %al
callq 0x5050
leaq 0x2e810(%rip), %rdi     # 0x341c7
movb $0x0, %al
callq 0x5050
leaq 0x2e843(%rip), %rdi     # 0x34208
movb $0x0, %al
callq 0x5050
leaq 0x2e849(%rip), %rdi     # 0x3421c
movb $0x0, %al
callq 0x5050
xorl %edi, %edi
callq 0x52e0
jmp 0x59e3
leaq -0x10(%rbp), %rdi
callq 0x7450
jmp 0x5953
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lunasorcery[P]succ/main.cpp
// Function: checkFilesActuallyExist()
static void checkFilesActuallyExist()
{
	bool hasAnyFiles = false;
	bool hasAnyMissingFiles = false;
	for (const auto& arg : std::arguments) {
		if (!isFlag(arg)) {
			if (fileExists(arg)) {
				hasAnyFiles = true;
			} else {
				hasAnyMissingFiles = true;
				fprintf(stderr, "succ: %serror:%s no such file or directory: '%s'\n", gColorBrightRed, gColorReset, arg.c_str());
			}
		}
	}
	if (!hasAnyFiles) {
		fprintf(stderr, "succ: %serror:%s no input files\n", gColorBrightRed, gColorReset);
		exit(1);
	} else if (hasAnyMissingFiles) {
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb $0x0, -0x1(%rbp)
movb $0x0, -0x2(%rbp)
leaq 0x47c61(%rip), %rax     # 0x4d678
movq %rax, -0x10(%rbp)
leaq 0x47c56(%rip), %rdi     # 0x4d678
callq 0x7360
movq %rax, -0x18(%rbp)
leaq 0x47c46(%rip), %rdi     # 0x4d678
callq 0x7390
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x73c0
xorb $-0x1, %al
testb $0x1, %al
jne 0x5a53
jmp 0x5ae2
leaq -0x18(%rbp), %rdi
callq 0x7400
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5bf0
testb $0x1, %al
jne 0x5ad2
movq -0x28(%rbp), %rdi
callq 0x5c20
testb $0x1, %al
jne 0x5a7c
jmp 0x5a82
movb $0x1, -0x1(%rbp)
jmp 0x5ad0
movb $0x1, -0x2(%rbp)
movq 0x47533(%rip), %rax     # 0x4cfc0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq 0x47c2d(%rip), %rax     # 0x4d6c8
movq %rax, -0x38(%rbp)
movq 0x47c2a(%rip), %rax     # 0x4d6d0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7770
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rax, %r8
leaq 0x2e779(%rip), %rsi     # 0x34242
movb $0x0, %al
callq 0x5360
jmp 0x5ad2
jmp 0x5ad4
leaq -0x18(%rbp), %rdi
callq 0x7450
jmp 0x5a3b
testb $0x1, -0x1(%rbp)
jne 0x5b18
movq 0x474d1(%rip), %rax     # 0x4cfc0
movq (%rax), %rdi
movq 0x47bcf(%rip), %rdx     # 0x4d6c8
movq 0x47bd0(%rip), %rcx     # 0x4d6d0
leaq 0x2e76d(%rip), %rsi     # 0x34274
movb $0x0, %al
callq 0x5360
movl $0x1, %edi
callq 0x52e0
testb $0x1, -0x2(%rbp)
je 0x5b28
movl $0x1, %edi
callq 0x52e0
jmp 0x5b2a
addq $0x40, %rsp
popq %rbp
retq
// File: lunasorcery[P]succ/main.cpp
// Function: attemptToBeFunny()
static void attemptToBeFunny()
{
	for (const auto& arg : std::arguments) {
		if (isFlag(arg)) {
			handleFlag(arg);
		} else {
			handleFile(arg);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x47b39(%rip), %rax     # 0x4d678
movq %rax, -0x8(%rbp)
leaq 0x47b2e(%rip), %rdi     # 0x4d678
callq 0x7360
movq %rax, -0x10(%rbp)
leaq 0x47b1e(%rip), %rdi     # 0x4d678
callq 0x7390
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x73c0
xorb $-0x1, %al
testb $0x1, %al
jne 0x5b78
jmp 0x5bb5
leaq -0x10(%rbp), %rdi
callq 0x7400
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5bf0
testb $0x1, %al
jne 0x5b94
jmp 0x5b9f
movq -0x20(%rbp), %rdi
callq 0x5c70
jmp 0x5ba8
movq -0x20(%rbp), %rdi
callq 0x5d10
jmp 0x5baa
leaq -0x10(%rbp), %rdi
callq 0x7450
jmp 0x5b63
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lunasorcery[P]succ/main.cpp
// Function: fileExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static bool fileExists(const std::string& path)
{
	FILE* fh = fopen(path.c_str(), "rb");
	if (fh) {
		fclose(fh);
		return true;
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7770
movq %rax, %rdi
leaq 0x2e656(%rip), %rsi     # 0x34295
callq 0x52d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5c5e
movq -0x18(%rbp), %rdi
callq 0x5240
movb $0x1, -0x1(%rbp)
jmp 0x5c62
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: lunasorcery[P]succ/main.cpp
// Function: handleFlag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static void handleFlag(const std::string& flag)
{
	handleDuplicateFlag(flag);

	if (flag.starts_with("-W") || flag == "-w") {
		handleWarningFlag(flag);
	} else if (flag.starts_with("-f")) {
		handleFeatureFlag(flag);
	} else if (flag.starts_with("-std=")) {
		handleStdFlag(flag);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6190
movq -0x8(%rbp), %rdi
leaq 0x2e615(%rip), %rsi     # 0x342a5
callq 0x77c0
testb $0x1, %al
jne 0x5caf
movq -0x8(%rbp), %rdi
leaq 0x2e604(%rip), %rsi     # 0x342a8
callq 0x7420
testb $0x1, %al
jne 0x5caf
jmp 0x5cba
movq -0x8(%rbp), %rdi
callq 0x6340
jmp 0x5cfe
movq -0x8(%rbp), %rdi
leaq 0x2e5e6(%rip), %rsi     # 0x342ab
callq 0x77c0
testb $0x1, %al
jne 0x5cd0
jmp 0x5cdb
movq -0x8(%rbp), %rdi
callq 0x6450
jmp 0x5cfc
movq -0x8(%rbp), %rdi
leaq 0x2e5c8(%rip), %rsi     # 0x342ae
callq 0x77c0
testb $0x1, %al
jne 0x5cf1
jmp 0x5cfa
movq -0x8(%rbp), %rdi
callq 0x6570
jmp 0x5cfc
jmp 0x5cfe
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]succ/main.cpp
// Function: handleWarningFlag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static void handleWarningFlag(const std::string& flag)
{
	if (flag.starts_with("-Wno-") || flag == "-w") {
		fprintf(stderr, "%swarning:%s Have confidence in your code. Do not try to disable warnings. [%s]\n", gColorBrightMagenta, gColorReset, flag.c_str());
		return;
	}

	if (flag == "-Werror" || flag.starts_with("-Werror=")) {
		fprintf(stderr, "succ: %serror:%s You asked for an error, so here, have one. [%s]\n", gColorBrightRed, gColorReset, flag.c_str());
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2e14c(%rip), %rsi     # 0x344a3
callq 0x77c0
testb $0x1, %al
jne 0x6376
movq -0x8(%rbp), %rdi
leaq 0x2df3d(%rip), %rsi     # 0x342a8
callq 0x7420
testb $0x1, %al
jne 0x6376
jmp 0x63c2
movq 0x46c43(%rip), %rax     # 0x4cfc0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x4734d(%rip), %rax     # 0x4d6d8
movq %rax, -0x18(%rbp)
movq 0x4733a(%rip), %rax     # 0x4d6d0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7770
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rax, %r8
leaq 0x2e0f0(%rip), %rsi     # 0x344a9
movb $0x0, %al
callq 0x5360
jmp 0x6440
movq -0x8(%rbp), %rdi
leaq 0x2e12d(%rip), %rsi     # 0x344fa
callq 0x7420
testb $0x1, %al
jne 0x63ec
movq -0x8(%rbp), %rdi
leaq 0x2e121(%rip), %rsi     # 0x34502
callq 0x77c0
testb $0x1, %al
jne 0x63ec
jmp 0x6440
movq 0x46bcd(%rip), %rax     # 0x4cfc0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq 0x472c7(%rip), %rax     # 0x4d6c8
movq %rax, -0x30(%rbp)
movq 0x472c4(%rip), %rax     # 0x4d6d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7770
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq %rax, %r8
leaq 0x2e0dc(%rip), %rsi     # 0x3450b
movb $0x0, %al
callq 0x5360
movl $0x1, %edi
callq 0x52e0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]succ/main.cpp
// Function: handleFeatureFlag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static void handleFeatureFlag(const std::string& flag)
{
	// https://twitter.com/___srv_/status/1205722571100041216
	// https://twitter.com/Andrew_Taylor/status/1205764994526265345
	if (std::regex_search(flag, std::regex("^-fpwe+ase$"))) {
		usleep((flag.length() - 7) * 1000000);
		return;
	}

	if (flag == "-fmodules" || flag == "-fmodules-ts") {
		fprintf(stderr, "succ: %serror:%s Don't even bother. Modules are broken and you know it. [%s]\n", gColorBrightRed, gColorReset, flag.c_str());
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x2e0e2(%rip), %rsi     # 0x3454d
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x10, %edx
callq 0x99d0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
xorl %edx, %edx
callq 0x9980
movb %al, -0x35(%rbp)
jmp 0x6491
leaq -0x28(%rbp), %rdi
callq 0x9a70
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x64a3
jmp 0x64dd
movq -0x8(%rbp), %rdi
callq 0x89b0
subq $0x7, %rax
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
movl %eax, %edi
callq 0x5340
jmp 0x655b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9a70
jmp 0x6561
movq -0x8(%rbp), %rdi
leaq 0x2e071(%rip), %rsi     # 0x34559
callq 0x7420
testb $0x1, %al
jne 0x6507
movq -0x8(%rbp), %rdi
leaq 0x2e067(%rip), %rsi     # 0x34563
callq 0x7420
testb $0x1, %al
jne 0x6507
jmp 0x655b
movq 0x46ab2(%rip), %rax     # 0x4cfc0
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq 0x471ac(%rip), %rax     # 0x4d6c8
movq %rax, -0x58(%rbp)
movq 0x471a9(%rip), %rax     # 0x4d6d0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7770
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq %rax, %r8
leaq 0x2e026(%rip), %rsi     # 0x34570
movb $0x0, %al
callq 0x5360
movl $0x1, %edi
callq 0x52e0
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5430
nopw (%rax,%rax)
// File: lunasorcery[P]succ/main.cpp
// Function: getFileLines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::vector<std::string> getFileLines(const std::string& path)
{
	std::vector<std::string> lines;
	std::ifstream fh(path);
	if (fh) {
		std::string line;
		while (getline(fh, line)) {
			lines.push_back(line);
		}
	}
	return lines;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x260(%rbp)
movq %rdi, %rax
movq %rax, -0x258(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6c50
movq -0x10(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x53a0
jmp 0x68b4
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x52f0
movb %al, -0x261(%rbp)
jmp 0x68d4
movb -0x261(%rbp), %al
testb $0x1, %al
jne 0x68e3
jmp 0x69a3
leaq -0x250(%rbp), %rdi
callq 0xf470
leaq -0x220(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x5080
movq %rax, -0x270(%rbp)
jmp 0x690b
movq -0x270(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x52f0
movb %al, -0x271(%rbp)
jmp 0x6929
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x6935
jmp 0x6997
movq -0x260(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x2aa50
jmp 0x694a
jmp 0x68ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x69e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x69bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x6df0
jmp 0x69bb
leaq -0x250(%rbp), %rdi
callq 0x6df0
movb $0x1, -0x11(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x5090
testb $0x1, -0x11(%rbp)
jne 0x69d5
jmp 0x69c9
leaq -0x220(%rbp), %rdi
callq 0x5090
jmp 0x69e5
movq -0x260(%rbp), %rdi
callq 0x6c70
movq -0x258(%rbp), %rax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x260(%rbp), %rdi
callq 0x6c70
movq -0x228(%rbp), %rdi
callq 0x5430
nopl (%rax)
// File: lunasorcery[P]succ/main.cpp
// Function: replaceTabsWithSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string replaceTabsWithSpaces(const std::string& str)
{
	const std::string tabAsSpaces = repeatChar(' ', kTabWidth);

	std::string result;
	for (const auto& c : str) {
		if (c == '\t') {
			result += tabAsSpaces;
		} else {
			result += c;
		}
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x20, %esi
movl $0x4, %edx
callq 0x6b20
movq -0x70(%rbp), %rdi
movb $0x0, -0x31(%rbp)
callq 0xf470
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x9b30
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x9b60
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa880
xorb $-0x1, %al
testb $0x1, %al
jne 0x6a75
jmp 0x6ae0
leaq -0x48(%rbp), %rdi
callq 0xec90
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x6abf
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x32bc0
jmp 0x6a9d
jmp 0x6ad3
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x6df0
leaq -0x30(%rbp), %rdi
callq 0x6df0
jmp 0x6b09
movq -0x70(%rbp), %rdi
movq -0x58(%rbp), %rax
movsbl (%rax), %esi
callq 0xf510
jmp 0x6ad1
jmp 0x6ad3
jmp 0x6ad5
leaq -0x48(%rbp), %rdi
callq 0xc760
jmp 0x6a60
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x6af3
movq -0x70(%rbp), %rdi
callq 0x6df0
leaq -0x30(%rbp), %rdi
callq 0x6df0
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x5430
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]succ/main.cpp
// Function: repeatChar[abi:cxx11](char, unsigned long)
static std::string repeatChar(char c, size_t count)
{
	std::string buffer;
	buffer.resize(count);
	memset(buffer.data(), c ? c : ' ', count);
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xf470
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x32d00
jmp 0x6b59
movq -0x38(%rbp), %rdi
callq 0x232e0
movq %rax, -0x48(%rbp)
cmpb $0x0, -0x9(%rbp)
je 0x6b74
movb -0x9(%rbp), %al
movb %al, -0x49(%rbp)
jmp 0x6b7b
movb $0x20, %al
movb %al, -0x49(%rbp)
jmp 0x6b7b
movq -0x48(%rbp), %rdi
movb -0x49(%rbp), %al
movsbl %al, %eax
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x5170
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x6bbd
jmp 0x6bb4
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6df0
jmp 0x6bc7
movq -0x38(%rbp), %rdi
callq 0x6df0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5430
// File: lunasorcery[P]succ/main.cpp
// Function: computePositionAccountingForTabs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
static size_t computePositionAccountingForTabs(const std::string& str, size_t pos)
{
	size_t adjustedPosition = 0;
	for (size_t i = 0; i < pos; ++i) {
		if (str[i] == '\t') {
			adjustedPosition += kTabWidth;
		} else {
			adjustedPosition++;
		}
	}
	return adjustedPosition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x6c39
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7790
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x6c1d
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x6c29
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6c2b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6bf0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: canzarlab[P]Trajan/src/match.cpp
// Function: path_tree(array2d&, tree const&, tree const&, int, int, int)
int path_tree(array2d& dp, const tree& t1, const tree& t2, const int lx, int x, int y)
{
    // trivial case: empty path
    if (x == lx)
        return 0;

    // memoization
    int& sol = dp(x, y);
    if (sol != NINF)
        return sol;

    // TODO: select the correct child
    // x's only child
    int w = t1.adj[x].front();

    // delete path node
    sol = max(sol, path_tree(dp, t1, t2, lx, w, y));
    for (int z : t2.adj[y])
    {
        // match x and y
        sol = max(sol, 1 + path_tree(dp, t1, t2, lx, w, z));
        // delete tree node
        sol = max(sol, path_tree(dp, t1, t2, lx, x, z));
    }
    return sol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x47b6
movl $0x0, -0x4(%rbp)
jmp 0x4923
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x7820
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x80000000, (%rax)     # imm = 0x80000000
je 0x47e3
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4923
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movslq -0x28(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x7860
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x3c(%rbp), %r8d
movl -0x2c(%rbp), %r9d
callq 0x4780
movq -0x70(%rbp), %rdi
movl %eax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x7890
movl (%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x48, %rax
movslq -0x2c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x78d0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x7900
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x7930
testb $0x1, %al
jne 0x4883
jmp 0x491a
leaq -0x50(%rbp), %rdi
callq 0x7970
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x3c(%rbp), %r8d
movl -0x5c(%rbp), %r9d
callq 0x4780
movq -0x80(%rbp), %rdi
addl $0x1, %eax
movl %eax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x7890
movl (%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x5c(%rbp), %r9d
callq 0x4780
movq -0x78(%rbp), %rdi
movl %eax, -0x64(%rbp)
leaq -0x64(%rbp), %rsi
callq 0x7890
movl (%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x7990
jmp 0x486d
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: canzarlab[P]Trajan/src/match.cpp
// Function: bipartite(array2d const&, array2d&, array2d&, int, unsigned long long)
int bipartite(const array2d& D, array2d& dp, array2d& pdp, int k, mask m)
{
    // nothing left to match
    if (k == D.n || m == 0)
        return 0;

    // memoization
    int& sol = dp(k, m);
    if (sol != NINF)
        return sol;

    // don't match kth tree with anyone
    sol = bipartite(D, dp, pdp, k + 1, m);

    // try to match kth tree in t1 with any avaliable tree in t2
    for (mask mi = m; mi != 0; mi -= ls(mi))
    {
        int nsol = D(k, tz(mi)) + bipartite(D, dp, pdp, k + 1, m ^ ls(mi));
        if (nsol > sol)
            sol = nsol, pdp(k, m) = tz(mi);
    }
    return sol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4bc0
cmpq $0x0, -0x30(%rbp)
jne 0x4bcc
movl $0x0, -0x4(%rbp)
jmp 0x4d17
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rax
movl %eax, %edx
callq 0x7820
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x80000000, (%rax)     # imm = 0x80000000
je 0x4bfc
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4d17
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movq -0x30(%rbp), %r8
callq 0x4b90
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x4d0e
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x40(%rbp), %rdi
callq 0x7a10
movq -0x80(%rbp), %rdi
movl -0x74(%rbp), %esi
movl %eax, %edx
callq 0x79b0
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x40(%rbp), %rdi
callq 0x7a30
movq -0x70(%rbp), %r8
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movl -0x4c(%rbp), %ecx
xorq %rax, %r8
callq 0x4b90
movl %eax, %ecx
movl -0x48(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x4cf0
movl -0x44(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rdi
callq 0x7a10
movl %eax, -0x84(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rax
movl %eax, %edx
callq 0x7820
movl -0x84(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x4cf2
movq -0x40(%rbp), %rdi
callq 0x7a30
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x4c27
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: canzarlab[P]Trajan/src/match.cpp
// Function: recover_matching_aux(tree const&, tree const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&, array2d const&, int, int, int, int)
void recover_matching_aux(const tree& t1, const tree& t2, vector<pair<int, int>>& matching, const array2d& tdp, const int lx, const int ly, int x, int y)
{
    if (x == lx || y == ly)
        return;

    switch (tdp(x, y))
    {
        case DEL_1:
            recover_matching_aux(t1, t2, matching, tdp, lx, ly, t1.par[x], y);
            break;
        case DEL_2:
            recover_matching_aux(t1, t2, matching, tdp, lx, ly, x, t2.par[y]);
            break;
        case MATCH:
            matching.emplace_back(x, y);
            recover_matching_aux(t1, t2, matching, tdp, lx, ly, t1.par[x], t2.par[y]);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl 0x10(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x5fe6
movl 0x18(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x5feb
jmp 0x60ea
movq -0x20(%rbp), %rdi
movl 0x10(%rbp), %esi
movl 0x18(%rbp), %edx
callq 0x79b0
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x601c
jmp 0x6005
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x6059
jmp 0x600f
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x6094
jmp 0x60ea
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
movq -0x8(%rbp), %rax
movslq 0x10(%rbp), %r10
movl 0x5f14(%rax,%r10,4), %r10d
movl 0x18(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x5fb0
jmp 0x60ea
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
movl 0x10(%rbp), %r10d
movq -0x10(%rbp), %rax
movslq 0x18(%rbp), %r11
movl 0x5f14(%rax,%r11,4), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x5fb0
jmp 0x60ea
movq -0x18(%rbp), %rdi
leaq 0x10(%rbp), %rsi
leaq 0x18(%rbp), %rdx
callq 0x84d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
movq -0x8(%rbp), %rax
movslq 0x10(%rbp), %r10
movl 0x5f14(%rax,%r10,4), %r10d
movq -0x10(%rbp), %rax
movslq 0x18(%rbp), %r11
movl 0x5f14(%rax,%r11,4), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x5fb0
addq $0x40, %rsp
popq %rbp
retq
// File: canzarlab[P]Trajan/src/match.cpp
// Function: valid(std::pair<int, int>, std::pair<int, int>, array2d&, array2d&)
bool valid(pair<int, int> a, pair<int, int> b, array2d& D1, array2d& D2)
{
    int i = get<0>(a), j = get<0>(b);
    int x = get<1>(a), y = get<1>(b);
    bool c2 = (D1(j, i) || D1(i, j)) == (D2(x, y) || D2(y, x));
    bool c1 = (D1(i, j) == D2(x, y)); // assuming c2 is satisfied
    bool c0 = (i != j && x != y);
    return c0 && c1 && c2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x86f0
movl (%rax), %eax
movl %eax, -0x24(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x86f0
movl (%rax), %eax
movl %eax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x8710
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x8710
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x7820
movq %rax, %rcx
movb $0x1, %al
cmpl $0x0, (%rcx)
movb %al, -0x34(%rbp)
jne 0x68c4
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x7820
cmpl $0x0, (%rax)
setne %al
movb %al, -0x34(%rbp)
movb -0x34(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x7820
movq %rax, %rcx
movb $0x1, %al
cmpl $0x0, (%rcx)
movb %al, -0x35(%rbp)
jne 0x6903
movq -0x20(%rbp), %rdi
movl -0x30(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x7820
cmpl $0x0, (%rax)
setne %al
movb %al, -0x35(%rbp)
movl -0x3c(%rbp), %eax
movb -0x35(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x7820
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x7820
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl (%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x32(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0x28(%rbp), %ecx
movb %al, -0x3d(%rbp)
je 0x6965
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
setne %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
andb $0x1, %al
movb %al, -0x33(%rbp)
xorl %eax, %eax
testb $0x1, -0x33(%rbp)
movb %al, -0x45(%rbp)
je 0x6989
xorl %eax, %eax
testb $0x1, -0x32(%rbp)
movb %al, -0x45(%rbp)
je 0x6989
movb -0x31(%rbp), %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: canzarlab[P]Trajan/src/match.cpp
// Function: array2d::transpose() const
array2d transpose() const
    {
        array2d D(m, n);
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                D(j, i) = (*this)(i, j);
        return D;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x11(%rbp)
movl 0x4(%rax), %esi
movl (%rax), %edx
movl $0x80000000, %ecx       # imm = 0x80000000
callq 0x7b70
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7aeb
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x7ade
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x79b0
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x7820
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7a9f
jmp 0x7ae0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7a8d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7afe
movq -0x38(%rbp), %rdi
callq 0x7b50
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: canzarlab[P]Trajan/src/read_csv.cpp
// Function: CSVReader::getDoubleFromStringData(int, int)
std::vector<std::vector<double> > CSVReader::getDoubleFromStringData(int from_row, int to_row) {
    vector<vector<double> > data;
    std::vector<std::vector<string> > dataList = getStringData();
    for (int i = from_row; i < std::min(to_row, (int) dataList.size()); ++i)
    {
        vector<double> temp;
        for (const auto & u: dataList.at(i))
        {
            temp.push_back(std::stod(u));
        }
        data.push_back(temp);
    }
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x15d30
movq -0x98(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
movl $0xf4240, %ecx          # imm = 0xF4240
callq 0x15050
jmp 0x15347
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0xb4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x15d90
movl %eax, -0x4c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x15d50
movq %rax, -0xb0(%rbp)
jmp 0x15378
movl -0xb4(%rbp), %eax
movq -0xb0(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1549f
leaq -0x68(%rbp), %rdi
callq 0x15dc0
movslq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x15de0
movq %rax, -0xc0(%rbp)
jmp 0x153ac
movq -0xc0(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x15e20
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x15e50
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x15e80
testb $0x1, %al
jne 0x153e7
jmp 0x15476
leaq -0x78(%rbp), %rdi
callq 0x15ec0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15f10
movsd %xmm0, -0xc8(%rbp)
jmp 0x15411
movsd -0xc8(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x15ee0
jmp 0x15433
jmp 0x15435
leaq -0x78(%rbp), %rdi
callq 0x15f50
jmp 0x153d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x154db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x154b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x14cc0
jmp 0x154b4
movq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x15f70
jmp 0x15488
leaq -0x68(%rbp), %rdi
callq 0x14cc0
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x1534d
movb $0x1, -0x19(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x15cd0
testb $0x1, -0x19(%rbp)
jne 0x154cb
jmp 0x154bf
leaq -0x38(%rbp), %rdi
callq 0x15cd0
jmp 0x154db
movq -0xa8(%rbp), %rdi
callq 0x94e0
movq -0xa0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x94e0
movq -0x40(%rbp), %rdi
callq 0x44e0
// File: kipa00[P]AplusB-mc/compiler/main.cpp
// Function: traverse_world(world const&, std::function<void (int, int, int)>)
void traverse_world(const world &w, std::function<void(int, int, int)> f) {
	int cx, cy, cz;
	for (cz=0; cz<32; ++cz) {
		for (cx=0; cx<32; ++cx) {
			for (cy=0; cy<16; ++cy) {
				if (w.has_world_data(cx, cy, cz)) {
					int x, y, z;
					for (z=0; z<16; ++z) {
						for (x=0; x<16; ++x) {
							for (y=0; y<16; ++y) {
								f((cx << 4) | x, (cy << 4) | y, (cz << 4) | z);
							}
						}
					}
				}
			}
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x20, 0x1c(%rsp)
jge 0x2586
movl $0x0, 0x24(%rsp)
cmpl $0x20, 0x24(%rsp)
jge 0x2574
movl $0x0, 0x20(%rsp)
cmpl $0x10, 0x20(%rsp)
jge 0x2562
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x1c(%rsp), %ecx
callq 0xa2c0
testb $0x1, %al
jne 0x24cb
jmp 0x2550
movl $0x0, 0x10(%rsp)
cmpl $0x10, 0x10(%rsp)
jge 0x254e
movl $0x0, 0x18(%rsp)
cmpl $0x10, 0x18(%rsp)
jge 0x253f
movl $0x0, 0x14(%rsp)
cmpl $0x10, 0x14(%rsp)
jge 0x2530
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
shll $0x4, %esi
orl 0x18(%rsp), %esi
movl 0x20(%rsp), %edx
shll $0x4, %edx
orl 0x14(%rsp), %edx
movl 0x1c(%rsp), %ecx
shll $0x4, %ecx
orl 0x10(%rsp), %ecx
callq 0x4700
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x24f1
jmp 0x2532
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x24e2
jmp 0x2541
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x24d3
jmp 0x2550
jmp 0x2552
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x24a1
jmp 0x2564
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x248e
jmp 0x2576
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x247b
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: kipa00[P]AplusB-mc/compiler/main.cpp
// Function: write_int(_IO_FILE*, unsigned int)
void write_int(FILE *fp, u32 x) {
	write_byte(fp, x >> 24);
	write_byte(fp, (x >> 16) & 255);
	write_byte(fp, (x >> 8) & 255);
	write_byte(fp, x & 255);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
shrl $0x18, %eax
movzbl %al, %esi
callq 0x2590
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movzbl %al, %esi
callq 0x2590
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movzbl %al, %esi
callq 0x2590
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
andl $0xff, %eax
movzbl %al, %esi
callq 0x2590
addq $0x18, %rsp
retq
nop