LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/unix.c
// Function: jlseek
off_t jlseek(struct jfs *fs, off_t offset, int whence)
{
	off_t rv;

	pthread_mutex_lock(&(fs->lock));
	rv = lseek(fs->fd, offset, whence);
	pthread_mutex_unlock(&(fs->lock));

	return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
callq 0x25f0
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2200
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
callq 0x23a0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/ansi.c
// Function: jfopen
struct jfs *jfopen(const char *path, const char *mode)
{
	int flags;
	int pos_at_the_beginning;
	struct jfs *fs;

	if (strlen(mode) < 1)
		return NULL;

	if (mode[0] == 'r') {
		pos_at_the_beginning = 1;
		if (strlen(mode) > 1 && strchr(mode, '+'))
			flags = O_RDWR;
		else
			flags = O_RDONLY;
	} else if (mode[0] == 'a') {
		if (strlen(mode) > 1 && strchr(mode, '+'))
			pos_at_the_beginning = 1;
		else
			pos_at_the_beginning = 0;
		flags = O_RDWR | O_CREAT | O_APPEND;
	} else if (mode[0] == 'w') {
		pos_at_the_beginning = 1;
		flags = O_RDWR | O_CREAT | O_TRUNC;
	} else {
		return NULL;
	}

	fs = jopen(path, flags, 0666, 0);
	if (fs == NULL)
		return NULL;

	if (pos_at_the_beginning)
		lseek(fs->fd, 0, SEEK_SET);
	else
		lseek(fs->fd, 0, SEEK_END);

	return fs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2140
cmpq $0x1, %rax
jae 0x635c
movq $0x0, -0x8(%rbp)
jmp 0x6473
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x63a4
movl $0x1, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2140
cmpq $0x1, %rax
jbe 0x639b
movq -0x18(%rbp), %rdi
movl $0x2b, %esi
callq 0x2190
cmpq $0x0, %rax
je 0x639b
movl $0x2, -0x1c(%rbp)
jmp 0x63a2
movl $0x0, -0x1c(%rbp)
jmp 0x6416
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jne 0x63ec
movq -0x18(%rbp), %rdi
callq 0x2140
cmpq $0x1, %rax
jbe 0x63dc
movq -0x18(%rbp), %rdi
movl $0x2b, %esi
callq 0x2190
cmpq $0x0, %rax
je 0x63dc
movl $0x1, -0x20(%rbp)
jmp 0x63e3
movl $0x0, -0x20(%rbp)
movl $0x442, -0x1c(%rbp)     # imm = 0x442
jmp 0x6414
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x77, %eax
jne 0x6408
movl $0x1, -0x20(%rbp)
movl $0x242, -0x1c(%rbp)     # imm = 0x242
jmp 0x6412
movq $0x0, -0x8(%rbp)
jmp 0x6473
jmp 0x6414
jmp 0x6416
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %ecx, %ecx
callq 0x22d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x643e
movq $0x0, -0x8(%rbp)
jmp 0x6473
cmpl $0x0, -0x20(%rbp)
je 0x6457
movq -0x28(%rbp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2200
jmp 0x646b
movq -0x28(%rbp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2200
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/ansi.c
// Function: jfclose
int jfclose(struct jfs *stream)
{
	int rv;
	rv = jclose(stream);
	free(stream);

	if (rv == 0)
		return 0;
	else
		return EOF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x24e0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2040
cmpl $0x0, -0x14(%rbp)
jne 0x64b0
movl $0x0, -0x4(%rbp)
jmp 0x64b7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/ansi.c
// Function: jfreopen
struct jfs *jfreopen(const char *path, const char *mode, struct jfs *stream)
{
	if (stream)
		jfclose(stream);

	stream = jfopen(path, mode);
	return stream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x64e4
movq -0x18(%rbp), %rdi
callq 0x2580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2340
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/ansi.c
// Function: jfread
size_t jfread(void *ptr, size_t size, size_t nmemb, struct jfs *stream)
{
	int rv;
	rv = jread(stream, ptr, size * nmemb);

	if (rv <= 0)
		return 0;

	return rv / size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
imulq -0x20(%rbp), %rdx
callq 0x20f0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jg 0x6541
movq $0x0, -0x8(%rbp)
jmp 0x6551
movslq -0x2c(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/ansi.c
// Function: jfwrite
size_t jfwrite(const void *ptr, size_t size, size_t nmemb, struct jfs *stream)
{
	int rv;
	rv = jwrite(stream, ptr, size * nmemb);

	if (rv <= 0)
		return 0;

	return rv / size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
imulq -0x20(%rbp), %rdx
callq 0x2310
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jg 0x65a1
movq $0x0, -0x8(%rbp)
jmp 0x65b1
movslq -0x2c(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/ansi.c
// Function: jfeof
int jfeof(struct jfs *stream)
{
	/* ANSI expects that when an EOF is reached in any operation (like
	 * fread() or fwrite()) some internal flag is set, and this function
	 * can be used to check if it is set or unset.
	 * As we don't do that (it's pointless for this kind of I/O), this
	 * just checks if the file pointer is at the end of the file */

	off_t curpos, endpos;

	pthread_mutex_lock(&(stream->lock));

	curpos = lseek(jfileno(stream), 0, SEEK_CUR);
	endpos = lseek(jfileno(stream), 0, SEEK_END);

	lseek(jfileno(stream), curpos, SEEK_SET);

	pthread_mutex_unlock(&(stream->lock));

	if (curpos >= endpos)
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x25f0
movq -0x10(%rbp), %rdi
callq 0x2480
movl %eax, %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x2200
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2480
movl %eax, %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2200
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2480
movl %eax, %edi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x2200
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x23a0
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x6659
movl $0x1, -0x4(%rbp)
jmp 0x6660
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/ansi.c
// Function: jfseek
int jfseek(struct jfs *stream, long offset, int whence)
{
	off_t pos;

	pthread_mutex_lock(&(stream->lock));
	pos = lseek(stream->fd, offset, whence);
	pthread_mutex_unlock(&(stream->lock));

	/* fseek returns 0 on success, -1 on error */
	if (pos == -1)
		return 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x25f0
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2200
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x23a0
cmpq $-0x1, -0x28(%rbp)
jne 0x66e3
movl $0x1, -0x4(%rbp)
jmp 0x66ea
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/generic-rotput.c
// Function: main
int
main(void)
{
    int nextpe;
    int me, npes;
    int src;
    int *dest;

    shmem_init();
    me = shmem_my_pe();
    npes = shmem_n_pes();

    nextpe = (me + 1) % npes;

    src = nextpe;

    dest = (int *) shmem_malloc(sizeof(*dest));
    assert(dest != NULL);

    *dest = -1;
    shmem_barrier_all();

    shmem_put(dest, &src, 1, nextpe);

    shmem_barrier_all();

    printf("%4d: got %4d: ", me, *dest);
    if (*dest == me) {
        printf("CORRECT");
    }
    else {
        printf("WRONG, expected %d", me);
    }
    printf("\n");

    shmem_barrier_all();
    shmem_free(dest);
    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
callq 0x10b0
callq 0x1080
movl %eax, 0x1c(%rsp)
callq 0x1060
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
cltd
idivl 0x18(%rsp)
movl %edx, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x14(%rsp)
movl $0x4, %edi
callq 0x1090
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1224
jmp 0x1243
leaq 0xdd9(%rip), %rdi       # 0x2004
leaq 0xddf(%rip), %rsi       # 0x2011
movl $0x4d, %edx
leaq 0xde4(%rip), %rcx       # 0x2022
callq 0x1050
movq 0x8(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
callq 0x10a0
movq 0x8(%rsp), %rdi
movl 0x20(%rsp), %ecx
leaq 0x14(%rsp), %rsi
movl $0x1, %edx
callq 0x1030
callq 0x10a0
movl 0x1c(%rsp), %esi
movq 0x8(%rsp), %rax
movl (%rax), %edx
leaq 0xdaf(%rip), %rdi       # 0x2031
movb $0x0, %al
callq 0x1040
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpl 0x1c(%rsp), %eax
jne 0x12a6
leaq 0xda3(%rip), %rdi       # 0x2040
movb $0x0, %al
callq 0x1040
jmp 0x12b8
movl 0x1c(%rsp), %esi
leaq 0xd97(%rip), %rdi       # 0x2048
movb $0x0, %al
callq 0x1040
leaq 0xd9c(%rip), %rdi       # 0x205b
movb $0x0, %al
callq 0x1040
callq 0x10a0
movq 0x8(%rsp), %rdi
callq 0x10c0
callq 0x1070
xorl %eax, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/child_exit_nonzero_status.c
// Function: main
int main() {
  libforks_ServerConn conn;

  check(libforks_start(&conn) == libforks_OK);

  int exit_fd;
  pid_t child_pid;

  libforks_Result r = libforks_fork(
    conn,
    &child_pid, // pid_ptr
    NULL, // socket_fd_ptr
    &exit_fd, // exit_fd_ptr
    child_main
  );
  check(r == libforks_OK);

  libforks_ExitEvent event;
  check(read(exit_fd, &event, sizeof event) == sizeof event);
  check(event.pid == child_pid);
  check(WIFEXITED(event.wait_status));
  check(WEXITSTATUS(event.wait_status) == 23);

  check(libforks_stop(conn) == libforks_OK);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1ab0
cmpl $0x0, %eax
jne 0x131f
jmp 0x1337
leaq 0x2cde(%rip), %rdi      # 0x4004
leaq 0x2cfc(%rip), %rsi      # 0x4029
movl $0xe, %edx
callq 0x1450
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x14(%rbp), %rcx
leaq 0x142(%rip), %r8        # 0x1490
callq 0x2280
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x135e
jmp 0x1376
leaq 0x2ce6(%rip), %rdi      # 0x404b
leaq 0x2cbd(%rip), %rsi      # 0x4029
movl $0x1a, %edx
callq 0x1450
movl -0x14(%rbp), %edi
leaq -0x24(%rbp), %rsi
movl $0x8, %edx
callq 0x1100
cmpq $0x8, %rax
jne 0x138f
jmp 0x13a7
leaq 0x2cc6(%rip), %rdi      # 0x405c
leaq 0x2c8c(%rip), %rsi      # 0x4029
movl $0x1d, %edx
callq 0x1450
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x13b1
jmp 0x13c9
leaq 0x2cd8(%rip), %rdi      # 0x4090
leaq 0x2c6a(%rip), %rsi      # 0x4029
movl $0x1e, %edx
callq 0x1450
movl -0x20(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x13d6
jmp 0x13ee
leaq 0x2cca(%rip), %rdi      # 0x40a7
leaq 0x2c45(%rip), %rsi      # 0x4029
movl $0x1f, %edx
callq 0x1450
movl -0x20(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x17, %eax
jne 0x1400
jmp 0x1418
leaq 0x2cbd(%rip), %rdi      # 0x40c4
leaq 0x2c1b(%rip), %rsi      # 0x4029
movl $0x20, %edx
callq 0x1450
movq -0x10(%rbp), %rdi
callq 0x2510
cmpl $0x0, %eax
jne 0x1428
jmp 0x1440
leaq 0x2cba(%rip), %rdi      # 0x40e9
leaq 0x2bf3(%rip), %rsi      # 0x4029
movl $0x22, %edx
callq 0x1450
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sos22[P]unexec/tests/iterate.c
// Function: main
int main() {
    for (unsigned x = 0; x < NR_ITERATIONS; x++) {
        dump_maps(x);
        char template[] = "iterateXXXXXX";
        close(mkstemp(template));
        printf("%d: in %s\n", x, template);
        double start  = now();
        int r = unexec(template, NULL);
        if (r < 0) err(1, "unexec");
        if (r == 0) {
            printf("%d: got restored after %f\n", x, now() - start);
            if (unlink(template) < 0) err(1, "unlink %s", template);
            continue; }
        printf("%d: unexec took %f\n", x, now() - start);
        if (chmod(template, 0700) < 0) err(1, "chmod");
        struct stat st;
        if (stat(template, &st) < 0) err(1, "stat %s", template);
        printf("%d: size %zx\n", x, st.st_size);
        execl(template, template, NULL);
        err(1, "execl %s", template); }
    return 0; }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x3e8, -0x8(%rbp)      # imm = 0x3E8
jae 0x13d5
movl -0x8(%rbp), %edi
callq 0x13e0
movq 0xdcb(%rip), %rax       # 0x2010
movq %rax, -0x16(%rbp)
movl 0xdc9(%rip), %eax       # 0x2018
movl %eax, -0xe(%rbp)
movw 0xdc3(%rip), %ax        # 0x201c
movw %ax, -0xa(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x10b0
movl %eax, %edi
callq 0x1080
movl -0x8(%rbp), %esi
leaq -0x16(%rbp), %rdx
leaq 0xda3(%rip), %rdi       # 0x201e
movb $0x0, %al
callq 0x1060
callq 0x1460
movsd %xmm0, -0x20(%rbp)
leaq -0x16(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10f0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x12b5
movl $0x1, %edi
leaq 0xd7b(%rip), %rsi       # 0x2029
movb $0x0, %al
callq 0x10a0
cmpl $0x0, -0x24(%rbp)
jne 0x130c
movl -0x8(%rbp), %eax
movl %eax, -0xbc(%rbp)
callq 0x1460
movl -0xbc(%rbp), %esi
subsd -0x20(%rbp), %xmm0
leaq 0xd55(%rip), %rdi       # 0x2030
movb $0x1, %al
callq 0x1060
leaq -0x16(%rbp), %rdi
callq 0x1040
cmpl $0x0, %eax
jge 0x1307
leaq -0x16(%rbp), %rdx
movl $0x1, %edi
leaq 0xd4b(%rip), %rsi       # 0x204b
movb $0x0, %al
callq 0x10a0
jmp 0x13c7
movl -0x8(%rbp), %eax
movl %eax, -0xc0(%rbp)
callq 0x1460
movl -0xc0(%rbp), %esi
subsd -0x20(%rbp), %xmm0
leaq 0xd29(%rip), %rdi       # 0x2055
movb $0x1, %al
callq 0x1060
leaq -0x16(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x10c0
cmpl $0x0, %eax
jge 0x1359
movl $0x1, %edi
leaq 0xd17(%rip), %rsi       # 0x2069
movb $0x0, %al
callq 0x10a0
leaq -0x16(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1090
cmpl $0x0, %eax
jge 0x1385
leaq -0x16(%rbp), %rdx
movl $0x1, %edi
leaq 0xcf1(%rip), %rsi       # 0x206f
movb $0x0, %al
callq 0x10a0
movl -0x8(%rbp), %esi
movq -0x88(%rbp), %rdx
leaq 0xce1(%rip), %rdi       # 0x2077
movb $0x0, %al
callq 0x1060
leaq -0x16(%rbp), %rdi
leaq -0x16(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x1100
leaq -0x16(%rbp), %rdx
movl $0x1, %edi
leaq 0xcc5(%rip), %rsi       # 0x2085
movb $0x0, %al
callq 0x10a0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1229
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sos22[P]unexec/tests/iterate.c
// Function: dump_maps
static void dump_maps(int x) {
    FILE *f = fopen("/proc/self/maps", "r");
    char * lineptr = NULL;
    size_t sz = 0;
    while (getline(&lineptr, &sz, f) >= 0) printf("%d: %s", x, lineptr);
    free(lineptr);
    fclose(f); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0xc9c(%rip), %rdi       # 0x208e
leaq 0xca5(%rip), %rsi       # 0x209e
callq 0x10d0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10e0
cmpq $0x0, %rax
jl 0x1440
movl -0x4(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0xc69(%rip), %rdi       # 0x20a0
movb $0x0, %al
callq 0x1060
jmp 0x1412
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/main.c
// Function: read_entropy_from_file
static void
read_entropy_from_file(char *fname)
/*
 * A frontend has generated entropy for us.
 * Let us hope it did the right thing.
 * We give it credit for 4 bits entropy per byte.
 */
{
	FILE *fentr;
	int c;

	if (fname == 0) {
		fprintf(stderr, "No entropy file supplied\n");
		return;
	}
	fentr = fopen(fname, "r");
	if (fentr == NULL) {
		fprintf(stderr, "Cannot open %s\n", fname);
		return;
	}
	while ((c = getc(fentr)) >= 0) {
		collect_more((byte *) &c, sizeof(c), 4);
	}
	fclose(fentr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x685d
movq 0x67ae(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x3dc1(%rip), %rsi      # 0xa615
movb $0x0, %al
callq 0x2150
jmp 0x68c4
movq -0x8(%rbp), %rdi
leaq 0x40d2(%rip), %rsi      # 0xa93a
callq 0x2190
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6896
movq 0x6779(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3da2(%rip), %rsi      # 0xa62f
movb $0x0, %al
callq 0x2150
jmp 0x68c4
jmp 0x6898
movq -0x10(%rbp), %rdi
callq 0x21e0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x68bb
leaq -0x14(%rbp), %rdi
movl $0x4, %edx
movl %edx, %esi
callq 0x6e50
jmp 0x6898
movq -0x10(%rbp), %rdi
callq 0x2060
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/main.c
// Function: random_set
static void
random_set(char *hashstr, byte *sr)
/*
 * hashstr is a 40 byte string of hex characters
 * we convert it into a 20 byte(160 bit) binary value
 */
{
	int i;

	if (strlen(hashstr) != 2*RMDbytes) {
		fprintf(stderr, "Argument %s should be %d characters long\n",
			hashstr, 2*RMDbytes);
		exit(-1);
	}
	for (i=0; i<RMDbytes; i++)
		sr[i] = hexval(hashstr[2*i+1]) | (hexval(hashstr[2*i])<<4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2070
cmpq $0x28, %rax
je 0x699a
movq 0x6682(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3d00(%rip), %rsi      # 0xa684
movl $0x28, %ecx
movb $0x0, %al
callq 0x2150
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21d0
movl $0x0, -0x14(%rbp)
cmpl $0x14, -0x14(%rbp)
jge 0x69f9
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x6d80
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x6d80
movl %eax, %ecx
movl -0x18(%rbp), %eax
shll $0x4, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x69a1
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/main.c
// Function: checkduphash
static void
checkduphash(char *hash)
/*
 * Paranoia function: if in test we ever run into the same 160 bit number again
 * it is time to reevaluate our assumptions
 */
{
	FILE *fhist;
	char oldhash[MESSLEN];
	int hashlen;
	int counter, badentry;

	hashlen = strlen(hash);
	fhist = fopen(HISTNAME, "a+");
	if (fhist == NULL) {
		fprintf(stderr, "Couldn't open %s\n", HISTNAME);
		return;
	}
	counter = 0;
	badentry = 0;
	fseek(fhist, 0L, 0);
	while (readline(fhist, oldhash, MESSLEN)) {
		if (strlen(oldhash) != hashlen) {
			badentry++;
			continue;
		}
		if (strcmp(oldhash, hash) == 0) {
			fprintf(flog, "Panic: same hash, index %d\n", counter);
			fprintf(stderr, "Panic: same hash, index %d\n", counter);
			exit(-1);
		}
		counter++;
	}
	fprintf(fhist, "%s\n", hash);
	fclose(fhist);
	fprintf(flog, "Checked hash against %d previous hashes\n", counter);
	if (badentry) {
		fprintf(flog, "The file %s contained %d bad entries\n",
			HISTNAME, badentry);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2070
movl %eax, -0x84(%rbp)
leaq 0x3ca8(%rip), %rdi      # 0xa6cd
leaq 0x3cae(%rip), %rsi      # 0xa6da
callq 0x2190
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6a60
movq 0x65b5(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x3c90(%rip), %rsi      # 0xa6dd
leaq 0x3c79(%rip), %rdx      # 0xa6cd
movb $0x0, %al
callq 0x2150
jmp 0x6b92
movl $0x0, -0x88(%rbp)
movl $0x0, -0x8c(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2170
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x64, %edx
callq 0x5db0
cmpl $0x0, %eax
je 0x6b2d
leaq -0x80(%rbp), %rdi
callq 0x2070
movslq -0x84(%rbp), %rcx
cmpq %rcx, %rax
je 0x6ac4
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x6a83
leaq -0x80(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2120
cmpl $0x0, %eax
jne 0x6b19
movq 0x93c3(%rip), %rdi      # 0xfea0
movl -0x88(%rbp), %edx
leaq 0x3c05(%rip), %rsi      # 0xa6ef
movb $0x0, %al
callq 0x2150
movq 0x6500(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movl -0x88(%rbp), %edx
leaq 0x3be7(%rip), %rsi      # 0xa6ef
movb $0x0, %al
callq 0x2150
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21d0
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0x6a83
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3cb4(%rip), %rsi      # 0xa7f0
movb $0x0, %al
callq 0x2150
movq -0x10(%rbp), %rdi
callq 0x2060
movq 0x934d(%rip), %rdi      # 0xfea0
movl -0x88(%rbp), %edx
leaq 0x3bab(%rip), %rsi      # 0xa70b
movb $0x0, %al
callq 0x2150
cmpl $0x0, -0x8c(%rbp)
je 0x6b92
movq 0x9329(%rip), %rdi      # 0xfea0
movl -0x8c(%rbp), %ecx
leaq 0x3bb0(%rip), %rsi      # 0xa734
leaq 0x3b42(%rip), %rdx      # 0xa6cd
movb $0x0, %al
callq 0x2150
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/main.c
// Function: hexval
static int
hexval(char c)
/*
 * Convert characters '0'..'9', 'A'..'F' and 'a'..'f' to 0..15
 */
{

	if (c >= '0' && c <= '9')
		return c - '0';
	if (c >= 'a' && c <= 'f')
		return c - 'a' + 10;
	if (c >= 'A' && c <= 'F')
		return c - 'A' + 10;
	fprintf(stderr, "Character %c is not a hexchar\n", c);
	exit(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x6dac
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x6dac
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x6e14
movsbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x6dcd
movsbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0x6dcd
movsbl -0x5(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x6e14
movsbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jl 0x6dee
movsbl -0x5(%rbp), %eax
cmpl $0x46, %eax
jg 0x6dee
movsbl -0x5(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x6e14
movq 0x6203(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movsbl -0x5(%rbp), %edx
leaq 0x38ab(%rip), %rsi      # 0xa6ae
movb $0x0, %al
callq 0x2150
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21d0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: init_goedel
static void
init_goedel(FILE *out)
{
	int i;
	byte ten[L];

	/*
	 * Initialize the array with powers of ten
	 * We need them in the next function
	 */
	mp96_zero(ten);
	ten[L-1] = 10;
	mp96_one(powers_of_ten[0]);
	for (i=1; i<MAXDECIMALS; i++) {
		mp96_mul(powers_of_ten[i], powers_of_ten[i-1], ten);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5560
movb $0xa, -0xd(%rbp)
leaq 0x7b00(%rip), %rdi      # 0xff70
callq 0x5590
movl $0x1, -0xc(%rbp)
cmpl $0x1d, -0xc(%rbp)
jge 0x84be
movslq -0xc(%rbp), %rax
leaq 0x7ae3(%rip), %rdi      # 0xff70
imulq $0xc, %rax, %rax
addq %rax, %rdi
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltq
leaq 0x7acd(%rip), %rsi      # 0xff70
imulq $0xc, %rax, %rax
addq %rax, %rsi
leaq -0x18(%rbp), %rdx
callq 0x5750
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x847c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: print_goedel
static void
print_goedel(FILE *out, int boardno, hr_p hrp)
/*
 * Write out the internal 96 bit numbers as a decimal number
 *
 * Unlikely that anyone would ever want this in real life
 */
{
	dl_num *dnp = hrp->hr_value.hv_dnp;
	byte value[L];
	int i;
	int decimal;
	int zero_suppress;
	char outchar;

	mp96_assign(value, dnp->dn_num);
	zero_suppress = 1;
	for (i=MAXDECIMALS-1; i>=0; i--) {
		/*
		 * Since we do not have division we do repeated subtraction
		 */
		decimal = 0;
		while (mp96_cmp(value, powers_of_ten[i])>=0) {
			mp96_sub(value, value, powers_of_ten[i]);
			decimal++;
		}
		if (decimal) {
			outchar = decimal + '0';
			zero_suppress = 0;
		} else {
			/*
			 * Suppress leading zeroes
			 * Special case all zeroes also handled
			 * That will be the day....
			 */
			outchar = zero_suppress && i ? ' ' : '0';
		}
		putc(outchar, out);
		/*
		 * Intersperse with commas for readability
		 */
		if (i%3 == 0) {
			putc(i==0 ? '\n' : zero_suppress ? ' ' : ',', out);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x2c(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x55c0
movl $0x1, -0x38(%rbp)
movl $0x1c, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jl 0x8607
movl $0x0, -0x34(%rbp)
leaq -0x2c(%rbp), %rdi
movslq -0x30(%rbp), %rax
leaq 0x7a46(%rip), %rsi      # 0xff70
imulq $0xc, %rax, %rax
addq %rax, %rsi
callq 0x56f0
cmpl $0x0, %eax
jl 0x8565
leaq -0x2c(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
movslq -0x30(%rbp), %rax
leaq 0x7a22(%rip), %rdx      # 0xff70
imulq $0xc, %rax, %rax
addq %rax, %rdx
callq 0x5670
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x851b
cmpl $0x0, -0x34(%rbp)
je 0x857d
movl -0x34(%rbp), %eax
addl $0x30, %eax
movb %al, -0x39(%rbp)
movl $0x0, -0x38(%rbp)
jmp 0x85a8
xorl %eax, %eax
cmpl $0x0, -0x38(%rbp)
movb %al, -0x3a(%rbp)
je 0x8592
cmpl $0x0, -0x30(%rbp)
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %dl
movl $0x30, %eax
movl $0x20, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, -0x39(%rbp)
movsbl -0x39(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x2130
movl -0x30(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x85f7
cmpl $0x0, -0x30(%rbp)
jne 0x85d5
movl $0xa, %eax
movl %eax, -0x40(%rbp)
jmp 0x85eb
movl -0x38(%rbp), %edx
movl $0x2c, %eax
movl $0x20, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x2130
jmp 0x85f9
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x850a
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: init_stat
static void
init_stat(FILE *out)
{

	/*
	 * Warn of consequences of looking at statistics
	 */
	printf("\nStatistics will be produced in an accompanying file.\n");
	printf("Usage of these statistics for a decision on whether or when\n");
	printf("to play this set of deals is a violation of the spirit of the\n");
	printf("Laws of Duplicate Contract Bridge.\n\n");
	printf("STATISTICS ARE FOR DISPLAY PURPOSES ONLY!!\n\n");
	/*
	 * At this point initialize counters if non-zero
	 */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2620(%rip), %rdi      # 0xac43
movb $0x0, %al
callq 0x20a0
leaq 0x2649(%rip), %rdi      # 0xac7a
movb $0x0, %al
callq 0x20a0
leaq 0x2678(%rip), %rdi      # 0xacb7
movb $0x0, %al
callq 0x20a0
leaq 0x26a9(%rip), %rdi      # 0xacf6
movb $0x0, %al
callq 0x20a0
leaq 0x26c0(%rip), %rdi      # 0xad1b
movb $0x0, %al
callq 0x20a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: print_avg
static void
print_avg(FILE *out, int sum, int divisor, int decimals, char *termstr)
/*
 * Prevent use of floating point
 */
{
	int power_of_ten;
	int i;
	int result;

	power_of_ten = 1;
	for (i=0; i<decimals; i++)
		power_of_ten *= 10;

	sum *= power_of_ten;
	/*
	 * Make sure of proper rounding
	 */
	sum += divisor/2;
	result = sum/divisor;

	fprintf(out, "%d", result/power_of_ten);
	if (decimals) {
		fprintf(out, ".");
		for (i=0; i<decimals; i++) {
			result -= result/power_of_ten*power_of_ten;
			power_of_ten /= 10;
			fprintf(out, "%d", result/power_of_ten);
		}
	}
	fprintf(out, "%s", termstr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x91c1
imull $0xa, -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x91a7
movl -0x24(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cltd
idivl -0x10(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %eax
cltd
idivl -0x24(%rbp)
movl %eax, %edx
leaq 0x1a0f(%rip), %rsi      # 0xac09
movb $0x0, %al
callq 0x2150
cmpl $0x0, -0x14(%rbp)
je 0x9273
movq -0x8(%rbp), %rdi
leaq 0x1c16(%rip), %rsi      # 0xae28
movb $0x0, %al
callq 0x2150
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9271
movl -0x2c(%rbp), %eax
cltd
idivl -0x24(%rbp)
movl %eax, %ecx
imull -0x24(%rbp), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %eax
cltd
idivl -0x24(%rbp)
movl %eax, %edx
leaq 0x19aa(%rip), %rsi      # 0xac09
movb $0x0, %al
callq 0x2150
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x9220
jmp 0x9273
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x1ba8(%rip), %rsi      # 0xae2a
movb $0x0, %al
callq 0x2150
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/server_method.c
// Function: helloWorldMethod
static UA_StatusCode
helloWorldMethod(void *handle, const UA_NodeId objectId, size_t inputSize, const UA_Variant *input,
                 size_t outputSize, UA_Variant *output) {
        UA_String *inputStr = (UA_String*)input->data;
        UA_String tmp = UA_STRING_ALLOC("Hello ");
        if(inputStr->length > 0) {
            tmp.data = realloc(tmp.data, tmp.length + inputStr->length);
            memcpy(&tmp.data[tmp.length], inputStr->data, inputStr->length);
            tmp.length += inputStr->length;
        }
        UA_Variant_setScalarCopy(output, &tmp, &UA_TYPES[UA_TYPES_STRING]);
        UA_String_deleteMembers(&tmp);
        UA_LOG_INFO(logger, UA_LOGCATEGORY_SERVER, "Hello World was called");
        return UA_STATUSCODE_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
leaq 0x136a(%rip), %rdi      # 0x3109
callq 0x10f0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x1df9
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
addq (%rax), %rsi
callq 0x1100
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
callq 0x10c0
movq -0x30(%rbp), %rax
movq (%rax), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq 0x31d0(%rip), %rdx      # 0x4fd8
addq $0x1b8, %rdx            # imm = 0x1B8
callq 0x10b0
leaq -0x40(%rbp), %rdi
callq 0x2070
cmpq $0x0, 0x3293(%rip)      # 0x50b8
je 0x1e40
movl $0x2, %edi
movl $0x3, %esi
leaq 0x12d8(%rip), %rdx      # 0x3110
movb $0x0, %al
callq *0x3278(%rip)           # 0x50b8
jmp 0x1e42
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/server_method.c
// Function: IncInt32ArrayValuesMethod
static UA_StatusCode
IncInt32ArrayValuesMethod(void *handle, const UA_NodeId objectId, size_t inputSize,
                          const UA_Variant *input, size_t outputSize, UA_Variant *output) {
	UA_Variant_setArrayCopy(output, input->data, 5, &UA_TYPES[UA_TYPES_INT32]);
	for(size_t i = 0; i< input->arrayLength; i++)
		((UA_Int32*)output->data)[i] = ((UA_Int32*)input->data)[i] + 1;
	return UA_STATUSCODE_GOOD;
}

// 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 -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0x5, %edx
movq 0x30d4(%rip), %rcx      # 0x4fd8
addq $0xc8, %rcx
callq 0x1050
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1f55
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1f18
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/server_method.c
// Function: fooBarMethod
static UA_StatusCode
fooBarMethod(void *handle, const UA_NodeId objectId, size_t inputSize, const UA_Variant *input,
                 size_t outputSize, UA_Variant *output) {
	// Exactly the same as helloWorld, but returns foobar
        UA_String *inputStr = (UA_String*)input->data;
        UA_String tmp = UA_STRING_ALLOC("FooBar! ");
        if(inputStr->length > 0) {
            tmp.data = realloc(tmp.data, tmp.length + inputStr->length);
            memcpy(&tmp.data[tmp.length], inputStr->data, inputStr->length);
            tmp.length += inputStr->length;
        }
        UA_Variant_setScalarCopy(output, &tmp, &UA_TYPES[UA_TYPES_STRING]);
        UA_String_deleteMembers(&tmp);
        UA_LOG_INFO(logger, UA_LOGCATEGORY_SERVER, "Hello World was called");
        return UA_STATUSCODE_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
leaq 0x1198(%rip), %rdi      # 0x3127
callq 0x10f0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x1fe9
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
addq (%rax), %rsi
callq 0x1100
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
callq 0x10c0
movq -0x30(%rbp), %rax
movq (%rax), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq 0x2fe0(%rip), %rdx      # 0x4fd8
addq $0x1b8, %rdx            # imm = 0x1B8
callq 0x10b0
leaq -0x40(%rbp), %rdi
callq 0x2070
cmpq $0x0, 0x30a3(%rip)      # 0x50b8
je 0x2030
movl $0x2, %edi
movl $0x3, %esi
leaq 0x10e8(%rip), %rdx      # 0x3110
movb $0x0, %al
callq *0x3088(%rip)           # 0x50b8
jmp 0x2032
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeniko[P]CS214-Malloc-Free/Test7.c
// Function: main
void main()
{
    void* p = malloc(1);
    free(p);
    printf("p has been freed\n");
    free(p + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
leaq 0xea0(%rip), %rsi       # 0x2004
movl $0x6, %edx
callq 0x11c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xe87(%rip), %rsi       # 0x2004
movl $0x7, %edx
callq 0x13c0
leaq 0xe7e(%rip), %rdi       # 0x200c
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
leaq 0xe60(%rip), %rsi       # 0x2004
movl $0x9, %edx
callq 0x13c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/janmojzis[P]mcencrypt/mckeypair.c
// Function: main
int main(int argc, char **argv) {

    if (!checkfd(5, POLLOUT)) die_usage(NAME, "write publickey failed", "5>publickey 9>secretkey");
    if (!checkfd(9, POLLOUT)) die_usage(NAME, "write secretkey failed", "5>publickey 9>secretkey");
    limits();
    if (crypto_kem_mceliece8192128sha512_keypair(pk, sk)) die_temp(NAME, "keypair failed");
    if (writeall(5, pk, sizeof pk) == -1) die_temp(NAME, "write publickey failed");
    if (fsyncfd(5) == -1) die_temp(NAME, "write publickey failed");
    if (writeall(9, sk, sizeof sk) == -1) die_temp(NAME, "write secretkey failed");
    if (fsyncfd(9) == -1) die_temp(NAME, "write secretkey failed");
    die(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x5, %edi
movl $0x4, %esi
callq 0x84d0
cmpl $0x0, %eax
jne 0x1284
leaq 0xcd93(%rip), %rdi      # 0xe004
leaq 0xcd96(%rip), %rsi      # 0xe00e
leaq 0xcda6(%rip), %rdx      # 0xe025
callq 0x9fb0
movl $0x9, %edi
movl $0x4, %esi
callq 0x84d0
cmpl $0x0, %eax
jne 0x12b2
leaq 0xcd65(%rip), %rdi      # 0xe004
leaq 0xcd97(%rip), %rsi      # 0xe03d
leaq 0xcd78(%rip), %rdx      # 0xe025
callq 0x9fb0
callq 0xb960
leaq 0xfdf2(%rip), %rdi      # 0x110b0
leaq 0x15b5eb(%rip), %rsi    # 0x15c8b0
callq 0xbe00
cmpl $0x0, %eax
je 0x12e2
leaq 0xcd2e(%rip), %rdi      # 0xe004
leaq 0xcd77(%rip), %rsi      # 0xe054
callq 0xa130
movl $0x5, %edi
leaq 0xfdc2(%rip), %rsi      # 0x110b0
movl $0x14b800, %edx         # imm = 0x14B800
callq 0xddd0
cmpl $-0x1, %eax
jne 0x1310
leaq 0xcd00(%rip), %rdi      # 0xe004
leaq 0xcd03(%rip), %rsi      # 0xe00e
callq 0xa130
movl $0x5, %edi
callq 0xaf60
cmpl $-0x1, %eax
jne 0x1332
leaq 0xccde(%rip), %rdi      # 0xe004
leaq 0xcce1(%rip), %rsi      # 0xe00e
callq 0xa130
movl $0x9, %edi
leaq 0x15b572(%rip), %rsi    # 0x15c8b0
movl $0x3700, %edx           # imm = 0x3700
callq 0xddd0
cmpl $-0x1, %eax
jne 0x1360
leaq 0xccb0(%rip), %rdi      # 0xe004
leaq 0xcce2(%rip), %rsi      # 0xe03d
callq 0xa130
movl $0x9, %edi
callq 0xaf60
cmpl $-0x1, %eax
jne 0x1382
leaq 0xcc8e(%rip), %rdi      # 0xe004
leaq 0xccc0(%rip), %rsi      # 0xe03d
callq 0xa130
xorl %edi, %edi
callq 0xa200
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/mpmc_queue_lock_synchronized/code06.cpp
// Function: consume()
void consume()
{
	std::lock_guard<std::mutex> lock(mt);
	while (!stdQueue.empty()){
		sum += stdQueue.front();
		stdQueue.pop();
	}
}

// Assembly:
subq $0x28, %rsp
leaq 0x20(%rsp), %rdi
leaq 0x5db8(%rip), %rsi      # 0x7148
callq 0x1640
leaq 0x5d54(%rip), %rdi      # 0x70f0
callq 0x16c0
movb %al, 0x13(%rsp)
jmp 0x13a7
movb 0x13(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13b3
jmp 0x1405
leaq 0x5d36(%rip), %rdi      # 0x70f0
callq 0x16e0
movq %rax, 0x8(%rsp)
jmp 0x13c6
movq 0x8(%rsp), %rax
movl (%rax), %ecx
movl 0x5d6d(%rip), %eax      # 0x7140
addl %ecx, %eax
movl %eax, 0x5d65(%rip)      # 0x7140
leaq 0x5d0e(%rip), %rdi      # 0x70f0
callq 0x16f0
jmp 0x13e9
jmp 0x1395
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x16a0
jmp 0x1414
leaq 0x20(%rsp), %rdi
callq 0x16a0
addq $0x28, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x1180
nop
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/mpmc_queue_lock_synchronized/code06.cpp
// Function: main
int main()
{
	std::thread t1{produce};
	std::thread t1a{produce};
	std::thread t2{consume};
	std::thread t3{consume};
	t3.join();
	t1.join();
	t2.join();
	t1a.join();
	
	
	std::cout << sum << '\n';
}

// Assembly:
subq $0x48, %rsp
leaq -0x12b(%rip), %rsi      # 0x1300
movq %rsi, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1700
movq 0x10(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x1700
jmp 0x144b
leaq -0xd2(%rip), %rsi       # 0x1380
leaq 0x20(%rsp), %rdi
callq 0x1700
jmp 0x145e
leaq -0xe5(%rip), %rsi       # 0x1380
leaq 0x18(%rsp), %rdi
callq 0x1700
jmp 0x1471
leaq 0x18(%rsp), %rdi
callq 0x1160
jmp 0x147d
leaq 0x40(%rsp), %rdi
callq 0x1160
jmp 0x1489
leaq 0x20(%rsp), %rdi
callq 0x1160
jmp 0x1495
leaq 0x38(%rsp), %rdi
callq 0x1160
jmp 0x14a1
movl 0x5c99(%rip), %esi      # 0x7140
movq 0x5b2a(%rip), %rdi      # 0x6fd8
callq 0x1170
movq %rax, 0x8(%rsp)
jmp 0x14ba
movq 0x8(%rsp), %rdi
movl $0xa, %esi
callq 0x1100
jmp 0x14cb
leaq 0x18(%rsp), %rdi
callq 0x17c0
leaq 0x20(%rsp), %rdi
callq 0x17c0
leaq 0x38(%rsp), %rdi
callq 0x17c0
leaq 0x40(%rsp), %rdi
callq 0x17c0
xorl %eax, %eax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1556
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x154c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1542
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x17c0
leaq 0x20(%rsp), %rdi
callq 0x17c0
leaq 0x38(%rsp), %rdi
callq 0x17c0
leaq 0x40(%rsp), %rdi
callq 0x17c0
movq 0x30(%rsp), %rdi
callq 0x1180
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/gemm.c
// Function: gemm_bin
void gemm_bin(int M, int N, int K, float ALPHA, 
        char  *A, int lda, 
        float *B, int ldb,
        float *C, int ldc)
{
    int i,j,k;
    for(i = 0; i < M; ++i){
        for(k = 0; k < K; ++k){
            char A_PART = A[i*lda+k];
            if(A_PART){
                for(j = 0; j < N; ++j){
                    C[i*ldc+j] += B[k*ldb+j];
                }
            } else {
                for(j = 0; j < N; ++j){
                    C[i*ldc+j] -= B[k*ldb+j];
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x36e9
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x36d9
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x35(%rbp)
cmpb $0x0, -0x35(%rbp)
je 0x3678
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x3676
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
imull 0x10(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
imull 0x20(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3632
jmp 0x36c9
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x36c7
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
imull 0x10(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm1
movq 0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
imull 0x20(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
subss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x367f
jmp 0x36c9
jmp 0x36cb
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3602
jmp 0x36db
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x35ef
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/gemm.c
// Function: random_matrix
float *random_matrix(int rows, int cols)
{
    int i;
    float *m = calloc(rows*cols, sizeof(float));
    for(i = 0; i < rows*cols; ++i){
        m[i] = (float)rand()/RAND_MAX;
    }
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x4(%rbp), %ecx
imull -0x8(%rbp), %ecx
cmpl %ecx, %eax
jge 0x3758
callq 0x34b0
cvtsi2ss %eax, %xmm0
movss 0x6d8c8(%rip), %xmm1    # 0x71004
divss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x371d
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/gemm.c
// Function: time_random_matrix
void time_random_matrix(int TA, int TB, int m, int k, int n)
{
    float *a;
    if(!TA) a = random_matrix(m,k);
    else a = random_matrix(k,m);
    int lda = (!TA)?k:m;
    float *b;
    if(!TB) b = random_matrix(k,n);
    else b = random_matrix(n,k);
    int ldb = (!TB)?n:k;

    float *c = random_matrix(m,n);
    int i;
    clock_t start = clock(), end;
    for(i = 0; i<10; ++i){
        gemm_cpu(TA,TB,m,n,k,1,a,lda,b,ldb,1,c,n);
    }
    end = clock();
    printf("Matrix Multiplication %dx%d * %dx%d, TA=%d, TB=%d: %lf ms\n",m,k,k,n, TA, TB, (float)(end-start)/CLOCKS_PER_SEC);
    free(a);
    free(b);
    free(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x37a5
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x36f0
movq %rax, -0x30(%rbp)
jmp 0x37b4
movl -0x20(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x36f0
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x37c2
movl -0x20(%rbp), %eax
movl %eax, -0x6c(%rbp)
jmp 0x37c8
movl -0x1c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x37e5
movl -0x20(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x36f0
movq %rax, -0x40(%rbp)
jmp 0x37f4
movl -0x24(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x36f0
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x3802
movl -0x24(%rbp), %eax
movl %eax, -0x70(%rbp)
jmp 0x3808
movl -0x20(%rbp), %eax
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x1c(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x36f0
movq %rax, -0x50(%rbp)
callq 0x30f0
movq %rax, -0x60(%rbp)
movl $0x0, -0x54(%rbp)
cmpl $0xa, -0x54(%rbp)
jge 0x388c
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x30(%rbp), %r9
movl -0x34(%rbp), %r14d
movq -0x40(%rbp), %rbx
movl -0x44(%rbp), %r11d
movq -0x50(%rbp), %r10
movl -0x24(%rbp), %eax
movss 0x6d7aa(%rip), %xmm1    # 0x7100c
movaps %xmm1, %xmm0
movl %r14d, (%rsp)
movq %rbx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x3900
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x382d
callq 0x30f0
movq %rax, -0x68(%rbp)
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movl -0x14(%rbp), %r9d
movl -0x18(%rbp), %eax
movq -0x68(%rbp), %rdi
subq -0x60(%rbp), %rdi
cvtsi2ss %rdi, %xmm0
movss 0x6d74a(%rip), %xmm1    # 0x71008
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x6d743(%rip), %rdi     # 0x71010
movl %eax, (%rsp)
movb $0x1, %al
callq 0x3130
movq -0x30(%rbp), %rdi
callq 0x3030
movq -0x40(%rbp), %rdi
callq 0x3030
movq -0x50(%rbp), %rdi
callq 0x3030
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop