LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/FirestonnneTFM[P]tfm_key_parser/src/class_info.cpp
// Function: class_info::get_trait_by_name(multiname_info*)
traits_info *class_info::get_trait_by_name(multiname_info *key) {
	auto search = ordered_trait.find(key);
	if(search != ordered_trait.end()) {
		return search->second;
	} else {
		std::cout << "name = " << key->str << std::endl;
		fatal("Could not find trait by name");
	}
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %rcx
addq $0x10, %rdi
movq %rdi, %rax
testq %rcx, %rcx
je 0x3b2e
movq %rdi, %rax
xorl %edx, %edx
cmpq %rbx, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x3b17
movq %rdi, %rcx
cmpq %rdi, %rax
je 0x3b41
cmpq %rbx, 0x20(%rax)
cmovaq %rdi, %rax
movq %rax, %rcx
cmpq %rdi, %rcx
je 0x3b4c
movq 0x28(%rcx), %rax
popq %rbx
retq
movq 0x547d(%rip), %rdi      # 0x8fd0
leaq 0x25e8(%rip), %rsi      # 0x6142
callq 0x21c0
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
movl $0x18, %edi
callq 0x2100
movl $0x99, (%rax)
leaq 0x25a5(%rip), %rcx      # 0x612f
movq %rcx, 0x8(%rax)
leaq 0x25b5(%rip), %rcx      # 0x614a
movq %rcx, 0x10(%rax)
leaq 0x51f0(%rip), %rsi      # 0x8d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x22d0
// File: /workspace/github_c_makefile_star2_O1/FirestonnneTFM[P]tfm_key_parser/src/exception_info.cpp
// Function: exception_info::load(abc_stream&)
void exception_info::load(abc_stream &stream) {
	stream >> from;
	stream >> to;
	stream >> target;
	uint32_t str_index;
	stream >> str_index;
	exc_type = abc_file::get_str(str_index);
	stream >> str_index;
	var_name = abc_file::get_str(str_index);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x3088
leaq 0x4(%rbx), %rsi
movq %r14, %rdi
callq 0x3088
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3088
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3088
movl (%r15), %edi
callq 0x2e5a
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3088
movl (%r15), %edi
callq 0x2e5a
movq %rax, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/FirestonnneTFM[P]tfm_key_parser/src/int_stack.cpp
// Function: int_stack::int_stack(int)
int_stack::int_stack(int n) {
	if (n != 0) {
		arr = new int32_t[n];
	} else {
		arr = nullptr;
	}
	ptr = arr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x41bf
movslq %esi, %rax
shlq $0x2, %rax
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
jmp 0x41c1
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/FirestonnneTFM[P]tfm_key_parser/src/method_info.cpp
// Function: method_info::load_header(abc_stream&)
void method_info::load_header(abc_stream &stream) {
	uint32_t param_count;
	stream >> param_count;
	uint32_t index;	
	stream >> index;
	return_type = abc_file::get_multiname(index);
	param_type = Array<multiname_info *>(param_count);
	for (unsigned i = 0; i < param_count; ++i) {
		stream >> index;
		param_type[i] = abc_file::get_multiname(index);
	}
	stream >> index;
	str = abc_file::get_str(index);
	stream >> flags;
	if (flags & HAS_OPTIONAL) {
		uint32_t count;
		stream >> count;
		uint32_t dummy1;
		uint8_t dummy2;
		for (unsigned i = 0; i < count; ++i) {
			stream >> dummy1;
			stream >> dummy2;
		}
	}
	if (flags & HAS_PARAM_NAMES) {
		uint32_t dummy1;
		for (unsigned i = 0; i < param_count; ++i) {
			stream >> dummy1;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x3088
leaq 0x10(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3088
movl (%r12), %edi
callq 0x2ea6
movq %rax, 0x10(%r14)
movl (%r15), %r15d
testq %r15, %r15
je 0x423d
movq %r15, %rdi
shlq $0x3, %rdi
callq 0x2030
jmp 0x423f
xorl %eax, %eax
movl %r15d, (%r14)
movq %rax, 0x8(%r14)
cmpl $0x0, 0xc(%rsp)
je 0x427e
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3088
movl 0x10(%rsp), %edi
callq 0x2ea6
movq 0x8(%r14), %rcx
movslq %r12d, %r12
movq %rax, (%rcx,%r12,8)
incl %r12d
cmpl 0xc(%rsp), %r12d
jb 0x4255
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3088
movl (%r15), %edi
callq 0x2e5a
movq %rax, 0x18(%r14)
leaq 0x20(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3062
testb $0x8, 0x20(%r14)
je 0x42f0
leaq 0x18(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3088
cmpl $0x0, (%r14)
je 0x42f0
xorl %ebp, %ebp
leaq 0x1c(%rsp), %r14
leaq 0x17(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3088
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3062
incl %ebp
cmpl 0x18(%rsp), %ebp
jb 0x42d2
cmpb $0x0, (%r15)
jns 0x4317
cmpl $0x0, 0xc(%rsp)
je 0x4317
xorl %ebp, %ebp
leaq 0x18(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3088
incl %ebp
cmpl 0xc(%rsp), %ebp
jb 0x4304
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x24(%rdi), %rsi
movq %rbx, %rdi
callq 0x3088
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x3088
leaq 0x2c(%r14), %rsi
movq %rbx, %rdi
callq 0x3088
leaq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x3088
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3088
movl (%r15), %r15d
testq %r15, %r15
je 0x4385
movq %r15, %rdi
callq 0x2030
jmp 0x4387
xorl %eax, %eax
movl %r15d, 0x38(%r14)
movq %rax, 0x40(%r14)
cmpl $0x0, 0xc(%rsp)
je 0x43b5
xorl %r15d, %r15d
movslq %r15d, %r15
movq 0x40(%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x3062
incl %r15d
cmpl 0xc(%rsp), %r15d
jb 0x4399
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3088
movl (%r15), %r15d
testq %r15, %r15
je 0x43db
movq %r15, %rdi
shlq $0x5, %rdi
callq 0x2030
jmp 0x43dd
xorl %eax, %eax
movl %r15d, 0x48(%r14)
movq %rax, 0x50(%r14)
cmpl $0x0, 0xc(%rsp)
je 0x440f
xorl %r15d, %r15d
movslq %r15d, %r15
movq %r15, %rdi
shlq $0x5, %rdi
addq 0x50(%r14), %rdi
movq %rbx, %rsi
callq 0x412c
incl %r15d
cmpl 0xc(%rsp), %r15d
jb 0x43ef
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3088
movl (%r15), %r15d
testq %r15, %r15
je 0x4439
movq %r15, %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
callq 0x2030
jmp 0x443b
xorl %eax, %eax
movl %r15d, 0x58(%r14)
movq %rax, 0x60(%r14)
cmpl $0x0, 0xc(%rsp)
je 0x446e
xorl %r15d, %r15d
movslq %r15d, %r15
leaq (%r15,%r15,2), %rdi
shlq $0x3, %rdi
addq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x4d54
incl %r15d
cmpl 0xc(%rsp), %r15d
jb 0x444d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x3088
movl (%r15), %edi
callq 0x2eea
movq %rax, (%r14)
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3088
movl (%r15), %r15d
testq %r15, %r15
je 0x4690
movq %r15, %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
callq 0x2030
jmp 0x4692
xorl %eax, %eax
movl %r15d, 0x8(%r14)
movq %rax, 0x10(%r14)
cmpl $0x0, 0x8(%rsp)
je 0x46c5
xorl %r15d, %r15d
movslq %r15d, %r15
leaq (%r15,%r15,2), %rdi
shlq $0x3, %rdi
addq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x4d54
incl %r15d
cmpl 0x8(%rsp), %r15d
jb 0x46a4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
movq (%rsi), %rax
movq %rax, (%rdi)
movzwl (%rax), %ecx
leaq 0x2(%rax), %rdx
movq %rdx, (%rdi)
movl %ecx, %edx
shrl $0x6, %edx
movw %dx, 0x8(%rdi)
andl $0x3f, %ecx
movl %ecx, 0xc(%rdi)
cmpl $0x3f, %ecx
jne 0x4d47
movl 0x2(%rax), %ecx
addq $0x6, %rax
movq %rax, (%rdi)
movl %ecx, 0xc(%rdi)
movl 0xc(%rdi), %eax
addq (%rdi), %rax
movq %rax, (%rsi)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/FirestonnneTFM[P]tfm_key_parser/src/traits_info.cpp
// Function: traits_info::load(abc_stream&)
void traits_info::load(abc_stream &stream){
	has_loaded_value = false;
	uint32_t name_index;
	stream >> name_index;
	if (name_index == 0)
		fatal("Multiname index cannot be zero");
	name = abc_file::get_multiname(name_index);
	stream >> kind;
	uint8_t kind_high = kind >> 4;
	kind = kind & 0x0f;
	if (kind_high & ATTR_Metadata)
		fatal("Trait attribute metadata unsupported");
	uint32_t slot_id;
	switch (kind) {
	case Trait_Slot:
	case Trait_Const: {
		stream >> slot_id;
		stream >> vindex;
		stream >> vindex;
		if (vindex) {
			uint8_t dummy;
			stream >> dummy;
		}
		break;
	}
	case Trait_Class:
	case Trait_Method:
	case Trait_Getter:
	case Trait_Setter:
	case Trait_Function:
		stream >> slot_id;
		stream >> vindex;
		break;
	default:
		std::cout << "traits_info, kind = " << +kind << std::endl;
		fatal("Low bits of trait kind unknown");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, 0x10(%rdi)
leaq 0xc(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x3088
movl (%r15), %edi
testl %edi, %edi
je 0x4e28
callq 0x2ea6
movq %rax, (%r14)
leaq 0x8(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3062
movzbl 0x8(%r14), %ecx
movl %ecx, %eax
andl $0xf, %eax
movb %al, 0x8(%r14)
testb $0x40, %cl
jne 0x4e4c
leal -0x1(%rax), %ecx
cmpl $0x5, %ecx
jae 0x4dd6
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3088
addq $0xc, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3088
jmp 0x4e1e
cmpl $0x6, %eax
je 0x4de3
testl %eax, %eax
jne 0x4e83
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3088
leaq 0xc(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3088
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3088
cmpl $0x0, 0xc(%r14)
je 0x4e1e
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x3062
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x18, %edi
callq 0x2100
movl $0xd, (%rax)
leaq 0x148b(%rip), %rcx      # 0x62ca
movq %rcx, 0x8(%rax)
leaq 0x1461(%rip), %rcx      # 0x62ab
jmp 0x4e6e
movl $0x18, %edi
callq 0x2100
movl $0x13, (%rax)
leaq 0x1467(%rip), %rcx      # 0x62ca
movq %rcx, 0x8(%rax)
leaq 0x1470(%rip), %rcx      # 0x62de
movq %rcx, 0x10(%rax)
leaq 0x3f17(%rip), %rsi      # 0x8d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x22d0
movq 0x4146(%rip), %rdi      # 0x8fd0
leaq 0x1472(%rip), %rsi      # 0x6303
callq 0x21c0
movzbl (%r15), %esi
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
callq 0x20f0
movl $0x18, %edi
callq 0x2100
movl $0x2b, (%rax)
leaq 0x1409(%rip), %rcx      # 0x62ca
movq %rcx, 0x8(%rax)
leaq 0x144c(%rip), %rcx      # 0x6318
jmp 0x4e6e
nop
// File: /workspace/github_c_makefile_star2_O1/FirestonnneTFM[P]tfm_key_parser/src/main_dumper.cpp
// Function: executer::call_prop(class_info*)
char executer::call_prop(class_info *c) {
	uint8_t op;
	*this >> op;
	if (op != OP_callproperty) {
		undo();
		return '\0';
	}
	uint32_t index, arg_count;
	*this >> index;
	*this >> arg_count;
	traits_info *trait = c->get_trait_by_name(abc_file::get_multiname(index));
	method_info *prop = abc_file::get_method(trait->vindex);
	executer e(prop->code.begin());
	assert(e.step() == OP_getlocal_0);
	assert(e.step() == OP_pushscope);
	assert(e.step() == OP_getlex);
	return COP[e.get_push()];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7(%rsp), %r15
movq %r15, %rsi
callq 0x3062
cmpb $0x46, (%r15)
jne 0x4f7f
leaq 0x1c(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3088
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x3088
movl (%r15), %edi
callq 0x2ea6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b00
movl 0xc(%rax), %edi
callq 0x2eea
movq 0x40(%rax), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3024
movq %rbx, %rdi
callq 0x27f4
cmpb $-0x30, %al
jne 0x4f93
leaq 0x8(%rsp), %rdi
callq 0x27f4
cmpb $0x30, %al
jne 0x4fa5
leaq 0x8(%rsp), %rdi
callq 0x27f4
cmpb $0x60, %al
jne 0x4fb7
movq 0x4a8a(%rip), %rbx      # 0x99f8
leaq 0x8(%rsp), %rdi
callq 0x29a2
cltq
movb (%rbx,%rax), %al
jmp 0x4f89
movq %r14, %rdi
callq 0x302c
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x18, %edi
callq 0x2100
movl $0x20, (%rax)
jmp 0x4fc7
movl $0x18, %edi
callq 0x2100
movl $0x21, (%rax)
jmp 0x4fc7
movl $0x18, %edi
callq 0x2100
movl $0x22, (%rax)
leaq 0x1377(%rip), %rcx      # 0x6345
movq %rcx, 0x8(%rax)
leaq 0x135e(%rip), %rcx      # 0x6337
movq %rcx, 0x10(%rax)
leaq 0x3dac(%rip), %rsi      # 0x8d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x22d0
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x27f4
cmpb $-0x2f, %al
jne 0x4ff2
movq %rbx, %rdi
callq 0x27f4
cmpb $-0x30, %al
jne 0x4ff2
movq %rbx, %rdi
callq 0x27f4
cmpb $-0x30, %al
jne 0x4ff2
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2f00
movq 0x78(%rax), %rax
movq 0x40(%rax), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3024
movq %r14, %rdi
movl $0x5e, %esi
callq 0x2976
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3088
cmpl $0x2c, (%r15)
jne 0x514b
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3088
movl (%r15), %edi
callq 0x2e5a
movq %rax, 0x4968(%rip)      # 0x99f8
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x2f00
movq 0x60(%rax), %rax
movq 0x40(%rax), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x3024
movups (%r15), %xmm0
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x4fee
xorl %edi, %edi
callq 0x2f00
movq %r14, %rdi
movq %rax, %rsi
callq 0x4ed0
movb %al, 0x20(%rsp)
leaq 0x21(%rsp), %r12
movq %r14, %rdi
callq 0x27f4
xorl %edi, %edi
callq 0x2f00
movq %r14, %rdi
movq %rax, %rsi
callq 0x4ed0
movb %al, (%r12)
movq %r14, %rdi
callq 0x27f4
incq %r12
cmpb $-0x60, %al
je 0x50d9
movq %r15, %rdi
callq 0x20e0
leaq 0x1(%rax), %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2180
movq %r13, (%rbx,%rbp,8)
incq %rbp
cmpq $0xc, %rbp
jne 0x50b6
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %edi
callq 0x2100
movl $0x3e, (%rax)
leaq 0x11e3(%rip), %rcx      # 0x6345
movq %rcx, 0x8(%rax)
leaq 0x11ca(%rip), %rcx      # 0x6337
movq %rcx, 0x10(%rax)
leaq 0x3c18(%rip), %rsi      # 0x8d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x22d0
// File: /workspace/github_c_makefile_star2_O1/diaxen[P]fft-garden/test.c
// Function: main
int main()
{
  for (int count = MIN_COUNT; count <= MAX_COUNT; count *= 2)
    {
      complex double s[count];	/* input */
      complex double t[count];	/* tested implementation output */
      complex double r[count];	/* reference output */

      /* random input */
      for (unsigned i = 0; i < count; i++)
	s[i] = (drand48() - .5) + I * (drand48() - .5);

      /* run fft under test */
      fft_init(count);

      /* run reference fft */
      simple_dft(count, r, s, 1);

#ifdef INPLACE
      fft(count, s);
      memcpy(t, s, sizeof(s));
#else
      fft(count, t, s);
#endif

      fft_cleanup();

      /* compare outputs */
      for (unsigned i = 0; i < count; i++)
	if (cabs(t[i] - r[i]) > 0.0001)
	  {
	    printf("LEN: %u\n", count);
	    printf("INPUT: ");
	    print_cpx_array(s, count);
	    printf("FFT: ");
	    print_cpx_array(t, count);
	    printf("REF: ");
	    print_cpx_array(r, count);
	    abort();
	  }

      printf("Ok %u\n", count);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x4, %eax
movq %rsp, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movl %eax, %r14d
movq %rsp, %r13
shlq $0x4, %r14
subq %r14, %r13
movq %r13, %rsp
movq %rsp, %r12
subq %r14, %r12
movq %r12, %rsp
movq %rsp, %r15
subq %r14, %r15
movq %r15, %rsp
xorl %ebx, %ebx
callq 0x10c0
movapd %xmm0, %xmm1
movsd 0x1d86(%rip), %xmm0     # 0x3008
addsd %xmm0, %xmm1
movsd %xmm1, -0x40(%rbp)
callq 0x10c0
addsd 0x1d70(%rip), %xmm0     # 0x3008
movapd %xmm0, %xmm1
mulsd 0x1d74(%rip), %xmm1     # 0x3018
addsd -0x40(%rbp), %xmm1
movsd %xmm1, (%r13,%rbx)
movsd %xmm0, 0x8(%r13,%rbx)
addq $0x10, %rbx
cmpq %rbx, %r14
jne 0x1271
movq -0x30(%rbp), %rbx
movl %ebx, %edi
callq 0x1edd
movl %ebx, %edi
movq %r15, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x13be
movl %ebx, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1a14
xorl %eax, %eax
callq 0x1eeb
xorl %ebx, %ebx
movsd (%r12,%rbx), %xmm0
movsd 0x8(%r12,%rbx), %xmm1
subsd (%r15,%rbx), %xmm0
subsd 0x8(%r15,%rbx), %xmm1
callq 0x10a0
ucomisd 0x1cf6(%rip), %xmm0     # 0x3010
ja 0x135d
addq $0x10, %rbx
cmpq %rbx, %r14
jne 0x12f3
leaq 0x1d3c(%rip), %rdi      # 0x3068
movq -0x30(%rbp), %rbx
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
movq -0x38(%rbp), %rsp
leal (%rbx,%rbx), %eax
cmpl $0x801, %ebx            # imm = 0x801
jb 0x1245
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ce7(%rip), %rdi      # 0x304b
movq -0x30(%rbp), %rbx
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x1cdc(%rip), %rdi      # 0x3054
xorl %eax, %eax
callq 0x1070
movq %r13, %rdi
movl %ebx, %esi
callq 0x11da
leaq 0x1ccc(%rip), %rdi      # 0x305c
xorl %eax, %eax
callq 0x1070
movq %r12, %rdi
movl %ebx, %esi
callq 0x11da
leaq 0x1cba(%rip), %rdi      # 0x3062
xorl %eax, %eax
callq 0x1070
movq %r15, %rdi
movl %ebx, %esi
callq 0x11da
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/diaxen[P]fft-garden/test.c
// Function: simple_dft
static void simple_dft(unsigned size, complex double *output,
		       const complex double *input,
		       unsigned stride /* = 1*/)
{
  unsigned half = size >> 1;

  if (!half)
    {
      output[0] = input[0];
    }
  else
    {
      simple_dft(half, output       , input         , stride << 1);
      simple_dft(half, output + half, input + stride, stride << 1);

      for (unsigned i = 0; i < half; i++)
	{
	  complex double a = output[i];
	  complex double b = output[i + half];

	  double angle = 2 * M_PI * i / size;
	  complex double tw = conj(cexp(angle * I));
	  complex double c = b * tw;

	  output[i] = a + c;
	  output[i + half] = a - c;
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %rbx
cmpl $0x1, %edi
ja 0x13f0
movupd (%r12), %xmm0
movupd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %r13d
movl %edi, %ebp
movl %edi, %r14d
shrl %r14d
leal (,%r13,2), %ecx
movl %ecx, (%rsp)
movl %r14d, %edi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x13be
movq %r14, %r15
shlq $0x4, %r15
addq %rbx, %r15
movl %r13d, %edx
shlq $0x4, %rdx
addq %r12, %rdx
movl %r14d, %edi
movq %r15, %rsi
movl (%rsp), %ecx
callq 0x13be
movl %ebp, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x8, %r12d
xorl %r13d, %r13d
movsd -0x8(%rbx,%r12), %xmm0
movsd %xmm0, (%rsp)
movsd (%rbx,%r12), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd -0x8(%r15,%r12), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%r15,%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm1, %xmm1
cvtsi2sd %r13d, %xmm1
mulsd 0x1b93(%rip), %xmm1     # 0x3020
divsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
mulsd 0x1b79(%rip), %xmm0     # 0x3018
callq 0x1060
movsd 0x10(%rsp), %xmm6
movsd 0x18(%rsp), %xmm5
movapd %xmm0, %xmm2
movapd %xmm1, %xmm3
movapd %xmm5, %xmm4
mulsd %xmm0, %xmm4
movapd %xmm6, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm6, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm4, %xmm0
movapd %xmm5, %xmm4
mulsd %xmm3, %xmm4
subsd %xmm4, %xmm1
ucomisd %xmm0, %xmm0
jp 0x1538
movsd (%rsp), %xmm4
movapd %xmm4, %xmm2
addsd %xmm0, %xmm2
movsd 0x20(%rsp), %xmm5
movapd %xmm5, %xmm3
addsd %xmm1, %xmm3
movsd %xmm2, -0x8(%rbx,%r12)
movsd %xmm3, (%rbx,%r12)
subsd %xmm0, %xmm4
subsd %xmm1, %xmm5
movsd %xmm4, -0x8(%r15,%r12)
movsd %xmm5, (%r15,%r12)
incq %r13
addq $0x10, %r12
cmpq %r13, %r14
jne 0x144c
jmp 0x13e1
ucomisd %xmm1, %xmm1
jnp 0x14e6
xorpd 0x1aea(%rip), %xmm3     # 0x3030
movapd %xmm5, %xmm0
movapd %xmm6, %xmm1
callq 0x2830
jmp 0x14e6
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %ebp
movl %edi, %r14d
movq %r14, %rsi
shlq $0x4, %rsi
movl $0x100, %edi            # imm = 0x100
callq 0x10b0
movq %rax, 0x3aff(%rip)      # 0x5080
testq %rax, %rax
je 0x15fe
testl %ebp, %ebp
je 0x15f3
movl %ebx, %eax
cvtsi2sd %rax, %xmm0
movsd 0x1ad7(%rip), %xmm1     # 0x3070
movsd %xmm0, 0x10(%rsp)
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movl $0x8, %ebx
xorl %r15d, %r15d
movl %r15d, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
mulsd 0x1ab4(%rip), %xmm1     # 0x3078
divsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x1060
movq 0x3aa4(%rip), %rax      # 0x5080
movsd %xmm0, -0x8(%rax,%rbx)
movsd %xmm1, (%rax,%rbx)
incq %r15
addq $0x10, %rbx
cmpq %r15, %r14
jne 0x15b1
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a83(%rip), %rdi      # 0x3088
leaq 0x1a85(%rip), %rsi      # 0x3091
leaq 0x1a89(%rip), %rcx      # 0x309c
movl $0x21, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movl %edi, %ebp
movl %edi, %r12d
movq %r12, %r14
shlq $0x4, %r14
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
callq 0x10b0
movq %rax, %r15
movq %rax, 0x3a32(%rip)      # 0x5080
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
callq 0x10b0
movq %rax, 0x3a26(%rip)      # 0x5088
testq %r15, %r15
je 0x1720
testl %ebp, %ebp
je 0x1713
movl %ebx, %eax
cvtsi2sd %rax, %xmm0
movsd 0x19ee(%rip), %xmm1     # 0x3070
movsd %xmm0, 0x10(%rsp)
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movl $0x8, %ebx
xorl %r14d, %r14d
movl %r14d, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
mulsd 0x19cb(%rip), %xmm1     # 0x3078
movsd %xmm1, 0x18(%rsp)
divsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x1060
movq 0x39b5(%rip), %rax      # 0x5080
movsd %xmm0, -0x8(%rax,%rbx)
movsd %xmm1, (%rax,%rbx)
movsd 0x18(%rsp), %xmm1
mulsd 0x199c(%rip), %xmm1     # 0x3080
divsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x1060
movq 0x398c(%rip), %rax      # 0x5088
movsd %xmm0, -0x8(%rax,%rbx)
movsd %xmm1, (%rax,%rbx)
incq %r14
addq $0x10, %rbx
cmpq %r14, %r12
jne 0x169a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1961(%rip), %rdi      # 0x3088
leaq 0x1963(%rip), %rsi      # 0x3091
leaq 0x1996(%rip), %rcx      # 0x30cb
movl $0x30, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
shrl %edi
shlq $0x2, %rdi
callq 0x1090
movq %rax, 0x392f(%rip)      # 0x5090
testq %rax, %rax
je 0x17d1
testl %ebx, %ebx
je 0x17cf
bsrl %ebx, %edx
notl %edx
addl $0x21, %edx
movl %ebx, %esi
xorl %r10d, %r10d
xorl %r8d, %r8d
xorl %edi, %edi
leaq 0x2(%r10), %r9
movl %r9d, %ecx
xorl %r10d, %ecx
bsrl %ecx, %r11d
xorl $0x1f, %r11d
movl %r8d, %ebx
subl %edi, %ebx
movl %edx, %ecx
shrl %cl, %ebx
movl %ebx, (%rax,%r10,2)
movb $0x1e, %cl
subb %r11b, %cl
movl $0x20000000, %r10d      # imm = 0x20000000
shrl %cl, %r10d
leal -0x1(%r10), %ecx
movl %r10d, %r11d
andl %r8d, %r11d
andl %ecx, %edi
orl %r11d, %edi
andl %r8d, %ecx
xorl %r10d, %r11d
addl %r11d, %r11d
orl %ecx, %r11d
movq %r9, %r10
movl %r11d, %r8d
cmpq %rsi, %r9
jb 0x177c
popq %rbx
retq
leaq 0x1925(%rip), %rdi      # 0x30fd
leaq 0x192b(%rip), %rsi      # 0x310a
leaq 0x1933(%rip), %rcx      # 0x3119
movl $0x20, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
shrl %edi
shlq $0x2, %rdi
callq 0x1090
movq %rax, 0x3887(%rip)      # 0x5098
testq %rax, %rax
je 0x1822
bsrl %ebx, %edi
xorl %esi, %esi
movl %edi, %edx
xorl %ecx, %ecx
popq %rbx
jmp 0x1841
leaq 0x1915(%rip), %rdi      # 0x313e
leaq 0x191b(%rip), %rsi      # 0x314b
leaq 0x1923(%rip), %rcx      # 0x315a
movl $0x37, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r15d
movl %esi, %r14d
movl %edi, %ebp
movl %edi, %r12d
subl %edx, %r12d
movl $0x1, %r13d
movl %r12d, %ecx
shll %cl, %r13d
cmpl $0x2, %r15d
je 0x18d4
cmpl $0x1, %r15d
je 0x18c4
leal -0x1(%r15), %edx
movl %ebp, %edi
movl %r14d, %esi
movl %ebx, %ecx
callq 0x1841
addl $-0x2, %r15d
movl $0x2, %esi
movl %r15d, %ecx
shll %cl, %esi
addl %r14d, %esi
addl %ebx, %r13d
movl %ebp, %edi
movl %r15d, %edx
movl %r13d, %ecx
callq 0x1841
movl $0x3, %eax
movl %r15d, %ecx
shll %cl, %eax
movl $0x3, %edx
movl %r12d, %ecx
shll %cl, %edx
addl %eax, %r14d
addl %edx, %ebx
addl $0x2, %r12d
jmp 0x185c
movq 0x37cd(%rip), %rax      # 0x5098
shrl %r14d
movl %ebx, (%rax,%r14,4)
jmp 0x18ea
movq 0x37bd(%rip), %rax      # 0x5098
shrl %r14d
movl %ebx, (%rax,%r14,4)
addl %ebx, %r13d
movl %r13d, 0x4(%rax,%r14,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
bsrl %edi, %r15d
leal (,%r15,4), %edi
callq 0x1090
movq %rax, 0x3779(%rip)      # 0x50a0
testq %rax, %rax
je 0x19bb
movq %rax, %r14
movl %r15d, %eax
xorl $0x1f, %eax
cmpl $0x1f, %eax
je 0x1966
cmpl $0x1, %r15d
movl %r15d, %eax
adcl $0x0, %eax
xorl %ecx, %ecx
leaq 0x182f(%rip), %rdx      # 0x3180
movl %r15d, %esi
movl (%rdx,%rsi,4), %esi
movl %esi, (%r14,%rcx,4)
incq %rcx
decl %r15d
cmpq %rcx, %rax
jne 0x1951
movl (%r14), %edi
incl %edi
shlq $0x2, %rdi
callq 0x1090
movq %rax, 0x372d(%rip)      # 0x50a8
testq %rax, %rax
je 0x19da
movl (%r14), %edx
xorl %ecx, %ecx
testl %edx, %edx
je 0x19b2
xorl %esi, %esi
leal 0x1(%rsi), %edi
movl %edi, %r8d
xorl %esi, %r8d
bsrl %r8d, %r8d
notl %r8d
testb $0x1, %r8b
je 0x19aa
movl %ecx, %r8d
incl %ecx
movl %esi, (%rax,%r8,4)
movl %edi, %esi
cmpl %edx, %ecx
jb 0x198b
movl %ecx, %ecx
movl %ebx, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x183e(%rip), %rdi      # 0x3200
leaq 0x1844(%rip), %rsi      # 0x320d
leaq 0x184c(%rip), %rcx      # 0x321c
movl $0x25, %edx
callq 0x1080
leaq 0x1860(%rip), %rdi      # 0x3241
leaq 0x1825(%rip), %rsi      # 0x320d
leaq 0x182d(%rip), %rcx      # 0x321c
movl $0x2b, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_19/undcl.c
// Function: main
int main(void)
{
  char temp[MAX_OUT_LEN + MAX_TOKEN_LEN];

  while (get_next_token() != EOF)
  {
    strcpy(out, token);

    while (get_next_token() != '\n')
    {
      if (next_token == PARENS)
      {
        if (out[0] == '*')
        {
          sprintf(temp, "(%s)", out);
          strcpy(out, temp);
        }

        strcat(out, token);
      }
      else if (next_token == BRACKETS)
      {
        if (out[0] == '*')
        {
          sprintf(temp, "(%s)", out);
          strcpy(out, temp);
        }

        sprintf(temp, "[%s]", token);
        strcat(out, temp);
      }
      else if (next_token == '*')
      {
        sprintf(temp, "*%s", out);
        strcpy(out, temp);
      }
      else if (next_token == NAME)
      {
        sprintf(temp, "%s %s", token, out);
        strcpy(out, temp);
      }
      else
      {
        printf("Syntax Error: Invalid input at %s.\n", token);
      }
    }
    puts(out);
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp            # imm = 0x458
callq 0x1316
cmpl $-0x1, %eax
je 0x1302
leaq 0x2eae(%rip), %rbx      # 0x4080
leaq 0x3297(%rip), %r14      # 0x4470
movq %rsp, %r12
leaq 0xe35(%rip), %rbp       # 0x2018
leaq 0xe1f(%rip), %r15       # 0x2009
leaq 0xe1d(%rip), %r13       # 0x200e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1030
callq 0x1316
cmpl $0xa, %eax
je 0x12ec
movl 0x32c4(%rip), %eax      # 0x44d4
cmpl $0x1, %eax
jg 0x1257
testl %eax, %eax
je 0x12b8
cmpl $0x1, %eax
jne 0x1261
cmpb $0x2a, 0x2e57(%rip)     # 0x4080
jne 0x124a
movq %r12, %rdi
leaq 0xdcf(%rip), %rsi       # 0x2004
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1070
jmp 0x11fc
cmpl $0x2, %eax
je 0x1270
cmpl $0x2a, %eax
je 0x12d1
movq %rbp, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1050
jmp 0x11fc
cmpb $0x2a, 0x2e09(%rip)     # 0x4080
jne 0x1298
movq %r12, %rdi
leaq 0xd81(%rip), %rsi       # 0x2004
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1030
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1070
jmp 0x11fc
movq %r12, %rdi
leaq 0xd50(%rip), %rsi       # 0x2012
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1080
jmp 0x12e1
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x11f7
movq %rbx, %rdi
callq 0x1040
callq 0x1316
cmpl $-0x1, %eax
jne 0x11f1
xorl %eax, %eax
addq $0x458, %rsp            # imm = 0x458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
callq 0x13ff
callq 0x1437
callq 0x13ff
movq 0x2cb0(%rip), %r14      # 0x3fe0
movq (%r14), %rdi
callq 0x1090
cmpl $0x5b, %eax
je 0x1371
movl %eax, %ebx
cmpl $0x28, %eax
jne 0x13af
callq 0x13ff
movq (%r14), %rdi
callq 0x1090
cmpl $0x29, %eax
jne 0x13e0
movb $0x0, 0x3111(%rip)      # 0x4472
movw $0x2928, 0x3106(%rip)   # imm = 0x2928
movl $0x1, %ebx
jmp 0x13ef
callq 0x13ff
leaq 0x30f3(%rip), %rdi      # 0x4470
movl $0x64, %esi
callq 0x14a4
callq 0x13ff
movq (%r14), %rdi
callq 0x1090
movl $0x2, %ebx
cmpl $0x5d, %eax
je 0x13ef
movq (%r14), %rsi
movl %eax, %edi
callq 0x1060
movl $0x5b, %ebx
jmp 0x13ef
callq 0x10a0
movq (%rax), %rax
movslq %ebx, %rcx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x13ef
movq (%r14), %rsi
movl %ebx, %edi
callq 0x1060
leaq 0x309e(%rip), %rdi      # 0x4470
movl $0x64, %esi
callq 0x14a4
xorl %ebx, %ebx
jmp 0x13ef
movq (%r14), %rsi
movl %eax, %edi
callq 0x1060
movl $0x28, %ebx
movl %ebx, 0x30df(%rip)      # 0x44d4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0x2ba1(%rip), %rbx      # 0x3fe0
movq (%rbx), %rdi
callq 0x1090
cmpl $0x2f, %eax
jne 0x1499
movq (%rbx), %rdi
callq 0x1090
cmpl $0x2f, %eax
je 0x1487
cmpl $0x2a, %eax
jne 0x1499
movq (%rbx), %rdi
callq 0x1090
cmpl $0x2a, %eax
je 0x1470
cmpl $-0x1, %eax
jne 0x145e
movq (%rbx), %rdi
callq 0x1090
movl %eax, %ecx
cmpl $0x2f, %eax
movl $0xa, %eax
cmovnel %ecx, %eax
jmp 0x1499
movq (%rbx), %rdi
callq 0x1090
cmpl $-0x1, %eax
je 0x1499
cmpl $0xa, %eax
jne 0x1487
movq (%rbx), %rsi
movl %eax, %edi
popq %rbx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x10a0
movq %rax, %r15
movq (%rax), %r13
movq 0x2b19(%rip), %r12      # 0x3fe0
movq (%r12), %rdi
callq 0x1090
movslq %eax, %rcx
testb $0x8, (%r13,%rcx,2)
sete %dl
cmpl $0x5f, %ecx
setne %cl
andb %dl, %cl
testq %r14, %r14
sete %dl
xorl %r13d, %r13d
orb %cl, %dl
jne 0x151e
movb %al, (%rbx,%r13)
incq %r13
movq (%r15), %rbp
movq (%r12), %rdi
callq 0x1090
movslq %eax, %rcx
testb $0x8, (%rbp,%rcx,2)
sete %dl
cmpl $0x5f, %ecx
setne %cl
testb %dl, %cl
jne 0x151e
cmpq %r14, %r13
jb 0x14f1
movb $0x0, (%rbx,%r13)
movq (%r12), %rsi
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x40(%rbp), %rsi
movl $0x10, %edx
callq 0x2a4f
testl %eax, %eax
jle 0x20d8
movl %eax, %ebx
leaq 0x46e4(%rip), %rdi      # 0x6717
xorl %eax, %eax
callq 0x1080
cmpl $0x10, %ebx
movl $0xf, %r15d
cmovael %ebx, %r15d
movl %ebx, %r12d
negq %r12
movq $-0x1, %r13
leaq 0x46cc(%rip), %r14      # 0x6727
movzbl -0x3f(%rbp,%r13), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1080
leaq (%r12,%r13), %rax
incq %rax
incq %r13
cmpq $-0x1, %rax
jne 0x205b
cmpq $0xe, %r13
ja 0x209d
subl %ebx, %r15d
incl %r15d
leaq 0x4225(%rip), %r14      # 0x62b3
movq %r14, %rdi
xorl %eax, %eax
callq 0x1080
decl %r15d
jne 0x208e
cmpl $0x2, %ebx
movl $0x1, %r14d
cmovgel %ebx, %r14d
xorl %ebx, %ebx
movzbl -0x40(%rbp,%rbx), %eax
leal -0x20(%rax), %ecx
cmpb $0x5f, %cl
jb 0x20be
movl $0x2e, %eax
movzbl %al, %edi
callq 0x1040
incq %rbx
cmpq %rbx, %r14
jne 0x20ac
movl $0xa, %edi
callq 0x1040
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %esi, %edx
movq %rdi, %rbx
leaq -0xa0(%rbp), %rsi
callq 0x4178
testl %eax, %eax
je 0x2133
leaq 0x4b84(%rip), %rdi      # 0x6c99
callq 0x1070
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0xa0(%rbp), %r14
movzwl 0x2(%r14), %esi
leaq 0x45e7(%rip), %rdi      # 0x672d
xorl %eax, %eax
callq 0x1080
movl $0x1, %r15d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
leal -0x1(%r15), %eax
movzwl -0x9e(%rbp), %ecx
cmpl %ecx, %eax
jae 0x218b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4407
testl %eax, %eax
jne 0x2120
movq %r14, %rdi
movl %r15d, %esi
callq 0x27f0
incl %r15d
testl %eax, %eax
je 0x2159
jmp 0x2120
xorl %r12d, %r12d
jmp 0x2120
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl (%rdi), %ecx
movl %ecx, %esi
andl $0x1, %esi
movzbl 0x1(%rdi), %edx
shrl %ecx
andl $0x1, %ecx
movzbl 0x2(%rdi), %r8d
cvtsi2sdl 0x14(%rdi), %xmm0
movsd 0x38ab(%rip), %xmm2     # 0x6008
divsd %xmm2, %xmm0
cvtsi2sdl 0x18(%rdi), %xmm1
divsd %xmm2, %xmm1
movzbl 0x3(%rdi), %r9d
leaq 0x4484(%rip), %rdi      # 0x6bfa
movb $0x2, %al
callq 0x1080
testb $0x1, (%rbx)
je 0x27b0
xorps %xmm0, %xmm0
cvtsi2sdl 0x4(%rbx), %xmm0
movsd 0x3886(%rip), %xmm2     # 0x6018
mulsd %xmm2, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x8(%rbx), %xmm1
mulsd %xmm2, %xmm1
leaq 0x449d(%rip), %rdi      # 0x6c46
movb $0x2, %al
callq 0x1080
testb $0x2, (%rbx)
jne 0x27bc
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorps %xmm0, %xmm0
cvtsi2sdl 0xc(%rbx), %xmm0
movsd 0x384c(%rip), %xmm2     # 0x6018
mulsd %xmm2, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x10(%rbx), %xmm1
mulsd %xmm2, %xmm1
leaq 0x4476(%rip), %rdi      # 0x6c59
movb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O1/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_stock_raw_seek
int swf_reader_stock_raw_seek(void *io,uint64_t pos) {
	swf_reader *swf = (swf_reader*)io;

	if (swf == NULL) return -1;
	if (swf->file_fd < 0) return -1;
	if (lseek(swf->file_fd,(off_t)pos,SEEK_SET) != (off_t)pos) return -1;
	swf->raw_current_pos = pos;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x29e2
movq %rdi, %r15
movl 0x10(%rdi), %edi
testl %edi, %edi
js 0x29e2
movq %rsi, %r14
xorl %edx, %edx
callq 0x1090
cmpq %r14, %rax
jne 0x29e2
movq %r14, (%r15)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_seek
int swf_reader_seek(swf_reader *r,uint64_t pos) {
	if (r == NULL) return -1;
	if (r->seek == NULL) return -1;
	r->eof = 0;
	return r->seek(r,pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2a48
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x2a48
movb $0x0, 0x71(%rdi)
popq %rbp
jmpq *%rax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_read
int swf_reader_read(swf_reader *r,void *buf,int len) {
	int rd;

	if (r == NULL) return -1;
	if (r->read == NULL) return -1;
	if (r->read_stop != (uint64_t)0ULL) {
		if (r->current_pos >= r->read_stop) return 0;
		if ((r->current_pos+(uint64_t)len) > r->read_stop)
			len = (int)(r->read_stop - r->current_pos);
	}

	rd = r->read(r,buf,len);
	if (rd < len) r->eof = 1;
	return rd;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x2aa8
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rcx
testq %rcx, %rcx
je 0x2aa4
movl %edx, %r14d
movq 0x60(%rbx), %rdx
testq %rdx, %rdx
je 0x2a93
movq 0x8(%rbx), %rdi
xorl %eax, %eax
cmpq %rdi, %rdx
jbe 0x2aa4
movslq %r14d, %rax
addq %rdi, %rax
cmpq %rdx, %rax
jbe 0x2a93
subl %edi, %edx
movl %edx, %r14d
movq %rbx, %rdi
movl %r14d, %edx
callq *%rcx
cmpl %r14d, %eax
jge 0x2aa4
movb $0x1, 0x71(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_read_UI8
swf_UI8 swf_reader_read_UI8(swf_reader *swf) {
	unsigned char c = 0x00;
	swf_reader_read_bytealign(swf);
	swf_reader_read(swf,&c,1);
	return (swf_UI8)c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %eax, %eax
leaq -0x9(%rbp), %rbx
movb %al, (%rbx)
movb %al, 0x59(%rdi)
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2a4f
movb (%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_read_RGBA
void swf_reader_read_RGBA(swf_reader *swf,swf_RGBA *rgb) {
	rgb->Red = swf_reader_read_UI8(swf);
	rgb->Green = swf_reader_read_UI8(swf);
	rgb->Blue = swf_reader_read_UI8(swf);
	rgb->Alpha = swf_reader_read_UI8(swf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq -0x21(%rbp), %r15
movb %r12b, (%r15)
movb %r12b, 0x59(%rdi)
movq %r15, %rsi
movl $0x1, %edx
callq 0x2a4f
movb (%r15), %al
movb %al, (%rbx)
leaq -0x22(%rbp), %r15
movb %r12b, (%r15)
movb %r12b, 0x59(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2a4f
movb (%r15), %al
movb %al, 0x1(%rbx)
leaq -0x23(%rbp), %r15
movb %r12b, (%r15)
movb %r12b, 0x59(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2a4f
movb (%r15), %al
movb %al, 0x2(%rbx)
leaq -0x24(%rbp), %r15
movb %r12b, (%r15)
movb %r12b, 0x59(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2a4f
movb (%r15), %al
movb %al, 0x3(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_read_RGB_as_RGBA
void swf_reader_read_RGB_as_RGBA(swf_reader *swf,swf_RGBA *rgb) {
	rgb->Red = swf_reader_read_UI8(swf);
	rgb->Green = swf_reader_read_UI8(swf);
	rgb->Blue = swf_reader_read_UI8(swf);
	rgb->Alpha = 0xFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq -0x21(%rbp), %r15
movb %r12b, (%r15)
movb %r12b, 0x59(%rdi)
movq %r15, %rsi
movl $0x1, %edx
callq 0x2a4f
movb (%r15), %al
movb %al, (%rbx)
leaq -0x22(%rbp), %r15
movb %r12b, (%r15)
movb %r12b, 0x59(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2a4f
movb (%r15), %al
movb %al, 0x1(%rbx)
leaq -0x23(%rbp), %r15
movb %r12b, (%r15)
movb %r12b, 0x59(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2a4f
movb (%r15), %al
movb %al, 0x2(%rbx)
movb $-0x1, 0x3(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq