LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/bitmap.cc
// Function: DNS_DB::Bitmap::getFirst(bool) const
int DNS_DB::Bitmap::getFirst(bool value) const {
	for (unsigned int idx = 0; idx < bitm.size(); idx++) {
		for (unsigned int off = 0; off < sizeof(unsigned int)*8; off++) {
			if (((bitm[idx] & (1<<off)) != 0) == value)
				return idx*sizeof(unsigned int)*8 + off;
		}
	}
	return -1;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %rcx, %rdx
je 0x7ef0
pushq %rbx
sarq $0x2, %rdx
xorl %edi, %edi
movl (%rcx,%rdi,4), %r10d
movl %r10d, %ebx
andb $0x1, %bl
movl $0x0, %r11d
movl $0x0, %r9d
cmpb %sil, %bl
je 0x7ec7
xorl %r9d, %r9d
movl $0x1, %r11d
cmpl $-0x1f, %r9d
je 0x7ed3
btl %r11d, %r10d
setb %bl
decl %r9d
incl %r11d
cmpb %sil, %bl
jne 0x7ea4
cmpl $-0x1f, %r9d
setb %r11b
negl %r9d
movl %edi, %r8d
shll $0x5, %r8d
addl %r9d, %r8d
jmp 0x7ede
negl %r9d
cmpl $0x1f, %r9d
setae %r11b
testb %r11b, %r11b
je 0x7eec
incl %edi
cmpq %rdi, %rdx
ja 0x7e80
jmp 0x7eef
movl %r8d, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/bitmap.cc
// Function: DNS_DB::Bitmap::getRightSet(unsigned int) const
int DNS_DB::Bitmap::getRightSet(unsigned int pos) const {
	unsigned int residue = pos%(8*sizeof(unsigned int));
	unsigned int mask = ((~0)<<residue);
	for (unsigned int idx = pos/(8*sizeof(unsigned int)); idx < bitm.size(); idx++) {
		unsigned int val = bitm[idx] & mask;
		if (val != 0) {
			unsigned int off = __builtin_ctz(val);
			return idx*sizeof(unsigned int)*8 + off;
		}
		mask = ~0;
	}
	return -1;
}

// Assembly:
movl %esi, %r8d
shrl $0x5, %r8d
movq (%rdi), %rdx
movq 0x8(%rdi), %rdi
subq %rdx, %rdi
sarq $0x2, %rdi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r8, %rdi
jbe 0x7f47
movl %esi, %ecx
shll %cl, %eax
leal 0x1(%r8), %ecx
movl %r8d, %esi
shll $0x5, %esi
movl %r9d, %r10d
andl (%rdx,%r8,4), %eax
bsfl %eax, %r9d
addl %esi, %r9d
testl %eax, %eax
cmovel %r10d, %r9d
jne 0x7f48
movl %ecx, %r8d
incl %ecx
addl $0x20, %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r8, %rdi
ja 0x7f1f
retq
movl %r9d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/bitmap.cc
// Function: DNS_DB::Bitmap::bitCount() const
int DNS_DB::Bitmap::bitCount() const {
	int ret = 0;
	for (unsigned int i = 0; i < bitm.size(); i++) {
		ret += __builtin_popcount(bitm[i]);
	}
	return ret;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
je 0x7fb4
sarq $0x2, %rdx
xorl %esi, %esi
movl $0x33333333, %edi       # imm = 0x33333333
xorl %eax, %eax
movl (%rcx,%rsi,4), %r8d
movl %r8d, %r9d
shrl %r9d
andl $0x55555555, %r9d       # imm = 0x55555555
subl %r9d, %r8d
movl %r8d, %r9d
andl %edi, %r9d
shrl $0x2, %r8d
andl %edi, %r8d
addl %r9d, %r8d
movl %r8d, %r9d
shrl $0x4, %r9d
addl %r8d, %r9d
andl $0xf0f0f0f, %r9d        # imm = 0xF0F0F0F
imull $0x1010101, %r9d, %r8d  # imm = 0x1010101
shrl $0x18, %r8d
addl %r8d, %eax
incq %rsi
movl %esi, %r8d
cmpq %r8, %rdx
ja 0x7f65
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/block_manager.cc
// Function: DNS_DB::BlockManager::getBlock(int)
DNS_DB::DnsBlockPtr DNS_DB::BlockManager::getBlock(int id) {
	if (blocks.find(id) == blocks.end()) {
		DnsBlock * nbl = db->getNewBlock(id);
		CachedBlock cb;
		cb.b.reset(nbl);
		
		blocks.insert({id, cb});

		if (blocks.size() > BlockManager_flush_trigger)
			flushUnusedBlocks();
	}
	return blocks.at(id).b;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
movq 0x10(%rsi), %rsi
leaq 0x8(%r14), %rax
movq %rax, %rcx
testq %rsi, %rsi
je 0x809b
movq %rax, %rcx
xorl %edi, %edi
cmpl %edx, 0x20(%rsi)
setl %dil
cmovgeq %rsi, %rcx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x8084
movq %rax, %rsi
cmpq %rax, %rcx
je 0x80ad
cmpl %edx, 0x20(%rcx)
cmovgq %rax, %rcx
movq %rcx, %rsi
cmpq %rax, %rsi
jne 0x8158
movq 0x38(%r14), %rdi
movl %edx, %esi
callq 0x3cf6
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rax, %rsi
callq 0x82a6
movl 0xc(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x8112
movq 0x6ebc(%rip), %rcx      # 0xefc0
cmpb $0x0, (%rcx)
je 0x810e
incl 0x8(%rax)
jmp 0x8112
lock
incl 0x8(%rax)
movq 0x20(%rsp), %rax
leaq 0x28(%rsp), %rsi
movq %rax, 0x18(%rsi)
movq %r14, %rdi
callq 0x83e6
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x8137
callq 0x46de
cmpq $0x281, 0x28(%r14)      # imm = 0x281
jb 0x8149
movq %r14, %rdi
callq 0x81c6
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8158
callq 0x46de
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x82f0
movq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x818d
movq 0x6e41(%rip), %rcx      # 0xefc0
cmpb $0x0, (%rcx)
je 0x8189
incl 0x8(%rax)
jmp 0x818d
lock
incl 0x8(%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x81af
callq 0x46de
jmp 0x81af
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x81be
callq 0x46de
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/block_manager.cc
// Function: DNS_DB::BlockManager::flushUnusedBlocks()
void DNS_DB::BlockManager::flushUnusedBlocks() {
	// Remove the blocks with less "t"
	while (blocks.size() > BlockManager_flush_maximum) {
		// Look for candidate:
		unsigned long min = (unsigned)~0;
		std::map < int, CachedBlock >::iterator cand = blocks.end();
		for (std::map< int, CachedBlock >::iterator it = blocks.begin(); it != blocks.end(); ++it) {
			if (it->second.t < min) {
				if (it->second.b.use_count() == 1) {
					cand = it;
					min = it->second.t;
				}
			}
		}

		// Now delete this block if there is only one reference to it
		if (min != (unsigned)~0) {
			assert(cand->second.b.use_count() == 1);
			blocks.erase(cand);
		}
		else
			break;
	}

	// Make sure no repeated IDs
	#ifdef EXTRA_CHECK
	std::map <int,int> rep;
	for (std::map< int, CachedBlock >::iterator it = blocks.begin(); it != blocks.end(); ++it) {
		int id = it->second.b->getID();
		assert (rep[id] == 0);
		rep[id]++;
	}
	#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x201, 0x28(%rdi)      # imm = 0x201
jb 0x8277
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq 0x18(%rbx), %rax
cmpq %r15, %rax
je 0x823d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq %r15, %r14
movq 0x38(%rax), %rcx
cmpq %r13, %rcx
jae 0x8227
movq 0x30(%rax), %rdx
testq %rdx, %rdx
je 0x821b
movl 0x8(%rdx), %edx
cmpl $0x1, %edx
sete %dl
jmp 0x821d
xorl %edx, %edx
testb %dl, %dl
cmovneq %rax, %r14
cmovneq %rcx, %r13
movq %rax, %rdi
callq 0x31b0
cmpq %r15, %rax
jne 0x81fe
cmpq %r12, %r13
setne %bpl
jmp 0x8242
xorl %ebp, %ebp
movq %r15, %r14
testb %bpl, %bpl
je 0x8263
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x8286
movl 0x8(%rax), %eax
cmpl $0x1, %eax
jne 0x8286
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8522
cmpq $0x201, 0x28(%rbx)      # imm = 0x201
setae %al
testb %al, %bpl
jne 0x81ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x288d(%rip), %rdi      # 0xab1a
leaq 0x28a6(%rip), %rsi      # 0xab3a
leaq 0x28b0(%rip), %rcx      # 0xab4b
movl $0x24, %edx
callq 0x3180
nop
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/./dns_db.h
// Function: DNS_DB::DnsIndex::Iterator::next()
void next() {
				if (block_it.end()) {
					p++;
					block_it = idx->getBlock(p)->getIterator(db, 0);
				}
				else
					block_it.next();
			}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x7016
testb %al, %al
je 0x8fca
movl (%rbx), %eax
incl %eax
movl %eax, (%rbx)
movq 0x8(%rbx), %rcx
movq (%rcx), %rdx
movq 0x18(%rcx), %rsi
cltq
imulq $0x4a, %rax, %rax
movl 0x46(%rdx,%rax), %edx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8060
movq (%r14), %rax
movq 0x20(%rbx), %rcx
movl 0x10(%rax), %esi
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
callq 0x6e82
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8fc2
callq 0x46de
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x6f9c
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8feb
callq 0x46de
movq %rbx, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/ext/gzstream.cc
// Function: gzstreambuf::close()
gzstreambuf * gzstreambuf::close() {
    if ( is_open()) {
        sync();
        opened = 0;
        if ( gzclose( file) == Z_OK)
            return this;
    }
    return (gzstreambuf*)0;
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x177(%rdi)
je 0x90ff
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
movb $0x0, 0x177(%rbx)
movq 0x40(%rbx), %rdi
callq 0x33d0
testl %eax, %eax
je 0x9101
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/ext/gzstream.cc
// Function: gzstreambuf::overflow(int)
int gzstreambuf::overflow( int c) { // used for output buffer only
    if ( ! ( mode & std::ios::out) || ! opened)
        return EOF;
    if (c != EOF) {
        *pptr() = c;
        pbump(1);
    }
    if ( flush_buffer() == EOF)
        return EOF;
    return c;
}

// Assembly:
testb $0x10, 0x178(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
je 0x9217
cmpb $0x0, 0x177(%rdi)
je 0x9217
pushq %rbx
movl %esi, %ebx
cmpl $-0x1, %esi
je 0x9209
movq 0x28(%rdi), %rax
movb %bl, (%rax)
incq 0x28(%rdi)
callq 0x91a0
cmpl $-0x1, %eax
cmovel %eax, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/hdlguy[P]fft_demo/fft.cpp
// Function: Fft::convolve(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>&)
void Fft::convolve(const vector<double> &x, const vector<double> &y, vector<double> &out) {
	if (x.size() != y.size() || x.size() != out.size())
		throw "Mismatched lengths";
	size_t n = x.size();
	vector<double> ximag(n), yimag(n), zimag(n);
	convolve(x, ximag, y, yimag, out, zimag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq 0x8(%rdi), %r12
subq (%rdi), %r12
movq 0x8(%rsi), %rax
subq (%rsi), %rax
cmpq %rax, %r12
jne 0x1e4c
movq %rdx, %rbx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
cmpq %rax, %r12
jne 0x1e4c
movq %rsi, %r14
movq %rdi, %r15
sarq $0x3, %r12
leaq -0x70(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %r12, %rsi
callq 0x1eb0
leaq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq %r12, %rsi
callq 0x1eb0
leaq -0x40(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %r12, %rsi
callq 0x1eb0
leaq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rcx
leaq -0x40(%rbp), %r9
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %r8
callq 0x1aea
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x1e23
callq 0x10c0
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x1e31
callq 0x10c0
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x1e3f
callq 0x10c0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x1070
leaq 0x11e3(%rip), %rcx      # 0x3040
movq %rcx, (%rax)
movq 0x3161(%rip), %rsi      # 0x4fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x1140
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x1e87
callq 0x10c0
jmp 0x1e87
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x1e9a
callq 0x10c0
jmp 0x1e9a
movq %rax, %rbx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x1ea8
callq 0x10c0
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/arm.cpp
// Function: arm::GetOppositeCond(arm::Cond)
Cond GetOppositeCond(Cond cond) {
  switch (cond) {
    case Cond::AL:
      return Cond::AL;
    case Cond::EQ:
      return Cond::NE;
    case Cond::NE:
      return Cond::EQ;
    case Cond::GT:
      return Cond::LE;
    case Cond::GE:
      return Cond::LT;
    case Cond::LT:
      return Cond::GE;
    case Cond::LE:
      return Cond::GT;
    default:
      MyAssert(0);
      break;
  }
}

// Assembly:
cmpl $0x7, %edi
jae 0x9cbe
movl %edi, %eax
leaq 0x653da(%rip), %rcx     # 0x6f094
movl (%rcx,%rax,4), %eax
retq
pushq %rax
movq 0x8632a(%rip), %rdi     # 0x8fff0
leaq 0x6549b(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x65498(%rip), %rsi     # 0x6f171
movq %rax, %rdi
callq 0x8280
leaq 0x666d8(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x1d, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/arm.cpp
// Function: arm::CondToString[abi:cxx11](arm::Cond)
std::string CondToString(Cond cond) {
  switch (cond) {
    case Cond::AL:
      return "";
    case Cond::EQ:
      return "eq";
    case Cond::NE:
      return "ne";
    case Cond::GT:
      return "gt";
    case Cond::GE:
      return "ge";
    case Cond::LT:
      return "lt";
    case Cond::LE:
      return "le";
    default:
      MyAssert(0);
      break;
  }
  return "";
}

// Assembly:
pushq %rbx
cmpl $0x6, %esi
ja 0x9ddc
movq %rdi, %rbx
movl %esi, %eax
leaq 0x652e3(%rip), %rcx     # 0x6f008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x6548d(%rip), %rdx     # 0x6f1c9
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x9dd2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x66563(%rip), %rsi     # 0x702b8
leaq 0x6655e(%rip), %rdx     # 0x702ba
jmp 0x9dcf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x6743e(%rip), %rsi     # 0x711aa
leaq 0x67439(%rip), %rdx     # 0x711ac
jmp 0x9dcf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x66531(%rip), %rsi     # 0x702b4
leaq 0x6652c(%rip), %rdx     # 0x702b6
jmp 0x9dcf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x6650a(%rip), %rsi     # 0x702a4
leaq 0x66505(%rip), %rdx     # 0x702a6
jmp 0x9dcf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x664fb(%rip), %rsi     # 0x702ac
leaq 0x664f6(%rip), %rdx     # 0x702ae
jmp 0x9dcf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x65c2a(%rip), %rsi     # 0x6f9f2
leaq 0x65c25(%rip), %rdx     # 0x6f9f4
movq %rbx, %rdi
callq 0xcaa0
movq %rbx, %rax
popq %rbx
retq
movq 0x8620d(%rip), %rdi     # 0x8fff0
leaq 0x6537e(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x6537b(%rip), %rsi     # 0x6f171
movq %rax, %rdi
callq 0x8280
leaq 0x665bb(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x33, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/arm.cpp
// Function: arm::Operand2::CheckImm8m(int)
bool Operand2::CheckImm8m(int imm) {
  // NOTE: assign a int to unsigned int
  unsigned int encoding = imm;
  for (int ror = 0; ror < 32; ror += 2) {
    // 如果encoding的前24bit都是0 说明imm能被表示成一个8bit循环右移偶数位得到
    if (!(encoding & ~0xFFu)) {
      return true;
    }
    encoding = (encoding << 30u) | (encoding >> 2u);
  }
  return false;
}

// Assembly:
movb $0x1, %al
cmpl $0x100, %edi            # imm = 0x100
jb 0xa678
xorl %ecx, %ecx
cmpl $0x1e, %ecx
setb %al
jae 0xa678
roll $0x1e, %edi
addl $0x2, %ecx
cmpl $0xff, %edi
ja 0xa662
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/arm.cpp
// Function: arm::Instruction::Instruction(arm::Instruction*)
Instruction::Instruction(Instruction* inst) : parent_(inst->parent_) {
  auto& inst_list = parent_->inst_list_;
  auto it = std::find(inst_list.begin(), inst_list.end(), inst);
  MyAssert(it != inst_list.end());
  inst_list.insert(it, this);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
movq %rsi, (%rdx)
leaq 0x83c5b(%rip), %rax     # 0x8e350
movq %rax, (%rdi)
movq 0x8(%rsi), %r14
movq %r14, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq 0x30(%r14), %rdi
movq 0x38(%r14), %rsi
callq 0xcc9b
cmpq 0x38(%r14), %rax
je 0xa739
addq $0x30, %r14
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
movq %r14, %rdi
movq %rax, %rsi
callq 0xcd3a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x858b0(%rip), %rdi     # 0x8fff0
leaq 0x64a21(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x64a1e(%rip), %rsi     # 0x6f171
movq %rax, %rdi
callq 0x8280
leaq 0x65c5e(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x6f, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/arm.cpp
// Function: arm::Branch::IsCall()
bool Branch::IsCall() {
  // 所有的标签都要由.开头
  if (this->has_l_ && this->label_.size() > 0 && this->label_ != "lr" && this->label_[0] != '.') {
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbx
cmpb $0x1, 0x38(%rdi)
jne 0xae42
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0xae42
addq $0x18, %rbx
leaq 0x643a2(%rip), %rsi     # 0x6f1ce
movq %rbx, %rdi
callq 0x8100
testl %eax, %eax
je 0xae42
movq (%rbx), %rcx
movb $0x1, %al
cmpb $0x2e, (%rcx)
jne 0xae44
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/arm_struct.cpp
// Function: ArmFunction::EmitCode(std::ostream&)
void ArmFunction::EmitCode(std::ostream& out) {
  out << ".global " << this->name_ << std::endl;
  out << "\t.type " << this->name_ << ", %function" << std::endl;
  out << this->name_ << ":" << std::endl;
#ifdef GENARM_WITH_COMMENT
  out << "@ call_func: ";
  for (auto func : this->call_func_list_) {
    out << func->name_ << " ";
  }
  out << std::endl;
  out << "@ arg_num: " << this->arg_num_ << " ";        // << std::endl;
  out << "@ stack_size: " << this->stack_size_ << " ";  // << std::endl;
  out << "@ virtual_reg_max: " << this->virtual_reg_max << " ";
  out << std::endl;
#endif
  out << "@ Function Begin:" << std::endl;
  for (auto bb : bb_list_) {
    bb->EmitCode(out);
    out << std::endl;
  }
  out << "@ Function End." << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x61f75(%rip), %rsi     # 0x6f3fd
movl $0x8, %edx
movq %rbx, %rdi
callq 0x8330
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x8330
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
leaq 0x61f41(%rip), %rsi     # 0x6f417
movl $0x7, %edx
movq %rbx, %rdi
callq 0x8330
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x8330
movq %rax, %r15
leaq 0x61f4c(%rip), %rsi     # 0x6f449
movl $0xb, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x8330
movq %rax, %r15
leaq 0x62e75(%rip), %rsi     # 0x703c0
movl $0x1, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
leaq 0x61ecf(%rip), %rsi     # 0x6f455
movl $0x11, %edx
movq %rbx, %rdi
callq 0x8330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x38(%r14), %r15
movq 0x40(%r14), %r14
cmpq %r14, %r15
je 0xd5ff
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xd640
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
addq $0x8, %r15
jmp 0xd5c2
leaq 0x61e61(%rip), %rsi     # 0x6f467
movl $0xf, %edx
movq %rbx, %rdi
callq 0x8330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x81f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/arm_struct.cpp
// Function: ArmBasicBlock::IndexInFunc()
int ArmBasicBlock::IndexInFunc() {
  MyAssert(nullptr != this->func_);
  auto& bbs = this->func_->bb_list_;
  MyAssert(std::find(bbs.begin(), bbs.end(), this) != bbs.end());
  return std::distance(bbs.begin(), std::find(bbs.begin(), bbs.end(), this));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0xd713
movq %rdi, %rbx
movq 0x38(%r14), %rdi
movq 0x40(%r14), %rsi
movq %rsp, %rdx
movq %rbx, (%rdx)
callq 0xd824
movq 0x40(%r14), %rsi
cmpq %rsi, %rax
je 0xd74e
movq 0x38(%r14), %r14
movq %rsp, %rdx
movq %rbx, (%rdx)
movq %r14, %rdi
callq 0xd824
subq %r14, %rax
shrq $0x3, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x828d6(%rip), %rdi     # 0x8fff0
leaq 0x61a47(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x61d4a(%rip), %rsi     # 0x6f477
movq %rax, %rdi
callq 0x8280
leaq 0x62c84(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0x9f, %esi
jmp 0xd787
movq 0x8289b(%rip), %rdi     # 0x8fff0
leaq 0x61a0c(%rip), %rsi     # 0x6f168
callq 0x8280
leaq 0x61d0f(%rip), %rsi     # 0x6f477
movq %rax, %rdi
callq 0x8280
leaq 0x62c49(%rip), %rsi     # 0x703c0
movq %rax, %rdi
callq 0x8280
movq %rax, %rdi
movl $0xa1, %esi
callq 0x8520
movq %rax, %rdi
callq 0x8180
movl $0xff, %edi
callq 0x8380
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::Root::PrintNode(int, std::ostream&)
void Root::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "Root" << LINE_NO << std::endl;
  for (const auto &ele : compunit_list_) {
    ele->PRINT_NODE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x61af9(%rip), %rsi     # 0x6f4a7
movl $0x4, %edx
movq %rbx, %rdi
callq 0x8330
leaq 0x636ed(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x61ac7(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xda3f
incl %ebp
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x18(%rax)
addq $0x8, %r15
cmpq %r14, %r15
jne 0xda28
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ArrayIdentifier::PrintNode(int, std::ostream&)
void ArrayIdentifier::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "ArrayIdentifier" << LINE_NO << std::endl;
  name_.PRINT_NODE;
  ++indentation;
  PRINT_INDENT;
  outfile << "Shape" << LINE_NO << std::endl;
  for (const auto &ele : shape_list_) {
    ele->PRINT_NODE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x617fa(%rip), %rsi     # 0x6f4c5
movl $0xf, %edx
movq %rbx, %rdi
callq 0x8330
leaq 0x633d0(%rip), %r12     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8330
movl 0x8(%r15), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %rbp
leaq 0x617a7(%rip), %r13     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x8330
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbp, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r15), %rdi
leal 0x1(%r14), %ebp
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movl %ebp, %edi
movq %rbx, %rsi
callq 0xd8c4
leaq 0x61774(%rip), %rsi     # 0x6f4d5
movl $0x5, %edx
movq %rbx, %rdi
callq 0x8330
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8330
movl 0x8(%r15), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x8330
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r12, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x18(%r15), %r12
movq 0x20(%r15), %r15
cmpq %r15, %r12
je 0xddef
addl $0x2, %r14d
movq (%r12), %rdi
movq (%rdi), %rax
movl %r14d, %esi
movq %rbx, %rdx
callq *0x20(%rax)
addq $0x10, %r12
cmpq %r15, %r12
jne 0xddd6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ConditionExpression::PrintNode(int, std::ostream&)
void ConditionExpression::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "ConditionExpression OP: " << OP_STRING(this->op_) << LINE_NO
          << std::endl;
  this->lhs_.PRINT_NODE;
  this->rhs_.PRINT_NODE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x61639(%rip), %rsi     # 0x6f4db
movl $0x18, %edx
movq %rbx, %rdi
callq 0x8330
movslq 0xc(%r14), %rax
shlq $0x5, %rax
leaq 0x82472(%rip), %rcx     # 0x90330
movq -0x2040(%rax,%rcx), %rsi
movq -0x2038(%rax,%rcx), %rdx
movq %rbx, %rdi
callq 0x8330
movq %rax, %r15
leaq 0x631cf(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x615a9(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::BinaryExpression::PrintNode(int, std::ostream&)
void BinaryExpression::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "BinaryExpression OP: " << OP_STRING(this->op_) << LINE_NO
          << std::endl;
  // this->lhs_.PRINT_NODE;
  this->lhs_->PRINT_NODE;
  this->rhs_.PRINT_NODE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x61500(%rip), %rsi     # 0x6f4f4
movl $0x15, %edx
movq %rbx, %rdi
callq 0x8330
movslq 0xc(%r14), %rax
shlq $0x5, %rax
leaq 0x82320(%rip), %rcx     # 0x90330
movq -0x2040(%rax,%rcx), %rsi
movq -0x2038(%rax,%rcx), %rdx
movq %rbx, %rdi
callq 0x8330
movq %rax, %r15
leaq 0x6307d(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x61457(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::UnaryExpression::PrintNode(int, std::ostream&)
void UnaryExpression::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "UnaryExpression OP: " << OP_STRING(this->op_) << LINE_NO
          << std::endl;
  this->rhs_.PRINT_NODE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x613d8(%rip), %rsi     # 0x6f50a
movl $0x14, %edx
movq %rbx, %rdi
callq 0x8330
movslq 0xc(%r14), %rax
shlq $0x5, %rax
leaq 0x821e2(%rip), %rcx     # 0x90330
movq -0x2040(%rax,%rcx), %rsi
movq -0x2038(%rax,%rcx), %rdx
movq %rbx, %rdi
callq 0x8330
movq %rax, %r15
leaq 0x62f3f(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x61319(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::FunctionCall::PrintNode(int, std::ostream&)
void FunctionCall::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "FunctionCall" << LINE_NO << std::endl;
  this->name_.PRINT_NODE;
  this->args_.PRINT_NODE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x61299(%rip), %rsi     # 0x6f51f
movl $0xc, %edx
movq %rbx, %rdi
callq 0x8330
leaq 0x62e15(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x611ef(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::VariableDefineWithInit::PrintNode(int, std::ostream&)
void VariableDefineWithInit::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "DefineWithInit" << (is_const_ ? " const" : "") << LINE_NO
          << std::endl;
  name_.PRINT_NODE;
  value_.PRINT_NODE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x6105a(%rip), %rsi     # 0x6f52c
movl $0xe, %edx
movq %rbx, %rdi
callq 0x8330
leaq 0x61055(%rip), %rax     # 0x6f53b
leaq 0x60cdc(%rip), %rsi     # 0x6f1c9
xorl %ecx, %ecx
cmpb $0x0, 0xc(%r14)
cmovneq %rax, %rsi
movl $0x6, %edx
cmoveq %rcx, %rdx
movq %rbx, %rdi
callq 0x8330
leaq 0x62b9f(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x60f79(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ArrayDefineWithInit::PrintNode(int, std::ostream&)
void ArrayDefineWithInit::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "DefineWithInit" << (is_const_ ? " const" : "") << LINE_NO
          << std::endl;
  name_.PRINT_NODE;
  value_.PRINT_NODE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x60df2(%rip), %rsi     # 0x6f52c
movl $0xe, %edx
movq %rbx, %rdi
callq 0x8330
leaq 0x60ded(%rip), %rax     # 0x6f53b
leaq 0x60a74(%rip), %rsi     # 0x6f1c9
xorl %ecx, %ecx
cmpb $0x0, 0xc(%r14)
cmovneq %rax, %rsi
movl $0x6, %edx
cmoveq %rcx, %rdx
movq %rbx, %rdi
callq 0x8330
leaq 0x62937(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x60d11(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::FunctionDefine::PrintNode(int, std::ostream&)
void FunctionDefine::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "FunctionDefine" << LINE_NO << std::endl;

  ++indentation;
  PRINT_INDENT;
  outfile << "ReturnType: " << TYPE_STRING(this->return_type_) << LINE_NO
          << std::endl;
  --indentation;

  this->name_.PRINT_NODE;
  this->args_.PRINT_NODE;
  this->body_.PRINT_NODE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x60ca0(%rip), %rsi     # 0x6f542
movl $0xe, %edx
movq %rbx, %rdi
callq 0x8330
leaq 0x627f9(%rip), %r15     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8330
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r13
leaq 0x60bd0(%rip), %r12     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x8330
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r13, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
incl %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0xd8c4
leaq 0x60c2a(%rip), %rsi     # 0x6f551
movl $0xc, %edx
movq %rbx, %rdi
callq 0x8330
movl 0xc(%r14), %eax
cmpl $0x122, %eax            # imm = 0x122
leaq 0x60c1a(%rip), %rcx     # 0x6f55e
leaq 0x62779(%rip), %rdx     # 0x710c4
cmoveq %rcx, %rdx
cmpl $0x121, %eax            # imm = 0x121
leaq 0x61234(%rip), %r13     # 0x6fb8f
cmovneq %rdx, %r13
movq %r13, %rdi
callq 0x8160
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x8330
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8330
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x18(%rax)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::AssignStatement::PrintNode(int, std::ostream&)
void AssignStatement::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "AssignStatement" << LINE_NO << std::endl;
  this->lhs_.PRINT_NODE;
  this->rhs_.PRINT_NODE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x60aab(%rip), %rsi     # 0x6f563
movl $0xf, %edx
movq %rbx, %rdi
callq 0x8330
leaq 0x625e3(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x609bd(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::IfElseStatement::~IfElseStatement()
IfElseStatement::~IfElseStatement() {
  delete &(this->cond_);
  delete &(this->thenstmt_);
  if (nullptr != this->elsestmt_) {
    delete this->elsestmt_;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x7fdc3(%rip), %rax     # 0x8e938
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xeb87
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xeb96
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xeba6
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::WhileStatement::PrintNode(int, std::ostream&)
void WhileStatement::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "WhileStatement" << LINE_NO << std::endl;

  ++indentation;
  PRINT_INDENT;
  outfile << "Condition" << LINE_NO << std::endl;
  this->cond_.PRINT_NODE;

  PRINT_INDENT;
  outfile << "Body" << LINE_NO << std::endl;
  this->bodystmt_.PRINT_NODE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x606cc(%rip), %rsi     # 0x6f597
movl $0xe, %edx
movq %rbx, %rdi
callq 0x8330
leaq 0x621d0(%rip), %r12     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8330
movl 0x8(%r15), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %rbp
leaq 0x605a7(%rip), %r13     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x8330
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %rbp, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
leal 0x1(%r14), %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0xd8c4
leaq 0x60631(%rip), %rsi     # 0x6f583
movl $0x9, %edx
movq %rbx, %rdi
callq 0x8330
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8330
movl 0x8(%r15), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x8330
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r12, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r15), %rdi
addl $0x2, %r14d
movq (%rdi), %rax
movl %r14d, %esi
movq %rbx, %rdx
callq *0x20(%rax)
movl %ebp, %edi
movq %rbx, %rsi
callq 0xd8c4
leaq 0x605cb(%rip), %rsi     # 0x6f5a6
movl $0x4, %edx
movq %rbx, %rdi
callq 0x8330
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x620b8(%rip), %rsi     # 0x710af
callq 0x8330
movl 0x8(%r15), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x8330
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r12, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x18(%r15), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movl %r14d, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ReturnStatement::PrintNode(int, std::ostream&)
void ReturnStatement::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "ReturnStatement" << LINE_NO << std::endl;
  if (nullptr != this->value_) {
    this->value_->PRINT_NODE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x6039e(%rip), %rsi     # 0x6f5ba
movl $0xf, %edx
movq %rbx, %rdi
callq 0x8330
leaq 0x61e7f(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x60259(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xf2aa
incl %ebp
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::Block::PrintNode(int, std::ostream&)
void Block::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "Block" << LINE_NO << std::endl;
  for (const auto &ele : this->statement_list_) {
    ele->PRINT_NODE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x600db(%rip), %rsi     # 0x6f5dd
movl $0x5, %edx
movq %rbx, %rdi
callq 0x8330
leaq 0x61b99(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x5ff73(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xf593
incl %ebp
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x18(%rax)
addq $0x8, %r15
cmpq %r14, %r15
jne 0xf57c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::DeclareStatement::PrintNode(int, std::ostream&)
void DeclareStatement::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "DeclareStatement Type: " << TYPE_STRING(this->type_) << LINE_NO
          << std::endl;
  for (const auto &ele : define_list_) {
    ele->PRINT_NODE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x5ff99(%rip), %rsi     # 0x6f5e3
movl $0x17, %edx
movq %rbx, %rdi
callq 0x8330
movl 0xc(%r14), %eax
cmpl $0x122, %eax            # imm = 0x122
leaq 0x5fef7(%rip), %rcx     # 0x6f55e
leaq 0x61a56(%rip), %rdx     # 0x710c4
cmoveq %rcx, %rdx
cmpl $0x121, %eax            # imm = 0x121
leaq 0x60511(%rip), %r15     # 0x6fb8f
cmovneq %rdx, %r15
movq %r15, %rdi
callq 0x8160
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8330
leaq 0x61a10(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x5fdea(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xf71c
incl %ebp
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rdx
callq *0x18(%rax)
addq $0x8, %r15
cmpq %r14, %r15
jne 0xf705
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ArrayInitVal::~ArrayInitVal()
ArrayInitVal::~ArrayInitVal() {
  if (nullptr != this->value_) {
    delete this->value_;
  }
  for (auto &ptr : this->initval_list_) {
    delete ptr;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x7f2fd(%rip), %rax     # 0x8ea58
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xf76d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %r15
cmpq %r15, %r14
je 0xf78e
movq (%r14), %rdi
testq %rdi, %rdi
je 0xf788
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0xf775
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xf7a8
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x82a0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::ArrayInitVal::PrintNode(int, std::ostream&)
void ArrayInitVal::PrintNode(int indentation, std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "ArrayInitVal" << LINE_NO << std::endl;
  if (this->is_exp_ && nullptr != this->value_) {
    this->value_->PRINT_NODE;
  }
  for (const auto &ele : this->initval_list_) {
    ele->PRINT_NODE;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x5fe13(%rip), %rsi     # 0x6f5fb
movl $0xc, %edx
movq %rbx, %rdi
callq 0x8330
leaq 0x618b3(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8330
movl 0x8(%r15), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r12
leaq 0x5fc8d(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r12, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
cmpb $0x1, 0xc(%r15)
jne 0xf871
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xf871
leal 0x1(%r14), %esi
movq (%rdi), %rax
movq %rbx, %rdx
callq *0x20(%rax)
movq 0x18(%r15), %r12
movq 0x20(%r15), %r15
cmpq %r15, %r12
je 0xf89a
incl %r14d
movq (%r12), %rdi
movq (%rdi), %rax
movl %r14d, %esi
movq %rbx, %rdx
callq *0x20(%rax)
addq $0x8, %r12
cmpq %r15, %r12
jne 0xf881
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/luooofan[P]hblzbd_compiler/src/ast.cpp
// Function: ast::FunctionFormalParameter::PrintNode(int, std::ostream&)
void FunctionFormalParameter::PrintNode(int indentation,
                                        std::ostream &outfile) {
  PRINT_INDENT;
  outfile << "FunctionFormalParameter Type: " << TYPE_STRING(this->type_)
          << LINE_NO << std::endl;
  this->name_.PRINT_NODE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
callq 0xd8c4
leaq 0x5fce6(%rip), %rsi     # 0x6f608
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x8330
movl 0xc(%r14), %eax
cmpl $0x122, %eax            # imm = 0x122
leaq 0x5fc1f(%rip), %rcx     # 0x6f55e
leaq 0x6177e(%rip), %rdx     # 0x710c4
cmoveq %rcx, %rdx
cmpl $0x121, %eax            # imm = 0x121
leaq 0x60239(%rip), %r15     # 0x6fb8f
cmovneq %rdx, %r15
movq %r15, %rdi
callq 0x8160
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8330
leaq 0x61738(%rip), %rsi     # 0x710af
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8330
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x8520
movq %rax, %r15
leaq 0x5fb12(%rip), %rsi     # 0x6f4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x8330
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x8270
movsbl %al, %esi
movq %r15, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81f0
movq 0x10(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax