LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Graphics/DrawingRLEBitmaps.c
// Function: DrawFilledRLEBitmap
void DrawFilledRLEBitmap(Bitmap *bitmap,const RLEBitmap *src,int x,int y,Pixel c)
{
	if(IsCompletelyOutside(x,y,src->width,src->height,bitmap->width,bitmap->height)) return;

	RLEBitmapSpanIterator iterator;
	InitializeRLEBitmapSpanIterator(&iterator,src);
	ClipRLEBitmapSpanIteratorRows(&iterator,bitmap,y);

	if(IsSpanCompletelyInside(x,src->width,bitmap->width)) DrawFilledRLEBitmapSpansNoClip(bitmap,&iterator,x,y,c);
	else DrawFilledRLEBitmapSpans(bitmap,&iterator,x,y,c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x40(%rsp), %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rax
movswl (%rax), %edx
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %ecx
movq -0x8(%rbp), %rax
movswl (%rax), %r8d
movq -0x8(%rbp), %rax
movswl 0x2(%rax), %r9d
callq 0xb870
testb $0x1, %al
jne 0xbe8c
jmp 0xbe8e
jmp 0xbef7
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xb8d0
movq -0x8(%rbp), %rsi
movl -0x18(%rbp), %edx
leaq -0x40(%rbp), %rdi
callq 0xb930
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rax
movswl (%rax), %esi
movq -0x8(%rbp), %rax
movswl (%rax), %edx
callq 0xb9b0
testb $0x1, %al
jne 0xbec7
jmp 0xbee0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
leaq -0x40(%rbp), %rsi
callq 0xbf00
jmp 0xbef7
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
leaq -0x40(%rbp), %rsi
callq 0xbf80
leaq 0x40(%rsp), %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Graphics/DrawingRLEBitmaps.c
// Function: DrawFilledRLEBitmapSpansNoClip
static void DrawFilledRLEBitmapSpansNoClip(Bitmap *bitmap,RLEBitmapSpanIterator *iterator,int x0,int y0,Pixel c)
{
	while(NextRLEBitmapSpan(iterator))
	{
		int x=RLEBitmapSpanStart(iterator);
		int y=RLEBitmapRow(iterator);
		int length=RLEBitmapSpanLength(iterator);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x30(%rsp), %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc2b0
testb $0x1, %al
jne 0xbf2a
jmp 0xbf6c
movq -0x10(%rbp), %rdi
callq 0xc3a0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc3b0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc3d0
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
addl -0x14(%rbp), %esi
movl -0x24(%rbp), %edx
addl -0x18(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0xc480
jmp 0xbf1b
leaq 0x30(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Graphics/DrawingRLEBitmaps.c
// Function: DrawFilledRLEBitmapSpans
static void DrawFilledRLEBitmapSpans(Bitmap *bitmap,RLEBitmapSpanIterator *iterator,int x0,int y0,Pixel c)
{
	while(NextRLEBitmapSpan(iterator))
	{
		int x=RLEBitmapSpanStart(iterator);
		int y=RLEBitmapRow(iterator);
		int length=RLEBitmapSpanLength(iterator);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x30(%rsp), %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc2b0
testb $0x1, %al
jne 0xbfaa
jmp 0xbfec
movq -0x10(%rbp), %rdi
callq 0xc3a0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc3b0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc3d0
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
addl -0x14(%rbp), %esi
movl -0x24(%rbp), %edx
addl -0x18(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x1c(%rbp), %r8d
callq 0xc4c0
jmp 0xbf9b
leaq 0x30(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Graphics/DrawingRLEBitmaps.c
// Function: CompositeFilledRLEBitmap
void CompositeFilledRLEBitmap(Bitmap *bitmap,const RLEBitmap *src,int x,int y,Pixel c,CompositionMode mode)
{
	if(IsCompletelyOutside(x,y,src->width,src->height,bitmap->width,bitmap->height)) return;

	RLEBitmapSpanIterator iterator;
	InitializeRLEBitmapSpanIterator(&iterator,src);
	ClipRLEBitmapSpanIteratorRows(&iterator,bitmap,y);

	if(IsSpanCompletelyInside(x,src->width,bitmap->width)) CompositeFilledRLEBitmapSpans(bitmap,&iterator,x,y,c,mode);
	else CompositeFilledRLEBitmapSpansNoClip(bitmap,&iterator,x,y,c,mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x50(%rsp), %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rax
movswl (%rax), %edx
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %ecx
movq -0x8(%rbp), %rax
movswl (%rax), %r8d
movq -0x8(%rbp), %rax
movswl 0x2(%rax), %r9d
callq 0xb870
testb $0x1, %al
jne 0xc0a0
jmp 0xc0a2
jmp 0xc113
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xb8d0
movq -0x8(%rbp), %rsi
movl -0x18(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0xb930
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rax
movswl (%rax), %esi
movq -0x8(%rbp), %rax
movswl (%rax), %edx
callq 0xb9b0
testb $0x1, %al
jne 0xc0db
jmp 0xc0f8
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
leaq -0x48(%rbp), %rsi
callq 0xc120
jmp 0xc113
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
leaq -0x48(%rbp), %rsi
callq 0xc1a0
leaq 0x50(%rsp), %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
leaq -0x40(%rsp), %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc2b0
testb $0x1, %al
jne 0xc14e
jmp 0xc194
movq -0x10(%rbp), %rdi
callq 0xc3a0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc3b0
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc3d0
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
addl -0x14(%rbp), %esi
movl -0x30(%rbp), %edx
addl -0x18(%rbp), %edx
movl -0x34(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0xc5d0
jmp 0xc13f
leaq 0x40(%rsp), %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x20(%rsp), %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0xc332
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jl 0xc330
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xc391
jmp 0xc332
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x10(%rcx)
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xc38d
movq -0x10(%rbp), %rdi
callq 0xc2b0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xc391
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
leaq 0x20(%rsp), %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
leaq -0x20(%rsp), %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0xc9cc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %esi
callq 0xc9e0
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xc9a0
movl -0x1c(%rbp), %eax
leaq 0x20(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x30(%rsp), %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0xca83
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq -0x30(%rbp), %rax
movzbl (%rax), %r9d
callq 0xca90
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movzbl (%rax), %esi
callq 0xc9e0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xca37
leaq 0x30(%rsp), %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
leaq -0x40(%rsp), %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0xcb5d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movl %eax, (%rsp)
callq 0xcb70
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movzbl (%rax), %esi
callq 0xc9e0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xcb0b
leaq 0x40(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Graphics/MonoFont.c
// Function: WidthOfMonoFontCharacter
int WidthOfMonoFontCharacter(const Font *font,int c)
{
	const MonoFont *self=(const MonoFont *)font;

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

	const uint8_t *data=self->glyphs[c-self->firstglyph];
	return data[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jl 0xcbfb
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x3c(%rcx), %eax
jle 0xcc04
movl $0x0, -0x4(%rbp)
jmp 0xcc4a
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rdx
subl 0x38(%rdx), %ecx
movslq %ecx, %rcx
cmpq $0x0, 0x40(%rax,%rcx,8)
jne 0xcc26
movl $0x0, -0x4(%rbp)
jmp 0xcc4a
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rdx
subl 0x38(%rdx), %ecx
movslq %ecx, %rcx
movq 0x40(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Graphics/MonoFont.c
// Function: GenericDrawCharacter
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
movq %rsp, %rbp
leaq -0x60(%rsp), %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x10(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jl 0xccf6
movl 0x10(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x3c(%rcx), %eax
jle 0xccfb
jmp 0xcdf1
movq -0x30(%rbp), %rax
movl 0x10(%rbp), %ecx
movq -0x30(%rbp), %rdx
subl 0x38(%rdx), %ecx
movslq %ecx, %rcx
cmpq $0x0, 0x40(%rax,%rcx,8)
jne 0xcd19
jmp 0xcdf1
movq -0x30(%rbp), %rax
movl 0x10(%rbp), %ecx
movq -0x30(%rbp), %rdx
subl 0x38(%rdx), %ecx
movslq %ecx, %rcx
movq 0x40(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0xcdf1
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0xcde1
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movzbl (%rax), %eax
addl -0x50(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jl 0xcd99
jmp 0xcde1
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movzbl (%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl -0x50(%rbp), %esi
movl -0x18(%rbp), %edx
addl -0x4c(%rbp), %edx
movl -0x54(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
movq 0x18(%rbp), %rax
movq %rax, (%rsp)
callq 0xcee0
movl -0x54(%rbp), %eax
addl -0x50(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0xcd6f
jmp 0xcde3
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xcd5c
leaq 0x60(%rsp), %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
leaq -0x40(%rsp), %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xd0c4
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xd0b4
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x3d(%rbp)
jge 0xcfdc
movl -0x28(%rbp), %eax
subl -0x2c(%rbp), %eax
cmpl $0xff, %eax
setl %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0xcfe5
jmp 0xd027
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %esi
addl -0xc(%rbp), %esi
movl -0x24(%rbp), %edx
addl -0x10(%rbp), %edx
callq 0xad60
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xd012
xorl %eax, %eax
testb $0x1, %al
jne 0xd01c
jmp 0xd01a
movb $0x1, %al
testb $0x1, %al
jne 0xd01c
jmp 0xd01a
jmp 0xd027
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xcfbe
movl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x3e(%rbp)
jge 0xd04b
movl -0x28(%rbp), %eax
subl -0x34(%rbp), %eax
cmpl $0xff, %eax
setl %al
movb %al, -0x3e(%rbp)
movb -0x3e(%rbp), %al
testb $0x1, %al
jne 0xd054
jmp 0xd096
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %esi
addl -0xc(%rbp), %esi
movl -0x24(%rbp), %edx
addl -0x10(%rbp), %edx
callq 0xad60
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xd081
xorl %eax, %eax
testb $0x1, %al
jne 0xd089
jmp 0xd08b
movb $0x1, %al
testb $0x1, %al
jne 0xd089
jmp 0xd08b
jmp 0xd096
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd02d
movl -0x28(%rbp), %eax
subl -0x34(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xcfac
jmp 0xd0b6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xcf99
movq -0x20(%rbp), %rax
shlq $0x2, %rax
addq $0x4, %rax
leaq 0x40(%rsp), %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq -0x80(%rsp), %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x68(%rbp)
movlpd %xmm1, -0x20(%rbp)
movss %xmm2, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
callq 0x10e0
movss %xmm0, -0x28(%rbp)
movss -0x24(%rbp), %xmm0
callq 0x1050
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm1
movss 0x9c0b(%rip), %xmm0     # 0x17004
subss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movss -0x48(%rbp), %xmm1
callq 0xd560
movq -0x70(%rbp), %rdi
movss %xmm1, -0x58(%rbp)
movlpd %xmm0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x3c(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x3c(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x8(%rbp)
movss -0x2c(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
mulss -0x10(%rbp), %xmm1
mulss -0x10(%rbp), %xmm1
addss %xmm1, %xmm0
movss -0x30(%rbp), %xmm1
mulss -0x10(%rbp), %xmm1
mulss -0xc(%rbp), %xmm1
movss -0x8(%rbp), %xmm2
mulss -0x28(%rbp), %xmm2
addss %xmm2, %xmm1
movss -0x30(%rbp), %xmm2
mulss -0x10(%rbp), %xmm2
mulss -0x8(%rbp), %xmm2
movss -0xc(%rbp), %xmm3
mulss -0x28(%rbp), %xmm3
subss %xmm3, %xmm2
movss -0x30(%rbp), %xmm3
mulss -0x10(%rbp), %xmm3
mulss -0xc(%rbp), %xmm3
movss -0x8(%rbp), %xmm4
mulss -0x28(%rbp), %xmm4
subss %xmm4, %xmm3
movss -0x2c(%rbp), %xmm4
movss -0x30(%rbp), %xmm5
mulss -0xc(%rbp), %xmm5
mulss -0xc(%rbp), %xmm5
addss %xmm5, %xmm4
movss -0x30(%rbp), %xmm5
mulss -0xc(%rbp), %xmm5
mulss -0x8(%rbp), %xmm5
movss -0x10(%rbp), %xmm6
mulss -0x28(%rbp), %xmm6
addss %xmm6, %xmm5
movss -0x30(%rbp), %xmm6
mulss -0x10(%rbp), %xmm6
mulss -0x8(%rbp), %xmm6
movss -0xc(%rbp), %xmm7
mulss -0x28(%rbp), %xmm7
addss %xmm7, %xmm6
movss -0x30(%rbp), %xmm7
mulss -0xc(%rbp), %xmm7
mulss -0x8(%rbp), %xmm7
movss -0x10(%rbp), %xmm8
mulss -0x28(%rbp), %xmm8
subss %xmm8, %xmm7
movss -0x2c(%rbp), %xmm8
movss -0x30(%rbp), %xmm9
mulss -0x8(%rbp), %xmm9
mulss -0x8(%rbp), %xmm9
addss %xmm9, %xmm8
movss %xmm8, (%rsp)
callq 0xd640
movq -0x68(%rbp), %rax
leaq 0x80(%rsp), %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x30(%rsp), %rsp
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
movlpd %xmm2, -0x30(%rbp)
movlpd %xmm3, -0x28(%rbp)
movss -0x30(%rbp), %xmm4
movss -0x2c(%rbp), %xmm8
movss -0x20(%rbp), %xmm1
movss -0x1c(%rbp), %xmm3
movaps %xmm1, %xmm0
mulss %xmm4, %xmm0
movss -0x18(%rbp), %xmm2
movaps %xmm2, %xmm5
mulss %xmm8, %xmm5
addss %xmm5, %xmm0
movss -0x28(%rbp), %xmm6
mulss %xmm6, %xmm1
movss -0x24(%rbp), %xmm5
mulss %xmm5, %xmm2
addss %xmm2, %xmm1
movaps %xmm3, %xmm2
mulss %xmm4, %xmm2
movss -0x14(%rbp), %xmm4
movaps %xmm4, %xmm7
mulss %xmm8, %xmm7
addss %xmm7, %xmm2
mulss %xmm6, %xmm3
mulss %xmm5, %xmm4
addss %xmm4, %xmm3
callq 0xdc20
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
leaq 0x30(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x10(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x38(%rbp), %rax
leaq 0x10(%rbp), %rcx
movss (%rcx), %xmm0
mulss (%rax), %xmm0
movss 0xc(%rcx), %xmm1
mulss 0x4(%rax), %xmm1
addss %xmm1, %xmm0
movss 0x18(%rcx), %xmm1
mulss 0x8(%rax), %xmm1
addss %xmm1, %xmm0
movss (%rcx), %xmm1
mulss 0xc(%rax), %xmm1
movss 0xc(%rcx), %xmm2
mulss 0x10(%rax), %xmm2
addss %xmm2, %xmm1
movss 0x18(%rcx), %xmm2
mulss 0x14(%rax), %xmm2
addss %xmm2, %xmm1
movss (%rcx), %xmm2
mulss 0x18(%rax), %xmm2
movss 0xc(%rcx), %xmm3
mulss 0x1c(%rax), %xmm3
addss %xmm3, %xmm2
movss 0x18(%rcx), %xmm3
mulss 0x20(%rax), %xmm3
addss %xmm3, %xmm2
movss 0x4(%rcx), %xmm3
mulss (%rax), %xmm3
movss 0x10(%rcx), %xmm4
mulss 0x4(%rax), %xmm4
addss %xmm4, %xmm3
movss 0x1c(%rcx), %xmm4
mulss 0x8(%rax), %xmm4
addss %xmm4, %xmm3
movss 0x4(%rcx), %xmm4
mulss 0xc(%rax), %xmm4
movss 0x10(%rcx), %xmm5
mulss 0x10(%rax), %xmm5
addss %xmm5, %xmm4
movss 0x1c(%rcx), %xmm5
mulss 0x14(%rax), %xmm5
addss %xmm5, %xmm4
movss 0x4(%rcx), %xmm5
mulss 0x18(%rax), %xmm5
movss 0x10(%rcx), %xmm6
mulss 0x1c(%rax), %xmm6
addss %xmm6, %xmm5
movss 0x1c(%rcx), %xmm6
mulss 0x20(%rax), %xmm6
addss %xmm6, %xmm5
movss 0x8(%rcx), %xmm6
mulss (%rax), %xmm6
movss 0x14(%rcx), %xmm7
mulss 0x4(%rax), %xmm7
addss %xmm7, %xmm6
movss 0x20(%rcx), %xmm7
mulss 0x8(%rax), %xmm7
addss %xmm7, %xmm6
movss 0x8(%rcx), %xmm7
mulss 0xc(%rax), %xmm7
movss 0x14(%rcx), %xmm8
mulss 0x10(%rax), %xmm8
addss %xmm8, %xmm7
movss 0x20(%rcx), %xmm8
mulss 0x14(%rax), %xmm8
addss %xmm8, %xmm7
movss 0x8(%rcx), %xmm8
mulss 0x18(%rax), %xmm8
movss 0x14(%rcx), %xmm9
mulss 0x1c(%rax), %xmm9
addss %xmm9, %xmm8
movss 0x20(%rcx), %xmm9
mulss 0x20(%rax), %xmm9
addss %xmm9, %xmm8
movss %xmm8, (%rsp)
callq 0xd640
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/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
leaq 0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x10, -0x4(%rbp)
jge 0xdeb2
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
movss %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xde92
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x8(%rbp), %edx
movl -0x14(%rbp), %esi
shll $0x2, %esi
addl %esi, %edx
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
movl -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
mulss (%rax,%rcx,4), %xmm0
addss -0x10(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xde4e
movq -0x38(%rbp), %rax
movss -0x10(%rbp), %xmm0
movslq -0x4(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xde23
movq -0x30(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x10(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x28(%rbp), %rcx
leaq 0x10(%rbp), %rax
movss (%rax), %xmm0
mulss (%rcx), %xmm0
movss 0x8(%rax), %xmm1
mulss 0x4(%rcx), %xmm1
addss %xmm1, %xmm0
movss (%rax), %xmm1
mulss 0x8(%rcx), %xmm1
movss 0x8(%rax), %xmm2
mulss 0xc(%rcx), %xmm2
addss %xmm2, %xmm1
movss (%rax), %xmm2
mulss 0x10(%rcx), %xmm2
movss 0x8(%rax), %xmm3
mulss 0x14(%rcx), %xmm3
addss %xmm3, %xmm2
addss 0x10(%rax), %xmm2
movss 0x4(%rax), %xmm3
mulss (%rcx), %xmm3
movss 0xc(%rax), %xmm4
mulss 0x4(%rcx), %xmm4
addss %xmm4, %xmm3
movss 0x4(%rax), %xmm4
mulss 0x8(%rcx), %xmm4
movss 0xc(%rax), %xmm5
mulss 0xc(%rcx), %xmm5
addss %xmm5, %xmm4
movss 0x4(%rax), %xmm5
mulss 0x10(%rcx), %xmm5
movss 0xc(%rax), %xmm6
mulss 0x14(%rcx), %xmm6
addss %xmm6, %xmm5
addss 0x14(%rax), %xmm5
callq 0xdf80
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/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x10(%rsp), %rsp
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x38(%rbp), %rcx
leaq 0x10(%rbp), %rax
movss (%rax), %xmm0
mulss (%rcx), %xmm0
movss 0xc(%rax), %xmm1
mulss 0x4(%rcx), %xmm1
addss %xmm1, %xmm0
movss (%rax), %xmm1
mulss 0xc(%rcx), %xmm1
movss 0xc(%rax), %xmm2
mulss 0x10(%rcx), %xmm2
addss %xmm2, %xmm1
movss (%rax), %xmm2
mulss 0x18(%rcx), %xmm2
movss 0xc(%rax), %xmm3
mulss 0x1c(%rcx), %xmm3
addss %xmm3, %xmm2
addss 0x18(%rax), %xmm2
movss 0x4(%rax), %xmm3
mulss (%rcx), %xmm3
movss 0x10(%rax), %xmm4
mulss 0x4(%rcx), %xmm4
addss %xmm4, %xmm3
movss 0x4(%rax), %xmm4
mulss 0xc(%rcx), %xmm4
movss 0x10(%rax), %xmm5
mulss 0x10(%rcx), %xmm5
addss %xmm5, %xmm4
movss 0x4(%rax), %xmm5
mulss 0x18(%rcx), %xmm5
movss 0x10(%rax), %xmm6
mulss 0x1c(%rcx), %xmm6
addss %xmm6, %xmm5
addss 0x1c(%rax), %xmm5
xorps %xmm7, %xmm7
movss 0x8f5b(%rip), %xmm8     # 0x17004
movaps %xmm7, %xmm6
movss %xmm8, (%rsp)
callq 0xd640
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/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:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movss (%rax), %xmm0
mulss 0x14(%rax), %xmm0
movss 0x4(%rax), %xmm1
mulss 0x10(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss (%rax), %xmm0
mulss 0x18(%rax), %xmm0
movss 0x8(%rax), %xmm1
mulss 0x10(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss (%rax), %xmm0
mulss 0x1c(%rax), %xmm0
movss 0xc(%rax), %xmm1
mulss 0x10(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss 0x4(%rax), %xmm0
mulss 0x18(%rax), %xmm0
movss 0x8(%rax), %xmm1
mulss 0x14(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss 0x4(%rax), %xmm0
mulss 0x1c(%rax), %xmm0
movss 0xc(%rax), %xmm1
mulss 0x14(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss 0x8(%rax), %xmm0
mulss 0x1c(%rax), %xmm0
movss 0xc(%rax), %xmm1
mulss 0x18(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x20(%rax), %xmm0
mulss 0x34(%rax), %xmm0
movss 0x24(%rax), %xmm1
mulss 0x30(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movss 0x20(%rax), %xmm0
mulss 0x38(%rax), %xmm0
movss 0x28(%rax), %xmm1
mulss 0x30(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movss 0x20(%rax), %xmm0
mulss 0x3c(%rax), %xmm0
movss 0x2c(%rax), %xmm1
mulss 0x30(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movss 0x24(%rax), %xmm0
mulss 0x38(%rax), %xmm0
movss 0x28(%rax), %xmm1
mulss 0x34(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss 0x24(%rax), %xmm0
mulss 0x3c(%rax), %xmm0
movss 0x2c(%rax), %xmm1
mulss 0x34(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movss 0x28(%rax), %xmm0
mulss 0x3c(%rax), %xmm0
movss 0x2c(%rax), %xmm1
mulss 0x38(%rax), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x4(%rbp), %xmm0
mulss -0x30(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
mulss -0x2c(%rbp), %xmm1
subss %xmm1, %xmm0
movss -0xc(%rbp), %xmm1
mulss -0x28(%rbp), %xmm1
addss %xmm1, %xmm0
movss -0x10(%rbp), %xmm1
mulss -0x24(%rbp), %xmm1
addss %xmm1, %xmm0
movss -0x14(%rbp), %xmm1
mulss -0x20(%rbp), %xmm1
subss %xmm1, %xmm0
movss -0x18(%rbp), %xmm1
mulss -0x1c(%rbp), %xmm1
addss %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat3x3inverse
mat3x3_t mat3x3inverse(mat3x3_t m)
{
	mat3x3_t res;
	float det=mat3x3det(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 -0x50(%rsp), %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x20(%rcx), %edx
movq %rsp, %rax
movl %edx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xeac0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movss %xmm0, -0x4(%rbp)
movss 0x10(%rcx), %xmm0
mulss 0x20(%rcx), %xmm0
movss 0x14(%rcx), %xmm1
mulss 0x1c(%rcx), %xmm1
subss %xmm1, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, (%rdi)
movss 0xc(%rcx), %xmm0
mulss 0x20(%rcx), %xmm0
movss 0x14(%rcx), %xmm1
mulss 0x18(%rcx), %xmm1
subss %xmm1, %xmm0
movd %xmm0, %edx
xorl $0x80000000, %edx       # imm = 0x80000000
movd %edx, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0xc(%rdi)
movss 0xc(%rcx), %xmm0
mulss 0x1c(%rcx), %xmm0
movss 0x10(%rcx), %xmm1
mulss 0x18(%rcx), %xmm1
subss %xmm1, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0x18(%rdi)
movss 0x4(%rcx), %xmm0
mulss 0x20(%rcx), %xmm0
movss 0x8(%rcx), %xmm1
mulss 0x1c(%rcx), %xmm1
subss %xmm1, %xmm0
movd %xmm0, %edx
xorl $0x80000000, %edx       # imm = 0x80000000
movd %edx, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0x4(%rdi)
movss (%rcx), %xmm0
mulss 0x20(%rcx), %xmm0
movss 0x8(%rcx), %xmm1
mulss 0x18(%rcx), %xmm1
subss %xmm1, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0x10(%rdi)
movss (%rcx), %xmm0
mulss 0x1c(%rcx), %xmm0
movss 0x4(%rcx), %xmm1
mulss 0x18(%rcx), %xmm1
subss %xmm1, %xmm0
movd %xmm0, %edx
xorl $0x80000000, %edx       # imm = 0x80000000
movd %edx, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0x1c(%rdi)
movss 0x4(%rcx), %xmm0
mulss 0x14(%rcx), %xmm0
movss 0x8(%rcx), %xmm1
mulss 0x10(%rcx), %xmm1
subss %xmm1, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0x8(%rdi)
movss (%rcx), %xmm0
mulss 0x14(%rcx), %xmm0
movss 0x8(%rcx), %xmm1
mulss 0xc(%rcx), %xmm1
subss %xmm1, %xmm0
movd %xmm0, %edx
xorl $0x80000000, %edx       # imm = 0x80000000
movd %edx, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0x14(%rdi)
movss (%rcx), %xmm0
mulss 0x10(%rcx), %xmm0
movss 0x4(%rcx), %xmm1
mulss 0xc(%rcx), %xmm1
subss %xmm1, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0x20(%rdi)
leaq 0x50(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat3x2affineinverse
mat3x2_t mat3x2affineinverse(mat3x2_t m)
{
	mat3x2_t res;
	float det=mat3x2affinedet(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 -0x40(%rsp), %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xf460
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movss %xmm0, -0x4(%rbp)
movss 0xc(%rcx), %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, (%rdi)
movss 0x8(%rcx), %xmm0
movd %xmm0, %edx
xorl $0x80000000, %edx       # imm = 0x80000000
movd %edx, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0x8(%rdi)
movss 0x4(%rcx), %xmm0
movd %xmm0, %edx
xorl $0x80000000, %edx       # imm = 0x80000000
movd %edx, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0x4(%rdi)
movss (%rcx), %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0xc(%rdi)
movss 0x10(%rcx), %xmm0
mulss (%rdi), %xmm0
movss 0x14(%rcx), %xmm1
mulss 0x8(%rdi), %xmm1
addss %xmm1, %xmm0
movd %xmm0, %edx
xorl $0x80000000, %edx       # imm = 0x80000000
movd %edx, %xmm0
movss %xmm0, 0x10(%rdi)
movss 0x10(%rcx), %xmm0
mulss 0x4(%rdi), %xmm0
movss 0x14(%rcx), %xmm1
mulss 0xc(%rdi), %xmm1
addss %xmm1, %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
movss %xmm0, 0x14(%rdi)
leaq 0x40(%rsp), %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/halcy[P]quasi_crystals_bot/Vector/Matrix.c
// Function: mat3x3affineinverse
mat3x3_t mat3x3affineinverse(mat3x3_t m)
{
	mat3x3_t res;
	float det=mat3x3affinedet(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 -0x50(%rsp), %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x20(%rcx), %edx
movq %rsp, %rax
movl %edx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xf650
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movss %xmm0, -0x4(%rbp)
movss 0x10(%rcx), %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, (%rdi)
movss 0xc(%rcx), %xmm0
movd %xmm0, %edx
xorl $0x80000000, %edx       # imm = 0x80000000
movd %edx, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0xc(%rdi)
movss 0x4(%rcx), %xmm0
movd %xmm0, %edx
xorl $0x80000000, %edx       # imm = 0x80000000
movd %edx, %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0x4(%rdi)
movss (%rcx), %xmm0
divss -0x4(%rbp), %xmm0
movss %xmm0, 0x10(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rdi)
movss 0x18(%rcx), %xmm0
mulss (%rdi), %xmm0
movss 0x1c(%rcx), %xmm1
mulss 0xc(%rdi), %xmm1
addss %xmm1, %xmm0
movd %xmm0, %edx
xorl $0x80000000, %edx       # imm = 0x80000000
movd %edx, %xmm0
movss %xmm0, 0x18(%rdi)
movss 0x18(%rcx), %xmm0
mulss 0x4(%rdi), %xmm0
movss 0x1c(%rcx), %xmm1
mulss 0x10(%rdi), %xmm1
addss %xmm1, %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
movss %xmm0, 0x1c(%rdi)
movss 0x79cb(%rip), %xmm0     # 0x17004
movss %xmm0, 0x20(%rdi)
leaq 0x50(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x50(%rsp), %rsp
leaq 0x10(%rbp), %rax
movlpd %xmm0, -0x30(%rbp)
movss %xmm1, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movss -0x20(%rbp), %xmm2
movss -0x1c(%rbp), %xmm4
movss (%rax), %xmm1
movss 0x4(%rax), %xmm5
movaps %xmm2, %xmm0
mulss %xmm1, %xmm0
movss 0xc(%rax), %xmm3
movaps %xmm4, %xmm1
mulss %xmm3, %xmm1
addss %xmm1, %xmm0
movss -0x18(%rbp), %xmm3
movss 0x18(%rax), %xmm6
movaps %xmm3, %xmm1
mulss %xmm6, %xmm1
addss %xmm1, %xmm0
movaps %xmm2, %xmm1
mulss %xmm5, %xmm1
movss 0x10(%rax), %xmm6
movaps %xmm4, %xmm5
mulss %xmm6, %xmm5
addss %xmm5, %xmm1
movss 0x1c(%rax), %xmm6
movaps %xmm3, %xmm5
mulss %xmm6, %xmm5
addss %xmm5, %xmm1
movss 0x8(%rax), %xmm5
mulss %xmm5, %xmm2
movss 0x14(%rax), %xmm5
mulss %xmm5, %xmm4
addss %xmm4, %xmm2
movss 0x20(%rax), %xmm4
mulss %xmm4, %xmm3
addss %xmm3, %xmm2
callq 0x104b0
movss %xmm1, -0x38(%rbp)
movlpd %xmm0, -0x40(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movss -0x48(%rbp), %xmm1
leaq 0x50(%rsp), %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x20(%rsp), %rsp
leaq 0x10(%rbp), %rax
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
movss -0x20(%rbp), %xmm3
movss -0x1c(%rbp), %xmm6
movss (%rax), %xmm1
movss 0x4(%rax), %xmm2
movaps %xmm3, %xmm0
mulss %xmm1, %xmm0
movss 0x10(%rax), %xmm4
movaps %xmm6, %xmm1
mulss %xmm4, %xmm1
addss %xmm1, %xmm0
movss -0x18(%rbp), %xmm5
movss 0x20(%rax), %xmm4
movaps %xmm5, %xmm1
mulss %xmm4, %xmm1
addss %xmm1, %xmm0
movss -0x14(%rbp), %xmm4
movss 0x30(%rax), %xmm7
movaps %xmm4, %xmm1
mulss %xmm7, %xmm1
addss %xmm1, %xmm0
movaps %xmm3, %xmm1
mulss %xmm2, %xmm1
movss 0x14(%rax), %xmm7
movaps %xmm6, %xmm2
mulss %xmm7, %xmm2
addss %xmm2, %xmm1
movss 0x24(%rax), %xmm7
movaps %xmm5, %xmm2
mulss %xmm7, %xmm2
addss %xmm2, %xmm1
movss 0x34(%rax), %xmm7
movaps %xmm4, %xmm2
mulss %xmm7, %xmm2
addss %xmm2, %xmm1
movss 0x8(%rax), %xmm7
movaps %xmm3, %xmm2
mulss %xmm7, %xmm2
movss 0x18(%rax), %xmm8
movaps %xmm6, %xmm7
mulss %xmm8, %xmm7
addss %xmm7, %xmm2
movss 0x28(%rax), %xmm8
movaps %xmm5, %xmm7
mulss %xmm8, %xmm7
addss %xmm7, %xmm2
movss 0x38(%rax), %xmm8
movaps %xmm4, %xmm7
mulss %xmm8, %xmm7
addss %xmm7, %xmm2
movss 0xc(%rax), %xmm7
mulss %xmm7, %xmm3
movss 0x1c(%rax), %xmm7
mulss %xmm7, %xmm6
addss %xmm6, %xmm3
movss 0x2c(%rax), %xmm6
mulss %xmm6, %xmm5
addss %xmm5, %xmm3
movss 0x3c(%rax), %xmm5
mulss %xmm5, %xmm4
addss %xmm4, %xmm3
callq 0x10750
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
leaq 0x20(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x20(%rsp), %rsp
leaq 0x10(%rbp), %rax
movlpd %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
movss 0x8(%rax), %xmm3
movss 0x14(%rax), %xmm2
mulss %xmm3, %xmm0
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
movss 0x20(%rax), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x10(%rbp), %xmm1
movss -0xc(%rbp), %xmm3
movss (%rax), %xmm2
movss 0x4(%rax), %xmm4
movaps %xmm1, %xmm0
mulss %xmm2, %xmm0
movss 0xc(%rax), %xmm5
movaps %xmm3, %xmm2
mulss %xmm5, %xmm2
addss %xmm2, %xmm0
movss 0x18(%rax), %xmm2
addss %xmm2, %xmm0
movss -0x14(%rbp), %xmm5
movss 0x67e4(%rip), %xmm2     # 0x17004
divss %xmm5, %xmm2
mulss %xmm2, %xmm0
mulss %xmm4, %xmm1
movss 0x10(%rax), %xmm4
mulss %xmm4, %xmm3
addss %xmm3, %xmm1
movss 0x1c(%rax), %xmm3
addss %xmm3, %xmm1
mulss %xmm2, %xmm1
callq 0x10860
movlpd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
leaq 0x20(%rsp), %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq -0x60(%rsp), %rsp
leaq 0x10(%rbp), %rax
movlpd %xmm0, -0x30(%rbp)
movss %xmm1, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
movss 0xc(%rax), %xmm3
movss 0x1c(%rax), %xmm2
mulss %xmm3, %xmm0
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
movss -0x18(%rbp), %xmm1
movss 0x2c(%rax), %xmm2
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
movss 0x3c(%rax), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x20(%rbp), %xmm2
movss -0x1c(%rbp), %xmm5
movss (%rax), %xmm1
movss 0x4(%rax), %xmm6
movaps %xmm2, %xmm0
mulss %xmm1, %xmm0
movss 0x10(%rax), %xmm3
movaps %xmm5, %xmm1
mulss %xmm3, %xmm1
addss %xmm1, %xmm0
movss -0x18(%rbp), %xmm4
movss 0x20(%rax), %xmm3
movaps %xmm4, %xmm1
mulss %xmm3, %xmm1
addss %xmm1, %xmm0
movss 0x30(%rax), %xmm1
addss %xmm1, %xmm0
movss -0x34(%rbp), %xmm1
movss 0x66ba(%rip), %xmm3     # 0x17004
divss %xmm1, %xmm3
mulss %xmm3, %xmm0
movaps %xmm2, %xmm1
mulss %xmm6, %xmm1
movss 0x14(%rax), %xmm7
movaps %xmm5, %xmm6
mulss %xmm7, %xmm6
addss %xmm6, %xmm1
movss 0x24(%rax), %xmm7
movaps %xmm4, %xmm6
mulss %xmm7, %xmm6
addss %xmm6, %xmm1
movss 0x34(%rax), %xmm6
addss %xmm6, %xmm1
mulss %xmm3, %xmm1
movss 0x8(%rax), %xmm6
mulss %xmm6, %xmm2
movss 0x18(%rax), %xmm6
mulss %xmm6, %xmm5
addss %xmm5, %xmm2
movss 0x28(%rax), %xmm5
mulss %xmm5, %xmm4
addss %xmm4, %xmm2
movss 0x38(%rax), %xmm4
addss %xmm4, %xmm2
mulss %xmm3, %xmm2
callq 0x104b0
movss %xmm1, -0x40(%rbp)
movlpd %xmm0, -0x48(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movss -0x50(%rbp), %xmm1
leaq 0x60(%rsp), %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)