LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: skyshore2001[P]symfind/symfind.cpp
// Function: SfFileIter::NextLink()
SfFile *NextLink() {
		SfFolder *folder;
		while (folder = SfFolderIter::Next()) {
			if (folder->files)
				break;
		}
		return folder? folder->files: NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x63c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x7016
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7014
jmp 0x7016
jmp 0x6ff4
cmpq $0x0, -0x10(%rbp)
je 0x702b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7033
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x7033
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: skyshore2001[P]symfind/symfind.cpp
// Function: SfSymbolIter::NextLink()
SfSymbol *NextLink() {
		SfFile *file;
		while (file = SfFileIter::Next()) {
			if (file->symbols)
				break;
		}
		return file? file->symbols: NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b70
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x7076
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7074
jmp 0x7076
jmp 0x7054
cmpq $0x0, -0x10(%rbp)
je 0x708b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7093
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x7093
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: skyshore2001[P]symfind/symfind.cpp
// Function: SfFolderIter::NextLink()
SfFolder *NextLink() {
		SfRepo *repo;
		while (repo = SfRepoIter::Next()) {
			if (repo->folders)
				break;
		}
		return repo? repo->folders: NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5920
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x7186
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7184
jmp 0x7186
jmp 0x7164
cmpq $0x0, -0x10(%rbp)
je 0x719b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x71a3
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x71a3
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: tkrobatsch[P]YAML_Maker/yaml_data.cpp
// Function: serialize_encaps(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string serialize_encaps(std::string input) {
	std::string serialize;
	serialize += "'";
	for (int i = 0; i < input.length(); i++) {
		if (!((input[i] < 0) || (input[i] > 255))) {
			serialize += input[i];
		}
	}
	//clear any spaces at end
	serialize.erase(std::find_if(serialize.rbegin(), serialize.rend(),
		std::not1(std::ptr_fun<int, int>(std::isspace))).base(), serialize.end());
	serialize += "'";
	return serialize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2280
movq -0x80(%rbp), %rdi
leaq 0x9ad8(%rip), %rsi      # 0xc014
callq 0x21c0
jmp 0x2543
movl $0x0, -0x28(%rbp)
movq -0x90(%rbp), %rdi
movslq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x22c0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x2620
movq -0x90(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x23b0
movq %rax, -0xa0(%rbp)
jmp 0x258d
movq -0xa0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jl 0x2610
movq -0x90(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x23b0
movq %rax, -0xa8(%rbp)
jmp 0x25b5
movq -0xa8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xff, %eax
jg 0x2610
movq -0x90(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x23b0
movq %rax, -0xb0(%rbp)
jmp 0x25df
movq -0x80(%rbp), %rdi
movq -0xb0(%rbp), %rax
movsbl (%rax), %esi
callq 0x2140
jmp 0x25f4
jmp 0x2610
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2130
jmp 0x272c
jmp 0x2612
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x254a
movq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2350
movq -0x80(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2230
movq 0xf96f(%rip), %rdi      # 0x11fb0
callq 0x61b0
movq %rax, -0xb8(%rbp)
jmp 0x264f
movq -0xb8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6180
movq %rax, -0xc0(%rbp)
jmp 0x266c
movq -0xc0(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x6100
jmp 0x268e
leaq -0x40(%rbp), %rdi
callq 0x61e0
movq %rax, -0xc8(%rbp)
jmp 0x26a0
movq -0xc8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6200
movq -0x80(%rbp), %rdi
callq 0x2100
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6200
movq -0x80(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x2070
movq %rax, -0xd0(%rbp)
jmp 0x26ec
movq -0x80(%rbp), %rdi
movq -0xd0(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x9912(%rip), %rsi      # 0xc014
callq 0x21c0
jmp 0x2709
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x271c
movq -0x80(%rbp), %rdi
callq 0x2130
movq -0x88(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: tkrobatsch[P]YAML_Maker/yaml_data.cpp
// Function: serialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string serialize(std::string input) {
	std::string serialize;
	for (int i = 0; i < input.length(); i++) {
		if (!((input[i] < 0) || (input[i] > 255))) {
			serialize += input[i];
		}
	}
	//clear any spaces at end
	serialize.erase(std::find_if(serialize.rbegin(), serialize.rend(),
		std::not1(std::ptr_fun<int, int>(std::isspace))).base(), serialize.end());
	return serialize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2280
movl $0x0, -0x18(%rbp)
movq -0x90(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x22c0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x2854
movq -0x90(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x23b0
movq %rax, -0xa0(%rbp)
jmp 0x27bb
movq -0xa0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jl 0x2844
movq -0x90(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x23b0
movq %rax, -0xa8(%rbp)
jmp 0x27e3
movq -0xa8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xff, %eax
jg 0x2844
movq -0x90(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x23b0
movq %rax, -0xb0(%rbp)
jmp 0x280d
movq -0x88(%rbp), %rdi
movq -0xb0(%rbp), %rax
movsbl (%rax), %esi
callq 0x2140
jmp 0x2825
jmp 0x2844
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2130
jmp 0x295a
jmp 0x2846
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2778
movq -0x88(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2350
movq -0x88(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2230
movq 0xf735(%rip), %rdi      # 0x11fb0
callq 0x61b0
movq %rax, -0xb8(%rbp)
jmp 0x2889
movq -0xb8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6180
movq %rax, -0xc0(%rbp)
jmp 0x28a6
movq -0xc0(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x6100
jmp 0x28c8
leaq -0x40(%rbp), %rdi
callq 0x61e0
movq %rax, -0xc8(%rbp)
jmp 0x28da
movq -0xc8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6200
movq -0x88(%rbp), %rdi
callq 0x2100
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6200
movq -0x88(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x2070
movq %rax, -0xd0(%rbp)
jmp 0x292c
movq -0xd0(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x294d
movq -0x88(%rbp), %rdi
callq 0x2130
movq -0x80(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/exprtk_simple_example_19.cpp
// Function: randu<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator()(const std::size_t& ps_index, parameter_list_t parameters)
   {
      vector_t v(parameters[0]);

      std::size_t r0 = 0;
      std::size_t r1 = v.size() - 1;

      using namespace exprtk::rtl::vecops::helper;

      if (
           (1 == ps_index) &&
           !load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
         )
         return T(0);

      for (std::size_t i = r0; i <= r1; ++i)
      {
         v[i] = rnd();
      }

      return T(1);
   }

// Assembly:
subq $0x78, %rsp
movq %rdx, 0x68(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x11af90
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x11b100
movq $0x0, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x11b260
subq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq (%rdx), %rcx
movb %al, 0x17(%rsp)
jne 0x11b45e
movq $0x1, 0x28(%rsp)
movq $0x2, 0x20(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x20(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x11b4e0
xorb $-0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x11b468
jmp 0x11b473
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0x11b4ce
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
ja 0x11b4c0
movq 0x8(%rsp), %rdi
callq 0x11b620
movsd %xmm0, (%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x11b640
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x11b47d
movsd 0x329b48(%rip), %xmm0   # 0x445010
movsd %xmm0, 0x70(%rsp)
movsd 0x70(%rsp), %xmm0
addq $0x78, %rsp
retq
nopl (%rax)
// File: wo3kie[P]calc/calc.cpp
// Function: double calc<>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double calc(
    std::string const & expr,
    TDoubles... ds
)
{
    std::string::const_iterator iter = expr.begin();
    std::string::const_iterator end = expr.end();

    Calculator< std::string::const_iterator > calc;
    
    boost::spirit::ascii::space_type space;

    ast::Expression expression;

    bool const r = phrase_parse( iter, end, calc, space, expression );

    if( r && iter == end )
    {
        ast::Calc calc( std::forward< TDoubles >( ds )... );
        return calc( expression );
    }
    
    throw std::runtime_error( "Parsing failed: " + std::string( iter, end ) );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp            # imm = 0x3F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42d0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4540
movq %rax, -0x18(%rbp)
leaq -0x2c8(%rbp), %rdi
movq %rdi, -0x3d0(%rbp)
callq 0xd2c0
leaq -0x2f8(%rbp), %rdi
movq %rdi, -0x3c8(%rbp)
callq 0x11e30
movq -0x3d0(%rbp), %rdx
movq -0x3c8(%rbp), %r8
movq -0x18(%rbp), %rax
movq %rax, -0x308(%rbp)
movq -0x308(%rbp), %rsi
leaq -0x10(%rbp), %rdi
leaq -0x2c9(%rbp), %rcx
callq 0x11e60
movb %al, -0x3bb(%rbp)
jmp 0xa8f7
movb -0x3bb(%rbp), %al
andb $0x1, %al
movb %al, -0x2f9(%rbp)
testb $0x1, -0x2f9(%rbp)
je 0xa98c
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11eb0
testb $0x1, %al
jne 0xa921
jmp 0xa98c
leaq -0x368(%rbp), %rdi
callq 0x11ef0
jmp 0xa92f
leaq -0x368(%rbp), %rdi
leaq -0x2f8(%rbp), %rsi
callq 0x11f20
movsd %xmm0, -0x3d8(%rbp)
jmp 0xa94c
leaq -0x2f8(%rbp), %rdi
callq 0x12090
leaq -0x2c8(%rbp), %rdi
callq 0x120c0
movsd -0x3d8(%rbp), %xmm0
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x310(%rbp)
movl %eax, -0x314(%rbp)
jmp 0xaabe
movb $0x1, -0x3ba(%rbp)
movl $0x10, %edi
callq 0x4120
movq %rax, -0x3e8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x3b0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x3b8(%rbp)
leaq -0x3b9(%rbp), %rdi
movq %rdi, -0x3e0(%rbp)
callq 0x44e0
movq -0x3e0(%rbp), %rcx
movq -0x3b0(%rbp), %rsi
movq -0x3b8(%rbp), %rdx
leaq -0x3a8(%rbp), %rdi
callq 0x12010
jmp 0xa9f0
leaq 0x4005f(%rip), %rsi     # 0x4aa56
leaq -0x388(%rbp), %rdi
leaq -0x3a8(%rbp), %rdx
callq 0x11fc0
jmp 0xaa0c
movq -0x3e8(%rbp), %rdi
leaq -0x388(%rbp), %rsi
callq 0x4450
jmp 0xaa21
movq -0x3e8(%rbp), %rdi
movb $0x0, -0x3ba(%rbp)
movq 0x665ba(%rip), %rsi     # 0x70ff0
movq 0x6657b(%rip), %rdx     # 0x70fb8
callq 0x44b0
jmp 0xaae2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x310(%rbp)
movl %eax, -0x314(%rbp)
jmp 0xaa99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x310(%rbp)
movl %eax, -0x314(%rbp)
jmp 0xaa8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x310(%rbp)
movl %eax, -0x314(%rbp)
leaq -0x388(%rbp), %rdi
callq 0x41b0
leaq -0x3a8(%rbp), %rdi
callq 0x41b0
leaq -0x3b9(%rbp), %rdi
callq 0x4350
testb $0x1, -0x3ba(%rbp)
jne 0xaab0
jmp 0xaabc
movq -0x3e8(%rbp), %rdi
callq 0x4220
jmp 0xaabe
leaq -0x2f8(%rbp), %rdi
callq 0x12090
leaq -0x2c8(%rbp), %rdi
callq 0x120c0
movq -0x310(%rbp), %rdi
callq 0x44d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wo3kie[P]calc/calc.cpp
// Function: ast::Calc::operator()(ast::Expression const&) const
double operator()( Expression const & x ) const
        {
            double state = boost::apply_visitor( *this, x.head_ );

            for( Operation const & oper : x.tail_ )
            {
                state = ( *this )( oper, state );
            }

            return state;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x47930
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17a50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17a80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17bd0
testb $0x1, %al
jne 0x11f7f
jmp 0x11fae
leaq -0x28(%rbp), %rdi
callq 0x17c50
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x47960
movsd %xmm0, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x17c80
jmp 0x11f6c
movsd -0x18(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: wo3kie[P]calc/calc.cpp
// Function: void error_handler_::operator()<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(boost::spirit::info const&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>) const
void operator()(
        qi::info const & what
      , TIterator err_pos, TIterator last ) const
    {
        std::cout
            << "Error! Expecting "
            << what
            << " here: \""
            << std::string( err_pos, last )
            << "\""
            << std::endl
        ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq 0x2c6ae(%rip), %rdi     # 0x70fc0
leaq 0x683d(%rip), %rsi      # 0x4b156
callq 0x42f0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x44ba0
movq %rax, %rdi
leaq 0x6834(%rip), %rsi      # 0x4b168
callq 0x42f0
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x44e0
movq -0x70(%rbp), %rcx
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x12010
jmp 0x44971
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x42b0
movq %rax, -0x80(%rbp)
jmp 0x44984
movq -0x80(%rbp), %rdi
leaq 0x67e0(%rip), %rsi      # 0x4b16f
callq 0x42f0
movq %rax, -0x88(%rbp)
jmp 0x4499d
movq -0x88(%rbp), %rdi
movq 0x2c5f5(%rip), %rsi     # 0x70fa0
callq 0x4330
jmp 0x449b2
leaq -0x40(%rbp), %rdi
callq 0x41b0
leaq -0x51(%rbp), %rdi
callq 0x4350
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x449f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41b0
leaq -0x51(%rbp), %rdi
callq 0x4350
movq -0x60(%rbp), %rdi
callq 0x44d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wo3kie[P]calc/calc.cpp
// Function: ast::Calc::operator()(ast::Signed const&) const
double operator()( Signed const & x ) const
        {
            double const rhs = boost::apply_visitor( *this, x.operand_ );

            switch( x.sign_ )
            {
                case '-':
                    return - rhs;

                case '+':
                    return + rhs;

                case '!':
                    return ( fabs( rhs ) < 0.000001 ) ? 1 : 0;

                default:
                    BOOST_ASSERT( 0 );
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x47930
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x21, %eax
je 0x4853a
jmp 0x484f7
movl -0x24(%rbp), %eax
subl $0x2b, %eax
je 0x4852e
jmp 0x48501
movl -0x24(%rbp), %eax
subl $0x2d, %eax
jne 0x4856b
jmp 0x4850b
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4858a
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4858a
movsd -0x20(%rbp), %xmm1
movaps 0x1b6a(%rip), %xmm0     # 0x4a0b0
pand %xmm0, %xmm1
movsd 0x1afe(%rip), %xmm0     # 0x4a050
xorl %eax, %eax
movl $0x1, %ecx
ucomisd %xmm1, %xmm0
cmoval %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4858a
leaq 0x2285(%rip), %rdi      # 0x4a7f7
leaq 0x1f52(%rip), %rsi      # 0x4a4cb
movl $0xf3, %edx
leaq 0x2c14(%rip), %rcx      # 0x4b199
callq 0x41e0
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: wo3kie[P]calc/calc.cpp
// Function: ast::Calc::operator()(ast::RightAssocExpr const&) const
double operator()( RightAssocExpr const & x ) const
        {
            double const base = boost::apply_visitor( *this, x.left_ );

            if( ! x.right_ ){
                return base;
            }
            
            double const exp = boost::apply_visitor( *this, x.right_.get() );

            return std::pow( base, exp );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x47930
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x48790
testb $0x1, %al
jne 0x48739
jmp 0x48745
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x48777
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x487b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x47930
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x44c0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lioncedric[P]cimpressGridCoverage/src/squares.cc
// Function: clear_square(int*, int, int const*)
void clear_square(int * puzzle, const int width, const int * square) {

    const int row = *(square + 1);
    const int col = *square;
    const int square_size = *(square + 2);
    const int * ptrLineMax = puzzle + col + (row + square_size) * width;
    for (int* ptrLine = puzzle + col + (row) * width; ptrLine < ptrLineMax; ptrLine += width) {
        const int * ptrColMax = ptrLine + square_size;
        for (int* ptrCol = ptrLine; ptrCol < ptrColMax; ++ptrCol) {
            *ptrCol = 1;
        }
    }

}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rsp)
movq -0x8(%rsp), %rax
movslq -0x20(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x1c(%rsp), %ecx
addl -0x24(%rsp), %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movq -0x8(%rsp), %rax
movslq -0x20(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x1c(%rsp), %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x30(%rsp), %rax
jae 0x10ef6
movq -0x38(%rsp), %rax
movslq -0x24(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
movq %rax, -0x48(%rsp)
movq -0x48(%rsp), %rax
cmpq -0x40(%rsp), %rax
jae 0x10eda
movq -0x48(%rsp), %rax
movl $0x1, (%rax)
movq -0x48(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x48(%rsp)
jmp 0x10eb3
jmp 0x10edc
movl -0xc(%rsp), %ecx
movq -0x38(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rsp)
jmp 0x10e87
retq
nopw (%rax,%rax)
// File: lioncedric[P]cimpressGridCoverage/src/squares.cc
// Function: use_squares(int*, int, int*)
void use_squares(int * puzzle, const int width, int * squares) {
    for (int* ptrSquares = squares; *ptrSquares >= 0; ptrSquares += 3) {
        const int row = *(ptrSquares + 1);
        const int col = *ptrSquares;
        const int square_size = *(ptrSquares + 2);
        const int id = (row) * width + col;
        const int * ptrLineMax = puzzle + col + (row + square_size) * width;
        for (int* ptrLine = puzzle + col + (row) * width; ptrLine < ptrLineMax; ptrLine += width) {
            const int * ptrColMax = ptrLine + square_size;
            for (int* ptrCol = ptrLine; ptrCol < ptrColMax; ++ptrCol) {
                *ptrCol = id;
            }
        }
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpl $0x0, (%rax)
jl 0x113a4
movq -0x20(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rsp)
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rsp)
movl -0x24(%rsp), %eax
imull -0xc(%rsp), %eax
addl -0x28(%rsp), %eax
movl %eax, -0x30(%rsp)
movq -0x8(%rsp), %rax
movslq -0x28(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x24(%rsp), %ecx
addl -0x2c(%rsp), %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rsp)
movq -0x8(%rsp), %rax
movslq -0x28(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x24(%rsp), %ecx
imull -0xc(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rsp)
movq -0x40(%rsp), %rax
cmpq -0x38(%rsp), %rax
jae 0x1138f
movq -0x40(%rsp), %rax
movslq -0x2c(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rsp)
movq -0x40(%rsp), %rax
movq %rax, -0x50(%rsp)
movq -0x50(%rsp), %rax
cmpq -0x48(%rsp), %rax
jae 0x11373
movl -0x30(%rsp), %ecx
movq -0x50(%rsp), %rax
movl %ecx, (%rax)
movq -0x50(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x50(%rsp)
jmp 0x1134c
jmp 0x11375
movl -0xc(%rsp), %ecx
movq -0x40(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rsp)
jmp 0x11320
jmp 0x11391
movq -0x20(%rsp), %rax
addq $0xc, %rax
movq %rax, -0x20(%rsp)
jmp 0x11288
retq
nopw %cs:(%rax,%rax)
// File: jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: remove_pending(int)
int remove_pending(int id) {
  std::lock_guard<std::mutex> guard(pending_lock);
  for (auto it = pending_requests.begin(); it != pending_requests.end(); it++) {
    if (*it == id) {
      pending_requests.erase(it);
      return 0;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
leaq 0x11caa(%rip), %rsi     # 0x15370
callq 0x5440
leaq 0x11c86(%rip), %rdi     # 0x15358
callq 0x5510
movq %rax, -0x18(%rbp)
leaq 0x11c76(%rip), %rdi     # 0x15358
callq 0x5580
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5540
testb $0x1, %al
jne 0x36fe
jmp 0x3776
leaq -0x18(%rbp), %rdi
callq 0x55b0
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x3760
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5640
movq -0x28(%rbp), %rsi
leaq 0x11c32(%rip), %rdi     # 0x15358
callq 0x55d0
movq %rax, -0x58(%rbp)
jmp 0x3731
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x4(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x3784
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x54e0
jmp 0x3796
jmp 0x3762
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x5680
movq %rax, -0x50(%rbp)
jmp 0x36db
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x44(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x54e0
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3470
nop
// File: jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: read_osc(int, oscpkt::PacketReader*)
int read_osc(int fd, oscpkt::PacketReader* pr) {
  uint32_t size;
  char buff[1024*128];
  int bytes = read(fd, &size, sizeof(size));
  if (bytes == -EAGAIN) return 0;
  if (bytes < sizeof(size) || size >=1024*128)
    return -1;
  bytes = read(fd, &buff, size);
  pr->init(&buff, bytes);
  return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20030, %rsp          # imm = 0x20030
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq 0x33a0
movl %eax, -0x20024(%rbp)
cmpl $-0xb, -0x20024(%rbp)
jne 0x3d4b
movl $0x0, -0x4(%rbp)
jmp 0x3da4
movslq -0x20024(%rbp), %rax
cmpq $0x4, %rax
jb 0x3d61
cmpl $0x20000, -0x14(%rbp)   # imm = 0x20000
jb 0x3d6a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3da4
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %eax
movl %eax, %edx
leaq -0x20020(%rbp), %rsi
callq 0x33a0
movl %eax, -0x20024(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x20024(%rbp), %rdx
leaq -0x20020(%rbp), %rsi
callq 0x5c80
movl -0x20024(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20030, %rsp          # imm = 0x20030
popq %rbp
retq
// File: jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: socket_read_loop(int)
int socket_read_loop(int fd) {
  oscpkt::PacketReader pr;
  while (true) {
    int ret = read_osc(fd, &pr);
    if (ret < 0 || !pr.isOk()) {
      return -1;
    }
    oscpkt::Message* msg;
    for (msg = pr.popMessage(); msg; msg = pr.popMessage()) {
      //std::cout << *msg << std::endl;
      oscpkt::Message::ArgReader arg = msg->arg();
      int resp_id = -1;
      if (arg.isInt32()) {
        arg.popInt32(resp_id);
        if (msg->match("/done"))
          remove_pending(resp_id);
        handle_message(msg, &arg, resp_id);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %edi, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5d30
jmp 0x3dc9
movl -0x4(%rbp), %edi
leaq -0x30(%rbp), %rsi
callq 0x3d10
movl %eax, -0xb0(%rbp)
jmp 0x3ddd
movl -0xb0(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x3e09
leaq -0x30(%rbp), %rdi
callq 0x5d70
movb %al, -0xb1(%rbp)
jmp 0x3dfd
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x3e31
jmp 0x3e09
leaq -0x30(%rbp), %rdi
callq 0x6050
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3fa9
leaq -0x30(%rbp), %rdi
callq 0x5d90
movq %rax, -0xc0(%rbp)
jmp 0x3e43
movq -0xc0(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x3fa4
movq -0x50(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x5e30
jmp 0x3e68
movl $0xffffffff, -0x6c(%rbp) # imm = 0xFFFFFFFF
leaq -0x68(%rbp), %rdi
callq 0x5e60
movb %al, -0xc1(%rbp)
jmp 0x3e80
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x3e8f
jmp 0x3f80
leaq -0x68(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
callq 0x5e90
jmp 0x3e9e
movq -0x50(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3480
movq -0xd0(%rbp), %rdx
leaq 0xa1f2(%rip), %rsi      # 0xe0bc
leaq -0xa8(%rbp), %rdi
callq 0x3370
jmp 0x3ed8
movq -0xd8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x5ec0
jmp 0x3ef4
leaq -0x88(%rbp), %rdi
callq 0x6030
movb %al, -0xd9(%rbp)
jmp 0x3f08
leaq -0xa8(%rbp), %rdi
callq 0x31b0
leaq -0xa9(%rbp), %rdi
callq 0x32e0
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x3f2c
jmp 0x3f6c
movl -0x6c(%rbp), %edi
callq 0x36b0
jmp 0x3f36
jmp 0x3f6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3f5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x31b0
leaq -0xa9(%rbp), %rdi
callq 0x32e0
jmp 0x3fa9
movq -0x50(%rbp), %rdi
movl -0x6c(%rbp), %edx
leaq -0x68(%rbp), %rsi
callq 0x3fc0
jmp 0x3f7e
jmp 0x3f80
jmp 0x3f82
leaq -0x30(%rbp), %rdi
callq 0x5d90
movq %rax, -0xe8(%rbp)
jmp 0x3f94
movq -0xe8(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x3e4e
jmp 0x3dc7
leaq -0x30(%rbp), %rdi
callq 0x6050
movq -0x40(%rbp), %rdi
callq 0x3470
nopl (%rax,%rax)
// File: jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: interactive_loop(int, int, std::istream&)
int interactive_loop(int sock, int start_id, std::istream& in) {
  bool keep_looping = true;
  char* buff = new char [1024];

  while (keep_looping) {
    in.getline(buff, 1024);

    char* trimmed = buff;
    while (trimmed < (buff+1024) && *trimmed && *trimmed == ' ')
      trimmed++;
    if (strncmp(trimmed, "quit", 4) == 0)
      break;

    osc_msg(sock, "/eval", start_id++, "s", trimmed);


    if (in.eof()) break;


  }

  delete[] buff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0x3030
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0x51d6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x30a0
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdx
addq $0x400, %rdx            # imm = 0x400
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x82(%rbp)
jae 0x507b
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x82(%rbp)
je 0x507b
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x82(%rbp)
movb -0x82(%rbp), %al
testb $0x1, %al
jne 0x5087
jmp 0x5095
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x503b
movq -0x28(%rbp), %rdi
leaq 0x9255(%rip), %rsi      # 0xe2f5
movl $0x4, %edx
callq 0x3140
cmpl $0x0, %eax
jne 0x50b4
jmp 0x51d6
movl -0x4(%rbp), %eax
movl %eax, -0x94(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3480
movq -0x90(%rbp), %rdx
leaq 0x9092(%rip), %rsi      # 0xe16d
leaq -0x48(%rbp), %rdi
callq 0x3370
jmp 0x50e6
movl -0x8(%rbp), %eax
movl %eax, -0xa4(%rbp)
incl %eax
movl %eax, -0x8(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3480
movq -0xa0(%rbp), %rdx
leaq 0x905e(%rip), %rsi      # 0xe173
leaq -0x80(%rbp), %rdi
callq 0x3370
jmp 0x5120
movl -0xa4(%rbp), %edx
movl -0x94(%rbp), %edi
movq -0x28(%rbp), %r8
xorl %eax, %eax
leaq -0x48(%rbp), %rsi
leaq -0x80(%rbp), %rcx
callq 0x37a0
jmp 0x5141
leaq -0x80(%rbp), %rdi
callq 0x31b0
leaq -0x81(%rbp), %rdi
callq 0x32e0
leaq -0x48(%rbp), %rdi
callq 0x31b0
leaq -0x49(%rbp), %rdi
callq 0x32e0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3490
testb $0x1, %al
jne 0x517e
jmp 0x51d1
jmp 0x51d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x51c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x51b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31b0
leaq -0x81(%rbp), %rdi
callq 0x32e0
leaq -0x48(%rbp), %rdi
callq 0x31b0
leaq -0x49(%rbp), %rdi
callq 0x32e0
jmp 0x51f5
jmp 0x5017
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, %rax
je 0x51f3
movq -0xb0(%rbp), %rdi
callq 0x3340
ud2
movq -0x58(%rbp), %rdi
callq 0x3470
nop
// File: jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: print_usage(char*)
int print_usage(char* execname) {
  print_version();
  std::cout << "USAGE:\n";
  std::cout << "\t" << execname << " [OPTIONS]\n";
  std::cout << "\n";
  std::string help_text = ""\
                          "--help -h\n"\
                          "\tShow this message\n"\
                          "\n"\
                          "--version -v\n"\
                          "\tDisplay the version string\n"\
                          "\n"\
                          "--socket-path -S\n"\
                          "\tPath to the UNIX socket of MoltenGamepad\n"\
                          "\n"\
                          "--exec -e <command>\n"\
                          "\tSend command to MoltenGamepad\n"\
                          "\n"\
                          "--interactive -i <command>\n"\
                          "\tRead and send commands from standard input.\n"\
                          "\n"\
                          ;

  std::cout << help_text;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
callq 0x5200
movq 0xfd70(%rip), %rdi      # 0x14fc8
movq %rdi, -0x50(%rbp)
leaq 0x8f48(%rip), %rsi      # 0xe1ab
callq 0x32a0
movq -0x50(%rbp), %rdi
leaq 0x8f40(%rip), %rsi      # 0xe1b3
callq 0x32a0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x32a0
movq %rax, %rdi
leaq 0x8f27(%rip), %rsi      # 0xe1b5
callq 0x32a0
movq -0x50(%rbp), %rdi
leaq 0x9023(%rip), %rsi      # 0xe2c1
callq 0x32a0
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3480
movq -0x48(%rbp), %rdx
leaq 0x8f06(%rip), %rsi      # 0xe1c1
leaq -0x28(%rbp), %rdi
callq 0x3370
jmp 0x52c6
leaq -0x29(%rbp), %rdi
callq 0x32e0
movq 0xfcf2(%rip), %rdi      # 0x14fc8
leaq -0x28(%rbp), %rsi
callq 0x3270
jmp 0x52e1
leaq -0x28(%rbp), %rdi
callq 0x31b0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x32e0
jmp 0x531e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31b0
movq -0x38(%rbp), %rdi
callq 0x3470
nopw (%rax,%rax)
// File: jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Message::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, oscpkt::TimeTag)
Message &init(const std::string &addr, TimeTag tt = TimeTag::immediate()) {
    clear();
    address = addr; time_tag = tt;
    if (address.empty() || address[0] != '/') OSCPKT_SET_ERR(MALFORMED_ADDRESS_PATTERN);     
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6f70
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rdi
callq 0x3040
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x3430
testb $0x1, %al
jne 0x5863
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34d0
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x587e
jmp 0x5865
movq -0x20(%rbp), %rax
cmpl $0x0, 0x78(%rax)
jne 0x587a
movq -0x20(%rbp), %rax
movl $0x1, 0x78(%rax)
jmp 0x587c
jmp 0x587e
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Message::pushStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Message &pushStr(const std::string &s) {
    assert(s.size() < 2147483647); // insane values are not welcome
    type_tags += TYPE_TAG_STRING;
    arguments.push_back(std::make_pair(storage.size(), s.size() + 1));
    strcpy(storage.getBytes(s.size()+1), s.c_str());
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jae 0x59ab
jmp 0x59ca
leaq 0x89e3(%rip), %rdi      # 0xe395
leaq 0x899c(%rip), %rsi      # 0xe355
movl $0x193, %edx            # imm = 0x193
leaq 0x89e6(%rip), %rcx      # 0xe3ab
callq 0x31d0
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movl $0x73, %esi
callq 0x31c0
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x48, %rax
movq %rax, -0x50(%rbp)
addq $0x60, %rdi
callq 0x7af0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
addq $0x1, %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7ac0
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x7a90
movq -0x38(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x7b90
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x3290
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::PacketWriter::addMessage(oscpkt::Message const&)
PacketWriter &addMessage(const Message &msg) {
    if (storage.size() != 0 && bundles.empty()) OSCPKT_SET_ERR(BUNDLE_REQUIRED_FOR_MULTI_MESSAGES);
    else msg.packMessage(storage, bundles.size()>0);
    if (!msg.isOk()) OSCPKT_SET_ERR(msg.getErr());
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x7af0
cmpq $0x0, %rax
je 0x5b11
movq -0x18(%rbp), %rdi
callq 0x8540
testb $0x1, %al
jne 0x5af6
jmp 0x5b11
jmp 0x5af8
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x5b0d
movq -0x18(%rbp), %rax
movl $0xa, 0x30(%rax)
jmp 0x5b0f
jmp 0x5b47
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
callq 0x8730
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
cmpq $0x0, %rax
seta %al
movzbl %al, %edx
andl $0x1, %edx
callq 0x8580
movq -0x10(%rbp), %rdi
callq 0x8750
testb $0x1, %al
jne 0x5b76
jmp 0x5b56
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x5b72
movq -0x10(%rbp), %rdi
callq 0x8770
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
jmp 0x5b74
jmp 0x5b76
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::PacketReader::init(void const*, unsigned long)
void init(const void *ptr, size_t sz) {
    err = OK_NO_ERROR; messages.clear();
    if ((sz%4) == 0) { 
      parse((const char*)ptr, (const char *)ptr+sz, TimeTag::immediate());
    } else OSCPKT_SET_ERR(INVALID_PACKET_SIZE);
    it_messages = messages.begin();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, 0x20(%rdi)
callq 0x8b50
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x5cea
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x5890
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
callq 0x8b80
jmp 0x5d05
jmp 0x5cec
movq -0x30(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x5d01
movq -0x30(%rbp), %rax
movl $0x9, 0x20(%rax)
jmp 0x5d03
jmp 0x5d05
movq -0x30(%rbp), %rdi
callq 0x8e80
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Message& oscpkt::Message::pushPod<int>(int, int)
Message &pushPod(int tag, POD v) {
    type_tags += (char)tag; 
    arguments.push_back(std::make_pair(storage.size(), sizeof(POD)));
    pod2bytes(v, storage.getBytes(sizeof(POD))); 
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %eax
addq $0x28, %rdi
movsbl %al, %esi
callq 0x31c0
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x48, %rax
movq %rax, -0x48(%rbp)
addq $0x60, %rdi
callq 0x7af0
movq %rax, -0x28(%rbp)
movq $0x4, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7ac0
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x7a90
movq -0x38(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x3c(%rbp)
addq $0x60, %rdi
movl $0x4, %esi
callq 0x7b90
movl -0x3c(%rbp), %edi
movq %rax, %rsi
callq 0x7b10
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: void oscpkt::pod2bytes<int>(int, char*)
void pod2bytes(const POD value, char *bytes) {
  PodBytes<POD> p; p.value = value; 
  for (size_t i=0; i < sizeof(POD); ++i) {
    if (isBigEndian()) 
      bytes[i] = p.bytes[i];
    else
      bytes[i] = p.bytes[sizeof(POD) - i - 1];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x4, -0x20(%rbp)
jae 0x7b80
callq 0x8440
testb $0x1, %al
jne 0x7b3f
jmp 0x7b54
movq -0x20(%rbp), %rax
movb -0x14(%rbp,%rax), %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x7b70
movl $0x4, %eax
subq -0x20(%rbp), %rax
subq $0x1, %rax
movb -0x14(%rbp,%rax), %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x7b72
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7b2d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Storage::getBytes(unsigned long)
char *getBytes(size_t sz) {
    assert((data.size() & 3) == 0);
    if (data.size() + sz > data.capacity()) { data.reserve((data.size() + sz)*2); }
    size_t sz4 = ceil4(sz);
    size_t pos = data.size(); 
    data.resize(pos + sz4); // resize will fill with zeros, so the zero padding is OK
    return &(data[pos]);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x68a0
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x7bb9
jmp 0x7bd8
leaq 0x677e(%rip), %rdi      # 0xe33e
leaq 0x678e(%rip), %rsi      # 0xe355
movl $0x9d, %edx
leaq 0x679a(%rip), %rcx      # 0xe36d
callq 0x31d0
movq -0x28(%rbp), %rdi
callq 0x68a0
movq -0x28(%rbp), %rdi
addq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x6880
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jbe 0x7c1a
movq -0x28(%rbp), %rdi
callq 0x68a0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq -0x10(%rbp), %rsi
shlq %rsi
callq 0x6690
movq -0x10(%rbp), %rdi
callq 0x8460
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x68a0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
addq -0x18(%rbp), %rsi
callq 0x7130
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8480
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Message::packMessage(oscpkt::Storage&, bool) const
void packMessage(Storage &s, bool write_size) const {
    if (!isOk()) return;
    size_t l_addr = address.size()+1, l_type = type_tags.size()+2;
    if (write_size) 
      pod2bytes<uint32_t>(uint32_t(ceil4(l_addr) + ceil4(l_type) + ceil4(storage.size())), s.getBytes(4));
    strcpy(s.getBytes(l_addr), address.c_str());
    strcpy(s.getBytes(l_type), ("," + type_tags).c_str());
    if (storage.size())
      memcpy(s.getBytes(storage.size()), const_cast<Storage&>(storage).begin(), storage.size());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x8750
testb $0x1, %al
jne 0x85b0
jmp 0x8722
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x31f0
movq -0x50(%rbp), %rdi
addq $0x1, %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x31f0
addq $0x2, %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x11(%rbp)
je 0x863f
movq -0x20(%rbp), %rdi
callq 0x8460
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8460
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq -0x68(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x60(%rbp)
addq $0x60, %rdi
callq 0x7af0
movq %rax, %rdi
callq 0x8460
movq %rax, %rcx
movq -0x60(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x7b90
movl -0x54(%rbp), %edi
movq %rax, %rsi
callq 0x8860
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7b90
movq -0x50(%rbp), %rdi
movq %rax, -0x78(%rbp)
addq $0x8, %rdi
callq 0x3100
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x3290
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7b90
movq -0x50(%rbp), %rdx
movq %rax, -0x70(%rbp)
addq $0x28, %rdx
leaq -0x48(%rbp), %rdi
leaq 0x5d55(%rip), %rsi      # 0xe3e2
callq 0x88e0
leaq -0x48(%rbp), %rdi
callq 0x3100
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x3290
leaq -0x48(%rbp), %rdi
callq 0x31b0
movq -0x50(%rbp), %rdi
addq $0x60, %rdi
callq 0x7af0
cmpq $0x0, %rax
je 0x8722
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
addq $0x60, %rdi
callq 0x7af0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x7b90
movq -0x50(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0x60, %rdi
callq 0x89f0
movq -0x50(%rbp), %rdi
movq %rax, -0x80(%rbp)
addq $0x60, %rdi
callq 0x7af0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
callq 0x3220
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: unsigned long oscpkt::bytes2pod<unsigned long>(char const*)
POD bytes2pod(const char *bytes) {
  PodBytes<POD> p; 
  for (size_t i=0; i < sizeof(POD); ++i) {
    if (isBigEndian()) 
      p.bytes[i] = bytes[i];
    else
      p.bytes[i] = bytes[sizeof(POD) - i - 1];
  }
  return p.value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x8, -0x18(%rbp)
jae 0x9137
callq 0x8440
testb $0x1, %al
jne 0x90f6
jmp 0x910b
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x18(%rbp), %rax
movb %cl, -0x10(%rbp,%rax)
jmp 0x9127
movq -0x8(%rbp), %rax
movl $0x8, %ecx
subq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %cl
movq -0x18(%rbp), %rax
movb %cl, -0x10(%rbp,%rax)
jmp 0x9129
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x90e4
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::isZeroPaddingCorrect(char const*)
inline bool isZeroPaddingCorrect(const char *p) {
  const char *q = ceil4(p);
  for (;p < q; ++p)
    if (*p != 0) { return false; }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9e70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x9de5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9dd5
movb $0x0, -0x1(%rbp)
jmp 0x9de9
jmp 0x9dd7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9db9
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Message::ArgReader& oscpkt::Message::ArgReader::popPod<int>(int, int&)
ArgReader &popPod(int tag, POD &v) {
      if (precheck(tag)) {
        v = bytes2pod<POD>(argBeg(arg_idx));
        ++arg_idx;
      } else v = POD(0);
      return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %esi
callq 0xab60
testb $0x1, %al
jne 0xab19
jmp 0xab48
movq -0x20(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0xac70
movq %rax, %rdi
callq 0xac00
movl %eax, %edx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xab52
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)