LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x3dd2(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x32fb
movq 0x18(%r14), %rax
jmp 0x3305
movabsq $0x1070000002000001, %rax # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x3312
movq 0x28(%r14), %rcx
jmp 0x331c
movabsq $0x10700003ff000001, %rcx # imm = 0x10700003FF000001
movaps 0x120d(%rip), %xmm0     # 0x4530
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x19002, 0x10(%rdi)    # imm = 0x19002
movq $0x19000, 0x18(%rdi)    # imm = 0x19000
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
pushq $0x48
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x48, %eax
jne 0x3388
movq %rsp, %rdi
pushq $0x48
popq %rsi
callq 0x24c1
cmpl $0x48, %eax
jne 0x3388
cmpl $0x0, 0x8(%r14)
jg 0x3392
cmpl $0x0, 0x20(%rsp)
jne 0x3388
movq 0x3c52(%rip), %rax      # 0x6fc8
movq (%rax), %rdi
leaq 0x38(%rsp), %rsi
pushq $0x10
popq %rdx
callq 0x39c0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq 0x3c5f(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x20(%rsp), %edx
leaq 0xdd9(%rip), %rsi       # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x3368
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/um/cmd_um_read_eprom.c
// Function: cmd_um_read_eprom_exec
int
cmd_um_read_eprom_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_um_read_eprom read_eprom;
	uint32_t offset;
	char *endptr;
	uint64_t laid, paid;
	int len;
	int ret;

	offset = strtoul(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(&read_eprom.dm_hdr, 1, PS3DM_FID_UM,
	    sizeof(read_eprom) - sizeof(struct ps3dm_header),
	    sizeof(read_eprom) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&read_eprom.ss_hdr, PS3DM_PID_UM_READ_EPROM,
	    laid, paid);
	read_eprom.offset = offset;

	len = sizeof(read_eprom);

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

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

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

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

	fprintf(stdout, "%02x\n", read_eprom.data);

	return (CMD_EOK);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq (%rcx), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2110
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x33e9
pushq $0x2
popq %rbx
jmp 0x3497
leaq 0x3cd0(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x33fd
movq 0x18(%r14), %rcx
jmp 0x3407
movabsq $0x1070000002000001, %rcx # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x3414
movq 0x28(%r14), %rdx
jmp 0x341e
movabsq $0x10700003ff000001, %rdx # imm = 0x10700003FF000001
movaps 0x117b(%rip), %xmm0     # 0x45a0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x600b, 0x10(%rdi)     # imm = 0x600B
movq $0x6000, 0x18(%rdi)     # imm = 0x6000
movq %rcx, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
movl %eax, 0x38(%rdi)
pushq $0x48
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x48, %eax
jne 0x3497
leaq 0x10(%rsp), %rdi
pushq $0x48
popq %rsi
callq 0x24c1
cmpl $0x48, %eax
jne 0x3497
cmpl $0x0, 0x8(%r14)
jg 0x34a1
cmpl $0x0, 0x30(%rsp)
jne 0x3497
movq 0x3b49(%rip), %rax      # 0x6fc8
movq (%rax), %rdi
movzbl 0x50(%rsp), %edx
leaq 0x1122(%rip), %rsi      # 0x45b0
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x20d0
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x3b50(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x30(%rsp), %edx
leaq 0xcca(%rip), %rsi       # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x3471
nop
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/um/cmd_um_write_eprom.c
// Function: cmd_um_write_eprom_exec
int
cmd_um_write_eprom_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_um_write_eprom write_eprom;
	uint32_t offset, data;
	char *endptr;
	uint64_t laid, paid;
	int len;
	int ret;

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

	data = strtoul(argv[1], &endptr, 0);
	if (*endptr != '\0' || data > 0xff)
		return (CMD_EINVAL);

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

	ps3dm_init_header(&write_eprom.dm_hdr, 1, PS3DM_FID_UM,
	    sizeof(write_eprom) - sizeof(struct ps3dm_header),
	    sizeof(write_eprom) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&write_eprom.ss_hdr, PS3DM_PID_UM_WRITE_EPROM,
	    laid, paid);
	write_eprom.offset = offset;
	write_eprom.data = data;

	len = sizeof(write_eprom);

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

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

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

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

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq (%rcx), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x2110
movq %rax, %rbx
movq (%r15), %rax
pushq $0x2
popq %rbp
cmpb $0x0, (%rax)
jne 0x35b5
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x2110
movq (%r14), %rcx
cmpb $0x0, (%rcx)
setne %cl
testl $0xffffff00, %eax       # imm = 0xFFFFFF00
setne %dl
orb %cl, %dl
jne 0x35b5
leaq 0x3b9c(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x3531
movq 0x18(%r14), %rcx
jmp 0x353b
movabsq $0x1070000002000001, %rcx # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x3548
movq 0x28(%r14), %rdx
jmp 0x3552
movabsq $0x10700003ff000001, %rdx # imm = 0x10700003FF000001
movaps 0x1047(%rip), %xmm0     # 0x45a0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x600c, 0x10(%rdi)     # imm = 0x600C
movq $0x6000, 0x18(%rdi)     # imm = 0x6000
movq %rcx, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
movl %ebx, 0x38(%rdi)
movb %al, 0x40(%rdi)
pushq $0x48
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbp
cmpl $0x48, %eax
jne 0x35b5
leaq 0x10(%rsp), %rdi
pushq $0x48
popq %rsi
callq 0x24a2
cmpl $0x48, %eax
jne 0x35b5
cmpl $0x0, 0x8(%r14)
jg 0x35c2
xorl %eax, %eax
cmpl $0x0, 0x30(%rsp)
setne %al
leal (%rax,%rax,2), %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3a2f(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x30(%rsp), %edx
leaq 0xba9(%rip), %rsi       # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x35a8
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/scm/cmd_scm_get_region_data.c
// Function: cmd_scm_get_region_data_exec
int
cmd_scm_get_region_data_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3dm_scm_get_region_data get_region_data;
	uint64_t id;
	char *endptr;
	uint64_t laid, paid;
	int len;
	int ret;

	id = 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(&get_region_data.dm_hdr, 1, PS3DM_FID_SCM,
	    sizeof(get_region_data) - sizeof(struct ps3dm_header),
	    sizeof(get_region_data) - sizeof(struct ps3dm_header));
	ps3dm_init_ss_header(&get_region_data.ss_hdr, PS3DM_PID_SCM_GET_REGION_DATA,
	    laid, paid);
	get_region_data.id = id;
	get_region_data.data_size = 0x30;

	len = sizeof(get_region_data);

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

	ret = dev_read(&get_region_data, sizeof(get_region_data));
	if (ret < (sizeof(struct ps3dm_header) + sizeof(struct ps3dm_ss_header)))
		return (CMD_EIO);

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

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

	if (ret != sizeof(get_region_data))
		return (CMD_EIO);

	fwrite(get_region_data.data, 1, get_region_data.data_size, stdout);

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq (%rcx), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x20b0
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x361d
pushq $0x2
popq %rbx
jmp 0x36d9
leaq 0x3a9c(%rip), %r14      # 0x70c0
cmpl $0x0, 0x20(%r14)
je 0x3631
movq 0x18(%r14), %rcx
jmp 0x363b
movabsq $0x1070000002000001, %rcx # imm = 0x1070000002000001
cmpl $0x0, 0x30(%r14)
je 0x3648
movq 0x28(%r14), %rdx
jmp 0x3652
movabsq $0x10700003ff000001, %rdx # imm = 0x10700003FF000001
movaps 0xfe7(%rip), %xmm0      # 0x4640
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x9006, 0x10(%rdi)     # imm = 0x9006
movq $0x9000, 0x18(%rdi)     # imm = 0x9000
movq %rcx, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movq $0x30, 0x40(%rdi)
pushq $0x78
popq %rsi
callq 0x24a2
pushq $0x3
popq %rbx
cmpl $0x78, %eax
jne 0x36d9
leaq 0x10(%rsp), %rdi
pushq $0x78
popq %rsi
callq 0x24c1
cmpl $0x38, %eax
jb 0x36d9
movl %eax, %ebp
cmpl $0x0, 0x8(%r14)
jg 0x36e7
cmpl $0x78, %ebp
jne 0x36d9
cmpl $0x0, 0x30(%rsp)
jne 0x36d9
leaq 0x58(%rsp), %rdi
movq -0x8(%rdi), %rdx
movq 0x38fc(%rip), %rax      # 0x6fc8
movq (%rax), %rcx
pushq $0x1
popq %rsi
callq 0x2130
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x390a(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x30(%rsp), %edx
leaq 0xa84(%rip), %rsi       # 0x4180
xorl %eax, %eax
callq 0x20d0
jmp 0x36b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
decl %r15d
xorl %r13d, %r13d
cmpl %r15d, %r13d
jg 0x3751
leal (%r15,%r13), %ebp
shrl %ebp
movq (%r14,%rbp,8), %r12
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x20c0
testl %eax, %eax
je 0x3754
js 0x374a
incl %ebp
movl %ebp, %r13d
jmp 0x3722
decl %ebp
movl %ebp, %r15d
jmp 0x3722
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq $0x1
popq %r12
testl %edx, %edx
jle 0x37b8
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %r15d
movq (%rcx), %rdx
callq 0x3708
testq %rax, %rax
je 0x37b8
movl 0x18(%rax), %ecx
cmpl $-0x1, %ecx
setne %dl
cmpl %ebp, %ecx
setge %cl
pushq $0x2
popq %r12
testb %cl, %dl
jne 0x37b8
movl 0x1c(%rax), %ecx
cmpl $-0x1, %ecx
setne %dl
decl %ebp
cmpl %ecx, %ebp
setg %cl
testb %cl, %dl
je 0x37c4
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rax), %rax
addq $0x8, %rbx
movl %r15d, %edi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edi, %ebx
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %ebx
movq %rsi, %r14
movq 0x37c8(%rip), %r12      # 0x6fc8
leaq 0xea2(%rip), %r15       # 0x46a9
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x3829
movq (%r12), %rdi
movq (%r14,%r13,8), %rax
movq (%rax), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x20d0
incq %r13
jmp 0x380a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, (%rsp)
movl %edi, %ebp
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %r14d
movq 0x376a(%rip), %r15      # 0x6fc8
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x38c0
movq (%rbx,%r12,8), %rdx
movl %ebp, %edi
movq (%rsp), %rsi
callq 0x3708
movq (%r15), %rdi
testq %rax, %rax
je 0x38a2
movq %rax, %r13
movq 0x8(%rax), %rdx
leaq 0xe1e(%rip), %rsi       # 0x46a9
xorl %eax, %eax
callq 0x20d0
movq (%r15), %rdi
movq 0x10(%r13), %rdx
leaq 0xe02(%rip), %rsi       # 0x46a2
jmp 0x38ad
movq (%rbx,%r12,8), %rdx
leaq 0xe00(%rip), %rsi       # 0x46ad
xorl %eax, %eax
callq 0x20d0
incq %r12
movq 0x370a(%rip), %r15      # 0x6fc8
jmp 0x3861
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/sguerrini97[P]ps3linux-ps3vuart-tools/util/util.c
// Function: parse_hex
int
parse_hex(const char *s, unsigned char *b, int maxlen)
{
	int len;
	char c;
	int i;

	len = strlen(s);
	if (len % 2)
		return (-1);

	for (i = 0; (i < (len / 2)) && (i < maxlen); i++) {
		if (!isxdigit(s[2 * i + 0]) || !isxdigit(s[2 * i + 1]))
			return (-1);

		b[i] = 0;

		c = tolower(s[2 * i + 0]);
		if (isdigit(c))
			b[i] += (c - '0') * 16;
		else
			b[i] += (c - 'a' + 10) * 16;

		c = tolower(s[2 * i + 1]);
		if (isdigit(c))
			b[i] += c - '0';
		else
			b[i] += c - 'a' + 10;
	}

	return (i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
callq 0x2050
movq %rax, %r12
pushq $-0x1
popq %rax
testb $0x1, %r12b
jne 0x39b1
sarl %r12d
cmpl %ebp, %r12d
cmovgel %ebp, %r12d
xorl %ebp, %ebp
testl %r12d, %r12d
cmovlel %ebp, %r12d
movl $0xa9, %ebx
cmpq %rbp, %r12
je 0x39ae
callq 0x2150
movq %rax, %r13
movq (%rax), %rax
movsbq (%r15,%rbp,2), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x39a9
movsbq 0x1(%r15,%rbp,2), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
je 0x39a9
movb $0x0, (%r14,%rbp)
callq 0x2140
movq (%rax), %rcx
movsbq (%r15,%rbp,2), %rdx
movl (%rcx,%rdx,4), %ecx
movq (%r13), %rdx
movsbq %cl, %rsi
movzwl (%rdx,%rsi,2), %edx
shll $0x4, %ecx
leal -0x70(%rcx), %esi
btl $0xb, %edx
movzbl %sil, %edx
cmovbl %ecx, %edx
movb %dl, (%r14,%rbp)
movq (%rax), %rax
movsbq 0x1(%r15,%rbp,2), %rcx
movsbq (%rax,%rcx,4), %rax
movq (%r13), %rcx
movzwl (%rcx,%rax,2), %ecx
btl $0xb, %ecx
movl $0xd0, %ecx
cmovael %ebx, %ecx
addb %al, %cl
addb %dl, %cl
movb %cl, (%r14,%rbp)
incq %rbp
jmp 0x3914
pushq $-0x1
popq %rax
jmp 0x39b1
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdx, %rdx
je 0x3a36
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0xa
popq %rbp
leaq 0xd10(%rip), %r12       # 0x46f3
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x3a1d
testq %r13, %r13
sete %al
testb $0xf, %r13b
setne %cl
orb %al, %cl
jne 0x3a06
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2090
movsbl (%r15,%r13), %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20d0
incq %r13
jmp 0x39e6
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2090
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %ebx
pushq $0x18
popq %rdi
callq 0x11a0
movq %rax, %r14
addl %ebx, %ebx
movl %ebx, 0x10(%rax)
movslq %ebx, %rsi
shlq $0x3, %rsi
pushq $0x1
popq %rdi
callq 0x1130
movq %rax, (%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
cmpb $0x2f, (%rbx,%r15)
leaq 0x1(%r15), %r15
jne 0x1dc0
movq %rbx, %rdi
callq 0x10c0
leaq (%rbx,%r15), %rdx
pushq $0x1
popq %rcx
leaq (%r15,%rcx), %rsi
cmpq %rsi, %rax
jbe 0x1df1
movb (%rdx,%rcx), %sil
movb %sil, -0x31(%rbp,%rcx)
incq %rcx
jmp 0x1dda
decl %ecx
movb $0x0, -0x30(%rbp,%rcx)
leaq -0x30(%rbp), %rdi
callq 0x1240
movl (%r14), %esi
movl %eax, %edi
callq 0x3cfc
cltq
shlq $0x4, %rax
movq 0x8(%r14,%rax), %r15
xorl %r14d, %r14d
movq 0x20(%r15), %r15
testq %r15, %r15
je 0x1e35
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
jne 0x1e19
movq 0x18(%r15), %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/logistic.c
// Function: VectorConcat
HVector* VectorConcat(HVector* F,HVector* S,int dif){
	int size=(F->count)+(S->count),c=0;
	size+=(size*0.3);
	HVector* C=CreateHVector(size);

	int fr,se;
	fr=F->sum;
	se=S->sum;
	if(fr>se){//Eelgxo pio ap ta dio vectors tha mpei proto
		c=0;
		for(int i=0 ; i<F->size ; i++){	//Isago tis leksis tou protou vector
			if(F[i].key!=-1){
				c++;
				C=InsertHVector(C,F[i].key,F[i].value);
			}
			if(c==F->count) break;
		}
		c=0;
		for(int i=0 ; i<S->size ; i++){	//Isago tis leksis tou defterou vectour me afksimeno to key kata dif
			if(S[i].key!=-1){
				c++;
				C=InsertHVector(C,(S[i].key)+dif,S[i].value);
			}
			if(c==S->count) break;
		}

	}else{
		c=0;
		for(int i=0 ; i<S->size ; i++){
			if(S[i].key!=-1){
				c++;
				C=InsertHVector(C,S[i].key,S[i].value);
			}
			if(c==S->count) break;
		}
		c=0;
		for(int i=0 ; i<F->size ; i++){
			if(F[i].key!=-1){
				c++;
				C=InsertHVector(C,(F[i].key)+dif,F[i].value);
			}
			if(c==F->count) break;
		}
	}
	return C;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl 0x18(%rsi), %eax
addl 0x18(%rdi), %eax
movl %edx, -0x2c(%rbp)
cvtsi2sd %eax, %xmm0
movsd 0x439c(%rip), %xmm1     # 0x6208
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edi
callq 0x3a54
cvttsd2si 0x10(%r15), %ecx
cvttsd2si 0x10(%r14), %edx
cmpl %edx, %ecx
jle 0x1f11
leaq 0x8(%r15), %r12
xorl %r13d, %r13d
pushq $-0x1
popq %rbx
movslq 0x1c(%r15), %rcx
incq %rbx
cmpq %rcx, %rbx
jge 0x1ecc
movl -0x8(%r12), %esi
cmpl $-0x1, %esi
je 0x1ec2
incl %r13d
movsd (%r12), %xmm0
movq %rax, %rdi
callq 0x3a9c
addq $0x20, %r12
cmpl 0x18(%r15), %r13d
jne 0x1e9b
leaq 0x8(%r14), %r15
xorl %r12d, %r12d
pushq $-0x1
popq %r13
movl -0x2c(%rbp), %ebx
movslq 0x1c(%r14), %rcx
incq %r13
cmpq %rcx, %r13
jge 0x1f8b
movl -0x8(%r15), %esi
cmpl $-0x1, %esi
je 0x1f05
incl %r12d
addl %ebx, %esi
movsd (%r15), %xmm0
movq %rax, %rdi
callq 0x3a9c
addq $0x20, %r15
cmpl 0x18(%r14), %r12d
jne 0x1eda
jmp 0x1f8b
leaq 0x8(%r14), %r12
xorl %r13d, %r13d
pushq $-0x1
popq %rbx
movslq 0x1c(%r14), %rcx
incq %rbx
cmpq %rcx, %rbx
jge 0x1f4c
movl -0x8(%r12), %esi
cmpl $-0x1, %esi
je 0x1f42
incl %r13d
movsd (%r12), %xmm0
movq %rax, %rdi
callq 0x3a9c
addq $0x20, %r12
cmpl 0x18(%r14), %r13d
jne 0x1f1b
leaq 0x8(%r15), %r14
xorl %r12d, %r12d
pushq $-0x1
popq %r13
movl -0x2c(%rbp), %ebx
movslq 0x1c(%r15), %rcx
incq %r13
cmpq %rcx, %r13
jge 0x1f8b
movl -0x8(%r14), %esi
cmpl $-0x1, %esi
je 0x1f81
incl %r12d
addl %ebx, %esi
movsd (%r14), %xmm0
movq %rax, %rdi
callq 0x3a9c
addq $0x20, %r14
cmpl 0x18(%r15), %r12d
jne 0x1f5a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x11a0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andl $0x0, 0x10(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1030
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
movq (%rbx), %rdi
cmpq %rax, %r14
jge 0x1fe2
movq (%rdi,%r14,8), %rdi
callq 0x35f7
incq %r14
jmp 0x1fc8
callq 0x1030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdi), %r13
leaq 0x10(%rdi), %r14
leaq 0x8(%rdi), %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jge 0x2573
movq 0x18(%rbx), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2582
movsd 0x3d22(%rip), %xmm3     # 0x6218
movsd 0x3d12(%rip), %xmm2     # 0x6210
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rax
cvtsi2sdl (%rax,%r13,4), %xmm1
subsd %xmm1, %xmm0
movslq 0x1c(%r12), %rax
leaq 0x8(%r12), %rcx
xorl %edx, %edx
pushq $-0x1
popq %rsi
incq %rsi
cmpq %rax, %rsi
jge 0x256b
movslq -0x8(%rcx), %rdi
cmpq $-0x1, %rdi
je 0x2560
incl %edx
movsd (%rcx), %xmm1
mulsd %xmm0, %xmm1
movq (%r14), %r8
mulsd %xmm2, %xmm1
addsd (%r8,%rdi,8), %xmm1
movsd %xmm1, (%r8,%rdi,8)
movsd (%r15), %xmm1
addsd %xmm0, %xmm1
mulsd %xmm3, %xmm1
movsd %xmm1, (%r15)
addq $0x20, %rcx
cmpl 0x18(%r12), %edx
jne 0x251f
incq %r13
jmp 0x24c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movsd (%rsi), %xmm0
movq (%rdi), %rax
movslq 0x1c(%rdx), %rcx
leaq 0x8(%rdx), %rsi
xorl %edi, %edi
movabsq $-0x1, %r8
incq %r8
cmpq %rcx, %r8
jge 0x27d1
movslq -0x8(%rsi), %r9
cmpq $-0x1, %r9
je 0x27c8
incl %edi
movsd (%rax,%r9,8), %xmm1
mulsd (%rsi), %xmm1
addsd %xmm1, %xmm0
addq $0x20, %rsi
cmpl 0x18(%rdx), %edi
jne 0x27a6
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/logistic.c
// Function: Newpred
double Newpred(double* w,double b,HVector* F,HVector* S,int dif){//Vriskei to predict xwris na ginei to concat

	int fr,se,c;
	double wx,sum=b;

	fr=F->sum;
	se=S->sum;
	if(fr>se){//Eelgxo pio ap ta dio vectors tha mpei proto
		c=0;
		for(int i=0 ; i<F->size ; i++){	//Isago tis leksis tou protou vector
			if(F[i].key!=-1){
				c++;
				wx=w[F[i].key]*(F[i].value);
				sum+=wx;
			}
			if(c==F->count) break;
		}
		c=0;
		for(int i=0 ; i<S->size ; i++){	//Isago tis leksis tou defterou vectour me afksimeno to key kata dif
			if(S[i].key!=-1){
				c++;
				wx=w[(S[i].key)+dif]*(S[i].value);
				sum+=wx;
			}
			if(c==S->count) break;
		}
	}else{
		c=0;
		for(int i=0 ; i<S->size ; i++){
			if(S[i].key!=-1){
				c++;
				wx=w[(S[i].key)]*(S[i].value);
				sum+=wx;
			}
			if(c==S->count) break;
		}
		c=0;
		for(int i=0 ; i<F->size ; i++){
			if(F[i].key!=-1){
				c++;
				wx=w[(F[i].key)+dif]*(F[i].value);
				sum+=wx;
			}
			if(c==F->count) break;
		}
	}
	sum=1 / (1 + exp(-(sum)));	//ipologizoume to p(f(x))
	return sum;
}

// Assembly:
cvttsd2si 0x10(%rsi), %eax
cvttsd2si 0x10(%rdx), %r8d
cmpl %r8d, %eax
jle 0x2881
movl 0x1c(%rsi), %eax
xorl %r9d, %r9d
testl %eax, %eax
cmovlel %r9d, %eax
shlq $0x5, %rax
addq $0x20, %rax
xorl %r8d, %r8d
leaq 0x20(%r9), %r10
cmpq %r10, %rax
je 0x282e
movslq (%rsi,%r9), %r11
cmpq $-0x1, %r11
je 0x2825
incl %r8d
movsd (%rdi,%r11,8), %xmm1
mulsd 0x8(%rsi,%r9), %xmm1
addsd %xmm1, %xmm0
movq %r10, %r9
cmpl 0x18(%rsi), %r8d
jne 0x27fe
movl 0x1c(%rdx), %eax
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
shlq $0x5, %rax
addq $0x20, %rax
xorl %esi, %esi
leaq 0x20(%r8), %r9
cmpq %r9, %rax
je 0x2912
movl (%rdx,%r8), %r10d
cmpl $-0x1, %r10d
je 0x2874
incl %esi
addl %ecx, %r10d
movslq %r10d, %r10
movsd (%rdi,%r10,8), %xmm1
mulsd 0x8(%rdx,%r8), %xmm1
addsd %xmm1, %xmm0
movq %r9, %r8
cmpl 0x18(%rdx), %esi
jne 0x2844
jmp 0x2912
movl 0x1c(%rdx), %eax
xorl %r9d, %r9d
testl %eax, %eax
cmovlel %r9d, %eax
shlq $0x5, %rax
addq $0x20, %rax
xorl %r8d, %r8d
leaq 0x20(%r9), %r10
cmpq %r10, %rax
je 0x28c8
movslq (%rdx,%r9), %r11
cmpq $-0x1, %r11
je 0x28bf
incl %r8d
movsd (%rdi,%r11,8), %xmm1
mulsd 0x8(%rdx,%r9), %xmm1
addsd %xmm1, %xmm0
movq %r10, %r9
cmpl 0x18(%rdx), %r8d
jne 0x2898
movl 0x1c(%rsi), %eax
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
shlq $0x5, %rax
addq $0x20, %rax
xorl %edx, %edx
leaq 0x20(%r8), %r9
cmpq %r9, %rax
je 0x2912
movl (%rsi,%r8), %r10d
cmpl $-0x1, %r10d
je 0x290a
incl %edx
addl %ecx, %r10d
movslq %r10d, %r10
movsd (%rdi,%r10,8), %xmm1
mulsd 0x8(%rsi,%r8), %xmm1
addsd %xmm1, %xmm0
movq %r9, %r8
cmpl 0x18(%rsi), %edx
jne 0x28de
pushq %rbp
movq %rsp, %rbp
xorpd 0x3922(%rip), %xmm0     # 0x6240
callq 0x12a0
movsd 0x38f5(%rip), %xmm1     # 0x6220
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdi), %r12d
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
xorl %ecx, %ecx
cmpq %r12, %rax
je 0x2b86
movq %rax, %rdx
shlq $0x4, %rdx
movq 0x8(%r15,%rdx), %rdx
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
je 0x2b81
cmpq $0x1, 0x10(%rdx)
adcl $0x0, %ecx
jmp 0x2b6e
incq %rax
jmp 0x2b5d
movslq %ecx, %rdi
shlq $0x3, %rdi
callq 0x11a0
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %r12, %rcx
je 0x2bc7
movq %rcx, %rsi
shlq $0x4, %rsi
movq 0x8(%r15,%rsi), %rsi
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x2bc2
cmpq $0x0, 0x10(%rsi)
jne 0x2ba7
movslq %edx, %rdx
movq %rsi, (%rax,%rdx,8)
incl %edx
jmp 0x2ba7
incq %rcx
jmp 0x2b96
movl %edx, (%r14)
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x38(%rbp), %rax
movq %rdi, (%rax)
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
movl 0x28(%rax), %edi
callq 0x1d58
movq %rax, %r13
andq $0x0, 0x8(%rax)
pushq $0x1
popq %r12
movsd 0x343a(%rip), %xmm0     # 0x6230
movsd %xmm0, -0x30(%rbp)
cmpl $0x4, %r12d
je 0x2e4e
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x21d3
leaq 0x3451(%rip), %rdi      # 0x6267
movl %r12d, %esi
xorl %eax, %eax
callq 0x10d0
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
leaq -0x38(%rbp), %rcx
movsd -0x30(%rbp), %xmm0
callq 0x2939
movsd -0x30(%rbp), %xmm0
addsd 0x33ec(%rip), %xmm0     # 0x6230
movsd %xmm0, -0x30(%rbp)
incl %r12d
jmp 0x2dfb
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x28
popq %rdi
callq 0x11a0
andq $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andl $0x0, 0x20(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x28
popq %rdi
callq 0x11a0
movq %rax, %r12
movq %r14, %rdi
callq 0x10c0
leaq 0x1(%rax), %rdi
callq 0x11a0
movq %rax, (%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0x1060
movq %rbx, 0x8(%r12)
movq 0x18(%r15), %rax
movq %rax, 0x18(%r12)
movq %r12, 0x18(%r15)
incl 0x20(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x33ba(%rip), %r15      # 0x62b0
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x2f4d
movq (%r14), %r13
movq %r13, %rdi
callq 0x10c0
leaq 0x1(%rax), %rdi
callq 0x11a0
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x1060
movq %r14, %r13
movq 0x18(%r13), %r13
testq %r13, %r13
je 0x2f43
movq (%r13), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1160
jmp 0x2f24
movq %r12, %rdi
callq 0x1030
jmp 0x2ef6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x40(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x3009
movq %rdx, %rbx
leaq 0x3324(%rip), %r12      # 0x62b0
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x3009
movq %rdi, -0x38(%rbp)
movq (%rdi), %r15
movq %r15, %rdi
callq 0x10c0
leaq 0x1(%rax), %rdi
callq 0x11a0
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x1060
movq -0x30(%rbp), %r14
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x2ffb
movq (%r14), %r15
movq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x3018
testl %eax, %eax
jne 0x2ff0
jmp 0x2fbf
movq (%r15), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x1160
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x2fdd
jmp 0x2fbf
movq %r13, %rdi
callq 0x1030
movq -0x38(%rbp), %rdi
jmp 0x2f8c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl $0x1, %eax
testq %rdi, %rdi
je 0x3037
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x3036
cmpq %rsi, (%rdi)
jne 0x3026
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x3065
movq %r15, %rdi
movq %r14, %rsi
callq 0x3018
testl %eax, %eax
je 0x3079
movq %r15, %rdi
jmp 0x3071
callq 0x32ae
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x30bf
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x3096
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3018
testl %eax, %eax
je 0x30b4
movq %r15, %rdi
jmp 0x30a2
callq 0x32ae
movq %rax, 0x10(%r14)
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30bf
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x11a0
movq %rbx, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/list.c
// Function: AppendCList
CList* AppendCList(CList* L ,CList* N){
	CList* T=L;
	CList* Head;
	Head=N; //To head einai h kefali ths listas N

	int ncount = N->camera_count;
	L->camera_count += ncount; 	//enhmerwnoume to count

	N=N->Next; //O diktis N pleon dixnei ston porto komvo me dedomena ths listas N kai oxi stin kefali ths

	if(Head->Diffrend!=NULL){ //	Oles oi klikes pou htan diaforetikes ap to head twra tha einai diaforetikes me thn L
		TList* Temp=Head->Diffrend;
		while(Temp->Next!=NULL){	//Gia kathe klika diaforetikh ths Head
			Temp=Temp->Next;
			if(L->Diffrend==NULL) L->Diffrend=CreateTList();	//Ean h L den exei Diffrend List dimiourgei
			if(FindTList(L->Diffrend,Temp->node)){	//Ean h paron CList pou einai diaforetikh me thn Head den einai diaforetikh ths L
				InsertTList(L->Diffrend,Temp->node);	//Vale thn stis diaforetikes ths L
				ReplaceTList(Temp->node->Diffrend,Head,L);	//Sthn Diffrend list ths parousas CList antikatestise thn Head me thn L
			}else{	//Ean h paron CList pou einai diaforetikh me thn Head einai diaforetikh ths L diegrapse apo thn Diffrend ths thn  Head
				RemoveTList(Temp->node->Diffrend,Head);
			}
		}
		FreeTList(Head->Diffrend);
	}

	Head->Next=NULL;
	free(Head);	//Apodesmevo thn kefali ths listas N
	while(L->Next!=NULL){//Pigene ston telefteo komvo ths listas L
		L=L->Next;
	}
	L->Next=N;//Valethn lista N sto telos ths listas L
	while(L->Next!=NULL){//O diktis tou komvou pou einai apothikevmeno to kathe neo product na deixnei se afthn thn klika(diladi thn lista L)
		L=L->Next;
		L->Head->clique=T;
	}
	return T;//Epestrepse thn L
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl 0x20(%rsi), %eax
addl %eax, 0x20(%rdi)
movq 0x10(%rsi), %r14
movq 0x18(%rsi), %r13
testq %r14, %r14
je 0x3182
movq %r15, -0x30(%rbp)
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x3179
movq 0x10(%rbx), %r15
testq %r15, %r15
jne 0x3131
callq 0x32ae
movq %rax, %r15
movq %rax, 0x10(%rbx)
movq (%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3018
testl %eax, %eax
je 0x3166
movq %r15, %rdi
movq %r12, %rsi
callq 0x30bf
movq (%r14), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x31c2
jmp 0x3113
movq 0x10(%r12), %rdi
movq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x31d9
jmp 0x3113
movq 0x10(%r15), %rdi
callq 0x31fe
movq %r15, %rdi
callq 0x1030
movq %rbx, %rcx
movq %rcx, %rax
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x318d
movq %r13, 0x18(%rax)
testq %r13, %r13
je 0x31b0
movq 0x8(%r13), %rax
movq %rbx, 0x10(%rax)
movq 0x18(%r13), %r13
jmp 0x319d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x31d7
cmpq %rsi, (%rdi)
jne 0x31c6
movq %rdx, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/list.c
// Function: RemoveTList
void RemoveTList(TList* L,CList* C){	//Diagrafi mias CList apo thn TList
	TList* T;
	while(L->Next!=NULL){
		if(L->Next->node==C){
			T=L->Next;
			L->Next=T->Next;
			T->node=NULL;
			free(T);
			break;
		}
		L=L->Next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x31fc
cmpq %rsi, (%rdi)
jne 0x31dd
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
popq %rbp
jmp 0x1030
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/list.c
// Function: FreeTList
void FreeTList(TList* L){//Apodesmevi thn TList
  TList* T;
  while(L->Next!=NULL){
    T=L->Next;
    L->Next=T->Next;
    T->node=NULL;
    free(T);
  }
  free(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x321f
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
callq 0x1030
jmp 0x3207
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/list.c
// Function: FreeCList
void FreeCList(CList* L){//Apodesmevi thn CList
  CList* T;
	if(L->Diffrend!=NULL){
		FreeTList(L->Diffrend);
		L->Diffrend=NULL;
	}
  while(L->Next!=NULL){
    T=L->Next;
    L->Next=T->Next;
    free(T->name);
    free(T);
  }
	free(L->name);
  free(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x3264
callq 0x31fe
andq $0x0, 0x10(%rbx)
jmp 0x3264
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq (%r14), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq 0x18(%rbx), %r14
testq %r14, %r14
jne 0x324c
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/list.c
// Function: Print_Camera_Count_TList
void Print_Camera_Count_TList(TList* T)
{
	int i = 1;
	TList* tptr = T->Next;
	while(tptr != NULL)
	{
		printf("list %d has %d cameras\n", i, tptr->node->camera_count);
		tptr = tptr->Next;
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r14
leaq 0x2fbe(%rip), %r15      # 0x62b8
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x331b
movq (%rbx), %rax
movl 0x20(%rax), %edx
movq %r15, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x10d0
incl %r14d
jmp 0x32fa
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/list.c
// Function: FreeeTList
void FreeeTList(TList* L){  //Apodesmevi thn TList kai tis CList pou exei os dedomena
	TList* T;
	while(L->Next!=NULL){
    T=L->Next;
    L->Next=T->Next;
    FreeCList(T->node);
    free(T);
  }
  free(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x3353
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rdi
callq 0x322d
movq %r14, %rdi
callq 0x1030
jmp 0x3330
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/list.c
// Function: CreateNList
NList* CreateNList(){ /*Dimiourgei mia nea WHash*/
	NList *L;
	L=(NList *)malloc(sizeof(NList));
	L->Next=NULL;
  L->camera=NULL;
	return L;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq $0x30
popq %rdi
callq 0x11a0
andq $0x0, 0x20(%rax)
andq $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/list.c
// Function: InsertNList
void InsertNList(NList* L,char* camera){//Eisagei ena neo product sthn arxh ths NList
	NList *N;
  N=(NList*)malloc(sizeof(NList));
  N->camera=strdup(camera);
	N->clique=NULL;
	N->Spear=NULL;
	N->vector=NULL;
  N->Next=L->Next;
  L->Next=N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x11a0
movq %rax, %r15
movq %rbx, %rdi
callq 0x1270
movq %rax, (%r15)
xorps %xmm0, %xmm0
andq $0x0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq 0x20(%r14), %rax
movq %rax, 0x20(%r15)
movq %r15, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/list.c
// Function: ConectNList
CList* ConectNList(NList* L,char* product,CList* clique){//Eisagei ena neo product sthn arxh ths CList
	while(L->Next!=NULL){	//Vrisko ton komvo ston opio einai apothikevmeno to product
		L=L->Next;
		if(!strcmp(L->camera,product)){
				break;
		}
	}

	if(L->clique==NULL){	//Ean den einai to product idi se kapia klika

		if(clique==NULL){	//Ean den exei dwthei kapia klika wste na mpei ekei to product
			L->clique=CreateCList();	//Dimiourgise mia nea klika
			InsertCList(L->clique,product,L);	//Vale to product sthn nea klika
		}else{	//Ean exei dothei mia klika sthn opia prepei na valw afto kai tous komvous ths klikas tou
			L->clique=clique;	//O komvos pou einai apothikevmeno to product dixnei sthn klika pou dothike
			InsertCList(L->clique,product,L);	//vale to product sthn klika pou dothike
		}

	}else{	//Ean to product einai idi se kapia klika

		if(clique!=NULL){ //Ean exei dwthei kapia klika wste na mpei ekei to product
			if(L->clique!=clique){	//ean oi dio klikes den einai idies
					L->clique=AppendCList(clique,L->clique);	//sigxonevw tis dio klikes
			}
		}

	}
		return L->clique; //Epistrefo thn klika sthn opia evala to product
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %r12, %rbx
movq 0x20(%r12), %r12
testq %r12, %r12
je 0x33f4
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1140
movq %r12, %rbx
testl %eax, %eax
jne 0x33d4
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x3415
testq %r14, %r14
je 0x343a
cmpq %r14, %rsi
je 0x343a
movq %r14, %rdi
callq 0x30e8
movq %r14, 0x10(%rbx)
jmp 0x343a
testq %r14, %r14
je 0x3423
movq %r14, 0x10(%rbx)
movq %r14, %rdi
jmp 0x342f
callq 0x2e60
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2e7d
movq 0x10(%rbx), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq