LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Character/Character.cc
// Function: Character::applyItem(std::shared_ptr<Item>)
void Character::applyItem(shared_ptr<Item> item) {
    // gets the item type
    ItemType itemType = item->getItemType();

    // if item is GoldPile
    if (itemType == ItemType::GoldPile) {
        // if GoldPile is not bound
        if (!(static_pointer_cast<GoldPile>(item)->getBoundState())) {
                this->addGold(item->getValue());
        }

    }

    // if item is Potion
    else if (itemType == ItemType::Potion) {
        this->applyPotion(static_pointer_cast<Potion>(item));
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x13abc
cmpl $0x1, %eax
je 0x11ed0
testl %eax, %eax
jne 0x11ef5
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x12c99
movq (%r15), %rdi
callq 0x13a9a
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0xd24a
testb %bpl, %bpl
jne 0x11ef5
movq (%r14), %rdi
callq 0x13ac0
movq %rbx, %rdi
movl %eax, %esi
callq 0x11f56
jmp 0x11ef5
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x12cb5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1105c
leaq 0x10(%rsp), %rdi
callq 0xd24a
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x11f12
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xd24a
movq %rbx, %rdi
callq 0x53c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Character/Character.cc
// Function: Character::addGold(int)
void Character::addGold(int amount) {
	this->wallet += amount;
	this->score += amount;

	this->addAction(makeMsg(this->name, WORD_GAIN_PAST_TENSE, to_string(amount)
		+ " " + WORD_GOLD_NOUN));
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xc8, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x60(%rdi), %xmm0
movd %esi, %xmm1
pshufd $0x50, %xmm1, %xmm1     # xmm1 = xmm1[0,0,1,1]
paddd %xmm0, %xmm1
movq %xmm1, 0x60(%rdi)
leaq 0x88(%rdi), %rsi
leaq 0x88(%rsp), %rdi
callq 0x52e0
leaq 0x142a2(%rip), %rsi     # 0x26238
leaq 0x68(%rsp), %rdi
callq 0x52e0
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x12c40
leaq 0x6be8(%rip), %rdx      # 0x18b9b
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xcdf7
leaq 0x1428f(%rip), %rdx     # 0x26258
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x12b82
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x48(%rsp), %rcx
callq 0x13ce8
addq $0x68, %rbx
leaq 0xa8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5410
leaq 0xa8(%rsp), %rdi
callq 0x5428
leaq 0x48(%rsp), %rdi
callq 0x5428
leaq 0x28(%rsp), %rdi
callq 0x5428
leaq 0x8(%rsp), %rdi
callq 0x5428
leaq 0x68(%rsp), %rdi
callq 0x5428
leaq 0x88(%rsp), %rdi
callq 0x5428
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x5428
jmp 0x1206c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5428
jmp 0x1207b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5428
jmp 0x1208a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5428
jmp 0x12099
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5428
leaq 0x88(%rsp), %rdi
callq 0x5428
movq %rbx, %rdi
callq 0x53c0
movq %rax, %rbx
jmp 0x120a3
nop
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Character/Character.cc
// Function: Character::setPlayer()
void Character::setPlayer() {
	this->isPlayer = true;
	this->isHostile = false;
	this->wallet = 0;
	this->name = NAME_PLAYER;
}

// Assembly:
movw $0x100, 0x48(%rdi)      # imm = 0x100
andl $0x0, 0x60(%rdi)
addq $0x88, %rdi
leaq 0x13ac8(%rip), %rsi     # 0x264f8
jmp 0x5170
nop
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Character/Elf.cc
// Function: Elf::postAttackRoutine(Character&, bool, Generator&)
void Elf::postAttackRoutine(Character& defender, bool hit, Generator& rng) {
	// not attacking again if already attacked or target is Drow
	if (extraAttacks == 0 || defender.getRace() == Race::Drow) {
		this->extraAttacks = ELF_NUMBER_OF_EXTRA_ATTACKS;
		return;
	}

	--(this->extraAttacks);

	// recursive call to attack, attack will
	// call postAttackRoutine again, but
	// will get stopped by base case
	this->attack(defender, rng);

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
cmpl $0x0, 0xa8(%rdi)
je 0x13358
movq %rcx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x12a68
cmpl $0x1, %eax
jne 0x13369
movl $0x1, 0xa8(%r15)
popq %rbx
popq %r14
popq %r15
retq
decl 0xa8(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x12174
nop
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Character/Human.cc
// Function: Human::deathRoutine()
void Human::deathRoutine() {
	vector<shared_ptr<Cell>> neighbourHood
		= (this->getCurrentCell())->getNeighbours();

	int numberOfGoldPilesAlreadyDropped = 0;


	for (auto neighbour : neighbourHood) {
		// if there is no item or character on a neighbouring cell
		if (neighbour && !(neighbour->getItem()) && !(neighbour->getOccupant())
            && neighbour->getCellType() == CellType::FloorTile) {
			
			neighbour->setItem
				(make_shared<GoldPile>(HUMAN_DROPPED_GOLD_PILE_VALUE));

			++numberOfGoldPilesAlreadyDropped;
		}

		if (numberOfGoldPilesAlreadyDropped
			== HUMAN_NUMBER_OF_GOLD_PILES_DROPPED) {

			return;
		}

	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x11dfa
movq (%rbx), %rsi
leaq 0x40(%rsp), %rdi
callq 0x109e4
leaq 0x8(%rsp), %rdi
callq 0xd24a
movq 0x40(%rsp), %rbp
movq 0x48(%rsp), %r14
leaq 0x18(%rsp), %r12
xorl %r13d, %r13d
movq %rsp, %r15
leaq 0x10(%rsp), %rbx
cmpq %r14, %rbp
je 0x135c7
movq %r15, %rdi
movq %rbp, %rsi
callq 0xd360
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x13536
movq %rbx, %rdi
callq 0x108f4
cmpq $0x0, 0x10(%rsp)
jne 0x1352e
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x109f6
cmpq $0x0, 0x20(%rsp)
je 0x1354c
leaq 0x28(%rsp), %rdi
callq 0xd24a
movq %r12, %rdi
callq 0xd24a
leaq 0x8(%rsp), %rdi
callq 0xd24a
addq $0x10, %rbp
cmpl $0x2, %r13d
jne 0x134e1
jmp 0x135c7
movq %r12, %r15
movq (%rsp), %rdi
callq 0x108f0
movl %eax, %r12d
leaq 0x28(%rsp), %rdi
callq 0xd24a
movq %r15, %rdi
callq 0xd24a
cmpl $0x1, %r12d
jne 0x135bc
movq (%rsp), %r12
movq %rbx, %rdi
leaq 0x5cff(%rip), %rsi      # 0x19280
callq 0xcfcd
movaps 0x10(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r12, %rdi
leaq 0x30(%rsp), %rsi
callq 0x108c4
leaq 0x38(%rsp), %rdi
callq 0xd24a
leaq 0x18(%rsp), %rdi
callq 0xd24a
incl %r13d
movq %r15, %r12
movq %rsp, %r15
jmp 0x13536
leaq 0x40(%rsp), %rdi
callq 0xd100
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xd24a
leaq 0x18(%rsp), %rdi
jmp 0x1361d
jmp 0x13624
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd24a
jmp 0x1363b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xd24a
jmp 0x1361a
movq %r12, %r15
movq %rax, %rbx
movq %r15, %rdi
callq 0xd24a
jmp 0x13627
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd24a
leaq 0x40(%rsp), %rdi
callq 0xd100
movq %rbx, %rdi
callq 0x53c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Character/Merchant.cc
// Function: Merchant::doStartTurnRoutine(Generator&)
void Merchant::doStartTurnRoutine(Generator& rng) {
	// makes merchant hostile if
	// player has killed a merchant before
	if (merchantsAngered) {
		this->setHostile();
	}

	if (this->getHP() != MERCHANT_HP_MAX) {
		merchantsAngered = true;
		this->setHostile();
	}

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x119eb(%rip), %r14     # 0x2508d
cmpb $0x1, (%r14)
jne 0x136b3
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x11f50
movq %rbx, %rdi
callq 0x111d6
cmpl $0x1e, %eax
jne 0x136c8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, (%r14)
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11f50
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Character/Merchant.cc
// Function: Merchant::deathRoutine()
void Merchant::deathRoutine() {
	vector<shared_ptr<Cell>> neighbourHood 
		= (this->getCurrentCell())->getNeighbours();

	int numberOfGoldPilesAlreadyDropped = 0;

	for (auto neighbour : neighbourHood) {
		// if there is no item or character on a neighbouring cell
		if (neighbour && !(neighbour->getItem()) && !(neighbour->getOccupant())
			&& neighbour->getCellType() == CellType::FloorTile) {

			neighbour->setItem
			(make_shared<GoldPile>(MERCHANT_DROPPED_GOLD_PILE_VALUE));

			++numberOfGoldPilesAlreadyDropped;
		}

		if (numberOfGoldPilesAlreadyDropped
			== MERCHANT_NUMBER_OF_GOLD_PILES_DROPPED) {

			return;
		}

	}

	merchantsAngered = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x11dfa
movq (%rbx), %rsi
leaq 0x40(%rsp), %rdi
callq 0x109e4
leaq 0x8(%rsp), %rdi
callq 0xd24a
movq 0x40(%rsp), %rbp
movq 0x48(%rsp), %r14
leaq 0x18(%rsp), %r12
xorl %r13d, %r13d
movq %rsp, %r15
leaq 0x10(%rsp), %rbx
cmpq %r14, %rbp
je 0x13814
movq %r15, %rdi
movq %rbp, %rsi
callq 0xd360
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x13780
movq %rbx, %rdi
callq 0x108f4
cmpq $0x0, 0x10(%rsp)
jne 0x13778
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x109f6
cmpq $0x0, 0x20(%rsp)
je 0x13799
leaq 0x28(%rsp), %rdi
callq 0xd24a
movq %r12, %rdi
callq 0xd24a
leaq 0x8(%rsp), %rdi
callq 0xd24a
addq $0x10, %rbp
cmpl $0x1, %r13d
jne 0x1372b
jmp 0x1381e
movq %r12, %r15
movq (%rsp), %rdi
callq 0x108f0
movl %eax, %r12d
leaq 0x28(%rsp), %rdi
callq 0xd24a
movq %r15, %rdi
callq 0xd24a
cmpl $0x1, %r12d
jne 0x13809
movq (%rsp), %r12
movq %rbx, %rdi
leaq 0x5abe(%rip), %rsi      # 0x1928c
callq 0xcfcd
movaps 0x10(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r12, %rdi
leaq 0x30(%rsp), %rsi
callq 0x108c4
leaq 0x38(%rsp), %rdi
callq 0xd24a
leaq 0x18(%rsp), %rdi
callq 0xd24a
incl %r13d
movq %r15, %r12
movq %rsp, %r15
jmp 0x13780
leaq 0x11872(%rip), %rax     # 0x2508d
movb $0x1, (%rax)
leaq 0x40(%rsp), %rdi
callq 0xd100
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xd24a
leaq 0x18(%rsp), %rdi
jmp 0x13874
jmp 0x1387b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd24a
jmp 0x13892
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xd24a
jmp 0x13871
movq %r12, %r15
movq %rax, %rbx
movq %r15, %rdi
callq 0xd24a
jmp 0x1387e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd24a
leaq 0x40(%rsp), %rdi
callq 0xd100
movq %rbx, %rdi
callq 0x53c0
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Character/Orc.cc
// Function: Orc::dealDamageTo(Character&, int&, Generator&)
bool Orc::dealDamageTo(Character& defender, int& damage, Generator& rng) {
	// if race is goblin, deal 50% more damage
	if (defender.getRace() == Race::Goblin) {
		damage *= 1.5;
	}

	return true;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdi
callq 0x12a68
cmpl $0x4, %eax
jne 0x13909
cvtsi2sdl (%rbx), %xmm0
mulsd 0x599d(%rip), %xmm0     # 0x192a0
cvttsd2si %xmm0, %eax
movl %eax, (%rbx)
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Character/Vampire.cc
// Function: Vampire::postAttackRoutine(Character&, bool, Generator&)
void Vampire::postAttackRoutine(Character& defender, bool hit, Generator& rng) {
	// calculates potential HP gain/loss
	int HPToBeAdded = defender.getRace() == Race::Dwarf
		? -1 * VAMPIRE_ON_HIT_HEAL : VAMPIRE_ON_HIT_HEAL;

	// only add if actually hit enemy
	if (hit) {
		this->addHP(HPToBeAdded);
	}

}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x12a68
testl %ebp, %ebp
je 0x13a2c
cmpl $0x6, %eax
pushq $-0x5
popq %rax
pushq $0x5
popq %rsi
cmovel %eax, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11728
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Generator/Generator.cc
// Function: Generator::genNPCRace()
Race Generator::genNPCRace() {
    float r = (float)rand()/INT_MAX;


    r -= HUMAN_SPAWN_CHANCE;
    if (r < 0) {
        return Race::Human;
    }

    r-= DWARF_SPAWN_CHANCE;
    if (r < 0) {
        return Race::Dwarf;
    }

    r-= HALFLING_SPAWN_CHANCE;
    if (r < 0) {
        return Race::Halfling;
    }

    r -= ELF_SPAWN_CHANCE;
    if (r < 0) {
        return Race::Elf;
    }

    r-= ORC_SPAWN_CHANCE;
    if (r < 0) {
        return Race::Orc;
    }



    return Race::Merchant;
}

// Assembly:
pushq %rax
callq 0x50d0
cvtsi2ss %eax, %xmm0
mulss 0x57a4(%rip), %xmm0     # 0x192f4
addss 0x57a0(%rip), %xmm0     # 0x192f8
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x13b64
pushq $0x5
jmp 0x13b95
addss 0x5790(%rip), %xmm0     # 0x192fc
ucomiss %xmm0, %xmm1
jbe 0x13b75
pushq $0x6
jmp 0x13b95
addss 0x5783(%rip), %xmm0     # 0x19300
ucomiss %xmm0, %xmm1
jbe 0x13b86
pushq $0xb
jmp 0x13b95
addss 0x5776(%rip), %xmm0     # 0x19304
ucomiss %xmm0, %xmm1
jbe 0x13b98
pushq $0x7
popq %rax
popq %rcx
retq
addss 0x5764(%rip), %xmm0     # 0x19304
xorl %eax, %eax
ucomiss %xmm0, %xmm1
seta %al
xorl $0x9, %eax
jmp 0x13b96
nop
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Generator/Generator.cc
// Function: Generator::genGold()
int Generator::genGold() {
    float r = (float)rand()/INT_MAX;

    r -= GOLD_PILE_SMALL_SPAWN_CHANCE;

    if (r < 0)
        return GOLD_PILE_SMALL_VALUE;

    r -= GOLD_PILE_NORMAL_SPAWN_CHANCE;

    if (r < 0)
        return GOLD_PILE_NORMAL_VALUE;

    return GOLD_PILE_DRAGON_HOARD_VALUE;
}

// Assembly:
pushq %rax
callq 0x50d0
cvtsi2ss %eax, %xmm0
mulss 0x5724(%rip), %xmm0     # 0x192f4
addss 0x5730(%rip), %xmm0     # 0x19308
movss 0x572c(%rip), %xmm1     # 0x1930c
addss %xmm0, %xmm1
xorps %xmm2, %xmm2
xorl %eax, %eax
ucomiss %xmm1, %xmm2
setbe %al
ucomiss %xmm0, %xmm2
leal 0x2(,%rax,4), %ecx
pushq $0x1
popq %rax
cmovbel %ecx, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/Generator/Generator.cc
// Function: Generator::genNeighbourCoord(std::vector<int, std::allocator<int>>)
std::vector<int> Generator::genNeighbourCoord(std::vector<int> base) {
    Direction d = genDirection();
    switch (d) {
        case Direction::North:
            ++base[0];
            break;
        case Direction::NorthEast:
            ++base[0];
            ++base[1];
            break;
        case Direction::East:
            ++base[1];
            break;
        case Direction::SouthEast:
            --base[0];
            ++base[1];
            break;
        case Direction::South:
            --base[0];
            break;
        case Direction::SouthWest:
            --base[0];
            --base[1];
            break;
        case Direction::West:
            --base[1];
            break;
        case Direction::NorthWest:
            ++base[0];
            --base[1];
            break;
        default:
            break;
    }
    return base;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x50d0
pushq $0x8
popq %rcx
cltd
idivl %ecx
movq (%rbx), %rax
cmpl $0x7, %edx
ja 0x13cc5
pushq $0x1
popq %rcx
leaq 0x5677(%rip), %rsi      # 0x19310
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
incl (%rax)
jmp 0x13cac
incl (%rax)
jmp 0x13cbf
decl (%rax)
leaq 0x4(%rax), %rdx
pushq $-0x1
popq %rcx
jmp 0x13cc3
pushq $-0x1
popq %rcx
movq %rax, %rdx
jmp 0x13cc3
decl (%rax)
leaq 0x4(%rax), %rdx
addl %ecx, (%rdx)
movq %rax, (%r14)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x13b2a
movl %eax, 0x4(%rsp)
leaq 0x1118a(%rip), %rcx     # 0x25090
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
cmpq %rcx, %rdx
je 0x13f59
leaq 0x4(%rdx), %rsi
cmpl %eax, (%rdx)
movq %rsi, %rdx
jne 0x13f0d
leaq 0x13724(%rip), %rdi     # 0x27648
leaq 0x4(%rsp), %rsi
callq 0x1429e
leaq 0x4c66(%rip), %rdx      # 0x18b9b
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x12c08
leaq 0x1360c(%rip), %rdx     # 0x27558
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12b82
jmp 0x13f86
leaq 0x135d8(%rip), %rsi     # 0x27538
leaq 0x4c34(%rip), %rdx      # 0x18b9b
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12c08
leaq 0x135dd(%rip), %rdx     # 0x27558
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12b82
leaq 0x8(%rsp), %rdi
callq 0x5428
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x13f9d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5428
movq %rbx, %rdi
callq 0x53c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x14008
movq %rsi, %r15
callq 0x13abc
testl %eax, %eax
je 0x1401e
movq (%r15), %rdi
callq 0x13abc
cmpl $0x1, %eax
jne 0x14008
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x12cb5
movq %rbx, %rdi
movq %r12, %rsi
callq 0x13ee9
leaq 0x10(%rsp), %rdi
jmp 0x14043
leaq 0x5322(%rip), %rsi      # 0x19331
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0xcda0
jmp 0x14048
leaq 0x20(%rsp), %r14
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x12c99
movq %rbx, %rdi
movq %r12, %rsi
callq 0x13eb2
leaq 0x20(%rsp), %rdi
callq 0xd24a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x14059
movq %rax, %rbx
movq %r14, %rdi
callq 0xd24a
movq %rbx, %rdi
callq 0x53c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe531(%rip), %rax      # 0x23cf0
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0xcef6
movq %r14, (%rsp)
leaq 0x20(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
andq $0x0, 0x30(%rbx)
leaq 0x38(%rbx), %rdi
movq %rdi, 0x18(%rsp)
callq 0x51b0
xorps %xmm0, %xmm0
movups %xmm0, 0x1d8(%rbx)
andq $0x0, 0x1e8(%rbx)
leaq 0x208(%rbx), %rax
movq %rax, 0x1f8(%rbx)
andq $0x0, 0x200(%rbx)
leaq 0x1c0(%rbx), %rax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
movb %r14b, 0x208(%rbx)
movb %r14b, 0x218(%rbx)
movq %rbx, 0x10(%rsp)
movl $0x1, 0x220(%rbx)
movq (%r13), %rax
leaq 0x20(%rsp), %rbp
movslq (%rax), %rax
cmpq %rax, %r14
jge 0x158a4
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x15c62
movq %rbp, %rdi
callq 0xee20
xorl %r12d, %r12d
imulq $0x18, %r14, %rbx
movq (%r13), %rax
cmpl 0x4(%rax), %r12d
jge 0x1589c
movq (%r15), %rdi
addq %rbx, %rdi
movb $0x20, 0x20(%rsp)
movq %rbp, %rsi
callq 0x15e74
incl %r12d
jmp 0x1587a
incq %r14
xorps %xmm0, %xmm0
jmp 0x1584d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
jmp 0x158e8
movq %rax, %r13
jmp 0x158fc
movq %rax, %r13
leaq 0x20(%rsp), %rdi
callq 0xee20
jmp 0x158cf
movq %rax, %r13
movq 0x8(%rsp), %rdi
callq 0xd0bc
movq 0x18(%rsp), %rdi
callq 0x51d0
movq 0x10(%rsp), %rbx
movq (%rsp), %r14
movq %r15, %rdi
callq 0xedb2
movq %r14, %rdi
callq 0xd484
movq %rbx, %rdi
callq 0x15404
movq %r13, %rdi
callq 0x53c0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %rdi, %r12
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x10e08
leaq 0x20(%r12), %r14
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x15fca
movq %r15, %rdi
callq 0xedb2
movq 0x8(%r12), %rax
xorl %r12d, %r12d
movslq (%rax), %rax
cmpq %rax, %r12
jge 0x159a9
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x15c62
movq %r15, %rdi
callq 0xee20
xorl %ebp, %ebp
imulq $0x18, %r12, %r13
movq (%rbx), %rax
cmpl 0x4(%rax), %ebp
jge 0x159a4
movq (%r14), %rdi
addq %r13, %rdi
movb $0x20, (%rsp)
movq %r15, %rsi
callq 0x15e74
incl %ebp
jmp 0x15986
incq %r12
jmp 0x15958
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xee20
movq %rbx, %rdi
callq 0x53c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsp, %r14
movq %r14, %rdi
callq *(%rax)
cmpb $0x1, 0x58(%r14)
jne 0x15a22
leaq 0x18(%rsp), %rsi
leaq 0x1d8(%rbx), %rdi
callq 0x10e08
movb 0x30(%rsp), %al
movb %al, 0x1f0(%rbx)
movq 0x20(%rbx), %rcx
movq 0x1d8(%rbx), %rdx
movslq (%rdx), %rsi
imulq $0x18, %rsi, %rsi
movslq 0x4(%rdx), %rdx
movq (%rcx,%rsi), %rcx
movb %al, (%rcx,%rdx)
jmp 0x15a48
leaq 0x38(%rsp), %rsi
leaq 0x1f8(%rbx), %rdi
callq 0x5170
movaps (%rsp), %xmm0
movups %xmm0, 0x1c0(%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x1d0(%rbx)
movq %rsp, %rdi
callq 0xd0bc
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd0bc
movq %rbx, %rdi
callq 0x53c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/XxAdi101xX[P]ChamberCrawler/TextDisplay/TextDisplay.cc
// Function: operator<<(std::ostream&, TextDisplay const&)
std::ostream &operator<<(std::ostream &out, const TextDisplay &td) {

    for (auto &row: td.theDisplay) {
        for (auto &c: row) {
            out << c;
        }
        out << std::endl;
    }
		std::string spaces(55, ' ');
    out << "Race: " << raceToText(td.info.race) << " Gold: " << td.info.gold
				<< spaces << "Floor " << td.floorNumber << std::endl;
    out << "HP: " << td.info.HP << std::endl;
    out << "Atk: " << td.info.attackValue << std::endl;
    out << "Def: " << td.info.defenceValue << std::endl;
    out << "Action: " << std::endl;
	out << td.info.lastAction << std::endl;

    return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r15
movq 0x28(%rsi), %r12
cmpq %r12, %r15
je 0x15ac0
movq (%r15), %r13
movq 0x8(%r15), %rbp
cmpq %rbp, %r13
je 0x15ab2
movsbl (%r13), %esi
movq %rbx, %rdi
callq 0x52a0
incq %r13
jmp 0x15a9b
movq %rbx, %rdi
callq 0x5140
addq $0x18, %r15
jmp 0x15a8f
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %rdi
pushq $0x37
popq %rsi
pushq $0x20
popq %rdx
callq 0x5290
leaq 0x386f(%rip), %rsi      # 0x1934f
movq %rbx, %rdi
callq 0x5250
movq %rax, %r15
movl 0x1c0(%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0x13e4e
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x5220
leaq 0x3846(%rip), %rsi      # 0x19356
movq %rax, %rdi
callq 0x5250
movl 0x1c4(%r14), %esi
movq %rax, %rdi
callq 0x53b0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x5220
leaq 0x3823(%rip), %rsi      # 0x1935e
movq %rax, %rdi
callq 0x5250
movl 0x220(%r14), %esi
movq %rax, %rdi
callq 0x53b0
movq %rax, %rdi
callq 0x5140
leaq 0x28(%rsp), %rdi
callq 0x5428
leaq 0x37fa(%rip), %rsi      # 0x19365
movq %rbx, %rdi
callq 0x5250
movl 0x1c8(%r14), %esi
movq %rax, %rdi
callq 0x53b0
movq %rax, %rdi
callq 0x5140
leaq 0x37d9(%rip), %rsi      # 0x1936a
movq %rbx, %rdi
callq 0x5250
movl 0x1cc(%r14), %esi
movq %rax, %rdi
callq 0x53b0
movq %rax, %rdi
callq 0x5140
leaq 0x37b9(%rip), %rsi      # 0x19370
movq %rbx, %rdi
callq 0x5250
movl 0x1d0(%r14), %esi
movq %rax, %rdi
callq 0x53b0
movq %rax, %rdi
callq 0x5140
leaq 0x3799(%rip), %rsi      # 0x19376
movq %rbx, %rdi
callq 0x5250
movq %rax, %rdi
callq 0x5140
addq $0x1f8, %r14            # imm = 0x1F8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5220
movq %rax, %rdi
callq 0x5140
leaq 0x8(%rsp), %rdi
callq 0x5428
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15c34
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5428
jmp 0x15c37
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5428
movq %rbx, %rdi
callq 0x53c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
leaq 0x28(%rsp), %rbx
movq 0x20(%rsi), %rax
xorl %edx, %edx
leaq 0x20(%rsp), %r12
movslq (%rax), %rcx
cmpq %rcx, %rdx
jge 0x165f4
movq %rdx, 0x10(%rsp)
imulq $0x18, %rdx, %r14
xorl %r13d, %r13d
xorl %ebp, %ebp
movslq 0x4(%rax), %rcx
cmpq %rcx, %rbp
jge 0x165ac
movq (%r15), %rax
movq (%rax,%r14), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0xd360
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x16597
callq 0x108f0
cmpl $0x4, %eax
je 0x165b6
movq %rbx, %rdi
callq 0xd24a
incq %rbp
movq 0x20(%r15), %rax
addq $0x10, %r13
jmp 0x16568
movq 0x10(%rsp), %rdx
incq %rdx
jmp 0x1654e
leaq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rax
movl %eax, (%rsi)
movl %ebp, 0x4(%rsi)
pushq $0x2
popq %rdx
leaq 0xf(%rsp), %rcx
movq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xce8c
movq %rbx, %rdi
callq 0xd24a
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rdi
callq 0x5150
movl $0x1, (%rax)
movq 0xd977(%rip), %rsi      # 0x23f80
movq %rax, %rdi
xorl %edx, %edx
callq 0x53a0
jmp 0x16615
movq %rax, %r14
movq %rbx, %rdi
callq 0xd24a
movq %r14, %rdi
callq 0x53c0
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_import_packages.cpp
// Function: void import_package_example<double>()
void import_package_example()
{
   typedef exprtk::symbol_table<T> symbol_table_t;
   typedef exprtk::expression<T>   expression_t;
   typedef exprtk::parser<T>       parser_t;

   symbol_table_t symbol_table;

   import_packages<T> import_package(symbol_table);

   symbol_table.add_function("import",import_package);

   expression_t expression;
   expression.register_symbol_table(symbol_table);

   parser_t parser;

   const std::string import_packages_program =
      " import('exprtk.rtl.io'     ); "
      " import('exprtk.rtl.io.file'); "
      " import('exprtk.rtl.vecops' ); "
      "                               "
      " var v[7] := [1:1];            "
      "                               "
      " println('v: ', v);            "
      "                               "
      " reverse(v);                   "
      "                               "
      " println('reversed v: ', v);   "
      "                               ";

   parser.compile(import_packages_program, expression);

   expression.value();
}

// Assembly:
pushq %rbx
subq $0x1550, %rsp           # imm = 0x1550
leaq 0x10(%rsp), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1135e8
leaq 0xab0(%rsp), %rdi
movq %rbx, %rsi
callq 0x11360c
leaq 0x130d44(%rip), %rsi    # 0x244116
leaq 0x188(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x113368
leaq 0x10(%rsp), %rdi
leaq 0x188(%rsp), %rsi
leaq 0xab0(%rsp), %rdx
callq 0x11375a
leaq 0x188(%rsp), %rdi
callq 0x111668
leaq 0x18(%rsp), %rdi
callq 0x113822
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x113882
leaq 0x38(%rsp), %rdi
pushq $0x7f
popq %rsi
callq 0x1138de
leaq 0x188(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1139ee
leaq 0x38(%rsp), %rdi
callq 0x114006
leaq 0x130cc9(%rip), %rsi    # 0x24411d
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x113368
leaq 0x188(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x11404e
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x38(%rsp), %rdi
callq 0x111668
leaq 0x188(%rsp), %rdi
callq 0x1144d0
leaq 0x18(%rsp), %rdi
callq 0x11460a
leaq 0xab0(%rsp), %rdi
callq 0x114620
leaq 0x10(%rsp), %rdi
callq 0x114664
addq $0x1550, %rsp           # imm = 0x1550
popq %rbx
retq
movq %rax, %rbx
jmp 0x113510
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x114006
jmp 0x11351d
jmp 0x1134e0
movq %rax, %rbx
jmp 0x11351d
jmp 0x1134f9
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
callq 0x111668
jmp 0x113527
movq %rax, %rbx
jmp 0x113527
movq %rax, %rbx
jmp 0x113534
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x111668
leaq 0x188(%rsp), %rdi
callq 0x1144d0
leaq 0x18(%rsp), %rdi
callq 0x11460a
leaq 0xab0(%rsp), %rdi
callq 0x114620
leaq 0x10(%rsp), %rdi
callq 0x114664
movq %rbx, %rdi
callq 0x111390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x130cab(%rip), %rsi    # 0x2442d2
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x113368
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1151fa
leaq 0x8(%rsp), %rdi
callq 0x111668
leaq 0x259142(%rip), %rax    # 0x36c798
movq %rax, (%rbx)
movq %r14, 0x48(%rbx)
andl $0x0, 0x58(%rbx)
andq $0x0, 0x60(%rbx)
leaq 0x50(%rbx), %r14
leaq 0x58(%rbx), %rax
movq %rax, 0x68(%rbx)
movq %rax, 0x70(%rbx)
andq $0x0, 0x78(%rbx)
leaq 0x80(%rbx), %r15
movq %r15, %rdi
callq 0x115230
leaq 0x150(%rbx), %r12
movq %r12, %rdi
callq 0x1152d4
leaq 0x2c0(%rbx), %rbp
movq %rbp, %rdi
callq 0x11539a
movb $0x0, 0x9(%rbx)
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x130bd7(%rip), %rsi    # 0x244292
movq %r14, %rdi
callq 0x119f1c
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x130bce(%rip), %rsi    # 0x2442a0
movq %r14, %rdi
callq 0x11a2de
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
leaq 0x130bca(%rip), %rsi    # 0x2442b3
movq %r14, %rdi
callq 0x11b066
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x113704
jmp 0x113704
movq %rax, %r13
movq %rbp, %rdi
callq 0x1157c0
jmp 0x113714
movq %rax, %r13
movq %r12, %rdi
callq 0x11590e
jmp 0x113721
movq %rax, %r13
movq %r15, %rdi
callq 0x11593c
movq %r14, %rdi
callq 0x11ba0c
movq %rbx, %rdi
callq 0x1171ca
movq %r13, %rdi
callq 0x111390
movq %rax, %r13
jmp 0x113729
movq %rax, %r13
leaq 0x8(%rsp), %rdi
callq 0x111668
jmp 0x113739
movq %rax, %r13
jmp 0x113739
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq (%rax), %rax
movq %rax, 0x8(%rsi)
leaq 0x50(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x115cd2
movq %r14, %rdi
movq %r15, %rsi
callq 0x11ba6a
movq %rax, %r14
movq %rsp, %rdi
callq 0x111668
leaq 0x58(%rbx), %rax
cmpq %r14, %rax
je 0x1159ca
addq $0x40, %r14
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x11ba56
testb %al, %al
jne 0x1159cf
xorps %xmm0, %xmm0
jmp 0x1159d7
movsd 0x129699(%rip), %xmm0   # 0x23f070
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x111668
movq %rbx, %rdi
callq 0x111390
// File: /workspace/github_cpp_makefile_star2_O2/ConsoleTVs[P]VirtualMachine/src/program.cpp
// Function: VM::Program::debug()
void Program::debug()
{
    for (uint32_t i = 0; i < this->code.size(); i++) {
        if (this->code[i] == OP_CONSTANT) {
            printf("%s ", CodeString[this->code[i++]].c_str());
            printf("%s\n", this->constants[this->code[i]]->to_string().c_str());
        } else printf("%s\n", CodeString[this->code[i]].c_str());
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x1125(%rip), %r14      # 0x3156
movq %rsp, %r15
leaq 0x4285(%rip), %r12      # 0x62c0
xorl %r13d, %r13d
movl %r13d, %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x20ac
movl (%rcx,%rax,4), %eax
testq %rax, %rax
je 0x206b
shlq $0x5, %rax
movq (%rax,%r12), %rdi
callq 0x1130
jmp 0x20a7
incl %r13d
movq 0x424b(%rip), %rsi      # 0x62c0
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movl (%rax,%r13,4), %eax
movq (%rcx,%rax,8), %rsi
movq %r15, %rdi
callq 0x23b6
movq (%rsp), %rdi
callq 0x1130
movq %r15, %rdi
callq 0x1060
incl %r13d
jmp 0x203e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23a8
leaq 0xe24(%rip), %rcx       # 0x3174
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 0x238c
cvtsi2ss %rax, %xmm0
retq
movsbl 0x8(%rdi), %eax
cvtsi2ss %eax, %xmm0
retq
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
jns 0x2370
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
leaq 0xe20(%rip), %rdi       # 0x31d0
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O2/ConsoleTVs[P]VirtualMachine/src/values.cpp
// Function: VM::Value::to_string[abi:cxx11]()
std::string Value::to_string()
{
    switch (this->type) {
        case VALUE_INTEGER: { return std::to_string(this->ivalue); }
        case VALUE_FLOAT: { return std::to_string(this->fvalue); }
        case VALUE_BOOLEAN: { return std::to_string(this->bvalue ? 1 : 0); }
        case VALUE_STRING: { return *this->svalue; }
        case VALUE_LIST: {
            // Printing a list is a bit more elaborate :)
            std::string result = "[";

            for (auto element : *this->lvalue) {
                result += element->to_string() + ", ";
            }

            // This will pop the last ',' and the ' '
            result.pop_back(); result.pop_back();

            return result + "]";
        }
        default: { printf("Error converting value to int.\n"); }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movzbl (%rsi), %eax
cmpq $0x4, %rax
ja 0x24dd
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xdaa(%rip), %rcx       # 0x3188
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r12), %esi
jmp 0x246c
movq %rbx, (%rsp)
leaq 0xda3(%rip), %rsi       # 0x319c
leaq 0x8(%rsp), %r14
leaq 0x48(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x1050
movq 0x8(%r12), %rax
movq (%rax), %rbp
movq 0x8(%rax), %rbx
leaq 0x28(%rsp), %r12
leaq 0xd78(%rip), %r13       # 0x319e
cmpq %rbx, %rbp
je 0x2496
movq (%rbp), %rsi
movq %r12, %rdi
callq 0x23b6
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x259c
movq %r14, %rdi
movq %r15, %rsi
callq 0x1190
movq %r15, %rdi
callq 0x1060
movq %r12, %rdi
callq 0x1060
addq $0x8, %rbp
jmp 0x2426
movzbl 0x8(%r12), %esi
movq %rbx, %rdi
callq 0x251e
jmp 0x24cb
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x1110
jmp 0x24cb
movss 0x8(%r12), %xmm0
movq %rbx, %rdi
callq 0x2577
jmp 0x24cb
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x10f0
movq %r14, %rdi
callq 0x10f0
leaq 0xcef(%rip), %rdx       # 0x31a1
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25bb
leaq 0x8(%rsp), %rdi
callq 0x1060
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcec(%rip), %rdi       # 0x31d0
callq 0x1130
jmp 0x24eb
movq %rax, %rbx
jmp 0x250c
movq %rax, %rbx
jmp 0x2502
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1060
leaq 0x28(%rsp), %rdi
callq 0x1060
leaq 0x8(%rsp), %rdi
callq 0x1060
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/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>>>::equal_range(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::pair<iterator, iterator> equal_range(const key_type& target)
    {
	iterator b = find(target);
	iterator e = b;

	if (e != end())
	    ++e;

	return std::make_pair(b, e);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x1a56
movq %rax, %rbx
addq $0x8, %r14
movq %rax, %rdx
cmpq %r14, %rax
je 0x18f0
movq %rbx, %rdi
callq 0x1c2e
movq %rax, %rdx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x1a56
movq %rax, %rbx
leaq 0x8(%r14), %rax
cmpq %rax, %rbx
jne 0x1992
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10c0
andl $0x0, 0x20(%rbx)
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1de4
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a60
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1070
movq %rsp, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1e02
addq $0x20, %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1070
movq %rsp, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d19
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rsi
callq 0x1d5a
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 0x1cbe
movq %rax, 0x30(%rbx)
movq 0x38(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1cbe
movq %rax, 0x38(%rbx)
jmp 0x1d1b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1be0
callq 0x10d0
movq %rax, %rbx
callq 0x10e0
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1bbe
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
leaq 0x30(%rdx), %rbx
pushq $0x38
popq %r12
pushq $0x30
popq %r13
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2322
movq %rbx, %rdi
movq %r14, %rsi
callq 0x216c
movq %r12, %rcx
testb %al, %al
jne 0x231a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x216c
movq %r13, %rcx
movq %rbx, %r15
testb %al, %al
je 0x231f
addq %rcx, %rbx
jmp 0x22eb
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>>>::summary_map(std::initializer_list<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>)
summary_map(std::initializer_list<value_type> init) :
	item_count(0)
    {
	try {
	    insert(init.begin(), init.end());
	}
	catch (...) {
	    delete_tree(allocator, header.left);
	    throw;
	}
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
andl $0x0, 0x28(%rdi)
imulq $0x28, %rdx, %rdx
addq %rsi, %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
callq 0x2704
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2(%r14), %r15
movq %rax, %rdi
callq 0x1060
movq 0x38(%r14), %rsi
movq %r15, %rdi
callq 0x1be0
callq 0x10d0
movq %rax, %r14
callq 0x10e0
movq %rbx, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1bbe