LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/maandree[P]libkeccak/libkeccak_cshake_initialise.c
// Function: feed_text
static size_t
feed_text(struct libkeccak_state *restrict state, uint8_t *restrict buf, const uint8_t *restrict text, size_t bytes,
          size_t bits, const char *restrict suffix, size_t off, size_t byterate, size_t *restrict bitoffp)
{
	size_t n, bitoff;

	if (off) {
		n = bytes < byterate - off ? bytes : byterate - off;
		memcpy(&buf[off], text, n);
		off += n;
		if (off == byterate) {
			libkeccak_zerocopy_update(state, buf, byterate);
			off = 0;
		}
		text = &text[n];
		bytes -= n;
	}
	if (bytes) {
		n = bytes;
		n -= bytes %= byterate;
		libkeccak_zerocopy_update(state, text, n);
		text = &text[n];
	}
	memcpy(&buf[off], text, bytes + !!bits);
	off += bytes;
	bitoff = bits;
	if (!bitoff)
		buf[off] = 0;
	for (; *suffix; suffix++) {
		if (*suffix == '1')
			buf[off] |= (uint8_t)(1 << bitoff);
		if (++bitoff == 8) {
			if (++off == byterate) {
				libkeccak_zerocopy_update(state, buf, byterate);
				off = 0;
			}
			bitoff = 0;
			buf[off] = 0;
		}
	}

	*bitoffp = bitoff;
	return off;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq 0x58(%rsp), %r12
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x787c
movq %r12, %rbp
subq %rax, %rbp
cmpq %rcx, %rbp
movq %rcx, (%rsp)
cmovaeq %rcx, %rbp
leaq (%r14,%rax), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x10d0
movq 0x50(%rsp), %rax
addq %rbp, %rax
cmpq %r12, %rax
jne 0x7870
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4864
xorl %eax, %eax
addq %rbp, %r15
movq (%rsp), %rcx
subq %rbp, %rcx
jmp 0x787e
xorl %eax, %eax
testq %rcx, %rcx
je 0x78b5
movq %rax, 0x10(%rsp)
movq %rcx, %rax
xorl %edx, %edx
divq %r12
movq %rdx, %rbp
subq %rdx, %rcx
movq %rcx, (%rsp)
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rcx, %rdx
callq 0x4864
movq 0x10(%rsp), %rax
addq (%rsp), %r15
jmp 0x78b7
xorl %ebp, %ebp
leaq (%r14,%rax), %rdi
xorl %edx, %edx
testq %r13, %r13
setne %dl
addq %rbp, %rdx
movq %r15, %rsi
movq %rax, %r15
callq 0x10d0
addq %r15, %rbp
testq %r13, %r13
jne 0x78de
movb $0x0, (%r14,%rbp)
pushq $0x1
popq %r15
movzbl (%rbx), %eax
cmpl $0x31, %eax
je 0x78f0
testl %eax, %eax
jne 0x78fc
jmp 0x792c
movl %r15d, %eax
movl %r13d, %ecx
shll %cl, %eax
orb %al, (%r14,%rbp)
incq %r13
cmpq $0x8, %r13
jne 0x7927
incq %rbp
cmpq %r12, %rbp
jne 0x791f
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4864
xorl %ebp, %ebp
movb $0x0, (%r14,%rbp)
xorl %r13d, %r13d
incq %rbx
jmp 0x78e2
movq 0x60(%rsp), %rax
movq %r13, (%rax)
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/maandree[P]libkeccak/extra/libkeccak_state_marshal.c
// Function: libkeccak_state_marshal
size_t
libkeccak_state_marshal(const struct libkeccak_state *restrict state, void *restrict data_)
{
#define set(VAR)\
	do {\
		__builtin_memcpy(data, &state->VAR, sizeof(state->VAR));\
		data += sizeof(state->VAR);\
	} while (0)

	unsigned char *restrict start = data_;
	unsigned char *restrict data = start;

	if (!data) {
		return 7 * sizeof(long int) +
		       1 * sizeof(uint64_t) +
		       sizeof(state->S) +
		       2 * sizeof(size_t) +
		       state->mptr;
	}

	set(r);
	set(c);
	set(n);
	set(b);
	set(w);
	set(wmod);
	set(l);
	set(nr);
	__builtin_memcpy(data, &state->S, sizeof(state->S));
	data += sizeof(state->S);
	set(mptr);
	set(mlen);
	memcpy(data, state->M, state->mptr * sizeof(char));
	data += state->mptr;

	return (size_t)(data - start);

#undef set
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x7b8d
movq %rsi, %r14
movups 0xc8(%rbx), %xmm0
movups %xmm0, (%rsi)
movups 0xd8(%rbx), %xmm0
movups %xmm0, 0x10(%rsi)
movups 0xe8(%rbx), %xmm0
movups %xmm0, 0x20(%rsi)
movups 0xf8(%rbx), %xmm0
movups %xmm0, 0x30(%rsi)
leaq 0x40(%rsi), %rdi
movl $0xc8, %edx
movq %rbx, %rsi
callq 0x10d0
movq 0x108(%rbx), %r15
movups 0x108(%rbx), %xmm0
movups %xmm0, 0x108(%r14)
movl $0x118, %r12d           # imm = 0x118
addq %r12, %r14
movq 0x118(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x10d0
addq %r12, %r15
jmp 0x7b9a
movl $0x118, %r15d           # imm = 0x118
addq 0x108(%rbx), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/maandree[P]libkeccak/extra/libkeccak_state_unmarshal.c
// Function: libkeccak_state_unmarshal
size_t
libkeccak_state_unmarshal(struct libkeccak_state *restrict state, const void *restrict data_)
{
#define get(VAR) \
	do {\
		__builtin_memcpy(&state->VAR, data, sizeof(state->VAR));\
		data += sizeof(state->VAR);\
	} while (0)

	const unsigned char *restrict start = data_;
	const unsigned char *restrict data = start;
	size_t mptr;

	if (!state) {
		data += 7U * sizeof(long int);
		data += 1U * sizeof(uint64_t);
		data += sizeof(state->S);
		mptr = *(const size_t *)data;
		data += 2U * sizeof(size_t);
		data += mptr;
		return (size_t)(data - start);
	}

	get(r);
	get(c);
	get(n);
	get(b);
	get(w);
	get(wmod);
	get(l);
	get(nr);
	memcpy(&state->S, data, sizeof(state->S));
	data += sizeof(state->S);
	get(mptr);
	get(mlen);
	if (state->mptr) {
		state->M = malloc(state->mptr * sizeof(char));
		if (!state->M)
			return 0;
		memcpy(state->M, data, state->mptr * sizeof(char));
		data += state->mptr;
	} else {
		state->M = NULL;
	}

	return (size_t)(data - start);

#undef get
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x7c45
movq %rdi, %r15
movups (%rbx), %xmm0
movups %xmm0, 0xc8(%rdi)
movups 0x10(%rbx), %xmm0
movups %xmm0, 0xd8(%rdi)
movups 0x20(%rbx), %xmm0
movups %xmm0, 0xe8(%rdi)
movups 0x30(%rbx), %xmm0
movups %xmm0, 0xf8(%rdi)
leaq 0x40(%rbx), %rsi
movl $0xc8, %edx
callq 0x10d0
movq 0x108(%rbx), %r12
movups 0x108(%rbx), %xmm0
movups %xmm0, 0x108(%r15)
leaq 0x118(%rbx), %r14
testq %r12, %r12
je 0x7c54
movq %r12, %rdi
callq 0x10e0
movq %rax, 0x118(%r15)
testq %rax, %rax
je 0x7c61
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x10d0
addq %r12, %r14
jmp 0x7c5c
movl $0x118, %r14d           # imm = 0x118
addq 0x108(%rbx), %r14
jmp 0x7c64
andq $0x0, 0x118(%r15)
subq %rbx, %r14
jmp 0x7c64
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/maandree[P]libkeccak/util/libkeccak_behex_upper.c
// Function: libkeccak_behex_upper
void
libkeccak_behex_upper(char *restrict output, const void *restrict hashsum_, size_t n)
{
	const unsigned char *restrict hashsum = hashsum_;

	output[2 * n] = '\0';
	while (n--) {
		output[2 * n + 0] = "0123456789ABCDEF"[(hashsum[n] >> 4) & 15];
		output[2 * n + 1] = "0123456789ABCDEF"[(hashsum[n] >> 0) & 15];
	}
}

// Assembly:
leaq (%rdx,%rdx), %r9
xorl %r8d, %r8d
leaq 0x8589(%rip), %rax      # 0x104f3
movq %rdx, %rcx
movb %r8b, (%rdi,%r9)
subq $0x1, %rcx
jb 0x7f9f
movzbl -0x1(%rsi,%rdx), %edx
movl %edx, %r8d
shrl $0x4, %r8d
movb (%r8,%rax), %r8b
movb %r8b, (%rdi,%rcx,2)
andl $0xf, %edx
movb (%rdx,%rax), %r8b
leaq 0x1(,%rcx,2), %r9
movq %rcx, %rdx
jmp 0x7f6d
retq
// File: /workspace/github_c_makefile_star2_O2/maandree[P]libkeccak/util/libkeccak_unhex.c
// Function: libkeccak_unhex
void
libkeccak_unhex(void *restrict output_, const char *restrict hashsum)
{
	unsigned char *restrict output = output_;
	size_t n = strlen(hashsum) / 2;
	unsigned char a, b;

	while (n--) {
		a = (unsigned char)hashsum[2 * n + 0];
		b = (unsigned char)hashsum[2 * n + 1];

		a = (unsigned char)((a & 15) + (a > '9' ? 9 : 0));
		b = (unsigned char)((b & 15) + (b > '9' ? 9 : 0));

		a = (unsigned char)(a << 4);
		a |= b;
		output[n] = a;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1070
shrq %rax
pushq $0x39
popq %rcx
movq %rax, %rdx
subq $0x1, %rdx
jb 0x81f0
movb (%rbx,%rdx,2), %sil
movb 0x1(%rbx,%rdx,2), %dil
cmpb $0x3a, %sil
movl $0x0, %r8d
cmovael %ecx, %r8d
addb %sil, %r8b
movl %edi, %esi
andb $0xf, %sil
xorl %r9d, %r9d
cmpb $0x3a, %dil
setae %r9b
leal (%r9,%r9,8), %edi
addb %sil, %dil
shlb $0x4, %r8b
orb %dil, %r8b
movb %r8b, -0x1(%r14,%rax)
movq %rdx, %rax
jmp 0x81a7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/maandree[P]libkeccak/extra/libkeccak_state_copy.c
// Function: libkeccak_state_copy
int
libkeccak_state_copy(struct libkeccak_state *restrict dest, const struct libkeccak_state *restrict src)
{
	*dest = *src;
	if (src->mlen) {
		dest->M = malloc(src->mlen * sizeof(char));
		if (!dest->M)
			return -1;
		memcpy(dest->M, src->M, src->mptr * sizeof(char));
	} else {
		dest->M = NULL;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x120, %edx            # imm = 0x120
callq 0x10d0
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x8241
callq 0x10e0
movq %rax, 0x118(%r14)
testq %rax, %rax
je 0x824d
movq 0x108(%rbx), %rdx
movq 0x118(%rbx), %rsi
movq %rax, %rdi
callq 0x10d0
jmp 0x8249
andq $0x0, 0x118(%r14)
xorl %eax, %eax
jmp 0x8250
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/randyrossi[P]fisher-modem/mkfilter/src/mkshapeargs.C
// Function: main
int main(int argc, char** argv) {
  int sampleRate = atoi(argv[1]);
  int baudRate = atoi(argv[2]);
  float beta = atof(argv[3]);

  float alpha = 1.0f / ((float)sampleRate / ((float)baudRate / 2.0f));

  int length = (sampleRate / baudRate * 2 + 1) * 2 - 1;

  printf("%18.10e %18.10e %d\n", alpha, beta, length);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x1050
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x1050
movl %eax, %r14d
movq 0x18(%rbx), %rdi
callq 0x1040
cvtsd2ss %xmm0, %xmm1
cvtsi2ss %ebp, %xmm0
cvtsi2ss %r14d, %xmm2
mulss 0xe6c(%rip), %xmm2      # 0x2004
divss %xmm2, %xmm0
movss 0xe64(%rip), %xmm2      # 0x2008
divss %xmm0, %xmm2
movl %ebp, %eax
cltd
idivl %r14d
leal 0x1(,%rax,4), %esi
cvtss2sd %xmm2, %xmm0
cvtss2sd %xmm1, %xmm1
leaq 0xe48(%rip), %rdi       # 0x200c
movb $0x2, %al
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/motet-a[P]libforks/tests/pid_ptr.c
// Function: main
int main() {
  libforks_ServerConn conn;

  check(pipe(pipe_fds) == 0);

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

  pid_t child_pid;

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

  pid_t received_child_pid;
  check(
    read(
      pipe_fds[0],
      &received_child_pid, sizeof received_child_pid
    ) == sizeof received_child_pid
  ); // blocks until the child writes
  check(child_pid == received_child_pid);

  check(libforks_stop(conn) == libforks_OK);

  check(child_pid == received_child_pid);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x4e14(%rip), %rdi      # 0x610c
callq 0x10e0
testl %eax, %eax
jne 0x1368
leaq 0x8(%rsp), %rdi
callq 0x179a
testl %eax, %eax
jne 0x1373
movq 0x8(%rsp), %rdi
leaq 0xc9(%rip), %r8         # 0x13e4
movq %rsp, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2096
testl %eax, %eax
jne 0x137e
movl 0x4ddb(%rip), %edi      # 0x610c
leaq 0x4(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x10f0
cmpq $0x4, %rax
jne 0x1389
movl (%rsp), %ebx
cmpl 0x4(%rsp), %ebx
jne 0x1394
movq 0x8(%rsp), %rdi
callq 0x223a
testl %eax, %eax
jne 0x139f
cmpl %ebx, (%rsp)
jne 0x13aa
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1c95(%rip), %rdi      # 0x3004
pushq $0x11
jmp 0x13b3
leaq 0x1cae(%rip), %rdi      # 0x3028
pushq $0x13
jmp 0x13b3
leaq 0x1cc8(%rip), %rdi      # 0x304d
pushq $0x1d
jmp 0x13b3
leaq 0x1d06(%rip), %rdi      # 0x3096
pushq $0x25
jmp 0x13b3
leaq 0x1d5c(%rip), %rdi      # 0x30f7
pushq $0x26
jmp 0x13b3
leaq 0x1d71(%rip), %rdi      # 0x3117
pushq $0x28
jmp 0x13b3
leaq 0x1d46(%rip), %rdi      # 0x30f7
pushq $0x2a
popq %rsi
callq 0x13b9
// File: /workspace/github_c_makefile_star2_O2/motet-a[P]libforks/tests/pid_ptr.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  (void)socket_fd;

  check(libforks_free_conn(conn) == libforks_OK);
  check(close(pipe_fds[0]) == 0);
  pid_t pid = getpid();
  check(write(pipe_fds[1], (void*)&pid, sizeof pid) == sizeof pid);
}

// Assembly:
pushq %rax
callq 0x2263
testl %eax, %eax
jne 0x141f
movl 0x4d18(%rip), %edi      # 0x610c
callq 0x10c0
testl %eax, %eax
jne 0x142a
callq 0x1090
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movl 0x4d01(%rip), %edi      # 0x6110
pushq $0x4
popq %rdx
callq 0x1080
cmpq $0x4, %rax
jne 0x1435
popq %rax
retq
leaq 0x1d30(%rip), %rdi      # 0x3156
pushq $0x8
jmp 0x143e
leaq 0x1d4d(%rip), %rdi      # 0x317e
pushq $0x9
jmp 0x143e
leaq 0x1d5a(%rip), %rdi      # 0x3196
pushq $0xb
popq %rsi
callq 0x13b9
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/read4.c
// Function: testcase_prepare
void testcase_prepare(unsigned long nr_tasks)
{
	int fd = mkstemp(tmpfile);
	char buf[FILESIZE];

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);
	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));
	close(fd);
}

// Assembly:
pushq %rbx
subq $0x100000, %rsp         # imm = 0x100000
leaq 0x2621(%rip), %rdi      # 0x51a0
callq 0x21f0
movl %eax, %ebx
movq %rsp, %rdi
movl $0x100000, %edx         # imm = 0x100000
xorl %esi, %esi
callq 0x2140
testl %ebx, %ebx
js 0x2bbf
movq %rsp, %rsi
movl $0x100000, %edx         # imm = 0x100000
movl %ebx, %edi
callq 0x20d0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x2bd8
movl %ebx, %edi
addq $0x100000, %rsp         # imm = 0x100000
popq %rbx
jmp 0x2150
leaq 0x6ba(%rip), %rdi       # 0x3280
leaq 0x6bb(%rip), %rsi       # 0x3288
leaq 0x6c2(%rip), %rcx       # 0x3296
pushq $0x15
jmp 0x2bef
leaq 0x6dc(%rip), %rdi       # 0x32bb
leaq 0x6a2(%rip), %rsi       # 0x3288
leaq 0x6a9(%rip), %rcx       # 0x3296
pushq $0x16
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/read4.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	int fd = open(tmpfile, O_DIRECT|O_RDONLY);
	char *p;

	p = aligned_alloc(getpagesize(), BUFLEN);

	while (1) {
		int ret = read(fd, p, BUFLEN);
		assert(ret >= 0);
		if (ret == 0)
			lseek(fd, 0, SEEK_SET);

		(*iterations)++;
	}
	free(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x259a(%rip), %rdi      # 0x51a0
movl $0x4000, %esi           # imm = 0x4000
xorl %eax, %eax
callq 0x2230
movl %eax, %ebp
callq 0x22a0
movslq %eax, %r14
movq %r14, %rdi
movq %r14, %rsi
callq 0x22c0
movq %rax, %r15
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2170
testl %eax, %eax
js 0x2c4d
jne 0x2c48
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
incq (%rbx)
jmp 0x2c2a
leaq 0x692(%rip), %rdi       # 0x32e6
leaq 0x62d(%rip), %rsi       # 0x3288
leaq 0x68d(%rip), %rcx       # 0x32ef
pushq $0x23
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/tools/bin2c.cc
// Function: usage()
void usage()
{
    cout << "Binary/text to C source conversion tool" << endl;
    cout << "Copyright (C) 2018 Jonathon Fowler <jf@jonof.id.au>" << endl;
    cout << "Released under the Artistic License 2.0" << endl;
    cout << endl;
    cout << "  bin2c [-text] <sourcefile> <symbol>" << endl;
    cout << "    <symbol>    Set the symbol name in the output file (default 'bin2cdata')" << endl;
    cout << "    -text       Generate text format output" << endl;
    cout << endl;
}

// Assembly:
pushq %rbx
movq 0x2cec(%rip), %rbx      # 0x4fd0
leaq 0xd19(%rip), %rsi       # 0x3004
movq %rbx, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2090
leaq 0xd2a(%rip), %rsi       # 0x302c
movq %rbx, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2090
leaq 0xd47(%rip), %rsi       # 0x3060
movq %rbx, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2090
leaq 0xd50(%rip), %rsi       # 0x3088
movq %rbx, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2090
leaq 0xd5f(%rip), %rsi       # 0x30ae
movq %rbx, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2090
leaq 0xd95(%rip), %rsi       # 0x30fb
movq %rbx, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
popq %rbx
jmp 0x2090
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch5/lua_error.c
// Function: main
int main() {

  lua_State *L = luaL_newstate();
  luaL_openlibs(L);
  lua_register(L, "fn", fn);
  
  // Call fn().
  lua_getglobal(L, "fn");
  lua_call(L, 0, 0);

  printf("Done!\n");

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x12b72
movq %rax, %rbx
movq %rax, %rdi
callq 0x12d98
leaq -0x45(%rip), %rsi       # 0x45fc
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4f92
leaq 0x199c4(%rip), %r14     # 0x1e016
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53d1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5060
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5838
leaq 0x19999(%rip), %rdi     # 0x1e019
callq 0x40c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/5-Signal/infinite_loop.c
// Function: main
int main(void) {
	unsigned int i = 0;

	signal(SIGINT, sig_handler);
	printf("PID %d\n", getpid());

	while(!stop) {
		sleep(1);
		printf("%d sec\n", ++i);
		fflush(stdout);
	}

	printf("Exit peacefully\n");
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq -0x19(%rip), %rsi       # 0x118c
pushq $0x2
popq %rdi
callq 0x1060
callq 0x1040
leaq 0xe4b(%rip), %rdi       # 0x2004
movl %eax, %esi
xorl %eax, %eax
callq 0x1050
pushq $0x1
popq %rbx
leaq 0xe40(%rip), %r14       # 0x200c
movq 0x2e0d(%rip), %r15      # 0x3fe0
movl %ebx, %ebp
cmpl $0x0, 0x2e80(%rip)      # 0x405c
jne 0x11fd
movl %ebx, %edi
callq 0x1080
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1050
movq (%r15), %rdi
callq 0x1070
incl %ebp
jmp 0x11d5
leaq 0xe10(%rip), %rdi       # 0x2014
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch1/runmodule.c
// Function: main
int main() {

  // Create a Lua state and load the module.
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);
  luaL_dofile(L, "eatyguy0.lua");
  lua_setglobal(L, "eatyguy");
  lua_settop(L, 0);

  // Run the init() function.
  lua_getglobal(L, "eatyguy");
  lua_getfield(L, -1, "init");  // -1 means stack top.
  lua_call(L, 0, 0);            // 0, 0 = #args, #retvals

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x12b66
movq %rax, %rbx
movq %rax, %rdi
callq 0x12d8c
leaq 0x199fa(%rip), %rsi     # 0x1e004
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12337
testl %eax, %eax
jne 0x462d
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5894
leaq 0x199dd(%rip), %r14     # 0x1e011
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53c5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x47ad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5054
leaq 0x199be(%rip), %rdx     # 0x1e019
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5170
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x582c
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/dropletzhu[P]msuite/msender.c
// Function: udp_csum
unsigned short
udp_csum(unsigned short *pseudo_header, unsigned short *buf, int nwords)
{
    unsigned long sum = 0;
	int  i = 0;

	for ( ; i < sizeof(pseudo_header_t)>>1; i++ )
		sum += *pseudo_header++;

    for ( ;nwords > 0; nwords--)
        sum += *buf++;

    sum = (sum >> 16) + (sum & 0xffff);
    sum += (sum >> 16);

    return (unsigned short)~sum;
}

// Assembly:
xorl %ecx, %ecx
xorl %eax, %eax
cmpl $0x6, %ecx
je 0x1258
movzwl (%rdi,%rcx,2), %r8d
addq %r8, %rax
incq %rcx
jmp 0x123a
movzwl (%rsi), %ecx
addq $0x2, %rsi
addq %rcx, %rax
decl %edx
testl %edx, %edx
jg 0x124c
movq %rax, %rcx
shrq $0x10, %rcx
movzwl %ax, %eax
addl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
notl %eax
retq
// File: /workspace/github_c_makefile_star2_O2/dropletzhu[P]msuite/msender.c
// Function: usage
void usage()
{
    printf("Usage: ./msender -s source -g group -p port -t ttl -l length -c count\n");
	printf(" -s source	the source ip\n");
	printf(" -g group	the group ip\n");
	printf(" -p port	the port\n");
	printf(" -t ttl		the ttl, default ttl is 1\n");
	printf(" -l length	the packet length, default length is 256 bytes\n");
	printf(" -c count	the packet count, default count is unlimited\n");
    printf(" Version	%s\n",version);
}

// Assembly:
pushq %rax
leaq 0xe1f(%rip), %rdi       # 0x2099
callq 0x1040
leaq 0xe59(%rip), %rdi       # 0x20df
callq 0x1040
leaq 0xe66(%rip), %rdi       # 0x20f8
callq 0x1040
leaq 0xe71(%rip), %rdi       # 0x210f
callq 0x1040
leaq 0xe77(%rip), %rdi       # 0x2121
callq 0x1040
leaq 0xe8e(%rip), %rdi       # 0x2144
callq 0x1040
leaq 0xebc(%rip), %rdi       # 0x217e
callq 0x1040
leaq 0xd76(%rip), %rdi       # 0x2044
leaq 0xd7c(%rip), %rsi       # 0x2051
xorl %eax, %eax
popq %rcx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]yasuna/src/libpolyaness/src/polyaness.c
// Function: get_polyaness
char* get_polyaness(const char* key, int record, polyaness_t** polyaness)
{
    if (polyaness == NULL   ||
            key == NULL     ||
            (*polyaness)->recs < record)
        return NULL;

    int     i       = 0,
            j       = 0;
    
    char*   match   = NULL,
        **  keys    = (*polyaness)->record[record]->key;

    j = (*polyaness)->record[record]->keys - 1;
    while (i < (*polyaness)->record[record]->keys && i <= j) {
        if (strcmp_lite(*(keys + i), key) == 0)
            return match = (*polyaness)->record[record]->value[i];
        if (strcmp_lite(*(keys + j), key) == 0)
            return match = (*polyaness)->record[record]->value[j];
        i++;
        j--;
    }

    return match;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x95e9
movq (%rdx), %rax
cmpl %esi, (%rax)
jge 0x95fe
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
movq 0x8(%rax), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %r13
movq %rax, (%rsp)
movslq (%rax), %r15
xorl %r14d, %r14d
movq %r15, %rbp
xorl %r12d, %r12d
cmpq %r15, %r12
jge 0x95ec
cmpq %rbp, %r12
jge 0x95ec
movq (%r13,%r12,8), %rdi
movq %rbx, %rsi
callq 0x9665
testl %eax, %eax
je 0x9654
movq -0x8(%r13,%rbp,8), %rdi
movq %rbx, %rsi
callq 0x9665
incq %r12
decq %rbp
testl %eax, %eax
jne 0x9620
jmp 0x9657
movq %r12, %rbp
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax,%rbp,8), %r14
jmp 0x95ec
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]yasuna/src/libpolyaness/src/polyaness.c
// Function: release_polyaness
void release_polyaness(polyaness_t* polyaness)
{
    if (polyaness == NULL)
        return;

    int     i   = 0,
            j   = 0;

    if (polyaness->record != NULL) {
        i = 0;
        j = polyaness->recs - 1;
        while (i <= j) {
            if (polyaness->record[i] != NULL)
                release_polyaness_cell(&polyaness->record[i]);
            if (polyaness->record[j] != NULL)
                release_polyaness_cell(&polyaness->record[j]);
            i++;
            j--;
        }
        free(polyaness->record);
    }

    free(polyaness);
    polyaness = NULL;

    return;
}

// Assembly:
testq %rdi, %rdi
je 0x9736
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x9725
movslq (%rbx), %r14
leaq -0x8(,%r14,8), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rdi
cmpq %r14, %r13
jge 0x9720
cmpq $0x0, (%rdi,%r12)
je 0x9701
addq %r12, %rdi
callq 0x9737
movq 0x8(%rbx), %rdi
cmpq $0x0, (%rdi,%r15)
je 0x9710
addq %r15, %rdi
callq 0x9737
incq %r13
addq $-0x8, %r15
addq $0x8, %r12
decq %r14
jmp 0x96e5
callq 0x2190
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2190
retq
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]yasuna/src/libpolyaness/src/polyaness.c
// Function: release_polyaness_cell
void release_polyaness_cell(polyaness_cell** record)
{
    int i   = 0,
        j   = 0;
    
    j = (*record)->keys - 1;
    while (j >= i) {
        if ((*record)->key[i] != NULL) {
            free((*record)->key[i]);
            (*record)->key[i] = NULL;
        }
        if ((*record)->value[i] != NULL) {
            free((*record)->value[i]);
            (*record)->value[i] = NULL;
        }
        if ((*record)->key[j] != NULL) {
            free((*record)->key[j]);
            (*record)->key[j] = NULL;
        }
        if ((*record)->value[j] != NULL) {
            free((*record)->value[j]);
            (*record)->value[j] = NULL;
        }
        i++;
        j--;
    }
    if ((*record)->key != NULL) {
        free((*record)->key);
        (*record)->key = NULL;
    }
    if ((*record)->value != NULL) {
        free((*record)->value);
        (*record)->value = NULL;
    }
    if (*record != NULL) {
        free(*record);
        *record = NULL;
    }

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movslq (%rax), %r14
xorl %r15d, %r15d
movq (%rbx), %rdi
movq 0x8(%rdi), %rax
cmpq %r15, %r14
jle 0x97ed
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x9778
movq %rax, %rdi
callq 0x2190
movq (%rbx), %rax
movq 0x8(%rax), %rax
andq $0x0, (%rax,%r15,8)
movq (%rbx), %rdi
movq 0x10(%rdi), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x979c
movq %rax, %rdi
callq 0x2190
movq (%rbx), %rax
movq 0x10(%rax), %rax
andq $0x0, (%rax,%r15,8)
movq (%rbx), %rdi
movq 0x8(%rdi), %rax
movq -0x8(%rax,%r14,8), %rax
testq %rax, %rax
je 0x97c2
movq %rax, %rdi
callq 0x2190
movq (%rbx), %rax
movq 0x8(%rax), %rax
andq $0x0, -0x8(%rax,%r14,8)
movq (%rbx), %rdi
movq 0x10(%rdi), %rax
movq -0x8(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x97e2
callq 0x2190
movq (%rbx), %rax
movq 0x10(%rax), %rax
andq $0x0, -0x8(%rax,%r14,8)
incq %r15
decq %r14
jmp 0x9748
testq %rax, %rax
je 0x9805
movq %rax, %rdi
callq 0x2190
movq (%rbx), %rax
andq $0x0, 0x8(%rax)
movq (%rbx), %rdi
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x9826
movq %rax, %rdi
callq 0x2190
movq (%rbx), %rax
andq $0x0, 0x10(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x982f
callq 0x2190
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]yasuna/src/subset.c
// Function: open_dict_file
int open_dict_file(FILE** fp, yasuna_t* yasuna)
{
    int     status  = 0;

    STRING* path    = new_string(NULL);

    struct  stat st;

    if (concat_file_path(path, yasuna) < 0) {
        status = -1; goto ERR;
    }

    if (stat(path->c_str(path), &st) != 0) {
        status = -2; goto ERR;
    }

    if ((st.st_mode & S_IFMT) == S_IFDIR) {
        status = -3; goto ERR;
    }
    if ((*fp = fopen(path->c_str(path), "r")) == NULL) {
        status = -4; goto ERR;
    }
    path->release(path);

    return 0;

ERR:
    switch (status) {
        case    -1:
            break;
        case    -2:
            fprintf(stderr, "%s: %s: %s\n",
                    PROGNAME, path->c_str(path), strerror(ENOENT));
            break;
        case    -3:
            fprintf(stderr, "%s: %s: %s\n",
                    PROGNAME, path->c_str(path), strerror(EISDIR));
            break;
        case    -4:
            fprintf(stderr, "%s: %s: %s\n",
                    PROGNAME, path->c_str(path), strerror(errno));
            break;
    }
    path->release(path);

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %r14
xorl %edi, %edi
callq 0x5954
movq %rax, %rbx
movq %rax, 0x8(%rsp)
testb $0x2, (%r15)
movq 0x58(%rax), %rax
jne 0x992a
leaq 0x1d0b(%rip), %rsi      # 0xb612
leaq 0x8(%rsp), %rdi
callq *%rax
testl %eax, %eax
js 0x99d5
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x1d06(%rip), %rsi      # 0xb62b
callq *0x68(%rax)
jmp 0x9935
movq 0x10(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq *%rax
testl %eax, %eax
js 0x99d5
movq %rbx, %rdi
callq *0xc8(%rbx)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2410
testl %eax, %eax
jne 0x99f1
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x9a31
movq %rbx, %rdi
callq *0xc8(%rbx)
leaq 0x1d57(%rip), %rsi      # 0xb6d6
movq %rax, %rdi
callq 0x20f0
movq %rax, (%r14)
xorl %ebp, %ebp
testq %rax, %rax
jne 0x99d8
movq 0x6650(%rip), %rax      # 0xffe8
movq (%rax), %r14
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rax, %r15
callq 0x2340
movl (%rax), %edi
callq 0x2240
leaq 0x1b8f(%rip), %rsi      # 0xb549
leaq 0x1855(%rip), %rdx      # 0xb216
movq %r14, %rdi
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2400
pushq $-0x4
jmp 0x99d7
pushq $-0x1
popq %rbp
movq %rbx, %rdi
callq *0x268(%rbx)
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x65f0(%rip), %rax      # 0xffe8
movq (%rax), %r14
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rax, %r15
pushq $0x2
popq %rdi
callq 0x2240
leaq 0x1b33(%rip), %rsi      # 0xb549
leaq 0x17f9(%rip), %rdx      # 0xb216
movq %r14, %rdi
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2400
pushq $-0x2
jmp 0x99d7
movq 0x65b0(%rip), %rax      # 0xffe8
movq (%rax), %r14
movq %rbx, %rdi
callq *0xc8(%rbx)
movq %rax, %r15
pushq $0x15
popq %rdi
callq 0x2240
leaq 0x1af3(%rip), %rsi      # 0xb549
leaq 0x17b9(%rip), %rdx      # 0xb216
movq %r14, %rdi
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x2400
pushq $-0x3
jmp 0x99d7
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]yasuna/src/subset.c
// Function: read_dict_file
int read_dict_file(FILE* fp, polyaness_t** pt)
{
    int     status  = 0;

    /* initialize libpolyaness */
    if (init_polyaness(fp, 0, pt) < 0) {
        status = -1; goto ERR;
    }

    /* no data */
    if ((*pt)->recs == 0) {
        status = -2; goto ERR;
    }

    return 0;

ERR:
    switch (status) {
        case    -1:
            fprintf(stderr, "%s: init_polyaness() failure\n",
                    PROGNAME);
            break;
        case    -2:
            release_polyaness(*pt);
            break;
    }

    return status;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
xorl %ebx, %ebx
xorl %esi, %esi
movq %r14, %rdx
callq 0x90d0
testl %eax, %eax
js 0x9aa8
movq (%r14), %rax
cmpl $0x0, (%rax)
jne 0x9a9e
movq (%r14), %rdi
callq 0x96bc
pushq $-0x2
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x6539(%rip), %rax      # 0xffe8
movq (%rax), %rdi
leaq 0x1a9c(%rip), %rsi      # 0xb555
leaq 0x1756(%rip), %rdx      # 0xb216
xorl %eax, %eax
callq 0x2400
pushq $-0x1
jmp 0x9a9d
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]yasuna/src/subset.c
// Function: create_rand
int create_rand(int lines)
{
    struct  timeval lo_timeval;

    /* get localtime */
    gettimeofday(&lo_timeval, NULL);

    /* 
     * # setting factor for pseudo-random number
     * current microseconds * PID
     */
    srand((unsigned)(
        lo_timeval.tv_usec * getpid()
    ));

    /* create pseudo-random number */
    return (int)(rand()%(lines+1));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x20c0
movl 0x8(%r14), %ebp
callq 0x2130
imull %eax, %ebp
movl %ebp, %edi
callq 0x2350
callq 0x23f0
incl %ebx
cltd
idivl %ebx
movl %edx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]yasuna/src/subset.c
// Function: print_all_quotes
void print_all_quotes(polyaness_t* pt, yasuna_t* yasuna)
{
    int     i   = 0;

    if (yasuna->flag & YASUNA_SPEAKER)
        fprintf(stdout, "*** speaker = %s, %d quotes ***\n",
                yasuna->sarg, pt->recs);

    while (i < pt->recs) {
        fprintf(stdout, "%4d %s\n",
                i, get_polyaness("quote", i, &pt));
        i++;
    }

    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, (%rsp)
testb $0x4, (%rsi)
je 0xa0c2
movq 0x5f4d(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq 0x8(%rsi), %rdx
movl (%rbx), %ecx
leaq 0x1528(%rip), %rsi      # 0xb5e3
xorl %eax, %eax
callq 0x2400
movq 0x5f2f(%rip), %r13      # 0xfff8
leaq 0x153c(%rip), %r14      # 0xb60c
movq %rsp, %r15
leaq 0x152a(%rip), %r12      # 0xb604
xorl %ebp, %ebp
cmpl (%rbx), %ebp
jge 0xa10b
movq (%r13), %rbx
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x95c7
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2400
incl %ebp
movq (%rsp), %rbx
jmp 0xa0dc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]yasuna/src/yasuna.c
// Function: release
static
void release(FILE* fp, polyaness_t* pt)
{
    if (fp != NULL) {
        fclose(fp);
        fp = NULL;
    }
    if (pt != NULL)
        release_polyaness(pt);

    return;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0xa42d
callq 0x2390
testq %rbx, %rbx
je 0xa43b
movq %rbx, %rdi
popq %rbx
jmp 0x96bc
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pencode-lab[P]Shoit/sendfile.c
// Function: open_data_source
static bool open_data_source(shoit_core_t *sender)
{

    sender->fromFd = -1;
    if(!sender->iStream){/*data source is file of disk*/

        if(!sender->fileName || access(sender->fileName,F_OK)==-1){
            fprintf(stderr,"The file does not exist <%s>\n",sender->fileName);
            return false;
        }

        struct stat filestat;
        if (stat(sender->fileName, &filestat) < 0) {
            fprintf(stderr,"stat error(%s).\n",strerror(errno));
            return false;
        }
        sender->fileSize = filestat.st_size;
        sender->fromFd = open(sender->fileName, O_RDONLY);
        if (sender->fromFd < 0) {
            fprintf(stderr,"open file failed(%s).\n",sender->fileName);
            return false;
        }
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
orl $-0x1, 0xf8(%rdi)
pushq $0x1
popq %rbp
cmpl $0x0, 0x1a4(%rdi)
jne 0x28a7
movq %rdi, %rbx
movq 0xf0(%rdi), %rdi
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x28b9
xorl %esi, %esi
callq 0x2390
movq 0xf0(%rbx), %rdx
cmpl $-0x1, %eax
je 0x28bb
movq %rsp, %rsi
movq %rdx, %rdi
callq 0x2270
testl %eax, %eax
js 0x28d5
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0xf0(%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2380
movl %eax, 0xf8(%rbx)
testl %eax, %eax
js 0x28fa
movl %ebp, %r14d
movl %r14d, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %edx, %edx
movq 0x6736(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x378d(%rip), %rsi      # 0x6059
xorl %eax, %eax
callq 0x2250
jmp 0x28aa
movq 0x671c(%rip), %rax      # 0x8ff8
movq (%rax), %rbx
callq 0x2060
movl (%rax), %edi
callq 0x2470
leaq 0x3785(%rip), %rsi      # 0x6077
movq %rbx, %rdi
movq %rax, %rdx
jmp 0x2912
movq 0x66f7(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movq 0xf0(%rbx), %rdx
leaq 0x3776(%rip), %rsi      # 0x6088
xorl %eax, %eax
callq 0x2250
xorl %r14d, %r14d
jmp 0x28aa
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/bench/mkpairs/main.c
// Function: main
int
main(int argc, char * argv[])
{
	uintmax_t N;
	uint64_t X, Y;
	uint8_t * buf;

	WARNP_INIT;

	/* Check number of arguments. */
	if (argc != 2) {
		fprintf(stderr, "usage: mkpairs N\n");
		exit(1);
	}

	/* Parse N. */
	if (PARSENUM(&N, argv[1])) {
		warnp("Invalid value for N: %s", argv[1]);
		exit(1);
	}

	/* Allocate buffer for 2^16 key-value pairs. */
	if ((buf = malloc(40 * 2 * 65536)) == NULL) {
		warnp("malloc");
		exit(1);
	}

	/* Create groups of key-value pairs. */
	for (X = 0; (X << 16) < N; X++) {
		/* Generate key-value pairs. */
		for (Y = 0; ((X << 16) + Y < N) && (Y < (1 << 16)); Y++) {
			mkkey(X, Y, &buf[Y * 80]);
			mkval(X, Y, &buf[Y * 80 + 40]);
		}

		/* Sort key-value pairs. */
		qsort(buf, (size_t)Y, 80, compar);

		/* Write out key-value pairs. */
		if (fwrite(buf, 80, (size_t)Y, stdout) < Y) {
			warnp("fwrite");
			exit(1);
		}
	}

	/* Free buffer. */
	free(buf);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x12ac
callq 0x1454
cmpl $0x2, %ebp
jne 0x12e1
callq 0x1060
andl $0x0, (%rax)
movq 0x8(%rbx), %r15
testq %r15, %r15
jne 0x12ff
leaq 0x2d73(%rip), %rdi      # 0x403c
leaq 0x2d76(%rip), %rsi      # 0x4046
leaq 0x2d91(%rip), %rcx      # 0x4068
movl $0xbb, %edx
callq 0x1090
movq 0x5d10(%rip), %rax      # 0x6ff8
movq (%rax), %rcx
leaq 0x2d12(%rip), %rdi      # 0x4004
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
callq 0x1160
jmp 0x136a
movq %rax, %r13
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1120
movq %rax, %r14
movq (%r12), %rax
cmpq %r15, %rax
je 0x134b
cmpb $0x0, (%rax)
jne 0x134b
cmpl $0x0, (%r13)
jne 0x1353
movl $0x500000, %edi         # imm = 0x500000
callq 0x1100
testq %rax, %rax
jne 0x1372
leaq 0x2cec(%rip), %rdi      # 0x402e
xorl %eax, %eax
callq 0x1660
jmp 0x136a
movl $0x16, (%r13)
movq 0x8(%rbx), %rsi
leaq 0x2cb8(%rip), %rdi      # 0x4016
xorl %eax, %eax
callq 0x14d1
andl $0x0, (%r13)
pushq $0x1
popq %rdi
callq 0x1150
movq %rax, %r12
movq %r13, 0x8(%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %rbp, %rax
shlq $0x10, %rax
cmpq %r14, %rax
jae 0x1426
movq %r12, %r15
xorl %ebx, %ebx
cmpq $0xffff, %rbx           # imm = 0xFFFF
ja 0x13cc
leaq (%rbx,%r13), %rax
cmpq %r14, %rax
jae 0x13cc
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x17e4
leaq 0x28(%r15), %rdx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x18d6
incq %rbx
addq $0x50, %r15
jmp 0x1394
movq %r12, %rdi
movq %rbx, %rsi
pushq $0x50
popq %r15
movq %r15, %rdx
leaq 0x6b(%rip), %rcx        # 0x144b
callq 0x1070
movq 0x5bec(%rip), %rax      # 0x6fd8
movq (%rax), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1160
incq %rbp
addq $0x10000, %r13          # imm = 0x10000
cmpq %rbx, %rax
jae 0x137f
movq 0x8(%rsp), %rbx
cmpl $0x0, (%rbx)
jne 0x1435
leaq 0x2c14(%rip), %rdi      # 0x4035
jmp 0x1342
movq %r12, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1150
leaq 0x2bf9(%rip), %rdi      # 0x4035
xorl %eax, %eax
callq 0x14d1
andl $0x0, (%rbx)
jmp 0x136a
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.9/cxx-exit.cpp
// Function: fact(int)
int fact(int n){
  int i;
  int factorial=1;
  for(i=1;i<=n;i++)
    factorial = factorial * i;
  return factorial;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
testl %edi, %edi
cmovgl %edi, %ecx
negl %ecx
movl $0x1, %edx
movl %edx, %eax
leal (%rcx,%rdx), %esi
cmpl $0x1, %esi
je 0x125f
imull %edx, %eax
incl %edx
jmp 0x1250
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.9/cxx-exit.cpp
// Function: do_some_work()
void do_some_work ()
{
  int k = 1;
  while (1) {
    /* Do some useful things here...  */
    cout << "factorial(" << k << ") = " << fact(k) << "\n";
    if (k++ == MAX)
      throw ThreadExitException (/* thread's return value = */ NULL);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
leaq 0xd8b(%rip), %r15       # 0x2004
leaq 0xd8f(%rip), %r12       # 0x200f
leaq 0xd8d(%rip), %r13       # 0x2014
movq 0x2d4a(%rip), %rdi      # 0x3fd8
movq %r15, %rsi
callq 0x1080
movq %rax, %rdi
movl %ebx, %esi
callq 0x10c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x1080
movq %rax, %r14
movl %ebx, %edi
callq 0x123c
movq %r14, %rdi
movl %eax, %esi
callq 0x10c0
movq %rax, %rdi
movq %r13, %rsi
callq 0x1080
incl %ebx
cmpl $0x6, %ebx
jne 0x1287
pushq $0x8
popq %rdi
callq 0x1050
andq $0x0, (%rax)
leaq 0x2ac4(%rip), %rsi      # 0x3da8
movq %rax, %rdi
xorl %edx, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.9/cxx-exit.cpp
// Function: main
int main(){
	pthread_t thread_id;
	pthread_create(&thread_id, NULL, &thread_function, NULL);
	pthread_join(thread_id, NULL);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x48(%rip), %rdx       # 0x12ee
leaq -0x10(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x10f0
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/src/asm/addr_diff.c
// Function: addr_diff_2_calcul
void	addr_diff_2_calcul(int i, int cmp, int inst_pos, int *count)
{
	if (i == cmp && *count == 0)
		*count = -1;
	else if (i == inst_pos && *count == 0)
		*count = 1;
	if (i == inst_pos && *count == -1)
		*count = 0;
	else if (i == cmp && *count == 1)
		*count = 0;
}

// Assembly:
cmpl %esi, %edi
jne 0x1195
cmpl $0x0, (%rcx)
je 0x11a2
cmpl %edx, %edi
jne 0x11a7
cmpl $0x0, (%rcx)
jne 0x11a7
pushq $0x1
jmp 0x11a4
pushq $-0x1
popq %rax
movl %eax, (%rcx)
cmpl %edx, %edi
jne 0x11b0
cmpl $-0x1, (%rcx)
je 0x11b9
cmpl %esi, %edi
jne 0x11bc
cmpl $0x1, (%rcx)
jne 0x11bc
andl $0x0, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/src/asm/addr_diff.c
// Function: addr_diff_2
int		addr_diff_2(t_data *data, int cmp, int inst_pos, int i)
{
	int			count;
	int			diff;
	t_label		*tmp_lbl;
	t_instruc	*tmp_inst;

	count = 0;
	diff = 0;
	tmp_lbl = data->label;
	while (tmp_lbl)
	{
		tmp_inst = tmp_lbl->insts;
		while (tmp_inst)
		{
			addr_diff_2_calcul(i, cmp, inst_pos, &count);
			if (count != 0)
				diff += 1 + get_params_size_ocp(tmp_inst);
			i++;
			tmp_inst = tmp_inst->next;
		}
		tmp_lbl = tmp_lbl->next;
	}
	return (diff);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, %ebp
leaq 0xc(%rsp), %r14
andl $0x0, (%r14)
movl %esi, %r15d
addq $0x38, %rdi
xorl %r13d, %r13d
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x122b
movq %rdi, 0x10(%rsp)
leaq 0x8(%rdi), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x1224
movl %ebx, %edi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
callq 0x118c
cmpl $0x0, 0xc(%rsp)
je 0x1220
movq %r12, %rdi
callq 0x20b7
addl %eax, %r13d
incl %r13d
incl %ebx
jmp 0x11f3
movq 0x10(%rsp), %rdi
jmp 0x11e2
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/src/asm/addr_diff.c
// Function: addr_diff
int		addr_diff(t_data *data, char *lbl_name, int inst_pos)
{
	int			i;
	t_label		*tmp_lbl;
	t_instruc	*tmp_inst;

	i = 0;
	tmp_lbl = data->label;
	while (tmp_lbl)
	{
		if (ft_strcmp(tmp_lbl->name, lbl_name) == 0)
			break ;
		tmp_inst = tmp_lbl->insts;
		while (tmp_inst)
		{
			i++;
			tmp_inst = tmp_inst->next;
		}
		tmp_lbl = tmp_lbl->next;
	}
	return (addr_diff_2(data, i, inst_pos, 0));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x38(%rdi), %r12
xorl %ebp, %ebp
movq (%r12), %r12
testq %r12, %r12
je 0x1280
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x3f68
testl %eax, %eax
je 0x1280
leaq 0x8(%r12), %rax
decl %ebp
movq (%rax), %rax
incl %ebp
testq %rax, %rax
jne 0x1274
jmp 0x1253
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11bd
nop
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/src/asm/asm.c
// Function: free_data
void	free_data(t_data *data)
{
	free(data->filename);
	free(data->name);
	free(data->comment);
	free(data->cor);
	free_inst_lbl(data->label);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1030
movq 0x18(%rbx), %rdi
callq 0x1030
movq 0x20(%rbx), %rdi
callq 0x1030
movq 0x28(%rbx), %rdi
callq 0x1030
movq 0x38(%rbx), %rdi
popq %rbx
jmp 0x2e7c
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/src/asm/asm.c
// Function: usage
void	usage(int argc, char *argv[])
{
	if (argc != 1)
		return ;
	ft_putstr("Usage : ");
	ft_putstr(argv[0]);
	ft_putendl(" [-v|-l|-b] <sourcefile.s>");
	ft_putendl("\t-v : verbose mode, write data and program in hexadecimal.");
	ft_printf("\t-l : live coding mode, you can write %s",
											"directly your s file manualy.\n");
	ft_printf("\t-b : binary mode, return your binary file %s",
													"in standard output.\n");
}

// Assembly:
cmpl $0x1, %edi
jne 0x134a
pushq %rbx
movq %rsi, %rbx
leaq 0x4d0a(%rip), %rdi      # 0x6004
callq 0x429c
movq (%rbx), %rdi
callq 0x429c
leaq 0x4cff(%rip), %rdi      # 0x600d
callq 0x42b4
leaq 0x4d0e(%rip), %rdi      # 0x6028
callq 0x42b4
leaq 0x4d3d(%rip), %rdi      # 0x6063
leaq 0x4d5f(%rip), %rsi      # 0x608c
xorl %eax, %eax
callq 0x45d4
leaq 0x4d70(%rip), %rdi      # 0x60ab
leaq 0x4d97(%rip), %rsi      # 0x60d9
xorl %eax, %eax
popq %rbx
jmp 0x45d4
retq
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/src/asm/asm.c
// Function: run
void	run(t_data *data, char *filename)
{
	init_data(data);
	if (filename != NULL)
	{
		set_filename(data, filename);
		data->fd = open(filename, O_RDONLY);
	}
	else
		live_coding_mode(data, filename);
	if (data->fd < 0)
		error("Open fail");
	parser(data);
	build(data);
	write_header(data);
	write_file(data);
	free_data(data);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
andl $0x0, 0x30(%rdi)
movl $0x1, 0x40(%rdi)
andl $0x0, 0x50(%rdi)
testq %rsi, %rsi
je 0x1392
movq %rsi, %r14
movq %rbx, %rdi
callq 0x1ccb
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x1070
movl %eax, 0x8(%rbx)
jmp 0x139f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2dbc
movl 0x8(%rbx), %eax
testl %eax, %eax
jns 0x13af
leaq 0x4d44(%rip), %rdi      # 0x60ee
callq 0x1e85
movq %rbx, %rdi
callq 0x3661
movq %rbx, %rdi
callq 0x14d4
movq %rbx, %rdi
callq 0x3df0
movq %rbx, %rdi
callq 0x1d8d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12b8
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/src/asm/asm.c
// Function: main
int		main(int argc, char *argv[])
{
	t_data	data;
	int		i;

	essential_char_in_label_chars();
	i = 1;
	data.verbose = 0;
	data.binary = 0;
	while (i < argc)
	{
		if (ft_strcmp(argv[i], "-v") == 0 && ++i > 0)
			data.verbose = 1;
		if (ft_strcmp(argv[i], "-b") == 0 && ++i > 0)
			data.binary = 1;
		if (ft_strcmp(argv[i], "-b") == 0 || ft_strcmp(argv[i], "-v") == 0)
			continue ;
		if (ft_strcmp(argv[i], "-l") == 0)
			run(&data, NULL);
		else
			run(&data, argv[i]);
		i++;
	}
	usage(argc, argv);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movl %edi, %ebp
callq 0x2700
movq %rsp, %rax
andq $0x0, (%rax)
pushq $0x1
popq %r13
leaq 0x4cf0(%rip), %r15      # 0x60f8
leaq 0x4cec(%rip), %r12      # 0x60fb
cmpl %ebp, %r13d
jge 0x14b8
movslq %r13d, %rax
movq (%rbx,%rax,8), %rdi
movq %r15, %rsi
callq 0x3f68
testl %eax, %eax
je 0x1430
movl %r13d, %r14d
jmp 0x1440
leal 0x1(%r13), %r14d
testl %r13d, %r13d
js 0x1440
movl $0x1, (%rsp)
movslq %r14d, %rax
movq (%rbx,%rax,8), %rdi
movq %r12, %rsi
callq 0x3f68
testl %eax, %eax
je 0x1458
movl %r14d, %r13d
jmp 0x1469
leal 0x1(%r14), %r13d
testl %r14d, %r14d
js 0x1469
movl $0x1, 0x4(%rsp)
movslq %r13d, %r14
movq (%rbx,%r14,8), %rdi
movq %r12, %rsi
callq 0x3f68
testl %eax, %eax
je 0x140f
movq (%rbx,%r14,8), %rdi
movq %r15, %rsi
callq 0x3f68
testl %eax, %eax
je 0x140f
movq (%rbx,%r14,8), %rdi
leaq 0x4c67(%rip), %rsi      # 0x60fe
callq 0x3f68
testl %eax, %eax
je 0x14a6
movq (%rbx,%r14,8), %rsi
jmp 0x14a8
xorl %esi, %esi
movq %rsp, %rdi
callq 0x134b
incl %r13d
jmp 0x140f
movl %ebp, %edi
movq %rbx, %rsi
callq 0x12ea
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop