LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/glad.c
// Function: get_exts
static int get_exts(void) {
#ifdef _GLAD_IS_SOME_NEW_VERSION
    if(max_loaded_major < 3) {
#endif
        exts = (const char *)glGetString(GL_EXTENSIONS);
#ifdef _GLAD_IS_SOME_NEW_VERSION
    } else {
        unsigned int index;

        num_exts_i = 0;
        glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i);
        if (num_exts_i > 0) {
            exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i));
        }

        if (exts_i == NULL) {
            return 0;
        }

        for(index = 0; index < (unsigned)num_exts_i; index++) {
            const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index);
            size_t len = strlen(gl_str_tmp);

            char *local_str = (char*)malloc((len+1) * sizeof(char));
            if(local_str != NULL) {
                memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char));
            }
            exts_i[index] = local_str;
        }
    }
#endif
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x3, 0x9509(%rip)      # 0xe718
jge 0x5228
movl $0x1f03, %edi           # imm = 0x1F03
callq *0x8dfc(%rip)           # 0xe018
movq %rax, 0x94fd(%rip)      # 0xe720
jmp 0x5302
movl $0x0, 0x94f6(%rip)      # 0xe728
movl $0x821d, %edi           # imm = 0x821D
leaq 0x94ea(%rip), %rsi      # 0xe728
callq *0x8d4c(%rip)           # 0xdf90
cmpl $0x0, 0x94dd(%rip)      # 0xe728
jle 0x5264
movslq 0x94d4(%rip), %rdi      # 0xe728
shlq $0x3, %rdi
callq 0x2110
movq %rax, 0x94cc(%rip)      # 0xe730
cmpq $0x0, 0x94c4(%rip)      # 0xe730
jne 0x527a
movl $0x0, -0x4(%rbp)
jmp 0x5309
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x949e(%rip), %eax      # 0xe728
jae 0x5300
movq 0x8d8d(%rip), %rax      # 0xe020
movl -0x8(%rbp), %esi
movl $0x1f03, %edi           # imm = 0x1F03
callq *%rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x2110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x52e3
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
shlq $0x0, %rdx
callq 0x2290
movq -0x20(%rbp), %rdx
movq 0x9442(%rip), %rax      # 0xe730
movl -0x8(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5281
jmp 0x5302
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/k0n10pl4tr[P]minimal_crafter/glad.c
// Function: has_ext
static int has_ext(const char *ext) {
#ifdef _GLAD_IS_SOME_NEW_VERSION
    if(max_loaded_major < 3) {
#endif
        const char *extensions;
        const char *loc;
        const char *terminator;
        extensions = exts;
        if(extensions == NULL || ext == NULL) {
            return 0;
        }

        while(1) {
            loc = strstr(extensions, ext);
            if(loc == NULL) {
                return 0;
            }

            terminator = loc + strlen(ext);
            if((loc == extensions || *(loc - 1) == ' ') &&
                (*terminator == ' ' || *terminator == '\0')) {
                return 1;
            }
            extensions = terminator;
        }
#ifdef _GLAD_IS_SOME_NEW_VERSION
    } else {
        int index;
        if(exts_i == NULL) return 0;
        for(index = 0; index < num_exts_i; index++) {
            const char *e = exts_i[index];

            if(exts_i[index] != NULL && strcmp(e, ext) == 0) {
                return 1;
            }
        }
    }
#endif

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x3, 0x93e5(%rip)      # 0xe718
jge 0x53eb
movq 0x93e0(%rip), %rax      # 0xe720
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5352
cmpq $0x0, -0x10(%rbp)
jne 0x535e
movl $0x0, -0x4(%rbp)
jmp 0x5466
jmp 0x5360
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2210
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5384
movl $0x0, -0x4(%rbp)
jmp 0x5466
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x53ba
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x20, %eax
jne 0x53de
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x53d2
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x53de
movl $0x1, -0x4(%rbp)
jmp 0x5466
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x5360
cmpq $0x0, 0x933d(%rip)      # 0xe730
jne 0x53fe
movl $0x0, -0x4(%rbp)
jmp 0x5466
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl 0x931a(%rip), %eax      # 0xe728
jge 0x545d
movq 0x9319(%rip), %rax      # 0xe730
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq 0x9306(%rip), %rax      # 0xe730
movslq -0x2c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5450
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2240
cmpl $0x0, %eax
jne 0x5450
movl $0x1, -0x4(%rbp)
jmp 0x5466
jmp 0x5452
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5405
jmp 0x545f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/glad.c
// Function: free_exts
static void free_exts(void) {
    if (exts_i != NULL) {
        int index;
        for(index = 0; index < num_exts_i; index++) {
            free((char *)exts_i[index]);
        }
        free((void *)exts_i);
        exts_i = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x92b0(%rip)      # 0xe730
je 0x54ca
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x9296(%rip), %eax      # 0xe728
jge 0x54b3
movq 0x9295(%rip), %rax      # 0xe730
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2190
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5489
movq 0x9276(%rip), %rdi      # 0xe730
callq 0x2190
movq $0x0, 0x9266(%rip) # 0xe730
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/util.c
// Function: bigEndianToHost32
unsigned int
bigEndianToHost32(unsigned int beValue)
{
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
	return 
		((beValue >> 24) & 0xFF      ) |
		((beValue <<  8) & 0xFF0000  ) |
		((beValue >>  8) & 0xFF00    ) |
		((beValue << 24) & 0xFF000000);
#else
	return beValue;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movl -0x4(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff00, %ecx           # imm = 0xFF00
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx       # imm = 0xFF000000
orl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/util.c
// Function: getFarbfeldImageData
unsigned short *
getFarbfeldImageData(const char *path, unsigned int *wi, unsigned int *hi)
{
	char header[9];
	unsigned int w, h;
	unsigned short *imageData;
	
	FILE *fp = fopen(path, "r");
	if(!fp) {
		printf("Could not open the image: %s\n", path);
		return (unsigned short*)-1;
	}

	fread(header, 8, 1, fp);

	fread(&w, sizeof(w), 1, fp);
	fread(&h, sizeof(h), 1, fp);

	w = bigEndianToHost32(w);
	h = bigEndianToHost32(h);

	imageData = malloc(4 * w * h * sizeof(short));
	fread(imageData, 1, sizeof(short) * w * h * 4, fp);
	
	for(unsigned int i = 0; i < w * h * 4; i++) {
		imageData[i] = bigEndianToHost16(imageData[i]);
	}
	*wi = w;
	*hi = h;
	fclose(fp);
	return imageData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3c6c(%rip), %rsi      # 0x933b
callq 0x2120
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x5701
movq -0x10(%rbp), %rsi
leaq 0x5583(%rip), %rdi      # 0xac6d
movb $0x0, %al
callq 0x2060
movq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x57ff
leaq -0x29(%rbp), %rdi
movq -0x48(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2230
movq -0x48(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2230
movq -0x48(%rbp), %rcx
leaq -0x34(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2230
movl -0x30(%rbp), %edi
callq 0x5670
movl %eax, -0x30(%rbp)
movl -0x34(%rbp), %edi
callq 0x5670
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
shll $0x2, %eax
imull -0x34(%rbp), %eax
movl %eax, %eax
movl %eax, %edi
shlq %rdi
callq 0x2110
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, %edx
shlq %rdx
movl -0x34(%rbp), %eax
imulq %rax, %rdx
shlq $0x2, %rdx
movq -0x48(%rbp), %rcx
movl $0x1, %esi
callq 0x2230
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl -0x30(%rbp), %ecx
imull -0x34(%rbp), %ecx
shll $0x2, %ecx
cmpl %ecx, %eax
jae 0x57dc
movq -0x40(%rbp), %rax
movl -0x4c(%rbp), %ecx
movzwl (%rax,%rcx,2), %edi
callq 0x5650
movw %ax, %dx
movq -0x40(%rbp), %rax
movl -0x4c(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x57a2
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x48(%rbp), %rdi
callq 0x2270
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/./linmath.h
// Function: mat4x4_perspective
LINMATH_H_FUNC void mat4x4_perspective(mat4x4 m, float y_fov, float aspect, float n, float f)
{
	/* NOTE: Degrees are an unhandy unit to work with.
	 * linmath.h uses radians for everything! */
	float const a = 1.f / tan(y_fov / 2.f);

	m[0][0] = a / aspect;
	m[0][1] = 0.f;
	m[0][2] = 0.f;
	m[0][3] = 0.f;

	m[1][0] = 0.f;
	m[1][1] = a;
	m[1][2] = 0.f;
	m[1][3] = 0.f;

	m[2][0] = 0.f;
	m[2][1] = 0.f;
	m[2][2] = -((f + n) / (f - n));
	m[2][3] = -1.f;

	m[3][0] = 0.f;
	m[3][1] = 0.f;
	m[3][2] = -((2.f * f * n) / (f - n));
	m[3][3] = 0.f;
}

// 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 %xmm3, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
movss 0x4fef(%rip), %xmm1     # 0xac9c
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2090
movaps %xmm0, %xmm1
movsd 0x33cb(%rip), %xmm0     # 0x9090
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
divss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x10(%rax)
movss -0x1c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rax)
movss -0x18(%rbp), %xmm0
addss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
subss -0x14(%rbp), %xmm1
divss %xmm1, %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
movss 0x4f14(%rip), %xmm0     # 0xaca0
movss %xmm0, 0x2c(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x30(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x34(%rax)
movss 0x4eeb(%rip), %xmm0     # 0xac9c
mulss -0x18(%rbp), %xmm0
mulss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
subss -0x14(%rbp), %xmm1
divss %xmm1, %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x38(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/./linmath.h
// Function: mat4x4_identity
LINMATH_H_FUNC void mat4x4_identity(mat4x4 M)
{
	int i, j;
	for(i=0; i<4; ++i)
		for(j=0; j<4; ++j)
			M[i][j] = i==j ? 1.f : 0.f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x5e80
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0x5e73
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
movss 0x4e74(%rip), %xmm0     # 0xaca4
xorps %xmm1, %xmm1
movss %xmm1, -0x18(%rbp)
cmpl %ecx, %eax
movss %xmm0, -0x14(%rbp)
je 0x5e4b
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5e1c
jmp 0x5e75
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5e0f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/rendering.c
// Function: resizeRenderingSystem
void
resizeRenderingSystem(int w, int h)
{
	printf("Resizing to %dx%d (aspect: %f\n", w, h, (float)w/h);
	mat4x4_perspective(projectionMatrix, TO_RADIANS(70.0), (float)w/h, 0.01, 1000.0);
	glUseProgram(cubeRenderingShader);
	glUniformMatrix4fv(cubeUniformProjectionLocation, 1, GL_FALSE, &projectionMatrix[0][0]);
	glUseProgram(0);

	glViewport(0, 0, w, h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
cvtsi2ssl -0x4(%rbp), %xmm0
cvtsi2ssl -0x8(%rbp), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x5174(%rip), %rdi      # 0xb031
movb $0x1, %al
callq 0x2060
cvtsi2ssl -0x4(%rbp), %xmm1
cvtsi2ssl -0x8(%rbp), %xmm0
divss %xmm0, %xmm1
leaq 0x8897(%rip), %rdi      # 0xe770
movss 0x4dab(%rip), %xmm0     # 0xac8c
movss 0x4dab(%rip), %xmm2     # 0xac94
movss 0x4db7(%rip), %xmm3     # 0xaca8
callq 0x5c80
leaq 0x85b3(%rip), %rax      # 0xe4b0
movq (%rax), %rax
movl 0x884a(%rip), %edi      # 0xe750
callq *%rax
leaq 0x8581(%rip), %rax      # 0xe490
movq (%rax), %rax
movl 0x8844(%rip), %edi      # 0xe75c
movl $0x1, %esi
xorl %edx, %edx
leaq 0x884a(%rip), %rcx      # 0xe770
callq *%rax
xorl %edi, %edi
leaq 0x857f(%rip), %rax      # 0xe4b0
callq *(%rax)
leaq 0x87ce(%rip), %rax      # 0xe708
movq (%rax), %rax
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
xorl %esi, %esi
movl %esi, %edi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/rendering.c
// Function: generateChunkModelAroundPos
void 
generateChunkModelAroundPos(int x, int y, int z, unsigned int distance)
{
	int chunks = distance;
	x = x / WORLD_CHUNK_SIZE;
	y = y / WORLD_CHUNK_SIZE;
	z = z / WORLD_CHUNK_SIZE;

	for(int xc = x - chunks; xc < x + chunks; xc++) {
		for(int yc = y - chunks; yc < y + chunks; yc++) {
			for(int zc = z - chunks; zc < z + chunks; zc++) {
				const WorldChunk* chunk = getWorldChunk(xc, yc, zc);
				if(chunk == NULL) 
					continue;
				generateChunkModel(xc, yc, zc);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x4(%rbp), %ecx
addl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6ec7
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x8(%rbp), %ecx
addl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6eb7
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6eaa
movl -0x18(%rbp), %edi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x8af0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6e91
jmp 0x6e9f
movl -0x18(%rbp), %edi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x5f50
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6e69
jmp 0x6eac
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6e53
jmp 0x6eb9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6e3d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/rendering.c
// Function: isChunkInsideRenderBoundry
unsigned char 
isChunkInsideRenderBoundry(ChunkBufferData* bData, int x, int y, int z, int bDistance)
{
	x = x / WORLD_CHUNK_SIZE;
	y = y / WORLD_CHUNK_SIZE;
	z = z / WORLD_CHUNK_SIZE;

	int xd = abs((int)bData->xOffset - x);
	int yd = abs((int)bData->yOffset - y);
	int zd = abs((int)bData->zOffset - z);
	
	return xd < bDistance && yd < bDistance && zd < bDistance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
subl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl -0x10(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
subl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x25(%rbp)
jge 0x7171
movl -0x20(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x25(%rbp)
jge 0x7171
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/./linmath.h
// Function: mat4x4_translate_in_place
LINMATH_H_FUNC void mat4x4_translate_in_place(mat4x4 M, float x, float y, float z)
{
	vec4 t = {x, y, z, 0};
	vec4 r;
	int i;
	for (i = 0; i < 4; ++i) {
		mat4x4_row(r, M, i);
		M[3][i] += vec4_mul_inner(r, t);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x4, -0x44(%rbp)
jge 0x759a
leaq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x44(%rbp), %edx
callq 0x7680
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x76d0
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
addss 0x30(%rax,%rcx,4), %xmm0
movss %xmm0, 0x30(%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x7558
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/./stb_perlin.h
// Function: stb_perlin_ridge_noise3
float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves)
{
   int i;
   float frequency = 1.0f;
   float prev = 1.0f;
   float amplitude = 0.5f;
   float sum = 0.0f;

   for (i = 0; i < octaves; i++) {
      float r = stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i);
      r = offset - (float) fabs(r);
      r = r*r;
      sum += r*amplitude*prev;
      prev = r;
      frequency *= lacunarity;
      amplitude *= gain;
   }
   return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movss %xmm4, -0x14(%rbp)
movss %xmm5, -0x18(%rbp)
movl %edi, -0x1c(%rbp)
movss 0x2e43(%rip), %xmm0     # 0xaca4
movss %xmm0, -0x24(%rbp)
movss 0x2e36(%rip), %xmm0     # 0xaca4
movss %xmm0, -0x28(%rbp)
movss 0x31e1(%rip), %xmm0     # 0xb05c
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7f5b
movss -0x4(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
mulss -0x24(%rbp), %xmm1
movss -0xc(%rbp), %xmm2
mulss -0x24(%rbp), %xmm2
movl -0x20(%rbp), %eax
xorl %edx, %edx
movl %edx, %edi
movl %edx, %esi
movzbl %al, %ecx
callq 0x7730
movss %xmm0, -0x34(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movaps 0x318c(%rip), %xmm2     # 0xb070
pand %xmm2, %xmm1
cvtsd2ss %xmm1, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x34(%rbp), %xmm0
mulss -0x34(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x34(%rbp), %xmm0
mulss -0x2c(%rbp), %xmm0
movss -0x28(%rbp), %xmm2
movss -0x30(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x34(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x10(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x14(%rbp), %xmm0
mulss -0x2c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7e8f
movss -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/./stb_perlin.h
// Function: stb_perlin_fbm_noise3
float stb_perlin_fbm_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)
{
   int i;
   float frequency = 1.0f;
   float amplitude = 1.0f;
   float sum = 0.0f;
   
   for (i = 0; i < octaves; i++) {
      sum += stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i)*amplitude;
      frequency *= lacunarity;
      amplitude *= gain;
   }
   return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movss %xmm4, -0x14(%rbp)
movl %edi, -0x18(%rbp)
movss 0x2d08(%rip), %xmm0     # 0xaca4
movss %xmm0, -0x20(%rbp)
movss 0x2cfb(%rip), %xmm0     # 0xaca4
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x8034
movss -0x4(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
mulss -0x20(%rbp), %xmm1
movss -0xc(%rbp), %xmm2
mulss -0x20(%rbp), %xmm2
movl -0x1c(%rbp), %eax
xorl %edx, %edx
movl %edx, %edi
movl %edx, %esi
movzbl %al, %ecx
callq 0x7730
movss -0x24(%rbp), %xmm2
movss -0x28(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x10(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7fbd
movss -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/./stb_perlin.h
// Function: stb_perlin_turbulence_noise3
float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)
{
   int i;
   float frequency = 1.0f;
   float amplitude = 1.0f;
   float sum = 0.0f;
   
   for (i = 0; i < octaves; i++) {
      float r = stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i)*amplitude;
      sum += (float) fabs(r);
      frequency *= lacunarity;
      amplitude *= gain;
   }
   return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movss %xmm4, -0x14(%rbp)
movl %edi, -0x18(%rbp)
movss 0x2c38(%rip), %xmm0     # 0xaca4
movss %xmm0, -0x20(%rbp)
movss 0x2c2b(%rip), %xmm0     # 0xaca4
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x8120
movss -0x4(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
mulss -0x20(%rbp), %xmm1
movss -0xc(%rbp), %xmm2
mulss -0x20(%rbp), %xmm2
movl -0x1c(%rbp), %eax
xorl %edx, %edx
movl %edx, %edi
movl %edx, %esi
movzbl %al, %ecx
callq 0x7730
mulss -0x24(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x2f8e(%rip), %xmm1     # 0xb070
pand %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
addss -0x28(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x10(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x808d
movss -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/world.c
// Function: createWorld
void
createWorld(unsigned int w, unsigned int h, unsigned int d)
{
	world.width  = w;
	world.height = h;
	world.depth  = d;
	world.seed    = getTimeNanoseconds();
	
	world.cachedChunks = malloc(sizeof(WorldChunk) * w * h * d);
	
	for(unsigned int i = 0; i < w * h * d; i++) {
		unsigned int x = i % w;
		unsigned int y = (i / w) % h;
		unsigned int z = i / (w * h);

		world.cachedChunks[i].xOffset = x;
		world.cachedChunks[i].yOffset = y;
		world.cachedChunks[i].zOffset = z;
		
		generateChunk(&world.cachedChunks[i], x, y, z, world.seed);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x7cd6(%rip)      # 0x10450
movl -0x8(%rbp), %eax
movl %eax, 0x7cd1(%rip)      # 0x10454
movl -0xc(%rbp), %eax
movl %eax, 0x7ccc(%rip)      # 0x10458
movb $0x0, %al
callq 0x55d0
movq %rax, 0x7cc6(%rip)      # 0x10460
movl -0x4(%rbp), %eax
imulq $0x4010, %rax, %rdi     # imm = 0x4010
movl -0x8(%rbp), %eax
imulq %rax, %rdi
movl -0xc(%rbp), %eax
imulq %rax, %rdi
callq 0x2110
movq %rax, 0x7caa(%rip)      # 0x10468
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x4(%rbp), %ecx
imull -0x8(%rbp), %ecx
imull -0xc(%rbp), %ecx
cmpl %ecx, %eax
jae 0x888e
movl -0x10(%rbp), %eax
xorl %edx, %edx
divl -0x4(%rbp)
movl %edx, -0x14(%rbp)
movl -0x10(%rbp), %eax
xorl %edx, %edx
divl -0x4(%rbp)
xorl %edx, %edx
divl -0x8(%rbp)
movl %edx, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl -0x4(%rbp), %ecx
imull -0x8(%rbp), %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %ecx
movq 0x7c57(%rip), %rax      # 0x10468
movl -0x10(%rbp), %edx
imulq $0x4010, %rdx, %rdx     # imm = 0x4010
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq 0x7c3e(%rip), %rax      # 0x10468
movl -0x10(%rbp), %edx
imulq $0x4010, %rdx, %rdx     # imm = 0x4010
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movq 0x7c24(%rip), %rax      # 0x10468
movl -0x10(%rbp), %edx
imulq $0x4010, %rdx, %rdx     # imm = 0x4010
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq 0x7c0d(%rip), %rdi      # 0x10468
movl -0x10(%rbp), %eax
imulq $0x4010, %rax, %rax     # imm = 0x4010
addq %rax, %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq 0x7be8(%rip), %rax      # 0x10460
movl %eax, %r8d
callq 0x88a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x87c5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/world.c
// Function: getWorldBlock
unsigned int
getWorldBlock(int xB, int yB, int zB)
{
	const WorldChunk* chunk = getWorldChunk(xB / WORLD_CHUNK_SIZE, yB / WORLD_CHUNK_SIZE, zB / WORLD_CHUNK_SIZE);
	if(chunk == NULL)
		return 0;
	return chunk->blocks[xB % WORLD_CHUNK_SIZE][yB % WORLD_CHUNK_SIZE][zB % WORLD_CHUNK_SIZE];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, %edi
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, %esi
movl -0x10(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, %edx
callq 0x8af0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8bd1
movl $0x0, -0x4(%rbp)
jmp 0x8c2f
movq -0x18(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movq -0x30(%rbp), %rax
movslq %edx, %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movslq %edx, %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/k0n10pl4tr[P]minimal_crafter/aabb.c
// Function: checkCollision
AABBCollisionBit
checkCollision(const AABBCollisor *a, const AABBCollisor *b)
{
	AABBCollisionBit xState = a->x + a->w >= b->x && b->x + b->w >= a->x;
	AABBCollisionBit yState = a->y + a->h >= b->y && b->y + b->h >= a->y;
	AABBCollisionBit zState = a->z + a->d >= b->z && b->z + b->d >= a->z;

	return xState && yState && zState;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0xc(%rax), %xmm0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
ucomiss (%rcx), %xmm0
movb %al, -0x14(%rbp)
jb 0x8c89
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
ucomiss (%rax), %xmm0
setae %al
movb %al, -0x14(%rbp)
movb -0x14(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x10(%rax), %xmm0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
ucomiss 0x4(%rcx), %xmm0
movb %al, -0x15(%rbp)
jb 0x8cd5
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
ucomiss 0x4(%rax), %xmm0
setae %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x14(%rax), %xmm0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
ucomiss 0x8(%rcx), %xmm0
movb %al, -0x16(%rbp)
jb 0x8d21
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0x14(%rax), %xmm0
movq -0x8(%rbp), %rax
ucomiss 0x8(%rax), %xmm0
setae %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x13(%rbp)
movzbl -0x11(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x17(%rbp)
je 0x8d55
movzbl -0x12(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x17(%rbp)
je 0x8d55
movzbl -0x13(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x17(%rbp)
movb -0x17(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.4/primes.c
// Function: compute_prime
void* compute_prime (void* arg)
{
	int candidate = 2;
	int n = *((int*) arg);
	while (1) {
		int factor;
		int is_prime = 1;
		/* Test primality by successive division. */
		for (factor = 2; factor < candidate; ++factor)
			if (candidate % factor == 0) {
				is_prime = 0;
				break;
			}
			/* Is this the prime number we’re looking for? */
		if (is_prime) {
			if (--n == 0) //retornar el numero primo deseado como el return del thread
				return (void*) candidate;
		}
		++candidate;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x2, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x1, -0x18(%rbp)
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x11b0
movl -0xc(%rbp), %eax
cltd
idivl -0x14(%rbp)
cmpl $0x0, %edx
jne 0x11a3
movl $0x0, -0x18(%rbp)
jmp 0x11b0
jmp 0x11a5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1186
cmpl $0x0, -0x18(%rbp)
je 0x11cc
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jne 0x11ca
movslq -0xc(%rbp), %rax
popq %rbp
retq
jmp 0x11cc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1178
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.4/primes.c
// Function: main
int main ()
{
	pthread_t thread;
	int which_prime = 100, n = 30, i;
	int prime;
	/* Start the computing thread, up to the 5,000th prime number. */
	pthread_create (&thread, NULL, &compute_prime, &which_prime);
	/* Do some other work here... */
  //Hacer otro trabajo mientras el otro hilo realiza el suyo
  //Por ejemplo calcular el fibonacci de un numero
	int fibonacci[n + 1];
  //Definicion de los caso base
	fibonacci[1] = 1;
	fibonacci[2] = 1;
  //calculo del enesimo fibonacci en este caso 100
	for(i = 3; i <= n; ++i){
		fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
	}

	printf("Fibonacci de %d es : %d\n", n, fibonacci[n]);

	/* Wait for the prime number thread to complete, and get the result.*/
	pthread_join (thread, (void*) &prime);
	/* Print the largest prime it computed. */
	printf("El %dth numero primo es %d.\n", which_prime, prime);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl $0x64, -0x14(%rbp)
movl $0x1e, -0x18(%rbp)
leaq -0xa4(%rip), %rdx       # 0x1160
xorl %eax, %eax
movl %eax, %esi
leaq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rcx
callq 0x1040
movl -0x18(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rsp, %rax
movq %rax, -0x28(%rbp)
leaq 0xf(,%rcx,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rax
subq %rdx, %rax
movq %rax, -0x38(%rbp)
movq %rax, %rsp
movq %rcx, -0x30(%rbp)
movl $0x1, 0x4(%rax)
movl $0x1, 0x8(%rax)
movl $0x3, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x128b
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movl -0x1c(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
addl (%rax,%rcx,4), %edx
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1255
movq -0x38(%rbp), %rax
movl -0x18(%rbp), %esi
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0xd64(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1050
movl -0x14(%rbp), %esi
movl -0x20(%rbp), %edx
leaq 0xd5c(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128n8t8silcv2/ref/silc.c
// Function: ae_init
int ae_init(ae_cxt* cxt, const byte* userkey, int keylen)
{
	if(keylen != CRYPTO_KEYBYTES){
		return KEY_ERROR;
	}
	cxt->userkey = (byte*)userkey;
	cxt->pt_ekey = &(cxt->ekey);
	AES_set_encrypt_key(userkey, keylen*8, cxt->pt_ekey); /* set the encryption key */
	cxt->klen = keylen;

	return SUCCESS;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
je 0x57f3
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x584d
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x120(%rax)
movq 0x18(%rsp), %rcx
addq $0x20, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x118(%rax)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
shll $0x3, %esi
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rdx
callq 0x10a0
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x128(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/test_src/sljitMain.c
// Function: devel
void devel(void)
{
	executable_code code;
	struct sljit_compiler *compiler;
	long buf[4] = {5, 12, 0, 0};

	if ((compiler = sljit_create_compiler()) == NULL)
		errx(-1, "out of memory");

#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
	sljit_compiler_verbose(compiler, stdout);
#endif
	sljit_emit_enter(compiler, 0, 1, 4, 5, 4, 0, 2 * sizeof(long));

	sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);

	code.code = sljit_generate_code(compiler);
	sljit_free_compiler(compiler);

	printf("Code at: %p\n", (void*)SLJIT_FUNC_OFFSET(code.code));

	printf("Function returned with %ld\n", (long)code.func((long*)buf));
	printf("buf[0] = %ld\n", (long)buf[0]);
	printf("buf[1] = %ld\n", (long)buf[1]);
	printf("buf[2] = %ld\n", (long)buf[2]);
	printf("buf[3] = %ld\n", (long)buf[3]);
	sljit_free_code(code.code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x2add1(%rip), %rax     # 0x2d010
movq %rax, -0x30(%rbp)
movq 0x2adce(%rip), %rax     # 0x2d018
movq %rax, -0x28(%rbp)
movq 0x2adcb(%rip), %rax     # 0x2d020
movq %rax, -0x20(%rbp)
movq 0x2adc8(%rip), %rax     # 0x2d028
movq %rax, -0x18(%rbp)
callq 0x18ba0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x2286
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq 0x2adb1(%rip), %rsi     # 0x2d030
movb $0x0, %al
callq 0x2060
movq -0x10(%rbp), %rdi
movq 0x31d4f(%rip), %rax     # 0x33fe0
movq (%rax), %rsi
callq 0x19040
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
movl $0x4, %r9d
movl $0x5, %r8d
movl %r9d, %ecx
movl $0x0, (%rsp)
movl $0x10, 0x8(%rsp)
callq 0x19b20
movq -0x10(%rbp), %rdi
movl $0x20, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1a7c0
movq -0x10(%rbp), %rdi
callq 0x19070
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18d90
movq -0x8(%rbp), %rsi
leaq 0x2ad3f(%rip), %rdi     # 0x2d03e
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rax
leaq -0x30(%rbp), %rdi
callq *%rax
movq %rax, %rsi
leaq 0x2ad31(%rip), %rdi     # 0x2d04b
movb $0x0, %al
callq 0x2070
movq -0x30(%rbp), %rsi
leaq 0x2ad3b(%rip), %rdi     # 0x2d067
movb $0x0, %al
callq 0x2070
movq -0x28(%rbp), %rsi
leaq 0x2ad37(%rip), %rdi     # 0x2d075
movb $0x0, %al
callq 0x2070
movq -0x20(%rbp), %rsi
leaq 0x2ad33(%rip), %rdi     # 0x2d083
movb $0x0, %al
callq 0x2070
movq -0x18(%rbp), %rsi
leaq 0x2ad2f(%rip), %rdi     # 0x2d091
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rdi
callq 0x18e10
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/test_src/sljitTest.c
// Function: test1
static void test1(void)
{
	/* Enter and return from an sljit function. */
	executable_code code;
	struct sljit_compiler* compiler = sljit_create_compiler();

	if (verbose)
		printf("Run test1\n");

	FAILED(!compiler, "cannot create compiler\n");

	/* 3 arguments passed, 3 arguments used. */
	sljit_emit_enter(compiler, 0, 3, 3, 3, 0, 0, 0);
	sljit_emit_return(compiler, SLJIT_MOV, SLJIT_S1, 0);

	SLJIT_ASSERT(sljit_get_generated_code_size(compiler) == 0);
	code.code = sljit_generate_code(compiler);
	CHECK(compiler);
	SLJIT_ASSERT(compiler->error == SLJIT_ERR_COMPILED);
	SLJIT_ASSERT(sljit_get_generated_code_size(compiler) > 0);
	sljit_free_compiler(compiler);

	FAILED(code.func3(3, -21, 86) != -21, "test1 case 1 failed\n");
	FAILED(code.func3(4789, 47890, 997) != 47890, "test1 case 2 failed\n");

	sljit_free_code(code.code);
	successful_tests++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x18ba0
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x31a2c(%rip)     # 0x34354
je 0x2938
leaq 0x2aa97(%rip), %rdi     # 0x2d3c8
movb $0x0, %al
callq 0x2070
cmpq $0x0, -0x10(%rbp)
jne 0x2952
leaq 0x2aa8d(%rip), %rdi     # 0x2d3d3
movb $0x0, %al
callq 0x2070
jmp 0x2ac3
movq -0x10(%rbp), %rdi
xorl %r9d, %r9d
movl $0x3, %r8d
movl %r9d, %esi
movl %r8d, %edx
movl %r8d, %ecx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x19b20
movq -0x10(%rbp), %rdi
movl $0x20, %esi
movl $0xb, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1a7c0
movq -0x10(%rbp), %rdi
callq 0x18010
cmpq $0x0, %rax
je 0x29ba
leaq 0x2aa42(%rip), %rdi     # 0x2d3eb
movl $0x9f, %esi
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x29bc
movq -0x10(%rbp), %rdi
callq 0x19070
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18030
cmpl $0x1, %eax
je 0x29fe
movq -0x10(%rbp), %rdi
callq 0x18030
movl %eax, %esi
leaq 0x2aa2f(%rip), %rdi     # 0x2d418
movb $0x0, %al
callq 0x2070
movq -0x10(%rbp), %rdi
callq 0x18d90
jmp 0x2ac3
jmp 0x2a00
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x2a21
leaq 0x2a9db(%rip), %rdi     # 0x2d3eb
movl $0xa2, %esi
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x2a23
jmp 0x2a25
movq -0x10(%rbp), %rdi
callq 0x18010
cmpq $0x0, %rax
ja 0x2a4c
leaq 0x2a9b0(%rip), %rdi     # 0x2d3eb
movl $0xa3, %esi
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x2a4e
movq -0x10(%rbp), %rdi
callq 0x18d90
movl $0x3, %edi
movq $-0x15, %rsi
movl $0x56, %edx
callq *-0x8(%rbp)
cmpq $-0x15, %rax
je 0x2a81
leaq 0x2a9b4(%rip), %rdi     # 0x2d42c
movb $0x0, %al
callq 0x2070
jmp 0x2ac3
movl $0x12b5, %edi           # imm = 0x12B5
movl $0xbb12, %esi           # imm = 0xBB12
movl $0x3e5, %edx            # imm = 0x3E5
callq *-0x8(%rbp)
cmpq $0xbb12, %rax           # imm = 0xBB12
je 0x2aab
leaq 0x2a99f(%rip), %rdi     # 0x2d441
movb $0x0, %al
callq 0x2070
jmp 0x2ac3
movq -0x8(%rbp), %rdi
callq 0x18e10
movl 0x318a2(%rip), %eax     # 0x3435c
addl $0x1, %eax
movl %eax, 0x31899(%rip)     # 0x3435c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/test_src/sljitTest.c
// Function: cond_set
static void cond_set(struct sljit_compiler *compiler, int dst, long dstw, int type)
{
	/* Testing both sljit_emit_op_flags and sljit_emit_jump. */
	struct sljit_jump* jump;
	struct sljit_label* label;

	sljit_emit_op_flags(compiler, SLJIT_MOV, dst, dstw, SLJIT_UNUSED, 0, type);
	jump = sljit_emit_jump(compiler, type);
	sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_KEEP_FLAGS, dst, dstw, dst, dstw, SLJIT_IMM, 2);
	label = sljit_emit_label(compiler);
	sljit_set_label(jump, label);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl $0x20, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %eax, (%rsp)
callq 0x29010
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x283d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %r8d
movq -0x18(%rbp), %r9
movl $0x4060, %esi           # imm = 0x4060
movl $0x40, (%rsp)
movq $0x2, 0x8(%rsp)
callq 0x1f8d0
movq -0x8(%rbp), %rdi
callq 0x28220
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x18e30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/test_src/sljitTest.c
// Function: cmp_test
static int cmp_test(struct sljit_compiler *compiler, int type, int src1, long src1w, int src2, long src2w)
{
	/* 2 = true, 1 = false */
	struct sljit_jump* jump;
	struct sljit_label* label;

	if (sljit_emit_op1(compiler, SLJIT_MOVU_UB, SLJIT_MEM1(SLJIT_S0), 1, SLJIT_IMM, 2))
		return compiler->error;
	jump = sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w);
	if (!jump)
		return compiler->error;
	if (sljit_emit_op1(compiler, SLJIT_MOV_UB, SLJIT_MEM1(SLJIT_S0), 0, SLJIT_IMM, 1))
		return compiler->error;
	label = sljit_emit_label(compiler);
	if (!label)
		return compiler->error;
	sljit_set_label(jump, label);
	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0x29, %esi
movl $0x8c, %edx
movl $0x1, %ecx
movl $0x40, %r8d
movl $0x2, %r9d
callq 0x1d3d0
cmpl $0x0, %eax
je 0x181c5
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1825c
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movq -0x30(%rbp), %r9
callq 0x2ac80
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x181f6
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1825c
movq -0x10(%rbp), %rdi
movl $0x21, %esi
movl $0x8c, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x40, %r8d
movl $0x1, %r9d
callq 0x1d3d0
cmpl $0x0, %eax
je 0x18229
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1825c
movq -0x10(%rbp), %rdi
callq 0x28220
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x18248
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1825c
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x18e30
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitUtils.c
// Function: sljit_stack_resize
long SLJIT_CALL sljit_stack_resize(struct sljit_stack* stack, unsigned long new_limit)
{
	unsigned long aligned_old_limit;
	unsigned long aligned_new_limit;

	if ((new_limit > stack->max_limit) || (new_limit < stack->base))
		return -1;
#ifdef _WIN32
	aligned_new_limit = (new_limit + uintptr_tage_align) & ~uintptr_tage_align;
	aligned_old_limit = (stack->limit + uintptr_tage_align) & ~uintptr_tage_align;
	if (aligned_new_limit != aligned_old_limit) {
		if (aligned_new_limit > aligned_old_limit) {
			if (!VirtualAlloc((void*)aligned_old_limit, aligned_new_limit - aligned_old_limit, MEM_COMMIT, PAGE_READWRITE))
				return -1;
		}
		else {
			if (!VirtualFree((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, MEM_DECOMMIT))
				return -1;
		}
	}
	stack->limit = new_limit;
	return 0;
#else
	if (new_limit >= stack->limit) {
		stack->limit = new_limit;
		return 0;
	}
	aligned_new_limit = (new_limit + uintptr_tage_align) & ~uintptr_tage_align;
	aligned_old_limit = (stack->limit + uintptr_tage_align) & ~uintptr_tage_align;
	/* If madvise is available, we release the unnecessary space. */
#if defined(MADV_DONTNEED)
	if (aligned_new_limit < aligned_old_limit)
		madvise((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, MADV_DONTNEED);
#elif defined(POSIX_MADV_DONTNEED)
	if (aligned_new_limit < aligned_old_limit)
		posix_madvise((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, POSIX_MADV_DONTNEED);
#endif
	stack->limit = new_limit;
	return 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
ja 0x1846c
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x18479
movq $-0x1, -0x8(%rbp)
jmp 0x1850f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x1849d
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1850f
movq -0x18(%rbp), %rax
addq 0x1bee0(%rip), %rax     # 0x34388
movq 0x1bed9(%rip), %rcx     # 0x34388
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq 0x1bebf(%rip), %rax     # 0x34388
movq 0x1beb8(%rip), %rcx     # 0x34388
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x184fb
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq -0x28(%rbp), %rsi
movl $0x4, %edx
callq 0x20f0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitExecAllocator.c
// Function: sljit_remove_free_block
static __inline void sljit_remove_free_block(struct free_block *free_block)
{
	if (free_block->next)
		free_block->next->prev = free_block->prev;

	if (free_block->prev)
		free_block->prev->next = free_block->next;
	else {
		SLJIT_ASSERT(free_blocks == free_block);
		free_blocks = free_block->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x187cb
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x187ec
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x18824
jmp 0x187ee
movq 0x1bb9b(%rip), %rax     # 0x34390
cmpq -0x8(%rbp), %rax
je 0x18813
leaq 0x17f8f(%rip), %rdi     # 0x30791
movl $0xaa, %esi
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x18815
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1bb6c(%rip)     # 0x34390
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)