LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: btbujiangjun[P]abcdl/src/utils/Log.cpp
// Function: abcdl::utils::log::env2int(char const*, int)
static inline int env2int(const char* env_name, int default_value = 0){
    char* env_value = getenv(env_name);
    if(env_value == nullptr){
        return default_value;
    }
        
    int return_value = default_value;
    try{
        return_value = std::stoi(env_value);
    }catch(...){
        //pass
    }
    return return_value;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq 0x68(%rsp), %rdi
callq 0x94d0
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x89141
movl 0x64(%rsp), %eax
movl %eax, 0x74(%rsp)
jmp 0x891f8
movl 0x64(%rsp), %eax
movl %eax, 0x54(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x9710
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x9580
jmp 0x89178
xorl %eax, %eax
movl %eax, %esi
leaq 0x30(%rsp), %rdi
movl $0xa, %edx
callq 0x8a190
movl %eax, 0x4(%rsp)
jmp 0x89191
movl 0x4(%rsp), %eax
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x9260
leaq 0x2f(%rsp), %rdi
callq 0x9470
jmp 0x891f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x891d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x9260
leaq 0x2f(%rsp), %rdi
callq 0x9470
movq 0x20(%rsp), %rdi
callq 0x9160
callq 0x9680
movl 0x54(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: btbujiangjun[P]abcdl/src/utils/Log.cpp
// Function: abcdl::utils::log::env2index(char const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, int)
static inline int env2index(const char* env_name,
                            const std::vector<std::string>& options,
                            int default_value){
    char* env_value = getenv(env_name);
    if(env_value != nullptr){
        for(size_t i = 0; i < options.size(); i++){
            if(options[i] == env_value){
                return static_cast<int>(i);
            }
        }
    }
    return default_value;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
callq 0x94d0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x892a2
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x8a3b0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x892a0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x8a080
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x8a3d0
testb $0x1, %al
jne 0x89283
jmp 0x8928e
movq 0x8(%rsp), %rax
movl %eax, 0x34(%rsp)
jmp 0x892aa
jmp 0x89290
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x89242
jmp 0x892a2
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: btbujiangjun[P]abcdl/src/utils/Log.cpp
// Function: abcdl::utils::log::LogMessage::generate_log_message()
void LogMessage::generate_log_message(){
    time_t timep;
    time(&timep);
    char time_data[64];
    strftime(time_data, sizeof(time_data), "%Y-%m-%d %H:%M:%S", localtime(&timep));
    if(!g_log_inited){
        fprintf(stderr, "[%s] [%s] [%s:%d] %s\n", g_log_level_name[_severity].c_str(), time_data,  _name, _line, str().c_str());
    }else{
        for(auto& fd : g_log_fds[this->_severity]){
            dprintf(fd, "[%s] [%s] [%s:%d] %s\n", g_log_level_name[_severity].c_str(), time_data, _name, _line, str().c_str());
        }
    }
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x128(%rsp), %rdi
callq 0x93f0
leaq 0xe0(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x128(%rsp), %rdi
callq 0x9300
movq 0x68(%rsp), %rdi
movq %rax, %rcx
movl $0x40, %esi
leaq 0xaa9c(%rip), %rdx      # 0x94493
callq 0x9360
testb $0x1, 0x42abd(%rip)     # 0xcc4c0
jne 0x89ab3
movq 0x60(%rsp), %rax
movq 0x425ab(%rip), %rcx     # 0xcbfc0
movq (%rcx), %rcx
movq %rcx, 0x38(%rsp)
movslq 0x7c(%rax), %rsi
leaq 0x42a48(%rip), %rdi     # 0xcc470
callq 0x8a080
movq %rax, %rdi
callq 0x9170
movq 0x60(%rsp), %rsi
movq %rax, 0x40(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x70(%rsi), %rax
movq %rax, 0x50(%rsp)
movl 0x78(%rsi), %eax
movl %eax, 0x5c(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x9440
leaq 0xc0(%rsp), %rdi
callq 0x9170
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
movl 0x5c(%rsp), %r9d
leaq 0xaa0f(%rip), %rsi      # 0x944a5
movq %rax, (%rsp)
movb $0x0, %al
callq 0x95f0
leaq 0xc0(%rsp), %rdi
callq 0x9260
jmp 0x89c03
movq 0x60(%rsp), %rax
movslq 0x7c(%rax), %rsi
leaq 0x429cd(%rip), %rdi     # 0xcc490
callq 0x8a0a0
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x8a0c0
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x8a0f0
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x8a120
testb $0x1, %al
jne 0x89b18
jmp 0x89c01
leaq 0xb0(%rsp), %rdi
callq 0x8a160
movq %rax, %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0xa0(%rsp)
movq 0xa0(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x1c(%rsp)
movslq 0x7c(%rax), %rsi
leaq 0x42922(%rip), %rdi     # 0xcc470
callq 0x8a080
movq %rax, %rdi
callq 0x9170
movq 0x60(%rsp), %rsi
movq %rax, 0x20(%rsp)
movq 0x70(%rsi), %rax
movq %rax, 0x28(%rsp)
movl 0x78(%rsi), %eax
movl %eax, 0x34(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x9440
movq 0x10(%rsp), %rdi
callq 0x9170
movl 0x1c(%rsp), %edi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %r8
movl 0x34(%rsp), %r9d
movq %rax, %rcx
movq %rsp, %rax
movq %rcx, (%rax)
leaq 0xa8f1(%rip), %rsi      # 0x944a5
xorl %eax, %eax
leaq 0xe0(%rsp), %rcx
callq 0x9220
jmp 0x89bc5
leaq 0x80(%rsp), %rdi
callq 0x9260
leaq 0xb0(%rsp), %rdi
callq 0x8a170
jmp 0x89afa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x9260
jmp 0x89c0b
jmp 0x89c03
addq $0x138, %rsp            # imm = 0x138
retq
movq 0x78(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
// File: btbujiangjun[P]abcdl/src/utils/Log.cpp
// Function: abcdl::utils::log::join(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&)
static std::string join(const std::string& part1, const std::string& part2){
    const char sep = '/';
    if(!part2.empty() && part2.front() == sep){
        return part2;
    }

    std::string return_value;
    return_value.reserve(part1.size() + part2.size() + 1);
    return_value = part1;
    if(!return_value.empty() && return_value.back() != sep){
        return_value += sep;
    }
    return_value += part2;

    return return_value;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movb $0x2f, 0x2f(%rsp)
movq 0x30(%rsp), %rdi
callq 0x96a0
testb $0x1, %al
jne 0x89d29
movq 0x30(%rsp), %rdi
callq 0x94f0
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x89d29
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x9180
jmp 0x89def
movq 0x8(%rsp), %rdi
movb $0x0, 0x2e(%rsp)
callq 0x95a0
movq 0x38(%rsp), %rdi
callq 0x92a0
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x92a0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
leaq 0x1(%rax,%rcx), %rsi
callq 0x9650
jmp 0x89d68
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x9040
jmp 0x89d79
movq 0x8(%rsp), %rdi
callq 0x96a0
testb $0x1, %al
jne 0x89dc6
movq 0x8(%rsp), %rdi
callq 0x92c0
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x89dc6
movq 0x8(%rsp), %rdi
movl $0x2f, %esi
callq 0x9270
jmp 0x89daa
jmp 0x89dc6
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x9260
jmp 0x89df9
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x9520
jmp 0x89dd7
movb $0x1, 0x2e(%rsp)
testb $0x1, 0x2e(%rsp)
jne 0x89ded
movq 0x8(%rsp), %rdi
callq 0x9260
jmp 0x89def
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x9700
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/khashl/test.c
// Function: test_int
KHASHL_MAP_INIT(, intmap_t, intmap, uint32_t, int, hash_fn, kh_eq_generic)

uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	intmap_t *h;
	h = intmap_init();
	for (i = 0, x = x0; i < n; ++i) {
		khint_t k;
		int absent;
		x = hash32(x);
		k = intmap_put(h, get_key(n, x), &absent);
#ifndef UDB2_TEST_DEL
		if (absent) kh_val(h, k) = 0;
		z += ++kh_val(h, k);
#else
		if (absent) ++z;
		else intmap_del(h, k);
#endif
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u; capacity: %u\n", kh_size(h), z, kh_capacity(h));
	x = kh_size(h);
	intmap_destroy(h);
	return x;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl $0x0, 0x34(%rsp)
callq 0x1700
movq %rax, 0x28(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jae 0x1673
movl 0x38(%rsp), %edi
callq 0x1250
movl %eax, 0x38(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x44(%rsp), %edi
movl 0x38(%rsp), %esi
callq 0x12c0
movq 0x18(%rsp), %rdi
movl %eax, %esi
leaq 0x20(%rsp), %rdx
callq 0x1a80
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x20(%rsp)
je 0x1641
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x24(%rsp), %ecx
movl $0x0, 0x4(%rax,%rcx,8)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rcx
movl 0x24(%rsp), %eax
movl %eax, %edx
movl 0x4(%rcx,%rdx,8), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx,%rdx,8)
addl 0x34(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x15de
movq 0x397e(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x16b6
movq 0x28(%rsp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x4(%rsp)
jmp 0x16be
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x16be
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %edx
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %r8d
leaq 0x199e(%rip), %rsi      # 0x3075
movb $0x0, %al
callq 0x1070
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x38(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1730
movl 0x38(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: daniel5151[P]mips241/src/bus.cc
// Function: MIPS::BUS::load(unsigned int)
uint32_t MIPS::BUS::load(uint32_t addr) {
  // Check if we are using any memory mapped I/O
  if (addr == 0xFFFF0004) {
    if (inputBuffer.empty()) {
      std::string input;
      getline(std::cin, input);
      input += "\n";
      for (int i = 0; i < input.length(); i++)
        inputBuffer.push_back(input[i]);
    }
    char in = inputBuffer.front();
    inputBuffer.pop_front();
    return in;
  } else {
    return ram.load(addr);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0xffff0004, -0x14(%rbp) # imm = 0xFFFF0004
jne 0x3905
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x3bb0
testb $0x1, %al
jne 0x382d
jmp 0x38dd
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x33d0
movq -0x60(%rbp), %rsi
movq 0x13793(%rip), %rdi     # 0x16fd8
callq 0x3080
jmp 0x384c
leaq 0xc7b1(%rip), %rsi      # 0x10004
leaq -0x38(%rbp), %rdi
callq 0x3230
jmp 0x385e
movl $0x0, -0x48(%rbp)
movslq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x33f0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x38d4
movq -0x58(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x78(%rbp)
movslq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3510
movq %rax, -0x70(%rbp)
jmp 0x38a1
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x3be0
jmp 0x38b0
jmp 0x38b2
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x3865
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3528
jmp 0x3923
leaq -0x38(%rbp), %rdi
callq 0x3528
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x3c40
movq -0x58(%rbp), %rdi
movb (%rax), %al
movb %al, -0x49(%rbp)
addq $0x8, %rdi
callq 0x3c70
movsbl -0x49(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3917
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xd9e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: daniel5151[P]mips241/src/bus.cc
// Function: MIPS::BUS::store(unsigned int, unsigned int)
void MIPS::BUS::store(uint32_t addr, uint32_t data) {
  // Check if we are using any memory mapped I/O
  if (addr == 0xFFFF000C) {
    outputBuffer = std::string(1, (char)data);
  } else {
    ram.store(addr, data);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0xffff000c, -0xc(%rbp) # imm = 0xFFFF000C
jne 0x39ba
movsbl -0x10(%rbp), %eax
movl %eax, -0x5c(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34d0
movl -0x5c(%rbp), %edx
movq -0x58(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x3ce0
jmp 0x397e
movq -0x50(%rbp), %rdi
addq $0x58, %rdi
leaq -0x30(%rbp), %rsi
callq 0x3340
leaq -0x30(%rbp), %rdi
callq 0x3528
leaq -0x31(%rbp), %rdi
callq 0x32d0
jmp 0x39cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32d0
jmp 0x39d2
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xd7f0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34c0
nopl (%rax,%rax)
// File: daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::CPU(MIPS::BUS&)
MIPS::CPU::CPU(MIPS::BUS & bus) : MEM(bus)
{
  // Internal flags and tracking vars
  isExecuting = true;
  cycles = 0;
  stage = S_FETCH;

  // Setup registers
  PC = 0x00000000;
  hi = lo = 0;
  RA = RB = RZ = RM = RY = 0;
  for (int i = 0; i < 32; i++) R[i] = 0;

  R[31] = 0x8123456C; // Exit address
  R[30] = 0x01000000; // Start of Stack
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x98(%rax)
movb $0x1, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0xa0(%rax)
movl $0x0, 0x8c(%rax)
movl $0x0, 0x94(%rax)
movl $0x0, 0x90(%rax)
movl $0x0, 0xb4(%rax)
movl $0x0, 0xb0(%rax)
movl $0x0, 0xac(%rax)
movl $0x0, 0xa8(%rax)
movl $0x0, 0xa4(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jge 0x534b
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, 0x8(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x532a
movq -0x20(%rbp), %rax
movl $0x8123456c, 0x84(%rax) # imm = 0x8123456C
movl $0x1000000, 0x80(%rax)  # imm = 0x1000000
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::setiRegister(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
void MIPS::CPU::setiRegister(std::string reg, uint32_t val) {
  #define IREG(name_str, var) if (reg == name_str) var = val;
    IREG("RA", RA);
    IREG("RB", RB);
    IREG("RZ", RZ);
    IREG("RM", RM);
    IREG("RY", RY);
    IREG("IR", IR);
    IREG("PC", PC);
    IREG("hi", hi);
    IREG("lo", lo);
  #undef IREG
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xac83(%rip), %rsi      # 0x10074
callq 0x5ee0
testb $0x1, %al
jne 0x53fc
jmp 0x5409
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xa4(%rax)
movq -0x28(%rbp), %rdi
leaq 0xac63(%rip), %rsi      # 0x10077
callq 0x5ee0
testb $0x1, %al
jne 0x541f
jmp 0x542c
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xa8(%rax)
movq -0x28(%rbp), %rdi
leaq 0xac43(%rip), %rsi      # 0x1007a
callq 0x5ee0
testb $0x1, %al
jne 0x5442
jmp 0x544f
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xac(%rax)
movq -0x28(%rbp), %rdi
leaq 0xac23(%rip), %rsi      # 0x1007d
callq 0x5ee0
testb $0x1, %al
jne 0x5465
jmp 0x5472
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xb0(%rax)
movq -0x28(%rbp), %rdi
leaq 0xac03(%rip), %rsi      # 0x10080
callq 0x5ee0
testb $0x1, %al
jne 0x5488
jmp 0x5495
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xb4(%rax)
movq -0x28(%rbp), %rdi
leaq 0xabe3(%rip), %rsi      # 0x10083
callq 0x5ee0
testb $0x1, %al
jne 0x54ab
jmp 0x54b8
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x88(%rax)
movq -0x28(%rbp), %rdi
leaq 0xabc3(%rip), %rsi      # 0x10086
callq 0x5ee0
testb $0x1, %al
jne 0x54ce
jmp 0x54db
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x8c(%rax)
movq -0x28(%rbp), %rdi
leaq 0xaba3(%rip), %rsi      # 0x10089
callq 0x5ee0
testb $0x1, %al
jne 0x54f1
jmp 0x54fe
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x90(%rax)
movq -0x28(%rbp), %rdi
leaq 0xab83(%rip), %rsi      # 0x1008c
callq 0x5ee0
testb $0x1, %al
jne 0x5514
jmp 0x5521
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x94(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::getiRegister(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
uint32_t MIPS::CPU::getiRegister(std::string reg) {
  #define IREG(name_str, var) if (reg == name_str) return var;
    IREG("RA", RA);
    IREG("RB", RB);
    IREG("RZ", RZ);
    IREG("RM", RM);
    IREG("RY", RY);
    IREG("IR", IR);
    IREG("PC", PC);
    IREG("hi", hi);
    IREG("lo", lo);
  #undef IREG

  return 0xBADA5555;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xaa96(%rip), %rsi      # 0x10074
callq 0x5ee0
testb $0x1, %al
jne 0x55e9
jmp 0x55fb
movq -0x20(%rbp), %rax
movl 0xa4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5736
movq -0x28(%rbp), %rdi
leaq 0xaa71(%rip), %rsi      # 0x10077
callq 0x5ee0
testb $0x1, %al
jne 0x5611
jmp 0x5623
movq -0x20(%rbp), %rax
movl 0xa8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5736
movq -0x28(%rbp), %rdi
leaq 0xaa4c(%rip), %rsi      # 0x1007a
callq 0x5ee0
testb $0x1, %al
jne 0x5639
jmp 0x564b
movq -0x20(%rbp), %rax
movl 0xac(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5736
movq -0x28(%rbp), %rdi
leaq 0xaa27(%rip), %rsi      # 0x1007d
callq 0x5ee0
testb $0x1, %al
jne 0x5661
jmp 0x5673
movq -0x20(%rbp), %rax
movl 0xb0(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5736
movq -0x28(%rbp), %rdi
leaq 0xaa02(%rip), %rsi      # 0x10080
callq 0x5ee0
testb $0x1, %al
jne 0x5689
jmp 0x569b
movq -0x20(%rbp), %rax
movl 0xb4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5736
movq -0x28(%rbp), %rdi
leaq 0xa9dd(%rip), %rsi      # 0x10083
callq 0x5ee0
testb $0x1, %al
jne 0x56b1
jmp 0x56c0
movq -0x20(%rbp), %rax
movl 0x88(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5736
movq -0x28(%rbp), %rdi
leaq 0xa9bb(%rip), %rsi      # 0x10086
callq 0x5ee0
testb $0x1, %al
jne 0x56d6
jmp 0x56e5
movq -0x20(%rbp), %rax
movl 0x8c(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5736
movq -0x28(%rbp), %rdi
leaq 0xa999(%rip), %rsi      # 0x10089
callq 0x5ee0
testb $0x1, %al
jne 0x56fb
jmp 0x570a
movq -0x20(%rbp), %rax
movl 0x90(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5736
movq -0x28(%rbp), %rdi
leaq 0xa977(%rip), %rsi      # 0x1008c
callq 0x5ee0
testb $0x1, %al
jne 0x5720
jmp 0x572f
movq -0x20(%rbp), %rax
movl 0x94(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5736
movl $0xbada5555, -0x4(%rbp) # imm = 0xBADA5555
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::decodeOPcode(unsigned int)
uint32_t MIPS::CPU::decodeOPcode(uint32_t IR) {
  bool hasImmediateValue = (IR >> 26) != 0;
  return (hasImmediateValue)
    ? IR & 0xFC000000   // Mask off all register identifiers + immediate bits
    : IR & 0x0000003F;  // Mask off all register identifiers
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
je 0x576f
movl -0xc(%rbp), %eax
andl $0xfc000000, %eax       # imm = 0xFC000000
movl %eax, -0x14(%rbp)
jmp 0x5778
movl -0xc(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::do_cycle()
void MIPS::CPU::do_cycle() {
  switch (stage) {
    case S_FETCH : fetch (); break;
    case S_DECODE: decode(); break;
    case S_EXEC  : exec  (); break;
    case S_MEMORY: memory(); break;
    case S_WBACK : wback (); break;
  }
  cycles++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xa0(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x4, %rax
ja 0x57ed
movq -0x10(%rbp), %rax
leaq 0xa8b1(%rip), %rcx      # 0x10060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x5800
jmp 0x57ed
movq -0x18(%rbp), %rdi
callq 0x5870
jmp 0x57ed
movq -0x18(%rbp), %rdi
callq 0x58d0
jmp 0x57ed
movq -0x18(%rbp), %rdi
callq 0x5d00
jmp 0x57ed
movq -0x18(%rbp), %rdi
callq 0x5db0
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::fetch()
void MIPS::CPU::fetch() {
  // Check if we JR'd to the exit
  if (PC == 0x8123456C) {
    isExecuting = false;
    return;
  }

  // Do a memory read
  IR = MEM.load(PC);

  // Increment PC
  PC += 4;

  // Move onto next stage
  stage = S_DECODE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x8123456c, 0x8c(%rax) # imm = 0x8123456C
jne 0x5829
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x5864
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
movl 0x8c(%rax), %esi
callq 0x37f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x88(%rax)
movl 0x8c(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x8c(%rax)
movl $0x1, 0xa0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::decode()
void MIPS::CPU::decode() {
  uint8_t  $s, $t;

  $s = (IR >> 21) & 0x1F;
  $t = (IR >> 16) & 0x1F;

  RA = R[$s];
  RB = R[$t];

  stage = S_EXEC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
shrl $0x15, %ecx
andl $0x1f, %ecx
movb %cl, -0x9(%rbp)
movl 0x88(%rax), %ecx
shrl $0x10, %ecx
andl $0x1f, %ecx
movb %cl, -0xa(%rbp)
movzbl -0x9(%rbp), %ecx
movl 0x8(%rax,%rcx,4), %ecx
movl %ecx, 0xa4(%rax)
movzbl -0xa(%rbp), %ecx
movl 0x8(%rax,%rcx,4), %ecx
movl %ecx, 0xa8(%rax)
movl $0x2, 0xa0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::memory()
void MIPS::CPU::memory() {
  switch (decodeOPcode(IR)) {
    case OP_LIS:
    case OP_LW:
      RY = MEM.load(RZ);
      break;
    case OP_SW:
      MEM.store(RZ, RM);
      break;
    default:
      RY = RZ;
      break;
  }

  stage = S_WBACK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl 0x88(%rdi), %esi
callq 0x5740
movl %eax, %ecx
movl %ecx, -0xc(%rbp)
subl $0x8c000000, %eax       # imm = 0x8C000000
je 0x5d43
jmp 0x5d2d
movl -0xc(%rbp), %eax
subl $0xac000000, %eax       # imm = 0xAC000000
je 0x5d67
jmp 0x5d39
movl -0xc(%rbp), %eax
subl $0x14, %eax
jne 0x5d85
jmp 0x5d43
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rdi
movl 0xac(%rax), %esi
callq 0x37f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xb4(%rax)
jmp 0x5d95
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rdi
movl 0xac(%rax), %esi
movl 0xb0(%rax), %edx
callq 0x3930
jmp 0x5d95
movq -0x18(%rbp), %rax
movl 0xac(%rax), %ecx
movl %ecx, 0xb4(%rax)
movq -0x18(%rbp), %rax
movl $0x4, 0xa0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: daniel5151[P]mips241/src/cpu.cc
// Function: MIPS::CPU::wback()
void MIPS::CPU::wback() {
  int $d = (IR >> 11) & 0x1F;
  int $t = (IR >> 16) & 0x1F;

  switch (decodeOPcode(IR)) {
      case OP_MULT:
      case OP_MULTU:
      case OP_DIV:
      case OP_DIVU:
      case OP_JR:
      case OP_BEQ:
      case OP_BNE:
      case OP_SW:
        // No writeback
        break;
      case OP_ADD:
      case OP_SUB:
      case OP_SLT:
      case OP_SLTU:
      case OP_MFHI:
      case OP_MFLO:
      case OP_LIS:
        // Writeback to $d
        if ($d != 0) R[$d] = RY;
        break;
      case OP_LW:
        // Writeback to $t
        if ($t != 0) R[$t] = RY;
        break;
      case OP_JALR  :
        // Writeback to $31
        R[31] = RY;
        break;
  }

  stage = S_FETCH;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl 0x88(%rdi), %eax
shrl $0xb, %eax
andl $0x1f, %eax
movl %eax, -0xc(%rbp)
movzwl 0x8a(%rdi), %eax
andl $0x1f, %eax
movl %eax, -0x10(%rbp)
movl 0x88(%rdi), %esi
callq 0x5740
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
subl $0x8c000000, %eax       # imm = 0x8C000000
je 0x5ea1
jmp 0x5dfd
movl -0x14(%rbp), %eax
subl $0xac000000, %eax       # imm = 0xAC000000
je 0x5e85
jmp 0x5e09
movl -0x14(%rbp), %eax
subl $0x8, %eax
je 0x5e85
jmp 0x5e13
movl -0x14(%rbp), %eax
subl $0x9, %eax
je 0x5ebb
jmp 0x5e21
movl -0x14(%rbp), %eax
subl $0x10, %eax
je 0x5e87
jmp 0x5e2b
movl -0x14(%rbp), %eax
subl $0x12, %eax
je 0x5e87
jmp 0x5e35
movl -0x14(%rbp), %eax
subl $0x14, %eax
je 0x5e87
jmp 0x5e3f
movl -0x14(%rbp), %eax
addl $-0x18, %eax
subl $0x4, %eax
jb 0x5e85
jmp 0x5e4c
movl -0x14(%rbp), %eax
subl $0x20, %eax
je 0x5e87
jmp 0x5e56
movl -0x14(%rbp), %eax
subl $0x22, %eax
je 0x5e87
jmp 0x5e60
movl -0x14(%rbp), %eax
addl $-0x2a, %eax
subl $0x2, %eax
jb 0x5e87
jmp 0x5e6d
movl -0x14(%rbp), %eax
subl $0x10000000, %eax       # imm = 0x10000000
je 0x5e85
jmp 0x5e79
movl -0x14(%rbp), %eax
subl $0x14000000, %eax       # imm = 0x14000000
jne 0x5ecb
jmp 0x5e85
jmp 0x5ecb
cmpl $0x0, -0xc(%rbp)
je 0x5e9f
movq -0x20(%rbp), %rax
movl 0xb4(%rax), %edx
movslq -0xc(%rbp), %rcx
movl %edx, 0x8(%rax,%rcx,4)
jmp 0x5ecb
cmpl $0x0, -0x10(%rbp)
je 0x5eb9
movq -0x20(%rbp), %rax
movl 0xb4(%rax), %edx
movslq -0x10(%rbp), %rcx
movl %edx, 0x8(%rax,%rcx,4)
jmp 0x5ecb
movq -0x20(%rbp), %rax
movl 0xb4(%rax), %ecx
movl %ecx, 0x84(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xa0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: daniel5151[P]mips241/src/debug.cc
// Function: MIPS::Debugger::Debugger(MIPS::CPU&, MIPS::RAM&, MIPS::BUS&)
Debugger::Debugger(CPU & cpu, RAM & ram, BUS & bus)
: cpu(cpu), ram(ram), bus(bus)
{
  prevInput = "step";

  cycleStep = false;

  step = false;

  // Break at the start of the program
  breakpoints.insert(0x00000000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
movq %rdi, -0x68(%rbp)
callq 0x80a0
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x60(%rbp)
callq 0x80c0
movq -0x50(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x58(%rbp)
callq 0x80c0
movq -0x50(%rbp), %rdi
addq $0xb0, %rdi
movq %rdi, -0x48(%rbp)
callq 0x33d0
movq -0x48(%rbp), %rdi
leaq 0xa106(%rip), %rsi      # 0x1009e
callq 0x33c0
jmp 0x5f9f
movq -0x50(%rbp), %rdi
movb $0x0, 0x48(%rdi)
movb $0x0, 0x49(%rdi)
addq $0x50, %rdi
movl $0x0, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x80e0
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x5fc8
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movb %al, -0x38(%rbp)
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3528
movq -0x58(%rbp), %rdi
callq 0x8130
movq -0x60(%rbp), %rdi
callq 0x8130
movq -0x68(%rbp), %rdi
callq 0x8150
movq -0x28(%rbp), %rdi
callq 0x34c0
nopl (%rax,%rax)
// File: daniel5151[P]mips241/src/debug.cc
// Function: MIPS::Debugger::print_stackRAM()
void Debugger::print_stackRAM() {
  bool oldHiglight_existed;
  char oldHiglight;

  cerr << "  ----------====== Stack RAM ======---------" << endl;
  uint32_t stackPtr = cpu.getRegister(30);

  oldHiglight_existed = (higlight.count(stackPtr) != 0);
  oldHiglight = (oldHiglight_existed) ? higlight[stackPtr] : ' ';

  higlight[stackPtr] = '>';
  printRAMFrom(stackPtr - 0x10, 12);

  if (oldHiglight_existed) higlight[stackPtr] = oldHiglight;
  else higlight.erase(stackPtr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xff15(%rip), %rdi      # 0x16ff0
leaq 0x9073(%rip), %rsi      # 0x10155
callq 0x3250
movq %rax, %rdi
movq 0xfeb7(%rip), %rsi      # 0x16fa8
callq 0x32a0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x1e, %esi
callq 0x5590
movq -0x18(%rbp), %rdi
movl %eax, -0x10(%rbp)
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x8170
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x7145
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x81d0
movb (%rax), %al
movb %al, -0x19(%rbp)
jmp 0x714c
movb $0x20, %al
movb %al, -0x19(%rbp)
jmp 0x714c
movq -0x18(%rbp), %rdi
movb -0x19(%rbp), %al
movb %al, -0xa(%rbp)
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x81d0
movq -0x18(%rbp), %rdi
movb $0x3e, (%rax)
movl -0x10(%rbp), %esi
subl $0x10, %esi
movl $0xc, %edx
callq 0x6070
testb $0x1, -0x9(%rbp)
je 0x719e
movq -0x18(%rbp), %rdi
movb -0xa(%rbp), %al
movb %al, -0x1a(%rbp)
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x81d0
movb -0x1a(%rbp), %cl
movb %cl, (%rax)
jmp 0x71af
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x84b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: daniel5151[P]mips241/src/debug.cc
// Function: MIPS::Debugger::print_progRAM()
void Debugger::print_progRAM() {
  bool oldHiglight_existed;
  char oldHiglight;

  cerr << "  ---------====== Program RAM ======--------" << endl;
  uint32_t currentPC = cpu.getPC();

  oldHiglight_existed = (higlight.count(currentPC) != 0);
  oldHiglight = (oldHiglight_existed) ? higlight[currentPC] : ' ';

  higlight[currentPC] = '>';
  uint32_t startAddr = ((int)currentPC - 0x20 >= 0x0)
    ? currentPC - 0x20
    : 0x0;
  printRAMFrom(startAddr, 16);

  if (oldHiglight_existed) higlight[currentPC] = oldHiglight;
  else higlight.erase(currentPC);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0xfe15(%rip), %rdi      # 0x16ff0
leaq 0x8fa0(%rip), %rsi      # 0x10182
callq 0x3250
movq %rax, %rdi
movq 0xfdb7(%rip), %rsi      # 0x16fa8
callq 0x32a0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x5570
movq -0x20(%rbp), %rdi
movl %eax, -0x10(%rbp)
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x8170
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x7240
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x81d0
movb (%rax), %al
movb %al, -0x21(%rbp)
jmp 0x7247
movb $0x20, %al
movb %al, -0x21(%rbp)
jmp 0x7247
movq -0x20(%rbp), %rdi
movb -0x21(%rbp), %al
movb %al, -0xa(%rbp)
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x81d0
movb $0x3e, (%rax)
movl -0x10(%rbp), %eax
subl $0x20, %eax
cmpl $0x0, %eax
jl 0x7277
movl -0x10(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x28(%rbp)
jmp 0x727e
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x727e
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
movl $0x10, %edx
callq 0x6070
testb $0x1, -0x9(%rbp)
je 0x72b9
movq -0x20(%rbp), %rdi
movb -0xa(%rbp), %al
movb %al, -0x29(%rbp)
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x81d0
movb -0x29(%rbp), %cl
movb %cl, (%rax)
jmp 0x72ca
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x84b0
addq $0x30, %rsp
popq %rbp
retq
// File: daniel5151[P]mips241/src/main.cc
// Function: readNum(std::istream&)
uint32_t readNum(std::istream & in) {
  std::string n_str;

  in >> n_str;
  std::stringstream n_ss (n_str);

  bool isDec = !(n_str[0] == '0' && n_str[1] == 'x') && !(n_str[1] == '0' && n_str[2] == 'x');

  long int x;
  n_ss >> ( (isDec) ? std::dec : std::hex ) >> x;

  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x33d0
movq -0x1d8(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x3380
jmp 0xcb01
movl $0x10, %edi
movl $0x8, %esi
callq 0x8640
movl %eax, -0x1dc(%rbp)
jmp 0xcb18
movl -0x1dc(%rbp), %edx
leaq -0x1c0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3420
jmp 0xcb30
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x3510
movq %rax, -0x1e8(%rbp)
jmp 0xcb46
movq -0x1e8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0xcb83
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x3510
movq %rax, -0x1f0(%rbp)
jmp 0xcb6c
movq -0x1f0(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x78, %ecx
movb %al, -0x1f1(%rbp)
je 0xcbec
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x3510
movq %rax, -0x200(%rbp)
jmp 0xcb9a
movq -0x200(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x201(%rbp)
jne 0xcbde
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x3510
movq %rax, -0x210(%rbp)
jmp 0xcbc8
movq -0x210(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x78, %eax
sete %al
movb %al, -0x201(%rbp)
movb -0x201(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1f1(%rbp)
movb -0x1f1(%rbp), %al
andb $0x1, %al
movb %al, -0x1c1(%rbp)
testb $0x1, -0x1c1(%rbp)
je 0xcc13
leaq -0x478a(%rip), %rax     # 0x8480
movq %rax, -0x218(%rbp)
jmp 0xcc23
leaq -0x45ba(%rip), %rax     # 0x8660
movq %rax, -0x218(%rbp)
jmp 0xcc23
movq -0x218(%rbp), %rsi
leaq -0x1c0(%rbp), %rdi
callq 0x3480
movq %rax, -0x220(%rbp)
jmp 0xcc3f
movq -0x220(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x3170
jmp 0xcc54
movq -0x1d0(%rbp), %rax
movl %eax, -0x224(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x31d0
leaq -0x28(%rbp), %rdi
callq 0x3528
movl -0x224(%rbp), %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xccab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x31d0
leaq -0x28(%rbp), %rdi
callq 0x3528
movq -0x30(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: daniel5151[P]mips241/src/ram.cc
// Function: MIPS::RAM::store(unsigned int, unsigned int)
void MIPS::RAM::store(uint32_t memaddr, uint32_t word) {
  if (memaddr % 4 != 0) {
    std::stringstream a; a << memaddr;
    error("Unaligned Access - Cannot Store to 0x" + a.str());
  }

  uint16_t page   = (memaddr >> 16) & 0xFFFF;
  uint16_t offset =  memaddr        & 0xFFFF;

  if (mem.count(page) == 0) {
    mem[page] = new uint32_t [(0xFFFF + 1) / 4](); // word addressable
  }

  mem[page][offset / 4] = word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xd904
leaq -0x198(%rbp), %rdi
callq 0x31b0
leaq -0x188(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x33a0
jmp 0xd83c
leaq -0x1e8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3240
jmp 0xd851
leaq 0x2f59(%rip), %rsi      # 0x107b1
leaq -0x1c8(%rbp), %rdi
leaq -0x1e8(%rbp), %rdx
callq 0xdce0
jmp 0xd86d
leaq -0x1c8(%rbp), %rdi
callq 0xca80
jmp 0xd87b
leaq -0x1c8(%rbp), %rdi
callq 0x3528
leaq -0x1e8(%rbp), %rdi
callq 0x3528
leaq -0x198(%rbp), %rdi
callq 0x31d0
jmp 0xd904
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0xd8f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0xd8e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x3528
leaq -0x1e8(%rbp), %rdi
callq 0x3528
leaq -0x198(%rbp), %rdi
callq 0x31d0
jmp 0xd9ce
movq -0x1f8(%rbp), %rdi
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x1ea(%rbp)
movl -0xc(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x1ec(%rbp)
leaq -0x1ea(%rbp), %rsi
callq 0xdd30
cmpq $0x0, %rax
jne 0xd97b
movl $0x10000, %edi          # imm = 0x10000
callq 0x3030
movq %rax, %rdi
movq %rdi, -0x200(%rbp)
xorl %esi, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x3150
movq -0x1f8(%rbp), %rdi
leaq -0x1ea(%rbp), %rsi
callq 0xdd90
movq -0x200(%rbp), %rcx
movq %rcx, (%rax)
movq -0x1f8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x20c(%rbp)
leaq -0x1ea(%rbp), %rsi
callq 0xdd90
movq (%rax), %rax
movq %rax, -0x208(%rbp)
movzwl -0x1ec(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl -0x20c(%rbp), %edx
movl %eax, %ecx
movq -0x208(%rbp), %rax
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x34c0
nopw (%rax,%rax)
// File: daniel5151[P]mips241/src/ram.cc
// Function: MIPS::RAM::load(unsigned int)
uint32_t MIPS::RAM::load(uint32_t memaddr) {
  if (memaddr % 4 != 0) {
    std::stringstream a; a << memaddr;
    error("Unaligned Access - Cannot Store to 0x" + a.str());
  }

  uint16_t page   = (memaddr >> 16) & 0xFFFF;
  uint16_t offset =  memaddr        & 0xFFFF;

  if (mem.count(page) == 0) {
    mem[page] = new uint32_t [(0xFFFF + 1) / 4](); // word addressable
  }

  return mem[page][offset / 4];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xdaf1
leaq -0x198(%rbp), %rdi
callq 0x31b0
leaq -0x188(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x33a0
jmp 0xda29
leaq -0x1e8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3240
jmp 0xda3e
leaq 0x2d6c(%rip), %rsi      # 0x107b1
leaq -0x1c8(%rbp), %rdi
leaq -0x1e8(%rbp), %rdx
callq 0xdce0
jmp 0xda5a
leaq -0x1c8(%rbp), %rdi
callq 0xca80
jmp 0xda68
leaq -0x1c8(%rbp), %rdi
callq 0x3528
leaq -0x1e8(%rbp), %rdi
callq 0x3528
leaq -0x198(%rbp), %rdi
callq 0x31d0
jmp 0xdaf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0xdae0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0xdad4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x3528
leaq -0x1e8(%rbp), %rdi
callq 0x3528
leaq -0x198(%rbp), %rdi
callq 0x31d0
jmp 0xdbac
movq -0x1f8(%rbp), %rdi
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x1ea(%rbp)
movl -0xc(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x1ec(%rbp)
leaq -0x1ea(%rbp), %rsi
callq 0xdd30
cmpq $0x0, %rax
jne 0xdb68
movl $0x10000, %edi          # imm = 0x10000
callq 0x3030
movq %rax, %rdi
movq %rdi, -0x200(%rbp)
xorl %esi, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x3150
movq -0x1f8(%rbp), %rdi
leaq -0x1ea(%rbp), %rsi
callq 0xdd90
movq -0x200(%rbp), %rcx
movq %rcx, (%rax)
movq -0x1f8(%rbp), %rdi
leaq -0x1ea(%rbp), %rsi
callq 0xdd90
movq (%rax), %rax
movq %rax, -0x208(%rbp)
movzwl -0x1ec(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x208(%rbp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x34c0
nopl (%rax,%rax)
// File: nickgammon[P]tinymudserver/tinymudserver.cpp
// Function: PeriodicUpdates()
void PeriodicUpdates ()
  {
    //      The example below just sends a message every MESSAGE_INTERVAL seconds.
    // send new command if it is time
  if (time (NULL) > (tLastMessage + MESSAGE_INTERVAL))
    {
    SendToAll ("You hear creepy noises ...\n");
    tLastMessage = time (NULL);
    }
    
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x43e0
leaq 0x23360(%rip), %rcx     # 0x29928
movq (%rcx), %rcx
addq $0x3c, %rcx
cmpq %rcx, %rax
jle 0x6662
leaq -0x21(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x46e0
movq -0x40(%rbp), %rdx
leaq 0x15a76(%rip), %rsi     # 0x1c066
leaq -0x20(%rbp), %rdi
callq 0x67d0
jmp 0x65fb
xorl %edx, %edx
movl %edx, %esi
leaq -0x20(%rbp), %rdi
callq 0x88a0
jmp 0x660a
leaq -0x20(%rbp), %rdi
callq 0x47d8
leaq -0x21(%rbp), %rdi
callq 0x44a0
xorl %eax, %eax
movl %eax, %edi
callq 0x43e0
movq %rax, %rcx
leaq 0x232f9(%rip), %rax     # 0x29928
movq %rcx, (%rax)
jmp 0x6662
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6657
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x47d8
leaq -0x21(%rbp), %rdi
callq 0x44a0
jmp 0x6668
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
// File: nickgammon[P]tinymudserver/tinymudserver.cpp
// Function: main
int main ()
{
  cout << "Tiny MUD server version " << VERSION << endl;

  LoadThings ();    // load stuff
  
  if (InitComms ()) // listen for new connections
    return 1;

  cout << "Accepting connections from port " <<  PORT << endl;
  
  MainLoop ();    // handle player input/output

  // game over - tell them all
  SendToAll ("\n\n** Game shut down. **\n\n");
  
  CloseComms ();  // stop listening

  cout << "Game shut down." << endl;  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2292a(%rip), %rdi     # 0x28fc0
leaq 0x159e5(%rip), %rsi     # 0x1c082
callq 0x4410
movq %rax, %rdi
leaq 0x22d94(%rip), %rsi     # 0x29440
callq 0x43d0
movq %rax, %rdi
movq 0x228dd(%rip), %rsi     # 0x28f98
callq 0x4480
callq 0xc380
callq 0x19a90
cmpl $0x0, %eax
je 0x66db
movl $0x1, -0x4(%rbp)
jmp 0x67b1
movq 0x228de(%rip), %rdi     # 0x28fc0
leaq 0x159b2(%rip), %rsi     # 0x1c09b
callq 0x4410
movq %rax, %rdi
movl $0xfa0, %esi            # imm = 0xFA0
callq 0x46c0
movq %rax, %rdi
movq 0x22893(%rip), %rsi     # 0x28f98
callq 0x4480
callq 0x1a670
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x46e0
movq -0x48(%rbp), %rdx
leaq 0x15995(%rip), %rsi     # 0x1c0bc
leaq -0x28(%rbp), %rdi
callq 0x67d0
jmp 0x6732
xorl %edx, %edx
movl %edx, %esi
leaq -0x28(%rbp), %rdi
callq 0x88a0
jmp 0x6741
leaq -0x28(%rbp), %rdi
callq 0x47d8
leaq -0x29(%rbp), %rdi
callq 0x44a0
callq 0x19eb0
movq 0x22861(%rip), %rdi     # 0x28fc0
leaq 0x15970(%rip), %rsi     # 0x1c0d6
callq 0x4410
movq %rax, %rdi
movq 0x22823(%rip), %rsi     # 0x28f98
callq 0x4480
movl $0x0, -0x4(%rbp)
jmp 0x67b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x67a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x47d8
leaq -0x29(%rbp), %rdi
callq 0x44a0
jmp 0x67ba
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x46d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nickgammon[P]tinymudserver/strings.cpp
// Function: FindAndReplace(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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string FindAndReplace
  (const string& source, const string target, const string replacement)
  {
  string str = source;
  string::size_type pos = 0,   // where we are now
                    found;     // where the found data is
  if (target.size () > 0)   // searching for nothing will cause a loop
    while ((found = str.find (target, pos)) != string::npos)
      {
      str.replace (found, target.size (), replacement);
      pos = found + replacement.size ();
      }
  return str;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rcx, -0x68(%rbp)
movq %rdx, -0x50(%rbp)
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x10(%rbp), %rsi
callq 0x41f0
movq -0x50(%rbp), %rdi
movq $0x0, -0x30(%rbp)
callq 0x4330
cmpq $0x0, %rax
jbe 0x6bf0
jmp 0x6b74
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rdx
callq 0x47c0
movq %rax, -0x38(%rbp)
cmpq $-0x1, %rax
je 0x6bee
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x4330
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rcx
movq %rax, %rdx
callq 0x41a0
jmp 0x6bb6
movq -0x68(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x4330
movq %rax, %rcx
movq -0x78(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x6b74
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x47d8
jmp 0x6c10
jmp 0x6bf0
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x6c03
movq -0x60(%rbp), %rdi
callq 0x47d8
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x46d0
nopl (%rax)
// File: nickgammon[P]tinymudserver/strings.cpp
// Function: Trim(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&)
string Trim (const string & s, const string & t)
{
  string d = s; 
  string::size_type i = d.find_last_not_of (t);
  if (i == string::npos)
    return "";
  else
   return d.erase (i + 1).erase (0, s.find_first_not_of (t)) ; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x41f0
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq $-0x1, %rdx
callq 0x4760
movq %rax, -0x40(%rbp)
cmpq $-0x1, -0x40(%rbp)
jne 0x6cc0
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x46e0
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x1544b(%rip), %rsi     # 0x1c0d5
callq 0x67d0
jmp 0x6c91
leaq -0x41(%rbp), %rdi
callq 0x44a0
movl $0x1, -0x58(%rbp)
jmp 0x6d34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x44a0
jmp 0x6d4a
movq -0x40(%rbp), %rsi
incq %rsi
leaq -0x38(%rbp), %rdi
movq $-0x1, %rdx
callq 0x40f0
movq %rax, -0x78(%rbp)
jmp 0x6cdd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x88(%rbp)
callq 0x4390
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
callq 0x40f0
movq %rax, -0x80(%rbp)
jmp 0x6d0e
movq -0x80(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x41f0
jmp 0x6d1d
movl $0x1, -0x58(%rbp)
jmp 0x6d34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6d4a
leaq -0x38(%rbp), %rdi
callq 0x47d8
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x47d8
movq -0x50(%rbp), %rdi
callq 0x46d0
nopl (%rax)