LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/comfies[P]custard/src/wm/window.c
// Function: get_window_by_id
window_t *get_window_by_id(xcb_window_t window_id) {
    if (window_id == xcb_screen->root || window_id == ewmh_window ||
        window_id == XCB_WINDOW_NONE)
        return NULL;

    if (windows) {
        window_t *window;
        while ((window = vector_iterator(windows))) {
            if (window->id == window_id) {
                reset_vector_iterator(windows);
                return window;
            }
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x5b93(%rip), %rax      # 0xc900
movq (%rax), %rax
cmpl %edi, (%rax)
jne 0x6d80
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %edi, %ebp
xorl %ebx, %ebx
testl %edi, %edi
je 0x6d76
leaq 0x5b89(%rip), %rax      # 0xc918
cmpl %ebp, (%rax)
je 0x6d76
cmpq $0x0, 0x5b4d(%rip)      # 0xc8e8
je 0x6d74
movq 0x5b44(%rip), %rdi      # 0xc8e8
callq 0x3851
testq %rax, %rax
je 0x6d74
movq %rax, %rbx
cmpl %ebp, (%rax)
jne 0x6d9d
movq 0x5b2c(%rip), %rdi      # 0xc8e8
callq 0x3885
testq %rbx, %rbx
jne 0x6d76
jmp 0x6d74
// File: /workspace/github_c_makefile_star2_O1/comfies[P]custard/src/wm/window.c
// Function: set_window_geometry
void set_window_geometry(window_t *window, void *geometry) {
    window->geometry = geometry;

    monitor_t *monitor = NULL;
    if (window->rule && window->rule->rules) {
        kv_value_t *value;
        value = get_value_from_key(window->rule->rules, "monitor");

        if (value)
            if (monitor_from_name(value->string))
                monitor = monitor_from_name(value->string);
    }

    if (!monitor)
        monitor = monitor_with_cursor_residence();

    screen_geometry_t *screen_geometry = NULL;
    if (window->floating)
        screen_geometry = (screen_geometry_t*)geometry;
    else
        screen_geometry = get_equivalent_screen_geometry(
            (grid_geometry_t*)geometry, monitor);
    apply_decoration_to_window_screen_geometry(window, screen_geometry);

    change_window_geometry(window->id,
        0, 0,
        (unsigned int)screen_geometry->height,
        (unsigned int)screen_geometry->width);

    change_window_geometry(window->parent,
        (unsigned int)screen_geometry->x,
        (unsigned int)screen_geometry->y,
        (unsigned int)screen_geometry->height,
        (unsigned int)screen_geometry->width);
    free(screen_geometry);

    log_debug("Window(%08x) window geometry set", window->id);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x70d3
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x70d3
leaq 0x111a(%rip), %rsi      # 0x81c9
callq 0x4e15
testq %rax, %rax
je 0x70d3
movq %rax, %r15
movq (%rax), %rdi
callq 0x69ad
testq %rax, %rax
je 0x70d3
movq (%r15), %rdi
callq 0x69ad
jmp 0x70d5
xorl %eax, %eax
testq %rax, %rax
jne 0x70df
callq 0x69f2
cmpw $0x0, 0x22(%rbx)
jne 0x70f4
movq %r14, %rdi
movq %rax, %rsi
callq 0x5feb
movq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x57cc
cvttss2si 0x8(%r14), %rcx
movl (%rbx), %edi
cvttss2si 0xc(%r14), %r8
xorl %esi, %esi
xorl %edx, %edx
callq 0x7a32
cvttss2si (%r14), %rsi
cvttss2si 0x4(%r14), %rdx
cvttss2si 0x8(%r14), %rcx
movl 0x4(%rbx), %edi
cvttss2si 0xc(%r14), %r8
callq 0x7a32
movq %r14, %rdi
callq 0x3060
movl (%rbx), %r9d
leaq 0x1592(%rip), %rsi      # 0x86d9
leaq 0x15d7(%rip), %rdx      # 0x8725
leaq 0x15e4(%rip), %r8       # 0x8739
movl $0x3, %edi
movl $0xfe, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x5206
// File: /workspace/github_c_makefile_star2_O1/comfies[P]custard/src/wm/window.c
// Function: unmanage_window
void unmanage_window(xcb_window_t window_id) {
    window_t *window;
    for (unsigned int index = 0; index < windows->size; index++) {
        window = get_from_vector(windows, index);

        if (window->id == window_id) {

            pull_from_vector(windows, index);
            xcb_destroy_window(xcb_connection, window->parent);
            free(window);

            log_debug("Window(%08x) unmanaged", window_id);
            return;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movq 0x5770(%rip), %rdi      # 0xc8e8
cmpl $0x0, 0xc(%rdi)
je 0x7199
xorl %ebp, %ebp
movl %ebp, %esi
callq 0x3873
cmpl %ebx, (%rax)
je 0x719e
incl %ebp
movq 0x5754(%rip), %rdi      # 0xc8e8
cmpl 0xc(%rdi), %ebp
jb 0x7180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq 0x5740(%rip), %rdi      # 0xc8e8
movl %ebp, %esi
callq 0x38d1
leaq 0x5742(%rip), %rax      # 0xc8f8
movq (%rax), %rdi
movl 0x4(%r14), %esi
callq 0x3070
movq %r14, %rdi
callq 0x3060
leaq 0x1508(%rip), %rsi      # 0x86d9
leaq 0x1526(%rip), %rdx      # 0x86fe
leaq 0x152f(%rip), %r8       # 0x870e
movl $0x3, %edi
movl $0xd4, %ecx
movl %ebx, %r9d
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x5206
// File: /workspace/github_c_makefile_star2_O1/comfies[P]custard/src/wm/window.c
// Function: get_setting_from_window_rules
kv_value_t *get_setting_from_window_rules(window_t *window, char *setting) {
    if (window->rule)
        return get_value_from_key_with_fallback(
            window->rule->rules, setting);
    return get_value_from_key(configuration, setting);
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x7209
movq 0x10(%rax), %rdi
jmp 0x4e60
leaq 0x56b0(%rip), %rax      # 0xc8c0
movq (%rax), %rdi
jmp 0x4e15
// File: /workspace/github_c_makefile_star2_O1/comfies[P]custard/src/wm/workspace.c
// Function: show_workspace_on_monitor
void show_workspace_on_monitor(monitor_t *monitor, unsigned int workspace) {
    // TODO: test for integrity of workspace
    if (!workspace)
        return; // workspace 0 unavailable

    unsigned int workspaces = get_value_from_key_with_fallback(
        monitor->configuration, "workspaces")->number;

    if (workspaces < workspace)
        return;

    monitor->workspace = workspace;

    window_t *window = NULL;
    while ((window = vector_iterator(windows))) {
        if (window->monitor != monitor)
            continue;

        if (monitor->workspace == window->workspace)
            map_window(window->parent);
        else
            unmap_window(window->parent);
    }
}

// Assembly:
testl %esi, %esi
je 0x723d
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x1146(%rip), %rsi      # 0x8376
callq 0x4e60
cmpl %ebp, (%rax)
jae 0x723e
popq %rbx
popq %r14
popq %rbp
retq
movl %ebp, 0x20(%rbx)
leaq 0x56a0(%rip), %r14      # 0xc8e8
movq (%r14), %rdi
callq 0x3851
testq %rax, %rax
je 0x7239
cmpq %rbx, 0x18(%rax)
jne 0x7248
movl 0x20(%rbx), %ecx
movl 0x4(%rax), %edi
cmpl 0x24(%rax), %ecx
jne 0x726d
callq 0x76d4
jmp 0x7248
callq 0x7712
jmp 0x7248
// File: /workspace/github_c_makefile_star2_O1/comfies[P]custard/src/xcb/window.c
// Function: focus_window
void focus_window(xcb_window_t window_id) {
    unsigned int values[2] = {
        XCB_ICCCM_WM_STATE_NORMAL,
        XCB_NONE
    };

    xcb_change_property(xcb_connection, XCB_PROP_MODE_REPLACE, window_id,
        ewmh_connection->_NET_WM_STATE, ewmh_connection->_NET_WM_STATE,
        32, 2, values);

    xcb_set_input_focus(xcb_connection, XCB_INPUT_FOCUS_POINTER_ROOT,
        window_id, XCB_CURRENT_TIME);
    xcb_ewmh_set_active_window(ewmh_connection, 0, window_id);

    log_debug("Window(%08x) focused", window_id);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %rax
movq $0x1, (%rax)
leaq 0x518a(%rip), %r14      # 0xc8f8
movq (%r14), %rdi
leaq 0x51a8(%rip), %r15      # 0xc920
movq (%r15), %rcx
movl 0x84(%rcx), %ecx
xorl %esi, %esi
movl %ebx, %edx
movl %ecx, %r8d
movl $0x20, %r9d
pushq %rax
pushq $0x2
callq 0x3660
addq $0x10, %rsp
movq (%r14), %rdi
movl $0x1, %esi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x3600
movq (%r15), %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x3110
leaq 0x1094(%rip), %rsi      # 0x8852
leaq 0x10fe(%rip), %rdx      # 0x88c3
leaq 0x1104(%rip), %r8       # 0x88d0
movl $0x3, %edi
movl $0x2a, %ecx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x5206
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/comfies[P]custard/src/xcb/window.c
// Function: raise_window
void raise_window(xcb_window_t window_id) {
    unsigned int value_mask = XCB_CONFIG_WINDOW_STACK_MODE;
    unsigned int values[1] = {
        XCB_STACK_MODE_ABOVE
    };

    configure_window(window_id, value_mask, values);

    log_debug("Window(%08x) raised", window_id);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x4(%rsp), %rcx
movl $0x0, (%rcx)
leaq 0x50f6(%rip), %rax      # 0xc8f8
movq (%rax), %rdi
movl %ebx, %esi
movl $0x40, %edx
callq 0x3300
leaq 0x103a(%rip), %r14      # 0x8852
leaq 0x1044(%rip), %rdx      # 0x8863
leaq 0x104e(%rip), %r8       # 0x8874
movl $0x3, %edi
movq %r14, %rsi
movl $0xd, %ecx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x5206
leaq 0x10a1(%rip), %rdx      # 0x88e5
leaq 0x10a7(%rip), %r8       # 0x88f2
movl $0x3, %edi
movq %r14, %rsi
movl $0x35, %ecx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x5206
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/comfies[P]custard/src/xcb/window.c
// Function: lower_window
void lower_window(xcb_window_t window_id) {
    unsigned int value_mask = XCB_CONFIG_WINDOW_STACK_MODE;
    unsigned int values[1] = {
        XCB_STACK_MODE_BELOW
    };

    configure_window(window_id, value_mask, values);

    log_debug("Window(%08x) lowered", window_id);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x4(%rsp), %rcx
movl $0x1, (%rcx)
leaq 0x5076(%rip), %rax      # 0xc8f8
movq (%rax), %rdi
movl %ebx, %esi
movl $0x40, %edx
callq 0x3300
leaq 0xfba(%rip), %r14       # 0x8852
leaq 0xfc4(%rip), %rdx       # 0x8863
leaq 0xfce(%rip), %r8        # 0x8874
movl $0x3, %edi
movq %r14, %rsi
movl $0xd, %ecx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x5206
leaq 0x1042(%rip), %rdx      # 0x8906
leaq 0x1048(%rip), %r8       # 0x8913
movl $0x3, %edi
movq %r14, %rsi
movl $0x40, %ecx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x5206
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/comfies[P]custard/src/xcb/window.c
// Function: change_window_geometry
void change_window_geometry(xcb_window_t window_id, unsigned int x,
    unsigned int y, unsigned int height, unsigned int width) {

    unsigned int value_mask = XCB_CONFIG_WINDOW_X |
        XCB_CONFIG_WINDOW_Y     |
        XCB_CONFIG_WINDOW_WIDTH |
        XCB_CONFIG_WINDOW_HEIGHT;
    unsigned int values[4] = { x, y, width, height };

    configure_window(window_id, value_mask, values);

    log_debug("Window(%08x) geometry changed %dx%d (%d,%d)", window_id,
        width, height, x, y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movl %ecx, %r14d
movl %edx, %r12d
movl %esi, %r15d
movl %edi, %ebp
movq %rsp, %rcx
movl %esi, (%rcx)
movl %edx, 0x4(%rcx)
movl %r8d, 0x8(%rcx)
movl %r14d, 0xc(%rcx)
leaq 0x4e93(%rip), %rax      # 0xc8f8
movq (%rax), %rdi
movl %ebp, %esi
movl $0xf, %edx
callq 0x3300
leaq 0xdd7(%rip), %r13       # 0x8852
leaq 0xde1(%rip), %rdx       # 0x8863
leaq 0xdeb(%rip), %r8        # 0x8874
movl $0x3, %edi
movq %r13, %rsi
movl $0xd, %ecx
movl %ebp, %r9d
xorl %eax, %eax
callq 0x5206
leaq 0xee6(%rip), %rdx       # 0x898d
leaq 0xef6(%rip), %r8        # 0x89a4
movl $0x3, %edi
movq %r13, %rsi
movl $0x7d, %ecx
movl %ebp, %r9d
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
callq 0x5206
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/comfies[P]custard/src/xcb/window.c
// Function: get_window_property
void *get_window_property(xcb_window_t window_id, xcb_atom_t property,
    xcb_atom_t atom_type) {
    xcb_get_property_cookie_t atom_cookie;
    atom_cookie = xcb_get_property(xcb_connection, 0, window_id, property,
        atom_type, 0, 256);

    xcb_get_property_reply_t *property_cookie;
    property_cookie = xcb_get_property_reply(xcb_connection, atom_cookie, NULL);

    void *window_property;
    window_property = xcb_get_property_value(property_cookie);

    return window_property;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edx, %r8d
movl %esi, %ecx
movl %edi, %edx
leaq 0x4e0a(%rip), %rbx      # 0xc8f8
movq (%rbx), %rdi
movl $0x100, (%rsp)          # imm = 0x100
xorl %esi, %esi
xorl %r9d, %r9d
callq 0x30d0
movq (%rbx), %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x3510
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x3180
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/attack.c
// Function: setUpBoss
void setUpBoss(void) {
	Character *b = malloc(sizeof(Character));
	b->name = "Big Boss Monster";
	b->special_count = 0;
	b->turn = 0;
	b->health = 25;
	b->health_max = 25;
	b->attack = 8;
	b->defense = 3;
	b->crit_chance = 6;
	b->chance_to_dodge = 6;
	b->defense_up = 0;
	b->type = 19;
	ENEMY = b;
	previous->type = 1;
	makeBossStrings();
}

// Assembly:
pushq %rax
movl $0xa8, %edi
callq 0x1160
leaq 0x5db6(%rip), %rcx      # 0x7094
movq %rcx, 0x38(%rax)
xorl %ecx, %ecx
movl %ecx, 0x8(%rax)
movq $0x19, (%rax)
movaps 0x5d1b(%rip), %xmm0     # 0x7010
movups %xmm0, 0xc(%rax)
movl %ecx, 0x24(%rax)
movabsq $0x600000013, %rcx      # imm = 0x600000013
movq %rcx, 0x1c(%rax)
leaq 0xbe2f(%rip), %rcx      # 0xd140
movq (%rcx), %rcx
movq %rax, 0x28(%rcx)
movl $0x1, 0xc(%rcx)
leaq 0x5d7f(%rip), %rcx      # 0x70a5
movq %rcx, 0x48(%rax)
leaq 0x5d9c(%rip), %rcx      # 0x70cd
movq %rcx, 0x50(%rax)
leaq 0x5db2(%rip), %rcx      # 0x70ee
movq %rcx, 0x68(%rax)
leaq 0x5dcb(%rip), %rcx      # 0x7112
movq %rcx, 0x70(%rax)
leaq 0x5dfa(%rip), %rcx      # 0x714c
movq %rcx, 0x78(%rax)
leaq 0x5e33(%rip), %rcx      # 0x7190
movq %rcx, 0x88(%rax)
leaq 0x5ebe(%rip), %rcx      # 0x7229
movq %rcx, 0x90(%rax)
leaq 0x5f02(%rip), %rcx      # 0x727b
movq %rcx, 0xa0(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/attack.c
// Function: printAttackPrompt
static void printAttackPrompt() {
	wclear(prompt_win);
	wprintw(prompt_win,"player health is %d, attack is %d, defense is %d, food is %d\n",PLAYER->health,PLAYER->attack,PLAYER->defense,PLAYER->food);
	wprintw(prompt_win,"\tdo you wish to\n\t\t1)attack\n\t\t2)raise defenses\n\t\t3)%s\n\t\t4)run away\n\t\t5)eat some food to recover health\n",PLAYER->special_name);
	wrefresh(prompt_win);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xb70a(%rip), %rbx      # 0xd118
movq (%rbx), %rdi
callq 0x1090
movq (%rbx), %rdi
leaq 0xb718(%rip), %r14      # 0xd138
movq (%r14), %rax
movq 0x28(%rax), %rax
movl (%rax), %edx
movl 0x10(%rax), %ecx
movl 0x14(%rax), %r8d
movl 0x2c(%rax), %r9d
leaq 0x5a6e(%rip), %rsi      # 0x74a9
xorl %eax, %eax
callq 0x1190
movq (%rbx), %rdi
movq (%r14), %rax
movq 0x28(%rax), %rax
movq 0x40(%rax), %rdx
leaq 0x5a90(%rip), %rsi      # 0x74e7
xorl %eax, %eax
callq 0x1190
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10d0
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/attack.c
// Function: attackEnemySelection
static void attackEnemySelection(Character *const attacker,Character *const defender) {
	if(getRandInt(10) > defender->chance_to_dodge || defender->turn != 0) {
		(getRandInt(10) > attacker->crit_chance) ? criticalHit(attacker,defender,attacker->critical_hit) : regularHit(attacker,defender,attacker->regular_attack);
	}
	else {
		missed(attacker,defender,attacker->regular_miss);
	}

	switch(attacker->type) {
		case 4:
		case 10:
		case 12: //allows these enemies a second attack
			if(getRandInt(10) > defender->chance_to_dodge) {
				(getRandInt(10) > attacker->crit_chance) ? criticalHit(attacker,defender,attacker->critical_hit_second) : regularHit(attacker,defender,attacker->regular_attack_second);
			}
			else {
				missed(attacker,defender,attacker->regular_miss_second);
			}
			break;
		default: //do nothing
			break;
	}
	refreshPrompt();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11c0
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jg 0x1a77
cltq
imulq $0x2c000001, %rax, %rax # imm = 0x2C000001
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x39, %rax
addl %ecx, %eax
cmpl 0x20(%rbx), %eax
jg 0x1aa4
cmpl $0x0, 0x4(%rbx)
je 0x1aee
callq 0x11c0
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jg 0x1aa4
cltq
imulq $0x2c000001, %rax, %rax # imm = 0x2C000001
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x39, %rax
addl %ecx, %eax
cmpl 0x18(%r14), %eax
jle 0x1add
movq 0x78(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f3a
jmp 0x1afd
movq 0x48(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fad
jmp 0x1afd
movq 0x50(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2024
movl 0x1c(%r14), %eax
cmpl $0xc, %eax
ja 0x1b9b
movl $0x1410, %ecx           # imm = 0x1410
btl %eax, %ecx
jae 0x1b9b
callq 0x11c0
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jg 0x1b18
cltq
imulq $0x2c000001, %rax, %rax # imm = 0x2C000001
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x39, %rax
addl %ecx, %eax
cmpl 0x20(%rbx), %eax
jle 0x1b7b
callq 0x11c0
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jg 0x1b3f
cltq
imulq $0x2c000001, %rax, %rax # imm = 0x2C000001
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x39, %rax
addl %ecx, %eax
cmpl 0x18(%r14), %eax
jle 0x1b8c
movq 0x80(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f3a
jmp 0x1b9b
movq 0x60(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2024
jmp 0x1b9b
movq 0x58(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fad
leaq 0xb576(%rip), %rax      # 0xd118
movq (%rax), %rdi
callq 0x10d0
movq 0xb41f(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/attack.c
// Function: raiseDefense
static void raiseDefense(Character *const attacker) {
	wprintw(prompt_win,"%s\n",attacker->raise_defense);
	attacker->defense += 2;
	attacker->defense_up = 1;
	refreshPrompt();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb54a(%rip), %r14      # 0xd118
movq (%r14), %rdi
movq 0x70(%rbx), %rdx
leaq 0x5a20(%rip), %rsi      # 0x75fc
xorl %eax, %eax
callq 0x1190
addl $0x2, 0x14(%rbx)
movl $0x1, 0x24(%rbx)
movq (%r14), %rdi
callq 0x10d0
movq 0xb3d3(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl 0x10(%rdi), %eax
subl 0x14(%rsi), %eax
leal 0x2(%rax), %ecx
testl %eax, %eax
movl $0x3, %ebx
cmovgl %ecx, %ebx
movq %rdx, %r14
subl %ebx, (%rsi)
movq %rsi, %rdi
callq 0x20a4
testl %eax, %eax
je 0x1f69
popq %rbx
popq %r14
popq %r15
retq
movl $0xd, %edi
callq 0x1160
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1180
leaq 0xb18c(%rip), %rax      # 0xd118
movq (%rax), %rdi
leaq 0x5666(%rip), %rsi      # 0x75fc
movq %r15, %rdx
xorl %eax, %eax
callq 0x1190
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl 0x10(%rdi), %eax
subl 0x14(%rsi), %eax
cmpl $0x2, %eax
movl $0x1, %ebx
cmovgel %eax, %ebx
subl %ebx, (%rsi)
movq %rdx, %r14
cmpl $0xb, 0x1c(%rsi)
je 0x1fe0
movq %rsi, %rdi
callq 0x20a4
testl %eax, %eax
je 0x1fe0
popq %rbx
popq %r14
popq %r15
retq
movl $0xd, %edi
callq 0x1160
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1180
leaq 0xb115(%rip), %rax      # 0xd118
movq (%rax), %rdi
leaq 0x55ef(%rip), %rsi      # 0x75fc
movq %r15, %rdx
xorl %eax, %eax
callq 0x1190
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x1c(%rsi), %eax
cmpl $0x13, %eax
ja 0x26ad
movl $0x7e000, %ecx          # imm = 0x7E000
btl %eax, %ecx
jae 0x2609
leaq 0xab2c(%rip), %rax      # 0xd118
movq (%rax), %rdi
movq 0x98(%r14), %rdx
leaq 0x4fff(%rip), %rsi      # 0x75fc
xorl %eax, %eax
callq 0x1190
addl $-0x4, (%rbx)
jmp 0x2635
movl $0x1830, %ecx           # imm = 0x1830
btl %eax, %ecx
jae 0x263d
leaq 0xaafe(%rip), %rax      # 0xd118
movq (%rax), %rdi
movq 0x98(%r14), %rdx
leaq 0x4fd1(%rip), %rsi      # 0x75fc
xorl %eax, %eax
callq 0x1190
addl $-0x2, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x13, %eax
jne 0x26ad
leaq 0xaacf(%rip), %rax      # 0xd118
movq (%rax), %rbx
callq 0x11c0
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jg 0x264c
cltq
imulq $0x2c000001, %rax, %rcx # imm = 0x2C000001
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x39, %rcx
addl %eax, %ecx
leaq 0xaacb(%rip), %rax      # 0xd140
movq (%rax), %rax
movq 0x28(%rax), %rax
cmpl 0x20(%rax), %ecx
jle 0x2705
addl $-0x2, (%rax)
movl $0x2, 0x4(%rax)
leaq 0xaaa2(%rip), %rax      # 0xd138
movq (%rax), %rax
movq 0x28(%rax), %rax
movl $0x1, 0x8(%rax)
leaq 0x57fe(%rip), %rdx      # 0x7ea9
jmp 0x270c
callq 0x11c0
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jg 0x26ad
cltq
imulq $0x2c000001, %rax, %rax # imm = 0x2C000001
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x39, %rax
addl %ecx, %eax
leaq 0xaa42(%rip), %rcx      # 0xd118
movq (%rcx), %rdi
cmpl 0x20(%r14), %eax
jle 0x2718
movq 0x88(%rbx), %rdx
leaq 0x4f0f(%rip), %rsi      # 0x75fc
xorl %eax, %eax
callq 0x1190
addl $0x2, 0x4(%r14)
addl $-0x2, (%r14)
incl 0x8(%rbx)
jmp 0x2635
leaq 0x580d(%rip), %rdx      # 0x7f19
leaq 0x4ee9(%rip), %rsi      # 0x75fc
movq %rbx, %rdi
jmp 0x2726
movq 0x90(%rbx), %rdx
leaq 0x4ed6(%rip), %rsi      # 0x75fc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x1c(%rsi), %eax
cmpl $0x13, %eax
ja 0x2813
movl $0x7e000, %ecx          # imm = 0x7E000
btl %eax, %ecx
jae 0x2778
leaq 0xa9bd(%rip), %rax      # 0xd118
movq (%rax), %rdi
movq 0x98(%r14), %rdx
leaq 0x4e90(%rip), %rsi      # 0x75fc
xorl %eax, %eax
callq 0x1190
addl $-0x4, (%rbx)
jmp 0x27a4
movl $0x344, %ecx            # imm = 0x344
btl %eax, %ecx
jae 0x27a9
leaq 0xa98f(%rip), %rax      # 0xd118
movq (%rax), %rdi
movq 0x98(%r14), %rdx
leaq 0x4e62(%rip), %rsi      # 0x75fc
xorl %eax, %eax
callq 0x1190
addl $-0x2, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x13, %eax
jne 0x2813
leaq 0xa963(%rip), %rax      # 0xd118
movq (%rax), %rbx
callq 0x11c0
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jg 0x27b8
cltq
imulq $0x2c000001, %rax, %rax # imm = 0x2C000001
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x39, %rax
addl %ecx, %eax
leaq 0xa95f(%rip), %rcx      # 0xd140
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jle 0x2875
leaq 0xa940(%rip), %rax      # 0xd138
movq (%rax), %rax
movq 0x28(%rax), %rax
addl $0x2, 0x10(%rax)
movl $0x1, 0x8(%rax)
leaq 0x574e(%rip), %rdx      # 0x7f5f
jmp 0x287c
callq 0x11c0
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jg 0x2813
cltq
imulq $0x2c000001, %rax, %rax # imm = 0x2C000001
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x39, %rax
addl %ecx, %eax
leaq 0xa8dc(%rip), %rcx      # 0xd118
movq (%rcx), %rdi
cmpl 0x20(%r14), %eax
jle 0x2888
movq 0x88(%rbx), %rdx
leaq 0x4da9(%rip), %rsi      # 0x75fc
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1190
movl 0x14(%r14), %eax
leal -0x3(%rax), %ecx
cmpl $0x3, %eax
cmovll %ebp, %ecx
movl %ecx, 0x14(%r14)
incl 0x8(%rbx)
jmp 0x27a4
leaq 0x5755(%rip), %rdx      # 0x7fd1
leaq 0x4d79(%rip), %rsi      # 0x75fc
movq %rbx, %rdi
jmp 0x2896
movq 0x90(%rbx), %rdx
leaq 0x4d66(%rip), %rsi      # 0x75fc
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0xa86c(%rip), %rax      # 0xd118
movq (%rax), %rdi
callq 0x1090
callq 0x11c0
cmpl $0x7ffffff7, %eax       # imm = 0x7FFFFFF7
jg 0x28b4
movslq %eax, %rcx
imulq $-0x5ffffff5, %rcx, %rcx # imm = 0xA000000B
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
sarl $0x1b, %ecx
addl %eax, %ecx
cmpl $0x9, %ecx
ja 0x28e9
movl $0x1f, %eax
btl %ecx, %eax
jae 0x290c
leaq 0xa850(%rip), %rax      # 0xd140
movq (%rax), %rax
movq 0x28(%rax), %rdi
leaq 0xa83a(%rip), %rax      # 0xd138
movq (%rax), %rax
movq 0x28(%rax), %rsi
callq 0x1a6d
jmp 0x294d
movl $0xe0, %eax
btl %ecx, %eax
jae 0x2931
leaq 0xa823(%rip), %rax      # 0xd140
movq (%rax), %rax
movq 0x28(%rax), %rdi
cmpl $0x0, 0x24(%rdi)
jne 0x2945
callq 0x1bc0
jmp 0x294d
leaq 0xa808(%rip), %rax      # 0xd140
movq (%rax), %rax
movq 0x28(%rax), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0x297b
movq %rbx, %rdi
callq 0x28a1
leaq 0xa7e4(%rip), %rax      # 0xd138
movq (%rax), %rax
movq 0x28(%rax), %rax
cmpl $0x0, (%rax)
jle 0x2973
leaq 0xa7d9(%rip), %rax      # 0xd140
movq (%rax), %rax
movq 0x28(%rax), %rax
cmpl $0x0, (%rax)
jg 0x2979
movl $0x0, (%rbx)
popq %rbx
retq
leaq 0xa7b6(%rip), %rax      # 0xd138
movq (%rax), %rax
movq 0x28(%rax), %rsi
callq 0x1c45
jmp 0x294d
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0xa3dd(%rip), %rax      # 0xd138
movq (%rax), %rax
movq $0x0, (%rax)
leaq 0xa3f4(%rip), %rcx      # 0xd160
movq (%rcx), %rdx
movl $0x0, 0xc(%rdx)
leaq 0xa3c3(%rip), %rsi      # 0xd140
movq %rdx, (%rsi)
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/main.c
// Function: killOrKilled
static void killOrKilled(void) {
	enemy_killed += continue_game;   //if enemy is killed, add one to count
	wclear(prompt_win);
	(continue_game) ? wprintw(prompt_win,"you defeated %s, good job!.",previous->character->name) : wprintw(prompt_win,"%s killed you. game over!",previous->character->name);
	wrefresh(prompt_win);
	getch();
}

// Assembly:
pushq %rbx
movl 0x9660(%rip), %eax      # 0xd0f8
addl %eax, 0x96ae(%rip)      # 0xd14c
leaq 0x9673(%rip), %rbx      # 0xd118
movq (%rbx), %rdi
callq 0x1090
cmpl $0x0, 0x9644(%rip)      # 0xd0f8
movq (%rbx), %rdi
movq 0x9682(%rip), %rax      # 0xd140
movq 0x28(%rax), %rax
movq 0x38(%rax), %rdx
leaq 0x472f(%rip), %rax      # 0x81fc
leaq 0x470c(%rip), %rsi      # 0x81e0
cmoveq %rax, %rsi
xorl %eax, %eax
callq 0x1190
movq (%rbx), %rdi
callq 0x10d0
movq 0x94e2(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
popq %rbx
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/main.c
// Function: printShrineAndPlayer
static void printShrineAndPlayer(void) {
	wclear(game_win);
	printHeroPlaces(); //printobjects.c
	printPlaces(previous->type); //printobjects.c
	wrefresh(game_win);
}

// Assembly:
pushq %rbx
leaq 0x9611(%rip), %rbx      # 0xd110
movq (%rbx), %rdi
callq 0x1090
callq 0x6490
movq 0x962d(%rip), %rax      # 0xd140
movl 0xc(%rax), %edi
callq 0x65a1
movq (%rbx), %rdi
popq %rbx
jmp 0x10d0
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/makemap.c
// Function: initMap
void initMap(void) {
	setUpMap();
	seedRandomNumber();
	setUPtile(getTile);
	initPieces();
	placePieces();
}

// Assembly:
pushq %rax
callq 0x3b46
callq 0x3e6b
leaq 0x3b9(%rip), %rdi       # 0x3eef
callq 0x3e81
callq 0x3f33
popq %rax
jmp 0x402a
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/makemap.c
// Function: setUPtile
static void setUPtile(char (*tileGet)(void)) {
	int i,j;
	int right = WIDTH - 1;
	int upper = HEIGHT - 1;
	fruit(i = 0; i<upper; i+=2) {
		fruit(j = 0; j <right; j+=2) {
			const char sets = tileGet();
			map[i][j] -> tile_set = sets;
			map[i][j+1] -> tile_set = sets;
			map[i+1][j] -> tile_set = sets;
			map[i+1][j+1] -> tile_set = sets;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9465(%rip), %r14      # 0xd2f8
xorl %r15d, %r15d
movq $-0x2, %r12
callq *%rbx
movq -0x188(%r14,%r12,8), %rcx
movb %al, 0x20(%rcx)
movq -0x180(%r14,%r12,8), %rcx
movb %al, 0x20(%rcx)
movq 0x8(%r14,%r12,8), %rcx
movb %al, 0x20(%rcx)
movq 0x10(%r14,%r12,8), %rcx
movb %al, 0x20(%rcx)
addq $0x2, %r12
cmpq $0x2f, %r12
jb 0x3e9d
leaq 0x2(%r15), %rax
addq $0x320, %r14            # imm = 0x320
cmpq $0x11, %r15
movq %rax, %r15
jb 0x3e96
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/makemap.c
// Function: getTile
static char getTile(void) {
	switch(getRand(6)) {
		case 0://
		case 1://
		case 2: return '^';
			break;
		case 3://
		case 4://
		case 5: return '/';
			break;
		case 6: return ' ';
			break;
		default : return ' ';
			break;
		}
}

// Assembly:
pushq %rax
callq 0x11c0
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jg 0x3ef0
cltq
imulq $0x38000001, %rax, %rax # imm = 0x38000001
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x3a, %rax
addl %ecx, %eax
leal (,%rax,8), %ecx
movabsq $0x202f2f2f5e5e5e, %rdx # imm = 0x202F2F2F5E5E5E
shrq %cl, %rdx
cmpl $0x7, %eax
movl $0x20, %eax
cmovbl %edx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/makemap.c
// Function: initPieces
static void initPieces(void) {
	makeList(ENEMY_LIMIT,enemy_x,enemy_y); //make enemy list
	makeList(CAMP_LIMIT,camp_x,camp_y);  //make camp list
	checkLocation(ENEMY_LIMIT,enemy_x,enemy_y,ENEMY_LIMIT,enemy_x,enemy_y); //check if enemy is on another
	checkLocation(CAMP_LIMIT,camp_x,camp_y,CAMP_LIMIT,camp_x,camp_y);  //checks if camp is located at or near another
	makeList(SHRINE_LIMIT, shrine_x,shrine_y); //make shrine list
	makeList(WELL_LIMIT,well_x,well_y);  //make well list
	checkLocation(SHRINE_LIMIT,shrine_x,shrine_y,SHRINE_LIMIT,shrine_x,shrine_y); //checks if shrine is at or near another shrine
	checkLocation(WELL_LIMIT,well_x,well_y,WELL_LIMIT,well_x,well_y); //checks if well is located at or near another one
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xb15e(%rip), %rbx      # 0xf0a0
leaq 0xb247(%rip), %r14      # 0xf190
movl $0x3c, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x46da
leaq 0xb320(%rip), %r15      # 0xf280
leaq 0xb389(%rip), %r12      # 0xf2f0
movl $0x19, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x46da
movl $0x3c, %edi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x3c, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x4756
movl $0x19, %edi
movq %r15, %rsi
movq %r12, %rdx
movl $0x19, %ecx
movq %r15, %r8
movq %r12, %r9
callq 0x4756
leaq 0xb3a0(%rip), %rbx      # 0xf354
leaq 0xb3a5(%rip), %r14      # 0xf360
movl $0x3, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x46da
leaq 0xb39e(%rip), %r15      # 0xf370
leaq 0xb3b7(%rip), %r12      # 0xf390
movl $0x5, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x46da
movl $0x3, %edi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x3, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x4756
movl $0x5, %edi
movq %r15, %rsi
movq %r12, %rdx
movl $0x5, %ecx
movq %r15, %r8
movq %r12, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4756
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/makemap.c
// Function: initMap2
void initMap2(void) {
	freeMap();
	free(previous);
	setUpMap();
	setUPtile(getTile2);
	initPieces();
	placePieces();
}

// Assembly:
pushq %rax
callq 0x456e
leaq 0x8bf6(%rip), %rax      # 0xd140
movq (%rax), %rdi
callq 0x1030
callq 0x3b46
leaq 0x138(%rip), %rdi       # 0x4696
callq 0x3e81
callq 0x3f33
popq %rax
jmp 0x402a
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/makemap.c
// Function: freeMap
void freeMap(void) {
	fruit(int i = 0; i < HEIGHT; i+=2) {
		fruit(int j = 0; j < WIDTH; j+=10) {
			free(map[i][j]);
			free(map[i][j+1]);
			free(map[i][j+2]);
			free(map[i][j+3]);
			free(map[i][j+4]);
			free(map[i][j+5]);
			free(map[i][j+6]);
			free(map[i][j+7]);
			free(map[i][j+8]);
			free(map[i][j+9]);
			free(map[i+1][j]);
			free(map[i+1][j+1]);
			free(map[i+1][j+2]);
			free(map[i+1][j+3]);
			free(map[i+1][j+4]);
			free(map[i+1][j+5]);
			free(map[i+1][j+6]);
			free(map[i+1][j+7]);
			free(map[i+1][j+8]);
			free(map[i+1][j+9]);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x8dbe(%rip), %rbx      # 0xd338
xorl %r14d, %r14d
movq $-0xa, %r15
movq -0x188(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x180(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x178(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x170(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x168(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x160(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x158(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x150(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x148(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x140(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x8(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x10(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x18(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x20(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x28(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x30(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x38(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x40(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x48(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x50(%rbx,%r15,8), %rdi
callq 0x1030
addq $0xa, %r15
cmpq $0x28, %r15
jb 0x4584
leaq 0x2(%r14), %rax
addq $0x320, %rbx            # imm = 0x320
cmpq $0x12, %r14
movq %rax, %r14
jb 0x457d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/makemap.c
// Function: getTile2
static char getTile2(void) {
	switch(getRand(6)) {
		case 0://
		case 1://
		case 2: return ':';
			break;
		case 3://
		case 4://
		case 5: return '~';
			break;
		case 6: return ' ';
			break;
		default : return ' ';
			break;
		}
}

// Assembly:
pushq %rax
callq 0x11c0
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jg 0x4697
cltq
imulq $0x38000001, %rax, %rax # imm = 0x38000001
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x3a, %rax
addl %ecx, %eax
leal (,%rax,8), %ecx
movabsq $0x207e7e7e3a3a3a, %rdx # imm = 0x207E7E7E3A3A3A
shrq %cl, %rdx
cmpl $0x7, %eax
movl $0x20, %eax
cmovbl %edx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/makemap.c
// Function: makeList
static void makeList(const int limit, int *const x, int *const y) {
	int i;
	fruit(i = 0; i < limit; i++) {
		x[i] = getRand(WIDTH - 1);
		y[i] = getRand(HEIGHT - 1);
	}
}

// Assembly:
testl %edi, %edi
jle 0x4755
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
xorl %r12d, %r12d
callq 0x11c0
cmpl $0x7fffffcf, %eax       # imm = 0x7FFFFFCF
jg 0x46f2
cltq
imulq $0x32000013, %rax, %rax # imm = 0x32000013
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x37, %rax
addl %ecx, %eax
movl %eax, (%r14,%r12,4)
callq 0x11c0
cmpl $0x7ffffff7, %eax       # imm = 0x7FFFFFF7
jg 0x4718
movslq %eax, %rcx
imulq $-0x5ffffff5, %rcx, %rcx # imm = 0xA000000B
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
sarl $0x1a, %ecx
addl %eax, %ecx
movl %ecx, (%rbx,%r12,4)
incq %r12
cmpq %r15, %r12
jne 0x46f2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/printenemy.c
// Function: printHero
void printHero(void) {
	wattron(game_win,WHITE);
	mvwprintw(game_win,11,10,"\\"); //sword
	mvwprintw(game_win,12,11,"\\"); //sword
	wattroff(game_win,WHITE);
	wattron(game_win,GREEN);
	mvwprintw(game_win,12,14,"|"); //upper torso
	mvwprintw(game_win,13,14,"|"); //lower torso
	wattroff(game_win,GREEN);
	wattron(game_win,YELLOW);
	mvwprintw(game_win,11,14,"O"); //head
	mvwprintw(game_win,12,12,"__"); //arms
	mvwprintw(game_win,12,15,"__"); //arms
	mvwprintw(game_win,14,13,"/ \\"); //legs
	mvwprintw(game_win,15,12,"/   \\"); //lowr legs
	wattroff(game_win,YELLOW);
	wattron(game_win,RED);
	mvwprintw(game_win,12,17,"|"); //sheild
	mvwprintw(game_win,13,17,"|"); //sheild
	wattroff(game_win,RED);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x8314(%rip), %r15      # 0xd110
movq (%r15), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x1110
movq (%r15), %rdi
leaq 0x5d38(%rip), %rbx      # 0xab4d
movl $0xb, %esi
movl $0xa, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0xc, %esi
movl $0xb, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x11b0
movq (%r15), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x1110
movq (%r15), %rdi
leaq 0x5e0e(%rip), %rbx      # 0xac76
movl $0xc, %esi
movl $0xe, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0xd, %esi
movl $0xe, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x11b0
movq (%r15), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r15), %rdi
leaq 0x5bfb(%rip), %rcx      # 0xaab6
movl $0xb, %esi
movl $0xe, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
leaq 0x5bd9(%rip), %r14      # 0xaaaf
movl $0xc, %esi
movl $0xc, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0xc, %esi
movl $0xf, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
leaq 0x5b97(%rip), %rcx      # 0xaaa2
movl $0xe, %esi
movl $0xd, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
leaq 0x5b3a(%rip), %rcx      # 0xaa60
movl $0xf, %esi
movl $0xc, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%r15), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
callq 0x1110
movq (%r15), %rdi
movl $0xc, %esi
movl $0x11, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0xd, %esi
movl $0x11, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/printenemy.c
// Function: printDog
void printDog(void) {
	wattron(game_win,WHITE);
	mvwprintw(game_win,12,26,"_"); //top of head
	mvwprintw(game_win,13,25,"<"); //snout
	wattroff(game_win,WHITE);
	wattron(game_win,RED);
	mvwprintw(game_win,13,26,"="); //eyes?
	wattroff(game_win,RED);	
	wattron(game_win,YELLOW);
	mvwprintw(game_win,12,27,"/"); //ears
	mvwprintw(game_win,13,27,"\\_______/"); //upperbody
	mvwprintw(game_win,14,28,"/\\    /\\"); //upper legs
	mvwprintw(game_win,15,27,"/  \\  /  \\"); //lower legs
	wattroff(game_win,YELLOW);	
}

// Assembly:
pushq %rbx
leaq 0x8171(%rip), %rbx      # 0xd110
movq (%rbx), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x5c6f(%rip), %rcx      # 0xac27
movl $0xc, %esi
movl $0x1a, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x5a93(%rip), %rcx      # 0xaa66
movl $0xd, %esi
movl $0x19, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x5a5c(%rip), %rcx      # 0xaa68
movl $0xd, %esi
movl $0x1a, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x5b1c(%rip), %rcx      # 0xab61
movl $0xc, %esi
movl $0x1b, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x5a0a(%rip), %rcx      # 0xaa6a
movl $0xd, %esi
movl $0x1b, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x59f9(%rip), %rcx      # 0xaa74
movl $0xe, %esi
movl $0x1c, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x59e7(%rip), %rcx      # 0xaa7d
movl $0xf, %esi
movl $0x1b, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
popq %rbx
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/printenemy.c
// Function: printDelmerBody
void printDelmerBody(const int y, const int x) {
	wattron(game_win,YELLOW);
	mvwprintw(game_win,11+y,29+x,"^"); //top of body
	mvwprintw(game_win,12+y,27+x,"<( )>"); //side of body
	mvwprintw(game_win,13+y,29+x,"v"); // bottom of body
	wattroff(game_win,YELLOW);
	wattron(game_win,RED);
	mvwprintw(game_win,12+y,29+x,"0"); //eye
	wattroff(game_win,RED);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movl %edi, %r14d
leaq 0x8044(%rip), %r12      # 0xd110
movq (%r12), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r12), %rdi
leal 0xb(%r14), %esi
leal 0x1d(%r15), %ebx
leaq 0x5a1a(%rip), %rcx      # 0xab09
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r12), %rdi
leal 0xc(%r14), %ebp
addl $0x1b, %r15d
leaq 0x597d(%rip), %rcx      # 0xaa88
movl %ebp, %esi
movl %r15d, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r12), %rdi
addl $0xd, %r14d
leaq 0x5968(%rip), %rcx      # 0xaa8e
movl %r14d, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r12), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%r12), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
callq 0x1110
movq (%r12), %rdi
leaq 0x5933(%rip), %rcx      # 0xaa90
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r12), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/printenemy.c
// Function: printHalflingL
static void printHalflingL(void) {
	wattron(game_win,YELLOW);
	mvwprintw(game_win,13,30,"0"); //head
	mvwprintw(game_win,14,28,"-- --"); //arms
	wattroff(game_win,YELLOW);	
	wattron(game_win,GREEN);
	mvwprintw(game_win,14,30,"|"); //torso
	wattroff(game_win,GREEN);
	wattron(game_win,BLUE);
	mvwprintw(game_win,15,29,"/ \\"); //legs
	wattroff(game_win,BLUE);
}

// Assembly:
pushq %rbx
leaq 0x7026(%rip), %rbx      # 0xd110
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x498d(%rip), %rcx      # 0xaa90
movl $0xd, %esi
movl $0x1e, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x49db(%rip), %rcx      # 0xaaf9
movl $0xe, %esi
movl $0x1c, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x4b1f(%rip), %rcx      # 0xac76
movl $0xe, %esi
movl $0x1e, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x800, %esi            # imm = 0x800
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x4912(%rip), %rcx      # 0xaaa2
movl $0xf, %esi
movl $0x1d, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x800, %esi            # imm = 0x800
xorl %edx, %edx
popq %rbx
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O1/return5[P]c_ish_one/./src/printenemy.c
// Function: printHalflingR
static void printHalflingR(void) {
	wattron(game_win,YELLOW);
	mvwprintw(game_win,13,40,"0"); //head
	mvwprintw(game_win,14,38,"-- --"); //arms
	wattroff(game_win,YELLOW);	
	wattron(game_win,MAGENTA);
	mvwprintw(game_win,14,40,"|"); //torso
	wattroff(game_win,MAGENTA);
	wattron(game_win,CYAN);
	mvwprintw(game_win,15,39,"/ \\"); //legs
	wattroff(game_win,CYAN);
}

// Assembly:
pushq %rbx
leaq 0x6f57(%rip), %rbx      # 0xd110
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x48be(%rip), %rcx      # 0xaa90
movl $0xd, %esi
movl $0x28, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x490c(%rip), %rcx      # 0xaaf9
movl $0xe, %esi
movl $0x26, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x700, %esi            # imm = 0x700
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x4a50(%rip), %rcx      # 0xac76
movl $0xe, %esi
movl $0x28, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x700, %esi            # imm = 0x700
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x500, %esi            # imm = 0x500
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x4843(%rip), %rcx      # 0xaaa2
movl $0xf, %esi
movl $0x27, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x500, %esi            # imm = 0x500
xorl %edx, %edx
popq %rbx
jmp 0x11b0