LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: eatFood
static void eatFood(void) {
	wprintw(prompt_win,"you eat some food, restoring 10 health.\n");
	refreshPrompt();
	PLAYER->health += 10;
	PLAYER->food -= 1;
	if(PLAYER->health > PLAYER->health_max) {
		PLAYER->health = PLAYER->health_max;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xf0dd(%rip), %rax      # 0x11128
movq (%rax), %rdi
leaq 0x9077(%rip), %rsi      # 0xb0cc
movb $0x0, %al
callq 0x11a0
callq 0x1830
leaq 0xf0e0(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl (%rax), %ecx
addl $0xa, %ecx
movl %ecx, (%rax)
leaq 0xf0cb(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x2c(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x2c(%rax)
leaq 0xf0b4(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
leaq 0xf0a4(%rip), %rcx      # 0x11148
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpl 0xc(%rcx), %eax
jle 0x20d1
leaq 0xf091(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0xc(%rax), %ecx
leaq 0xf080(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: getRandInt
static int getRandInt(const int limit) {
	const int divisor = RAND_MAX/(limit + 1);
	int value;
	do{
		value = rand() / divisor;
	} while(value > limit);

	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
callq 0x11d0
cltd
idivl -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x20fc
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: criticalHit
static void criticalHit(Character *const attacker,Character *const enemy, const char *const str) {
	const int damage = (attacker->attack - enemy->defense > 0) ? (attacker->attack - enemy->defense) + 2 : 3;
	enemy->health -= damage;
	if(checkIfHealthIsHalf(enemy) == 0) {
		char *str1 = malloc(sizeof(char) * sizeof(str) + 5);
		sprintf(str1,str,damage);
		wprintw(prompt_win,"%s\n",str1);
		free(str1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x14(%rcx), %eax
cmpl $0x0, %eax
jle 0x215d
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x14(%rcx), %eax
addl $0x2, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2167
movl $0x3, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2167
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2300
cmpl $0x0, %eax
jne 0x21cd
movl $0xd, %edi
callq 0x1160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb $0x0, %al
callq 0x1190
leaq 0xef79(%rip), %rax      # 0x11128
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x8435(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
movq -0x28(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: regularHit
static void regularHit(Character *const attacker,Character *const defender, const char *const str) {
	const int damage = (attacker->attack - defender->defense > 0) ? attacker->attack - defender->defense : 1;
	defender->health -= damage;
	if(defender->type == 11 || checkIfHealthIsHalf(defender) == 0) {
		char *str1 = malloc(sizeof(char) * sizeof(str) + 5);
		sprintf(str1,str,damage);
		wprintw(prompt_win,"%s\n",str1);
		free(str1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x14(%rcx), %eax
cmpl $0x0, %eax
jle 0x221a
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x14(%rcx), %eax
movl %eax, -0x2c(%rbp)
jmp 0x2224
movl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2224
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0xb, 0x1c(%rax)
je 0x224f
movq -0x10(%rbp), %rdi
callq 0x2300
cmpl $0x0, %eax
jne 0x2294
movl $0xd, %edi
callq 0x1160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb $0x0, %al
callq 0x1190
leaq 0xeeb2(%rip), %rax      # 0x11128
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x836e(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
movq -0x28(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: critHitRLEnemy
static int critHitRLEnemy(Character *const defender) {
	const int selection = getRandInt(1);
	switch (defender->type) {
		case 10: 
			makeHalflingEnragedStrings();
		    printHalflingCut(selection);
			ENEMY->type += (selection + 3);
			break;
		case 11: 
			makeMonsterEnragedStrings();
			printGiantCut(selection);
			ENEMY->type += (selection + 4);
			break;
		case 12: 
			makeDelmerEnragedStrings();
			printDelmerCut(selection);
			ENEMY->type += (selection + 5);
			break;
		default: return 0; //if not one of the select three, just return 0;
			break;
	}
	//add enraged stat modifier to halfling,delmer,and monster
	ENEMY->attack += 2;
	ENEMY->defense += 1;
	ENEMY->defense_value += 1;
	ENEMY->health += 10;
	ENEMY->health_max = defender->health;
	ENEMY->special_count = -1;
	ENEMY->crit_chance -= 1; //increases chance to do crit attack. counterintuitive with the minus
	printNewEnemy();
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
callq 0x20e0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0xa, %eax
je 0x238e
jmp 0x237a
movl -0x18(%rbp), %eax
subl $0xb, %eax
je 0x23b7
jmp 0x2384
movl -0x18(%rbp), %eax
subl $0xc, %eax
je 0x23e0
jmp 0x2409
callq 0x24d0
movl -0x14(%rbp), %edi
callq 0x25d0
movl -0x14(%rbp), %ecx
addl $0x3, %ecx
leaq 0xeda8(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
jmp 0x2415
callq 0x2650
movl -0x14(%rbp), %edi
callq 0x2750
movl -0x14(%rbp), %ecx
addl $0x4, %ecx
leaq 0xed7f(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
jmp 0x2415
callq 0x27d0
movl -0x14(%rbp), %edi
callq 0x28d0
movl -0x14(%rbp), %ecx
addl $0x5, %ecx
leaq 0xed56(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
jmp 0x2415
movl $0x0, -0x4(%rbp)
jmp 0x24be
leaq 0xed34(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x10(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x10(%rax)
leaq 0xed1d(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
leaq 0xed06(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
leaq 0xecef(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl (%rax), %ecx
addl $0xa, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
leaq 0xecd4(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl %ecx, 0xc(%rax)
leaq 0xecc3(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
leaq 0xecae(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x18(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x18(%rax)
callq 0x2950
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: makeHalflingEnragedStrings
static void makeHalflingEnragedStrings(void) {
	ENEMY->regular_attack = "enraged halfling attacks you for %d damage.";
	ENEMY->regular_miss = "halfing strikes at you but misses.";
	ENEMY->counter_miss = "enraged halfling counters and hits you for 2 damage.";
	ENEMY->raise_defense = "enraged halfling gets even angrier, his defense is raised by 2.";
	ENEMY->critical_hit = "in a rage the halfling hits you pretty hard.\nhe inflicts %d damage to you.";
	ENEMY->special_attack = "halfling summouns all his anger and channels it\nhe hits you inflicting %d damage.";
	ENEMY->special_attack_miss = "in his rage the halfling misses his attack.";
	ENEMY->special_fail = "halfling is just too angry, your attack fails.\nhe retaliates against you doing four damage.";
	ENEMY->prompt = "you killed his friend\nthe surviving halfling is now thrown into an enraged state.";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xec75(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x810d(%rip), %rcx      # 0xa5f6
movq %rcx, 0x48(%rax)
leaq 0xec5c(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8120(%rip), %rcx      # 0xa622
movq %rcx, 0x50(%rax)
leaq 0xec43(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x812a(%rip), %rcx      # 0xa645
movq %rcx, 0x68(%rax)
leaq 0xec2a(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8146(%rip), %rcx      # 0xa67a
movq %rcx, 0x70(%rax)
leaq 0xec11(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x816d(%rip), %rcx      # 0xa6ba
movq %rcx, 0x78(%rax)
leaq 0xebf8(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x819f(%rip), %rcx      # 0xa705
movq %rcx, 0x88(%rax)
leaq 0xebdc(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x81d5(%rip), %rcx      # 0xa757
movq %rcx, 0x90(%rax)
leaq 0xebc0(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x81e5(%rip), %rcx      # 0xa783
movq %rcx, 0x98(%rax)
leaq 0xeba4(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8225(%rip), %rcx      # 0xa7df
movq %rcx, 0xa0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: makeMonsterEnragedStrings
static void makeMonsterEnragedStrings(void) {
	ENEMY->regular_attack = "enraged beast attacks you dealing %d damage.";
	ENEMY->regular_miss = "angry monster missed you with his attack.";
	ENEMY->counter_miss = "enraged beast counters your attack inflicting four damage.";
	ENEMY->raise_defense = "in his enraged state the monster now has increased defense.";
	ENEMY->critical_hit = "in his fury the monster hits you very hard.\nyou suffer %d damage.";
	ENEMY->special_attack = "the very angry monster swings with all his might\nyou suffer %d damage.";
	ENEMY->special_attack_miss = "the beast is just too angry to hit you.";
	ENEMY->special_fail = "nothing but good old fashion stabbing is going to take down this infuriated beast.\nhe counters doing four damage.";
	ENEMY->prompt = "cutting off his other head aggravates the monster. he is now enraged.";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xeaf5(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8225(%rip), %rcx      # 0xa88e
movq %rcx, 0x48(%rax)
leaq 0xeadc(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8239(%rip), %rcx      # 0xa8bb
movq %rcx, 0x50(%rax)
leaq 0xeac3(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x824a(%rip), %rcx      # 0xa8e5
movq %rcx, 0x68(%rax)
leaq 0xeaaa(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x826c(%rip), %rcx      # 0xa920
movq %rcx, 0x70(%rax)
leaq 0xea91(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x828f(%rip), %rcx      # 0xa95c
movq %rcx, 0x78(%rax)
leaq 0xea78(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x82b8(%rip), %rcx      # 0xa99e
movq %rcx, 0x88(%rax)
leaq 0xea5c(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x82e3(%rip), %rcx      # 0xa9e5
movq %rcx, 0x90(%rax)
leaq 0xea40(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x82ef(%rip), %rcx      # 0xaa0d
movq %rcx, 0x98(%rax)
leaq 0xea24(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8345(%rip), %rcx      # 0xaa7f
movq %rcx, 0xa0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: makeDelmerEnragedStrings
static void makeDelmerEnragedStrings(void) {
	ENEMY->regular_attack = "angered delmer eye hits you for %d damage.";
	ENEMY->regular_miss = "enraged delmer eye missed.";
	ENEMY->counter_miss = "the angry delmer eye counters your attack dealing four damage to you.";
	ENEMY->raise_defense = "the enraged delmer eye increases its defense.";
	ENEMY->critical_hit = "the infuriated delmer eye hit you forcibly.\nyou suffer %d damage";
	ENEMY->special_attack = "the angry delmer eye savagely strikes at you inflicting %d damage.";
	ENEMY->special_attack_miss = "you manage to block the delmer eye's ferocious attack";
	ENEMY->special_fail = "the enraged delmer is immune to any special attack from you.\nyou take 4 damage in your attempt.";
	ENEMY->prompt = "\nkilling the delmer eye causes the other to enter into a rage.";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe975(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8371(%rip), %rcx      # 0xab5a
movq %rcx, 0x48(%rax)
leaq 0xe95c(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8383(%rip), %rcx      # 0xab85
movq %rcx, 0x50(%rax)
leaq 0xe943(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8385(%rip), %rcx      # 0xaba0
movq %rcx, 0x68(%rax)
leaq 0xe92a(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x83b2(%rip), %rcx      # 0xabe6
movq %rcx, 0x70(%rax)
leaq 0xe911(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x83c7(%rip), %rcx      # 0xac14
movq %rcx, 0x78(%rax)
leaq 0xe8f8(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x83ef(%rip), %rcx      # 0xac55
movq %rcx, 0x88(%rax)
leaq 0xe8dc(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8416(%rip), %rcx      # 0xac98
movq %rcx, 0x90(%rax)
leaq 0xe8c0(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8430(%rip), %rcx      # 0xacce
movq %rcx, 0x98(%rax)
leaq 0xe8a4(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
leaq 0x8474(%rip), %rcx      # 0xad2e
movq %rcx, 0xa0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: printNewEnemy
static void printNewEnemy(void) {
	wclear(game_win);
	switch(ENEMY->type) { //reprint background for halfing camp and monster
		case 13://enraged halflings
		case 14://enraged halflings		
			printPlaces(1); //printobjects.c
			break;
		case 15://enraged monster
		case 16://enraged monster
			printPlaces(3); //printobjects.c
			break;
		default: //do nothing
			break;
	}
	printHero();  //printenemy.c
	printEnemies(ENEMY->type); //printenemy.c
	wrefresh(game_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe7c1(%rip), %rax      # 0x11120
movq (%rax), %rdi
callq 0x1090
leaq 0xe7e2(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x4(%rbp)
addl $-0xd, %eax
subl $0x2, %eax
jb 0x2992
jmp 0x2985
movl -0x4(%rbp), %eax
addl $-0xf, %eax
subl $0x2, %eax
jb 0x299e
jmp 0x29aa
movl $0x1, %edi
callq 0x96b0
jmp 0x29ac
movl $0x3, %edi
callq 0x96b0
jmp 0x29ac
jmp 0x29ac
callq 0x7550
leaq 0xe798(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x1c(%rax), %edi
callq 0x7a40
leaq 0xe752(%rip), %rax      # 0x11120
movq (%rax), %rdi
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: playerSpecial
static void playerSpecial(void) {
	switch(PLAYER->special) {
		case 0:throwOpponent(PLAYER,ENEMY);
			break;
		case 1:defenseDown(PLAYER,ENEMY);
			break;
		case 2:powerAttack(PLAYER,ENEMY);
			break;
		default: //do nothing
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe709(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x30(%rax), %eax
movl %eax, -0x4(%rbp)
testl %eax, %eax
je 0x2a66
jmp 0x2a52
movl -0x4(%rbp), %eax
subl $0x1, %eax
je 0x2a89
jmp 0x2a5c
movl -0x4(%rbp), %eax
subl $0x2, %eax
je 0x2aac
jmp 0x2acf
leaq 0xe6db(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rdi
leaq 0xe6d5(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rsi
callq 0x2c60
jmp 0x2ad1
leaq 0xe6b8(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rdi
leaq 0xe6b2(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rsi
callq 0x2dd0
jmp 0x2ad1
leaq 0xe695(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rdi
leaq 0xe68f(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rsi
callq 0x2ae0
jmp 0x2ad1
jmp 0x2ad1
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: throwOpponent
static void throwOpponent(Character *const attacker,Character *const defender) {
	switch(defender->type) {
		case 4://thief
		case 5://archer
		case 11://monster
		case 12://delmer
			//throws dont work on these guys
			wprintw(prompt_win,"%s\n",defender->special_fail);
			attacker->health -= 2;
			break;
		case 13://enraged halflings
		case 14://enraged halflings
		case 15://enraged monster
		case 16://enraged monster
		case 17://enraged delmer
		case 18://enraged delmer
				// throws dont work on enraged enemies
				wprintw(prompt_win,"%s\n",defender->special_fail);
				attacker->health -= 4;
			break;
		case 19: 
			wprintw(prompt_win,"%s\n",throwBoss()); //special throw against boss
			break;
		default: //against any other enemy
			if(getRandInt(10) > defender->chance_to_dodge) {
				wprintw(prompt_win,"%s\n",attacker->special_attack);
				defender->turn += 2;
				defender->health -= 2;
				attacker->special_count += 1;
			}
			else {
			wprintw(prompt_win,"%s\n",attacker->special_attack_miss);
			}
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
addl $-0x4, %eax
subl $0x2, %eax
jb 0x2cab
jmp 0x2c84
movl -0x14(%rbp), %eax
addl $-0xb, %eax
subl $0x2, %eax
jb 0x2cab
jmp 0x2c91
movl -0x14(%rbp), %eax
addl $-0xd, %eax
subl $0x6, %eax
jb 0x2cde
jmp 0x2c9e
movl -0x14(%rbp), %eax
subl $0x13, %eax
je 0x2d11
jmp 0x2d3e
leaq 0xe476(%rip), %rax      # 0x11128
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdx
leaq 0x792b(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x2, %ecx
movl %ecx, (%rax)
jmp 0x2dc0
leaq 0xe443(%rip), %rax      # 0x11128
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdx
leaq 0x78f8(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x4, %ecx
movl %ecx, (%rax)
jmp 0x2dc0
leaq 0xe410(%rip), %rax      # 0x11128
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x32b0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x78c0(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
jmp 0x2dc0
movl $0xa, %edi
callq 0x20e0
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jle 0x2d9b
leaq 0xe3d0(%rip), %rax      # 0x11128
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdx
leaq 0x7885(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl $0x2, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x2dbe
leaq 0xe386(%rip), %rax      # 0x11128
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdx
leaq 0x783b(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
jmp 0x2dc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: defenseDown
static void defenseDown(Character *const attacker,Character *const defender) {
	switch(defender->type) {
		case 2://skeleton
		case 6://spearman
		case 8://mage
		case 9://scrugg
			//spell doesnt work against these enemy types
			wprintw(prompt_win,"%s\n",defender->special_fail);
			attacker->health -= 2;
			break;
		case 13://enraged halfling
		case 14://enraged halfling
		case 15://enraged monster
		case 16://enraged monster
		case 17://enraged delmer
		case 18://enraged delmer
			//spells dont work on enraged monsters
			wprintw(prompt_win,"%s\n",defender->special_fail);
			attacker->health -= 4;
			break;
		case 19: wprintw(prompt_win,"%s\n",defensedownBoss()); //defense down against boss
			break;
		default: // against any other type of enemy.
			if(getRandInt(10) > defender->chance_to_dodge) {
				wprintw(prompt_win,"%s\n",attacker->special_attack);
				defender->defense -= 3;
				if(defender->defense < 0) {
					defender->defense = 0;
				}
				attacker->special_count += 1;
			}
			else {
				wprintw(prompt_win,"%s\n",attacker->special_attack_miss);
			}
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
je 0x2e22
jmp 0x2df1
movl -0x14(%rbp), %eax
subl $0x6, %eax
je 0x2e22
jmp 0x2dfb
movl -0x14(%rbp), %eax
addl $-0x8, %eax
subl $0x2, %eax
jb 0x2e22
jmp 0x2e08
movl -0x14(%rbp), %eax
addl $-0xd, %eax
subl $0x6, %eax
jb 0x2e55
jmp 0x2e15
movl -0x14(%rbp), %eax
subl $0x13, %eax
je 0x2e88
jmp 0x2eb5
leaq 0xe2ff(%rip), %rax      # 0x11128
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdx
leaq 0x77b4(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x2, %ecx
movl %ecx, (%rax)
jmp 0x2f41
leaq 0xe2cc(%rip), %rax      # 0x11128
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdx
leaq 0x7781(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x4, %ecx
movl %ecx, (%rax)
jmp 0x2f41
leaq 0xe299(%rip), %rax      # 0x11128
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x3340
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x7749(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
jmp 0x2f41
movl $0xa, %edi
callq 0x20e0
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jle 0x2f1c
leaq 0xe259(%rip), %rax      # 0x11128
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdx
leaq 0x770e(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
subl $0x3, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jge 0x2f0d
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x2f3f
leaq 0xe205(%rip), %rax      # 0x11128
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdx
leaq 0x76ba(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
jmp 0x2f41
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: theifSpecial
static void theifSpecial(void) {
	int check = 0;
	if(PLAYER->food != 0) {
		if(getRandInt(10) > PLAYER->chance_to_dodge) {
			wprintw(prompt_win,"thief stole some food from you.");
			PLAYER->food -= 1;
			ENEMY->special_count = 1;
			check += 1;
		}
	}

	if(getRandInt(10) > PLAYER->chance_to_dodge) {
		wprintw(prompt_win,"%s\n",ENEMY->special_attack);
		score -= 10;
		ENEMY->special_count = 1;
		check += 1;
	}

	if (!check) {
		wprintw(prompt_win,"%s\n",ENEMY->special_attack_miss);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe1e2(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x2c(%rax)
je 0x2fdf
movl $0xa, %edi
callq 0x20e0
leaq 0xe1c4(%rip), %rcx      # 0x11148
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jle 0x2fdd
leaq 0xe191(%rip), %rax      # 0x11128
movq (%rax), %rdi
leaq 0x8062(%rip), %rsi      # 0xb003
movb $0x0, %al
callq 0x11a0
leaq 0xe199(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x2c(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x2c(%rax)
leaq 0xe18a(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl $0x1, 0x8(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2fdf
movl $0xa, %edi
callq 0x20e0
leaq 0xe158(%rip), %rcx      # 0x11148
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jle 0x305c
leaq 0xe125(%rip), %rax      # 0x11128
movq (%rax), %rdi
leaq 0xe143(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x88(%rax), %rdx
leaq 0x75d0(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
leaq 0xe100(%rip), %rax      # 0x11130
movl (%rax), %ecx
subl $0xa, %ecx
leaq 0xe0f4(%rip), %rax      # 0x11130
movl %ecx, (%rax)
leaq 0xe10b(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl $0x1, 0x8(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x308f
leaq 0xe0bf(%rip), %rax      # 0x11128
movq (%rax), %rdi
leaq 0xe0dd(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x90(%rax), %rdx
leaq 0x756a(%rip), %rsi      # 0xa5f2
movb $0x0, %al
callq 0x11a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: bossSpecial
static void bossSpecial(void) {		
	if(getRandInt(10) > PLAYER->chance_to_dodge && getRandInt(10) >= ENEMY->crit_chance) {
		char *const str = malloc(160);		
		sprintf(str,ENEMY->special_attack,ENEMY->attack);
		PLAYER->defense -= 2;
		PLAYER->health -= ENEMY->attack;
		PLAYER->turn = 2;
		ENEMY->special_count = 1;
		wprintw(prompt_win,"%s",str);
		free(str);
	}
	else {
		wprintw(prompt_win,"%s",ENEMY->special_attack_miss);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xa, %edi
callq 0x20e0
leaq 0xe08f(%rip), %rcx      # 0x11148
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jle 0x31b6
movl $0xa, %edi
callq 0x20e0
leaq 0xe076(%rip), %rcx      # 0x11150
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jl 0x31b6
movl $0xa0, %edi
callq 0x1160
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xe04d(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x88(%rax), %rsi
leaq 0xe038(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x10(%rax), %edx
movb $0x0, %al
callq 0x1190
leaq 0xe018(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x14(%rax), %ecx
subl $0x2, %ecx
movl %ecx, 0x14(%rax)
leaq 0xe009(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x10(%rax), %edx
leaq 0xdff0(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
leaq 0xdfdc(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl $0x2, 0x4(%rax)
leaq 0xdfcf(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl $0x1, 0x8(%rax)
leaq 0xdf92(%rip), %rax      # 0x11128
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x7126(%rip), %rsi      # 0xa2ca
movb $0x0, %al
callq 0x11a0
movq -0x8(%rbp), %rdi
callq 0x1030
jmp 0x31e3
leaq 0xdf6b(%rip), %rax      # 0x11128
movq (%rax), %rdi
leaq 0xdf89(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x90(%rax), %rdx
leaq 0x70ee(%rip), %rsi      # 0xa2ca
movb $0x0, %al
callq 0x11a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: powerAttackBoss
static char *powerAttackBoss(void) {
	if(getRandInt(10) > ENEMY->chance_to_dodge) {
		const int damage = (PLAYER->attack + 4) - ENEMY->defense;
		ENEMY->health -= damage;
		PLAYER->special_count = 1;
		char *const str1 = malloc(160);
		sprintf(str1,"you find a big ass sword laying at your feet.\nyou pick it up and swing with all your might.\nyou hit the boss for %d damage, unfortunately the sword breaks.",damage);
		return str1;
	}
	else {
		return "you swing very very hard but miss the big monster.";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0xa, %edi
callq 0x20e0
leaq 0xdf47(%rip), %rcx      # 0x11150
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jle 0x329a
leaq 0xdf28(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x10(%rax), %eax
addl $0x4, %eax
leaq 0xdf1c(%rip), %rcx      # 0x11150
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
subl 0x14(%rcx), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
leaq 0xdf05(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
leaq 0xdee9(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl $0x1, 0x8(%rax)
movl $0xa0, %edi
callq 0x1160
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x7b47(%rip), %rsi      # 0xadd0
movb $0x0, %al
callq 0x1190
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x32a5
leaq 0x7bcb(%rip), %rax      # 0xae6c
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: throwBoss
static char *throwBoss(void) {
	if(getRandInt(10) > ENEMY->chance_to_dodge) {
		ENEMY->health -= 2;
		ENEMY->turn = 2;	
		PLAYER->special_count = 1;
		return "boss is too big and floats too much for you to throw.\ninstead you poke its eyes out.\nboss cant see for 2 turns.";
	}
	else {
		return "you try to poke the monster's eyes out but couldn't get close enough.";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xa, %edi
callq 0x20e0
leaq 0xde87(%rip), %rcx      # 0x11150
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jle 0x3321
leaq 0xde74(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl (%rax), %ecx
subl $0x2, %ecx
movl %ecx, (%rax)
leaq 0xde5f(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl $0x2, 0x4(%rax)
leaq 0xde42(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl $0x1, 0x8(%rax)
leaq 0x7b84(%rip), %rax      # 0xae9f
movq %rax, -0x8(%rbp)
jmp 0x332c
leaq 0x7be7(%rip), %rax      # 0xaf0f
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: defensedownBoss
static char *defensedownBoss(void) {
	if(getRandInt(10) > ENEMY->chance_to_dodge) {
		PLAYER->attack += 2;
		PLAYER->special_count = 1;
		return "your spell failed against boss\nyou try a different spell, this one increases your attack by 2.\nit works just fine";
	}
	else {
		return "you tried to cast a spell against boss monster, but failed.";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xa, %edi
callq 0x20e0
leaq 0xddf7(%rip), %rcx      # 0x11150
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jle 0x339e
leaq 0xdddc(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x10(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x10(%rax)
leaq 0xddc5(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
movl $0x1, 0x8(%rax)
leaq 0x7bbd(%rip), %rax      # 0xaf55
movq %rax, -0x8(%rbp)
jmp 0x33a9
leaq 0x7c22(%rip), %rax      # 0xafc7
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: checkEnragedEnemy
static int checkEnragedEnemy(void){
	switch(ENEMY->type) {
		case 13://enraged halflings
		case 14://enraged halflings
		case 15://enraged monster
		case 16://enraged monster
		case 17://enraged delmer
		case 18://enraged delmer
			return 1;
			break;
		default: return 0;
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xdd85(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
movl 0x1c(%rax), %eax
addl $-0xd, %eax
subl $0x5, %eax
ja 0x33e8
jmp 0x33df
movl $0x1, -0x4(%rbp)
jmp 0x33ef
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: computerSelection
static void computerSelection(int *const play) {
	wclear(prompt_win);
	switch(getRandInt(9)+1) {
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:attackEnemySelection(ENEMY,PLAYER);
			break;
		case 6:
		case 7:
		case 8:(ENEMY->defense_up == 0) ? raiseDefense(ENEMY) : computerSelection(play);
			break;		
		case 9:
		case 10:(ENEMY->special_count < 1) ? useSpecial(ENEMY,PLAYER) : computerSelection(play);
			break;
		default:attackEnemySelection(ENEMY,PLAYER);
			break;
	}	
	if (PLAYER->health < 1 || ENEMY->health < 1) {
		*play = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xdd15(%rip), %rax      # 0x11128
movq (%rax), %rdi
callq 0x1090
movl $0x9, %edi
callq 0x20e0
movl %eax, %ecx
incl %ecx
movl %ecx, -0xc(%rbp)
subl $0x5, %eax
jb 0x3450
jmp 0x3433
movl -0xc(%rbp), %eax
addl $-0x6, %eax
subl $0x3, %eax
jb 0x3476
jmp 0x3440
movl -0xc(%rbp), %eax
addl $-0x9, %eax
subl $0x2, %eax
jb 0x34aa
jmp 0x34ec
leaq 0xdcf9(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rdi
leaq 0xdce3(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rsi
callq 0x1d00
jmp 0x350d
leaq 0xdcd3(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x24(%rax)
jne 0x349f
leaq 0xdcbf(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rdi
callq 0x1e30
jmp 0x34a8
movq -0x8(%rbp), %rdi
callq 0x3400
jmp 0x350d
leaq 0xdc9f(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
cmpl $0x1, 0x8(%rax)
jge 0x34e1
leaq 0xdc8b(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rdi
leaq 0xdc75(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rsi
callq 0x1ec0
jmp 0x34ea
movq -0x8(%rbp), %rdi
callq 0x3400
jmp 0x350d
leaq 0xdc5d(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rdi
leaq 0xdc47(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rsi
callq 0x1d00
leaq 0xdc34(%rip), %rax      # 0x11148
movq (%rax), %rax
movq 0x28(%rax), %rax
cmpl $0x1, (%rax)
jl 0x3533
leaq 0xdc29(%rip), %rax      # 0x11150
movq (%rax), %rax
movq 0x28(%rax), %rax
cmpl $0x1, (%rax)
jge 0x353d
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/attack.c
// Function: resetTile
static void resetTile(void) {
	if(previous->tile_set == 'e') {
		switch(previous->type) {
			case 1:
			case 2:
			case 3:
			case 5: previous->tile_set = 'x';
				break;
			default: previous->tile_set = previous->tile_temp;
				break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xdbf5(%rip), %rax      # 0x11150
movq (%rax), %rax
movsbl 0x20(%rax), %eax
cmpl $0x65, %eax
jne 0x35b6
leaq 0xdbe2(%rip), %rax      # 0x11150
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
decl %eax
subl $0x3, %eax
jb 0x358a
jmp 0x3580
movl -0x4(%rbp), %eax
subl $0x5, %eax
jne 0x359a
jmp 0x358a
leaq 0xdbbf(%rip), %rax      # 0x11150
movq (%rax), %rax
movb $0x78, 0x20(%rax)
jmp 0x35b4
leaq 0xdbaf(%rip), %rax      # 0x11150
movq (%rax), %rax
movb 0x21(%rax), %cl
leaq 0xdba2(%rip), %rax      # 0x11150
movq (%rax), %rax
movb %cl, 0x20(%rax)
jmp 0x35b6
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/initgame.c
// Function: initGame
void initGame(void) {
	initWindow();
	initColors();
	makeGameWin();
	makePromptWin();
	initMap();      //makemap.c
	makePlayer();
	setUpStart();	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x35f0
callq 0x3660
callq 0x3710
callq 0x37c0
callq 0x5580
callq 0x3800
callq 0x3aa0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/initgame.c
// Function: initWindow
static void initWindow(void) {
	initscr();
	noecho();	      //dont display key strokes
	cbreak();	     //disable line buffering
	curs_set(0);	//dont display cursor
	keypad(stdscr, TRUE); //enable keypad
	half_y = COLS / 2;
	half_x = LINES / 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x10b0
callq 0x10a0
callq 0x1140
xorl %edi, %edi
callq 0x1060
movq 0xd9bf(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x10f0
movq 0xd9bb(%rip), %rax      # 0x10fe0
movl (%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
leaq 0xdb00(%rip), %rax      # 0x11138
movl %ecx, (%rax)
movq 0xd9a7(%rip), %rax      # 0x10fe8
movl (%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
leaq 0xdae0(%rip), %rax      # 0x11134
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/initgame.c
// Function: initColors
static void initColors(void) {
	start_color();
	init_color(COLOR_YELLOW,700,700,98);
	init_pair(1,COLOR_BLACK,COLOR_BLACK);   
	init_pair(2,COLOR_WHITE,COLOR_BLACK);  
	init_pair(3,COLOR_GREEN,COLOR_BLACK);  
	init_pair(4,COLOR_YELLOW,COLOR_BLACK);  
	init_pair(5,COLOR_CYAN,COLOR_BLACK);  
	init_pair(6,COLOR_RED,COLOR_BLACK);	
	init_pair(7,COLOR_MAGENTA,COLOR_BLACK);
	init_pair(8,COLOR_BLUE,COLOR_BLACK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x10e0
movl $0x3, %edi
movl $0x2bc, %edx            # imm = 0x2BC
movl $0x62, %ecx
movl %edx, %esi
callq 0x1170
movl $0x1, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x1150
movl $0x2, %edi
movl $0x7, %esi
xorl %edx, %edx
callq 0x1150
movl $0x3, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1150
movl $0x4, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1150
movl $0x5, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x1150
movl $0x6, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1150
movl $0x7, %edi
movl $0x5, %esi
xorl %edx, %edx
callq 0x1150
movl $0x8, %edi
movl $0x4, %esi
xorl %edx, %edx
callq 0x1150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/initgame.c
// Function: makeGameWin
static void makeGameWin(void){
	game_win = newwin(HEIGHT,WIDTH,3,3);
	game_border = newwin(HEIGHT+2,WIDTH+2,2,2);
	wborder(game_border,'|','|','-', '-', '+', '+', '+', '+');	
	refresh();
	wrefresh(game_win);
	wrefresh(game_border);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x14, %edi
movl $0x32, %esi
movl $0x3, %ecx
movl %ecx, %edx
callq 0x1040
movq %rax, 0xd9eb(%rip)      # 0x11120
movl $0x16, %edi
movl $0x34, %esi
movl $0x2, %ecx
movl %ecx, %edx
callq 0x1040
movq %rax, 0xd9c6(%rip)      # 0x11118
movq 0xd9bf(%rip), %rdi      # 0x11118
movl $0x7c, %edx
movl $0x2d, %r8d
movl $0x2b, %r9d
movl %edx, %esi
movl %r8d, %ecx
movl $0x2b, (%rsp)
movl $0x2b, 0x8(%rsp)
movl $0x2b, 0x10(%rsp)
callq 0x1070
movq 0xd83e(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
callq 0x10c0
movq 0xd97f(%rip), %rdi      # 0x11120
callq 0x10c0
movq 0xd96b(%rip), %rdi      # 0x11118
callq 0x10c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/initgame.c
// Function: setUpStart
void setUpStart(void) {
	player->x = 0;
	player->y = 0;
	map[0][0]->type = 0;
 	previous = map[0][0];
	map[0][0] = player;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xd69d(%rip), %rax      # 0x11148
movq (%rax), %rax
movl $0x0, (%rax)
leaq 0xd68d(%rip), %rax      # 0x11148
movq (%rax), %rax
movl $0x0, 0x4(%rax)
leaq 0xd6a4(%rip), %rax      # 0x11170
movq (%rax), %rax
movl $0x0, 0xc(%rax)
leaq 0xd693(%rip), %rax      # 0x11170
movq (%rax), %rcx
leaq 0xd669(%rip), %rax      # 0x11150
movq %rcx, (%rax)
leaq 0xd657(%rip), %rax      # 0x11148
movq (%rax), %rcx
leaq 0xd675(%rip), %rax      # 0x11170
movq %rcx, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/main.c
// Function: main
int main(void) {
	initGame();	//initgame.c
	refresh();
	runGameLoop();
	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x35c0
movq 0xd475(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
callq 0x10c0
callq 0x3b70
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/main.c
// Function: runGameLoop
static void runGameLoop(void) {
	while(continue_game) {
		checkTileForEnemyAndObj();
		checkForThings();
		(teleport == 0) ? checkScore() : teleportPlayer();
		if(!continue_game) {
			break;
		}
		printMap();
		printPrompt();
		int c = getch();
		getPlayerMovement(c);

	}
	cleanUp();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0xd581(%rip)      # 0x11100
je 0x3bd1
callq 0x3be0
callq 0x3c40
cmpl $0x0, 0xd5c6(%rip)      # 0x11158
jne 0x3b9b
callq 0x3ce0
jmp 0x3ba0
callq 0x3d00
cmpl $0x0, 0xd559(%rip)      # 0x11100
jne 0x3bab
jmp 0x3bd1
callq 0x3e10
callq 0x3ee0
movq 0xd414(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
callq 0x1080
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x3f70
jmp 0x3b78
callq 0x4080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/main.c
// Function: checkTileForEnemyAndObj
static void checkTileForEnemyAndObj(void) {
	switch (previous->type) {
		case 1: foundEnemy();
			break;
		case 2: foundObj();
			break;
		case 3: foundWell();
			break;
		case 4: foundShrine();
			break;
		default: //do nothing
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xd561(%rip), %rax      # 0x11150
movl 0xc(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x8(%rbp)
subl $0x3, %eax
ja 0x3c2f
movq -0x8(%rbp), %rax
leaq 0x7556(%rip), %rcx      # 0xb160
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x4090
jmp 0x3c31
callq 0x40e0
jmp 0x3c31
callq 0x41b0
jmp 0x3c31
callq 0x4210
jmp 0x3c31
jmp 0x3c31
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/main.c
// Function: checkForThings
static void checkForThings(void) {
	int detect_thing = 0;
	wclear(prompt_win);
	checkForThingsFront(&detect_thing);
	checkForThingsBehind(&detect_thing);
	checkForThingsAbove(&detect_thing);
	checkForThingsBelow(&detect_thing);
	mvwprintw(prompt_win,0, half_x-9,"%s",(detect_thing == 0) ? "you dont detect anything." : "you detect something nearby.");
	wrefresh(prompt_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xd4d2(%rip), %rax      # 0x11128
movq (%rax), %rdi
callq 0x1090
leaq -0x4(%rbp), %rdi
callq 0x49d0
leaq -0x4(%rbp), %rdi
callq 0x4a60
leaq -0x4(%rbp), %rdi
callq 0x4af0
leaq -0x4(%rbp), %rdi
callq 0x4cb0
leaq 0xd49f(%rip), %rax      # 0x11128
movq (%rax), %rdi
movl 0xd4a2(%rip), %edx      # 0x11134
subl $0x9, %edx
movl -0x4(%rbp), %ecx
leaq 0x797f(%rip), %r8       # 0xb61e
leaq 0x795e(%rip), %rax      # 0xb604
cmpl $0x0, %ecx
cmoveq %rax, %r8
xorl %esi, %esi
leaq 0x6614(%rip), %rcx      # 0xa2ca
movb $0x0, %al
callq 0x10d0
leaq 0xd464(%rip), %rax      # 0x11128
movq (%rax), %rdi
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/main.c
// Function: teleportPlayer
static void teleportPlayer(void) {
	if(player->x == (HEIGHT/2) && player->y == (WIDTH/2) ) {
		teleport = 0;
		if(boss < 1) {
			boss = 1;
			score_limit = score + 100;
			wclear(game_win);
			wclear(prompt_win);
			wprintw(prompt_win,"you enter the teleporter to be transported to another land.");
			wrefresh(game_win);
			wrefresh(prompt_win);
			getch();
			temp = malloc(sizeof(tile));
			*temp = *player;
			initMap2(); //makemap.c
			player = temp;
			setUpStart(); //initgame.c
		}
		else{
			BossFight();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xd43d(%rip), %rax      # 0x11148
cmpl $0xa, (%rax)
jne 0x3e02
movq 0xd42d(%rip), %rax      # 0x11148
cmpl $0x19, 0x4(%rax)
jne 0x3e02
movl $0x0, 0xd429(%rip)      # 0x11158
cmpl $0x1, 0xd432(%rip)      # 0x11168
jge 0x3dfb
movl $0x1, 0xd422(%rip)      # 0x11168
movl 0xd3e4(%rip), %eax      # 0x11130
addl $0x64, %eax
movl %eax, 0xd3af(%rip)      # 0x11104
leaq 0xd3c4(%rip), %rax      # 0x11120
movq (%rax), %rdi
callq 0x1090
leaq 0xd3bd(%rip), %rax      # 0x11128
movq (%rax), %rdi
callq 0x1090
leaq 0xd3ae(%rip), %rax      # 0x11128
movq (%rax), %rdi
leaq 0x791e(%rip), %rsi      # 0xb6a2
movb $0x0, %al
callq 0x11a0
leaq 0xd38e(%rip), %rax      # 0x11120
movq (%rax), %rdi
callq 0x10c0
leaq 0xd387(%rip), %rax      # 0x11128
movq (%rax), %rdi
callq 0x10c0
movq 0xd220(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
callq 0x1080
movl $0x38, %edi
callq 0x1160
movq %rax, 0xd377(%rip)      # 0x11140
movq 0xd370(%rip), %rdi      # 0x11140
movq 0xd371(%rip), %rsi      # 0x11148
movl $0x38, %edx
callq 0x1120
callq 0x59f0
movq 0xd353(%rip), %rax      # 0x11140
movq %rax, 0xd354(%rip)      # 0x11148
callq 0x3aa0
jmp 0x3e00
callq 0x50b0
jmp 0x3e02
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/main.c
// Function: printMap
static void printMap(void){
	int i,j;
	wclear(game_win);
	fruit(i = 0; i < HEIGHT; i++) {
		fruit(j = 0; j < WIDTH; j++) {
			setColorAttrOn(map[i][j]->tile_set);
			mvwprintw(game_win,i,j,"%c",map[i][j]->tile_set);
			setColorAttrOff();
		}
	}
	wrefresh(game_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xd301(%rip), %rax      # 0x11120
movq (%rax), %rdi
callq 0x1090
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0x3ecb
movl $0x0, -0x8(%rbp)
cmpl $0x32, -0x8(%rbp)
jge 0x3ebb
movslq -0x4(%rbp), %rcx
leaq 0xd320(%rip), %rax      # 0x11170
imulq $0x190, %rcx, %rcx      # imm = 0x190
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x20(%rax), %edi
callq 0x5200
leaq 0xd2ae(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movslq -0x4(%rbp), %rcx
leaq 0xd2ea(%rip), %rax      # 0x11170
imulq $0x190, %rcx, %rcx      # imm = 0x190
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x20(%rax), %r8d
leaq 0x7900(%rip), %rcx      # 0xb7a4
movb $0x0, %al
callq 0x10d0
callq 0x5370
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3e3f
jmp 0x3ebd
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3e2e
leaq 0xd24e(%rip), %rax      # 0x11120
movq (%rax), %rdi
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq