LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-png.c
// Function: write_png_chunk_pHYs
static void write_png_chunk_pHYs(struct deark_png_encode_info *pei,
	dbuf *cdbuf)
{
	dbuf_writeu32be(cdbuf, (i64)pei->xdens);
	dbuf_writeu32be(cdbuf, (i64)pei->ydens);
	dbuf_writebyte(cdbuf, pei->phys_units);
	write_png_chunk_from_cdbuf(pei, cdbuf, CODE_pHYs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, %esi
callq 0x168b80
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, %esi
callq 0x168b80
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl 0x48(%rax), %esi
callq 0x168380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x70485973, %edx       # imm = 0x70485973
callq 0x19b690
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-png.c
// Function: write_png_chunk_tIME
static void write_png_chunk_tIME(struct deark_png_encode_info *pei,
	dbuf *cdbuf)
{
	struct de_struct_tm tm2;

	de_gmtime(&pei->internal_mod_time, &tm2);
	if(!tm2.is_valid) return;

	dbuf_writeu16be(cdbuf, (i64)tm2.tm_fullyear);
	dbuf_writebyte(cdbuf, (u8)(1+tm2.tm_mon));
	dbuf_writebyte(cdbuf, (u8)tm2.tm_mday);
	dbuf_writebyte(cdbuf, (u8)tm2.tm_hour);
	dbuf_writebyte(cdbuf, (u8)tm2.tm_min);
	dbuf_writebyte(cdbuf, (u8)tm2.tm_sec);
	write_png_chunk_from_cdbuf(pei, cdbuf, CODE_tIME);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
leaq -0x30(%rbp), %rsi
callq 0x15de50
cmpl $0x0, -0x30(%rbp)
jne 0x19b329
jmp 0x19b396
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x168a50
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %eax
addl $0x1, %eax
movzbl %al, %esi
callq 0x168380
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movzbl %al, %esi
callq 0x168380
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
movzbl %al, %esi
callq 0x168380
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movzbl %al, %esi
callq 0x168380
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movzbl %al, %esi
callq 0x168380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x74494d45, %edx       # imm = 0x74494D45
callq 0x19b690
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-png.c
// Function: write_png_chunk_htSP
static void write_png_chunk_htSP(struct deark_png_encode_info *pei,
	dbuf *cdbuf)
{
	// This is the UUID b9fe4f3d-8f32-456f-aa02-dcd79cce0e24
	static const u8 uuid[16] = {0xb9,0xfe,0x4f,0x3d,0x8f,0x32,0x45,0x6f,
		0xaa,0x02,0xdc,0xd7,0x9c,0xce,0x0e,0x24};

	dbuf_write(cdbuf, uuid, 16);
	dbuf_writei32be(cdbuf, (i64)pei->hotspot_x);
	dbuf_writei32be(cdbuf, (i64)pei->hotspot_y);
	write_png_chunk_from_cdbuf(pei, cdbuf, CODE_htSP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x42675(%rip), %rsi     # 0x1dda30
movl $0x10, %edx
callq 0x166170
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0x64(%rax), %rsi
callq 0x168cc0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0x68(%rax), %rsi
callq 0x168cc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x68745350, %edx       # imm = 0x68745350
callq 0x19b690
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-png.c
// Function: write_png_chunk_tEXt
static void write_png_chunk_tEXt(struct deark_png_encode_info *pei,
	dbuf *cdbuf, const char *keyword, const char *value)
{
	i64 kwlen, vlen;
	kwlen = (i64)de_strlen(keyword);
	vlen = (i64)de_strlen(value);
	dbuf_write(cdbuf, (const u8*)keyword, kwlen);
	dbuf_writebyte(cdbuf, 0);
	dbuf_write(cdbuf, (const u8*)value, vlen);
	write_png_chunk_from_cdbuf(pei, cdbuf, CODE_tEXt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x190e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x190e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x166170
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x168380
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x166170
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x74455874, %edx       # imm = 0x74455874
callq 0x19b690
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-png.c
// Function: my_IDAT_write_cb
static void my_IDAT_write_cb(dbuf *f, void *userdata,
	const u8 *mem_orig, i64 memsize_orig)
{
	struct IDAT_write_userdata_struct *iwu = (struct IDAT_write_userdata_struct*)userdata;
	const u8 *mem = mem_orig;
	i64 memsize = memsize_orig;

	// We *could* just write a single IDAT chunk for each call to this function.
	// We would get a PNG with IDATs having various random-ish sizes.
	// I want the PNG output to be more predictable and stable than that, though,
	// so we'll do some buffering to make each chunk (except the last) have
	// DE_MAX_IDAT_CHUNKSIZE bytes.

	while(iwu->cdbuf->len + memsize >= DE_MAX_IDAT_CHUNKSIZE) {
		i64 amt_to_use_from_membuf;

		if(iwu->cdbuf->len >= DE_MAX_IDAT_CHUNKSIZE) {
			amt_to_use_from_membuf = 0;
		}
		else {
			amt_to_use_from_membuf = DE_MAX_IDAT_CHUNKSIZE - iwu->cdbuf->len;
		}

		dbuf_write(iwu->cdbuf, mem, amt_to_use_from_membuf);
		mem += amt_to_use_from_membuf;
		memsize -= amt_to_use_from_membuf;
		// cdbuf should now have exactly DE_MAX_IDAT_CHUNKSIZE bytes in it.

		write_png_chunk_from_cdbuf(iwu->pei, iwu->cdbuf, CODE_IDAT);
		iwu->IDAT_count++;
		dbuf_empty(iwu->cdbuf);
	}

	// Save any remaining compressed pixel data for next time.
	if(memsize > 0) {
		dbuf_write(iwu->cdbuf, mem, memsize);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
addq -0x38(%rbp), %rax
cmpq $0x100000, %rax         # imm = 0x100000
jl 0x19b7d5
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x100000, 0x18(%rax)   # imm = 0x100000
jl 0x19b758
movq $0x0, -0x40(%rbp)
jmp 0x19b76d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x100000, %eax         # imm = 0x100000
subq 0x18(%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x166170
movq -0x40(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x49444154, %edx       # imm = 0x49444154
callq 0x19b690
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x169310
jmp 0x19b720
cmpq $0x0, -0x38(%rbp)
jle 0x19b7f1
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x166170
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jsummers[P]deark/src/deark-png.c
// Function: write_png_chunk_from_mem
static void write_png_chunk_from_mem(struct deark_png_encode_info *pei,
	const u8 *mem, i64 memlen, u32 chunktype)
{
	u32 crc;
	u8 tmpbuf[4];

	de_crcobj_reset(pei->crco);

	// length field
	dbuf_writeu32be(pei->outf, memlen);

	// chunk type field
	de_writeu32be_direct(tmpbuf, (i64)chunktype);
	de_crcobj_addbuf(pei->crco, tmpbuf, 4);
	dbuf_write(pei->outf, tmpbuf, 4);

	// data field
	de_crcobj_addbuf(pei->crco, mem, memlen);
	dbuf_write(pei->outf, mem, memlen);

	// CRC field
	crc = de_crcobj_getval(pei->crco);
	dbuf_writeu32be(pei->outf, (i64)crc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x15f250
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x168b80
leaq -0x24(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x168b10
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
callq 0x15f430
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
callq 0x166170
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15f430
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x166170
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x15f340
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x168b80
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/utils/bits/test/test_bits.c
// Function: main
int main() {
    mp_init(1 << 30, mp_exit);
    boolean pass = T;
    int     prefix;

    // 0110 1001  1100 0011
    bits *b = bits_init_with_minimum_bytes("\x69\xC3", 0, 16);
    bits *s1 = bits_sub(b, 4, 12); // 0011 0110
    bits *s2 = bits_sub(b, 3, 5);  // 0011 0110

    if ((prefix = bits_prefix(b, s1, 1)) != 0) {
        print_err("prefix want 0, got %d\n", prefix);
        pass = F;
    }

    if ((prefix = bits_prefix(b, s1, 1)) != 0) {
        print_err("prefix want 0, got %d\n", prefix);
        pass = F;
    }

    if ((prefix = bits_prefix(b, s2, 1)) != 2) {
        print_err("prefix want 2, got %d\n", prefix);
        pass = F;
    }

    if (pass) {
        print_ok("All testcases passed.\n");
    } else {
        print_err("Some errors!\n");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x40000000, %edi       # imm = 0x40000000
leaq -0xbfb(%rip), %rsi      # 0x1190
callq 0x11a0
leaq 0x401(%rip), %rax       # 0x2198
movl (%rax), %eax
movl %eax, -0x8(%rbp)
leaq 0x3fd(%rip), %rdi       # 0x21a0
xorl %esi, %esi
movl $0x10, %edx
callq 0x15f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x4, %esi
movl $0xc, %edx
callq 0x17b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3, %esi
movl $0x5, %edx
callq 0x17b0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x18e0
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x1e18
movl -0xc(%rbp), %esi
leaq 0x39e(%rip), %rdi       # 0x21a3
movb $0x0, %al
callq 0x1bf0
leaq 0x389(%rip), %rax       # 0x219c
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x18e0
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x1e4f
movl -0xc(%rbp), %esi
leaq 0x367(%rip), %rdi       # 0x21a3
movb $0x0, %al
callq 0x1bf0
leaq 0x352(%rip), %rax       # 0x219c
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x18e0
movl %eax, -0xc(%rbp)
cmpl $0x2, %eax
je 0x1e86
movl -0xc(%rbp), %esi
leaq 0x347(%rip), %rdi       # 0x21ba
movb $0x0, %al
callq 0x1bf0
leaq 0x31b(%rip), %rax       # 0x219c
movl (%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1e9c
leaq 0x33e(%rip), %rdi       # 0x21d1
movb $0x0, %al
callq 0x1cb0
jmp 0x1eaa
leaq 0x345(%rip), %rdi       # 0x21e8
movb $0x0, %al
callq 0x1bf0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb-c-mp.c
// Function: test_int
int test_int(int n)
{
	int i, cnt = 0;
	uint64_t x = 11;
	intmap_t *d, *r;
	struct rb_table *h;
	kmempool_t(node) *mp;

	mp = kmp_init(node);
	h = rb_create(int_cmp, 0, 0);
	for (i = 0; i < n; ++i) {
		unsigned y = x % (n>>1);
		x = kad_splitmix64(x);
		d = kmp_alloc(node, mp);
		d->key = y; d->value = i;
		if (rb_find(h, d) == 0) {
			rb_insert(h, d);
			++cnt;
		} else {
			r = rb_delete(h, d);
			kmp_free(node, mp, d);
			kmp_free(node, mp, r);
			--cnt;
		}
	}
	rb_destroy(h, 0);
	kmp_destroy(node, mp);
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movq $0xb, -0x18(%rbp)
callq 0x3920
movq %rax, -0x38(%rbp)
leaq -0x7a(%rip), %rdi       # 0x37b0
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x11b0
movq %rax, -0x30(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x38ff
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3940
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
callq 0x39c0
movq %rax, -0x20(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1280
cmpq $0x0, %rax
jne 0x38bb
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1920
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x38ef
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x19f0
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a30
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3a30
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x38f1
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3841
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3550
movq -0x38(%rbp), %rdi
callq 0x3ae0
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/gpss.c
// Function: gpss_greedy
static int gpss_greedy(int *S, int *P)
{
	int *ptmk;	/* indicates if each point is selected */
	int S_n = 0;
	int i;
	ptmk = calloc(pt_n, sizeof(ptmk[0]));
	for (i = 0; i < pt_n; i++) {
		int p = gpss_greedy_next(P, ptmk);
		if (p < 0)
			break;
		ptmk[p] = 1;
		S[S_n++] = p;
	}
	free(ptmk);
	return S_n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movslq 0x369a(%rip), %rdi      # 0x5068
movl $0x4, %esi
callq 0x1070
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl 0x367c(%rip), %eax      # 0x5068
jge 0x1a38
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2040
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x1a06
jmp 0x1a38
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x19e3
movq -0x18(%rbp), %rdi
callq 0x1030
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/gpss.c
// Function: gpss_greedymin
static int gpss_greedymin(int *S, int *P)
{
	int *ptmk;	/* indicates if each point is selected */
	int S_n;
	ptmk = calloc(pt_n, sizeof(ptmk[0]));
	S_n = gpss_greedymin_cont(S, P, ptmk);
	free(ptmk);
	return S_n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movslq 0x3601(%rip), %rdi      # 0x5068
movl $0x4, %esi
callq 0x1070
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2170
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/gpss.c
// Function: gpss_greedymax
static int gpss_greedymax(int *S, int *P)
{
	int *ptmk;	/* indicates if each point is removed */
	int S_n = 0;
	int i;
	ptmk = malloc(pt_n * sizeof(ptmk[0]));
	for (i = 0; i < pt_n; i++)
		ptmk[i] = 1;
	for (i = 0; i < pt_n; i++) {
		int p = gpss_greedymax_next(P, ptmk);
		if (p < 0)
			break;
		ptmk[p] = 0;
	}
	for (i = 0; i < pt_n; i++)
		if (ptmk[i])
			S[S_n++] = i;
	free(ptmk);
	return S_n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movslq 0x35aa(%rip), %rdi      # 0x5068
shlq $0x2, %rdi
callq 0x1080
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl 0x358d(%rip), %eax      # 0x5068
jge 0x1af7
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1ad2
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl 0x3561(%rip), %eax      # 0x5068
jge 0x1b3b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x24e0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x1b21
jmp 0x1b3b
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1afe
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl 0x351d(%rip), %eax      # 0x5068
jge 0x1b80
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x1b73
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1b75
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1b42
movq -0x18(%rbp), %rdi
callq 0x1030
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/gpss.c
// Function: gpss_main
static int gpss_main(int *S, int *P)
{
	int *filt;
	int n1, n2, n3;
	int i;
	filt = calloc(pt_n, sizeof(filt[0]));
	gpss_part(filt, P);
	n1 = gpss_iset(filt, S, P);
	for (i = 0; i < pt_n; i++)
		filt[i] = !filt[i];
	n2 = gpss_iset(filt, S + n1, P);
	memset(filt, 0, pt_n * sizeof(filt[0]));
	for (i = 0; i < n1 + n2; i++)
		filt[S[i]] = 1;
	/* adding other points if possible */
	n3 = gpss_greedymin_cont(S + n1 + n2, P, filt);
	free(filt);
	return n1 + n2 + n3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movslq 0x34b1(%rip), %rdi      # 0x5068
movl $0x4, %esi
callq 0x1070
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2770
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2910
movl %eax, -0x1c(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl 0x3472(%rip), %eax      # 0x5068
jge 0x1c24
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edx
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1bed
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x2910
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movslq 0x341a(%rip), %rdx      # 0x5068
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1060
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1c8f
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1c60
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movslq -0x20(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2170
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/gpss.c
// Function: report
static void report(int *S, int n)
{
	char mark[NPT] = {0};
	int i;
	for (i = 0; i < n; i++)
		mark[S[i]] = 1;
	printf("%d", pt_n - n);
	for (i = 0; i < pt_n; i++)
		if (!mark[i])
			printf(" %d", i);
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2730, %rsp           # imm = 0x2730
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x2720(%rbp), %rdi
xorl %esi, %esi
movl $0x2710, %edx           # imm = 0x2710
callq 0x1060
movl $0x0, -0x2724(%rbp)
movl -0x2724(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1d42
movq -0x8(%rbp), %rax
movslq -0x2724(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
movb $0x1, -0x2720(%rbp,%rax)
movl -0x2724(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2724(%rbp)
jmp 0x1d0f
movl 0x3320(%rip), %esi      # 0x5068
subl -0xc(%rbp), %esi
leaq 0x12c8(%rip), %rdi      # 0x301a
movb $0x0, %al
callq 0x1050
movl $0x0, -0x2724(%rbp)
movl -0x2724(%rbp), %eax
cmpl 0x32f9(%rip), %eax      # 0x5068
jge 0x1da9
movslq -0x2724(%rbp), %rax
cmpb $0x0, -0x2720(%rbp,%rax)
jne 0x1d96
movl -0x2724(%rbp), %esi
leaq 0x128a(%rip), %rdi      # 0x3019
movb $0x0, %al
callq 0x1050
jmp 0x1d98
movl -0x2724(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2724(%rbp)
jmp 0x1d63
leaq 0x1267(%rip), %rdi      # 0x3017
movb $0x0, %al
callq 0x1050
addq $0x2730, %rsp           # imm = 0x2730
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/gpss.c
// Function: data_free
static void data_free(void)
{
	int i;
	for (i = 0; i < ln_n; i++)
		free(ln[i]);
	for (i = 0; i < pt_n; i++)
		free(pt_ln[i]);
	free(ln);
	free(pt_ln);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x3294(%rip), %eax      # 0x506c
jge 0x1df9
movq 0x328f(%rip), %rax      # 0x5070
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1dcf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x325f(%rip), %eax      # 0x5068
jge 0x1e2a
movq 0x326e(%rip), %rax      # 0x5080
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1e00
movq 0x323f(%rip), %rdi      # 0x5070
callq 0x1030
movq 0x3243(%rip), %rdi      # 0x5080
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/gpss.c
// Function: gpss_greedy_next
static int gpss_greedy_next(int *P, int *ptmk)
{
	int i, j, k;
	for (i = 0; i < pt_n; i++) {
		int p = P[i];
		if (ptmk[p])
			continue;
		for (j = 0; j < pt_cnt[p]; j++) {
			int l = pt_ln[p][j];
			int lcnt = 0;
			for (k = 0; k < ln_cnt[l]; k++)
				if (ptmk[ln[l][k]])
					lcnt++;
			if (lcnt >= 2)
				break;
		}
		if (j == pt_cnt[p])
			return p;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x300c(%rip), %eax      # 0x5068
jge 0x2155
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x2083
jmp 0x2147
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq 0x2ff4(%rip), %rcx      # 0x5088
movslq -0x28(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x212a
movq 0x2fd8(%rip), %rax      # 0x5080
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq 0x2fa6(%rip), %rcx      # 0x5078
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2112
movq -0x18(%rbp), %rax
movq 0x2f8a(%rip), %rcx      # 0x5070
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x24(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x2105
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2107
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x20c8
cmpl $0x2, -0x30(%rbp)
jl 0x211a
jmp 0x212a
jmp 0x211c
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x208a
movl -0x20(%rbp), %eax
movq 0x2f54(%rip), %rcx      # 0x5088
movslq -0x28(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x2145
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x215c
jmp 0x2147
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2053
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/gpss.c
// Function: gpss_greedymin_cont
static int gpss_greedymin_cont(int *S, int *P, int *ptmk)
{
	int i;
	int S_n = 0;
	for (i = 0; i < pt_n; i++) {
		int p = gpss_greedymin_next(P, ptmk);
		if (p < 0)
			break;
		ptmk[p] = 1;
		S[S_n++] = p;
	}
	return S_n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x2ecd(%rip), %eax      # 0x5068
jge 0x21e7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x21f0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x21b5
jmp 0x21e7
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2192
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/gpss.c
// Function: gpss_part
static void gpss_part(int *filt, int *P)
{
	int i, j, k;
	for (i = 0; i < pt_n; i++) {
		int p = P[i];
		int n1 = 0;
		int n2 = 0;
		for (j = 0; j < pt_cnt[p]; j++) {	/* decide which part to put p in */
			int l = pt_ln[p][j];
			for (k = 0; k < ln_cnt[l]; k++) {
				if (filt[ln[l][k]] == 1)
					n1++;
				if (filt[ln[l][k]] == 2)
					n2++;
			}
		}
		if (n1 > n2)
			filt[p] = 2;
		if (n2 > n1 || filt[p] == 0)
			filt[p] = 1;
	}
	for (i = 0; i < pt_n; i++)
		filt[P[i]] = filt[P[i]] == 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x28dc(%rip), %eax      # 0x5068
jge 0x28bc
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq 0x28c9(%rip), %rcx      # 0x5088
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2870
movq 0x28ad(%rip), %rax      # 0x5080
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq 0x2882(%rip), %rcx      # 0x5078
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2860
movq -0x8(%rbp), %rax
movq 0x2866(%rip), %rcx      # 0x5070
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x2829
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x283c(%rip), %rcx      # 0x5070
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x2, (%rax,%rcx,4)
jne 0x2853
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2855
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27ec
jmp 0x2862
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x27b5
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x2887
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl $0x2, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0x289d
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x28ac
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
jmp 0x28ae
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2783
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x279c(%rip), %eax      # 0x5068
jge 0x2908
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x1, (%rax,%rcx,4)
sete %al
andb $0x1, %al
movzbl %al, %edx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x28c3
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]gpss/gpss.c
// Function: iset_next
static int iset_next(int *P, char *mark)
{
	int i, j, k;
	int best = -1;
	int best_odeg = 0;
	for (i = 0; i < pt_n; i++) {
		int p = P[i];
		int odeg = 0;
		if (mark[p])
			continue;
		for (j = 0; j < pt_cnt[p]; j++) {
			int l = pt_ln[p][j];
			for (k = 0; k < ln_cnt[l]; k++)
				if (mark[ln[l][k]] == 0)
					odeg += 1;
		}
		if (best < 0 || odeg < best_odeg) {
			best = p;
			best_odeg = odeg;
		}
	}
	return best;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x24(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x250e(%rip), %eax      # 0x5068
jge 0x2c49
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2b88
jmp 0x2c3b
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq 0x24ef(%rip), %rcx      # 0x5088
movslq -0x28(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2c1f
movq 0x24d7(%rip), %rax      # 0x5080
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq 0x24ac(%rip), %rcx      # 0x5078
movslq -0x30(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2c0f
movq -0x10(%rbp), %rax
movq 0x2490(%rip), %rcx      # 0x5070
movslq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x2c02
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2c04
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2bc2
jmp 0x2c11
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b8f
cmpl $0x0, -0x20(%rbp)
jl 0x2c2d
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x2c39
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x2c3b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b51
movl -0x20(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/test_recdata.c
// Function: main
int main(int argc, char** argv) {
    FILE* user_data;
    FILE* item_data;
    int N_users;
    int N_items;
    int N_prefs;
    int binary;
    recdata_t* recdata;

    if (!read_args(argc, argv, &user_data, &item_data, &N_users, &N_items, &N_prefs, &binary)) {
        return EXIT_FAILURE;
    }

    recdata = recdata_simple_create(user_data, item_data, N_users, N_items, N_prefs, binary);
    
    fclose(user_data);
    fclose(item_data);
    
    recdata_close(recdata);
    
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %r8
leaq -0x28(%rbp), %r9
leaq -0x2c(%rbp), %r10
leaq -0x30(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3190
cmpl $0x0, %eax
jne 0x1261
movl $0x1, -0x4(%rbp)
jmp 0x12a2
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x2c(%rbp), %r8d
movl -0x30(%rbp), %r9d
callq 0x1840
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
movq -0x20(%rbp), %rdi
callq 0x1060
movq -0x38(%rbp), %rdi
callq 0x1370
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recdata_simple.c
// Function: recdata_simple_close
void recdata_simple_close(void* args) {
    recdata_simple_args_t* a = args;
    
    free(a->n_userdata);
    free(a->i_userdata[0]);
    free(a->i_userdata);
    if (!a->binary) {
        free(a->r_userdata[0]);
        free(a->r_userdata);
    }
    free(a->n_itemdata);
    free(a->i_itemdata[0]);
    free(a->i_itemdata);
    if (!a->binary) {
        free(a->r_itemdata[0]);
        free(a->r_itemdata);
    }
    free(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x1564
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x15b5
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recdata_simple.c
// Function: recdata_simple_create
recdata_t* recdata_simple_create(FILE* user_data, FILE* item_data, int N_users, int N_items, int N_prefs, int binary) {
    recdata_t* recdata;
    recdata_simple_args_t* args;
    
    recdata = malloc(sizeof(recdata_t));
    recdata->N_users = N_users;
    recdata->N_items = N_items;
    recdata->N_prefs = N_prefs;
    
    recdata->userdata_size = recdata_simple_userdata_size;
    recdata->itemdata_size = recdata_simple_itemdata_size;
    recdata->userdata = recdata_simple_userdata;
    recdata->itemdata = recdata_simple_itemdata;
    recdata->close = recdata_simple_close;
    
    args = malloc(sizeof(recdata_simple_args_t));
    recdata->args = args;
    
    args->binary = binary;
    read_data(&(args->n_userdata), &(args->i_userdata), &(args->r_userdata), user_data, N_users, N_prefs, binary);
    
    read_data(&(args->n_itemdata), &(args->i_itemdata), &(args->r_itemdata), item_data, N_items, N_prefs, binary);
    
    return recdata;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movl $0x40, %edi
callq 0x10b0
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
leaq -0x4f4(%rip), %rcx      # 0x13a0
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
leaq -0x4d3(%rip), %rcx      # 0x13d0
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
leaq -0x4b2(%rip), %rcx      # 0x1400
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
leaq -0x441(%rip), %rcx      # 0x1480
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
leaq -0x3d0(%rip), %rcx      # 0x1500
movq %rcx, 0x30(%rax)
movl $0x38, %edi
callq 0x10b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdx
addq $0x10, %rdx
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl -0x20(%rbp), %eax
movl %eax, (%rsp)
callq 0x15d0
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq -0x30(%rbp), %rsi
addq $0x20, %rsi
movq -0x30(%rbp), %rdx
addq $0x28, %rdx
movq -0x10(%rbp), %rcx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl -0x20(%rbp), %eax
movl %eax, (%rsp)
callq 0x15d0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recdata_transposed.c
// Function: recdata_transposed_create
recdata_t* recdata_transposed_create(recdata_t* recdata0) {
    recdata_t* recdata;
    
    recdata = malloc(sizeof(recdata_t));
    recdata->N_users = recdata0->N_items;
    recdata->N_items = recdata0->N_users;
    recdata->N_prefs = recdata0->N_prefs;
    
    recdata->userdata_size = recdata0->itemdata_size;
    recdata->itemdata_size = recdata0->userdata_size;
    recdata->userdata = recdata0->itemdata;
    recdata->itemdata = recdata0->userdata;
    recdata->close = recdata_transposed_close;
    
    recdata->args = recdata0->args;
    
    return recdata;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x40, %edi
callq 0x10b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
leaq -0x9d(%rip), %rcx       # 0x1960
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/similarity_setcosine.c
// Function: similarity_setcosine_create
similarity_t* similarity_setcosine_create(recdata_t* recdata) {
    similarity_t* similarity;
    
    similarity = malloc(sizeof(similarity_t));
    similarity->calculate = similarity_setcosine_calculate;
    similarity->close = similarity_setcosine_close;
    similarity->args = recdata;
    
    return similarity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x10b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq -0x215(%rip), %rcx      # 0x1a80
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq -0x43(%rip), %rcx       # 0x1c60
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/similarity_veccosine.c
// Function: calculate_norm
double* calculate_norm(recdata_t* recdata) {
    int i;
    int uid;
    idpairs_t* ud;
    double* norm;
    
    norm = malloc(recdata->N_users * sizeof(double));
     
    for (uid = 0; uid < recdata->N_users; uid++) {
        ud = recdata_userdata(recdata, uid);
        norm[uid] = 0.0;
        for (i = 0; i < idpairs_size(ud); i++) {
            norm[uid] += idpairs_values(ud)[i] * idpairs_values(ud)[i];
        }
        norm[uid] = 1 / sqrt(norm[uid]);
        idpairs_close_shallow(ud);
    }
     
    return norm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x10b0
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1fed
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1310
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2ff0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x1fa8
movq -0x18(%rbp), %rdi
callq 0x3020
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3020
movsd -0x30(%rbp), %xmm0
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f3d
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x1100
movaps %xmm0, %xmm1
movsd 0x2043(%rip), %xmm0     # 0x4008
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x18(%rbp), %rdi
callq 0x2fd0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1f07
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/similarity_veccosine.c
// Function: similarity_veccosine_create
similarity_t* similarity_veccosine_create(recdata_t* recdata) {
    similarity_t* similarity;
    similarity_veccosine_args_t* args;
    
    similarity = malloc(sizeof(similarity_t));
    similarity->calculate = similarity_veccosine_calculate;
    similarity->close = similarity_veccosine_close;
    
    args = malloc(sizeof(similarity_veccosine_args_t));
    args->recdata = recdata;
    args->norm = calculate_norm(recdata);
    similarity->args = args;
    
    return similarity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x10b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq -0x365(%rip), %rcx      # 0x1cc0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq -0x183(%rip), %rcx      # 0x1eb0
movq %rcx, 0x8(%rax)
movl $0x10, %edi
callq 0x10b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x1ee0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/topn.c
// Function: topn_create
topn_t* topn_create(int capacity) {
    topn_t* topn = malloc(sizeof(topn_t));

    topn->capacity = capacity;
    topn->keys = calloc(capacity, sizeof(int));
    topn->values = calloc(capacity, sizeof(double));
    topn->size = 0;
    
    return topn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x10b0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movslq -0x4(%rbp), %rdi
movl $0x4, %esi
callq 0x1090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x1090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/topn.c
// Function: swap
void swap(topn_t* topn, int i, int j) {
    int k;
    double v;

    k = topn->keys[i];
    topn->keys[i] = topn->keys[j];
    topn->keys[j] = k;
    v = topn->values[i];
    topn->values[i] = topn->values[j];
    topn->values[j] = v;
}

// 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
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/topn.c
// Function: reverse
void reverse(topn_t* topn) {
    int i = 0;
    int j = topn->size - 1;
    while (j > i) {
        swap(topn, i, j);
        j--;
        i++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x223b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x2150
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/topn.c
// Function: minChild
int minChild(topn_t* topn, int i) {
    int l = left(i);
    int r = right(i);

    if (l >= topn->capacity) {
        return -1;
    }

    if (r >= topn->size) {
        return l;
    }

    return (topn->values[l] < topn->values[r] || (topn->values[l] == topn->values[r] && topn->keys[l] < topn->keys[r])) ? l : r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x2270
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
callq 0x2290
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x22ed
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2384
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jl 0x2304
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2384
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
ja 0x2370
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jne 0x2378
jp 0x2378
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2378
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x237e
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)