LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/maandree[P]libkeccak/extra/libkeccak_state_duplicate.c
// Function: libkeccak_state_duplicate
struct libkeccak_state *
libkeccak_state_duplicate(const struct libkeccak_state *src)
{
	struct libkeccak_state *dest = malloc(sizeof(struct libkeccak_state));
	if (!dest || libkeccak_state_copy(dest, src)) {
		libkeccak_state_free(dest);
		return NULL;
	}
	return dest;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x120, %edi            # imm = 0x120
callq 0x10e0
testq %rax, %rax
je 0x8abd
movq %rax, %rbx
sete %bpl
movq %rax, %rdi
movq %r14, %rsi
callq 0x922c
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %cl
cmoveq %rbx, %rax
orb %bpl, %cl
jne 0x8abf
movq %rbx, %rdi
callq 0x8c98
movq 0x118(%rbx), %rdi
callq 0x1030
movq $0x0, 0x118(%rbx)
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8b7f
movq %rsi, %r14
movq 0xc8(%rbx), %rax
movq %rax, (%rsi)
movq 0xd0(%rbx), %rax
movq %rax, 0x8(%rsi)
movq 0xd8(%rbx), %rax
movq %rax, 0x10(%rsi)
movq 0xe0(%rbx), %rax
movq %rax, 0x18(%rsi)
movq 0xe8(%rbx), %rax
movq %rax, 0x20(%rsi)
movq 0xf0(%rbx), %rax
movq %rax, 0x28(%rsi)
movq 0xf8(%rbx), %rax
movq %rax, 0x30(%rsi)
movq 0x100(%rbx), %rax
movq %rax, 0x38(%rsi)
leaq 0x40(%rsi), %rdi
movl $0xc8, %edx
movq %rbx, %rsi
callq 0x10d0
movq 0x108(%rbx), %r15
movq %r15, 0x108(%r14)
movq 0x110(%rbx), %rax
movq %rax, 0x110(%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 0x8b8c
movl $0x118, %r15d           # imm = 0x118
addq 0x108(%rbx), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x8c67
movq %rdi, %r14
movq (%rbx), %rax
movq %rax, 0xc8(%rdi)
movq 0x8(%rbx), %rax
movq %rax, 0xd0(%rdi)
movq 0x10(%rbx), %rax
movq %rax, 0xd8(%rdi)
movq 0x18(%rbx), %rax
movq %rax, 0xe0(%rdi)
movq 0x20(%rbx), %rax
movq %rax, 0xe8(%rdi)
movq 0x28(%rbx), %rax
movq %rax, 0xf0(%rdi)
movq 0x30(%rbx), %rax
movq %rax, 0xf8(%rdi)
movq 0x38(%rbx), %rax
movq %rax, 0x100(%rdi)
leaq 0x40(%rbx), %rsi
movl $0xc8, %edx
callq 0x10d0
movq 0x108(%rbx), %r12
movq %r12, 0x108(%r14)
movq 0x110(%rbx), %rax
movq %rax, 0x110(%r14)
leaq 0x118(%rbx), %r15
testq %r12, %r12
je 0x8c76
movq %r12, %rdi
callq 0x10e0
movq %rax, 0x118(%r14)
testq %rax, %rax
je 0x8c86
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x10d0
addq %r12, %r15
jmp 0x8c81
movl $0x118, %r15d           # imm = 0x118
addq 0x108(%rbx), %r15
jmp 0x8c89
movq $0x0, 0x118(%r14)
subq %rbx, %r15
jmp 0x8c89
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb $0x0, (%rdi,%rdx,2)
testq %rdx, %rdx
je 0x8fdb
leaq 0x8503(%rip), %rax      # 0x114b3
movzbl -0x1(%rsi,%rdx), %ecx
movl %ecx, %r8d
shrl $0x4, %r8d
movb (%r8,%rax), %r8b
movb %r8b, -0x2(%rdi,%rdx,2)
andl $0xf, %ecx
movb (%rcx,%rax), %cl
movb %cl, -0x1(%rdi,%rdx,2)
leaq -0x1(%rdx), %rcx
movq %rcx, %rdx
testq %rcx, %rcx
jne 0x8fb0
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x2, %rax
jb 0x9223
shrq %rax
movl $0x39, %ecx
movb -0x2(%rbx,%rax,2), %dl
movb -0x1(%rbx,%rax,2), %sil
cmpb $0x3a, %dl
movl $0x0, %edi
cmovael %ecx, %edi
addb %dl, %dil
movl %esi, %edx
andb $0xf, %dl
xorl %r8d, %r8d
cmpb $0x3a, %sil
setae %r8b
leal (%r8,%r8,8), %esi
addb %dl, %sil
shlb $0x4, %dil
orb %sil, %dil
movb %dil, -0x1(%r14,%rax)
decq %rax
jne 0x91e4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x9275
callq 0x10e0
movq %rax, 0x118(%r14)
testq %rax, %rax
je 0x9284
movq 0x108(%rbx), %rdx
movq 0x118(%rbx), %rsi
movq %rax, %rdi
callq 0x10d0
jmp 0x9280
movq $0x0, 0x118(%r14)
xorl %eax, %eax
jmp 0x9289
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
cvtsi2ss %r14d, %xmm2
mulss 0xe69(%rip), %xmm2      # 0x2004
divss %xmm2, %xmm0
movss 0xe61(%rip), %xmm2      # 0x2008
divss %xmm0, %xmm2
movl %ebp, %eax
cltd
idivl %r14d
leal 0x1(,%rax,4), %esi
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
cvtss2sd %xmm1, %xmm1
leaq 0xe42(%rip), %rdi       # 0x200c
movb $0x2, %al
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4df4(%rip), %rdi      # 0x610c
callq 0x10e0
testl %eax, %eax
jne 0x138a
leaq 0x8(%rsp), %rdi
callq 0x180b
testl %eax, %eax
jne 0x139b
movq 0x8(%rsp), %rdi
leaq 0xf1(%rip), %r8         # 0x142c
movq %rsp, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x225f
testl %eax, %eax
jne 0x13ac
movl 0x4dbb(%rip), %edi      # 0x610c
leaq 0x4(%rsp), %rsi
movl $0x4, %edx
callq 0x10f0
cmpq $0x4, %rax
jne 0x13bd
movl 0x4(%rsp), %ebx
cmpl %ebx, (%rsp)
jne 0x13ce
movq 0x8(%rsp), %rdi
callq 0x241a
testl %eax, %eax
jne 0x13df
cmpl %ebx, (%rsp)
jne 0x13f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1c73(%rip), %rdi      # 0x3004
movl $0x11, %esi
callq 0x1401
leaq 0x1c86(%rip), %rdi      # 0x3028
movl $0x13, %esi
callq 0x1401
leaq 0x1c9a(%rip), %rdi      # 0x304d
movl $0x1d, %esi
callq 0x1401
leaq 0x1cd2(%rip), %rdi      # 0x3096
movl $0x25, %esi
callq 0x1401
leaq 0x1d22(%rip), %rdi      # 0x30f7
movl $0x26, %esi
callq 0x1401
leaq 0x1d31(%rip), %rdi      # 0x3117
movl $0x28, %esi
callq 0x1401
leaq 0x1d00(%rip), %rdi      # 0x30f7
movl $0x2a, %esi
callq 0x1401
// File: /workspace/github_c_makefile_star2_O1/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 0x2447
testl %eax, %eax
jne 0x1469
movl 0x4cd0(%rip), %edi      # 0x610c
callq 0x10c0
testl %eax, %eax
jne 0x147a
callq 0x1090
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movl 0x4cb9(%rip), %edi      # 0x6110
movl $0x4, %edx
callq 0x1080
cmpq $0x4, %rax
jne 0x148b
popq %rax
retq
leaq 0x1ce6(%rip), %rdi      # 0x3156
movl $0x8, %esi
callq 0x1401
leaq 0x1cfd(%rip), %rdi      # 0x317e
movl $0x9, %esi
callq 0x1401
leaq 0x1d04(%rip), %rdi      # 0x3196
movl $0xb, %esi
callq 0x1401
// File: /workspace/github_c_makefile_star2_O1/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 0x2575(%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 0x2c6b
movq %rsp, %rsi
movl $0x100000, %edx         # imm = 0x100000
movl %ebx, %edi
callq 0x20d0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x2c8a
movl %ebx, %edi
addq $0x100000, %rsp         # imm = 0x100000
popq %rbx
jmp 0x2150
leaq 0x60e(%rip), %rdi       # 0x3280
leaq 0x60f(%rip), %rsi       # 0x3288
leaq 0x616(%rip), %rcx       # 0x3296
movl $0x15, %edx
callq 0x2130
leaq 0x62a(%rip), %rdi       # 0x32bb
leaq 0x5f0(%rip), %rsi       # 0x3288
leaq 0x5f7(%rip), %rcx       # 0x3296
movl $0x16, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O1/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 0x24e6(%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 %rax, %rsi
movq %r14, %rdx
callq 0x2170
testl %eax, %eax
js 0x2d08
testl %eax, %eax
jne 0x2cfe
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
incq (%rbx)
movl %ebp, %edi
movq %r15, %rsi
jmp 0x2ce3
leaq 0x5d7(%rip), %rdi       # 0x32e6
leaq 0x572(%rip), %rsi       # 0x3288
leaq 0x5d2(%rip), %rcx       # 0x32ef
movl $0x23, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O1/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 0x13fde
movq %rax, %rbx
movq %rax, %rdi
callq 0x141e0
leaq -0x47(%rip), %rsi       # 0x47ac
movq %rbx, %rdi
xorl %edx, %edx
callq 0x51a9
leaq 0x1b812(%rip), %r14     # 0x20016
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55df
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5278
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5a3a
leaq 0x1b7e7(%rip), %rdi     # 0x20019
callq 0x40d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
leaq -0x17(%rip), %rsi       # 0x118c
movl $0x2, %edi
callq 0x1060
callq 0x1040
leaq 0xe4b(%rip), %rdi       # 0x2004
movl %eax, %esi
xorl %eax, %eax
callq 0x1050
cmpl $0x0, 0x2e93(%rip)      # 0x405c
jne 0x1207
movl $0x1, %ebx
leaq 0xe35(%rip), %r14       # 0x200c
movq 0x2e02(%rip), %r15      # 0x3fe0
movl $0x1, %edi
callq 0x1080
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x1050
movq (%r15), %rdi
callq 0x1070
incl %ebx
cmpl $0x0, 0x2e57(%rip)      # 0x405c
je 0x11de
leaq 0xe06(%rip), %rdi       # 0x2014
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13fd2
movq %rax, %rbx
movq %rax, %rdi
callq 0x141d4
leaq 0x1b84a(%rip), %rsi     # 0x20004
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13745
testl %eax, %eax
jne 0x47df
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5a96
leaq 0x1b82b(%rip), %r14     # 0x20011
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55d3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x495d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x526c
leaq 0x1b80c(%rip), %rdx     # 0x20019
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5383
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5a2e
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movzwl (%rdi,%rcx,2), %r8d
addq %r8, %rax
incq %rcx
cmpl $0x6, %ecx
jne 0x1243
testl %edx, %edx
jle 0x126a
incl %edx
movzwl (%rsi), %ecx
addq $0x2, %rsi
addq %rcx, %rax
decl %edx
cmpl $0x1, %edx
jg 0x1259
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_O1/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 0xe11(%rip), %rdi       # 0x2099
callq 0x1040
leaq 0xe4b(%rip), %rdi       # 0x20df
callq 0x1040
leaq 0xe58(%rip), %rdi       # 0x20f8
callq 0x1040
leaq 0xe63(%rip), %rdi       # 0x210f
callq 0x1040
leaq 0xe69(%rip), %rdi       # 0x2121
callq 0x1040
leaq 0xe80(%rip), %rdi       # 0x2144
callq 0x1040
leaq 0xeae(%rip), %rdi       # 0x217e
callq 0x1040
leaq 0xd68(%rip), %rdi       # 0x2044
leaq 0xd6e(%rip), %rsi       # 0x2051
xorl %eax, %eax
popq %rcx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0xa49e
movq (%rdx), %rax
cmpl %esi, (%rax)
jl 0xa49e
movq 0x8(%rax), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
movslq (%rax), %r12
testq %r12, %r12
jle 0xa49e
movq %rdi, %rbx
movq %rax, (%rsp)
movq 0x8(%rax), %rbp
leaq -0x1(%r12), %r15
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%rbp,%r13,8), %rdi
movq %rbx, %rsi
callq 0xa4c4
testl %eax, %eax
je 0xa4b6
movq (%rbp,%r15,8), %rdi
movq %rbx, %rsi
callq 0xa4c4
testl %eax, %eax
je 0xa4b3
incq %r13
cmpq %r12, %r13
jae 0xa4a1
leaq -0x1(%r15), %rax
cmpq %r15, %r13
movq %rax, %r15
jl 0xa466
jmp 0xa4a1
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %r13
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax,%r13,8), %r14
jmp 0xa4a1
// File: /workspace/github_c_makefile_star2_O1/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 0xa5c5
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xa5b4
movslq (%rbx), %r14
testq %r14, %r14
jle 0xa5ab
leaq -0x8(,%r14,8), %r15
decq %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rdi
cmpq $0x0, (%rdi,%r12)
je 0xa581
addq %r12, %rdi
callq 0xa5c6
movq 0x8(%rbx), %rdi
cmpq $0x0, (%rdi,%r15)
je 0xa594
addq %r15, %rdi
callq 0xa5c6
incq %r13
addq $0x8, %r12
addq $-0x8, %r15
leaq -0x1(%r14), %rax
cmpq %r14, %r13
movq %rax, %r14
jl 0xa56e
movq 0x8(%rbx), %rdi
callq 0x2190
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2190
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %r14, %r14
jle 0xa686
decq %r14
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0xa607
callq 0x2190
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax,%r15,8)
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0xa62b
callq 0x2190
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax,%r15,8)
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xa64f
callq 0x2190
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax,%r14,8)
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xa673
callq 0x2190
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax,%r14,8)
incq %r15
leaq -0x1(%r14), %rax
cmpq %r15, %r14
movq %rax, %r14
jg 0xa5e3
movq (%rbx), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0xa6a2
callq 0x2190
movq (%rbx), %rax
movq $0x0, 0x8(%rax)
movq (%rbx), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xa6be
callq 0x2190
movq (%rbx), %rax
movq $0x0, 0x10(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa6d2
callq 0x2190
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6414
movq %rax, %rbx
movq %rax, 0x8(%rsp)
testb $0x2, (%r15)
movq 0x58(%rax), %rax
jne 0xa7d2
leaq 0x1e7f(%rip), %rsi      # 0xc62e
leaq 0x8(%rsp), %rdi
callq *%rax
testl %eax, %eax
js 0xa83e
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x1e7a(%rip), %rsi      # 0xc647
callq *0x68(%rax)
jmp 0xa7dd
movq 0x10(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq *%rax
testl %eax, %eax
js 0xa83e
movq %rbx, %rdi
callq *0xc8(%rbx)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2400
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
testl %eax, %eax
jne 0xa843
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
cmpl $0x4000, %eax           # imm = 0x4000
je 0xa843
movq %rbx, %rdi
callq *0xc8(%rbx)
leaq 0x1ecd(%rip), %rsi      # 0xc6f2
movq %rax, %rdi
callq 0x20f0
movq %rax, (%r14)
xorl %ebp, %ebp
testq %rax, %rax
jne 0xa848
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
jmp 0xa843
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $-0x1, %ebp
jne 0xa861
movq %rbx, %rdi
callq *0x268(%rbx)
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
cmpl $-0x4, %ebp
je 0xa875
cmpl $-0x3, %ebp
jne 0xa87c
callq 0x26de
jmp 0xa848
callq 0x2768
jmp 0xa848
callq 0x2723
jmp 0xa848
// File: /workspace/github_c_makefile_star2_O1/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 0x23e0
incl %ebx
cltd
idivl %ebx
movl %edx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, (%rsp)
testb $0x4, (%rsi)
je 0xae9c
movq 0x6176(%rip), %rax      # 0x10ff8
movq (%rax), %rax
movq 0x8(%rsi), %rdx
movl (%rdi), %ecx
leaq 0x176d(%rip), %rsi      # 0xc5ff
movq %rax, %rdi
xorl %eax, %eax
callq 0x23f0
movq (%rsp), %rax
cmpl $0x0, (%rax)
jle 0xaeec
movq 0x614c(%rip), %r13      # 0x10ff8
leaq 0x1775(%rip), %rbx      # 0xc628
movq %rsp, %r14
leaq 0x1763(%rip), %r15      # 0xc620
xorl %ebp, %ebp
movq (%r13), %r12
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0xa41b
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x23f0
incl %ebp
movq (%rsp), %rax
cmpl (%rax), %ebp
jl 0xaebf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xb1d5
callq 0x2380
testq %rbx, %rbx
je 0xb1e3
movq %rbx, %rdi
popq %rbx
jmp 0xa539
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl $0xffffffff, 0xf8(%rdi) # imm = 0xFFFFFFFF
movl $0x1, %ebx
cmpl $0x0, 0x1a4(%rdi)
jne 0x2bcf
movq %rdi, %r15
leaq 0xf0(%rdi), %r14
movq 0xf0(%rdi), %rdi
testq %rdi, %rdi
je 0x2bbe
xorl %esi, %esi
callq 0x2390
cmpl $-0x1, %eax
je 0x2bbe
movq (%r14), %rdi
movq %rsp, %rsi
callq 0x2270
testl %eax, %eax
js 0x2bc8
movq 0x30(%rsp), %rax
movq %rax, 0x10(%r15)
movq 0xf0(%r15), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2380
movl %eax, 0xf8(%r15)
testl %eax, %eax
jns 0x2bcf
movq %r14, %rdi
callq 0x2500
jmp 0x2bcd
movq %r14, %rdi
callq 0x254a
jmp 0x2bcd
callq 0x251e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
testl %edi, %edi
jle 0x1261
negl %edi
movl $0x1, %eax
movl $0x1, %ecx
imull %ecx, %eax
leal (%rdi,%rcx), %edx
incl %edx
incl %ecx
cmpl $0x1, %edx
jne 0x1250
jmp 0x1266
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %r14d
xorl %r12d, %r12d
movq 0x2d52(%rip), %rbx      # 0x3fd8
leaq 0xd87(%rip), %r13       # 0x2014
movl $0xa, %edx
movq %rbx, %rdi
leaq 0xd68(%rip), %rsi       # 0x2004
callq 0x1080
movq %rbx, %rdi
movl %r14d, %esi
callq 0x10c0
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
leaq 0xd51(%rip), %rsi       # 0x200f
callq 0x1080
movl $0x1, %esi
movl $0x1, %eax
imull %eax, %esi
leal (%r12,%rax), %ecx
incl %ecx
incl %eax
cmpl $0x2, %ecx
jne 0x12cd
movq %r15, %rdi
callq 0x10c0
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x1080
leal 0x1(%r14), %eax
decl %r12d
cmpl $0x5, %r14d
movl %eax, %r14d
jne 0x128d
movl $0x8, %edi
callq 0x1050
movq $0x0, (%rax)
leaq 0x2a8b(%rip), %rsi      # 0x3da8
movq %rax, %rdi
xorl %edx, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/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       # 0x1327
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_O1/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 0x11b5
cmpl $0x0, (%rcx)
je 0x11c5
cmpl %edx, %edi
jne 0x11cc
cmpl $0x0, (%rcx)
jne 0x11cc
movl $0x1, %eax
jmp 0x11ca
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rcx)
cmpl %edx, %edi
jne 0x11d5
cmpl $-0x1, (%rcx)
je 0x11de
cmpl %esi, %edi
jne 0x11e4
cmpl $0x1, (%rcx)
jne 0x11e4
movl $0x0, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x1285
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
xorl %r15d, %r15d
xorl %r13d, %r13d
movq %rax, (%rsp)
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x1277
movl $0x1, %eax
testl %r13d, %r13d
je 0x1224
movl %r13d, %eax
cmpl %ebx, %ebp
cmovnel %r13d, %eax
xorl %ecx, %ecx
cmpl $0x1, %r13d
sbbl %ecx, %ecx
orl %eax, %ecx
cmpl %ebx, %r14d
cmovnel %eax, %ecx
movl $0x0, %edx
cmpl $0x1, %ecx
je 0x1246
movl %ecx, %edx
cmpl %ebx, %r14d
notl %ecx
cmovel %edx, %eax
movl %ebp, %edx
xorl %ebx, %edx
orl %ecx, %edx
movl %eax, %r13d
jne 0x125c
xorl %r13d, %r13d
testl %r13d, %r13d
je 0x126f
movq %r12, %rdi
callq 0x2196
addl %eax, %r15d
incl %r15d
incl %ebx
movq (%r12), %r12
jmp 0x1212
movq (%rsp), %rax
movq (%rax), %rax
testq %rax, %rax
jne 0x120a
jmp 0x1288
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %r14
movq 0x38(%rdi), %r12
testq %r12, %r12
je 0x12e2
movq %rsi, %r15
xorl %ebp, %ebp
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x4198
testl %eax, %eax
je 0x12e4
leaq 0x8(%r12), %rax
decl %ebp
movq (%rax), %rax
incl %ebp
testq %rax, %rax
jne 0x12cd
movq (%r12), %r12
testq %r12, %r12
jne 0x12b5
jmp 0x12e4
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11e5
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2fa8
// File: /workspace/github_c_makefile_star2_O1/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 0x13b1
pushq %rbx
movq %rsi, %rbx
leaq 0x4ca3(%rip), %rdi      # 0x6004
callq 0x452c
movq (%rbx), %rdi
callq 0x452c
leaq 0x4c98(%rip), %rdi      # 0x600d
callq 0x4548
leaq 0x4ca7(%rip), %rdi      # 0x6028
callq 0x4548
leaq 0x4cd6(%rip), %rdi      # 0x6063
leaq 0x4cf8(%rip), %rsi      # 0x608c
xorl %eax, %eax
callq 0x48d0
leaq 0x4d09(%rip), %rdi      # 0x60ab
leaq 0x4d30(%rip), %rsi      # 0x60d9
xorl %eax, %eax
popq %rbx
jmp 0x48d0
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq $0x0, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
xorl %eax, %eax
movl %eax, 0x30(%rdi)
movl $0x1, 0x40(%rdi)
movl %eax, 0x50(%rdi)
testq %rsi, %rsi
je 0x13fc
movq %rsi, %r14
movq %rbx, %rdi
callq 0x1d42
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x1090
movl %eax, 0x8(%rbx)
jmp 0x1406
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2ef8
cmpl $0x0, 0x8(%rbx)
jns 0x1418
leaq 0x4cdb(%rip), %rdi      # 0x60ee
callq 0x1f38
movq %rbx, %rdi
callq 0x3800
movq %rbx, %rdi
callq 0x1544
movq %rbx, %rdi
callq 0x4014
movq %rbx, %rdi
callq 0x1e2d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x131f
// File: /workspace/github_c_makefile_star2_O1/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 0x280c
movq $0x0, (%rsp)
cmpl $0x2, %ebp
jl 0x1529
movl $0x1, %r12d
leaq 0x4c7b(%rip), %r14      # 0x60f8
leaq 0x4c77(%rip), %r15      # 0x60fb
movslq %r12d, %rax
movq (%rbx,%rax,8), %rdi
movq %r14, %rsi
callq 0x4198
testl %eax, %eax
je 0x149c
movl %r12d, %r13d
jmp 0x14ad
leal 0x1(%r12), %r13d
testl %r12d, %r12d
js 0x14ad
movl $0x1, (%rsp)
movslq %r13d, %rax
movq (%rbx,%rax,8), %rdi
movq %r15, %rsi
callq 0x4198
testl %eax, %eax
je 0x14c5
movl %r13d, %r12d
jmp 0x14d6
leal 0x1(%r13), %r12d
testl %r13d, %r13d
js 0x14d6
movl $0x1, 0x4(%rsp)
movslq %r12d, %r13
movq (%rbx,%r13,8), %rdi
movq %r15, %rsi
callq 0x4198
testl %eax, %eax
je 0x1520
movq (%rbx,%r13,8), %rdi
movq %r14, %rsi
callq 0x4198
testl %eax, %eax
je 0x1520
movq (%rbx,%r13,8), %rdi
leaq 0x4bfa(%rip), %rsi      # 0x60fe
callq 0x4198
testl %eax, %eax
je 0x1513
movq (%rbx,%r13,8), %rsi
jmp 0x1515
xorl %esi, %esi
movq %rsp, %rdi
callq 0x13b2
incl %r12d
cmpl %ebp, %r12d
jl 0x1484
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1351
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/build.c
// Function: build
void	build(t_data *data)
{
	t_label		*tmp_lbl;
	t_instruc	*tmp_inst;
	int			inst_pos;

	tmp_lbl = data->label;
	inst_pos = 0;
	while (tmp_lbl)
	{
		tmp_inst = tmp_lbl->insts;
		while (tmp_inst)
		{
			add_to_prog(data, ((unsigned char *)(&tmp_inst->opcode))[0]);
			if (tmp_inst->ocp > 0)
				add_to_prog(data, ((unsigned char *)(&tmp_inst->ocp))[0]);
			add_param_to_prog(data, tmp_inst, tmp_lbl->name, inst_pos);
			tmp_inst = tmp_inst->next;
			inst_pos++;
		}
		tmp_lbl = tmp_lbl->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x38(%rdi), %r15
testq %r15, %r15
je 0x15a3
movq %rdi, %rbx
xorl %ebp, %ebp
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x159b
movzbl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x388c
cmpl $0x0, 0x38(%r14)
jle 0x1583
movzbl 0x38(%r14), %esi
movq %rbx, %rdi
callq 0x388c
movq 0x10(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x15ae
incl %ebp
movq (%r14), %r14
jmp 0x155d
movq (%r15), %r15
testq %r15, %r15
jne 0x1559
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/build.c
// Function: add_param_to_prog
void	add_param_to_prog(t_data *data, t_instruc *inst, char *lbl_name,
															int inst_pos)
{
	int		ind;

	ind = 0;
	if (ft_strcmp(inst->name, "sti") == 0 ||
			ft_strcmp(inst->name, "lldi") == 0 ||
			ft_strcmp(inst->name, "ldi") == 0)
		ind = 1;
	if (inst->param_1 != NULL)
	{
		if (inst->ocp == -4)
			set_live(data, inst->param_1, lbl_name, inst_pos);
		else if (inst->ocp == -2)
			set_special(data, inst->param_1, lbl_name, inst_pos);
		else if (get_ocp(inst->ocp, 0) == 1)
			set_register(data, inst->param_1);
		else if (ind == 0 && get_ocp(inst->ocp, 0) == 2)
			set_direct(data, inst->param_1, lbl_name, inst_pos);
		else if (get_ocp(inst->ocp, 0) == 3)
			set_indirect(data, inst->param_1, lbl_name, inst_pos);
		else if (ind == 1)
			set_address(data, inst->param_1, lbl_name, inst_pos);
	}
	add_param_to_prog_2(data, inst, lbl_name, inst_pos);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rsi), %rdi
leaq 0x4b32(%rip), %rsi      # 0x6101
callq 0x4198
testl %eax, %eax
je 0x1607
movq 0x8(%r15), %rdi
leaq 0x4b22(%rip), %rsi      # 0x6105
callq 0x4198
testl %eax, %eax
je 0x1607
movq 0x8(%r15), %rdi
leaq 0x4b0f(%rip), %rsi      # 0x6106
callq 0x4198
testl %eax, %eax
je 0x1607
movb $0x1, %r13b
xorl %ebp, %ebp
jmp 0x160d
movb $0x1, %bpl
xorl %r13d, %r13d
movq 0x18(%r15), %rsi
testq %rsi, %rsi
je 0x16c4
movl 0x38(%r15), %edi
cmpl $-0x2, %edi
je 0x163a
cmpl $-0x4, %edi
jne 0x1649
movq %r12, %rdi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x3c6a
jmp 0x16c4
movq %r12, %rdi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x3d06
jmp 0x16c4
xorl %esi, %esi
callq 0x2050
cmpl $0x1, %eax
jne 0x1663
movq 0x18(%r15), %rsi
movq %r12, %rdi
callq 0x3bd9
jmp 0x16c4
testb %r13b, %r13b
je 0x168b
movl 0x38(%r15), %edi
xorl %esi, %esi
callq 0x2050
cmpl $0x2, %eax
jne 0x168b
movq 0x18(%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x3acc
jmp 0x16c4
movl 0x38(%r15), %edi
xorl %esi, %esi
callq 0x2050
cmpl $0x3, %eax
jne 0x16ae
movq 0x18(%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x3b68
jmp 0x16c4
testb %bpl, %bpl
je 0x16c4
movq 0x18(%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x3bf4
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x181f
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/build.c
// Function: add_param_to_prog_3
void	add_param_to_prog_3(t_data *data, t_instruc *inst, char *lbl_name,
		int inst_pos)
{
	int		ind;

	ind = 0;
	if (ft_strcmp(inst->name, "sti") == 0 ||
			ft_strcmp(inst->name, "lldi") == 0 ||
			ft_strcmp(inst->name, "ldi") == 0)
		ind = 1;
	if (inst->param_3 != NULL)
	{
		if (get_ocp(inst->ocp, 2) == 1)
			set_register(data, inst->param_3);
		else if (ind == 0 && get_ocp(inst->ocp, 2) == 2)
			set_direct(data, inst->param_3, lbl_name, inst_pos);
		else if (get_ocp(inst->ocp, 2) == 3)
			set_indirect(data, inst->param_3, lbl_name, inst_pos);
		else if (ind == 1)
			set_address(data, inst->param_3, lbl_name, inst_pos);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rsi), %rdi
leaq 0x49fe(%rip), %rsi      # 0x6101
callq 0x4198
testl %eax, %eax
je 0x173d
movq 0x8(%r12), %rdi
leaq 0x49ed(%rip), %rsi      # 0x6105
callq 0x4198
testl %eax, %eax
je 0x173d
movq 0x8(%r12), %rdi
leaq 0x49d9(%rip), %rsi      # 0x6106
callq 0x4198
testl %eax, %eax
je 0x173d
movb $0x1, %r13b
xorl %ebp, %ebp
jmp 0x1743
movb $0x1, %bpl
xorl %r13d, %r13d
cmpq $0x0, 0x28(%r12)
je 0x1810
movl 0x38(%r12), %edi
movl $0x2, %esi
callq 0x2050
cmpl $0x1, %eax
jne 0x177e
movq 0x28(%r12), %rsi
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3bd9
testb %r13b, %r13b
je 0x17b7
movl 0x38(%r12), %edi
movl $0x2, %esi
callq 0x2050
cmpl $0x2, %eax
jne 0x17b7
movq 0x28(%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3acc
movl 0x38(%r12), %edi
movl $0x2, %esi
callq 0x2050
cmpl $0x3, %eax
jne 0x17eb
movq 0x28(%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b68
testb %bpl, %bpl
je 0x1810
movq 0x28(%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3bf4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq