LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_bs_read_1
static int smk_bs_read_1(struct smk_bit_t * const bs)
{
	int ret;
	/* null check */
	assert(bs);

	/* don't die when running out of bits, but signal */
	if (bs->buffer >= bs->end) {
		fputs("libsmacker::smk_bs_read_1(): ERROR: bitstream exhausted.\n", stderr);
		return -1;
	}

	/* get next bit and store for return */
	ret = (*bs->buffer >> bs->bit_num) & 1;

	/* advance to next bit */
	if (bs->bit_num >= 7) {
		/* Out of bits in this byte: next! */
		bs->buffer ++;
		bs->bit_num = 0;
	} else
		bs->bit_num ++;

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x47bd5
jmp 0x47bf4
leaq 0xa78fe(%rip), %rdi     # 0xef4da
leaq 0xa56e0(%rip), %rsi     # 0xed2c3
movl $0x33, %edx
leaq 0xa69c9(%rip), %rcx     # 0xee5b8
callq 0x8230
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x47c24
movq 0xd13cc(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa69cd(%rip), %rdi     # 0xee5e3
callq 0x8430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x47c75
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
sarl %cl, %eax
andl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x7, 0x10(%rax)
jb 0x47c62
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x47c6f
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_huff8_build
static int smk_huff8_build(struct smk_huff8_t * const t, struct smk_bit_t * const bs)
{
	int bit;
	/* null check */
	assert(t);
	assert(bs);

	/* Smacker huff trees begin with a set-bit. */
	if ((bit = smk_bs_read_1(bs)) < 0) {
		fputs("libsmacker::smk_huff8_build() - ERROR: initial get_bit returned -1\n", stderr);
		return 0;
	}

	/* OK to fill out the struct now */
	t->size = 0;

	/* First bit indicates whether a tree is present or not. */
	/*  Very small or audio-only files may have no tree. */
	if (bit) {
		if (! _smk_huff8_build_rec(t, bs)) {
			fputs("libsmacker::smk_huff8_build() - ERROR: tree build failed\n", stderr);
			return 0;
		}
	} else
		t->tree[0] = 0;

	/* huff trees end with an unset-bit */
	if ((bit = smk_bs_read_1(bs)) < 0) {
		fputs("libsmacker::smk_huff8_build() - ERROR: final get_bit returned -1\n", stderr);
		return 0;
	}

	/* a 0 is expected here, a 1 generally indicates a problem! */
	if (bit) {
		fputs("libsmacker::smk_huff8_build() - ERROR: final get_bit returned 1\n", stderr);
		return 0;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x47c99
jmp 0x47cb8
leaq 0x93015(%rip), %rdi     # 0xdacb5
leaq 0xa561c(%rip), %rsi     # 0xed2c3
movl $0xb3, %edx
leaq 0xa696a(%rip), %rcx     # 0xee61d
callq 0x8230
cmpq $0x0, -0x18(%rbp)
je 0x47cc1
jmp 0x47ce0
leaq 0xa7812(%rip), %rdi     # 0xef4da
leaq 0xa55f4(%rip), %rsi     # 0xed2c3
movl $0xb4, %edx
leaq 0xa6942(%rip), %rcx     # 0xee61d
callq 0x8230
movq -0x18(%rbp), %rdi
callq 0x47bc0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x47d13
movq 0xd12e0(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6963(%rip), %rdi     # 0xee665
callq 0x8430
movl $0x0, -0x4(%rbp)
jmp 0x47dbd
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x47d57
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x48220
cmpl $0x0, %eax
jne 0x47d55
movq 0xd129b(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6962(%rip), %rdi     # 0xee6a9
callq 0x8430
movl $0x0, -0x4(%rbp)
jmp 0x47dbd
jmp 0x47d61
movq -0x10(%rbp), %rax
movw $0x0, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x47bc0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x47d91
movq 0xd125f(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6960(%rip), %rdi     # 0xee6e3
callq 0x8430
movl $0x0, -0x4(%rbp)
jmp 0x47dbd
cmpl $0x0, -0x1c(%rbp)
je 0x47db6
movq 0xd123a(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa697d(%rip), %rdi     # 0xee725
callq 0x8430
movl $0x0, -0x4(%rbp)
jmp 0x47dbd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_bs_read_8
static int smk_bs_read_8(struct smk_bit_t * const bs)
{
	/* null check */
	assert(bs);

	/* don't die when running out of bits, but signal */
	if (bs->buffer + (bs->bit_num > 0) >= bs->end) {
		fputs("libsmacker::smk_bs_read_8(): ERROR: bitstream exhausted.\n", stderr);
		return -1;
	}

	if (bs->bit_num) {
		/* unaligned read */
		int ret = *bs->buffer >> bs->bit_num;
		bs->buffer ++;
		return ret | (*bs->buffer << (8 - bs->bit_num) & 0xFF);
	}

	/* aligned read */
	return *bs->buffer++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x47de5
jmp 0x47e04
leaq 0xa76ee(%rip), %rdi     # 0xef4da
leaq 0xa54d0(%rip), %rsi     # 0xed2c3
movl $0x4e, %edx
leaq 0xa6b09(%rip), %rcx     # 0xee908
callq 0x8230
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpl $0x0, 0x10(%rcx)
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x47e4b
movq 0xd11a5(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6af6(%rip), %rdi     # 0xee933
callq 0x8430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x47eba
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x47ea3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
sarl %cl, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movzbl (%rcx), %edx
movq -0x10(%rbp), %rsi
movl $0x8, %ecx
subl 0x10(%rsi), %ecx
shll %cl, %edx
movl %edx, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x47eba
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_huff8_lookup
static int smk_huff8_lookup(const struct smk_huff8_t * const t, struct smk_bit_t * const bs)
{
	int bit, index = 0;
	/* null check */
	assert(t);
	assert(bs);

	while (t->tree[index] & SMK_HUFF8_BRANCH) {
		if ((bit = smk_bs_read_1(bs)) < 0) {
			fputs("libsmacker::smk_huff8_lookup() - ERROR: get_bit returned -1\n", stderr);
			return -1;
		}

		if (bit) {
			/* take the right branch */
			index = t->tree[index] & SMK_HUFF8_LEAF_MASK;
		} else {
			/* take the left branch */
			index ++;
		}
	}

	/* at leaf node.  return the value at this point. */
	return t->tree[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x48410
jmp 0x4842f
leaq 0x9289e(%rip), %rdi     # 0xdacb5
leaq 0xa4ea5(%rip), %rsi     # 0xed2c3
movl $0xde, %edx
leaq 0xa6793(%rip), %rcx     # 0xeebbd
callq 0x8230
cmpq $0x0, -0x18(%rbp)
je 0x48438
jmp 0x48457
leaq 0xa709b(%rip), %rdi     # 0xef4da
leaq 0xa4e7d(%rip), %rsi     # 0xed2c3
movl $0xdf, %edx
leaq 0xa676b(%rip), %rcx     # 0xeebbd
callq 0x8230
jmp 0x48459
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzwl 0x8(%rax,%rcx,2), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x484c8
movq -0x18(%rbp), %rdi
callq 0x47bc0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x484a0
movq 0xd0b50(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa677a(%rip), %rdi     # 0xeec0c
callq 0x8430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x484d8
cmpl $0x0, -0x1c(%rbp)
je 0x484bd
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzwl 0x8(%rax,%rcx,2), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movl %eax, -0x20(%rbp)
jmp 0x484c6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x48459
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzwl 0x8(%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_huff16_lookup
static int smk_huff16_lookup(struct smk_huff16_t * const t, struct smk_bit_t * const bs)
{
	int bit, value, index = 0;
	/* null check */
	assert(t);
	assert(bs);

	while (t->tree[index] & SMK_HUFF16_BRANCH) {
		if ((bit = smk_bs_read_1(bs)) < 0) {
			fputs("libsmacker::smk_huff16_lookup() - ERROR: get_bit returned -1\n", stderr);
			return -1;
		}

		if (bit) {
			/* take the right branch */
			index = t->tree[index] & SMK_HUFF16_LEAF_MASK;
		} else {
			/* take the left branch */
			index ++;
		}
	}

	/* Get the value at this point */
	value = t->tree[index];

	if (value & SMK_HUFF16_CACHE) {
		/* uses cached value instead of actual value */
		value = t->cache[value & SMK_HUFF16_LEAF_MASK];
	}

	if (t->cache[0] != value) {
		/* Update the cache, by moving val to the front of the queue,
			if it isn't already there. */
		t->cache[2] = t->cache[1];
		t->cache[1] = t->cache[0];
		t->cache[0] = value;
	}

	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x49590
jmp 0x495af
leaq 0x9171e(%rip), %rdi     # 0xdacb5
leaq 0xa3d25(%rip), %rsi     # 0xed2c3
movl $0x1c4, %edx            # imm = 0x1C4
leaq 0xa5e23(%rip), %rcx     # 0xef3cd
callq 0x8230
cmpq $0x0, -0x18(%rbp)
je 0x495b8
jmp 0x495d7
leaq 0xa5f1b(%rip), %rdi     # 0xef4da
leaq 0xa3cfd(%rip), %rsi     # 0xed2c3
movl $0x1c5, %edx            # imm = 0x1C5
leaq 0xa5dfb(%rip), %rcx     # 0xef3cd
callq 0x8230
jmp 0x495d9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x4964d
movq -0x18(%rbp), %rdi
callq 0x47bc0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x49624
movq 0xcf9cf(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa5e05(%rip), %rdi     # 0xef418
callq 0x8430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x496c4
cmpl $0x0, -0x1c(%rbp)
je 0x49642
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, -0x24(%rbp)
jmp 0x4964b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x495d9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl $0x40000000, %eax       # imm = 0x40000000
cmpl $0x0, %eax
je 0x49683
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
movslq %ecx, %rcx
movzwl 0x10(%rax,%rcx,2), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
cmpl -0x20(%rbp), %eax
je 0x496be
movq -0x10(%rbp), %rax
movw 0x12(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x14(%rax)
movq -0x10(%rbp), %rax
movw 0x10(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x12(%rax)
movl -0x20(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x10(%rax)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/startgtk_game.c
// Function: setup_messages_mode
static void setup_messages_mode(gboolean allowcancel)
{
    gtk_notebook_set_current_page(GTK_NOTEBOOK(controls.tabs), TAB_MESSAGES);

    // Disable all the controls on the Configuration page.
    gtk_container_foreach(GTK_CONTAINER(controls.configbox),
            foreach_gtk_widget_set_sensitive, (gpointer)FALSE);
    gtk_widget_set_sensitive(controls.alwaysshowcheck, FALSE);

    gtk_widget_set_sensitive(controls.chooseimportbutton, FALSE);
    gtk_widget_set_sensitive(controls.importinfobutton, FALSE);

    gtk_widget_set_sensitive(controls.cancelbutton, allowcancel);
    gtk_widget_set_sensitive(controls.startbutton, FALSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x32e1ae(%rip), %rax    # 0x377e40
movq %rax, -0x18(%rbp)
callq 0x8ee0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
movl $0x1, %esi
callq 0x9160
movq 0x32e18d(%rip), %rax    # 0x377e48
movq %rax, -0x10(%rbp)
callq 0x8ad0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
leaq 0x11b6(%rip), %rsi      # 0x4ae90
xorl %eax, %eax
movl %eax, %edx
callq 0x8af0
movq 0x32e166(%rip), %rdi    # 0x377e50
xorl %esi, %esi
callq 0x90d0
movq 0x32e1a0(%rip), %rdi    # 0x377e98
xorl %esi, %esi
callq 0x90d0
movq 0x32e19a(%rip), %rdi    # 0x377ea0
xorl %esi, %esi
callq 0x90d0
movq 0x32e124(%rip), %rdi    # 0x377e38
movl -0x4(%rbp), %esi
callq 0x90d0
movq 0x32e10d(%rip), %rdi    # 0x377e30
xorl %esi, %esi
callq 0x90d0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/startgtk_game.c
// Function: startwin_puts
int startwin_puts(const char *str)
{
    // Called in either the main thread or the import thread via buildprintf.
    if (!gtkenabled || !str) return 0;
    if (!startwin) return 1;

    g_main_context_invoke(NULL, startwin_puts_inner, (gpointer)strdup(str));

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xc466a5(%rip), %rax    # 0xc90478
cmpl $0x0, (%rax)
je 0x49ddf
cmpq $0x0, -0x10(%rbp)
jne 0x49de8
movl $0x0, -0x4(%rbp)
jmp 0x49e1e
cmpq $0x0, 0x32e030(%rip)    # 0x377e20
jne 0x49dfb
movl $0x1, -0x4(%rbp)
jmp 0x49e1e
movq -0x10(%rbp), %rdi
callq 0x8070
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x1e(%rip), %rsi        # 0x49e30
callq 0x89b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/startgtk_game.c
// Function: startwin_run
int startwin_run(struct startwin_settings *settings)
{
    if (!gtkenabled || !startwin) return STARTWIN_RUN;

    set_settings(settings);
    setup_config_mode();
    startwinloop = TRUE;
    while (startwinloop) {
        gtk_main_iteration_do(TRUE);
    }
    setup_messages_mode(FALSE);
    set_settings(NULL);

    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xc46435(%rip), %rax    # 0xc90478
cmpl $0x0, (%rax)
je 0x4a052
cmpq $0x0, 0x32ddd0(%rip)    # 0x377e20
jne 0x4a05b
movl $0x1, -0x4(%rbp)
jmp 0x4a0a1
movq -0x10(%rbp), %rdi
callq 0x4a0b0
callq 0x4a0d0
movl $0x1, 0x32ddb9(%rip)    # 0x377e2c
cmpl $0x0, 0x32ddb2(%rip)    # 0x377e2c
je 0x4a088
movl $0x1, %edi
callq 0x8520
jmp 0x4a073
xorl %edi, %edi
callq 0x49c80
xorl %eax, %eax
movl %eax, %edi
callq 0x4a0b0
movl 0xd0f42(%rip), %eax     # 0x11afe0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/startgtk_game.c
// Function: on_importinfobutton_clicked
static void on_importinfobutton_clicked(GtkButton *button, gpointer user_data)
{
    GtkWidget *dialog;

    (void)button; (void)user_data;

    dialog = gtk_message_dialog_new(startwin, GTK_DIALOG_DESTROY_WITH_PARENT,
        GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
        "JFTekWar can scan locations of your choosing for TekWar game data");
    gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dialog),
        "Click the 'Choose a location...' button, then locate a folder to scan.\n\n"
        "Common locations to check include:\n"
        " • CD/DVD drives\n"
        " • Unzipped data from copies of the full DOS game");
    gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x32d489(%rip), %rdi    # 0x377e20
movl $0x2, %ecx
xorl %edx, %edx
leaq 0xa4ca5(%rip), %r8      # 0xef64a
movl %ecx, %esi
movb $0x0, %al
callq 0x8c90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x8cd0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
leaq 0xa4cb7(%rip), %rsi     # 0xef68c
movb $0x0, %al
callq 0x8df0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x8900
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
callq 0x8340
movq -0x18(%rbp), %rdi
callq 0x81d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/startgtk_game.c
// Function: import_thread_func
static void import_thread_func(GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable)
{
    char *filename = (char *)task_data;
    struct importdatameta meta = {
        (void *)cancellable,
        importmeta_progress,
        importmeta_cancelled
    };
    (void)source_object;
    g_task_return_int(task, ImportDataFromPath(filename, &meta));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x41(%rip), %rax        # 0x4ade0
movq %rax, -0x38(%rbp)
leaq 0x76(%rip), %rax        # 0x4ae20
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x44320
movq -0x48(%rbp), %rdi
movslq %eax, %rsi
callq 0x8c40
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/mmulti.c
// Function: issameaddress
static int issameaddress(struct sockaddr *a, struct sockaddr *b) {
	if (a->sa_family != b->sa_family) {
		// Different families.
		return 0;
	}
	if (a->sa_family == AF_INET) {
		// IPV4.
		struct sockaddr_in *a4 = (struct sockaddr_in *)a;
		struct sockaddr_in *b4 = (struct sockaddr_in *)b;
		return a4->sin_addr.s_addr == b4->sin_addr.s_addr &&
			a4->sin_port == b4->sin_port;
	}
	if (a->sa_family == AF_INET6) {
		// IPV6.
		struct sockaddr_in6 *a6 = (struct sockaddr_in6 *)a;
		struct sockaddr_in6 *b6 = (struct sockaddr_in6 *)b;
		return IN6_ARE_ADDR_EQUAL(&a6->sin6_addr, &b6->sin6_addr) &&
			a6->sin6_port == b6->sin6_port;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
je 0x8741a
movl $0x0, -0x4(%rbp)
jmp 0x8753e
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x2, %eax
jne 0x87473
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x4d(%rbp)
jne 0x87463
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %eax
movq -0x28(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x8753e
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xa, %eax
jne 0x87537
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %ecx
movq -0x48(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x4e(%rbp)
jne 0x874fc
movq -0x40(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x48(%rbp), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x4e(%rbp)
jne 0x874fc
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x48(%rbp), %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x4e(%rbp)
jne 0x874fc
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x48(%rbp), %rcx
cmpl 0xc(%rcx), %eax
sete %al
movb %al, -0x4e(%rbp)
movb -0x4e(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x4c(%rbp)
movb %al, -0x4f(%rbp)
je 0x8752a
movq -0x30(%rbp), %rax
movzwl 0x2(%rax), %eax
movq -0x38(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x4f(%rbp)
movb -0x4f(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x8753e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/mmulti.c
// Function: initmultiplayers_reset
static void initmultiplayers_reset(void)
{
	int i;

	initcrc16();
	memset(icnt0,0,sizeof(icnt0));
	memset(ocnt0,0,sizeof(ocnt0));
	memset(ocnt1,0,sizeof(ocnt1));
	memset(ipak,0,sizeof(ipak));
	//memset(opak,0,sizeof(opak)); //Don't need to init opak
	//memset(pakmem,0,sizeof(pakmem)); //Don't need to init pakmem
#if (SIMLAG > 1)
	memset(simlagcnt,0,sizeof(simlagcnt));
#endif

	lastsendtims[0] = GetTickCount();
	for(i=0;i<MAXPLAYERS;i++) {
		lastsendtims[i] = lastsendtims[0];
		lastrecvtims[i] = prevlastrecvtims[i] = 0;
		connectpoint2[i] = -1;
		playerslive[i] = 0;
	}
	connecthead = 0;
	numplayers = 1; myconnectindex = 0;

	memset(otherhost,0,sizeof(otherhost));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x89410
leaq 0x71db8c(%rip), %rdi    # 0x7a5180
xorl %esi, %esi
movl $0x40, %edx
callq 0x8410
leaq 0x725bb9(%rip), %rdi    # 0x7ad1c0
xorl %esi, %esi
movl $0x40, %edx
callq 0x8410
leaq 0x725be6(%rip), %rdi    # 0x7ad200
xorl %esi, %esi
movl $0x40, %edx
callq 0x8410
leaq 0x71db93(%rip), %rdi    # 0x7a51c0
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x8410
callq 0x88de0
movl %eax, 0x71d9fc(%rip)    # 0x7a5040
movl $0x0, -0x4(%rbp)
cmpl $0x10, -0x4(%rbp)
jge 0x876b5
movl 0x71d9e9(%rip), %edx    # 0x7a5040
movslq -0x4(%rbp), %rcx
leaq 0x71d9de(%rip), %rax    # 0x7a5040
movl %edx, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x71d980(%rip), %rax    # 0x7a4ff0
movl $0x0, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x71d92e(%rip), %rax    # 0x7a4fb0
movl $0x0, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x71d8cc(%rip), %rax    # 0x7a4f60
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movslq -0x4(%rbp), %rcx
leaq 0x71d98a(%rip), %rax    # 0x7a5030
movb $0x0, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8764b
movl $0x0, 0x71d891(%rip)    # 0x7a4f50
movl $0x1, 0x71d883(%rip)    # 0x7a4f4c
movl $0x0, 0x71d871(%rip)    # 0x7a4f44
leaq 0x71ce96(%rip), %rdi    # 0x7a4570
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x8410
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/mmulti.c
// Function: presentaddress
static const char *presentaddress(struct sockaddr *a) {
	static char str[128+32];
	char addr[128];
	int port;

	if (a->sa_family == AF_INET) {
		struct sockaddr_in *s = (struct sockaddr_in *)a;
		inet_ntop(AF_INET, &s->sin_addr, addr, sizeof(addr));
		port = ntohs(s->sin_port);
	} else if (a->sa_family == AF_INET6) {
		struct sockaddr_in6 *s = (struct sockaddr_in6 *)a;
		strcpy(addr, "[");
		inet_ntop(AF_INET6, &s->sin6_addr, addr+1, sizeof(addr)-2);
		strcat(addr, "]");
		port = ntohs(s->sin6_port);
	} else {
		return NULL;
	}

	strcpy(str, addr);
	sprintf(addr, ":%d", port);
	strcat(str, addr);

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x2, %eax
jne 0x87ff5
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rsi
addq $0x4, %rsi
leaq -0x90(%rbp), %rdx
movl $0x2, %edi
movl $0x80, %ecx
callq 0x82b0
movq -0xa0(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x8f90
movzwl %ax, %eax
movl %eax, -0x94(%rbp)
jmp 0x8807e
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xa, %eax
jne 0x88072
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x90(%rbp), %rdi
leaq 0x68def(%rip), %rsi     # 0xf0e09
callq 0x8550
movq -0xa8(%rbp), %rsi
addq $0x8, %rsi
leaq -0x90(%rbp), %rdx
addq $0x1, %rdx
movl $0xa, %edi
movl $0x7e, %ecx
callq 0x82b0
leaq -0x90(%rbp), %rdi
leaq 0x6df24(%rip), %rsi     # 0xf5f76
callq 0x8950
movq -0xa8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x8f90
movzwl %ax, %eax
movl %eax, -0x94(%rbp)
jmp 0x8807c
movq $0x0, -0x8(%rbp)
jmp 0x880ca
jmp 0x8807e
leaq -0x90(%rbp), %rsi
leaq 0xb2d5c4(%rip), %rdi    # 0xbb5650
callq 0x8550
leaq -0x90(%rbp), %rdi
movl -0x94(%rbp), %edx
leaq 0x68d66(%rip), %rsi     # 0xf0e0b
movb $0x0, %al
callq 0x8e50
leaq -0x90(%rbp), %rsi
leaq 0xb2d596(%rip), %rdi    # 0xbb5650
callq 0x8950
leaq 0xb2d58a(%rip), %rax    # 0xbb5650
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/mmulti.c
// Function: sendpacket
void sendpacket (int other, unsigned char *bufptr, int messleng)
{
	if (numplayers < 2) return;

	if (pakmemi+messleng+2 > (int)sizeof(pakmem)) pakmemi = 1;
	opak[other][ocnt1[other]&(FIFSIZ-1)] = pakmemi;
	*(short *)&pakmem[pakmemi] = messleng;
	memcpy(&pakmem[pakmemi+2],bufptr,messleng); pakmemi += messleng+2;
	ocnt1[other]++;

	dosendpackets(other);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x2, 0x71bcb3(%rip)    # 0x7a4f4c
jge 0x892a0
jmp 0x8935e
movl 0xa2e62(%rip), %eax     # 0x12c108
addl -0x14(%rbp), %eax
addl $0x2, %eax
cmpl $0x400000, %eax         # imm = 0x400000
jle 0x892bd
movl $0x1, 0xa2e4b(%rip)     # 0x12c108
movl 0xa2e45(%rip), %edx     # 0x12c108
movslq -0x4(%rbp), %rcx
leaq 0x723f72(%rip), %rax    # 0x7ad240
shlq $0xb, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rsi
leaq 0x723f20(%rip), %rcx    # 0x7ad200
movl (%rcx,%rsi,4), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
movw %ax, %dx
movslq 0xa2e0c(%rip), %rcx     # 0x12c108
leaq 0x72bf3d(%rip), %rax    # 0x7b5240
movw %dx, (%rax,%rcx)
movl 0xa2dfb(%rip), %eax     # 0x12c108
addl $0x2, %eax
cltq
leaq 0x72bf27(%rip), %rdi    # 0x7b5240
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x80e0
movl -0x14(%rbp), %eax
addl $0x2, %eax
addl 0xa2dd3(%rip), %eax     # 0x12c108
movl %eax, 0xa2dcd(%rip)     # 0x12c108
movslq -0x4(%rbp), %rcx
leaq 0x723eba(%rip), %rax    # 0x7ad200
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x723ead(%rip), %rax    # 0x7ad200
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edi
callq 0x88ef0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/mmulti.c
// Function: savesnatchhost
void savesnatchhost(int other)
{
	if (other == myconnectindex) return;

	memcpy(&otherhost[other], &snatchhost, sizeof(snatchhost));
	replyfrom4[other] = snatchreplyfrom4;
	replyfrom6[other] = snatchreplyfrom6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x71bbc0(%rip), %eax    # 0x7a4f44
jne 0x89388
jmp 0x893e6
movslq -0x4(%rbp), %rax
leaq 0x71b1dd(%rip), %rdi    # 0x7a4570
shlq $0x7, %rax
addq %rax, %rdi
leaq 0x71bb0f(%rip), %rsi    # 0x7a4eb0
movl $0x80, %edx
callq 0x80e0
movslq -0x4(%rbp), %rcx
leaq 0x71b9ba(%rip), %rax    # 0x7a4d70
movl 0x71bb74(%rip), %edx    # 0x7a4f30
movl %edx, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x71b9e6(%rip), %rax    # 0x7a4db0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x71bb5c(%rip), %rcx    # 0x7a4f34
movq %rcx, (%rax)
movq 0x71bb5a(%rip), %rcx    # 0x7a4f3c
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/mmulti.c
// Function: initcrc16
static void initcrc16 (void)
{
	int i, j, k, a;
	for(j=0;j<256;j++)
	{
		for(i=7,k=(j<<8),a=0;i>=0;i--,k=((k<<1)&65535))
		{
			if ((k^a)&0x8000) a = ((a<<1)&65535)^0x1021;
							 else a = ((a<<1)&65535);
		}
		crctab16[j] = (a&65535);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
cmpl $0x100, -0x8(%rbp)      # imm = 0x100
jge 0x894b5
movl $0x7, -0x4(%rbp)
movl -0x8(%rbp), %eax
shll $0x8, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x89490
movl -0xc(%rbp), %eax
xorl -0x10(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x89469
movl -0x10(%rbp), %eax
shll %eax
andl $0xffff, %eax           # imm = 0xFFFF
xorl $0x1021, %eax           # imm = 0x1021
movl %eax, -0x10(%rbp)
jmp 0x89476
movl -0x10(%rbp), %eax
shll %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
jmp 0x89478
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
shll %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0xc(%rbp)
jmp 0x8943f
movl -0x10(%rbp), %edx
andl $0xffff, %edx           # imm = 0xFFFF
movslq -0x8(%rbp), %rcx
leaq 0xb2bdac(%rip), %rax    # 0xbb5250
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x8941b
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-dissect.c
// Function: main
int main(int argc, char **argv)
{
	static struct reporter reporter = {
		.r_symdef = r_symdef,
		.r_memdef = r_memdef,
		.r_symbol = r_symbol,
		.r_member = r_member,
	};

	struct string_list *filelist = NULL;
	sparse_initialize(argc, argv, &filelist);
	dissect(&reporter, filelist);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x14410
movq -0x18(%rbp), %rsi
leaq 0x75d27(%rip), %rdi     # 0x87190
callq 0x11ae0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-dissect.c
// Function: r_symbol
static void r_symbol(unsigned mode, struct position *pos, struct symbol *sym)
{
	print_usage(pos, sym, mode);

	if (!sym->ident)
		sym->ident = built_in_ident("__asm__");

	printf("%c %c %-32.*s %s\n",
		symscope(sym), sym->kind, sym->ident->len, sym->ident->name,
		show_typename(sym->ctype.base_type));

	switch (sym->kind) {
	case 'd':
		break;
	case 's':
		if (sym->type == SYM_STRUCT || sym->type == SYM_UNION)
			break;
		goto err;
	case 't':
		break;
	case 'f':
		if (sym->type != SYM_BAD && sym->ctype.base_type->type != SYM_FN)
			goto err;
	case 'v':
		if (sym->type == SYM_NODE || sym->type == SYM_BAD)
			break;
		goto err;
	default:
		goto err;
	}

	return;
err:
	warning(*pos, "r_symbol bad sym type=%d kind=%d", sym->type, sym->kind);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x4(%rbp), %edx
callq 0x11850
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x11525
leaq 0x52b3b(%rip), %rdi     # 0x64050
callq 0x2eb00
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x11950
movsbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rcx
movsbl 0xd0(%rcx), %eax
movl %eax, -0x30(%rbp)
movq 0x18(%rcx), %rax
movq 0x60(%rcx), %rdi
movzbl 0x10(%rax), %ecx
movl %ecx, -0x2c(%rbp)
addq $0x12, %rax
movq %rax, -0x28(%rbp)
callq 0x271f0
movl -0x34(%rbp), %esi
movl -0x30(%rbp), %edx
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq %rax, %r9
leaq 0x52ae3(%rip), %rdi     # 0x64058
xorl %eax, %eax
callq 0x110f0
movq -0x18(%rbp), %rax
movsbl 0xd0(%rax), %eax
addl $-0x64, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x12, %eax
ja 0x11621
movq -0x20(%rbp), %rax
leaq 0x52a60(%rip), %rcx     # 0x64004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x11623
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x7, %eax
je 0x115cf
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x8, %eax
jne 0x115d1
jmp 0x11623
jmp 0x11625
jmp 0x11623
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x10, %eax
je 0x115fb
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x5, %eax
je 0x115fb
jmp 0x11625
jmp 0x115fd
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
je 0x1161d
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x10, %eax
jne 0x1161f
jmp 0x11623
jmp 0x11625
jmp 0x11625
jmp 0x11651
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edx
andl $0xff, %edx
movq -0x18(%rbp), %rcx
movsbl 0xd0(%rcx), %ecx
movq (%rax), %rdi
leaq 0x52a20(%rip), %rsi     # 0x6406a
movb $0x0, %al
callq 0x13e30
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-dissect.c
// Function: print_usage
static void print_usage(struct position *pos, struct symbol *sym, unsigned mode)
{
	static unsigned curr_stream = -1;
	static struct ident null;
	struct ident *ctx = &null;

	if (curr_stream != pos->stream) {
		curr_stream = pos->stream;
		printf("\nFILE: %s\n\n", stream_name(curr_stream));
	}

	if (dissect_ctx)
		ctx = dissect_ctx->ident;

	printf("%4d:%-3d %-16.*s %s ",
		pos->line, pos->pos, ctx->len, ctx->name, show_mode(mode));

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x7d11e(%rip), %rax     # 0x8e988
movq %rax, -0x20(%rbp)
movl 0x7593c(%rip), %eax     # 0x871b0
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x6, %rcx
andq $0x3fff, %rcx           # imm = 0x3FFF
cmpl %ecx, %eax
je 0x118bd
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x6, %rax
andq $0x3fff, %rax           # imm = 0x3FFF
movl %eax, 0x7590f(%rip)     # 0x871b0
movl 0x75909(%rip), %edi     # 0x871b0
callq 0x2dc20
movq %rax, %rsi
leaq 0x527d5(%rip), %rdi     # 0x6408b
movb $0x0, %al
callq 0x110f0
leaq 0x7d0ec(%rip), %rax     # 0x8e9b0
cmpq $0x0, (%rax)
je 0x118dc
leaq 0x7d0df(%rip), %rax     # 0x8e9b0
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x16, %rax
andq $0x3ff, %rax            # imm = 0x3FF
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
addq $0x12, %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x119b0
movl -0x34(%rbp), %esi
movl -0x30(%rbp), %edx
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq %rax, %r9
leaq 0x5275d(%rip), %rdi     # 0x64097
movb $0x0, %al
callq 0x110f0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-dissect.c
// Function: symscope
static char symscope(struct symbol *sym)
{
	if (sym_is_local(sym)) {
		if (!dissect_ctx)
			warning(sym->pos, "no context");
		return '.';
	}
	return ' ';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11a40
testb $0x1, %al
jne 0x1196b
jmp 0x11994
leaq 0x7d03e(%rip), %rax     # 0x8e9b0
cmpq $0x0, (%rax)
jne 0x1198e
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x5272a(%rip), %rsi     # 0x640b1
movb $0x0, %al
callq 0x13e30
movb $0x2e, -0x1(%rbp)
jmp 0x11998
movb $0x20, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-dissect.c
// Function: show_mode
static inline const char *show_mode(unsigned mode)
{
	static char str[3];

	if (mode == -1)
		return "def";

#define	U(u_r)	"-rwm"[(mode / u_r) & 3]
	str[0] = U(U_R_AOF);
	str[1] = U(U_R_VAL);
	str[2] = U(U_R_PTR);
#undef	U

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x119ca
leaq 0x53956(%rip), %rax     # 0x6531a
movq %rax, -0x8(%rbp)
jmp 0x11a2c
movl -0xc(%rbp), %eax
shrl $0x0, %eax
andl $0x3, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x526ce(%rip), %rax     # 0x640ac
movb (%rax,%rcx), %al
movb %al, 0x7cfb9(%rip)      # 0x8e9a0
movl -0xc(%rbp), %eax
shrl $0x2, %eax
andl $0x3, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x526b1(%rip), %rax     # 0x640ac
movb (%rax,%rcx), %al
movb %al, 0x7cf9d(%rip)      # 0x8e9a1
movl -0xc(%rbp), %eax
shrl $0xa, %eax
andl $0x3, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x52694(%rip), %rax     # 0x640ac
movb (%rax,%rcx), %al
movb %al, 0x7cf81(%rip)      # 0x8e9a2
leaq 0x7cf78(%rip), %rax     # 0x8e9a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/hotspot_read/main.c
// Function: hotspotread
static int
hotspotread(struct wire_requestqueue * Q, uint64_t N)
{
	struct hotspotread_state C;
	uint8_t buf[40];	/* dummy */

	/* Initialize. */
	C.Q = Q;
	C.Nip = 0;
	C.Xmax = N / 65536;
	C.X = 0;
	C.Y = 65536;
	C.failed = 0;
	C.done = 0;

	/* Allocate key structure. */
	memset(buf, 0, 40);
	if ((C.key = kvldskey_create(buf, 40)) == NULL)
		goto err0;

	/* Prepare benchmark time handling. */
	if ((C.B = bench_init(BENCHMARK_START, BENCHMARK_SECONDS)) == NULL) {
		warn0("bench_init");
		goto err1;
	}

	/* Send an initial batch of 4096 requests. */
	if (sendbatch(&C))
		goto err2;

	/* Wait until we've finished. */
	if (events_spin(&C.done) || C.failed) {
		warnp("SET request failed");
		goto err2;
	}

	/* Print median number of reads performed in a single second. */
	printf("%" PRIu64 "\n", bench_median(C.B));

	/* Free the key structure. */
	bench_free(C.B);
	kvldskey_free(C.key);

	/* Success! */
	return (0);

err2:
	bench_free(C.B);
err1:
	kvldskey_free(C.key);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x10000, -0x40(%rbp)   # imm = 0x10000
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x21a0
leaq -0x90(%rbp), %rdi
movl $0x28, %esi
callq 0x7660
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2930
jmp 0x2a14
movl $0x32, %edi
movl $0xa, %esi
callq 0x6e90
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2969
jmp 0x294b
leaq 0x1489f(%rip), %rdi     # 0x171f1
movb $0x0, %al
callq 0x6c50
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2a0b
leaq -0x60(%rbp), %rdi
callq 0x2a30
cmpl $0x0, %eax
je 0x297c
jmp 0x2a02
leaq -0x60(%rbp), %rdi
addq $0x34, %rdi
callq 0x2e90
cmpl $0x0, %eax
jne 0x2994
cmpl $0x0, -0x30(%rbp)
je 0x29cd
jmp 0x2996
callq 0x20a0
cmpl $0x0, (%rax)
je 0x29bb
leaq 0x14855(%rip), %rdi     # 0x171fc
movb $0x0, %al
callq 0x6a00
callq 0x20a0
movl $0x0, (%rax)
jmp 0x29c9
leaq 0x1483a(%rip), %rdi     # 0x171fc
movb $0x0, %al
callq 0x6c50
jmp 0x29cb
jmp 0x2a02
movq -0x20(%rbp), %rdi
callq 0x7300
movq %rax, %rsi
leaq 0x1482f(%rip), %rdi     # 0x1720f
movb $0x0, %al
callq 0x2160
movq -0x20(%rbp), %rdi
callq 0x7420
movq -0x28(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x2a1b
movq -0x20(%rbp), %rdi
callq 0x7420
movq -0x28(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/hotspot_read/main.c
// Function: sendbatch
static int
sendbatch(struct hotspotread_state * C)
{

	while (C->Nip < 4096) {
		/* Do we need to pick a new batch? */
		if (C->Y == 65536) {
			C->X = (size_t)random() % C->Xmax;
			C->Y = 0;
		}

		/* Generate a key. */
		mkkey(C->X, C->Y++, C->key->buf);

		/* Send the request. */
		if (proto_kvlds_request_get(C->Q, C->key,
		    callback_get, C))
			goto err0;
		C->Nip += 1;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1000, 0x10(%rax)     # imm = 0x1000
jae 0x2ae6
movq -0x10(%rbp), %rax
cmpq $0x10000, 0x20(%rax)    # imm = 0x10000
jne 0x2a7f
callq 0x2220
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x28(%rcx)
movq -0x10(%rbp), %rax
movq %rdx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
addq $0x1, %rdx
callq 0x7460
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rcx
leaq 0x3b(%rip), %rdx        # 0x2b00
callq 0x8620
cmpl $0x0, %eax
je 0x2ad1
jmp 0x2aef
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x2a3c
movl $0x0, -0x4(%rbp)
jmp 0x2af6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/pattern_match/ac_auto/ac_auto.c
// Function: compare
int compare(void *args, int i, int j) {
    char **        args_patterns = (char **)(((void **)args)[0]);
    ac_tree_node **args_nodes = (ac_tree_node **)(((void **)args)[1]);

    int res = args_nodes[j]->match_number - args_nodes[i]->match_number;
    if (res == 0) {
        res = compare_string(args_patterns[i], args_patterns[j]);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x1c(%rax), %eax
movq -0x20(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
subl 0x1c(%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x48d0
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2db0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/pattern_match/ac_auto/ac_auto.c
// Function: swap
void swap(void *args, int i, int j) {
    char **        args_patterns = (char **)(((void **)args)[0]);
    ac_tree_node **args_nodes = (ac_tree_node **)(((void **)args)[1]);

    char *temp_parrtern = args_patterns[i];
    args_patterns[i] = args_patterns[j];
    args_patterns[j] = temp_parrtern;

    ac_tree_node *temp_nodes = args_nodes[i];
    args_nodes[i] = args_nodes[j];
    args_nodes[j] = temp_nodes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-cli.c
// Function: main
int
main(int argc, char **argv) {
  if (argc != 3) return usage(argv[0]);

  struct in_addr inaddr;
  if (inet_aton(argv[1], &inaddr) == 0) return usage(argv[0]);
  return client(inaddr.s_addr, argv[2]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x12ed
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1330
movl %eax, -0x4(%rbp)
jmp 0x1327
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x1314
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1330
movl %eax, -0x4(%rbp)
jmp 0x1327
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1370
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-trace.c
// Function: prepare_shm
static void prepare_shm(void) {
  _u8 buf[128];
  _u32 i;

#ifdef __CYGWIN__
  if (!getenv("CYGWIN")) {
    debug("Sorry, you need to enable SHM support in Cygwin first:\n"
          "  1. Install Cygwin IPC service ('cygserver-config').\n"
	  "  2. Launch the service ('net start cygserver').\n"
	  "  3. Export 'CYGWIN=server' to your environment.\n");
    exit(1);
  }	  
#endif /* __CYGWIN__ */
  
  shmid = shmget(0, OUTPUT_BUF + sizeof(struct shm_record), IPC_CREAT | 0600);
  if (shmid < 0) pfatal("unable to get %d kB of shared memory", OUTPUT_BUF / 1024);  
  
  shmreg = shmat(shmid, 0, 0);
  if (!shmreg || (long)shmreg == -1) pfatal("unable to attach shared memory");

  sprintf(buf,"%u",shmid);
  setenv("BUNNY_SHMID",buf,1);
  
  shmreg->length      = OUTPUT_BUF;
  shmreg->child_crash = 0;

  for (i=0;i<16;i++)
    shmreg->func_quota[i] = (1<<30); /* 1^30 = infty */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
xorl %edi, %edi
movl $0x80054, %esi          # imm = 0x80054
movl $0x380, %edx            # imm = 0x380
callq 0x1060
movl %eax, 0x3bc6(%rip)      # 0x5128
cmpl $0x0, 0x3bbf(%rip)      # 0x5128
jge 0x15cc
jmp 0x156d
movq 0x3a6c(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1beb(%rip), %rsi      # 0x3169
movl $0x200, %edx            # imm = 0x200
movb $0x0, %al
callq 0x1170
movq 0x3a4f(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1b08(%rip), %rsi      # 0x30a3
leaq 0x1c02(%rip), %rdx      # 0x31a4
leaq 0x1b0f(%rip), %rcx      # 0x30b8
movl $0x18c, %r8d            # imm = 0x18C
movb $0x0, %al
callq 0x1170
leaq 0x1bf3(%rip), %rdi      # 0x31b0
callq 0x10d0
movl $0x1, %edi
callq 0x1140
movl 0x3b56(%rip), %edi      # 0x5128
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1150
movq %rax, 0x3b4c(%rip)      # 0x5130
cmpq $0x0, 0x3b44(%rip)      # 0x5130
je 0x15fb
movq 0x3b3b(%rip), %rax      # 0x5130
cmpq $-0x1, %rax
jne 0x1657
jmp 0x15fd
movq 0x39dc(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1bb2(%rip), %rsi      # 0x31c0
movb $0x0, %al
callq 0x1170
movq 0x39c4(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1a7d(%rip), %rsi      # 0x30a3
leaq 0x1b77(%rip), %rdx      # 0x31a4
leaq 0x1a84(%rip), %rcx      # 0x30b8
movl $0x18f, %r8d            # imm = 0x18F
movb $0x0, %al
callq 0x1170
leaq 0x1b68(%rip), %rdi      # 0x31b0
callq 0x10d0
movl $0x1, %edi
callq 0x1140
leaq -0x80(%rbp), %rdi
movl 0x3ac7(%rip), %edx      # 0x5128
leaq 0x1f87(%rip), %rsi      # 0x35ef
movb $0x0, %al
callq 0x1030
leaq -0x80(%rbp), %rsi
leaq 0x1b7b(%rip), %rdi      # 0x31f5
movl $0x1, %edx
callq 0x1190
movq 0x3aa5(%rip), %rax      # 0x5130
movl $0x80000, 0x4(%rax)     # imm = 0x80000
movq 0x3a97(%rip), %rax      # 0x5130
movl $0x0, 0x10(%rax)
movl $0x0, -0x84(%rbp)
cmpl $0x10, -0x84(%rbp)
jae 0x16d9
movq 0x3a76(%rip), %rax      # 0x5130
movl -0x84(%rbp), %ecx
movl $0x40000000, 0x14(%rax,%rcx,4) # imm = 0x40000000
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x16aa
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-trace.c
// Function: setup_signals
static void setup_signals(void) {
  /* At least pretend to be nice. */  
  signal(SIGTERM,handle_kill);
  signal(SIGINT,handle_kill);
  signal(SIGHUP,handle_kill);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xf, %edi
leaq 0x2f0(%rip), %rsi       # 0x19f0
callq 0x1120
movl $0x2, %edi
leaq 0x2df(%rip), %rsi       # 0x19f0
callq 0x1120
movl $0x1, %edi
leaq 0x2ce(%rip), %rsi       # 0x19f0
callq 0x1120
popq %rbp
retq
nopl (%rax)