LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/sm/cmd_sm_drive_auth.c
// Function: cmd_sm_drive_auth_exec
int
cmd_sm_drive_auth_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_sm_drive_auth drive_auth;
	uint64_t arg, laid, paid;
	char *endptr;
	int ret;

	arg = strtoull(argv[0], &endptr, 0);
	if (*endptr != '\0')
		return (CMD_EINVAL);

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&drive_auth.dm_hdr, 1, PS3DM_FID_SM,
	    sizeof(drive_auth) - sizeof(struct ps3dm_header),
	    sizeof(drive_auth) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&drive_auth.ss_hdr, PS3DM_PID_SM_DRIVE_AUTH,
	    laid, paid);
	drive_auth.arg = arg;

	ret = dev_write(&drive_auth, sizeof(drive_auth));
	if (ret != sizeof(drive_auth))
		return (CMD_EIO);

	ret = dev_read(&drive_auth, sizeof(drive_auth));
	if (ret != sizeof(drive_auth))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", drive_auth.ss_hdr.status);

	if (drive_auth.ss_hdr.status)
		return (CMD_EIO);

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x80(%rbp), %rsi
xorl %edx, %edx
callq 0x20a0
movq %rax, -0x68(%rbp)
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2827
movl $0x2, -0x4(%rbp)
jmp 0x2975
leaq 0x6892(%rip), %rax      # 0x90c0
cmpl $0x0, 0x20(%rax)
je 0x2848
leaq 0x6885(%rip), %rax      # 0x90c0
movq 0x18(%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0x285b
movabsq $0x1070000002000001, %rax # imm = 0x1070000002000001
movq %rax, -0x90(%rbp)
jmp 0x285b
movq -0x90(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x6853(%rip), %rax      # 0x90c0
cmpl $0x0, 0x30(%rax)
je 0x2887
leaq 0x6846(%rip), %rax      # 0x90c0
movq 0x28(%rax), %rax
movq %rax, -0x98(%rbp)
jmp 0x289a
movabsq $0x10700003ff000001, %rax # imm = 0x10700003FF000001
movq %rax, -0x98(%rbp)
jmp 0x289a
movq -0x98(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
movl $0x1, %esi
movl $0x5000, %edx           # imm = 0x5000
movl $0x30, %r8d
movl %r8d, %ecx
callq 0x2990
leaq -0x60(%rbp), %rdi
addq $0x10, %rdi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
movl $0x5004, %esi           # imm = 0x5004
callq 0x29d0
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x60(%rbp), %rdi
movl $0x40, %esi
callq 0x2620
movl %eax, -0x84(%rbp)
movslq -0x84(%rbp), %rax
cmpq $0x40, %rax
je 0x290d
movl $0x3, -0x4(%rbp)
jmp 0x2975
leaq -0x60(%rbp), %rdi
movl $0x40, %esi
callq 0x2670
movl %eax, -0x84(%rbp)
movslq -0x84(%rbp), %rax
cmpq $0x40, %rax
je 0x2937
movl $0x3, -0x4(%rbp)
jmp 0x2975
leaq 0x6782(%rip), %rax      # 0x90c0
cmpl $0x0, 0x8(%rax)
jle 0x295f
movq 0x66ad(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movl -0x40(%rbp), %edx
leaq 0x38cc(%rip), %rsi      # 0x6224
movb $0x0, %al
callq 0x20c0
cmpl $0x0, -0x40(%rbp)
je 0x296e
movl $0x3, -0x4(%rbp)
jmp 0x2975
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/sm/../ps3dm_msg.h
// Function: ps3dm_init_header
static inline void
ps3dm_init_header(struct ps3dm_header *hdr, uint32_t tag, uint32_t fid,
    uint32_t payload_length, uint32_t reply_length)
{
	hdr->tag = tag;
	hdr->fid = fid;
	hdr->payload_length = payload_length;
	hdr->reply_length = reply_length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/sm/../ps3dm_msg.h
// Function: ps3dm_init_ss_header
static inline void
ps3dm_init_ss_header( struct ps3dm_ss_header *hdr, uint64_t pid,
    uint64_t laid, uint64_t paid)
{
	hdr->pid = pid;
	hdr->fid = PS3DM_FID(pid);
	hdr->laid = laid;
	hdr->paid = paid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
andq $-0x1000, %rcx          # imm = 0xF000
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/sm/cmd_sm_get_rnd.c
// Function: cmd_sm_get_rnd_exec
int
cmd_sm_get_rnd_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_sm_get_rnd get_rnd;
	uint64_t laid, paid;
	int len;
	int ret;

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x1070000031000001ull;

	ps3dm_init_header(&get_rnd.dm_hdr, 1, PS3DM_FID_SM,
	    sizeof(struct ps3dm_ss_header),
	    sizeof(get_rnd) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&get_rnd.ss_hdr, PS3DM_PID_SM_GET_RND,
	    laid, paid);

	len = sizeof(struct ps3dm_header) + sizeof(struct ps3dm_ss_header);

	ret = dev_write(&get_rnd, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&get_rnd, sizeof(get_rnd));
	if (ret != sizeof(get_rnd))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", get_rnd.ss_hdr.status);

	if (get_rnd.ss_hdr.status)
		return (CMD_EIO);

	fwrite((char *) get_rnd.rnd, 1, sizeof(get_rnd.rnd), stdout);

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x6680(%rip), %rax      # 0x90c0
cmpl $0x0, 0x20(%rax)
je 0x2a5a
leaq 0x6673(%rip), %rax      # 0x90c0
movq 0x18(%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0x2a6d
movabsq $0x1070000002000001, %rax # imm = 0x1070000002000001
movq %rax, -0x90(%rbp)
jmp 0x2a6d
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x6641(%rip), %rax      # 0x90c0
cmpl $0x0, 0x30(%rax)
je 0x2a99
leaq 0x6634(%rip), %rax      # 0x90c0
movq 0x28(%rax), %rax
movq %rax, -0x98(%rbp)
jmp 0x2aac
movabsq $0x1070000031000001, %rax # imm = 0x1070000031000001
movq %rax, -0x98(%rbp)
jmp 0x2aac
movq -0x98(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
movl $0x1, %esi
movl $0x5000, %edx           # imm = 0x5000
movl $0x28, %ecx
movl $0x40, %r8d
callq 0x2bc0
leaq -0x70(%rbp), %rdi
addq $0x10, %rdi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
movl $0x5003, %esi           # imm = 0x5003
callq 0x2c00
movl $0x38, -0x84(%rbp)
movslq -0x84(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x2620
movl %eax, -0x88(%rbp)
movl -0x88(%rbp), %eax
cmpl -0x84(%rbp), %eax
je 0x2b29
movl $0x3, -0x4(%rbp)
jmp 0x2bb2
leaq -0x70(%rbp), %rdi
movl $0x50, %esi
callq 0x2670
movl %eax, -0x88(%rbp)
movslq -0x88(%rbp), %rax
cmpq $0x50, %rax
je 0x2b53
movl $0x3, -0x4(%rbp)
jmp 0x2bb2
leaq 0x6566(%rip), %rax      # 0x90c0
cmpl $0x0, 0x8(%rax)
jle 0x2b7b
movq 0x6491(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movl -0x50(%rbp), %edx
leaq 0x36b0(%rip), %rsi      # 0x6224
movb $0x0, %al
callq 0x20c0
cmpl $0x0, -0x50(%rbp)
je 0x2b8a
movl $0x3, -0x4(%rbp)
jmp 0x2bb2
leaq -0x70(%rbp), %rdi
addq $0x38, %rdi
movq 0x642f(%rip), %rax      # 0x8fc8
movq (%rax), %rcx
movl $0x1, %esi
movl $0x18, %edx
callq 0x2130
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/sm/cmd_sm_get_version.c
// Function: cmd_sm_get_version_exec
int
cmd_sm_get_version_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_sm_get_version get_version;
	uint64_t laid, paid;
	int len;
	int ret;

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&get_version.dm_hdr, 1, PS3DM_FID_SM,
	    sizeof(struct ps3dm_ss_header),
	    sizeof(get_version) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&get_version.ss_hdr, PS3DM_PID_SM_GET_VERSION,
	    laid, paid);

	len = sizeof(struct ps3dm_header) + sizeof(struct ps3dm_ss_header);

	ret = dev_write(&get_version, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&get_version, sizeof(get_version));
	if (ret != sizeof(get_version))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", get_version.ss_hdr.status);

	if (get_version.ss_hdr.status)
		return (CMD_EIO);

	hex_fprintf(stdout, (char *) get_version.version,
	    sizeof(get_version.version));

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x6450(%rip), %rax      # 0x90c0
cmpl $0x0, 0x20(%rax)
je 0x2c87
leaq 0x6443(%rip), %rax      # 0x90c0
movq 0x18(%rax), %rax
movq %rax, -0x80(%rbp)
jmp 0x2c97
movabsq $0x1070000002000001, %rax # imm = 0x1070000002000001
movq %rax, -0x80(%rbp)
jmp 0x2c97
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x641a(%rip), %rax      # 0x90c0
cmpl $0x0, 0x30(%rax)
je 0x2cc0
leaq 0x640d(%rip), %rax      # 0x90c0
movq 0x28(%rax), %rax
movq %rax, -0x88(%rbp)
jmp 0x2cd3
movabsq $0x10700003ff000001, %rax # imm = 0x10700003FF000001
movq %rax, -0x88(%rbp)
jmp 0x2cd3
movq -0x88(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
movl $0x1, %esi
movl $0x5000, %edx           # imm = 0x5000
movl $0x28, %ecx
movl $0x30, %r8d
callq 0x2dd0
leaq -0x60(%rbp), %rdi
addq $0x10, %rdi
movq -0x68(%rbp), %rdx
movq -0x70(%rbp), %rcx
movl $0x5006, %esi           # imm = 0x5006
callq 0x2e10
movl $0x38, -0x74(%rbp)
movslq -0x74(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x2620
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %eax
cmpl -0x74(%rbp), %eax
je 0x2d3e
movl $0x3, -0x4(%rbp)
jmp 0x2dbc
leaq -0x60(%rbp), %rdi
movl $0x40, %esi
callq 0x2670
movl %eax, -0x78(%rbp)
movslq -0x78(%rbp), %rax
cmpq $0x40, %rax
je 0x2d62
movl $0x3, -0x4(%rbp)
jmp 0x2dbc
leaq 0x6357(%rip), %rax      # 0x90c0
cmpl $0x0, 0x8(%rax)
jle 0x2d8a
movq 0x6282(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movl -0x40(%rbp), %edx
leaq 0x34a1(%rip), %rsi      # 0x6224
movb $0x0, %al
callq 0x20c0
cmpl $0x0, -0x40(%rbp)
je 0x2d99
movl $0x3, -0x4(%rbp)
jmp 0x2dbc
movq 0x6228(%rip), %rax      # 0x8fc8
movq (%rax), %rdi
leaq -0x60(%rbp), %rsi
addq $0x38, %rsi
movl $0x8, %edx
callq 0x56e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/vtrm/cmd_vtrm_init.c
// Function: cmd_vtrm_init_exec
int
cmd_vtrm_init_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_vtrm_init init;
	uint64_t laid, paid;
	int len;
	int ret;

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&init.dm_hdr, 1, PS3DM_FID_SM,
	    sizeof(struct ps3dm_ss_header),
	    sizeof(init) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&init.ss_hdr, PS3DM_PID_VTRM_INIT,
	    laid, paid);

	len = sizeof(struct ps3dm_header) + sizeof(struct ps3dm_ss_header);

	ret = dev_write(&init, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&init, sizeof(init));
	if (ret != sizeof(init))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", init.ss_hdr.status);

	if (init.ss_hdr.status)
		return (CMD_EIO);

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x5820(%rip), %rax      # 0x90c0
cmpl $0x0, 0x20(%rax)
je 0x38b7
leaq 0x5813(%rip), %rax      # 0x90c0
movq 0x18(%rax), %rax
movq %rax, -0x78(%rbp)
jmp 0x38c7
movabsq $0x1070000002000001, %rax # imm = 0x1070000002000001
movq %rax, -0x78(%rbp)
jmp 0x38c7
movq -0x78(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x57ea(%rip), %rax      # 0x90c0
cmpl $0x0, 0x30(%rax)
je 0x38ed
leaq 0x57dd(%rip), %rax      # 0x90c0
movq 0x28(%rax), %rax
movq %rax, -0x80(%rbp)
jmp 0x38fd
movabsq $0x10700003ff000001, %rax # imm = 0x10700003FF000001
movq %rax, -0x80(%rbp)
jmp 0x38fd
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x58(%rbp), %rdi
movl $0x1, %esi
movl $0x5000, %edx           # imm = 0x5000
movl $0x28, %r8d
movl %r8d, %ecx
callq 0x39e0
leaq -0x58(%rbp), %rdi
addq $0x10, %rdi
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rcx
movl $0x2001, %esi           # imm = 0x2001
callq 0x3a20
movl $0x38, -0x6c(%rbp)
movslq -0x6c(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x2620
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %eax
cmpl -0x6c(%rbp), %eax
je 0x3963
movl $0x3, -0x4(%rbp)
jmp 0x39c5
leaq -0x58(%rbp), %rdi
movl $0x38, %esi
callq 0x2670
movl %eax, -0x70(%rbp)
movslq -0x70(%rbp), %rax
cmpq $0x38, %rax
je 0x3987
movl $0x3, -0x4(%rbp)
jmp 0x39c5
leaq 0x5732(%rip), %rax      # 0x90c0
cmpl $0x0, 0x8(%rax)
jle 0x39af
movq 0x565d(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movl -0x38(%rbp), %edx
leaq 0x287c(%rip), %rsi      # 0x6224
movb $0x0, %al
callq 0x20c0
cmpl $0x0, -0x38(%rbp)
je 0x39be
movl $0x3, -0x4(%rbp)
jmp 0x39c5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/aim/cmd_aim_get_dev_id.c
// Function: cmd_aim_get_dev_id_exec
int
cmd_aim_get_dev_id_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_aim_get_dev_id get_dev_id;
	uint64_t laid, paid;
	int len;
	int ret;

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&get_dev_id.dm_hdr, 1, PS3DM_FID_AIM,
	    sizeof(get_dev_id) - sizeof(struct ps3dm_header),
	    sizeof(get_dev_id) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&get_dev_id.ss_hdr, PS3DM_PID_AIM_GET_DEV_ID,
	    laid, paid);

	len = sizeof(get_dev_id);

	ret = dev_write(&get_dev_id, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&get_dev_id, sizeof(get_dev_id));
	if (ret != sizeof(get_dev_id))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", get_dev_id.ss_hdr.status);

	if (get_dev_id.ss_hdr.status)
		return (CMD_EIO);

	hex_fprintf(stdout, (char *) get_dev_id.data, sizeof(get_dev_id.data));

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x4a70(%rip), %rax      # 0x90c0
cmpl $0x0, 0x20(%rax)
je 0x466a
leaq 0x4a63(%rip), %rax      # 0x90c0
movq 0x18(%rax), %rax
movq %rax, -0x88(%rbp)
jmp 0x467d
movabsq $0x1070000002000001, %rax # imm = 0x1070000002000001
movq %rax, -0x88(%rbp)
jmp 0x467d
movq -0x88(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x4a31(%rip), %rax      # 0x90c0
cmpl $0x0, 0x30(%rax)
je 0x46a9
leaq 0x4a24(%rip), %rax      # 0x90c0
movq 0x28(%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0x46bc
movabsq $0x10700003ff000001, %rax # imm = 0x10700003FF000001
movq %rax, -0x90(%rbp)
jmp 0x46bc
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x68(%rbp), %rdi
movl $0x1, %esi
movl $0x19000, %edx          # imm = 0x19000
movl $0x38, %r8d
movl %r8d, %ecx
callq 0x47b0
leaq -0x68(%rbp), %rdi
addq $0x10, %rdi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
movl $0x19003, %esi          # imm = 0x19003
callq 0x47f0
movl $0x48, -0x7c(%rbp)
movslq -0x7c(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x2620
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %eax
cmpl -0x7c(%rbp), %eax
je 0x4725
movl $0x3, -0x4(%rbp)
jmp 0x47a3
leaq -0x68(%rbp), %rdi
movl $0x48, %esi
callq 0x2670
movl %eax, -0x80(%rbp)
movslq -0x80(%rbp), %rax
cmpq $0x48, %rax
je 0x4749
movl $0x3, -0x4(%rbp)
jmp 0x47a3
leaq 0x4970(%rip), %rax      # 0x90c0
cmpl $0x0, 0x8(%rax)
jle 0x4771
movq 0x489b(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movl -0x48(%rbp), %edx
leaq 0x1aba(%rip), %rsi      # 0x6224
movb $0x0, %al
callq 0x20c0
cmpl $0x0, -0x48(%rbp)
je 0x4780
movl $0x3, -0x4(%rbp)
jmp 0x47a3
movq 0x4841(%rip), %rax      # 0x8fc8
movq (%rax), %rdi
leaq -0x68(%rbp), %rsi
addq $0x38, %rsi
movl $0x10, %edx
callq 0x56e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/aim/cmd_aim_get_dev_type.c
// Function: cmd_aim_get_dev_type_exec
int
cmd_aim_get_dev_type_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_aim_get_dev_type get_dev_type;
	uint64_t laid, paid;
	int len;
	int ret;

	laid = opts.laid_valid ? opts.laid : 0x1070000002000001ull;
	paid = opts.paid_valid ? opts.paid : 0x10700003ff000001ull;

	ps3dm_init_header(&get_dev_type.dm_hdr, 1, PS3DM_FID_AIM,
	    sizeof(get_dev_type) - sizeof(struct ps3dm_header),
	    sizeof(get_dev_type) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&get_dev_type.ss_hdr, PS3DM_PID_AIM_GET_DEV_TYPE,
	    laid, paid);

	len = sizeof(get_dev_type);

	ret = dev_write(&get_dev_type, len);
	if (ret != len)
		return (CMD_EIO);

	ret = dev_read(&get_dev_type, sizeof(get_dev_type));
	if (ret != sizeof(get_dev_type))
		return (CMD_EIO);

	if (opts.do_verbose > 0)
		fprintf(stderr, "ss status %d\n", get_dev_type.ss_hdr.status);

	if (get_dev_type.ss_hdr.status)
		return (CMD_EIO);

	hex_fprintf(stdout, (char *) get_dev_type.data, sizeof(get_dev_type.data));

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x4860(%rip), %rax      # 0x90c0
cmpl $0x0, 0x20(%rax)
je 0x487a
leaq 0x4853(%rip), %rax      # 0x90c0
movq 0x18(%rax), %rax
movq %rax, -0x88(%rbp)
jmp 0x488d
movabsq $0x1070000002000001, %rax # imm = 0x1070000002000001
movq %rax, -0x88(%rbp)
jmp 0x488d
movq -0x88(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x4821(%rip), %rax      # 0x90c0
cmpl $0x0, 0x30(%rax)
je 0x48b9
leaq 0x4814(%rip), %rax      # 0x90c0
movq 0x28(%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0x48cc
movabsq $0x10700003ff000001, %rax # imm = 0x10700003FF000001
movq %rax, -0x90(%rbp)
jmp 0x48cc
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x68(%rbp), %rdi
movl $0x1, %esi
movl $0x19000, %edx          # imm = 0x19000
movl $0x38, %r8d
movl %r8d, %ecx
callq 0x49c0
leaq -0x68(%rbp), %rdi
addq $0x10, %rdi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
movl $0x19002, %esi          # imm = 0x19002
callq 0x4a00
movl $0x48, -0x7c(%rbp)
movslq -0x7c(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x2620
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %eax
cmpl -0x7c(%rbp), %eax
je 0x4935
movl $0x3, -0x4(%rbp)
jmp 0x49b3
leaq -0x68(%rbp), %rdi
movl $0x48, %esi
callq 0x2670
movl %eax, -0x80(%rbp)
movslq -0x80(%rbp), %rax
cmpq $0x48, %rax
je 0x4959
movl $0x3, -0x4(%rbp)
jmp 0x49b3
leaq 0x4760(%rip), %rax      # 0x90c0
cmpl $0x0, 0x8(%rax)
jle 0x4981
movq 0x468b(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movl -0x48(%rbp), %edx
leaq 0x18aa(%rip), %rsi      # 0x6224
movb $0x0, %al
callq 0x20c0
cmpl $0x0, -0x48(%rbp)
je 0x4990
movl $0x3, -0x4(%rbp)
jmp 0x49b3
movq 0x4631(%rip), %rax      # 0x8fc8
movq (%rax), %rdi
leaq -0x68(%rbp), %rsi
addq $0x38, %rsi
movl $0x10, %edx
callq 0x56e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/cmd/cmd.c
// Function: cmd_find
struct cmd *
cmd_find(int cmdc, struct cmd **cmdv, const char *name)
{
	int l, r, m;
	int cmp;

	l = 0;
	r = cmdc - 1;

	while (l <= r) {
		m = (l + r) / 2;

		cmp = strcmp(name, cmdv[m]->name);
		if (!cmp)
			return (cmdv[m]);
		else if (cmp < 0)
			r = m - 1;
		else
			l = m + 1;

	}

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jg 0x52ed
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x20b0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0x52cf
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x52f5
cmpl $0x0, -0x30(%rbp)
jge 0x52e0
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x52e9
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x52eb
jmp 0x5283
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/cmd/cmd.c
// Function: cmd_exec
int
cmd_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct cmd *cmd;

	if (argc <= 0)
		return (CMD_EBADCMD);

	cmd = cmd_find(cmdc, cmdv, argv[0]);
	if (!cmd)
		return (CMD_EBADCMD);

	if ((cmd->min_argc != -1 && (argc - 1) < cmd->min_argc) ||
	    (cmd->max_argc != -1 && (argc - 1) > cmd->max_argc))
		return (CMD_EINVAL);

	return (cmd->exec(cmdc, cmdv, argc - 1, argv + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x5328
movl $0x1, -0x4(%rbp)
jmp 0x53ac
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x5260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x534f
movl $0x1, -0x4(%rbp)
jmp 0x53ac
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
je 0x5368
movl -0x14(%rbp), %eax
subl $0x1, %eax
movq -0x28(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x5381
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x1c(%rax)
je 0x538a
movl -0x14(%rbp), %eax
subl $0x1, %eax
movq -0x28(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jle 0x538a
movl $0x2, -0x4(%rbp)
jmp 0x53ac
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
subl $0x1, %edx
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/cmd/cmd_list.c
// Function: cmd_list_exec
int
cmd_list_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	int i;

	for (i = 0; i < cmdc; i++)
		fprintf(stdout, "%s\n", cmdv[i]->name);

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5417
movq 0x3bdc(%rip), %rax      # 0x8fc8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdx
leaq 0x120c(%rip), %rsi      # 0x6611
movb $0x0, %al
callq 0x20c0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x53dd
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/cmd/cmd_help.c
// Function: cmd_help_exec
int
cmd_help_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct cmd *cmd;
	int i;

	for (i = 0; i < argc; i++) {
		cmd = cmd_find(cmdc, cmdv, argv[i]);
		if (cmd) {
			fprintf(stdout, "%s\n", cmd->help);
			fprintf(stdout, "usage: %s\n", cmd->usage);
		} else {
			fprintf(stdout, "invalid command %s\n", argv[i]);
		}
	}

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x54e2
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x5260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x54ae
movq 0x3b55(%rip), %rax      # 0x8fc8
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x118c(%rip), %rsi      # 0x6611
movb $0x0, %al
callq 0x20c0
movq 0x3b35(%rip), %rax      # 0x8fc8
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x1165(%rip), %rsi      # 0x660a
movb $0x0, %al
callq 0x20c0
jmp 0x54d2
movq 0x3b13(%rip), %rax      # 0x8fc8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x114a(%rip), %rsi      # 0x6615
movb $0x0, %al
callq 0x20c0
jmp 0x54d4
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x543d
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/util/util.c
// Function: hex_fprintf
void
hex_fprintf(FILE *fp, const char *buf, size_t len)
{
	int i;

	if (len <= 0)
		return;

	for (i = 0; i < len; i++) {
		if ((i > 0) && !(i % 16))
			fprintf(fp, "\n");

		fprintf(fp, "%02x ", buf[i]);
	}

	fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
ja 0x56fd
jmp 0x5771
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x575f
cmpl $0x0, -0x1c(%rbp)
jle 0x5736
movl -0x1c(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x5736
movq -0x8(%rbp), %rdi
leaq 0xaa3(%rip), %rsi       # 0x61d2
movb $0x0, %al
callq 0x20c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0xf0e(%rip), %rsi       # 0x665b
movb $0x0, %al
callq 0x20c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5704
movq -0x8(%rbp), %rdi
leaq 0xa68(%rip), %rsi       # 0x61d2
movb $0x0, %al
callq 0x20c0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/logistic.c
// Function: ModelIinit
Model* ModelIinit(int size){
	Model* model=malloc(sizeof(Model));
	model->array_size=2*size;
  model->weight_array=malloc(sizeof(double)*(model->array_size));
  memset(model->weight_array, 0,(model->array_size)*sizeof(double));
	return model;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x1190
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
shll %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x1190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x10d0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/logistic.c
// Function: GetCameraVector
HVector* GetCameraVector(char* camera_id, Hash* H){
	NList *L;
	int i=0,j=0,in;
	char name[20];
	while(camera_id[i]!='/')
	{//Vrisko to simio pou teliwnei to onoma ths istoselidas tou proiontos
		i++;
	}
	i+=2;//pigeno to i sthn thesh pou arxizei o arithmos tou proiontos
	while(i<strlen(camera_id))
	{
		name[j]=camera_id[i];
		j++;
		i++;
	}
	name[j]='\0';
	in=atoi(name);//apothievo ton arithmo tou proiontos ston int in
	int index=hash(in,H->size);
	L=(NList*)H[index].Head;//pernw thn lista pou vriskete sto index bucket tou HashTable
	L = L->Next;
	while(L!=NULL){
		if(strcmp(L->camera,camera_id) == 0)	return L->vector;
		L=L->Next;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x236a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x234e
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x23b7
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %cl
movslq -0x28(%rbp), %rax
movb %cl, -0x40(%rbp,%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2373
movslq -0x28(%rbp), %rax
movb $0x0, -0x40(%rbp,%rax)
leaq -0x40(%rbp), %rdi
callq 0x1230
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x5970
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rax
movslq -0x44(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2438
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x242a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2440
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2400
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/logistic.c
// Function: InputInit
Input* InputInit(){
	Input* in = malloc(sizeof(Input));
	in->Cons = NULL;
	in->matches = NULL;
	in->size = 0;
	return in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x1190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/logistic.c
// Function: FreeInput
void FreeInput(Input* input)
{
	free(input->matches);
	for(int i =0; i<input->size; i++)
	{
		FreeHVector(input->Cons[i]);
	}
	free(input->Cons);
	free(input);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x279b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4cf0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2770
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/logistic.c
// Function: JobTraining
void JobTraining(void *args){

	TrainStruct* arg=(TrainStruct*)args;
	int i,j,c;
	double k,p,result;
	HVector* Con;
	for( i=arg->start ; i<arg->end ; i++){
			Con=arg->input->Cons[i];
    	p=Predict(&(arg->w),&(arg->b),Con);	//Ipologizoume thn provlepsh tou modelou
    	k=p-(arg->input->matches[i]);	//Ipologizoume thn apoklhsh ths provlepshs
			c=0;
    	for( j=0 ;  j<Con->size ; j++){	//Gia kathe varos
				if(Con[j].key!=-1){
					c++;
					result=k*Con[j].value;	//Ipologizoume to ginomeno ths apoklishs epi thn timh tou concat se afthn thn diastash
					arg->w[Con[j].key]=arg->w[Con[j].key]-(0.6*result);
					arg->b = (double)((arg->b) +k)/(double)2;	//enimeronoume to b
				}
				if(c==Con->count) break;
    	}
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3026
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x40(%rbp), %rdx
callq 0x3030
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x40(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x3016
movq -0x40(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
je 0x2ff8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x40(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
mulsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x40(%rbp), %rcx
movslq -0x18(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x38(%rbp), %xmm0
movsd 0x527a(%rip), %xmm2     # 0x8228
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x40(%rbp), %rcx
movslq -0x18(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd 0x5235(%rip), %xmm1     # 0x8220
divsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl -0x1c(%rbp), %eax
movq -0x40(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x3006
jmp 0x3016
jmp 0x3008
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2f33
jmp 0x3018
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2ebd
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/logistic.c
// Function: Fx
double Fx(double** w,double* b,HVector* con){
  double wx,sum=*(b);
	double* W=*w;
	int c=0;
  for(int i=0; i<con->size ; i++){	//Ipologismos tou f(X)
		if(con[i].key!=-1){
			c++;
			wx=W[con[i].key]*(con[i].value);
			sum+=wx;
		}
		if(c==con->count) break;
	}
  return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x3450
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
je 0x3432
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x38(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
mulsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x3440
jmp 0x3450
jmp 0x3442
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x33c6
movsd -0x28(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/logistic.c
// Function: MakeArrays
void MakeArrays(Hash* H,int* s,NList*** nodes){ //Dimiourgo ena pinaka me NList nodes twn kamerwn pou den einai mesa se kapia klika
	NList* N;
	int sum=0;
	for(int i=0 ; i<H->size ; i++){
		N=(NList*)H[i].Head;
    while(N->Next!=NULL){
      N=N->Next;
			if(N->clique==NULL){
      	sum++;
			}
    }
	}

	NList** nl=malloc(sum*sizeof(NList*));
	sum=0;
	for(int i=0 ; i<H->size ; i++){
		N=(NList*)H[i].Head;
    while(N->Next!=NULL){
      N=N->Next;
			if(N->clique==NULL){
				nl[sum]=N;
      	sum++;
			}
    }
	}
	*s=sum;
	*nodes=nl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3b0e
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3b01
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3aff
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3ad4
jmp 0x3b03
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3ab2
movslq -0x24(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1190
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3b99
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3b8c
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3b8a
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3b4f
jmp 0x3b8e
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3b2d
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/logistic.c
// Function: RepetitiveTaining
Model* RepetitiveTaining(Input* input,Hash* H,JobSheduler* Sheduler){
	int size = H->Head->Next->vec_size,ep=1;
	Model* model;
	double threshold=0.1,stepvalue=0.1;
	model=ModelIinit(size);

	model->b=0;
	while (threshold < 0.35){
		model = Training(model,input,H,Sheduler);
		printf("Just finished the training for %d time\n",ep);
		TestAndAdd(H,model,Sheduler,&input,threshold);
		threshold+=stepvalue;
		ep++;
	}
	return model;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl 0x28(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movsd 0x436b(%rip), %xmm0     # 0x8240
movsd %xmm0, -0x30(%rbp)
movsd 0x435e(%rip), %xmm0     # 0x8240
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %edi
callq 0x2290
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x4341(%rip), %xmm0     # 0x8248
ucomisd -0x30(%rbp), %xmm0
jbe 0x3f6c
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x2a60
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %esi
leaq 0x4336(%rip), %rdi      # 0x8267
movb $0x0, %al
callq 0x10b0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsd -0x30(%rbp), %xmm0
leaq -0x8(%rbp), %rcx
callq 0x3770
movsd -0x38(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3eff
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/list.c
// Function: CreateCList
CList* CreateCList(){ //Dimiourgei mia nea CList
	CList *L;
	L=(CList *)malloc(sizeof(CList));
	L->Next=NULL;
  	L->name=NULL;
	L->Diffrend=NULL;
	L->camera_count = 0;
	return L;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x28, %edi
callq 0x1190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/list.c
// Function: InsertCList
void InsertCList(CList* L,char* product,NList* Head){//Eisagei ena neo product sthn arxh ths CList
  CList *N;
  N=(CList*)malloc(sizeof(CList));
  N->name=malloc(sizeof(char)*(strlen(product)+1));
  strcpy(N->name,product);
	N->Head=Head;
  N->Next=L->Next;
  L->Next=N;
  L->camera_count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x28, %edi
callq 0x1190
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1190
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1050
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/list.c
// Function: TransferCList
void TransferCList(CList* L,FILE* csvfile){	//Eisagi  ta proionta sto csv file
  CList* N;
  char* current;
  while(L->Next!=NULL){
    L=L->Next;
    N=L;
    current=malloc(sizeof(char)*(strlen(L->name)+1));//apothikefsi tou trexon komvou
    strcpy(current,L->name);
    while(N->Next!=NULL){	//Eisagogi tou trexon komvou mazi me ton kathe ena ap tous epomenous
      N=N->Next;
      fprintf(csvfile,"%s, %s\n",current,N->name);

    }
    free(current);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4107
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x10a0
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1190
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x1050
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x40f9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x41c0(%rip), %rsi      # 0x82b0
movb $0x0, %al
callq 0x1140
jmp 0x40c3
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x4070
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/list.c
// Function: DiffCList
void DiffCList(CList* L,TList* Transfered,FILE* csvfile){	//Eisagi  ta proionta sto csv file
  TList* N;
	TList* C;
	CList* T;
  char* current;
	int i=0;
	if(L->Diffrend!=NULL){//Ean yparxoun klikes pou diaferoun me thn L
			C=L->Diffrend;	//Krataw thn TList me oles tis klikes pou diaferoun me thn L
			while(L->Next!=NULL){ //Gia kathe proion ths L
				L=L->Next;
				current=malloc(sizeof(char)*(strlen(L->name)+1));//apothikefsi tou trexon komvou
		    strcpy(current,L->name);
				N=C;
				while(N->Next!=NULL){ //Gia kathe lista pou diaferei
					N=N->Next;
					T=N->node;

					if(FindTList(Transfered,T)){ //Ean den exw elegksei thn T pio prin
						while(T->Next!=NULL){ //Gia kathe proion ths T klikas
							T=T->Next;
							fprintf(csvfile,"%s, %s\n",current,T->name);
							i++;
						}
					}

				}
				free(current);
			}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4222
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4220
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x10a0
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1190
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x1050
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4212
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4230
cmpl $0x0, %eax
je 0x4210
jmp 0x41cf
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x420e
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
leaq 0x40b4(%rip), %rsi      # 0x82b0
movb $0x0, %al
callq 0x1140
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x41cf
jmp 0x4210
jmp 0x4199
movq -0x38(%rbp), %rdi
callq 0x1030
jmp 0x4146
jmp 0x4222
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/list.c
// Function: FindTList
int FindTList(TList* L,CList* node){//Epistrefei 0 an iparxi to node sthn lista allios epistrefei 1
	if(L==NULL) return 1;
	while(L->Next!=NULL){
		L=L->Next;
		if(L->node==node) return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x424c
movl $0x1, -0x4(%rbp)
jmp 0x4284
jmp 0x424e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x427d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x427b
movl $0x0, -0x4(%rbp)
jmp 0x4284
jmp 0x424e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/list.c
// Function: Diff
void Diff(CList* F,CList* S){
	if(F->Diffrend==NULL){	//Ean h Diffrend ths F einai NULL dimiourgisethn kai vale mesa thn S
		F->Diffrend=CreateTList();
		InsertTList(F->Diffrend,S);
	}else{ //Allios an h S den einai mesa sthn Diffrend ths F vale thn mesa
		if(FindTList(F->Diffrend,S)) InsertTList(F->Diffrend,S);
	}

	if(S->Diffrend==NULL){//Ean h Diffrend ths S einai NULL dimiourgisethn kai vale mesa thn F
		S->Diffrend=CreateTList();
		InsertTList(S->Diffrend,F);
	}else{//Allios an h F den einai mesa sthn Diffrend ths S vale thn mesa
		if(FindTList(S->Diffrend,F)) InsertTList(S->Diffrend,F);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x42ce
callq 0x4750
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4360
jmp 0x42f7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4230
cmpl $0x0, %eax
je 0x42f5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4360
jmp 0x42f7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4325
callq 0x4750
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4360
jmp 0x434e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4230
cmpl $0x0, %eax
je 0x434c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4360
jmp 0x434e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/list.c
// Function: InsertTList
void InsertTList(TList* L,CList* node){//Isagogi mias CList sthn TList
		TList* N;
		N=(TList*)malloc(sizeof(TList));
		N->node=node;
	  N->Next=L->Next;
	  L->Next=N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x1190
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/list.c
// Function: ReplaceTList
void ReplaceTList(TList* T,CList* P,CList* N){	//Antikathista mia CList sthn TList
	while(T->Next!=NULL){
		T=T->Next;
		if(T->node==P){
			T->node=N;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4563
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x4561
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4563
jmp 0x4530
popq %rbp
retq
nopw %cs:(%rax,%rax)