LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/beejjorgensen[P]conquest/conq4.c
// Function: zero_tf
void zero_tf(tteam tm, int tf_num)
{
    int x, y, i;
    if (tf[tm][tf_num].dest != 0) {
        x = tf[tm][tf_num].x;
        y = tf[tm][tf_num].y;
        if ((tf[tm][tf_num].s + tf[tm][tf_num].t + tf[tm][tf_num].c +
             tf[tm][tf_num].b) == 0) {
            if (tf[tm][tf_num].eta == 0) {
                tf_stars[tf[tm][tf_num].dest][tm]--;
            };
            tf[tm][tf_num].dest = 0;
            if (tm == player) {
                board[x][y].tf = ' ';
                for (i = 1; i <= 26; i++) {
                    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 = '*';
                    };
                }
                update_board(x, y, right);
            }

        };
    };
}

// Assembly:
movl %edi, %eax
movslq %edi, %rdx
movslq %esi, %rcx
imulq $0x34, %rcx, %rdi
imulq $0x57c, %rdx, %rcx      # imm = 0x57C
addq 0x9909(%rip), %rcx      # 0xcfb8
movslq 0x20(%rdi,%rcx), %rsi
testq %rsi, %rsi
je 0x3774
addq %rdi, %rcx
movl 0x14(%rcx), %edi
addl 0x10(%rcx), %edi
addl 0x18(%rcx), %edi
addl 0x1c(%rcx), %edi
jne 0x3774
cmpl $0x0, 0x24(%rcx)
jne 0x36e6
shlq $0x3, %rsi
addq 0x98fd(%rip), %rsi      # 0xcfe0
decl (%rsi,%rdx,4)
movslq (%rcx), %rdi
movslq 0x4(%rcx), %rsi
movl $0x0, 0x20(%rcx)
cmpl $0x1, %eax
jne 0x3774
leaq (%rsi,%rsi,2), %rax
leaq (%rdi,%rdi,2), %rcx
shlq $0x6, %rcx
addq 0x989c(%rip), %rcx      # 0xcfa8
leaq (%rcx,%rax,4), %rax
addq $0x8, %rax
movl $0x20, (%rax)
movl $0x1, %ecx
xorl %edx, %edx
leaq 0xb278(%rip), %r8       # 0xe9a0
movl $0x2a, %r9d
cmpl $0x0, 0x5d0(%r8,%rdx)
je 0x375e
cmpl %edi, 0x5b0(%r8,%rdx)
jne 0x375e
cmpl %esi, 0x5b4(%r8,%rdx)
jne 0x375e
movl %ecx, %r10d
orl $0x60, %r10d
cmpl $0x20, (%rax)
cmovnel %r9d, %r10d
movl %r10d, (%rax)
incl %ecx
addq $0x34, %rdx
cmpq $0x548, %rdx            # imm = 0x548
jne 0x372e
xorl %edx, %edx
jmp 0x2d64
retq
// File: /workspace/github_c_makefile_star2_O1/beejjorgensen[P]conquest/conq4.c
// Function: up_year
void up_year(void)
{
    point(39, 18);
    turn = turn + 1;
    printw("%3d", turn);
    point(48, 19);
    production_year = production_year + 1;
    printw("%d", production_year);
}

// Assembly:
pushq %rax
movl $0x27, %edi
movl $0x12, %esi
callq 0x4f69
leaq 0xc008(%rip), %rax      # 0xf794
movl (%rax), %esi
incl %esi
movl %esi, (%rax)
leaq 0x6073(%rip), %rdi      # 0x980c
xorl %eax, %eax
callq 0x2030
movl $0x30, %edi
movl $0x13, %esi
callq 0x4f69
leaq 0xbfe2(%rip), %rax      # 0xf798
movl (%rax), %esi
incl %esi
movl %esi, (%rax)
leaq 0x605c(%rip), %rdi      # 0x981f
xorl %eax, %eax
popq %rcx
jmp 0x2030
nop
// File: /workspace/github_c_makefile_star2_O1/beejjorgensen[P]conquest/conqb2.c
// Function: battle
void battle(void)
{
    boolean first;
    int starnum;
    first = true;
    for (starnum = 1; starnum <= nstars; starnum++) {
        if (tf_stars[starnum][ENEMY] > 0
            && tf_stars[starnum][player] > 0
            && (any_bc(ENEMY, starnum) || any_bc(player, starnum))
            ) {
            if (first) {
                point(33, 20);
                printw("* Tf battle *   ");
                first = false;
            };
            tf_battle(starnum);
        };
        if ((any_bc(ENEMY, starnum)) && (col_stars[starnum][player]
                                         > 0))
            EN2MY_attack(starnum);
        else if ((tf_stars[starnum][player] > 0)
                 && (col_stars[starnum][ENEMY] > 0))
            pl2yerattack(starnum);
    };
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1, %ebp
movl $0x1, %ebx
leaq 0xa44b(%rip), %r15      # 0xdc30
leaq 0x5b7c(%rip), %r14      # 0x9368
leaq 0xa4ed(%rip), %r12      # 0xdce0
cmpl $0x0, (%r15,%rbx,8)
jle 0x3845
cmpl $0x0, 0x4(%r15,%rbx,8)
jle 0x3845
xorl %edi, %edi
movl %ebx, %esi
callq 0x224c
testl %eax, %eax
jne 0x381f
movl $0x1, %edi
movl %ebx, %esi
callq 0x224c
testl %eax, %eax
je 0x3845
testl %ebp, %ebp
je 0x383c
movl $0x21, %edi
movl $0x14, %esi
callq 0x4f69
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
movl %ebx, %edi
callq 0x2e3e
xorl %ebp, %ebp
xorl %edi, %edi
movl %ebx, %esi
callq 0x224c
testl %eax, %eax
je 0x3863
cmpl $0x0, 0x4(%r12,%rbx,8)
jle 0x3863
movl %ebx, %edi
callq 0x2841
jmp 0x3879
cmpl $0x0, 0x4(%r15,%rbx,8)
jle 0x3879
cmpl $0x0, (%r12,%rbx,8)
jle 0x3879
movl %ebx, %edi
callq 0x2bb0
incq %rbx
cmpq $0x16, %rbx
jne 0x37f3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/beejjorgensen[P]conquest/conqbat.c
// Function: blast
void blast(tplanet *planet, int factors)
{
    int killed;

    killed = MIN(planet->capacity, factors / 4);
    planet->inhabitants =
        MIN(planet->inhabitants, planet->capacity) - killed;
    planet->iu = MIN(planet->iu - killed, planet->inhabitants * iu_ratio);
    planet->capacity = planet->capacity - killed;
    if (planet->inhabitants <= 0) {
        planet->inhabitants = 0;
        planet->iu = 0;
        planet->mb = 0;
        planet->amb = 0;
        if (planet->team != none) {
            col_stars[planet->pstar][planet->team]--;
            planet->team = none;
            planet->esee_team = none;
            planet->conquered = false;
            on_board(stars[planet->pstar].x, stars[planet->pstar].y);
        };
    };
}

// Assembly:
leal 0x3(%rsi), %eax
testl %esi, %esi
cmovnsl %esi, %eax
sarl $0x2, %eax
movl 0x4(%rdi), %ecx
movl 0x10(%rdi), %edx
cmpl %eax, %ecx
cmovll %ecx, %eax
movl %ecx, %esi
subl %eax, %esi
cmpl %ecx, %edx
cmovgel %esi, %edx
movl %edx, 0x10(%rdi)
movl 0x14(%rdi), %ecx
subl %eax, %ecx
leal (%rdx,%rdx), %eax
cmpl %eax, %ecx
cmovgel %eax, %ecx
movl %ecx, 0x14(%rdi)
movl %esi, 0x4(%rdi)
testl %edx, %edx
jg 0x38dd
leaq 0x10(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movslq 0xc(%rdi), %rax
cmpq $0x2, %rax
jne 0x38de
retq
movslq 0x30(%rdi), %rcx
shlq $0x3, %rcx
addq 0x96d3(%rip), %rcx      # 0xcfc0
decl (%rcx,%rax,4)
movl $0x2, %eax
movl %eax, 0xc(%rdi)
movl %eax, 0x28(%rdi)
movl $0x0, 0x20(%rdi)
movslq 0x30(%rdi), %rax
leaq (%rax,%rax,2), %rax
leaq 0xbb8f(%rip), %rcx      # 0xf4a0
movl (%rcx,%rax,8), %edi
movl 0x4(%rcx,%rax,8), %esi
jmp 0x7580
// File: /workspace/github_c_makefile_star2_O1/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      # 0x952a
xorl %eax, %eax
callq 0x2030
callq 0x7377
movl $0x1, %ebx
movl $0x1, %edi
movl $0x13, %esi
callq 0x4f69
movq 0x8db6(%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 0x71a2
leaq 0x8(%rsp), %rdx
leaq 0x7(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x73f2
movl $0x32, %edi
movl $0x1, %esi
callq 0x4f69
cmpb $0x20, (%r12)
jne 0x4297
movl %ebx, %edi
callq 0x7793
incl %ebx
cmpl $0x16, %ebx
jne 0x4287
jmp 0x42d0
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
movsbl 0x7(%rsp), %edi
addl $-0x40, %edi
callq 0x7793
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x73f2
cmpb $0x20, 0x7(%rsp)
jne 0x42ab
callq 0x731e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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      # 0x9537
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 0x71a2
leaq 0xc(%rsp), %rdx
leaq 0x7(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x73f2
movl $0x32, %edi
movl $0x1, %esi
callq 0x4f69
cmpb $0x20, (%r12)
jne 0x4357
movl %ebx, %edi
callq 0x7683
incl %ebx
cmpl $0x1b, %ebx
jne 0x4347
jmp 0x4390
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0x7(%rsp), %r12
movsbl 0x7(%rsp), %edi
addl $-0x40, %edi
callq 0x7683
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x73f2
cmpb $0x20, 0x7(%rsp)
jne 0x436b
callq 0x731e
callq 0x7377
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %r14
leaq (%r14,%r14,2), %rax
leaq 0xb0df(%rip), %rcx      # 0xf4a0
movq 0x8(%rcx,%rax,8), %r15
leaq 0x9913(%rip), %rdx      # 0xdce0
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 0x448f
movl %edi, %ebx
leaq (%rcx,%rax,8), %r12
shlq $0x3, %r14
addq 0x8bc2(%rip), %r14      # 0xcfc0
cmpl $0x0, 0x20(%r15)
je 0x4482
cmpl $0x1, 0xc(%r15)
jne 0x441c
movl $0x1, %edi
movl %ebx, %esi
callq 0x224c
testl %eax, %eax
je 0x443d
cmpl $0x0, 0xc(%r15)
jne 0x4433
xorl %r13d, %r13d
xorl %edi, %edi
movl %ebx, %esi
callq 0x224c
testl %eax, %eax
je 0x4449
movl $0x2, %eax
movb $0x1, %r13b
jmp 0x4450
xorl %r13d, %r13d
movl $0x1, %eax
xorl %ebp, %ebp
jmp 0x4450
movl $0x1, %ebp
xorl %eax, %eax
testb %r13b, %r13b
jne 0x4482
decl (%r14,%rax,4)
movslq %ebp, %rax
incl (%r14,%rax,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 0x7580
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0x43fe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x4fc5
leal -0x2(%rax), %ecx
cmpl $0x2, %eax
movl $0x1, %r13d
cmovgel %ecx, %r13d
testl %r13d, %r13d
je 0x45cf
movl $0x40, %edi
callq 0x2080
testl %r13d, %r13d
jle 0x45d1
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 0x4fc5
addl %r15d, %eax
movl %eax, (%r14)
movl $0x4, %edi
callq 0x4fc5
cmpl $0x3, %eax
jl 0x455c
movl $0x4, %edi
callq 0x4fc5
leal (%rax,%rax,4), %eax
leal 0x14(,%rax,2), %eax
jmp 0x4569
movl $0x3, %edi
callq 0x4fc5
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 0x459e
xorl %eax, %eax
movq %r14, %rcx
jmp 0x45ab
movl $0x40, %edi
callq 0x2080
movq %rax, %rcx
movq %rax, 0x38(%r14)
addl $0x2, %r15d
movq %rcx, %r14
decl %r13d
jne 0x4527
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %r15
movq (%rsp), %rax
jmp 0x45d1
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_O1/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 0x8fbe(%rip), %rax      # 0xdd90
movb $0x56, (%rax)
leaq 0x9bc4(%rip), %r12      # 0xe9a0
movl $0x1, 0x4c(%r12)
movl $0x2, 0x44(%r12)
xorl %ebp, %ebp
xorl %edi, %edi
movl $0x56, %esi
movl $0x2, %edx
callq 0x7cc9
movl $0x1, %ebx
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
xorl %r13d, %r13d
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x72ca
movl $0x5, %edi
callq 0x4fc5
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl %r13d, %eax
cmovgl %eax, %r13d
cmovgl %ebx, %ebp
incl %ebx
cmpl $0x16, %ebx
jne 0x4e13
movl %ebp, 0x54(%r12)
movslq %ebp, %rbx
leaq (%rbx,%rbx,2), %rax
leaq 0xa64a(%rip), %rcx      # 0xf4a0
movl (%rcx,%rax,8), %edx
movl %edx, 0x34(%r12)
movl 0x4(%rcx,%rax,8), %edx
movl %edx, 0x38(%r12)
movl $0x1, %edx
movl %edx, 0x10(%rcx,%rax,8)
leaq 0x8db9(%rip), %rax      # 0xdc30
movl %edx, (%rax,%rbx,8)
movl $0x32, %edi
movl $0x1, %esi
callq 0x4f69
movl 0x5d0(%r12), %edi
callq 0x7793
callq 0x731e
cmpl 0x5d0(%r12), %ebx
jne 0x4eaf
callq 0x7377
callq 0x37cc
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x481b(%rip), %rdi      # 0x9718
xorl %eax, %eax
callq 0x2030
callq 0x4985
callq 0x4dbd
leaq 0xa9a3(%rip), %rbx      # 0xf8b8
leaq 0xa87c(%rip), %r14      # 0xf798
leaq 0xa871(%rip), %r15      # 0xf794
callq 0x6dc9
cmpl $0x0, (%rbx)
jne 0x4f52
callq 0x528c
callq 0x5a9c
callq 0x37cc
cmpl $0x4, (%r14)
jne 0x4f4d
cmpl $0x63, (%r15)
jg 0x4f4d
callq 0x8d6b
callq 0x3775
callq 0x2301
cmpl $0x0, (%rbx)
je 0x4f23
callq 0x20c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x806f(%rip), %rax      # 0xcfe8
movq (%rax), %rdi
leal -0x1(%rbx), %esi
leal -0x1(%r14), %edx
callq 0x20b0
leaq 0xa931(%rip), %rax      # 0xf8c0
movl %r14d, (%rax)
leaq 0xa92b(%rip), %rax      # 0xf8c4
movl %ebx, (%rax)
cmpl $0x14, %r14d
setge %al
cmpl $0x12, %ebx
sete %cl
orb %al, %cl
jne 0x4fbd
movslq %ebx, %rax
leaq 0xa91a(%rip), %rcx      # 0xf8d0
movl $0x1, (%rcx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5054
cmpl $0x2, 0x18(%rbx)
jl 0x5159
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 0x505e
testl %edi, %edi
je 0x5159
callq 0x4fc5
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 0x508d
movl 0x20(%rbx), %edx
leaq 0x4(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x2a18
movl 0x1c(%rbx), %eax
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
movslq (%r15), %rax
imulq $0x34, %rax, %rax
leaq 0x98cf(%rip), %rcx      # 0xe9a0
movl %edx, 0x1c(%rcx,%rax)
subl %edx, 0x1c(%rbx)
movl 0x18(%rbx), %edx
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
movl %esi, 0x18(%rcx,%rax)
subl %esi, 0x18(%rbx)
cmpl $0x4, 0x14(%rbx)
jl 0x50fd
movl $0x2, 0x14(%rcx,%rax)
addl $-0x2, 0x14(%rbx)
movl %r12d, 0x20(%rcx,%rax)
xorps %xmm0, %xmm0
cvtss2sd (%r14,%r12,4), %xmm0
addsd 0x4145(%rip), %xmm0     # 0x9258
leaq 0xa59e(%rip), %rdx      # 0xf6b8
xorps %xmm1, %xmm1
cvtsi2sdl (%rdx), %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
incl %edx
movl %edx, 0x24(%rcx,%rax)
movslq 0x20(%rbx), %rax
leaq 0x8af6(%rip), %rcx      # 0xdc30
leaq 0x8b9f(%rip), %rdx      # 0xdce0
movl 0x4(%rdx,%rax,8), %edx
addl 0x4(%rcx,%rax,8), %edx
jle 0x5159
leaq 0xa6ae(%rip), %rcx      # 0xf800
movl $0x1, (%rcx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa32b(%rip), %rcx      # 0xf4a0
cmpl $0x0, 0x10(%rcx,%rax,8)
je 0x51e0
movl 0x28(%rdi), %eax
cmpl $0x1, %eax
je 0x51e7
movl $0x64, %ebx
testl %eax, %eax
jne 0x51f8
movl $0x3e8, %eax            # imm = 0x3E8
cmpl $0x0, 0x20(%rdi)
jne 0x51d1
movl 0x1c(%rdi), %eax
leal (%rax,%rax,2), %eax
addl %eax, %eax
addl 0x18(%rdi), %eax
movslq 0x14(%rdi), %rcx
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %esi
shrl $0x1f, %esi
sarl $0x3, %edx
addl %esi, %edx
xorl %esi, %esi
cmpl %edx, %eax
movl $0x12c, %eax            # imm = 0x12C
cmovgl %esi, %eax
cmpq $0x8, %rcx
cmovll %esi, %eax
leal -0xfa(%rax), %ebx
cmpl $0x4, 0x1c(%rdi)
cmovll %eax, %ebx
jmp 0x51f8
movl $0x258, %ebx            # imm = 0x258
jmp 0x520a
cmpl $0x0, 0x20(%rdi)
movl $0xc8, %eax
movl $0x190, %ebx            # imm = 0x190
cmovel %eax, %ebx
cmpl $0x27, 0x4(%rdi)
jg 0x520a
cmpl $0xf, 0x14(%rdi)
leal -0x64(%rbx), %eax
cmovgel %ebx, %eax
movl %eax, %ebx
movl $0x14, %edi
callq 0x4fc5
addl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa279(%rip), %rcx      # 0xf4a0
cmpl $0x0, 0x10(%rcx,%rax,8)
je 0x5270
movl 0x28(%rdi), %edx
testl %edx, %edx
movl $0x1e, %esi
movl $0x28, %ecx
cmovnel %ecx, %esi
xorl %eax, %eax
cmpl $0x1, %edx
cmovnel %esi, %eax
je 0x5275
movl 0x4(%rdi), %edx
subl 0x10(%rdi), %edx
leaq 0xa53d(%rip), %rsi      # 0xf794
movl (%rsi), %esi
movl %esi, %edi
shrl $0x1f, %edi
addl %esi, %edi
sarl %edi
subl %edi, %ecx
leal 0x28(%rax), %esi
cmpl %ecx, %edx
cmovlel %eax, %esi
movl %esi, %eax
jmp 0x5275
movl $0x3c, %eax
addss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x44ab(%rip), %xmm0     # 0x9730
cvttsd2si %xmm0, %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9702(%rip), %rbx      # 0xe9a0
addq $0x34, %rbx
movq $-0x1a, %r12
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
cmpl $0x0, 0x24(%rbx)
jne 0x52f8
movl 0x20(%rbx), %edi
testl %edi, %edi
je 0x52f8
movq %r14, %rsi
movq %r15, %rdx
callq 0x72ca
movq %r14, %rdi
movq %rbx, %rsi
callq 0x530d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x54fe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5792
leal 0x1b(%r12), %esi
xorl %edi, %edi
callq 0x3695
addq $0x34, %rbx
incq %r12
jne 0x52b3
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movslq %edi, %rax
leaq (%rax,%rax,2), %rax
leaq 0x9ac9(%rip), %rcx      # 0xf4a0
movq 0x8(%rcx,%rax,8), %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x5a36
movl $0x88888889, %r15d      # imm = 0x88888889
cmpl $0x0, 0xc(%r14)
jne 0x5a29
movl 0x14(%r14), %eax
cmpl $0xb, %eax
jl 0x5a29
movl 0x1c(%r14), %ecx
leal (%rcx,%rcx,2), %ebp
addl %ebp, %ebp
addl 0x18(%r14), %ebp
movl %eax, %eax
imulq %r15, %rax
shrq $0x23, %rax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
callq 0x4fe2
movl $0x1, %ecx
cmpl %eax, %ebp
jl 0x5a27
movl %ebx, %ecx
movl %ecx, %ebx
movq 0x38(%r14), %r14
testq %r14, %r14
je 0x5a36
testl %ebx, %ebx
je 0x59e9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2de0(%rip), %rdi      # 0x9aa2
xorl %eax, %eax
callq 0x2030
leaq 0xb(%rsp), %rbx
movq %rbx, %rdi
callq 0x7187
callq 0x7377
movl $0x1, %edi
movl $0x13, %esi
callq 0x4f69
movsbl (%rbx), %edi
leal -0x5b(%rdi), %eax
cmpb $-0x1b, %al
ja 0x6d02
callq 0x73e3
leaq 0x2c95(%rip), %rdi      # 0x9995
jmp 0x6d65
addl $-0x40, %edi
movl %edi, %eax
imulq $0x34, %rax, %rax
leaq 0x7c8e(%rip), %rcx      # 0xe9a0
cmpl $0x0, 0x59c(%rcx,%rax)
je 0x6d45
addq %rcx, %rax
addq $0x57c, %rax            # imm = 0x57C
movl 0x24(%rax), %ecx
testl %ecx, %ecx
je 0x6d53
cmpl 0x28(%rax), %ecx
jne 0x6d37
cmpl $0x0, 0x30(%rax)
je 0x6d53
callq 0x73e3
leaq 0x2d6e(%rip), %rdi      # 0x9ab1
jmp 0x6d65
callq 0x73e3
leaq 0x2c52(%rip), %rdi      # 0x99a3
jmp 0x6d65
cmpl $0x0, 0x2c(%rax)
je 0x6d72
callq 0x73e3
leaq 0x2d6a(%rip), %rdi      # 0x9acf
xorl %eax, %eax
callq 0x2030
addq $0x10, %rsp
popq %rbx
retq
movl $0x0, 0x30(%rax)
leaq 0xc(%rsp), %rsi
callq 0x6edc
jmp 0x6d6c
// File: /workspace/github_c_makefile_star2_O1/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 0x73c3
leaq 0x2d53(%rip), %rdi      # 0x9ae9
xorl %eax, %eax
callq 0x2030
leaq 0xf(%rsp), %rbx
movq %rbx, %rdi
callq 0x7187
cmpb $0x59, (%rbx)
jne 0x6dbe
leaq 0x8b02(%rip), %rax      # 0xf8b8
movl $0x1, (%rax)
jmp 0x6dc3
callq 0x61f4
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0x21, %edi
movl $0x14, %esi
callq 0x4f69
leaq 0x2d15(%rip), %rdi      # 0x9b00
xorl %eax, %eax
callq 0x2030
leaq 0x2d18(%rip), %rbx      # 0x9b11
leaq 0xf(%rsp), %r14
leaq 0x2d2b(%rip), %r15      # 0x9b30
leaq 0x2a18(%rip), %r12      # 0x9824
xorl %ebp, %ebp
movl $0x1, %edi
movl $0x12, %esi
callq 0x4f69
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
movl $0x2, %edi
movl $0x12, %esi
callq 0x4f69
movq %r14, %rdi
callq 0x7187
movzbl 0xf(%rsp), %eax
leal -0x3f(%rax), %ecx
cmpl $0x15, %ecx
ja 0x6e5b
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
jmpq *%rax
callq 0x63dc
jmp 0x6ec6
cmpl $0x20, %eax
je 0x6e76
callq 0x73e3
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
jmp 0x6ec6
callq 0x6d85
movl $0x1, %ebp
jmp 0x6ec6
movl $0x1, %edi
callq 0x74d3
jmp 0x6ec6
callq 0x4000
jmp 0x6ec6
callq 0x61f4
jmp 0x6ec6
callq 0x6856
jmp 0x6ec6
callq 0x42e1
jmp 0x6ec6
callq 0x7c11
jmp 0x6ec6
callq 0x6cb6
jmp 0x6ec6
callq 0x81c8
jmp 0x6ec6
callq 0x7e60
jmp 0x6ec6
callq 0x41f9
testl %ebp, %ebp
je 0x6e0e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x5eaa(%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_O1/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, 0x8(%rsp)
movl $0x1, %r12d
leaq 0x7(%rsp), %r14
movq %r14, %rdi
callq 0x7130
movzbl 0x7(%rsp), %r13d
cmpl $0xa, %r13d
je 0x7274
cmpl $0x8, %r13d
jne 0x722d
movl $0x1, %r15d
cmpl $0x1, %r12d
je 0x7277
testl %ebp, %ebp
je 0x7210
movq 0x5de8(%rip), %rax      # 0xcfe8
movq (%rax), %rdi
movl $0x8, %esi
callq 0x20a0
decl %r12d
testl %ebp, %ebp
jne 0x7274
cmpl $0x1, %r12d
je 0x7274
leaq 0x29b4(%rip), %rdi      # 0x9bd5
xorl %eax, %eax
callq 0x2030
decl %r12d
jmp 0x7274
movsbl %r13b, %ebx
leaq 0x2d16(%rip), %rdi      # 0x9f4e
movl %ebx, %esi
xorl %eax, %eax
callq 0x2030
movslq %r12d, %rax
leaq 0x1(%rax), %r15
movq 0x8(%rsp), %rcx
movb %bl, (%rcx,%rax)
testl %ebp, %ebp
je 0x7277
movq %rcx, %rbx
movq 0x5d8a(%rip), %rax      # 0xcfe8
movq (%rax), %rdi
movl $0x20, %esi
callq 0x20a0
movb $0x20, (%rbx,%r15)
addl $0x2, %r12d
movl %r12d, %r15d
cmpb $0xa, %r13b
je 0x728a
movl %r15d, %r12d
cmpl $0x19, %r15d
jl 0x71c7
cmpl $0x50, %r15d
je 0x72b0
movslq %r15d, %rax
movq 0x8(%rsp), %rdi
addq %rax, %rdi
movl $0x4f, %edx
subl %r15d, %edx
incq %rdx
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_O1/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 0x83ef(%rip), %rax      # 0xf6c0
movl (%rax), %eax
movslq %edi, %rcx
imulq $0x58, %rcx, %rcx
addq 0x5d0f(%rip), %rcx      # 0xcff0
xorl %edi, %edi
movl $0x1, %r8d
movl (%rcx,%r8,4), %r11d
xorl %r9d, %r9d
cmpl %r11d, %eax
setge %r10b
jge 0x72fe
xorps %xmm0, %xmm0
jmp 0x7306
xorps %xmm0, %xmm0
cvtsi2ss %r11d, %xmm0
movb %r10b, %r9b
addl %r9d, %edi
movss %xmm0, (%rsi,%r8,4)
incq %r8
cmpq $0x16, %r8
jne 0x72e9
movl %edi, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8598(%rip), %rax      # 0xf8c4
movl (%rax), %ebp
leaq 0x8587(%rip), %r15      # 0xf8bc
cmpl (%r15), %ebp
jg 0x7367
leaq 0x1f8e(%rip), %rbx      # 0x92cf
movl %ebp, %r14d
movl $0x32, %edi
movl %r14d, %esi
callq 0x4f69
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
leal 0x1(%r14), %eax
cmpl (%r15), %r14d
movl %eax, %r14d
jl 0x7344
decl %ebp
movl %ebp, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8548(%rip), %r15      # 0xf8d0
leaq 0x1f40(%rip), %r14      # 0x92cf
cmpl $0x0, (%r15,%rbx,4)
je 0x73b4
movl $0x1, %edi
movl %ebx, %esi
callq 0x4f69
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
movl $0x0, (%r15,%rbx,4)
incq %rbx
cmpq $0x19, %rbx
jne 0x738f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7433
cmpb $0x20, %r11b
je 0x7418
cmpq $0x4f, %rbx
jg 0x7490
addb $-0x3a, %r11b
movl $0x1, %r8d
cmpb $-0xa, %r11b
jb 0x7486
sarq $0x20, %r10
movb (%rdi,%r10), %r10b
leal -0x30(%r10), %r11d
xorl %r8d, %r8d
cmpb $0x9, %r11b
ja 0x7486
addq %rdi, %r9
xorl %r8d, %r8d
movsbl %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 0x7464
cltq
movb (%rdi,%rax), %r9b
incl %eax
jmp 0x7496
xorl %r8d, %r8d
movb $0x20, %r9b
movslq %eax, %r11
leal -0x2(%r11), %eax
leaq 0x1(%r11), %r10
incl %eax
cmpq $0x4f, %r11
jg 0x74b3
cmpb $0x20, (%rdi,%r11)
movq %r10, %r11
jne 0x749d
decq %r10
incl %eax
cmpq $0x4f, %r10
jg 0x74c9
cmpb $0x20, (%rdi,%r10)
leaq 0x1(%r10), %r10
je 0x74b6
movl %eax, (%rsi)
movl %r8d, (%rdx)
movb %r9b, (%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f69
cmpl $0x1, %ebx
leaq 0x5c6b(%rip), %rax      # 0xd160
leaq 0x5bc4(%rip), %rcx      # 0xd0c0
cmoveq %rax, %rcx
cmpl $0x2, %ebx
leaq 0x5d36(%rip), %rax      # 0xd240
cmovneq %rcx, %rax
cmpl $0x3, %ebx
leaq 0x5dc8(%rip), %rcx      # 0xd2e0
cmovneq %rax, %rcx
cmpl $0x4, %ebx
leaq 0x5e6a(%rip), %r15      # 0xd390
cmovneq %rcx, %r15
movq (%r15), %rsi
testq %rsi, %rsi
je 0x7571
addq $0x10, %r15
movl $0x2, %r14d
leaq 0x289c(%rip), %rbx      # 0x9ddf
movq -0x8(%r15), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
leal 0x1(%r14), %ebp
movl $0x32, %edi
movl %r14d, %esi
callq 0x4f69
movq (%r15), %rsi
addq $0x10, %r15
movl %ebp, %r14d
testq %rsi, %rsi
jne 0x7543
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x731e
// File: /workspace/github_c_makefile_star2_O1/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 0x5a0f(%rip), %rax      # 0xcfa8
leaq (%rax,%rcx,4), %rax
movl $0x20, 0x8(%rax)
movl $0x1, %edx
leaq 0x73f0(%rip), %rcx      # 0xe9a0
movl $0x2a, %r8d
movl $0x1b, %r9d
movl %edx, %r10d
imulq $0x34, %r10, %r10
cmpl $0x0, 0x59c(%rcx,%r10)
je 0x75f7
addq %rcx, %r10
addq $0x57c, %r10            # imm = 0x57C
cmpl %edi, (%r10)
jne 0x75f7
cmpl %esi, 0x4(%r10)
jne 0x75f7
leal 0x60(%rdx), %r10d
cmpl $0x20, 0x8(%rax)
cmovnel %r8d, %r10d
cmovnel %r9d, %edx
movl %r10d, 0x8(%rax)
leal 0x1(%rdx), %r10d
cmpl $0x1a, %edx
movl %r10d, %edx
jl 0x75bc
movslq 0x4(%rax), %rcx
cmpq $0x2e, %rcx
je 0x7634
movl $0x20, (%rax)
leaq 0x66c6(%rip), %rdx      # 0xdce0
xorl %r8d, %r8d
cmpl $0x0, -0x1fc(%rdx,%rcx,8)
setne %r8b
shll $0x5, %r8d
addl $0x20, %r8d
movl %r8d, (%rax)
movl $0x2, %edx
jmp 0x2d64
// File: /workspace/github_c_makefile_star2_O1/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 0x4f69
leaq 0x2792(%rip), %rdi      # 0x9deb
xorl %eax, %eax
callq 0x2030
leaq 0xf(%rsp), %rbx
movq %rbx, %rdi
callq 0x7130
movsbl (%rbx), %esi
leaq 0x28d7(%rip), %rdi      # 0x9f4e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O1/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 0x7792
movl %edi, %esi
movslq %edi, %rax
imulq $0x34, %rax, %rax
leaq 0x72fa(%rip), %rcx      # 0xe9a0
cmpl $0x0, 0x59c(%rcx,%rax)
je 0x7792
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq (%rcx,%rax), %rbx
addq $0x57c, %rbx            # imm = 0x57C
addl $0x60, %esi
leaq 0x2737(%rip), %rdi      # 0x9e07
xorl %eax, %eax
callq 0x2030
movl (%rbx), %ebp
cmpl $0x0, 0x24(%rbx)
movl 0x4(%rbx), %r14d
movq 0x5900(%rip), %rax      # 0xcfe8
movq (%rax), %rdi
movl $0x20, %esi
jne 0x76f8
movl 0x20(%rbx), %esi
addl $0x40, %esi
callq 0x20a0
leaq 0x2709(%rip), %rdi      # 0x9e0d
movl %ebp, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x2030
leaq 0x81a9(%rip), %r14      # 0xf8c0
movl (%r14), %edi
addl $0xe, %edi
leaq 0x81a0(%rip), %r15      # 0xf8c4
movl (%r15), %esi
callq 0x4f69
addl $-0xe, (%r14)
movq %rbx, %rdi
callq 0x27a9
cmpl $0x0, 0x24(%rbx)
je 0x777b
leaq 0x26e1(%rip), %rdi      # 0x9e26
movl $0x9b, %esi
xorl %eax, %eax
callq 0x2030
movl 0x20(%rbx), %esi
movl 0x24(%rbx), %edx
addl $0x40, %esi
leaq 0x1a05(%rip), %rdi      # 0x9166
xorl %eax, %eax
callq 0x2030
leaq 0x26bc(%rip), %rdi      # 0x9e2b
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 0x4f69
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7bab
cmpl $0x57, %edi
je 0x7b67
cmpl $0x56, %edi
jne 0x7c0f
movl $0x35, %edi
movl $0x12, %esi
callq 0x4f69
leaq 0x7b86(%rip), %rbx      # 0xf6b8
movl 0x4(%rbx), %esi
leaq 0x2372(%rip), %rdi      # 0x9eae
xorl %eax, %eax
callq 0x2030
movslq 0x4(%rbx), %rax
cmpq $0xb, %rax
jg 0x7c00
leaq 0x7b88(%rip), %rcx      # 0xf6e0
movl 0x4(%rcx), %esi
leaq 0x7bfe(%rip), %rcx      # 0xf760
jmp 0x7bed
movl $0x35, %edi
movl $0x14, %esi
callq 0x4f69
leaq 0x7b4b(%rip), %rbx      # 0xf6c8
movl 0x4(%rbx), %esi
leaq 0x2346(%rip), %rdi      # 0x9ecd
xorl %eax, %eax
callq 0x2030
movslq 0x4(%rbx), %rax
cmpq $0x9, %rax
jg 0x7c00
leaq 0x7b31(%rip), %rcx      # 0xf6d0
movl 0x4(%rcx), %esi
leaq 0x7b47(%rip), %rcx      # 0xf6f0
jmp 0x7bed
movl $0x35, %edi
movl $0x13, %esi
callq 0x4f69
leaq 0x7aff(%rip), %rbx      # 0xf6c0
movl 0x4(%rbx), %esi
leaq 0x22fc(%rip), %rdi      # 0x9ec7
xorl %eax, %eax
callq 0x2030
movslq 0x4(%rbx), %rax
cmpq $0xe, %rax
jg 0x7c00
leaq 0x7af5(%rip), %rcx      # 0xf6d8
movl 0x4(%rcx), %esi
leaq 0x7b33(%rip), %rcx      # 0xf720
movl 0x4(%rcx,%rax,4), %edx
leaq 0x22bc(%rip), %rdi      # 0x9eb4
xorl %eax, %eax
popq %rbx
jmp 0x2030
leaq 0x16d3(%rip), %rdi      # 0x92da
xorl %eax, %eax
popq %rbx
jmp 0x2030
popq %rbx
retq