LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/tx0/mach.c
// Function: initmach
void
initmach(void)
{
	memset(&fl, 0, sizeof(fl));
	fl.in = open("/tmp/fl", O_RDWR);
	if(fl.in < 0)
		panic("can't open /tmp/fl");
	fl.out = fl.in;

	memset(&tx0, 0, sizeof(tx0));
	tx0.pbs = 0;
	tx0.ios = 1;
	tx0.fl = &fl;
	tx0.mar = tx0.pc = 040;

	FILE *mf;
	mf = mustopen("out.mem", "r");
	if(mf){
		readmem(&tx0, mf);
		fclose(mf);
	}
	mf = fopen("out.sym", "r");
	if(mf){
		readsyms(mf);
		fclose(mf);
	}

	tx0.scope_fd = dial("localhost", 3400);

	cmdchan = chancreate(sizeof(Msg), 1);
	threadcreate(simthread, &tx0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x48f41(%rip), %rdi     # 0x4e950
xorl %esi, %esi
movl $0xc, %edx
callq 0x2140
leaq 0x989(%rip), %rdi       # 0x63ab
movl $0x2, %esi
movb $0x0, %al
callq 0x2310
movl %eax, 0x48f1c(%rip)     # 0x4e950
cmpl $0x0, 0x48f15(%rip)     # 0x4e950
jge 0x5a4b
leaq 0x95c(%rip), %rdi       # 0x63a0
movb $0x0, %al
callq 0x2540
movl 0x48eff(%rip), %eax     # 0x4e950
movl %eax, 0x48efd(%rip)     # 0x4e954
leaq 0x8e22(%rip), %rdi      # 0xe880
xorl %esi, %esi
movl $0x40058, %edx          # imm = 0x40058
callq 0x2140
movl $0x0, 0x8e14(%rip)      # 0xe888
movl $0x1, 0x8e06(%rip)      # 0xe884
leaq 0x48ecb(%rip), %rax     # 0x4e950
movq %rax, 0x48e34(%rip)     # 0x4e8c0
movl $0x20, 0x8e0a(%rip)     # 0xe8a0
movl $0x20, 0x8dfc(%rip)     # 0xe89c
leaq 0x90c(%rip), %rdi       # 0x63b3
leaq 0x991(%rip), %rsi       # 0x643f
callq 0x2640
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5ad7
movq -0x8(%rbp), %rsi
leaq 0x8db7(%rip), %rdi      # 0xe880
callq 0x5600
movq -0x8(%rbp), %rdi
callq 0x20d0
leaq 0x8dd(%rip), %rdi       # 0x63bb
leaq 0x95a(%rip), %rsi       # 0x643f
callq 0x2320
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5b07
movq -0x8(%rbp), %rdi
callq 0x5740
movq -0x8(%rbp), %rdi
callq 0x20d0
leaq 0x8b5(%rip), %rdi       # 0x63c3
movl $0xd48, %esi            # imm = 0xD48
callq 0x3b40
movl %eax, 0x48db2(%rip)     # 0x4e8d0
movl $0x8, %edi
movl $0x1, %esi
callq 0x4420
movq %rax, 0x48e14(%rip)     # 0x4e948
leaq -0xa7b(%rip), %rdi      # 0x50c0
leaq 0x8d3e(%rip), %rsi      # 0xe880
callq 0x4130
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conq1.c
// Function: any_bc
boolean any_bc(tteam team, int starnum)
{
    boolean any;
    int tf_number;
    any = false;
    if (tf_stars[starnum][team] > 0) {
        tf_number = 1;
        while ((!any) && (tf_number < 27)) {
            any = (tf[team][tf_number].dest == starnum) &&
                (tf[team][tf_number].eta == 0) &&
                ((tf[team][tf_number].c > 0) ||
                 (tf[team][tf_number].b > 0));
            tf_number = tf_number + 1;
        };
    };
    return (any);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x109c4(%rip), %rax     # 0x12c30
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x237b
movl $0x1, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
jne 0x229d
cmpl $0x1b, -0x10(%rbp)
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x22a9
jmp 0x2379
movslq -0x4(%rbp), %rcx
leaq 0x116ec(%rip), %rax     # 0x139a0
imulq $0x57c, %rcx, %rcx      # imm = 0x57C
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x12(%rbp)
jne 0x2360
movslq -0x4(%rbp), %rax
leaq 0x116bb(%rip), %rcx     # 0x139a0
imulq $0x57c, %rax, %rax      # imm = 0x57C
addq %rax, %rcx
movslq -0x10(%rbp), %rax
imulq $0x34, %rax, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpl $0x0, 0x24(%rcx)
movb %al, -0x12(%rbp)
jne 0x2360
movslq -0x4(%rbp), %rax
leaq 0x11690(%rip), %rcx     # 0x139a0
imulq $0x57c, %rax, %rax      # imm = 0x57C
addq %rax, %rcx
movslq -0x10(%rbp), %rax
imulq $0x34, %rax, %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0x0, 0x18(%rcx)
movb %al, -0x13(%rbp)
jg 0x235a
movslq -0x4(%rbp), %rcx
leaq 0x11665(%rip), %rax     # 0x139a0
imulq $0x57c, %rcx, %rcx      # imm = 0x57C
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x1c(%rax)
setg %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2288
jmp 0x237b
movl -0xc(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conq1.c
// Function: best_plan
void best_plan(int *St9rnum, int *S9ze, tteam *T9am)
{
    tplanet *pplanet;
    int starnum, size;
    tteam team;
    team = none;
    starnum = *St9rnum;
    size = 0;
    pplanet = stars[starnum].first_planet;
    while (pplanet != nil) {
        if (pplanet->capacity > size) {
            size = pplanet->capacity;
            team = pplanet->team;
        };
        pplanet = pplanet->next;
    };
    *T9am = team;
    *St9rnum = starnum;
    *S9ze = size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x2, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x120ee(%rip), %rax     # 0x144a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x23f6
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x28(%rbp), %eax
jle 0x23e8
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x23c1
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conq1.c
// Function: disp_tf
void disp_tf(struct sttf *taskf)
{
    if (taskf->t != 0)
        printw("%2dt", taskf->t);
    else
        printw("   ");
    if (taskf->s != 0)
        printw("%2ds", taskf->s);
    else
        printw("   ");
    if (taskf->c != 0)
        printw("%2dc", taskf->c);
    else
        printw("   ");
    if (taskf->b != 0)
        printw("%2db", taskf->b);
    else
        printw("   ");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x2b2d
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
leaq 0xb61b(%rip), %rdi      # 0xe13f
movb $0x0, %al
callq 0x2030
jmp 0x2b3b
leaq 0xbc0d(%rip), %rdi      # 0xe741
movb $0x0, %al
callq 0x2030
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x2b5c
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0xb5f1(%rip), %rdi      # 0xe144
movb $0x0, %al
callq 0x2030
jmp 0x2b6a
leaq 0xbbde(%rip), %rdi      # 0xe741
movb $0x0, %al
callq 0x2030
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x2b8b
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0xb5c7(%rip), %rdi      # 0xe149
movb $0x0, %al
callq 0x2030
jmp 0x2b99
leaq 0xbbaf(%rip), %rdi      # 0xe741
movb $0x0, %al
callq 0x2030
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x2bba
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
leaq 0xb59d(%rip), %rdi      # 0xe14e
movb $0x0, %al
callq 0x2030
jmp 0x2bc8
leaq 0xbb80(%rip), %rdi      # 0xe741
movb $0x0, %al
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conq2.c
// Function: joinsilent
void joinsilent(tteam team, struct sttf *parent, struct sttf *child)
{
    parent->t = parent->t + child->t;
    parent->s = parent->s + child->s;
    parent->c = parent->c + child->c;
    parent->b = parent->b + child->b;
    if ((parent->dest != 0) && (child->dest != 0))
        tf_stars[parent->dest][team]--;
    child->dest = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x18(%rbp), %rax
addl 0x14(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
addl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x18(%rbp), %rax
addl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x18(%rbp), %rax
addl 0x1c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x31ca
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x31ca
movq -0x10(%rbp), %rax
movslq 0x20(%rax), %rcx
leaq 0xfa7a(%rip), %rax      # 0x12c30
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conq2.c
// Function: lose
void lose(int *Ship9s, boolean *L0se_none, char typ, float percent)
{
    int i, sleft;
    int ships;
    boolean lose_none;
    ships = *Ship9s;
    lose_none = *L0se_none;
    if (ships > 0) {
        sleft = ships;
        for (i = 1; i <= ships; i++) {
            if (((float) (rand() & 0x7fff) / (float) (0x7fff)) > percent) {
                lose_none = false;
                sleft = sleft - 1;
            };
        };
        if (sleft < ships) {
            printw(" %2d%c", ships - sleft, typ);
            ships = sleft;
        };
    };
    *Ship9s = ships;
    *L0se_none = lose_none;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x328c
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0x3264
callq 0x2100
andl $0x7fff, %eax           # imm = 0x7FFF
cvtsi2ss %eax, %xmm0
movss 0xaf2b(%rip), %xmm1     # 0xe168
divss %xmm1, %xmm0
ucomiss -0x18(%rbp), %xmm0
jbe 0x3257
movl $0x0, -0x28(%rbp)
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3259
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x321f
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x328a
movl -0x24(%rbp), %esi
subl -0x20(%rbp), %esi
movsbl -0x11(%rbp), %edx
leaq 0xaeef(%rip), %rdi      # 0xe16c
movb $0x0, %al
callq 0x2030
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x328c
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conq3.c
// Function: new_research
void new_research(void)
{
    if (weapons[player] - weapons[ENEMY] > 1)
        en_research = 'W';
    else {
        switch (rnd(10)) {

        case 1:
        case 2:
        case 3:
            en_research = 'V';
            break;
        default:
            en_research = 'W';
            break;
        case 10:
            en_research = 'R';

        };                      /*switch ( */
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x11409(%rip), %rax     # 0x146c8
movl 0x4(%rax), %eax
leaq 0x113ff(%rip), %rcx     # 0x146c8
subl (%rcx), %eax
cmpl $0x1, %eax
jle 0x32dc
leaq 0xfab9(%rip), %rax      # 0x12d90
movb $0x57, (%rax)
jmp 0x3324
movl $0xa, %edi
callq 0x6a70
movl %eax, %ecx
movl %ecx, %eax
decl %eax
movl %ecx, -0x4(%rbp)
subl $0x3, %eax
jb 0x3300
jmp 0x32f6
movl -0x4(%rbp), %eax
subl $0xa, %eax
je 0x3318
jmp 0x330c
leaq 0xfa89(%rip), %rax      # 0x12d90
movb $0x56, (%rax)
jmp 0x3322
leaq 0xfa7d(%rip), %rax      # 0x12d90
movb $0x57, (%rax)
jmp 0x3322
leaq 0xfa71(%rip), %rax      # 0x12d90
movb $0x52, (%rax)
jmp 0x3324
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conq4.c
// Function: update_board
void update_board(int x, int y, toption option)
{
    int scren_x, screen_y;
    scren_x = 3 * x + 1;
    screen_y = 16 - y;
    switch (option) {
    case left:
        point(scren_x, screen_y);
        addch(board[x][y].enemy);
        break;

    case right:
        point(scren_x + 2, screen_y);
        addch(board[x][y].tf);
        break;

    case both:
        point(scren_x, screen_y);
        printw("%c%c%c", board[x][y].enemy, board[x][y].star,
               board[x][y].tf);
        break;
    };                          /*switch ( */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, %eax
leal 0x1(%rax,%rax,2), %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %ecx
movl $0x10, %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x3582
jmp 0x3526
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x3541
jmp 0x3530
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x35c7
jmp 0x3648
movl -0x10(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x69f0
movq 0xea9d(%rip), %rax      # 0x11ff0
movq (%rax), %rdi
movslq -0x4(%rbp), %rcx
leaq 0xf83f(%rip), %rax      # 0x12da0
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
callq 0x20a0
jmp 0x3648
movl -0x10(%rbp), %edi
addl $0x2, %edi
movl -0x14(%rbp), %esi
callq 0x69f0
movq 0xea59(%rip), %rax      # 0x11ff0
movq (%rax), %rdi
movslq -0x4(%rbp), %rcx
leaq 0xf7fb(%rip), %rax      # 0x12da0
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
callq 0x20a0
jmp 0x3648
movl -0x10(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x69f0
movslq -0x4(%rbp), %rcx
leaq 0xf7c3(%rip), %rax      # 0x12da0
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
movslq -0x4(%rbp), %rcx
leaq 0xf7a1(%rip), %rax      # 0x12da0
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edx
movslq -0x4(%rbp), %rcx
leaq 0xf77e(%rip), %rax      # 0x12da0
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
leaq 0xad87(%rip), %rdi      # 0xe3c8
movb $0x0, %al
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/beejjorgensen[P]conquest/conq4.c
// Function: withdraw
void withdraw(int starnum, int plnum)
{
    int withnum;
    boolean error;
    printw("ithdraw ");
    cle3r_left();
    point(1, 19);
    split_tf(&plnum, &withnum);
    if (tf[player][withnum].dest != 0) {
        point(1, 20);
        set_des(withnum, &error);
        if (error) {
            tf[player][plnum].dest = starnum;
            joinsilent(player, &tf[player][plnum], &tf[player][withnum]);
            tf_stars[starnum][player] = 1;
        } else
            tf[player][withnum].withdrew = true;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0xa2ea(%rip), %rdi      # 0xe45f
movb $0x0, %al
callq 0x2030
callq 0xa720
movl $0x1, %edi
movl $0x13, %esi
callq 0x69f0
leaq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xbb20
movslq -0xc(%rbp), %rcx
leaq 0xf7f8(%rip), %rax      # 0x139a0
addq $0x57c, %rax            # imm = 0x57C
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
je 0x4270
movl $0x1, %edi
movl $0x14, %esi
callq 0x69f0
movl -0xc(%rbp), %edi
leaq -0x10(%rbp), %rsi
callq 0x9f40
cmpl $0x0, -0x10(%rbp)
je 0x424f
movl -0x4(%rbp), %ecx
movslq -0x8(%rbp), %rdx
leaq 0xf7b2(%rip), %rax      # 0x139a0
addq $0x57c, %rax            # imm = 0x57C
imulq $0x34, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x20(%rax)
movslq -0x8(%rbp), %rax
leaq 0xf797(%rip), %rsi      # 0x139a0
addq $0x57c, %rsi            # imm = 0x57C
imulq $0x34, %rax, %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rax
leaq 0xf77e(%rip), %rdx      # 0x139a0
addq $0x57c, %rdx            # imm = 0x57C
imulq $0x34, %rax, %rax
addq %rax, %rdx
movl $0x1, %edi
callq 0x3130
movslq -0x4(%rbp), %rcx
leaq 0xe9eb(%rip), %rax      # 0x12c30
movl $0x1, 0x4(%rax,%rcx,8)
jmp 0x426e
movslq -0xc(%rbp), %rcx
leaq 0xf746(%rip), %rax      # 0x139a0
addq $0x57c, %rax            # imm = 0x57C
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x30(%rax)
jmp 0x4270
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movl $0x27, %edi
movl $0x12, %esi
callq 0x69f0
leaq 0x1020a(%rip), %rax     # 0x14794
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x101fe(%rip), %rax     # 0x14794
movl %ecx, (%rax)
leaq 0x101f5(%rip), %rax     # 0x14794
movl (%rax), %esi
leaq 0xa3b0(%rip), %rdi      # 0xe958
movb $0x0, %al
callq 0x2030
movl $0x30, %edi
movl $0x13, %esi
callq 0x69f0
leaq 0x101d3(%rip), %rax     # 0x14798
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x101c7(%rip), %rax     # 0x14798
movl %ecx, (%rax)
leaq 0x101be(%rip), %rax     # 0x14798
movl (%rax), %esi
leaq 0xa388(%rip), %rdi      # 0xe96b
movb $0x0, %al
callq 0x2030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
cmpl $0x15, -0x8(%rbp)
jg 0x46ee
movslq -0x8(%rbp), %rcx
leaq 0xe615(%rip), %rax      # 0x12c30
cmpl $0x0, (%rax,%rcx,8)
jle 0x4686
movslq -0x8(%rbp), %rcx
leaq 0xe604(%rip), %rax      # 0x12c30
cmpl $0x0, 0x4(%rax,%rcx,8)
jle 0x4686
movl -0x8(%rbp), %esi
xorl %edi, %edi
callq 0x2250
cmpl $0x0, %eax
jne 0x4654
movl -0x8(%rbp), %esi
movl $0x1, %edi
callq 0x2250
cmpl $0x0, %eax
je 0x4686
cmpl $0x0, -0x4(%rbp)
je 0x467e
movl $0x21, %edi
movl $0x14, %esi
callq 0x69f0
leaq 0x9df8(%rip), %rdi      # 0xe468
movb $0x0, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x8(%rbp), %edi
callq 0x3650
movl -0x8(%rbp), %esi
xorl %edi, %edi
callq 0x2250
cmpl $0x0, %eax
je 0x46b1
movslq -0x8(%rbp), %rcx
leaq 0xe640(%rip), %rax      # 0x12ce0
cmpl $0x0, 0x4(%rax,%rcx,8)
jle 0x46b1
movl -0x8(%rbp), %edi
callq 0x2bd0
jmp 0x46de
movslq -0x8(%rbp), %rcx
leaq 0xe574(%rip), %rax      # 0x12c30
cmpl $0x0, 0x4(%rax,%rcx,8)
jle 0x46dc
movslq -0x8(%rbp), %rcx
leaq 0xe612(%rip), %rax      # 0x12ce0
cmpl $0x0, (%rax,%rcx,8)
jle 0x46dc
movl -0x8(%rbp), %edi
callq 0x3330
jmp 0x46de
jmp 0x46e0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4606
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x4739
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x4747
movl -0xc(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x4769
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x4776
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
subl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x47a6
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x47b2
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
shll %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jg 0x4891
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x2, 0xc(%rax)
je 0x488f
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
leaq 0xe4c0(%rip), %rax      # 0x12ce0
shlq $0x3, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movslq 0xc(%rcx), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl $0x2, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
leaq 0xfc38(%rip), %rax      # 0x144a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
leaq 0xfc20(%rip), %rax      # 0x144a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %esi
callq 0xaa50
jmp 0x4891
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x91ab(%rip), %rdi      # 0xe62a
movb $0x0, %al
callq 0x2030
callq 0xa720
movl $0x1, %edi
movl $0x13, %esi
callq 0x69f0
movq 0xcb4f(%rip), %rax      # 0x11ff0
movq (%rax), %rdi
movl $0x3a, %esi
callq 0x20a0
leaq -0x60(%rbp), %rdi
leaq -0x64(%rbp), %rsi
movl $0x1, %edx
callq 0xa4b0
leaq -0x60(%rbp), %rdi
leaq -0x64(%rbp), %rsi
leaq -0x6c(%rbp), %rdx
leaq -0x6d(%rbp), %rcx
callq 0xa7e0
movl $0x32, %edi
movl $0x1, %esi
callq 0x69f0
movsbl -0x6d(%rbp), %eax
cmpl $0x20, %eax
jne 0x550f
movl $0x1, -0x68(%rbp)
cmpl $0x15, -0x68(%rbp)
jg 0x550d
movl -0x68(%rbp), %edi
callq 0xaeb0
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x54f4
jmp 0x5546
jmp 0x5511
movsbl -0x6d(%rbp), %eax
subl $0x41, %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %edi
callq 0xaeb0
leaq -0x60(%rbp), %rdi
leaq -0x64(%rbp), %rsi
leaq -0x6c(%rbp), %rdx
leaq -0x6d(%rbp), %rcx
callq 0xa7e0
movsbl -0x6d(%rbp), %eax
cmpl $0x20, %eax
jne 0x5511
jmp 0x5546
callq 0xa6a0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x90c8(%rip), %rdi      # 0xe637
movb $0x0, %al
callq 0x2030
leaq -0x60(%rbp), %rdi
leaq -0x64(%rbp), %rsi
movl $0x1, %edx
callq 0xa4b0
leaq -0x60(%rbp), %rdi
leaq -0x64(%rbp), %rsi
leaq -0x8(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0xa7e0
movl $0x32, %edi
movl $0x1, %esi
callq 0x69f0
movsbl -0x9(%rbp), %eax
cmpl $0x20, %eax
jne 0x55d7
movl $0x1, -0x4(%rbp)
cmpl $0x1a, -0x4(%rbp)
jg 0x55d5
movl -0x4(%rbp), %edi
callq 0xaca0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x55bc
jmp 0x560e
jmp 0x55d9
movsbl -0x9(%rbp), %eax
subl $0x41, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xaca0
leaq -0x60(%rbp), %rdi
leaq -0x64(%rbp), %rsi
leaq -0x8(%rbp), %rdx
leaq -0x9(%rbp), %rcx
callq 0xa7e0
movsbl -0x9(%rbp), %eax
cmpl $0x20, %eax
jne 0x55d9
jmp 0x560e
callq 0xa6a0
callq 0xa720
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0xc5f1(%rip), %rax      # 0x12d90
movb $0x56, (%rax)
leaq 0xd1f7(%rip), %rax      # 0x139a0
movl $0x1, 0x4c(%rax)
leaq 0xd1e9(%rip), %rax      # 0x139a0
movl $0x2, 0x44(%rax)
movl $0x2, -0x4(%rbp)
leaq 0xc5c4(%rip), %rax      # 0x12d90
movb (%rax), %al
movl -0x4(%rbp), %edx
xorl %edi, %edi
movsbl %al, %esi
callq 0xb670
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
cmpl $0x15, -0x10(%rbp)
jg 0x6837
movl -0x10(%rbp), %edi
leaq -0x70(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0xa5f0
movl $0x5, %edi
callq 0x6a70
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x682a
movl -0x14(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x682c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x67f0
movl -0xc(%rbp), %ecx
leaq 0xd15f(%rip), %rax      # 0x139a0
movl %ecx, 0x54(%rax)
movslq -0xc(%rbp), %rcx
leaq 0xdc51(%rip), %rax      # 0x144a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
leaq 0xd141(%rip), %rax      # 0x139a0
movl %ecx, 0x34(%rax)
movslq -0xc(%rbp), %rcx
leaq 0xdc33(%rip), %rax      # 0x144a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
leaq 0xd122(%rip), %rax      # 0x139a0
movl %ecx, 0x38(%rax)
movslq -0xc(%rbp), %rcx
leaq 0xdc14(%rip), %rax      # 0x144a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x10(%rax)
movslq -0xc(%rbp), %rcx
leaq 0xc38b(%rip), %rax      # 0x12c30
movl $0x1, (%rax,%rcx,8)
movl $0x32, %edi
movl $0x1, %esi
callq 0x69f0
leaq 0xd0de(%rip), %rax      # 0x139a0
movl 0x5d0(%rax), %edi
callq 0xaeb0
callq 0xa6a0
movl -0xc(%rbp), %eax
leaq 0xd0c4(%rip), %rcx      # 0x139a0
cmpl 0x5d0(%rcx), %eax
jne 0x68ee
callq 0xa720
callq 0x45f0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x20f0
leaq 0x7f0d(%rip), %rdi      # 0xe878
movb $0x0, %al
callq 0x2030
callq 0x5e50
callq 0x6790
callq 0x9e20
leaq 0xdf30(%rip), %rax      # 0x148b8
cmpl $0x0, (%rax)
jne 0x69be
callq 0x6fb0
callq 0x7ae0
callq 0x45f0
leaq 0xddf5(%rip), %rax      # 0x14798
cmpl $0x4, (%rax)
jne 0x69b9
leaq 0xdde5(%rip), %rax      # 0x14794
cmpl $0x64, (%rax)
jge 0x69b9
callq 0xd2a0
callq 0x4570
callq 0x2420
leaq 0xdeee(%rip), %rax      # 0x148b8
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x697c
callq 0x20c0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0xb5eb(%rip), %rax      # 0x11ff0
movq (%rax), %rdi
movl -0x8(%rbp), %esi
subl $0x1, %esi
movl -0x4(%rbp), %edx
subl $0x1, %edx
callq 0x20b0
movl -0x4(%rbp), %ecx
leaq 0xde9d(%rip), %rax      # 0x148c0
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
leaq 0xde95(%rip), %rax      # 0x148c4
movl %ecx, (%rax)
leaq 0xde88(%rip), %rax      # 0x148c0
cmpl $0x14, (%rax)
jge 0x6a61
leaq 0xde80(%rip), %rax      # 0x148c4
cmpl $0x12, (%rax)
je 0x6a61
leaq 0xde74(%rip), %rax      # 0x148c4
movslq (%rax), %rcx
leaq 0xde76(%rip), %rax      # 0x148d0
movl $0x1, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
leaq 0xd715(%rip), %rax      # 0x144a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x10(%rax)
jne 0x6da4
movl $0x258, -0xc(%rbp)      # imm = 0x258
jmp 0x6e91
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x6ddc
jmp 0x6db4
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x6e56
jmp 0x6dc2
movl -0x10(%rbp), %eax
subl $0x2, %eax
jne 0x6e72
jmp 0x6dd0
movl $0x64, -0xc(%rbp)
jmp 0x6e72
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x6def
movl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
jmp 0x6e3f
movq -0x8(%rbp), %rax
imull $0x6, 0x1c(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x18(%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl $0xf, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jg 0x6e36
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x6e2d
movq -0x8(%rbp), %rax
cmpl $0x8, 0x14(%rax)
jl 0x6e36
movl $0x12c, -0xc(%rbp)      # imm = 0x12C
jmp 0x6e3d
movl $0x0, -0xc(%rbp)
jmp 0x6e3f
movq -0x8(%rbp), %rax
cmpl $0x4, 0x1c(%rax)
jl 0x6e54
movl -0xc(%rbp), %eax
subl $0xfa, %eax
movl %eax, -0xc(%rbp)
jmp 0x6e72
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x6e69
movl $0x190, -0xc(%rbp)      # imm = 0x190
jmp 0x6e70
movl $0xc8, -0xc(%rbp)
jmp 0x6e72
movq -0x8(%rbp), %rax
cmpl $0x28, 0x4(%rax)
jge 0x6e8f
movq -0x8(%rbp), %rax
cmpl $0xf, 0x14(%rax)
jge 0x6e8f
movl -0xc(%rbp), %eax
subl $0x64, %eax
movl %eax, -0xc(%rbp)
jmp 0x6e91
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x14, %edi
callq 0x6a70
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rcx
leaq 0xd5c4(%rip), %rax      # 0x144a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x10(%rax)
jne 0x6ef5
movl $0x3c, -0x10(%rbp)
jmp 0x6f79
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x6f22
jmp 0x6f05
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x6f2b
jmp 0x6f0f
movl -0x14(%rbp), %eax
subl $0x2, %eax
jne 0x6f32
jmp 0x6f19
movl $0x28, -0x10(%rbp)
jmp 0x6f32
movl $0x1e, -0x10(%rbp)
jmp 0x6f32
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x28(%rax)
je 0x6f77
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x10(%rcx), %eax
movl %eax, -0x18(%rbp)
leaq 0xd840(%rip), %rax      # 0x14794
movl (%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
movl -0x18(%rbp), %eax
movl $0x28, %ecx
subl %edx, %ecx
cmpl %ecx, %eax
jle 0x6f77
movl -0x10(%rbp), %eax
addl $0x28, %eax
movl %eax, -0x10(%rbp)
jmp 0x6f79
movss 0x70ab(%rip), %xmm0     # 0xe02c
mulss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x7336(%rip), %xmm1     # 0xe2c8
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl -0x10(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x1, -0x8(%rbp)
cmpl $0x1a, -0x8(%rbp)
jg 0x7094
movslq -0x8(%rbp), %rcx
leaq 0xc9cc(%rip), %rax      # 0x139a0
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x24(%rax)
jne 0x7084
movslq -0x8(%rbp), %rcx
leaq 0xc9b0(%rip), %rax      # 0x139a0
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
je 0x7084
movslq -0x8(%rbp), %rcx
leaq 0xc994(%rip), %rax      # 0x139a0
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq -0x70(%rbp), %rsi
leaq -0x4(%rbp), %rdx
callq 0xa5f0
leaq -0x70(%rbp), %rdi
movslq -0x8(%rbp), %rax
leaq 0xc968(%rip), %rsi      # 0x139a0
imulq $0x34, %rax, %rax
addq %rax, %rsi
callq 0x70a0
leaq -0x70(%rbp), %rdi
movslq -0x8(%rbp), %rax
leaq 0xc94d(%rip), %rsi      # 0x139a0
imulq $0x34, %rax, %rax
addq %rax, %rsi
callq 0x7320
movslq -0x8(%rbp), %rax
leaq 0xc936(%rip), %rdi      # 0x139a0
imulq $0x34, %rax, %rax
addq %rax, %rdi
leaq -0x70(%rbp), %rsi
callq 0x76c0
movl -0x8(%rbp), %esi
xorl %edi, %edi
callq 0x4280
jmp 0x7086
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6fbf
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xcad3(%rip), %rax      # 0x144a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x15(%rbp)
je 0x79f4
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x79fd
jmp 0x7a59
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x7a4b
movq -0x10(%rbp), %rax
cmpl $0xa, 0x14(%rax)
jle 0x7a4b
movq -0x10(%rbp), %rax
imull $0x6, 0x1c(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x18(%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl $0xf, %ecx
cltd
idivl %ecx
cvtsi2ss %eax, %xmm0
callq 0x6ab0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x7a4b
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x79dc
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x501b(%rip), %rdi      # 0xec6a
movb $0x0, %al
callq 0x2030
leaq -0x1(%rbp), %rdi
callq 0xa480
callq 0xa720
movl $0x1, %edi
movl $0x13, %esi
callq 0x69f0
movsbl -0x1(%rbp), %eax
subl $0x41, %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jl 0x9c8c
cmpl $0x1a, -0x8(%rbp)
jle 0x9ca4
callq 0xa7c0
leaq 0x4ec5(%rip), %rdi      # 0xeb5d
movb $0x0, %al
callq 0x2030
jmp 0x9dc8
movslq -0x8(%rbp), %rcx
leaq 0x9cf1(%rip), %rax      # 0x139a0
addq $0x57c, %rax            # imm = 0x57C
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
jne 0x9cda
callq 0xa7c0
leaq 0x4e9d(%rip), %rdi      # 0xeb6b
movb $0x0, %al
callq 0x2030
jmp 0x9dc6
movslq -0x8(%rbp), %rcx
leaq 0x9cbb(%rip), %rax      # 0x139a0
addq $0x57c, %rax            # imm = 0x57C
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x24(%rax)
je 0x9d64
movslq -0x8(%rbp), %rcx
leaq 0x9c9d(%rip), %rax      # 0x139a0
addq $0x57c, %rax            # imm = 0x57C
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
movl 0x24(%rax), %eax
movslq -0x8(%rbp), %rdx
leaq 0x9c82(%rip), %rcx      # 0x139a0
addq $0x57c, %rcx            # imm = 0x57C
imulq $0x34, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x28(%rcx), %eax
jne 0x9d4f
movslq -0x8(%rbp), %rcx
leaq 0x9c64(%rip), %rax      # 0x139a0
addq $0x57c, %rax            # imm = 0x57C
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x30(%rax)
je 0x9d64
callq 0xa7c0
leaq 0x4f1e(%rip), %rdi      # 0xec79
movb $0x0, %al
callq 0x2030
jmp 0x9dc4
movslq -0x8(%rbp), %rcx
leaq 0x9c31(%rip), %rax      # 0x139a0
addq $0x57c, %rax            # imm = 0x57C
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x2c(%rax)
je 0x9d97
callq 0xa7c0
leaq 0x4f09(%rip), %rdi      # 0xec97
movb $0x0, %al
callq 0x2030
jmp 0x9dc2
movslq -0x8(%rbp), %rcx
leaq 0x9bfe(%rip), %rax      # 0x139a0
addq $0x57c, %rax            # imm = 0x57C
imulq $0x34, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x30(%rax)
movl -0x8(%rbp), %edi
leaq -0xc(%rbp), %rsi
callq 0x9f40
jmp 0x9dc4
jmp 0x9dc6
jmp 0x9dc8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xa790
leaq 0x4ecd(%rip), %rdi      # 0xecb1
movb $0x0, %al
callq 0x2030
leaq -0x1(%rbp), %rdi
callq 0xa480
movsbl -0x1(%rbp), %eax
cmpl $0x59, %eax
je 0x9e04
callq 0x8b40
jmp 0x9e11
leaq 0xaaad(%rip), %rax      # 0x148b8
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x21, %edi
movl $0x14, %esi
callq 0x69f0
leaq 0x4e8a(%rip), %rdi      # 0xecc8
movb $0x0, %al
callq 0x2030
movl $0x0, -0x8(%rbp)
movl $0x1, %edi
movl $0x12, %esi
movl %esi, -0x14(%rbp)
callq 0x69f0
leaq 0x4e74(%rip), %rdi      # 0xecd9
xorl %eax, %eax
callq 0x2030
movl -0x14(%rbp), %esi
movl $0x2, %edi
callq 0x69f0
leaq -0x1(%rbp), %rdi
callq 0xa480
movsbl -0x1(%rbp), %eax
addl $-0x20, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x34, %eax
ja 0x9f13
movq -0x10(%rbp), %rax
leaq 0x4ad1(%rip), %rcx      # 0xe970
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x8b40
jmp 0x9f26
callq 0x8d90
jmp 0x9f26
movl $0x1, -0x8(%rbp)
jmp 0x9f26
movl $0x1, %edi
callq 0xa970
jmp 0x9f26
callq 0x9490
jmp 0x9f26
callq 0x9c40
jmp 0x9f26
callq 0x5470
jmp 0x9f26
callq 0xb9c0
jmp 0x9f26
callq 0xc110
jmp 0x9f26
callq 0x5170
jmp 0x9f26
callq 0xb5d0
jmp 0x9f26
movl $0x1, -0x8(%rbp)
callq 0x9dd0
jmp 0x9f26
jmp 0x9f26
callq 0x5560
jmp 0x9f26
callq 0xa7c0
leaq 0x4dd9(%rip), %rdi      # 0xecf8
movb $0x0, %al
callq 0x2030
jmp 0x9f28
cmpl $0x0, -0x8(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9e4c
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x7bbd(%rip), %rax      # 0x11ff0
movq (%rax), %rdi
callq 0x2120
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0xd, %eax
je 0xa450
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0xa454
movb $0xa, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x7f, %eax
jne 0xa461
movb $0x8, -0x9(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x2070
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)