LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/method_info.cpp
// Function: method_info::load_body(abc_stream&)
void method_info::load_body(abc_stream &stream) {
	stream >> max_stack;
	stream >> local_count;
	stream >> init_scope_depth;
	stream >> max_scope_depth;
	uint32_t count;
	stream >> count;
	code = Array<uint8_t>(count);
	for (unsigned i = 0; i < count; ++i) {
		stream >> code[i];
	}
	stream >> count;
	exceptions = Array<exception_info>(count);
	for (unsigned i = 0; i < count; ++i) {
		exceptions[i].load(stream);
	}
	stream >> count;
	traits = Array<traits_info>(count);
	for (unsigned i = 0; i < count; ++i) {
		traits[i].load(stream);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x68(%rbp)
movq -0x10(%rbp), %rdi
addq $0x24, %rsi
callq 0x43d0
movq -0x68(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
callq 0x43d0
movq -0x68(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x2c, %rsi
callq 0x43d0
movq -0x68(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x30, %rsi
callq 0x43d0
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x43d0
movl -0x14(%rbp), %esi
leaq -0x28(%rbp), %rdi
callq 0x71b0
movq -0x68(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x40(%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x70e3
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x38, %rdi
movl -0x2c(%rbp), %esi
callq 0x7200
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x4370
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x70ac
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x43d0
movl -0x14(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x7220
movq -0x68(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x50(%rax)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x7146
movq -0x68(%rbp), %rdi
addq $0x48, %rdi
movl -0x44(%rbp), %esi
callq 0x7290
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6d60
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x7117
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x43d0
movl -0x14(%rbp), %esi
leaq -0x58(%rbp), %rdi
callq 0x5440
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x60(%rax)
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x71a9
movq -0x68(%rbp), %rdi
addq $0x58, %rdi
movl -0x5c(%rbp), %esi
callq 0x54b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x8af0
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x717a
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/script_info.cpp
// Function: script_info::load(abc_stream&)
void script_info::load(abc_stream &stream) {
	uint32_t index;
	stream >> index;
	init = abc_file::get_method(index);
	uint32_t count;
	stream >> count;
	traits = Array<traits_info>(count);
	for (unsigned i = 0; i < count; ++i) {
		traits[i].load(stream);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x43d0
movl -0x14(%rbp), %edi
callq 0x3670
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x43d0
movl -0x18(%rbp), %esi
leaq -0x28(%rbp), %rdi
callq 0x5440
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x761a
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0x2c(%rbp), %esi
callq 0x54b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x8af0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x75eb
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/swf_file.cpp
// Function: swf_file::get_tags(unsigned short, swf_tag*, unsigned int)
void swf_file::get_tags(uint16_t kind, swf_tag *out_tags, uint32_t n) {
	unsigned i = 0;
	for (auto item : tags) {
		if (item.kind == kind) {
			out_tags[i] = item;
			++i;
			if (i == n)
				return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0x20(%rbp)
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7ec0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7ef0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7f20
testb $0x1, %al
jne 0x7cda
jmp 0x7d3d
leaq -0x30(%rbp), %rdi
callq 0x7f60
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movzwl -0x40(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x7d30
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x7d2e
jmp 0x7d3d
jmp 0x7d30
jmp 0x7d32
leaq -0x30(%rbp), %rdi
callq 0x7f80
jmp 0x7cc7
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/swf_tag.cpp
// Function: swf_tag::swf_tag(unsigned char**)
swf_tag::swf_tag(uint8_t **raw) {
	handle = *raw;
	uint16_t header = conv_copy<uint16_t>(handle);
	kind = header >> 6;
	length = header & 63;
	if (length == 0x3f) {
		length = conv_copy<uint32_t>(handle);
	}
	*raw += (handle - *raw) + length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
callq 0x8a90
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, -0x12(%rbp)
movzwl -0x12(%rbp), %ecx
sarl $0x6, %ecx
movw %cx, 0x8(%rax)
movzwl -0x12(%rbp), %ecx
andl $0x3f, %ecx
movl %ecx, 0xc(%rax)
cmpl $0x3f, 0xc(%rax)
jne 0x8a5f
movq -0x20(%rbp), %rdi
callq 0x8ac0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
movl 0xc(%rax), %eax
addq %rax, %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_dumper.cpp
// Function: executer::pattern_1()
void executer::pattern_1() {
	for ( ; ; ) {
		if (step() == OP_getlocal_1
			&& step() == OP_getlocal_0
			&& step() == OP_getlocal_0) {
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b00
movzbl %al, %eax
cmpl $0xd1, %eax
jne 0x8fcf
movq -0x10(%rbp), %rdi
callq 0x2b00
movzbl %al, %eax
cmpl $0xd0, %eax
jne 0x8fcf
movq -0x10(%rbp), %rdi
callq 0x2b00
movzbl %al, %eax
cmpl $0xd0, %eax
jne 0x8fcf
jmp 0x8fd1
jmp 0x8f94
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_dumper.cpp
// Function: go(char**)
void go(char **bufs) {
	method_info *info = abc_file::get_class(0)->static_ctor;
	executer exec(info->code.begin());
	exec.step_until(OP_findproperty);
	uint32_t op;
	exec >> op;
	assert(op == OP_pushstring);
	uint32_t index;
	exec >> index;
	COP = abc_file::get_str(index);

	info = abc_file::get_class(0)->ctor;
	exec = executer(info->code.begin());
	for (int i = 0; i < 12; ++i) {
		exec.pattern_1();
		char buf[50];
		int j = 0;
		buf[j] = exec.call_prop(abc_file::get_class(0));
		++j;
		do {
			// usually is OP_getlocal_0
			exec.step();
			buf[j] = exec.call_prop(abc_file::get_class(0));
			++j;
		} while (exec.step() == OP_add);
		bufs[i] = make_global(buf);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
callq 0x36a0
movq 0x78(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x5560
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x98e0
leaq -0x20(%rbp), %rdi
movl $0x5e, %esi
callq 0x2d60
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x43d0
cmpl $0x2c, -0x24(%rbp)
je 0x909d
movl $0x18, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
leaq 0x1639(%rip), %rsi      # 0xa68f
leaq 0x1640(%rip), %rdx      # 0xa69d
movl $0x3e, %ecx
callq 0x2f30
jmp 0x9069
movq -0x90(%rbp), %rdi
leaq 0x5d11(%rip), %rsi      # 0xed88
xorl %eax, %eax
movl %eax, %edx
callq 0x22b0
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x2110
jmp 0x91c0
jmp 0x909f
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x43d0
movl -0x38(%rbp), %edi
callq 0x3510
movq %rax, 0x692d(%rip)      # 0xf9e8
xorl %edi, %edi
callq 0x36a0
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x5560
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x98e0
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x4c(%rbp)
cmpl $0xc, -0x4c(%rbp)
jge 0x91b7
leaq -0x20(%rbp), %rdi
callq 0x8f80
movl $0x0, -0x84(%rbp)
xorl %edi, %edi
callq 0x36a0
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x8d50
movb %al, %cl
movslq -0x84(%rbp), %rax
movb %cl, -0x80(%rbp,%rax)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2b00
xorl %edi, %edi
callq 0x36a0
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x8d50
movb %al, %cl
movslq -0x84(%rbp), %rax
movb %cl, -0x80(%rbp,%rax)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2b00
movzbl %al, %eax
cmpl $0xa0, %eax
je 0x9146
leaq -0x80(%rbp), %rdi
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x90fa
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_dumper.cpp
// Function: make_global(char*)
static char *make_global(char *old) {
	size_t len = strlen(old);
	++len;
	char *buf = new char[len];
	memcpy(buf, old, len);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2140
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/twiddles.c
// Function: twiddles_init
void twiddles_init(unsigned l, unsigned N)
{
#ifdef SHORT_TW
  l = N / 8 + 1;
#endif
#ifndef NO_TW
  twiddles = aligned_alloc(256, l * sizeof(complex double));
  assert(twiddles);

  for (unsigned i = 0; i < l; i++)
    twiddles[i] = cexp(-2 * M_PI * I * i / N);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %esi
shlq $0x4, %rsi
movl $0x100, %edi            # imm = 0x100
callq 0x10a0
movq %rax, 0x48d0(%rip)      # 0x6078
cmpq $0x0, 0x48c8(%rip)      # 0x6078
je 0x17b4
jmp 0x17d3
leaq 0x28b5(%rip), %rdi      # 0x4070
leaq 0x28b7(%rip), %rsi      # 0x4079
movl $0x21, %edx
leaq 0x28b6(%rip), %rcx      # 0x4084
callq 0x1070
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x1853
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x2866(%rip), %xmm2     # 0x4058
movaps %xmm0, %xmm1
mulsd %xmm2, %xmm1
movsd 0x285f(%rip), %xmm2     # 0x4060
mulsd %xmm2, %xmm0
movl -0x8(%rbp), %eax
cvtsi2sd %rax, %xmm2
divsd %xmm2, %xmm1
divsd %xmm2, %xmm0
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x1050
movq 0x4843(%rip), %rax      # 0x6078
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x17da
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/twiddles.c
// Function: twiddles_sr_init
void twiddles_sr_init(unsigned l, unsigned N)
{
#ifndef NO_TW
# ifdef SHORT_TW
  twiddles_init(N / 8, N);
# else
  twiddles = aligned_alloc(256, l * sizeof(complex double));
  twiddles_sr = aligned_alloc(256, l * sizeof(complex double));
  assert(twiddles);

  for (unsigned i = 0; i < l; i++)
    {
      twiddles[i]    = cexp(-2 * M_PI * I * i     / N);
      twiddles_sr[i] = cexp(-2 * M_PI * I * i * 3 / N);
    }

# endif
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %esi
shlq $0x4, %rsi
movl $0x100, %edi            # imm = 0x100
callq 0x10a0
movq %rax, 0x47f0(%rip)      # 0x6078
movl -0x4(%rbp), %eax
movl %eax, %esi
shlq $0x4, %rsi
movl $0x100, %edi            # imm = 0x100
callq 0x10a0
movq %rax, 0x47de(%rip)      # 0x6080
cmpq $0x0, 0x47ce(%rip)      # 0x6078
je 0x18ae
jmp 0x18cd
leaq 0x27bb(%rip), %rdi      # 0x4070
leaq 0x27bd(%rip), %rsi      # 0x4079
movl $0x30, %edx
leaq 0x27eb(%rip), %rcx      # 0x40b3
callq 0x1070
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x19cd
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x2768(%rip), %xmm2     # 0x4058
movsd %xmm2, -0x40(%rbp)
movaps %xmm0, %xmm1
mulsd %xmm2, %xmm1
movsd 0x275c(%rip), %xmm2     # 0x4060
movsd %xmm2, -0x38(%rbp)
mulsd %xmm2, %xmm0
movl -0x8(%rbp), %eax
cvtsi2sd %rax, %xmm2
divsd %xmm2, %xmm1
divsd %xmm2, %xmm0
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x1050
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
movq 0x4731(%rip), %rax      # 0x6078
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
movsd %xmm0, (%rax,%rcx)
movsd %xmm1, 0x8(%rax,%rcx)
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm0
movaps %xmm0, %xmm1
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
movsd 0x26f4(%rip), %xmm2     # 0x4068
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm0
movl -0x8(%rbp), %eax
cvtsi2sd %rax, %xmm2
divsd %xmm2, %xmm1
divsd %xmm2, %xmm0
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x1050
movq 0x46d4(%rip), %rax      # 0x6080
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x18d4
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/cp_input_lut.c
// Function: cp_input_lut_init
void cp_input_lut_init(unsigned N)
{
  unsigned log2_N = 31 - clz32(N);
  unsigned r = 32 - log2_N;
  uint32_t p = 0, q = 0;

  cp_input_lut = malloc(N / 2 * sizeof(*cp_input_lut));
  assert(cp_input_lut);

  for (uint32_t hn, h = 0; h < N; h = hn) {

    /* eval binary carry sequence */
    hn = h + 2;
    unsigned c = 30 - clz32(h ^ hn);

    /* input indices */
    unsigned i0 = (p - q) >> r;

    cp_input_lut[h / 2] = i0;

    /* advance to next input index */
    uint32_t m2 = 0x20000000 >> c;
    uint32_t m1 = m2 - 1;
    uint32_t m  = p & m2;
    q = (q & m1) | m;
    p = (p & m1) | ((m ^ m2) << 1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
bsrl %eax, %ecx
xorl $0x1f, %ecx
movl $0x1f, %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movl $0x20, %eax
subl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x1080
movq %rax, 0x4638(%rip)      # 0x6088
cmpq $0x0, 0x4630(%rip)      # 0x6088
je 0x1a5c
jmp 0x1a7b
leaq 0x2682(%rip), %rdi      # 0x40e5
leaq 0x2688(%rip), %rsi      # 0x40f2
movl $0x20, %edx
leaq 0x268b(%rip), %rcx      # 0x4101
callq 0x1070
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x1b18
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
xorl -0x18(%rbp), %eax
bsrl %eax, %ecx
xorl $0x1f, %ecx
movl $0x1e, %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
subl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
shrl %cl, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
movq 0x45c3(%rip), %rax      # 0x6088
movl -0x1c(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %ecx
movl $0x20000000, %eax       # imm = 0x20000000
sarl %cl, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x10(%rbp), %eax
andl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl -0x2c(%rbp), %eax
orl -0x30(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
andl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
xorl -0x28(%rbp), %ecx
shll %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a82
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/sr_input_lut.c
// Function: sr_input_lut_init
void sr_input_lut_init(unsigned N)
{
  unsigned log2_N = 31 - clz32(N);

  sr_input_lut = malloc(N / 2 * sizeof(*sr_input_lut));
  assert(sr_input_lut);

  sr_lut_dr(log2_N, 0, log2_N, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
bsrl %eax, %ecx
xorl $0x1f, %ecx
movl $0x1f, %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x1080
movq %rax, 0x4519(%rip)      # 0x6090
cmpq $0x0, 0x4511(%rip)      # 0x6090
je 0x1b83
jmp 0x1ba2
leaq 0x259c(%rip), %rdi      # 0x4126
leaq 0x25a2(%rip), %rsi      # 0x4133
movl $0x37, %edx
leaq 0x25a5(%rip), %rcx      # 0x4142
callq 0x1070
movl -0x8(%rbp), %edi
movl -0x8(%rbp), %edx
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x1bc0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/sr_input_lut.c
// Function: sr_lut_dr
static void
sr_lut_dr(unsigned log2_N, unsigned out,
	   unsigned l, unsigned i)
{
  unsigned is = 1 << (log2_N - l);
  unsigned os = 1 << (l - 2);

  switch (l)
    {
    case 1:
      sr_input_lut[out / 2] = i;
      break;

    case 2:
      sr_lut_dr(log2_N, out, 1, i);
      sr_input_lut[1 + out / 2] = i + is;
      break;

    default:
      sr_lut_dr(log2_N, out, l - 1, i);
      sr_lut_dr(log2_N, out + os * 2, l - 2, i + is);
      sr_lut_dr(log2_N, out + 3 * os, l - 2, i + 3 * is);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl -0xc(%rbp), %ecx
subl %ecx, %eax
movb %al, %cl
movl $0x1, %eax
movl %eax, %edx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, -0x14(%rbp)
movb -0xc(%rbp), %cl
addb $-0x2, %cl
shll %cl, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x1c0e
jmp 0x1c04
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x1c27
jmp 0x1c56
movl -0x10(%rbp), %edx
movq 0x4478(%rip), %rax      # 0x6090
movl -0x8(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x1ca8
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0x10(%rbp), %ecx
movl $0x1, %edx
callq 0x1bc0
movl -0x10(%rbp), %edx
addl -0x14(%rbp), %edx
movq 0x4449(%rip), %rax      # 0x6090
movl -0x8(%rbp), %ecx
shrl %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x1ca8
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
subl $0x1, %edx
movl -0x10(%rbp), %ecx
callq 0x1bc0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0x18(%rbp), %eax
shll %eax
addl %eax, %esi
movl -0xc(%rbp), %edx
subl $0x2, %edx
movl -0x10(%rbp), %ecx
addl -0x14(%rbp), %ecx
callq 0x1bc0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
imull $0x3, -0x18(%rbp), %eax
addl %eax, %esi
movl -0xc(%rbp), %edx
subl $0x2, %edx
movl -0x10(%rbp), %ecx
imull $0x3, -0x14(%rbp), %eax
addl %eax, %ecx
callq 0x1bc0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/sr_sched_lut.c
// Function: sr_sched_lut_init
void sr_sched_lut_init(unsigned N)
{
  unsigned log2_N = 31 - clz32(N);
  unsigned i, j;

  static const unsigned jacobsthal[32] = {
    0,1,1,3,5,11,21,43,85,171,341,683,1365,2731,5461,10923,21845,
    43691,87381,174763,349525,699051,1398101,2796203,5592405,
    11184811,22369621,44739243,89478485,178956971,357913941
  };

  sr_sched_cnt = malloc(log2_N * sizeof(*sr_sched_cnt));
  assert(sr_sched_cnt);

  for (i = 0; i < log2_N; i++)
    sr_sched_cnt[i] = jacobsthal[log2_N - i];

  sr_sched_off = malloc((sr_sched_cnt[0] + 1) * sizeof(*sr_sched_off));
  assert(sr_sched_off);

  for (j = i = 0; j < sr_sched_cnt[0]; i++)
    if (__builtin_clz(i ^ (i + 1)) & 1)
      sr_sched_off[j++] = i;

  sr_sched_off[j] = N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
bsrl %eax, %ecx
xorl $0x1f, %ecx
movl $0x1f, %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x1080
movq %rax, 0x4395(%rip)      # 0x6098
cmpq $0x0, 0x438d(%rip)      # 0x6098
je 0x1d0f
jmp 0x1d2e
leaq 0x24da(%rip), %rdi      # 0x41f0
leaq 0x24e0(%rip), %rsi      # 0x41fd
movl $0x25, %edx
leaq 0x24e3(%rip), %rcx      # 0x420c
callq 0x1070
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x1d69
movl -0x8(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2422(%rip), %rax      # 0x4170
movl (%rax,%rcx,4), %edx
movq 0x4340(%rip), %rax      # 0x6098
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1d35
movq 0x4328(%rip), %rax      # 0x6098
movl (%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x1080
movq %rax, 0x4317(%rip)      # 0x60a0
cmpq $0x0, 0x430f(%rip)      # 0x60a0
je 0x1d95
jmp 0x1db4
leaq 0x2495(%rip), %rdi      # 0x4231
leaq 0x245a(%rip), %rsi      # 0x41fd
movl $0x2b, %edx
leaq 0x245d(%rip), %rcx      # 0x420c
callq 0x1070
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq 0x42cc(%rip), %rcx      # 0x6098
cmpl (%rcx), %eax
jae 0x1e10
movl -0xc(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
xorl %ecx, %eax
bsrl %eax, %eax
xorl $0x1f, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1e03
movl -0xc(%rbp), %edx
movq 0x42ad(%rip), %rax      # 0x60a0
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x1e05
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1dc2
movl -0x4(%rbp), %edx
movq 0x4286(%rip), %rax      # 0x60a0
movl -0x10(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/./cp_bf.h
// Function: cp_dit_bf_0
static inline void
cp_dit_bf_0(unsigned s,
         complex double * restrict out)
{
  complex double a = out[0];
  complex double b = out[s];
  complex double c = out[s * 2];
  complex double d = out[s * 3];

  double rsu = creal(c) + creal(d);
  double rsb = creal(c) - creal(d);
  double isu = cimag(c) + cimag(d);
  double isb = cimag(c) - cimag(d);

  out[0]     = CMPLX(creal(a) + rsu, cimag(a) + isu);
  out[s]     = CMPLX(creal(b) + isb, cimag(b) - rsb);
  out[s * 2] = CMPLX(creal(a) - rsu, cimag(a) - isu);
  out[s * 3] = CMPLX(creal(b) - isb, cimag(b) + rsb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shll %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x40(%rbp)
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
imull $0x3, -0x4(%rbp), %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x50(%rbp)
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
addsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x40(%rbp), %xmm0
subsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x38(%rbp), %xmm0
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x20(%rbp), %xmm1
addsd -0x58(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
addsd -0x68(%rbp), %xmm0
movsd %xmm1, -0x80(%rbp)
movsd %xmm0, -0x78(%rbp)
movsd -0x80(%rbp), %xmm1
movsd -0x78(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
movsd -0x30(%rbp), %xmm1
addsd -0x70(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
subsd -0x60(%rbp), %xmm0
movsd %xmm1, -0x90(%rbp)
movsd %xmm0, -0x88(%rbp)
movsd -0x90(%rbp), %xmm1
movsd -0x88(%rbp), %xmm0
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm1
subsd -0x58(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
subsd -0x68(%rbp), %xmm0
movsd %xmm1, -0xa0(%rbp)
movsd %xmm0, -0x98(%rbp)
movsd -0xa0(%rbp), %xmm1
movsd -0x98(%rbp), %xmm0
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shll %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
movsd -0x30(%rbp), %xmm1
subsd -0x70(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
addsd -0x60(%rbp), %xmm0
movsd %xmm1, -0xb0(%rbp)
movsd %xmm0, -0xa8(%rbp)
movsd -0xb0(%rbp), %xmm1
movsd -0xa8(%rbp), %xmm0
movq -0x10(%rbp), %rax
imull $0x3, -0x4(%rbp), %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_19/undcl.c
// Function: get_next_token
int get_next_token(void)
{
  skip_blanks();
  skip_comments();
  skip_blanks();

  int c = getc(stdin);
  if (c == '(')
  {
    skip_blanks();

    c = getc(stdin);
    if (c == ')')
    {
      strcpy(token, "()");
      return next_token = PARENS;
    }
    ungetc(c, stdin);

    return next_token = PAREN_OPEN;
  }
  else if (c == '[')
  {
    skip_blanks();
    get_name(token, MAX_TOKEN_LEN);
    skip_blanks();

    c = getc(stdin);
    if (c == ']')
    {
      return next_token = BRACKETS;
    }
    ungetc(c, stdin);

    return next_token = BRACKET_OPEN;
  }
  else if (isalpha(c))
  {
    ungetc(c, stdin);
    get_name(token, MAX_TOKEN_LEN);
    return next_token = NAME;
  }

  return next_token = c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1500
callq 0x1560
callq 0x1500
movq 0x2c42(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movl %eax, -0x8(%rbp)
cmpl $0x28, -0x8(%rbp)
jne 0x141d
callq 0x1500
movq 0x2c25(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movl %eax, -0x8(%rbp)
cmpl $0x29, -0x8(%rbp)
jne 0x13f5
leaq 0x309d(%rip), %rdi      # 0x4470
leaq 0xc62(%rip), %rsi       # 0x203c
callq 0x1030
movl $0x1, 0x30eb(%rip)      # 0x44d4
movl $0x1, -0x4(%rbp)
jmp 0x14f1
movl -0x8(%rbp), %edi
movq 0x2be1(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x1060
movl $0x28, 0x30c3(%rip)     # 0x44d4
movl $0x28, -0x4(%rbp)
jmp 0x14f1
cmpl $0x5b, -0x8(%rbp)
jne 0x1491
callq 0x1500
leaq 0x3041(%rip), %rdi      # 0x4470
movl $0x64, %esi
callq 0x1660
callq 0x1500
movq 0x2b9b(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movl %eax, -0x8(%rbp)
cmpl $0x5d, -0x8(%rbp)
jne 0x146c
movl $0x2, 0x3074(%rip)      # 0x44d4
movl $0x2, -0x4(%rbp)
jmp 0x14f1
movl -0x8(%rbp), %edi
movq 0x2b6a(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x1060
movl $0x5b, 0x304c(%rip)     # 0x44d4
movl $0x5b, -0x4(%rbp)
jmp 0x14f1
callq 0x10a0
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x14e1
movl -0x8(%rbp), %edi
movq 0x2b2b(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x1060
leaq 0x2fac(%rip), %rdi      # 0x4470
movl $0x64, %esi
callq 0x1660
movl $0x0, 0x2ffc(%rip)      # 0x44d4
movl $0x0, -0x4(%rbp)
jmp 0x14f1
jmp 0x14e3
jmp 0x14e5
movl -0x8(%rbp), %eax
movl %eax, 0x2fe6(%rip)      # 0x44d4
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_19/undcl.c
// Function: skip_comments
void skip_comments()
{
  int c = getc(stdin);
  if (c == '/')
  {
    c = getc(stdin);
    if (c == '/')
    {
      while ((c = getc(stdin)) != '\n' && c != EOF)
        ;
    }
    else if (c == '*')
    {
      while ((c = getc(stdin)) != '*' && c != EOF)
        ;
      c = getc(stdin);
      if (c == '/')
      {
        ungetc('\n', stdin);
        return;
      }
    }
  }
  ungetc(c, stdin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x2a71(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movl %eax, -0x4(%rbp)
cmpl $0x2f, -0x4(%rbp)
jne 0x1642
movq 0x2a55(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movl %eax, -0x4(%rbp)
cmpl $0x2f, -0x4(%rbp)
jne 0x15d3
jmp 0x159e
movq 0x2a3b(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movl %eax, %ecx
movl %ecx, -0x4(%rbp)
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x5(%rbp)
je 0x15c6
cmpl $-0x1, -0x4(%rbp)
setne %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x15cf
jmp 0x15d1
jmp 0x159e
jmp 0x1640
cmpl $0x2a, -0x4(%rbp)
jne 0x163e
jmp 0x15db
movq 0x29fe(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movl %eax, %ecx
movl %ecx, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x2a, %ecx
movb %al, -0x6(%rbp)
je 0x1603
cmpl $-0x1, -0x4(%rbp)
setne %al
movb %al, -0x6(%rbp)
movb -0x6(%rbp), %al
testb $0x1, %al
jne 0x160c
jmp 0x160e
jmp 0x15db
movq 0x29cb(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movl %eax, -0x4(%rbp)
cmpl $0x2f, -0x4(%rbp)
jne 0x163c
movq 0x29b3(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1060
jmp 0x1654
jmp 0x163e
jmp 0x1640
jmp 0x1642
movl -0x4(%rbp), %edi
movq 0x2994(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_19/undcl.c
// Function: get_name
void get_name(char *dest, const size_t max_len)
{
  int c;
  size_t i = 0;
  while ((isalnum(c = getc(stdin)) || c == '_') && i < max_len)
  {
    dest[i++] = c;
  }
  dest[i] = '\0';
  ungetc(c, stdin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x10a0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x2955(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x16b6
xorl %eax, %eax
cmpl $0x5f, -0x14(%rbp)
movb %al, -0x29(%rbp)
jne 0x16c4
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x16cd
jmp 0x16ea
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x1678
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %edi
movq 0x28e0(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x1060
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swfdump.c
// Function: dump_tag_raw_remainder
static void dump_tag_raw_remainder(swf_reader *swf) {
	unsigned char temp[16];
	int i,rd;

	rd = swf_reader_read(swf,temp,sizeof(temp));
	if (rd > 0) {
		printf("    REMAINDER: ");
		for (i=0;i < rd;i++) printf("%02x ",temp[i]);
		for (;i < 16;i++) printf("   ");
		for (i=0;i < rd;i++) {
			if (temp[i] >= 0x20 && temp[i] < 0x7F)
				printf("%c",temp[i]);
			else
				printf(".");
		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x3190
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0x1ee8
leaq 0x6b0b(%rip), %rdi      # 0x892d
movb $0x0, %al
callq 0x1060
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x1e5a
movslq -0x24(%rbp), %rax
movzbl -0x20(%rbp,%rax), %esi
leaq 0x6af5(%rip), %rdi      # 0x893d
movb $0x0, %al
callq 0x1060
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1e30
jmp 0x1e5c
cmpl $0x10, -0x24(%rbp)
jge 0x1e7b
leaq 0x664e(%rip), %rdi      # 0x84b7
movb $0x0, %al
callq 0x1060
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1e5c
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x1eda
movslq -0x24(%rbp), %rax
movzbl -0x20(%rbp,%rax), %eax
cmpl $0x20, %eax
jl 0x1ebf
movslq -0x24(%rbp), %rax
movzbl -0x20(%rbp,%rax), %eax
cmpl $0x7f, %eax
jge 0x1ebf
movslq -0x24(%rbp), %rax
movzbl -0x20(%rbp,%rax), %esi
leaq 0x6a8d(%rip), %rdi      # 0x8943
movb $0x0, %al
callq 0x1060
jmp 0x1ecd
leaq 0x6a80(%rip), %rdi      # 0x8946
movb $0x0, %al
callq 0x1060
jmp 0x1ecf
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1e82
leaq 0x6f5d(%rip), %rdi      # 0x8e3e
movb $0x0, %al
callq 0x1060
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swfdump.c
// Function: dump_FILLSTYLEARRAY
static int dump_FILLSTYLEARRAY(swf_reader *swf,unsigned int tag_code) {
	swf_FILLSTYLEARRAY_read nfo;
	unsigned int i;

	if (swf_reader_read_FILLSTYLEARRAY_header(swf,&nfo,tag_code)) {
		printf("    FILLSTYLEARRAY (unable to read)\n");
		return -1;
	}
	printf("    FILLSTYLEARRAY FillStyleCount=%u\n",nfo.FillStyleCount);
	for (i=0;i < nfo.FillStyleCount;i++) {
		if (dump_FILLSTYLE(swf,&nfo,i+1)) return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x98(%rbp), %rsi
callq 0x5410
cmpl $0x0, %eax
je 0x1f31
leaq 0x6a27(%rip), %rdi      # 0x8948
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1fa2
movzwl -0x96(%rbp), %esi
leaq 0x6a2e(%rip), %rdi      # 0x896d
movb $0x0, %al
callq 0x1060
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
movzwl -0x96(%rbp), %ecx
cmpl %ecx, %eax
jae 0x1f9b
movq -0x10(%rbp), %rdi
movl -0x9c(%rbp), %edx
addl $0x1, %edx
leaq -0x98(%rbp), %rsi
callq 0x2780
cmpl $0x0, %eax
je 0x1f88
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1fa2
jmp 0x1f8a
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x1f50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swfdump.c
// Function: dump_LINESTYLEARRAY
static int dump_LINESTYLEARRAY(swf_reader *swf,unsigned int tag_code) {
	swf_LINESTYLEARRAY_read nfo;
	unsigned int i;

	if (swf_reader_read_LINESTYLEARRAY_header(swf,&nfo,tag_code)) {
		printf("    LINESTYLEARRAY (unable to read)\n");
		return -1;
	}
	printf("    LINESTYLEARRAY LineStyleCount=%u\n",nfo.LineStyleCount);
	if (tag_code == swftag_DefineShape4) {
		for (i=0;i < nfo.LineStyleCount;i++) {
			if (dump_LINESTYLE2(swf,&nfo,i+1)) return -1;
		}
	}
	else {
		for (i=0;i < nfo.LineStyleCount;i++) {
			if (dump_LINESTYLE(swf,&nfo,i+1)) return -1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0xa8(%rbp), %rsi
callq 0x59b0
cmpl $0x0, %eax
je 0x1ff4
leaq 0x6b06(%rip), %rdi      # 0x8ae7
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20c4
movzwl -0xa6(%rbp), %esi
leaq 0x6b0a(%rip), %rdi      # 0x8b0c
movb $0x0, %al
callq 0x1060
cmpl $0x53, -0x14(%rbp)
jne 0x2066
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
movzwl -0xa6(%rbp), %ecx
cmpl %ecx, %eax
jae 0x2064
movq -0x10(%rbp), %rdi
movl -0xac(%rbp), %edx
addl $0x1, %edx
leaq -0xa8(%rbp), %rsi
callq 0x2a10
cmpl $0x0, %eax
je 0x2051
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20c4
jmp 0x2053
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x2019
jmp 0x20bd
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
movzwl -0xa6(%rbp), %ecx
cmpl %ecx, %eax
jae 0x20bb
movq -0x10(%rbp), %rdi
movl -0xac(%rbp), %edx
addl $0x1, %edx
leaq -0xa8(%rbp), %rsi
callq 0x2bc0
cmpl $0x0, %eax
je 0x20a8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20c4
jmp 0x20aa
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x2070
jmp 0x20bd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swfdump.c
// Function: dump_MATRIX
static void dump_MATRIX(swf_MATRIX *m) {
	printf("HasScale=%u [%u-bit] HasRotate=%u [%u-bit] Translation=(%.3f,%.3f) [%u-bit]",
		m->HasScale,
		m->NScaleBits,
		m->HasRotate,
		m->NRotateBits,
		(double)m->TranslateX / SWF_TWIPS_PER_PIXEL,
		(double)m->TranslateY / SWF_TWIPS_PER_PIXEL,
		m->NTranslateBits);
	if (m->HasScale)
		printf(" Scale=(%.6f,%.6f)",
			(double)m->ScaleX / 0x10000,
			(double)m->ScaleY / 0x10000);
	if (m->HasRotate)
		printf(" Rotate=(skew %.6f,%.6f)",
			(double)m->RotateSkew0 / 0x10000,
			(double)m->RotateSkew1 / 0x10000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %esi
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %edx
movq -0x8(%rbp), %rax
movb (%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %r8d
movq -0x8(%rbp), %rax
cvtsi2sdl 0x14(%rax), %xmm0
movsd 0x5ada(%rip), %xmm1     # 0x8010
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdl 0x18(%rax), %xmm1
movsd 0x5ac5(%rip), %xmm2     # 0x8010
divsd %xmm2, %xmm1
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %r9d
leaq 0x694c(%rip), %rdi      # 0x8eab
movb $0x2, %al
callq 0x1060
movq -0x8(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x25ae
movq -0x8(%rbp), %rax
cvtsi2sdl 0x4(%rax), %xmm0
movsd 0x5a91(%rip), %xmm1     # 0x8018
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm1
movsd 0x5a7c(%rip), %xmm2     # 0x8018
divsd %xmm2, %xmm1
leaq 0x6950(%rip), %rdi      # 0x8ef7
movb $0x2, %al
callq 0x1060
movq -0x8(%rbp), %rax
movb (%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x25f8
movq -0x8(%rbp), %rax
cvtsi2sdl 0xc(%rax), %xmm0
movsd 0x5a47(%rip), %xmm1     # 0x8018
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdl 0x10(%rax), %xmm1
movsd 0x5a32(%rip), %xmm2     # 0x8018
divsd %xmm2, %xmm1
leaq 0x6919(%rip), %rdi      # 0x8f0a
movb $0x2, %al
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swfdump.c
// Function: dump_tag_raw_text
static void dump_tag_raw_text(swf_reader *swf) {
	unsigned char tmp[81];
	int rd;

	printf("    RAW TEXT:\n");
	while ((rd=swf_reader_read(swf,tmp,80)) > 0) {
		tmp[rd] = 0;
		printf("        %s\n",tmp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x6910(%rip), %rdi      # 0x8f23
movb $0x0, %al
callq 0x1060
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x50, %edx
callq 0x3190
movl %eax, -0x64(%rbp)
cmpl $0x0, %eax
jle 0x2651
movslq -0x64(%rbp), %rax
movb $0x0, -0x60(%rbp,%rax)
leaq -0x60(%rbp), %rsi
leaq 0x68ea(%rip), %rdi      # 0x8f32
movb $0x0, %al
callq 0x1060
jmp 0x261a
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swfdump.c
// Function: dump_tag_raw
static void dump_tag_raw(swf_reader *swf,swf_tag *tag) {
	unsigned char temp[16];
	int i,rd;

	if (swf_reader_seek(swf,tag->absolute_offset))
		return;

	rd = swf_reader_read(swf,temp,sizeof(temp));
	if (rd > 0) {
		printf("    RAW: ");
		for (i=0;i < rd;i++) printf("%02x ",temp[i]);
		for (;i < 16;i++) printf("   ");
		for (i=0;i < rd;i++) {
			if (temp[i] >= 0x20 && temp[i] < 0x7F)
				printf("%c",temp[i]);
			else
				printf(".");
		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3130
cmpl $0x0, %eax
je 0x268b
jmp 0x2777
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x3190
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0x2777
leaq 0x688d(%rip), %rdi      # 0x8f3e
movb $0x0, %al
callq 0x1060
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x26e9
movslq -0x24(%rbp), %rax
movzbl -0x20(%rbp,%rax), %esi
leaq 0x6266(%rip), %rdi      # 0x893d
movb $0x0, %al
callq 0x1060
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x26bf
jmp 0x26eb
cmpl $0x10, -0x24(%rbp)
jge 0x270a
leaq 0x5dbf(%rip), %rdi      # 0x84b7
movb $0x0, %al
callq 0x1060
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x26eb
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x2769
movslq -0x24(%rbp), %rax
movzbl -0x20(%rbp,%rax), %eax
cmpl $0x20, %eax
jl 0x274e
movslq -0x24(%rbp), %rax
movzbl -0x20(%rbp,%rax), %eax
cmpl $0x7f, %eax
jge 0x274e
movslq -0x24(%rbp), %rax
movzbl -0x20(%rbp,%rax), %esi
leaq 0x61fe(%rip), %rdi      # 0x8943
movb $0x0, %al
callq 0x1060
jmp 0x275c
leaq 0x61f1(%rip), %rdi      # 0x8946
movb $0x0, %al
callq 0x1060
jmp 0x275e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2711
leaq 0x66ce(%rip), %rdi      # 0x8e3e
movb $0x0, %al
callq 0x1060
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swfdump.c
// Function: dump_GRADIENT
static void dump_GRADIENT(swf_GRADIENT *g) {
	swf_GRADRECORD *r;
	unsigned int i;

	printf("          SpreadMode=%u InterpolationMode=%u NumGradients=%u FocalPoint=%.3f\n",
		g->SpreadMode,
		g->InterpolationMode,
		g->NumGradients,
		(double)g->FocalPoint / 256);
	for (i=0;i < g->NumGradients;i++) {
		r = &g->GradientRecords[i];

		printf("            Ratio=%.3f Color=RGBA %u / %u / %u / %u\n",
			(double)r->Ratio / 255,
			r->Color.Red,
			r->Color.Green,
			r->Color.Blue,
			r->Color.Alpha);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %edx
movb %dl, %cl
movl %edx, %esi
andl $0x3, %esi
shrl $0x2, %edx
andl $0x3, %edx
shrb $0x4, %cl
movzbl %cl, %ecx
movswl 0x52(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd 0x5692(%rip), %xmm1     # 0x8008
divsd %xmm1, %xmm0
leaq 0x60e3(%rip), %rdi      # 0x8a64
movb $0x1, %al
callq 0x1060
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movb (%rcx), %cl
shrb $0x4, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jae 0x2a07
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
leaq (%rcx,%rcx,4), %rcx
leaq 0x1(%rax,%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cvtsi2sd %eax, %xmm0
movsd 0x5657(%rip), %xmm1     # 0x8020
divsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %esi
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %edx
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %ecx
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %r8d
leaq 0x60bd(%rip), %rdi      # 0x8ab2
movb $0x1, %al
callq 0x1060
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x298f
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swfdump.c
// Function: dump_LINESTYLE2
static int dump_LINESTYLE2(swf_reader *swf,swf_LINESTYLEARRAY_read *nfo,unsigned int i) {
	if (swf_reader_read_LINESTYLE2(swf,nfo)) return -1;

	printf("      LineStyle2[%u]: Width=%.3f StartCapStyle=%u JoinStyle=%u HasFillFlag=%u NoHScaleFlag=%u\n"
               "          NoVScaleFlag=%u PixelHintingFlag=%u NoClose=%u EndCapStyle=%u MiterLimitFactor=%u\n",
	       i,(double)nfo->Width / SWF_TWIPS_PER_PIXEL,
	       nfo->StartCapStyle,
	       nfo->JoinStyle,
	       nfo->HasFillFlag,
	       nfo->NoHScaleFlag,
	       nfo->NoVScaleFlag,
	       nfo->PixelHintingFlag,
	       nfo->NoClose,
	       nfo->EndCapStyle,
	       nfo->MiterLimitFactor);
	if (nfo->HasFillFlag)
		dump_FILLSTYLE_nr(&nfo->FillType,i);
	else {
		printf("        Color: %s %u / %u / %u / %u\n",
			nfo->color_rgba ? "RGBA" : "RGB(A)",
			nfo->Color.Red,
			nfo->Color.Green,
			nfo->Color.Blue,
			nfo->Color.Alpha);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movl %edx, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5500
cmpl $0x0, %eax
je 0x2a44
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ba5
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rax
movzwl 0x4(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd 0x55b5(%rip), %xmm1     # 0x8010
divsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movw 0xa(%rax), %ax
andw $0x3, %ax
movzwl %ax, %edx
movq -0x28(%rbp), %rax
movw 0xa(%rax), %ax
shrw $0x2, %ax
andw $0x3, %ax
movzwl %ax, %ecx
movq -0x28(%rbp), %rax
movw 0xa(%rax), %ax
shrw $0x4, %ax
andw $0x1, %ax
movzwl %ax, %r8d
movq -0x28(%rbp), %rax
movw 0xa(%rax), %ax
shrw $0x5, %ax
andw $0x1, %ax
movzwl %ax, %r9d
movq -0x28(%rbp), %rax
movw 0xa(%rax), %ax
shrw $0x6, %ax
andw $0x1, %ax
movzwl %ax, %r14d
movq -0x28(%rbp), %rax
movw 0xa(%rax), %ax
shrw $0x7, %ax
andw $0x1, %ax
movzwl %ax, %ebx
movq -0x28(%rbp), %rax
movw 0xa(%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %r11d
movq -0x28(%rbp), %rax
movw 0xa(%rax), %ax
shrw $0x9, %ax
andw $0x3, %ax
movzwl %ax, %r10d
movq -0x28(%rbp), %rax
movzwl 0xc(%rax), %eax
leaq 0x602b(%rip), %rdi      # 0x8b32
movl %r14d, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movb $0x1, %al
callq 0x1060
movq -0x28(%rbp), %rax
movw 0xa(%rax), %ax
shrw $0x4, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x2b4e
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movl -0x2c(%rbp), %esi
callq 0x27d0
jmp 0x2b9e
movq -0x28(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %ecx
leaq 0x5e84(%rip), %rsi      # 0x89e4
leaq 0x5e78(%rip), %rax      # 0x89df
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movq -0x28(%rbp), %rax
movzbl 0x6(%rax), %edx
movq -0x28(%rbp), %rax
movzbl 0x7(%rax), %ecx
movq -0x28(%rbp), %rax
movzbl 0x8(%rax), %r8d
movq -0x28(%rbp), %rax
movzbl 0x9(%rax), %r9d
leaq 0x5e23(%rip), %rdi      # 0x89ba
movb $0x0, %al
callq 0x1060
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swfdump.c
// Function: dump_LINESTYLE
static int dump_LINESTYLE(swf_reader *swf,swf_LINESTYLEARRAY_read *nfo,unsigned int i) {
	if (swf_reader_read_LINESTYLE(swf,nfo)) return -1;

	printf("      LineStyle[%u]: Width=%.3f\n",i,(double)nfo->Width / SWF_TWIPS_PER_PIXEL);
	printf("        Color: %s %u / %u / %u / %u\n",
		nfo->color_rgba ? "RGBA" : "RGB(A)",
		nfo->Color.Red,
		nfo->Color.Green,
		nfo->Color.Blue,
		nfo->Color.Alpha);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54a0
cmpl $0x0, %eax
je 0x2bf1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2c71
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd 0x5408(%rip), %xmm1     # 0x8010
divsd %xmm1, %xmm0
leaq 0x5fda(%rip), %rdi      # 0x8bed
movb $0x1, %al
callq 0x1060
movq -0x18(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %ecx
leaq 0x5db8(%rip), %rsi      # 0x89e4
leaq 0x5dac(%rip), %rax      # 0x89df
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movq -0x18(%rbp), %rax
movzbl 0x6(%rax), %edx
movq -0x18(%rbp), %rax
movzbl 0x7(%rax), %ecx
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %r8d
movq -0x18(%rbp), %rax
movzbl 0x9(%rax), %r9d
leaq 0x5d57(%rip), %rdi      # 0x89ba
movb $0x0, %al
callq 0x1060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)