LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: glXCreateNewContext
extern GLXContext glXCreateNewContext( Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct )
{
	GLXContext ctx;

	ctx = override_create_context(dpy, NULL, &config, shareList, direct, NULL);
	if (ctx == NULL) {
		GH_GET_PTR_GL(glXCreateNewContext);
		ctx=GH_glXCreateNewContext(dpy, config, renderType, shareList, direct);
	}
	create_context(ctx);
	return ctx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %r15
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
xorl %esi, %esi
xorl %r9d, %r9d
callq 0x3015
movq %rax, %r12
testq %rax, %rax
jne 0x40e5
leaq 0x70d5(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x7110(%rip)      # 0xb1b8
jne 0x40bd
leaq 0x305d(%rip), %rdi      # 0x710e
callq 0x3b1e
movq %rax, 0x70fb(%rip)      # 0xb1b8
leaq 0x70ac(%rip), %rdi      # 0xb170
callq 0x2120
movq 0x70e8(%rip), %rax      # 0xb1b8
movq 0x8(%rsp), %rsi
movq %r15, %rdi
movl %ebp, %edx
movq %r14, %rcx
movl %ebx, %r8d
callq *%rax
movq %rax, %r12
movq %r12, %rdi
callq 0x3c05
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: glXCreateContextAttribsARB
extern GLXContext glXCreateContextAttribsARB (Display * dpy, GLXFBConfig config, GLXContext shareList, Bool direct, const int *attr)
{
	GLXContext ctx;

	ctx = override_create_context(dpy, NULL, &config, shareList, direct, attr);
	if (ctx == NULL) {
		GH_GET_PTR_GL(glXCreateContextAttribsARB);
		ctx=GH_glXCreateContextAttribsARB(dpy, config, shareList, direct, attr);
	}
	create_context(ctx);
	return ctx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
xorl %esi, %esi
movq %r14, %rcx
movl %ebp, %r8d
movq %rbx, %r9
callq 0x3015
movq %rax, %r12
testq %rax, %rax
jne 0x4185
leaq 0x7035(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x7078(%rip)      # 0xb1c0
jne 0x415d
leaq 0x2fd1(%rip), %rdi      # 0x7122
callq 0x3b1e
movq %rax, 0x7063(%rip)      # 0xb1c0
leaq 0x700c(%rip), %rdi      # 0xb170
callq 0x2120
movq 0x7050(%rip), %rax      # 0xb1c0
movq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
callq *%rax
movq %rax, %r12
movq %r12, %rdi
callq 0x3c05
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: glXImportContextEXT
extern GLXContext glXImportContextEXT (Display *dpy, GLXContextID id)
{
	GLXContext ctx;

	GH_GET_PTR_GL(glXImportContextEXT);
	ctx=GH_glXImportContextEXT(dpy, id);
	create_context(ctx);
	return ctx;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6fc2(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x700d(%rip)      # 0xb1c8
jne 0x41d0
leaq 0x2f79(%rip), %rdi      # 0x713d
callq 0x3b1e
movq %rax, 0x6ff8(%rip)      # 0xb1c8
leaq 0x6f99(%rip), %rdi      # 0xb170
callq 0x2120
movq 0x6fe5(%rip), %rax      # 0xb1c8
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
movq %rax, %rbx
movq %rax, %rdi
callq 0x3c05
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: glXCreateContextWithConfigSGIX
extern GLXContext glXCreateContextWithConfigSGIX (Display *dpy, GLXFBConfigSGIX config, int renderType, GLXContext shareList, Bool direct)
{
	GLXContext ctx;

	/* TODO: override_create_context for this case */
	GH_GET_PTR_GL(glXCreateContextWithConfigSGIX);
	ctx=GH_glXCreateContextWithConfigSGIX(dpy, config, renderType, shareList, direct);
	create_context(ctx);
	return ctx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x6f52(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x6fa5(%rip)      # 0xb1d0
jne 0x4240
leaq 0x2f1d(%rip), %rdi      # 0x7151
callq 0x3b1e
movq %rax, 0x6f90(%rip)      # 0xb1d0
leaq 0x6f29(%rip), %rdi      # 0xb170
callq 0x2120
movq 0x6f7d(%rip), %rax      # 0xb1d0
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movl %ebx, %r8d
callq *%rax
movq %rax, %rbx
movq %rax, %rdi
callq 0x3c05
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: glDebugMessageCallback
extern void glDebugMessageCallback(GLDEBUGPROC proc, const GLvoid *user_ptr)
{
	GH_GET_PTR_GL(glDebugMessageCallback);
	if (GH_glDebugMessageCallback) {
		gl_context_t *glc=(gl_context_t*)pthread_getspecific(ctx_current);
		if (glc) {
			glc->original_debug_callback = proc;
			glc->original_debug_callback_user_ptr = user_ptr;

			if (glc->flags & GH_GL_INTERCEPT_DEBUG) {
				GH_verbose(GH_MSG_INFO, "injecting debug output [core]!\n");
				proc = GH_debug_callback;
				user_ptr = glc;
			}
		} else {
			GH_verbose(GH_MSG_WARNING, "debug message callback without current context!\n");
		}
		GH_glDebugMessageCallback(proc, user_ptr);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x63c7(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x644a(%rip)      # 0xb200
jne 0x4dcb
leaq 0x23d5(%rip), %rdi      # 0x7194
callq 0x3b1e
movq %rax, 0x6435(%rip)      # 0xb200
leaq 0x639e(%rip), %rdi      # 0xb170
callq 0x2120
cmpq $0x0, 0x6421(%rip)      # 0xb200
je 0x4e27
movl 0x6421(%rip), %edi      # 0xb208
callq 0x2070
testq %rax, %rax
je 0x4e2d
movq %rax, %r15
movq %r14, 0x818(%rax)
movq %rbx, 0x828(%rax)
testb $0x4, 0x18(%rax)
je 0x4e40
leaq 0x239c(%rip), %rsi      # 0x71ab
movl $0x3, %edi
xorl %eax, %eax
callq 0x2c88
leaq 0x32(%rip), %r14        # 0x4e54
movq %r15, %rbx
jmp 0x4e40
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2397(%rip), %rsi      # 0x71cb
movl $0x2, %edi
xorl %eax, %eax
callq 0x2c88
movq 0x63b9(%rip), %rax      # 0xb200
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: GH_debug_callback
static void APIENTRY
GH_debug_callback(GLenum source, GLenum type, GLuint id, GLenum severity,
		  GLsizei length, const GLchar *message, const GLvoid* userParam)
{
	const gl_context_t *glc=(const gl_context_t*)userParam;
	if (glc) {
		GH_verbose(GH_MSG_INFO, "GLDEBUG: %s %s %s [0x%x]: %s\n",
					translateDebugSourceEnum(source),
					translateDebugTypeEnum(type),
					translateDebugSeverityEnum(severity),
					id, message);
		if (glc->original_debug_callback) {
			glc->original_debug_callback(source, type, id, severity,
						     length, message, glc->original_debug_callback_user_ptr);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x50(%rsp), %rbx
testq %rbx, %rbx
je 0x4f78
movl %ecx, %r14d
movl %edx, %r12d
movl %esi, %r13d
leal -0x8246(%rdi), %eax
cmpl $0x5, %eax
ja 0x4e96
movl %eax, %eax
leaq 0x218f(%rip), %rcx      # 0x701c
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmp 0x4e9d
leaq 0x355d(%rip), %rdx      # 0x83fa
leal -0x824c(%r13), %eax
cmpl $0x5, %eax
ja 0x4ebb
movl %eax, %eax
leaq 0x2182(%rip), %r11      # 0x7034
movslq (%r11,%rax,4), %rcx
addq %r11, %rcx
jmp 0x4ec2
leaq 0x357f(%rip), %rcx      # 0x8441
cmpl $0x9146, %r14d          # imm = 0x9146
movq %rdi, 0x10(%rsp)
jg 0x4eee
cmpl $0x826b, %r14d          # imm = 0x826B
je 0x4f18
cmpl $0x9146, %r14d          # imm = 0x9146
jne 0x4f0c
movl %r8d, %ebp
leaq 0x3564(%rip), %r8       # 0x8450
jmp 0x4f2e
cmpl $0x9148, %r14d          # imm = 0x9148
je 0x4f24
cmpl $0x9147, %r14d          # imm = 0x9147
jne 0x4f0c
movl %r8d, %ebp
leaq 0x354b(%rip), %r8       # 0x8455
jmp 0x4f2e
movl %r8d, %ebp
leaq 0x3557(%rip), %r8       # 0x846d
jmp 0x4f2e
movl %r8d, %ebp
leaq 0x353e(%rip), %r8       # 0x8460
jmp 0x4f2e
movl %r8d, %ebp
leaq 0x352e(%rip), %r8       # 0x845c
movq %r9, (%rsp)
leaq 0x3465(%rip), %rsi      # 0x839e
movl $0x3, %edi
movq %r9, %r15
movl %r12d, %r9d
xorl %eax, %eax
callq 0x2c88
movq 0x818(%rbx), %rax
testq %rax, %rax
movq 0x10(%rsp), %rdi
je 0x4f78
movq 0x828(%rbx), %rcx
movq %rcx, (%rsp)
movl %r13d, %esi
movl %r12d, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movq %r15, %r9
callq *%rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: glDebugMessageCallbackARB
extern void glDebugMessageCallbackARB(GLDEBUGPROC proc, const GLvoid *user_ptr)
{
	GH_GET_PTR_GL(glDebugMessageCallbackARB);
	if (GH_glDebugMessageCallbackARB) {
		gl_context_t *glc=(gl_context_t*)pthread_getspecific(ctx_current);
		if (glc) {
			glc->original_debug_callback = proc;
			glc->original_debug_callback_user_ptr = user_ptr;

			if (glc->flags & GH_GL_INTERCEPT_DEBUG) {
				GH_verbose(GH_MSG_INFO, "injecting debug output [ARB]!\n");
				proc = GH_debug_callback;
				user_ptr = glc;
			}
		} else {
			GH_verbose(GH_MSG_WARNING, "debug message callback without current context!\n");
		}
		GH_glDebugMessageCallbackARB(proc, user_ptr);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x61d7(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x626a(%rip)      # 0xb210
jne 0x4fbb
leaq 0x224d(%rip), %rdi      # 0x71fc
callq 0x3b1e
movq %rax, 0x6255(%rip)      # 0xb210
leaq 0x61ae(%rip), %rdi      # 0xb170
callq 0x2120
cmpq $0x0, 0x6241(%rip)      # 0xb210
je 0x5017
movl 0x6231(%rip), %edi      # 0xb208
callq 0x2070
testq %rax, %rax
je 0x501d
movq %rax, %r15
movq %r14, 0x818(%rax)
movq %rbx, 0x828(%rax)
testb $0x4, 0x18(%rax)
je 0x5030
leaq 0x2217(%rip), %rsi      # 0x7216
movl $0x3, %edi
xorl %eax, %eax
callq 0x2c88
leaq -0x1be(%rip), %r14      # 0x4e54
movq %r15, %rbx
jmp 0x5030
popq %rbx
popq %r14
popq %r15
retq
leaq 0x21a7(%rip), %rsi      # 0x71cb
movl $0x2, %edi
xorl %eax, %eax
callq 0x2c88
movq 0x61d9(%rip), %rax      # 0xb210
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: glDebugMessageCallbackKHR
extern void glDebugMessageCallbackKHR(GLDEBUGPROC proc, const GLvoid *user_ptr)
{
	GH_GET_PTR_GL(glDebugMessageCallbackKHR);
	if (GH_glDebugMessageCallbackKHR) {
		gl_context_t *glc=(gl_context_t*)pthread_getspecific(ctx_current);
		if (glc) {
			glc->original_debug_callback = proc;
			glc->original_debug_callback_user_ptr = user_ptr;

			if (glc->flags & GH_GL_INTERCEPT_DEBUG) {
				GH_verbose(GH_MSG_INFO, "injecting debug output [KHR]!\n");
				proc = GH_debug_callback;
				user_ptr = glc;
			}
		} else {
			GH_verbose(GH_MSG_WARNING, "debug message callback without current context!\n");
		}
		GH_glDebugMessageCallbackKHR(proc, user_ptr);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x611a(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x61b5(%rip)      # 0xb218
jne 0x5078
leaq 0x21c9(%rip), %rdi      # 0x7235
callq 0x3b1e
movq %rax, 0x61a0(%rip)      # 0xb218
leaq 0x60f1(%rip), %rdi      # 0xb170
callq 0x2120
cmpq $0x0, 0x618c(%rip)      # 0xb218
je 0x50d4
movl 0x6174(%rip), %edi      # 0xb208
callq 0x2070
testq %rax, %rax
je 0x50da
movq %rax, %r15
movq %r14, 0x818(%rax)
movq %rbx, 0x828(%rax)
testb $0x4, 0x18(%rax)
je 0x50ed
leaq 0x2193(%rip), %rsi      # 0x724f
movl $0x3, %edi
xorl %eax, %eax
callq 0x2c88
leaq -0x27b(%rip), %r14      # 0x4e54
movq %r15, %rbx
jmp 0x50ed
popq %rbx
popq %r14
popq %r15
retq
leaq 0x20ea(%rip), %rsi      # 0x71cb
movl $0x2, %edi
xorl %eax, %eax
callq 0x2c88
movq 0x6124(%rip), %rax      # 0xb218
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: glDebugMessageCallbackAMD
extern void glDebugMessageCallbackAMD(GLDEBUGPROCAMD proc, GLvoid *user_ptr)
{
	GH_GET_PTR_GL(glDebugMessageCallbackAMD);
	if (GH_glDebugMessageCallbackAMD) {
		gl_context_t *glc=(gl_context_t*)pthread_getspecific(ctx_current);
		if (glc) {
			glc->original_debug_callback_AMD = proc;
			glc->original_debug_callback_AMD_user_ptr = user_ptr;

			if (glc->flags & GH_GL_INTERCEPT_DEBUG) {
				GH_verbose(GH_MSG_INFO, "injecting debug output [AMD]!\n");
				proc = GH_debug_callback_AMD;
				user_ptr = glc;
			}
		} else {
			GH_verbose(GH_MSG_WARNING, "debug message callback without current context!\n");
		}
		GH_glDebugMessageCallbackAMD(proc, user_ptr);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x605d(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x6100(%rip)      # 0xb220
jne 0x5135
leaq 0x2145(%rip), %rdi      # 0x726e
callq 0x3b1e
movq %rax, 0x60eb(%rip)      # 0xb220
leaq 0x6034(%rip), %rdi      # 0xb170
callq 0x2120
cmpq $0x0, 0x60d7(%rip)      # 0xb220
je 0x5191
movl 0x60b7(%rip), %edi      # 0xb208
callq 0x2070
testq %rax, %rax
je 0x5197
movq %rax, %r15
movq %r14, 0x820(%rax)
movq %rbx, 0x830(%rax)
testb $0x4, 0x18(%rax)
je 0x51aa
leaq 0x210f(%rip), %rsi      # 0x7288
movl $0x3, %edi
xorl %eax, %eax
callq 0x2c88
leaq 0x32(%rip), %r14        # 0x51be
movq %r15, %rbx
jmp 0x51aa
popq %rbx
popq %r14
popq %r15
retq
leaq 0x202d(%rip), %rsi      # 0x71cb
movl $0x2, %edi
xorl %eax, %eax
callq 0x2c88
movq 0x606f(%rip), %rax      # 0xb220
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: GH_debug_callback_AMD
static void APIENTRY
GH_debug_callback_AMD(GLuint id, GLenum category, GLenum severity,
		  GLsizei length, const GLchar *message, GLvoid* userParam)
{
	const gl_context_t *glc=(const gl_context_t*)userParam;

	if (glc) {
		GH_verbose(GH_MSG_INFO, "GLDEBUG[AMD]: %s %s %s [0x%x]: %s\n",
					translateDebugCategoryEnum(category),
					translateDebugSeverityEnum(severity),
					id, message);
		if (glc->original_debug_callback_AMD) {
			glc->original_debug_callback_AMD(id, category, severity,
							 length, message,
							 glc->original_debug_callback_AMD_user_ptr);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %r9, %r9
je 0x52ab
movq %r9, %r15
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r12d
movl %edi, %r13d
leal -0x9149(%r12), %eax
cmpl $0x7, %eax
ja 0x5202
movl %eax, %eax
leaq 0x1e53(%rip), %rcx      # 0x704c
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmp 0x5209
leaq 0x32b0(%rip), %rdx      # 0x84b9
cmpl $0x9146, %r14d          # imm = 0x9146
jg 0x522d
cmpl $0x826b, %r14d          # imm = 0x826B
je 0x5251
cmpl $0x9146, %r14d          # imm = 0x9146
jne 0x5248
leaq 0x3225(%rip), %rcx      # 0x8450
jmp 0x5261
cmpl $0x9148, %r14d          # imm = 0x9148
je 0x525a
cmpl $0x9147, %r14d          # imm = 0x9147
jne 0x5248
leaq 0x320f(%rip), %rcx      # 0x8455
jmp 0x5261
leaq 0x321e(%rip), %rcx      # 0x846d
jmp 0x5261
leaq 0x3208(%rip), %rcx      # 0x8460
jmp 0x5261
leaq 0x31fb(%rip), %rcx      # 0x845c
leaq 0x3218(%rip), %rsi      # 0x8480
movl $0x3, %edi
movl %r13d, %r8d
movq %rbx, %r9
xorl %eax, %eax
callq 0x2c88
movq 0x820(%r15), %rax
testq %rax, %rax
je 0x52ab
movq 0x830(%r15), %r9
movl %r13d, %edi
movl %r12d, %esi
movl %r14d, %edx
movl %ebp, %ecx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: latency_before_swap
static void
latency_before_swap(GH_latency *lat)
{
	GLsync sync;

	switch(lat->latency) {
		case GH_LATENCY_NOP:
		case GH_LATENCY_FINISH_AFTER:
			(void)lat;
			break;
		case GH_LATENCY_FINISH_BEFORE:
			GH_glFinish();
			break;
		default:
			if ( (sync=lat->sync_object[lat->cur_pos]) ) {
				if (lat->flags & GH_LATENCY_FLAG_MANUAL_WAIT) {
					/* check for the fence in a loop */
					while(GH_glClientWaitSync(sync, GL_SYNC_FLUSH_COMMANDS_BIT, lat->gl_wait_interval) == GL_TIMEOUT_EXPIRED) {
						if (lat->self_wait_interval) {
							usleep(lat->self_wait_interval);
						}
					}
				} else {
					/* just wait for the fence */
					GH_glClientWaitSync(sync, GL_SYNC_FLUSH_COMMANDS_BIT, lat->gl_wait_timeout);
					/* NOTE: we do not care about the result */
				}
			}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
leal 0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x5ab2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testl %eax, %eax
jne 0x5ac3
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x5805(%rip)           # 0xb2c8
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %ecx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x5aaa
testb $0x1, 0x14(%rbx)
jne 0x5af8
movq 0x5825(%rip), %rax      # 0xb308
movq 0x18(%rbx), %rdx
movq %r14, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq 0x20(%rbx), %rdx
movq %r14, %rdi
movl $0x1, %esi
callq *0x57fe(%rip)           # 0xb308
cmpl $0x911b, %eax           # imm = 0x911B
jne 0x5aaa
movl 0x28(%rbx), %edi
testl %edi, %edi
je 0x5af8
callq 0x21d0
jmp 0x5af8
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: latency_after_swap
static void
latency_after_swap(GH_latency *lat)
{
	switch(lat->latency) {
		case GH_LATENCY_NOP:
		case GH_LATENCY_FINISH_BEFORE:
			(void)lat;
			break;
		case GH_LATENCY_FINISH_AFTER:
			GH_glFinish();
			break;
		default:
			if ( (lat->sync_object[lat->cur_pos]) ) {
				GH_glDeleteSync(lat->sync_object[lat->cur_pos]);
			}
			lat->sync_object[lat->cur_pos]=GH_glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
			if (++lat->cur_pos == (unsigned)lat->latency) {
				lat->cur_pos=0;
			}
	}
}

// Assembly:
movl (%rdi), %eax
cmpl $-0x2, %eax
je 0x5b7c
testl %eax, %eax
je 0x5b7c
cmpl $-0x1, %eax
jne 0x5b35
jmpq *0x5793(%rip)           # 0xb2c8
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %ecx
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x5b51
callq *0x57af(%rip)           # 0xb300
xorl %ebp, %ebp
movl $0x9117, %edi           # imm = 0x9117
xorl %esi, %esi
callq *0x5798(%rip)           # 0xb2f8
movq 0x8(%rbx), %rcx
movl 0x10(%rbx), %edx
movq %rax, (%rcx,%rdx,8)
leal 0x1(%rdx), %eax
cmpl (%rbx), %eax
cmovel %ebp, %eax
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: parse_name
static void
parse_name(char *buf, size_t size, const char *name_template, unsigned int ctx_num)
{
	struct timespec ts_now;
	int in_escape=0;
	size_t pos=0;
	char c;

	buf[--size]=0; /* resverve space for final NUL terminator */
	while ( (pos < size) && (c=*(name_template++)) ) {
		if (in_escape) {
			switch(c) {
				case '%':
					buf[pos++]=c;
					break;
				case 'c':
					pos=buf_printf(buf,pos,size,"%u",ctx_num);
					break;
				case 'p':
					pos=buf_printf(buf,pos,size,"%u",(unsigned)getpid());
					break;
				case 't':
					clock_gettime(CLOCK_REALTIME, &ts_now);
					pos=buf_printf(buf,pos,size,"%09lld.%ld",
							(long long)ts_now.tv_sec,
							ts_now.tv_nsec);
					break;
				default:
					pos=buf_printf(buf,pos,size,"%%%c",c);
			}
			in_escape=0;
		} else {
			switch(c) {
				case '%':
					in_escape=1;
					break;
				default:
					buf[pos++]=c;
			}
		}
	}
	buf[pos]=0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, 0xfff(%rdi)
xorl %r13d, %r13d
leaq 0x191c(%rip), %r15      # 0x74e0
xorl %r12d, %r12d
movsbl (%r14), %r8d
testl %r8d, %r8d
je 0x5c8e
testl %r12d, %r12d
je 0x5c36
movzbl %r8b, %eax
cmpl $0x6f, %eax
jg 0x5bfd
cmpl $0x25, %eax
je 0x5c42
cmpl $0x63, %eax
jne 0x5c4e
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rcx
movl %ebp, %r8d
jmp 0x5c74
cmpl $0x70, %eax
je 0x5c60
cmpl $0x74, %eax
jne 0x5c4e
xorl %r12d, %r12d
xorl %edi, %edi
leaq 0x8(%rsp), %rsi
callq 0x2080
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x18b6(%rip), %rcx      # 0x74e3
xorl %eax, %eax
callq 0x5ca2
jmp 0x5c7b
movl $0x1, %r12d
cmpb $0x25, %r8b
je 0x5c7e
movb %r8b, (%rbx,%r13)
incq %r13
xorl %r12d, %r12d
jmp 0x5c7e
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x1890(%rip), %rcx      # 0x74ee
jmp 0x5c74
callq 0x2090
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x5ca2
movq %rax, %r13
incq %r14
cmpq $0xfff, %r13            # imm = 0xFFF
jb 0x5bc7
movb $0x0, (%rbx,%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: GH_get_gl_proc
static void *
GH_get_gl_proc(const char *name)
{
	static void *proc;

	/* try glXGetProcAddressARB first */
	GH_GET_PTR(glXGetProcAddressARB);
	if (GH_glXGetProcAddressARB && (proc=GH_glXGetProcAddressARB(name)) )
		return proc;

	/* try glXGetProcAddress as second chance */
	GH_GET_PTR(glXGetProcAddress);
	if (GH_glXGetProcAddress && (proc=GH_glXGetProcAddress(name)) )
		return proc;

	/* try dlsym as last resort */
	return GH_dlsym_gl(name);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x540f(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x543a(%rip)      # 0xb1a8
jne 0x5dba
cmpq $0x0, 0x5420(%rip)      # 0xb198
je 0x5d96
movq 0x5417(%rip), %rax      # 0xb198
leaq 0x133f(%rip), %rsi      # 0x70c7
movq $-0x1, %rdi
callq *%rax
movq %rax, %r14
jmp 0x5db3
leaq 0x16e0(%rip), %rsi      # 0x747d
leaq 0x1323(%rip), %rdx      # 0x70c7
xorl %r14d, %r14d
movl $0x2, %edi
xorl %eax, %eax
callq 0x2c88
movq %r14, 0x53ee(%rip)      # 0xb1a8
leaq 0x53af(%rip), %rdi      # 0xb170
callq 0x2120
cmpq $0x0, 0x53da(%rip)      # 0xb1a8
je 0x5dec
movq 0x53d1(%rip), %rax      # 0xb1a8
movq %rbx, %rdi
callq *%rax
movq %rax, 0x5495(%rip)      # 0xb278
testq %rax, %rax
jne 0x5e7a
leaq 0x537d(%rip), %rdi      # 0xb170
callq 0x21a0
cmpq $0x0, 0x53a0(%rip)      # 0xb1a0
jne 0x5e4c
cmpq $0x0, 0x538e(%rip)      # 0xb198
je 0x5e28
movq 0x5385(%rip), %rax      # 0xb198
leaq 0x127d(%rip), %rsi      # 0x7097
movq $-0x1, %rdi
callq *%rax
movq %rax, %r14
jmp 0x5e45
leaq 0x164e(%rip), %rsi      # 0x747d
leaq 0x1261(%rip), %rdx      # 0x7097
xorl %r14d, %r14d
movl $0x2, %edi
xorl %eax, %eax
callq 0x2c88
movq %r14, 0x5354(%rip)      # 0xb1a0
leaq 0x531d(%rip), %rdi      # 0xb170
callq 0x2120
cmpq $0x0, 0x5340(%rip)      # 0xb1a0
je 0x5e82
movq 0x5337(%rip), %rax      # 0xb1a0
movq %rbx, %rdi
callq *%rax
movq %rax, 0x5403(%rip)      # 0xb278
testq %rax, %rax
je 0x5e82
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3b1e
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: get_envui
static unsigned int
get_envui(const char *name, unsigned int def)
{
	const char *s=getenv(name);
	int i;

	if (s) {
		i=(unsigned)strtoul(s,NULL,0);
	} else {
		i=def;
	}
	return i;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x2030
testq %rax, %rax
je 0x662f
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2170
movq %rax, %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: frametimes_flush
static void
frametimes_flush(GH_frametimes *ft)
{
	unsigned int i;
	GH_frametime *last;
	const GH_frametime *cur,*prev=&ft->frametime[ft->num_results * ft->num_timestamps];

	if (ft->cur_result == 0) {
		return;
	}

	GH_verbose(GH_MSG_DEBUG, "frametimes: dumping results of %u frames\n", ft->cur_result);
	for (i=0; i<ft->cur_result; i++) {
		unsigned int frame=ft->frame - ft->cur_result + i;
		if (frame >= ft->delay) {
			fprintf(ft->dump, "%u", frame - ft->delay);
			cur=&ft->frametime[i * ft->num_timestamps];
			frametimes_dump_results(ft, cur, prev);
			prev=cur;
			fputc('\n', ft->dump);
		}
	}
	fflush(ft->dump);
	/* copy the last result */
	last=&ft->frametime[ft->num_results * ft->num_timestamps];
	cur=&ft->frametime[(ft->cur_result-1) * ft->num_timestamps];
	for (i=0; i<ft->num_timestamps; i++) {
		last[i]=cur[i];
	}


	ft->cur_result=0;
}

// Assembly:
movl 0x28(%rdi), %edx
testl %edx, %edx
je 0x67cc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movl 0x8(%rdi), %r15d
movl 0xc(%rdi), %ebp
leaq 0x1ae1(%rip), %rsi      # 0x8142
movl $0x4, %edi
xorl %eax, %eax
callq 0x2c88
movl 0x28(%rbx), %eax
testl %eax, %eax
je 0x6762
imull %ebp, %r15d
leaq (%r15,%r15,2), %rcx
leaq (%r14,%rcx,8), %r12
leaq 0x1ae1(%rip), %r15      # 0x816c
xorl %ebp, %ebp
movl 0x2c(%rbx), %edx
subl %eax, %edx
addl %ebp, %edx
subl 0x4(%rbx), %edx
jb 0x6755
movq 0x30(%rbx), %rdi
leaq 0xe38(%rip), %rsi       # 0x74e0
xorl %eax, %eax
callq 0x2100
movq 0x20(%rbx), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%rbx), %eax
movl %eax, %ecx
imull %ebp, %ecx
movq %rcx, 0x8(%rsp)
testl %eax, %eax
je 0x6735
movq 0x8(%rsp), %rax
leaq (%rax,%rax,2), %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %r13
addq $0x10, %r13
xorl %r14d, %r14d
movq -0x10(%r13), %rdx
movq 0x30(%rbx), %rdi
subq 0x18(%r12), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
movq (%r13), %rdx
movq 0x30(%rbx), %rdi
subq 0x28(%r12), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
movq (%r13), %rdx
movq 0x30(%rbx), %rdi
subq -0x8(%r13), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
incq %r14
movl 0x8(%rbx), %eax
addq $0x18, %r13
cmpq %rax, %r14
jb 0x66e2
movq 0x8(%rsp), %rax
leaq (%rax,%rax,2), %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %r12
movq 0x30(%rbx), %rsi
movl $0xa, %edi
callq 0x20d0
incl %ebp
movl 0x28(%rbx), %eax
cmpl %eax, %ebp
jb 0x668d
movq 0x30(%rbx), %rdi
callq 0x2140
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
je 0x67b7
movq 0x20(%rbx), %rax
movl 0xc(%rbx), %edx
imull %ecx, %edx
movl 0x28(%rbx), %esi
decl %esi
imull %ecx, %esi
shlq $0x3, %rdx
leaq (%rdx,%rdx,2), %rcx
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %rdx
xorl %esi, %esi
movq 0x10(%rax,%rdx), %rdi
movq %rdi, 0x10(%rax,%rcx)
movups (%rax,%rdx), %xmm0
movups %xmm0, (%rax,%rcx)
incq %rsi
movl 0x8(%rbx), %edi
addq $0x18, %rax
cmpq %rdi, %rsi
jb 0x6796
movl $0x0, 0x28(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/derhass[P]glx_hook/glx_hook.c
// Function: timestamp_set
static void
timestamp_set(GH_timestamp *ts, GH_frametime *rs, GH_frametime_mode mode)
{
	/* CPU */
	/* collect previous result */
	rs->cpu=(uint64_t)ts->timestamp_cpu.tv_sec * (uint64_t)1000000000UL
		+ (uint64_t)ts->timestamp_cpu.tv_nsec;
	/* new query */
	clock_gettime(CLOCK_REALTIME, &ts->timestamp_cpu);

	/* GPU */
	if (mode >= GH_FRAMETIME_CPU_GPU) {
		/* collect previous result */
		if (ts->query_object) {
			GLuint64 value;
			GH_glGetQueryObjectui64v(ts->query_object, GL_QUERY_RESULT, &value);
			rs->gpu=(uint64_t)value;
		} else {
			GH_glGenQueries(1, &ts->query_object);
		}
		rs->gl=(uint64_t)(ts->timestamp_gl);
		/* new query */
		GH_glQueryCounter(ts->query_object, GL_TIMESTAMP);
		GH_glGetInteger64v(GL_TIMESTAMP, (GLint64*)&ts->timestamp_gl);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
imulq $0x3b9aca00, (%rdi), %rax # imm = 0x3B9ACA00
movq %rsi, %r14
addq 0x8(%rdi), %rax
movq %rax, (%rsi)
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2080
cmpl $0x2, %ebp
jb 0x6851
movl 0x18(%rbx), %edi
testl %edi, %edi
je 0x681a
movq %rsp, %r15
movl $0x8866, %esi           # imm = 0x8866
movq %r15, %rdx
callq *0x4adf(%rip)           # 0xb2f0
movq (%r15), %rax
movq %rax, 0x10(%r14)
jmp 0x6829
leaq 0x18(%rbx), %rsi
movl $0x1, %edi
callq *0x4aa7(%rip)           # 0xb2d0
leaq 0x10(%rbx), %r15
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movl 0x18(%rbx), %edi
movl $0x8e28, %esi           # imm = 0x8E28
callq *0x4aa5(%rip)           # 0xb2e8
movl $0x8e28, %edi           # imm = 0x8E28
movq %r15, %rsi
callq *0x4a8f(%rip)           # 0xb2e0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: path_destroy
void path_destroy(path_t *path)
{
    if (path->sid)
        free(path->sid);
    if (path->v)
        free(path->v);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4bd1
callq 0x3060
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4be0
popq %rbx
jmp 0x3060
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: path_v_destroy
void path_v_destroy(path_v *path)
{
    size_t i;
    for (i = 0; i < path->n; ++i)
        path_destroy(&path->a[i]);
    free(path->a);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4c0e
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rdi
addq %r14, %rdi
callq 0x4bc0
incq %r15
addq $0x30, %r14
cmpq (%rbx), %r15
jb 0x4bf6
movq 0x10(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3060
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: asg_seg_len
uint64_t asg_seg_len(asg_t *asg)
{
    asmg_t *g = asg->asmg;
    uint64_t i, seg_len = 0;
    for (i = 0; i < g->n_vtx; ++i) {
        if (g->vtx[i].del) continue;
        seg_len += g->vtx[i].len;
    }
    return seg_len;
}

// Assembly:
movq 0x20(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x4c46
movq 0x10(%rax), %rdx
addq $0x20, %rdx
xorl %eax, %eax
testb $0x40, 0x3(%rdx)
jne 0x4c3c
addq -0x8(%rdx), %rax
addq $0x28, %rdx
decq %rcx
jne 0x4c32
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: add_next
static void add_next(llnode *node, struct list_node *next)
{
    if (node->n_m == node->n_n)
        MYEXPAND(node->next, node->n_m);
    node->next[node->n_n] = next;
    node->n_n++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jne 0x818c
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x10, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x20, %rax
orq %rcx, %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq 0x20(%rbx), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x3330
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %r14, (%rcx,%rax,8)
incq %rax
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: llnode_destroy
static void llnode_destroy(llnode *node)
{
    size_t i;
    for (i = 0; i < node->n_n; ++i)
        llnode_destroy(node->next[i]);
    free(node->next);
    free(node);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x81ce
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x81a7
incq %r14
cmpq 0x18(%rbx), %r14
jb 0x81b8
movq 0x20(%rbx), %rdi
callq 0x3060
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3060
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: asg_name2id
uint32_t asg_name2id(asg_t *g, char *name)
{
    sdhash_t *h = g->h_seg;
    khint_t k;
    k = kh_sdict_get(h, name);
    return k == kh_end(h)? UINT32_MAX : kh_val(h, k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x18(%rdi), %r9
movq 0x10(%r9), %r14
xorl %esi, %esi
movl $0x0, %edx
testq %r14, %r14
je 0x8720
movl (%r9), %ecx
movl $0x1, %r8d
shll %cl, %r8d
movsbl (%rbx), %eax
testl %eax, %eax
je 0x86ba
movb 0x1(%rbx), %dl
testb %dl, %dl
je 0x86bc
leaq 0x2(%rbx), %rsi
movl %eax, %edi
shll $0x5, %edi
subl %eax, %edi
movsbl %dl, %eax
addl %edi, %eax
movb (%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0x86a3
jmp 0x86bc
xorl %eax, %eax
imull $0x9e3779b9, %eax, %r12d # imm = 0x9E3779B9
negb %cl
shrl %cl, %r12d
movq %r8, 0x10(%rsp)
leal -0x1(%r8), %ebp
movq %r9, 0x8(%rsp)
movq 0x8(%r9), %r15
movl %r12d, %r13d
movl %r13d, %eax
shrl $0x5, %eax
movl (%r15,%rax,4), %eax
btl %r13d, %eax
jae 0x870f
movl %r13d, %eax
leaq (%rax,%rax,2), %rax
movq (%r14,%rax,4), %rdi
movq %rbx, %rsi
callq 0x3250
testl %eax, %eax
je 0x8716
incl %r13d
andl %ebp, %r13d
cmpl %r12d, %r13d
jne 0x86dd
movq 0x10(%rsp), %rdx
jmp 0x8719
movl %r13d, %edx
xorl %esi, %esi
movq 0x8(%rsp), %r9
testq %r14, %r14
je 0x872f
movb (%r9), %cl
movl $0x1, %esi
shll %cl, %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, %edx
je 0x8743
movl %edx, %eax
leaq (%rax,%rax,2), %rax
movl 0x8(%r14,%rax,4), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: path_sort
void path_sort(path_v *paths)
{
    // sort by wlen -> len -> circ -> nv
    qsort(paths->a, paths->n, sizeof(path_t), pcmpfunc);

    size_t i;
    double b_ll, b_cl;
    b_ll = b_cl = .0;
    for (i = 0 ; i < paths->n; ++i) {
        if (!paths->a[i].circ && paths->a[i].wlen > b_ll)
            b_ll = paths->a[i].wlen;
        if (paths->a[i].circ && paths->a[i].wlen > b_cl)
            b_cl = paths->a[i].wlen;
    }
    if (b_cl >= b_ll)
        b_ll = DBL_MAX;
    // find best
    for (i = 0 ; i < paths->n; ++i) {
        if (!paths->a[i].circ && paths->a[i].wlen >= b_ll)
            paths->a[i].best = 1;
        if (paths->a[i].circ && paths->a[i].wlen >= b_cl)
            paths->a[i].best = 1;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x10(%rdi), %rdi
leaq 0xdc(%rip), %rcx        # 0x8840
movl $0x30, %edx
callq 0x30c0
movq (%rbx), %rax
testq %rax, %rax
je 0x87bc
movq 0x10(%rbx), %rcx
addq $0x20, %rcx
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
movl -0x18(%rcx), %edx
btl $0x1e, %edx
jb 0x879d
movsd (%rcx), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x879d
movapd %xmm2, %xmm1
btl $0x1e, %edx
jae 0x87b1
movsd (%rcx), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x87b1
movapd %xmm2, %xmm0
addq $0x30, %rcx
decq %rax
jne 0x8786
jmp 0x87c4
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq $0x0, (%rbx)
je 0x883e
movapd %xmm1, %xmm2
cmpnlesd %xmm0, %xmm2
andpd %xmm2, %xmm1
movsd 0x10cb1(%rip), %xmm3    # 0x19490
andnpd %xmm3, %xmm2
orpd %xmm1, %xmm2
movl $0x8, %eax
xorl %ecx, %ecx
movq 0x10(%rbx), %rdx
movl (%rdx,%rax), %esi
btl $0x1e, %esi
jb 0x8810
movsd 0x18(%rdx,%rax), %xmm1
ucomisd %xmm2, %xmm1
jb 0x8810
orl $0x80000000, %esi       # imm = 0x80000000
movl %esi, (%rdx,%rax)
movq 0x10(%rbx), %rdx
movl (%rdx,%rax), %esi
btl $0x1e, %esi
jae 0x8832
movsd 0x18(%rdx,%rax), %xmm1
ucomisd %xmm0, %xmm1
jb 0x8832
orl $0x80000000, %esi       # imm = 0x80000000
movl %esi, (%rdx,%rax)
incq %rcx
addq $0x30, %rax
cmpq (%rbx), %rcx
jb 0x87ee
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: pcmpfunc
static int pcmpfunc(const void *a, const void *b)
{
    path_t x, y;
    x = *(path_t *) a;
    y = *(path_t *) b;
    if (x.wlen != y.wlen)
        return (x.wlen < y.wlen) - (x.wlen > y.wlen);
    if (x.len != y.len)
        return (x.len < y.len) - (x.len > y.len);
    if (x.circ != y.circ)
        return x.circ? -1 : 1;
    if (x.srcc != y.srcc)
        return (x.srcc < y.srcc) - (x.srcc > y.srcc);
    if (x.nv != y.nv)
        return (x.nv < y.nv) - (x.nv > y.nv);

    return 0;
}

// Assembly:
movsd 0x20(%rdi), %xmm0
movsd 0x20(%rsi), %xmm1
ucomisd %xmm1, %xmm0
jne 0x8852
jnp 0x8867
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
seta %cl
subl %ecx, %eax
retq
movl 0x18(%rsi), %eax
cmpl %eax, 0x18(%rdi)
jne 0x88ab
movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %edx
movl %ecx, %eax
shrl $0x1e, %eax
andl $0x1, %eax
btl $0x1e, %edx
movl %eax, %r8d
sbbl $0x0, %r8d
jne 0x88b7
movsd 0x28(%rdi), %xmm0
movsd 0x28(%rsi), %xmm1
ucomisd %xmm1, %xmm0
jne 0x8852
jp 0x8852
movl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
andl %eax, %ecx
andl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
je 0x88b6
seta %al
movzbl %al, %eax
sbbl $0x0, %eax
negl %eax
retq
negl %eax
orl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: path_rotate
void path_rotate(asg_t *g, path_t *path, hmm_annot_db_t *annots, OG_TYPE_t og_type)
{
    double coeff, coeff_rev;
    coeff = path_rotate_core(g, path, annots, og_type);

    rev_path(path);
    coeff_rev = path_rotate_core(g, path, annots, og_type);

    if (coeff > coeff_rev) {
        // redo rev complement
        rev_path(path);
        if (path->circ)
            // make the last element the first
            array_left_rotate(path->v, path->nv-1, path->nv);
    } else {
        coeff = coeff_rev;
    }

    path->srcc = coeff;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x89c6
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rax
movl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
andl 0x8(%rbx), %ecx
cmpl $0x2, %ecx
jb 0x890c
decl %ecx
decq %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
movl 0x4(%rax,%rcx,4), %edi
movl %edi, (%rax,%rdx,4)
movl %esi, 0x4(%rax,%rcx,4)
incq %rdx
movl %ecx, %esi
decq %rcx
cmpq %rsi, %rdx
jb 0x88f1
testl $0x3fffffff, 0x8(%rbx)  # imm = 0x3FFFFFFF
je 0x892c
xorl %ecx, %ecx
xorb $0x1, (%rax,%rcx,4)
incq %rcx
movl 0x8(%rbx), %edx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
cmpq %rdx, %rcx
jb 0x8917
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x89c6
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x89b6
movq 0x10(%rbx), %rdi
movl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
andl 0x8(%rbx), %eax
cmpl $0x2, %eax
jb 0x897a
decl %eax
decq %rax
xorl %ecx, %ecx
movl (%rdi,%rcx,4), %edx
movl 0x4(%rdi,%rax,4), %esi
movl %esi, (%rdi,%rcx,4)
movl %edx, 0x4(%rdi,%rax,4)
incq %rcx
movl %eax, %edx
decq %rax
cmpq %rdx, %rcx
jb 0x895f
testl $0x3fffffff, 0x8(%rbx)  # imm = 0x3FFFFFFF
je 0x899a
xorl %eax, %eax
xorb $0x1, (%rdi,%rax,4)
incq %rax
movl 0x8(%rbx), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
cmpq %rcx, %rax
jb 0x8985
movl 0x8(%rbx), %edx
btl $0x1e, %edx
jae 0x89b1
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
leal -0x1(%rdx), %esi
callq 0x9865
movsd (%rsp), %xmm0
movsd %xmm0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: array_left_rotate
static void array_left_rotate(uint32_t arr[], uint32_t d, uint32_t n)
{
    uint32_t i, j;
    // if number of elements to be rotated is more than array size
    if(d > n)
        d = d % n;
    if(d == 0 || d == n)
        return;
    i = d;
    j = n - d;
    while (i != j) {
        if(i < j) { // left block arr[0..d-1] is shorter
            swap(arr, d-i, d+j-i, i);
            j -= i;
        } else { // rigth block arr[d..n-1] is shorter
            swap(arr, d-i, d, j);
            i -= j;
        }
    }
    // finally, block swap A and B
    swap(arr, d-i, d, i);
}

// Assembly:
movl %edx, %ecx
cmpl %edx, %esi
jbe 0x9873
movl %esi, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %esi
testl %esi, %esi
sete %al
subl %esi, %ecx
sete %dl
orb %al, %dl
jne 0x991f
movl %esi, %eax
negl %eax
cmpl %ecx, %esi
jne 0x9891
movl %esi, %edx
jmp 0x98fc
pushq %rbp
pushq %rbx
movl %esi, %edx
movl %edx, %r8d
subl %ecx, %r8d
jae 0x98c8
testl %edx, %edx
je 0x98c4
movl %edx, %r8d
addl %esi, %eax
movl %eax, %r9d
movl (%rdi,%r9,4), %r10d
leal (%rcx,%rax), %r11d
movl (%rdi,%r11,4), %ebx
movl %ebx, (%rdi,%r9,4)
movl %r10d, (%rdi,%r11,4)
incl %eax
decq %r8
jne 0x98a6
subl %edx, %ecx
jmp 0x98f2
testl %ecx, %ecx
je 0x98ef
movl %ecx, %edx
movl %esi, %r9d
leal (%rax,%r9), %r10d
movl (%rdi,%r10,4), %r11d
movl %r9d, %ebx
movl (%rdi,%rbx,4), %ebp
movl %ebp, (%rdi,%r10,4)
movl %r11d, (%rdi,%rbx,4)
incl %r9d
decq %rdx
jne 0x98d1
movl %r8d, %edx
movl %edx, %eax
negl %eax
cmpl %ecx, %edx
jne 0x9895
popq %rbx
popq %rbp
testl %edx, %edx
je 0x991f
movl %edx, %ecx
leal (%rax,%rsi), %edx
movl (%rdi,%rdx,4), %r8d
movl %esi, %r9d
movl (%rdi,%r9,4), %r10d
movl %r10d, (%rdi,%rdx,4)
movl %r8d, (%rdi,%r9,4)
incl %esi
decq %rcx
jne 0x9902
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: put_chars
static void put_chars(char *seq, int len, int rv, int ow, FILE *fo, uint64_t *l, int line_wd)
{
    int i;
    if (!rv) {
        // forward
        for (i = ow; i < len; ++i) {
            fputc(seq[i], fo);
            if (++(*l) % line_wd == 0)
                fputc('\n', fo);
        }
    } else {
         // reverse
        for (i = len - ow - 1; i >= 0; --i) {
            fputc(comp_table[(int) seq[i]], fo);
            if (++(*l) % line_wd == 0)
                fputc('\n', fo);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movl %esi, %r15d
movq %rdi, %r12
movl 0x40(%rsp), %eax
testl %edx, %edx
je 0xa1aa
movl %ecx, %edx
notl %edx
addl %r15d, %edx
js 0xa1ef
movslq %eax, %r13
movl %edx, %eax
subl %ecx, %r15d
addq %rax, %r12
leaq 0xf474(%rip), %rbp      # 0x195e0
movsbq (%r12), %rax
movsbl (%rax,%rbp), %edi
movq %r14, %rsi
callq 0x3200
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
xorl %edx, %edx
divq %r13
testq %rdx, %rdx
jne 0xa19d
movl $0xa, %edi
movq %r14, %rsi
callq 0x3200
decl %r15d
decq %r12
testl %r15d, %r15d
jg 0xa16c
jmp 0xa1ef
subl %ecx, %r15d
jle 0xa1ef
movslq %eax, %r13
movslq %ecx, %rax
addq %rax, %r12
xorl %ebp, %ebp
movsbl (%r12,%rbp), %edi
movq %r14, %rsi
callq 0x3200
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
xorl %edx, %edx
divq %r13
testq %rdx, %rdx
jne 0xa1e7
movl $0xa, %edi
movq %r14, %rsi
callq 0x3200
incq %rbp
cmpl %ebp, %r15d
jne 0xa1ba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: print_all_best_seqs
void print_all_best_seqs(asg_t *g, path_v *paths, FILE *fo)
{
    if (paths->n == 0)
        return;

    size_t i;
    for (i = 0; i < paths->n; ++i)
        if (!!paths->a[i].best)
            print_seq(g, &paths->a[i], fo, i, 0, 60, 100);
}

// Assembly:
cmpq $0x0, (%rsi)
je 0xa739
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
cmpq $0x0, (%rsi)
je 0xa72c
movq %rdx, %rbx
movq %rdi, %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x10(%r14), %rsi
cmpl $0x0, 0x8(%rsi,%r13)
jns 0xa720
addq %r13, %rsi
movl $0x64, (%rsp)
movq %r15, %rdi
movq %rbx, %rdx
movl %r12d, %ecx
xorl %r8d, %r8d
movl $0x3c, %r9d
callq 0x9bc4
incq %r12
addq $0x30, %r13
cmpq (%r14), %r12
jb 0xa6f3
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: asg_destroy
void asg_destroy(asg_t *g)
{
    if (!g) return;
    uint64_t i;
    for (i = 0; i < g->n_seg; ++i)
        asg_seg_destroy(&g->seg[i]);
    free(g->seg);
    // key has been freed by asg_seg_destroy
    if (g->h_seg) kh_sdict_destroy(g->h_seg);
    if (g->asmg) asmg_destroy(g->asmg);
    free(g);
}

// Assembly:
testq %rdi, %rdi
je 0xa82e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xa7d4
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %r12
movq -0x8(%r12,%r14), %rdi
testq %rdi, %rdi
je 0xa7b9
callq 0x3060
movq (%r12,%r14), %rdi
testq %rdi, %rdi
je 0xa7c7
callq 0x3060
incq %r15
addq $0x18, %r14
cmpq 0x8(%rbx), %r15
jb 0xa7a6
movq 0x10(%rbx), %rdi
callq 0x3060
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0xa80d
movq 0x10(%r14), %rsi
movq 0x18(%r14), %r15
movq %r15, %rdi
callq 0x1726a
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x1726a
movq %r15, %rdi
movq %r14, %rsi
callq 0x1726a
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xa81b
callq 0x118c4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3060
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: asg_add_seg
uint32_t asg_add_seg(asg_t *g, char *name, int allow_dups)
{
    if (!name)
        return UINT32_MAX;
    sdhash_t *h = g->h_seg;
    khint_t k;
    int absent;
    k = kh_sdict_put(h, name, &absent);
    if (absent) {
        asg_seg_t *s;
        if (g->n_seg == g->m_seg)
            MYEXPAND(g->seg, g->m_seg);
        s = &g->seg[g->n_seg];
        s->len = 0;
        s->seq = 0;
        s->cov = 0;
        kh_key(h, k) = s->name = strdup(name);
        kh_val(h, k) = g->n_seg++;
    } else if (!allow_dups) {
        fprintf(stderr, "[E::%s] duplicate segment '%s'\n", __func__, name);
        exit(EXIT_FAILURE);
    }
    return kh_val(h, k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0xa921
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rbx
leaq 0x14(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa94f
cmpl $0x0, (%r12)
movl %eax, %esi
je 0xa928
movq %rsi, 0x8(%rsp)
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
jne 0xa8d8
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x10, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x20, %rax
orq %rcx, %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movq 0x10(%r14), %rdi
leaq 0x8(,%rax,8), %rax
leaq (%rax,%rax,2), %rsi
callq 0x3330
movq %rax, 0x10(%r14)
movq 0x8(%r14), %r13
movq 0x10(%r14), %rbp
leaq (,%r13,2), %r12
addq %r13, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbp,%r12,8)
movq %r15, %rdi
callq 0x3480
movq %rax, (%rbp,%r12,8)
movq 0x10(%rbx), %rcx
movq 0x8(%rsp), %rsi
leaq (%rsi,%rsi,2), %rdx
movq %rax, (%rcx,%rdx,4)
leaq 0x1(%r13), %rax
movq %rax, 0x8(%r14)
movl %r13d, 0x8(%rcx,%rdx,4)
jmp 0xa92c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xa938
testl %ebp, %ebp
je 0xa947
movq 0x10(%rbx), %rax
leaq (%rsi,%rsi,2), %rcx
movl 0x8(%rax,%rcx,4), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x384c
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: asg_add_seg1
uint32_t asg_add_seg1(asg_t *g, char *name, char *seq, uint32_t len, uint64_t cov, int allow_dups)
{
    uint32_t k = asg_add_seg(g, name, allow_dups);
    asg_seg_t *s = &g->seg[k];
    s->seq = strdup(seq);
    s->len = len;
    s->cov = cov;
    return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %r15
movl %r9d, %edx
callq 0xa82f
movl %eax, %r12d
movq 0x10(%r15), %r15
movl %eax, %eax
leaq (%rax,%rax,2), %r13
movq %r14, %rdi
callq 0x3480
movq %rax, 0x8(%r15,%r13,8)
movl %ebp, 0x10(%r15,%r13,8)
movl %ebx, 0x14(%r15,%r13,8)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/c-zhou[P]oatk/path.c
// Function: asg_make_asmg_copy
asmg_t *asg_make_asmg_copy(asmg_t *g, asmg_t *_g)
{
    asmg_t *g1;
    
    if (_g)
        g1 = _g;
    else
        MYCALLOC(g1, 1);
    
    g1->n_vtx = g1->m_vtx = g->n_vtx;
    MYCALLOC(g1->vtx, g1->n_vtx);
    // this works as a and seq are always 0
    memcpy(g1->vtx, g->vtx, sizeof(asmg_vtx_t) * g1->n_vtx);
    g1->n_arc = g1->m_arc = g->n_arc;
    MYCALLOC(g1->arc, g1->n_arc);
    memcpy(g1->arc, g->arc, sizeof(asmg_arc_t) * g1->n_arc);

    uint64_t n_vtx = asmg_vtx_n(g1);
    MYCALLOC(g1->idx_p, n_vtx);
    memcpy(g1->idx_p, g->idx_p, sizeof(uint64_t) * n_vtx);
    MYCALLOC(g1->idx_n, n_vtx);
    memcpy(g1->idx_n, g->idx_n, sizeof(uint64_t) * n_vtx);
    
    return g1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jne 0xad48
movl $0x1, %edi
movl $0x40, %esi
callq 0x3240
movq %rax, %rbx
movq (%r14), %r15
movq %r15, 0x8(%rbx)
movq %r15, (%rbx)
movl $0x28, %esi
movq %r15, %rdi
callq 0x3240
movq %rax, 0x10(%rbx)
movq 0x10(%r14), %rsi
leaq (,%r15,8), %rcx
leaq (%rcx,%rcx,4), %rdx
movq %rax, %rdi
callq 0x32c0
movq 0x18(%r14), %r12
movq %r12, 0x20(%rbx)
movq %r12, 0x18(%rbx)
movl $0x30, %esi
movq %r12, %rdi
callq 0x3240
movq %rax, 0x28(%rbx)
movq 0x28(%r14), %rsi
shlq $0x4, %r12
leaq (%r12,%r12,2), %rdx
movq %rax, %rdi
callq 0x32c0
leaq (%r15,%r15), %r12
movl $0x8, %esi
movq %r12, %rdi
callq 0x3240
movq %rax, 0x30(%rbx)
movq 0x30(%r14), %rsi
shlq $0x4, %r15
movq %rax, %rdi
movq %r15, %rdx
callq 0x32c0
movl $0x8, %esi
movq %r12, %rdi
callq 0x3240
movq %rax, 0x38(%rbx)
movq 0x38(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x32c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq