LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x3036
cmpb $0x46, (%r15)
jne 0x4db7
leaq 0x1c(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x305c
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x305c
movl (%r15), %edi
callq 0x2d54
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3968
movl 0xc(%rax), %edi
callq 0x2d94
movq 0x40(%rax), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2ff8
movq %rbx, %rdi
callq 0x2770
cmpb $-0x30, %al
jne 0x4dcb
leaq 0x8(%rsp), %rdi
callq 0x2770
cmpb $0x30, %al
jne 0x4ddb
leaq 0x8(%rsp), %rdi
callq 0x2770
cmpb $0x60, %al
jne 0x4deb
movq 0x4c32(%rip), %rbx      # 0x99d8
leaq 0x8(%rsp), %rdi
callq 0x28fc
cltq
movb (%rbx,%rax), %al
jmp 0x4dc1
movq %r14, %rdi
callq 0x3000
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x20, (%rax)
jmp 0x4df9
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x21, (%rax)
jmp 0x4df9
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x22, (%rax)
leaq 0x1545(%rip), %rcx      # 0x6345
movq %rcx, 0x8(%rax)
leaq 0x152c(%rip), %rcx      # 0x6337
movq %rcx, 0x10(%rax)
leaq 0x3f7a(%rip), %rsi      # 0x8d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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 0x2770
cmpb $-0x2f, %al
jne 0x4e24
movq %rbx, %rdi
callq 0x2770
cmpb $-0x30, %al
jne 0x4e24
movq %rbx, %rdi
callq 0x2770
cmpb $-0x30, %al
jne 0x4e24
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2daa
movq 0x78(%rax), %rax
movq 0x40(%rax), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2ff8
pushq $0x5e
popq %rsi
movq %r14, %rdi
callq 0x28de
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x305c
cmpl $0x2c, (%r15)
jne 0x4f80
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x305c
movl (%r15), %edi
callq 0x2d08
movq %rax, 0x4b18(%rip)      # 0x99d8
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x2daa
movq 0x60(%rax), %rax
movq 0x40(%rax), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x2ff8
movups (%r15), %xmm0
movaps %xmm0, (%r14)
cmpq $0xc, %rbp
je 0x4f71
movq %r14, %rdi
callq 0x4e20
xorl %edi, %edi
callq 0x2daa
movq %r14, %rdi
movq %rax, %rsi
callq 0x4d08
movb %al, 0x20(%rsp)
leaq 0x21(%rsp), %r12
movq %r14, %rdi
callq 0x2770
xorl %edi, %edi
callq 0x2daa
movq %r14, %rdi
movq %rax, %rsi
callq 0x4d08
movb %al, (%r12)
movq %r14, %rdi
callq 0x2770
incq %r12
cmpb $-0x60, %al
je 0x4f13
movq %r15, %rdi
callq 0x20d0
leaq 0x1(%rax), %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2150
movq %r13, (%rbx,%rbp,8)
incq %rbp
jmp 0x4ee6
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x3e, (%rax)
leaq 0x13b0(%rip), %rcx      # 0x6345
movq %rcx, 0x8(%rax)
leaq 0x1397(%rip), %rcx      # 0x6337
movq %rcx, 0x10(%rax)
leaq 0x3de5(%rip), %rsi      # 0x8d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x4
popq %rbx
cmpl $0x1001, %ebx           # imm = 0x1001
jae 0x133b
movq %rsp, -0x38(%rbp)
movl %ebx, -0x2c(%rbp)
movl %ebx, %r15d
movq %rsp, %r14
shlq $0x4, %r15
subq %r15, %r14
movq %r14, %rsp
movq %rsp, %r13
subq %r15, %r13
movq %r13, %rsp
movq %rsp, %r12
subq %r15, %r12
movq %r12, %rsp
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0x12b1
callq 0x10c0
movapd %xmm0, %xmm1
movsd 0x1d91(%rip), %xmm0     # 0x3008
addsd %xmm0, %xmm1
movsd %xmm1, -0x40(%rbp)
callq 0x10c0
addsd 0x1d7b(%rip), %xmm0     # 0x3008
movapd %xmm0, %xmm1
mulsd 0x1d7f(%rip), %xmm1     # 0x3018
addsd -0x40(%rbp), %xmm1
movsd %xmm1, (%r14,%rbx)
movsd %xmm0, 0x8(%r14,%rbx)
addq $0x10, %rbx
jmp 0x1261
movl -0x2c(%rbp), %ebx
movl %ebx, %edi
callq 0x1c5f
movl %ebx, %edi
movq %r12, %rsi
movq %r14, %rdx
pushq $0x1
popq %rcx
callq 0x13ac
movl %ebx, %edi
movq %r13, %rsi
movq %r14, %rdx
callq 0x19a4
xorl %eax, %eax
callq 0x1c6d
addq $0x10, %r15
xorl %eax, %eax
leaq 0x10(%rax), %rbx
cmpq %rbx, %r15
je 0x131d
movsd (%r13,%rax), %xmm0
movsd 0x8(%r13,%rax), %xmm1
subsd (%r12,%rax), %xmm0
subsd 0x8(%r12,%rax), %xmm1
callq 0x10a0
ucomisd 0x1cfa(%rip), %xmm0     # 0x3010
movq %rbx, %rax
jbe 0x12e5
jmp 0x134c
leaq 0x1d44(%rip), %rdi      # 0x3068
movl -0x2c(%rbp), %ebx
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
movq -0x38(%rbp), %rsp
addl %ebx, %ebx
jmp 0x122a
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1cf8(%rip), %rdi      # 0x304b
movl -0x2c(%rbp), %ebx
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x1cee(%rip), %rdi      # 0x3054
xorl %eax, %eax
callq 0x1070
movq %r14, %rdi
movl %ebx, %esi
callq 0x11da
leaq 0x1cde(%rip), %rdi      # 0x305c
xorl %eax, %eax
callq 0x1070
movq %r13, %rdi
movl %ebx, %esi
callq 0x11da
leaq 0x1ccc(%rip), %rdi      # 0x3062
xorl %eax, %eax
callq 0x1070
movq %r12, %rdi
movl %ebx, %esi
callq 0x11da
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x13de
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 0x13ac
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 0x13ac
movl %ebp, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
pushq $0x8
popq %r12
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x13cf
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)
cvtsi2sd %r13d, %xmm1
mulsd 0x1ba5(%rip), %xmm1     # 0x3020
divsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
mulsd 0x1b8b(%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 0x151d
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
jmp 0x1438
ucomisd %xmm1, %xmm1
jnp 0x14d4
xorpd 0x1b05(%rip), %xmm3     # 0x3030
movapd %xmm5, %xmm0
movapd %xmm6, %xmm1
callq 0x2690
jmp 0x14d4
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl %edi, %r14d
movq %r14, %rsi
shlq $0x4, %rsi
movl $0x100, %edi            # imm = 0x100
callq 0x10b0
movq %rax, 0x3b1e(%rip)      # 0x5080
testq %rax, %rax
je 0x15d5
movl %ebx, %eax
cvtsi2sd %rax, %xmm0
movsd 0x1afa(%rip), %xmm1     # 0x3070
movsd %xmm0, 0x8(%rsp)
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
pushq $0x8
popq %rbx
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x15cb
movl %r15d, %eax
cvtsi2sd %rax, %xmm1
mulsd 0x1ad8(%rip), %xmm1     # 0x3078
divsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
callq 0x1060
movq 0x3ac9(%rip), %rax      # 0x5080
movsd %xmm0, -0x8(%rax,%rbx)
movsd %xmm1, (%rax,%rbx)
incq %r15
addq $0x10, %rbx
jmp 0x158b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1aac(%rip), %rdi      # 0x3088
leaq 0x1aae(%rip), %rsi      # 0x3091
leaq 0x1ab2(%rip), %rcx      # 0x309c
pushq $0x21
popq %rdx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %r12d
movq %r12, %r14
shlq $0x4, %r14
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
callq 0x10b0
movq %rax, %r15
movq %rax, 0x3a60(%rip)      # 0x5080
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
callq 0x10b0
movq %rax, 0x3a54(%rip)      # 0x5088
testq %r15, %r15
je 0x16e3
movl %ebx, %eax
cvtsi2sd %rax, %xmm0
movsd 0x1a24(%rip), %xmm1     # 0x3070
movsd %xmm0, 0x8(%rsp)
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
pushq $0x8
popq %rbx
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x16d7
movl %r14d, %eax
cvtsi2sd %rax, %xmm1
mulsd 0x1a02(%rip), %xmm1     # 0x3078
movsd %xmm1, 0x10(%rsp)
divsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
callq 0x1060
movq 0x39ed(%rip), %rax      # 0x5080
movsd %xmm0, -0x8(%rax,%rbx)
movsd %xmm1, (%rax,%rbx)
movsd 0x10(%rsp), %xmm1
mulsd 0x19d4(%rip), %xmm1     # 0x3080
divsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
callq 0x1060
movq 0x39c5(%rip), %rax      # 0x5088
movsd %xmm0, -0x8(%rax,%rbx)
movsd %xmm1, (%rax,%rbx)
incq %r14
addq $0x10, %rbx
jmp 0x1661
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x199e(%rip), %rdi      # 0x3088
leaq 0x19a0(%rip), %rsi      # 0x3091
leaq 0x19d3(%rip), %rcx      # 0x30cb
pushq $0x30
popq %rdx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/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, 0x396f(%rip)      # 0x5090
testq %rax, %rax
je 0x178d
bsrl %ebx, %edx
notl %edx
addl $0x21, %edx
movl %ebx, %esi
xorl %r9d, %r9d
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rsi, %r9
jae 0x178b
leaq 0x2(%r9), %r10
leal -0x2(%r10), %ecx
xorl %r10d, %ecx
bsrl %ecx, %r11d
movl %r8d, %ebx
subl %edi, %ebx
movl %edx, %ecx
shrl %cl, %ebx
xorl $0x1f, %r11d
movb $0x1e, %cl
subb %r11b, %cl
movl $0x20000000, %r11d      # imm = 0x20000000
shrl %cl, %r11d
movl %ebx, (%rax,%r9,2)
leal -0x1(%r11), %ecx
movl %r11d, %ebx
andl %r8d, %ebx
andl %ecx, %edi
orl %ebx, %edi
andl %r8d, %ecx
xorl %r11d, %ebx
addl %ebx, %ebx
orl %ecx, %ebx
movq %r10, %r9
movl %ebx, %r8d
jmp 0x1738
popq %rbx
retq
leaq 0x1969(%rip), %rdi      # 0x30fd
leaq 0x196f(%rip), %rsi      # 0x310a
leaq 0x1977(%rip), %rcx      # 0x3119
pushq $0x20
popq %rdx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/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, 0x38cb(%rip)      # 0x5098
testq %rax, %rax
je 0x17de
bsrl %ebx, %edi
xorl %esi, %esi
movl %edi, %edx
xorl %ecx, %ecx
popq %rbx
jmp 0x17fb
leaq 0x1959(%rip), %rdi      # 0x313e
leaq 0x195f(%rip), %rsi      # 0x314b
leaq 0x1967(%rip), %rcx      # 0x315a
pushq $0x37
popq %rdx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r13
movl %r12d, %ecx
shll %cl, %r13d
cmpl $0x2, %r15d
je 0x1881
cmpl $0x1, %r15d
je 0x1875
leal -0x1(%r15), %edx
movl %ebp, %edi
movl %r14d, %esi
movl %ebx, %ecx
callq 0x17fb
addl $-0x2, %r15d
pushq $0x2
popq %rsi
movl %r15d, %ecx
shll %cl, %esi
addl %r14d, %esi
addl %ebx, %r13d
movl %ebp, %edi
movl %r15d, %edx
movl %r13d, %ecx
callq 0x17fb
pushq $0x3
popq %rdx
movl %edx, %eax
movl %r15d, %ecx
shll %cl, %eax
movl %r12d, %ecx
shll %cl, %edx
addl %eax, %r14d
addl %edx, %ebx
addl $0x2, %r12d
jmp 0x1816
movq 0x381c(%rip), %rax      # 0x5098
shrl %r14d
jmp 0x1895
movq 0x3810(%rip), %rax      # 0x5098
shrl %r14d
movl %ebx, (%rax,%r14,4)
addl %r13d, %ebx
incl %r14d
movl %r14d, %ecx
movl %ebx, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
bsrl %edi, %r14d
leal (,%r14,4), %edi
callq 0x1090
movq %rax, 0x37ca(%rip)      # 0x50a0
testq %rax, %rax
je 0x1953
movl %r14d, %edi
leaq 0x189b(%rip), %rcx      # 0x3180
movq %rax, %rdx
movq %rdi, %rsi
subq $0x1, %rsi
jb 0x1901
movl %edi, %edi
movl (%rcx,%rdi,4), %edi
movl %edi, (%rdx)
addq $0x4, %rdx
movq %rsi, %rdi
jmp 0x18eb
movl (%rax), %r14d
leal 0x1(%r14), %edi
shlq $0x2, %rdi
callq 0x1090
movq %rax, 0x3790(%rip)      # 0x50a8
testq %rax, %rax
je 0x196c
xorl %ecx, %ecx
xorl %edi, %edi
movl %ecx, %edx
cmpl %r14d, %ecx
jae 0x1948
leal 0x1(%rdi), %esi
xorl %esi, %edi
bsrl %edi, %r8d
notl %r8d
movl %esi, %edi
testb $0x1, %r8b
je 0x1921
incl %ecx
leal -0x1(%rsi), %edi
movl %edi, (%rax,%rdx,4)
movl %esi, %edi
jmp 0x1921
movl %ebx, (%rax,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18a6(%rip), %rdi      # 0x3200
leaq 0x18ac(%rip), %rsi      # 0x320d
leaq 0x18b4(%rip), %rcx      # 0x321c
pushq $0x25
jmp 0x1983
leaq 0x18ce(%rip), %rdi      # 0x3241
leaq 0x1893(%rip), %rsi      # 0x320d
leaq 0x189b(%rip), %rcx      # 0x321c
pushq $0x2b
popq %rdx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edi, %eax
shlq $0x4, %rax
leal (%rdi,%rdi), %ecx
shlq $0x4, %rcx
leal (%rdi,%rdi,2), %edx
shlq $0x4, %rdx
movupd (%rsi), %xmm0
movupd (%rsi,%rcx), %xmm1
movupd (%rsi,%rdx), %xmm2
movapd %xmm1, %xmm3
addpd %xmm2, %xmm3
movupd (%rsi,%rax), %xmm4
subpd %xmm2, %xmm1
shufpd $0x1, %xmm1, %xmm1      # xmm1 = xmm1[1,0]
movapd %xmm0, %xmm2
addpd %xmm3, %xmm2
movupd %xmm2, (%rsi)
movapd %xmm4, %xmm2
addpd %xmm1, %xmm2
subpd %xmm1, %xmm4
movapd %xmm4, %xmm1
movsd %xmm2, %xmm1            # xmm1 = xmm2[0],xmm1[1]
movupd %xmm1, (%rsi,%rax)
subpd %xmm3, %xmm0
movupd %xmm0, (%rsi,%rcx)
shufpd $0x2, %xmm2, %xmm4      # xmm4 = xmm4[0],xmm2[1]
movupd %xmm4, (%rsi,%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x2ebc(%rip), %rbx      # 0x4080
leaq 0x32a5(%rip), %r14      # 0x4470
movq %rsp, %r12
leaq 0xe2f(%rip), %rbp       # 0x2004
leaq 0xe2d(%rip), %r15       # 0x2009
leaq 0xe35(%rip), %r13       # 0x2018
callq 0x130b
cmpl $-0x1, %eax
je 0x12f7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1030
callq 0x130b
cmpl $0xa, %eax
je 0x12ea
movl 0x32c4(%rip), %eax      # 0x44d4
testl %eax, %eax
je 0x12c8
cmpl $0x2a, %eax
je 0x12b2
cmpl $0x2, %eax
je 0x125c
cmpl $0x1, %eax
jne 0x12a0
cmpb $0x2a, 0x2e4e(%rip)     # 0x4080
jne 0x124f
movq %r12, %rdi
movq %rbp, %rsi
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
cmpb $0x2a, 0x2e1d(%rip)     # 0x4080
jne 0x1280
movq %r12, %rdi
movq %rbp, %rsi
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 %r13, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1050
jmp 0x11fc
movq %r12, %rdi
leaq 0xd52(%rip), %rsi       # 0x200e
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1080
jmp 0x12df
movq %r12, %rdi
leaq 0xd40(%rip), %rsi       # 0x2012
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x11f7
movq %rbx, %rdi
callq 0x1040
jmp 0x11e3
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_O2/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 0x13e3
callq 0x141b
callq 0x13e3
movq 0x2cbb(%rip), %r14      # 0x3fe0
movq (%r14), %rdi
callq 0x1090
cmpl $0x5b, %eax
je 0x135f
movl %eax, %ebx
cmpl $0x28, %eax
jne 0x1389
callq 0x13e3
movq (%r14), %rdi
callq 0x1090
cmpl $0x29, %eax
jne 0x13b8
movb $0x0, 0x3120(%rip)      # 0x4472
movw $0x2928, 0x3115(%rip)   # imm = 0x2928
pushq $0x1
jmp 0x13d2
callq 0x13e3
leaq 0x3105(%rip), %rdi      # 0x4470
pushq $0x64
popq %rsi
callq 0x1486
callq 0x13e3
movq (%r14), %rdi
callq 0x1090
cmpl $0x5d, %eax
jne 0x13c6
pushq $0x2
jmp 0x13d2
callq 0x10a0
movq (%rax), %rax
movslq %ebx, %rcx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x13d3
movq (%r14), %rsi
movl %ebx, %edi
callq 0x1060
leaq 0x30c4(%rip), %rdi      # 0x4470
pushq $0x64
popq %rsi
callq 0x1486
xorl %ebx, %ebx
jmp 0x13d3
movq (%r14), %rsi
movl %eax, %edi
callq 0x1060
pushq $0x28
jmp 0x13d2
movq (%r14), %rsi
movl %eax, %edi
callq 0x1060
pushq $0x5b
popq %rbx
movl %ebx, 0x30fb(%rip)      # 0x44d4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2bbd(%rip), %rbx      # 0x3fe0
movq (%rbx), %rdi
callq 0x1090
cmpl $0x2f, %eax
jne 0x147b
movq (%rbx), %rdi
callq 0x1090
cmpl $0x2f, %eax
je 0x1469
cmpl $0x2a, %eax
jne 0x147b
movq (%rbx), %rdi
callq 0x1090
cmpl $0x2a, %eax
je 0x1454
cmpl $-0x1, %eax
jne 0x1442
movq (%rbx), %rdi
callq 0x1090
movl %eax, %ecx
cmpl $0x2f, %eax
pushq $0xa
popq %rax
cmovnel %ecx, %eax
jmp 0x147b
movq (%rbx), %rdi
callq 0x1090
cmpl $-0x1, %eax
je 0x147b
cmpl $0xa, %eax
jne 0x1469
movq (%rbx), %rsi
movl %eax, %edi
popq %rbx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r12d, %r12d
callq 0x10a0
movq %rax, %r15
movq 0x2b37(%rip), %r13      # 0x3fe0
movq (%r15), %rbp
movq (%r13), %rdi
callq 0x1090
movslq %eax, %rcx
testb $0x8, (%rbp,%rcx,2)
sete %dl
cmpl $0x5f, %ecx
setne %cl
testb %dl, %cl
jne 0x14d8
cmpq %r14, %r12
jae 0x14d8
movb %al, (%rbx,%r12)
incq %r12
jmp 0x14a9
movb $0x0, (%rbx,%r12)
movq (%r13), %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_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
leaq -0x30(%rbp), %rsi
pushq $0x10
popq %rdx
callq 0x2571
testl %eax, %eax
jle 0x1c7c
movl %eax, %ebx
leaq 0x3b13(%rip), %rdi      # 0x5717
xorl %eax, %eax
callq 0x1080
movl %ebx, %r15d
leaq 0x3b12(%rip), %r14      # 0x5727
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x1c32
movzbl -0x30(%rbp,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1080
incq %r12
jmp 0x1c18
leaq 0x367a(%rip), %r14      # 0x52b3
cmpl $0x10, %ebx
jae 0x1c4c
movq %r14, %rdi
xorl %eax, %eax
callq 0x1080
incl %ebx
jmp 0x1c39
xorl %ebx, %ebx
pushq $0x2e
popq %r14
cmpq %rbx, %r15
je 0x1c74
movzbl -0x30(%rbp,%rbx), %eax
leal -0x20(%rax), %ecx
cmpb $0x5f, %cl
jb 0x1c67
movl %r14d, %eax
movzbl %al, %edi
callq 0x1040
incq %rbx
jmp 0x1c52
pushq $0xa
popq %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, %edx
movq %rdi, %rbx
leaq -0xa8(%rbp), %rsi
callq 0x3895
testl %eax, %eax
je 0x1cc4
leaq 0x3fe0(%rip), %rdi      # 0x5c99
callq 0x1070
pushq $-0x1
popq %r14
jmp 0x1d1d
leaq -0xa8(%rbp), %r15
movzwl 0x2(%r15), %esi
leaq 0x3a56(%rip), %rdi      # 0x572d
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x1080
pushq $0x1
popq %r12
pushq $-0x1
popq %r13
leal -0x1(%r12), %eax
movzwl -0xa6(%rbp), %ecx
cmpl %ecx, %eax
jae 0x1d1d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a8b
testl %eax, %eax
jne 0x1d1a
movq %r15, %rdi
movl %r12d, %esi
callq 0x2324
incl %r12d
testl %eax, %eax
je 0x1ce9
movl %r13d, %r14d
movl %r14d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0xb8(%rbp), %rsi
movl %r14d, %edx
callq 0x3bc2
testl %eax, %eax
je 0x1d80
leaq 0x3f57(%rip), %rdi      # 0x5cbd
callq 0x1070
pushq $-0x1
popq %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl -0xb6(%rbp), %esi
leaq 0x3ae6(%rip), %rdi      # 0x5874
xorl %eax, %eax
callq 0x1080
pushq $0x1
popq %r15
cmpl $0x53, %r14d
jne 0x1ec4
leal -0x1(%r15), %eax
movzwl -0xb6(%rbp), %ecx
cmpl %ecx, %eax
jae 0x1f61
movq %rbx, %rdi
leaq -0xb8(%rbp), %rsi
callq 0x3915
testl %eax, %eax
jne 0x1d6b
movzwl -0xb4(%rbp), %eax
cvtsi2sd %eax, %xmm0
divsd 0x322c(%rip), %xmm0     # 0x5008
movzwl -0xae(%rbp), %r10d
movl %r10d, %edx
andl $0x3, %edx
movl %r10d, %ecx
shrl $0x2, %ecx
andl $0x3, %ecx
movl %r10d, %r8d
shrl $0x4, %r8d
andl $0x1, %r8d
movl %r10d, %r9d
shrl $0x5, %r9d
andl $0x1, %r9d
movl %r10d, %r11d
shrl $0x6, %r11d
andl $0x1, %r11d
movl %r10d, %r14d
shrl $0x7, %r14d
andl $0x1, %r14d
movl %r10d, %r12d
shrl $0x8, %r12d
andl $0x1, %r12d
shrl $0x9, %r10d
andl $0x3, %r10d
movzwl -0xac(%rbp), %r13d
subq $0x8, %rsp
leaq 0x3a55(%rip), %rdi      # 0x589a
movl %r15d, %esi
movb $0x1, %al
pushq %r13
pushq %r10
pushq %r12
pushq %r14
pushq %r11
callq 0x1080
addq $0x30, %rsp
testb $0x10, -0xae(%rbp)
jne 0x1ead
testb $0x1, -0xb8(%rbp)
leaq 0x392b(%rip), %rsi      # 0x579f
leaq 0x3929(%rip), %rax      # 0x57a4
cmoveq %rax, %rsi
movzbl -0xb2(%rbp), %edx
movzbl -0xb1(%rbp), %ecx
movzbl -0xb0(%rbp), %r8d
movzbl -0xaf(%rbp), %r9d
leaq 0x38d6(%rip), %rdi      # 0x577a
xorl %eax, %eax
callq 0x1080
jmp 0x1ebc
leaq -0xa8(%rbp), %rdi
movl %r15d, %esi
callq 0x2324
incl %r15d
jmp 0x1da3
leaq 0x38d9(%rip), %r12      # 0x57a4
leaq 0x38cd(%rip), %r13      # 0x579f
leaq 0x38a1(%rip), %r14      # 0x577a
leal -0x1(%r15), %eax
movzwl -0xb6(%rbp), %ecx
cmpl %ecx, %eax
jae 0x1f61
movq %rbx, %rdi
leaq -0xb8(%rbp), %rsi
callq 0x38db
testl %eax, %eax
jne 0x1d6b
movzwl -0xb4(%rbp), %eax
cvtsi2sd %eax, %xmm0
divsd 0x30f6(%rip), %xmm0     # 0x5008
leaq 0x3a3c(%rip), %rdi      # 0x5955
movl %r15d, %esi
movb $0x1, %al
callq 0x1080
testb $0x1, -0xb8(%rbp)
movq %r13, %rsi
cmoveq %r12, %rsi
movzbl -0xb2(%rbp), %edx
movzbl -0xb1(%rbp), %ecx
movzbl -0xb0(%rbp), %r8d
movzbl -0xaf(%rbp), %r9d
movq %r14, %rdi
xorl %eax, %eax
callq 0x1080
incl %r15d
jmp 0x1ed9
xorl %eax, %eax
jmp 0x1d6e
// File: /workspace/github_c_makefile_star2_O2/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 0x2d6d(%rip), %xmm2     # 0x5008
divsd %xmm2, %xmm0
cvtsi2sdl 0x18(%rdi), %xmm1
divsd %xmm2, %xmm1
movzbl 0x3(%rdi), %r9d
leaq 0x3946(%rip), %rdi      # 0x5bfa
movb $0x2, %al
callq 0x1080
movb (%rbx), %al
testb $0x1, %al
je 0x22eb
cvtsi2sdl 0x4(%rbx), %xmm0
movsd 0x2d4a(%rip), %xmm2     # 0x5018
mulsd %xmm2, %xmm0
cvtsi2sdl 0x8(%rbx), %xmm1
mulsd %xmm2, %xmm1
leaq 0x3964(%rip), %rdi      # 0x5c46
movb $0x2, %al
callq 0x1080
movb (%rbx), %al
testb $0x2, %al
jne 0x22f6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cvtsi2sdl 0xc(%rbx), %xmm0
movsd 0x2d15(%rip), %xmm2     # 0x5018
mulsd %xmm2, %xmm0
cvtsi2sdl 0x10(%rbx), %xmm1
mulsd %xmm2, %xmm1
leaq 0x3942(%rip), %rdi      # 0x5c59
movb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x2504
movq %rdi, %r15
movl 0x10(%rdi), %edi
testl %edi, %edi
js 0x2504
movq %rsi, %r14
xorl %edx, %edx
callq 0x1090
cmpq %r14, %rax
jne 0x2504
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_O2/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 0x256a
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x256a
movb $0x0, 0x71(%rdi)
popq %rbp
jmpq *%rax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x25c8
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rcx
testq %rcx, %rcx
je 0x25c4
movl %edx, %r14d
movq 0x60(%rbx), %rdx
testq %rdx, %rdx
je 0x25b3
movq 0x8(%rbx), %rdi
xorl %eax, %eax
cmpq %rdi, %rdx
jbe 0x25c4
movslq %r14d, %rax
addq %rdi, %rax
cmpq %rdx, %rax
jbe 0x25b3
subl %edi, %edx
movl %edx, %r14d
movq %rbx, %rdi
movl %r14d, %edx
callq *%rcx
cmpl %r14d, %eax
jge 0x25c4
movb $0x1, 0x71(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x2571
movb (%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x25d3
movb %al, (%rbx)
movq %r14, %rdi
callq 0x25d3
movb %al, 0x1(%rbx)
movq %r14, %rdi
callq 0x25d3
movb %al, 0x2(%rbx)
movq %r14, %rdi
callq 0x25d3
movb %al, 0x3(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x25d3
movb %al, (%rbx)
movq %r14, %rdi
callq 0x25d3
movb %al, 0x1(%rbx)
movq %r14, %rdi
callq 0x25d3
movb %al, 0x2(%rbx)
movb $-0x1, 0x3(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_read_UB
swf_UI32 swf_reader_read_UB(swf_reader *swf,int bits) {
	swf_UI32 r = 0;
	int avail;

	if (bits <= 0 || bits > 32) return 0;

	while (bits > 0) {
		if (swf->bit_buffer_bits == 0) {
			swf->bit_buffer = swf_reader_read_UI8(swf);
			swf->bit_buffer_bits = 8;
		}

		avail = swf->bit_buffer_bits;
		if (avail > bits) avail = bits;
		swf->bit_buffer_bits -= avail;
		r <<= (swf_UI32)avail;
		r |= (((swf_UI32)swf->bit_buffer >> (swf_UI32)swf->bit_buffer_bits)) &
			(((swf_UI32)1 << (swf_UI32)avail) - 1);
		bits -= avail;
	}

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
leal -0x21(%r14), %eax
xorl %ebx, %ebx
cmpl $-0x20, %eax
jae 0x26b8
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r15
xorl %ebx, %ebx
pushq $-0x1
popq %r12
testl %r14d, %r14d
jle 0x26ad
movb 0x59(%r15), %cl
testb %cl, %cl
je 0x26d4
movb 0x58(%r15), %al
jmp 0x26e2
movq %r15, %rdi
callq 0x25d3
movb %al, 0x58(%r15)
movb $0x8, %cl
movzbl %cl, %edx
cmpl %edx, %r14d
movl %edx, %esi
cmovbl %r14d, %esi
movl %esi, %ecx
shll %cl, %ebx
subb %sil, %dl
movb %dl, 0x59(%r15)
movzbl %al, %eax
movl %edx, %ecx
shrl %cl, %eax
movl %r12d, %edx
movl %esi, %ecx
shll %cl, %edx
notl %edx
andl %eax, %edx
orl %edx, %ebx
subl %esi, %r14d
jmp 0x26c1
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_read_SB
swf_SI32 swf_reader_read_SB(swf_reader *swf,int bits) {
	swf_UI32 r = 0;

	/* FIXME: Do we sign-extend if the field is only 1 bit long and bit is set? */
	if (bits <= 0 || bits > 32) return 0;
	r = swf_reader_read_UB(swf,bits);
	if (r & ((swf_UI32)1 << ((swf_UI32)(bits-1))))
		r |= (swf_UI32)0xFFFFFFFF << bits;

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
leal -0x21(%rbx), %ecx
xorl %eax, %eax
cmpl $-0x20, %ecx
jb 0x2744
movl %ebx, %esi
callq 0x2694
movl %eax, %edx
leal -0x1(%rbx), %eax
movzbl %al, %esi
pushq $-0x1
popq %rdi
movl %ebx, %ecx
shll %cl, %edi
xorl %eax, %eax
btl %esi, %edx
cmovbl %edi, %eax
orl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_read_RECT
void swf_reader_read_RECT(swf_reader *swf,swf_RECT *rect) {
	swf_reader_read_bytealign(swf);				/* "The RECT record must be byte aligned" */
	rect->Nbits = swf_reader_read_UB(swf,5);		/* UB[5] */
	rect->Xmin = swf_reader_read_SB(swf,rect->Nbits);	/* SB[Nbits] */
	rect->Xmax = swf_reader_read_SB(swf,rect->Nbits);	/* SB[Nbits] */
	rect->Ymin = swf_reader_read_SB(swf,rect->Nbits);	/* SB[Nbits] */
	rect->Ymax = swf_reader_read_SB(swf,rect->Nbits);	/* SB[Nbits] */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, 0x59(%rdi)
pushq $0x5
popq %rsi
callq 0x2694
movb %al, (%rbx)
movzbl %al, %esi
movq %r14, %rdi
callq 0x2712
movl %eax, 0x4(%rbx)
movzbl (%rbx), %esi
movq %r14, %rdi
callq 0x2712
movl %eax, 0x8(%rbx)
movzbl (%rbx), %esi
movq %r14, %rdi
callq 0x2712
movl %eax, 0xc(%rbx)
movzbl (%rbx), %esi
movq %r14, %rdi
callq 0x2712
movl %eax, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_read_UI16
swf_UI16 swf_reader_read_UI16(swf_reader *swf) {
	unsigned char buf[2] = {0};
	swf_reader_read_bytealign(swf);
	swf_reader_read(swf,buf,2);
	return (swf_UI16)__le_u16(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0xa(%rbp), %rbx
andw $0x0, (%rbx)
movb $0x0, 0x59(%rdi)
pushq $0x2
popq %rdx
movq %rbx, %rsi
callq 0x2571
movzwl (%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_read_UI32
swf_UI32 swf_reader_read_UI32(swf_reader *swf) {
	unsigned char buf[4] = {0};
	swf_reader_read_bytealign(swf);
	swf_reader_read(swf,buf,4);
	return (swf_UI32)__le_u32(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0xc(%rbp), %rbx
andl $0x0, (%rbx)
movb $0x0, 0x59(%rdi)
pushq $0x4
popq %rdx
movq %rbx, %rsi
callq 0x2571
movl (%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_uncompressed_seek
int swf_reader_uncompressed_seek(void *io,uint64_t pos) {
	swf_reader *r = (swf_reader*)io;
	int rd;

	rd = swf_reader_raw_seek((swf_reader*)io,pos);
	r->current_pos = r->raw_current_pos;
	return rd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x289b
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x289b
movq %rbx, %rdi
callq *%rcx
movq (%rbx), %rcx
movq %rcx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_uncompressed_read
int swf_reader_uncompressed_read(void *io,void *buf,int len) {
	swf_reader *r = (swf_reader*)io;
	int rd;

	rd = swf_reader_raw_read((swf_reader*)io,buf,len);
	r->current_pos = r->raw_current_pos;
	return rd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0x28c8
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x28c8
movq %rbx, %rdi
callq *%rcx
movq (%rbx), %rcx
movq %rcx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_stock_raw_read
int swf_reader_stock_raw_read(void *io,void *buf,int len) {
	swf_reader *swf = (swf_reader*)io;
	int rd;

	if (swf == NULL) return -1;
	if (swf->file_fd < 0) return -1;
	if (len <= 0) return 0;
	rd = read(swf->file_fd,buf,len);
	if (rd < 0) return -1;
	swf->raw_current_pos += (uint64_t)rd;
	return rd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x290f
movq %rdi, %r14
movl 0x10(%rdi), %edi
testl %edi, %edi
js 0x290f
testl %edx, %edx
jle 0x290d
movl %edx, %edx
callq 0x10d0
testl %eax, %eax
js 0x290f
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq %rcx, (%r14)
movl %eax, %ebx
jmp 0x290f
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_close_file
void swf_reader_close_file(swf_reader *r) {
	if (r->zlib.next_in != NULL) {
		inflateEnd(&r->zlib);
		memset(&r->zlib,0,sizeof(r->zlib));
	}
	if (r->lzma.next_in != NULL) {
		lzma_end(&r->lzma);
		memset(&r->lzma,0,sizeof(r->lzma));
	}
	r->decom_buf = sliding_window_v4_destroy(r->decom_buf);
	r->out_buf = sliding_window_v4_destroy(r->out_buf);
	if (r->file_fd >= 0) {
		if (r->file_fd_owner) close(r->file_fd);
		r->file_fd = -1;
	}
	r->file_fd_owner = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x88(%rdi)
je 0x2980
leaq 0x88(%rbx), %r14
movq %r14, %rdi
callq 0x1110
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x60(%r14)
cmpq $0x0, 0xf8(%rbx)
je 0x29a8
leaq 0xf8(%rbx), %r14
movq %r14, %rdi
callq 0x1130
movl $0x88, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
movq 0x78(%rbx), %rdi
callq 0x47fe
movq %rax, 0x78(%rbx)
movq 0x80(%rbx), %rdi
callq 0x47fe
movq %rax, 0x80(%rbx)
movl 0x10(%rbx), %edi
testl %edi, %edi
js 0x29de
cmpb $0x0, 0x14(%rbx)
je 0x29da
callq 0x10c0
orl $-0x1, 0x10(%rbx)
movb $0x0, 0x14(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_create
swf_reader *swf_reader_create() {
	swf_reader *r = (swf_reader*)malloc(sizeof(swf_reader));
	if (r == NULL) return NULL;
	if (swf_reader_init(r)) {
		free(r);
		return NULL;
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq $0x1
popq %rdi
movl $0x180, %esi            # imm = 0x180
callq 0x10e0
testq %rax, %rax
je 0x2a0b
orl $-0x1, 0x10(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/swf.c
// Function: swf_reader_destroy
swf_reader *swf_reader_destroy(swf_reader *r) {
	if (r != NULL) {
		swf_reader_free(r);
		free(r);
	}

	return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x2a2e
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2938
movq %rbx, %rdi
callq 0x1030
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq