LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tdv[P]boss/boss/include/common/xml_property_bag.h
// Function: Boss::XmlPropertyBag::GetProperty(char const*, Boss::IBase**) const
virtual RetCode BOSS_CALL GetProperty(char const *name, IBase **value) const
    {
      if (!name || !*name || !value || *value)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        auto Iter = Props.find(name);
        if (Iter == std::end(Props))
          return Status::NotFound;
        return Iter->second.QueryInterface(value);
      }
      catch (...)
      {
        return Status::Fail;
      }
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0xa0(%rsp)
je 0x29fdd
movq 0xa0(%rsp), %rax
cmpb $0x0, (%rax)
je 0x29fdd
cmpq $0x0, 0x98(%rsp)
je 0x29fdd
movq 0x98(%rsp), %rax
cmpq $0x0, (%rax)
je 0x29fed
movl $0x5, 0xb4(%rsp)
jmp 0x2a1af
movq 0x38(%rsp), %rsi
addq $0x20, %rsi
leaq 0x90(%rsp), %rdi
callq 0x22340
jmp 0x2a005
movq 0x38(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x20(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x4a200
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0xc7340
jmp 0x2a045
movq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2c070
movq %rax, 0x18(%rsp)
jmp 0x2a05b
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xc49c0
leaq 0x57(%rsp), %rdi
callq 0x4a220
movq 0x38(%rsp), %rdi
addq $0x48, %rdi
callq 0x2c0c0
movq %rax, 0x10(%rsp)
jmp 0x2a08e
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2c0a0
testb $0x1, %al
jne 0x2a0b0
jmp 0x2a137
movl $0x3, 0xb4(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0x2a16e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2a18a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2a115
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xc49c0
leaq 0x57(%rsp), %rdi
callq 0x4a220
jmp 0x2a17d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2a17d
leaq 0x78(%rsp), %rdi
callq 0x2c0f0
movq %rax, %rdi
addq $0x20, %rdi
movq 0x98(%rsp), %rsi
callq 0x2c110
movl %eax, 0xc(%rsp)
jmp 0x2a15b
movl 0xc(%rsp), %eax
movl %eax, 0xb4(%rsp)
movl $0x1, 0x44(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x22460
jmp 0x2a1af
leaq 0x90(%rsp), %rdi
callq 0x22460
movq 0x88(%rsp), %rdi
callq 0x480e0
movl $0x2, 0xb4(%rsp)
movl $0x1, 0x44(%rsp)
callq 0x48150
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nop
// File: tdv[P]boss/boss/include/common/xml_property_bag.h
// Function: Boss::XmlPropertyBag::SetProperty(char const*, Boss::IBase*)
virtual RetCode BOSS_CALL SetProperty(char const *name, IBase *value)
    {
      if (!name || !*name || !value)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        Props[name] = value;
        return Status::Ok;
      }
      catch (...)
      {
        return Status::Fail;
      }
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x80(%rsp)
je 0x2a209
movq 0x80(%rsp), %rax
cmpb $0x0, (%rax)
je 0x2a209
cmpq $0x0, 0x78(%rsp)
jne 0x2a219
movl $0x5, 0x94(%rsp)
jmp 0x2a330
movq 0x30(%rsp), %rsi
addq $0x20, %rsi
leaq 0x70(%rsp), %rdi
callq 0x22340
jmp 0x2a22e
movq 0x30(%rsp), %rax
movq 0x78(%rsp), %rcx
movq %rcx, 0x10(%rsp)
addq $0x48, %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x4a200
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0xc7340
jmp 0x2a278
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2c7f0
movq %rax, 0x8(%rsp)
jmp 0x2a28e
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x2c820
jmp 0x2a29f
leaq 0x40(%rsp), %rdi
callq 0xc49c0
leaq 0x3f(%rsp), %rdi
callq 0x4a220
movl $0x0, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x22460
jmp 0x2a330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x2a316
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x2a302
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xc49c0
leaq 0x3f(%rsp), %rdi
callq 0x4a220
leaq 0x70(%rsp), %rdi
callq 0x22460
movq 0x68(%rsp), %rdi
callq 0x480e0
movl $0x2, 0x94(%rsp)
callq 0x48150
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nop
// File: tdv[P]boss/boss/include/common/xml_property_bag.h
// Function: Boss::XmlPropertyBag::EnumProperties(Boss::IEnum**)
virtual RetCode BOSS_CALL EnumProperties(IEnum **props)
    {
      if (!props || *props)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        auto PropEnum = Base<Enum>::Create();
        for (auto &prop : Props)
          PropEnum->AddItem(Base<NamedValue>::Create(prop.first, prop.second));
        return PropEnum.QueryInterface(props);
      }
      catch (...)
      {
        return Status::Fail;
      }
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x2a36b
movq 0x60(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2a378
movl $0x5, 0x74(%rsp)
jmp 0x2a4e5
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
leaq 0x58(%rsp), %rdi
callq 0x22340
jmp 0x2a38d
leaq 0x40(%rsp), %rdi
callq 0x23c80
jmp 0x2a399
movq 0x10(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2d400
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2c790
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2d430
testb $0x1, %al
jne 0x2a3dd
jmp 0x2a487
leaq 0x30(%rsp), %rdi
callq 0x2d450
movq %rax, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x23e60
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, %rdx
addq $0x20, %rdx
leaq 0x18(%rsp), %rdi
callq 0x2d510
jmp 0x2a413
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2d470
jmp 0x2a424
leaq 0x18(%rsp), %rdi
callq 0x2d620
leaq 0x30(%rsp), %rdi
callq 0x2d640
jmp 0x2a3c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x2a4ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x2a4c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x2a4ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2d620
jmp 0x2a4ba
movq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x2d670
movl %eax, 0x4(%rsp)
jmp 0x2a49c
movl 0x4(%rsp), %eax
movl %eax, 0x74(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x24300
leaq 0x58(%rsp), %rdi
callq 0x22460
jmp 0x2a4e5
leaq 0x40(%rsp), %rdi
callq 0x24300
leaq 0x58(%rsp), %rdi
callq 0x22460
movq 0x50(%rsp), %rdi
callq 0x480e0
movl $0x2, 0x74(%rsp)
callq 0x48150
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nop
// File: tdv[P]boss/boss/include/core/utils.h
// Function: unsigned int Boss::FromString<unsigned int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline T FromString(std::string const &str)
  {
    std::stringstream Io;
    Io << str;
    T Ret;
    Io >> Ret;
    return Ret;
  }

// Assembly:
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, 0x1a0(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xbdc30
leaq 0x28(%rsp), %rdi
movq 0x1a0(%rsp), %rsi
callq 0xc7410
jmp 0x377fd
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9a7e0
jmp 0x3780e
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xba050
movl 0x4(%rsp), %eax
addq $0x1a8, %rsp            # imm = 0x1A8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xba050
movq 0x10(%rsp), %rdi
callq 0xf31f0
nop
// File: tdv[P]boss/boss/include/other/rapidxml-1.13/rapidxml.hpp
// Function: rapidxml::memory_pool<char>::allocate_string(char const*, unsigned long)
Ch *allocate_string(const Ch *source = 0, std::size_t size = 0)
        {
            assert(source || size);     // Either source or size (or both) must be specified
            if (size == 0)
                size = internal::measure(source) + 1;
            Ch *result = static_cast<Ch *>(allocate_aligned(size * sizeof(Ch)));
            if (source)
                for (std::size_t i = 0; i < size; ++i)
                    result[i] = source[i];
            return result;
        }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movb $0x1, %al
cmpq $0x0, 0x28(%rsp)
movb %al, 0xf(%rsp)
jne 0x397f7
cmpq $0x0, 0x20(%rsp)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x39801
jmp 0x39803
jmp 0x39822
leaq 0xbd311(%rip), %rdi     # 0xf6b1b
leaq 0xbcedd(%rip), %rsi     # 0xf66ee
movl $0x1de, %edx            # imm = 0x1DE
leaq 0xbd30d(%rip), %rcx     # 0xf6b2a
callq 0x1c150
cmpq $0x0, 0x20(%rsp)
jne 0x3983d
movq 0x28(%rsp), %rdi
callq 0x34c60
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
shlq $0x0, %rsi
callq 0x36040
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x3989d
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x3989b
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x39865
jmp 0x3989d
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tdv[P]boss/boss/include/other/rapidxml-1.13/rapidxml_print.hpp
// Function: std::ostream_iterator<char, char, std::char_traits<char>> rapidxml::internal::print_data_node<std::ostream_iterator<char, char, std::char_traits<char>>, char>(std::ostream_iterator<char, char, std::char_traits<char>>, rapidxml::xml_node<char> const*, int, int)
inline OutIt print_data_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_data);
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out);
            return out;
        }

// Assembly:
subq $0x98, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movl %r8d, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x37730
cmpl $0x2, %eax
jne 0x3aa0e
jmp 0x3aa2d
leaq 0xbc30a(%rip), %rdi     # 0xf6d1f
leaq 0xbc1b0(%rip), %rsi     # 0xf6bcc
movl $0xf2, %edx
leaq 0xbc311(%rip), %rcx     # 0xf6d39
callq 0x1c150
movl 0x7c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3aa76
movq 0x20(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x3a270
movl 0x78(%rsp), %edx
leaq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rsi
movl $0x9, %ecx
callq 0x3b8b0
movq 0x20(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, (%rax)
movq 0x70(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x80(%rsp), %rdi
callq 0x36d60
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
callq 0x36d60
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rdi
callq 0x36da0
movq 0x20(%rsp), %rsi
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3a270
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x48(%rsp), %rdi
xorl %ecx, %ecx
leaq 0x38(%rsp), %r8
callq 0x3bd90
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x48(%rsp), %rax
movq %rax, (%rsi)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsi)
callq 0x3a270
movq 0x30(%rsp), %rax
addq $0x98, %rsp
retq
nop
// File: tdv[P]boss/boss/include/other/rapidxml-1.13/rapidxml_print.hpp
// Function: std::ostream_iterator<char, char, std::char_traits<char>> rapidxml::internal::print_declaration_node<std::ostream_iterator<char, char, std::char_traits<char>>, char>(std::ostream_iterator<char, char, std::char_traits<char>>, rapidxml::xml_node<char> const*, int, int)
inline OutIt print_declaration_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            // Print declaration start
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'), ++out;
            *out = Ch('?'), ++out;
            *out = Ch('x'), ++out;
            *out = Ch('m'), ++out;
            *out = Ch('l'), ++out;

            // Print attributes
            out = print_attributes(out, node, flags);
            
            // Print declaration end
            *out = Ch('?'), ++out;
            *out = Ch('>'), ++out;
            
            return out;
        }

// Assembly:
subq $0x88, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movl %r8d, 0x68(%rsp)
movl 0x6c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3aeba
movq (%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x3a270
movl 0x68(%rsp), %edx
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movl $0x9, %ecx
callq 0x3b8b0
movq (%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, (%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq (%rsp), %rdi
movb $0x3c, 0x47(%rsp)
callq 0x3b840
movq %rax, %rdi
leaq 0x47(%rsp), %rsi
callq 0x3b850
movq (%rsp), %rdi
callq 0x3b8a0
movq (%rsp), %rdi
movb $0x3f, 0x46(%rsp)
callq 0x3b840
movq %rax, %rdi
leaq 0x46(%rsp), %rsi
callq 0x3b850
movq (%rsp), %rdi
callq 0x3b8a0
movq (%rsp), %rdi
movb $0x78, 0x45(%rsp)
callq 0x3b840
movq %rax, %rdi
leaq 0x45(%rsp), %rsi
callq 0x3b850
movq (%rsp), %rdi
callq 0x3b8a0
movq (%rsp), %rdi
movb $0x6d, 0x44(%rsp)
callq 0x3b840
movq %rax, %rdi
leaq 0x44(%rsp), %rsi
callq 0x3b850
movq (%rsp), %rdi
callq 0x3b8a0
movq (%rsp), %rdi
movb $0x6c, 0x43(%rsp)
callq 0x3b840
movq %rax, %rdi
leaq 0x43(%rsp), %rsi
callq 0x3b850
movq (%rsp), %rdi
callq 0x3b8a0
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3a270
movq 0x70(%rsp), %rdx
movl 0x6c(%rsp), %ecx
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3b9c0
movq (%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, (%rdi)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rdi)
movb $0x3f, 0x1f(%rsp)
callq 0x3b840
movq %rax, %rdi
leaq 0x1f(%rsp), %rsi
callq 0x3b850
movq (%rsp), %rdi
callq 0x3b8a0
movq (%rsp), %rdi
movb $0x3e, 0x1e(%rsp)
callq 0x3b840
movq %rax, %rdi
leaq 0x1e(%rsp), %rsi
callq 0x3b850
movq (%rsp), %rdi
callq 0x3b8a0
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x3a270
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: tdv[P]boss/boss/include/other/rapidxml-1.13/rapidxml_print.hpp
// Function: bool rapidxml::internal::find_char<char, (char)34>(char const*, char const*)
inline bool find_char(const Ch *begin, const Ch *end)
        {
            while (begin != end)
                if (*begin++ == ch)
                    return true;
            return false;
        }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpq -0x18(%rsp), %rax
je 0x3c2b8
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x3c2b6
movb $0x1, -0x1(%rsp)
jmp 0x3c2bd
jmp 0x3c28a
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nop
// File: tdv[P]boss/boss/include/other/rapidxml-1.13/rapidxml.hpp
// Function: rapidxml::xml_attribute<char>::next_attribute(char const*, unsigned long, bool) const
xml_attribute<Ch> *next_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
        {
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_attribute<Ch> *attribute = m_next_attribute; attribute; attribute = attribute->m_next_attribute)
                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
                        return attribute;
                return 0;
            }
            else
                return this->m_parent ? m_next_attribute : 0;
        }

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x3c397
cmpq $0x0, 0x28(%rsp)
jne 0x3c318
movq 0x30(%rsp), %rdi
callq 0x34c60
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x3c38c
movq 0x18(%rsp), %rdi
callq 0x33040
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x33080
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movb 0x27(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x34ca0
testb $0x1, %al
jne 0x3c36e
jmp 0x3c37a
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x3c3c3
jmp 0x3c37c
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x3c326
movq $0x0, 0x40(%rsp)
jmp 0x3c3c3
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3c3b2
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
jmp 0x3c3ba
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x3c3ba
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: tdv[P]boss/boss/include/plugin/service_info.h
// Function: Boss::Private::ServiceInfo<Boss::ILocalServiceInfo, true>::GetServiceId(unsigned int*) const
virtual RetCode BOSS_CALL GetServiceId(ServiceId *serviceId) const
      {
        if (!serviceId)
          return Status::InvalidArgument;
        *serviceId = SrvId;
        return Status::Ok;
      }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0x3cfc6
movl $0x5, -0x4(%rsp)
jmp 0x3cfdd
movq -0x20(%rsp), %rax
movl 0x14(%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tdv[P]boss/boss/include/plugin/service_info.h
// Function: Boss::RemoteServiceInfo::GetSerializerId(unsigned int*) const
virtual RetCode BOSS_CALL GetSerializerId(ClassId *id) const
    {
      if (!id)
        return Status::InvalidArgument;
      *id = SerializerId;
      return Status::Ok;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0x3e5d6
movl $0x5, -0x4(%rsp)
jmp 0x3e5ed
movq -0x20(%rsp), %rax
movl 0x38(%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tdv[P]boss/boss/include/plugin/service_info.h
// Function: Boss::RemoteServiceInfo::GetRemotingId(unsigned int*) const
virtual RetCode BOSS_CALL GetRemotingId(ClassId *id) const
    {
      if (!id)
        return Status::InvalidArgument;
      *id = RemotingId;
      return Status::Ok;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0x3e626
movl $0x5, -0x4(%rsp)
jmp 0x3e63d
movq -0x20(%rsp), %rax
movl 0x3c(%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tdv[P]boss/boss/include/plugin/service_info.h
// Function: Boss::RemoteServiceInfo::GetTransportId(unsigned int*) const
virtual RetCode BOSS_CALL GetTransportId(ClassId *id) const
    {
      if (!id)
        return Status::InvalidArgument;
      *id = TransportId;
      return Status::Ok;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0x3e676
movl $0x5, -0x4(%rsp)
jmp 0x3e68d
movq -0x20(%rsp), %rax
movl 0x40(%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tdv[P]boss/boss/include/plugin/module_holder.h
// Function: Boss::ModuleHolder::GetServiceId() const
ServiceId const GetServiceId() const
    {
      typedef RetCode (*PFNBossGetServiceId)(ServiceId *);
      auto *BossGetServiceId = Dll.GetProc<PFNBossGetServiceId>("BossGetServiceId");
      ServiceId SrvId = 0;
      if (BossGetServiceId(&SrvId) != Status::Ok)
        throw ModuleHolderException("Failed to call BossGetServiceId.");
      return SrvId;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4a200
movq 0x18(%rsp), %rdx
leaq 0xb6b39(%rip), %rsi     # 0xf84f7
leaq 0x38(%rsp), %rdi
callq 0xc7340
jmp 0x419ca
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x42510
movq %rax, 0x8(%rsp)
jmp 0x419e0
leaq 0x38(%rsp), %rdi
callq 0xc49c0
leaq 0x37(%rsp), %rdi
callq 0x4a220
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movl $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq *0x58(%rsp)
cmpl $0x0, %eax
je 0x41a9e
movl $0x10, %edi
callq 0x47f80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0xb6ad5(%rip), %rsi     # 0xf8508
callq 0x426c0
jmp 0x41a3a
movq (%rsp), %rdi
leaq 0x1004fb(%rip), %rsi    # 0x141f40
leaq 0xcb4(%rip), %rdx       # 0x42700
callq 0x48fd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x41a79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xc49c0
leaq 0x37(%rsp), %rdi
callq 0x4a220
jmp 0x41aa7
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x47fe0
jmp 0x41aa7
movl 0x20(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xf31f0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tdv[P]boss/boss/include/core/crc32.h
// Function: Boss::Crc32(void const*, unsigned int)
inline UInt Crc32(void const *data, UInt bytes)
  {
    std::uint8_t const *Buf = reinterpret_cast<std::uint8_t const *>(data);
    std::uint32_t Crc = 0;
    Crc = Crc ^ ~0U;
    while (bytes--)
      Crc = Private::Crc32Table::Table[(Crc ^ *Buf++) & 0xFF] ^ (Crc >> 8);
    return Crc ^ ~0U;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
xorl $-0x1, %eax
movl %eax, -0x1c(%rsp)
movl -0xc(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rsp)
cmpl $0x0, %eax
je 0x42064
movl -0x1c(%rsp), %eax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movzbl (%rcx), %ecx
xorl %ecx, %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xb699e(%rip), %rax     # 0xf89f0
movl (%rax,%rcx,4), %eax
movl -0x1c(%rsp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x1c(%rsp)
jmp 0x42016
movl -0x1c(%rsp), %eax
xorl $-0x1, %eax
retq
nopl (%rax)
// File: attractivechaos[P]udb2/khashpp/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	klib::KHash<aux_t, aux_hash, aux_eq> h;
	for (i = 0, x = x0; i < n; ++i) {
		aux_t a;
		size_t k;
		int absent;
		x = hash32(x);
		a.key = get_key(n, x), a.cnt = 0;
		k = h.put(a, &absent);
		z += ++h.at(k).cnt;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0x88, %rsp
movl %edi, 0x84(%rsp)
movl %esi, 0x80(%rsp)
movl $0x0, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1730
movl $0x0, 0x7c(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0x84(%rsp), %eax
jae 0x16b2
movl 0x78(%rsp), %edi
callq 0x1250
movl %eax, 0x28(%rsp)
jmp 0x160a
movl 0x28(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x84(%rsp), %edi
movl 0x78(%rsp), %esi
callq 0x12c0
movl %eax, 0x24(%rsp)
jmp 0x1628
movl 0x24(%rsp), %eax
movl %eax, 0x48(%rsp)
movl $0x0, 0x4c(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x3c(%rsp), %rdx
callq 0x1770
movl %eax, 0x20(%rsp)
jmp 0x1652
movl 0x20(%rsp), %eax
movl %eax, %eax
movq %rax, 0x40(%rsp)
movl 0x40(%rsp), %esi
leaq 0x50(%rsp), %rdi
callq 0x1b10
movq %rax, 0x18(%rsp)
jmp 0x1672
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
addl 0x74(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x15ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1b40
jmp 0x1712
movq 0x2927(%rip), %rax      # 0x3fe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1b30
movl %eax, 0x14(%rsp)
jmp 0x16d1
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rdi
movl 0x74(%rsp), %ecx
leaq 0x990(%rip), %rsi       # 0x2075
xorl %eax, %eax
callq 0x10a0
leaq 0x50(%rsp), %rdi
callq 0x1b30
movl %eax, 0x4(%rsp)
jmp 0x16fc
leaq 0x50(%rsp), %rdi
callq 0x1b40
movl 0x4(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x10d0
nopl (%rax)
// File: maxgodfrey2004[P]gss/main.cc
// Function: main
int main(int argc, char *argv[]) {
  // Optimize std::cout - this will (hopefully) help us run faster than grep.
  std::ios::sync_with_stdio(false);
  std::cout.tie(nullptr);

  cli::CheckArgv(argv, argv + argc);

  std::string filename(argv[1]);
  std::string search_pattern(argv[2]);
  gss::fileutils::Match(filename, search_pattern);

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %edi, %edi
movl %edi, -0xc4(%rbp)
callq 0x20b0
movl -0xc4(%rbp), %eax
movq 0x677d(%rip), %rdi      # 0x8fd0
movq (%rdi), %rcx
movq -0x18(%rcx), %rcx
addq %rcx, %rdi
movl %eax, %esi
callq 0x2110
movq -0x10(%rbp), %rdi
movslq -0x8(%rbp), %rax
leaq (%rdi,%rax,8), %rsi
callq 0x25d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x22c0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x2a40
jmp 0x28ad
leaq -0x31(%rbp), %rdi
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x22c0
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x2a40
jmp 0x28ee
leaq -0x69(%rbp), %rdi
callq 0x21d0
leaq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20c0
jmp 0x2909
leaq -0xb0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x20c0
jmp 0x291b
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x3110
jmp 0x2930
leaq -0xb0(%rbp), %rdi
callq 0x2308
leaq -0x90(%rbp), %rdi
callq 0x2308
movl $0x0, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2308
leaq -0x30(%rbp), %rdi
callq 0x2308
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x21d0
jmp 0x29ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x21d0
jmp 0x29e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x29db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x29cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2308
leaq -0x90(%rbp), %rdi
callq 0x2308
leaq -0x68(%rbp), %rdi
callq 0x2308
leaq -0x30(%rbp), %rdi
callq 0x2308
movq -0x40(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: maxgodfrey2004[P]gss/main.cc
// Function: cli::PrintHelpUtil()
inline void PrintHelpUtil() {
  std::cout << "gss: Grep for Small Strings\n"
            << "Usage: gss [--help] [FILE] [PATTERN]\n\n"
            << "Flags:\n"
            << "  -h, --help    display this help text and exit"
            << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x64d5(%rip), %rdi      # 0x8fd0
leaq 0x3567(%rip), %rsi      # 0x6069
callq 0x2180
movq %rax, %rdi
leaq 0x3575(%rip), %rsi      # 0x6086
callq 0x2180
movq %rax, %rdi
leaq 0x358d(%rip), %rsi      # 0x60ad
callq 0x2180
movq %rax, %rdi
leaq 0x3586(%rip), %rsi      # 0x60b5
callq 0x2180
movq %rax, %rdi
movq 0x647a(%rip), %rsi      # 0x8fb8
callq 0x21b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: maxgodfrey2004[P]gss/src/fileutils.cc
// Function: gss::fileutils::CheckAccessible(char const*)
inline void CheckAccessible(const char *filename) {
  struct stat buffer;
  if (stat(filename, &buffer) != 0) {
    std::cerr << "ERROR: `" << filename << "` is not accessible." << std::endl;
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2170
cmpl $0x0, %eax
je 0x359b
movq 0x5a95(%rip), %rdi      # 0x8ff0
leaq 0x2bb8(%rip), %rsi      # 0x611a
callq 0x2180
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2180
movq %rax, %rdi
leaq 0x2ba6(%rip), %rsi      # 0x6123
callq 0x2180
movq %rax, %rdi
movq 0x5a2c(%rip), %rsi      # 0x8fb8
callq 0x21b0
movl $0x1, %edi
callq 0x2210
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk-extras/exprtk_maze_generator.cpp
// Function: shuffle<double>::shuffle()
shuffle()
   : exprtk::igeneric_function<T>("V")
   {
      std::random_device device;
      std::array<unsigned int,std::mt19937::state_size> seed;
      std::generate_n(seed.data(), seed.size(), std::ref(device));
      std::seed_seq seq(std::begin(seed), std::end(seed));
      generator.seed(seq);
   }

// Assembly:
subq $0x1de8, %rsp           # imm = 0x1DE8
movq %rdi, 0x1de0(%rsp)
movq 0x1de0(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x1dbf(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x114690
movq 0x38(%rsp), %rdx
leaq 0x34c6c6(%rip), %rsi    # 0x46a650
leaq 0x1dc0(%rsp), %rdi
callq 0x11b7a0
jmp 0x11df99
movq 0x30(%rsp), %rdi
leaq 0x1dc0(%rsp), %rsi
xorl %edx, %edx
callq 0x120b10
jmp 0x11dfaf
leaq 0x1dc0(%rsp), %rdi
callq 0x1147d8
leaq 0x1dbf(%rsp), %rdi
callq 0x1147c0
movq 0x30(%rsp), %rdi
leaq 0x4c382b(%rip), %rax    # 0x5e1800
movq %rax, (%rdi)
addq $0x48, %rdi
callq 0x120b70
jmp 0x11dfe3
movq 0x30(%rsp), %rdi
addq $0x13d0, %rdi           # imm = 0x13D0
xorps %xmm0, %xmm0
movsd 0x34600e(%rip), %xmm1   # 0x464008
callq 0x120b90
jmp 0x11e001
leaq 0xa20(%rsp), %rdi
callq 0x120bc0
jmp 0x11e010
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x120cd0
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x120ce0
movq %rax, 0x28(%rsp)
leaq 0xa20(%rsp), %rdi
callq 0x120cf0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdx
callq 0x120c60
jmp 0x11e05b
leaq 0x60(%rsp), %rdi
callq 0x120d20
movq %rax, 0x10(%rsp)
jmp 0x11e06c
leaq 0x60(%rsp), %rdi
callq 0x120d30
movq %rax, 0x8(%rsp)
jmp 0x11e07d
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x120d40
jmp 0x11e093
movq 0x30(%rsp), %rdi
addq $0x48, %rdi
leaq 0x40(%rsp), %rsi
callq 0x120e20
jmp 0x11e0a8
leaq 0x40(%rsp), %rdi
callq 0x120fa0
leaq 0xa20(%rsp), %rdi
callq 0x120fb0
addq $0x1de8, %rsp           # imm = 0x1DE8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1db0(%rsp)
movl %eax, 0x1dac(%rsp)
jmp 0x11e0fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1db0(%rsp)
movl %eax, 0x1dac(%rsp)
leaq 0x1dc0(%rsp), %rdi
callq 0x1147d8
leaq 0x1dbf(%rsp), %rdi
callq 0x1147c0
jmp 0x11e16e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1db0(%rsp)
movl %eax, 0x1dac(%rsp)
jmp 0x11e164
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1db0(%rsp)
movl %eax, 0x1dac(%rsp)
jmp 0x11e157
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1db0(%rsp)
movl %eax, 0x1dac(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x120fa0
leaq 0xa20(%rsp), %rdi
callq 0x120fb0
movq 0x30(%rsp), %rdi
callq 0x121130
movq 0x1db0(%rsp), %rdi
callq 0x114470
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::function_compositor<double>::function::vars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline function& vars(const std::string& v0,
                               const std::string& v1,
                               const std::string& v2)
         {
            v_.push_back(v0);
            v_.push_back(v1);
            v_.push_back(v2);
            return (*this);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x40, %rdi
movq 0x18(%rsp), %rsi
callq 0x14b200
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x10(%rsp), %rsi
callq 0x14b200
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x8(%rsp), %rsi
callq 0x14b200
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/src/CPU.cc
// Function: CPU::~CPU()
CPU::~CPU() {
  // Free up Mapped Opcode Execute Methods
  for (auto key: this->oMap) {
    delete key.second;
  }
  for (auto key: this->pMap) {
    delete key.second;
  }
  delete this->ppu;
  cpuExecDump.close();

  // Clean up Debug Data
  for (auto &p : this->instr_iters) {
    delete p.second;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
addq $0xa8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb4070
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb40a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb40d0
testb $0x1, %al
jne 0x4a4ee
jmp 0x4a541
leaq -0x18(%rbp), %rdi
callq 0xb4100
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x4a534
movq -0x88(%rbp), %rdi
callq 0xb4130
movq -0x88(%rbp), %rdi
movl $0x50, %esi
callq 0xd100
jmp 0x4a536
leaq -0x18(%rbp), %rdi
callq 0xb4160
jmp 0x4a4db
movq -0x80(%rbp), %rax
addq $0xe0, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xb4070
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xb40a0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb40d0
testb $0x1, %al
jne 0x4a57c
jmp 0x4a5cf
leaq -0x40(%rbp), %rdi
callq 0xb4100
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x4a5c2
movq -0x90(%rbp), %rdi
callq 0xb4130
movq -0x90(%rbp), %rdi
movl $0x50, %esi
callq 0xd100
jmp 0x4a5c4
leaq -0x40(%rbp), %rdi
callq 0xb4160
jmp 0x4a569
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
je 0x4a5f4
movq -0x98(%rbp), %rdi
movl $0x28, %esi
callq 0xd100
movq -0x80(%rbp), %rdi
addq $0x10158, %rdi          # imm = 0x10158
callq 0xd880
jmp 0x4a606
movq -0x80(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0xb41a0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0xb41d0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xb4200
testb $0x1, %al
jne 0x4a63f
jmp 0x4a67f
leaq -0x68(%rbp), %rdi
callq 0xb4230
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x4a672
movq -0xa0(%rbp), %rdi
movl $0x10, %esi
callq 0xd100
jmp 0x4a674
leaq -0x68(%rbp), %rdi
callq 0xb4260
jmp 0x4a62c
movq -0x80(%rbp), %rdi
addq $0x10158, %rdi          # imm = 0x10158
callq 0xd780
movq -0x80(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0xb3fa0
movq -0x80(%rbp), %rdi
addq $0xe0, %rdi
callq 0xb3fc0
movq -0x80(%rbp), %rdi
addq $0xa8, %rdi
callq 0xb3fc0
movq -0x80(%rbp), %rdi
addq $0x70, %rdi
callq 0xb3fe0
movq -0x80(%rbp), %rdi
addq $0x10, %rdi
callq 0xb4000
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb4190
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/src/CPU.cc
// Function: CPU::tick()
void CPU::tick() {
  if (!halted)
    ppu->execute();
  else
    handleInterrupt();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x12a(%rax)
jne 0x4a71b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbd060
jmp 0x4a724
movq -0x10(%rbp), %rdi
callq 0x4a730
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/src/CPU.cc
// Function: CPU::checkHalfCarry(unsigned char, unsigned char)
void CPU::checkHalfCarry(uint8_t prev, uint8_t after) { // Overflow from 3rd Bit
  this->reg.F &= 0xDF;                    // Unset H Flag
  if ((prev & 0x0F) != (after & 0x0F))    // LSB Change
    if ((prev & 0xF0) != (after & 0xF0))  // MSB Change
      this->reg.F |= 0x20;                // Set H Flag
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzbl 0x11d(%rax), %ecx
andl $0xdf, %ecx
movb %cl, 0x11d(%rax)
movzbl -0x9(%rbp), %eax
andl $0xf, %eax
movzbl -0xa(%rbp), %ecx
andl $0xf, %ecx
cmpl %ecx, %eax
je 0x4abdd
movzbl -0x9(%rbp), %eax
andl $0xf0, %eax
movzbl -0xa(%rbp), %ecx
andl $0xf0, %ecx
cmpl %ecx, %eax
je 0x4abdb
movq -0x18(%rbp), %rax
movzbl 0x11d(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x11d(%rax)
jmp 0x4abdd
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/src/CPU.cc
// Function: CPU::checkCarry(unsigned char, unsigned char)
void CPU::checkCarry(uint8_t prev, uint8_t after) { // Overflow from 7th Bit
  this->reg.F &= 0xEF;                         // Unset C Flag

  // Overflow Result
  if (prev > after)
    this->reg.F |= 0x10;                       // Set C Flag
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzbl 0x11d(%rax), %ecx
andl $0xef, %ecx
movb %cl, 0x11d(%rax)
movzbl -0x9(%rbp), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jle 0x4ac2e
movq -0x18(%rbp), %rax
movzbl 0x11d(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x11d(%rax)
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/src/CPU.cc
// Function: CPU::getCpuStateSnapshot()
const CPU_State CPU::getCpuStateSnapshot() {
  return {
    reg,
    SP,
    PC,
    ppu->getLY(),
    IME,
    halted,
    running
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x118(%rax), %rcx
movq %rcx, -0x10(%rbp)
movw 0x12e(%rax), %cx
movw %cx, -0x8(%rbp)
movw 0x12c(%rax), %cx
movw %cx, -0x6(%rbp)
movq (%rax), %rdi
callq 0xbd040
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x4(%rbp)
movb 0x128(%rax), %cl
andb $0x1, %cl
movb %cl, -0x3(%rbp)
movb 0x12a(%rax), %cl
andb $0x1, %cl
movb %cl, -0x2(%rbp)
movb 0x12b(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/src/Instructions.cc
// Function: CPU::ADC(unsigned char)
void CPU::ADC(uint8_t u8) {                 // ADC A, u8
  uint8_t result = this->reg.A + ((this->reg.F & 0x10) >> 4) + u8;

  // Set Flags
  this->setZeroFlag(result == 0);     // Zero Flag
  this->setAddSubFlag(false);   // Unset N Flag
  this->checkHalfCarry(result, this->reg.A);
  this->checkCarry(this->reg.A, result);

  // Set new A Value
  this->reg.A = result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movzbl 0x118(%rdi), %eax
movzbl 0x11d(%rdi), %ecx
andl $0x10, %ecx
sarl $0x4, %ecx
addl %ecx, %eax
movzbl -0x9(%rbp), %ecx
addl %ecx, %eax
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x4a9b0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x4aa20
movq -0x18(%rbp), %rax
movb -0xa(%rbp), %cl
movq %rax, %rdi
movzbl %cl, %esi
movzbl 0x118(%rax), %edx
callq 0x4ab70
movq -0x18(%rbp), %rdi
movb 0x118(%rdi), %al
movzbl %al, %esi
movzbl -0xa(%rbp), %edx
callq 0x4abe0
movq -0x18(%rbp), %rax
movb -0xa(%rbp), %cl
movb %cl, 0x118(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/src/Instructions.cc
// Function: CPU::ADD(unsigned char)
void CPU::ADD(uint8_t u8) {                 // ADD A, u8
  uint8_t result = this->reg.A + u8;

  // Set Flags
  this->setZeroFlag(result == 0);     // Zero Flag
  this->setAddSubFlag(false);   // Unset N Flag
  this->checkHalfCarry(result, this->reg.A);
  this->checkCarry(this->reg.A, result);

  // New A Value
  this->reg.A = result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movzbl 0x118(%rdi), %eax
movzbl -0x9(%rbp), %ecx
addl %ecx, %eax
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x4a9b0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x4aa20
movq -0x18(%rbp), %rax
movb -0xa(%rbp), %cl
movq %rax, %rdi
movzbl %cl, %esi
movzbl 0x118(%rax), %edx
callq 0x4ab70
movq -0x18(%rbp), %rdi
movb 0x118(%rdi), %al
movzbl %al, %esi
movzbl -0xa(%rbp), %edx
callq 0x4abe0
movq -0x18(%rbp), %rax
movb -0xa(%rbp), %cl
movb %cl, 0x118(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/src/Instructions.cc
// Function: CPU::AND(unsigned char)
void CPU::AND(uint8_t u8) {                 // AND A, u8
  uint8_t result = this->reg.A & u8;

  // Set Flags
  this->setZeroFlag(result == 0);     // Zero Flag
  this->setAddSubFlag(false);   // Unset N Flag
  this->setHalfCarryFlag(true); // Set H Flag
  this->setCarryFlag(false);    // Unset C Flag

  // New A Value
  this->reg.A = result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movzbl 0x118(%rdi), %eax
movzbl -0x9(%rbp), %ecx
andl %ecx, %eax
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x4a9b0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x4aa20
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x4aa90
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x4ab00
movq -0x18(%rbp), %rax
movb -0xa(%rbp), %cl
movb %cl, 0x118(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/src/Instructions.cc
// Function: CPU::CP(unsigned char)
void CPU::CP(uint8_t u8) {                  // CP A, u8
  uint8_t result = this->reg.A - u8;

  // Set Flags
  this->setZeroFlag(result == 0);     // Zero Flag
  this->setAddSubFlag(true);  // Set N Flag
  this->checkHalfCarry(this->reg.A, result); // Set if borrow from bit 4
  this->checkCarry(u8, this->reg.A); // Set if borrow
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movzbl 0x118(%rdi), %eax
movzbl -0x9(%rbp), %ecx
subl %ecx, %eax
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x4a9b0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x4aa20
movq -0x18(%rbp), %rdi
movb 0x118(%rdi), %al
movzbl %al, %esi
movzbl -0xa(%rbp), %edx
callq 0x4ab70
movq -0x18(%rbp), %rax
movb -0x9(%rbp), %cl
movq %rax, %rdi
movzbl %cl, %esi
movzbl 0x118(%rax), %edx
callq 0x4abe0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/src/Instructions.cc
// Function: CPU::DEC(unsigned char*)
void CPU::DEC(uint8_t *r8) {                // DEC r8
  uint8_t result = *r8 - 1;

  // Set Flags
  this->setZeroFlag(result == 0);   // Zero Flag
  this->setAddSubFlag(true);  // Set N Flag
  this->checkHalfCarry(*r8, result); // Set if borrow from bit 4

  // New r8 value
  *r8 = result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
subl $0x1, %eax
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x4a9b0
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x4aa20
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movb (%rax), %al
movzbl %al, %esi
movzbl -0x11(%rbp), %edx
callq 0x4ab70
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/src/Instructions.cc
// Function: CPU::DEC(unsigned short)
void CPU::DEC(uint16_t a16) {               // DEC [HL]
  uint8_t result = this->memory.read(a16) - 1;

  // Set Flags
  this->setZeroFlag(result == 0);   // Zero Flag
  this->setAddSubFlag(true);  // Set N Flag
  this->checkHalfCarry(this->memory.read(a16), result); // Set if borrow from bit 4

  this->memory.write(a16, result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x130, %rdi            # imm = 0x130
movzwl -0xa(%rbp), %esi
callq 0xbc0c0
movq -0x18(%rbp), %rdi
movzbl %al, %eax
subl $0x1, %eax
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x4a9b0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x4aa20
movq -0x18(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movzwl -0xa(%rbp), %esi
callq 0xbc0c0
movq -0x18(%rbp), %rdi
movzbl %al, %esi
movzbl -0xb(%rbp), %edx
callq 0x4ab70
movq -0x18(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movw -0xa(%rbp), %ax
movzwl %ax, %esi
movzbl -0xb(%rbp), %edx
callq 0xbc150
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/src/Instructions.cc
// Function: CPU::INC(unsigned char*)
void CPU::INC(uint8_t *r8) {                // INC r8
  uint8_t result = *r8 + 1;

  // Set Flags
  this->setZeroFlag(result == 0);   // Zero Flag
  this->setAddSubFlag(false);       // Unset N Flag
  this->checkHalfCarry(*r8, result);     // Set if overflow from bit 3

  // New r8 value
  *r8 = result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
addl $0x1, %eax
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x4a9b0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x4aa20
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movb (%rax), %al
movzbl %al, %esi
movzbl -0x11(%rbp), %edx
callq 0x4ab70
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/src/Instructions.cc
// Function: CPU::INC(unsigned short)
void CPU::INC(uint16_t a16) {               // INC [HL]
  uint8_t result = this->memory.read(a16) + 1;

  // Set Flags
  this->setZeroFlag(result == 0);   // Zero Flag
  this->setAddSubFlag(false);  // Unset N Flag
  this->checkHalfCarry(this->memory.read(a16), result); // Set if overflow from bit 3

  this->memory.write(a16, result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x130, %rdi            # imm = 0x130
movzwl -0xa(%rbp), %esi
callq 0xbc0c0
movq -0x18(%rbp), %rdi
movzbl %al, %eax
addl $0x1, %eax
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x4a9b0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x4aa20
movq -0x18(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movzwl -0xa(%rbp), %esi
callq 0xbc0c0
movq -0x18(%rbp), %rdi
movzbl %al, %esi
movzbl -0xb(%rbp), %edx
callq 0x4ab70
movq -0x18(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movw -0xa(%rbp), %ax
movzwl %ax, %esi
movzbl -0xb(%rbp), %edx
callq 0xbc150
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/src/Instructions.cc
// Function: CPU::OR(unsigned char)
void CPU::OR(uint8_t u8) {                  // OR A, u8
  uint8_t result = this->reg.A | u8;

  // Set Flags
  this->reg.F = 0x00;                // Reset Flags
  this->setZeroFlag(result == 0);     // Zero Flag

  this->reg.A = result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movzbl 0x118(%rdi), %eax
movzbl -0x9(%rbp), %ecx
orl %ecx, %eax
movb %al, -0xa(%rbp)
movb $0x0, 0x11d(%rdi)
movzbl -0xa(%rbp), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x4a9b0
movq -0x18(%rbp), %rax
movb -0xa(%rbp), %cl
movb %cl, 0x118(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)