LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq -0x70(%rsp), %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x11d0
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x1110
movq -0x50(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
movsd 0x6738(%rip), %xmm0     # 0x17510
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x10f30
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd (%rax), %xmm1
mulsd (%rax), %xmm1
addsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
mulsd (%rax), %xmm1
mulsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
mulsd -0x10(%rbp), %xmm2
addsd %xmm2, %xmm1
movsd -0x20(%rbp), %xmm2
mulsd (%rax), %xmm2
mulsd 0x10(%rax), %xmm2
movsd 0x8(%rax), %xmm3
mulsd -0x10(%rbp), %xmm3
subsd %xmm3, %xmm2
movsd -0x20(%rbp), %xmm3
mulsd (%rax), %xmm3
mulsd 0x8(%rax), %xmm3
movsd 0x10(%rax), %xmm4
mulsd -0x10(%rbp), %xmm4
subsd %xmm4, %xmm3
movsd -0x18(%rbp), %xmm4
movsd -0x20(%rbp), %xmm5
mulsd 0x8(%rax), %xmm5
mulsd 0x8(%rax), %xmm5
addsd %xmm5, %xmm4
movsd -0x20(%rbp), %xmm5
mulsd 0x8(%rax), %xmm5
mulsd 0x10(%rax), %xmm5
movsd (%rax), %xmm6
mulsd -0x10(%rbp), %xmm6
addsd %xmm6, %xmm5
movsd -0x20(%rbp), %xmm6
mulsd (%rax), %xmm6
mulsd 0x10(%rax), %xmm6
movsd 0x8(%rax), %xmm7
mulsd -0x10(%rbp), %xmm7
addsd %xmm7, %xmm6
movsd -0x20(%rbp), %xmm7
mulsd 0x8(%rax), %xmm7
mulsd 0x10(%rax), %xmm7
movsd (%rax), %xmm8
mulsd -0x10(%rbp), %xmm8
subsd %xmm8, %xmm7
movsd -0x18(%rbp), %xmm8
movsd -0x20(%rbp), %xmm9
mulsd 0x10(%rax), %xmm9
mulsd 0x10(%rax), %xmm9
addsd %xmm9, %xmm8
movsd %xmm8, (%rsp)
callq 0x10fd0
movq -0x40(%rbp), %rax
leaq 0x70(%rsp), %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat3x3inverselookat
dmat3x3_t dmat3x3inverselookat(dvec3_t eye,dvec3_t center,dvec3_t up)
{
	dvec3_t backward=dvec3norm(dvec3sub(eye,center));
	dvec3_t right=dvec3norm(dvec3cross(up,backward));
	dvec3_t actualup=dvec3norm(dvec3cross(backward,right));

	return dmat3x3cols(right,actualup,backward);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0xf0(%rsp), %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, -0x98(%rbp)
leaq 0x40(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq 0x28(%rbp), %rax
leaq 0x10(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x11250
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x10f30
movq -0xa8(%rbp), %rcx
leaq -0x60(%rbp), %rdi
leaq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x169b0
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x10f30
leaq -0x90(%rbp), %rdi
leaq -0x18(%rbp), %rcx
leaq -0x48(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x169b0
leaq -0x78(%rbp), %rdi
leaq -0x90(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x10f30
movq -0xa0(%rbp), %rdi
leaq -0x48(%rbp), %rdx
leaq -0x78(%rbp), %rcx
leaq -0x18(%rbp), %rax
movq (%rdx), %rsi
movq %rsi, (%rsp)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rsp)
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x20(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
callq 0x112a0
movq -0x98(%rbp), %rax
leaq 0xf0(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x10(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x30(%rbp), %rax
leaq 0x10(%rbp), %rcx
movsd (%rcx), %xmm0
mulsd (%rax), %xmm0
movsd 0x10(%rcx), %xmm1
mulsd 0x8(%rax), %xmm1
addsd %xmm1, %xmm0
movsd (%rcx), %xmm1
mulsd 0x10(%rax), %xmm1
movsd 0x10(%rcx), %xmm2
mulsd 0x18(%rax), %xmm2
addsd %xmm2, %xmm1
movsd 0x8(%rcx), %xmm2
mulsd (%rax), %xmm2
movsd 0x18(%rcx), %xmm3
mulsd 0x8(%rax), %xmm3
addsd %xmm3, %xmm2
movsd 0x8(%rcx), %xmm3
mulsd 0x10(%rax), %xmm3
movsd 0x18(%rcx), %xmm4
mulsd 0x18(%rax), %xmm4
addsd %xmm4, %xmm3
callq 0x11390
movq -0x8(%rbp), %rax
leaq 0x10(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x10(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x58(%rbp), %rax
leaq 0x10(%rbp), %rcx
movsd (%rcx), %xmm0
mulsd (%rax), %xmm0
movsd 0x18(%rcx), %xmm1
mulsd 0x8(%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0x30(%rcx), %xmm1
mulsd 0x10(%rax), %xmm1
addsd %xmm1, %xmm0
movsd (%rcx), %xmm1
mulsd 0x18(%rax), %xmm1
movsd 0x18(%rcx), %xmm2
mulsd 0x20(%rax), %xmm2
addsd %xmm2, %xmm1
movsd 0x30(%rcx), %xmm2
mulsd 0x28(%rax), %xmm2
addsd %xmm2, %xmm1
movsd (%rcx), %xmm2
mulsd 0x30(%rax), %xmm2
movsd 0x18(%rcx), %xmm3
mulsd 0x38(%rax), %xmm3
addsd %xmm3, %xmm2
movsd 0x30(%rcx), %xmm3
mulsd 0x40(%rax), %xmm3
addsd %xmm3, %xmm2
movsd 0x8(%rcx), %xmm3
mulsd (%rax), %xmm3
movsd 0x20(%rcx), %xmm4
mulsd 0x8(%rax), %xmm4
addsd %xmm4, %xmm3
movsd 0x38(%rcx), %xmm4
mulsd 0x10(%rax), %xmm4
addsd %xmm4, %xmm3
movsd 0x8(%rcx), %xmm4
mulsd 0x18(%rax), %xmm4
movsd 0x20(%rcx), %xmm5
mulsd 0x20(%rax), %xmm5
addsd %xmm5, %xmm4
movsd 0x38(%rcx), %xmm5
mulsd 0x28(%rax), %xmm5
addsd %xmm5, %xmm4
movsd 0x8(%rcx), %xmm5
mulsd 0x30(%rax), %xmm5
movsd 0x20(%rcx), %xmm6
mulsd 0x38(%rax), %xmm6
addsd %xmm6, %xmm5
movsd 0x38(%rcx), %xmm6
mulsd 0x40(%rax), %xmm6
addsd %xmm6, %xmm5
movsd 0x10(%rcx), %xmm6
mulsd (%rax), %xmm6
movsd 0x28(%rcx), %xmm7
mulsd 0x8(%rax), %xmm7
addsd %xmm7, %xmm6
movsd 0x40(%rcx), %xmm7
mulsd 0x10(%rax), %xmm7
addsd %xmm7, %xmm6
movsd 0x10(%rcx), %xmm7
mulsd 0x18(%rax), %xmm7
movsd 0x28(%rcx), %xmm8
mulsd 0x20(%rax), %xmm8
addsd %xmm8, %xmm7
movsd 0x40(%rcx), %xmm8
mulsd 0x28(%rax), %xmm8
addsd %xmm8, %xmm7
movsd 0x10(%rcx), %xmm8
mulsd 0x30(%rax), %xmm8
movsd 0x28(%rcx), %xmm9
mulsd 0x38(%rax), %xmm9
addsd %xmm9, %xmm8
movsd 0x40(%rcx), %xmm9
mulsd 0x40(%rax), %xmm9
addsd %xmm9, %xmm8
movsd %xmm8, (%rsp)
callq 0x10fd0
movq -0x8(%rbp), %rax
leaq 0x10(%rsp), %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
leaq 0x90(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x10, -0x4(%rbp)
jge 0x11625
movl -0x4(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0xc, %eax
movl %eax, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x11605
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl -0x8(%rbp), %edx
movl -0x1c(%rbp), %esi
shll $0x2, %esi
addl %esi, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
movl -0xc(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
mulsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x115c1
movq -0x40(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movslq -0x4(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x11596
movq -0x38(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x10(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x40(%rbp), %rcx
leaq 0x10(%rbp), %rax
movsd (%rax), %xmm0
mulsd (%rcx), %xmm0
movsd 0x10(%rax), %xmm1
mulsd 0x8(%rcx), %xmm1
addsd %xmm1, %xmm0
movsd (%rax), %xmm1
mulsd 0x10(%rcx), %xmm1
movsd 0x10(%rax), %xmm2
mulsd 0x18(%rcx), %xmm2
addsd %xmm2, %xmm1
movsd (%rax), %xmm2
mulsd 0x20(%rcx), %xmm2
movsd 0x10(%rax), %xmm3
mulsd 0x28(%rcx), %xmm3
addsd %xmm3, %xmm2
addsd 0x20(%rax), %xmm2
movsd 0x8(%rax), %xmm3
mulsd (%rcx), %xmm3
movsd 0x18(%rax), %xmm4
mulsd 0x8(%rcx), %xmm4
addsd %xmm4, %xmm3
movsd 0x8(%rax), %xmm4
mulsd 0x10(%rcx), %xmm4
movsd 0x18(%rax), %xmm5
mulsd 0x18(%rcx), %xmm5
addsd %xmm5, %xmm4
movsd 0x8(%rax), %xmm5
mulsd 0x20(%rcx), %xmm5
movsd 0x18(%rax), %xmm6
mulsd 0x28(%rcx), %xmm6
addsd %xmm6, %xmm5
addsd 0x28(%rax), %xmm5
callq 0x116f0
movq -0x8(%rbp), %rax
leaq 0x10(%rsp), %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x10(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x58(%rbp), %rcx
leaq 0x10(%rbp), %rax
movsd (%rax), %xmm0
mulsd (%rcx), %xmm0
movsd 0x18(%rax), %xmm1
mulsd 0x8(%rcx), %xmm1
addsd %xmm1, %xmm0
movsd (%rax), %xmm1
mulsd 0x18(%rcx), %xmm1
movsd 0x18(%rax), %xmm2
mulsd 0x20(%rcx), %xmm2
addsd %xmm2, %xmm1
movsd (%rax), %xmm2
mulsd 0x30(%rcx), %xmm2
movsd 0x18(%rax), %xmm3
mulsd 0x38(%rcx), %xmm3
addsd %xmm3, %xmm2
addsd 0x30(%rax), %xmm2
movsd 0x8(%rax), %xmm3
mulsd (%rcx), %xmm3
movsd 0x20(%rax), %xmm4
mulsd 0x8(%rcx), %xmm4
addsd %xmm4, %xmm3
movsd 0x8(%rax), %xmm4
mulsd 0x18(%rcx), %xmm4
movsd 0x20(%rax), %xmm5
mulsd 0x20(%rcx), %xmm5
addsd %xmm5, %xmm4
movsd 0x8(%rax), %xmm5
mulsd 0x30(%rcx), %xmm5
movsd 0x20(%rax), %xmm6
mulsd 0x38(%rcx), %xmm6
addsd %xmm6, %xmm5
addsd 0x38(%rax), %xmm5
xorps %xmm7, %xmm7
movsd 0x5cf7(%rip), %xmm8     # 0x17510
movaps %xmm7, %xmm6
movsd %xmm8, (%rsp)
callq 0x10fd0
movq -0x8(%rbp), %rax
leaq 0x10(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movsd (%rax), %xmm0
mulsd 0x28(%rax), %xmm0
movsd 0x8(%rax), %xmm1
mulsd 0x20(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd (%rax), %xmm0
mulsd 0x30(%rax), %xmm0
movsd 0x10(%rax), %xmm1
mulsd 0x20(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd (%rax), %xmm0
mulsd 0x38(%rax), %xmm0
movsd 0x18(%rax), %xmm1
mulsd 0x20(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%rax), %xmm0
mulsd 0x30(%rax), %xmm0
movsd 0x10(%rax), %xmm1
mulsd 0x28(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x8(%rax), %xmm0
mulsd 0x38(%rax), %xmm0
movsd 0x18(%rax), %xmm1
mulsd 0x28(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x10(%rax), %xmm0
mulsd 0x38(%rax), %xmm0
movsd 0x18(%rax), %xmm1
mulsd 0x30(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x40(%rax), %xmm0
mulsd 0x68(%rax), %xmm0
movsd 0x48(%rax), %xmm1
mulsd 0x60(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x40(%rax), %xmm0
mulsd 0x70(%rax), %xmm0
movsd 0x50(%rax), %xmm1
mulsd 0x60(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x40(%rax), %xmm0
mulsd 0x78(%rax), %xmm0
movsd 0x58(%rax), %xmm1
mulsd 0x60(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x48(%rax), %xmm0
mulsd 0x70(%rax), %xmm0
movsd 0x50(%rax), %xmm1
mulsd 0x68(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x48(%rax), %xmm0
mulsd 0x78(%rax), %xmm0
movsd 0x58(%rax), %xmm1
mulsd 0x68(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x50(%rax), %xmm0
mulsd 0x78(%rax), %xmm0
movsd 0x58(%rax), %xmm1
mulsd 0x70(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x60(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
mulsd -0x58(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x50(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
mulsd -0x48(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd -0x28(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd -0x30(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
addsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat3x3inverse
dmat3x3_t dmat3x3inverse(dmat3x3_t m)
{
	dmat3x3_t res;
	double det=dmat3x3det(m); // singular if det==0

	res.m[0]=(m.m[4]*m.m[8]-m.m[5]*m.m[7])/det;
	res.m[3]=-(m.m[3]*m.m[8]-m.m[5]*m.m[6])/det;
	res.m[6]=(m.m[3]*m.m[7]-m.m[4]*m.m[6])/det;

	res.m[1]=-(m.m[1]*m.m[8]-m.m[2]*m.m[7])/det;
	res.m[4]=(m.m[0]*m.m[8]-m.m[2]*m.m[6])/det;
	res.m[7]=-(m.m[0]*m.m[7]-m.m[1]*m.m[6])/det;

	res.m[2]=(m.m[1]*m.m[5]-m.m[2]*m.m[4])/det;
	res.m[5]=-(m.m[0]*m.m[5]-m.m[2]*m.m[3])/det;
	res.m[8]=(m.m[0]*m.m[4]-m.m[1]*m.m[3])/det;

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x70(%rsp), %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x40(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x12260
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd %xmm0, -0x8(%rbp)
movsd 0x20(%rcx), %xmm0
mulsd 0x40(%rcx), %xmm0
movsd 0x28(%rcx), %xmm1
mulsd 0x38(%rcx), %xmm1
subsd %xmm1, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, (%rdi)
movsd 0x18(%rcx), %xmm0
mulsd 0x40(%rcx), %xmm0
movsd 0x28(%rcx), %xmm1
mulsd 0x30(%rcx), %xmm1
subsd %xmm1, %xmm0
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x18(%rcx), %xmm0
mulsd 0x38(%rcx), %xmm0
movsd 0x20(%rcx), %xmm1
mulsd 0x30(%rcx), %xmm1
subsd %xmm1, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x30(%rdi)
movsd 0x8(%rcx), %xmm0
mulsd 0x40(%rcx), %xmm0
movsd 0x10(%rcx), %xmm1
mulsd 0x38(%rcx), %xmm1
subsd %xmm1, %xmm0
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd (%rcx), %xmm0
mulsd 0x40(%rcx), %xmm0
movsd 0x10(%rcx), %xmm1
mulsd 0x30(%rcx), %xmm1
subsd %xmm1, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x20(%rdi)
movsd (%rcx), %xmm0
mulsd 0x38(%rcx), %xmm0
movsd 0x8(%rcx), %xmm1
mulsd 0x30(%rcx), %xmm1
subsd %xmm1, %xmm0
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x38(%rdi)
movsd 0x8(%rcx), %xmm0
mulsd 0x28(%rcx), %xmm0
movsd 0x10(%rcx), %xmm1
mulsd 0x20(%rcx), %xmm1
subsd %xmm1, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd (%rcx), %xmm0
mulsd 0x28(%rcx), %xmm0
movsd 0x10(%rcx), %xmm1
mulsd 0x18(%rcx), %xmm1
subsd %xmm1, %xmm0
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x28(%rdi)
movsd (%rcx), %xmm0
mulsd 0x20(%rcx), %xmm0
movsd 0x8(%rcx), %xmm1
mulsd 0x18(%rcx), %xmm1
subsd %xmm1, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x40(%rdi)
leaq 0x70(%rsp), %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat3x2affineinverse
dmat3x2_t dmat3x2affineinverse(dmat3x2_t m)
{
	dmat3x2_t res;
	double det=dmat3x2affinedet(m); // singular if det==0

	res.m[0]=m.m[3]/det;
	res.m[2]=-m.m[2]/det;

	res.m[1]=-m.m[1]/det;
	res.m[3]=m.m[0]/det;

	res.m[4]=-(m.m[4]*res.m[0]+m.m[5]*res.m[2]);
	res.m[5]=-(m.m[4]*res.m[1]+m.m[5]*res.m[3]);

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x50(%rsp), %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x12db0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd %xmm0, -0x8(%rbp)
movsd 0x18(%rcx), %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, (%rdi)
movsd 0x10(%rcx), %xmm0
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x8(%rcx), %xmm0
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd (%rcx), %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x20(%rcx), %xmm0
mulsd (%rdi), %xmm0
movsd 0x28(%rcx), %xmm1
mulsd 0x10(%rdi), %xmm1
addsd %xmm1, %xmm0
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
movsd %xmm0, 0x20(%rdi)
movsd 0x20(%rcx), %xmm0
mulsd 0x8(%rdi), %xmm0
movsd 0x28(%rcx), %xmm1
mulsd 0x18(%rdi), %xmm1
addsd %xmm1, %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, 0x28(%rdi)
leaq 0x50(%rsp), %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Vector/MatrixDouble.c
// Function: dmat3x3affineinverse
dmat3x3_t dmat3x3affineinverse(dmat3x3_t m)
{
	dmat3x3_t res;
	double det=dmat3x3affinedet(m); // singular if det==0

	res.m[0]=m.m[4]/det;
	res.m[3]=-m.m[3]/det;

	res.m[1]=-m.m[1]/det;
	res.m[4]=m.m[0]/det;

	res.m[2]=0;
	res.m[5]=0;

	res.m[6]=-(m.m[6]*res.m[0]+m.m[7]*res.m[3]);
	res.m[7]=-(m.m[6]*res.m[1]+m.m[7]*res.m[4]);
	res.m[8]=1;

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x70(%rsp), %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x40(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x12fd0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd %xmm0, -0x8(%rbp)
movsd 0x20(%rcx), %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, (%rdi)
movsd 0x18(%rcx), %xmm0
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x8(%rcx), %xmm0
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd (%rcx), %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x20(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rdi)
movsd 0x30(%rcx), %xmm0
mulsd (%rdi), %xmm0
movsd 0x38(%rcx), %xmm1
mulsd 0x18(%rdi), %xmm1
addsd %xmm1, %xmm0
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
movsd %xmm0, 0x30(%rdi)
movsd 0x30(%rcx), %xmm0
mulsd 0x8(%rdi), %xmm0
movsd 0x38(%rcx), %xmm1
mulsd 0x20(%rdi), %xmm1
addsd %xmm1, %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, 0x38(%rdi)
movsd 0x4551(%rip), %xmm0     # 0x17510
movsd %xmm0, 0x40(%rdi)
leaq 0x70(%rsp), %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x10(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x58(%rbp), %rcx
leaq 0x10(%rbp), %rax
movsd (%rcx), %xmm0
mulsd (%rax), %xmm0
movsd 0x8(%rcx), %xmm1
mulsd 0x18(%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0x10(%rcx), %xmm1
mulsd 0x30(%rax), %xmm1
addsd %xmm1, %xmm0
movsd (%rcx), %xmm1
mulsd 0x8(%rax), %xmm1
movsd 0x8(%rcx), %xmm2
mulsd 0x20(%rax), %xmm2
addsd %xmm2, %xmm1
movsd 0x10(%rcx), %xmm2
mulsd 0x38(%rax), %xmm2
addsd %xmm2, %xmm1
movsd (%rcx), %xmm2
mulsd 0x10(%rax), %xmm2
movsd 0x8(%rcx), %xmm3
mulsd 0x28(%rax), %xmm3
addsd %xmm3, %xmm2
movsd 0x10(%rcx), %xmm3
mulsd 0x40(%rax), %xmm3
addsd %xmm3, %xmm2
callq 0x142f0
movq -0x8(%rbp), %rax
leaq 0x10(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x10(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x70(%rbp), %rcx
leaq 0x10(%rbp), %rax
movsd (%rcx), %xmm0
mulsd (%rax), %xmm0
movsd 0x8(%rcx), %xmm1
mulsd 0x18(%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0x10(%rcx), %xmm1
mulsd 0x30(%rax), %xmm1
addsd %xmm1, %xmm0
addsd 0x48(%rax), %xmm0
movsd (%rcx), %xmm1
mulsd 0x8(%rax), %xmm1
movsd 0x8(%rcx), %xmm2
mulsd 0x20(%rax), %xmm2
addsd %xmm2, %xmm1
movsd 0x10(%rcx), %xmm2
mulsd 0x38(%rax), %xmm2
addsd %xmm2, %xmm1
addsd 0x50(%rax), %xmm1
movsd (%rcx), %xmm2
mulsd 0x10(%rax), %xmm2
movsd 0x8(%rcx), %xmm3
mulsd 0x28(%rax), %xmm3
addsd %xmm3, %xmm2
movsd 0x10(%rcx), %xmm3
mulsd 0x40(%rax), %xmm3
addsd %xmm3, %xmm2
addsd 0x58(%rax), %xmm2
callq 0x142f0
movq -0x8(%rbp), %rax
leaq 0x10(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x10(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x90(%rbp), %rcx
leaq 0x10(%rbp), %rax
movsd (%rcx), %xmm0
mulsd (%rax), %xmm0
movsd 0x8(%rcx), %xmm1
mulsd 0x20(%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0x10(%rcx), %xmm1
mulsd 0x40(%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0x18(%rcx), %xmm1
mulsd 0x60(%rax), %xmm1
addsd %xmm1, %xmm0
movsd (%rcx), %xmm1
mulsd 0x8(%rax), %xmm1
movsd 0x8(%rcx), %xmm2
mulsd 0x28(%rax), %xmm2
addsd %xmm2, %xmm1
movsd 0x10(%rcx), %xmm2
mulsd 0x48(%rax), %xmm2
addsd %xmm2, %xmm1
movsd 0x18(%rcx), %xmm2
mulsd 0x68(%rax), %xmm2
addsd %xmm2, %xmm1
movsd (%rcx), %xmm2
mulsd 0x10(%rax), %xmm2
movsd 0x8(%rcx), %xmm3
mulsd 0x30(%rax), %xmm3
addsd %xmm3, %xmm2
movsd 0x10(%rcx), %xmm3
mulsd 0x50(%rax), %xmm3
addsd %xmm3, %xmm2
movsd 0x18(%rcx), %xmm3
mulsd 0x70(%rax), %xmm3
addsd %xmm3, %xmm2
movsd (%rcx), %xmm3
mulsd 0x18(%rax), %xmm3
movsd 0x8(%rcx), %xmm4
mulsd 0x38(%rax), %xmm4
addsd %xmm4, %xmm3
movsd 0x10(%rcx), %xmm4
mulsd 0x58(%rax), %xmm4
addsd %xmm4, %xmm3
movsd 0x18(%rcx), %xmm4
mulsd 0x78(%rax), %xmm4
addsd %xmm4, %xmm3
callq 0x144e0
movq -0x8(%rbp), %rax
leaq 0x10(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x30(%rsp), %rsp
leaq 0x10(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd 0x10(%rax), %xmm3
movsd 0x28(%rax), %xmm2
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd 0x40(%rax), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm3
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm4
movaps %xmm1, %xmm0
mulsd %xmm2, %xmm0
movsd 0x18(%rax), %xmm5
movaps %xmm3, %xmm2
mulsd %xmm5, %xmm2
addsd %xmm2, %xmm0
movsd 0x30(%rax), %xmm2
addsd %xmm2, %xmm0
movsd -0x28(%rbp), %xmm5
movsd 0x2f5b(%rip), %xmm2     # 0x17510
divsd %xmm5, %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm4, %xmm1
movsd 0x20(%rax), %xmm4
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm1
movsd 0x38(%rax), %xmm3
addsd %xmm3, %xmm1
mulsd %xmm2, %xmm1
callq 0x14600
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
leaq 0x30(%rsp), %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x10(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x10(%rbp)
leaq 0x90(%rbp), %rcx
leaq 0x10(%rbp), %rax
movsd (%rcx), %xmm0
mulsd 0x18(%rax), %xmm0
movsd 0x8(%rcx), %xmm1
mulsd 0x38(%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0x10(%rcx), %xmm1
mulsd 0x58(%rax), %xmm1
addsd %xmm1, %xmm0
addsd 0x78(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd (%rcx), %xmm0
mulsd (%rax), %xmm0
movsd 0x8(%rcx), %xmm1
mulsd 0x20(%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0x10(%rcx), %xmm1
mulsd 0x40(%rax), %xmm1
addsd %xmm1, %xmm0
addsd 0x60(%rax), %xmm0
divsd -0x8(%rbp), %xmm0
movsd (%rcx), %xmm1
mulsd 0x8(%rax), %xmm1
movsd 0x8(%rcx), %xmm2
mulsd 0x28(%rax), %xmm2
addsd %xmm2, %xmm1
movsd 0x10(%rcx), %xmm2
mulsd 0x48(%rax), %xmm2
addsd %xmm2, %xmm1
addsd 0x68(%rax), %xmm1
divsd -0x8(%rbp), %xmm1
movsd (%rcx), %xmm2
mulsd 0x10(%rax), %xmm2
movsd 0x8(%rcx), %xmm3
mulsd 0x30(%rax), %xmm3
addsd %xmm3, %xmm2
movsd 0x10(%rcx), %xmm3
mulsd 0x50(%rax), %xmm3
addsd %xmm3, %xmm2
addsd 0x70(%rax), %xmm2
divsd -0x8(%rbp), %xmm2
callq 0x142f0
movq -0x10(%rbp), %rax
leaq 0x10(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x30(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movss -0x10(%rbp), %xmm0
mulss -0x10(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x8(%rbp), %xmm0
mulss -0x8(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x4(%rbp), %xmm0
mulss -0x4(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
addss -0x18(%rbp), %xmm0
subss -0x1c(%rbp), %xmm0
subss -0x20(%rbp), %xmm0
movss -0xc(%rbp), %xmm2
mulss -0x8(%rbp), %xmm2
movss -0x10(%rbp), %xmm1
mulss -0x4(%rbp), %xmm1
subss %xmm1, %xmm2
movss 0x1a06(%rip), %xmm1     # 0x17010
mulss %xmm2, %xmm1
movss -0xc(%rbp), %xmm3
mulss -0x4(%rbp), %xmm3
movss -0x10(%rbp), %xmm2
mulss -0x8(%rbp), %xmm2
addss %xmm2, %xmm3
movss 0x19e2(%rip), %xmm2     # 0x17010
mulss %xmm3, %xmm2
movss -0xc(%rbp), %xmm4
mulss -0x8(%rbp), %xmm4
movss -0x10(%rbp), %xmm3
mulss -0x4(%rbp), %xmm3
addss %xmm3, %xmm4
movss 0x19be(%rip), %xmm3     # 0x17010
mulss %xmm4, %xmm3
movss -0x14(%rbp), %xmm4
subss -0x18(%rbp), %xmm4
addss -0x1c(%rbp), %xmm4
subss -0x20(%rbp), %xmm4
movss -0x8(%rbp), %xmm6
mulss -0x4(%rbp), %xmm6
movss -0x10(%rbp), %xmm5
mulss -0xc(%rbp), %xmm5
subss %xmm5, %xmm6
movss 0x1986(%rip), %xmm5     # 0x17010
mulss %xmm6, %xmm5
movss -0xc(%rbp), %xmm7
mulss -0x4(%rbp), %xmm7
movss -0x10(%rbp), %xmm6
mulss -0x8(%rbp), %xmm6
subss %xmm6, %xmm7
movss 0x1962(%rip), %xmm6     # 0x17010
mulss %xmm7, %xmm6
movss -0x8(%rbp), %xmm8
mulss -0x4(%rbp), %xmm8
movss -0x10(%rbp), %xmm7
mulss -0xc(%rbp), %xmm7
addss %xmm7, %xmm8
movss 0x193b(%rip), %xmm7     # 0x17010
mulss %xmm8, %xmm7
movss -0x14(%rbp), %xmm8
subss -0x18(%rbp), %xmm8
subss -0x1c(%rbp), %xmm8
addss -0x20(%rbp), %xmm8
movss %xmm8, (%rsp)
callq 0x15710
movq -0x28(%rbp), %rax
leaq 0x30(%rsp), %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x30(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movsd (%rax), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0x8(%rax), %xmm0
mulsd 0x8(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x10(%rax), %xmm0
mulsd 0x10(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x18(%rax), %xmm0
mulsd 0x18(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd 0x8(%rax), %xmm2
mulsd 0x10(%rax), %xmm2
movsd (%rax), %xmm1
mulsd 0x18(%rax), %xmm1
subsd %xmm1, %xmm2
movsd 0xb77(%rip), %xmm1      # 0x17048
mulsd %xmm2, %xmm1
movsd 0x8(%rax), %xmm3
mulsd 0x18(%rax), %xmm3
movsd (%rax), %xmm2
mulsd 0x10(%rax), %xmm2
addsd %xmm2, %xmm3
movsd 0xb54(%rip), %xmm2      # 0x17048
mulsd %xmm3, %xmm2
movsd 0x8(%rax), %xmm4
mulsd 0x10(%rax), %xmm4
movsd (%rax), %xmm3
mulsd 0x18(%rax), %xmm3
addsd %xmm3, %xmm4
movsd 0xb31(%rip), %xmm3      # 0x17048
mulsd %xmm4, %xmm3
movsd -0x8(%rbp), %xmm4
subsd -0x10(%rbp), %xmm4
addsd -0x18(%rbp), %xmm4
subsd -0x20(%rbp), %xmm4
movsd 0x10(%rax), %xmm6
mulsd 0x18(%rax), %xmm6
movsd (%rax), %xmm5
mulsd 0x8(%rax), %xmm5
subsd %xmm5, %xmm6
movsd 0xafa(%rip), %xmm5      # 0x17048
mulsd %xmm6, %xmm5
movsd 0x8(%rax), %xmm7
mulsd 0x18(%rax), %xmm7
movsd (%rax), %xmm6
mulsd 0x10(%rax), %xmm6
subsd %xmm6, %xmm7
movsd 0xad7(%rip), %xmm6      # 0x17048
mulsd %xmm7, %xmm6
movsd 0x10(%rax), %xmm8
mulsd 0x18(%rax), %xmm8
movsd (%rax), %xmm7
mulsd 0x8(%rax), %xmm7
addsd %xmm7, %xmm8
movsd 0xab1(%rip), %xmm7      # 0x17048
mulsd %xmm8, %xmm7
movsd -0x8(%rbp), %xmm8
subsd -0x10(%rbp), %xmm8
subsd -0x18(%rbp), %xmm8
addsd -0x20(%rbp), %xmm8
movsd %xmm8, (%rsp)
callq 0x165d0
movq -0x28(%rbp), %rax
leaq 0x30(%rsp), %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/socketcan-writer/socketcan-writer.c
// Function: openCanDevice
static int openCanDevice(char *device, int *canSocket)
{
  struct sockaddr_can addr;
  struct ifreq        ifr;

  if (strcmp(device, "stdout") == 0 || strcmp(device, "-") == 0)
  {
    *canSocket = STDOUT_FILENO;
    return 0;
  }

  if ((*canSocket = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0)
  {
    perror("socket");
    return 1;
  }

  strncpy(ifr.ifr_name, device, IFNAMSIZ - 1);
  ifr.ifr_name[IFNAMSIZ - 1] = '\0';
  ifr.ifr_ifindex            = if_nametoindex(ifr.ifr_name);
  if (!ifr.ifr_ifindex)
  {
    perror("if_nametoindex");
    return 1;
  }

  addr.can_family  = AF_CAN;
  addr.can_ifindex = ifr.ifr_ifindex;

  if (bind(*canSocket, (struct sockaddr *) &addr, sizeof(addr)) < 0)
  {
    perror("bind");
    return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x49b7(%rip), %rsi      # 0x7072
callq 0x2160
cmpl $0x0, %eax
je 0x26da
movq -0x10(%rbp), %rdi
leaq 0x49a9(%rip), %rsi      # 0x7079
callq 0x2160
cmpl $0x0, %eax
jne 0x26f0
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x27ad
movl $0x1d, %edi
movl $0x3, %esi
movl $0x1, %edx
callq 0x2320
movq -0x18(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
jge 0x2727
leaq 0x4965(%rip), %rdi      # 0x707b
callq 0x2250
movl $0x1, -0x4(%rbp)
jmp 0x27ad
leaq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xf, %edx
callq 0x2050
movb $0x0, -0x49(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2180
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jne 0x2764
leaq 0x492c(%rip), %rdi      # 0x7082
callq 0x2250
movl $0x1, -0x4(%rbp)
jmp 0x27ad
movw $0x1d, -0x30(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
leaq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
movl $0x18, %edx
callq 0x2220
cmpl $0x0, %eax
jge 0x27a6
leaq 0x48f9(%rip), %rdi      # 0x7091
callq 0x2250
movl $0x1, -0x4(%rbp)
jmp 0x27ad
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x30(%rbp)
cvtsi2sdq -0x18(%rbp), %xmm0
cvtsi2sdq -0x10(%rbp), %xmm1
movsd 0x4818(%rip), %xmm2     # 0x7008
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
cvtsi2sdq -0x28(%rbp), %xmm0
cvtsi2sdq -0x20(%rbp), %xmm1
movsd 0x47f7(%rip), %xmm2     # 0x7008
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x48(%rbp), %xmm0
jbe 0x2853
movq -0x30(%rbp), %rsi
leaq 0x4812(%rip), %rdi      # 0x7054
movb $0x0, %al
callq 0x2e40
movq $0x0, -0x8(%rbp)
jmp 0x2882
movsd -0x48(%rbp), %xmm0
movsd 0x47b0(%rip), %xmm2     # 0x7010
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/socketcan-writer/socketcan-writer.c
// Function: writeRawPGNToCanSocket
static void writeRawPGNToCanSocket(RawMessage *msg, int socket)
{
  struct can_frame frame;
  memset(&frame, 0, sizeof(frame));

  if (msg->pgn >= (1 << 18)) // PGNs can't have more than 18 bits, otherwise it overwrites priority bits
  {
    logError("Invalid PGN, too big (0x%x). Skipping.\n", msg->pgn);
    return;
  }

  frame.can_id = getCanIdFromISO11783Bits(msg->prio, msg->pgn, msg->src, msg->dst);

  if (msg->len <= 8) // 8 or less bytes of data -> PGN fits into a single CAN frame
  {
    frame.can_dlc = msg->len;
    memcpy(frame.data, msg->data, msg->len);
    sendCanFrame(&frame, socket);
  }
  else
  { // Send PGN as n2k fast packet (spans multiple CAN frames, but CAN ID is still same for each frame)
    sendN2kFastPacket(msg, &frame, socket);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2120
movq -0x8(%rbp), %rax
cmpl $0x40000, 0x40(%rax)    # imm = 0x40000
jb 0x28d3
movq -0x8(%rbp), %rax
movl 0x40(%rax), %esi
leaq 0x47cc(%rip), %rdi      # 0x7096
movb $0x0, %al
callq 0x2e40
jmp 0x294e
movq -0x8(%rbp), %rax
movzbl 0x3c(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %esi
movq -0x8(%rbp), %rax
movzbl 0x45(%rax), %edx
movq -0x8(%rbp), %rax
movzbl 0x44(%rax), %ecx
callq 0x41b0
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x46(%rax), %eax
cmpl $0x8, %eax
jg 0x293e
movq -0x8(%rbp), %rax
movb 0x46(%rax), %al
movb %al, -0x1c(%rbp)
leaq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x47, %rsi
movq -0x8(%rbp), %rax
movzbl 0x46(%rax), %eax
movl %eax, %edx
callq 0x21a0
movl -0xc(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x2960
jmp 0x294e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq -0x20(%rbp), %rsi
callq 0x29a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/socketcan-writer/socketcan-writer.c
// Function: sendN2kFastPacket
static void sendN2kFastPacket(RawMessage *msg, struct can_frame *frame, int socket)
{
  int index              = 0;
  int remainingDataBytes = msg->len;
  while (remainingDataBytes > 0)
  {
    frame->data[0]
        = index; // fast packet index (increases by 1 for every CAN frame), 'order' (the 3 uppermost bits) is left as 0 for now

    if (index == 0) // 1st frame
    {
      frame->data[1] = msg->len;             // fast packet payload size
      memcpy(frame->data + 2, msg->data, 6); // 6 first data bytes
      frame->can_dlc = 8;
      remainingDataBytes -= 6;
    }
    else // further frames
    {
      if (remainingDataBytes > 7)
      {
        memcpy(frame->data + 1, msg->data + 6 + (index - 1) * 7, 7); // 7 next data bytes
        frame->can_dlc = 8;
        remainingDataBytes -= 7;
      }
      else
      {
        memcpy(frame->data + 1, msg->data + 6 + (index - 1) * 7, remainingDataBytes); // 7 next data bytes
        frame->can_dlc     = 1 + remainingDataBytes;
        remainingDataBytes = 0;
      }
    }
    sendCanFrame(frame, socket);
    index++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x46(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x2ac0
movl -0x18(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x8(%rax)
cmpl $0x0, -0x18(%rbp)
jne 0x2a1b
movq -0x8(%rbp), %rax
movb 0x46(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x47(%rcx), %edx
movl %edx, 0xa(%rax)
movw 0x4b(%rcx), %cx
movw %cx, 0xe(%rax)
movq -0x10(%rbp), %rax
movb $0x8, 0x4(%rax)
movl -0x1c(%rbp), %eax
subl $0x6, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2aa6
cmpl $0x7, -0x1c(%rbp)
jle 0x2a5f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x18(%rbp), %edx
subl $0x1, %edx
imull $0x7, %edx, %edx
movslq %edx, %rdx
movl 0x4d(%rcx,%rdx), %esi
movl %esi, 0x9(%rax)
movw 0x51(%rcx,%rdx), %si
movw %si, 0xd(%rax)
movb 0x53(%rcx,%rdx), %cl
movb %cl, 0xf(%rax)
movq -0x10(%rbp), %rax
movb $0x8, 0x4(%rax)
movl -0x1c(%rbp), %eax
subl $0x7, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2aa4
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x1, %rdi
movq -0x8(%rbp), %rsi
addq $0x47, %rsi
addq $0x6, %rsi
movl -0x18(%rbp), %eax
subl $0x1, %eax
imull $0x7, %eax, %eax
cltq
addq %rax, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movl $0x0, -0x1c(%rbp)
jmp 0x2aa6
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2960
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x29c5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/joltikneq9696v13/ref/joltik.c
// Function: set_block_number_in_tweak
static void set_block_number_in_tweak(uint8_t *tweak, const uint64_t block_no) {
    tweak[ 6] = (tweak[6]&0xf0) ^ ((block_no >> 40ULL) & 0xf);
    tweak[ 7] = ((block_no >> 32ULL) & 0xff);
    tweak[ 8] = ((block_no >> 24ULL) & 0xff);
    tweak[ 9] = ((block_no >> 16ULL) & 0xff);
    tweak[10] = ((block_no >>  8ULL) & 0xff);
    tweak[11] = ((block_no >>  0ULL) & 0xff);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movzbl 0x6(%rax), %eax
andl $0xf0, %eax
cltq
movq -0x10(%rsp), %rcx
shrq $0x28, %rcx
andq $0xf, %rcx
xorq %rcx, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rsp), %rax
shrq $0x20, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x7(%rax)
movq -0x10(%rsp), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x8(%rax)
movq -0x10(%rsp), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x9(%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xa(%rax)
movq -0x10(%rsp), %rax
shrq $0x0, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xb(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
movq -0x10(%rsp), %rcx
movzbl (%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x3(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rsp), %rax
movzbl 0x3(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x4(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rsp), %rax
movzbl 0x4(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x5(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rsp), %rax
movzbl 0x5(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x6(%rax)
retq
nopl (%rax)