LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat4x4transformvec3
vec3_t mat4x4transformvec3(mat4x4_t m,vec3_t v)
{
	float w=v.x*m.m[3]+v.y*m.m[7]+v.z*m.m[11]+m.m[15];
	return vec3(
	(v.x*m.m[0]+v.y*m.m[4]+v.z*m.m[8]+m.m[12])/w,
	(v.x*m.m[1]+v.y*m.m[5]+v.z*m.m[9]+m.m[13])/w,
	(v.x*m.m[2]+v.y*m.m[6]+v.z*m.m[10]+m.m[14])/w);
}

// Assembly:
movsldup %xmm0, %xmm2            # xmm2 = xmm0[0,0,2,2]
movsd 0x10(%rsp), %xmm4
movsldup %xmm1, %xmm3            # xmm3 = xmm1[0,0,2,2]
movsd 0x30(%rsp), %xmm6
movsd 0x20(%rsp), %xmm5
movshdup %xmm0, %xmm0            # xmm0 = xmm0[1,1,3,3]
movsd 0x40(%rsp), %xmm1
movsd 0x18(%rsp), %xmm7
mulps %xmm3, %xmm6
mulps %xmm2, %xmm4
mulps %xmm0, %xmm5
mulps %xmm0, %xmm7
movaps 0x3974(%rip), %xmm0     # 0xc530
addps %xmm6, %xmm1
addps %xmm4, %xmm5
movsd 0x8(%rsp), %xmm6
mulps %xmm2, %xmm6
movsd 0x28(%rsp), %xmm2
mulps %xmm3, %xmm2
movsd 0x38(%rsp), %xmm3
addps %xmm5, %xmm1
addps %xmm6, %xmm7
addps %xmm2, %xmm3
movshdup %xmm1, %xmm4            # xmm4 = xmm1[1,1,3,3]
rcpps %xmm4, %xmm5
divss %xmm4, %xmm1
addps %xmm7, %xmm3
mulps %xmm5, %xmm4
subps %xmm4, %xmm0
mulps %xmm5, %xmm0
addps %xmm5, %xmm0
mulps %xmm3, %xmm0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat3x3rotate
dmat3x3_t dmat3x3rotate(double angle,dvec3_t axis)
{
	double sine=sin(angle);
	double cosine=cos(angle);
	double one_minus_cosine=1-cosine;

	axis=dvec3norm(axis);

	return dmat3x3(
	cosine + one_minus_cosine*axis.x*axis.x,
	one_minus_cosine*axis.x*axis.y + axis.z*sine,
	one_minus_cosine*axis.x*axis.z - axis.y*sine,

	one_minus_cosine*axis.x*axis.y - axis.z*sine,
	cosine + one_minus_cosine*axis.y*axis.y,
	one_minus_cosine*axis.y*axis.z + axis.x*sine,

	one_minus_cosine*axis.x*axis.z + axis.y*sine,
	one_minus_cosine*axis.y*axis.z - axis.x*sine,
	cosine + one_minus_cosine*axis.z*axis.z);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq -0x70(%rsp), %rsp
leaq 0x48(%rsp), %r15
leaq 0x50(%rsp), %r14
movq %rdi, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x10e0
movsd (%r15), %xmm0
movsd 0x341d(%rip), %xmm1     # 0xc050
subsd %xmm0, %xmm1
movapd %xmm0, 0x30(%rsp)
movapd %xmm1, 0x20(%rsp)
movsd (%r14), %xmm0
leaq 0x58(%rsp), %r14
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x90(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x8d80
movups (%r14), %xmm0
movq 0x10(%r14), %rax
movapd 0x20(%rsp), %xmm3
movsd 0x18(%rsp), %xmm8
movq %rax, 0xa0(%rsp)
movapd %xmm3, %xmm10
movq %rbx, %rax
movaps %xmm0, 0x90(%rsp)
movupd 0x98(%rsp), %xmm1
movsd 0x90(%rsp), %xmm0
movsd 0xa0(%rsp), %xmm5
movapd %xmm0, %xmm2
movapd %xmm5, %xmm7
mulsd %xmm3, %xmm2
mulsd %xmm8, %xmm7
movapd %xmm1, %xmm4
movsd %xmm3, %xmm4            # xmm4 = xmm3[0],xmm4[1]
mulpd %xmm1, %xmm4
movapd %xmm2, %xmm3
movapd %xmm2, %xmm6
mulsd %xmm5, %xmm2
mulsd %xmm0, %xmm3
mulsd %xmm8, %xmm0
mulsd %xmm1, %xmm8
mulsd %xmm1, %xmm6
movapd %xmm2, %xmm5
movapd %xmm8, %xmm9
movapd %xmm4, %xmm8
subsd %xmm9, %xmm5
addsd %xmm2, %xmm9
mulsd %xmm1, %xmm8
shufpd $0x1, %xmm10, %xmm1     # xmm1 = xmm1[1],xmm10[0]
movapd 0x30(%rsp), %xmm10
mulpd %xmm4, %xmm1
movapd %xmm7, %xmm4
addsd %xmm10, %xmm3
addsd %xmm6, %xmm4
subsd %xmm7, %xmm6
addsd %xmm10, %xmm8
movsd %xmm3, (%rbx)
movsd %xmm6, 0x8(%rbx)
movsd %xmm9, 0x10(%rbx)
movsd %xmm4, 0x18(%rbx)
movapd %xmm1, %xmm7
movsd %xmm8, 0x20(%rbx)
subsd %xmm0, %xmm7
unpcklpd %xmm10, %xmm0           # xmm0 = xmm0[0],xmm10[0]
addpd %xmm1, %xmm0
movsd %xmm7, 0x28(%rbx)
movsd %xmm5, 0x30(%rbx)
movupd %xmm0, 0x38(%rbx)
leaq 0x70(%rsp), %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat2x2mul
dmat2x2_t dmat2x2mul(dmat2x2_t a,dmat2x2_t b)
{
	return dmat2x2(a.m[0]*b.m[0]+a.m[2]*b.m[1],
	              a.m[0]*b.m[2]+a.m[2]*b.m[3],

	              a.m[1]*b.m[0]+a.m[3]*b.m[1],
	              a.m[1]*b.m[2]+a.m[3]*b.m[3]);
}

// Assembly:
movapd 0x8(%rsp), %xmm0
movddup 0x28(%rsp), %xmm1       # xmm1 = mem[0,0]
movddup 0x38(%rsp), %xmm4       # xmm4 = mem[0,0]
movapd 0x18(%rsp), %xmm2
movddup 0x30(%rsp), %xmm3       # xmm3 = mem[0,0]
movddup 0x40(%rsp), %xmm5       # xmm5 = mem[0,0]
movq %rdi, %rax
mulpd %xmm0, %xmm1
mulpd %xmm2, %xmm3
mulpd %xmm0, %xmm4
mulpd %xmm2, %xmm5
addpd %xmm1, %xmm3
addpd %xmm4, %xmm5
movupd %xmm3, (%rdi)
movupd %xmm5, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat3x3mul
dmat3x3_t dmat3x3mul(dmat3x3_t a,dmat3x3_t b)
{
	return dmat3x3(a.m[0]*b.m[0]+a.m[3]*b.m[1]+a.m[6]*b.m[2],
	              a.m[0]*b.m[3]+a.m[3]*b.m[4]+a.m[6]*b.m[5],
	              a.m[0]*b.m[6]+a.m[3]*b.m[7]+a.m[6]*b.m[8],

	              a.m[1]*b.m[0]+a.m[4]*b.m[1]+a.m[7]*b.m[2],
	              a.m[1]*b.m[3]+a.m[4]*b.m[4]+a.m[7]*b.m[5],
	              a.m[1]*b.m[6]+a.m[4]*b.m[7]+a.m[7]*b.m[8],

	              a.m[2]*b.m[0]+a.m[5]*b.m[1]+a.m[8]*b.m[2],
	              a.m[2]*b.m[3]+a.m[5]*b.m[4]+a.m[8]*b.m[5],
	              a.m[2]*b.m[6]+a.m[5]*b.m[7]+a.m[8]*b.m[8]);
}

// Assembly:
movsd 0x50(%rsp), %xmm4
movsd 0x60(%rsp), %xmm5
movapd 0x8(%rsp), %xmm12
movapd 0x38(%rsp), %xmm10
movsd 0x18(%rsp), %xmm9
movsd 0x30(%rsp), %xmm8
movsd 0x58(%rsp), %xmm0
movsd 0x80(%rsp), %xmm11
movsd 0x68(%rsp), %xmm14
movsd 0x90(%rsp), %xmm2
movq %rdi, %rax
movddup %xmm4, %xmm7            # xmm7 = xmm4[0,0]
movddup %xmm5, %xmm3            # xmm3 = xmm5[0,0]
movapd %xmm9, %xmm13
movapd %xmm8, %xmm6
movddup %xmm11, %xmm15          # xmm15 = xmm11[0,0]
movapd %xmm0, -0x18(%rsp)
movapd %xmm9, %xmm1
mulsd %xmm11, %xmm9
movapd %xmm2, -0x38(%rsp)
movsd 0x88(%rsp), %xmm11
mulpd %xmm12, %xmm7
mulpd %xmm10, %xmm3
mulsd %xmm4, %xmm13
mulsd %xmm0, %xmm6
movsd 0x48(%rsp), %xmm4
movsd 0x78(%rsp), %xmm0
mulpd %xmm12, %xmm15
mulsd %xmm14, %xmm1
movapd %xmm0, -0x28(%rsp)
addsd %xmm13, %xmm6
movddup %xmm14, %xmm13          # xmm13 = xmm14[0,0]
movddup -0x18(%rsp), %xmm14     # xmm14 = mem[0,0]
mulpd %xmm12, %xmm13
movddup %xmm2, %xmm12           # xmm12 = xmm2[0,0]
movapd %xmm8, %xmm2
mulsd %xmm11, %xmm8
movddup %xmm11, %xmm11          # xmm11 = xmm11[0,0]
mulpd %xmm10, %xmm12
addpd %xmm7, %xmm3
movapd %xmm4, %xmm7
mulsd %xmm5, %xmm7
movddup %xmm0, %xmm5            # xmm5 = xmm0[0,0]
movsd 0x70(%rsp), %xmm0
mulpd %xmm10, %xmm5
movupd 0x20(%rsp), %xmm10
mulsd %xmm0, %xmm2
movddup %xmm0, %xmm0            # xmm0 = xmm0[0,0]
addsd %xmm9, %xmm8
mulpd %xmm10, %xmm14
mulpd %xmm10, %xmm0
mulpd %xmm10, %xmm11
addsd %xmm6, %xmm7
addpd %xmm15, %xmm12
addsd %xmm1, %xmm2
movapd %xmm4, %xmm1
mulsd -0x38(%rsp), %xmm4
mulsd -0x28(%rsp), %xmm1
addpd %xmm13, %xmm5
addsd %xmm8, %xmm4
addsd %xmm2, %xmm1
addpd %xmm14, %xmm3
addpd %xmm11, %xmm12
addpd %xmm0, %xmm5
movupd %xmm3, (%rdi)
movsd %xmm7, 0x10(%rdi)
movupd %xmm5, 0x18(%rdi)
movsd %xmm1, 0x28(%rdi)
movupd %xmm12, 0x30(%rdi)
movsd %xmm4, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat4x4mul
dmat4x4_t dmat4x4mul(dmat4x4_t a,dmat4x4_t b)
{
        dmat4x4_t res;
        for(int i=0;i<16;i++)
        {
                int row=i&3,column=i&12;
                double val=0;
                for(int j=0;j<4;j++) val+=a.m[row+j*4]*b.m[column+j];
                res.m[i]=val;
        }
        return res;
}

// Assembly:
movq %rdi, %rax
leaq 0x88(%rsp), %rcx
leaq 0x8(%rsp), %rdx
xorl %esi, %esi
pushq $-0x20
popq %rdi
cmpq $0x10, %rsi
je 0x9263
movl %esi, %r8d
movl %esi, %r9d
xorpd %xmm0, %xmm0
movq %rdi, %r10
andl $0xc, %r8d
andl $0x3, %r9d
leaq (%rcx,%r8,8), %r8
leaq (%rdx,%r9,8), %r9
testq %r10, %r10
je 0x9259
movsd 0x20(%r8,%r10), %xmm1
mulsd 0x80(%r9,%r10,4), %xmm1
addq $0x8, %r10
addsd %xmm1, %xmm0
jmp 0x9239
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
jmp 0x9216
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat3x2affinemul
dmat3x2_t dmat3x2affinemul(dmat3x2_t a,dmat3x2_t b)
{
	return dmat3x2(a.m[0]*b.m[0]+a.m[2]*b.m[1],
	              a.m[0]*b.m[2]+a.m[2]*b.m[3],
	              a.m[0]*b.m[4]+a.m[2]*b.m[5]+a.m[4],

	              a.m[1]*b.m[0]+a.m[3]*b.m[1],
	              a.m[1]*b.m[2]+a.m[3]*b.m[3],
	              a.m[1]*b.m[4]+a.m[3]*b.m[5]+a.m[5]);
}

// Assembly:
movapd 0x8(%rsp), %xmm0
movddup 0x58(%rsp), %xmm5       # xmm5 = mem[0,0]
movapd 0x18(%rsp), %xmm2
movddup 0x60(%rsp), %xmm6       # xmm6 = mem[0,0]
movddup 0x38(%rsp), %xmm1       # xmm1 = mem[0,0]
movddup 0x48(%rsp), %xmm4       # xmm4 = mem[0,0]
movddup 0x40(%rsp), %xmm3       # xmm3 = mem[0,0]
movq %rdi, %rax
mulpd %xmm0, %xmm5
mulpd %xmm2, %xmm6
mulpd %xmm0, %xmm1
mulpd %xmm0, %xmm4
movddup 0x50(%rsp), %xmm0       # xmm0 = mem[0,0]
mulpd %xmm2, %xmm3
mulpd %xmm2, %xmm0
addpd %xmm5, %xmm6
addpd %xmm1, %xmm3
addpd %xmm4, %xmm0
addpd 0x28(%rsp), %xmm6
movupd %xmm3, (%rdi)
movupd %xmm0, 0x10(%rdi)
movupd %xmm6, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat3x3affinemul
dmat3x3_t dmat3x3affinemul(dmat3x3_t a,dmat3x3_t b)
{
	return dmat3x3(a.m[0]*b.m[0]+a.m[3]*b.m[1],
	              a.m[0]*b.m[3]+a.m[3]*b.m[4],
	              a.m[0]*b.m[6]+a.m[3]*b.m[7]+a.m[6],

	              a.m[1]*b.m[0]+a.m[4]*b.m[1],
	              a.m[1]*b.m[3]+a.m[4]*b.m[4],
	              a.m[1]*b.m[6]+a.m[4]*b.m[7]+a.m[7],

	              0,0,1);
}

// Assembly:
movupd 0x20(%rsp), %xmm3
movddup 0x88(%rsp), %xmm6       # xmm6 = mem[0,0]
movapd 0x8(%rsp), %xmm1
movddup 0x80(%rsp), %xmm5       # xmm5 = mem[0,0]
movddup 0x50(%rsp), %xmm2       # xmm2 = mem[0,0]
movddup 0x68(%rsp), %xmm4       # xmm4 = mem[0,0]
movddup 0x58(%rsp), %xmm0       # xmm0 = mem[0,0]
movq %rdi, %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
mulpd %xmm1, %xmm5
mulpd %xmm1, %xmm2
mulpd %xmm1, %xmm4
movddup 0x70(%rsp), %xmm1       # xmm1 = mem[0,0]
mulpd %xmm3, %xmm6
mulpd %xmm3, %xmm0
mulpd %xmm3, %xmm1
addpd %xmm5, %xmm6
addpd %xmm2, %xmm0
addpd %xmm4, %xmm1
addpd 0x38(%rsp), %xmm6
movupd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movupd %xmm1, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movupd %xmm6, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat4x4det
double dmat4x4det(dmat4x4_t m)
{
	double a0=m.m[0]*m.m[5]-m.m[1]*m.m[4];
	double a1=m.m[0]*m.m[6]-m.m[2]*m.m[4];
	double a2=m.m[0]*m.m[7]-m.m[3]*m.m[4];
	double a3=m.m[1]*m.m[6]-m.m[2]*m.m[5];
	double a4=m.m[1]*m.m[7]-m.m[3]*m.m[5];
	double a5=m.m[2]*m.m[7]-m.m[3]*m.m[6];
	double b0=m.m[8]*m.m[13]-m.m[9]*m.m[12];
	double b1=m.m[8]*m.m[14]-m.m[10]*m.m[12];
	double b2=m.m[8]*m.m[15]-m.m[11]*m.m[12];
	double b3=m.m[9]*m.m[14]-m.m[10]*m.m[13];
	double b4=m.m[9]*m.m[15]-m.m[11]*m.m[13];
	double b5=m.m[10]*m.m[15]-m.m[11]*m.m[14];
	return a0*b5-a1*b4+a2*b3+a3*b2-a4*b1+a5*b0;
}

// Assembly:
movsd 0x18(%rsp), %xmm14
movsd 0x28(%rsp), %xmm4
movupd 0x10(%rsp), %xmm2
movupd 0x20(%rsp), %xmm13
movsd 0x40(%rsp), %xmm5
movsd 0x8(%rsp), %xmm3
movupd 0x30(%rsp), %xmm6
movsd 0x38(%rsp), %xmm10
movsd 0x58(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movsd 0x68(%rsp), %xmm12
movsd 0x80(%rsp), %xmm7
movsd 0x78(%rsp), %xmm15
mulsd %xmm14, %xmm4
movapd %xmm5, %xmm8
unpcklpd %xmm5, %xmm14           # xmm14 = xmm14[0],xmm5[0]
unpcklpd %xmm3, %xmm5            # xmm5 = xmm5[0],xmm3[0]
mulsd %xmm3, %xmm10
movapd %xmm0, %xmm11
movapd %xmm1, -0x38(%rsp)
movapd %xmm15, %xmm9
mulpd %xmm14, %xmm5
mulsd %xmm12, %xmm11
unpcklpd %xmm0, %xmm12           # xmm12 = xmm12[0],xmm0[0]
unpcklpd %xmm7, %xmm0            # xmm0 = xmm0[0],xmm7[0]
mulsd -0x38(%rsp), %xmm9
unpcklpd %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0]
movapd %xmm13, %xmm14
movapd %xmm2, -0x28(%rsp)
movsd 0x60(%rsp), %xmm2
mulpd %xmm6, %xmm3
shufpd $0x1, %xmm6, %xmm14     # xmm14 = xmm14[1],xmm6[0]
unpcklpd %xmm2, %xmm15           # xmm15 = xmm15[0],xmm2[0]
movsd %xmm4, -0x40(%rsp)
movapd %xmm13, %xmm4
mulsd %xmm6, %xmm4
shufpd $0x1, %xmm13, %xmm6     # xmm6 = xmm6[1],xmm13[0]
subsd -0x40(%rsp), %xmm10
subsd %xmm9, %xmm11
mulpd %xmm13, %xmm6
movapd %xmm7, %xmm13
unpcklpd %xmm1, %xmm7            # xmm7 = xmm7[0],xmm1[0]
movupd 0x60(%rsp), %xmm1
mulpd %xmm0, %xmm7
movupd 0x70(%rsp), %xmm0
mulpd %xmm15, %xmm1
movsd 0x50(%rsp), %xmm15
movapd %xmm4, -0x18(%rsp)
movapd -0x28(%rsp), %xmm4
mulsd %xmm15, %xmm13
mulsd %xmm0, %xmm2
unpcklpd %xmm0, %xmm15           # xmm15 = xmm15[0],xmm0[0]
mulpd 0x48(%rsp), %xmm0
mulpd %xmm4, %xmm14
mulpd %xmm12, %xmm15
mulsd %xmm4, %xmm8
subsd -0x18(%rsp), %xmm8
subpd %xmm6, %xmm5
subsd %xmm13, %xmm2
subpd %xmm1, %xmm7
mulsd %xmm11, %xmm8
subpd %xmm15, %xmm0
subpd %xmm14, %xmm3
mulsd %xmm2, %xmm10
addsd %xmm10, %xmm8
mulpd %xmm3, %xmm7
mulpd %xmm5, %xmm0
haddpd %xmm7, %xmm0
haddpd %xmm0, %xmm0
addsd %xmm8, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat3x3transform
dvec3_t dmat3x3transform(dmat3x3_t m,dvec3_t v)
{
	return dvec3(
	v.x*m.m[0]+v.y*m.m[3]+v.z*m.m[6],
	v.x*m.m[1]+v.y*m.m[4]+v.z*m.m[7],
	v.x*m.m[2]+v.y*m.m[5]+v.z*m.m[8]);
}

// Assembly:
movsd 0x50(%rsp), %xmm1
movsd 0x60(%rsp), %xmm0
movupd 0x20(%rsp), %xmm6
movsd 0x58(%rsp), %xmm4
movq %rdi, %rax
movddup %xmm1, %xmm2            # xmm2 = xmm1[0,0]
movddup %xmm0, %xmm3            # xmm3 = xmm0[0,0]
movddup %xmm4, %xmm5            # xmm5 = xmm4[0,0]
mulsd 0x18(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm4
mulsd 0x48(%rsp), %xmm0
mulpd 0x8(%rsp), %xmm2
mulpd 0x38(%rsp), %xmm3
mulpd %xmm5, %xmm6
addsd %xmm1, %xmm4
addsd %xmm4, %xmm0
addpd %xmm2, %xmm3
addpd %xmm6, %xmm3
movupd %xmm3, (%rdi)
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat4x3transform
dvec3_t dmat4x3transform(dmat4x3_t m,dvec3_t v)
{
	return dvec3(
	v.x*m.m[0]+v.y*m.m[3]+v.z*m.m[6]+m.m[9],
	v.x*m.m[1]+v.y*m.m[4]+v.z*m.m[7]+m.m[10],
	v.x*m.m[2]+v.y*m.m[5]+v.z*m.m[8]+m.m[11]);
}

// Assembly:
movsd 0x68(%rsp), %xmm3
movsd 0x78(%rsp), %xmm0
movupd 0x20(%rsp), %xmm5
movsd 0x70(%rsp), %xmm1
movupd 0x50(%rsp), %xmm6
movq %rdi, %rax
movddup %xmm3, %xmm2            # xmm2 = xmm3[0,0]
movddup %xmm0, %xmm7            # xmm7 = xmm0[0,0]
movddup %xmm1, %xmm4            # xmm4 = xmm1[0,0]
mulsd 0x18(%rsp), %xmm3
mulsd 0x30(%rsp), %xmm1
mulsd 0x48(%rsp), %xmm0
mulpd 0x8(%rsp), %xmm2
mulpd 0x38(%rsp), %xmm7
mulpd %xmm4, %xmm5
addsd %xmm3, %xmm1
addsd %xmm1, %xmm0
addpd %xmm5, %xmm6
addpd %xmm2, %xmm7
addsd 0x60(%rsp), %xmm0
addpd %xmm6, %xmm7
movupd %xmm7, (%rdi)
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat4x4transform
dvec4_t dmat4x4transform(dmat4x4_t m,dvec4_t v)
{
	return dvec4(
	v.x*m.m[0]+v.y*m.m[4]+v.z*m.m[8]+v.w*m.m[12],
	v.x*m.m[1]+v.y*m.m[5]+v.z*m.m[9]+v.w*m.m[13],
	v.x*m.m[2]+v.y*m.m[6]+v.z*m.m[10]+v.w*m.m[14],
	v.x*m.m[3]+v.y*m.m[7]+v.z*m.m[11]+v.w*m.m[15]);
}

// Assembly:
movddup 0x88(%rsp), %xmm1       # xmm1 = mem[0,0]
movapd 0x8(%rsp), %xmm3
movddup 0x90(%rsp), %xmm0       # xmm0 = mem[0,0]
movapd 0x28(%rsp), %xmm2
movddup 0x98(%rsp), %xmm4       # xmm4 = mem[0,0]
movapd 0x48(%rsp), %xmm5
movddup 0xa0(%rsp), %xmm6       # xmm6 = mem[0,0]
movapd 0x68(%rsp), %xmm7
movq %rdi, %rax
mulpd %xmm1, %xmm3
mulpd %xmm0, %xmm2
mulpd %xmm4, %xmm5
mulpd %xmm6, %xmm7
mulpd 0x18(%rsp), %xmm1
mulpd 0x38(%rsp), %xmm0
mulpd 0x58(%rsp), %xmm4
mulpd 0x78(%rsp), %xmm6
addpd %xmm3, %xmm2
addpd %xmm5, %xmm7
addpd %xmm1, %xmm0
addpd %xmm4, %xmm6
addpd %xmm2, %xmm7
addpd %xmm0, %xmm6
movupd %xmm7, (%rdi)
movupd %xmm6, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat3x3transformvec2
dvec2_t dmat3x3transformvec2(dmat3x3_t m,dvec2_t v)
{
	double z=v.x*m.m[2]+v.y*m.m[5]+m.m[8];
	return dvec2(
	(v.x*m.m[0]+v.y*m.m[3]+m.m[6])/z,
	(v.x*m.m[1]+v.y*m.m[4]+m.m[7])/z);
}

// Assembly:
movddup %xmm0, %xmm2            # xmm2 = xmm0[0,0]
movddup %xmm1, %xmm3            # xmm3 = xmm1[0,0]
mulsd 0x18(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm1
mulpd 0x8(%rsp), %xmm2
addsd %xmm0, %xmm1
movsd 0x1795(%rip), %xmm0     # 0xc050
addsd 0x48(%rsp), %xmm1
divsd %xmm1, %xmm0
movupd 0x20(%rsp), %xmm1
mulpd %xmm3, %xmm1
addpd %xmm2, %xmm1
addpd 0x38(%rsp), %xmm1
movddup %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat4x4transformvec3
dvec3_t dmat4x4transformvec3(dmat4x4_t m,dvec3_t v)
{
	double w=v.x*m.m[3]+v.y*m.m[7]+v.z*m.m[11]+m.m[15];
	return dvec3(
	(v.x*m.m[0]+v.y*m.m[4]+v.z*m.m[8]+m.m[12])/w,
	(v.x*m.m[1]+v.y*m.m[5]+v.z*m.m[9]+m.m[13])/w,
	(v.x*m.m[2]+v.y*m.m[6]+v.z*m.m[10]+m.m[14])/w);
}

// Assembly:
movsd 0x88(%rsp), %xmm2
movsd 0x20(%rsp), %xmm3
movsd 0x90(%rsp), %xmm1
movsd 0x40(%rsp), %xmm4
movsd 0x98(%rsp), %xmm0
movsd 0x60(%rsp), %xmm5
movq %rdi, %rax
mulsd %xmm2, %xmm3
mulsd %xmm1, %xmm4
mulsd %xmm0, %xmm5
movddup %xmm0, %xmm6            # xmm6 = xmm0[0,0]
mulsd 0x58(%rsp), %xmm0
mulpd 0x48(%rsp), %xmm6
addsd %xmm3, %xmm4
movsd 0x170e(%rip), %xmm3     # 0xc050
addsd %xmm4, %xmm5
movddup %xmm2, %xmm4            # xmm4 = xmm2[0,0]
mulsd 0x18(%rsp), %xmm2
mulpd 0x8(%rsp), %xmm4
addsd 0x80(%rsp), %xmm5
divsd %xmm5, %xmm3
movddup %xmm1, %xmm5            # xmm5 = xmm1[0,0]
mulsd 0x38(%rsp), %xmm1
mulpd 0x28(%rsp), %xmm5
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addpd %xmm4, %xmm5
addsd 0x78(%rsp), %xmm0
addpd %xmm5, %xmm6
addpd 0x68(%rsp), %xmm6
movddup %xmm3, %xmm1            # xmm1 = xmm3[0,0]
mulsd %xmm3, %xmm0
mulpd %xmm6, %xmm1
movupd %xmm1, (%rdi)
movsd %xmm0, 0x10(%rdi)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/Quaternion.c
// Function: mat3x3quat
mat3x3_t mat3x3quat(quat_t q)
{
	float s2=q.r*q.r;
	float x2=q.i.x*q.i.x;
	float y2=q.i.y*q.i.y;
	float z2=q.i.z*q.i.z;

	return mat3x3(
	s2+x2-y2-z2,
	2*(q.i.x*q.i.y-q.r*q.i.z),
	2*(q.i.x*q.i.z+q.r*q.i.y),

	2*(q.i.x*q.i.y+q.r*q.i.z),
	s2-x2+y2-z2,
	2*(q.i.y*q.i.z-q.r*q.i.x),

	2*(q.i.x*q.i.z-q.r*q.i.y),
	2*(q.i.y*q.i.z+q.r*q.i.x),
	s2-x2-y2+z2);
}

// Assembly:
movshdup %xmm0, %xmm7            # xmm7 = xmm0[1,1,3,3]
movaps %xmm0, %xmm2
movshdup %xmm1, %xmm10           # xmm10 = xmm1[1,1,3,3]
movaps %xmm1, %xmm9
movaps %xmm1, %xmm8
movaps %xmm1, %xmm11
movq %rdi, %rax
movaps %xmm7, %xmm12
mulss %xmm0, %xmm2
movaps %xmm10, %xmm3
movaps %xmm10, %xmm4
movaps %xmm10, %xmm5
mulss %xmm7, %xmm9
mulss %xmm1, %xmm8
mulss %xmm10, %xmm1
mulss %xmm0, %xmm11
mulss %xmm7, %xmm12
mulss %xmm10, %xmm5
mulss %xmm7, %xmm3
mulss %xmm0, %xmm4
mulss %xmm7, %xmm0
movaps %xmm2, %xmm6
movaps %xmm9, %xmm7
subss %xmm12, %xmm2
subss %xmm4, %xmm7
movaps %xmm3, %xmm10
addss %xmm9, %xmm4
movaps %xmm5, %xmm13
movaps %xmm1, %xmm9
addss %xmm12, %xmm6
subss %xmm11, %xmm3
subss %xmm0, %xmm9
addss %xmm1, %xmm0
addss %xmm11, %xmm10
addss %xmm8, %xmm13
movaps %xmm2, %xmm12
subss %xmm8, %xmm2
addss %xmm4, %xmm4
addss %xmm7, %xmm7
addss %xmm3, %xmm3
addss %xmm8, %xmm12
subss %xmm13, %xmm6
addss %xmm0, %xmm0
addss %xmm10, %xmm10
addss %xmm9, %xmm9
addss %xmm5, %xmm2
subss %xmm5, %xmm12
movss %xmm6, (%rdi)
movss %xmm4, 0x4(%rdi)
movss %xmm3, 0x8(%rdi)
movss %xmm7, 0xc(%rdi)
movss %xmm12, 0x10(%rdi)
movss %xmm0, 0x14(%rdi)
movss %xmm10, 0x18(%rdi)
movss %xmm9, 0x1c(%rdi)
movss %xmm2, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/halcy[P]quasi_crystals_bot/Vector/QuaternionDouble.c
// Function: dmat3x3quat
dmat3x3_t dmat3x3quat(dquat_t q)
{
	double s2=q.r*q.r;
	double x2=q.i.x*q.i.x;
	double y2=q.i.y*q.i.y;
	double z2=q.i.z*q.i.z;

	return dmat3x3(
	s2+x2-y2-z2,
	2*(q.i.x*q.i.y-q.r*q.i.z),
	2*(q.i.x*q.i.z+q.r*q.i.y),

	2*(q.i.x*q.i.y+q.r*q.i.z),
	s2-x2+y2-z2,
	2*(q.i.y*q.i.z-q.r*q.i.x),

	2*(q.i.x*q.i.z-q.r*q.i.y),
	2*(q.i.y*q.i.z+q.r*q.i.x),
	s2-x2-y2+z2);
}

// Assembly:
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm5
movsd 0x20(%rsp), %xmm4
movsd 0x18(%rsp), %xmm7
movq %rdi, %rax
movapd %xmm1, %xmm8
movapd %xmm5, %xmm0
movapd %xmm7, %xmm6
movapd %xmm7, %xmm13
movapd %xmm4, %xmm9
movapd %xmm4, %xmm2
mulsd %xmm1, %xmm8
mulsd %xmm5, %xmm0
mulsd %xmm7, %xmm6
mulsd %xmm1, %xmm13
mulsd %xmm1, %xmm9
mulsd %xmm5, %xmm2
mulsd %xmm5, %xmm1
movapd %xmm8, %xmm3
movapd %xmm13, %xmm11
movapd %xmm6, %xmm14
movapd %xmm9, %xmm12
addsd %xmm0, %xmm3
subsd %xmm8, %xmm0
movapd %xmm4, %xmm8
subsd %xmm2, %xmm11
addsd %xmm13, %xmm2
mulsd %xmm4, %xmm8
mulsd %xmm7, %xmm4
mulsd %xmm5, %xmm7
movapd %xmm0, %xmm10
subsd %xmm6, %xmm0
addsd %xmm2, %xmm2
addsd %xmm11, %xmm11
movapd %xmm4, %xmm5
addsd %xmm6, %xmm10
subsd %xmm7, %xmm9
addsd %xmm7, %xmm12
addsd %xmm8, %xmm14
subsd %xmm1, %xmm5
addsd %xmm4, %xmm1
addsd %xmm8, %xmm0
subsd %xmm14, %xmm3
addsd %xmm9, %xmm9
subsd %xmm8, %xmm10
addsd %xmm12, %xmm12
addsd %xmm1, %xmm1
addsd %xmm5, %xmm5
movsd %xmm3, (%rdi)
movsd %xmm2, 0x8(%rdi)
movsd %xmm9, 0x10(%rdi)
movsd %xmm11, 0x18(%rdi)
movsd %xmm10, 0x20(%rdi)
movsd %xmm1, 0x28(%rdi)
movsd %xmm12, 0x30(%rdi)
movsd %xmm5, 0x38(%rdi)
movsd %xmm0, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/canboat[P]canboat/socketcan-writer/socketcan-writer.c
// Function: time_diff
unsigned long time_diff(struct timeval x, struct timeval y, char *timestamp)
{
  double x_ms, y_ms, diff;

  x_ms = (double) x.tv_sec * 1000000 + (double) x.tv_usec;
  y_ms = (double) y.tv_sec * 1000000 + (double) y.tv_usec;

  diff = (double) y_ms - (double) x_ms;
  if (diff < 0.0)
  {
    logError("Timestamp back in time at %s\n", timestamp);
    return 0;
  }

  return (unsigned long) diff;
}

// Assembly:
pushq %rbx
cvtsi2sd %rdi, %xmm1
cvtsi2sd %rsi, %xmm0
movsd 0x2842(%rip), %xmm2     # 0x5020
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sd %rdx, %xmm0
cvtsi2sd %rcx, %xmm3
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
subsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x281b
leaq 0x285f(%rip), %rdi      # 0x506c
xorl %ebx, %ebx
movq %r8, %rsi
xorl %eax, %eax
callq 0x2aed
jmp 0x283a
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x27f9(%rip), %xmm0     # 0x5028
cvttsd2si %xmm0, %rbx
andq %rcx, %rbx
orq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/joltikneq9696v13/ref/joltik.c
// Function: set_nonce_in_tweak
static void set_nonce_in_tweak(uint8_t *tweak, const uint8_t *nonce) {
    tweak[0] = (tweak[0]&0xf0)     ^ (nonce[0] >> 4);
    tweak[1] = (nonce[0]&0xf) << 4 ^ (nonce[1] >> 4);
    tweak[2] = (nonce[1]&0xf) << 4 ^ (nonce[2] >> 4);
    tweak[3] = (nonce[2]&0xf) << 4 ^ (nonce[3] >> 4);
    tweak[4] = (nonce[3]&0xf) << 4 ^ (nonce[4] >> 4);
    tweak[5] = (nonce[4]&0xf) << 4 ^ (nonce[5] >> 4);
    tweak[6] = (nonce[5]&0xf) << 4;
}

// Assembly:
movb (%rdi), %al
andb $-0x10, %al
movb (%rsi), %cl
shrb $0x4, %cl
orb %al, %cl
movb %cl, (%rdi)
movb (%rsi), %al
movb 0x1(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x1(%rdi)
movb 0x1(%rsi), %al
movb 0x2(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x2(%rdi)
movb 0x2(%rsi), %al
movb 0x3(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x3(%rdi)
movb 0x3(%rsi), %al
movb 0x4(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x4(%rdi)
movb 0x4(%rsi), %al
movb 0x5(%rsi), %cl
shrb $0x4, %cl
shlb $0x4, %al
orb %cl, %al
movb %al, 0x5(%rdi)
movb 0x5(%rsi), %al
shlb $0x4, %al
movb %al, 0x6(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_test_fib.c
// Function: producer
int producer(void *ctx)
{
	printf("producer\n"); //DELETEME
	struct spsc_queue *q = (struct spsc_queue *) ctx;
	
	srand((unsigned) time(0) + thread_get_id());
	size_t pause = rand() % 1000;

	/* Wait for global start signal */
	while (g_start == 0)
		thrd_yield();
	
		/* Wait for a random time */
	for (size_t i = 0; i != pause; i += 1)
		nop();
	
	/* Enqueue */
	for (unsigned long count = 0, n1 = 0, n2 = 1; count < N; count++) {
		fibs[count] = n1 + n2;
		
		void *fibptr = (void *) &fibs[count];
		
		if (!spsc_queue_push(q, fibptr)) {
			printf("Queue push failed at count %lu, %d, free slots %d\n", count, 1<<20, spsc_queue_available(q));
			return -1;
		}
		
		n1 = n2; n2 = fibs[count];
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe92(%rip), %rdi       # 0x20a7
callq 0x1040
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %edx, %ebp
cmpl $0x0, 0x2e61(%rip)      # 0x40a0
jne 0x1248
callq 0x1070
jmp 0x1238
movslq %ebp, %rax
subq $0x1, %rax
jb 0x1255
pause
jmp 0x124b
pushq $0x1
popq %rbp
xorl %r14d, %r14d
leaq 0x2e4e(%rip), %r13      # 0x40b0
movq %rsp, %r15
pushq $0x1
popq %r12
xorl %eax, %eax
cmpq $0x1312d00, %r14        # imm = 0x1312D00
je 0x12bf
addl %ebp, %eax
movl %eax, (%r13)
movq %r13, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x16cd
testl %eax, %eax
je 0x129f
movl %ebp, %eax
movl (%r13), %ebp
incq %r14
addq $0x4, %r13
jmp 0x126b
movq %rbx, %rdi
callq 0x16a9
leaq 0xd56(%rip), %rdi       # 0x2004
movq %r14, %rsi
movl $0x100000, %edx         # imm = 0x100000
movl %eax, %ecx
xorl %eax, %eax
callq 0x1060
xorl %eax, %eax
cmpq $0x1312d00, %r14        # imm = 0x1312D00
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_test_fib.c
// Function: consumer
int consumer(void *ctx)
{
	printf("consumer\n"); 	//DELETEME
	struct spsc_queue *q = (struct spsc_queue *) ctx;
	
	srand((unsigned) time(0) + thread_get_id());
	size_t pause = rand() % 1000;

	/* Wait for global start signal */
	while (g_start == 0)
		thrd_yield();
	
	/* Wait for a random time */
	for (size_t i = 0; i != pause; i += 1)
		nop();
	
	/* Dequeue */
	for (unsigned long count = 0, n1 = 0, n2 = 1; count < N; count++) {
		int fib = n1 + n2;
		int *pulled;
		
		while (!spsc_queue_pull(q, (void **) &pulled)) {
			//printf("Queue empty: %d\n", temp);
			//return -1;
		}
		
		if (*pulled != fib) {
			printf("Pulled != fib\n");
			return -1;
		}		
		
		n1 = n2; n2 = fib;
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xdbf(%rip), %rdi       # 0x20b0
callq 0x1040
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %edx, %ebp
cmpl $0x0, 0x2d85(%rip)      # 0x40a0
jne 0x1324
callq 0x1070
jmp 0x1314
movslq %ebp, %rax
subq $0x1, %rax
jb 0x1331
pause
jmp 0x1327
pushq $0x1
popq %r14
xorl %ecx, %ecx
leaq 0x8(%rsp), %r13
leaq 0x10(%rsp), %r15
xorl %ebp, %ebp
movq %r14, %r12
cmpq $0x1312d00, %rcx        # imm = 0x1312D00
je 0x1398
movq %rcx, (%rsp)
addq %r12, %rbp
movq %r13, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1729
testl %eax, %eax
je 0x1356
movq 0x8(%rsp), %rax
cmpl %ebp, (%rax)
jne 0x1388
movslq %ebp, %rax
movq (%rsp), %rcx
incq %rcx
movq %r12, %rbp
movq %rax, %r12
jmp 0x1346
leaq 0xd2a(%rip), %rdi       # 0x20b9
callq 0x1040
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x1312d00, %rcx        # imm = 0x1312D00
sbbl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_test_fib.c
// Function: test_single_threaded
int test_single_threaded(struct spsc_queue *q)
{
	int resp, resc;
	g_start = 1;
	resp = producer(q);
	if (resp)
		printf("Enqueuing failed\n");
	
	resc = consumer(q);
	if (resc)
		printf("Consumer failed\n");
	
	if (resc || resp)
		printf("Single Thread Test Failed\n");
	else
		printf("Single Thread Test Complete\n");
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1, 0x2cdd(%rip)      # 0x40a0
callq 0x1200
movl %eax, %ebx
testl %eax, %eax
je 0x13da
leaq 0xcf2(%rip), %rdi       # 0x20c7
callq 0x1040
movq %r14, %rdi
callq 0x12d9
movl %eax, %ebp
testl %eax, %eax
je 0x13f4
leaq 0xce9(%rip), %rdi       # 0x20d8
callq 0x1040
orl %ebx, %ebp
leaq 0xceb(%rip), %rax       # 0x20e8
leaq 0xd00(%rip), %rdi       # 0x2104
cmoveq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_test_fib.c
// Function: test_multi_threaded
int test_multi_threaded(struct spsc_queue *q)
{
	thrd_t thrp, thrc;
	int resp, resc;
	
	g_start = 0;
	
	thrd_create(&thrp, consumer, q);	/** @todo Why producer thread runs earlier? */
	thrd_create(&thrc, producer, q);
	
	sleep(1);

	uint64_t start_tsc_time, end_tsc_time;

	start_tsc_time = rdtscp();
	g_start = 1;

	thrd_join(thrp, &resp);
	thrd_join(thrc, &resc);
	
	end_tsc_time = rdtscp();

	if (resc || resp)
		printf("Queue Test failed\n");
	else
		printf("Two-thread Test Complete\n");

	printf("cycles/op for rdtsc %lu\n", (end_tsc_time - start_tsc_time)/N);

	size_t used = spsc_queue_available(q);
	if (spsc_queue_available(q) != q->capacity)
		printf("%zu slots in use? There is something wrong with the test\n", used);
	
	int ret = spsc_queue_destroy(q);
	if (ret)
		printf("Failed to destroy queue: %d\n", ret);
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x0, 0x2c71(%rip)      # 0x40a0
leaq -0x15d(%rip), %rsi      # 0x12d9
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x153d
leaq -0x24d(%rip), %rsi      # 0x1200
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x153d
pushq $0x1
popq %rdi
callq 0x10e0
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, %r14
movl $0x1, 0x2c25(%rip)      # 0x40a0
movq (%r15), %rdi
leaq 0x4(%rsp), %r15
movq %r15, %rsi
callq 0x154a
movq (%r12), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x154a
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, %r13
movl (%r15), %eax
orl (%r12), %eax
leaq 0xc83(%rip), %rax       # 0x2137
leaq 0xc63(%rip), %rdi       # 0x211e
cmovneq %rax, %rdi
callq 0x1040
subq %r14, %r13
movl $0x1312d00, %ecx        # imm = 0x1312D00
movq %r13, %rax
xorl %edx, %edx
divq %rcx
leaq 0xb5c(%rip), %rdi       # 0x2037
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x16a9
movl %eax, %ebp
movq %rbx, %rdi
callq 0x16a9
cltq
cmpq %rax, 0x48(%rbx)
je 0x1510
movslq %ebp, %rsi
leaq 0xb47(%rip), %rdi       # 0x2050
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x15e5
testl %eax, %eax
je 0x152c
leaq 0xb67(%rip), %rdi       # 0x208a
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_queue.c
// Function: spsc_queue_init
struct spsc_queue * spsc_queue_init(struct spsc_queue * q, size_t size, const struct memtype *mem)
{
	/* Queue size must be 2 exponent */
	if ((size < 2) || ((size & (size - 1)) != 0))
		return NULL;
	
	q = memory_alloc(mem, sizeof(struct spsc_queue) + (sizeof(q->pointers[0]) * size));
	if (!q)
		return NULL;
	
	q->mem = mem;
	
	q->capacity = size - 1;

	atomic_init(&q->_tail, 0);
	atomic_init(&q->_head, 0);

	return q;
}

// Assembly:
cmpq $0x2, %rsi
jae 0x15a1
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
leaq -0x1(%rsi), %r14
testq %r14, %rsi
jne 0x15db
movq %rdx, %rbx
leaq 0x98(,%rsi,8), %rsi
movq %rdx, %rdi
callq 0x17c8
testq %rax, %rax
je 0x15db
movq %rbx, 0x40(%rax)
movq %r14, 0x48(%rax)
andl $0x0, 0x50(%rax)
andl $0x0, 0x94(%rax)
jmp 0x15dd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_queue.c
// Function: spsc_queue_get_many
int spsc_queue_get_many(struct spsc_queue *q, void **ptrs[], size_t cnt)
{
	if (q->capacity <= spsc_queue_available(q))
		cnt = 0;
	else if (cnt > q->capacity - spsc_queue_available(q))
		cnt = q->capacity - spsc_queue_available(q);
	
	/**@todo Is atomic_load_explicit needed here for loading q->_head? */
	for (int i = 0; i < cnt; i++)
		ptrs[i] = &(q->pointers[q->_head % (q->capacity + 1)]);
	
	return cnt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %r12
callq 0x16a9
cltq
cmpq %rax, %r12
jbe 0x1667
movq %r14, %rdi
callq 0x16a9
cltq
movq %r12, %rcx
subq %rax, %rcx
cmpq %r15, %rcx
jae 0x166a
movq %r14, %rdi
callq 0x16a9
cltq
subq %rax, %r12
movq %r12, %r15
jmp 0x166a
xorl %r15d, %r15d
leaq 0x98(%r14), %rcx
xorl %esi, %esi
cmpq %rsi, %r15
je 0x169a
movl 0x94(%r14), %eax
cltq
movq 0x48(%r14), %rdi
incq %rdi
xorl %edx, %edx
divq %rdi
leaq (%rcx,%rdx,8), %rax
movq %rax, (%rbx,%rsi,8)
incq %rsi
jmp 0x1673
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_queue.c
// Function: spsc_queue_available
int spsc_queue_available(struct spsc_queue *q)
{
	if (atomic_load_explicit(&q->_tail, memory_order_acquire) < atomic_load_explicit(&q->_head, memory_order_acquire))
		return q->_head - q->_tail - 1;
	else
		return q->_head + (q->capacity - q->_tail);
}

// Assembly:
movl 0x50(%rdi), %ecx
movl 0x94(%rdi), %edx
movl 0x94(%rdi), %eax
cmpl %edx, %ecx
jge 0x16c4
movl 0x50(%rdi), %ecx
notl %ecx
addl %ecx, %eax
retq
movl 0x50(%rdi), %ecx
subl %ecx, %eax
addl 0x48(%rdi), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_queue.c
// Function: spsc_queue_push_many
int spsc_queue_push_many(struct spsc_queue *q, void *ptrs[], size_t cnt)
{
	//int free_slots = q->_tail < q->_head ? q->_head - q->_tail - 1 : q->_head + (q->capacity - q->_tail);
	size_t free_slots = spsc_queue_available(q);
	
	if (cnt > free_slots)
		cnt = free_slots;
	
	for (size_t i = 0; i < cnt; i++) {
		q->pointers[q->_tail] = ptrs[i];
		atomic_store_explicit(&q->_tail, (q->_tail + 1)%(q->capacity + 1), memory_order_release);
	}
	
	return cnt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x16a9
cltq
cmpq %rbx, %rax
cmovbq %rax, %rbx
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x1721
movq (%r14,%rcx,8), %rax
movl 0x50(%r15), %edx
movslq %edx, %rdx
movq %rax, 0x98(%r15,%rdx,8)
movl 0x50(%r15), %eax
cltq
incq %rax
movq 0x48(%r15), %rsi
incq %rsi
xorl %edx, %edx
divq %rsi
movl %edx, 0x50(%r15)
incq %rcx
jmp 0x16eb
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_queue.c
// Function: spsc_queue_pull_many
int spsc_queue_pull_many(struct spsc_queue *q, void **ptrs[], size_t cnt)
{
	if (q->capacity <= spsc_queue_available(q))
		cnt = 0;
	else if (cnt > q->capacity - spsc_queue_available(q))
		cnt = q->capacity - spsc_queue_available(q);
	
	for (size_t i = 0; i < cnt; i++) {
		*ptrs[i] = q->pointers[q->_head];
		atomic_store_explicit(&q->_head, (q->_head + 1)%(q->capacity + 1), memory_order_release);
	}
	
	return cnt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %r12
callq 0x16a9
cltq
cmpq %rax, %r12
jbe 0x1771
movq %r14, %rdi
callq 0x16a9
cltq
movq %r12, %rcx
subq %rax, %rcx
cmpq %r15, %rcx
jae 0x1774
movq %r14, %rdi
callq 0x16a9
cltq
subq %rax, %r12
movq %r12, %r15
jmp 0x1774
xorl %r15d, %r15d
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0x17b7
movl 0x94(%r14), %eax
cltq
movq 0x98(%r14,%rax,8), %rax
movq (%rbx,%rcx,8), %rdx
movq %rax, (%rdx)
movl 0x94(%r14), %eax
cltq
incq %rax
movq 0x48(%r14), %rsi
incq %rsi
xorl %edx, %edx
divq %rsi
movl %edx, 0x94(%r14)
incq %rcx
jmp 0x1776
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/calmopyrin[P]tedplay/Audio.cpp
// Function: Audio::createWav(char const*)
bool Audio::createWav(const char *fileName)
{
	WAVHEADER wav = {
		'R','I','F','F',
		0,
		'W','A','V','E','f','m','t',' ',
		16,
		1,
		1,
		0,
		0,
		2,
		16,
		'd','a','t','a',
		0
	};

	wav.nSamplesPerSec = sampleFrq;
	wav.nAvgBytesPerSec = wav.nSamplesPerSec * wav.nChannels * (wav.nBitsPerSample/8);

	if ((wavFileHandle = std::fopen(fileName, "wb"))) {
		if (std::fwrite(&wav, sizeof(wav), 1, wavFileHandle)) {
			recording = true;
		} else {
			std::fclose(wavFileHandle);
		}
	}
	return recording;
}

// Assembly:
subq $0x38, %rsp
movq %rsi, %rax
movups 0xa878(%rip), %xmm0     # 0xe04c
movups %xmm0, 0x1c(%rsp)
movups 0xa860(%rip), %xmm0     # 0xe040
movaps %xmm0, 0x10(%rsp)
movups 0xa844(%rip), %xmm0     # 0xe030
movaps %xmm0, (%rsp)
movl 0xc(%rdi), %ecx
movl %ecx, 0x18(%rsp)
addl %ecx, %ecx
movl %ecx, 0x1c(%rsp)
leaq 0xa85f(%rip), %rsi      # 0xe063
movq %rax, %rdi
callq 0x3260
movq %rax, 0x20aa5(%rip)     # 0x242b8
testq %rax, %rax
je 0x3843
movq %rsp, %rdi
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
movq %rax, %rcx
callq 0x33a0
testq %rax, %rax
je 0x3837
movb $0x1, 0x20a7c(%rip)     # 0x242b1
jmp 0x3843
movq 0x20a7a(%rip), %rdi     # 0x242b8
callq 0x3210
movb 0x20a68(%rip), %al      # 0x242b1
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/calmopyrin[P]tedplay/Audio.cpp
// Function: Audio::closeWav()
void Audio::closeWav()
{
	while (usingFileHandle);
	if (wavFileHandle) {
		unsigned int foo = (unsigned int)(ftell(wavFileHandle) - 8);
		// RIFF chunk size
		std::fseek(wavFileHandle, 4, SEEK_SET);
		std::fwrite(&foo, sizeof(foo), 1, wavFileHandle);

		// data chunk size
		foo = foo - sizeof(WAVHEADER) + 8;
		std::fseek(wavFileHandle, sizeof(WAVHEADER) - sizeof(unsigned long), SEEK_SET);
		std::fwrite(&foo, sizeof(foo), 1, wavFileHandle);

		std::fclose(wavFileHandle);
		wavFileHandle = 0;
	}
	recording = false;	
}

// Assembly:
movq 0x20a63(%rip), %rdi     # 0x242b8
testq %rdi, %rdi
je 0x38ea
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
callq 0x3030
addl $-0x8, %eax
leaq 0xc(%rsp), %rbx
movl %eax, (%rbx)
movq 0x20a3b(%rip), %rdi     # 0x242b8
pushq $0x4
popq %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x3250
movq 0x20a26(%rip), %rcx     # 0x242b8
pushq $0x1
popq %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x33a0
addl $-0x24, (%rbx)
movq 0x20a0a(%rip), %rdi     # 0x242b8
pushq $0x24
popq %rsi
xorl %edx, %edx
callq 0x3250
movq 0x209f9(%rip), %rcx     # 0x242b8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x33a0
movq 0x209e4(%rip), %rdi     # 0x242b8
callq 0x3210
andq $0x0, 0x209d7(%rip)     # 0x242b8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movb $0x0, 0x209c0(%rip)     # 0x242b1
retq
// File: /workspace/github_c_makefile_star2_O2/calmopyrin[P]tedplay/AudioSDL.cpp
// Function: AudioSDL::setSampleRate(unsigned int)
void AudioSDL::setSampleRate(unsigned int newSampleRate)
{
	if (audiohwspec) {
		SDL_PauseAudio(1);
		unsigned int fadeoutTime = 1000 * bufferLength / audiohwspec->samples;
		SDL_Delay(fadeoutTime);
		SDL_CloseAudio();

		SDL_AudioSpec *obtained = new SDL_AudioSpec;
		audiohwspec->samples = newSampleRate;
		try {
			SDL_OpenAudio(audiohwspec, obtained);
			if (obtained) {
				SDL_AudioSpec *temp = audiohwspec;
				audiohwspec = obtained;
				delete temp;
			}
			SDL_PauseAudio(0);
		} catch (char *txt) {
			std::cerr << "Exception occurred: " << txt << std::endl;
		}
	} else {
	}
	Audio::setSampleRate(newSampleRate);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x39b5
pushq $0x1
popq %rdi
callq 0x3180
imull $0x3e8, 0x8(%r14), %eax # imm = 0x3E8
movq 0x10(%r14), %rcx
movzwl 0x8(%rcx), %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %edi
callq 0x3160
callq 0x3140
pushq $0x20
popq %rdi
callq 0x3220
movq %rax, %r15
movq 0x10(%r14), %rdi
movw %bx, 0x8(%rdi)
movq %rax, %rsi
callq 0x32f0
movq 0x10(%r14), %rdi
movq %r15, 0x10(%r14)
pushq $0x20
popq %rsi
callq 0x3230
xorl %edi, %edi
callq 0x3180
movl %ebx, 0xc(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x3a07
movq %r15, %rdi
callq 0x30d0
movq %rax, %r15
movq 0x10617(%rip), %rdi     # 0x13ff0
leaq 0xa686(%rip), %rsi      # 0xe066
callq 0x3200
movq %rax, %rdi
movq %r15, %rsi
callq 0x3200
movq %rax, %rdi
callq 0x3110
callq 0x3310
jmp 0x39b5
movq %rax, %r15
callq 0x3310
movq %r15, %rdi
callq 0x3340
nop
// File: /workspace/github_c_makefile_star2_O2/calmopyrin[P]tedplay/AudioSDL.cpp
// Function: AudioSDL::~AudioSDL()
AudioSDL::~AudioSDL()
{
    SDL_PauseAudio(1);
    SDL_Delay(20);
	SDL_CloseAudio();
	SDL_Quit();
	if (audiohwspec)
		delete audiohwspec;
	if (ringBuffer)
		delete [] ringBuffer;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xfe29(%rip), %rax      # 0x13ae8
movq %rax, (%rdi)
pushq $0x1
popq %rdi
callq 0x3180
pushq $0x14
popq %rdi
callq 0x3160
callq 0x3140
callq 0x33b0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3ced
pushq $0x20
popq %rsi
callq 0x3230
leaq 0x205a4(%rip), %rax     # 0x24298
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3d02
popq %rbx
jmp 0x3290
popq %rbx
retq
movq %rax, %rdi
callq 0x3d21
// File: /workspace/github_c_makefile_star2_O2/calmopyrin[P]tedplay/./CbmTune.h
// Function: CbmTune::getNrOfSubtunes()
virtual unsigned int getNrOfSubtunes() {
		if (bufferPtr[CBM8M_HDR_FIELDS] & CBM8M_FIELD_SUBTUNES)
			return bufferPtr[CBM8M_HDR_STRINGS
				+ strlen(getReleaseDate()) + strlen(getAuthor()) + strlen(getName()) + 3];
		else
			return 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r12
xorl %eax, %eax
testb $0x1, 0x8(%r12)
je 0x4050
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
callq 0x30e0
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %rdi
callq 0x30e0
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %rax, %rdi
callq 0x30e0
addq %r14, %r12
addq %r15, %r12
movzbl 0xc(%rax,%r12), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/calmopyrin[P]tedplay/./CbmTune.h
// Function: CbmTune::getDefaultSubtune()
virtual unsigned int getDefaultSubtune() {
		if (bufferPtr[CBM8M_HDR_FIELDS] & CBM8M_FIELD_DEFAULT)
			return bufferPtr[CBM8M_HDR_FIELDS
				+ 1
				+ strlen(getReleaseDate()) + strlen(getAuthor()) + strlen(getName()) + 3];
		else
			return 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r12
xorl %eax, %eax
testb $0x2, 0x8(%r12)
je 0x40b6
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
callq 0x30e0
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %rdi
callq 0x30e0
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %rax, %rdi
callq 0x30e0
addq %r14, %r12
addq %r15, %r12
movzbl 0xc(%rax,%r12), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/calmopyrin[P]tedplay/Cpu.cpp
// Function: CPU::CPU(MemoryHandler*, unsigned char*, unsigned char*)
CPU::CPU( MemoryHandler *memhandler, unsigned char *irqreg, unsigned char *cpustack ) : mem(memhandler), irq_register(irqreg), stack(cpustack)
{
	irq_sequence = 0;
	IRQcount = 0;
	cpu_jammed = false;
	PC = 0xFFFF;
	for( int i=0; i<nr_of_bps; i++) {
		bp[i].address = 0x10000;
		bp[i].enabled = false;
		bp[i].slot_free = true;
	}
	nr_activebps = 0;
	memset( stats, 0, sizeof(stats));
}

// Assembly:
leaq 0xfaf5(%rip), %rax      # 0x13be0
movq %rax, (%rdi)
movq %rdx, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movq %rsi, 0x40(%rdi)
xorl %eax, %eax
movb %al, 0x38(%rdi)
andl $0x0, 0x24(%rdi)
movb %al, 0xa4(%rdi)
movl $0xffff, 0x10(%rdi)     # imm = 0xFFFF
cmpq $0xb, %rax
je 0x412a
movl $0x10000, 0x48(%rdi,%rax,8) # imm = 0x10000
movw $0x100, 0x4c(%rdi,%rax,8) # imm = 0x100
incq %rax
jmp 0x4110
andl $0x0, 0xa0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/calmopyrin[P]tedplay/Cpu.cpp
// Function: CPU::saveshot(void*)
bool CPU::saveshot(void *CPUdump)
{
	FILE *img = (FILE *) CPUdump;

	fwrite(&currins,sizeof(currins),1,img);
	fwrite(&nextins,sizeof(nextins),1,img);
	fwrite(&ptr,sizeof(ptr),1,img);
	fwrite(&PC,sizeof(PC),1,img);
	fwrite(&cycle,sizeof(cycle),1,img);
	fwrite(&SP,sizeof(SP),1,img);
  	fwrite(&ST,sizeof(ST),1,img);
   	fwrite(&AC,sizeof(AC),1,img);
   	fwrite(&X,sizeof(X),1,img);
   	fwrite(&Y,sizeof(Y),1,img);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsbl 0x8(%rdi), %edi
callq 0x3280
movsbl 0x9(%r14), %edi
movq %rbx, %rsi
callq 0x3280
leaq 0xc(%r14), %rdi
pushq $0x4
popq %r15
pushq $0x1
popq %r12
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x33a0
leaq 0x10(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x33a0
leaq 0x20(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x33a0
movsbl 0x14(%r14), %edi
movq %rbx, %rsi
callq 0x3280
leaq 0x18(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x33a0
movsbl 0x1c(%r14), %edi
movq %rbx, %rsi
callq 0x3280
movsbl 0x1d(%r14), %edi
movq %rbx, %rsi
callq 0x3280
movsbl 0x1e(%r14), %edi
movq %rbx, %rsi
callq 0x3280
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/calmopyrin[P]tedplay/Cpu.cpp
// Function: CPU::loadshot(void*)
bool CPU::loadshot(void *CPUdump)
{
	FILE *img = (FILE *) CPUdump;

	fread(&currins,sizeof(currins),1,img);
	fread(&nextins,sizeof(nextins),1,img);
	fread(&ptr,sizeof(ptr),1,img);
   	fread(&PC,sizeof(PC),1,img);
	PC &= 0xFFFF;
	fread(&cycle,sizeof(cycle),1,img);
   	fread(&SP,sizeof(SP),1,img);
  	fread(&ST,sizeof(ST),1,img);
   	fread(&AC,sizeof(AC),1,img);
   	fread(&X,sizeof(X),1,img);
   	fread(&Y,sizeof(Y),1,img);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
pushq $0x1
popq %r15
movq %r15, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x32d0
leaq 0x9(%r14), %rdi
movq %r15, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x32d0
leaq 0xc(%r14), %rdi
pushq $0x4
popq %r12
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x32d0
leaq 0x10(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x32d0
movzwl 0x10(%r14), %eax
movl %eax, 0x10(%r14)
leaq 0x20(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x32d0
leaq 0x14(%r14), %rdi
movq %r15, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x32d0
leaq 0x18(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x32d0
leaq 0x1c(%r14), %rdi
movq %r15, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x32d0
leaq 0x1d(%r14), %rdi
movq %r15, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x32d0
addq $0x1e, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x32d0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/calmopyrin[P]tedplay/Cpu.cpp
// Function: CPU::Reset()
void CPU::Reset()
{
	ST=0x24;
	softreset();
	IRQcount = cycle = 0;
	irq_sequence = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x24, 0x18(%rdi)
callq 0x430e
andq $0x0, 0x20(%rbx)
movb $0x0, 0x38(%rbx)
popq %rbx
retq
nop