LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/XxAdi101xX[P]ChamberCrawler/Messaging/Messaging.cc
// Function: potionToText[abi:cxx11](std::shared_ptr<Potion>)
string potionToText(const shared_ptr<Potion> potion) {
	PotionType type = potion->getPotionType();
	bool used = false;

	// check if player has used potion
	for (auto usedPotion: usedPotions) {
		if (usedPotion == type) {
			used = true;
			break;
		}

	}

	if (used) {
		return potionTypes[type] + " " + NAME_ITEM_POTION;
	}

	return NAME_POTION_UNKNOWN + " " + NAME_ITEM_POTION;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x1a3e4
movl %eax, 0x2c(%rsp)
leaq 0xf5cc(%rip), %rcx      # 0x2a098
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
cmpq %rcx, %rdx
je 0x1ab5f
addq $0x4, %rdx
xorl %esi, %esi
movl $0x1, %edi
movzbl %sil, %esi
cmpl %eax, -0x4(%rdx)
cmovel %edi, %esi
je 0x1aaff
leaq 0x4(%rdx), %r8
cmpq %rcx, %rdx
movq %r8, %rdx
jne 0x1aae7
testb $0x1, %sil
je 0x1ab5f
leaq 0x11b44(%rip), %rdi     # 0x2c650
leaq 0x2c(%rsp), %rsi
callq 0x1b088
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x193f0
leaq 0x4fda(%rip), %rsi      # 0x1fb17
movq %r14, %rdi
callq 0x5420
movq 0x11a14(%rip), %rsi     # 0x2c560
movq 0x11a15(%rip), %rdx     # 0x2c568
leaq 0x8(%rsp), %rdi
callq 0x5100
jmp 0x1abad
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x119d1(%rip), %rsi     # 0x2c540
movq 0x119d2(%rip), %rdx     # 0x2c548
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x193f0
leaq 0x4f8a(%rip), %rsi      # 0x1fb17
movq %r14, %rdi
callq 0x5420
movq 0x119c4(%rip), %rsi     # 0x2c560
movq 0x119c5(%rip), %rdx     # 0x2c568
leaq 0x8(%rsp), %rdi
callq 0x5100
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x1abcf
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x1abd5
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ac03
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5280
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1ac16
jmp 0x1ac16
jmp 0x1ac16
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ac30
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5280
movq %rbx, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/XxAdi101xX[P]ChamberCrawler/Messaging/Messaging.cc
// Function: itemToText[abi:cxx11](std::shared_ptr<Item>)
string itemToText(const shared_ptr<Item> item) {
    if (item == nullptr) {
        return "";
    }

    else if (item->getItemType() == ItemType::GoldPile) {
        return goldPileToText(static_pointer_cast<GoldPile>(item));
    }

    else if (item->getItemType() == ItemType::Potion) {
        return potionToText(static_pointer_cast<Potion>(item));
    }

	return "";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1ac8a
movq %rsi, %r14
callq 0x1a366
testl %eax, %eax
je 0x1aca5
movq (%r14), %rdi
callq 0x1a366
cmpl $0x1, %eax
jne 0x1ac8a
movq (%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1ace8
movq 0xe328(%rip), %rcx      # 0x28fa8
cmpb $0x0, (%rcx)
je 0x1ace4
incl 0x8(%rax)
jmp 0x1ace8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5619(%rip), %rdx      # 0x202b1
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x12306
jmp 0x1ad04
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x1acd0
movq 0xe2e6(%rip), %rcx      # 0x28fa8
cmpb $0x0, (%rcx)
je 0x1accc
incl 0x8(%rax)
jmp 0x1acd0
lock
incl 0x8(%rax)
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x1aa68
movq 0x20(%rsp), %rdi
jmp 0x1acfa
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1aaad
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ad04
callq 0x12250
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x1ad21
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1ad2b
callq 0x12250
movq %rbx, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/XxAdi101xX[P]ChamberCrawler/TextDisplay/TextDisplay.cc
// Function: TextDisplay::TextDisplay(std::vector<int, std::allocator<int>>)
TextDisplay::TextDisplay(std::vector<int> gridSize):
    gridSize {gridSize}
    {
        for (int i = 0; i < gridSize[0]; ++i) {
            theDisplay.push_back(std::vector<char>());
            for (int j = 0; j < gridSize[1]; ++j) {
                theDisplay[i].push_back(' ');
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xca35(%rip), %rax      # 0x28cf0
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x11fd4
movq %r14, (%rsp)
leaq 0x20(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq $0x0, 0x30(%rbx)
leaq 0x38(%rbx), %rdi
movq %rdi, 0x30(%rsp)
callq 0x51d0
xorps %xmm0, %xmm0
movups %xmm0, 0x1d8(%rbx)
xorl %eax, %eax
movq %rax, 0x1e8(%rbx)
leaq 0x208(%rbx), %rcx
movq %rcx, 0x1f8(%rbx)
movq %rax, 0x200(%rbx)
movb %al, 0x208(%rbx)
movb %al, 0x218(%rbx)
movq %rbx, 0x8(%rsp)
movl $0x1, 0x220(%rbx)
movq (%r13), %rax
cmpl $0x0, (%rax)
jle 0x1c3ce
movq 0x8(%rsp), %rax
addq $0x1c0, %rax            # imm = 0x1C0
movq %rax, 0x28(%rsp)
xorl %r14d, %r14d
leaq 0x10(%rsp), %rbp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x1ca66
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c38a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x5280
movq (%r13), %rax
cmpl $0x0, 0x4(%rax)
jle 0x1c3bf
xorl %r12d, %r12d
leaq (%r14,%r14,2), %rbx
shlq $0x3, %rbx
movq (%r15), %rdi
addq %rbx, %rdi
movb $0x20, 0x10(%rsp)
movq %rbp, %rsi
callq 0x1cc7e
incl %r12d
movq (%r13), %rax
cmpl 0x4(%rax), %r12d
jl 0x1c39f
incq %r14
movq (%r13), %rax
movslq (%rax), %rax
cmpq %rax, %r14
jl 0x1c357
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
jmp 0x1c432
movq %rax, %r13
jmp 0x1c452
movq %rax, %r13
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c406
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x5280
jmp 0x1c406
movq %rax, %r13
movq 0x28(%rsp), %rdi
callq 0x120f8
movq 0xcb71(%rip), %rsi      # 0x28f88
movq 0x30(%rsp), %rdi
callq 0x51f0
movq 0x8(%rsp), %rbx
leaq 0xb8(%rbx), %rdi
callq 0x5110
movq (%rsp), %r14
movq %r15, %rdi
callq 0x13b78
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c452
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x5280
movq %rbx, %rdi
callq 0x1bf44
movq %r13, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/XxAdi101xX[P]ChamberCrawler/TextDisplay/TextDisplay.cc
// Function: TextDisplay::setGridSize(std::vector<int, std::allocator<int>>)
void TextDisplay::setGridSize(std::vector<int> size) {
    gridSize = size;
    theDisplay = std::vector<std::vector<char>>();
    for (int i = 0; i < gridSize[0]; ++i) {
        theDisplay.push_back(std::vector<char>());
        for (int j = 0; j < gridSize[1]; ++j) {
            theDisplay[i].push_back(' ');
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x1564a
xorl %eax, %eax
leaq 0x20(%rsp), %r15
movq %rax, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq 0x20(%rbx), %rax
movups 0x28(%rbx), %xmm0
movq (%r15), %rcx
movq %rcx, 0x20(%rbx)
movq 0x8(%r15), %rcx
movq %rcx, 0x28(%rbx)
movq 0x10(%r15), %rcx
movq %rcx, 0x30(%rbx)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%r15)
movq %rdx, 0x8(%r15)
movq %rsi, 0x10(%r15)
callq 0x13b78
movq %r15, %rdi
callq 0x13b78
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax)
jle 0x1c565
addq $0x20, %rbx
xorl %r12d, %r12d
movq %rsp, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1ca66
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c528
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5280
movq (%r14), %rax
cmpl $0x0, 0x4(%rax)
jle 0x1c557
xorl %ebp, %ebp
leaq (%r12,%r12,2), %r13
shlq $0x3, %r13
movq (%rbx), %rdi
addq %r13, %rdi
movb $0x20, (%rsp)
movq %r15, %rsi
callq 0x1cc7e
incl %ebp
movq (%r14), %rax
cmpl 0x4(%rax), %ebp
jl 0x1c53b
incq %r12
movq (%r14), %rax
movslq (%rax), %rax
cmpq %rax, %r12
jl 0x1c4f7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c58d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5280
movq %rbx, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/XxAdi101xX[P]ChamberCrawler/TextDisplay/TextDisplay.cc
// Function: TextDisplay::notify(Subject&)
void TextDisplay::notify(Subject &notifier) {
    Info i = notifier.getInfo();
    if (i.isCellInfo) {
        info.coordinates = i.coordinates;
        info.displayChar = i.displayChar;
        theDisplay[info.coordinates[0]][info.coordinates[1]] = info.displayChar;
    }
    else {

        info.lastAction = i.lastAction;
        info.race = i.race;
        info.gold = i.gold;
        info.HP = i.HP;
        info.attackValue = i.attackValue;
        info.defenceValue = i.defenceValue;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *(%rax)
cmpb $0x1, 0x58(%r14)
jne 0x1c5ee
leaq 0x20(%rsp), %rsi
leaq 0x1d8(%rbx), %rdi
callq 0x1564a
movb 0x38(%rsp), %al
movb %al, 0x1f0(%rbx)
movq 0x20(%rbx), %rcx
movq 0x1d8(%rbx), %rdx
movslq (%rdx), %rsi
leaq (%rsi,%rsi,2), %rsi
movslq 0x4(%rdx), %rdx
movq (%rcx,%rsi,8), %rcx
movb %al, (%rcx,%rdx)
jmp 0x1c631
leaq 0x40(%rsp), %rsi
leaq 0x1f8(%rbx), %rdi
callq 0x5180
movl 0x8(%rsp), %eax
movl %eax, 0x1c0(%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x1c4(%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x1c8(%rbx)
movl 0x14(%rsp), %eax
movl %eax, 0x1cc(%rbx)
movl 0x18(%rsp), %eax
movl %eax, 0x1d0(%rbx)
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c64c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x5280
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1c663
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x5280
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x120f8
movq %rbx, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/XxAdi101xX[P]ChamberCrawler/Floor/Floor.cc
// Function: Floor::getStairCoords()
vector<int> Floor::getStairCoords() {
    for (int i = 0; i < floorDimensions[0]; ++i) {
        for (int j = 0; j < floorDimensions[1]; ++j) {
			shared_ptr<Cell> tempCell = theFloor[i][j];
			if (tempCell && tempCell->getCellType() == CellType::Stairs) {
				return vector<int>{i,j};
			}
        }
    }
	throw 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x20(%rsi), %rax
cmpl $0x0, (%rax)
setg %al
jle 0x1d53a
movq %rsi, %r14
movq $0x0, 0x10(%rsp)
movb %al, 0xe(%rsp)
movq 0x20(%r14), %rax
cmpl $0x0, 0x4(%rax)
setg %bl
jle 0x1d51a
movl $0x8, %r12d
movq 0x10(%rsp), %rax
leaq (%rax,%rax,2), %rbp
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%rbp,8), %rax
movq -0x8(%rax,%r12), %rdi
movq (%rax,%r12), %r13
testq %r13, %r13
je 0x1d4ac
movq 0xbb0c(%rip), %rax      # 0x28fa8
cmpb $0x0, (%rax)
je 0x1d4a7
incl 0x8(%r13)
jmp 0x1d4ac
lock
incl 0x8(%r13)
testq %rdi, %rdi
je 0x1d4bb
callq 0x14f2c
cmpl $0x4, %eax
je 0x1d4e1
testq %r13, %r13
je 0x1d4c8
movq %r13, %rdi
callq 0x12250
incq %r15
movq 0x20(%r14), %rax
movslq 0x4(%rax), %rax
addq $0x10, %r12
cmpq %rax, %r15
setl %bl
jl 0x1d480
jmp 0x1d51a
movq 0x10(%rsp), %rax
movl %eax, 0x20(%rsp)
movl %r15d, 0x24(%rsp)
movl $0x2, %edx
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0xf(%rsp), %rcx
callq 0x11f84
testq %r13, %r13
je 0x1d515
movq %r13, %rdi
callq 0x12250
testb $0x1, %bl
jne 0x1d55b
movq 0x10(%rsp), %rdx
incq %rdx
movq 0x20(%r14), %rax
movslq (%rax), %rax
movq %rdx, 0x10(%rsp)
cmpq %rax, %rdx
setl %al
jl 0x1d459
movl $0x4, %edi
callq 0x5160
movl $0x1, (%rax)
movq 0xba2f(%rip), %rsi      # 0x28f80
movq %rax, %rdi
xorl %edx, %edx
callq 0x53c0
testb $0x1, 0xe(%rsp)
je 0x1d53a
movq 0x18(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d578
movq %rax, %rbx
testq %r13, %r13
je 0x1d588
movq %r13, %rdi
callq 0x12250
movq %rbx, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_import_packages.cpp
// Function: import_packages<double>::import_packages(exprtk::symbol_table<double>&)
import_packages(symbol_table_t& symbol_table)
   : igfun_t("S")
   , symbol_table_(symbol_table)
   {
      igfun_t::has_side_effects() = false;

      package_map_.emplace(
         "exprtk.rtl.io"     ,
         [&](symbol_table_t& symbtab) -> bool { return symbtab.add_package(io_package); });

      package_map_.emplace(
         "exprtk.rtl.io.file",
         [&](symbol_table_t& symbtab) -> bool { return symbtab.add_package(file_package); });

      package_map_.emplace(
         "exprtk.rtl.vecops" ,
         [&](symbol_table_t& symbtab) -> bool { return symbtab.add_package(vector_package); });
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ba364(%rip), %rsi    # 0x2d6ae2
leaq 0x1ba35e(%rip), %rdx    # 0x2d6ae3
leaq 0x8(%rsp), %rdi
callq 0x11c682
movw $0x100, 0x8(%rbx)       # imm = 0x100
movq $0x0, 0x10(%rbx)
movq $-0x1, 0x18(%rbx)
leaq 0x2c33dc(%rip), %rax    # 0x3dfb88
movq %rax, (%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %r12
movq %r12, 0x20(%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
callq 0x11e998
movl $0x0, 0x40(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x11c7eb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1190b0
leaq 0x2c3306(%rip), %rax    # 0x3dfaf8
movq %rax, (%rbx)
movq %r14, 0x48(%rbx)
leaq 0x50(%rbx), %r14
leaq 0x58(%rbx), %rax
movl $0x0, 0x58(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movq %rax, 0x70(%rbx)
movq %rcx, 0x78(%rbx)
leaq 0x80(%rbx), %r15
movq %r15, %rdi
callq 0x11eeb8
leaq 0x150(%rbx), %r13
movq %r13, %rdi
callq 0x11ef98
leaq 0x2c0(%rbx), %rbp
movq %rbp, %rdi
callq 0x11f0ba
movb $0x0, 0x9(%rbx)
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x1ba248(%rip), %rsi    # 0x2d6aa2
movq %r14, %rdi
callq 0x126e8a
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x1ba23f(%rip), %rsi    # 0x2d6ab0
movq %r14, %rdi
callq 0x127232
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x1ba23b(%rip), %rsi    # 0x2d6ac3
movq %r14, %rdi
callq 0x128f0e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11c8a3
jmp 0x11c8a3
movq %rax, (%rsp)
movq %rbp, %rdi
callq 0x11f764
jmp 0x11c8b5
movq %rax, (%rsp)
movq %r13, %rdi
callq 0x11fb7a
jmp 0x11c8c3
movq %rax, (%rsp)
movq %r15, %rdi
callq 0x11fc1e
movq %r14, %rdi
callq 0x129a48
leaq 0x2c32ae(%rip), %rax    # 0x3dfb88
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
cmpq %r12, %rdi
je 0x11c913
movq (%r12), %rsi
incq %rsi
callq 0x1190b0
jmp 0x11c913
movq %rax, (%rsp)
jmp 0x11c8cb
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x11c913
movq 0x18(%rsp), %rsi
jmp 0x11c8ea
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x119360
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_import_packages.cpp
// Function: import_packages<double>::operator()(exprtk::type_store<double>::parameter_list)
inline T operator()(parameter_list_t parameters) override
   {
      const string_t package(parameters[0]);

      const auto itr = package_map_.find(exprtk::to_str(package));

      if (package_map_.end() == itr)
      {
         return T(0);
      }

      return itr->second(symbol_table_) ? T(1) : T(0);
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
leaq 0x50(%rdi), %r14
leaq 0x18(%rsp), %r12
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x11c682
movq %r14, %rdi
movq %r15, %rsi
callq 0x129aa4
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11fd21
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1190b0
leaq 0x58(%rbx), %rax
cmpq %r14, %rax
je 0x11fd44
cmpq $0x0, 0x50(%r14)
je 0x11fd5d
movq %r14, %rdi
addq $0x40, %rdi
movq 0x48(%rbx), %rsi
callq *0x58(%r14)
testb %al, %al
jne 0x11fd49
xorps %xmm0, %xmm0
jmp 0x11fd51
movsd 0x1b238f(%rip), %xmm0   # 0x2d20e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1195a0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11fd7c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1190b0
movq %rbx, %rdi
callq 0x119360
// File: /workspace/github_cpp_makefile_star2_O1/ConsoleTVs[P]VirtualMachine/src/values.cpp
// Function: VM::Value::to_float()
float Value::to_float()
{
    switch (this->type) {
        case VALUE_INTEGER: { return (float) this->ivalue; }
        case VALUE_FLOAT: { return (float) this->fvalue; }
        case VALUE_BOOLEAN: { return this->bvalue ? 1 : 0; }
        case VALUE_STRING: { return (float) this->svalue->length(); }
        case VALUE_LIST: { return (float) this->lvalue->size(); }
        default: { printf("Error converting value to int.\n"); }
    }
}

// Assembly:
movzbl (%rdi), %eax
cmpq $0x4, %rax
ja 0x274c
leaq 0xaa0(%rip), %rcx       # 0x3194
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2ssl 0x8(%rdi), %xmm0
retq
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x3, %rax
js 0x2730
cvtsi2ss %rax, %xmm0
retq
movsbl 0x8(%rdi), %eax
cvtsi2ss %eax, %xmm0
retq
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
jns 0x2714
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
retq
movss 0x8(%rdi), %xmm0
retq
pushq %rax
callq 0x11a3
// File: /workspace/github_cpp_makefile_star2_O1/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
mapped_type& operator[](const key_type& key)
    {
	iterator i = find(key);

	if (i == end())
	    i = insert(std::make_pair(key, mapped_type())).first;

	return i->second;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %rdx
callq 0x22f2
movq %rax, %r14
cmpq %r15, %rax
jne 0x1a81
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x1ef4
movl $0x0, 0x20(%r14)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rax
cmpq %r13, %rax
je 0x1a18
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x1a22
movups (%r13), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rsp), %rax
leaq 0x28(%rsp), %rcx
movq %rax, 0x8(%rcx)
movq %r13, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movl $0x0, 0x20(%rcx)
leaq 0x2(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2352
movq %rax, %r14
testb $0x1, %dl
je 0x1a64
incq 0x50(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a73
callq 0x1090
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1a81
callq 0x1090
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x1a9d
movq %r14, %rcx
andb $-0x3, 0x2c(%rcx)
movq %rax, %rcx
movq 0x40(%rax), %rax
testq %rax, %rax
jne 0x1a8d
addq $0x20, %r14
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1ac4
callq 0x1090
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ad2
callq 0x1090
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O1/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::copy_subtree(std::allocator<summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node>&, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static node *copy_subtree(node_allocator& alloc, node *new_parent,
			      node *src)
    {
	if (!src)
	    return 0;

	node *copy = new_node(alloc, src->value);

	try {
	    copy->flags = src->flags;
	    copy->sum = src->sum;
	    copy->parent = new_parent;
	    copy->left = copy_subtree(alloc, copy, src->left);
	    copy->right = copy_subtree(alloc, copy, src->right);
	} catch (...) {
	    delete_tree(alloc, copy);
	    throw;
	}

	return copy;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x1e3b
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rsi
callq 0x1e7c
movq %rax, %rbx
movl 0x2c(%r15), %eax
movl %eax, 0x2c(%rbx)
movl 0x28(%r15), %eax
movl %eax, 0x28(%rbx)
movq %r12, 0x40(%rbx)
movq 0x30(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1de0
movq %rax, 0x30(%rbx)
movq 0x38(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1de0
movq %rax, 0x38(%rbx)
jmp 0x1e3d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1050
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c92
callq 0x10b0
movq %rax, %rbx
callq 0x10c0
movq %rbx, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1c86
// File: /workspace/github_cpp_makefile_star2_O1/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::find_ge(std::less<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&, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static node *find_ge(const key_compare& cmp, const key_type& target,
			 node *header)
    {
	node *n = header->left;
	node *best = header;

	while (n) {
	    if (cmp(n->value.first, target)) {
		n = n->right;
	    } else if (cmp(target, n->value.first)) {
		best = n;
		n = n->left;
	    } else {
		return n;
	    }
	}

	return best;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq 0x30(%rdx), %rbx
testq %rbx, %rbx
je 0x2595
movq %rsi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1030
testl %eax, %eax
js 0x2582
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1030
movl $0x30, %ecx
movq %rbx, %r15
testl %eax, %eax
js 0x2587
jmp 0x2592
movl $0x38, %ecx
movq (%rbx,%rcx), %rbx
testq %rbx, %rbx
jne 0x255a
jmp 0x2595
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x25a0
movq %rax, %rdi
callq 0x1c86
// File: /workspace/github_cpp_makefile_star2_O1/Baobaobear[P]sort/./sortlib.hpp
// Function: void baobao::internal::max_heapify_p<int*, std::less<int>>(int*, int*, int*, std::less<int>)
void max_heapify_p(RandomAccessIterator first, RandomAccessIterator target, RandomAccessIterator last, Comp compare)
{
    typename std::iterator_traits<RandomAccessIterator>::value_type temp = *target;
    --first;
    RandomAccessIterator son;
    for (; (son = target + (target - first)) <= last; target = son)
    {
        if (son < last && compare(*son, *(son + 1)))
            ++son;
        if (compare(temp, *son))
            *target = *son;
        else
            break;
    }
    *target = temp;
}

// Assembly:
movl (%rsi), %eax
addq $-0x4, %rdi
movq %rsi, %rcx
subq %rdi, %rcx
addq %rsi, %rcx
cmpq %rdx, %rcx
jbe 0x571e
movq %rsi, %r8
jmp 0x574c
cmpq %rdx, %rcx
jae 0x5730
movl (%rcx), %r8d
cmpl 0x4(%rcx), %r8d
jge 0x5730
addq $0x4, %rcx
movq %rcx, %r8
movl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x5719
movl %ecx, (%rsi)
movq %r8, %rcx
subq %rdi, %rcx
addq %r8, %rcx
movq %r8, %rsi
cmpq %rdx, %rcx
jbe 0x571e
movl %eax, (%r8)
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_02_03.cc
// Function: main
int main(int argc, char const *argv[])
{
	cout << compare(1.1f, 1.2f) << endl;

	std::vector<int> vect1{1, 2, 3};
	std::vector<int> vect2{4, 5, 6};
	cout << compare(vect1, vect2) << endl;

	// Sales_data data1, data2;
	// cout << compare(data1, data2) << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq 0x2d7c(%rip), %rdi      # 0x3fd8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
leaq -0x40(%rbp), %rdi
leaq -0x4c(%rbp), %rbx
movl $0x3, %edx
movq %rbx, %rcx
callq 0x139a
movabsq $0x500000004, %rax      # imm = 0x500000004
movq %rax, (%rbx)
movl $0x6, 0x8(%rbx)
leaq -0x28(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
leaq -0x9(%rbp), %rcx
movl $0x3, %edx
callq 0x139a
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13df
movq 0x2cdd(%rip), %rdi      # 0x3fd8
movl %eax, %esi
callq 0x10e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x1341
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x1356
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x137c
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x137c
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x1391
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
movq %rbx, %rdi
callq 0x10f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/IdelCoder[P]PTransE-ag/Test_TransE_path.cpp
// Function: vec_len(std::vector<double, std::allocator<double>>)
double vec_len(vector<double> a)
{
	double res=0;
	for (int i=0; i<a.size(); i++)
		res+=a[i]*a[i];
	return sqrt(res);
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
subq %rax, %rcx
je 0x2957
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x2942
ucomisd %xmm1, %xmm0
jb 0x2180
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/IdelCoder[P]PTransE-ag/Test_TransE_path.cpp
// Function: main
int main(int argc,char**argv)
{
    if (argc<2)
        return 0;
    else
    {
        version = argv[1];
        if (argc==3)
            used = argv[2];
        prepare();
        test.run();
    }
}

// Assembly:
cmpl $0x2, %edi
jl 0x423f
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %r14
movq 0xb096(%rip), %r15      # 0xf268
leaq 0xb087(%rip), %r12      # 0xf260
movq %r14, %rdi
callq 0x20f0
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x2280
cmpl $0x3, %ebp
jne 0x4226
movq 0x10(%rbx), %rbx
movq 0xaffc(%rip), %r14      # 0xf200
leaq 0xafed(%rip), %r15      # 0xf1f8
movq %rbx, %rdi
callq 0x20f0
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x2280
callq 0x2a6e
leaq 0x3bf7e(%rip), %rdi     # 0x401b0
callq 0x48cc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/IdelCoder[P]PTransE-ag/Test_TransE_path.cpp
// Function: Test::add(int, int, int, std::vector<std::pair<std::vector<int, std::allocator<int>>, double>, std::allocator<std::pair<std::vector<int, std::allocator<int>>, double>>>)
void add(int x,int y,int z, vector<pair<vector<int>,double> > path_list)
    {
		if (z!=-1)
		{
        	fb_h.push_back(x);
        	fb_r.push_back(z);
        	fb_l.push_back(y);
			// 保存测试数据的三元组
        	ok[make_pair(x,z)][y]=1;
		}
		if (path_list.size()>0)
		// 保存所有路径信息
		fb_path[make_pair(x,y)] = path_list;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rdi, %r14
movl %esi, 0xc(%rsp)
movl %edx, 0x4(%rsp)
movl %ecx, 0x8(%rsp)
cmpl $-0x1, %ecx
je 0x4570
movq 0x80(%r14), %rax
cmpq 0x88(%r14), %rax
je 0x44c1
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0x80(%r14)
jmp 0x44d2
leaq 0x78(%r14), %rdi
leaq 0xc(%rsp), %rdx
movq %rax, %rsi
callq 0x9a90
movq 0xb0(%r14), %rsi
cmpq 0xb8(%r14), %rsi
je 0x44f5
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xb0(%r14)
jmp 0x4506
leaq 0xa8(%r14), %rdi
leaq 0x8(%rsp), %rdx
callq 0x9a90
movq 0x98(%r14), %rsi
cmpq 0xa0(%r14), %rsi
je 0x4529
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x98(%r14)
jmp 0x453a
leaq 0x90(%r14), %rdi
leaq 0x4(%rsp), %rdx
callq 0x9a90
leaq 0xf0(%r14), %rdi
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
callq 0x6f4c
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x46da
movl $0x1, (%rax)
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x45aa
addq $0xc0, %r14
movl 0xc(%rsp), %eax
movl 0x4(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
movq %r14, %rdi
callq 0x6fda
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7068
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/IdelCoder[P]PTransE-ag/Test_TransE_path.cpp
// Function: Test::calc_path(int, std::vector<int, std::allocator<int>>)
double calc_path(int r1,vector<int> rel_path)
    {
        double sum=0;
        for (int ii=0; ii<n; ii++)
		{
			double tmp = relation_vec[r1][ii];
			for (int j=0; j<rel_path.size(); j++)
				tmp-=relation_vec[rel_path[j]][ii];
	        if (L1_flag)
				sum+=-fabs(tmp);
			else
				sum+=-sqr(tmp);
		}
        return 10+sum;
    }

// Assembly:
movslq 0x68cf(%rip), %rax      # 0xf1cc
testq %rax, %rax
jle 0x8991
pushq %rbx
movslq %esi, %rsi
movq (%rdi), %rcx
leaq (%rsi,%rsi,2), %rsi
movq (%rcx,%rsi,8), %rsi
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
movq %rdx, %r8
subq %rdi, %r8
sarq $0x2, %r8
cmpq $0x1, %r8
adcq $0x0, %r8
movb 0x6893(%rip), %r9b      # 0xf1c8
xorpd %xmm0, %xmm0
xorl %r10d, %r10d
movapd 0x270c(%rip), %xmm1     # 0xb050
movsd (%rsi,%r10,8), %xmm2
cmpq %rdi, %rdx
je 0x896c
xorl %r11d, %r11d
movslq (%rdi,%r11,4), %rbx
leaq (%rbx,%rbx,2), %rbx
movq (%rcx,%rbx,8), %rbx
subsd (%rbx,%r10,8), %xmm2
incq %r11
cmpq %r11, %r8
jne 0x8952
testb %r9b, %r9b
jne 0x8977
mulsd %xmm2, %xmm2
jmp 0x897b
andpd %xmm1, %xmm2
subsd %xmm2, %xmm0
incq %r10
cmpq %rax, %r10
jne 0x8944
addsd 0x26f9(%rip), %xmm0     # 0xb088
popq %rbx
retq
movsd 0x26ef(%rip), %xmm0     # 0xb088
retq
// File: /workspace/github_cpp_makefile_star2_O1/BohangZhang[P]Sorcery-C-Project/ascii_graphics.cc
// Function: display_spell(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
card_template_t display_spell(std::string name,int cost,std::string desc) {
  std::ostringstream oss;
  card_template_t out(CARD_TEMPLATE_SPELL);
  prepare_for_replace(out);
  replace_text_left(out,'N',name);
  oss << cost;
  replace_text_right(out,'C',oss.str());
  replace_text_right(out,'T',"Spell");
  replace_text_left(out,'E',desc);
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x88(%rsp), %rdi
callq 0x5270
leaq 0x26a2c(%rip), %rsi     # 0x34220
movq %rbx, %rdi
callq 0xe3da
movq %rbx, %rdi
callq 0xd638
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
callq 0xb6a4
leaq 0x68(%rsp), %r15
movq %rbx, %rdi
movl $0x4e, %esi
movq %r15, %rdx
callq 0xd669
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xd84c
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x51f0
leaq 0x88(%rsp), %rdi
movl %ebp, %esi
callq 0x5310
leaq 0x90(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x52c0
leaq 0x48(%rsp), %r15
movq %rbx, %rdi
movl $0x43, %esi
movq %r15, %rdx
callq 0xd71d
movq (%r15), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xd89c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x51f0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a03b(%rip), %rsi     # 0x278e8
leaq 0x1a039(%rip), %rdx     # 0x278ed
leaq 0x28(%rsp), %rdi
callq 0xb734
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movl $0x54, %esi
movq %r15, %rdx
callq 0xd71d
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xd8e8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51f0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xb6a4
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movl $0x45, %esi
movq %r14, %rdx
callq 0xd669
movq (%r14), %rdi
cmpq %r15, %rdi
je 0xd92f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51f0
movq 0x26682(%rip), %rsi     # 0x33fb8
leaq 0x88(%rsp), %rdi
callq 0x5120
leaq 0xf8(%rsp), %rdi
callq 0x50b0
movq %rbx, %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd96a
movq %rax, %r14
jmp 0xd975
movq %rax, %r14
movq %rbx, %rdi
callq 0xc96c
movq 0x2663c(%rip), %rsi     # 0x33fb8
leaq 0x88(%rsp), %rdi
callq 0x5120
leaq 0xf8(%rsp), %rdi
callq 0x50b0
movq %r14, %rdi
callq 0x5320
// File: /workspace/github_cpp_makefile_star2_O1/BohangZhang[P]Sorcery-C-Project/enchantment.cc
// Function: Enchantment::attackMinion(int)
void Enchantment::attackMinion(int j)  {
    vector<shared_ptr<Minion>> s = this->master->getGame()->getNoncurrent()->getSlot()->getSlot();
    if (s.size() > j) {
        s[j]->subDefense(this->getAttack());
        this->subDefense(s[j]->getAttack());
    }
    else throw 3; // Number; The opponent player doesn't have the ith minion
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x70(%rdi), %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x17b9e
movq (%r14), %rsi
movq %rsp, %rdi
callq 0x1206a
movq (%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x17bd0
movq 0x10(%rsp), %rdi
callq 0x24706
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x11b20
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x10a09
callq 0xb634
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x10a18
callq 0xb634
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x10a27
callq 0xb634
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movslq %ebp, %r15
cmpq %r15, %rcx
jbe 0x10a91
shlq $0x4, %r15
movq (%rax,%r15), %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq (%r14), %rcx
movq %r14, %rdi
movl %eax, %esi
callq *0xb8(%rcx)
movq 0x20(%rsp), %rax
movq (%rax,%r15), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq *0xb8(%rcx)
leaq 0x20(%rsp), %rdi
callq 0xb5e2
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %edi
callq 0x5100
movl $0x3, (%rax)
movq 0x234e8(%rip), %rsi     # 0x33f90
movq %rax, %rdi
xorl %edx, %edx
callq 0x5300
movq %rax, %rbx
jmp 0x10ace
movq %rax, %rbx
jmp 0x10add
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x10ace
callq 0xb634
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x10add
callq 0xb634
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x10afb
callq 0xb634
jmp 0x10afb
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb5e2
movq %rbx, %rdi
callq 0x5320
nop
// File: /workspace/github_cpp_makefile_star2_O1/BohangZhang[P]Sorcery-C-Project/game.cc
// Function: Game::Game(std::shared_ptr<Player>, std::shared_ptr<Player>)
Game::Game(shared_ptr<Player> player1, shared_ptr<Player> player2) : player1{player1}, player2{player2} {
    curplayer = player1;
    noncurplayer = player2;
    Round = 1;
    eog = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x11f88
movq 0x22046(%rip), %rcx     # 0x33fc0
cmpb $0x0, (%rcx)
je 0x11f84
incl 0x8(%rax)
jmp 0x11f88
lock
incl 0x8(%rax)
leaq 0x8(%rsi), %rax
movq (%r14), %rcx
movq %rcx, 0x18(%rbx)
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rcx
movq %rcx, 0x20(%rbx)
testq %rcx, %rcx
je 0x11fb9
movq 0x22015(%rip), %rdx     # 0x33fc0
cmpb $0x0, (%rdx)
je 0x11fb5
incl 0x8(%rcx)
jmp 0x11fb9
lock
incl 0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
movq (%rsi), %rcx
movq %rcx, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq %rax, %rsi
callq 0xe8da
movq (%r14), %rax
movq %rax, 0x38(%rbx)
leaq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0xe8da
movl $0x1, (%rbx)
movb $0x0, 0x4(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/BohangZhang[P]Sorcery-C-Project/game.cc
// Function: Game::nextTurn()
void Game::nextTurn() {
    notify("End");
    shared_ptr<Player> p = curplayer;
    curplayer = noncurplayer;
    noncurplayer = p;
    ++Round;
    if (Round % 2 == 0) {
        addMagic(2, 1);
        addCard(2);
    } else {
        addMagic(1, 1);
        addCard(1);
    }
    notify("Start");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x168ec(%rip), %rsi     # 0x28a24
leaq 0x168e8(%rip), %rdx     # 0x28a27
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0xb734
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdx
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12304
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x12171
callq 0xb634
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x12188
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x51f0
movq 0x28(%rbx), %rax
leaq 0x8(%rsp), %r14
movq %rax, -0x8(%r14)
leaq 0x30(%rbx), %rdi
movq 0x30(%rbx), %rax
movq %rax, (%r14)
testq %rax, %rax
je 0x121ba
movq 0x21e14(%rip), %rcx     # 0x33fc0
cmpb $0x0, (%rcx)
je 0x121b6
incl 0x8(%rax)
jmp 0x121ba
lock
incl 0x8(%rax)
movq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
leaq 0x40(%rbx), %r15
movq %r15, %rsi
callq 0xe8da
movq (%rsp), %rax
movq %rax, 0x38(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0xe8da
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
testb $0x1, %al
jne 0x12200
movq 0x8(%rbx), %rdi
movl $0x1, %esi
callq 0x17cb0
leaq 0x8(%rbx), %rax
jmp 0x12212
movq 0x18(%rbx), %rdi
movl $0x1, %esi
callq 0x17cb0
leaq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x1d5ae
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x167fe(%rip), %rsi     # 0x28a28
leaq 0x167fc(%rip), %rdx     # 0x28a2d
leaq 0x10(%rsp), %rdi
callq 0xb734
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x12304
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x12262
callq 0xb634
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x12279
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12288
callq 0xb634
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x122a4
callq 0xb634
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x122ed
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51f0
jmp 0x122ed
jmp 0x122ea
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x122d1
callq 0xb634
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x122fc
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x51f0
jmp 0x122fc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x122fc
callq 0xb634
movq %rbx, %rdi
callq 0x5320
// File: /workspace/github_cpp_makefile_star2_O1/BohangZhang[P]Sorcery-C-Project/game.cc
// Function: Game::notify(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<Minion>)
void Game::notify(string t, shared_ptr<Minion> m) {
    if (t == "Enter") {
        this->curplayer->notify("MEnter", m);
        this->noncurplayer->notify("OEnter", m);
    }
    if (t == "Start" || t == "End") {
        this->curplayer->notify(t);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1673e(%rip), %rsi     # 0x28a62
movq %rbx, %rdi
callq 0x50a0
testl %eax, %eax
jne 0x12441
movq 0x28(%r14), %r12
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x16719(%rip), %rsi     # 0x28a61
leaq 0x16718(%rip), %rdx     # 0x28a67
leaq 0x50(%rsp), %rdi
callq 0xb734
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x12384
movq 0x21c4a(%rip), %rcx     # 0x33fc0
cmpb $0x0, (%rcx)
je 0x12380
incl 0x8(%rax)
jmp 0x12384
lock
incl 0x8(%rax)
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x1b418
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x123a5
callq 0xb634
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x123bc
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x51f0
movq 0x38(%r14), %r12
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x16698(%rip), %rsi     # 0x28a68
leaq 0x16697(%rip), %rdx     # 0x28a6e
leaq 0x30(%rsp), %rdi
callq 0xb734
movq (%r15), %rax
movq %rax, (%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1240b
movq 0x21bc3(%rip), %rcx     # 0x33fc0
cmpb $0x0, (%rcx)
je 0x12407
incl 0x8(%rax)
jmp 0x1240b
lock
incl 0x8(%rax)
leaq 0x30(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
callq 0x1b418
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1242a
callq 0xb634
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x12441
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x51f0
leaq 0x165e0(%rip), %rsi     # 0x28a28
movq %rbx, %rdi
callq 0x50a0
testl %eax, %eax
je 0x12467
leaq 0x165c9(%rip), %rsi     # 0x28a24
movq %rbx, %rdi
callq 0x50a0
testl %eax, %eax
jne 0x124cd
movq 0x28(%r14), %r14
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xb6a4
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b418
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x124b3
callq 0xb634
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0x124cd
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x51f0
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x124f0
callq 0xb634
movq 0x30(%rsp), %rdi
jmp 0x12527
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x12509
callq 0xb634
movq 0x50(%rsp), %rdi
jmp 0x12527
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x12522
callq 0xb634
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0x12538
movq (%r13), %rsi
incq %rsi
callq 0x51f0
movq %rbx, %rdi
callq 0x5320
// File: /workspace/github_cpp_makefile_star2_O1/BohangZhang[P]Sorcery-C-Project/game.cc
// Function: Game::boardDisplay()
void Game::boardDisplay() {
    // print player 1
    player1->boardDisplay(1);
    // print center graphic
    for (auto it = CENTRE_GRAPHIC.begin() ; it != CENTRE_GRAPHIC.end(); ++it) {
        cout << *it;
        std::cout << '\n';
    }  
    // print player 2
    player2->boardDisplay(2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl $0x1, %esi
callq 0x1e1b4
leaq 0x1ea5f(%rip), %r12     # 0x342c8
movq (%r12), %r13
cmpq 0x8(%r12), %r13
je 0x158b0
movq 0x1e74d(%rip), %r14     # 0x33fc8
leaq 0xf(%rsp), %r15
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x5240
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5240
addq $0x20, %r13
cmpq 0x8(%r12), %r13
jne 0x15880
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0x1e1b4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/BohangZhang[P]Sorcery-C-Project/player.cc
// Function: Player::attack(int)
void Player::attack(int i) {
    if (getSlot()->getSize() < i) throw 11; // Number; The Minion doesn't exist
    shared_ptr<Minion> m = getSlot()->getSlot()[i - 1];
    m->attackPlayer();
/*  string type = m->getType();
    if (m->ifDead()) {
        if (type == "Enchantment") {
            shared_ptr<Minion> dead_m = getDatabase()->getMinion(m->getOriginName());
            getGraveyard()->pushfirst(dead_m);
        }
        else {
            shared_ptr<Minion> dead_m = getDatabase()->getMinion(m->getName());
            getGraveyard()->pushfirst(dead_m);
        }
        getSlot()->pop(m);
    } */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movq 0x50(%r14), %rbx
testq %rbx, %rbx
je 0x1ab9a
movq 0x19434(%rip), %rax     # 0x33fc0
cmpb $0x0, (%rax)
je 0x1ab96
incl 0x8(%rbx)
jmp 0x1ab9a
lock
incl 0x8(%rbx)
callq 0x2470a
movl %eax, %r15d
testq %rbx, %rbx
je 0x1abaf
movq %rbx, %rdi
callq 0xb634
cmpl %ebp, %r15d
jl 0x1ac4a
movq 0x48(%r14), %rdi
movq 0x50(%r14), %rbx
testq %rbx, %rbx
je 0x1abda
movq 0x193f4(%rip), %rax     # 0x33fc0
cmpb $0x0, (%rax)
je 0x1abd6
incl 0x8(%rbx)
jmp 0x1abda
lock
incl 0x8(%rbx)
callq 0x24706
movq (%rax), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
movq -0x10(%rax,%rcx), %r15
movq -0x8(%rax,%rcx), %r14
testq %r14, %r14
je 0x1ac0f
movq 0x193c1(%rip), %rax     # 0x33fc0
cmpb $0x0, (%rax)
je 0x1ac0a
incl 0x8(%r14)
jmp 0x1ac0f
lock
incl 0x8(%r14)
testq %rbx, %rbx
je 0x1ac1c
movq %rbx, %rdi
callq 0xb634
movq (%r15), %rax
movq %r15, %rdi
callq *0xc8(%rax)
testq %r14, %r14
je 0x1ac3f
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb634
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %edi
callq 0x5100
movl $0xb, (%rax)
movq 0x1932f(%rip), %rsi     # 0x33f90
movq %rax, %rdi
xorl %edx, %edx
callq 0x5300
movq %rax, %r15
movq %r14, %rbx
testq %r14, %r14
jne 0x1ac82
jmp 0x1ac8a
jmp 0x1ac7a
movq %rax, %r15
testq %rbx, %rbx
je 0x1ac8a
movq %rbx, %rdi
callq 0xb634
movq %r15, %rdi
callq 0x5320