LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/rendering.c
// Function: isChunkInsideRenderBoundry
unsigned char 
isChunkInsideRenderBoundry(ChunkBufferData* bData, int x, int y, int z, int bDistance)
{
	x = x / WORLD_CHUNK_SIZE;
	y = y / WORLD_CHUNK_SIZE;
	z = z / WORLD_CHUNK_SIZE;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal 0xf(%rsi), %eax
testl %esi, %esi
cmovnsl %esi, %eax
sarl $0x4, %eax
leal 0xf(%rcx), %esi
testl %ecx, %ecx
cmovnsl %ecx, %esi
sarl $0x4, %esi
movl 0xc(%rdi), %ecx
subl %eax, %ecx
movl 0x14(%rdi), %r9d
movl %ecx, %r10d
negl %r10d
cmovsl %ecx, %r10d
subl %esi, %r9d
movl %r9d, %eax
negl %eax
cmovsl %r9d, %eax
cmpl %r8d, %r10d
jge 0x5b5e
leal 0xf(%rdx), %ecx
testl %edx, %edx
cmovnsl %edx, %ecx
sarl $0x4, %ecx
movl 0x10(%rdi), %edx
subl %ecx, %edx
movl %edx, %ecx
negl %ecx
cmovsl %edx, %ecx
cmpl %r8d, %ecx
jae 0x5b5e
cmpl %r8d, %eax
setb %al
jmp 0x5b60
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/./stb_perlin.h
// Function: stb_perlin_ridge_noise3
float stb_perlin_ridge_noise3(float x, float y, float z, float lacunarity, float gain, float offset, int octaves)
{
   int i;
   float frequency = 1.0f;
   float prev = 1.0f;
   float amplitude = 0.5f;
   float sum = 0.0f;

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

// Assembly:
testl %edi, %edi
jle 0x62eb
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebx
movaps %xmm2, %xmm6
movaps %xmm1, %xmm2
movaps %xmm0, %xmm1
movss 0xe12(%rip), %xmm9      # 0x7018
movss 0x2de1(%rip), %xmm8     # 0x8ff0
xorps %xmm0, %xmm0
xorl %r14d, %r14d
movaps %xmm9, %xmm7
movss %xmm5, -0x2c(%rbp)
movss %xmm4, -0x28(%rbp)
movss %xmm3, -0x24(%rbp)
movss %xmm6, -0x20(%rbp)
movss %xmm2, -0x1c(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm9, -0x30(%rbp)
movss %xmm7, -0x34(%rbp)
movss %xmm8, -0x38(%rbp)
movss %xmm0, -0x14(%rbp)
movaps %xmm7, %xmm0
mulss %xmm1, %xmm0
movaps %xmm7, %xmm1
mulss %xmm2, %xmm1
movaps %xmm7, %xmm2
mulss %xmm6, %xmm2
movzbl %r14b, %ecx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5e48
movss -0x38(%rbp), %xmm8
movss -0x1c(%rbp), %xmm2
movss -0x20(%rbp), %xmm6
movss -0x24(%rbp), %xmm3
movss -0x28(%rbp), %xmm4
movss -0x2c(%rbp), %xmm1
andps 0x2d69(%rip), %xmm0     # 0x9000
subss %xmm0, %xmm1
mulss %xmm1, %xmm1
movaps %xmm8, %xmm0
mulss %xmm1, %xmm0
mulss -0x30(%rbp), %xmm0
movss -0x14(%rbp), %xmm7
addss %xmm0, %xmm7
movss %xmm7, -0x14(%rbp)
movss -0x34(%rbp), %xmm7
movss -0x14(%rbp), %xmm0
mulss %xmm3, %xmm7
mulss %xmm4, %xmm8
incl %r14d
movaps %xmm1, %xmm9
movss -0x18(%rbp), %xmm1
cmpl %r14d, %ebx
jne 0x6237
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/./stb_perlin.h
// Function: stb_perlin_turbulence_noise3
float stb_perlin_turbulence_noise3(float x, float y, float z, float lacunarity, float gain, int octaves)
{
   int i;
   float frequency = 1.0f;
   float amplitude = 1.0f;
   float sum = 0.0f;
   
   for (i = 0; i < octaves; i++) {
      float r = stb_perlin_noise3_internal(x*frequency,y*frequency,z*frequency,0,0,0,(unsigned char)i)*amplitude;
      sum += (float) fabs(r);
      frequency *= lacunarity;
      amplitude *= gain;
   }
   return sum;
}

// Assembly:
testl %edi, %edi
jle 0x649a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
movaps %xmm2, %xmm5
movaps %xmm1, %xmm2
movaps %xmm0, %xmm1
movss 0xc31(%rip), %xmm7      # 0x7018
xorps %xmm0, %xmm0
xorl %r14d, %r14d
movaps %xmm7, %xmm6
movss %xmm4, -0x28(%rbp)
movss %xmm3, -0x24(%rbp)
movss %xmm5, -0x20(%rbp)
movss %xmm2, -0x1c(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm6, -0x2c(%rbp)
movss %xmm7, -0x30(%rbp)
movss %xmm0, -0x14(%rbp)
movaps %xmm6, %xmm0
mulss %xmm1, %xmm0
movaps %xmm6, %xmm1
mulss %xmm2, %xmm1
movaps %xmm6, %xmm2
mulss %xmm5, %xmm2
movzbl %r14b, %ecx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5e48
movss -0x30(%rbp), %xmm7
movss -0x18(%rbp), %xmm1
movss -0x1c(%rbp), %xmm2
movss -0x20(%rbp), %xmm5
movss -0x24(%rbp), %xmm3
movss -0x28(%rbp), %xmm4
mulss %xmm7, %xmm0
andps 0x2b9b(%rip), %xmm0     # 0x9000
movss -0x14(%rbp), %xmm6
addss %xmm0, %xmm6
movss %xmm6, -0x14(%rbp)
movss -0x2c(%rbp), %xmm6
movss -0x14(%rbp), %xmm0
mulss %xmm3, %xmm6
mulss %xmm4, %xmm7
incl %r14d
cmpl %r14d, %ebx
jne 0x6409
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/world.c
// Function: createWorld
void
createWorld(unsigned int w, unsigned int h, unsigned int d)
{
	world.width  = w;
	world.height = h;
	world.depth  = d;
	world.seed    = getTimeNanoseconds();
	
	world.cachedChunks = malloc(sizeof(WorldChunk) * w * h * d);
	
	for(unsigned int i = 0; i < w * h * d; i++) {
		unsigned int x = i % w;
		unsigned int y = (i / w) % h;
		unsigned int z = i / (w * h);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movl %esi, %ebx
movl %edi, %r14d
movl %edi, 0x76b1(%rip)      # 0xdf80
movl %esi, 0x76af(%rip)      # 0xdf84
movl %edx, 0x76ad(%rip)      # 0xdf88
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x4c2d
movq %rax, 0x76a4(%rip)      # 0xdf90
movl %r14d, %eax
movl %ebx, %ecx
imulq %rax, %rcx
movl %r12d, %eax
imulq %rcx, %rax
imulq $0x4010, %rax, %rdi     # imm = 0x4010
callq 0x2110
movq %rax, 0x7689(%rip)      # 0xdf98
movl %ebx, %r13d
imull %r14d, %r13d
imull %r13d, %r12d
testl %r12d, %r12d
je 0x698b
movl %ebx, %ecx
movl %r12d, %eax
imulq $0x4010, %rax, %rax     # imm = 0x4010
movq %rax, -0x30(%rbp)
xorl %ebx, %ebx
movl %r15d, %eax
xorl %edx, %edx
divl %r14d
movl %edx, %esi
xorl %edx, %edx
divl %ecx
movl %r14d, %r12d
movl %ecx, %r14d
movl %edx, %ecx
movl %r15d, %eax
xorl %edx, %edx
divl %r13d
movq 0x7642(%rip), %rdx      # 0xdf98
leaq (%rdx,%rbx), %rdi
movl %esi, (%rdx,%rbx)
movl %ecx, 0x4(%rdx,%rbx)
movl %eax, 0x8(%rdx,%rbx)
movl 0x7624(%rip), %r8d      # 0xdf90
movl %ecx, %edx
movl %eax, %ecx
callq 0x699a
movl %r14d, %ecx
movl %r12d, %r14d
addq $0x4010, %rbx           # imm = 0x4010
incl %r15d
cmpq %rbx, -0x30(%rbp)
jne 0x6931
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/world.c
// Function: generateChunk
void
generateChunk(WorldChunk *chunk, unsigned int xc, unsigned int yc, unsigned int zc, unsigned int seed)
{
	for(int i = 0; i < WORLD_CHUNK_NBLOCKS; i++) {
		int xb = (i % WORLD_CHUNK_SIZE);
		int yb = (i / WORLD_CHUNK_SIZE) % WORLD_CHUNK_SIZE;
		int zb = (i / (WORLD_CHUNK_SIZE * WORLD_CHUNK_SIZE));

		float height = stb_perlin_noise3_seed((float)(xb + xc * WORLD_CHUNK_SIZE) / WORLD_CHUNK_SIZE, 
				0, 
				(float)(zb + zc * WORLD_CHUNK_SIZE) / WORLD_CHUNK_SIZE,
				0, 0, 0, seed) * 4.0 + 16;

		int heightInt = floor(height * height) / 16;

		if(yb + yc * WORLD_CHUNK_SIZE == heightInt) 
			chunk->blocks[xb][yb][zb] = 1;
		else if(yb + yc * WORLD_CHUNK_SIZE > heightInt - 4 && yb + yc * WORLD_CHUNK_SIZE < heightInt)
			chunk->blocks[xb][yb][zb] = 2;
		else if(yb + yc * WORLD_CHUNK_SIZE <= heightInt - 4)
			chunk->blocks[xb][yb][zb] = 3;
		else
			chunk->blocks[xb][yb][zb] = 0;

		if (yb + yc * WORLD_CHUNK_SIZE <= heightInt) {
			chunk->numBlocks++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
shll $0x4, %esi
movl %esi, -0x2c(%rbp)
shll $0x4, %ecx
movq %rcx, -0x48(%rbp)
shll $0x4, %edx
movl %edx, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
leaq 0xc(%rdi), %rax
movq %rax, -0x38(%rbp)
xorl %r12d, %r12d
movzbl %r8b, %r13d
movl %r12d, %r14d
andl $0xf, %r14d
movl %r12d, %ebx
shrl $0x4, %ebx
andl $0xf, %ebx
movl %r14d, %eax
orl -0x2c(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
movl %r12d, %r15d
shrl $0x8, %r15d
movss 0x25f6(%rip), %xmm1     # 0x8ff4
mulss %xmm1, %xmm0
movq -0x48(%rbp), %rax
addl %r15d, %eax
xorps %xmm2, %xmm2
cvtsi2ss %rax, %xmm2
mulss %xmm1, %xmm2
xorps %xmm1, %xmm1
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
movl %r13d, %ecx
callq 0x5e48
cvtss2sd %xmm0, %xmm0
mulsd 0x25de(%rip), %xmm0     # 0x9010
addsd 0x25de(%rip), %xmm0     # 0x9018
cvtsd2ss %xmm0, %xmm0
mulss %xmm0, %xmm0
callq 0x21e0
cvtss2sd %xmm0, %xmm0
mulsd 0x25cd(%rip), %xmm0     # 0x9020
cvttsd2si %xmm0, %eax
movl %ebx, %ecx
orl -0x30(%rbp), %ecx
movl %r15d, %edx
cmpl %eax, %ecx
jne 0x6a7a
shll $0xa, %r14d
addq -0x38(%rbp), %r14
shll $0x6, %ebx
addq %r14, %rbx
movl $0x1, (%rbx,%rdx,4)
jmp 0x6ab1
leal -0x4(%rax), %esi
shll $0xa, %r14d
addq -0x38(%rbp), %r14
shll $0x6, %ebx
addq %r14, %rbx
leaq (%rbx,%rdx,4), %rdx
cmpl %eax, %ecx
jae 0x6a9f
cmpl %esi, %ecx
jbe 0x6a9f
movl $0x2, (%rdx)
jmp 0x6ab1
cmpl %esi, %ecx
jbe 0x6aab
movl $0x0, (%rdx)
jmp 0x6ab1
movl $0x3, (%rdx)
cmpl %eax, %ecx
ja 0x6abf
movq -0x40(%rbp), %rax
incl 0x400c(%rax)
incl %r12d
cmpl $0x1000, %r12d          # imm = 0x1000
jne 0x69d1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/aabb.c
// Function: checkCollision
AABBCollisionBit
checkCollision(const AABBCollisor *a, const AABBCollisor *b)
{
	AABBCollisionBit xState = a->x + a->w >= b->x && b->x + b->w >= a->x;
	AABBCollisionBit yState = a->y + a->h >= b->y && b->y + b->h >= a->y;
	AABBCollisionBit zState = a->z + a->d >= b->z && b->z + b->d >= a->z;

	return xState && yState && zState;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss (%rdi), %xmm0
movss 0xc(%rdi), %xmm2
addss %xmm0, %xmm2
movss (%rsi), %xmm1
ucomiss %xmm1, %xmm2
jae 0x6bea
xorl %ecx, %ecx
jmp 0x6bf5
addss 0xc(%rsi), %xmm1
ucomiss %xmm0, %xmm1
setae %cl
movss 0x4(%rdi), %xmm0
movss 0x10(%rdi), %xmm2
addss %xmm0, %xmm2
movss 0x4(%rsi), %xmm1
ucomiss %xmm1, %xmm2
jae 0x6c11
xorl %edx, %edx
jmp 0x6c1c
addss 0x10(%rsi), %xmm1
ucomiss %xmm0, %xmm1
setae %dl
movss 0x8(%rdi), %xmm0
movss 0x14(%rdi), %xmm2
addss %xmm0, %xmm2
movss 0x8(%rsi), %xmm1
xorl %eax, %eax
ucomiss %xmm1, %xmm2
movl $0x0, %edi
jb 0x6c47
addss 0x14(%rsi), %xmm1
ucomiss %xmm0, %xmm1
setae %dil
movzbl %dil, %esi
testb %dl, %cl
cmovnel %esi, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/k0n10pl4tr[P]minimal_crafter/aabb.c
// Function: checkCollisionWorld
AABBCollisionBit
checkCollisionWorld(const AABBCollisor* a)
{
	int xInt = (int)a->x;
	int yInt = (int)a->y;
	int zInt = (int)a->z;
	
	int wInt = (int)a->w;
	int hInt = (int)a->h;
	int dInt = (int)a->d;

	union {
		struct {
			unsigned int topLeftBackBlock;   
			unsigned int topRightBackBlock;
			unsigned int topLeftFrontBlock;    
			unsigned int topRightFrontBlock;   
			unsigned int bottomLeftBackBlock;  
			unsigned int bottomRightBackBlock; 
			unsigned int bottomLeftFrontBlock;
			unsigned int bottomRightFrontBlock;
		};
		unsigned int data[8];
	} blocks;

	blocks.topLeftBackBlock      = getWorldBlock(xInt, yInt + hInt, zInt);
	blocks.topRightBackBlock     = getWorldBlock(xInt + wInt, yInt + hInt, zInt);
	blocks.topLeftFrontBlock     = getWorldBlock(xInt, yInt + hInt, zInt + dInt);
	blocks.topRightFrontBlock    = getWorldBlock(xInt + wInt, yInt + hInt, zInt + dInt);
	blocks.bottomLeftBackBlock   = getWorldBlock(xInt, yInt, zInt);
	blocks.bottomRightBackBlock  = getWorldBlock(xInt + wInt, yInt, zInt);
	blocks.bottomLeftFrontBlock  = getWorldBlock(xInt, yInt, zInt + dInt);
	blocks.bottomRightFrontBlock = getWorldBlock(xInt + wInt, yInt, zInt + dInt);

	for(unsigned int i = 0; i < 8; i++) {
		if(blocks.data[i] != 0)
			return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cvttss2si (%rdi), %r12d
cvttss2si 0x4(%rdi), %eax
movl %eax, -0x2c(%rbp)
cvttss2si 0x8(%rdi), %r13d
cvttss2si 0xc(%rdi), %r14d
cvttss2si 0x10(%rdi), %ebx
cvttss2si 0x14(%rdi), %r15d
addl %eax, %ebx
movl %r12d, %edi
movl %ebx, %esi
movl %r13d, %edx
callq 0x6b38
movl %eax, -0x4c(%rbp)
addl %r12d, %r14d
movl %r14d, %edi
movl %ebx, %esi
movl %r13d, %edx
callq 0x6b38
movl %eax, -0x48(%rbp)
addl %r13d, %r15d
movl %r12d, %edi
movl %ebx, %esi
movl %r15d, %edx
callq 0x6b38
movl %eax, -0x44(%rbp)
movl %r14d, %edi
movl %ebx, %esi
movl %r15d, %edx
callq 0x6b38
movl %eax, -0x40(%rbp)
movl %r12d, %edi
movl -0x2c(%rbp), %ebx
movl %ebx, %esi
movl %r13d, %edx
callq 0x6b38
movl %eax, -0x3c(%rbp)
movl %r14d, %edi
movl %ebx, %esi
movl %r13d, %edx
callq 0x6b38
movl %eax, -0x38(%rbp)
movl %r12d, %edi
movl %ebx, %esi
movl %r15d, %edx
callq 0x6b38
movl %eax, -0x34(%rbp)
movl %r14d, %edi
movl %ebx, %esi
movl %r15d, %edx
callq 0x6b38
movl %eax, -0x30(%rbp)
movb $0x1, %al
cmpl $0x0, -0x4c(%rbp)
jne 0x6d37
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x7, %rcx
je 0x6d30
leaq 0x1(%rax), %rcx
cmpl $0x0, -0x48(%rbp,%rax,4)
je 0x6d1c
cmpq $0x7, %rax
setb %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.4/primes.c
// Function: compute_prime
void* compute_prime (void* arg)
{
	int candidate = 2;
	int n = *((int*) arg);
	while (1) {
		int factor;
		int is_prime = 1;
		/* Test primality by successive division. */
		for (factor = 2; factor < candidate; ++factor)
			if (candidate % factor == 0) {
				is_prime = 0;
				break;
			}
			/* Is this the prime number we’re looking for? */
		if (is_prime) {
			if (--n == 0) //retornar el numero primo deseado como el return del thread
				return (void*) candidate;
		}
		++candidate;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %esi
movl $0x2, %ecx
xorl %edi, %edi
cmpl $0x3, %ecx
jb 0x1192
movl $0x2, %r8d
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
testl %edx, %edx
je 0x1196
leal (%rdi,%r8), %eax
incl %eax
movl %r8d, %edx
incl %edx
movl %edx, %r8d
cmpl $0x2, %eax
jne 0x1174
decl %esi
je 0x119c
incl %ecx
decl %edi
jmp 0x1169
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.4/primes.c
// Function: main
int main ()
{
	pthread_t thread;
	int which_prime = 100, n = 30, i;
	int prime;
	/* Start the computing thread, up to the 5,000th prime number. */
	pthread_create (&thread, NULL, &compute_prime, &which_prime);
	/* Do some other work here... */
  //Hacer otro trabajo mientras el otro hilo realiza el suyo
  //Por ejemplo calcular el fibonacci de un numero
	int fibonacci[n + 1];
  //Definicion de los caso base
	fibonacci[1] = 1;
	fibonacci[2] = 1;
  //calculo del enesimo fibonacci en este caso 100
	for(i = 3; i <= n; ++i){
		fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq -0x14(%rbp), %rcx
movl $0x64, (%rcx)
leaq -0x63(%rip), %rdx       # 0x115c
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x1040
movq %rsp, %r14
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, -0x9c(%rbp)
movl $0x3, %eax
movl $0x1, %ecx
addl -0xa8(%rbp,%rax,4), %ecx
movl %ecx, -0xa0(%rbp,%rax,4)
incq %rax
cmpq $0x1f, %rax
jne 0x11e8
movl -0x28(%rbp), %edx
leaq 0xdfb(%rip), %rdi       # 0x2004
movl $0x1e, %esi
xorl %eax, %eax
callq 0x1030
movq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rbx
movq %rbx, %rsi
callq 0x1050
movl -0x14(%rbp), %esi
movl (%rbx), %edx
leaq 0xdec(%rip), %rdi       # 0x201d
xorl %eax, %eax
callq 0x1030
movq %r14, %rsp
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/test_src/sljitMain.c
// Function: devel
void devel(void)
{
	executable_code code;
	struct sljit_compiler *compiler;
	long buf[4] = {5, 12, 0, 0};

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

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

	sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);

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

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movaps 0x1ddc6(%rip), %xmm0    # 0x20020
movaps %xmm0, 0x10(%rsp)
movaps 0x1ddaa(%rip), %xmm0    # 0x20010
movaps %xmm0, (%rsp)
callq 0x147c6
testq %rax, %rax
je 0x235d
movq %rax, %r14
movq 0x25d5e(%rip), %rax     # 0x27fe0
movq (%rax), %rsi
movq %r14, %rdi
callq 0x149b1
movq %r14, %rdi
xorl %esi, %esi
movl $0x1, %edx
movl $0x4, %ecx
movl $0x5, %r8d
movl $0x4, %r9d
pushq $0x10
pushq $0x0
callq 0x14e64
addq $0x10, %rsp
movq %r14, %rdi
movl $0x20, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x15470
movq %r14, %rdi
callq 0x149be
movq %rax, %rbx
movq %r14, %rdi
callq 0x148ac
leaq 0x1dd5b(%rip), %rdi     # 0x2003e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2080
movq %rsp, %r14
movq %r14, %rdi
callq *%rbx
leaq 0x1dd4f(%rip), %rdi     # 0x2004b
movq %rax, %rsi
xorl %eax, %eax
callq 0x2080
movq (%r14), %rsi
leaq 0x1dd57(%rip), %rdi     # 0x20067
xorl %eax, %eax
callq 0x2080
movq 0x8(%r14), %rsi
leaq 0x1dd53(%rip), %rdi     # 0x20075
xorl %eax, %eax
callq 0x2080
movq 0x10(%r14), %rsi
leaq 0x1dd4f(%rip), %rdi     # 0x20083
xorl %eax, %eax
callq 0x2080
movq 0x18(%r14), %rsi
leaq 0x1dd4b(%rip), %rdi     # 0x20091
xorl %eax, %eax
callq 0x2080
movq %rbx, %rdi
callq 0x148f4
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1dccc(%rip), %rsi     # 0x20030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x2070
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/test_src/sljitTest.c
// Function: cond_set
static void cond_set(struct sljit_compiler *compiler, int dst, long dstw, int type)
{
	/* Testing both sljit_emit_op_flags and sljit_emit_jump. */
	struct sljit_jump* jump;
	struct sljit_label* label;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
subq $0x8, %rsp
movl $0x20, %esi
movl %ebp, %edx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r14
callq 0x1d7f1
addq $0x10, %rsp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1d10b
movq %rax, %r14
movq %rbx, %rdi
movl $0x4060, %esi           # imm = 0x4060
movl %ebp, %edx
movq %r15, %rcx
movl %ebp, %r8d
movq %r15, %r9
pushq $0x2
pushq $0x40
callq 0x1804b
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x1d01e
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x148f9
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/test_src/sljitTest.c
// Function: cmp_test
static int cmp_test(struct sljit_compiler *compiler, int type, int src1, long src1w, int src2, long src2w)
{
	/* 2 = true, 1 = false */
	struct sljit_jump* jump;
	struct sljit_label* label;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, %ebp
movq %rcx, %r15
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
movl $0x1, %ecx
movl $0x2, %r9d
movl $0x29, %esi
movl $0x8c, %edx
movl $0x40, %r8d
callq 0x16c8b
testl %eax, %eax
je 0x14237
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
movq %r15, %rcx
movl %ebp, %r8d
movq %r14, %r9
callq 0x1e7f2
testq %rax, %rax
je 0x14228
movq %rax, %r14
movl $0x1, %r9d
movq %rbx, %rdi
movl $0x21, %esi
movl $0x8c, %edx
xorl %ecx, %ecx
movl $0x40, %r8d
callq 0x16c8b
testl %eax, %eax
jne 0x14228
movq %rbx, %rdi
callq 0x1d01e
testq %rax, %rax
je 0x14228
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x148f9
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0x13a50(%rip), %rdi     # 0x28148
callq 0x2140
movq 0x13a1c(%rip), %rbx     # 0x28120
testq %rbx, %rbx
je 0x14796
leaq 0x13a0c(%rip), %r14     # 0x28120
movq %rbx, %rdi
movq 0x10(%rbx), %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x14764
movq 0x20(%rdi), %rsi
cmpq $0x1, (%rdi,%rsi)
jne 0x14764
subq %rsi, 0x139fc(%rip)     # 0x28130
movq 0x18(%rdi), %rax
testq %rbx, %rbx
je 0x14741
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x1474c
addq $0x10, %rax
jmp 0x14758
movq %r14, %rax
cmpq %rdi, 0x139ca(%rip)     # 0x28120
jne 0x147ae
movq %rbx, (%rax)
addq $0x10, %rsi
callq 0x20f0
testq %rbx, %rbx
jne 0x14714
cmpq $0x0, 0x139af(%rip)     # 0x28120
setne %al
cmpq $0x0, 0x139b4(%rip)     # 0x28130
setne %cl
cmpb %al, %cl
jne 0x147a0
leaq 0x139be(%rip), %rdi     # 0x28148
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
cmpq $0x0, 0x13992(%rip)     # 0x28130
je 0x14783
leaq 0xeacb(%rip), %rdi      # 0x23272
movl $0x136, %esi            # imm = 0x136
jmp 0x147ba
leaq 0xeabd(%rip), %rdi      # 0x23272
movl $0xaa, %esi
xorl %eax, %eax
callq 0x2080
callq 0x2040
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x148cc
movq (%rdi), %r14
callq 0x2030
movq %r14, %rdi
testq %r14, %r14
jne 0x148bc
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x148e5
movq (%rdi), %r14
callq 0x2030
movq %r14, %rdi
testq %r14, %r14
jne 0x148d5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x1491c
movq 0x10(%rdi), %rax
andq $-0x4, %rax
incq %rax
movq %rax, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x14936
movq 0x10(%rdi), %rax
andq $-0x4, %rax
orq $0x2, %rax
movq %rax, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq 0x40(%rdi), %r15
movq 0x8(%r15), %rax
leaq (%rax,%rsi), %rcx
cmpq $0xff0, %rcx            # imm = 0xFF0
ja 0x1497c
addq %r15, %rax
addq $0x10, %rax
movq %rcx, 0x8(%r15)
jmp 0x149ab
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1000, %edi           # imm = 0x1000
callq 0x20e0
testq %rax, %rax
je 0x149a2
movq %r15, (%rax)
movq %rax, 0x40(%r14)
movq %rbx, 0x8(%rax)
addq $0x10, %rax
jmp 0x149ab
movl $0x2, (%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x15, %edx
jg 0x14e1d
movl %ebp, %edi
xorl $0x1, %edi
callq 0x1e02b
addb $-0x10, %al
movb %al, (%rbx)
movb $0xd, 0x1(%rbx)
addq $0x2, %rbx
movw $0xb949, (%rbx)         # imm = 0xB949
leaq 0x2(%rbx), %rax
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rcx
testb $0x1, %cl
jne 0x14e3c
movq 0x18(%r14), %rcx
movq %rcx, (%rax)
jmp 0x14e44
orq $0x10, %rcx
movq %rcx, 0x10(%r14)
movw $0xff41, 0xa(%rbx)      # imm = 0xFF41
cmpl $0x17, %ebp
setl %al
shlb $0x4, %al
addb $-0x2f, %al
movb %al, 0xc(%rbx)
addq $0xd, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
cmpq $0x101, %rsi            # imm = 0x101
jae 0x1527d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %r15
movq 0x8(%r15), %rax
leaq (%rax,%rsi), %rcx
cmpq $0xff0, %rcx            # imm = 0xFF0
ja 0x1524e
addq %r15, %rax
addq $0x10, %rax
movq %rcx, 0x8(%r15)
jmp 0x15277
movl $0x1000, %edi           # imm = 0x1000
callq 0x20e0
testq %rax, %rax
je 0x1526e
movq %r15, (%rax)
movq %rax, 0x38(%r14)
movq %rbx, 0x8(%rax)
addq $0x10, %rax
jmp 0x15277
movl $0x2, (%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xe0bb(%rip), %rdi      # 0x2333f
movl $0x1d7, %esi            # imm = 0x1D7
xorl %eax, %eax
callq 0x2080
callq 0x2040
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %ebx
testl %ebx, %ebx
jne 0x153c9
movl %r9d, %r13d
movl %r8d, %r15d
movl %ecx, %r12d
movl %esi, %ebp
movq %rdi, %r14
movl 0x48(%rsp), %r10d
movl 0x40(%rsp), %r11d
cmpl $0x0, 0x84(%rdi)
je 0x152db
movl $0x0, 0x84(%r14)
jmp 0x15377
cmpl $0x2, %ebp
jae 0x153da
cmpl $0x4, %edx
jae 0x153e8
cmpl $0xd, %r12d
jae 0x153f6
cmpl $0xd, %r15d
jae 0x15404
leal (%r15,%r12), %eax
cmpl $0xd, %eax
jae 0x15412
cmpl %r15d, %edx
ja 0x15420
cmpl $0x7, %r13d
jae 0x1542e
cmpl $0x7, %r11d
jae 0x1543c
leal (%r11,%r13), %eax
cmpl $0x7, %eax
jae 0x1544a
cmpl $0x10001, %r10d         # imm = 0x10001
jae 0x15458
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0x15377
leaq 0xe073(%rip), %rsi      # 0x233c8
movl %r12d, %ecx
movl %r15d, %r8d
movl %r13d, %r9d
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x20c0
movl 0x50(%rsp), %r11d
movl 0x58(%rsp), %r10d
addq $0x10, %rsp
movl %ebp, 0x4(%r14)
movl %r12d, 0x48(%r14)
movl %r15d, 0x4c(%r14)
movl %r13d, 0x50(%r14)
movl %r11d, 0x54(%r14)
movl %r10d, 0x80(%r14)
leal 0x1ffffffa(%r12), %eax
xorl %ecx, %ecx
cmpl $0x6, %r12d
cmovgel %eax, %ecx
cmpl $0x6, %r15d
movl $0x6, %eax
cmovll %r15d, %eax
addl %ecx, %eax
leal 0x8(,%rax,8), %ecx
leal (%r10,%rax,8), %eax
addl $0x1f, %eax
andl $-0x10, %eax
subl %ecx, %eax
movl %eax, 0x58(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdf5e(%rip), %rdi      # 0x2333f
movl $0x3ab, %esi            # imm = 0x3AB
jmp 0x15464
leaq 0xdf50(%rip), %rdi      # 0x2333f
movl $0x3ac, %esi            # imm = 0x3AC
jmp 0x15464
leaq 0xdf42(%rip), %rdi      # 0x2333f
movl $0x3ad, %esi            # imm = 0x3AD
jmp 0x15464
leaq 0xdf34(%rip), %rdi      # 0x2333f
movl $0x3ae, %esi            # imm = 0x3AE
jmp 0x15464
leaq 0xdf26(%rip), %rdi      # 0x2333f
movl $0x3af, %esi            # imm = 0x3AF
jmp 0x15464
leaq 0xdf18(%rip), %rdi      # 0x2333f
movl $0x3b0, %esi            # imm = 0x3B0
jmp 0x15464
leaq 0xdf0a(%rip), %rdi      # 0x2333f
movl $0x3b1, %esi            # imm = 0x3B1
jmp 0x15464
leaq 0xdefc(%rip), %rdi      # 0x2333f
movl $0x3b2, %esi            # imm = 0x3B2
jmp 0x15464
leaq 0xdeee(%rip), %rdi      # 0x2333f
movl $0x3b3, %esi            # imm = 0x3B3
jmp 0x15464
leaq 0xdee0(%rip), %rdi      # 0x2333f
movl $0x3b4, %esi            # imm = 0x3B4
xorl %eax, %eax
callq 0x2080
callq 0x2040
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0xb, %esi
callq 0x15218
testq %rax, %rax
je 0x16892
movb $0xa, (%rax)
addq $0xa, 0x60(%r14)
movslq %ebp, %rcx
leaq 0xc967(%rip), %rdx      # 0x231d0
movl $0xf10f, %esi           # imm = 0xF10F
btq %rcx, %rsi
setb %sil
xorb $0x49, %sil
movb %sil, 0x1(%rax)
movb (%rcx,%rdx), %cl
andb $0x7, %cl
orb $-0x48, %cl
movb %cl, 0x2(%rax)
movq %rbx, 0x3(%rax)
xorl %eax, %eax
jmp 0x16895
movl (%r14), %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: emit_mov_half
static int emit_mov_half(struct sljit_compiler *compiler, int sign,
	int dst, long dstw,
	int src, long srcw)
{
	u_char* inst;
	int dst_r;

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

	if (dst == SLJIT_UNUSED && !(src & SLJIT_MEM))
		return SLJIT_SUCCESS; /* Empty instruction. */

	if (src & SLJIT_IMM) {
		if (FAST_IS_REG(dst)) {
#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
			return emit_do_imm(compiler, MOV_r_i32 + reg_map[dst], srcw);
#else
			inst = emit_x86_instruction(compiler, 1, SLJIT_IMM, srcw, dst, 0);
			FAIL_IF(!inst);
			*inst = MOV_rm_i32;
			return SLJIT_SUCCESS;
#endif
		}
		inst = emit_x86_instruction(compiler, 1 | EX86_HALF_ARG | EX86_NO_REXW | EX86_PREF_66, SLJIT_IMM, srcw, dst, dstw);
		FAIL_IF(!inst);
		*inst = MOV_rm_i32;
		return SLJIT_SUCCESS;
	}

	dst_r = FAST_IS_REG(dst) ? dst : TMP_REG1;

	if ((dst & SLJIT_MEM) && FAST_IS_REG(src))
		dst_r = src;
	else {
		inst = emit_x86_instruction(compiler, 2, dst_r, 0, src, srcw);
		FAIL_IF(!inst);
		*inst++ = GROUP_0F;
		*inst = sign ? MOVSX_r_rm16 : MOVZX_r_rm16;
	}

	if (dst & SLJIT_MEM) {
		inst = emit_x86_instruction(compiler, 1 | EX86_NO_REXW | EX86_PREF_66, dst_r, 0, dst, dstw);
		FAIL_IF(!inst);
		*inst = MOV_rm_r;
	}

	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x0, 0x70(%rdi)
movl %r8d, %eax
andl $0x80, %eax
xorl %r14d, %r14d
orl %edx, %eax
je 0x17d82
movq %rcx, %r15
movl %edx, %ebp
movq %rdi, %rbx
testb $0x40, %r8b
jne 0x17ce1
cmpl $0x40, %ebp
movl $0xe, %r12d
cmovll %ebp, %r12d
testb %bpl, %bpl
sets %al
cmpl $0x40, %r8d
setl %cl
testb %cl, %al
je 0x17d01
movl %r8d, %r12d
jmp 0x17d35
cmpl $0x3f, %ebp
jg 0x17d5a
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movl $0x40, %edx
movq %r9, %rcx
movl %ebp, %r8d
xorl %r9d, %r9d
jmp 0x17d70
movl %esi, %r13d
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x15da2
testq %rax, %rax
je 0x17d7f
testl %r13d, %r13d
setne %cl
shlb $0x3, %cl
orb $-0x49, %cl
movb $0xf, (%rax)
movb %cl, 0x1(%rax)
testb %bpl, %bpl
jns 0x17d82
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x481, %esi            # imm = 0x481
movl %r12d, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
movq %r15, %r9
callq 0x15da2
testq %rax, %rax
je 0x17d7f
movb $-0x77, (%rax)
jmp 0x17d82
movq %rbx, %rdi
movl $0x681, %esi            # imm = 0x681
movl $0x40, %edx
movq %r9, %rcx
movl %ebp, %r8d
movq %r15, %r9
callq 0x15da2
testq %rax, %rax
je 0x17d7f
movb $-0x39, (%rax)
jmp 0x17d82
movl (%rbx), %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/sljit_src/sljitNativeX86_64.c
// Function: emit_mov_int
static int emit_mov_int(struct sljit_compiler *compiler, int sign,
	int dst, long dstw,
	int src, long srcw)
{
	u_char* inst;
	int dst_r;

	compiler->mode32 = 0;

	if (dst == SLJIT_UNUSED && !(src & SLJIT_MEM))
		return SLJIT_SUCCESS; /* Empty instruction. */

	if (src & SLJIT_IMM) {
		if (FAST_IS_REG(dst)) {
			if (sign || ((unsigned long)srcw <= 0x7fffffff)) {
				inst = emit_x86_instruction(compiler, 1, SLJIT_IMM, (long)(int)srcw, dst, dstw);
				FAIL_IF(!inst);
				*inst = MOV_rm_i32;
				return SLJIT_SUCCESS;
			}
			return emit_load_imm64(compiler, dst, srcw);
		}
		compiler->mode32 = 1;
		inst = emit_x86_instruction(compiler, 1, SLJIT_IMM, (long)(int)srcw, dst, dstw);
		FAIL_IF(!inst);
		*inst = MOV_rm_i32;
		compiler->mode32 = 0;
		return SLJIT_SUCCESS;
	}

	dst_r = FAST_IS_REG(dst) ? dst : TMP_REG1;

	if ((dst & SLJIT_MEM) && FAST_IS_REG(src))
		dst_r = src;
	else {
		if (sign) {
			inst = emit_x86_instruction(compiler, 1, dst_r, 0, src, srcw);
			FAIL_IF(!inst);
			*inst++ = MOVSXD_r_rm;
		} else {
			compiler->mode32 = 1;
			FAIL_IF(emit_mov(compiler, dst_r, 0, src, srcw));
			compiler->mode32 = 0;
		}
	}

	if (dst & SLJIT_MEM) {
		compiler->mode32 = 1;
		inst = emit_x86_instruction(compiler, 1, dst_r, 0, dst, dstw);
		FAIL_IF(!inst);
		*inst = MOV_rm_r;
		compiler->mode32 = 0;
	}

	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x0, 0x70(%rdi)
movl %r8d, %eax
andl $0x80, %eax
xorl %ebx, %ebx
orl %edx, %eax
je 0x17ef6
movq %rcx, %r15
movl %edx, %ebp
movq %rdi, %r14
testb $0x40, %r8b
jne 0x17de9
cmpl $0x40, %ebp
movl $0xe, %r12d
cmovll %ebp, %r12d
testb %bpl, %bpl
sets %al
cmpl $0x40, %r8d
setl %cl
testb %cl, %al
je 0x17e2d
movl %r8d, %r12d
jmp 0x17ebf
cmpl $0x3f, %ebp
jg 0x17e51
testl %esi, %esi
sete %al
cmpq $0x7fffffff, %r9        # imm = 0x7FFFFFFF
seta %cl
testb %cl, %al
jne 0x17e7e
movslq %r9d, %rcx
movq %r14, %rdi
movl $0x1, %esi
movl $0x40, %edx
movl %ebp, %r8d
movq %r15, %r9
callq 0x15da2
testq %rax, %rax
je 0x17ef3
movb $-0x39, (%rax)
jmp 0x17ef6
testl %esi, %esi
je 0x17e93
movq %r14, %rdi
movl $0x1, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x15da2
testq %rax, %rax
je 0x17ef3
movb $0x63, (%rax)
jmp 0x17eba
movl $0x1, 0x70(%r14)
movslq %r9d, %rcx
movq %r14, %rdi
movl $0x1, %esi
movl $0x40, %edx
movl %ebp, %r8d
movq %r15, %r9
callq 0x15da2
testq %rax, %rax
je 0x17ef3
movb $-0x39, (%rax)
jmp 0x17ee9
movq %r14, %rdi
movl %ebp, %esi
movq %r9, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1683c
movl $0x1, 0x70(%r14)
movq %r14, %rdi
movl %r12d, %esi
xorl %edx, %edx
movl %r8d, %ecx
movq %r9, %r8
callq 0x16ad7
testl %eax, %eax
jne 0x17ef3
movl $0x0, 0x70(%r14)
testb %bpl, %bpl
jns 0x17ef6
movl $0x1, 0x70(%r14)
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x1, %esi
movl %r12d, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
movq %r15, %r9
callq 0x15da2
testq %rax, %rax
je 0x17ef3
movb $-0x77, (%rax)
movl $0x0, 0x70(%r14)
jmp 0x17ef6
movl (%r14), %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: emit_unary
static int emit_unary(struct sljit_compiler *compiler, u_char opcode,
	int dst, long dstw,
	int src, long srcw)
{
	u_char* inst;

	if (dst == SLJIT_UNUSED) {
		EMIT_MOV(compiler, TMP_REG1, 0, src, srcw);
		inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REG1, 0);
		FAIL_IF(!inst);
		*inst++ = GROUP_F7;
		*inst |= opcode;
		return SLJIT_SUCCESS;
	}
	if (dst == src && dstw == srcw) {
		/* Same input and output */
		inst = emit_x86_instruction(compiler, 1, 0, 0, dst, dstw);
		FAIL_IF(!inst);
		*inst++ = GROUP_F7;
		*inst |= opcode;
		return SLJIT_SUCCESS;
	}
	if (FAST_IS_REG(dst)) {
		EMIT_MOV(compiler, dst, 0, src, srcw);
		inst = emit_x86_instruction(compiler, 1, 0, 0, dst, dstw);
		FAIL_IF(!inst);
		*inst++ = GROUP_F7;
		*inst |= opcode;
		return SLJIT_SUCCESS;
	}
	EMIT_MOV(compiler, TMP_REG1, 0, src, srcw);
	inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REG1, 0);
	FAIL_IF(!inst);
	*inst++ = GROUP_F7;
	*inst |= opcode;
	EMIT_MOV(compiler, dst, dstw, TMP_REG1, 0);
	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
testl %edx, %edx
je 0x17f3f
movq %rcx, %r15
movl %edx, %r12d
cmpl %r8d, %edx
setne %al
cmpq %r9, %rcx
setne %cl
orb %al, %cl
jne 0x17f83
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl %r12d, %r8d
movq %r15, %r9
jmp 0x17f70
movq %rbx, %rdi
movl $0xe, %esi
xorl %edx, %edx
movl %r8d, %ecx
movq %r9, %r8
callq 0x16ad7
testl %eax, %eax
jne 0x17fb8
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0xe, %r8d
xorl %r9d, %r9d
callq 0x15da2
testq %rax, %rax
je 0x17fb8
movb $-0x9, (%rax)
orb %bpl, 0x1(%rax)
jmp 0x17fbb
movq %rbx, %rdi
cmpl $0x3f, %r12d
jg 0x17fa2
movl %r12d, %esi
xorl %edx, %edx
movl %r8d, %ecx
movq %r9, %r8
callq 0x16ad7
testl %eax, %eax
jne 0x17fb8
jmp 0x17f28
movl $0xe, %esi
xorl %edx, %edx
movl %r8d, %ecx
movq %r9, %r8
callq 0x16ad7
testl %eax, %eax
je 0x17fc7
movl (%rbx), %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0xe, %r8d
xorl %r9d, %r9d
callq 0x15da2
testq %rax, %rax
je 0x17fb8
movb $-0x9, (%rax)
orb %bpl, 0x1(%rax)
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl %r12d, %r8d
movq %r15, %r9
callq 0x15da2
testq %rax, %rax
je 0x17fb8
movb $-0x77, (%rax)
jmp 0x17fbb
// File: /workspace/github_c_makefile_star2_O3/mmcco[P]sljit/sljit_src/sljitNativeX86_common.c
// Function: emit_shift_with_flags
static int emit_shift_with_flags(struct sljit_compiler *compiler,
	u_char mode, int set_flags,
	int dst, long dstw,
	int src1, long src1w,
	int src2, long src2w)
{
	/* The CPU does not set flags if the shift count is 0. */
	if (src2 & SLJIT_IMM) {
#if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
		if ((src2w & 0x3f) != 0 || (compiler->mode32 && (src2w & 0x1f) != 0))
			return emit_shift(compiler, mode, dst, dstw, src1, src1w, src2, src2w);
#else
		if ((src2w & 0x1f) != 0)
			return emit_shift(compiler, mode, dst, dstw, src1, src1w, src2, src2w);
#endif
		if (!set_flags)
			return emit_mov(compiler, dst, dstw, src1, src1w);
		/* OR dst, src, 0 */
		return emit_cum_binary(compiler, OR_r_rm, OR_rm_r, OR, OR_EAX_i32,
			dst, dstw, src1, src1w, SLJIT_IMM, 0);
	}

	if (!set_flags)
		return emit_shift(compiler, mode, dst, dstw, src1, src1w, src2, src2w);

	if (!FAST_IS_REG(dst))
		FAIL_IF(emit_cmp_binary(compiler, src1, src1w, SLJIT_IMM, 0));

	FAIL_IF(emit_shift(compiler,mode, dst, dstw, src1, src1w, src2, src2w));

	if (FAST_IS_REG(dst))
		return emit_cmp_binary(compiler, dst, dstw, SLJIT_IMM, 0);
	return SLJIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r10d
movq %r8, %rax
movl %ecx, %ebp
movl %esi, %r13d
movq %rdi, %r14
movq 0x60(%rsp), %r15
movl 0x58(%rsp), %ebx
movq 0x50(%rsp), %r12
testb $0x40, %bl
jne 0x1a346
testl %edx, %edx
je 0x1a34c
cmpl $0x40, %ebp
jge 0x1a3aa
movzbl %r13b, %esi
movq %r14, %rdi
movl %ebp, %edx
movq %rax, %rcx
movl %r10d, %r8d
movq %r12, %r9
pushq %r15
pushq %rbx
movq %rax, %rbx
callq 0x1f5e0
addq $0x10, %rsp
testl %eax, %eax
jne 0x1a3f9
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movl $0x40, %ecx
xorl %r8d, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19a0c
testb $0x3f, %r15b
je 0x1a36f
movzbl %r13b, %esi
movq %r14, %rdi
movl %ebp, %edx
movq %rax, %rcx
movl %r10d, %r8d
movq %r12, %r9
pushq %r15
pushq %rbx
callq 0x1f5e0
addq $0x28, %rsp
jmp 0x1a400
testl %edx, %edx
je 0x1a40b
subq $0x8, %rsp
movq %r14, %rdi
movl $0xb, %esi
movl $0x9, %edx
movl $0x8, %ecx
movl $0xd, %r8d
movl %ebp, %r9d
pushq $0x0
pushq $0x40
pushq %r12
pushq %r10
pushq %rax
callq 0x19468
addq $0x48, %rsp
jmp 0x1a400
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movl %r10d, %esi
movq %r12, %rdx
movl $0x40, %ecx
xorl %r8d, %r8d
movq %r10, 0x8(%rsp)
callq 0x19a0c
testl %eax, %eax
jne 0x1a3f9
movzbl %r13b, %esi
movq %r14, %rdi
movl %ebp, %edx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq %r12, %r9
pushq %r15
pushq %rbx
callq 0x1f5e0
addq $0x10, %rsp
testl %eax, %eax
movl $0x0, %eax
je 0x1a3fc
movl (%r14), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
movq %rax, %rdx
movl %r10d, %ecx
movq %r12, %r8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x16ad7
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
testl %eax, %eax
jne 0x1a536
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1a545
movl %edx, %r15d
leal -0x1(%r15), %eax
cmpl $0xf, %eax
jae 0x1a553
movq %rdi, %r14
movq 0x78(%rdi), %rcx
movl %r15d, %r12d
testq %rcx, %rcx
je 0x1a506
leaq 0x90b8(%rip), %rdi      # 0x2357e
movl $0xb, %esi
movl $0x1, %edx
callq 0x2130
leaq 0x90ae(%rip), %r13      # 0x2358a
xorl %ebp, %ebp
movq 0x78(%r14), %rdi
movzbl (%rbx,%rbp), %edx
movq %r13, %rsi
xorl %eax, %eax
callq 0x20c0
incq %rbp
cmpq %rbp, %r12
jne 0x1a4de
movq 0x78(%r14), %rsi
movl $0xa, %edi
callq 0x20a0
leal 0x1(%r15), %esi
movq %r14, %rdi
callq 0x15218
testq %rax, %rax
je 0x1a533
movq %rax, %rdi
incq %rdi
movb %r15b, (%rax)
addq %r12, 0x60(%r14)
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2110
xorl %eax, %eax
jmp 0x1a536
movl (%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8df3(%rip), %rdi      # 0x2333f
movl $0x45e, %esi            # imm = 0x45E
jmp 0x1a55f
leaq 0x8de5(%rip), %rdi      # 0x2333f
movl $0x460, %esi            # imm = 0x460
xorl %eax, %eax
callq 0x2080
callq 0x2040
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
je 0x1d035
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rbx
movq 0x78(%rdi), %rcx
testq %rcx, %rcx
je 0x1d057
leaq 0x6592(%rip), %rdi      # 0x235da
movl $0x7, %esi
movl $0x1, %edx
callq 0x2130
cmpl $0x0, 0x74(%rbx)
je 0x1d08f
movl $0x7, %esi
movq %rbx, %rdi
callq 0x15218
testq %rax, %rax
je 0x1d100
movb $0x6, (%rax)
addq $0x6, 0x60(%rbx)
movl $0x648d489d, 0x1(%rax)  # imm = 0x648D489D
movw $0xf824, 0x5(%rax)      # imm = 0xF824
movl $0x0, 0x74(%rbx)
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x1d0a2
movq 0x10(%r14), %rax
cmpq 0x60(%rbx), %rax
je 0x1d02a
movl $0x18, %esi
movq %rbx, %rdi
callq 0x14955
testq %rax, %rax
je 0x1d027
movq %rax, %r14
movq $0x0, (%rax)
movq 0x60(%rbx), %rax
movq %rax, 0x10(%r14)
movq 0x20(%rbx), %rax
leaq 0x8(%rbx), %rcx
testq %rax, %rax
cmovneq %rax, %rcx
movq %r14, (%rcx)
movq %r14, 0x20(%rbx)
movl $0x2, %esi
movq %rbx, %rdi
callq 0x15218
testq %rax, %rax
je 0x1d027
movw $0x0, (%rax)
jmp 0x1d02a
cmpl $0x0, (%rbx)
jne 0x1d027
jmp 0x1d08f