LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqd3.c
// Function: starsum
void starsum(void)
{
    char iline[81];
    int ind, i, value;
    char strs;
    printw("tar summary:");
    cle3r_left();
    point(1, 19);
    addch(':');

    get_line(iline, &ind, true);
    get_token(iline, &ind, &value, &strs);
    point(50, 1);
    if (strs == ' ') {
        for (i = 1; i <= nstars; i++)
            pr5nt_star(i);
    } else {
        do {
            i = strs - 'A' + 1;
            pr5nt_star(i);
            get_token(iline, &ind, &value, &strs);
        }
        while (strs != ' ');
    };
    clear_field();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x531f(%rip), %rdi      # 0x9572
xorl %eax, %eax
callq 0x2030
callq 0x7322
movl $0x1, %ebx
movl $0x1, %edi
movl $0x13, %esi
callq 0x4f79
movq 0x8d6e(%rip), %rax      # 0xcfe8
movq (%rax), %rdi
movl $0x3a, %esi
callq 0x20a0
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x716e
leaq 0x8(%rsp), %rdx
leaq 0x7(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x739d
movl $0x32, %edi
movl $0x1, %esi
callq 0x4f79
movb (%r12), %al
cmpb $0x20, %al
jne 0x42e0
movl %ebx, %edi
callq 0x7730
incl %ebx
cmpl $0x16, %ebx
jne 0x42d0
jmp 0x4318
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
movsbl %al, %edi
addl $-0x40, %edi
callq 0x7730
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x739d
movb 0x7(%rsp), %al
cmpb $0x20, %al
jne 0x42f4
callq 0x72c9
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqd3.c
// Function: tfsum
void tfsum(void)
{
    int i, value;
    char tfs;
    char iline[81];
    int ind;
    printw("f summary :");
    get_line(iline, &ind, true);
    get_token(iline, &ind, &value, &tfs);
    point(50, 1);
    if (tfs == ' ') {
        for (i = 1; i <= 26; i++)
            pr3nt_tf(i);
    } else {
        do {
            i = tfs - 'A' + 1;
            pr3nt_tf(i);
            get_token(iline, &ind, &value, &tfs);
        }
        while (tfs != ' ');
    };
    clear_field();
    cle3r_left();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x5244(%rip), %rdi      # 0x957f
xorl %eax, %eax
callq 0x2030
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movl $0x1, %ebx
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x716e
leaq 0xc(%rsp), %rdx
leaq 0x7(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x739d
movl $0x32, %edi
movl $0x1, %esi
callq 0x4f79
movb (%r12), %al
cmpb $0x20, %al
jne 0x43a0
movl %ebx, %edi
callq 0x7620
incl %ebx
cmpl $0x1b, %ebx
jne 0x4390
jmp 0x43d8
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0x7(%rsp), %r12
movsbl %al, %edi
addl $-0x40, %edi
callq 0x7620
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x739d
movb 0x7(%rsp), %al
cmpb $0x20, %al
jne 0x43b4
callq 0x72c9
callq 0x7322
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqi2.c
// Function: revolt
void revolt(int starnum)
{
    tplanet *pplan;
    tteam loses, gets_back;
    pplan = stars[starnum].first_planet;
    if (col_stars[starnum][ENEMY] + col_stars[starnum][player] > 0) {
        while (pplan != nil) {
            if (pplan->conquered) {
                if ((pplan->team == player) && (!any_bc(player, starnum))) {
                    loses = player;
                    gets_back = ENEMY;
                } else if ((pplan->team == ENEMY) &&
                           (!any_bc(ENEMY, starnum))) {
                    loses = ENEMY;
                    gets_back = player;
                } else
                    loses = none;
                if (loses != none) {
                    col_stars[starnum][loses] =
                        col_stars[starnum][loses] - 1;
                    col_stars[starnum][gets_back]++;
                    pplan->team = gets_back;
                    pplan->conquered = false;
                    pplan->psee_capacity = pplan->capacity;
                    on_board(stars[starnum].x, stars[starnum].y);
                };
            };
            pplan = pplan->next;
        };
    };
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %r14
leaq (%r14,%r14,2), %rax
leaq 0xb08a(%rip), %rcx      # 0xf490
movq 0x8(%rcx,%rax,8), %r15
leaq 0x98be(%rip), %rdx      # 0xdcd0
movl 0x4(%rdx,%r14,8), %esi
addl (%rdx,%r14,8), %esi
setg %dl
testq %r15, %r15
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x44bd
movl %edi, %ebx
leaq (%rcx,%rax,8), %r12
shlq $0x3, %r14
addq 0x8b75(%rip), %r14      # 0xcfb8
cmpl $0x0, 0x20(%r15)
je 0x44b4
movl 0xc(%r15), %eax
cmpl $0x1, %eax
jne 0x4467
movl $0x1, %edi
movl %ebx, %esi
callq 0x223c
testl %eax, %eax
je 0x4481
movl 0xc(%r15), %eax
testl %eax, %eax
jne 0x44b4
xorl %edi, %edi
movl %ebx, %esi
callq 0x223c
testl %eax, %eax
jne 0x44b4
movl $0x1, %eax
xorl %ecx, %ecx
jmp 0x4488
xorl %eax, %eax
movl $0x1, %ecx
decl (%r14,%rcx,4)
movl %eax, %ecx
incl (%r14,%rcx,4)
movl %eax, 0xc(%r15)
movl $0x0, 0x20(%r15)
movl 0x4(%r15), %eax
movl %eax, 0x8(%r15)
movl (%r12), %edi
movl 0x4(%r12), %esi
callq 0x752b
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0x4443
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqin.c
// Function: assign_planets
void assign_planets(tstar *Ustar0, int starnum)
{
    int i1, nplanets;
    tplanet *pplanet;
    tstar ustar;

    ustar = *Ustar0;
    nplanets = rnd(4) - 2;
    if (nplanets < 0)
        nplanets = 1;
    if (nplanets == 0)
        ustar.first_planet = nil;
    else {
        new(pplanet);
        ustar.first_planet = pplanet;
        for (i1 = 1; i1 <= nplanets; i1++) {
            pplanet->number = rnd(2) + (2 * i1) - 2;
            if (rnd(4) > 2)
                pplanet->capacity = 10 * (rnd(4) + 2);
            else
                pplanet->capacity = 5 * rnd(3);
            pplanet->psee_capacity = pplanet->capacity;
            pplanet->team = none;
            pplanet->inhabitants = 0;
            pplanet->iu = 0;
            pplanet->mb = 0;
            pplanet->amb = 0;
            pplanet->conquered = false;
            pplanet->under_attack = false;
            pplanet->esee_team = none;
            pplanet->esee_def = 1;
            pplanet->pstar = starnum;
            if (i1 == nplanets)
                pplanet->next = nil;
            else {
                new(pplanet->next);
                pplanet = pplanet->next;
            }
        }
    };
    *Ustar0 = ustar;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x10(%rdi), %r14
movl $0x4, %edi
callq 0x4fd5
leal -0x2(%rax), %ecx
cmpl $0x2, %eax
movl $0x1, %r13d
cmovgel %ecx, %r13d
testl %r13d, %r13d
je 0x45fb
movl $0x40, %edi
callq 0x2080
testl %r13d, %r13d
jle 0x45fd
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
xorl %r15d, %r15d
movabsq $0x100000002, %r12      # imm = 0x100000002
movq %rax, (%rsp)
movq %rax, %r14
movl $0x2, %edi
callq 0x4fd5
addl %r15d, %eax
movl %eax, (%r14)
movl $0x4, %edi
callq 0x4fd5
cmpl $0x3, %eax
jl 0x4588
movl $0x4, %edi
callq 0x4fd5
leal (%rax,%rax,4), %eax
leal 0x14(,%rax,2), %eax
jmp 0x4595
movl $0x3, %edi
callq 0x4fd5
leal (%rax,%rax,4), %eax
movl %eax, 0x4(%r14)
movl %eax, 0x8(%r14)
movl $0x2, 0xc(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movq %r12, 0x28(%r14)
movl %ebp, 0x30(%r14)
cmpl $0x1, %r13d
jne 0x45ca
xorl %eax, %eax
movq %r14, %rcx
jmp 0x45d7
movl $0x40, %edi
callq 0x2080
movq %rax, %rcx
movq %rax, 0x38(%r14)
addl $0x2, %r15d
movq %rcx, %r14
decl %r13d
jne 0x4553
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %r15
movq (%rsp), %rax
jmp 0x45fd
xorl %eax, %eax
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqin.c
// Function: initmach
void initmach(void)
{
    int res_amt, maxx, start_star, starnum, count;
    float slist[nstars + 1];

    en_research = 'V';
    tf[ENEMY][1].c = 1;
    tf[ENEMY][1].s = 2;
    res_amt = 2;
    research(ENEMY, en_research, res_amt);
    maxx = 0;
    start_star = 0;
    for (starnum = 1; starnum <= nstars; starnum++) {
        get_stars(starnum, slist, &count);
        count += rnd(5);
        if (count > maxx) {
            maxx = count;
            start_star = starnum;
        }
    }
    tf[ENEMY][1].dest = start_star;
    tf[ENEMY][1].x = stars[start_star].x;
    tf[ENEMY][1].y = stars[start_star].y;
    stars[start_star].visit[ENEMY] = true;
    tf_stars[start_star][ENEMY] = 1;
    point(50, 1);
    pr5nt_star(tf[player][1].dest);
    clear_field();
    if (start_star == tf[player][1].dest) {
        cle3r_left();
        battle();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x8f97(%rip), %rax      # 0xdd80
movb $0x56, (%rax)
leaq 0x9b9d(%rip), %r12      # 0xe990
movl $0x1, 0x4c(%r12)
movl $0x2, 0x44(%r12)
xorl %ebp, %ebp
xorl %edi, %edi
movl $0x56, %esi
movl $0x2, %edx
callq 0x7c5d
movl $0x1, %ebx
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
xorl %r13d, %r13d
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7275
movl $0x5, %edi
callq 0x4fd5
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl %r13d, %eax
cmovgl %eax, %r13d
cmovgl %ebx, %ebp
incl %ebx
cmpl $0x16, %ebx
jne 0x4e2a
movl %ebp, 0x54(%r12)
movslq %ebp, %rbx
leaq (%rbx,%rbx,2), %rax
leaq 0xa623(%rip), %rcx      # 0xf490
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x34(%r12)
movl $0x1, %edx
movl %edx, 0x10(%rcx,%rax,8)
leaq 0x8d9a(%rip), %rax      # 0xdc20
movl %edx, (%rax,%rbx,8)
movl $0x32, %edi
movl $0x1, %esi
callq 0x4f79
movl 0x5d0(%r12), %edi
callq 0x7730
callq 0x72c9
cmpl 0x5d0(%r12), %ebx
jne 0x4ebe
callq 0x7322
callq 0x383c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqmain.c
// Function: main
int main(void)
{
    initscr();

    printw("\n *** CONQUEST *** \n");
    initconst();
    initmach();
    do {
        inputplayer();
        if (!game_over) {
            inputmach();
            move_ships();
            battle();
            if (production_year == 4 && turn < 100) {
                invest();
            }
            up_year();
        }
        check_game_over();
    }
    while (!game_over);

    endwin();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x20f0
leaq 0x485b(%rip), %rdi      # 0x9768
xorl %eax, %eax
callq 0x2030
callq 0x49aa
callq 0x4dd4
leaq 0xa983(%rip), %rbx      # 0xf8a8
leaq 0xa85c(%rip), %r14      # 0xf788
leaq 0xa851(%rip), %r15      # 0xf784
callq 0x6da8
cmpl $0x0, (%rbx)
jne 0x4f62
callq 0x52a1
callq 0x5a98
callq 0x383c
cmpl $0x4, (%r14)
jne 0x4f5d
cmpl $0x63, (%r15)
jg 0x4f5d
callq 0x8cd4
callq 0x37e3
callq 0x22f2
cmpl $0x0, (%rbx)
je 0x4f33
callq 0x20c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqmain.c
// Function: point
void point(int col, int row)
{
    move(row - 1, col - 1);     // curses is 0-based
    x_cursor = col;
    y_cursor = row;
    if ((x_cursor < 20) && (y_cursor != 18))
        left_line[y_cursor] = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
movq 0x805f(%rip), %rax      # 0xcfe8
movq (%rax), %rdi
leal -0x1(%rbx), %esi
leal -0x1(%r14), %edx
callq 0x20b0
leaq 0xa911(%rip), %rax      # 0xf8b0
movl %r14d, (%rax)
leaq 0xa90b(%rip), %rax      # 0xf8b4
movl %ebx, (%rax)
cmpl $0x14, %r14d
setge %al
cmpl $0x12, %ebx
sete %cl
orb %al, %cl
jne 0x4fcd
movslq %ebx, %rax
leaq 0xa8fa(%rip), %rcx      # 0xf8c0
movl $0x1, (%rcx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqmc.c
// Function: wander_bc
void wander_bc(struct sttf *task, float slist[nstars + 1])
{
    int ships, i, count, dest, new_tf;
    if ((task->b > 1) || (task->c > 1)) {
        count = 0;
        for (i = 1; i <= nstars; i++) {
            if (slist[i] != 0)
                count = count + 1;
        };
        if (count > 0) {
            dest = rnd(count);
            count = 0;
            i = 0;
            do {
                i = i + 1;
                if (slist[i] > 0)
                    count = count + 1;
            }
            while (count != dest);
            get_tf(ENEMY, &new_tf, task->dest);
            ships = task->b / 2;
            tf[ENEMY][new_tf].b = ships;
            task->b = task->b - ships;
            ships = task->c / 2;
            tf[ENEMY][new_tf].c = ships;
            task->c = task->c - ships;

            if (task->t > 3) {
                tf[ENEMY][new_tf].t = 2;
                task->t = task->t - 2;
            };

            tf[ENEMY][new_tf].dest = i;
            tf[ENEMY][new_tf].eta = (int) ((slist[i] - 0.01) /
                                           vel[ENEMY]) + 1;
            depart(task->dest);
        };
    };
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, 0x1c(%rdi)
jg 0x5064
cmpl $0x2, 0x18(%rbx)
jl 0x516e
xorl %edi, %edi
movl $0x1, %eax
xorps %xmm0, %xmm0
movss (%r14,%rax,4), %xmm1
cmpneqss %xmm0, %xmm1
movd %xmm1, %ecx
subl %ecx, %edi
incq %rax
cmpq $0x16, %rax
jne 0x506e
testl %edi, %edi
je 0x516e
callq 0x4fd5
xorl %r12d, %r12d
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movss 0x4(%r14,%r12,4), %xmm1
incq %r12
xorl %edx, %edx
ucomiss %xmm0, %xmm1
seta %dl
addl %edx, %ecx
cmpl %eax, %ecx
jne 0x509d
movl 0x20(%rbx), %edx
leaq 0x4(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x2ac4
movslq (%r15), %rax
imulq $0x34, %rax, %rax
leaq 0x98bb(%rip), %rcx      # 0xe990
movq 0x18(%rbx), %xmm0
movdqa %xmm0, %xmm1
psrld $0x1f, %xmm1
paddd %xmm0, %xmm1
psrad $0x1, %xmm1
movq %xmm1, 0x18(%rcx,%rax)
movq 0x18(%rbx), %xmm0
psubd %xmm1, %xmm0
movq %xmm0, 0x18(%rbx)
cmpl $0x4, 0x14(%rbx)
jl 0x5112
movl $0x2, 0x14(%rcx,%rax)
addl $-0x2, 0x14(%rbx)
movl %r12d, 0x20(%rcx,%rax)
xorps %xmm0, %xmm0
cvtss2sd (%r14,%r12,4), %xmm0
addsd 0x4178(%rip), %xmm0     # 0x92a0
leaq 0xa579(%rip), %rdx      # 0xf6a8
xorps %xmm1, %xmm1
cvtsi2sdl (%rdx), %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
incl %edx
movl %edx, 0x24(%rcx,%rax)
movslq 0x20(%rbx), %rax
leaq 0x8ad1(%rip), %rcx      # 0xdc20
leaq 0x8b7a(%rip), %rdx      # 0xdcd0
movl 0x4(%rdx,%rax,8), %edx
addl 0x4(%rcx,%rax,8), %edx
jle 0x516e
leaq 0xa689(%rip), %rcx      # 0xf7f0
movl $0x1, (%rcx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqmc.c
// Function: eval_bc_col
int eval_bc_col(struct stplanet *planet)
{
    int result;
    if (!(stars[planet->pstar].visit[ENEMY])) {
        result = 600;
    } else {
        switch (planet->esee_team) {

        case none:
            result = 100;
            break;

        case ENEMY:
            if (planet->conquered)
                result = 1000;
            else {

                if (((6 * planet->amb + planet->mb) <= (planet->iu / 15))
                    && (!((!planet->conquered)
                          && (planet->iu < mb_cost)))
                    ) {
                    result = 300;
                } else {
                    result = 0;
                };
            };

            if (planet->amb >= 4)
                result = result - 250;

            break;

        case player:
            if (planet->conquered) {
                result = 400;
            } else {
                result = 200;
            };
            break;
        };                      /*switch ( */
        if ((planet->capacity < 40) && (planet->iu < 15))
            result = result - 100;
    };
    result = result + rnd(20);
    return (result);
}

// Assembly:
pushq %rbx
movslq 0x30(%rdi), %rax
leaq (%rax,%rax,2), %rax
leaq 0xa306(%rip), %rcx      # 0xf490
cmpl $0x0, 0x10(%rcx,%rax,8)
je 0x51fa
movl 0x28(%rdi), %eax
cmpl $0x1, %eax
je 0x5201
movl $0x64, %ebx
testl %eax, %eax
jne 0x5212
cmpl $0x0, 0x20(%rdi)
movl 0x1c(%rdi), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
jne 0x51ec
leal (%rax,%rax,2), %ecx
addl %ecx, %ecx
addl 0x18(%rdi), %ecx
movslq 0x14(%rdi), %rdx
imulq $-0x77777777, %rdx, %rsi # imm = 0x88888889
shrq $0x20, %rsi
addl %edx, %esi
movl %esi, %r8d
shrl $0x1f, %r8d
sarl $0x3, %esi
addl %r8d, %esi
xorl %r8d, %r8d
cmpl %esi, %ecx
movl $0x12c, %ecx            # imm = 0x12C
cmovgl %r8d, %ecx
cmpq $0x8, %rdx
cmovll %r8d, %ecx
leal -0xfa(%rcx), %ebx
cmpl $0x4, %eax
cmovll %ecx, %ebx
jmp 0x5212
movl $0x258, %ebx            # imm = 0x258
jmp 0x5224
cmpl $0x0, 0x20(%rdi)
movl $0xc8, %eax
movl $0x190, %ebx            # imm = 0x190
cmovel %eax, %ebx
cmpl $0x27, 0x4(%rdi)
jg 0x5224
cmpl $0xf, 0x14(%rdi)
leal -0x64(%rbx), %eax
cmovgel %ebx, %eax
movl %eax, %ebx
movl $0x14, %edi
callq 0x4fd5
addl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqmc.c
// Function: eval_t_col
int eval_t_col(struct stplanet *planet, float range)
{
    int result;
    if ((!stars[planet->pstar].visit[ENEMY]))
        result = 60;
    else {
        switch (planet->esee_team) {
        case none:
            result = 40;
            break;
        case ENEMY:
            result = 30;
            break;
        case player:
            result = 0;
        };                      /*switch ( */
        if ((planet->esee_team != player)
            && (planet->capacity - planet->inhabitants > 40 - (turn / 2)))
            result = result + 40;
    };
    result -= (int) (2 * range + .5);
    return (result);
}

// Assembly:
movslq 0x30(%rdi), %rax
leaq (%rax,%rax,2), %rax
leaq 0xa24f(%rip), %rcx      # 0xf490
cmpl $0x0, 0x10(%rcx,%rax,8)
je 0x5285
movl 0x28(%rdi), %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
je 0x528a
testl %ecx, %ecx
movl $0x1e, %ecx
movl $0x28, %edx
cmovnel %edx, %ecx
movl 0x4(%rdi), %esi
subl 0x10(%rdi), %esi
leaq 0xa516(%rip), %rax      # 0xf784
movl (%rax), %eax
movl %eax, %edi
shrl $0x1f, %edi
addl %eax, %edi
sarl %edi
subl %edi, %edx
leal 0x28(%rcx), %eax
cmpl %edx, %esi
cmovlel %ecx, %eax
jmp 0x528a
movl $0x3c, %eax
addss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x44e6(%rip), %xmm0     # 0x9780
cvttsd2si %xmm0, %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqmc.c
// Function: inputmach
void inputmach(void)
{
    int count, tfnum, starnum;
    float slist[nstars + 1];
    for (tfnum = 1; tfnum <= 26; tfnum++) {
        if ((tf[ENEMY][tfnum].eta == 0) && (tf[ENEMY][tfnum].dest != 0)) {
            starnum = tf[ENEMY][tfnum].dest;
            get_stars(starnum, slist, &count);
            send_scouts(slist, &tf[ENEMY][tfnum]);
            send4transports(slist, &tf[ENEMY][tfnum]);
            move_bc(&tf[ENEMY][tfnum], slist);
            zero_tf(ENEMY, tfnum);
        };
    };
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x96dd(%rip), %rbx      # 0xe990
addq $0x34, %rbx
movq $-0x1a, %r12
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
cmpl $0x0, 0x24(%rbx)
jne 0x530d
movl 0x20(%rbx), %edi
testl %edi, %edi
je 0x530d
movq %r14, %rsi
movq %r15, %rdx
callq 0x7275
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5322
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5517
movq %rbx, %rdi
movq %r14, %rsi
callq 0x57b1
leal 0x1b(%r12), %esi
xorl %edi, %edi
callq 0x36f5
addq $0x34, %rbx
incq %r12
jne 0x52c8
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqmc.c
// Function: underdefended
boolean underdefended(int starnum)
{
    struct stplanet *pplanet;
    boolean result;
    result = false;
    pplanet = stars[starnum].first_planet;
    while ((pplanet != nil) && (!result)) {
        if ((pplanet->team == ENEMY) && (pplanet->iu > 10) &&
            ((6 * pplanet->amb + pplanet->mb) <
             conq_round(pplanet->iu / 15)))
            result = true;
        pplanet = pplanet->next;
    };
    return (result);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movslq %edi, %rax
leaq (%rax,%rax,2), %rax
leaq 0x9ab0(%rip), %rcx      # 0xf490
movq 0x8(%rcx,%rax,8), %rbx
testq %rbx, %rbx
je 0x5a39
movl $0x88888889, %r14d      # imm = 0x88888889
xorl %eax, %eax
cmpl $0x0, 0xc(%rbx)
jne 0x5a2a
movl 0x14(%rbx), %ecx
cmpl $0xb, %ecx
jl 0x5a2a
movl 0x1c(%rbx), %eax
leal (%rax,%rax,2), %ebp
addl %ebp, %ebp
addl 0x18(%rbx), %ebp
movl %ecx, %eax
imulq %r14, %rax
shrq $0x23, %rax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
callq 0x4ff2
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %ebp
setl %al
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
je 0x5a3b
testl %eax, %eax
je 0x59f0
jmp 0x5a3b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqpl.c
// Function: send_tf
void send_tf(void)
{
    char tf_move;
    int tf_num;
    boolean error;
    printw("estination tf:");
    get_char(&tf_move);
    cle3r_left();
    point(1, 19);
    tf_num = tf_move - 'A' + 1;
    if ((tf_num < 1) || (tf_num > 26)) {
        error_message();
        printw(" !illegal tf");
    } else if (tf[player][tf_num].dest == 0) {
        error_message();
        printw(" !nonexistent tf");
    } else if ((tf[player][tf_num].eta != 0) &&
               ((tf[player][tf_num].eta != tf[player][tf_num].origeta) ||
                (tf[player][tf_num].withdrew))
        ) {
        error_message();
        printw(" !Tf is not in normal space  ");
    } else if (tf[player][tf_num].blasting) {
        error_message();
        printw(" !Tf is blasting a planet");
    } else {
        tf[player][tf_num].withdrew = false;
        set_des(tf_num, &error);
    };
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x2e51(%rip), %rdi      # 0x9af2
xorl %eax, %eax
callq 0x2030
leaq 0xb(%rsp), %rbx
movq %rbx, %rdi
callq 0x7153
callq 0x7322
movl $0x1, %edi
movl $0x13, %esi
callq 0x4f79
movsbl (%rbx), %edi
leal -0x5b(%rdi), %eax
cmpb $-0x1b, %al
ja 0x6ce1
callq 0x738e
leaq 0x2d06(%rip), %rdi      # 0x99e5
jmp 0x6d44
addl $-0x40, %edi
movl %edi, %eax
imulq $0x34, %rax, %rax
leaq 0x7c9f(%rip), %rcx      # 0xe990
cmpl $0x0, 0x59c(%rcx,%rax)
je 0x6d24
addq %rcx, %rax
addq $0x57c, %rax            # imm = 0x57C
movl 0x24(%rax), %ecx
testl %ecx, %ecx
je 0x6d32
cmpl 0x28(%rax), %ecx
jne 0x6d16
cmpl $0x0, 0x30(%rax)
je 0x6d32
callq 0x738e
leaq 0x2ddf(%rip), %rdi      # 0x9b01
jmp 0x6d44
callq 0x738e
leaq 0x2cc3(%rip), %rdi      # 0x99f3
jmp 0x6d44
cmpl $0x0, 0x2c(%rax)
je 0x6d51
callq 0x738e
leaq 0x2ddb(%rip), %rdi      # 0x9b1f
xorl %eax, %eax
callq 0x2030
addq $0x10, %rsp
popq %rbx
retq
movl $0x0, 0x30(%rax)
leaq 0xc(%rsp), %rsi
callq 0x6eb8
jmp 0x6d4b
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqpl.c
// Function: quit
void quit(void)
{
    char answer;
    cle2r_screen();
    printw("Quit game....[verify]\n");
    get_char(&answer);
    if (answer != 'Y')
        printmap();
    else {
        game_over = true;
    };
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
callq 0x736e
leaq 0x2dc4(%rip), %rdi      # 0x9b39
xorl %eax, %eax
callq 0x2030
leaq 0xf(%rsp), %rbx
movq %rbx, %rdi
callq 0x7153
cmpb $0x59, (%rbx)
jne 0x6d9d
leaq 0x8b13(%rip), %rax      # 0xf8a8
movl $0x1, (%rax)
jmp 0x6da2
callq 0x6228
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqpl.c
// Function: inputplayer
void inputplayer(void)
{
    char key;
    boolean fin;
    point(33, 20);
    printw("* Movement *    ");
    fin = false;
    do {
        point(1, 18);
        printw("?                             ");
        point(2, 18);
        get_char(&key);
        switch (key) {
        case 'M':
            printmap();
            break;
        case 'B':
            bl2st_planet();
            break;
        case 'G':
        case ' ':
            fin = true;
            break;
        case 'H':
            help(1);
            break;
        case 'L':
            land();
            break;
        case 'D':
            send_tf();
            break;
        case 'S':
            starsum();
            break;
        case 'N':
            make_tf();
            break;
        case 'J':
            join_tf();
            break;
        case 'C':
            print_col();
            break;
        case 'R':
            ressum();
            break;
        case 'Q':
            fin = true;
            quit();
            break;
        case '?':
            break;
        case 'T':
            tfsum();
            break;
        default:
            error_message();
            printw("  !illegal command");
        };                      /*switch ( */
    }
    while (!fin);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x21, %edi
movl $0x14, %esi
callq 0x4f79
leaq 0x2d8a(%rip), %rdi      # 0x9b50
xorl %eax, %eax
callq 0x2030
leaq 0x2d8d(%rip), %rbx      # 0x9b61
leaq 0x7(%rsp), %r14
leaq 0x2da0(%rip), %r15      # 0x9b80
leaq 0x2a8d(%rip), %r12      # 0x9874
movl $0x1, %edi
movl $0x12, %esi
callq 0x4f79
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
movl $0x2, %edi
movl $0x12, %esi
callq 0x4f79
movq %r14, %rdi
callq 0x7153
movzbl 0x7(%rsp), %eax
leal -0x3f(%rax), %ecx
cmpl $0x15, %ecx
ja 0x6e8b
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
jmpq *%rax
callq 0x6400
jmp 0x6de7
callq 0x6228
jmp 0x6de7
callq 0x8132
jmp 0x6de7
movl $0x1, %edi
callq 0x747e
jmp 0x6de7
callq 0x4241
jmp 0x6de7
callq 0x6c95
jmp 0x6de7
callq 0x6849
jmp 0x6de7
callq 0x4048
jmp 0x6de7
callq 0x4329
jmp 0x6de7
callq 0x7e00
jmp 0x6de7
callq 0x7ba5
jmp 0x6de7
cmpl $0x20, %eax
je 0x6ea9
callq 0x738e
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
jmp 0x6de7
callq 0x6d64
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqs3.c
// Function: read_char
void read_char(char *C)
{
    char result;
    result = getch();
    if (result == 0x0d || result == 0x0a)
        result = '\n';
    if (result == 0x7f)
        result = '\b';
    *C = toupper(result);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5ede(%rip), %rax      # 0xcfe8
movq (%rax), %rdi
callq 0x2110
movl %eax, %ecx
shll $0x18, %ecx
cmpl $0xa000000, %ecx        # imm = 0xA000000
movl $0xa, %edx
cmovel %edx, %eax
cmpl $0xd000000, %ecx        # imm = 0xD000000
cmovel %edx, %eax
cmpb $0x7f, %al
movl $0x8, %r14d
cmovnel %eax, %r14d
callq 0x2090
movq (%rax), %rax
movsbq %r14b, %rcx
movb (%rax,%rcx,4), %al
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqs3.c
// Function: get_line
void get_line(char *iline, int *Ind0, int onech)
{
    char ch;
    int ind;

    ind = 1;
    do {
        read_char(&ch);
        if (ch == '\b') {       /*backspace */
            if (ind != 1) {
                if ((ind != 1) && onech) {
                    addch('\b');
                    ind = ind - 1;
                };
                if ((ind != 1) && !onech) {
                    printw("\b \b");
                    ind = ind - 1;
                }
            };
        } else if (ch != '\n') {
            printw("%c", ch);
            iline[ind] = ch;
            ind = ind + 1;
            if (onech) {
                addch(' ');
                iline[ind] = ' ';
                ind = ind + 1;
            };
        };
    }
    while (ind < 25 && ch != '\n');
    while (ind != 80) {
        iline[ind] = ' ';
        ind = ind + 1;
    };
    *Ind0 = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movl $0x1, %r13d
leaq 0xf(%rsp), %r15
movl %r13d, %ebx
movq %r15, %rdi
callq 0x70fc
movzbl 0xf(%rsp), %eax
cmpl $0x8, %eax
je 0x71f1
cmpl $0xa, %eax
je 0x723b
movsbl %al, %r12d
leaq 0x2de4(%rip), %rdi      # 0x9f9e
movl %r12d, %esi
xorl %eax, %eax
callq 0x2030
movslq %ebx, %rax
leaq 0x1(%rax), %r13
movb %r12b, (%r14,%rax)
testl %ebp, %ebp
je 0x7229
movq 0x5e0e(%rip), %rax      # 0xcfe8
movq (%rax), %rdi
movl $0x20, %esi
callq 0x20a0
movb $0x20, (%r14,%r13)
addl $0x2, %ebx
jmp 0x7226
movl $0x1, %r13d
cmpl $0x1, %ebx
je 0x7229
testl %ebp, %ebp
je 0x7216
movq 0x5de1(%rip), %rax      # 0xcfe8
movq (%rax), %rdi
movl $0x8, %esi
callq 0x20a0
jmp 0x7224
leaq 0x2a08(%rip), %rdi      # 0x9c25
xorl %eax, %eax
callq 0x2030
decl %ebx
movl %ebx, %r13d
cmpl $0x19, %r13d
jl 0x7191
cmpl $0x50, %r13d
jne 0x723e
jmp 0x725b
movl %ebx, %r13d
movslq %r13d, %rax
addq %rax, %r14
movl $0x4f, %edx
subl %eax, %edx
incq %rdx
movq %r14, %rdi
movl $0x20, %esi
callq 0x2040
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqs3.c
// Function: get_stars
void get_stars(int s_star, float slist[nstars + 1], int *C0unt)
{
    int starnum, count;

    count = 0;
    for (starnum = 1; starnum <= nstars; starnum++) {
        if (range[0] >= r2nge[s_star][starnum]) {
            count = count + 1;
            slist[starnum] = r2nge[s_star][starnum];
        } else
            slist[starnum] = 0;
    };
    *C0unt = count;
}

// Assembly:
leaq 0x8434(%rip), %rax      # 0xf6b0
movl (%rax), %eax
movslq %edi, %rcx
imulq $0x58, %rcx, %rcx
addq 0x5d64(%rip), %rcx      # 0xcff0
xorl %edi, %edi
movl $0x1, %r8d
movl (%rcx,%r8,4), %r11d
xorl %r9d, %r9d
cmpl %r11d, %eax
setge %r10b
jge 0x72a9
xorps %xmm0, %xmm0
jmp 0x72b1
xorps %xmm0, %xmm0
cvtsi2ss %r11d, %xmm0
movb %r10b, %r9b
addl %r9d, %edi
movss %xmm0, (%rsi,%r8,4)
incq %r8
cmpq $0x16, %r8
jne 0x7294
movl %edi, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqs3.c
// Function: clear_field
void clear_field(void)
{
    int new_bottom, y;
    new_bottom = y_cursor - 1;
    if (new_bottom < bottom_field) {
        for (y = new_bottom + 1; y <= bottom_field; y++) {
            point(50, y);
            printw(blank_line);
        };
    };
    bottom_field = new_bottom;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x85dd(%rip), %rax      # 0xf8b4
movl (%rax), %ebp
leaq 0x85cc(%rip), %r15      # 0xf8ac
cmpl (%r15), %ebp
jg 0x7312
leaq 0x202b(%rip), %rbx      # 0x9317
movl %ebp, %r14d
movl $0x32, %edi
movl %r14d, %esi
callq 0x4f79
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
leal 0x1(%r14), %eax
cmpl (%r15), %r14d
movl %eax, %r14d
jl 0x72ef
decl %ebp
movl %ebp, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqs3.c
// Function: cle3r_left
void cle3r_left(void)
{
    int i;
    for (i = 19; i <= 24; i++) {
        if (left_line[i]) {
            point(1, i);
            printw(blank_line);
            left_line[i] = false;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x13, %ebx
leaq 0x858d(%rip), %r15      # 0xf8c0
leaq 0x1fdd(%rip), %r14      # 0x9317
cmpl $0x0, (%r15,%rbx,4)
je 0x735f
movl $0x1, %edi
movl %ebx, %esi
callq 0x4f79
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
movl $0x0, (%r15,%rbx,4)
incq %rbx
cmpq $0x19, %rbx
jne 0x733a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqs3.c
// Function: get_token
void get_token(char *line, int *Index0, int *Value0, char *Token0)
{
    int index, value;
    char token;
    index = *Index0;
    value = 0;
    token = ' ';
    while (line[index] == ' ' && (index < 80))
        index = index + 1;
    if (index < 80) {
        if ((line[index] < '0') || (line[index] > '9'))
            value = 1;
        else {
            while (line[index] >= '0' && (line[index] <= '9')) {
                value = 10 * value + line[index] - '0';
                index = index + 1;
            };
        };
        token = line[index];
        index = index + 1;
    }
    while (line[index] != ' ' && (index < 80))
        index = index + 1;
    while (line[index] == ' ' && (index < 80))
        index = index + 1;
    *Index0 = index;
    *Value0 = value;
    *Token0 = token;
}

// Assembly:
pushq %rbx
movslq (%rsi), %r9
leal -0x1(%r9), %eax
movq %r9, %r8
shlq $0x20, %r8
movabsq $-0x100000000, %r10     # imm = 0xFFFFFFFF00000000
addq %r8, %r10
movabsq $0x100000000, %r8       # imm = 0x100000000
movq %r9, %rbx
addq %r8, %r10
movb (%rdi,%r9), %r11b
incq %r9
incl %eax
cmpq $0x4f, %rbx
jg 0x73de
cmpb $0x20, %r11b
je 0x73c3
cmpq $0x4f, %rbx
jg 0x743b
addb $-0x3a, %r11b
movl $0x1, %r8d
cmpb $-0xa, %r11b
jb 0x7431
sarq $0x20, %r10
movb (%rdi,%r10), %r10b
leal -0x30(%r10), %r11d
xorl %r8d, %r8d
cmpb $0x9, %r11b
ja 0x7431
addq %rdi, %r9
xorl %r8d, %r8d
movzbl %r10b, %r10d
leal (%r8,%r8,4), %r8d
leal (%r10,%r8,2), %r8d
addl $-0x30, %r8d
movb (%r9), %r10b
leal -0x30(%r10), %r11d
incl %eax
incq %r9
cmpb $0xa, %r11b
jb 0x740f
cltq
movb (%rdi,%rax), %r9b
incl %eax
jmp 0x7441
xorl %r8d, %r8d
movb $0x20, %r9b
movslq %eax, %r11
leal -0x2(%r11), %eax
leaq 0x1(%r11), %r10
incl %eax
cmpq $0x4f, %r11
jg 0x745e
cmpb $0x20, (%rdi,%r11)
movq %r10, %r11
jne 0x7448
decq %r10
incl %eax
cmpq $0x4f, %r10
jg 0x7474
cmpb $0x20, (%rdi,%r10)
leaq 0x1(%r10), %r10
je 0x7461
movl %eax, (%rsi)
movl %r8d, (%rdx)
movb %r9b, (%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqs3.c
// Function: help
void help(int which)
{
    struct helpst *h;
    int j;

    j = 1;
    point(50, j++);
    if (which == 0)
        h = help0;
    if (which == 1)
        h = help1;
    if (which == 2)
        h = help2;
    if (which == 3)
        h = help3;
    if (which == 4)
        h = help4;
    while (h->cmd != 0) {
        printw("%2s - %-25s", h->cmd, h->does);
        point(50, j++);
        h++;
    }
    clear_field();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x32, %edi
movl $0x1, %esi
callq 0x4f79
cmpl $0x1, %ebx
leaq 0x5cb0(%rip), %rax      # 0xd150
leaq 0x5c09(%rip), %rcx      # 0xd0b0
cmoveq %rax, %rcx
cmpl $0x2, %ebx
leaq 0x5d7b(%rip), %rax      # 0xd230
cmovneq %rcx, %rax
cmpl $0x3, %ebx
leaq 0x5e0d(%rip), %rcx      # 0xd2d0
cmovneq %rax, %rcx
cmpl $0x4, %ebx
leaq 0x5eaf(%rip), %r15      # 0xd380
cmovneq %rcx, %r15
movq (%r15), %rsi
testq %rsi, %rsi
je 0x751c
addq $0x10, %r15
movl $0x2, %r14d
leaq 0x2941(%rip), %rbx      # 0x9e2f
movq -0x8(%r15), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
leal 0x1(%r14), %ebp
movl $0x32, %edi
movl %r14d, %esi
callq 0x4f79
movq (%r15), %rsi
addq $0x10, %r15
movl %ebp, %r14d
testq %rsi, %rsi
jne 0x74ee
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x72c9
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqs3.c
// Function: on_board
void on_board(int x, int y)
{
    int i;
    int starnum;
    board[x][y].tf = ' ';
    i = 1;
    do {
        if ((tf[player][i].dest != 0) && (tf[player][i].x == x)
            && (tf[player][i].y == y)) {
            if (board[x][y].tf == ' ')
                board[x][y].tf = i + 'a' - 1;
            else {
                board[x][y].tf = '*';
                i = 27;
            };
        };
        i = i + 1;
    }
    while (i <= 26);
    if (board[x][y].star != '.') {
        board[x][y].enemy = ' ';
        starnum = board[x][y].star - 'A' + 1;
        if (col_stars[starnum][player] != 0)
            board[x][y].enemy = '@';
    };
    update_board(x, y, both);
}

// Assembly:
movslq %edi, %rax
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x6, %rax
addq 0x5a5c(%rip), %rax      # 0xcfa0
leaq (%rax,%rcx,4), %rax
movl $0x20, 0x8(%rax)
movl $0x20, %r9d
movl $0x61, %ecx
xorl %edx, %edx
leaq 0x742d(%rip), %r8       # 0xe990
cmpl $0x0, 0x5d0(%r8,%rdx)
je 0x758e
cmpl %edi, 0x5b0(%r8,%rdx)
jne 0x758e
cmpl %esi, 0x5b4(%r8,%rdx)
jne 0x758e
cmpl $0x20, %r9d
jne 0x75d2
movl %ecx, 0x8(%rax)
movl %ecx, %r9d
incl %ecx
addq $0x34, %rdx
cmpq $0x548, %rdx            # imm = 0x548
jne 0x7563
movslq 0x4(%rax), %rcx
cmpq $0x2e, %rcx
je 0x75c8
leaq 0x6722(%rip), %rdx      # 0xdcd0
xorl %r8d, %r8d
cmpl $0x0, -0x1fc(%rdx,%rcx,8)
setne %r8b
shll $0x5, %r8d
addl $0x20, %r8d
movl %r8d, (%rax)
movl $0x2, %edx
jmp 0x2df8
movl $0x2a, 0x8(%rax)
jmp 0x759d
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqs3.c
// Function: pause
void pause(void)
{
    char dummy;
    point(1, 18);
    printw("Press any key to continue  ");
    get_char(&dummy);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x1, %edi
movl $0x12, %esi
callq 0x4f79
leaq 0x2845(%rip), %rdi      # 0x9e3b
xorl %eax, %eax
callq 0x2030
leaq 0xf(%rsp), %rbx
movq %rbx, %rdi
callq 0x70fc
movsbl (%rbx), %esi
leaq 0x298a(%rip), %rdi      # 0x9f9e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqs3.c
// Function: pr3nt_tf
void pr3nt_tf(int i)
{
    int x, y;
    if ((i != 0) && (i < 27)) {
        if (tf[player][i].dest != 0) {
            printw("TF%c:", i + 'a' - 1);
            x = tf[player][i].x;
            y = tf[player][i].y;
            if (tf[player][i].eta == 0)
                addch(tf[player][i].dest + 'A' - 1);
            else
                addch(' ');
            printw("(%2d,%2d)               ", x, y);
            point(x_cursor + 14, y_cursor);
            x_cursor = x_cursor - 14;
            disp_tf(&tf[player][i]);
            if (tf[player][i].eta != 0) {
                printw("%c2m", 0x9b);
                printw("%c%d",
                       tf[player][i].dest + 'A' - 1, tf[player][i].eta);
                printw("%c0m", 0x9b);
            };
            point(x_cursor, y_cursor + 1);
        };
    };
}

// Assembly:
testl %edi, %edi
sete %al
cmpl $0x1b, %edi
setge %cl
orb %al, %cl
jne 0x772f
movl %edi, %esi
movslq %edi, %rax
imulq $0x34, %rax, %rax
leaq 0x734d(%rip), %rcx      # 0xe990
cmpl $0x0, 0x59c(%rcx,%rax)
je 0x772f
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq (%rcx,%rax), %rbx
addq $0x57c, %rbx            # imm = 0x57C
addl $0x60, %esi
leaq 0x27ea(%rip), %rdi      # 0x9e57
xorl %eax, %eax
callq 0x2030
movl (%rbx), %ebp
cmpl $0x0, 0x24(%rbx)
movl 0x4(%rbx), %r14d
movq 0x5963(%rip), %rax      # 0xcfe8
movq (%rax), %rdi
movl $0x20, %esi
jne 0x7695
movl 0x20(%rbx), %esi
addl $0x40, %esi
callq 0x20a0
leaq 0x27bc(%rip), %rdi      # 0x9e5d
movl %ebp, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x2030
leaq 0x81fc(%rip), %r14      # 0xf8b0
movl (%r14), %edi
addl $0xe, %edi
leaq 0x81f3(%rip), %r15      # 0xf8b4
movl (%r15), %esi
callq 0x4f79
addl $-0xe, (%r14)
movq %rbx, %rdi
callq 0x27b4
cmpl $0x0, 0x24(%rbx)
je 0x7718
leaq 0x2794(%rip), %rdi      # 0x9e76
movl $0x9b, %esi
xorl %eax, %eax
callq 0x2030
movl 0x20(%rbx), %esi
movl 0x24(%rbx), %edx
addl $0x40, %esi
leaq 0x1ab0(%rip), %rdi      # 0x91ae
xorl %eax, %eax
callq 0x2030
leaq 0x276f(%rip), %rdi      # 0x9e7b
movl $0x9b, %esi
xorl %eax, %eax
callq 0x2030
movl (%r14), %edi
movl (%r15), %esi
incl %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4f79
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqsubs.c
// Function: pr2nt_res
void pr2nt_res(char field)
{
    switch (field) {
    case 'V':
        point(53, 18);
        printw("V:%2d", vel[player]);
        if (vel[player] < max_vel)
            printw(" res: %3d need:%4d", vel_working[player],
                   vel_req[vel[player] + 1]);
        else
            printw("                   ");
        break;
    case 'R':
        point(53, 19);
        printw("R:%2d", range[player]);
        if (range[player] < bdsize)
            printw(" res: %3d need:%4d", ran_working[player],
                   ran_req[range[player] + 1]);
        else
            printw("                   ");
        break;
    case 'W':
        point(53, 20);
        printw("W:%2d", weapons[player]);
        if (weapons[player] < 10)
            printw(" res: %3d need:%4d", weap_working[player],
                   weap_req[weapons[player] + 1]);
        else
            printw("                   ");
        break;
    };                          /*switch ( */
}

// Assembly:
pushq %rbx
cmpl $0x52, %edi
je 0x7b3f
cmpl $0x57, %edi
je 0x7afb
cmpl $0x56, %edi
jne 0x7ba3
movl $0x35, %edi
movl $0x12, %esi
callq 0x4f79
leaq 0x7be2(%rip), %rbx      # 0xf6a8
movl 0x4(%rbx), %esi
leaq 0x242e(%rip), %rdi      # 0x9efe
xorl %eax, %eax
callq 0x2030
movslq 0x4(%rbx), %rax
cmpq $0xb, %rax
jg 0x7b94
leaq 0x7be4(%rip), %rcx      # 0xf6d0
movl 0x4(%rcx), %esi
leaq 0x7c5a(%rip), %rcx      # 0xf750
jmp 0x7b81
movl $0x35, %edi
movl $0x14, %esi
callq 0x4f79
leaq 0x7ba7(%rip), %rbx      # 0xf6b8
movl 0x4(%rbx), %esi
leaq 0x2402(%rip), %rdi      # 0x9f1d
xorl %eax, %eax
callq 0x2030
movslq 0x4(%rbx), %rax
cmpq $0x9, %rax
jg 0x7b94
leaq 0x7b8d(%rip), %rcx      # 0xf6c0
movl 0x4(%rcx), %esi
leaq 0x7ba3(%rip), %rcx      # 0xf6e0
jmp 0x7b81
movl $0x35, %edi
movl $0x13, %esi
callq 0x4f79
leaq 0x7b5b(%rip), %rbx      # 0xf6b0
movl 0x4(%rbx), %esi
leaq 0x23b8(%rip), %rdi      # 0x9f17
xorl %eax, %eax
callq 0x2030
movslq 0x4(%rbx), %rax
cmpq $0xe, %rax
jg 0x7b94
leaq 0x7b51(%rip), %rcx      # 0xf6c8
movl 0x4(%rcx), %esi
leaq 0x7b8f(%rip), %rcx      # 0xf710
movl 0x4(%rcx,%rax,4), %edx
leaq 0x2378(%rip), %rdi      # 0x9f04
xorl %eax, %eax
popq %rbx
jmp 0x2030
leaq 0x1787(%rip), %rdi      # 0x9322
xorl %eax, %eax
popq %rbx
jmp 0x2030
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqsubs.c
// Function: ressum
void ressum(void)
{
    char key;
    int value, ind;
    char iline[81];
    printw("esearch field(s):");
    get_line(iline, &ind, true);
    get_token(iline, &ind, &value, &key);
    cle3r_left();
    if (key == ' ') {
        pr2nt_res('R');
        pr2nt_res('V');
        pr2nt_res('W');
    } else {
        do {
            pr2nt_res(key);
            get_token(iline, &ind, &value, &key);
        }
        while (key != ' ');
    };
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x236c(%rip), %rdi      # 0x9f23
xorl %eax, %eax
callq 0x2030
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x716e
leaq 0xc(%rsp), %rdx
leaq 0x7(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x739d
callq 0x7322
movb (%r15), %al
cmpb $0x20, %al
jne 0x7c1c
movl $0x52, %edi
callq 0x7a98
movl $0x56, %edi
callq 0x7a98
movl $0x57, %edi
callq 0x7a98
jmp 0x7c51
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0x7(%rsp), %r12
movsbl %al, %edi
callq 0x7a98
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x739d
movb 0x7(%rsp), %al
cmpb $0x20, %al
jne 0x7c30
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqtf.c
// Function: make_tf
void make_tf(void)
{
    char task;
    int tf_num;
    boolean error;
    int new_tf;
    printw("ew tf- from tf:");
    get_char(&task);
    cle3r_left();
    tf_num = task - 'A' + 1;
    error = (tf_num < 1) || (tf_num > 26);
    if (!error)
        error = (tf[player][tf_num].eta != 0) ||
            (tf[player][tf_num].dest == 0);
    if (error) {
        error_message();
        printw("  !illegal tf");
    } else if (tf[player][tf_num].blasting) {
        error = true;
        error_message();
        printw(" !Tf is blasting a planet     ");
    } else {
        point(1, 19);
        split_tf(&tf_num, &new_tf);
        point(1, 20);
        pr3nt_tf(new_tf);
        point(1, 21);
        pr3nt_tf(tf_num);
    };
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x2147(%rip), %rdi      # 0x9f55
xorl %eax, %eax
callq 0x2030
leaq 0xf(%rsp), %rbx
movq %rbx, %rdi
callq 0x7153
callq 0x7322
movsbl (%rbx), %eax
leal -0x5b(%rax), %ecx
addl $-0x40, %eax
movl %eax, 0x10(%rsp)
cmpb $-0x1a, %cl
jb 0x7e50
movl %eax, %eax
imulq $0x34, %rax, %rax
leaq 0x6b4a(%rip), %rcx      # 0xe990
cmpl $0x0, 0x5a0(%rcx,%rax)
je 0x7e6b
callq 0x738e
leaq 0x1b88(%rip), %rdi      # 0x99e4
xorl %eax, %eax
callq 0x2030
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq (%rcx,%rax), %rdx
addq $0x57c, %rdx            # imm = 0x57C
cmpl $0x0, 0x20(%rdx)
je 0x7e50
cmpl $0x0, 0x5a8(%rcx,%rax)
je 0x7e94
callq 0x738e
leaq 0x20d3(%rip), %rdi      # 0x9f65
jmp 0x7e5c
movl $0x1, %edi
movl $0x13, %esi
callq 0x4f79
leaq 0x10(%rsp), %rbx
leaq 0x14(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7eea
movl $0x1, %edi
movl $0x14, %esi
callq 0x4f79
movl (%r14), %edi
callq 0x7620
movl $0x1, %edi
movl $0x15, %esi
callq 0x4f79
movl (%rbx), %edi
callq 0x7620
jmp 0x7e63
// File: /workspace/github_c_makefile_star2_O3/beejjorgensen[P]conquest/conqve.c
// Function: invest
void invest(void)
{
    int newborn, starnum;
    struct stplanet *pplan;
    production_year = 0;
    point(33, 20);
    printw("* investment *  ");
    for (starnum = 1; starnum <= nstars; starnum++) {
        pplan = stars[starnum].first_planet;
        while (pplan != nil) {
            if (((pplan->esee_team) == player)
                && ((pplan->capacity) > 10)
                && ((pplan->esee_def) < 12))
                pplan->esee_def = (pplan->esee_def) + 1;
            if ((pplan->team) != none) {
                newborn = conq_round((pplan->inhabitants)
                                     * growth_rate[pplan->team] *
                                     (1 -
                                      ((pplan->inhabitants) /
                                       (pplan->capacity))));
                if (pplan->conquered)
                    newborn = newborn / 2;
                pplan->inhabitants = (pplan->inhabitants)
                    + newborn;
                pplan->iu = (pplan->iu) + newborn;
                if (pplan->team == ENEMY)
                    inv_enemy(pplan);
                else
                    inv_player(stars[starnum].x, stars[starnum].y, pplan);
            };
            pplan = pplan->next;
        };
    };
    battle();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x6aa4(%rip), %rax      # 0xf788
movl $0x0, (%rax)
movl $0x21, %edi
movl $0x14, %esi
callq 0x4f79
leaq 0x14c3(%rip), %rdi      # 0xa1c3
xorl %eax, %eax
callq 0x2030
movl $0x1, %r14d
leaq 0x677c(%rip), %r15      # 0xf490
leaq 0x6985(%rip), %r12      # 0xf6a0
leaq (%r14,%r14,2), %rax
movq 0x8(%r15,%rax,8), %rbx
testq %rbx, %rbx
je 0x8dd3
leaq (%r15,%rax,8), %r13
cmpl $0x1, 0x28(%rbx)
jne 0x8d4a
cmpl $0xb, 0x4(%rbx)
jl 0x8d4a
movl 0x2c(%rbx), %eax
cmpl $0xb, %eax
jg 0x8d4a
incl %eax
movl %eax, 0x2c(%rbx)
movslq 0xc(%rbx), %rcx
cmpq $0x2, %rcx
je 0x8dc6
movl 0x10(%rbx), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss (%r12,%rcx,4), %xmm1
cltd
idivl 0x4(%rbx)
movl $0x1, %ecx
subl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
mulss %xmm1, %xmm0
callq 0x4ff2
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl $0x0, 0x20(%rbx)
cmovel %eax, %ecx
movq 0x10(%rbx), %xmm0
movd %ecx, %xmm1
pshufd $0x50, %xmm1, %xmm1     # xmm1 = xmm1[0,0,1,1]
paddd %xmm0, %xmm1
movq %xmm1, 0x10(%rbx)
cmpl $0x0, 0xc(%rbx)
je 0x8dbe
movl (%r13), %edi
movl 0x4(%r13), %esi
movq %rbx, %rdx
callq 0x8643
jmp 0x8dc6
movq %rbx, %rdi
callq 0x836c
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0x8d31
incq %r14
cmpq $0x16, %r14
jne 0x8d1b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x383c
// File: /workspace/github_c_makefile_star2_O3/hasindu2008[P]f5p/socket.c
// Function: send_all
void send_all(int socket, void* buffer, int64_t length) {
    char* ptr = (char*)buffer;
    int64_t i = 0;
    while (length > 0) {
        i = send(socket, ptr, length, 0);
        if (i < 1) {
            if(verbose_socklibc>=1) {
				WARNING("%s", "Could not send all data. Trying again.");
			}
            sleep(1);
        }
        ptr += i;
        length -= i;
    }
    return;
}

// Assembly:
testq %rdx, %rdx
jle 0x19ad
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x10d0
movq %rax, %r15
testq %rax, %rax
jg 0x1992
cmpl $0x0, 0x47c2(%rip)      # 0x6148
jg 0x199c
movl $0x1, %edi
callq 0x1240
addq %r15, %r14
subq %r15, %rbx
jg 0x1968
jmp 0x19a3
callq 0x1280
jmp 0x1988
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq