LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: grow_primitives
void grow_primitives(void) {
	Max_prims += PRIM_SEG_SIZE;
	Primitives = (PRIM *) realloc(Primitives, sizeof(PRIM) * Max_prims);
	if (Primitives == NULL)
		fatal("grow_primitives: out of physical memory");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xa0ba(%rip), %eax      # 0x28c24
addl $0x100, %eax            # imm = 0x100
movl %eax, 0xa0af(%rip)      # 0x28c24
movq 0x9b5c(%rip), %rdi      # 0x286d8
movslq 0xa0a1(%rip), %rax      # 0x28c24
imulq $0x28, %rax, %rsi
callq 0x3190
movq %rax, 0x9b45(%rip)      # 0x286d8
cmpq $0x0, 0x9b3d(%rip)      # 0x286d8
jne 0x1eba9
leaq 0x296d(%rip), %rdi      # 0x21511
callq 0x3c70
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: add_primitives
void add_primitives(char *name, PRIM *p) {
	cell	v, n, new;
	int	i;

	if (name) {
		n = symbol_ref(name);
		set(box_value(S_extensions), node(n, box_value(S_extensions)));
	}
	for (i=0; p && p && p[i].name; i++) {
		if (Callcc_magic < 0 && !strcmp(p[i].name, "call/cc"))
			Callcc_magic = Last_prim;
		v = symbol_ref(p[i].name);
		n = new_atom(Last_prim, NIL);
		n = new_atom(T_PRIMITIVE, n);
		if (Last_prim >= Max_prims)
			grow_primitives();
		memcpy(&Primitives[Last_prim], &p[i], sizeof(PRIM));
		Last_prim++;
		Environment = extend(v, n, Environment);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1ec0b
movq -0x8(%rbp), %rdi
callq 0x9420
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x99f1(%rip), %rax      # 0x285d0
movq 0xa02a(%rip), %rcx      # 0x28c10
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x99d0(%rip), %rax      # 0x285d0
movq 0xa009(%rip), %rcx      # 0x28c10
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x2c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x2d(%rbp)
je 0x1ec43
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x2d(%rbp)
je 0x1ec43
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x1ec4f
jmp 0x1ed53
cmpq $0x0, 0x9fa1(%rip)      # 0x28bf8
jge 0x1ec8a
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
leaq 0x245d(%rip), %rsi      # 0x210cf
callq 0x3120
cmpl $0x0, %eax
jne 0x1ec8a
movslq 0x9f9d(%rip), %rax      # 0x28c20
movq %rax, 0x9f6e(%rip)      # 0x28bf8
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x9420
movq %rax, -0x18(%rbp)
movslq 0x9f74(%rip), %rdi      # 0x28c20
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq $-0x1d, %rdi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movl 0x9f40(%rip), %eax      # 0x28c20
cmpl 0x9f3e(%rip), %eax      # 0x28c24
jl 0x1eced
callq 0x1eb60
movq 0x99e4(%rip), %rdi      # 0x286d8
movslq 0x9f25(%rip), %rax      # 0x28c20
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x2c(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
movl $0x28, %edx
callq 0x3140
movl 0x9eff(%rip), %eax      # 0x28c20
addl $0x1, %eax
movl %eax, 0x9ef6(%rip)      # 0x28c20
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x93df(%rip), %rdx      # 0x28118
callq 0x127f0
movq %rax, 0x93d3(%rip)      # 0x28118
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1ec12
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: init_extensions
void init_extensions(void) {
	cell	e, n;
	char	initproc[TOKEN_LENGTH+2];
	char	*s;
	char	*mlite = "mlite";

	e = box_value(S_extensions);
	while (mlite || e != NIL) {
		s = mlite? mlite: string(car(e));
		if (strlen(s)*2+1 >= TOKEN_LENGTH)
			fatal("init_extension(): procedure name too long");
		sprintf(initproc, "%s:%s", s, s);
		n = find_symbol(initproc);
		if (n != NIL) {
			n = node(n, NIL);
			eval(n);
		}
		e = mlite? e: cdr(e);
		mlite = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
leaq 0x202b(%rip), %rax      # 0x214ad
movq %rax, -0x430(%rbp)
movq 0x9140(%rip), %rax      # 0x285d0
movq 0x9779(%rip), %rcx      # 0x28c10
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movb $0x1, %al
cmpq $0x0, -0x430(%rbp)
movb %al, -0x431(%rbp)
jne 0x1f4bf
cmpq $-0x1, -0x8(%rbp)
setne %al
movb %al, -0x431(%rbp)
movb -0x431(%rbp), %al
testb $0x1, %al
jne 0x1f4ce
jmp 0x1f5ed
cmpq $0x0, -0x430(%rbp)
je 0x1f4e8
movq -0x430(%rbp), %rax
movq %rax, -0x440(%rbp)
jmp 0x1f517
movq 0x9109(%rip), %rax      # 0x285f8
movq 0x90da(%rip), %rcx      # 0x285d0
movq 0x8c83(%rip), %rdx      # 0x28180
movq -0x8(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x440(%rbp)
movq -0x440(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rdi
callq 0x30a0
shlq %rax
addq $0x1, %rax
cmpq $0x400, %rax            # imm = 0x400
jb 0x1f54c
leaq 0x2078(%rip), %rdi      # 0x215bf
callq 0x3c70
leaq -0x420(%rbp), %rdi
movq -0x428(%rbp), %rdx
movq -0x428(%rbp), %rcx
leaq 0x2081(%rip), %rsi      # 0x215e9
movb $0x0, %al
callq 0x3200
leaq -0x420(%rbp), %rdi
callq 0x9330
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x1f5a5
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19ed0
cmpq $0x0, -0x430(%rbp)
je 0x1f5bc
movq -0x8(%rbp), %rax
movq %rax, -0x448(%rbp)
jmp 0x1f5d2
movq 0x900d(%rip), %rax      # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x448(%rbp)
movq -0x448(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x430(%rbp)
jmp 0x1f49f
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: usage
void usage(int quit) {
	pr("Usage: mlite [-h?] [-i name] [-gqv] [-f prog [args]] ");
	pr("[-m size[m]]");
	nl();
	pr("             [-l prog] [-t count] [-d image] [-- [args]]");
	nl();
	if (quit) bye(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x1fdd(%rip), %rdi      # 0x215ef
callq 0x3ab0
leaq 0x2007(%rip), %rdi      # 0x21625
callq 0x3ab0
leaq 0x23a9(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x1ffc(%rip), %rdi      # 0x21632
callq 0x3ab0
leaq 0x2391(%rip), %rdi      # 0x219d3
callq 0x3ab0
cmpl $0x0, -0x4(%rbp)
je 0x1f657
movl $0x1, %edi
callq 0x3b10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: long_usage
void long_usage() {
	nl();
	usage(0);
	nl();
	pr("-h              display this summary (also -?)"); nl();
	pr("-i name         base name of image file (must be first option!)");
	nl();
	pr("-i -            ignore image, load mlite.m instead"); nl();
	pr("-d file         dump heap image to file and exit"); nl();
	pr("-f file [args]  run program and exit (implies -q)"); nl();
	pr("-g              print GC summaries (-gg = more)"); nl();
	pr("-l file         load program (may be repeated)"); nl();
	pr("-m n[m]         set memory limit to nK (or nM) nodes"); nl();
	pr("-q              be quiet (no banner, no prompt, exit on errors)");
	nl();
	pr("-t n            list up to N procedures in call traces"); nl();
	pr("-v              print version and exit"); nl();
	pr("-- [args]       pass subsequent arguments to program"); nl();
	nl();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2368(%rip), %rdi      # 0x219d3
callq 0x3ab0
xorl %edi, %edi
callq 0x1f600
leaq 0x2355(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x1fe1(%rip), %rdi      # 0x2166b
callq 0x3ab0
leaq 0x233d(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x1ff8(%rip), %rdi      # 0x2169a
callq 0x3ab0
leaq 0x2325(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x2020(%rip), %rdi      # 0x216da
callq 0x3ab0
leaq 0x230d(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x203b(%rip), %rdi      # 0x2170d
callq 0x3ab0
leaq 0x22f5(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x2054(%rip), %rdi      # 0x2173e
callq 0x3ab0
leaq 0x22dd(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x206e(%rip), %rdi      # 0x21770
callq 0x3ab0
leaq 0x22c5(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x2086(%rip), %rdi      # 0x217a0
callq 0x3ab0
leaq 0x22ad(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x209d(%rip), %rdi      # 0x217cf
callq 0x3ab0
leaq 0x2295(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x20ba(%rip), %rdi      # 0x21804
callq 0x3ab0
leaq 0x227d(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x20e2(%rip), %rdi      # 0x21844
callq 0x3ab0
leaq 0x2265(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x2101(%rip), %rdi      # 0x2187b
callq 0x3ab0
leaq 0x224d(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x2110(%rip), %rdi      # 0x218a2
callq 0x3ab0
leaq 0x2235(%rip), %rdi      # 0x219d3
callq 0x3ab0
leaq 0x2229(%rip), %rdi      # 0x219d3
callq 0x3ab0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: get_size_k
long get_size_k(char *s) {
	int	c;
	long	n;

	c = s[strlen(s)-1];
	n = atol(s);
	if (isdigit(c))
		;
	else if (c == 'M' || c == 'm')
		n *= 1024L;
	else
		usage(1);
	return n * 1024;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31b0
movq %rax, -0x18(%rbp)
callq 0x3240
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x1fab8
jmp 0x1fade
cmpl $0x4d, -0xc(%rbp)
je 0x1fac4
cmpl $0x6d, -0xc(%rbp)
jne 0x1fad2
movq -0x18(%rbp), %rax
shlq $0xa, %rax
movq %rax, -0x18(%rbp)
jmp 0x1fadc
movl $0x1, %edi
callq 0x1f600
jmp 0x1fade
movq -0x18(%rbp), %rax
shlq $0xa, %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3sm/dev.c
// Function: dev_read
int
dev_read(void *buf, size_t len)
{
	char tmp[4096];
	struct ps3sm_header *hdr;
	int ret;

	if (fd < 0)
		return (-1);

	hdr = (struct ps3sm_header *) tmp;

	while (1) {
		ret = read(fd, hdr, sizeof(*hdr));
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	while (1) {
		ret = read(fd, hdr + 1, hdr->payload_length);
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	if (len > (sizeof(*hdr) + hdr->payload_length))
		len = sizeof(*hdr) + hdr->payload_length;

	memcpy(buf, tmp, len);

	return (len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, 0x3bf6(%rip)      # 0x51a0
jge 0x15b8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16ae
leaq -0x1020(%rbp), %rax
movq %rax, -0x1028(%rbp)
movl 0x3bd4(%rip), %edi      # 0x51a0
movq -0x1028(%rbp), %rsi
movl $0x10, %edx
callq 0x1080
movl %eax, -0x102c(%rbp)
cmpl $0x0, -0x102c(%rbp)
jge 0x1604
callq 0x1030
cmpl $0xb, (%rax)
je 0x1602
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16ae
jmp 0x1611
cmpl $0x0, -0x102c(%rbp)
jle 0x160f
jmp 0x1613
jmp 0x1611
jmp 0x15c6
jmp 0x1615
movl 0x3b85(%rip), %edi      # 0x51a0
movq -0x1028(%rbp), %rsi
addq $0x10, %rsi
movq -0x1028(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x1080
movl %eax, -0x102c(%rbp)
cmpl $0x0, -0x102c(%rbp)
jge 0x165b
callq 0x1030
cmpl $0xb, (%rax)
je 0x1659
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16ae
jmp 0x1668
cmpl $0x0, -0x102c(%rbp)
jle 0x1666
jmp 0x166a
jmp 0x1668
jmp 0x1615
movq -0x18(%rbp), %rax
movq -0x1028(%rbp), %rcx
movl 0x4(%rcx), %ecx
addq $0x10, %rcx
cmpq %rcx, %rax
jbe 0x1693
movq -0x1028(%rbp), %rax
movl 0x4(%rax), %eax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10b0
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3sm/cmd/cmd_ctl_led.c
// Function: cmd_ctl_led_exec
int
cmd_ctl_led_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3sm_ctl_led ctl_led;
	uint32_t arg1, arg2, arg3, arg4;
	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' || arg3 > 0xff)
		return (CMD_EINVAL);

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

	ps3sm_init_header(PS3SM_HDR(&ctl_led),
	    sizeof(ctl_led) - sizeof(struct ps3sm_header),
	    PS3SM_SID_CTL_LED, 0);

	ctl_led.version = PS3SM_CTL_LED_VERSION;
	ctl_led.arg1 = arg1;
	ctl_led.arg2 = arg2;
	ctl_led.arg3 = arg3;
	ctl_led.arg4 = arg4;

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

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movl %eax, -0x3c(%rbp)
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1700
cmpl $0xff, -0x3c(%rbp)
jbe 0x170c
movl $0x2, -0x4(%rbp)
jmp 0x180a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movl %eax, -0x40(%rbp)
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1737
cmpl $0xff, -0x40(%rbp)
jbe 0x1743
movl $0x2, -0x4(%rbp)
jmp 0x180a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movl %eax, -0x44(%rbp)
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x176e
cmpl $0xff, -0x44(%rbp)
jbe 0x177a
movl $0x2, -0x4(%rbp)
jmp 0x180a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movl %eax, -0x48(%rbp)
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x17a5
cmpl $0xff, -0x48(%rbp)
jbe 0x17ae
movl $0x2, -0x4(%rbp)
jmp 0x180a
leaq -0x38(%rbp), %rdi
movl $0x8, %esi
movl $0xc, %edx
xorl %ecx, %ecx
callq 0x1820
movb $0x1, -0x28(%rbp)
movl -0x3c(%rbp), %eax
movb %al, -0x27(%rbp)
movl -0x40(%rbp), %eax
movb %al, -0x26(%rbp)
movl -0x44(%rbp), %eax
movb %al, -0x24(%rbp)
movl -0x48(%rbp), %eax
movb %al, -0x23(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x18, %esi
callq 0x1540
movl %eax, -0x54(%rbp)
movslq -0x54(%rbp), %rax
cmpq $0x18, %rax
je 0x1803
movl $0x3, -0x4(%rbp)
jmp 0x180a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3sm/cmd/../ps3sm_msg.h
// Function: ps3sm_init_header
static inline void
ps3sm_init_header(struct ps3sm_header *hdr, uint32_t payload_length,
    uint16_t sid, uint32_t tag)
{
	hdr->version = PS3SM_VERSION;
	hdr->length = sizeof(struct ps3sm_header);
	hdr->payload_length = payload_length;
	hdr->sid = sid;
	hdr->tag = tag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rax
movb $0x10, 0x1(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movw -0xe(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3sm/cmd/cmd_get_inter_lpar_param.c
// Function: cmd_get_inter_lpar_param_exec
int
cmd_get_inter_lpar_param_exec(int cmdc, struct cmd **cmdv, int argc, char **argv)
{
	struct ps3sm_get_inter_lpar_param get_inter_lpar_param;
	struct ps3sm_get_inter_lpar_param_reply get_inter_lpar_param_reply;
	uint32_t arg;
	char *endptr;
	int ret;

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

	ps3sm_init_header(PS3SM_HDR(&get_inter_lpar_param),
	    sizeof(get_inter_lpar_param) - sizeof(struct ps3sm_header),
	    PS3SM_SID_GET_INTER_LPAR_PARAM, 0);

	get_inter_lpar_param.version = PS3SM_GET_INTER_LPAR_PARAM_VERSION;
	get_inter_lpar_param.arg = arg;

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

	ret = dev_read(&get_inter_lpar_param_reply, sizeof(get_inter_lpar_param_reply));
	if (ret < 0)
		return (CMD_EIO);

	if (arg == 1)
		hex_fprintf(stdout, (char *) get_inter_lpar_param_reply.u.arg1.data,
		    sizeof(PS3SM_HDR(&get_inter_lpar_param_reply)->payload_length));
	else
		fprintf(stdout, "%02x %02x %02x %02x %08x %016llx\n",
		    get_inter_lpar_param_reply.u.arg2.val1,
		    get_inter_lpar_param_reply.u.arg2.val2,
		    get_inter_lpar_param_reply.u.arg2.val3,
		    get_inter_lpar_param_reply.u.arg2.val4,
		    get_inter_lpar_param_reply.u.arg2.val5,
		    get_inter_lpar_param_reply.u.arg2.val6);

	return (CMD_EOK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x670, %rsp            # imm = 0x670
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x658(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movl %eax, -0x64c(%rbp)
movq -0x658(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x18c5
cmpl $0x1, -0x64c(%rbp)
jb 0x18c5
cmpl $0x2, -0x64c(%rbp)
jbe 0x18d1
movl $0x2, -0x4(%rbp)
jmp 0x19c7
leaq -0x38(%rbp), %rdi
movl $0x8, %esi
movl $0x9, %edx
xorl %ecx, %ecx
callq 0x19e0
movb $0x1, -0x28(%rbp)
movl -0x64c(%rbp), %eax
movb %al, -0x27(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x18, %esi
callq 0x1540
movl %eax, -0x65c(%rbp)
movslq -0x65c(%rbp), %rax
cmpq $0x18, %rax
je 0x1920
movl $0x3, -0x4(%rbp)
jmp 0x19c7
leaq -0x648(%rbp), %rdi
movl $0x610, %esi            # imm = 0x610
callq 0x1590
movl %eax, -0x65c(%rbp)
cmpl $0x0, -0x65c(%rbp)
jge 0x1949
movl $0x3, -0x4(%rbp)
jmp 0x19c7
cmpl $0x1, -0x64c(%rbp)
jne 0x1973
movq 0x366f(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
leaq -0x648(%rbp), %rsi
addq $0x10, %rsi
movl $0x4, %edx
callq 0x23b0
jmp 0x19c0
movq 0x364e(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
movzbl -0x638(%rbp), %edx
movzbl -0x637(%rbp), %ecx
movzbl -0x636(%rbp), %r8d
movzbl -0x635(%rbp), %r9d
movl -0x634(%rbp), %r10d
movq -0x630(%rbp), %rax
leaq 0x1772(%rip), %rsi      # 0x3122
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x10a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x670, %rsp            # imm = 0x670
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x58(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movb %al, -0x4d(%rbp)
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1a70
movzbl -0x4d(%rbp), %eax
cmpl $0x1, %eax
jle 0x1a7c
movl $0x2, -0x4(%rbp)
jmp 0x1b0c
leaq -0x34(%rbp), %rdi
movl $0x4, %esi
movl $0xd, %edx
xorl %ecx, %ecx
callq 0x1b20
movb $0x1, -0x24(%rbp)
movb -0x4d(%rbp), %al
movb %al, -0x23(%rbp)
leaq -0x34(%rbp), %rdi
movl $0x14, %esi
callq 0x1540
movl %eax, -0x5c(%rbp)
movslq -0x5c(%rbp), %rax
cmpq $0x14, %rax
je 0x1abf
movl $0x3, -0x4(%rbp)
jmp 0x1b0c
leaq -0x4c(%rbp), %rdi
movl $0x18, %esi
callq 0x1590
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
jge 0x1adf
movl $0x3, -0x4(%rbp)
jmp 0x1b0c
movq 0x34e2(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
movzbl -0x38(%rbp), %edx
movzbl -0x37(%rbp), %eax
imull $0x64, %eax, %ecx
sarl $0x8, %ecx
leaq 0x168f(%rip), %rsi      # 0x318d
movb $0x0, %al
callq 0x10a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movl %eax, -0x3c(%rbp)
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1bb0
cmpl $0xff, -0x3c(%rbp)
jbe 0x1bbc
movl $0x2, -0x4(%rbp)
jmp 0x1c74
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movl %eax, -0x40(%rbp)
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1be7
cmpl $0xff, -0x40(%rbp)
jbe 0x1bf3
movl $0x2, -0x4(%rbp)
jmp 0x1c74
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movl %eax, -0x44(%rbp)
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1c1e
movl $0x2, -0x4(%rbp)
jmp 0x1c74
leaq -0x38(%rbp), %rdi
movl $0x8, %esi
movl $0x15, %edx
xorl %ecx, %ecx
callq 0x1c80
movb $0x1, -0x28(%rbp)
movl -0x3c(%rbp), %eax
movb %al, -0x27(%rbp)
movl -0x40(%rbp), %eax
movb %al, -0x26(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x18, %esi
callq 0x1540
movl %eax, -0x54(%rbp)
movslq -0x54(%rbp), %rax
cmpq $0x18, %rax
je 0x1c6d
movl $0x3, -0x4(%rbp)
jmp 0x1c74
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movl %eax, -0x3c(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1d10
movl $0x2, -0x4(%rbp)
jmp 0x1d57
leaq -0x38(%rbp), %rdi
movl $0x8, %edx
xorl %ecx, %ecx
movl %edx, %esi
callq 0x1d60
movb $0x1, -0x28(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x18, %esi
callq 0x1540
movl %eax, -0x4c(%rbp)
movslq -0x4c(%rbp), %rax
cmpq $0x18, %rax
je 0x1d50
movl $0x3, -0x4(%rbp)
jmp 0x1d57
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movb %al, -0x39(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movb %al, -0x3a(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x58(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movb %al, -0x3b(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1e2b
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1e2b
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1e37
movl $0x2, -0x4(%rbp)
jmp 0x1ecb
movzbl -0x3a(%rbp), %eax
cmpl $0x2, %eax
jne 0x1e75
movzbl -0x3b(%rbp), %eax
cmpl $0x33, %eax
jl 0x1e54
movzbl -0x3b(%rbp), %eax
cmpl $0xfc, %eax
jle 0x1e75
movq 0x319d(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x13cb(%rip), %rsi      # 0x3230
movb $0x0, %al
callq 0x10a0
movl $0x2, -0x4(%rbp)
jmp 0x1ecb
leaq -0x38(%rbp), %rdi
movl $0x8, %esi
movl $0x19, %edx
xorl %ecx, %ecx
callq 0x1ee0
movb $0x1, -0x28(%rbp)
movb -0x39(%rbp), %al
movb %al, -0x27(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x26(%rbp)
movb -0x3b(%rbp), %al
movb %al, -0x25(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x18, %esi
callq 0x1540
movl %eax, -0x5c(%rbp)
movslq -0x5c(%rbp), %rax
cmpq $0x18, %rax
je 0x1ec4
movl $0x3, -0x4(%rbp)
jmp 0x1ecb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x9, 0x10(%rsp)
jae 0x1226
movl 0x10(%rsp), %edi
callq 0x1150
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x11e3
jmp 0x1202
leaq 0xecc(%rip), %rdi       # 0x20b6
leaq 0xed1(%rip), %rsi       # 0x20c2
movl $0x1c, %edx
leaq 0xed3(%rip), %rcx       # 0x20d0
callq 0x1040
movl 0x10(%rsp), %esi
movq 0x8(%rsp), %rdx
leaq 0xecd(%rip), %rdi       # 0x20df
movb $0x0, %al
callq 0x1030
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x11c4
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x0, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x70(%rbp)
callq 0xdf70
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x68(%rbp)
callq 0xdf90
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x60(%rbp)
callq 0xdf90
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x58(%rbp)
callq 0xdf90
movq -0x48(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x50(%rbp)
callq 0xdf90
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xbbe8
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xdfe0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xdfb0
jmp 0xbbba
leaq -0x30(%rbp), %rdi
callq 0xe000
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbb7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xe000
jmp 0xbc86
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xbc31
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
movslq -0x40(%rbp), %rsi
callq 0xe060
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0xe080
jmp 0xbc16
jmp 0xbc18
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xbbef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xbc86
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0xe110
jmp 0xbc44
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
movslq -0x10(%rbp), %rsi
callq 0xe110
jmp 0xbc57
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
movslq -0x10(%rbp), %rsi
callq 0xe110
jmp 0xbc6a
movq -0x48(%rbp), %rdi
addq $0x70, %rdi
movslq -0x10(%rbp), %rsi
callq 0xe110
jmp 0xbc7d
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xe1a0
movq -0x58(%rbp), %rdi
callq 0xe1a0
movq -0x60(%rbp), %rdi
callq 0xe1a0
movq -0x68(%rbp), %rdi
callq 0xe1a0
movq -0x70(%rbp), %rdi
callq 0xe200
movq -0x38(%rbp), %rdi
callq 0x3570
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x18ee0
movq -0x58(%rbp), %rdi
addq $0x48, %rdi
leaq -0x30(%rbp), %rsi
callq 0x3380
leaq -0x30(%rbp), %rdi
callq 0x31b0
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x19100
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
leaq -0x50(%rbp), %rsi
callq 0x3380
leaq -0x50(%rbp), %rdi
callq 0x31b0
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0x3200
movq -0x58(%rbp), %rdi
movl %eax, 0x10(%rdi)
addq $0x68, %rdi
callq 0x19330
movq -0x58(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x68, %rsi
callq 0x19350
movl %eax, %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0x80(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl (%rax), %esi
leaq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1a3e0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x1a3e0
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x20, %esi
callq 0x1a3e0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movl 0xc(%rax), %esi
callq 0x1a3e0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movl 0x40(%rax), %esi
callq 0x1a3e0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movl 0x44(%rax), %esi
callq 0x1a3e0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movl 0x48(%rax), %esi
callq 0x1a3e0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movl 0x4c(%rax), %esi
callq 0x1a3e0
movq -0x58(%rbp), %rsi
addq $0x10, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x10b70
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl 0xc(%rax), %ecx
xorl %edx, %edx
callq 0x1a4e0
jmp 0xdbd6
leaq -0x30(%rbp), %rdi
callq 0xe000
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xe000
movq -0x38(%rbp), %rdi
callq 0x3570
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movss (%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0x4(%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0x8(%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0xc(%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0x10(%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0x14(%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0x18(%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0x1c(%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0x20(%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0x24(%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x28(%rax), %esi
callq 0x1a3e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x2c(%rax), %esi
callq 0x1a3e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x30(%rax), %esi
callq 0x1a3e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x34(%rax), %esi
callq 0x1a3e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x38(%rax), %esi
callq 0x1a3e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movss (%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0x4(%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movss 0x8(%rax), %xmm0
callq 0x1a460
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0xc(%rax), %esi
callq 0x1a3e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %esi
callq 0x1a3e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x14(%rax), %esi
callq 0x1a3e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x18(%rax), %esi
callq 0x1a3e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x1c(%rax), %esi
callq 0x1a3e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x20(%rax), %esi
callq 0x1a3e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xdfe0
movq -0x38(%rbp), %rdi
movl $0x4, %esi
callq 0xe080
jmp 0x11801
movq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x119f0
jmp 0x11810
leaq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0x11750
movsbl (%rax), %eax
shll $0x18, %eax
movl %eax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x11750
movq %rax, %rcx
movl -0x50(%rbp), %eax
movsbl (%rcx), %ecx
andl $0xff, %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x11750
movq %rax, %rcx
movl -0x4c(%rbp), %eax
movsbl (%rcx), %ecx
andl $0xff, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11750
movq %rax, %rcx
movl -0x48(%rbp), %eax
movsbl (%rcx), %ecx
andl $0xff, %ecx
orl %ecx, %eax
movl %eax, -0x44(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe000
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe000
movq -0x28(%rbp), %rdi
callq 0x3570
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/0x3f00[P]PhotonCpp/./PhotonInputStream.h
// Function: PhotonInputStream::readFloat()
float readFloat() {
		float res;
		int32_t value = readInt();
		res = *reinterpret_cast<float*>(&value);
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x117d0
movl %eax, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %rcx, %rdi
addq $0x28, %rdi
movl (%rcx), %eax
imull 0x4(%rcx), %eax
movslq %eax, %rsi
callq 0xe110
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x12142
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0x10(%rbp), %rsi
callq 0x11750
movq -0x28(%rbp), %rdi
movsbl (%rax), %eax
andl $0xff, %eax
movl %eax, -0x2c(%rbp)
addq $0x10, %rdi
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x11750
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movsbl (%rcx), %ecx
andl $0xff, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
andl $0xf800, %eax           # imm = 0xF800
shll $0x8, %eax
movl -0x14(%rbp), %ecx
andl $0x7c0, %ecx            # imm = 0x7C0
shll $0x5, %ecx
orl %ecx, %eax
movl -0x14(%rbp), %ecx
andl $0x1f, %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x14(%rbp), %eax
andl $0x20, %eax
cmpl $0x20, %eax
jne 0x120f9
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x11750
movq -0x28(%rbp), %rdi
movsbl (%rax), %eax
andl $0xff, %eax
movl %eax, -0x30(%rbp)
addq $0x10, %rdi
movl -0x10(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rsi
callq 0x11750
movq %rax, %rcx
movl -0x30(%rbp), %eax
movsbl (%rcx), %ecx
andl $0xf, %ecx
shll $0x8, %ecx
orl %ecx, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x120fb
cmpl $0x0, -0x1c(%rbp)
jle 0x12132
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
addq $0x28, %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %eax, %rsi
callq 0x11770
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x120fb
jmp 0x12134
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12007
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3420
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3420
movq -0x30(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x40(%rbp)
callq 0x13260
movq -0x30(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x38(%rbp)
callq 0x12b00
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xac(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xb0(%rax)
movq -0x10(%rbp), %rdi
callq 0x118d0
movss %xmm0, -0x28(%rbp)
jmp 0x12be7
movq -0x30(%rbp), %rax
movss -0x28(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x118d0
movss %xmm0, -0x54(%rbp)
jmp 0x12c04
movq -0x30(%rbp), %rax
movss -0x54(%rbp), %xmm0
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x118d0
movss %xmm0, -0x58(%rbp)
jmp 0x12c22
movq -0x30(%rbp), %rax
movss -0x58(%rbp), %xmm0
movss %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x117d0
movl %eax, -0x5c(%rbp)
jmp 0x12c3e
movq -0x30(%rbp), %rax
movl -0x5c(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x117d0
movl %eax, -0x60(%rbp)
jmp 0x12c56
movq -0x30(%rbp), %rax
movl -0x60(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x117d0
movl %eax, -0x64(%rbp)
jmp 0x12c6e
movq -0x30(%rbp), %rax
movl -0x64(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0x117d0
movl %eax, -0x68(%rbp)
jmp 0x12c86
movq -0x30(%rbp), %rax
movl -0x68(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x117d0
movl %eax, -0x6c(%rbp)
jmp 0x12c9e
movq -0x30(%rbp), %rax
movl -0x6c(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rdi
callq 0x117d0
movl %eax, -0x70(%rbp)
jmp 0x12cb6
movq -0x30(%rbp), %rax
movl -0x70(%rbp), %ecx
movl %ecx, 0x20(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xdeb0
movq -0x40(%rbp), %rdi
callq 0x13280
movq -0x48(%rbp), %rdi
callq 0x31b0
movq -0x50(%rbp), %rdi
callq 0x31b0
movq -0x20(%rbp), %rdi
callq 0x3570
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x10, %rdi
callq 0x18e10
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x18e30
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x18e30
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x18e30
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x18e30
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)