LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/src/disasm.cc
// Function: Disassembler::checkDW[abi:cxx11](unsigned short, unsigned short)
std::string Disassembler::checkDW(uint16_t cur, uint16_t prev) {
  uint32_t addr = (cur << 16) + prev;
  std::string ret = symbols[addr];
  if (ret.empty()) {
    addr = (prev << 16) + cur;
    ret = symbols[addr];
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
shll $0x10, %ebp
orl %ecx, %ebp
leaq 0xc(%rsp), %rsi
movl %ebp, (%rsi)
movq %r14, %rdi
callq 0x95ac
movq %rbx, %rdi
movq %rax, %rsi
callq 0x52c0
cmpq $0x0, 0x8(%rbx)
jne 0xc517
roll $0x10, %ebp
leaq 0xc(%rsp), %rsi
movl %ebp, (%rsi)
movq %r14, %rdi
callq 0x95ac
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5170
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5140
movq %r14, %rdi
callq 0x53c0
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/src/api.cc
// Function: Fingerprints::add(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned char)
void Fingerprints::add(const std::vector<uint8_t> &keys, std::string name,
                       uint8_t numDB) {
  auto node = root;
  for (auto key : keys) {
    if (node->map.find(key) == node->map.end()) {
      node->map.insert(std::pair<uint8_t, std::shared_ptr<Fingerprint>>
                       (key, std::make_shared<Fingerprint>()));
    }
    node = node->map[key];
  }
  node->name = name;
  node->numDB = numDB;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, 0x38(%rsp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0xecce
movq (%rbx), %r13
movq 0x8(%rbx), %rbx
leaq 0xb(%rsp), %rbp
leaq 0x40(%rsp), %r14
cmpq %rbx, %r13
je 0xd285
movb (%r13), %al
movb %al, 0xb(%rsp)
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0xef70
movq 0x10(%rsp), %r15
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
jne 0xd267
leaq 0x20(%rsp), %rdi
callq 0xea57
movb 0xb(%rsp), %al
movb %al, 0x40(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x48(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0xefc2
leaq 0x50(%rsp), %rdi
callq 0x61e4
leaq 0x28(%rsp), %rdi
callq 0x61e4
movq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0xea72
movq %r12, %rdi
movq %rax, %rsi
callq 0xece2
incq %r13
jmp 0xd1f3
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movq 0x38(%rsp), %rsi
callq 0x5170
leaq 0x18(%rsp), %rdi
movq -0x8(%rdi), %rax
movl 0xc(%rsp), %ecx
movb %cl, 0x30(%rax)
callq 0x61e4
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd2db
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x61e4
leaq 0x28(%rsp), %rdi
callq 0x61e4
jmp 0xd2de
jmp 0xd2db
jmp 0xd2db
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x61e4
movq %rbx, %rdi
callq 0x53c0
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/src/api.cc
// Function: API::setIntrinsic(std::shared_ptr<TheHandle>, std::shared_ptr<symbol::Symbol>)
void API::setIntrinsic(Handle h, std::shared_ptr<symbol::Symbol> s) {
  auto i = std::static_pointer_cast<symbol::Intrinsic>(s);
  auto type = h->r8();
  switch (type) {
    case symbol::Intrinsic::U8:
      i->type = symbol::Intrinsic::U8;
      break;
    case symbol::Intrinsic::U16:
      i->type = symbol::Intrinsic::U16;
      break;
    case symbol::Intrinsic::U32:
      i->type = symbol::Intrinsic::U32;
      break;
    case symbol::Intrinsic::S8:
      i->type = symbol::Intrinsic::S8;
      break;
    case symbol::Intrinsic::S16:
      i->type = symbol::Intrinsic::S16;
      break;
    case symbol::Intrinsic::S32:
      i->type = symbol::Intrinsic::S32;
      break;
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xebae
movq (%rbx), %rdi
callq 0x8966
cmpb $0x6, %al
jae 0xd963
movzbl %al, %eax
movq (%rsp), %rcx
movl %eax, 0x28(%rcx)
leaq 0x8(%rsp), %rdi
callq 0x61e4
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61e4
movq %rbx, %rdi
callq 0x53c0
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/src/api.cc
// Function: API::setEnum(std::shared_ptr<TheHandle>, std::shared_ptr<symbol::Symbol>)
void API::setEnum(Handle h, std::shared_ptr<symbol::Symbol> s) {
  auto e = std::static_pointer_cast<symbol::Enum>(s);
  e->type = lookup(h->r32());
  auto num = h->r32();
  for (uint32_t i = 0; i < num; i++) {
    auto value = h->r32();
    e->entries[h->rs()] = value;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xebca
movq (%rbx), %rdi
callq 0x88ce
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xe0a6
movq (%rsp), %rdi
addq $0x28, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1012c
leaq 0x18(%rsp), %rdi
callq 0x61e4
movq (%rbx), %rdi
callq 0x88ce
movl %eax, %ebp
leaq 0x10(%rsp), %r14
subl $0x1, %ebp
jb 0xda22
movq (%rbx), %rdi
callq 0x88ce
movl %eax, %r15d
movq (%rsp), %r12
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x8976
addq $0x38, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xebe6
movl %r15d, (%rax)
movq %r14, %rdi
callq 0x5140
jmp 0xd9e7
leaq 0x8(%rsp), %rdi
callq 0x61e4
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xda3f
jmp 0xda3f
jmp 0xda3f
movq %rax, %rbx
jmp 0xda51
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5140
leaq 0x8(%rsp), %rdi
callq 0x61e4
movq %rbx, %rdi
callq 0x53c0
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/src/api.cc
// Function: API::setRef(std::shared_ptr<TheHandle>, std::shared_ptr<symbol::Symbol>)
void API::setRef(Handle h, std::shared_ptr<symbol::Symbol> s) {
  auto r = std::static_pointer_cast<symbol::Ref>(s);
  auto id = h->r32();
  if (id == 0) {
    r->symbol = nullptr;
  } else {
    r->symbol = lookup(id);
    r->pointer = h->r32();
    r->array = static_cast<int32_t>(h->r32());
    r->reg = h->rs();
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xec4c
movq (%rbx), %rdi
callq 0x88ce
testl %eax, %eax
je 0xdafd
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xe0a6
movq (%rsp), %rdi
addq $0x28, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1012c
leaq 0x18(%rsp), %rdi
callq 0x61e4
movq (%rbx), %rdi
callq 0x88ce
movq (%rsp), %rcx
movl %eax, 0x38(%rcx)
movq (%rbx), %rdi
callq 0x88ce
movq (%rsp), %rcx
movl %eax, 0x3c(%rcx)
movq (%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x8976
movq (%rsp), %rdi
addq $0x40, %rdi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x5250
movq %rbx, %rdi
callq 0x5140
jmp 0xdb1f
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq (%rsp), %rdi
addq $0x28, %rdi
callq 0x1012c
leaq 0x18(%rsp), %rdi
callq 0x61e4
leaq 0x8(%rsp), %rdi
callq 0x61e4
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0xdb35
jmp 0xdb35
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61e4
movq %rbx, %rdi
callq 0x53c0
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/src/api.cc
// Function: API::setFunction(std::shared_ptr<TheHandle>, std::shared_ptr<symbol::Symbol>)
void API::setFunction(Handle h, std::shared_ptr<symbol::Symbol> s) {
  auto f = std::static_pointer_cast<symbol::Function>(s);
  auto numArgs = h->r32();
  for (uint32_t i = 0; i < numArgs; i++) {
    auto key = h->rs();
    auto ref = std::make_shared<symbol::Ref>();
    setRef(h, ref);
    f->arguments.push_back({key, ref});
  }
  f->returnType = std::make_shared<symbol::Ref>();
  setRef(h, f->returnType);
  auto numSig = h->r32();
  for (uint32_t i = 0; i < numSig; i++) {
    f->signature.push_back(static_cast<int32_t>(h->r32()));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x6055
movq %rbx, 0x8(%rsp)
movq (%rbx), %rdi
callq 0x88ce
movl %eax, %ebp
leaq 0xa8(%rsp), %r13
leaq 0x68(%rsp), %rbx
subl $0x1, %ebp
jb 0xdf5c
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq %r13, %rdi
callq 0x8976
movq %rbx, %rdi
callq 0xeaf6
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x67fc
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %rbx, %r15
movq %rbx, %rsi
callq 0x10714
movq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xda64
leaq 0x50(%rsp), %rdi
callq 0x61e4
leaq 0x60(%rsp), %rdi
callq 0x61e4
movq 0x10(%rsp), %r14
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x52c0
addq $0x28, %r14
leaq 0x98(%rsp), %rdi
movq %r15, %rsi
callq 0xed1a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10728
movq %rbx, %rdi
callq 0xec9a
leaq 0x70(%rsp), %rdi
callq 0x61e4
movq %r13, %rdi
callq 0x5140
movq %r15, %rbx
jmp 0xde9c
leaq 0x78(%rsp), %rdi
callq 0xeaf6
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
leaq 0x78(%rsp), %rsi
callq 0x1093e
leaq 0x80(%rsp), %rdi
callq 0x61e4
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x67fc
movq 0x10(%rsp), %rsi
addq $0x40, %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x10714
movq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xda64
leaq 0x30(%rsp), %rdi
callq 0x61e4
leaq 0x40(%rsp), %rdi
callq 0x61e4
movq (%rbx), %rdi
callq 0x88ce
movl %eax, %ebp
leaq 0x78(%rsp), %r14
subl $0x1, %ebp
jb 0xe00b
movq 0x10(%rsp), %r15
movq (%rbx), %rdi
callq 0x88ce
addq $0x50, %r15
movl %eax, 0x78(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1096c
jmp 0xdfe4
leaq 0x18(%rsp), %rdi
callq 0x61e4
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe091
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x61e4
leaq 0x40(%rsp), %rdi
callq 0x61e4
jmp 0xe094
jmp 0xe091
jmp 0xe091
movq %rax, %rbx
jmp 0xe080
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x61e4
leaq 0x60(%rsp), %rdi
callq 0x61e4
jmp 0xe076
movq %rax, %rbx
jmp 0xe076
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xec9a
leaq 0x70(%rsp), %rdi
callq 0x61e4
leaq 0xa8(%rsp), %rdi
callq 0x5140
jmp 0xe094
jmp 0xe091
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x61e4
movq %rbx, %rdi
callq 0x53c0
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/src/api.cc
// Function: API::search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
void API::search(std::string keyword, uint32_t org) {
  for (auto &s : symbols) {
    auto it = std::search(s.first.begin(), s.first.end(),
                          keyword.begin(), keyword.end(),
                          [](char a, char b) {
                            return std::toupper(a) == std::toupper(b);
                          });
    if (it != s.first.end()) {
      dumpSymbol(s.second, org);
      printf("\n");
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0x4(%rsp)
movq 0x18(%rdi), %rcx
movq %rdi, 0x10(%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq 0x20(%rsp), %rcx
je 0xe20e
movq 0x20(%rcx), %r12
movq %rcx, 0x8(%rsp)
movq 0x28(%rcx), %rcx
leaq (%r12,%rcx), %r14
movq 0x8(%rsi), %rax
testq %rcx, %rcx
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0xe1b7
movq (%rsi), %rbp
cmpq $0x1, %rax
jne 0xe157
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xe937
movq %rax, %r12
jmp 0xe1b7
pushq $0x2
popq %r15
subq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xe937
cmpq %r14, %rax
je 0xe1f7
movq %rax, %rbx
leaq 0x1(%rax), %r12
cmpq %r14, %r12
je 0xe1f7
pushq $0x1
popq %r13
movsbl (%rbx,%r13), %edi
movsbl (%rbp,%r13), %esi
callq 0xea38
testb %al, %al
je 0xe15e
leaq (%r15,%r13), %rax
cmpq $0x1, %rax
je 0xe1b4
leaq (%rbx,%r13), %rax
incq %rax
incq %r13
cmpq %r14, %rax
jne 0xe185
jmp 0xe1f7
movq %rbx, %r12
cmpq %r14, %r12
je 0xe1f7
movq 0x8(%rsp), %rax
leaq 0x40(%rax), %rsi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x61a4
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl 0x4(%rsp), %edx
xorl %ecx, %ecx
callq 0xe232
leaq 0x30(%rsp), %rdi
callq 0x61e4
pushq $0xa
popq %rdi
callq 0x52d0
movq 0x8(%rsp), %rdi
callq 0x5190
movq %rax, %rcx
movq 0x18(%rsp), %rsi
jmp 0xe10b
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x61e4
movq %rbx, %rdi
callq 0x53c0
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/src/api.cc
// Function: API::dumpRef(std::shared_ptr<symbol::Ref>)
void API::dumpRef(std::shared_ptr<symbol::Ref> ref) {
  for (int i = 0; i < ref->pointer; i++) {
    printf("^");
  }
  printf("%s", ref->symbol->name.c_str());
  if (ref->array > 0) {
    printf("[%d]", ref->array);
  } else if (ref->array == 0) {
    printf("[]");
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %r14d, %r14d
pushq $0x5e
popq %rbp
movq (%rbx), %rax
cmpl 0x38(%rax), %r14d
jae 0xe8c0
movl %ebp, %edi
callq 0x52d0
incl %r14d
jmp 0xe8ab
movq 0x28(%rax), %rax
movq (%rax), %rsi
leaq 0x62fc(%rip), %rdi      # 0x14bca
xorl %eax, %eax
callq 0x5050
movq (%rbx), %rax
movl 0x3c(%rax), %esi
testl %esi, %esi
jle 0xe8f1
leaq 0x62e7(%rip), %rdi      # 0x14bcd
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x5050
je 0xe8f8
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x62d3(%rip), %rdi      # 0x14bd2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x5050
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/src/scanner.cc
// Function: Scanner::getAddress(unsigned int)
Handle Scanner::getAddress(uint32_t address) {
  for (auto &s : segments) {
    if (address >= s.mapped && address < s.mapped + s.length) {
      s.data->seek(address - s.mapped);
      return s.data;
    }
  }
  return nullptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rsi), %r14
movq 0x38(%rsi), %rax
addq $0x50, %r14
leaq -0x50(%r14), %rcx
cmpq %rax, %rcx
je 0x1110f
movl 0x60(%rcx), %ecx
movl %edx, %esi
subl %ecx, %esi
jb 0x11109
addl -0x48(%r14), %ecx
cmpl %edx, %ecx
ja 0x11117
addq $0x68, %r14
jmp 0x110ef
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x1112a
movq (%r14), %rdi
callq 0x8a68
movq %rbx, %rdi
movq %r14, %rsi
callq 0x67fc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/src/scanner.cc
// Function: Scanner::hex[abi:cxx11](unsigned int, unsigned long)
std::string Scanner::hex(uint32_t value, size_t len) {
  static const char *digits = "0123456789abcdef";
  if (len == 6) {
    std::string ret="00/0000";
    for (size_t i = 0, j = 5 << 2; i < 6; i++, j -= 4) {
      ret[i < 2 ? i : i + 1] = digits[(value >> j) & 0xf];
    }
    return ret;
  }
  std::string ret(len, '0');
  for (size_t i = 0, j = (len - 1) << 2; i < len; i++, j -= 4) {
    ret[i] = digits[(value >> j) & 0xf];
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
cmpq $0x6, %rcx
jne 0x11196
leaq 0x31f3(%rip), %rsi      # 0x14343
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x5fd6
pushq $0x14
popq %rcx
pushq $0x1
popq %rax
leaq 0x31c7(%rip), %rdx      # 0x14331
cmpq $0x7, %rax
je 0x111de
leaq -0x1(%rax), %rsi
movl %ebp, %edi
shrl %cl, %edi
andl $0xf, %edi
movb (%rdi,%rdx), %dil
cmpq $0x2, %rsi
cmovaeq %rax, %rsi
movq (%rbx), %r8
movb %dil, (%r8,%rsi)
addl $-0x4, %ecx
incq %rax
jmp 0x1116a
movq %rcx, %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
pushq $0x30
popq %rdx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x5240
leal -0x4(,%r14,4), %ecx
xorl %eax, %eax
leaq 0x3172(%rip), %rdx      # 0x14331
cmpq %rax, %r14
je 0x111de
movl %ebp, %esi
shrl %cl, %esi
andl $0xf, %esi
movb (%rsi,%rdx), %sil
movq (%rbx), %rdi
movb %sil, (%rdi,%rax)
incq %rax
addl $-0x4, %ecx
jmp 0x111bf
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mrkite[P]regs/src/scanner.cc
// Function: Scanner::getBlock(unsigned int)
std::shared_ptr<Block> Scanner::getBlock(uint32_t address) {
  auto res = std::find_if(blocks.begin(), blocks.end(),
                          [address](const std::shared_ptr<Block> n) {
                            return n->address == address;
                          });
  if (res != blocks.end()) {
    return *res;
  }
  auto block = std::make_shared<Block>(address);
  block->branchLen = 0;
  block->length = 0;
  blocks.push_back(block);
  return block;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movl %edx, 0x14(%rsp)
leaq 0xb8(%rsi), %rax
movq %rax, 0x20(%rsp)
movq 0xb8(%rsi), %r12
movq 0xc0(%rsi), %rbx
leaq 0x10(%rsp), %r13
movl %edx, (%r13)
movq %rbx, 0x18(%rsp)
subq %r12, %rbx
movq %rbx, %r14
sarq $0x6, %r14
testq %r14, %r14
jle 0x11611
movq %r13, %rdi
movq %r12, %rsi
callq 0x11dd6
testb %al, %al
jne 0x11643
leaq 0x10(%r12), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x11dd6
testb %al, %al
jne 0x1166f
leaq 0x20(%r12), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x11dd6
testb %al, %al
jne 0x1166f
leaq 0x30(%r12), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x11dd6
testb %al, %al
jne 0x1166f
addq $0x40, %r12
decq %r14
addq $-0x40, %rbx
jmp 0x115b0
sarq $0x4, %rbx
cmpq $0x1, %rbx
je 0x11663
cmpq $0x2, %rbx
je 0x11648
cmpq $0x3, %rbx
jne 0x1166a
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x11dd6
testb %al, %al
movq 0x8(%rsp), %rbx
jne 0x1165e
addq $0x10, %r12
jmp 0x1164d
movq %r12, %rbp
jmp 0x1166f
movq 0x8(%rsp), %rbx
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x11dd6
testb %al, %al
je 0x116be
movq %r12, %rbp
jmp 0x11674
movq 0x8(%rsp), %rbx
jmp 0x116c2
movq 0x18(%rsp), %rbp
movq 0x8(%rsp), %rbx
cmpq 0xc0(%r15), %rbp
je 0x1168a
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x12042
jmp 0x116ac
leaq 0x14(%rsp), %rsi
movq %rbx, %rdi
callq 0x11f80
movq (%rbx), %rax
andq $0x0, 0x4(%rax)
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x11f3c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x10, %r12
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x11dd6
testb %al, %al
movq 0x18(%rsp), %rbp
cmovneq %r12, %rbp
jmp 0x11674
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x61e4
movq %r14, %rdi
callq 0x53c0
// File: /workspace/github_c_makefile_star2_O2/openshmem-org[P]openshmem-examples/c/collect32.c
// Function: main
int
main(void)
{
    int i;

    shmem_init();
    npes = shmem_n_pes();
    me = shmem_my_pe();

    for (i = 0; i < DST_SIZE; i++) {
        dst[i] = -1;
    }

    for (i = 0; i < SHMEM_BCAST_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }

    shmem_barrier_all();

    if (me < 4) {
        shmem_collect32(dst, src, me + 1, 0, 0, 4, pSync);
        show_dst("AFTER");
    }

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
callq 0x10a0
callq 0x1050
movl %eax, 0x2ecb(%rip)      # 0x4090
callq 0x1070
movl %eax, 0x2ec4(%rip)      # 0x4094
xorl %eax, %eax
leaq 0x2ec7(%rip), %rbx      # 0x40a0
cmpq $0x50, %rax
je 0x11e9
orl $-0x1, (%rax,%rbx)
addq $0x4, %rax
jmp 0x11d9
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, 0x2efb(%rip)     # 0x40f0
callq 0x1090
movslq 0x2e93(%rip), %rdx      # 0x4094
cmpq $0x3, %rdx
jg 0x127a
incq %rdx
leaq 0x2edf(%rip), %rax      # 0x40f0
movq %rax, (%rsp)
leaq 0x2e54(%rip), %rsi      # 0x4070
pushq $0x4
popq %r9
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1080
movl 0x2e61(%rip), %edx      # 0x4094
movl 0x2e57(%rip), %ecx      # 0x4090
leaq 0xdca(%rip), %rdi       # 0x200a
leaq 0xdbd(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1030
leaq 0xdc7(%rip), %r14       # 0x201c
xorl %r15d, %r15d
cmpq $0x50, %r15
je 0x1272
movl (%r15,%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
addq $0x4, %r15
jmp 0x1258
pushq $0xa
popq %rdi
callq 0x1040
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/designer/designer.cpp
// Function: Designer::TimerProc()
void Designer::TimerProc()
{
	Designer_EditComponent	*object;
	Bool			 mouseOnWindow = False;

	for (Int i = 0; i < dlgs.Length(); i++)
	{
		object = dlgs.GetNth(i);

		Point	 mousePos = object->GetWindow()->GetMousePosition();

		if (mousePos.x > 0 && mousePos.y > 0 && mousePos.x < object->GetWindow()->GetWidth() && mousePos.y < object->GetWindow()->GetHeight())
		{
			mouseOnWindow = True;

			break;
		}
	}

	if (!mouseOnWindow && (statusbar->GetText() != "Ready")) statusbar->SetText("Ready");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x660(%rdi), %r14
xorl %ebp, %ebp
cmpl 0x668(%rbx), %ebp
jge 0x4d5e
movq %r14, %rdi
movl %ebp, %esi
callq 0x6102
movq (%rax), %r15
movq %r15, %rdi
callq 0x6624
movq %rax, %rdi
callq 0x4130
movq %rax, %r12
movq %rax, %r13
shrq $0x20, %r13
testl %r12d, %r12d
setg %al
testl %r13d, %r13d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4d5a
movq %r15, %rdi
callq 0x6624
cmpl %r12d, 0xb0(%rax)
jle 0x4d5a
movq %r15, %rdi
callq 0x6624
cmpl %r13d, 0xb4(%rax)
jg 0x4db1
incl %ebp
jmp 0x4cf6
movq 0x5d8(%rbx), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
leaq 0x22f2(%rip), %rsi      # 0x7067
movq %rax, %rdi
callq 0x4230
testb %al, %al
je 0x4db1
movq 0x5d8(%rbx), %rbx
leaq 0x22d8(%rip), %rsi      # 0x7067
movq %rsp, %r14
movq %r14, %rdi
callq 0x4350
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x4200
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4200
movq %rbx, %rdi
callq 0x4150
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/designer/designer.cpp
// Function: Designer::ExitProc()
Bool Designer::ExitProc()
{
	for (Int i = 0; i < dlgs.Length(); i++)
	{
		delete dlgs.GetNth(i);
	}

	dlgs.RemoveAll();

	return True;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x660(%rdi), %rbx
xorl %ebp, %ebp
cmpl 0x668(%r14), %ebp
jge 0x4f4f
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6102
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4f4b
movq (%rdi), %rax
callq *0x10(%rax)
incl %ebp
jmp 0x4f2a
movq %rbx, %rdi
callq 0x557e
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/designer/designer.cpp
// Function: Designer::~Designer()
Designer::~Designer()
{
	timer1->Stop();

	DeleteObject(title);
	DeleteObject(wnd);
	DeleteObject(menubar);
	DeleteObject(iconbar);
	DeleteObject(statusbar);
	DeleteObject(timer1);

	delete menu_file;
	delete menu_dialog;
	delete menu_widgets;
	delete menu_widgets_add;
	delete menu_widgets_add_smooth;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x574f(%rip), %rax      # 0xa6b8
movq %rax, (%rdi)
movq 0x608(%rdi), %rdi
callq 0x41a0
movq 0x5c0(%rbx), %rdi
callq 0x43c0
movq 0x5b8(%rbx), %rdi
callq 0x43c0
movq 0x5c8(%rbx), %rdi
callq 0x43c0
movq 0x5d0(%rbx), %rdi
callq 0x43c0
movq 0x5d8(%rbx), %rdi
callq 0x43c0
movq 0x608(%rbx), %rdi
callq 0x43c0
movq 0x5e0(%rbx), %rdi
testq %rdi, %rdi
je 0x4fd2
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x5e8(%rbx), %rdi
testq %rdi, %rdi
je 0x4fe4
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x5f0(%rbx), %rdi
testq %rdi, %rdi
je 0x4ff6
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x5f8(%rbx), %rdi
testq %rdi, %rdi
je 0x5008
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x600(%rbx), %rdi
testq %rdi, %rdi
je 0x501a
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x660(%rbx), %rdi
callq 0x5546
leaq 0x628(%rbx), %rdi
callq 0x4200
movq %rbx, %rdi
popq %rbx
jmp 0x4220
movq %rax, %rdi
callq 0x5573
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/tools/designer/edit_component.cpp
// Function: Designer_EditComponent::AddObject(short)
Widget *Designer_EditComponent::AddObject(Short objid)
{
	Widget	*newobj;
	Widget	*registrar;
	Point	 pos;
	Size	 size;

	switch (objid)
	{
		case SMOOTH_BUTTON:
			registrar = wnd;

			pos.x	  = 100;
			pos.y	  = 100;
			size.cx	  = 0;
			size.cy	  = 0;

			newobj	  = new Button("Button", pos, size);

			break;
		case SMOOTH_LAYER:
			registrar = wnd;
			newobj	  = new Layer("Layer");

			break;
		case SMOOTH_MENUBAR:
			registrar = wnd;
			newobj	  = new Menubar();

			break;
		default:
			QuickMessage("Unknown object ID!", "Error", Message::Buttons::Ok, Message::Icon::Error);

			return NIL;
	}

	registrar->Add(newobj);

	objects.Add(newobj);

	return newobj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
andq $0x0, 0x30(%rsp)
andq $0x0, 0x28(%rsp)
cmpl $0x3, %esi
je 0x66d0
cmpl $0x2, %esi
je 0x66ad
cmpl $0x1, %esi
jne 0x6739
movq 0x5b8(%r14), %r15
movabsq $0x6400000064, %rax     # imm = 0x6400000064
movq %rax, 0x30(%rsp)
andl $0x0, 0x2c(%rsp)
movl $0x5c8, %edi            # imm = 0x5C8
callq 0x4250
movq %rax, %rbx
leaq 0xa14(%rip), %rsi       # 0x709e
leaq 0x8(%rsp), %rdi
callq 0x4350
leaq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x4190
jmp 0x6702
movq 0x5b8(%r14), %r15
movl $0x688, %edi            # imm = 0x688
callq 0x4250
movq %rax, %rbx
movq %rax, %rdi
callq 0x4140
movq %rbx, 0x20(%rsp)
jmp 0x6711
movq 0x5b8(%r14), %r15
movl $0x5b8, %edi            # imm = 0x5B8
callq 0x4250
movq %rax, %rbx
leaq 0x9ba(%rip), %rsi       # 0x70a5
leaq 0x8(%rsp), %rdi
callq 0x4350
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4100
movq %rbx, 0x20(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x4200
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
addq $0x5c8, %r14            # imm = 0x5C8
leaq 0x20(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c74
movq (%rbx), %rax
jmp 0x6787
leaq 0xb20(%rip), %rsi       # 0x7260
leaq 0x8(%rsp), %rdi
callq 0x4350
leaq 0xb22(%rip), %rsi       # 0x7273
leaq 0x38(%rsp), %rdi
callq 0x4350
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
xorl %edx, %edx
movl $0x7f01, %ecx           # imm = 0x7F01
callq 0x41c0
leaq 0x38(%rsp), %rdi
callq 0x4200
leaq 0x8(%rsp), %rdi
callq 0x4200
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x4200
jmp 0x67c1
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4200
jmp 0x67d0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4200
jmp 0x67da
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4200
jmp 0x67f1
movq %rax, %r14
movl $0x5c8, %esi            # imm = 0x5C8
jmp 0x67e9
movq %rax, %r14
movl $0x5b8, %esi            # imm = 0x5B8
jmp 0x67e9
movq %rax, %r14
movl $0x688, %esi            # imm = 0x688
movq %rbx, %rdi
callq 0x4050
movq %r14, %rdi
callq 0x4150
nop
// File: /workspace/github_c_makefile_star2_O2/truenas[P]binaries/src/plx_eeprom.c
// Function: plx_eeprom_read
static uint32_t
plx_eeprom_read(void *mem, u_int addr)
{
	uint32_t val;

	if ((addr > 0x00ffffff) || (addr & 0x3) != 0)
		errx(EX_OSERR, "Incorrect EEPROM address %x", addr);

	/* Write address byte 3. */
	val = read4(mem, 0x26c);
	write4(mem, 0x26c, (val & ~0xff) | (addr >> 24));

	/* Initiate read. */
	addr >>= 2;
	val = read4(mem, 0x260);
	val &= 0xffe00000;
	val |= ((addr & 0x2000) << 7) | (3 << 13) | (addr & 0x1fff);
	write4(mem, 0x260, val);

	/* Wait for completion. */
	val = 100;
	while ((read4(mem, 0x260) & 0x40000) != 0 && val > 0) {
		usleep(100);
		val--;
	}
	if (val == 0)
		errx(EX_OSERR, "EEPROM write timeout");

	/* Read result. */
	val = read4(mem, 0x264);
	return (val);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %edx
testl $0xff000003, %esi       # imm = 0xFF000003
jne 0x17fe
movq %rdi, %rbx
andl $0xffffff00, 0x26c(%rdi) # imm = 0xFFFFFF00
movl %edx, %eax
shrl $0x2, %eax
movl $0xffe00000, %ecx       # imm = 0xFFE00000
andl 0x260(%rdi), %ecx
shll $0x5, %edx
andl $0x100000, %edx         # imm = 0x100000
andl $0x1fff, %eax           # imm = 0x1FFF
orl %edx, %eax
addl %ecx, %eax
addl $0x6000, %eax           # imm = 0x6000
movl %eax, 0x260(%rdi)
pushq $-0x64
popq %r14
pushq $0x64
popq %rbp
btl $0x12, 0x260(%rbx)
jae 0x17ee
testl %r14d, %r14d
je 0x17ee
movl %ebp, %edi
callq 0x1150
incl %r14d
jmp 0x17d3
testl %r14d, %r14d
je 0x180f
movl 0x264(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8cc(%rip), %rsi       # 0x20d1
pushq $0x47
popq %rdi
xorl %eax, %eax
callq 0x1070
leaq 0x8d7(%rip), %rsi       # 0x20ed
pushq $0x47
popq %rdi
xorl %eax, %eax
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/truenas[P]binaries/src/plx_eeprom.c
// Function: plx_config_print
static void
plx_config_print(char *buf, int n)
{
	int i, r, port, error;
	uint32_t val;

	printf("   #\tPort\tReg\tValue\n");
	printf("--------------------------------\n");
	n /= 6;
	for (i = 0; i < n; i++) {
		printf(" %3d\t", i);
		val = le16dec(&buf[i * 6]);
		port = val >> 10;
		if ((port & 0x38) == 0x20)
			printf("A-LUT %d", port & 0x3);
		else if (port == 0x2c)
			printf("DMA RAM");
		else if ((port & 0x38) == 0x28)
			printf("DMA %d", port & 0x7);
		else if ((port & 0x38) == 0x30)
			printf("S%dP0", port & 0x7);
		else if ((port & 0x38) == 0x38)
			printf("NT%d %c", (port >> 1) & 0x1,
			    (port & 0x1) ? 'V' : 'L');
		else
			printf("%d", port);
		printf("\t%03x\t%08x\n",
		    (val & 0x3ff) * 4, le32dec(&buf[i * 6] + 2));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x99b(%rip), %rdi       # 0x21d2
callq 0x1040
leaq 0x9a3(%rip), %rdi       # 0x21e6
callq 0x1040
pushq $0x6
popq %rcx
movl %ebp, %eax
xorl %edx, %edx
divl %ecx
movl %eax, %r14d
addq $0x2, %rbx
leaq 0x8f8(%rip), %r15       # 0x2157
leaq 0x91d(%rip), %r13       # 0x2183
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x1935
movq %r15, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1080
movzwl -0x2(%rbx), %r12d
movl %r12d, %esi
shrl $0xa, %esi
movl %esi, %eax
andl $-0x8, %eax
cmpl $0x20, %eax
jne 0x18a5
andl $0x3, %esi
leaq 0x8c1(%rip), %rdi       # 0x215d
xorl %eax, %eax
callq 0x1080
jmp 0x18b8
cmpl $0x2c, %esi
jne 0x18db
leaq 0x8b5(%rip), %rdi       # 0x2166
xorl %eax, %eax
callq 0x1080
shll $0x2, %r12d
andl $0xffc, %r12d           # imm = 0xFFC
movl (%rbx), %edx
movq %r13, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x1080
incq %rbp
addq $0x6, %rbx
jmp 0x1868
cmpl $0x38, %eax
je 0x1902
cmpl $0x30, %eax
je 0x18f6
cmpl $0x28, %eax
jne 0x1929
andl $0x7, %esi
leaq 0x87a(%rip), %rdi       # 0x216e
jmp 0x189c
andl $0x7, %esi
leaq 0x875(%rip), %rdi       # 0x2175
jmp 0x189c
movl %r12d, %esi
shrl $0xb, %esi
andl $0x1, %esi
btl $0xa, %r12d
pushq $0x56
popq %rdx
pushq $0x4c
popq %rax
cmovael %eax, %edx
leaq 0x85b(%rip), %rdi       # 0x217b
xorl %eax, %eax
callq 0x1080
jmp 0x18b8
leaq 0x842(%rip), %rdi       # 0x2172
jmp 0x189c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/orangeduck[P]mpc/examples/doge.c
// Function: main
int main(int argc, char **argv) {

  mpc_result_t r;
  
  mpc_parser_t* Adjective = mpc_new("adjective");
  mpc_parser_t* Noun      = mpc_new("noun");
  mpc_parser_t* Phrase    = mpc_new("phrase");
  mpc_parser_t* Doge      = mpc_new("doge");

  mpca_lang(MPCA_LANG_DEFAULT,
    " adjective : \"wow\" | \"many\" | \"so\" | \"such\";                 "
    " noun      : \"lisp\" | \"language\" | \"c\" | \"book\" | \"build\"; "
    " phrase    : <adjective> <noun>;                                     "
    " doge      : /^/ <phrase>* /$/;                                      ",
    Adjective, Noun, Phrase, Doge, NULL);
  
  if (argc > 1) {
    
    if (mpc_parse_contents(argv[1], Doge, &r)) {
      mpc_ast_print(r.output);
      mpc_ast_delete(r.output);
    } else {
      mpc_err_print(r.error);
      mpc_err_delete(r.error);
    }
  
  } else {

    if (mpc_parse_pipe("<stdin>", stdin, Doge, &r)) {
      mpc_ast_print(r.output);
      mpc_ast_delete(r.output);
    } else {
      mpc_err_print(r.error);
      mpc_err_delete(r.error);
    }
  
  }

  mpc_cleanup(4, Adjective, Noun, Phrase, Doge);
  
  return 0;
  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movl %edi, %ebp
leaq 0x7cce(%rip), %rdi      # 0x9004
callq 0x2bc6
movq %rax, %rbx
leaq 0x7cc9(%rip), %rdi      # 0x900e
callq 0x2bc6
movq %rax, %r14
leaq 0x7cbf(%rip), %rdi      # 0x9013
callq 0x2bc6
movq %rax, %r15
leaq 0x7cb7(%rip), %rdi      # 0x901a
callq 0x2bc6
movq %rax, %r12
andq $0x0, (%rsp)
leaq 0x7ca8(%rip), %rsi      # 0x901f
xorl %edi, %edi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x714a
cmpl $0x2, %ebp
jl 0x13a7
movq 0x8(%r13), %rdi
leaq 0x10(%rsp), %r13
movq %r12, %rsi
movq %r13, %rdx
callq 0x29bf
jmp 0x13c8
movq 0xcc32(%rip), %rax      # 0xdfe0
movq (%rax), %rsi
leaq 0x7d6a(%rip), %rdi      # 0x9122
leaq 0x10(%rsp), %r13
movq %r12, %rdx
movq %r13, %rcx
callq 0x28f9
movq (%r13), %rdi
testl %eax, %eax
je 0x13e1
callq 0x5c9d
movq 0x10(%rsp), %rdi
callq 0x589b
jmp 0x13f0
callq 0x1463
movq 0x10(%rsp), %rdi
callq 0x1418
pushq $0x4
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2fba
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/tests/obtest_test.c
// Function: main
int main(){

  int i;
  obtest *test_obj, *a, *b;
  test_obj = obtest_new(1);
  a = obtest_new(3);
  b = obtest_new(3);

  /* ob_retain object, reference count should be 4 */
  for(i=0; i<3; i++){
    ob_retain((obj *)test_obj);
  }

  if(ob_reference_count((obj *)test_obj) != 4){
    fprintf(stderr, "obtest_test: reference count not incrememted correctly by "
                    "ob_retain\nTEST FAILED\n");
    exit(1);
  }

  /* ob_release object until test_obj is deallocated or until ob_release has been
   * called more than 4 times */
  i=0;
  while(++i < 5 && ob_release((obj *)test_obj) != NULL){}

  if(i<4){
    fprintf(stderr, "obtest_test: test_obj ob_released before reference count "
                    "reached zero, TEST FAILED\n");
    exit(1);
	}
  else if(i>4){
    fprintf(stderr, "obtest_test: test_obj not ob_released when reference count "
                    "reached zero\n");
    exit(1);
	}

  if(!ob_has_same_class((obj *)a, (obj *)b)){
    fprintf(stderr, "obtest_test: Two obtest objects were not of the same "
                    "class, TEST FAILED\n");
    exit(1);
  }

  if(!ob_has_class((obj *)a, "obtest")){
    fprintf(stderr, "obtest_test: An obtest object was not considered to be an "
                    "obtest object during check, TEST FAILED\n");
    exit(1);
  }

  ob_hash((obj *)a);

  printf("obtest: TEST PASSED\n");
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $0x1
popq %rdi
callq 0x12d0
movq %rax, %r14
pushq $0x3
popq %rbp
movl %ebp, %edi
callq 0x12d0
movq %rax, %rbx
movl %ebp, %edi
callq 0x12d0
movq %rax, %r15
movq %r14, %rdi
subl $0x1, %ebp
jb 0x11e4
callq 0x16e3
jmp 0x11d5
callq 0x1718
cmpl $0x4, %eax
jne 0x127e
pushq $0x4
popq %rbp
subl $0x1, %ebp
jb 0x125a
movq %r14, %rdi
callq 0x16ae
testq %rax, %rax
jne 0x11f5
testl %ebp, %ebp
jne 0x1293
movq %rbx, %rdi
movq %r15, %rsi
callq 0x174e
testb %al, %al
je 0x12a8
leaq 0xf12(%rip), %rsi       # 0x213b
movq %rbx, %rdi
callq 0x1726
testb %al, %al
je 0x12bb
movq %rbx, %rdi
callq 0x15be
leaq 0xf5d(%rip), %rdi       # 0x21a5
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d97(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xe3e(%rip), %rdi       # 0x20a9
pushq $0x48
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
pushq $0x1
popq %rdi
callq 0x1090
movq 0x2d73(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd75(%rip), %rdi       # 0x2004
pushq $0x50
jmp 0x126d
movq 0x2d5e(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xdb1(%rip), %rdi       # 0x2055
pushq $0x53
jmp 0x126d
movq 0x2d49(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xe39(%rip), %rdi       # 0x20f2
jmp 0x126b
movq 0x2d36(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xe76(%rip), %rdi       # 0x2142
pushq $0x62
jmp 0x126d
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/main.c
// Function: usage
static void
usage(const char *argv0)
{
  printf("\n");
  printf("Usage ... %s [OPTIONS] <file.bc>\n", argv0);
  printf("\n");
  printf("  -f FUNCTION         Function to diagnose [ALL]\n");
  printf("  -l                  Dump lowered function(s)\n");
  printf("  -p                  Dump parsed function(s)\n");
  printf("  -i                  List all functions\n");
  printf("  -n                  Don't try to run code\n");
  printf("\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x3040
leaq 0x1a67a(%rip), %rdi     # 0x1e0c2
movq %r14, %rsi
xorl %eax, %eax
callq 0x3190
movl %ebx, %edi
callq 0x3040
leaq 0x1a7b0(%rip), %rdi     # 0x1e210
callq 0x30e0
leaq 0x1a7d5(%rip), %rdi     # 0x1e241
callq 0x30e0
leaq 0x1a7f8(%rip), %rdi     # 0x1e270
callq 0x30e0
leaq 0x1a81a(%rip), %rdi     # 0x1e29e
callq 0x30e0
leaq 0x1a837(%rip), %rdi     # 0x1e2c7
callq 0x30e0
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_function.c
// Function: vmir_find_function
ir_function_t *
vmir_find_function(ir_unit_t *iu, const char *name)
{
  for(int i = 0; i < VECTOR_LEN(&iu->iu_functions); i++) {
    ir_function_t *f = VECTOR_ITEM(&iu->iu_functions, i);
    if(f->if_name != NULL && !strcmp(f->if_name, name))
      return f;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2e0(%rdi), %r12
xorl %r13d, %r13d
cmpq %r13, %r12
jbe 0x3b1a
movq 0x2d8(%r14), %rax
movq (%rax,%r13,8), %r15
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x3b15
movq %rbx, %rsi
callq 0x3300
testl %eax, %eax
je 0x3b1d
incq %r13
jmp 0x3af0
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_type.c
// Function: legalize_type
static int
legalize_type(const ir_type_t *ty)
{
  if(ty->it_code == IR_TYPE_INTx) {
    if(ty->it_bits <= 8)
      return IR_TYPE_INT8;
    else if(ty->it_bits <= 16)
      return IR_TYPE_INT16;
    else if(ty->it_bits <= 32)
      return IR_TYPE_INT32;
    else if(ty->it_bits <= 64)
      return IR_TYPE_INT64;
  }
  return ty->it_code;
}

// Assembly:
movl (%rdi), %eax
cmpl $0x7, %eax
jne 0x3fc1
movl 0x8(%rdi), %ecx
cmpl $0x9, %ecx
jge 0x3fa7
pushq $0x3
jmp 0x3fb7
cmpl $0x11, %ecx
jae 0x3fb0
pushq $0x4
jmp 0x3fb7
cmpl $0x21, %ecx
jae 0x3fb9
pushq $0x5
popq %rax
retq
cmpl $0x41, %ecx
jae 0x3fc1
pushq $0x6
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir.c
// Function: vmir_log
static void
vmir_log(ir_unit_t *iu, vmir_log_level_t level, const char *fmt, ...)
{
  if(level > iu->iu_log_level)
    return;

  va_list ap;
  char tmp[1024];
  va_start(ap, fmt);
  vsnprintf(tmp, sizeof(tmp), fmt, ap);
  va_end(ap);

  if(iu->iu_logger) {
    iu->iu_logger(iu, level, tmp);
  } else {
    printf("%s\n", tmp);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x4d8, %rsp            # imm = 0x4D8
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x400c
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
cmpl %esi, 0x630(%rdi)
jb 0x4084
movl %esi, %ebx
movq %rdi, %r14
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rsp, %rcx
movq %rax, (%rcx)
leaq 0x4f0(%rsp), %rax
movq %rax, 0x8(%rcx)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rcx)
leaq 0xd0(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x3120
movq 0x628(%r14), %rax
testq %rax, %rax
je 0x4077
leaq 0xd0(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq *%rax
jmp 0x4084
leaq 0xd0(%rsp), %rdi
callq 0x30e0
addq $0x4d8, %rsp            # imm = 0x4D8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_str
static const char *
type_str(ir_unit_t *iu, const ir_type_t *it)
{
  int len = type_print(NULL, iu, it);
  char *dst = tmpstr(iu, len);
  const char *ret = dst;
  type_print(&dst, iu, it);
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc284
movq %r14, %rdi
movl %eax, %esi
callq 0xc540
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc284
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_mem_alloc
uint32_t
vmir_mem_alloc(ir_unit_t *iu, uint32_t size, void *hostaddr_)
{
  void **hostaddr = hostaddr_;
  void *p = vmir_heap_malloc(iu, size);
  if(p == NULL) {
    if(hostaddr)
      *hostaddr = NULL;
    return 0;
  }
  if(hostaddr)
    *hostaddr = p;
  return p - iu->iu_mem;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x9f49
testq %rax, %rax
je 0x40fa
testq %rbx, %rbx
je 0x40f4
movq %rax, (%rbx)
subl 0x20(%r14), %eax
jmp 0x4105
xorl %eax, %eax
testq %rbx, %rbx
je 0x4105
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vfd_get
static vmir_fd_t *
vfd_get(ir_unit_t *iu, unsigned int fd, int type)
{
  if(fd >= VECTOR_LEN(&iu->iu_vfds))
    return NULL;
  vmir_fd_t *vfd = &VECTOR_ITEM(&iu->iu_vfds, fd);
  if(vfd->type == 0 || (type != -1 && vfd->type != type))
    return NULL; // Bad/Closed fd
  return vfd;
}

// Assembly:
movl %esi, %eax
cmpq %rax, 0xd8(%rdi)
jbe 0x9d3f
movq 0xd0(%rdi), %rcx
imulq $0x18, %rax, %rax
movzbl 0x10(%rcx,%rax), %esi
testl %esi, %esi
je 0x9d3f
addq %rax, %rcx
xorl %eax, %eax
cmpl %edx, %esi
cmoveq %rcx, %rax
cmpl $-0x1, %edx
cmoveq %rcx, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_fd_create
int
vmir_fd_create(ir_unit_t *iu, intptr_t handle, int type,
               vmir_fd_release_t *relfunc)
{
  int fd = vfd_create(iu, type);
  vmir_fd_t *vfd = &VECTOR_ITEM(&iu->iu_vfds, fd);
  vfd->fh = handle;
  vfd->release = relfunc;
  return fd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
movslq 0xe8(%rdi), %rax
cmpq $-0x1, %rax
je 0x9d81
movq 0xd0(%r12), %rcx
imulq $0x18, %rax, %rdx
movl (%rcx,%rdx), %edx
movl %edx, 0xe8(%r12)
movl %eax, %r15d
jmp 0x9de7
movq 0xd0(%r12), %rax
movq 0xd8(%r12), %r15
leaq 0x1(%r15), %r13
cmpq 0xe0(%r12), %r13
jbe 0x9dc3
leaq (,%r13,2), %rcx
movq %rcx, 0xe0(%r12)
imulq $0x30, %r13, %rsi
movq %rax, %rdi
callq 0x33c0
movq %rax, 0xd0(%r12)
movq %r13, 0xd8(%r12)
imulq $0x18, %r15, %rcx
andq $0x0, 0x10(%rax,%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx)
movq 0xd0(%r12), %rcx
movslq %r15d, %rax
imulq $0x18, %rax, %rdx
movb %bpl, 0x10(%rcx,%rdx)
imulq $0x18, %rax, %rax
movq %r14, (%rcx,%rax)
movq %rbx, 0x8(%rcx,%rax)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_fd_close
void
vmir_fd_close(ir_unit_t *iu, int fd)
{
  vmir_fd_t *vfd = vfd_get(iu, fd, -1);
  if(vfd == NULL)
    return;
  if(vfd->release)
    vfd->release(iu, vfd->fh);
  vfd->type = 0;
  vfd->freelist = iu->iu_vfd_free;
  iu->iu_vfd_free = fd;
}

// Assembly:
movl %esi, %eax
cmpq %rax, 0xd8(%rdi)
jbe 0x9e91
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xd0(%rdi), %r15
imulq $0x18, %rax, %rax
cmpb $0x0, 0x10(%r15,%rax)
je 0x9e8c
movl %esi, %ebx
addq %rax, %r15
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x9e76
movq (%r15), %rsi
movq %r14, %rdi
callq *%rax
movb $0x0, 0x10(%r15)
movl 0xe8(%r14), %eax
movl %eax, (%r15)
movl %ebx, 0xe8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_function_tab_lookup
vm_ext_function_t *
vmir_function_tab_lookup(const char *function,
                         const vmir_function_tab_t *array, int length)
{
  for(int i = 0; i < length; i++) {
    const vmir_function_tab_t *ft = array + i;
    if(!strcmp(function, ft->name)) {
      return ft->extfunc;
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
xorl %ebx, %ebx
testl %edx, %edx
cmovlel %ebx, %r15d
movq %rdi, %r12
shlq $0x4, %r15
addq $0x10, %r15
xorl %ecx, %ecx
leaq 0x10(%rcx), %r13
cmpq %r13, %r15
je 0x9ed7
movq (%r14,%rcx), %rsi
movq %r12, %rdi
callq 0x3300
movq %r13, %rcx
testl %eax, %eax
jne 0x9eb6
movq -0x8(%r14,%r13), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_walk_fds
void
vmir_walk_fds(ir_unit_t *iu,
              void (*fn)(void *opaque, int fd, int type),
              void *opaque)
{
  for(int i = 0; i < VECTOR_LEN(&iu->iu_vfds); i++) {
    vmir_fd_t *vfd = &VECTOR_ITEM(&iu->iu_vfds, i);
    if(vfd->type != 0)
      fn(opaque, i, vfd->type);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x10
popq %r13
xorl %r12d, %r12d
cmpq %r12, 0xd8(%r15)
jbe 0x9f3f
movq 0xd0(%r15), %rax
movzbl (%rax,%r13), %edx
testl %edx, %edx
je 0x9f36
movq %rbx, %rdi
movl %r12d, %esi
callq *%r14
incq %r12
addq $0x18, %r13
jmp 0x9f14
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_heap_malloc
static void *
vmir_heap_malloc(ir_unit_t *iu, int size)
{
  heap_t *h = iu->iu_heap;
  heap_block_t *hb;
  size += sizeof(heap_block_t);
  size = VMIR_ALIGN(size, 16);

  TAILQ_FOREACH(hb, &h->h_blocks, hb_link) {
    if(hb->hb_magic != HEAP_MAGIC_FREE)
      continue;

    if(size <= hb->hb_size) {
      int remain = hb->hb_size - size;
      if(remain < sizeof(heap_block_t) * 2) {
        size = hb->hb_size;
      } else {
        heap_block_t *split = (void *)hb + size;
        split->hb_magic = HEAP_MAGIC_FREE;
        split->hb_size = remain;
        TAILQ_INSERT_AFTER(&h->h_blocks, hb, split, hb_link);
      }

      hb->hb_magic = HEAP_MAGIC_ALLOC;
      hb->hb_size = size;
      return (void *)(hb + 1);
    }
  }
  return NULL;
}

// Assembly:
movq 0x90(%rdi), %rdx
addl $0x27, %esi
movslq %esi, %rcx
andq $-0x10, %rcx
movq %rdx, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x9f7c
cmpl $0xf4eef4ee, (%rax)     # imm = 0xF4EEF4EE
jne 0x9f76
movl 0x4(%rax), %esi
movl %esi, %edi
subl %ecx, %edi
jge 0x9f7f
addq $0x8, %rax
jmp 0x9f5d
xorl %eax, %eax
retq
cmpl $0x30, %edi
jb 0x9fc3
leaq (%rax,%rcx), %rsi
leaq (%rax,%rcx), %r8
addq $0x8, %r8
movl $0xf4eef4ee, -0x8(%r8)  # imm = 0xF4EEF4EE
movl %edi, -0x4(%r8)
leaq 0x8(%rax), %rdi
movq 0x8(%rax), %r9
movq %r9, (%r8)
addq $0x8, %rdx
leaq 0x10(%r9), %r10
testq %r9, %r9
cmoveq %rdx, %r10
movq %r8, (%r10)
movq %rsi, 0x8(%rax)
movq %rdi, 0x8(%r8)
movl %ecx, %esi
movl $0xa110ced, (%rax)      # imm = 0xA110CED
movl %esi, 0x4(%rax)
addq $0x18, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_heap_free
static void
vmir_heap_free(ir_unit_t *iu, void *ptr)
{
  if(ptr == NULL)
    return;
  heap_t *h = iu->iu_heap;
  heap_block_t *hb = ptr;
  hb--;
  assert(hb->hb_magic == HEAP_MAGIC_ALLOC);
  hb->hb_magic = HEAP_MAGIC_FREE;

  vmir_heap_merge_next(h, hb);
  heap_block_t *prev = TAILQ_PREV(hb, heap_block_queue, hb_link);
  if(prev != NULL) {
    assert(prev < hb);
    vmir_heap_merge_next(h, prev);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xa027
movq %rsi, %r14
cmpl $0xa110ced, -0x18(%rsi) # imm = 0xA110CED
jne 0xa02d
movq 0x90(%rdi), %rbx
leaq -0x18(%r14), %r15
movl $0xf4eef4ee, -0x18(%r14) # imm = 0xF4EEF4EE
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdf95
movq -0x8(%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xa027
cmpq %r15, %rsi
jae 0xa04c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xdf95
popq %rbx
popq %r14
popq %r15
retq
leaq 0x16457(%rip), %rdi     # 0x2048b
leaq 0x16471(%rip), %rsi     # 0x204ac
leaq 0x165cd(%rip), %rcx     # 0x2060f
movl $0xe4, %edx
callq 0x31e0
leaq 0x165e5(%rip), %rdi     # 0x20638
leaq 0x16452(%rip), %rsi     # 0x204ac
leaq 0x165ae(%rip), %rcx     # 0x2060f
movl $0xea, %edx
callq 0x31e0