LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_perspectiveInf
void mat4_perspectiveInf(float *out,float fov,float aspect,float znear) {
  float yScale=1.0f/tanf(fov/2.0f);
  float xScale=yScale/aspect;

  memset(out,0,sizeof(float)*16);

  out[0]=xScale;
  out[5]=yScale;
  out[10]=-1.0f;
  out[11]=-2.0f*znear;
  out[14]=-1.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
movss 0xd55a4(%rip), %xmm1    # 0x4e490c
divss %xmm1, %xmm0
callq 0x426640
movaps %xmm0, %xmm1
movss 0xd4108(%rip), %xmm0    # 0x4e3484
divss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
divss -0x10(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x4010e0
movss -0x1c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rax
movss 0xd5839(%rip), %xmm0    # 0x4e4c04
movss %xmm0, 0x28(%rax)
movss 0xd5830(%rip), %xmm0    # 0x4e4c08
mulss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movss 0xd5812(%rip), %xmm0    # 0x4e4c04
movss %xmm0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_ortho
void mat4_ortho(float *out,float left,float right,
                float bottom,float top,float nearVal,
                float farVal) {

  memset(out,0,sizeof(float)*16);

  float tx = -(right+left)/(right-left);
  float ty = -(top+bottom)/(top-bottom);
  float tz = -(farVal+nearVal)/(farVal-nearVal);

  out[0]=2.0f/(right-left);
  out[3]=tx;
  out[5]=2.0f/(top-bottom);
  out[7]=ty;
  out[10]=-2.0f/(nearVal-farVal);
  out[11]=tz;
  out[15]=1.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movss %xmm4, -0x1c(%rbp)
movss %xmm5, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x4010e0
movss -0x10(%rbp), %xmm0
addss -0xc(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss -0x10(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x18(%rbp), %xmm0
addss -0x14(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss -0x18(%rbp), %xmm1
subss -0x14(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x20(%rbp), %xmm0
addss -0x1c(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss -0x20(%rbp), %xmm1
subss -0x1c(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x10(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
movss 0xd5442(%rip), %xmm0    # 0x4e490c
divss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movss -0x24(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
movss -0x18(%rbp), %xmm1
subss -0x14(%rbp), %xmm1
movss 0xd5416(%rip), %xmm0    # 0x4e490c
divss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movss -0x1c(%rbp), %xmm1
subss -0x20(%rbp), %xmm1
movss 0xd56e5(%rip), %xmm0    # 0x4e4c08
divss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x28(%rax)
movss -0x2c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movss 0xd3f3a(%rip), %xmm0    # 0x4e3484
movss %xmm0, 0x3c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rbinit
RB_ENTRY(tree) *
rbinit(int (*cmp)(const void *, const void *, const void *), const void *config)
#else
RB_STATIC struct RB_ENTRY(tree) *RB_ENTRY(init)(void)
#endif /* RB_CUSTOMIZE */
{
	struct RB_ENTRY(tree) *retval;
	char c;

	c=rcsid[0]; /* This does nothing but shutup the -Wall */

	if ((retval=(struct RB_ENTRY(tree) *) malloc(sizeof(struct RB_ENTRY(tree))))==NULL)
		return(NULL);
	
#ifndef RB_CUSTOMIZE
	retval->rb_cmp=cmp;
	retval->rb_config=config;
#endif /* RB_CUSTOMIZE */
	retval->rb_root=RBNULL;

	return(retval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb 0x11698a(%rip), %al     # 0x526230
movb %al, -0x21(%rbp)
movl $0x18, %edi
callq 0x452d20
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x40f8c7
movq $0x0, -0x8(%rbp)
jmp 0x40f8f5
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
leaq 0x116917(%rip), %rcx    # 0x526200
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rbdestroy
RB_STATIC void
RB_ENTRY(destroy)(struct RB_ENTRY(tree) *rbinfo)
{
	if (rbinfo==NULL)
		return;

	if (rbinfo->rb_root!=RBNULL)
		RB_ENTRY(_destroy)(rbinfo->rb_root);
	
	free(rbinfo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x40f915
jmp 0x40f93c
movq -0x8(%rbp), %rax
leaq 0x1168e0(%rip), %rcx    # 0x526200
cmpq %rcx, 0x10(%rax)
je 0x40f933
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x40f950
movq -0x8(%rbp), %rdi
callq 0x453060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rb_destroy
static void
RB_ENTRY(_destroy)(struct RB_ENTRY(node) *x)
{
	if (x!=RBNULL)
	{
		if (x->left!=RBNULL)
			RB_ENTRY(_destroy)(x->left);
		if (x->right!=RBNULL)
			RB_ENTRY(_destroy)(x->right);
		RB_ENTRY(_free)(x);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x11689d(%rip), %rax    # 0x526200
cmpq %rax, -0x8(%rbp)
je 0x40f9ac
movq -0x8(%rbp), %rax
leaq 0x11688c(%rip), %rcx    # 0x526200
cmpq %rcx, (%rax)
je 0x40f985
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x40f950
movq -0x8(%rbp), %rax
leaq 0x116870(%rip), %rcx    # 0x526200
cmpq %rcx, 0x8(%rax)
je 0x40f9a3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x40f950
movq -0x8(%rbp), %rdi
callq 0x4108a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rbsearch
RB_STATIC const RB_ENTRY(data_t) *
RB_ENTRY(search)(const RB_ENTRY(data_t) *key, struct RB_ENTRY(tree) *rbinfo)
{
	struct RB_ENTRY(node) *x;

	if (rbinfo==NULL)
		return(NULL);

	x=RB_ENTRY(_traverse)(1, key, rbinfo);

	return((x==RBNULL) ? NULL : RB_GET(x, key));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x40f9e1
movq $0x0, -0x8(%rbp)
jmp 0x40fa20
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %edi
callq 0x40fa30
movq %rax, -0x20(%rbp)
leaq 0x116802(%rip), %rax    # 0x526200
cmpq %rax, -0x20(%rbp)
jne 0x40fa0c
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x40fa18
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rbfind
RB_STATIC const RB_ENTRY(data_t) * 
RB_ENTRY(find)(const RB_ENTRY(data_t) *key, struct RB_ENTRY(tree) *rbinfo)
{
	struct RB_ENTRY(node) *x;

	if (rbinfo==NULL)
		return(NULL);

	/* If we have a NULL root (empty tree) then just return */
	if (rbinfo->rb_root==RBNULL)
		return(NULL);

	x=RB_ENTRY(_traverse)(0, key, rbinfo);

	return((x==RBNULL) ? NULL : RB_GET(x, key));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x40fdf1
movq $0x0, -0x8(%rbp)
jmp 0x40fe48
movq -0x18(%rbp), %rax
leaq 0x116404(%rip), %rcx    # 0x526200
cmpq %rcx, 0x10(%rax)
jne 0x40fe0c
movq $0x0, -0x8(%rbp)
jmp 0x40fe48
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %edi, %edi
callq 0x40fa30
movq %rax, -0x20(%rbp)
leaq 0x1163da(%rip), %rax    # 0x526200
cmpq %rax, -0x20(%rbp)
jne 0x40fe34
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x40fe40
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rbdelete
RB_STATIC const RB_ENTRY(data_t) * 
RB_ENTRY(delete)(const RB_ENTRY(data_t) *key, struct RB_ENTRY(tree) *rbinfo)
{
	struct RB_ENTRY(node) *x;
	const RB_ENTRY(data_t) * y;

	if (rbinfo==NULL)
		return(NULL);

	x=RB_ENTRY(_traverse)(0, key, rbinfo);

	if (x==RBNULL)
	{
		return(NULL);
	}
	else
	{
		y=RB_GET(x, key);
		RB_ENTRY(_delete)(&rbinfo->rb_root, x);

		return(y);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x40fe81
movq $0x0, -0x8(%rbp)
jmp 0x40fed0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %edi, %edi
callq 0x40fa30
movq %rax, -0x20(%rbp)
leaq 0x116365(%rip), %rax    # 0x526200
cmpq %rax, -0x20(%rbp)
jne 0x40feab
movq $0x0, -0x8(%rbp)
jmp 0x40fed0
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
callq 0x40fee0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rb_delete
static void
RB_ENTRY(_delete)(struct RB_ENTRY(node) **rootp, struct RB_ENTRY(node) *z)
{
	struct RB_ENTRY(node) *x, *y;

	if (z->left == RBNULL || z->right == RBNULL)
		y=z;
	else
		y=RB_ENTRY(_successor)(z);

	if (y->left != RBNULL)
		x=y->left;
	else
		x=y->right;

	x->up = y->up;

	if (y->up == RBNULL)
	{
		*rootp=x;
	}
	else
	{
		if (y==y->up->left)
			y->up->left = x;
		else
			y->up->right = x;
	}

	if (y!=z)
	{
		RB_SET(z, key, RB_GET(y, key));
	}

	if (y->colour == BLACK)
		RB_ENTRY(_delete_fix)(rootp, x);

	RB_ENTRY(_free)(y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x116305(%rip), %rcx    # 0x526200
cmpq %rcx, (%rax)
je 0x40ff11
movq -0x10(%rbp), %rax
leaq 0x1162f5(%rip), %rcx    # 0x526200
cmpq %rcx, 0x8(%rax)
jne 0x40ff1b
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x40ff28
movq -0x10(%rbp), %rdi
callq 0x410760
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x1162cd(%rip), %rcx    # 0x526200
cmpq %rcx, (%rax)
je 0x40ff45
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x40ff51
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
leaq 0x116294(%rip), %rcx    # 0x526200
cmpq %rcx, 0x10(%rax)
jne 0x40ff7f
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x40ffb3
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jne 0x40ffa1
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
jmp 0x40ffb1
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x40ffb3
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x40ffcd
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x40ffe4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4108c0
movq -0x20(%rbp), %rdi
callq 0x4108a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rb_walk
static void
RB_ENTRY(_walk)(const struct RB_ENTRY(node) *x, void (*action)(const RB_ENTRY(data_t) *, const VISIT, const int, void *), void *arg, int level)
{
	if (x==RBNULL)
		return;

	if (x->left==RBNULL && x->right==RBNULL)
	{
		/* leaf */
		(*action)(RB_GET(x, key), leaf, level, arg);
	}
	else
	{
		(*action)(RB_GET(x, key), preorder, level, arg);

		RB_ENTRY(_walk)(x->left, action, arg, level+1);

		(*action)(RB_GET(x, key), postorder, level, arg);

		RB_ENTRY(_walk)(x->right, action, arg, level+1);

		(*action)(RB_GET(x, key), endorder, level, arg);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0x1161a2(%rip), %rax    # 0x526200
cmpq %rax, -0x8(%rbp)
jne 0x410069
jmp 0x410129
movq -0x8(%rbp), %rax
leaq 0x11618c(%rip), %rcx    # 0x526200
cmpq %rcx, (%rax)
jne 0x4100a9
movq -0x8(%rbp), %rax
leaq 0x11617c(%rip), %rcx    # 0x526200
cmpq %rcx, 0x8(%rax)
jne 0x4100a9
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
movl $0x3, %esi
callq *%rax
jmp 0x410129
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
xorl %esi, %esi
callq *%rax
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
callq 0x410040
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
callq 0x410040
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
movl $0x2, %esi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rb_openlist
static RBLIST *
RB_ENTRY(_openlist)(const struct RB_ENTRY(node) *rootp)
{
	RBLIST *rblistp;

	rblistp=(RBLIST *) malloc(sizeof(RBLIST));
	if (!rblistp)
		return(NULL);

	rblistp->rootp=rootp;
	rblistp->nextp=rootp;

	if (rootp!=RBNULL)
	{
		while(rblistp->nextp->left!=RBNULL)
		{
			rblistp->nextp=rblistp->nextp->left;
		}
	}

	return(rblistp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x10, %edi
callq 0x452d20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x41019b
movq $0x0, -0x8(%rbp)
jmp 0x4101f4
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x116047(%rip), %rax    # 0x526200
cmpq %rax, -0x10(%rbp)
je 0x4101ec
jmp 0x4101c1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x116030(%rip), %rcx    # 0x526200
cmpq %rcx, (%rax)
je 0x4101ea
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4101c1
jmp 0x4101ec
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rb_readlist
static const RB_ENTRY(data_t) * 
RB_ENTRY(_readlist)(RBLIST *rblistp)
{
	const RB_ENTRY(data_t) *key=NULL;

	if (rblistp!=NULL && rblistp->nextp!=RBNULL)
	{
		key=RB_GET(rblistp->nextp, key);
		rblistp->nextp=RB_ENTRY(_successor)(rblistp->nextp);
	}

	return(key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x410294
movq -0x8(%rbp), %rax
leaq 0x115f9a(%rip), %rcx    # 0x526200
cmpq %rcx, 0x8(%rax)
je 0x410294
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x410760
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rblookup
RB_STATIC const RB_ENTRY(data_t) * 
RB_ENTRY(lookup)(int mode, const RB_ENTRY(data_t) *key, struct RB_ENTRY(tree) *rbinfo)
{
	struct RB_ENTRY(node) *x;

	/* If we have a NULL root (empty tree) then just return NULL */
	if (rbinfo==NULL || rbinfo->rb_root==NULL)
		return(NULL);

	x=RB_ENTRY(_lookup)(mode, key, rbinfo);

	return((x==RBNULL) ? NULL : RB_GET(x, key));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x410325
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x41032f
movq $0x0, -0x8(%rbp)
jmp 0x41036c
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x410380
movq %rax, -0x28(%rbp)
leaq 0x115eb6(%rip), %rax    # 0x526200
cmpq %rax, -0x28(%rbp)
jne 0x410358
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x410364
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rb_left_rotate
static void
RB_ENTRY(_left_rotate)(struct RB_ENTRY(node) **rootp, struct RB_ENTRY(node) *x)
{
	struct RB_ENTRY(node) *y;

	assert(x!=RBNULL);
	assert(x->right!=RBNULL);

	y=x->right; /* set Y */

	/* Turn Y's left subtree into X's right subtree (move B)*/
	x->right = y->left;

	/* If B is not null, set it's parent to be X */
	if (y->left != RBNULL)
		y->left->up = x;

	/* Set Y's parent to be what X's parent was */
	y->up = x->up;

	/* if X was the root */
	if (x->up == RBNULL)
	{
		*rootp=y;
	}
	else
	{
		/* Set X's parent's left or right pointer to be Y */
		if (x == x->up->left)
		{
			x->up->left=y;
		}
		else
		{
			x->up->right=y;
		}
	}

	/* Put X on Y's left */
	y->left=x;

	/* Set X's parent to be Y */
	x->up = y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
leaq 0x115c1e(%rip), %rcx    # 0x526200
cmpq %rcx, (%rax)
je 0x4105f6
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x115bef(%rip), %rcx    # 0x526200
cmpq %rcx, 0x10(%rax)
jne 0x410624
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x410658
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jne 0x410646
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
jmp 0x410656
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x410658
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rb_right_rotate
static void
RB_ENTRY(_right_rotate)(struct RB_ENTRY(node) **rootp, struct RB_ENTRY(node) *y)
{
	struct RB_ENTRY(node) *x;

	assert(y!=RBNULL);
	assert(y->left!=RBNULL);

	x=y->left; /* set X */

	/* Turn X's right subtree into Y's left subtree (move B) */
	y->left = x->right;

	/* If B is not null, set it's parent to be Y */
	if (x->right != RBNULL)
		x->right->up = y;

	/* Set X's parent to be what Y's parent was */
	x->up = y->up;

	/* if Y was the root */
	if (y->up == RBNULL)
	{
		*rootp=x;
	}
	else
	{
		/* Set Y's parent's left or right pointer to be X */
		if (y == y->up->left)
		{
			y->up->left=x;
		}
		else
		{
			y->up->right=x;
		}
	}

	/* Put Y on X's right */
	x->right=y;

	/* Set Y's parent to be X */
	y->up = x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
leaq 0x115b4f(%rip), %rcx    # 0x526200
cmpq %rcx, 0x8(%rax)
je 0x4106c7
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x115b1e(%rip), %rcx    # 0x526200
cmpq %rcx, 0x10(%rax)
jne 0x4106f5
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x410729
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jne 0x410717
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
jmp 0x410727
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x410729
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rb_successor
static struct RB_ENTRY(node) *
RB_ENTRY(_successor)(const struct RB_ENTRY(node) *x)
{
	struct RB_ENTRY(node) *y;

	if (x->right!=RBNULL)
	{
		/* If right is not NULL then go right one and
		** then keep going left until we find a node with
		** no left pointer.
		*/
		for (y=x->right; y->left!=RBNULL; y=y->left);
	}
	else
	{
		/* Go up the tree until we get to a node that is on the
		** left of its parent (or the root) and then return the
		** parent.
		*/
		y=x->up;
		while(y!=RBNULL && x==y->right)
		{
			x=y;
			y=y->up;
		}
	}
	return(y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x115a8d(%rip), %rcx    # 0x526200
cmpq %rcx, 0x8(%rax)
je 0x4107a6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x115a70(%rip), %rcx    # 0x526200
cmpq %rcx, (%rax)
je 0x4107a4
jmp 0x410797
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x410785
jmp 0x4107f7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
leaq 0x115a45(%rip), %rcx    # 0x526200
cmpq %rcx, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x4107d6
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x4107df
jmp 0x4107f5
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4107b2
jmp 0x4107f7
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/redblack.c
// Function: rb_predecessor
static struct RB_ENTRY(node) *
RB_ENTRY(_predecessor)(const struct RB_ENTRY(node) *x)
{
	struct RB_ENTRY(node) *y;

	if (x->left!=RBNULL)
	{
		/* If left is not NULL then go left one and
		** then keep going right until we find a node with
		** no right pointer.
		*/
		for (y=x->left; y->right!=RBNULL; y=y->right);
	}
	else
	{
		/* Go up the tree until we get to a node that is on the
		** right of its parent (or the root) and then return the
		** parent.
		*/
		y=x->up;
		while(y!=RBNULL && x==y->left)
		{
			x=y;
			y=y->up;
		}
	}
	return(y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x1159ed(%rip), %rcx    # 0x526200
cmpq %rcx, (%rax)
je 0x410846
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x1159d2(%rip), %rcx    # 0x526200
cmpq %rcx, 0x8(%rax)
je 0x410844
jmp 0x410836
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x410823
jmp 0x410896
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
leaq 0x1159a5(%rip), %rcx    # 0x526200
cmpq %rcx, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x410875
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x41087e
jmp 0x410894
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x410852
jmp 0x410896
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: stbi_loadf_main
float *stbi_loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *data;
   #ifndef STBI_NO_HDR
   if (stbi__hdr_test(s))
      return stbi__hdr_load(s,x,y,comp,req_comp);
   #endif
   data = stbi_load_main(s, x, y, comp, req_comp);
   if (data)
      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4115f0
cmpl $0x0, %eax
je 0x41155c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x411620
movq %rax, -0x8(%rbp)
jmp 0x4115e4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x411160
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4115c9
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x4115a8
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x4115b1
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x3c(%rbp), %edx
movl -0x40(%rbp), %esi
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %ecx
callq 0x411cb0
movq %rax, -0x8(%rbp)
jmp 0x4115e4
leaq 0xd3e08(%rip), %rdi     # 0x4e53d8
callq 0x411080
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: stbi__info_main
static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
{
   if (stbi__jpeg_info(s, x, y, comp))
       return 1;
   if (stbi__png_info(s, x, y, comp))
       return 1;
   if (stbi__gif_info(s, x, y, comp))
       return 1;
   if (stbi__bmp_info(s, x, y, comp))
       return 1;
   if (stbi__psd_info(s, x, y, comp))
       return 1;
   if (stbi__pic_info(s, x, y, comp))
       return 1;
   #ifndef STBI_NO_HDR
   if (stbi__hdr_info(s, x, y, comp))
       return 1;
   #endif
   // test tga last because it's a crappy test!
   if (stbi__tga_info(s, x, y, comp))
       return 1;
   return stbi__err("unknown image type", "Image not of any known type, or corrupt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x41dda0
cmpl $0x0, %eax
je 0x41273e
movl $0x1, -0x4(%rbp)
jmp 0x41284b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x41ddf0
cmpl $0x0, %eax
je 0x412764
movl $0x1, -0x4(%rbp)
jmp 0x41284b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x41de30
cmpl $0x0, %eax
je 0x41278a
movl $0x1, -0x4(%rbp)
jmp 0x41284b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x41de70
cmpl $0x0, %eax
je 0x4127b0
movl $0x1, -0x4(%rbp)
jmp 0x41284b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x41dfb0
cmpl $0x0, %eax
je 0x4127d3
movl $0x1, -0x4(%rbp)
jmp 0x41284b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x41e0d0
cmpl $0x0, %eax
je 0x4127f6
movl $0x1, -0x4(%rbp)
jmp 0x41284b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x41e280
cmpl $0x0, %eax
je 0x412819
movl $0x1, -0x4(%rbp)
jmp 0x41284b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x41e470
cmpl $0x0, %eax
je 0x41283c
movl $0x1, -0x4(%rbp)
jmp 0x41284b
leaq 0xd2b95(%rip), %rdi     # 0x4e53d8
callq 0x411080
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: stbi__jpeg_test
static int stbi__jpeg_test(stbi__context *s)
{
   int r;
   stbi__jpeg j;
   j.s = s;
   r = decode_jpeg_header(&j, SCAN_type);
   stbi__rewind(s);
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3700, %rsp           # imm = 0x3700
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x3700(%rbp)
leaq -0x3700(%rbp), %rdi
movl $0x1, %esi
callq 0x414bd0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x414d00
movl -0xc(%rbp), %eax
addq $0x3700, %rsp           # imm = 0x3700
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: decode_jpeg_header
static int decode_jpeg_header(stbi__jpeg *z, int scan)
{
   int m;
   z->marker = STBI__MARKER_none; // initialize cached marker to empty
   m = stbi__get_marker(z);
   if (!stbi__SOI(m)) return stbi__err("no stbi__SOI","Corrupt JPEG");
   if (scan == SCAN_type) return 1;
   m = stbi__get_marker(z);
   while (!stbi__SOF(m)) {
      if (!stbi__process_marker(z,m)) return 0;
      m = stbi__get_marker(z);
      while (m == STBI__MARKER_none) {
         // some files have extra padding after their blocks, so ok, we'll scan
         if (stbi__at_eof(z->s)) return stbi__err("no stbi__SOF", "Corrupt JPEG");
         m = stbi__get_marker(z);
      }
   }
   if (!stbi__process_frame_header(z, scan)) return 0;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movb $-0x1, 0x36c8(%rax)
movq -0x10(%rbp), %rdi
callq 0x414d20
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0xd8, -0x18(%rbp)
je 0x414c16
leaq 0xd07e2(%rip), %rdi     # 0x4e53eb
callq 0x411080
movl %eax, -0x4(%rbp)
jmp 0x414ce8
cmpl $0x1, -0x14(%rbp)
jne 0x414c28
movl $0x1, -0x4(%rbp)
jmp 0x414ce8
movq -0x10(%rbp), %rdi
callq 0x414d20
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movb $0x1, %al
cmpl $0xc0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x414c52
cmpl $0xc1, -0x18(%rbp)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x414c5d
jmp 0x414cc7
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x414db0
cmpl $0x0, %eax
jne 0x414c77
movl $0x0, -0x4(%rbp)
jmp 0x414ce8
movq -0x10(%rbp), %rdi
callq 0x414d20
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0xff, -0x18(%rbp)
jne 0x414cc2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4151a0
cmpl $0x0, %eax
je 0x414cb1
leaq 0xd0751(%rip), %rdi     # 0x4e53f8
callq 0x411080
movl %eax, -0x4(%rbp)
jmp 0x414ce8
movq -0x10(%rbp), %rdi
callq 0x414d20
movzbl %al, %eax
movl %eax, -0x18(%rbp)
jmp 0x414c86
jmp 0x414c37
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x415220
cmpl $0x0, %eax
jne 0x414ce1
movl $0x0, -0x4(%rbp)
jmp 0x414ce8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: decode_jpeg_image
static int decode_jpeg_image(stbi__jpeg *j)
{
   int m;
   j->restart_interval = 0;
   if (!decode_jpeg_header(j, SCAN_load)) return 0;
   m = stbi__get_marker(j);
   while (!stbi__EOI(m)) {
      if (stbi__SOS(m)) {
         if (!stbi__process_scan_header(j)) return 0;
         if (!stbi__parse_entropy_coded_data(j)) return 0;
         if (j->marker == STBI__MARKER_none ) {
            // handle 0s at the end of image data from IP Kamera 9060
            while (!stbi__at_eof(j->s)) {
               int x = stbi__get8(j->s);
               if (x == 255) {
                  j->marker = stbi__get8(j->s);
                  break;
               } else if (x != 0) {
                  return 0;
               }
            }
            // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
         }
      } else {
         if (!stbi__process_marker(j, m)) return 0;
      }
      m = stbi__get_marker(j);
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x36e4(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x414bd0
cmpl $0x0, %eax
jne 0x416566
movl $0x0, -0x4(%rbp)
jmp 0x41667c
movq -0x10(%rbp), %rdi
callq 0x414d20
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0xd9, -0x14(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x41658a
jmp 0x416675
cmpl $0xda, -0x14(%rbp)
jne 0x416645
movq -0x10(%rbp), %rdi
callq 0x416cd0
cmpl $0x0, %eax
jne 0x4165b1
movl $0x0, -0x4(%rbp)
jmp 0x41667c
movq -0x10(%rbp), %rdi
callq 0x416f30
cmpl $0x0, %eax
jne 0x4165cb
movl $0x0, -0x4(%rbp)
jmp 0x41667c
movq -0x10(%rbp), %rax
movzbl 0x36c8(%rax), %eax
cmpl $0xff, %eax
jne 0x416643
jmp 0x4165df
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4151a0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4165f9
jmp 0x416641
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x415960
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0xff, -0x18(%rbp)
jne 0x41662e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x415960
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x36c8(%rax)
jmp 0x416641
cmpl $0x0, -0x18(%rbp)
je 0x41663d
movl $0x0, -0x4(%rbp)
jmp 0x41667c
jmp 0x41663f
jmp 0x4165df
jmp 0x416643
jmp 0x416661
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x414db0
cmpl $0x0, %eax
jne 0x41665f
movl $0x0, -0x4(%rbp)
jmp 0x41667c
jmp 0x416661
movq -0x10(%rbp), %rdi
callq 0x414d20
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0x416575
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: stbi__cleanup_jpeg
static void stbi__cleanup_jpeg(stbi__jpeg *j)
{
   int i;
   for (i=0; i < j->s->img_n; ++i) {
      if (j->img_comp[i].raw_data) {
         free(j->img_comp[i].raw_data);
         j->img_comp[i].raw_data = NULL;
         j->img_comp[i].data = NULL;
      }
      if (j->img_comp[i].linebuf) {
         free(j->img_comp[i].linebuf);
         j->img_comp[i].linebuf = NULL;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x416791
movq -0x8(%rbp), %rax
addq $0x35a0, %rax           # imm = 0x35A0
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x38(%rax)
je 0x41672a
movq -0x8(%rbp), %rax
addq $0x35a0, %rax           # imm = 0x35A0
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rdi
callq 0x453060
movq -0x8(%rbp), %rax
addq $0x35a0, %rax           # imm = 0x35A0
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x35a0, %rax           # imm = 0x35A0
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
addq $0x35a0, %rax           # imm = 0x35A0
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x40(%rax)
je 0x416781
movq -0x8(%rbp), %rax
addq $0x35a0, %rax           # imm = 0x35A0
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rdi
callq 0x453060
movq -0x8(%rbp), %rax
addq $0x35a0, %rax           # imm = 0x35A0
movslq -0xc(%rbp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x40(%rax)
jmp 0x416783
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4166a3
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: stbi__YCbCr_to_RGB_row
static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
{
   int i;
   for (i=0; i < count; ++i) {
      int y_fixed = (y[i] << 16) + 32768; // rounding
      int r,g,b;
      int cr = pcr[i] - 128;
      int cb = pcb[i] - 128;
      r = y_fixed + cr*float2fixed(1.40200f);
      g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f);
      b = y_fixed                            + cb*float2fixed(1.77200f);
      r >>= 16;
      g >>= 16;
      b >>= 16;
      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
      out[0] = (stbi_uc)r;
      out[1] = (stbi_uc)g;
      out[2] = (stbi_uc)b;
      out[3] = 255;
      out += step;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x416ccc
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x10, %eax
addl $0x8000, %eax           # imm = 0x8000
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
subl $0x80, %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
subl $0x80, %eax
movl %eax, -0x44(%rbp)
movl -0x30(%rbp), %eax
imull $0x166e9, -0x40(%rbp), %ecx # imm = 0x166E9
addl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
imull $0xb6d2, -0x40(%rbp), %ecx # imm = 0xB6D2
subl %ecx, %eax
imull $0x581a, -0x44(%rbp), %ecx # imm = 0x581A
subl %ecx, %eax
movl %eax, -0x38(%rbp)
movl -0x30(%rbp), %eax
imull $0x1c5a2, -0x44(%rbp), %ecx # imm = 0x1C5A2
addl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x34(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x3c(%rbp)
cmpl $0xff, -0x34(%rbp)
jbe 0x416c40
cmpl $0x0, -0x34(%rbp)
jge 0x416c37
movl $0x0, -0x34(%rbp)
jmp 0x416c3e
movl $0xff, -0x34(%rbp)
jmp 0x416c40
cmpl $0xff, -0x38(%rbp)
jbe 0x416c61
cmpl $0x0, -0x38(%rbp)
jge 0x416c58
movl $0x0, -0x38(%rbp)
jmp 0x416c5f
movl $0xff, -0x38(%rbp)
jmp 0x416c61
cmpl $0xff, -0x3c(%rbp)
jbe 0x416c82
cmpl $0x0, -0x3c(%rbp)
jge 0x416c79
movl $0x0, -0x3c(%rbp)
jmp 0x416c80
movl $0xff, -0x3c(%rbp)
jmp 0x416c82
movl -0x34(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0x38(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x3c(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x3(%rax)
movl -0x28(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x416b83
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: stbi__extend_receive
stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
{
   unsigned int m = 1 << (n-1);
   unsigned int k;
   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);

   #if 1
   k = stbi_lrot(j->code_buffer, n);
   j->code_buffer = k & ~stbi__bmask[n];
   k &= stbi__bmask[n];
   j->code_bits -= n;
   #else
   k = (j->code_buffer >> (32 - n)) & stbi__bmask[n];
   j->code_bits -= n;
   j->code_buffer <<= n;
   #endif
   // the following test is probably a random branch that won't
   // predict well. I tried to table accelerate it but failed.
   // maybe it's compiling as a conditional move?
   if (k < m)
      return (-1 << n) + k + 1;
   else
      return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x36c4(%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x418447
movq -0x10(%rbp), %rdi
callq 0x418110
movq -0x10(%rbp), %rax
movl 0x36c0(%rax), %eax
movl -0x14(%rbp), %ecx
shll %cl, %eax
movq -0x10(%rbp), %rcx
movl 0x36c0(%rcx), %edx
movl $0x20, %ecx
subl -0x14(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movslq -0x14(%rbp), %rdx
leaq 0x10de71(%rip), %rax    # 0x5262f0
movl (%rax,%rdx,4), %eax
xorl $-0x1, %eax
andl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x36c0(%rax)
movslq -0x14(%rbp), %rcx
leaq 0x10de54(%rip), %rax    # 0x5262f0
movl (%rax,%rcx,4), %eax
andl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x36c4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x36c4(%rax)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x4184d7
movl -0x14(%rbp), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
addl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4184dd
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: stbi__do_png
static unsigned char *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp)
{
   unsigned char *result=NULL;
   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
   if (stbi__parse_png_file(p, SCAN_load, req_comp)) {
      result = p->out;
      p->out = NULL;
      if (req_comp && req_comp != p->s->img_out_n) {
         result = stbi__convert_format(result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
         p->s->img_out_n = req_comp;
         if (result == NULL) return result;
      }
      *x = p->s->img_x;
      *y = p->s->img_y;
      if (n) *n = p->s->img_out_n;
   }
   free(p->out);      p->out      = NULL;
   free(p->expanded); p->expanded = NULL;
   free(p->idata);    p->idata    = NULL;

   return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x4185d0
cmpl $0x4, -0x2c(%rbp)
jle 0x4185f0
leaq 0xccf0d(%rip), %rdi     # 0x4e54e4
callq 0x411080
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x418710
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %edx
xorl %esi, %esi
callq 0x418720
cmpl $0x0, %eax
je 0x4186bd
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
cmpl $0x0, -0x2c(%rbp)
je 0x418685
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0xc(%rcx), %eax
je 0x418685
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %esi
movl -0x2c(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %r8d
callq 0x4192e0
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0xc(%rax)
cmpq $0x0, -0x38(%rbp)
jne 0x418683
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x418710
jmp 0x418685
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x4186bb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x4186bd
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x453060
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x453060
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x453060
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: stbi__zexpand
static int stbi__zexpand(stbi__zbuf *z, int n)  // need to make room for n bytes
{
   char *q;
   int cur, limit;
   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
   cur   = (int) (z->zout     - z->zout_start);
   limit = (int) (z->zout_end - z->zout_start);
   while (cur + n > limit)
      limit *= 2;
   q = (char *) realloc(z->zout_start, limit);
   if (q == NULL) return stbi__err("outofmem", "Out of memory");
   z->zout_start = q;
   z->zout       = q + cur;
   z->zout_end   = q + limit;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x41d7ad
leaq 0xc836b(%rip), %rdi     # 0x4e5b0b
callq 0x411080
movl %eax, -0x4(%rbp)
jmp 0x41d854
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl -0x14(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x41d7ee
movl -0x28(%rbp), %eax
shll %eax
movl %eax, -0x28(%rbp)
jmp 0x41d7d9
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x28(%rbp), %rsi
callq 0x4533b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x41d81b
leaq 0xc7cca(%rip), %rdi     # 0x4e54db
callq 0x411080
movl %eax, -0x4(%rbp)
jmp 0x41d854
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movslq -0x28(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: stbi__jpeg_info_raw
static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
{
   if (!decode_jpeg_header(j, SCAN_header)) {
      stbi__rewind( j->s );
      return 0;
   }
   if (x) *x = j->s->img_x;
   if (y) *y = j->s->img_y;
   if (comp) *comp = j->s->img_n;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x414bd0
cmpl $0x0, %eax
jne 0x41e620
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x414d00
movl $0x0, -0x4(%rbp)
jmp 0x41e66b
cmpq $0x0, -0x18(%rbp)
je 0x41e636
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x41e64d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x41e664
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)