LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/spacifici[P]st/src/hb.c
// Function: hbfindfont
hb_font_t *
hbfindfont(XftFont *match)
{
	for (int i = 0; i < hbfontslen; i++) {
		if (hbfontcache[i].match == match)
			return hbfontcache[i].font;
	}

	/* Font not found in cache, caching it now. */
	hbfontcache = realloc(hbfontcache, sizeof(HbFontMatch) * (hbfontslen + 1));
	FT_Face face = XftLockFace(match);
	hb_font_t *font = hb_ft_font_create(face, NULL);
	if (font == NULL)
		die("Failed to load Harfbuzz font.");

	hbfontcache[hbfontslen].match = match;
	hbfontcache[hbfontslen].font = font;
	hbfontslen += 1;

	return font;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x1332c(%rip), %eax     # 0x25878
jge 0x12595
movq 0x1332b(%rip), %rax     # 0x25880
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x12588
movq 0x13310(%rip), %rax     # 0x25880
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1263b
jmp 0x1258a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12543
movq 0x132e4(%rip), %rdi     # 0x25880
movl 0x132d6(%rip), %eax     # 0x25878
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x4, %rsi
callq 0x68f0
movq %rax, 0x132c8(%rip)     # 0x25880
movq -0x10(%rbp), %rdi
callq 0x63a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x125eb
leaq 0x2194(%rip), %rdi      # 0x14778
movb $0x0, %al
callq 0x6b90
movq -0x10(%rbp), %rcx
movq 0x1328a(%rip), %rax     # 0x25880
movslq 0x1327b(%rip), %rdx     # 0x25878
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq 0x1326e(%rip), %rax     # 0x25880
movslq 0x1325f(%rip), %rdx     # 0x25878
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl 0x1324e(%rip), %eax     # 0x25878
addl $0x1, %eax
movl %eax, 0x13245(%rip)     # 0x25878
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/spacifici[P]st/src/hb.c
// Function: hbtransformsegment
void
hbtransformsegment(XftFont *xfont, const Glyph *string, hb_codepoint_t *codepoints, int start, int length)
{
	hb_font_t *font = hbfindfont(xfont);
	if (font == NULL)
		return;

	Rune rune;
	ushort mode = USHRT_MAX;
	hb_buffer_t *buffer = hb_buffer_create();
	hb_buffer_set_direction(buffer, HB_DIRECTION_LTR);

	/* Fill buffer with codepoints. */
	for (int i = start; i < (start+length); i++) {
		rune = string[i].u;
		mode = string[i].mode;
		if (mode & ATTR_WDUMMY)
			rune = 0x0020;
		hb_buffer_add_codepoints(buffer, &rune, 1, 0, 1);
	}

	/* Shape the segment. */
	hb_shape(font, buffer, NULL, 0);

	/* Get new glyph info. */
	hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, NULL);

	/* Write new codepoints. */
	for (int i = 0; i < length; i++) {
		hb_codepoint_t gid = info[i].codepoint;
		codepoints[start+i] = gid;
	}

	/* Cleanup. */
	hb_buffer_destroy(buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12530
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12934
jmp 0x12a35
movw $0xffff, -0x2e(%rbp)    # imm = 0xFFFF
callq 0x6790
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl $0x4, %esi
callq 0x66c0
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jge 0x129c7
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movw 0x4(%rax), %ax
movw %ax, -0x2e(%rbp)
movzwl -0x2e(%rbp), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x129a4
movl $0x20, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
movl $0x1, %r8d
xorl %ecx, %ecx
movl %r8d, %edx
callq 0x6280
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x12957
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x61c0
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6420
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x12a2c
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %edx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x4c(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x129f2
movq -0x38(%rbp), %rdi
callq 0x6530
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/pwrite2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = open(tmpfile, O_RDWR);

	assert(fd >= 0);

	while (1) {
		assert(pwrite(fd, buf, BUFLEN, 0) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3076(%rip), %rdi      # 0x5190
movl $0x2, %esi
movb $0x0, %al
callq 0x1220
movl %eax, -0x1014(%rbp)
cmpl $0x0, -0x1014(%rbp)
jl 0x2137
jmp 0x2156
leaq 0x113a(%rip), %rdi      # 0x3278
leaq 0x113b(%rip), %rsi      # 0x3280
movl $0x1e, %edx
leaq 0x118f(%rip), %rcx      # 0x32e0
callq 0x1120
jmp 0x2158
movl -0x1014(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
xorl %eax, %eax
movl %eax, %ecx
callq 0x11f0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x217d
jmp 0x219c
leaq 0x118f(%rip), %rdi      # 0x3313
leaq 0x10f5(%rip), %rsi      # 0x3280
movl $0x21, %edx
leaq 0x1149(%rip), %rcx      # 0x32e0
callq 0x1120
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2158
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/kvldsperf/main.c
// Function: main
int
main(int argc, char * argv[])
{
	struct sock_addr ** sas;
	int s;
	struct wire_requestqueue * Q;

	WARNP_INIT;

	/* Check number of arguments. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_kvlds %s\n", "<socketname>");
		exit(1);
	}

	/* Resolve the socket address and connect. */
	if ((sas = sock_resolve(argv[1])) == NULL) {
		warnp("Error resolving socket address: %s", argv[1]);
		exit(1);
	}
	if (sas[0] == NULL) {
		warn0("No addresses found for %s", argv[1]);
		exit(1);
	}
	if ((s = sock_connect(sas)) == -1)
		exit(1);

	/* Create a request queue. */
	if ((Q = wire_requestqueue_init(s)) == NULL) {
		warnp("Cannot create packet write queue");
		exit(1);
	}

	/* Test creating 10000000 key-value pairs. */
	if (createmany(Q, 10000000))
		exit(1);

	/* Free the request queue. */
	wire_requestqueue_destroy(Q);
	wire_requestqueue_free(Q);

	/* Free socket addresses. */
	sock_addr_freelist(sas);

	/* Success! */
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x244c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6650
jmp 0x244e
cmpl $0x2, -0x8(%rbp)
je 0x247d
movq 0x12b9d(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xcb9f(%rip), %rsi      # 0xf004
leaq 0xcbae(%rip), %rdx      # 0xf01a
movb $0x0, %al
callq 0x21c0
movl $0x1, %edi
callq 0x22b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4aa0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x24e5
jmp 0x2496
callq 0x20a0
cmpl $0x0, (%rax)
je 0x24c3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xcb78(%rip), %rdi      # 0xf027
movb $0x0, %al
callq 0x6710
callq 0x20a0
movl $0x0, (%rax)
jmp 0x24d9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xcb55(%rip), %rdi      # 0xf027
movb $0x0, %al
callq 0x6960
jmp 0x24db
movl $0x1, %edi
callq 0x22b0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x251c
jmp 0x24f1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xcb4a(%rip), %rdi      # 0xf04a
movb $0x0, %al
callq 0x6960
callq 0x20a0
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x22b0
movq -0x18(%rbp), %rdi
callq 0x5970
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x2537
movl $0x1, %edi
callq 0x22b0
movl -0x1c(%rbp), %edi
callq 0x8c50
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x258a
jmp 0x254b
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2570
leaq 0xcb08(%rip), %rdi      # 0xf064
movb $0x0, %al
callq 0x6710
callq 0x20a0
movl $0x0, (%rax)
jmp 0x257e
leaq 0xcaed(%rip), %rdi      # 0xf064
movb $0x0, %al
callq 0x6960
jmp 0x2580
movl $0x1, %edi
callq 0x22b0
movq -0x28(%rbp), %rdi
movl $0x989680, %esi         # imm = 0x989680
callq 0x25d0
cmpl $0x0, %eax
je 0x25a7
movl $0x1, %edi
callq 0x22b0
movq -0x28(%rbp), %rdi
callq 0x9220
movq -0x28(%rbp), %rdi
callq 0x9260
movq -0x18(%rbp), %rdi
callq 0x56d0
xorl %edi, %edi
callq 0x22b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/kvldsperf/main.c
// Function: createmany
static int
createmany(struct wire_requestqueue * Q, size_t N)
{
	struct createmany_state C;
	uint8_t buf[8];	/* dummy */

	/* Initialize. */
	C.Q = Q;
	C.Nsent = 0;
	C.Nmax = N;
	C.Nip = 0;
	C.failed = 0;
	C.done = 0;

	/* Allocate key structure. */
	memset(buf, 0, 8);
	if ((C.key = kvldskey_create(buf, 8)) == NULL)
		return (-1);

	/* Send an initial batch of 4096 requests. */
	if (sendbatch(&C))
		return (-1);

	/* Wait for N SETs to complete. */
	if (events_spin(&C.done) || C.failed) {
		warnp("SET request failed");
		return (-1);
	}

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

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x2170
leaq -0x50(%rbp), %rdi
movl $0x8, %esi
callq 0x6ba0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x263f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26be
leaq -0x48(%rbp), %rdi
callq 0x26d0
cmpl $0x0, %eax
je 0x2656
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26be
leaq -0x48(%rbp), %rdi
addq $0x24, %rdi
callq 0x2ba0
cmpl $0x0, %eax
jne 0x266e
cmpl $0x0, -0x28(%rbp)
je 0x26ae
jmp 0x2670
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2695
leaq 0xca04(%rip), %rdi      # 0xf085
movb $0x0, %al
callq 0x6710
callq 0x20a0
movl $0x0, (%rax)
jmp 0x26a3
leaq 0xc9e9(%rip), %rdi      # 0xf085
movb $0x0, %al
callq 0x6960
jmp 0x26a5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26be
movq -0x20(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/kvldsperf/main.c
// Function: sendbatch
static int
sendbatch(struct createmany_state * C)
{

	while ((C->Nsent < C->Nmax) && (C->Nip < 4096)) {
		/* Construct the key/value. */
		be64enc(C->key->buf, C->Nsent);

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

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x11(%rbp)
jae 0x2705
movq -0x10(%rbp), %rax
cmpq $0x1000, 0x18(%rax)     # imm = 0x1000
setb %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x270e
jmp 0x277a
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x27a0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x10(%rbp), %r8
leaq 0x127(%rip), %rcx       # 0x2870
callq 0x6ff0
cmpl $0x0, %eax
je 0x2755
jmp 0x2783
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x26dc
movl $0x0, -0x4(%rbp)
jmp 0x278a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/kvldsperf/main.c
// Function: callback_done
static int
callback_done(void * cookie, int failed)
{
	struct createmany_state * C = cookie;

	/* This request is no longer in progress. */
	C->Nip -= 1;

	/* Did we fail? */
	if (failed)
		C->failed = 1;

	/* Send more requests if possible. */
	if (sendbatch(C))
		goto err0;

	/* Are we done? */
	if (C->Nip == 0)
		C->done = 1;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x18(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x28a8
movq -0x20(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x20(%rbp), %rdi
callq 0x26d0
cmpl $0x0, %eax
je 0x28b8
jmp 0x28d7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x28ce
movq -0x20(%rbp), %rax
movl $0x1, 0x24(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x28de
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/randhhh1D.c
// Function: init
void init(double SSepsilon, double prob) {
	int i;
	SSepsval = SSepsilon;
	srand(SEED);
#ifdef PROB
	ignoreProb = 1 - prob;
	logIgnoreProb = log(ignoreProb);
	minusQuantity = log(RAND_MAX) / logIgnoreProb;
	nrIgnore = log((float)rand()) / logIgnoreProb - minusQuantity;
#endif
	for (i = 0; i < NUM_COUNTERS; i++)
		counters[i] = LCU_Init(max(SSepsilon, twototheminus(leveleps[i])));
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x5dc2(%rip)     # 0x7150
movl $0xd5d, %edi            # imm = 0xD5D
callq 0x10e0
movl $0x0, 0x14(%rsp)
cmpl $0x5, 0x14(%rsp)
jge 0x13fe
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x14(%rsp), %rcx
leaq 0x5d61(%rip), %rax      # 0x7120
movl (%rax,%rcx,4), %edi
callq 0x1320
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x12e0
cvtsd2ss %xmm0, %xmm0
callq 0x2310
movq %rax, %rdx
movslq 0x14(%rsp), %rcx
leaq 0x5d73(%rip), %rax      # 0x7160
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x13a0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/randhhh1D.c
// Function: cmpHH
int cmpHH(const void * lhs, const void * rhs) {
	if (((const HeavyHitter*) lhs)->item > ((const HeavyHitter*) rhs)->item) return 1;
	if (((const HeavyHitter*) lhs)->item < ((const HeavyHitter*) rhs)->item) return -1;
	if (((const HeavyHitter*) lhs)->mask > ((const HeavyHitter*) rhs)->mask) return 1;
	if (((const HeavyHitter*) lhs)->mask < ((const HeavyHitter*) rhs)->mask) return -1;
	if (((const HeavyHitter*) lhs)->upper != ((const HeavyHitter*) rhs)->upper) return ((const HeavyHitter*) lhs)->upper - ((const HeavyHitter*) rhs)->upper;
	return ((const HeavyHitter*) lhs)->lower - ((const HeavyHitter*) rhs)->lower;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jbe 0x14c7
movl $0x1, -0x4(%rsp)
jmp 0x1555
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x14e1
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1555
movq -0x10(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x14fd
movl $0x1, -0x4(%rsp)
jmp 0x1555
movq -0x10(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x1519
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1555
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x1541
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0x4(%rsp)
jmp 0x1555
movq -0x10(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_InsertIntoHashtable
void LCU_InsertIntoHashtable(LCU_type *lcu, LCUITEM *newi, int i, LCLitem_t newitem){
	newi->nexti=lcu->hashtable[i];
	newi->item=newitem; // overwrite the old item
	newi->hash=i;
	newi->previousi=NULL;
	// insert item into the hashtable
	if (lcu->hashtable[i])
		lcu->hashtable[i]->previousi=newi;
	lcu->hashtable[i]=newi;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movl -0x18(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movl -0x14(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x26e1
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rdx
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_cmp
int LCU_cmp( const void * a, const void * b) {
	LCUITEM * x = (LCUITEM*) a;
	LCUITEM * y = (LCUITEM*) b;
	if (x->parentg->count<y->parentg->count) return -1;
	else if (x->parentg->count>y->parentg->count) return 1;
	else return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
movq -0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x2740
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x276a
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
movq -0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jle 0x2762
movl $0x1, -0x4(%rsp)
jmp 0x276a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_GetNewCounter
LCUITEM * LCU_GetNewCounter(LCU_type * lcu) {
	LCUITEM * newi;
	int j;

	newi=lcu->root->items;  // take a counter from the first group
	// but currently it remains in the same group

	newi->nexting->previousing=newi->previousing;
	newi->previousing->nexting=newi->nexting;
	// unhook the new item from the linked list in the hash table	    

	// need to remove this item from the hashtable
	j = newi->hash;
	if (lcu->hashtable[j]==newi)
		lcu->hashtable[j]=newi->nexti;

	if (newi->nexti!=NULL)
		newi->nexti->previousi=newi->previousi;
	if (newi->previousi!=NULL)
		newi->previousi->nexti=newi->nexti;

	return (newi);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rsp), %rax
jne 0x27f3
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rdx
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2815
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2837
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_PutInNewGroup
void LCU_PutInNewGroup(LCU_type * lcu, LCUITEM *newi, LCUGROUP * tmpg){ 
	LCUGROUP * oldgroup;

	oldgroup=newi->parentg;  
	// put item in the tmpg group
	newi->parentg=tmpg;

	if (newi->nexting!=newi) // if the group does not have size 1
	{ // remove the item from its current group
		newi->nexting->previousing=newi->previousing;
		newi->previousing->nexting=newi->nexting;
		oldgroup->items=oldgroup->items->nexting;
	}
	else { // group will be empty
		if (oldgroup->nextg!=NULL) // there is another group
			oldgroup->nextg->previousg=oldgroup->previousg;
		if (lcu->root==oldgroup) // this is the first group
			lcu->root=oldgroup->nextg;
		else
			oldgroup->previousg->nextg=oldgroup->nextg;
		lcu->freegroups[--lcu->gpt]=oldgroup;
		// if we have created an empty group, remove it 
	}	
	newi->nexting=tmpg->items;
	newi->previousing=tmpg->items->previousing;
	newi->previousing->nexting=newi;
	newi->nexting->previousing=newi;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rax
cmpq -0x10(%rsp), %rax
je 0x28bf
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x293e
movq -0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x28e1
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
cmpq -0x20(%rsp), %rax
jne 0x2905
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x291b
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rsp), %rdx
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rsp), %rsi
movl 0x4(%rsi), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rsp), %rcx
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rsp), %rcx
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x30(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_AddNewGroupAfter
void LCU_AddNewGroupAfter(LCU_type * lcu, LCUITEM *newi, LCUGROUP *oldgroup) {
	LCUGROUP *newgroup;

	// remove item from old group...
	newi->nexting->previousing=newi->previousing;
	newi->previousing->nexting=newi->nexting;
	oldgroup->items=newi->nexting;
	//get new group
	newgroup=lcu->freegroups[lcu->gpt++];
	newgroup->count=oldgroup->count+1; // set count to be one more the prev group
	newgroup->items=newi;
	newgroup->previousg=oldgroup;
	newgroup->nextg=oldgroup->nextg;
	oldgroup->nextg=newgroup;
	if (newgroup->nextg!=NULL) // if there is another group
		newgroup->nextg->previousg=newgroup;
	newi->parentg=newgroup;
	newi->nexting=newi;
	newi->previousing=newi;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rsp), %rdx
movl 0x4(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x4(%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2a6d
movq -0x20(%rsp), %rcx
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_IncrementCounter
void LCU_IncrementCounter(LCU_type * lcu, LCUITEM *newi)
{
	LCUGROUP *oldgroup;

	oldgroup=newi->parentg;
	if ((oldgroup->nextg!=NULL) && 
		(oldgroup->nextg->count - oldgroup->count==1))
		LCU_PutInNewGroup(lcu, newi,oldgroup->nextg);
	// if the next group exists
	else { // need to create a new group with a differential of one
		if (newi->nexting==newi) // if there is only one item in the group...
			newi->parentg->count++;
		else      
			LCU_AddNewGroupAfter(lcu,newi,oldgroup);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2af4
movq (%rsp), %rax
movq 0x18(%rax), %rax
movl (%rax), %eax
movq (%rsp), %rcx
subl (%rcx), %eax
cmpl $0x1, %eax
jne 0x2af4
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x2840
jmp 0x2b2b
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
cmpq 0x8(%rsp), %rax
jne 0x2b16
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2b29
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x2990
jmp 0x2b2b
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_Update
void LCU_Update(LCU_type * lcu, LCLitem_t newitem) {
	int h;
	LCUITEM *il;

	lcu->n++;
	h=hash31(lcu->a,lcu->b,newitem) % lcu->tblsz;
	il=lcu->hashtable[h];
	while (il) {
		if (il->item == newitem) 
			break;
		il=il->nexti;
	}
	if (il==NULL) // item is not monitored (not in hashtable) 
	{
		il=LCU_GetNewCounter(lcu);
		/// and put it into the hashtable for the new item 
		il->delta=lcu->root->count;
		// initialize delta with count of first group
		LCU_InsertIntoHashtable(lcu,il,h,newitem);
		// put the new counter into the first group
		// counter is already in first group by defn of how we got it
		LCU_IncrementCounter(lcu, il);
	}
	else 
		LCU_IncrementCounter(lcu, il);
	// if we have an item, we need to increment its counter 
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0x37b0
movq 0x10(%rsp), %rcx
movslq 0xc(%rcx), %rcx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2bb3
movq (%rsp), %rax
movl (%rax), %eax
cmpl 0xc(%rsp), %eax
jne 0x2ba5
jmp 0x2bb3
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
jmp 0x2b90
cmpq $0x0, (%rsp)
jne 0x2c00
movq 0x10(%rsp), %rdi
callq 0x2770
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movl (%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %ecx
callq 0x2660
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x2aa0
jmp 0x2c0e
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x2aa0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_Destroy
void LCU_Destroy(LCU_type * lcu)
{
	free(lcu->freegroups);
	free(lcu->items);
	free(lcu->groups);
	free(lcu->hashtable);
	free (lcu);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x1040
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1040
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x1040
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x1040
movq (%rsp), %rdi
callq 0x1040
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_PointEstUpp
int LCU_PointEstUpp(LCU_type * lcu, LCLitem_t newitem) {
	int h;
	LCUITEM *il;

	lcu->n++;
	h=hash31(lcu->a,lcu->b,newitem) % lcu->tblsz;
	il=lcu->hashtable[h];
	while (il) {
		if (il->item == newitem) 
			return il->parentg->count;
		il=il->nexti;
	}
	return (lcu->root != NULL ? lcu->root->count : 0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x14(%rsp), %eax
movl %eax, %edx
callq 0x37b0
movq 0x18(%rsp), %rcx
movslq 0xc(%rcx), %rcx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2d37
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0x2d27
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x2d64
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2d01
movq 0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2d54
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x2d5c
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x2d5c
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_PointEstLow
int LCU_PointEstLow(LCU_type * lcu, LCLitem_t newitem) {
	int h;
	LCUITEM *il;

	lcu->n++;
	h=hash31(lcu->a,lcu->b,newitem) % lcu->tblsz;
	il=lcu->hashtable[h];
	while (il) {
		if (il->item == newitem) 
			return thismax(il->parentg->count - il->delta, 0);
		il=il->nexti;
	}
	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x14(%rsp), %eax
movl %eax, %edx
callq 0x37b0
movq 0x18(%rsp), %rcx
movslq 0xc(%rcx), %rcx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2e46
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0x2e36
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl (%rax), %edi
movq 0x8(%rsp), %rax
subl 0x8(%rax), %edi
xorl %esi, %esi
callq 0x2d70
movl %eax, 0x24(%rsp)
jmp 0x2e4e
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2e01
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/hashtable.c
// Function: HT_Clear
void HT_Clear(LL ** hashtable, int size) { //destroy
	int i;
	LL * ptr, * tmp;
	for (i = 0; i < size; i++) {
		ptr = hashtable[i];
		hashtable[i] = NULL;
		while (ptr) {
			tmp = ptr->next;
			free(ptr);
			ptr = tmp;
		}
	}
	free(hashtable);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x2eff
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
cmpq $0x0, 0x10(%rsp)
je 0x2ef0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1040
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x2ec4
jmp 0x2ef2
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2e95
movq 0x20(%rsp), %rdi
callq 0x1040
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/hashtable.c
// Function: HT_Insert
LL * HT_Insert(LL ** hashtable, int64__t item, int val, int size) { //if item already exists just return the pointer, otherwise insert and set val
	int hash = (int) hash31(HASHA_VAL, HASHB_VAL, item) % size;

	//ptr is the start of the list
	LL * ptr = hashtable[hash];

	//search thru the list
	while (ptr) {
		if (ptr->item == item) return ptr; //if we have found it, we are done
		ptr = ptr->next; //keep looking
	}
	
	//if we get here then ptr = NULL and we aren't in the list yet so we may prepend it to the list
	ptr = (LL*) calloc(1, sizeof(LL));
	ptr->item = item;
	ptr->val = val;
	ptr->next = hashtable[hash];
	ptr->prev = NULL;
	if (hashtable[hash] != NULL) hashtable[hash]->prev = ptr;
	hashtable[hash] = ptr;
	return ptr;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movq 0x20(%rsp), %rdx
movl $0x9041077, %edi        # imm = 0x9041077
movl $0x66939d, %esi         # imm = 0x66939D
callq 0x37b0
cltd
idivl 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2f8c
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x2f7c
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3022
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2f56
movl $0x1, %edi
movl $0x20, %esi
callq 0x10f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x3005
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/hashtable.c
// Function: HT_Find
LL * HT_Find(LL ** hashtable, int64__t item, int size) { //find the LL corresponding to the item. All updates happen via this, as do removes
	int hash = (int) hash31(HASHA_VAL, HASHB_VAL, item) % size;

	//ptr is the start of the list
	LL * ptr = hashtable[hash];

	//search thru the list
	while (ptr) {
		if (ptr->item == item) return ptr; //if we have found it, we are done
		ptr = ptr->next; //keep looking
	}
	//can't find
	return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x10(%rsp), %rdx
movl $0x9041077, %edi        # imm = 0x9041077
movl $0x66939d, %esi         # imm = 0x66939D
callq 0x37b0
cltd
idivl 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x309f
movq (%rsp), %rax
movq (%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x3091
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x30a8
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x3071
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/prng.c
// Function: hash31
long hash31(int64__t a, int64__t b, int64__t x)
{

  int64__t result;
  long lresult;

  // return a hash of x using a and b mod (2^31 - 1)
// may need to do another mod afterwards, or drop high bits
// depending on d, number of bad guys
// 2^31 - 1 = 2147483647

  //  result = ((int64__t) a)*((int64__t) x)+((int64__t) b);
  result=(a * x) + b;
  result = ((result >> HL) + result) & MOD;
  lresult=(long) result;

  return(lresult);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
imulq -0x18(%rsp), %rax
addq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
sarq $0x1f, %rax
addq -0x20(%rsp), %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/prng.c
// Function: ran3
unsigned long ran3(prng_type * prng) {

  unsigned long x;

  /* generate next random number */

  x = prng->randbuffer[prng->r_p1] = rotl(prng->randbuffer[prng->r_p2], R1)
    +  rotl(prng->randbuffer[prng->r_p1], R2);
  /* rotate list pointers */
  if (--prng->r_p1 < 0) prng->r_p1 = KK - 1;
  if (--prng->r_p2 < 0) prng->r_p2 = KK - 1;
  /* conversion to float */
  return x;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rcx
movslq 0x1ac(%rcx), %rcx
movq 0x120(%rax,%rcx,8), %rdi
movl $0x5, %esi
callq 0x3c60
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rcx
movslq 0x1a8(%rcx), %rcx
movq 0x120(%rax,%rcx,8), %rdi
movl $0x3, %esi
callq 0x3c60
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rsp), %rdx
movslq 0x1a8(%rdx), %rdx
movq %rax, 0x120(%rcx,%rdx,8)
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1a8(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x1a8(%rcx)
cmpl $0x0, %eax
jge 0x3d33
movq 0x10(%rsp), %rax
movl $0x10, 0x1a8(%rax)
movq 0x10(%rsp), %rcx
movl 0x1ac(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x1ac(%rcx)
cmpl $0x0, %eax
jge 0x3d5b
movq 0x10(%rsp), %rax
movl $0x10, 0x1ac(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/prng.c
// Function: RanrotAInit
void RanrotAInit (prng_type * prng, unsigned long seed) {

  int i;

  /* put semi-random numbers into the buffer */
  for (i=0; i<KK; i++) {
    prng->randbuffer[i] = seed;
    seed = rotl(seed,5) + 97;}

  /* initialize pointers to circular buffer */
  prng->r_p1 = 0;  prng->r_p2 = JJ;

  /* randomize */
  for (i = 0;  i < 300;  i++) ran3(prng);
  prng->scale = ldexp(1.0f, -8.0f * sizeof(unsigned long));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x11, 0x4(%rsp)
jge 0x3e39
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq %rdx, 0x120(%rax,%rcx,8)
movq 0x8(%rsp), %rdi
movl $0x5, %esi
callq 0x3c60
addq $0x61, %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3df6
movq 0x10(%rsp), %rax
movl $0x0, 0x1a8(%rax)
movq 0x10(%rsp), %rax
movl $0xa, 0x1ac(%rax)
movl $0x0, 0x4(%rsp)
cmpl $0x12c, 0x4(%rsp)       # imm = 0x12C
jge 0x3e80
movq 0x10(%rsp), %rdi
callq 0x3c90
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3e5f
movsd 0x1180(%rip), %xmm0     # 0x5008
movl $0xffffffc0, %edi       # imm = 0xFFFFFFC0
callq 0x1050
cvtsd2ss %xmm0, %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x4(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/prng.c
// Function: prng_int
long prng_int(prng_type * prng) {

  // returns a pseudo-random long integer.  Initialise the generator
  // before use!

  long response=0;

  switch (prng->usenric)
    {
    case 1 : response=(ran2(prng)); break;
    case 2 : response=(ran3(prng)); break;
    case 3 : response=(lrand48()); break;
    }
  return response;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x1, %eax
je 0x3eea
jmp 0x3ed4
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x3efb
jmp 0x3edf
movl 0x4(%rsp), %eax
subl $0x3, %eax
je 0x3f0c
jmp 0x3f16
movq 0x10(%rsp), %rdi
callq 0x3a90
movq %rax, 0x8(%rsp)
jmp 0x3f16
movq 0x10(%rsp), %rdi
callq 0x3c90
movq %rax, 0x8(%rsp)
jmp 0x3f16
callq 0x1130
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/prng.c
// Function: prng_float
float prng_float(prng_type * prng) {

  // returns a pseudo-random float in the range [0.0,1.0].
  // Initialise the generator before use!
  float result=0;

  switch (prng->usenric)
    {
    case 1 : result=(ran1(prng)); break;
    case 2 : result=(ran4(prng)); break;
    case 3 : result=(drand48()); break;
    }
  return result;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
subl $0x1, %eax
je 0x3f59
jmp 0x3f43
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0x3f6b
jmp 0x3f4e
movl 0x8(%rsp), %eax
subl $0x3, %eax
je 0x3f81
jmp 0x3f90
movq 0x10(%rsp), %rdi
callq 0x3870
movss %xmm0, 0xc(%rsp)
jmp 0x3f90
movq 0x10(%rsp), %rdi
callq 0x3d70
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x3f90
callq 0x11d0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/prng.c
// Function: prng_Init
prng_type * prng_Init(long seed, int nric) {

  // Initialise the random number generators.  nric determines
  // which algorithm to use, 1 for Numerical Recipes in C,
  // 0 for the other one.
  prng_type * result;

  result=(prng_type *) calloc(1,sizeof(prng_type));

  result->iy=0;
  result->usenric=nric;
  result->floatidum=-1;
  result->intidum=-1;
  result->iset=0;
  // set a global variable to record which algorithm to use
  switch (nric)
    {
    case 2 :
      RanrotAInit(result,seed);
      break;
    case 1 :
      if (seed>0) {
	// to initialise the NRiC PRNGs, call it with a negative value
	// so make sure it gets a negative value!
	result->floatidum = -(seed);  result->intidum = -(seed);
      } else {
	result->floatidum=seed; result->intidum=seed;
      }
      break;
    case 3 :
      srand48(seed);
      break;
    }

  prng_float(result);
  prng_int(result);
  // call the routines to actually initialise them
  return(result);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl $0x1, %edi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x10f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movq $-0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $-0x1, 0x10(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x1b0(%rax)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x4038
jmp 0x4011
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x4027
jmp 0x401c
movl 0xc(%rsp), %eax
subl $0x3, %eax
je 0x4084
jmp 0x408e
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x3de0
jmp 0x408e
cmpq $0x0, 0x20(%rsp)
jle 0x4066
xorl %eax, %eax
movl %eax, %ecx
subq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
movl %eax, %ecx
subq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x4082
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x408e
movq 0x20(%rsp), %rdi
callq 0x1150
movq 0x10(%rsp), %rdi
callq 0x3f20
movq 0x10(%rsp), %rdi
callq 0x3eb0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/prng.c
// Function: prng_Reseed
void prng_Reseed(prng_type * prng, long seed)
{
  switch (prng->usenric)
    {
    case 2 :
      RanrotAInit(prng,seed);
      break;
    case 1 :
      if (seed>0) {
	// to initialise the NRiC PRNGs, call it with a negative value
	// so make sure it gets a negative value!
	prng->floatidum = -(seed);  prng->intidum = -(seed);
      } else {
	prng->floatidum=seed; prng->intidum=seed;
      }
      break;
    case 3 :
      srand48(seed);
      break;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x1, %eax
je 0x40f7
jmp 0x40d0
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x40e6
jmp 0x40db
movl 0x4(%rsp), %eax
subl $0x3, %eax
je 0x4143
jmp 0x414d
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3de0
jmp 0x414d
cmpq $0x0, 0x8(%rsp)
jle 0x4125
xorl %eax, %eax
movl %eax, %ecx
subq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
movl %eax, %ecx
subq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x4141
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x414d
movq 0x8(%rsp), %rdi
callq 0x1150
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ranbenbasat[P]RHHH/prng.c
// Function: prng_normal
double prng_normal(prng_type * prng) {

  // Pick random values distributed N(0,1) using the Box-Muller transform
  // Taken from numerical recipes in C p289
  // picks two at a time, returns one per call (buffers the other)

  double fac,rsq,v1,v2;
  if (prng->iset == 0) {
    do {
      v1 = 2.0*prng_float(prng)-1.0;
      v2 = 2.0*prng_float(prng)-1.0;
      rsq=v1*v1+v2*v2;
    } while (rsq >= 1.0 || rsq == 0.0);

    fac = sqrt((double) -2.0*log((double)rsq)/rsq);
    prng->gset=v1*fac;
    prng->iset=1;
    return v2*fac;
  }
  else {
    prng->iset = 0;
    return prng->gset;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x1b0(%rax)
jne 0x42a1
jmp 0x418d
movq 0x28(%rsp), %rdi
callq 0x3f20
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0xe99(%rip), %xmm1      # 0x5040
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3f20
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0xe75(%rip), %xmm1      # 0x5040
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movb $0x1, %al
movsd 0xdfd(%rip), %xmm1      # 0x5008
ucomisd %xmm1, %xmm0
movb %al, 0x7(%rsp)
jae 0x422e
movsd 0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x418d
movsd 0x18(%rsp), %xmm0
callq 0x10c0
movaps %xmm0, %xmm1
movsd 0xf28(%rip), %xmm0      # 0x5178
mulsd %xmm1, %xmm0
divsd 0x18(%rsp), %xmm0
callq 0x11a0
movsd %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, 0x1b8(%rax)
movq 0x28(%rsp), %rax
movl $0x1, 0x1b0(%rax)
movsd 0x8(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x42c3
movq 0x28(%rsp), %rax
movl $0x0, 0x1b0(%rax)
movq 0x28(%rsp), %rax
movsd 0x1b8(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nop