LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3sm/cmd/cmd_get_temperature.c
// Function: cmd_get_temperature_exec
int
cmd_get_temperature_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3sm_get_temperature get_temperature;
	struct ps3sm_get_temperature_reply get_temperature_reply;

	uint8_t cell_rsx;
	char *endptr;
	int ret;

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


	ps3sm_init_header(PS3SM_HDR(&get_temperature),
	    sizeof(get_temperature) - sizeof(struct ps3sm_header),
	    PS3SM_SID_GET_TEMPERATURE, 0);

	get_temperature.version = PS3SM_GET_TEMPERATURE_VERSION;
	get_temperature.arg = cell_rsx;

	ret = dev_write(&get_temperature, sizeof(get_temperature));
	if (ret != sizeof(get_temperature))
		return (CMD_EIO);
	
	ret = dev_read(&get_temperature_reply, sizeof(get_temperature_reply));
	if (ret < 0)
		return (CMD_EIO);
	
	fprintf(stdout, "%02d.%02d\n", get_temperature_reply.temp_0, ((get_temperature_reply.temp_1*0x64) >> 8));

	return (CMD_EOK);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq (%rcx), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x10f0
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
setne %cl
testb $-0x2, %al
setne %dl
orb %cl, %dl
movl $0x2, %ebx
jne 0x1798
leaq 0x2c(%rsp), %rdi
movw $0x1001, (%rdi)         # imm = 0x1001
movl $0x4, 0x4(%rdi)
movw $0xd, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movb $0x1, 0x10(%rdi)
movb %al, 0x11(%rdi)
movl $0x14, %esi
callq 0x1418
movl $0x3, %ebx
cmpl $0x14, %eax
jne 0x1798
leaq 0x14(%rsp), %rdi
movl $0x18, %esi
callq 0x1439
testl %eax, %eax
js 0x1798
movq 0x2853(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
movzbl 0x28(%rsp), %edx
movzbl 0x29(%rsp), %eax
imull $0x64, %eax, %ecx
shrl $0x8, %ecx
leaq 0xa1c(%rip), %rsi       # 0x21ab
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10b0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3sm/cmd/cmd_ring_buzzer.c
// Function: cmd_ring_buzzer_exec
int
cmd_ring_buzzer_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3sm_ring_buzzer ring_buzzer;
	uint32_t arg1, arg2, arg3;
	char *endptr;
	int ret;

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

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

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

	ps3sm_init_header(PS3SM_HDR(&ring_buzzer),
	    sizeof(ring_buzzer) - sizeof(struct ps3sm_header),
	    PS3SM_SID_RING_BUZZER, 0);

	ring_buzzer.version = PS3SM_RING_BUZZER_VERSION;
	ring_buzzer.arg1 = arg1;
	ring_buzzer.arg2 = arg2;
	ring_buzzer.arg3 = arg3;

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

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq (%rcx), %rdi
movq %rsp, %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x10f0
movq %rax, %rbx
movq (%r15), %rax
cmpb $0x0, (%rax)
setne %al
testl $0xffffff00, %ebx       # imm = 0xFFFFFF00
setne %cl
orb %al, %cl
movl $0x2, %ebp
jne 0x1867
movq 0x8(%r14), %rdi
movq %rsp, %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x10f0
movq %rax, %r15
movq (%r12), %rax
cmpb $0x0, (%rax)
setne %al
testl $0xffffff00, %r15d      # imm = 0xFFFFFF00
setne %cl
orb %al, %cl
jne 0x1867
movq 0x10(%r14), %rdi
movq %rsp, %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x10f0
movq (%r14), %rcx
cmpb $0x0, (%rcx)
jne 0x1867
leaq 0x8(%rsp), %rdi
movw $0x1001, (%rdi)         # imm = 0x1001
movl $0x8, 0x4(%rdi)
movw $0x15, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movb $0x1, 0x10(%rdi)
movb %bl, 0x11(%rdi)
movb %r15b, 0x12(%rdi)
movl %eax, 0x14(%rdi)
movl $0x18, %esi
callq 0x1418
xorl %ecx, %ecx
cmpl $0x18, %eax
setne %cl
leal (%rcx,%rcx,2), %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3sm/cmd/cmd_set_attr.c
// Function: cmd_set_attr_exec
int
cmd_set_attr_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3sm_set_attr set_attr;
	uint32_t attrs;
	char *endptr;
	int ret;

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

	ps3sm_init_header(PS3SM_HDR(&set_attr),
	    sizeof(set_attr) - sizeof(struct ps3sm_header),
	    PS3SM_SID_SET_ATTR, 0);

	set_attr.version = PS3SM_SET_ATTR_VERSION;
	set_attr.attrs = attrs;

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

	return (CMD_EOK);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq (%rcx), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x10f0
movq (%rbx), %rdx
movl $0x2, %ecx
cmpb $0x0, (%rdx)
jne 0x18d4
leaq 0x8(%rsp), %rdi
movw $0x1001, (%rdi)         # imm = 0x1001
movl $0x8, 0x4(%rdi)
movw $0x8, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movb $0x1, 0x10(%rdi)
movl %eax, 0x14(%rdi)
movl $0x18, %esi
callq 0x1418
xorl %ecx, %ecx
cmpl $0x18, %eax
setne %cl
leal (%rcx,%rcx,2), %ecx
movl %ecx, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sguerrini97[P]ps3linux-ps3vuart-tools/ps3sm/cmd/cmd_set_fan_policy.c
// Function: cmd_set_fan_policy_exec
int
cmd_set_fan_policy_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3sm_set_fan_policy set_fan_policy;

	uint8_t arg1, arg2, arg3;

	char *endptr1, *endptr2, *endptr3;
	int ret;

	arg1 = strtoul(argv[0], &endptr1, 0);
	arg2 = strtoul(argv[1], &endptr2, 0);
	arg3 = strtoul(argv[2], &endptr3, 0);

	if (*endptr1 != '\0' || *endptr2 != '\0' || *endptr3 != '\0')
		return (CMD_EINVAL);

	if (arg2 == 2 && (arg3 < 0x33 || arg3 > 0xfc))
	{
		fprintf(stderr, "Dangerous fan speed, aborting\n");
		return (CMD_EINVAL);
	}

	ps3sm_init_header(PS3SM_HDR(&set_fan_policy),
    	sizeof(set_fan_policy) - sizeof(struct ps3sm_header),
    	PS3SM_SID_FAN_POLICY_1, 0);

	set_fan_policy.version = PS3SM_SET_FAN_POLICY_VERSION;
	set_fan_policy.arg1 = arg1;
	set_fan_policy.arg2 = arg2;
	set_fan_policy.arg3 = arg3;

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

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq (%rcx), %rdi
leaq 0x10(%rsp), %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x10f0
movq %rax, %rbx
movq 0x8(%r15), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x10f0
movq %rax, %r14
movq 0x10(%r15), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0x10f0
movq (%r12), %rcx
movl $0x2, %ebp
cmpb $0x0, (%rcx)
jne 0x199a
movq 0x8(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x199a
movq (%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x199a
cmpb $0x2, %r14b
jne 0x1959
movzbl %al, %ecx
addl $0xffffff03, %ecx       # imm = 0xFFFFFF03
cmpl $0xffffff35, %ecx       # imm = 0xFFFFFF35
jbe 0x19a9
leaq 0x18(%rsp), %rdi
movw $0x1001, (%rdi)         # imm = 0x1001
movl $0x8, 0x4(%rdi)
movw $0x19, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movb $0x1, 0x10(%rdi)
movb %bl, 0x11(%rdi)
movb %r14b, 0x12(%rdi)
movb %al, 0x13(%rdi)
movl $0x18, %esi
callq 0x1418
xorl %ecx, %ecx
cmpl $0x18, %eax
setne %cl
leal (%rcx,%rcx,2), %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1150
jmp 0x199a
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/tests/error.c
// Function: main
int main(void)
{
	dhara_error_t err;

	for (err = DHARA_E_NONE; err < DHARA_E_MAX; err++) {
		const char *msg = dhara_strerror(err);

		assert(msg != NULL);
		printf("%4d: %s\n", err, msg);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0xf85(%rip), %rbx       # 0x2103
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x114c
testq %rax, %rax
je 0x11ab
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1030
incl %ebp
cmpl $0x9, %ebp
jne 0x1180
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xf28(%rip), %rdi       # 0x20da
leaq 0xf2d(%rip), %rsi       # 0x20e6
leaq 0xf34(%rip), %rcx       # 0x20f4
movl $0x1c, %edx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::PhotonLayer(int, int)
PhotonLayer(int width, int height) {
        width_ = width;
        height_ = height;

		for (int h = 0; h < height; h++)
			iArray.push_back({});

		for (int h = 0; h < height; h++)
			iArray[h].resize(width);

        pixels.resize(height);
        rowIslands.resize(height);
        rowUnsupported.resize(height);
        rowSupported.resize(height);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r13d
movl %esi, %r15d
movl $0x0, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x28(%rdi), %rax
movq %rax, -0x48(%rbp)
leaq 0x40(%rdi), %rax
movq %rax, -0x40(%rbp)
leaq 0x58(%rdi), %rax
movq %rax, -0x38(%rbp)
leaq 0x70(%rdi), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movq $0x0, 0x80(%rdi)
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
testl %edx, %edx
jle 0x84ff
leaq -0x60(%rbp), %r12
movl %r13d, %r14d
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9744
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x84fa
callq 0x21d0
decl %r14d
jne 0x84d2
testl %r13d, %r13d
jle 0x852c
movslq %r15d, %r15
movl %r13d, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r14
xorl %r12d, %r12d
movq (%rbx), %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x9690
addq $0x18, %r12
cmpq %r12, %r14
jne 0x8515
movslq %r13d, %r14
movq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x96c2
movq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x96c2
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x96c2
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x96c2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8570
movq %rax, %r14
jmp 0x8586
movq %rax, %r14
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x8586
callq 0x21d0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x8597
callq 0x21d0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x85a8
callq 0x21d0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x85b9
callq 0x21d0
movq -0x48(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x85ca
callq 0x21d0
movq %rbx, %rdi
callq 0x96fa
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonFilePreview.h
// Function: PhotonFilePreview::PhotonFilePreview(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
PhotonFilePreview(int previewAddress, const std::string & fileContent) {
        std::string data(fileContent.begin() + previewAddress, fileContent.begin() + previewAddress + 32);
		std::stringstream ss(data);
        PhotonInputStream ds(ss);

        resolutionX_ = ds.readInt();
        resolutionY_ = ds.readInt();
        imageAddress_ = ds.readInt();
        dataSize_ = ds.readInt();
        p1_ = ds.readInt();
        p2_ = ds.readInt();
        p3_ = ds.readInt();
        p4_ = ds.readInt();

        rawImageData_.assign(fileContent.begin() + imageAddress_, fileContent.begin() + imageAddress_ + dataSize_);

        decodeImageData();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdx, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq (%rdx), %rax
movslq %esi, %rcx
leaq (%rax,%rcx), %rsi
leaq 0x20(%rax,%rcx), %rdx
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
leaq -0x50(%rbp), %rdi
callq 0xa24e
leaq -0x1d8(%rbp), %r12
leaq -0x50(%rbp), %rsi
movq %r12, %rdi
movl $0x18, %edx
callq 0x2350
leaq -0x30(%rbp), %rdi
movq %r12, (%rdi)
callq 0x9f66
movl %eax, (%r14)
leaq -0x30(%rbp), %rdi
callq 0x9f66
movl %eax, 0x4(%r14)
leaq -0x30(%rbp), %rdi
callq 0x9f66
movl %eax, 0x8(%r14)
leaq -0x30(%rbp), %rdi
callq 0x9f66
movl %eax, 0xc(%r14)
leaq -0x30(%rbp), %rdi
callq 0x9f66
movl %eax, 0x40(%r14)
leaq -0x30(%rbp), %rdi
callq 0x9f66
movl %eax, 0x44(%r14)
leaq -0x30(%rbp), %rdi
callq 0x9f66
movl %eax, 0x48(%r14)
leaq -0x30(%rbp), %rdi
callq 0x9f66
movl %eax, 0x4c(%r14)
movslq 0x8(%r14), %rsi
addq (%r15), %rsi
movslq 0xc(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xa2cc
movq %r14, %rdi
callq 0xa18a
movq 0x9564(%rip), %rsi      # 0x11fa8
leaq -0x1d8(%rbp), %rdi
callq 0x2180
leaq -0x158(%rbp), %rdi
callq 0x20d0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x8a6a
callq 0x21d0
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8a88
movq %rax, %r15
jmp 0x8aaa
movq %rax, %r15
jmp 0x8ab8
movq %rax, %r15
movq 0x9516(%rip), %rsi      # 0x11fa8
leaq -0x1d8(%rbp), %rdi
callq 0x2180
leaq -0x158(%rbp), %rdi
callq 0x20d0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x8ab8
callq 0x21d0
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x8ac6
callq 0x21d0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8ad3
callq 0x21d0
movq %r15, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonFilePrintParameters.h
// Function: PhotonFilePrintParameters::PhotonFilePrintParameters(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
PhotonFilePrintParameters(int parametersPos, const std::string & fileContent) {
        std::string data(fileContent.begin() + parametersPos, fileContent.begin() + parametersPos + getByteSize());
		std::stringstream ss(data);
        PhotonInputStream ds(ss);

        bottomLiftDistance_ = ds.readFloat();
        bottomLiftSpeed_ = ds.readFloat();

        liftingDistance_ = ds.readFloat();
        liftingSpeed_ = ds.readFloat();
        retractSpeed_ = ds.readFloat();

        volumeMl_ = ds.readFloat();
        weightG_ = ds.readFloat();
        costDollars_ = ds.readFloat();

        bottomLightOffDelay_ = ds.readFloat();
        lightOffDelay_ = ds.readFloat();
        bottomLayerCount_ = ds.readInt();

        p1_ = ds.readInt();
        p2_ = ds.readInt();
        p3_ = ds.readInt();
        p4_ = ds.readInt();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
movaps 0x4528(%rip), %xmm0     # 0xd020
movups %xmm0, (%rdi)
movl $0x43960000, 0x10(%rdi) # imm = 0x43960000
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%rdi)
movl $0x0, 0x24(%rdi)
movq (%rdx), %rax
movslq %esi, %rcx
leaq (%rax,%rcx), %rsi
leaq 0x3c(%rax,%rcx), %rdx
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0xa24e
leaq -0x1d0(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x18, %edx
callq 0x2350
leaq -0x28(%rbp), %rdi
movq %r14, (%rdi)
callq 0x9f66
movl %eax, (%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x4(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x8(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0xc(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x10(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
leaq 0x14(%rbx), %rcx
movl %eax, (%rcx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x18(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x1c(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x20(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x24(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x28(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x2c(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x30(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x34(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x9f66
movl %eax, 0x38(%rbx)
movq 0x939d(%rip), %rsi      # 0x11fa8
leaq -0x1d0(%rbp), %rdi
callq 0x2180
leaq -0x150(%rbp), %rdi
callq 0x20d0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x8c31
callq 0x21d0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x8c68
movq %rax, %rbx
movq 0x9358(%rip), %rsi      # 0x11fa8
leaq -0x1d0(%rbp), %rdi
callq 0x2180
leaq -0x150(%rbp), %rdi
callq 0x20d0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x8c76
callq 0x21d0
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonFileLayer.h
// Function: PhotonFileLayer::saveLayer(PhotonLayer&)
void saveLayer(PhotonLayer & photonLayer) {
        packedLayerImage_ = photonLayer.packLayerImage();
        imageData_ = photonLayer.packImageData();
        dataSize_ = imageData_.size();
        islandRows_.clear();
        isLandsCount_ = photonLayer.setIslands(islandRows_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xbb14
leaq 0x48(%rbx), %rdi
movq %r15, %rsi
callq 0x2270
movq (%r15), %rdi
leaq -0x30(%rbp), %r12
cmpq %r12, %rdi
je 0x90fc
callq 0x21d0
movq %r15, %rdi
movq %r14, %rsi
callq 0xbc72
leaq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x2270
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x9120
callq 0x21d0
movl 0x30(%rbx), %eax
movl %eax, 0x10(%rbx)
leaq 0x68(%rbx), %r15
movq 0x68(%rbx), %rsi
movq %r15, %rdi
callq 0xbfdc
movq %r14, %rdi
movq %r15, %rsi
callq 0xbdce
movl %eax, 0x80(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonFilePreview.h
// Function: PhotonFilePreview::save(PhotonOutputStream, int)
void save(PhotonOutputStream os, int startAddress) {
        os.writeInt(resolutionX_);
        os.writeInt(resolutionY_);
        os.writeInt(startAddress + 4+4+4+4 + 4+4+4+4);
        os.writeInt(dataSize_);
        os.writeInt(p1_);
        os.writeInt(p2_);
        os.writeInt(p3_);
        os.writeInt(p4_);
        os.write(rawImageData_, 0, dataSize_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq %rsi, (%r14)
movl (%rdi), %esi
movq %r14, %rdi
callq 0xc228
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0xc228
addl $0x20, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0xc228
movl 0xc(%rbx), %esi
movq %r14, %rdi
callq 0xc228
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0xc228
movl 0x44(%rbx), %esi
movq %r14, %rdi
callq 0xc228
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0xc228
movl 0x4c(%rbx), %esi
movq %r14, %rdi
callq 0xc228
leaq 0x10(%rbx), %rsi
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x9e66
movq (%r14), %rsi
cmpq 0x8(%r14), %rsi
je 0x938d
movslq 0xc(%rbx), %rdx
movq -0x20(%rbp), %rdi
callq 0x22a0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x939b
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x93b7
callq 0x21d0
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonFilePrintParameters.h
// Function: PhotonFilePrintParameters::save(PhotonOutputStream&)
void save(PhotonOutputStream & os) {
        os.writeFloat(bottomLiftDistance_);
        os.writeFloat(bottomLiftSpeed_);

        os.writeFloat(liftingDistance_);
        os.writeFloat(liftingSpeed_);
        os.writeFloat(retractSpeed_);

        os.writeFloat(volumeMl_);
        os.writeFloat(weightG_);
        os.writeFloat(costDollars_);

        os.writeFloat(bottomLightOffDelay_);
        os.writeFloat(lightOffDelay_);
        os.writeInt(bottomLayerCount_);

        os.writeInt(p1_);
        os.writeInt(p2_);
        os.writeInt(p3_);
        os.writeInt(p4_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x14(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x20(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x24(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x2c(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x30(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x34(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x38(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc228
nop
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonFileLayer.h
// Function: PhotonFileLayer::save(PhotonOutputStream&)
void save(PhotonOutputStream & os) {
        os.writeFloat(layerPositionZ_);
        os.writeFloat(layerExposure_);
        os.writeFloat(layerOffTimeSeconds_);

        os.writeInt(dataAddress_);
        os.writeInt(dataSize_);

        os.writeInt(unknown1_);
        os.writeInt(unknown2_);
        os.writeInt(unknown3_);
        os.writeInt(unknown4_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x14(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0xc228
movl 0x20(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc228
nop
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonInputStream.h
// Function: PhotonInputStream::readInt()
uint32_t readInt() {
		std::vector<char> buf;
		buf.resize(4);
        readFully(buf);
        return (buf[3]) << 24 | (buf[2] & 0xff) << 16 |
                (buf[1] & 0xff) << 8 | (buf[0] & 0xff);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x4, %esi
callq 0x9690
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
cmpq %rdx, %rsi
je 0x9fa6
movq (%rbx), %rdi
subq %rsi, %rdx
callq 0x2280
movq -0x20(%rbp), %rdi
movl (%rdi), %ebx
callq 0x21d0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x9fcb
callq 0x21d0
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonFilePreview.h
// Function: PhotonFilePreview::decodeImageData()
void decodeImageData() {
        imageData_.resize(resolutionX_ * resolutionY_);
        int d = 0;
        for (int i = 0; i < dataSize_; i++) {
			int32_t dot = (rawImageData_[i] & 0xFF) | ((rawImageData_[i+1] & 0xFF) << 8);
			i++;

			int32_t color =   ((dot & 0xF800) << 8) | ((dot & 0x07C0) << 5) | ((dot & 0x001F) << 3);

//            int red = ((dot >> 11) & 0x1F) << 3;
//            int green = ((dot >> 6) & 0x1F) << 3;
//            int blue = (dot & 0x1F) << 3;
//            color = red<<16 | green<<8 | blue;

            int repeat = 1;
            if ((dot & 0x0020) == 0x0020) {
                repeat += (rawImageData_[i+1] & 0xFF) | ((rawImageData_[i+2] & 0x0F) << 8);
				i += 2;
            }

            while (repeat > 0) {
                imageData_[d++] = color;
                repeat--;
            }
        }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x28, %rdi
movslq (%rbx), %rax
movslq 0x4(%rbx), %rsi
imulq %rax, %rsi
callq 0x96c2
cmpl $0x0, 0xc(%rbx)
jle 0xa247
movq 0x10(%rbx), %rax
movq 0x28(%rbx), %rcx
xorl %edx, %edx
xorl %esi, %esi
movslq %esi, %r8
movzbl (%rax,%r8), %edi
testb $0x20, %dil
jne 0xa1d7
leaq 0x1(%r8), %rsi
movl $0x1, %r9d
jmp 0xa1f5
movzbl 0x2(%rax,%r8), %r9d
leaq 0x3(%r8), %rsi
movzbl 0x3(%rax,%r8), %r10d
andl $0xf, %r10d
shll $0x8, %r10d
addl %r10d, %r9d
incl %r9d
movzbl 0x1(%rax,%r8), %r10d
movl %r10d, %r8d
shll $0x10, %r8d
leal (%r8,%rdi,8), %r8d
shll $0xd, %r10d
shll $0x5, %edi
orl %r10d, %edi
andl $0xf800, %edi           # imm = 0xF800
andl $0xf800f8, %r8d         # imm = 0xF800F8
orl %edi, %r8d
movslq %edx, %rdi
leaq (%rcx,%rdi,4), %rdi
movl %r9d, %r9d
xorl %r10d, %r10d
movl %r8d, (%rdi,%r10,4)
incq %r10
cmpl %r10d, %r9d
jne 0xa22d
addl %r10d, %edx
incl %esi
cmpl 0xc(%rbx), %esi
jl 0xa1bd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonFileLayer.h
// Function: PhotonFileLayer::PhotonFileLayer(PhotonInputStream&, int, int)
PhotonFileLayer(PhotonInputStream & ds, int32_t width, int32_t height) {
		width_ = width;
		height_ = height;
		layerPositionZ_ = ds.readFloat();
        layerExposure_ = ds.readFloat();
        layerOffTimeSeconds_ = ds.readFloat();

        dataAddress_ = ds.readInt();
        dataSize_ = ds.readInt();

        unknown1_ = ds.readInt();
        unknown2_ = ds.readInt();
        unknown3_ = ds.readInt();
        unknown4_ = ds.readInt();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
xorl %eax, %eax
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x58(%rdi), %r14
movq %r14, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
leaq 0x68(%rdi), %rsi
movq %rsi, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rdi)
movq %rax, 0x78(%rdi)
leaq 0x90(%rdi), %r12
movups %xmm0, 0x90(%rdi)
movq %rax, 0xa0(%rdi)
movl %edx, 0xac(%rdi)
movl %ecx, 0xb0(%rdi)
movq %r15, %rdi
callq 0x9f66
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x9f66
movl %eax, 0x4(%rbx)
movq %r15, %rdi
callq 0x9f66
movl %eax, 0x8(%rbx)
movq %r15, %rdi
callq 0x9f66
movl %eax, 0xc(%rbx)
movq %r15, %rdi
callq 0x9f66
movl %eax, 0x10(%rbx)
movq %r15, %rdi
callq 0x9f66
movl %eax, 0x14(%rbx)
movq %r15, %rdi
callq 0x9f66
movl %eax, 0x18(%rbx)
movq %r15, %rdi
callq 0x9f66
movl %eax, 0x1c(%rbx)
movq %r15, %rdi
callq 0x9f66
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x95e8
movq -0x30(%rbp), %rdi
callq 0xa648
movq 0x48(%rbx), %rdi
cmpq %r14, %rdi
je 0xa4ed
callq 0x21d0
movq 0x28(%rbx), %rdi
cmpq %r13, %rdi
je 0xa4fb
callq 0x21d0
movq %r15, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::unLink()
void unLink() {
        iArray.clear();
        pixels.clear();
        rowIslands.clear();
        rowUnsupported.clear();
        rowSupported.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rdi
callq 0xbad2
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0xa616
movq %rax, 0x30(%rbx)
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0xa624
movq %rax, 0x48(%rbx)
movq 0x58(%rbx), %rax
cmpq %rax, 0x60(%rbx)
je 0xa632
movq %rax, 0x60(%rbx)
movq 0x70(%rbx), %rax
cmpq %rax, 0x78(%rbx)
je 0xa640
movq %rax, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::packLayerImage[abi:cxx11]()
std::string packLayerImage() {
		std::stringstream baos;

		{
            for (int y = 0; y < height_; y++) {
                if (pixels[y] == 0) {
                    add(baos, PhotonDot::OFF, width_);
                } else {
                    char current = PhotonDot::OFF;
                    int length = 0;
                    for (int x = 0; x < width_; x++) {
						char next = iArray[y][x];
                        if (next != current) {
                            if (length > 0) {
                                add(baos, current, length);
                            }
                            current = next;
                            length = 1;
                        } else {
                            length++;
                        }
                    }
                    if (length > 0) {
                        add(baos, current, length);
                    }
                }
            }

			return baos.str();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x2160
cmpl $0x0, 0x4(%r14)
jle 0xbbfb
xorl %r15d, %r15d
movq 0x28(%r14), %rax
cmpl $0x0, (%rax,%r15,4)
movl (%r14), %ecx
je 0xbbb3
testl %ecx, %ecx
movq %r15, -0x38(%rbp)
jle 0xbbc6
xorl %ebx, %ebx
leaq (%r15,%r15,2), %r15
xorl %ecx, %ecx
xorl %eax, %eax
movq 0x10(%r14), %rdx
movq (%rdx,%r15,8), %rdx
movb (%rdx,%rbx), %r13b
cmpb %al, %r13b
jne 0xbb84
incl %ecx
movl %eax, %r13d
movl %ecx, %r12d
jmp 0xbba0
movl $0x1, %r12d
testl %ecx, %ecx
jle 0xbba0
movsbl %al, %edx
movq %r14, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xbe8e
incq %rbx
movslq (%r14), %rdx
movl %r12d, %ecx
movl %r13d, %eax
cmpq %rdx, %rbx
jl 0xbb69
jmp 0xbbcc
movq %r14, %rdi
leaq -0x1b0(%rbp), %rsi
xorl %edx, %edx
callq 0xbe8e
jmp 0xbbeb
xorl %r13d, %r13d
xorl %r12d, %r12d
testl %r12d, %r12d
movq -0x38(%rbp), %r15
jle 0xbbeb
movsbl %r13b, %edx
movq %r14, %rdi
leaq -0x1b0(%rbp), %rsi
movl %r12d, %ecx
callq 0xbe8e
incq %r15
movslq 0x4(%r14), %rax
cmpq %rax, %r15
jl 0xbb49
leaq -0x1a8(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2340
movq 0x6393(%rip), %rsi      # 0x11fa8
leaq -0x1c0(%rbp), %rdi
callq 0x2180
leaq -0x140(%rbp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbc48
jmp 0xbc48
jmp 0xbc48
movq %rax, %rbx
movq 0x6356(%rip), %rsi      # 0x11fa8
leaq -0x1c0(%rbp), %rdi
callq 0x2180
leaq -0x140(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::packImageData[abi:cxx11]()
std::string packImageData() {
		std::stringstream baos;
		
		{
            for (int y = 0; y < height_; y++) {
                if (pixels[y] == 0) {
                    addPhotonRLE(baos, true, width_);
                } else {
                    char current = PhotonDot::OFF;
                    int length = 0;
                    for (int x = 0; x < width_; x++) {
						char next = iArray[y][x];
                        if (next != current) {
                            if (length > 0) {
                                addPhotonRLE(baos, current == PhotonDot::OFF, length);
                            }
                            current = next;
                            length = 1;
                        } else {
                            length++;
                        }
                    }
                    if (length > 0) {
                        addPhotonRLE(baos, current == PhotonDot::OFF, length);
                    }
                }
            }

            return baos.str();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x2160
cmpl $0x0, 0x4(%r14)
jle 0xbd57
xorl %r12d, %r12d
movq 0x28(%r14), %rax
cmpl $0x0, (%rax,%r12,4)
movl (%r14), %ecx
je 0xbd17
testl %ecx, %ecx
jle 0xbd2d
xorl %r13d, %r13d
leaq (%r12,%r12,2), %rbx
xorl %ecx, %ecx
xorl %eax, %eax
movq 0x10(%r14), %rdx
movq (%rdx,%rbx,8), %rdx
movb (%rdx,%r13), %r15b
cmpb %al, %r15b
jne 0xbcd9
incl %ecx
jmp 0xbd05
testl %ecx, %ecx
jle 0xbcfd
xorl %edx, %edx
testb %al, %al
sete %dl
movq %r14, %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xbf36
movl %r15d, %eax
movl $0x1, %ecx
jmp 0xbd05
movl %r15d, %eax
movl $0x1, %ecx
incq %r13
movslq (%r14), %rdx
cmpq %rdx, %r13
jl 0xbcc4
testb %al, %al
sete %al
jmp 0xbd31
movq %r14, %rdi
leaq -0x1a8(%rbp), %rsi
movl $0x1, %edx
callq 0xbf36
jmp 0xbd47
xorl %ecx, %ecx
movb $0x1, %al
testl %ecx, %ecx
jle 0xbd47
movzbl %al, %edx
movq %r14, %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xbf36
incq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jl 0xbca7
leaq -0x1a0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2340
movq 0x6237(%rip), %rsi      # 0x11fa8
leaq -0x1b8(%rbp), %rdi
callq 0x2180
leaq -0x138(%rbp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbda4
jmp 0xbda4
jmp 0xbda4
movq %rax, %rbx
movq 0x61fa(%rip), %rsi      # 0x11fa8
leaq -0x1b8(%rbp), %rdi
callq 0x2180
leaq -0x138(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::setIslands(std::vector<std::vector<bool, std::allocator<bool>>, std::allocator<std::vector<bool, std::allocator<bool>>>>&)
int setIslands(std::vector<photoncpp::BitSet> & islandRows) {
        int islands = 0;
        for (int y = 0; y < height_; y++) {
			photoncpp::BitSet bitSet;
            if (rowIslands[y] > 0) {
                for (int x = 0; x < width_; x++) {
                    if (iArray[y][x] == PhotonDot::ISLAND) {
						bitSet[x] = true;
                    }
                }
            }
            islandRows.push_back(bitSet);
            islands += rowIslands[y];
        }
        return islands;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x4(%rdi)
jle 0xbe4c
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r13, -0x50(%rbp)
movl %r13d, -0x48(%rbp)
movq %r13, -0x40(%rbp)
movl %r13d, -0x38(%rbp)
movq %r13, -0x30(%rbp)
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0xc00c
movq 0x40(%r14), %rax
addl (%rax,%r12,4), %r15d
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xbe3e
callq 0x21d0
movq %r13, -0x50(%rbp)
movl %r13d, -0x48(%rbp)
movq %r13, -0x40(%rbp)
movl %r13d, -0x38(%rbp)
movq %r13, -0x30(%rbp)
incq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jl 0xbdf4
jmp 0xbe4f
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xbe86
callq 0x21d0
xorl %eax, %eax
movq %rax, -0x50(%rbp)
movl %eax, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movl %eax, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::add(std::ostream&, char, int)
void add(std::ostream & baos, char current, int length) {
        if (length < 32) {
			std::vector<char> data(1, 0);
            data[0] = (char) ((current << 5) | (length & 0x1f));
            baos.write(data.data(), data.size());
        } else {
			std::vector<char> data(2, 0);
            data[0] = (char) (0x80 | (current << 5) | (length >> 8 & 0x00FF));
            data[1] = (char) (length & 0x00FF);
            baos.write(data.data(), data.size());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r14
cmpl $0x1f, %ecx
jg 0xbed7
movl $0x1, %edi
callq 0x21f0
movq %rax, %rbx
movzbl %r12b, %eax
shll $0x5, %eax
andl $0x1f, %r15d
orl %eax, %r15d
movb %r15b, (%rbx)
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22a0
jmp 0xbf11
movl $0x2, %edi
callq 0x21f0
movq %rax, %rbx
movw $0x0, (%rax)
movzbl %r12b, %eax
shll $0x5, %eax
movl %r15d, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
orb $-0x80, %cl
movb %cl, (%rbx)
movb %r15b, 0x1(%rbx)
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22a0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
jmp 0xbf23
movq %rax, %r14
movq %rbx, %rdi
callq 0x21d0
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::addPhotonRLE(std::ostream&, bool, int)
void addPhotonRLE(std::ostream & baos, bool off, int length) {
		std::vector<char> data({ 0 });
        while (length>0) {
            int lineLength = std::min(length, 125); // max storage length of 0x7D (125) ?? Why not 127?
            data[0] = (char) ((off ? 0x00: 0x80) | (lineLength & 0x7f));
            baos.write(data.data(), data.size());
            length -= lineLength;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movl %edx, %r15d
movq %rsi, %r14
leaq -0x22(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
leaq -0x21(%rbp), %rcx
movl $0x1, %edx
callq 0xa0e2
testl %ebx, %ebx
jle 0xbfa7
xorb $0x1, %r15b
movzbl %r15b, %r15d
shll $0x7, %r15d
cmpl $0x7d, %ebx
movl $0x7d, %r12d
cmovll %ebx, %r12d
movl %r12d, %eax
orl %r15d, %eax
movq -0x40(%rbp), %rcx
movb %al, (%rcx)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq %rsi, %rdx
movq %r14, %rdi
callq 0x22a0
subl %r12d, %ebx
jg 0xbf76
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xbfb5
callq 0x21d0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xbfd3
callq 0x21d0
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O1/0x3f00[P]PhotonCpp/./PhotonOutputStream.h
// Function: PhotonOutputStream::writeInt(int)
void writeInt(int v) {
		outputStream_.put(0xFF & v);
		outputStream_.put(0xFF & (v >> 8));
		outputStream_.put(0xFF & (v >> 16));
		outputStream_.put(0xFF & (v >> 24));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
movsbl %bl, %esi
callq 0x2040
movq (%r14), %rdi
movl %ebx, %eax
shrl $0x8, %eax
movsbl %al, %esi
callq 0x2040
movq (%r14), %rdi
movl %ebx, %eax
shrl $0x10, %eax
movsbl %al, %esi
callq 0x2040
movq (%r14), %rdi
sarl $0x18, %ebx
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/chatziko-k08[P]lecture-code/tests/ADTList_test.c
// Function: test_create
void test_create(void) {
	// Δημιουργούμε μια κενή λίστα με NULL δείκτη συνάρτησης delete_value
	List list = list_create(NULL);
	list_set_destroy_value(list, NULL);

	// Ελέγχουμε ότι δεν απέτυχε η malloc στην λίστα, και ότι
	// αρχικοποιείται με μέγεθος 0 (δηλαδή χωρίς κόμβους)
	TEST_ASSERT(list != NULL);
	TEST_ASSERT(list_size(list) == 0);

	list_destroy(list);
}

// Assembly:
pushq %rbx
xorl %edi, %edi
callq 0x4928
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x4a8c
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
leaq 0x1552(%rip), %rsi      # 0x5318
leaq 0x17d0(%rip), %rcx      # 0x559d
leaq 0x1553(%rip), %r8       # 0x5327
movl $0x14, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3e22
movq %rbx, %rdi
callq 0x496a
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x151d(%rip), %rsi      # 0x5318
leaq 0x179b(%rip), %rcx      # 0x559d
leaq 0x152b(%rip), %r8       # 0x5334
movl $0x15, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3e22
movq %rbx, %rdi
popq %rbx
jmp 0x4a95
callq 0x2e03
// File: /workspace/github_c_makefile_star2_O1/chatziko-k08[P]lecture-code/tests/ADTList_test.c
// Function: test_find
void test_find(void) {
	List list = list_create(NULL);
	int N = 1000;
	int* array = malloc(N * sizeof(*array));					

	// Εισάγουμε δοκιμαστικές τιμές στον πίνακα, για να ελέγξουμε την test_find
	for (int i = 0; i < N; i++) {
		array[i] = i;
		list_insert_next(list, LIST_BOF, &array[i]);
	}

	// Εύρεση όλων των στοιχείων
	for (int i = 0; i < N; i++) {
		int* value = list_find(list, &i, compare_ints); 
		TEST_ASSERT(value == &array[i]);
	}

	// Δοκιμάζουμε, για μια τυχαία τιμή που δεν μπορεί πιθανώς να υπάρχει στην λίστα,
	// αν η list_find γυρνάει σωστά NULL pointer
	int not_exists = -1;
	TEST_ASSERT(list_find(list, &not_exists, compare_ints) == NULL);

	list_destroy(list);
	free(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x4928
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, %r14
movq %rax, %r15
movl %r12d, (%r15)
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x496e
incq %r12
addq $0x4, %r15
cmpq $0x3e8, %r12            # imm = 0x3E8
jne 0x4195
movq %rsp, %r15
movl $0x0, (%r15)
leaq 0x1152(%rip), %r13      # 0x5318
leaq 0x13d0(%rip), %rbp      # 0x559d
leaq 0x128b(%rip), %r12      # 0x545f
movq %rbx, %rdi
movq %r15, %rsi
leaq -0x79(%rip), %rdx       # 0x4168
callq 0x4a18
movslq (%rsp), %rcx
leaq (%r14,%rcx,4), %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
movq %r13, %rsi
movl $0x7d, %edx
movq %rbp, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x4287
movl (%rsp), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rsp)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x41d4
leaq 0x4(%rsp), %rsi
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
leaq -0xca(%rip), %rdx       # 0x4168
movq %rbx, %rdi
callq 0x4a18
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0x10ce(%rip), %rsi      # 0x5318
leaq 0x134c(%rip), %rcx      # 0x559d
leaq 0x121a(%rip), %r8       # 0x5472
movl $0x83, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x4287
movq %rbx, %rdi
callq 0x4a95
movq %r14, %rdi
callq 0x2290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2e03
// File: /workspace/github_c_makefile_star2_O1/chatziko-k08[P]lecture-code/tests/ADTList_test.c
// Function: test_find_node
void test_find_node(void) {
	List list = list_create(NULL);

	// Εισαγωγή τιμών στον πίνακα
	int N = 1000;
	int* array = malloc(N * sizeof(*array));					

	for (int i = 0; i < N; i++) {
		array[i] = i;
		list_insert_next(list, LIST_BOF, &array[i]);
	}

	// Ξεκινάμε από την αρχή της λίστας
	ListNode node = list_first(list);

	for (int i = N - 1; i >= 0; i--) {
		// Ελέγχουμε ότι η list_find_node βρίσκει σωστά τον πρώτο κόμβο με value τον δείκτη &array[i].
		// Σε αυτή την λίστα, δοκιμάζουμε ότι ο πρώτος κόμβος περιέχει τον δείκτη &array[N - 1], 
		// o δεύτερος τον &array[998] κοκ
		ListNode found_node = list_find_node(list, &i, compare_ints); 
		TEST_ASSERT(found_node == node);
		TEST_ASSERT(list_node_value(list, found_node) == &array[i]);

		// Προχωράμε στον επόμενο κόμβο για να προσπελάσουμε όλη την λίστα
		node = list_next(list, node);
	}

	list_destroy(list);
	free(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x4928
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, %r14
movq %rax, %r15
movl %r12d, (%r15)
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x496e
incq %r12
addq $0x4, %r15
cmpq $0x3e8, %r12            # imm = 0x3E8
jne 0x42b4
movq %rbx, %rdi
callq 0x4ad6
movq %rax, %r12
leaq 0x4(%rsp), %rax
movl $0x3e7, (%rax)          # imm = 0x3E7
leaq 0x1027(%rip), %rbp      # 0x5318
leaq 0x12a5(%rip), %r13      # 0x559d
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
leaq -0x19f(%rip), %rdx      # 0x4168
callq 0x4a60
movq %rax, %r15
xorl %edi, %edi
cmpq %r12, %rax
sete %dil
movq %rbp, %rsi
movl $0x9e, %edx
movq %r13, %rcx
leaq 0x117b(%rip), %r8       # 0x54a5
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x43af
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b14
movslq 0x4(%rsp), %rcx
leaq (%r14,%rcx,4), %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
movq %rbp, %rsi
movl $0x9f, %edx
movq %r13, %rcx
leaq 0x1154(%rip), %r8       # 0x54b8
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x43af
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4aeb
movq %rax, %r12
movl 0x4(%rsp), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x4(%rsp)
testl %eax, %eax
jg 0x42f8
movq %rbx, %rdi
callq 0x4a95
movq %r14, %rdi
callq 0x2290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2e03
// File: /workspace/github_c_makefile_star2_O1/meaning-matters[P]Except/Test.c
// Function: t1
int t1(void)
{
    try
    {
        return(6);
    }
    catch (Throwable, e)
    {
        printf("%s\n", e->getMessage());
    }
    finally;
    return(7);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x9f2f(%rip), %rbp      # 0xd270
movq (%rbp), %rdi
leaq 0x714c(%rip), %rbx      # 0xa498
movl $0x6f, %edx
movq %rbx, %rsi
callq 0x151a
leaq 0x9f90(%rip), %r14      # 0xd2f0
movl $0x1, %eax
leaq 0x7094(%rip), %r15      # 0xa400
movl %eax, %eax
movl %eax, 0xc(%rsp)
movq %rax, 0x10(%rsp)
movq (%rbp), %rdi
callq 0x12d2
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x6f, %ecx
callq 0x1b4a
testl %eax, %eax
je 0x33bd
movq (%r12), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x33bd
addq $0x8, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x3480
movq %r12, %rdi
movq %r14, %rsi
leaq 0x9cf6(%rip), %rdx      # 0xd0c0
movq %rbx, %rcx
movl $0x73, %r8d
callq 0x1bde
testl %eax, %eax
je 0x3427
movq (%r12), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x3427
movq %r12, %rdi
leaq 0x9ccd(%rip), %rsi      # 0xd0c0
callq 0x18a9
testl %eax, %eax
je 0x3427
movq 0x8(%r12), %rdi
movl $0x1, %esi
callq 0x1f2b
movq (%r12), %rcx
movl $0x2, 0x1b8(%rcx)
callq *0x1e0(%rax)
movq %rax, %rdi
callq 0x1070
cmpl $0x0, 0x9ec2(%rip)      # 0xd2f0
je 0x346b
movq (%r12), %rdi
movl $0x3, %r13d
cmpl $0x0, 0x1b4(%rdi)
jne 0x3471
addq $0xd0, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
jne 0x3471
movq (%r12), %rax
movl $0x1, 0x1b4(%rax)
xorl %r13d, %r13d
jmp 0x3471
movl $0x2, %r13d
movl %r13d, %r13d
movl %r13d, %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq (%r12), %rax
movl $0x1, 0x1b8(%rax)
movq %r12, %rdi
callq 0x129c
cmpl $-0x1, %eax
je 0x34eb
movq %r12, %rdi
movl $0xc8, %esi
movq %rbx, %rdx
movl $0x71, %ecx
callq 0x216e
movq %rax, %r13
movq %r12, %rdi
callq 0x12d2
movq (%rax), %rax
movq %r13, 0x1a0(%rax)
movq %r13, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x34f6
movq %r13, %rdi
callq 0x1040
movl 0xc(%rsp), %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movl $0x1, %r13d
jmp 0x3471
movq %r12, %rdi
callq 0x1b11
movq 0x10(%rsp), %rax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movl $0x6, %eax
jmp 0x35db
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x354e
movq (%rbp), %rdi
callq 0x18f4
testl %eax, %eax
je 0x3570
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x354e
jmp 0x352c
movq (%rbp), %rdi
callq 0x129c
movl $0x7, %r14d
cmpl $-0x1, %eax
je 0x35d8
movq (%rbp), %rdi
leaq 0x6f09(%rip), %rdx      # 0xa498
movl $0xc8, %esi
movl $0x78, %ecx
callq 0x216e
movq %rax, %rbx
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x35cf
movq %rbx, %rdi
callq 0x1040
jmp 0x35d8
movq (%rbp), %rdi
callq 0x1b11
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq