LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitExecAllocator.c
// Function: sljit_insert_free_block
static __inline void sljit_insert_free_block(struct free_block *free_block, unsigned long size)
{
	free_block->header.size = 0;
	free_block->size = size;

	free_block->next = free_blocks;
	free_block->prev = NULL;
	if (free_blocks)
		free_blocks->prev = free_block;
	free_blocks = free_block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq 0x1bab6(%rip), %rcx     # 0x34390
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
cmpq $0x0, 0x1ba9a(%rip)     # 0x34390
je 0x18907
movq -0x8(%rbp), %rcx
movq 0x1ba8d(%rip), %rax     # 0x34390
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x1ba7e(%rip)     # 0x34390
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitExecAllocator.c
// Function: sljit_free_unused_memory_exec
void sljit_free_unused_memory_exec(void)
{
	struct free_block* free_block;
	struct free_block* next_free_block;

	allocator_grab_lock();

	free_block = free_blocks;
	while (free_block) {
		next_free_block = free_block->next;
		if (!free_block->header.prev_size && 
				AS_BLOCK_HEADER(free_block, free_block->size)->size == 1) {
			total_size -= free_block->size;
			sljit_remove_free_block(free_block);
			free_chunk(free_block, free_block->size + sizeof(struct block_header));
		}
		free_block = next_free_block;
	}

	SLJIT_ASSERT((total_size && free_blocks) || (!total_size && !free_blocks));
	allocator_release_lock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x18780
movq 0x1b8bc(%rip), %rax     # 0x34390
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x18b4a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x18b40
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpq $0x1, (%rax,%rcx)
jne 0x18b40
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq 0x1b888(%rip), %rax     # 0x343a0
subq %rcx, %rax
movq %rax, 0x1b87e(%rip)     # 0x343a0
movq -0x8(%rbp), %rdi
callq 0x187a0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0x10, %rsi
callq 0x18a90
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x18ad8
jmp 0x18b4c
cmpq $0x0, 0x1b84c(%rip)     # 0x343a0
je 0x18b60
cmpq $0x0, 0x1b832(%rip)     # 0x34390
jne 0x18b8c
cmpq $0x0, 0x1b838(%rip)     # 0x343a0
jne 0x18b74
cmpq $0x0, 0x1b81e(%rip)     # 0x34390
je 0x18b8c
leaq 0x17c16(%rip), %rdi     # 0x30791
movl $0x136, %esi            # imm = 0x136
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x18b8e
callq 0x18830
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: init_compiler
static void init_compiler(void)
{
	sse2_buffer = (int*)(((unsigned long)sse2_data + 15) & ~0xf);
	/* Single precision constants. */
	sse2_buffer[0] = 0x80000000;
	sse2_buffer[4] = 0x7fffffff;
	/* Double precision constants. */
	sse2_buffer[8] = 0;
	sse2_buffer[9] = 0x80000000;
	sse2_buffer[12] = 0xffffffff;
	sse2_buffer[13] = 0x7fffffff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1b6b5(%rip), %rax     # 0x343e0
addq $0xf, %rax
andq $-0x10, %rax
movq %rax, 0x1b676(%rip)     # 0x343b0
movq 0x1b66f(%rip), %rax     # 0x343b0
movl $0x80000000, (%rax)     # imm = 0x80000000
movq 0x1b662(%rip), %rax     # 0x343b0
movl $0x7fffffff, 0x10(%rax) # imm = 0x7FFFFFFF
movq 0x1b654(%rip), %rax     # 0x343b0
movl $0x0, 0x20(%rax)
movq 0x1b646(%rip), %rax     # 0x343b0
movl $0x80000000, 0x24(%rax) # imm = 0x80000000
movq 0x1b638(%rip), %rax     # 0x343b0
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq 0x1b62a(%rip), %rax     # 0x343b0
movl $0x7fffffff, 0x34(%rax) # imm = 0x7FFFFFFF
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: sljit_free_compiler
void sljit_free_compiler(struct sljit_compiler *compiler)
{
	struct sljit_memory_fragment *buf;
	struct sljit_memory_fragment *curr;

	buf = compiler->buf;
	while (buf != NULL) {
		curr = buf;
		buf = buf->next;
		free(curr);
	}

	buf = compiler->abuf;
	while (buf != NULL) {
		curr = buf;
		buf = buf->next;
		free(curr);
	}

#if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
	free(compiler->cpool);
#endif
	free(compiler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x18dcd
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2030
jmp 0x18da8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x18dfe
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2030
jmp 0x18dd9
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: sljit_set_label
void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label)
{
	if (!!jump && !!label) {
		jump->flags &= ~JUMP_ADDR;
		jump->flags |= JUMP_LABEL;
		jump->u.label = label;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x18e76
cmpq $0x0, -0x10(%rbp)
je 0x18e76
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
andq $-0x3, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: sljit_set_target
void sljit_set_target(struct sljit_jump *jump, unsigned long target)
{
	if (!!jump) {
		jump->flags &= ~JUMP_LABEL;
		jump->flags |= JUMP_ADDR;
		jump->u.target = target;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x18ebf
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
andq $-0x2, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
orq $0x2, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: sljit_alloc_memory
void* sljit_alloc_memory(struct sljit_compiler *compiler, int size)
{
	CHECK_ERROR_PTR();

#if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
	if (size <= 0 || size > 128)
		return NULL;
	size = (size + 7) & ~0x111;
#else
	if (size <= 0 || size > 64)
		return NULL;
	size = (size + 3) & ~0x11;
#endif
	return ensure_abuf(compiler, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x18ef2
movq $0x0, -0x8(%rbp)
jmp 0x18f2c
jmp 0x18ef4
cmpl $0x0, -0x14(%rbp)
jle 0x18f03
cmpl $0x80, -0x14(%rbp)
jle 0x18f0d
movq $0x0, -0x8(%rbp)
jmp 0x18f2c
movl -0x14(%rbp), %eax
addl $0x7, %eax
andl $0xfffffeee, %eax       # imm = 0xFFFFFEEE
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x18f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: ensure_abuf
static void* ensure_abuf(struct sljit_compiler *compiler, unsigned long size)
{
	u_char *ret;
	struct sljit_memory_fragment *new_frag;

	SLJIT_ASSERT(size <= 256);
	if (compiler->abuf->used_size + size <= (ABUF_SIZE - (unsigned long)SLJIT_OFFSETOF(struct sljit_memory_fragment, memory))) {
		ret = compiler->abuf->memory + compiler->abuf->used_size;
		compiler->abuf->used_size += size;
		return ret;
	}
	new_frag = malloc(ABUF_SIZE);
	PTR_FAIL_IF_NULL(new_frag);
	new_frag->next = compiler->abuf;
	compiler->abuf = new_frag;
	new_frag->used_size = size;
	return new_frag->memory;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x100, -0x18(%rbp)     # imm = 0x100
jbe 0x18f72
leaq 0x178fd(%rip), %rdi     # 0x3085e
movl $0x1ea, %esi            # imm = 0x1EA
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x18f74
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movl $0x1000, %ecx           # imm = 0x1000
movl $0x10, %edx
addq $0x10, %rdx
subq $0x10, %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
ja 0x18fd8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
addq $0x10, %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19036
movl $0x1000, %edi           # imm = 0x1000
callq 0x20d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x19001
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x19036
jmp 0x19003
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: check_sljit_generate_code
static __inline CHECK_RETURN_TYPE check_sljit_generate_code(struct sljit_compiler *compiler)
{
#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
	struct sljit_jump *jump;
#endif

	(void)compiler;

#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
	CHECK_ARGUMENT(compiler->size > 0);
	jump = compiler->jumps;
	while (jump) {
		/* All jumps have target. */
		CHECK_ARGUMENT(jump->flags & (JUMP_LABEL | JUMP_ADDR));
		jump = jump->next;
	}
#endif
	CHECK_RETURN_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
ja 0x1960f
leaq 0x17260(%rip), %rdi     # 0x3085e
movl $0x37c, %esi            # imm = 0x37C
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x19611
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1965f
jmp 0x19626
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x19650
leaq 0x1721f(%rip), %rdi     # 0x3085e
movl $0x380, %esi            # imm = 0x380
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x19652
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1961d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: reverse_buf
static __inline void reverse_buf(struct sljit_compiler *compiler)
{
	struct sljit_memory_fragment *buf = compiler->buf;
	struct sljit_memory_fragment *prev = NULL;
	struct sljit_memory_fragment *tmp;

	do {
		tmp = buf->next;
		buf->next = prev;
		prev = buf;
		buf = tmp;
	} while (buf != NULL);

	compiler->buf = prev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1968c
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_64.c
// Function: generate_far_jump_code
static u_char* generate_far_jump_code(struct sljit_jump *jump, u_char *code_ptr, int type)
{
	if (type < SLJIT_JUMP) {
		/* Invert type. */
		*code_ptr++ = get_jump_code(type ^ 0x1) - 0x10;
		*code_ptr++ = 10 + 3;
	}

	SLJIT_COMPILE_ASSERT(reg_map[TMP_REG3] == 9, tmp3_is_9_first);
	*code_ptr++ = REX_W | REX_B;
	*code_ptr++ = MOV_r_i32 + 1;
	jump->addr = (unsigned long)code_ptr;

	if (jump->flags & JUMP_LABEL)
		jump->flags |= PATCH_MD;
	else
		*(long*)code_ptr = jump->u.target;

	code_ptr += sizeof(long);
	*code_ptr++ = REX_B;
	*code_ptr++ = GROUP_FF;
	*code_ptr++ = (type >= SLJIT_FAST_CALL) ? (MOD_REG | CALL_rm | 1) : (MOD_REG | JMP_rm | 1);

	return code_ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x16, -0x14(%rbp)
jge 0x1994f
movl -0x14(%rbp), %edi
xorl $0x1, %edi
callq 0x29e90
movzbl %al, %eax
subl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0xd, (%rax)
jmp 0x19951
jmp 0x19953
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x49, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $-0x47, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x199a7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
orq $0x10, %rcx
movq %rcx, 0x10(%rax)
jmp 0x199b6
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x41, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $-0x1, (%rax)
movl -0x14(%rbp), %edx
movl $0xe1, %eax
movl $0xd1, %ecx
cmpl $0x17, %edx
cmovgel %ecx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_64.c
// Function: generate_fixed_jump
static u_char* generate_fixed_jump(u_char *code_ptr, long addr, int type)
{
	long delta = addr - ((long)code_ptr + 1 + sizeof(int));

	if (delta <= HALFWORD_MAX && delta >= HALFWORD_MIN) {
		*code_ptr++ = (type == 2) ? CALL_i32 : JMP_i32;
		*(long*)code_ptr = delta;
	}
	else {
		SLJIT_COMPILE_ASSERT(reg_map[TMP_REG3] == 9, tmp3_is_9_second);
		*code_ptr++ = REX_W | REX_B;
		*code_ptr++ = MOV_r_i32 + 1;
		*(long*)code_ptr = addr;
		code_ptr += sizeof(long);
		*code_ptr++ = REX_B;
		*code_ptr++ = GROUP_FF;
		*code_ptr++ = (type == 2) ? (MOD_REG | CALL_rm | 1) : (MOD_REG | JMP_rm | 1);
	}

	return code_ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x1, %rcx
addq $0x4, %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
jg 0x19a90
cmpq $-0x80000000, -0x20(%rbp) # imm = 0x80000000
jl 0x19a90
movl -0x14(%rbp), %edx
movl $0xe9, %eax
movl $0xe8, %ecx
cmpl $0x2, %edx
cmovel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x19b19
jmp 0x19a92
jmp 0x19a94
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x49, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $-0x47, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x41, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $-0x1, (%rax)
movl -0x14(%rbp), %edx
movl $0xe1, %eax
movl $0xd1, %ecx
cmpl $0x2, %edx
cmovel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: set_emit_enter
static __inline void set_emit_enter(struct sljit_compiler *compiler,
	int options, int args, int scratches, int saveds,
	int fscratches, int fsaveds, int local_size)
{
	(void)local_size;

	compiler->options = options;
	compiler->scratches = scratches;
	compiler->saveds = saveds;
	compiler->fscratches = fscratches;
	compiler->fsaveds = fsaveds;
#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
	compiler->logical_local_size = local_size;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x48(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
movl 0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movl 0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x80(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: ensure_buf
static void* ensure_buf(struct sljit_compiler *compiler, unsigned long size)
{
	u_char *ret;
	struct sljit_memory_fragment *new_frag;

	SLJIT_ASSERT(size <= 256);
	if (compiler->buf->used_size + size <= (BUF_SIZE - (unsigned long)SLJIT_OFFSETOF(struct sljit_memory_fragment, memory))) {
		ret = compiler->buf->memory + compiler->buf->used_size;
		compiler->buf->used_size += size;
		return ret;
	}
	new_frag = malloc(BUF_SIZE);
	PTR_FAIL_IF_NULL(new_frag);
	new_frag->next = compiler->buf;
	compiler->buf = new_frag;
	new_frag->used_size = size;
	return new_frag->memory;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x100, -0x18(%rbp)     # imm = 0x100
jbe 0x1a362
leaq 0x1650d(%rip), %rdi     # 0x3085e
movl $0x1d7, %esi            # imm = 0x1D7
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x1a364
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movl $0x1000, %ecx           # imm = 0x1000
movl $0x10, %edx
addq $0x10, %rdx
subq $0x10, %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
ja 0x1a3c8
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x10, %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a426
movl $0x1000, %edi           # imm = 0x1000
callq 0x20d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1a3f1
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1a426
jmp 0x1a3f3
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_64.c
// Function: sljit_set_context
int sljit_set_context(struct sljit_compiler *compiler,
	int options, int args, int scratches, int saveds,
	int fscratches, int fsaveds, int local_size)
{
	int saved_reg_size;

	CHECK_ERROR();
	CHECK(check_sljit_set_context(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size));
	set_set_context(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size);

	/* Including the return address saved by the call instruction. */
	saved_reg_size = GET_SAVED_REGS_SIZE(scratches, saveds, 1);
	compiler->local_size = ((local_size + SLJIT_LOCALS_OFFSET + saved_reg_size + 15) & ~15) - saved_reg_size;
	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1a46a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a534
jmp 0x1a46c
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movl 0x10(%rbp), %r10d
movl 0x18(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x1a540
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movl 0x10(%rbp), %r10d
movl 0x18(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x1a760
cmpl $0x6, -0x1c(%rbp)
jge 0x1a4cb
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a4d4
movl -0x1c(%rbp), %eax
subl $0x6, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x6, -0x20(%rbp)
jge 0x1a4e8
movl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x1a4f2
movl $0x6, %eax
movl %eax, -0x34(%rbp)
jmp 0x1a4f2
movl -0x30(%rbp), %eax
movl -0x34(%rbp), %ecx
addl %ecx, %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, -0x28(%rbp)
movslq 0x18(%rbp), %rax
addq $0x8, %rax
movslq -0x28(%rbp), %rcx
addq %rcx, %rax
addq $0xf, %rax
andq $-0x10, %rax
movslq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x58(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: emit_mov_before_return
static __inline int emit_mov_before_return(struct sljit_compiler *compiler, int op, int src, long srcw)
{
	/* Return if don't need to do anything. */
	if (op == SLJIT_UNUSED)
		return SLJIT_SUCCESS;

#if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
	/* At the moment the pointer size is always equal to long. May be changed in the future. */
	if (src == SLJIT_RETURN_REG && (op == SLJIT_MOV || op == SLJIT_MOV_P))
		return SLJIT_SUCCESS;
#else
	if (src == SLJIT_RETURN_REG && (op == SLJIT_MOV || op == SLJIT_MOV_UI || op == SLJIT_MOV_SI || op == SLJIT_MOV_P))
		return SLJIT_SUCCESS;
#endif

#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
		|| (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
	compiler->skip_checks = 1;
#endif
	return sljit_emit_op1(compiler, op, SLJIT_RETURN_REG, 0, src, srcw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1b1c5
movl $0x0, -0x4(%rbp)
jmp 0x1b20e
cmpl $0x1, -0x18(%rbp)
jne 0x1b1e0
cmpl $0x20, -0x14(%rbp)
je 0x1b1d7
cmpl $0x27, -0x14(%rbp)
jne 0x1b1e0
movl $0x0, -0x4(%rbp)
jmp 0x1b20e
movq -0x10(%rbp), %rax
movl $0x1, 0x84(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %r8d
movq -0x20(%rbp), %r9
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1d3d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_64.c
// Function: emit_load_imm64
static int emit_load_imm64(struct sljit_compiler *compiler, int reg, long imm)
{
	u_char *inst;

	inst = ensure_buf(compiler, 1 + 2 + sizeof(long));
	FAIL_IF(!inst);
	INC_SIZE(2 + sizeof(long));
	*inst++ = REX_W | ((reg_map[reg] <= 7) ? 0 : REX_B);
	*inst++ = MOV_r_i32 + (reg_map[reg] & 0x7);
	*(long*)inst = imm;
	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb, %esi
callq 0x1a330
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1cb6a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1cbfc
jmp 0x1cb6c
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0xa, (%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
addq $0xa, %rcx
movq %rcx, 0x60(%rax)
movslq -0x14(%rbp), %rcx
leaq 0x13bc7(%rip), %rax     # 0x30760
movzbl (%rax,%rcx), %edx
movl $0x41, %eax
xorl %ecx, %ecx
cmpl $0x7, %edx
cmovlel %ecx, %eax
orl $0x48, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movslq -0x14(%rbp), %rcx
leaq 0x13b95(%rip), %rax     # 0x30760
movzbl (%rax,%rcx), %eax
andl $0x7, %eax
addl $0xb8, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: check_sljit_emit_op0
static __inline CHECK_RETURN_TYPE check_sljit_emit_op0(struct sljit_compiler *compiler, int op)
{
#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
	CHECK_ARGUMENT((op >= SLJIT_BREAKPOINT && op <= SLJIT_LSMUL)
		|| ((op & ~SLJIT_INT_OP) >= SLJIT_LUDIV && (op & ~SLJIT_INT_OP) <= SLJIT_LSDIV));
	CHECK_ARGUMENT(op < SLJIT_LUMUL || compiler->scratches >= 2);
#endif
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
	if (!!compiler->verbose)
		fprintf(compiler->verbose, "  %s%s\n", !(op & SLJIT_INT_OP) ? "" : "i", op0_names[GET_OPCODE(op) - SLJIT_OP0_BASE]);
#endif
	CHECK_RETURN_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x1cfcb
cmpl $0x3, -0xc(%rbp)
jle 0x1cffd
movl -0xc(%rbp), %eax
andl $0xfffffeff, %eax       # imm = 0xFFFFFEFF
cmpl $0x4, %eax
jl 0x1cfe5
movl -0xc(%rbp), %eax
andl $0xfffffeff, %eax       # imm = 0xFFFFFEFF
cmpl $0x5, %eax
jle 0x1cffd
leaq 0x13872(%rip), %rdi     # 0x3085e
movl $0x3f9, %esi            # imm = 0x3F9
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x1cfff
jmp 0x1d001
cmpl $0x2, -0xc(%rbp)
jl 0x1d029
movq -0x8(%rbp), %rax
cmpl $0x2, 0x48(%rax)
jge 0x1d029
leaq 0x13846(%rip), %rdi     # 0x3085e
movl $0x3fa, %esi            # imm = 0x3FA
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x1d02b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x1d08b
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movl -0xc(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
setne %cl
xorb $-0x1, %cl
leaq 0x13995(%rip), %rdx     # 0x309eb
leaq 0x102a0(%rip), %rax     # 0x2d2fd
testb $0x1, %cl
cmovneq %rax, %rdx
movl -0xc(%rbp), %eax
andl $0xffff80ff, %eax       # imm = 0xFFFF80FF
subl $0x0, %eax
movslq %eax, %rcx
leaq 0x170e7(%rip), %rax     # 0x34160
movq (%rax,%rcx,8), %rcx
leaq 0x13999(%rip), %rsi     # 0x30a1d
movb $0x0, %al
callq 0x20a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: emit_save_flags
static __inline int emit_save_flags(struct sljit_compiler *compiler)
{
	u_char *inst;

#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
	inst = ensure_buf(compiler, 1 + 5);
	FAIL_IF(!inst);
	INC_SIZE(5);
#else
	inst = ensure_buf(compiler, 1 + 6);
	FAIL_IF(!inst);
	INC_SIZE(6);
	*inst++ = REX_W;
#endif
	*inst++ = LEA_r_m; /* lea esp/rsp, [esp/rsp + sizeof(long)] */
	*inst++ = 0x64;
	*inst++ = 0x24;
	*inst++ = (u_char)sizeof(long);
	*inst++ = PUSHF;
	compiler->flags_saved = 1;
	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x7, %esi
callq 0x1a330
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1f3c3
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f465
jmp 0x1f3c5
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x6, (%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
addq $0x6, %rcx
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x48, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $-0x73, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x64, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x24, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x8, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $-0x64, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x74(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: emit_restore_flags
static __inline int emit_restore_flags(struct sljit_compiler *compiler, int keep_flags)
{
	u_char *inst;

#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
	inst = ensure_buf(compiler, 1 + 5);
	FAIL_IF(!inst);
	INC_SIZE(5);
	*inst++ = POPF;
#else
	inst = ensure_buf(compiler, 1 + 6);
	FAIL_IF(!inst);
	INC_SIZE(6);
	*inst++ = POPF;
	*inst++ = REX_W;
#endif
	*inst++ = LEA_r_m; /* lea esp/rsp, [esp/rsp - sizeof(long)] */
	*inst++ = 0x64;
	*inst++ = 0x24;
	*inst++ = (u_char)-(s_char)sizeof(long);
	compiler->flags_saved = keep_flags;
	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x7, %esi
callq 0x1a330
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x21de6
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x21e87
jmp 0x21de8
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x6, (%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
addq $0x6, %rcx
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $-0x63, (%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x48, (%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $-0x73, (%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x64, (%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x24, (%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $-0x8, (%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x74(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: sljit_emit_op_custom
int sljit_emit_op_custom(struct sljit_compiler *compiler,
	void *instruction, int size)
{
	u_char *inst;

	CHECK_ERROR();
	CHECK(check_sljit_emit_op_custom(compiler, instruction, size));

	inst = ensure_buf(compiler, 1 + size);
	FAIL_IF(!inst);
	INC_SIZE(size);
	memmove(inst, instruction, size);
	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x238c7
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x23941
jmp 0x238c9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x23950
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x1a330
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x23901
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x23941
jmp 0x23903
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movslq -0x1c(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2100
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: check_sljit_emit_op_custom
static __inline CHECK_RETURN_TYPE check_sljit_emit_op_custom(struct sljit_compiler *compiler,
	void *instruction, int size)
{
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
	int i;
#endif

	(void)compiler;

#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
	CHECK_ARGUMENT(instruction);
#if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
	CHECK_ARGUMENT(size > 0 && size < 16);
#elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
	CHECK_ARGUMENT((size == 2 && (((long)instruction) & 0x1) == 0)
		|| (size == 4 && (((long)instruction) & 0x3) == 0));
#else
	CHECK_ARGUMENT(size == 4 && (((long)instruction) & 0x3) == 0);
#endif

#endif
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
	if (!!compiler->verbose) {
		fprintf(compiler->verbose, "  op_custom");
		for (i = 0; i < size; i++)
			fprintf(compiler->verbose, " 0x%x", ((u_char*)instruction)[i]);
		fprintf(compiler->verbose, "\n");
	}
#endif
	CHECK_RETURN_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x23982
leaq 0xceed(%rip), %rdi      # 0x3085e
movl $0x45e, %esi            # imm = 0x45E
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x23984
jmp 0x23986
cmpl $0x0, -0x14(%rbp)
jle 0x23992
cmpl $0x10, -0x14(%rbp)
jl 0x239aa
leaq 0xcec5(%rip), %rdi      # 0x3085e
movl $0x460, %esi            # imm = 0x460
movb $0x0, %al
callq 0x2070
callq 0x2040
jmp 0x239ac
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x23a1f
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
leaq 0xd0d7(%rip), %rsi      # 0x30a9d
movb $0x0, %al
callq 0x20a0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x23a09
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0xd0b2(%rip), %rsi      # 0x30aa9
movb $0x0, %al
callq 0x20a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x239d4
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
leaq 0x98e4(%rip), %rsi      # 0x2d2fc
movb $0x0, %al
callq 0x20a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: sljit_emit_fop1_cmp
static __inline int sljit_emit_fop1_cmp(struct sljit_compiler *compiler, int op,
	int src1, long src1w,
	int src2, long src2w)
{
	compiler->flags_saved = 0;
	if (!FAST_IS_REG(src1)) {
		FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, TMP_FREG, src1, src1w));
		src1 = TMP_FREG;
	}
	return emit_sse2_logic(compiler, UCOMISD_x_xm, !(op & SLJIT_SINGLE_OP), src1, src2, src2w);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %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), %rax
movl $0x0, 0x74(%rax)
cmpl $0x3f, -0x18(%rbp)
jle 0x24b05
jmp 0x24ad1
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
andl $0x100, %esi            # imm = 0x100
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %r8
xorl %edx, %edx
callq 0x26e90
cmpl $0x0, %eax
je 0x24afc
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x24b36
jmp 0x24afe
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edx
movl -0x18(%rbp), %ecx
movl -0x24(%rbp), %r8d
movq -0x30(%rbp), %r9
movl $0x2e, %esi
callq 0x26f10
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: sljit_emit_fop1_convw_fromd
static __inline int sljit_emit_fop1_convw_fromd(struct sljit_compiler *compiler, int op,
	int dst, long dstw,
	int src, long srcw)
{
	int dst_r = SLOW_IS_REG(dst) ? dst : TMP_REG1;
	u_char *inst;

#if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
	if (GET_OPCODE(op) == SLJIT_CONVW_FROMD)
		compiler->mode32 = 0;
#endif

	inst = emit_x86_instruction(compiler, 2 | ((op & SLJIT_SINGLE_OP) ? EX86_PREF_F3 : EX86_PREF_F2) | EX86_SSE2_OP2, dst_r, 0, src, srcw);
	FAIL_IF(!inst);
	*inst++ = GROUP_0F;
	*inst = CVTTSD2SI_r_xm;

	if (dst_r == TMP_REG1 && dst != SLJIT_UNUSED)
		return emit_mov(compiler, dst, dstw, TMP_REG1, 0);
	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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)
cmpl $0x0, -0x18(%rbp)
jle 0x25662
cmpl $0x3f, -0x18(%rbp)
jg 0x25662
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x2566c
movl $0xe, %eax
movl %eax, -0x44(%rbp)
jmp 0x2566c
movl -0x44(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
andl $0xffff80ff, %eax       # imm = 0xFFFF80FF
cmpl $0x82, %eax
jne 0x2568c
movq -0x10(%rbp), %rax
movl $0x0, 0x70(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %ecx
andl $0x100, %ecx            # imm = 0x100
movl $0x800, %esi            # imm = 0x800
movl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %ecx
cmovnel %eax, %esi
orl $0x2, %esi
orl $0x4000, %esi           # imm = 0x4000
movl -0x34(%rbp), %edx
movl -0x24(%rbp), %r8d
movq -0x30(%rbp), %r9
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b8f0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x256dc
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x25729
jmp 0x256de
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0xf, (%rax)
movq -0x40(%rbp), %rax
movb $0x2c, (%rax)
cmpl $0xe, -0x34(%rbp)
jne 0x25722
cmpl $0x0, -0x18(%rbp)
je 0x25722
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
movl $0xe, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x1d0a0
movl %eax, -0x4(%rbp)
jmp 0x25729
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: emit_sse2_logic
static int emit_sse2_logic(struct sljit_compiler *compiler, u_char opcode,
	int pref66, int xmm1, int xmm2, long xmm2w)
{
	u_char *inst;

	inst = emit_x86_instruction(compiler, 2 | (pref66 ? EX86_PREF_66 : 0) | EX86_SSE2, xmm1, 0, xmm2, xmm2w);
	FAIL_IF(!inst);
	*inst++ = GROUP_0F;
	*inst = opcode;
	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %ecx
xorl %esi, %esi
movl $0x400, %eax            # imm = 0x400
cmpl $0x0, %ecx
cmovnel %eax, %esi
orl $0x2, %esi
orl $0x6000, %esi           # imm = 0x6000
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b8f0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x26f77
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x26f9b
jmp 0x26f79
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0xf, (%rax)
movb -0x11(%rbp), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: emit_sse2
static int emit_sse2(struct sljit_compiler *compiler, u_char opcode,
	int single, int xmm1, int xmm2, long xmm2w)
{
	u_char *inst;

	inst = emit_x86_instruction(compiler, 2 | (single ? EX86_PREF_F3 : EX86_PREF_F2) | EX86_SSE2, xmm1, 0, xmm2, xmm2w);
	FAIL_IF(!inst);
	*inst++ = GROUP_0F;
	*inst = opcode;
	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %ecx
movl $0x800, %esi            # imm = 0x800
movl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %ecx
cmovnel %eax, %esi
orl $0x2, %esi
orl $0x6000, %esi           # imm = 0x6000
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %r8d
movq -0x28(%rbp), %r9
xorl %eax, %eax
movl %eax, %ecx
callq 0x1b8f0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x281ea
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2820e
jmp 0x281ec
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0xf, (%rax)
movb -0x11(%rbp), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: sljit_emit_label
struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler)
{
	u_char *inst;
	struct sljit_label *label;

	CHECK_ERROR_PTR();
	CHECK_PTR(check_sljit_emit_label(compiler));

	/* We should restore the flags before the label,
	   since other taken jumps has their own flags as well. */
	if (compiler->flags_saved) {
		if (emit_restore_flags(compiler, 0))
			return NULL;
	}

	if (compiler->last_label && compiler->last_label->size == compiler->size)
		return compiler->last_label;

	label = ensure_abuf(compiler, sizeof(struct sljit_label));
	if (!label)
		return NULL;
	set_label(label, compiler);

	inst = ensure_buf(compiler, 2);
	if (!inst)
		return NULL;

	*inst++ = 0;
	*inst++ = 0;

	return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x28242
movq $0x0, -0x8(%rbp)
jmp 0x28324
jmp 0x28244
movq -0x10(%rbp), %rdi
callq 0x28330
movq -0x10(%rbp), %rax
cmpl $0x0, 0x74(%rax)
je 0x28276
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x21db0
cmpl $0x0, %eax
je 0x28274
movq $0x0, -0x8(%rbp)
jmp 0x28324
jmp 0x28276
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x282a5
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jne 0x282a5
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x28324
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x18f40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x282c8
movq $0x0, -0x8(%rbp)
jmp 0x28324
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x28370
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x1a330
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x282f8
movq $0x0, -0x8(%rbp)
jmp 0x28324
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: set_label
static __inline void set_label(struct sljit_label *label, struct sljit_compiler *compiler)
{
	label->next = NULL;
	label->size = compiler->size;
	if (compiler->last_label)
		compiler->last_label->next = label;
	else
		compiler->labels = label;
	compiler->last_label = label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x283b3
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
jmp 0x283bf
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: sljit_emit_jump
struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, int type)
{
	u_char *inst;
	struct sljit_jump *jump;

	CHECK_ERROR_PTR();
	CHECK_PTR(check_sljit_emit_jump(compiler, type));

	if (compiler->flags_saved) {
		if ((type & 0xff) <= SLJIT_JUMP) {
			if (emit_restore_flags(compiler, 0))
				return NULL;
		}
		compiler->flags_saved = 0;
	}

	jump = ensure_abuf(compiler, sizeof(struct sljit_jump));
	PTR_FAIL_IF_NULL(jump);
	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
	type &= 0xff;

	if (type >= SLJIT_CALL1) {
		if (call_with_args(compiler, type))
			return NULL;
	}

	/* Worst case size. */
#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
	compiler->size += (type >= SLJIT_JUMP) ? 5 : 6;
#else
	compiler->size += (type >= SLJIT_JUMP) ? (10 + 3) : (2 + 10 + 3);
#endif

	inst = ensure_buf(compiler, 2);
	PTR_FAIL_IF_NULL(inst);

	*inst++ = 0;
	*inst++ = type + 4;
	return jump;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x283f5
movq $0x0, -0x8(%rbp)
jmp 0x28541
jmp 0x283f7
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x28550
movq -0x10(%rbp), %rax
cmpl $0x0, 0x74(%rax)
je 0x28444
movl -0x14(%rbp), %eax
andl $0xff, %eax
cmpl $0x16, %eax
jg 0x28439
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x21db0
cmpl $0x0, %eax
je 0x28437
movq $0x0, -0x8(%rbp)
jmp 0x28541
jmp 0x28439
movq -0x10(%rbp), %rax
movl $0x0, 0x74(%rax)
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x18f40
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x28474
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x28541
jmp 0x28476
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
andl $0x1000, %edx           # imm = 0x1000
callq 0x28710
movl -0x14(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x14(%rbp)
cmpl $0x19, -0x14(%rbp)
jl 0x284bd
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x28770
cmpl $0x0, %eax
je 0x284bb
movq $0x0, -0x8(%rbp)
jmp 0x28541
jmp 0x284bd
movl -0x14(%rbp), %edx
movl $0xf, %eax
movl $0xd, %ecx
cmpl $0x16, %edx
cmovgel %ecx, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x1a330
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2850c
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x28541
jmp 0x2850e
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movl -0x14(%rbp), %eax
addl $0x4, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/sljit_src/sljitLir.c
// Function: set_jump
static __inline void set_jump(struct sljit_jump *jump, struct sljit_compiler *compiler, int flags)
{
	jump->next = NULL;
	jump->flags = flags;
	if (compiler->last_jump)
		compiler->last_jump->next = jump;
	else
		compiler->jumps = jump;
	compiler->last_jump = jump;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movslq -0x14(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x28752
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
jmp 0x2875e
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax)