LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sprt[P]lossless-transport/src/window.c
// Function: window_pop_timestamp
pkt_t *window_pop_timestamp(window_t *w, uint32_t timestamp) {
	struct node **cur = &w->front;
	struct node **match = cur;
	while (*cur != NULL) {
		if (pkt_get_timestamp((*cur)->pkt) == timestamp) {
			match = cur;
			break;
		}
		cur = &(*cur)->next;
	}
	return window_pop_node(w, match);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2bcc
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x19c0
cmpl -0xc(%rbp), %eax
jne 0x2bbb
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2bcc
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x2b93
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2af0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sprt[P]lossless-transport/src/window.c
// Function: window_find_min_timestamp
struct node **window_find_min_timestamp(window_t *w) {
	struct node **cur = &w->front;
	struct node **min = cur;
	while (*cur != NULL) {
		if (pkt_get_timestamp((*cur)->pkt) < pkt_get_timestamp((*min)->pkt)) {
			min = cur;
		}
		cur = &(*cur)->next;
	}
	return min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2c4d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x19c0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x19c0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jae 0x2c3c
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x2c00
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sprt[P]lossless-transport/src/window.c
// Function: window_peek_min_timestamp
pkt_t *window_peek_min_timestamp(window_t *w) {
	struct node **min = window_find_min_timestamp(w);
	if (*min == NULL) {
		return NULL;
	}
	return (*min)->pkt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2be0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2c8d
movq $0x0, -0x8(%rbp)
jmp 0x2c9b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sprt[P]lossless-transport/src/window.c
// Function: window_find_min_seqnum
struct node **window_find_min_seqnum(window_t *w) {
	struct node **cur = &w->front;
	struct node **min = cur;
	while (*cur != NULL) {
		if (pkt_get_seqnum((*cur)->pkt) < pkt_get_seqnum((*min)->pkt)) {
			min = cur;
		}
		cur = &(*cur)->next;
	}
	return min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2d53
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x19a0
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x19a0
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x2d42
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x2d00
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sprt[P]lossless-transport/src/window.c
// Function: window_peek_min_seqnum
pkt_t *window_peek_min_seqnum(window_t *w) {
	struct node **min = window_find_min_seqnum(w);
	if (*min == NULL) {
		return NULL;
	}
	return (*min)->pkt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ce0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2d8d
movq $0x0, -0x8(%rbp)
jmp 0x2d9b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sprt[P]lossless-transport/src/receiver.c
// Function: wait_for_client
int wait_for_client(void) {
	char buf[MAX_PACKET_SIZE];
	struct sockaddr_in6 addr;
	socklen_t addrlen = sizeof (addr);

	/* Wait for a packet from anyone */
	if (recvfrom(sockfd, buf, MAX_PACKET_SIZE, MSG_PEEK, (struct sockaddr *) &addr, &addrlen) == -1) {
		log_perror("recvfrom");
		return -1;
	}

	/* For UDP, connecting merely implies setting the address to which data
	 * is sent by default, and the only address from which data is received. */
	if (connect(sockfd, (struct sockaddr *) &addr, addrlen) == -1) {
		log_perror("connect");
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movl $0x1c, -0x240(%rbp)
movl 0x4339(%rip), %edi      # 0x7134
leaq -0x220(%rbp), %rsi
movl $0x210, %edx            # imm = 0x210
movl $0x2, %ecx
leaq -0x23c(%rbp), %r8
leaq -0x240(%rbp), %r9
callq 0x1130
cmpq $-0x1, %rax
jne 0x2e3a
leaq 0x13c2(%rip), %rdi      # 0x41ee
callq 0x1d80
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e73
movl 0x42f4(%rip), %edi      # 0x7134
movl -0x240(%rbp), %edx
leaq -0x23c(%rbp), %rsi
callq 0x11d0
cmpl $-0x1, %eax
jne 0x2e6c
leaq 0x1314(%rip), %rdi      # 0x4172
callq 0x1d80
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e73
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sprt[P]lossless-transport/src/receiver.c
// Function: main
int main(int argc, char **argv) {
	parse_args(argc, argv, &hostname, &port, &filename);

	if (filename == NULL) {
		outfile = stdout;
	} else {
		outfile = fopen(filename, "wb+");
		if (outfile == NULL) {
			exit_perror("fopen");
		}
	}

	w = window_create(MAX_WINDOW_SIZE, MAX_WINDOW_SIZE, 255);
	if (w == NULL) {
		exit_msg("Could not create window\n");
	}

	struct sockaddr_in6 addr;
	const char *err = real_address(hostname, &addr);
	if (err != NULL) {
		exit_msg("real_address: %s\n", err);
	}

	/* Bind the socket */
	sockfd = create_socket(&addr, port, NULL, -1);
	if (sockfd == -1) {
		exit(1);
	}

	log_msg("Waiting for sender...\n");
	if (wait_for_client() == -1) {
		exit_msg("Error waiting for sender\n");
	}

	log_msg("Received first packet, connected\n");

	while (true) {
		/* This is probably the line you're looking for */
		main_loop();
	}

	window_free(w);
	fclose(outfile);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x3f0c(%rip), %rdx      # 0x7580
leaq 0x3f0d(%rip), %rcx      # 0x7588
leaq 0x3f0e(%rip), %r8       # 0x7590
callq 0x2010
cmpq $0x0, 0x3f01(%rip)      # 0x7590
jne 0x36a4
movq 0x3930(%rip), %rax      # 0x6fc8
movq (%rax), %rax
movq %rax, 0x3ed6(%rip)      # 0x7578
jmp 0x36d6
movq 0x3ee5(%rip), %rdi      # 0x7590
leaq 0xd7f(%rip), %rsi       # 0x4431
callq 0x1160
movq %rax, 0x3eba(%rip)      # 0x7578
cmpq $0x0, 0x3eb2(%rip)      # 0x7578
jne 0x36d4
leaq 0xd66(%rip), %rdi       # 0x4435
callq 0x1e50
jmp 0x36d6
movl $0x1f, %esi
movl $0xff, %edx
movq %rsi, %rdi
callq 0x2590
movq %rax, 0x3e81(%rip)      # 0x7570
cmpq $0x0, 0x3e79(%rip)      # 0x7570
jne 0x3707
leaq 0xd3b(%rip), %rdi       # 0x443b
movb $0x0, %al
callq 0x1da0
movq 0x3e72(%rip), %rdi      # 0x7580
leaq -0x2c(%rbp), %rsi
callq 0x2160
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3734
movq -0x38(%rbp), %rsi
leaq 0xd27(%rip), %rdi       # 0x4454
movb $0x0, %al
callq 0x1da0
movzwl 0x3e4d(%rip), %esi      # 0x7588
leaq -0x2c(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2230
movl %eax, 0x39e1(%rip)      # 0x7134
cmpl $-0x1, 0x39da(%rip)     # 0x7134
jne 0x3766
movl $0x1, %edi
callq 0x11c0
leaq 0xcf9(%rip), %rdi       # 0x4466
movb $0x0, %al
callq 0x1cd0
callq 0x2de0
cmpl $-0x1, %eax
jne 0x378c
leaq 0xcf8(%rip), %rdi       # 0x447d
movb $0x0, %al
callq 0x1da0
leaq 0xd04(%rip), %rdi       # 0x4497
movb $0x0, %al
callq 0x1cd0
callq 0x2e80
jmp 0x379a
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/tst/hex.c
// Function: main
int main() {
    for (char a = 'a'; a <= 'f'; a++) {
        assert(isHex(a));
    }
    for (char a = 'A'; a <= 'F'; a++) {
        assert(isHex(a));
    }
    for (char a = '0'; a <= '9'; a++) {
        assert(isHex(a));
    }

    const char thirtySix[] = "24";
    uint8_t parsedThirtySix = hexString16ToUint8(thirtySix);
    assert(parsedThirtySix == 36);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movb $0x61, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0x11a7
movsbl -0x5(%rbp), %edi
callq 0x1290
cmpl $0x0, %eax
je 0x117c
jmp 0x119b
leaq 0xe81(%rip), %rdi       # 0x2004
leaq 0xe83(%rip), %rsi       # 0x200d
movl $0x7, %edx
leaq 0xe81(%rip), %rcx       # 0x2017
callq 0x1030
jmp 0x119d
movb -0x5(%rbp), %al
addb $0x1, %al
movb %al, -0x5(%rbp)
jmp 0x1163
movb $0x41, -0x6(%rbp)
movsbl -0x6(%rbp), %eax
cmpl $0x46, %eax
jg 0x11ef
movsbl -0x6(%rbp), %edi
callq 0x1290
cmpl $0x0, %eax
je 0x11c4
jmp 0x11e3
leaq 0xe39(%rip), %rdi       # 0x2004
leaq 0xe3b(%rip), %rsi       # 0x200d
movl $0xa, %edx
leaq 0xe39(%rip), %rcx       # 0x2017
callq 0x1030
jmp 0x11e5
movb -0x6(%rbp), %al
addb $0x1, %al
movb %al, -0x6(%rbp)
jmp 0x11ab
movb $0x30, -0x7(%rbp)
movsbl -0x7(%rbp), %eax
cmpl $0x39, %eax
jg 0x1237
movsbl -0x7(%rbp), %edi
callq 0x1290
cmpl $0x0, %eax
je 0x120c
jmp 0x122b
leaq 0xdf1(%rip), %rdi       # 0x2004
leaq 0xdf3(%rip), %rsi       # 0x200d
movl $0xd, %edx
leaq 0xdf1(%rip), %rcx       # 0x2017
callq 0x1030
jmp 0x122d
movb -0x7(%rbp), %al
addb $0x1, %al
movb %al, -0x7(%rbp)
jmp 0x11f3
movw 0xde4(%rip), %ax        # 0x2022
movw %ax, -0xa(%rbp)
movb 0xddc(%rip), %al        # 0x2024
movb %al, -0x8(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x1310
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %eax
cmpl $0x24, %eax
jne 0x1262
jmp 0x1281
leaq 0xdbc(%rip), %rdi       # 0x2025
leaq 0xd9d(%rip), %rsi       # 0x200d
movl $0x12, %edx
leaq 0xd9b(%rip), %rcx       # 0x2017
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/hex.h
// Function: isHex
static inline int isHex(char h) {
    if ('0' <= h && h <= '9') {
        return 1;
    }
    if ('a' <= h && h <= 'f') {
        return 1;
    }
    if ('A' <= h && h <= 'F') {
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x12b9
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x12b9
movl $0x1, -0x4(%rbp)
jmp 0x12fe
movsbl -0x5(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x12d8
movsbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0x12d8
movl $0x1, -0x4(%rbp)
jmp 0x12fe
movsbl -0x5(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x12f7
movsbl -0x5(%rbp), %eax
cmpl $0x46, %eax
jg 0x12f7
movl $0x1, -0x4(%rbp)
jmp 0x12fe
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/cooccur.c
// Function: hashsearch
HASHREC *hashsearch(HASHREC **ht, char *w) {
    HASHREC     *htmp, *hprv;
    unsigned int hval = HASHFN(w, TSIZE, SEED);
    for (hprv = NULL, htmp=ht[hval]; htmp != NULL && scmp(htmp->word, w) != 0; hprv = htmp, htmp = htmp->next);
    if ( htmp != NULL && hprv!=NULL ) { // move to front on access
        hprv->next = htmp->next;
        htmp->next = ht[hval];
        ht[hval] = htmp;
    }
    return(htmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x100000, %esi         # imm = 0x100000
movl $0x11b049, %edx         # imm = 0x11B049
callq 0x3130
movl %eax, -0x24(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x25(%rbp)
je 0x1322
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x30c0
cmpl $0x0, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x132b
jmp 0x1343
jmp 0x132d
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x12fd
cmpq $0x0, -0x18(%rbp)
je 0x1383
cmpq $0x0, -0x20(%rbp)
je 0x1383
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/cooccur.c
// Function: hashinsert
void hashinsert(HASHREC **ht, char *w, long long id) {
    HASHREC     *htmp, *hprv;
    unsigned int hval = HASHFN(w, TSIZE, SEED);
    for (hprv = NULL, htmp = ht[hval]; htmp != NULL && scmp(htmp->word, w) != 0; hprv = htmp, htmp = htmp->next);
    if (htmp == NULL) {
        htmp = (HASHREC *) malloc(sizeof(HASHREC));
        htmp->word = (char *) malloc(strlen(w) + 1);
        strcpy(htmp->word, w);
        htmp->num = id;
        htmp->next = NULL;
        if (hprv == NULL) ht[hval] = htmp;
        else hprv->next = htmp;
    }
    else fprintf(stderr, "Error, duplicate entry located: %s.\n",htmp->word);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x100000, %esi         # imm = 0x100000
movl $0x11b049, %edx         # imm = 0x11B049
callq 0x3130
movl %eax, -0x2c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x2d(%rbp)
je 0x13f6
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x30c0
cmpl $0x0, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x13ff
jmp 0x1417
jmp 0x1401
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x13d1
cmpq $0x0, -0x20(%rbp)
jne 0x1499
movl $0x18, %edi
callq 0x1150
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1150
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1060
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x28(%rbp)
jne 0x148b
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x1497
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x14b8
movq 0x5b58(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x2baf(%rip), %rsi      # 0x4060
movb $0x0, %al
callq 0x1130
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/cooccur.c
// Function: write_chunk
int write_chunk(CREC *cr, long long length, FILE *fout) {
    if (length == 0) return 0;

    long long a = 0;
    CREC old = cr[a];
    
    for (a = 1; a < length; a++) {
        if (cr[a].word1 == old.word1 && cr[a].word2 == old.word2) {
            old.val += cr[a].val;
            continue;
        }
        fwrite(&old, sizeof(CREC), 1, fout);
        old = cr[a];
    }
    fwrite(&old, sizeof(CREC), 1, fout);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x14e7
movl $0x0, -0x4(%rbp)
jmp 0x15d4
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x15b6
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x38(%rbp), %eax
jne 0x1570
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x34(%rbp), %eax
jne 0x1570
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x15a5
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x10, %esi
movl $0x1, %edx
callq 0x11b0
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1515
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x10, %esi
movl $0x1, %edx
callq 0x11b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/cooccur.c
// Function: insert
void insert(CRECID *pq, CRECID new, int size) {
    int j = size - 1, p;
    pq[j] = new;
    while ( (p=(j-1)/2) >= 0 ) {
        if (compare_crecid(pq[p],pq[j]) > 0) {swap_entry(pq,p,j); j = p;}
        else break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rcx
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x17c0
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x1620
cmpl $0x0, %eax
jle 0x17b9
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1660
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x17bb
jmp 0x17c0
jmp 0x1731
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/cooccur.c
// Function: merge_write
int merge_write(CRECID new, CRECID *old, FILE *fout) {
    if (new.word1 == old->word1 && new.word2 == old->word2) {
        old->val += new.val;
        return 0; // Indicates duplicate entry
    }
    fwrite(old, sizeof(CREC), 1, fout);
    *old = new;
    return 1; // Actually wrote to file
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1a72
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x1a72
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1aae
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x10, %esi
movl $0x1, %edx
callq 0x11b0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/cooccur.c
// Function: free_resources
void free_resources(HASHREC** vocab_hash, CREC *cr, long long *lookup, 
                    long long *history, real *bigram_table) {
    free_table(vocab_hash);
    free(cr);
    free(lookup);
    free(history);
    free(bigram_table);
}

// 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 %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3420
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: cmatrix
char **cmatrix(int nsam, int len)
{
	int i;
	char **m;
	if (!(m = (char**)malloc((size_t)nsam*sizeof(char*))))
		perror("alloc error in cmatrix");
	for (i=0; i < nsam; i++)
		if (!(m[i] = (char*)malloc((size_t)len*sizeof(char))))
			perror("alloc error in cmatric. 2");
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x10f0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2cb1
leaq 0x55c3(%rip), %rdi      # 0x826f
callq 0x1070
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2cf8
movslq -0x8(%rbp), %rdi
shlq $0x0, %rdi
callq 0x10f0
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x2ceb
leaq 0x55a0(%rip), %rdi      # 0x8286
callq 0x1070
jmp 0x2ced
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2cb8
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: prtree
void prtree(struct node *ptree, int nsam)
{
	int i;
	int *descl = (int*)malloc((size_t)(2*nsam-1)*sizeof(int));
	int *descr = (int*)malloc((size_t)(2*nsam-1)*sizeof(int));

	for (i=0; i < 2*nsam-1; i++)
		descl[i] = descr[i] = -1;
	for (i=0; i <  2*nsam-2; i++)
	{
		if (descl[(ptree+i)->abv] == -1)
			descl[(ptree+i)->abv] = i;
		else
			descr[(ptree+i)->abv] = i;
	}
	parens(ptree, descl, descr, 2*nsam-2);
	free(descl);
	free(descr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll %eax
subl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x10f0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
shll %eax
subl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x10f0
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x38be
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3886
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0x3937
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x390e
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x392a
movl -0x10(%rbp), %edx
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x392c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x38c5
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0xc(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
callq 0x4660
movq -0x18(%rbp), %rdi
callq 0x10c0
movq -0x20(%rbp), %rdi
callq 0x10c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: ndes_setup
void ndes_setup(struct node *ptree, int nsam)
{
	int i;
	for (i=0; i < nsam; i++)
		(ptree + i)->ndes = 1;
	for (i=nsam; i < 2*nsam-1; i++)
		(ptree+i)->ndes = 0;
	for (i=0; i < 2*nsam-2; i++)
		(ptree+((ptree+i)->abv))->ndes += (ptree+i)->ndes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x39ab
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x1, 0x4(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3982
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x39e1
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x4(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x39b1
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0x3a37
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movslq -0x10(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
movslq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x39e8
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: ttime
double ttime(struct node *ptree, int nsam)
{
	int i;
	double t = (ptree+2*nsam-2)->time;

	for (i=nsam; i < 2*nsam-1; i++)
		t += (ptree+i)->time;
	
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd -0x18(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3aa6
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3a6e
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: ttimemf
double ttimemf(struct node *ptree, int nsam, int mfreq)
{
	int i;
	double t = 0;

	for (i=0; i < 2*nsam-2; i++)
		if (((ptree+i)->ndes >= mfreq) && ((ptree+i)->ndes <= nsam - mfreq))
			t += (ptree+(ptree+i)->abv)->time - (ptree+i)->time;
	
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0x3b63
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x10(%rbp), %eax
jl 0x3b53
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl -0xc(%rbp), %ecx
subl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jg 0x3b53
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
subsd 0x8(%rax), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x3b55
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3acd
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: poisso
int poisso(double u)
{
	int i = 1;
	double cump, ru, p;

	if (u > 30.0)
	{
		i = (int)(0.5+gasdev(u,u));
		if (i < 0)
			return 0;
		else
			return i;
	} 
	ru = genrand_real3();
	p = exp(-u);
	if (ru < p)
		return 0;
	cump = p;
	while (ru > (cump += (p *= u/i)) )
		i++;
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x4487(%rip), %xmm1     # 0x8018
ucomisd %xmm1, %xmm0
jbe 0x3bd9
movsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x49e0
movaps %xmm0, %xmm1
movsd 0x446f(%rip), %xmm0     # 0x8020
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x3bce
movl $0x0, -0x4(%rbp)
jmp 0x3c6a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3c6a
callq 0x4ee0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x1160
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3c22
movl $0x0, -0x4(%rbp)
jmp 0x3c6a
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
cvtsi2sdl -0x14(%rbp), %xmm2
divsd %xmm2, %xmm1
mulsd -0x30(%rbp), %xmm1
movsd %xmm1, -0x30(%rbp)
addsd -0x20(%rbp), %xmm1
movsd %xmm1, -0x20(%rbp)
ucomisd %xmm1, %xmm0
jbe 0x3c64
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3c2c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: biggerlist
int biggerlist(int nsam, char **list)
{
	int i;
	for (i=0; i < nsam; i++)
	{
		list[i] = (char*)realloc(list[i], (size_t)maxsites*sizeof(char));
		if (list[i] == NULL)
			perror("realloc error. bigger");
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3cf2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl 0x7420(%rip), %eax      # 0xb0d0
movl %eax, %esi
shlq $0x0, %rsi
callq 0x1130
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x3ce5
leaq 0x4579(%rip), %rdi      # 0x8259
callq 0x1070
jmp 0x3ce7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3c96
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: make_gametes
int make_gametes(int nsam, int mfreq, struct node *ptree, double tt, int newsites, int ns, char **list)
{
	int tip, j, node;

	for (j=ns; j < ns+newsites; j++)
	{
		if (mfreq == 1)
			node = pickb(nsam, ptree, tt);
		else
			node = pickbmf(nsam, mfreq, ptree, tt);
		for (tip=0; tip < nsam; tip++)
		{
			if (tdesn(ptree, tip, node))
				list[tip][j] = STATE1;
			else
				list[tip][j] = STATE2;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x20(%rbp), %ecx
addl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x3dd6
cmpl $0x1, -0x8(%rbp)
jne 0x3d55
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x4440
movl %eax, -0x34(%rbp)
jmp 0x3d6c
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movsd -0x18(%rbp), %xmm0
callq 0x4500
movl %eax, -0x34(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3dc6
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x34(%rbp), %edx
callq 0x4600
cmpl $0x0, %eax
je 0x3da5
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movb $0x31, (%rax,%rcx)
jmp 0x3db9
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movb $0x30, (%rax,%rcx)
jmp 0x3dbb
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3d73
jmp 0x3dc8
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3d28
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: locate
int locate(int n, double beg, double len, double *ptr)
{
	int i;
	ordran(n, ptr);
	for (i=0; i < n; i++)
		ptr[i] = beg+ptr[i]*len;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x3f50
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3e4b
movsd -0x10(%rbp), %xmm1
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3e0c
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: mnmial
int mnmial(int n, int nclass, double p[], int rv[])
{
	int i, j;
	double x, s;

	for (i=0; i < nclass; i++)
		rv[i] = 0;
	for (i=0; i < n; i++)
	{
		x = genrand_real3();
		j = 0;
		s = p[0];
		while ((x > s) && (j < (nclass-1)))
			s += p[++j];
		rv[j]++;
	}
	return j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x3e9f
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3e7d
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3f3b
callq 0x4ee0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
xorl %eax, %eax
ucomisd -0x30(%rbp), %xmm0
movb %al, -0x31(%rbp)
jbe 0x3ef2
movl -0x20(%rbp), %eax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x3efb
jmp 0x3f1c
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x20(%rbp)
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x3ed0
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ea6
movl -0x20(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: free_eventlist
void free_eventlist(struct devent *pt, int npop)
{
	int pop;
	struct devent *next;
   
	while (pt != 0)
	{
		next = pt->nextde;
		if (pt->detype == 'a')
		{
			for (pop=0; pop < npop; pop++)
				free((pt->mat)[pop]);
			free(pt->mat);
		}
		free(pt);
		pt = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x432e
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x28(%rax), %eax
cmpl $0x61, %eax
jne 0x431b
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x430e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x42e6
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x10c0
movq -0x8(%rbp), %rdi
callq 0x10c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x42bf
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: argcheck
void argcheck(int arg, int argc, char *argv[])
{
	if ((arg >= argc ) || (argv[arg][0] == '-'))
	{
		fprintf(stderr, "not enough arguments after %s\n", argv[arg-1]);
		fprintf(stderr, "For usage type: msmove<return>\n");
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x436e
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x43b9
movq 0x6c6b(%rip), %rax      # 0xafe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x4136(%rip), %rsi      # 0x84c6
movb $0x0, %al
callq 0x1110
movq 0x6c42(%rip), %rax      # 0xafe0
movq (%rax), %rdi
leaq 0x413d(%rip), %rsi      # 0x84e5
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: addtoelist
void addtoelist(struct devent *pt, struct devent *elist) 
{
	struct devent *plast, *pevent, *ptemp;

	pevent = elist;
	while ((pevent != 0) && (pevent->time <= pt->time))
	{
		plast = pevent;
		pevent = pevent->nextde;
	}
	ptemp = plast->nextde;
	plast->nextde = pt;
	pt->nextde = ptemp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0x43fa
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4403
jmp 0x4419
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x43d4
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: pickb
int pickb(int nsam, struct node *ptree, double tt)
{
	int i;
	double y = 0;
	double x = genrand_real3()*tt;

	for (i=0; i < 2*nsam-2; i++)
	{
		y += (ptree+(ptree+i)->abv)->time - (ptree+i)->time;
		if (y >= x)
			return i;
	}

	return 2*nsam-3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x4ee0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x8(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0x44e2
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
subsd 0x8(%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jb 0x44d5
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x44ed
jmp 0x44d7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4472
movl -0x8(%rbp), %eax
shll %eax
subl $0x3, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: pickbmf
int pickbmf(int nsam, int mfreq, struct node *ptree, double tt)
{
	int i;
	int lastbranch = 0;
	double x = genrand_real3()*tt;
	double y = 0;

	for (i=0; i < 2*nsam-2; i++)
	{
		if (((ptree+i)->ndes >= mfreq) && ((ptree+i)->ndes <= nsam - mfreq))
		{
			y += (ptree+(ptree+i)->abv)->time - (ptree+i)->time;
			lastbranch = i;
		}
		if (y >= x)
			return i;
	}

	return lastbranch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
callq 0x4ee0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x8(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0x45ec
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0x45c8
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl -0x8(%rbp), %ecx
subl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jg 0x45c8
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
subsd 0x8(%rax), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jb 0x45dc
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x45f2
jmp 0x45de
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x453c
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: tdesn
int tdesn(struct node *ptree, int tip, int node)
{
	int k;

	for (k=tip; k < node; k = (ptree+k)->abv);

	if (k == node)
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4634
jmp 0x461e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x4614
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x4645
movl $0x1, -0x4(%rbp)
jmp 0x464c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: parens
void parens(struct node *ptree, int *descl, int *descr, int noden)
{
	double time;

	if (descl[noden] == -1)
		fprintf(stdout, "%d:%5.3lf", noden+1, (ptree+((ptree+noden)->abv))->time);
	else
	{
		fprintf(stdout, "(");
		parens(ptree, descl, descr, descl[noden]);
		fprintf(stdout, ",");
		parens(ptree, descl, descr, descr[noden]);
		if ((ptree+noden)->abv == 0)
			fprintf(stdout, ");\n"); 
		else
		{
			time = (ptree+(ptree+noden)->abv)->time - (ptree+noden)->time;
			fprintf(stdout, "):%5.3lf", time);
		}
	}
}

// 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 -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x46ca
movq 0x693c(%rip), %rax      # 0xafc8
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
leaq 0x46ad(%rip), %rsi      # 0x8d6b
movb $0x1, %al
callq 0x1110
jmp 0x47ba
movq 0x68f7(%rip), %rax      # 0xafc8
movq (%rax), %rdi
leaq 0x469a(%rip), %rsi      # 0x8d75
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
callq 0x4660
movq 0x68c3(%rip), %rax      # 0xafc8
movq (%rax), %rdi
leaq 0x4668(%rip), %rsi      # 0x8d77
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
callq 0x4660
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x4760
movq 0x687b(%rip), %rax      # 0xafc8
movq (%rax), %rdi
leaq 0x4622(%rip), %rsi      # 0x8d79
movb $0x0, %al
callq 0x1110
jmp 0x47b8
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq 0x6826(%rip), %rax      # 0xafc8
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
leaq 0x45cc(%rip), %rsi      # 0x8d7d
movb $0x1, %al
callq 0x1110
jmp 0x47ba
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: ranvec
int ranvec(int n, double pbuf[])
{
	int i;
	for (i=0; i < n; i++)
		pbuf[i] = genrand_real3();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x486b
callq 0x4ee0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4846
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: order
int order(int n, double pbuf[])
{
	int gap, i, j;
	double temp;

	for (gap=n/2; gap > 0; gap /= 2)
		for (i=gap; i < n; i++)
			for (j=i-gap; j >= 0 && pbuf[j] > pbuf[j+gap]; j -= gap)
			{
				temp = pbuf[j];
				pbuf[j] = pbuf[j+gap];
				pbuf[j+gap] = temp;
			}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x4974
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x495f
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x29(%rbp)
jl 0x48ee
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
ucomisd (%rax,%rcx,8), %xmm0
seta %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x48f7
jmp 0x494f
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x48be
jmp 0x4951
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x48a9
jmp 0x4961
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
jmp 0x4899
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: dbinom
int dbinom(int n, double p)
{
	int i, s;
	for (i=0, s=0; i < n; i++) 
		if (genrand_real3() <= p)
			++s;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x49cf
callq 0x4ee0
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x49c2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x49c4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x499e
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)