LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Graphics/DrawingRLEBitmaps.c
// Function: CompositeFilledRLEBitmapSpans
static void CompositeFilledRLEBitmapSpans(Bitmap *bitmap,RLEBitmapSpanIterator *iterator,int x0,int y0,Pixel c,CompositionMode mode)
{
	while(NextRLEBitmapSpan(iterator))
	{
		int x=RLEBitmapSpanStart(iterator);
		int y=RLEBitmapRow(iterator);
		int length=RLEBitmapSpanLength(iterator);

		CompositeHorizontalLine(bitmap,x+x0,y+y0,length,c,mode);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x89aa
testb %al, %al
je 0x895d
movl 0x8(%r12), %ecx
movl (%r12), %esi
movl 0x4(%r12), %edx
addl %r15d, %esi
addl %r14d, %edx
movq %r13, %rdi
movl %ebp, %r8d
movq %rbx, %r9
callq 0x8a64
movq %r12, %rdi
jmp 0x892d
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Graphics/RLEBitmap.h
// Function: NextRLEBitmapSpan
static inline bool NextRLEBitmapSpan(RLEBitmapSpanIterator *self)
{
	self->x+=self->spanlength;
	self->pointer+=self->spanlength;
	if(self->x>=self->width)
	{
		self->x=0;
		self->y++;
		if(self->y>=self->height) { self->spanlength=0; return false; }
	}

	Pixel spans=*self->pointer++;
	int empty=spans>>8;
	int filled=spans&0xff;

	self->x+=empty;
	self->spanlength=filled;

	if(!self->spanlength) return NextRLEBitmapSpan(self);
	return true;
}

// Assembly:
movslq 0x8(%rdi), %rax
movl (%rdi), %ecx
addl %eax, %ecx
movl %ecx, (%rdi)
shlq $0x2, %rax
addq 0x10(%rdi), %rax
movq %rax, 0x10(%rdi)
cmpl 0x18(%rdi), %ecx
jl 0x89d8
movl $0x0, (%rdi)
movl 0x4(%rdi), %ecx
incl %ecx
movl %ecx, 0x4(%rdi)
cmpl 0x1c(%rdi), %ecx
jge 0x89f6
leaq 0x4(%rax), %rcx
movq %rcx, 0x10(%rdi)
movl (%rax), %eax
movl %eax, %ecx
shrl $0x8, %ecx
addl %ecx, (%rdi)
andl $0xff, %eax
movl %eax, 0x8(%rdi)
je 0x89aa
movb $0x1, %al
retq
movl $0x0, 0x8(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Graphics/Font.c
// Function: WidthOfSimpleString
int WidthOfSimpleString(const Font *font,const void *str)
{
	const uint8_t *cstring=str;
	int len=0;
	while(*cstring) len+=WidthOfCharacter(font,*cstring++);
	return len;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movb (%rsi), %al
testb %al, %al
je 0x8cda
movq %rsi, %rbx
movq %rdi, %r14
incq %rbx
xorl %ebp, %ebp
movzbl %al, %esi
movq 0x8(%r14), %rax
movq %r14, %rdi
callq *%rax
addl %eax, %ebp
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x8cc1
jmp 0x8cdc
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Graphics/Font.c
// Function: DrawSimpleString
void DrawSimpleString(Bitmap *bitmap,const Font *font,int x,int y,Pixel col,const void *str)
{
	const uint8_t *cstring=str;
	while(*cstring)
	{
		DrawCharacter(bitmap,font,x,y,col,*cstring);
		x+=WidthOfCharacter(font,*cstring);
		cstring++;
	}
}

// Assembly:
movb (%r9), %al
testb %al, %al
je 0x8d4d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
incq %rbx
movzbl %al, %r9d
movq 0x18(%r12), %rax
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %r14d, %ecx
movl %ebp, %r8d
callq *%rax
movzbl -0x1(%rbx), %esi
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *%rax
addl %eax, %r15d
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x8d0a
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Graphics/Font.c
// Function: CompositeSimpleString
void CompositeSimpleString(Bitmap *bitmap,const Font *font,int x,int y,Pixel col,CompositionMode comp,const void *str)
{
	const uint8_t *cstring=str;
	while(*cstring)
	{
		CompositeCharacter(bitmap,font,x,y,col,comp,*cstring);
		x+=WidthOfCharacter(font,*cstring);
		cstring++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq -0x18(%rsp), %rsp
movq 0x50(%rsp), %rbx
movb (%rbx), %al
testb %al, %al
je 0x8dbb
movq %r9, %rbp
movl %r8d, %r14d
movl %ecx, %r13d
movl %edx, %r15d
movq %rsi, %r12
incq %rbx
movq %rdi, 0x10(%rsp)
movzbl %al, %eax
movq 0x28(%r12), %r10
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %r13d, %ecx
movl %r14d, %r8d
movq %rbp, %r9
movl %eax, (%rsp)
callq *%r10
movzbl -0x1(%rbx), %esi
movq 0x8(%r12), %rax
movq %r12, %rdi
callq *%rax
addl %eax, %r15d
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x8d7f
leaq 0x18(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Graphics/MonoFont.c
// Function: DrawMonoFontCharacter
static inline void GenericDrawCharacter(Bitmap *bitmap,const Font *font,int x,int y,
Pixel col,CompositionMode comp,int c,GenericDrawHorizontalLineFunction *hlinefunc)
{
	const MonoFont *self=(const MonoFont *)font;

	if(c<self->firstglyph || c>self->lastglyph) return;
	if(!self->glyphs[c-self->firstglyph]) return;

	const uint8_t *data=self->glyphs[c-self->firstglyph];
	int width=data[1];
	int height=data[2];
	const uint8_t *spans=&data[3];

	for(int dy=0;dy<height;dy++)
	{
		int dx=0;
		while(dx<width)
		{
			dx+=*spans++;
			if(dx>=width) break;

			int length=*spans++;
			GenericDrawHorizontalLine(bitmap,x+dx,y+dy,length,col,comp,hlinefunc);
			dx+=length;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq -0x28(%rsp), %rsp
movl %r9d, %eax
subl 0x38(%rsi), %eax
movl %r8d, 0xc(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jl 0x8ea7
cmpl %r9d, 0x3c(%rsi)
jl 0x8ea7
cltq
movq 0x40(%rsi,%rax,8), %r14
testq %r14, %r14
je 0x8ea7
movzbl 0x2(%r14), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x8ea7
movq %rdi, %r12
movzbl 0x1(%r14), %ebx
addq $0x3, %r14
xorl %ecx, %ecx
testb %bl, %bl
je 0x8e9f
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rsp)
leal (%rcx,%rax), %ebp
incq %r14
xorl %eax, %eax
movzbl -0x1(%r14), %r15d
addl %eax, %r15d
cmpl %ebx, %r15d
jge 0x8e9a
movzbl (%r14), %r13d
movq 0x20(%rsp), %rax
leal (%r15,%rax), %esi
movq %r12, %rdi
movl %ebp, %edx
movl %r13d, %ecx
movl 0xc(%rsp), %r8d
callq 0x8a00
addl %r13d, %r15d
addq $0x2, %r14
cmpl %ebx, %r15d
movl %r15d, %eax
jl 0x8e5c
decq %r14
movq 0x10(%rsp), %rcx
incl %ecx
cmpl 0x8(%rsp), %ecx
jne 0x8e46
leaq 0x28(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Graphics/RLEBitmap.c
// Function: SizeOfRLEBitmapFromPartialBitmap
size_t SizeOfRLEBitmapFromPartialBitmap(const Bitmap *bitmap,int x0,int y0,int width,int height)
{
	size_t numpixels=0;

	for(int y=0;y<height;y++)
	{
		int x=0;
		while(x<width)
		{
			int emptystart=x;
			while(x<width && x-emptystart<0xff)
			{
				Pixel p=ReadPixel(bitmap,x+x0,y+y0);
				if(!IsPixelTransparent(p)) break;
				x++;
			}
			//int empty=x-emptystart;

			int filledstart=x;
			while(x<width && x-filledstart<0xff)
			{
				Pixel p=ReadPixel(bitmap,x+x0,y+y0);
				if(IsPixelTransparent(p)) break;
				x++;
			}
			int filled=x-filledstart;

			numpixels+=1+filled;

			#ifdef SingleBytePixels
			if(x<width || filled!=0) numpixels++;
			#endif
		}
	}

	return sizeof(RLEBitmap)+numpixels*sizeof(Pixel);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq -0x28(%rsp), %rsp
movq %rdx, 0x10(%rsp)
movl %r8d, 0x4(%rsp)
testl %r8d, %r8d
movq %rsi, 0x8(%rsp)
jle 0x90a8
movl %ecx, %ebp
movq %rdi, %r12
xorl %ebx, %ebx
xorl %ecx, %ecx
testl %ebp, %ebp
movq %rcx, 0x18(%rsp)
jle 0x908d
movq 0x10(%rsp), %rax
leal (%rcx,%rax), %r13d
xorl %r15d, %r15d
movq %rbx, 0x20(%rsp)
movl %r15d, %ebx
cmpl %ebp, %ebx
jge 0x9039
movl %ebx, %eax
subl %r15d, %eax
cmpl $0xfe, %eax
jg 0x9039
movq 0x8(%rsp), %rax
leal (%rbx,%rax), %esi
movq %r12, %rdi
movl %r13d, %edx
callq 0x7c3a
andl $0x80, %eax
movl %eax, %r14d
shrl $0x7, %r14d
xorl $0x1, %r14d
addl %ebx, %r14d
testl %eax, %eax
movl %r14d, %ebx
je 0x8ffa
jmp 0x903c
movl %ebx, %r14d
movl %r14d, %r15d
movq 0x20(%rsp), %rbx
cmpl %ebp, %r15d
jge 0x9077
movl %r15d, %eax
subl %r14d, %eax
cmpl $0xfe, %eax
jg 0x9077
movq 0x8(%rsp), %rax
leal (%r15,%rax), %esi
movq %r12, %rdi
movl %r13d, %edx
callq 0x7c3a
shrl $0x7, %eax
andl $0x1, %eax
addl %eax, %r15d
testl %eax, %eax
jne 0x9044
movl %r15d, %eax
subl %r14d, %eax
incl %eax
cltq
addq %rax, %rbx
cmpl %ebp, %r15d
jl 0x8ff2
movq 0x18(%rsp), %rcx
incl %ecx
cmpl 0x4(%rsp), %ecx
jne 0x8fd9
leaq 0x4(,%rbx,4), %rax
jmp 0x90ad
movl $0x4, %eax
leaq 0x28(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Graphics/RLEBitmap.c
// Function: InitializeRLEBitmapFromPartialBitmap
void InitializeRLEBitmapFromPartialBitmap(RLEBitmap *self,const Bitmap *bitmap,int x0,int y0,int width,int height)
{
	self->width=width;
	self->height=height;
	Pixel *ptr=self->codes;

	for(int y=0;y<height;y++)
	{
		int x=0;
		while(x<width)
		{
			int emptystart=x;
			while(x<width && x-emptystart<0xff)
			{
				Pixel p=ReadPixel(bitmap,x+x0,y+y0);
				if(!IsPixelTransparent(p)) break;
				x++;
			}
			int empty=x-emptystart;

			int filledstart=x;
			while(x<width && x-filledstart<0xff)
			{
				Pixel p=ReadPixel(bitmap,x+x0,y+y0);
				if(IsPixelTransparent(p)) break;
				x++;
			}
			int filled=x-filledstart;

			#ifdef SingleBytePixels
			*ptr++=empty;
			if(x<width || filled!=0) *ptr++=filled;
			#else
			*ptr++=RLECode(empty,filled);
			memcpy(ptr,ConstBitmapPixelPointer(bitmap,filledstart+x0,y+y0),filled*sizeof(Pixel));
			ptr+=filled;
			#endif
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq -0x38(%rsp), %rsp
movl %r8d, %ebp
movq %rcx, 0x20(%rsp)
movq %rdx, 0x10(%rsp)
testl %r9d, %r9d
movw %bp, (%rdi)
movl %r9d, 0x1c(%rsp)
movq %rdi, 0x8(%rsp)
movw %r9w, 0x2(%rdi)
jle 0x921b
movq %rsi, %r12
addq $0x4, 0x8(%rsp)
xorl %ecx, %ecx
testl %ebp, %ebp
movq %rcx, 0x28(%rsp)
jle 0x920a
movq 0x20(%rsp), %rax
leal (%rcx,%rax), %r14d
xorl %r15d, %r15d
movslq %r14d, %rax
movq %rax, 0x30(%rsp)
movl %r15d, %ebx
cmpl %ebp, %ebx
jge 0x9174
movl %ebx, %eax
subl %r15d, %eax
cmpl $0xfe, %eax
jg 0x9174
movq 0x10(%rsp), %rax
leal (%rbx,%rax), %esi
movq %r12, %rdi
movl %r14d, %edx
callq 0x7c3a
andl $0x80, %eax
movl %eax, %r13d
shrl $0x7, %r13d
xorl $0x1, %r13d
addl %ebx, %r13d
testl %eax, %eax
movl %r13d, %ebx
je 0x9135
jmp 0x9177
movl %ebx, %r13d
movl %r13d, %ebx
subl %r15d, %ebx
movl %r13d, %r15d
cmpl %ebp, %r15d
jge 0x91b3
movl %r15d, %eax
subl %r13d, %eax
cmpl $0xfe, %eax
jg 0x91b3
movq 0x10(%rsp), %rax
leal (%r15,%rax), %esi
movq %r12, %rdi
movl %r14d, %edx
callq 0x7c3a
shrl $0x7, %eax
andl $0x1, %eax
addl %eax, %r15d
testl %eax, %eax
jne 0x9180
movl %r15d, %eax
subl %r13d, %eax
shll $0x8, %ebx
orl %eax, %ebx
movl %ebx, %ecx
movq 0x8(%rsp), %rbx
movl %ecx, (%rbx)
movslq 0x4(%r12), %rcx
imulq 0x30(%rsp), %rcx
leaq 0x4(%rbx), %rdi
addl 0x10(%rsp), %r13d
addq 0x8(%r12), %rcx
movslq %r13d, %rdx
movslq %eax, %r13
leaq (%rcx,%rdx,4), %rsi
leaq (,%r13,4), %rdx
callq 0x1140
cmpl %ebp, %r15d
leaq 0x4(%rbx,%r13,4), %rbx
movq %rbx, 0x8(%rsp)
jl 0x9132
movq 0x28(%rsp), %rcx
incl %ecx
cmpl 0x1c(%rsp), %ecx
jne 0x9111
leaq 0x38(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat3x3rotate
mat3x3_t mat3x3rotate(float angle,vec3_t axis)
{
	float sine=sinf(angle);
	float cosine=cosf(angle);
	float one_minus_cosine=1-cosine;

	axis=vec3norm(axis);

	return mat3x3(
	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 -0x20(%rsp), %rsp
movaps %xmm1, %xmm5
movaps %xmm2, %xmm4
mulss %xmm1, %xmm5
mulss %xmm2, %xmm4
movshdup %xmm1, %xmm3            # xmm3 = xmm1[1,1,3,3]
movaps %xmm3, %xmm6
addss %xmm5, %xmm4
mulss %xmm3, %xmm6
addss %xmm6, %xmm4
xorps %xmm5, %xmm5
rsqrtss %xmm4, %xmm5
movaps %xmm4, %xmm6
mulss %xmm5, %xmm6
movss 0x4da3(%rip), %xmm7     # 0xe010
mulss %xmm6, %xmm7
mulss %xmm5, %xmm6
addss 0x4d97(%rip), %xmm6     # 0xe014
andps 0x4dac(%rip), %xmm4     # 0xe030
cmpltss 0x4d8b(%rip), %xmm4     # 0xe018
mulss %xmm7, %xmm6
andnps %xmm6, %xmm4
xorps %xmm5, %xmm5
ucomiss %xmm5, %xmm4
movq %rdi, %rbx
xorps %xmm6, %xmm6
je 0x92c6
movss 0x4d5e(%rip), %xmm5     # 0xe008
divss %xmm4, %xmm5
mulss %xmm5, %xmm1
mulss %xmm5, %xmm3
mulss %xmm5, %xmm2
insertps $0x10, %xmm3, %xmm1     # xmm1 = xmm1[0],xmm3[0],xmm1[2,3]
movaps %xmm1, %xmm6
movaps %xmm2, %xmm5
movaps %xmm6, 0x10(%rsp)
movss %xmm5, 0x4(%rsp)
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1030
movss (%r15), %xmm0
movss 0x4d15(%rip), %xmm2     # 0xe008
subss %xmm0, %xmm2
movaps 0x10(%rsp), %xmm4
movaps %xmm4, %xmm3
mulss %xmm2, %xmm3
movss (%r14), %xmm5
movshdup %xmm4, %xmm1            # xmm1 = xmm4[1,1,3,3]
movaps %xmm4, %xmm12
movaps %xmm3, %xmm4
movaps %xmm1, %xmm6
mulss %xmm12, %xmm4
mulss %xmm2, %xmm6
movaps %xmm3, %xmm7
movss 0x4(%rsp), %xmm10
movaps %xmm10, %xmm9
mulss %xmm1, %xmm7
mulss %xmm5, %xmm9
mulss %xmm10, %xmm3
movaps %xmm1, %xmm8
mulss %xmm5, %xmm8
mulss %xmm6, %xmm1
mulss %xmm10, %xmm6
movaps %xmm10, %xmm11
mulss %xmm10, %xmm11
addss %xmm0, %xmm4
movaps %xmm7, %xmm10
mulss %xmm5, %xmm12
movaps %xmm3, %xmm5
addss %xmm9, %xmm10
subss %xmm8, %xmm5
subss %xmm9, %xmm7
mulss %xmm2, %xmm11
addss %xmm0, %xmm1
addss %xmm3, %xmm8
movaps %xmm6, %xmm2
subss %xmm12, %xmm6
addss %xmm12, %xmm2
addss %xmm0, %xmm11
movss %xmm4, (%rbx)
movss %xmm7, 0x4(%rbx)
movss %xmm8, 0x8(%rbx)
movss %xmm10, 0xc(%rbx)
movss %xmm1, 0x10(%rbx)
movss %xmm6, 0x14(%rbx)
movss %xmm5, 0x18(%rbx)
movq %rbx, %rax
movss %xmm2, 0x1c(%rbx)
movss %xmm11, 0x20(%rbx)
leaq 0x20(%rsp), %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat2x2mul
mat2x2_t mat2x2mul(mat2x2_t a,mat2x2_t b)
{
	return mat2x2(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:
movaps %xmm0, %xmm4
movaps %xmm2, %xmm6
movshdup %xmm2, %xmm5            # xmm5 = xmm2[1,1,3,3]
mulss %xmm0, %xmm6
movaps %xmm5, %xmm0
mulss %xmm1, %xmm0
movshdup %xmm4, %xmm7            # xmm7 = xmm4[1,1,3,3]
movshdup %xmm3, %xmm8            # xmm8 = xmm3[1,1,3,3]
mulss %xmm7, %xmm2
mulss %xmm3, %xmm7
movaps %xmm3, %xmm9
mulss %xmm4, %xmm9
movaps %xmm8, %xmm3
mulss %xmm1, %xmm3
movshdup %xmm1, %xmm1            # xmm1 = xmm1[1,1,3,3]
mulss %xmm1, %xmm5
mulss %xmm1, %xmm8
addss %xmm6, %xmm0
addss %xmm9, %xmm3
addss %xmm2, %xmm5
addss %xmm7, %xmm8
insertps $0x10, %xmm5, %xmm0     # xmm0 = xmm0[0],xmm5[0],xmm0[2,3]
insertps $0x10, %xmm8, %xmm3     # xmm3 = xmm3[0],xmm8[0],xmm3[2,3]
movaps %xmm3, %xmm1
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat3x3mul
mat3x3_t mat3x3mul(mat3x3_t a,mat3x3_t b)
{
	return mat3x3(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:
movss 0x30(%rsp), %xmm1
movss 0x34(%rsp), %xmm12
movss 0x8(%rsp), %xmm5
movaps %xmm1, %xmm0
movaps %xmm1, %xmm8
movss %xmm1, -0x14(%rsp)
movss 0x14(%rsp), %xmm4
movaps %xmm12, %xmm1
mulss %xmm5, %xmm0
mulss %xmm4, %xmm1
addss %xmm0, %xmm1
movss 0x38(%rsp), %xmm6
movss 0x20(%rsp), %xmm0
movss %xmm0, -0x8(%rsp)
movaps %xmm6, %xmm2
mulss %xmm0, %xmm2
movss 0xc(%rsp), %xmm3
addss %xmm1, %xmm2
movss %xmm2, -0x4(%rsp)
movss 0x3c(%rsp), %xmm10
movaps %xmm10, %xmm1
movss 0x18(%rsp), %xmm15
movaps %xmm3, %xmm0
movaps %xmm15, %xmm7
mulss %xmm8, %xmm0
mulss %xmm12, %xmm7
mulss %xmm5, %xmm1
movss %xmm1, -0x1c(%rsp)
movss 0x40(%rsp), %xmm11
movaps %xmm11, %xmm14
movss 0x48(%rsp), %xmm1
mulss %xmm4, %xmm14
mulss %xmm1, %xmm5
movss %xmm5, -0xc(%rsp)
movss %xmm1, -0x18(%rsp)
addss %xmm0, %xmm7
movss 0x24(%rsp), %xmm8
movss 0x4c(%rsp), %xmm0
movaps %xmm8, %xmm13
mulss %xmm0, %xmm4
movss %xmm0, -0x10(%rsp)
mulss %xmm6, %xmm13
movaps %xmm3, %xmm9
movaps %xmm15, %xmm5
mulss %xmm10, %xmm9
mulss %xmm11, %xmm5
mulss %xmm1, %xmm3
mulss %xmm0, %xmm15
movss 0x10(%rsp), %xmm2
movss 0x1c(%rsp), %xmm1
movss -0x14(%rsp), %xmm0
mulss %xmm2, %xmm0
mulss %xmm1, %xmm12
mulss %xmm2, %xmm10
mulss %xmm1, %xmm11
addss -0x1c(%rsp), %xmm14
addss -0xc(%rsp), %xmm4
movss %xmm4, -0x1c(%rsp)
addss %xmm7, %xmm13
addss %xmm9, %xmm5
addss %xmm3, %xmm15
addss %xmm0, %xmm12
addss %xmm10, %xmm11
movss 0x44(%rsp), %xmm3
mulss -0x18(%rsp), %xmm2
movaps %xmm3, %xmm7
movss -0x8(%rsp), %xmm4
mulss %xmm4, %xmm7
mulss -0x10(%rsp), %xmm1
movaps %xmm8, %xmm9
movss 0x28(%rsp), %xmm10
mulss %xmm3, %xmm9
mulss %xmm10, %xmm6
mulss %xmm10, %xmm3
movss 0x50(%rsp), %xmm0
addss %xmm2, %xmm1
mulss %xmm0, %xmm4
mulss %xmm0, %xmm8
mulss %xmm0, %xmm10
addss %xmm14, %xmm7
addss %xmm12, %xmm6
addss %xmm5, %xmm9
addss %xmm11, %xmm3
movq %rdi, %rax
addss -0x1c(%rsp), %xmm4
addss %xmm15, %xmm8
addss %xmm1, %xmm10
movss -0x4(%rsp), %xmm1
movss %xmm1, (%rdi)
movss %xmm13, 0x4(%rdi)
movss %xmm6, 0x8(%rdi)
movss %xmm7, 0xc(%rdi)
movss %xmm9, 0x10(%rdi)
movss %xmm3, 0x14(%rdi)
movss %xmm4, 0x18(%rdi)
movss %xmm8, 0x1c(%rdi)
movss %xmm10, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat4x4mul
mat4x4_t mat4x4mul(mat4x4_t a,mat4x4_t b)
{
        mat4x4_t res;
        for(int i=0;i<16;i++)
        {
                int row=i&3,column=i&12;
                float 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 0x48(%rsp), %rcx
leaq 0x8(%rsp), %rdx
xorl %esi, %esi
movl %esi, %edi
movq %rsi, %r8
andl $0x3, %edi
andq $-0x4, %r8
leaq (%rdx,%rdi,4), %rdi
leaq (%rcx,%r8,4), %r8
xorps %xmm0, %xmm0
movq $-0x10, %r9
movss 0x10(%r8,%r9), %xmm1
mulss 0x40(%rdi,%r9,4), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r9
jne 0x98b0
movss %xmm0, (%rax,%rsi,4)
incq %rsi
cmpq $0x10, %rsi
jne 0x9892
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat3x2affinemul
mat3x2_t mat3x2affinemul(mat3x2_t a,mat3x2_t b)
{
	return mat3x2(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:
movss 0x20(%rsp), %xmm3
movss 0x24(%rsp), %xmm1
movss 0x8(%rsp), %xmm4
movaps %xmm3, %xmm7
movss 0xc(%rsp), %xmm5
mulss %xmm4, %xmm7
movss 0x10(%rsp), %xmm0
movaps %xmm1, %xmm2
mulss %xmm0, %xmm2
movss 0x28(%rsp), %xmm9
movaps %xmm9, %xmm10
movss 0x2c(%rsp), %xmm6
mulss %xmm4, %xmm10
movaps %xmm6, %xmm8
mulss %xmm0, %xmm8
movss 0x30(%rsp), %xmm11
mulss %xmm11, %xmm4
movss 0x34(%rsp), %xmm12
mulss %xmm5, %xmm3
mulss %xmm5, %xmm9
mulss %xmm11, %xmm5
movss 0x14(%rsp), %xmm11
mulss %xmm12, %xmm0
mulss %xmm11, %xmm1
mulss %xmm11, %xmm6
mulss %xmm12, %xmm11
addss %xmm7, %xmm2
addss %xmm10, %xmm8
addss %xmm4, %xmm0
addss %xmm3, %xmm1
addss %xmm5, %xmm11
addss %xmm9, %xmm6
addss 0x18(%rsp), %xmm0
addss 0x1c(%rsp), %xmm11
movq %rdi, %rax
movss %xmm2, (%rdi)
movss %xmm1, 0x4(%rdi)
movss %xmm8, 0x8(%rdi)
movss %xmm6, 0xc(%rdi)
movss %xmm0, 0x10(%rdi)
movss %xmm11, 0x14(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat3x3affinemul
mat3x3_t mat3x3affinemul(mat3x3_t a,mat3x3_t b)
{
	return mat3x3(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:
movss 0x30(%rsp), %xmm3
movss 0x34(%rsp), %xmm1
movss 0x8(%rsp), %xmm2
movaps %xmm3, %xmm7
movss 0xc(%rsp), %xmm4
mulss %xmm2, %xmm7
movss 0x14(%rsp), %xmm0
movss 0x3c(%rsp), %xmm9
movaps %xmm1, %xmm6
movaps %xmm9, %xmm10
mulss %xmm0, %xmm6
mulss %xmm2, %xmm10
movss 0x40(%rsp), %xmm5
movss 0x48(%rsp), %xmm12
movaps %xmm5, %xmm8
mulss %xmm12, %xmm2
mulss %xmm4, %xmm3
movss 0x18(%rsp), %xmm11
mulss %xmm4, %xmm9
mulss %xmm12, %xmm4
movss 0x4c(%rsp), %xmm12
mulss %xmm11, %xmm1
mulss %xmm0, %xmm8
mulss %xmm12, %xmm0
mulss %xmm11, %xmm5
mulss %xmm12, %xmm11
addss %xmm7, %xmm6
addss %xmm3, %xmm1
addss %xmm10, %xmm8
addss %xmm2, %xmm0
addss %xmm9, %xmm5
addss %xmm4, %xmm11
movq %rdi, %rax
addss 0x20(%rsp), %xmm0
addss 0x24(%rsp), %xmm11
movss %xmm6, (%rdi)
movss %xmm1, 0x4(%rdi)
xorl %ecx, %ecx
movl %ecx, 0x8(%rdi)
movss %xmm8, 0xc(%rdi)
movss %xmm5, 0x10(%rdi)
movl %ecx, 0x14(%rdi)
movss %xmm0, 0x18(%rdi)
movss %xmm11, 0x1c(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat4x4det
float mat4x4det(mat4x4_t m)
{
	float a0=m.m[0]*m.m[5]-m.m[1]*m.m[4];
	float a1=m.m[0]*m.m[6]-m.m[2]*m.m[4];
	float a2=m.m[0]*m.m[7]-m.m[3]*m.m[4];
	float a3=m.m[1]*m.m[6]-m.m[2]*m.m[5];
	float a4=m.m[1]*m.m[7]-m.m[3]*m.m[5];
	float a5=m.m[2]*m.m[7]-m.m[3]*m.m[6];
	float b0=m.m[8]*m.m[13]-m.m[9]*m.m[12];
	float b1=m.m[8]*m.m[14]-m.m[10]*m.m[12];
	float b2=m.m[8]*m.m[15]-m.m[11]*m.m[12];
	float b3=m.m[9]*m.m[14]-m.m[10]*m.m[13];
	float b4=m.m[9]*m.m[15]-m.m[11]*m.m[13];
	float 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:
movss 0x1c(%rsp), %xmm1
movss 0x8(%rsp), %xmm9
movss 0xc(%rsp), %xmm12
movss 0x18(%rsp), %xmm3
movaps %xmm1, %xmm0
movaps %xmm3, %xmm2
mulss %xmm9, %xmm0
movss %xmm0, -0x4(%rsp)
mulss %xmm12, %xmm2
movss %xmm2, -0x8(%rsp)
movss 0x20(%rsp), %xmm10
movss 0x10(%rsp), %xmm0
movaps %xmm0, %xmm2
movss 0x14(%rsp), %xmm4
mulss %xmm3, %xmm2
movss %xmm2, -0xc(%rsp)
mulss %xmm4, %xmm3
movss %xmm3, -0x10(%rsp)
movaps %xmm10, %xmm2
movaps %xmm0, %xmm3
mulss %xmm1, %xmm3
movss %xmm3, -0x18(%rsp)
mulss %xmm4, %xmm1
movss %xmm1, -0x14(%rsp)
mulss %xmm10, %xmm4
movss %xmm4, -0x1c(%rsp)
mulss %xmm9, %xmm10
movss 0x24(%rsp), %xmm14
mulss %xmm14, %xmm9
mulss %xmm12, %xmm2
movss %xmm2, -0x20(%rsp)
mulss %xmm14, %xmm12
movss 0x3c(%rsp), %xmm11
movss 0x28(%rsp), %xmm13
movaps %xmm11, %xmm15
mulss %xmm0, %xmm14
mulss %xmm13, %xmm15
movss 0x2c(%rsp), %xmm6
movss 0x38(%rsp), %xmm7
movaps %xmm7, %xmm0
movss 0x30(%rsp), %xmm8
mulss %xmm6, %xmm0
movss %xmm0, -0x24(%rsp)
movaps %xmm8, %xmm5
mulss %xmm7, %xmm5
movss 0x34(%rsp), %xmm3
mulss %xmm3, %xmm7
movaps %xmm8, %xmm4
mulss %xmm11, %xmm4
movss 0x40(%rsp), %xmm2
mulss %xmm3, %xmm11
mulss %xmm2, %xmm3
movaps %xmm2, %xmm1
mulss %xmm13, %xmm2
movss 0x44(%rsp), %xmm0
mulss %xmm0, %xmm13
mulss %xmm6, %xmm1
mulss %xmm0, %xmm6
mulss %xmm8, %xmm0
subss -0x10(%rsp), %xmm9
movss -0x20(%rsp), %xmm8
subss -0x18(%rsp), %xmm8
subss -0x1c(%rsp), %xmm14
subss -0x24(%rsp), %xmm15
subss %xmm7, %xmm13
subss %xmm4, %xmm1
movss -0x4(%rsp), %xmm4
subss -0x8(%rsp), %xmm4
subss %xmm3, %xmm0
subss -0xc(%rsp), %xmm10
subss -0x14(%rsp), %xmm12
mulss %xmm14, %xmm15
subss %xmm2, %xmm5
mulss %xmm8, %xmm13
mulss %xmm9, %xmm1
subss %xmm6, %xmm11
mulss %xmm4, %xmm0
addss %xmm15, %xmm1
addss %xmm13, %xmm0
mulss %xmm12, %xmm5
mulss %xmm10, %xmm11
addss %xmm5, %xmm11
addss %xmm1, %xmm0
addss %xmm11, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat3x3transform
vec3_t mat3x3transform(mat3x3_t m,vec3_t v)
{
	return vec3(
	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:
movaps %xmm0, %xmm2
movss 0x8(%rsp), %xmm3
mulss %xmm0, %xmm3
movss 0x20(%rsp), %xmm0
mulss %xmm1, %xmm0
movss 0xc(%rsp), %xmm4
mulss %xmm2, %xmm4
movss 0x24(%rsp), %xmm5
mulss %xmm1, %xmm5
movss 0x10(%rsp), %xmm6
mulss %xmm2, %xmm6
mulss 0x28(%rsp), %xmm1
movshdup %xmm2, %xmm2            # xmm2 = xmm2[1,1,3,3]
movss 0x14(%rsp), %xmm7
addss %xmm3, %xmm0
mulss %xmm2, %xmm7
addss %xmm4, %xmm5
movss 0x18(%rsp), %xmm3
mulss %xmm2, %xmm3
addss %xmm6, %xmm1
mulss 0x1c(%rsp), %xmm2
addss %xmm7, %xmm0
addss %xmm3, %xmm5
addss %xmm2, %xmm1
insertps $0x10, %xmm5, %xmm0     # xmm0 = xmm0[0],xmm5[0],xmm0[2,3]
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat4x3transform
vec3_t mat4x3transform(mat4x3_t m,vec3_t v)
{
	return vec3(
	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:
movaps %xmm0, %xmm2
movss 0x8(%rsp), %xmm3
mulss %xmm0, %xmm3
movss 0x20(%rsp), %xmm0
mulss %xmm1, %xmm0
movss 0xc(%rsp), %xmm5
mulss %xmm2, %xmm5
movss 0x24(%rsp), %xmm4
mulss %xmm1, %xmm4
movss 0x10(%rsp), %xmm6
mulss %xmm2, %xmm6
mulss 0x28(%rsp), %xmm1
movshdup %xmm2, %xmm2            # xmm2 = xmm2[1,1,3,3]
movss 0x14(%rsp), %xmm7
addss %xmm3, %xmm0
mulss %xmm2, %xmm7
addss %xmm5, %xmm4
movss 0x18(%rsp), %xmm3
mulss %xmm2, %xmm3
addss %xmm6, %xmm1
mulss 0x1c(%rsp), %xmm2
addss %xmm7, %xmm0
addss %xmm3, %xmm4
addss %xmm2, %xmm1
addss 0x2c(%rsp), %xmm0
addss 0x30(%rsp), %xmm4
addss 0x34(%rsp), %xmm1
insertps $0x10, %xmm4, %xmm0     # xmm0 = xmm0[0],xmm4[0],xmm0[2,3]
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat4x4transform
vec4_t mat4x4transform(mat4x4_t m,vec4_t v)
{
	return vec4(
	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:
movaps %xmm0, %xmm2
movss 0x8(%rsp), %xmm5
mulss %xmm0, %xmm5
movshdup %xmm0, %xmm3            # xmm3 = xmm0[1,1,3,3]
movss 0x18(%rsp), %xmm7
mulss %xmm3, %xmm7
movss 0x28(%rsp), %xmm6
mulss %xmm1, %xmm6
movshdup %xmm1, %xmm4            # xmm4 = xmm1[1,1,3,3]
movss 0x38(%rsp), %xmm0
movss 0xc(%rsp), %xmm9
mulss %xmm4, %xmm0
mulss %xmm2, %xmm9
movss 0x1c(%rsp), %xmm11
movss 0x2c(%rsp), %xmm8
mulss %xmm3, %xmm11
mulss %xmm1, %xmm8
movss 0x3c(%rsp), %xmm10
movss 0x10(%rsp), %xmm12
mulss %xmm4, %xmm10
mulss %xmm2, %xmm12
movss 0x20(%rsp), %xmm14
movss 0x30(%rsp), %xmm13
mulss %xmm1, %xmm13
movss 0x14(%rsp), %xmm15
mulss %xmm2, %xmm15
movss 0x34(%rsp), %xmm2
mulss %xmm1, %xmm2
movss 0x40(%rsp), %xmm1
mulss %xmm3, %xmm14
mulss %xmm4, %xmm1
mulss 0x24(%rsp), %xmm3
mulss 0x44(%rsp), %xmm4
addss %xmm5, %xmm6
addss %xmm7, %xmm0
addss %xmm9, %xmm8
addss %xmm11, %xmm10
addss %xmm12, %xmm13
addss %xmm14, %xmm1
addss %xmm15, %xmm2
addss %xmm3, %xmm4
addss %xmm6, %xmm0
addss %xmm8, %xmm10
addss %xmm13, %xmm1
addss %xmm2, %xmm4
insertps $0x10, %xmm10, %xmm0    # xmm0 = xmm0[0],xmm10[0],xmm0[2,3]
insertps $0x10, %xmm4, %xmm1     # xmm1 = xmm1[0],xmm4[0],xmm1[2,3]
retq
// File: /workspace/github_c_makefile_star2_O1/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat3x3transformvec2
vec2_t mat3x3transformvec2(mat3x3_t m,vec2_t v)
{
	float z=v.x*m.m[2]+v.y*m.m[5]+m.m[8];
	return vec2(
	(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:
movss 0x10(%rsp), %xmm2
movshdup %xmm0, %xmm1            # xmm1 = xmm0[1,1,3,3]
movss 0x1c(%rsp), %xmm3
mulss %xmm0, %xmm2
mulss %xmm1, %xmm3
addss %xmm2, %xmm3
addss 0x28(%rsp), %xmm3
movss 0x2d23(%rip), %xmm2     # 0xe008
divss %xmm3, %xmm2
movss 0x8(%rsp), %xmm3
mulss %xmm0, %xmm3
movss 0xc(%rsp), %xmm4
mulss %xmm0, %xmm4
movss 0x14(%rsp), %xmm0
mulss %xmm1, %xmm0
mulss 0x18(%rsp), %xmm1
addss %xmm3, %xmm0
addss %xmm4, %xmm1
addss 0x20(%rsp), %xmm0
addss 0x24(%rsp), %xmm1
mulss %xmm2, %xmm0
mulss %xmm2, %xmm1
insertps $0x10, %xmm1, %xmm0     # xmm0 = xmm0[0],xmm1[0],xmm0[2,3]
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movss 0x14(%rsp), %xmm2
movss 0x34(%rsp), %xmm5
mulss %xmm0, %xmm2
mulss %xmm1, %xmm5
movshdup %xmm0, %xmm3            # xmm3 = xmm0[1,1,3,3]
movss 0x24(%rsp), %xmm4
addss %xmm2, %xmm5
mulss %xmm3, %xmm4
addss %xmm4, %xmm5
addss 0x44(%rsp), %xmm5
movss 0x2ca0(%rip), %xmm4     # 0xe008
divss %xmm5, %xmm4
movss 0x8(%rsp), %xmm6
mulss %xmm0, %xmm6
movss 0x28(%rsp), %xmm2
mulss %xmm1, %xmm2
movss 0xc(%rsp), %xmm7
mulss %xmm0, %xmm7
movss 0x2c(%rsp), %xmm5
mulss %xmm1, %xmm5
movss 0x10(%rsp), %xmm8
mulss %xmm0, %xmm8
mulss 0x30(%rsp), %xmm1
movss 0x18(%rsp), %xmm0
addss %xmm6, %xmm2
mulss %xmm3, %xmm0
addss %xmm7, %xmm5
movss 0x1c(%rsp), %xmm6
mulss %xmm3, %xmm6
addss %xmm8, %xmm1
mulss 0x20(%rsp), %xmm3
addss %xmm0, %xmm2
addss %xmm6, %xmm5
addss %xmm3, %xmm1
addss 0x38(%rsp), %xmm2
addss 0x3c(%rsp), %xmm5
addss 0x40(%rsp), %xmm1
mulss %xmm4, %xmm2
mulss %xmm4, %xmm5
mulss %xmm4, %xmm1
insertps $0x10, %xmm5, %xmm2     # xmm2 = xmm2[0],xmm5[0],xmm2[2,3]
movaps %xmm2, %xmm0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 -0x10(%rsp), %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x10e0
movsd 0x30(%rsp), %xmm4
movsd 0x38(%rsp), %xmm6
movapd %xmm4, %xmm0
movapd %xmm6, %xmm1
mulsd %xmm4, %xmm0
mulsd %xmm6, %xmm1
movsd 0x40(%rsp), %xmm7
movapd %xmm7, %xmm2
addsd %xmm0, %xmm1
mulsd %xmm7, %xmm2
addsd %xmm1, %xmm2
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
movsd 0x2bea(%rip), %xmm8     # 0xe050
movapd %xmm8, %xmm3
divsd %xmm0, %xmm8
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movsd (%r15), %xmm2
mulsd %xmm8, %xmm4
cmpeqsd %xmm1, %xmm0
subsd %xmm2, %xmm3
movsd (%r14), %xmm5
andnpd %xmm4, %xmm0
xorpd %xmm4, %xmm4
je 0xb4ac
mulsd %xmm8, %xmm6
mulsd %xmm8, %xmm7
movapd %xmm6, %xmm1
movapd %xmm7, %xmm4
movapd %xmm0, %xmm6
mulsd %xmm3, %xmm6
movlpd %xmm0, 0x30(%rsp)
movapd %xmm1, %xmm7
movsd %xmm1, 0x38(%rsp)
mulsd %xmm3, %xmm7
movsd %xmm4, 0x40(%rsp)
movapd %xmm6, %xmm8
mulsd %xmm0, %xmm8
movapd %xmm6, %xmm9
mulsd %xmm1, %xmm9
movapd %xmm4, %xmm11
mulsd %xmm5, %xmm11
mulsd %xmm4, %xmm6
movapd %xmm1, %xmm10
mulsd %xmm7, %xmm1
mulsd %xmm4, %xmm7
mulsd %xmm4, %xmm4
mulsd %xmm5, %xmm10
movapd %xmm9, %xmm12
mulsd %xmm5, %xmm0
addsd %xmm2, %xmm8
addsd %xmm11, %xmm12
movapd %xmm6, %xmm5
mulsd %xmm3, %xmm4
subsd %xmm10, %xmm5
subsd %xmm11, %xmm9
addsd %xmm2, %xmm1
addsd %xmm6, %xmm10
movapd %xmm7, %xmm3
subsd %xmm0, %xmm7
addsd %xmm0, %xmm3
addsd %xmm2, %xmm4
movsd %xmm8, (%rbx)
movsd %xmm9, 0x8(%rbx)
movsd %xmm10, 0x10(%rbx)
movsd %xmm12, 0x18(%rbx)
movsd %xmm1, 0x20(%rbx)
movsd %xmm7, 0x28(%rbx)
movsd %xmm5, 0x30(%rbx)
movq %rbx, %rax
movsd %xmm3, 0x38(%rbx)
movsd %xmm4, 0x40(%rbx)
leaq 0x10(%rsp), %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
leaq -0x98(%rsp), %rsp
movsd 0xb0(%rsp), %xmm0
movsd 0xb8(%rsp), %xmm1
subsd 0xc8(%rsp), %xmm0
subsd 0xd0(%rsp), %xmm1
movsd 0xc0(%rsp), %xmm2
subsd 0xd8(%rsp), %xmm2
movapd %xmm0, %xmm3
movapd %xmm1, %xmm4
mulsd %xmm0, %xmm3
mulsd %xmm1, %xmm4
movapd %xmm2, %xmm5
addsd %xmm3, %xmm4
mulsd %xmm2, %xmm5
addsd %xmm4, %xmm5
xorps %xmm3, %xmm3
sqrtsd %xmm5, %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm3
movq %rdi, %rbx
leaq 0xe0(%rsp), %rax
jne 0xb614
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
jmp 0xb63e
movsd 0x2a34(%rip), %xmm4     # 0xe050
divsd %xmm3, %xmm4
mulsd %xmm4, %xmm0
mulsd %xmm4, %xmm1
mulsd %xmm4, %xmm2
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x38(%rsp)
movsd %xmm2, 0x40(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movups %xmm0, (%rsp)
callq 0xdef0
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movapd %xmm0, %xmm3
movapd %xmm1, %xmm4
mulsd %xmm0, %xmm3
mulsd %xmm1, %xmm4
movsd 0x10(%r14), %xmm2
movapd %xmm2, %xmm5
addsd %xmm3, %xmm4
mulsd %xmm2, %xmm5
addsd %xmm4, %xmm5
xorps %xmm3, %xmm3
sqrtsd %xmm5, %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm3
jne 0xb6c9
xorpd %xmm0, %xmm0
movapd %xmm0, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
jmp 0xb6f3
movsd 0x297f(%rip), %xmm4     # 0xe050
divsd %xmm3, %xmm4
mulsd %xmm4, %xmm0
mulsd %xmm4, %xmm1
mulsd %xmm4, %xmm2
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x58(%rsp)
movsd %xmm2, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x68(%rsp), %r14
movaps 0x30(%rsp), %xmm0
movq %r14, %rdi
movups %xmm0, (%rsp)
callq 0xdef0
movsd (%r14), %xmm5
movsd 0x8(%r14), %xmm0
movapd %xmm5, %xmm1
movapd %xmm0, %xmm3
mulsd %xmm5, %xmm1
mulsd %xmm0, %xmm3
movsd 0x10(%r14), %xmm2
movapd %xmm2, %xmm4
addsd %xmm1, %xmm3
mulsd %xmm2, %xmm4
addsd %xmm3, %xmm4
xorps %xmm1, %xmm1
sqrtsd %xmm4, %xmm1
movsd 0x28e9(%rip), %xmm4     # 0xe050
divsd %xmm1, %xmm4
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm1
mulsd %xmm4, %xmm5
cmpeqsd %xmm3, %xmm1
andnpd %xmm5, %xmm1
xorpd %xmm5, %xmm5
je 0xb796
mulsd %xmm4, %xmm0
mulsd %xmm4, %xmm2
movapd %xmm0, %xmm3
movapd %xmm2, %xmm5
movups 0x58(%rsp), %xmm0
movaps 0x30(%rsp), %xmm2
movsd 0x40(%rsp), %xmm4
movsd 0x50(%rsp), %xmm6
movsd %xmm6, (%rbx)
movups %xmm0, 0x8(%rbx)
movlpd %xmm1, 0x18(%rbx)
movsd %xmm3, 0x20(%rbx)
movsd %xmm5, 0x28(%rbx)
movq %rbx, %rax
movups %xmm2, 0x30(%rbx)
movsd %xmm4, 0x40(%rbx)
leaq 0x98(%rsp), %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movsd 0x28(%rsp), %xmm2
movsd 0x30(%rsp), %xmm0
movsd 0x8(%rsp), %xmm3
movapd %xmm2, %xmm5
movsd 0x10(%rsp), %xmm4
mulsd %xmm3, %xmm5
movsd 0x18(%rsp), %xmm1
movapd %xmm0, %xmm6
mulsd %xmm1, %xmm6
movsd 0x38(%rsp), %xmm7
mulsd %xmm7, %xmm3
mulsd %xmm4, %xmm2
movsd 0x20(%rsp), %xmm8
mulsd %xmm7, %xmm4
movsd 0x40(%rsp), %xmm7
mulsd %xmm8, %xmm0
mulsd %xmm7, %xmm1
mulsd %xmm7, %xmm8
addsd %xmm5, %xmm6
addsd %xmm2, %xmm0
addsd %xmm3, %xmm1
addsd %xmm4, %xmm8
movq %rdi, %rax
movsd %xmm6, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm8, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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), %xmm5
movsd 0x58(%rsp), %xmm1
movsd 0x8(%rsp), %xmm6
movapd %xmm5, %xmm0
movsd 0x20(%rsp), %xmm2
movapd %xmm1, %xmm4
movapd %xmm1, %xmm3
mulsd %xmm6, %xmm0
mulsd %xmm2, %xmm4
movsd 0x68(%rsp), %xmm8
movsd 0x70(%rsp), %xmm10
movapd %xmm8, %xmm1
movapd %xmm10, %xmm7
mulsd %xmm6, %xmm1
mulsd %xmm2, %xmm7
movsd 0x10(%rsp), %xmm15
addsd %xmm0, %xmm4
movsd %xmm4, -0x8(%rsp)
addsd %xmm1, %xmm7
movsd %xmm7, -0x10(%rsp)
movsd 0x80(%rsp), %xmm0
mulsd %xmm0, %xmm6
movsd 0x88(%rsp), %xmm4
mulsd %xmm4, %xmm2
movsd 0x28(%rsp), %xmm9
movapd %xmm15, %xmm1
movapd %xmm9, %xmm11
mulsd %xmm5, %xmm1
mulsd %xmm3, %xmm11
movapd %xmm15, %xmm12
movapd %xmm9, %xmm13
mulsd %xmm8, %xmm12
mulsd %xmm10, %xmm13
mulsd %xmm0, %xmm15
mulsd %xmm4, %xmm9
movsd 0x18(%rsp), %xmm7
movsd 0x30(%rsp), %xmm14
mulsd %xmm7, %xmm5
mulsd %xmm14, %xmm3
mulsd %xmm7, %xmm8
mulsd %xmm14, %xmm10
addsd %xmm6, %xmm2
movsd %xmm2, -0x18(%rsp)
addsd %xmm1, %xmm11
addsd %xmm12, %xmm13
movsd 0x38(%rsp), %xmm6
addsd %xmm15, %xmm9
movsd 0x60(%rsp), %xmm12
addsd %xmm5, %xmm3
movsd %xmm3, -0x20(%rsp)
movapd %xmm12, %xmm15
mulsd %xmm6, %xmm15
addsd %xmm8, %xmm10
movsd 0x78(%rsp), %xmm5
mulsd %xmm0, %xmm7
movsd 0x40(%rsp), %xmm1
mulsd %xmm4, %xmm14
movapd %xmm5, %xmm4
movapd %xmm1, %xmm3
mulsd %xmm6, %xmm4
mulsd %xmm12, %xmm3
movapd %xmm1, %xmm2
movsd 0x48(%rsp), %xmm8
mulsd %xmm5, %xmm2
mulsd %xmm8, %xmm12
mulsd %xmm8, %xmm5
movsd 0x90(%rsp), %xmm0
addsd %xmm7, %xmm14
mulsd %xmm0, %xmm6
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm8
addsd -0x8(%rsp), %xmm15
addsd %xmm11, %xmm3
addsd -0x10(%rsp), %xmm4
addsd -0x20(%rsp), %xmm12
addsd %xmm13, %xmm2
addsd %xmm10, %xmm5
movq %rdi, %rax
addsd -0x18(%rsp), %xmm6
addsd %xmm9, %xmm1
addsd %xmm14, %xmm8
movsd %xmm15, (%rdi)
movsd %xmm3, 0x8(%rdi)
movsd %xmm12, 0x10(%rdi)
movsd %xmm4, 0x18(%rdi)
movsd %xmm2, 0x20(%rdi)
movsd %xmm5, 0x28(%rdi)
movsd %xmm6, 0x30(%rdi)
movsd %xmm1, 0x38(%rdi)
movsd %xmm8, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %esi, %edi
movq %rsi, %r8
andl $0x3, %edi
andq $-0x4, %r8
leaq (%rdx,%rdi,8), %rdi
leaq (%rcx,%r8,8), %r8
xorpd %xmm0, %xmm0
movq $-0x20, %r9
movsd 0x20(%r8,%r9), %xmm1
mulsd 0x80(%rdi,%r9,4), %xmm1
addsd %xmm1, %xmm0
addq $0x8, %r9
jne 0xba68
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x10, %rsi
jne 0xba49
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movsd 0x38(%rsp), %xmm3
movsd 0x40(%rsp), %xmm1
movsd 0x8(%rsp), %xmm4
movapd %xmm3, %xmm7
movsd 0x10(%rsp), %xmm5
mulsd %xmm4, %xmm7
movsd 0x18(%rsp), %xmm0
movapd %xmm1, %xmm2
mulsd %xmm0, %xmm2
movsd 0x48(%rsp), %xmm9
movapd %xmm9, %xmm10
movsd 0x50(%rsp), %xmm6
mulsd %xmm4, %xmm10
movapd %xmm6, %xmm8
mulsd %xmm0, %xmm8
movsd 0x58(%rsp), %xmm11
mulsd %xmm11, %xmm4
movsd 0x60(%rsp), %xmm12
mulsd %xmm5, %xmm3
mulsd %xmm5, %xmm9
mulsd %xmm11, %xmm5
movsd 0x20(%rsp), %xmm11
mulsd %xmm12, %xmm0
mulsd %xmm11, %xmm1
mulsd %xmm11, %xmm6
mulsd %xmm12, %xmm11
addsd %xmm7, %xmm2
addsd %xmm10, %xmm8
addsd %xmm4, %xmm0
addsd %xmm3, %xmm1
addsd %xmm5, %xmm11
addsd %xmm9, %xmm6
addsd 0x28(%rsp), %xmm0
addsd 0x30(%rsp), %xmm11
movq %rdi, %rax
movsd %xmm2, (%rdi)
movsd %xmm1, 0x8(%rdi)
movsd %xmm8, 0x10(%rdi)
movsd %xmm6, 0x18(%rdi)
movsd %xmm0, 0x20(%rdi)
movsd %xmm11, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movsd 0x50(%rsp), %xmm3
movsd 0x58(%rsp), %xmm1
movsd 0x8(%rsp), %xmm7
movapd %xmm3, %xmm8
movsd 0x10(%rsp), %xmm5
mulsd %xmm7, %xmm8
movsd 0x20(%rsp), %xmm0
movapd %xmm1, %xmm2
mulsd %xmm0, %xmm2
movsd 0x68(%rsp), %xmm9
movapd %xmm9, %xmm10
movsd 0x70(%rsp), %xmm4
mulsd %xmm7, %xmm10
movapd %xmm4, %xmm6
mulsd %xmm0, %xmm6
movsd 0x80(%rsp), %xmm11
mulsd %xmm11, %xmm7
movsd 0x88(%rsp), %xmm12
mulsd %xmm5, %xmm3
mulsd %xmm5, %xmm9
mulsd %xmm11, %xmm5
movsd 0x28(%rsp), %xmm11
mulsd %xmm12, %xmm0
mulsd %xmm11, %xmm1
mulsd %xmm11, %xmm4
mulsd %xmm12, %xmm11
addsd %xmm8, %xmm2
addsd %xmm10, %xmm6
addsd %xmm7, %xmm0
addsd %xmm3, %xmm1
addsd %xmm9, %xmm4
addsd %xmm5, %xmm11
addsd 0x38(%rsp), %xmm0
movq %rdi, %rax
addsd 0x40(%rsp), %xmm11
movsd %xmm2, (%rdi)
xorl %ecx, %ecx
movsd %xmm1, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movsd %xmm6, 0x18(%rdi)
movsd %xmm4, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movsd %xmm0, 0x30(%rdi)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movsd %xmm11, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x30(%rsp), %xmm1
movsd 0x8(%rsp), %xmm9
movsd 0x10(%rsp), %xmm12
movsd 0x28(%rsp), %xmm3
movapd %xmm1, %xmm0
movapd %xmm3, %xmm2
mulsd %xmm9, %xmm0
movsd %xmm0, -0x8(%rsp)
mulsd %xmm12, %xmm2
movsd %xmm2, -0x10(%rsp)
movsd 0x38(%rsp), %xmm10
movsd 0x18(%rsp), %xmm0
movapd %xmm0, %xmm2
movsd 0x20(%rsp), %xmm4
mulsd %xmm3, %xmm2
movsd %xmm2, -0x18(%rsp)
mulsd %xmm4, %xmm3
movsd %xmm3, -0x20(%rsp)
movapd %xmm10, %xmm2
movapd %xmm0, %xmm3
mulsd %xmm1, %xmm3
movsd %xmm3, -0x30(%rsp)
mulsd %xmm4, %xmm1
movsd %xmm1, -0x28(%rsp)
mulsd %xmm10, %xmm4
movsd %xmm4, -0x38(%rsp)
mulsd %xmm9, %xmm10
movsd 0x40(%rsp), %xmm14
mulsd %xmm14, %xmm9
mulsd %xmm12, %xmm2
movsd %xmm2, -0x40(%rsp)
mulsd %xmm14, %xmm12
movsd 0x70(%rsp), %xmm11
movsd 0x48(%rsp), %xmm13
movapd %xmm11, %xmm15
mulsd %xmm0, %xmm14
mulsd %xmm13, %xmm15
movsd 0x50(%rsp), %xmm6
movsd 0x68(%rsp), %xmm7
movapd %xmm7, %xmm0
movsd 0x58(%rsp), %xmm8
mulsd %xmm6, %xmm0
movsd %xmm0, -0x48(%rsp)
movapd %xmm8, %xmm5
mulsd %xmm7, %xmm5
movsd 0x60(%rsp), %xmm3
mulsd %xmm3, %xmm7
movapd %xmm8, %xmm4
mulsd %xmm11, %xmm4
movsd 0x78(%rsp), %xmm2
mulsd %xmm3, %xmm11
mulsd %xmm2, %xmm3
movapd %xmm2, %xmm1
mulsd %xmm13, %xmm2
movsd 0x80(%rsp), %xmm0
mulsd %xmm0, %xmm13
mulsd %xmm6, %xmm1
mulsd %xmm0, %xmm6
mulsd %xmm8, %xmm0
subsd -0x20(%rsp), %xmm9
movsd -0x40(%rsp), %xmm8
subsd -0x30(%rsp), %xmm8
subsd -0x38(%rsp), %xmm14
subsd -0x48(%rsp), %xmm15
subsd %xmm7, %xmm13
subsd %xmm4, %xmm1
movsd -0x8(%rsp), %xmm4
subsd -0x10(%rsp), %xmm4
subsd %xmm3, %xmm0
subsd -0x18(%rsp), %xmm10
subsd -0x28(%rsp), %xmm12
mulsd %xmm14, %xmm15
subsd %xmm2, %xmm5
mulsd %xmm8, %xmm13
mulsd %xmm9, %xmm1
subsd %xmm6, %xmm11
mulsd %xmm4, %xmm0
mulsd %xmm12, %xmm5
addsd %xmm15, %xmm1
mulsd %xmm10, %xmm11
addsd %xmm13, %xmm0
addsd %xmm5, %xmm11
addsd %xmm1, %xmm0
addsd %xmm11, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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), %xmm2
movsd 0x58(%rsp), %xmm0
movsd 0x8(%rsp), %xmm3
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm3
mulsd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm4
movsd 0x28(%rsp), %xmm5
mulsd %xmm2, %xmm4
mulsd %xmm0, %xmm5
mulsd 0x18(%rsp), %xmm2
mulsd 0x30(%rsp), %xmm0
addsd %xmm3, %xmm1
movsd 0x60(%rsp), %xmm3
movsd 0x38(%rsp), %xmm6
addsd %xmm4, %xmm5
mulsd %xmm3, %xmm6
addsd %xmm2, %xmm0
movsd 0x40(%rsp), %xmm2
mulsd %xmm3, %xmm2
mulsd 0x48(%rsp), %xmm3
addsd %xmm1, %xmm6
addsd %xmm5, %xmm2
addsd %xmm0, %xmm3
movq %rdi, %rax
movsd %xmm6, (%rdi)
movsd %xmm2, 0x8(%rdi)
movsd %xmm3, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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), %xmm2
movsd 0x70(%rsp), %xmm0
movsd 0x8(%rsp), %xmm3
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm3
mulsd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm4
movsd 0x28(%rsp), %xmm5
mulsd %xmm2, %xmm4
mulsd %xmm0, %xmm5
mulsd 0x18(%rsp), %xmm2
mulsd 0x30(%rsp), %xmm0
addsd %xmm3, %xmm1
movsd 0x78(%rsp), %xmm3
movsd 0x38(%rsp), %xmm6
addsd %xmm4, %xmm5
mulsd %xmm3, %xmm6
addsd %xmm2, %xmm0
movsd 0x40(%rsp), %xmm2
mulsd %xmm3, %xmm2
mulsd 0x48(%rsp), %xmm3
addsd %xmm1, %xmm6
addsd %xmm5, %xmm2
addsd %xmm0, %xmm3
addsd 0x50(%rsp), %xmm6
addsd 0x58(%rsp), %xmm2
addsd 0x60(%rsp), %xmm3
movq %rdi, %rax
movsd %xmm6, (%rdi)
movsd %xmm2, 0x8(%rdi)
movsd %xmm3, 0x10(%rdi)
retq