LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/liuhaotian[P]xmppsh/libstrophe/examples/active.c
// Function: main
int main(int argc, char **argv)
{
    xmpp_ctx_t *ctx;
    xmpp_conn_t *conn;

    if (argc != 3) {
	fprintf(stderr, "Usage: active <jid> <pass>\n\n");
	return 1;
    }

    /* initialize lib */
    xmpp_initialize();

    /* create a context */
    ctx = xmpp_ctx_new(NULL, NULL);

    /* create a connection */
    conn = xmpp_conn_new(ctx);

    /* setup authentication information */
    xmpp_conn_set_jid(conn, argv[1]);
    xmpp_conn_set_pass(conn, argv[2]);

    /* initiate connection */
    xmpp_connect_client(conn, NULL, 0, conn_handler, ctx);

    /* start the event loop */
    xmpp_run(ctx);

    /* release our connection and context */
    xmpp_conn_release(conn);
    xmpp_ctx_free(ctx);

    /* shutdown lib */
    xmpp_shutdown();

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x3, %edi
jne 0x2733
movq %rsi, %r15
callq 0x4a40
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
callq 0x4e01
movq %rax, %r14
movq %rax, %rdi
callq 0x3e24
movq %rax, %r12
movq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x4454
movq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x4490
leaq -0x73(%rip), %rcx       # 0x2686
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %r8
callq 0x44cf
movq %r14, %rdi
callq 0x5440
movq %r12, %rdi
callq 0x4226
movq %r14, %rdi
callq 0x4e6a
callq 0x4a4c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x24b6
movl $0x1, %ebx
jmp 0x2725
nop
// File: /workspace/github_c_makefile_star2_O1/Keith-S-Thompson[P]kst-time-utils/gettimeofday.c
// Function: main
int main(void) {
    struct timeval tv = { 0, 0 };

    if (gettimeofday(&tv, NULL) == 0) {
        printf("%ld.%06ld\n", (long)tv.tv_sec, (long)tv.tv_usec);
        exit(EXIT_SUCCESS);
    }
    else {
        perror("gettimeofday");
        exit(EXIT_FAILURE);
    }
}

// Assembly:
subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x1040
testl %eax, %eax
jne 0x11a2
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0xe70(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1030
xorl %edi, %edi
callq 0x1060
leaq 0xe66(%rip), %rdi       # 0x200f
callq 0x1050
movl $0x1, %edi
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/cirocosta[P]stress/src/mem-rw.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	setbuf(stdout, NULL);
	stress_parse_args(argc, argv, &args);
	allocate_and_use(args.n);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movl $0x2008, %edx           # imm = 0x2008
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
movq 0x2518(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1090
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x14f9
movl (%r14), %edi
callq 0x172b
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/benchmark.c
// Function: resize
clock_t resize(struct bench_image image, int out_width, int out_height)
{
	int i;
	enum oil_colorspace cs;
	struct oil_scale os;
	unsigned char *inbuf, *outbuf;
	size_t in_row_stride;
	clock_t t;

	cs = image.cs;
	in_row_stride = image.width * OIL_CMP(cs);

	inbuf = image.buffer;
	outbuf = malloc(out_width * OIL_CMP(cs));

	t = clock();
	oil_scale_init(&os, image.height, out_height, image.width, out_width, cs);
	for(i=0; i<out_height; i++) {
		while (oil_scale_slots(&os)) {
			oil_scale_in(&os, inbuf);
			inbuf += in_row_stride;
		}
		oil_scale_out(&os, outbuf);
	}
	t = clock() - t;
	free(outbuf);
	oil_scale_free(&os);
	return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
movl %edi, %ebp
movl 0xb0(%rsp), %r13d
movl 0xa8(%rsp), %r14d
movzbl %r13b, %eax
movq 0xa0(%rsp), %r12
movl %eax, 0x4(%rsp)
movl %eax, %edi
imull %ebp, %edi
callq 0x1150
movq %rax, %r15
callq 0x10b0
movq %rax, 0x8(%rsp)
movl 0xac(%rsp), %esi
leaq 0x10(%rsp), %rdi
movl %ebx, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movl %r13d, %r9d
callq 0x166c
testl %ebx, %ebx
jle 0x348d
imull 0x4(%rsp), %r14d
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x1c70
movq %rbp, %rdi
testl %eax, %eax
je 0x347d
movq %r12, %rsi
callq 0x1ca2
addq %r14, %r12
jmp 0x3461
movq %r15, %rsi
callq 0x287c
incl %r13d
cmpl %ebx, %r13d
jne 0x3461
callq 0x10b0
movq %rax, %rbx
subq 0x8(%rsp), %rbx
movq %r15, %rdi
callq 0x1040
leaq 0x10(%rsp), %rdi
callq 0x1925
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/benchmark.c
// Function: do_bench
void do_bench(struct bench_image image, double ratio, int iterations)
{
	int i, out_width, out_height;
	clock_t t_min, t_tmp;

	out_width = round(image.width * ratio);
	out_height = 500000; /* reasonable maximum height */

	oil_fix_ratio(image.width, image.height, &out_width, &out_height);

	t_min = 0;
	for (i=0; i<iterations; i++) {
		t_tmp = resize(image, out_width, out_height);
		if (!t_min || t_tmp < t_min) {
			t_min = t_tmp;
		}
	}

	printf("    to %4dx%4d %6.2fms\n", out_width, out_height, time_to_ms(t_min));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movl 0x58(%rsp), %ebp
movl 0x5c(%rsp), %r14d
cvtsi2sd %ebp, %xmm1
mulsd %xmm1, %xmm0
callq 0x1060
cvttsd2si %xmm0, %eax
leaq 0x24(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x20(%rsp), %rcx
movl $0x7a120, (%rcx)        # imm = 0x7A120
movl %ebp, %edi
movl %r14d, %esi
callq 0x31e2
testl %ebx, %ebx
jle 0x354e
leaq 0x50(%rsp), %r14
xorl %r15d, %r15d
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movupd (%r14), %xmm0
movupd %xmm0, (%rsp)
callq 0x33ea
cmpq %r15, %rax
movq %r15, %rcx
cmovlq %rax, %rcx
testq %r15, %r15
movq %rcx, %r15
cmoveq %rax, %r15
decl %ebx
jne 0x350c
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
jmp 0x3552
xorpd %xmm0, %xmm0
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
divsd 0xb9e(%rip), %xmm0      # 0x4100
leaq 0xbef(%rip), %rdi       # 0x4158
movb $0x1, %al
callq 0x10e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/benchmark.c
// Function: do_bench_sizes
void do_bench_sizes(char *name, char *path, enum oil_colorspace cs, int iterations)
{
	struct bench_image image;

	image = png(path, cs);

	printf("%dx%d %s\n", image.width, image.height, name);

	do_bench(image, 0.01, iterations);
	do_bench(image, 0.125, iterations);
	do_bench(image, 0.8, iterations);
	do_bench(image, 2.14, iterations);

	free(image.buffer);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebx
movq %rdi, %r15
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x3640
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
leaq 0xbcb(%rip), %rdi       # 0x4170
movq %r15, %rcx
xorl %eax, %eax
callq 0x10e0
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movsd 0xb40(%rip), %xmm0      # 0x4108
movl %ebx, %edi
callq 0x34be
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movsd 0xb28(%rip), %xmm0      # 0x4110
movl %ebx, %edi
callq 0x34be
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movsd 0xb10(%rip), %xmm0      # 0x4118
movl %ebx, %edi
callq 0x34be
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movsd 0xaf8(%rip), %xmm0      # 0x4120
movl %ebx, %edi
callq 0x34be
movq (%r14), %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbi_write_tga
int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
{
   int has_alpha = (comp == 2 || comp == 4);
   int colorbytes = has_alpha ? comp-1 : comp;
   int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3
   return outfile(filename, -1,-1, x, y, comp, 0, (void *) data, has_alpha, 0,
                  "111 221 2222 11", 0,0,format, 0,0,0, 0,0,x,y, (colorbytes+has_alpha)*8, has_alpha*8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r10
movl %ecx, %r9d
movl %esi, %ecx
leal -0x2(%r9), %eax
xorl %esi, %esi
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
sete %sil
movl %r9d, %eax
subl %esi, %eax
xorl %r11d, %r11d
cmpl $0x2, %eax
setl %r11b
orl $0x2, %r11d
leal (,%r9,8), %r15d
leal (,%rsi,8), %r12d
subq $0x8, %rsp
xorl %ebx, %ebx
leaq 0xdadf(%rip), %r14      # 0x1220f
movl %edx, %r8d
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %rdx
pushq %rcx
pushq %rbx
pushq %rbx
pushq %rbx
pushq %rbx
pushq %rbx
pushq %r11
pushq %rbx
pushq %rbx
pushq %r14
pushq %rbx
pushq %rsi
pushq %r10
pushq %rbx
callq 0x434d
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__write_run_data(_IO_FILE*, int, unsigned char)
void stbiw__write_run_data(FILE *f, int length, unsigned char databyte)
{
   unsigned char lengthbyte = (unsigned char) (length+128);
   STBIW_ASSERT(length+128 <= 255);
   fwrite(&lengthbyte, 1, 1, f);
   fwrite(&databyte, 1, 1, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x80, %esi
jge 0x4839
movl %edx, %r14d
movq %rdi, %rbx
movsbl %sil, %edi
xorl $-0x80, %edi
movq %rbx, %rsi
callq 0x22e0
movsbl %r14b, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x22e0
leaq 0xd9df(%rip), %rdi      # 0x1221f
leaq 0xd9ea(%rip), %rsi      # 0x12231
leaq 0xd9f7(%rip), %rcx      # 0x12245
movl $0x109, %edx            # imm = 0x109
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__write_dump_data(_IO_FILE*, int, unsigned char*)
void stbiw__write_dump_data(FILE *f, int length, unsigned char *data)
{
   unsigned char lengthbyte = (unsigned char )(length & 0xff);
   STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
   fwrite(&lengthbyte, 1, 1, f);
   fwrite(data, length, 1, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x81, %esi
jge 0x489c
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movsbl %r15b, %edi
movq %rbx, %rsi
callq 0x22e0
movslq %r15d, %rsi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2410
leaq 0xd9d9(%rip), %rdi      # 0x1227c
leaq 0xd987(%rip), %rsi      # 0x12231
leaq 0xd9d9(%rip), %rcx      # 0x1228a
movl $0x111, %edx            # imm = 0x111
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbi_write_hdr
int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
{
   int i;
   FILE *f;
   if (y <= 0 || x <= 0 || data == NULL) return 0;
   f = fopen(filename, "wb");
   if (f) {
      /* Each component is stored separately. Allocate scratch space for full output scanline. */
      unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
      fprintf(f, "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"      );
      fprintf(f, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n"                 , y, x);
      for(i=0; i < y; i++)
         stbiw__write_hdr_scanline(f, x, comp, scratch, data + comp*i*x);
      STBIW_FREE(scratch);
      fclose(f);
   }
   return f != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movl %edx, %r13d
testl %edx, %edx
setle %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %r8, %r8
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x4deb
movq %r8, %rbx
movl %esi, %r15d
leaq 0xd58d(%rip), %rsi      # 0x122c4
callq 0x22a0
movq %rax, %r12
testq %rax, %rax
je 0x4de3
leal (,%r15,4), %edi
callq 0x22f0
movq %rax, -0x40(%rbp)
leaq 0xd567(%rip), %rdi      # 0x122c7
movl $0x41, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x2410
leaq 0xd590(%rip), %rsi      # 0x12309
movl %r14d, -0x2c(%rbp)
xorl %r14d, %r14d
movq %r12, %rdi
movl %r13d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2300
testl %r13d, %r13d
movq %r12, -0x38(%rbp)
jle 0x4dce
movq %rbx, %r12
movl %r13d, %eax
movq %r15, %r13
movl -0x2c(%rbp), %ebx
imull %r13d, %ebx
movl %eax, %r15d
movslq %r14d, %r14
leaq (%r12,%r14,4), %r8
movq -0x38(%rbp), %rdi
movl %r13d, %esi
movl -0x2c(%rbp), %edx
movq -0x40(%rbp), %rcx
callq 0x48bb
addl %ebx, %r14d
decq %r15
jne 0x4dac
movq -0x40(%rbp), %rdi
callq 0x22b0
movq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x2210
xorl %eax, %eax
testq %r12, %r12
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__sbgrowf(void**, int, int)
static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
{
   int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
   void *p = STBIW_REALLOC(*arr ? stbiw__sbraw(*arr) : 0, itemsize * m + sizeof(int)*2);
   STBIW_ASSERT(p);
   if (p) {
      if (!*arr) ((int *) p)[1] = 0;
      *arr = (void *) ((int *) p + 2);
      stbiw__sbm(*arr) = m;
   }
   return *arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x5617
movl -0x8(%rax), %ecx
leal 0x1(,%rcx,2), %r14d
jmp 0x561d
movl $0x2, %r14d
leaq -0x8(%rax), %rdi
testq %rax, %rax
cmoveq %rax, %rdi
imull %r14d, %esi
movslq %esi, %rsi
addq $0x8, %rsi
callq 0x23b0
testq %rax, %rax
je 0x565c
cmpq $0x0, (%rbx)
jne 0x564a
movl $0x0, 0x4(%rax)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, (%rbx)
movl %r14d, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xe03d(%rip), %rdi      # 0x136a0
leaq 0xcbc7(%rip), %rsi      # 0x12231
leaq 0xd019(%rip), %rcx      # 0x1268a
movl $0x196, %edx            # imm = 0x196
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__zlib_flushf(unsigned char*, unsigned int*, int*)
static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
{
   while (*bitcount >= 8) {
      stbiw__sbpush(data, (unsigned char) *bitbuffer);
      *bitbuffer >>= 8;
      *bitcount -= 8;
   }
   return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, -0x20(%rbp)
cmpl $0x8, (%rdx)
jl 0x56dc
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x20(%rbp), %r15
movq -0x20(%rbp), %rax
testq %rax, %rax
je 0x56ab
movl -0x4(%rax), %ecx
incl %ecx
cmpl -0x8(%rax), %ecx
jl 0x56b8
movq %r15, %rdi
movl $0x1, %esi
callq 0x55f8
movb (%r14), %al
movq -0x20(%rbp), %rcx
movslq -0x4(%rcx), %rdx
leal 0x1(%rdx), %esi
movl %esi, -0x4(%rcx)
movb %al, (%rcx,%rdx)
shrl $0x8, (%r14)
movl (%rbx), %eax
leal -0x8(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0xf, %eax
jg 0x5698
movq -0x20(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__crc32(unsigned char*, int)
unsigned int stbiw__crc32(unsigned char *buffer, int len)
{
   static unsigned int crc_table[256];
   unsigned int crc = ~0u;
   int i,j;
   if (crc_table[1] == 0)
      for(i=0; i < 256; i++)
         for (crc_table[i]=i, j=0; j < 8; ++j)
            crc_table[i] = (crc_table[i] >> 1) ^ (crc_table[i] & 1 ? 0xedb88320 : 0);
   for (i=0; i < len; ++i)
      crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
   return ~crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x13b7e(%rip)     # 0x19274
leaq 0x13b73(%rip), %rcx     # 0x19270
jne 0x5736
xorl %eax, %eax
movl %eax, (%rcx,%rax,4)
movl $0x8, %edx
movl %eax, %r8d
movl %r8d, %r9d
shrl %r9d
andl $0x1, %r8d
negl %r8d
andl $0xedb88320, %r8d       # imm = 0xEDB88320
xorl %r9d, %r8d
decl %edx
jne 0x570c
movl %r8d, (%rcx,%rax,4)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x5701
testl %esi, %esi
jle 0x5762
movl %esi, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
movzbl %al, %r8d
shrl $0x8, %eax
movzbl (%rdi,%rsi), %r9d
xorl %r9d, %r8d
xorl (%rcx,%r8,4), %eax
incq %rsi
cmpq %rsi, %rdx
jne 0x5743
notl %eax
jmp 0x5764
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbi_write_png
int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
   FILE *f;
   int len;
   unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (!png) return 0;
   f = fopen(filename, "wb");
   if (!f) { STBIW_FREE(png); return 0; }
   fwrite(png, 1, len, f);
   fclose(f);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %r9d, %r10d
movl %ecx, %eax
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %r14
leaq -0x14(%rbp), %r9
movq %r8, %rdi
movl %r10d, %esi
movl %eax, %r8d
callq 0x5766
testq %rax, %rax
je 0x5d38
movq %rax, %rbx
leaq 0xc5c0(%rip), %rsi      # 0x122c4
movq %r14, %rdi
callq 0x22a0
testq %rax, %rax
je 0x5d3d
movq %rax, %r14
movslq -0x14(%rbp), %rdx
movl $0x1, %esi
movq %rbx, %rdi
movq %rax, %rcx
callq 0x2410
movq %r14, %rdi
callq 0x2210
movl $0x1, %r14d
jmp 0x5d40
xorl %r14d, %r14d
jmp 0x5d48
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x22b0
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./main.h
// Function: strlwr(char*)
char * strlwr(char * string) {
    int length = strlen(string);
    for (int i = 0; i < length; ++i)
    {
        string[i] = tolower(string[i]);
    }
    return string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2120
movq %rax, %r14
testl %r14d, %r14d
jle 0x5d8e
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0x2310
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x5d78
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./main.h
// Function: strupr(char*)
char * strupr(char * string) {
    int length = strlen(string);
    for (int i = 0; i < length; ++i)
    {
        string[i] = toupper(string[i]);
    }
    return string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2120
movq %rax, %r14
testl %r14d, %r14d
jle 0x5dd6
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0x23f0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x5dc0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./stable.h
// Function: StringTable::Get(char const*)
const char * Get(const char *str)
  {
    CharPtrSet::iterator found;
    found = mStrings.find( str );
    if ( found != mStrings.end() ) return (*found);
    int l = strlen(str);
    char *mem = new char[l+1];
    strcpy(mem,str);
    mStrings.insert( mem );
    return mem;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x6a82
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x6a40
movq 0x20(%rax), %rax
jmp 0x6a76
movq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x2120
incl %eax
movslq %eax, %rdi
callq 0x2040
leaq -0x28(%rbp), %r15
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6af6
movq (%r15), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/arglist.cpp
// Function: TranslateEscapedChar(int)
int TranslateEscapedChar( int ch )
{
  switch( ch )
  {
  case 't':
    ch = '\t';
    break;
  case 'n':
    ch = '\n';
    break;
  case 'f':
    ch = '\f';
    break;
  }
  return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x66, %edi
je 0x6dff
movl %edi, %eax
cmpl $0x6e, %edi
je 0x6df8
cmpl $0x74, %eax
jne 0x6e04
movl $0x9, %eax
jmp 0x6e04
movl $0xa, %eax
jmp 0x6e04
movl $0xc, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/fload.cpp
// Function: Fload::Fload(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Fload::Fload(const String& fname)
{
  mName = SGET( fname );
  mData = 0;
  mLen = 0;

  FILE *fph = fopen( mName, "rb");
  if ( fph )
  {
    fseek(fph, 0L, SEEK_END);
    mLen = ftell(fph);
    if ( mLen )
    {
      fseek(fph, 0L, SEEK_SET);
      mData = (void *) new unsigned char[mLen+1];
      assert( mData );
      if ( mData )
      {
        int r = fread(mData, mLen, 1, fph);
        assert( r );
        if ( !r )
        {
          delete (char *) mData;
          mData = 0;
        }
		((char *)mData)[mLen]=0;
      }
    }
    fclose(fph);
  }
  mReadLoc = (char *)mData;
  mReadLen = mLen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb02b(%rip), %rax      # 0x12bb2
movq %rax, (%rdi)
callq 0x697e
movq (%r14), %rsi
movq %rax, %rdi
callq 0x6a12
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
leaq 0xa635(%rip), %rsi      # 0x121e8
movq %rax, %rdi
callq 0x22a0
testq %rax, %rax
je 0x7c29
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2270
movq %r14, %rdi
callq 0x2030
movl %eax, 0x10(%rbx)
testl %eax, %eax
je 0x7c21
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2270
movslq 0x10(%rbx), %r15
leaq 0x1(%r15), %rdi
callq 0x2040
movq %rax, 0x8(%rbx)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x2330
testl %eax, %eax
je 0x7c42
movq 0x8(%rbx), %rax
movslq 0x10(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq %r14, %rdi
callq 0x2210
movq 0x8(%rbx), %rax
movq %rax, 0x18(%rbx)
movl 0x10(%rbx), %eax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb960(%rip), %rdi      # 0x135a9
leaq 0xaf3b(%rip), %rsi      # 0x12b8b
leaq 0xaf3e(%rip), %rcx      # 0x12b95
movl $0x2e, %edx
callq 0x2180
nop
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/fload.cpp
// Function: Fload::GetString()
char * Fload::GetString(void)
{
  if ( !mReadLoc )
  {
    return 0;
  }

  // now advance read pointer to end of string and stomp a zero
  // byte on top of it as a null string terminator.
  while ( *mReadLoc == 0 || *mReadLoc == 10 || *mReadLoc == 13 )
  {
    mReadLoc++;
    mReadLen--;
    if ( !mReadLen )
    {
      mReadLoc = 0;
      return 0;
    }
  }

  char *ret = mReadLoc; // current read location is string location

  while ( *mReadLoc && *mReadLoc != 10 && *mReadLoc != 13 )
  {
    mReadLoc++;
    mReadLen--;
    if ( !mReadLen )
    {
      mReadLoc = 0;
      break;
    }
  }

  if ( mReadLen ) *mReadLoc = 0; // replace line feeds with null terminated strings.

  if ( mReadLoc ) mReadLoc++;
  mReadLen--;

  if ( !mReadLen )
  {
    mReadLoc = 0;
  }
  return ret;
}

// Assembly:
cmpq $0x0, 0x18(%rdi)
je 0x7cbd
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
movl 0x20(%rdi), %ecx
decl %ecx
movl $0x2401, %edx           # imm = 0x2401
movzbl (%rax), %esi
cmpl $0xd, %esi
ja 0x7cc0
btl %esi, %edx
jae 0x7cc0
incq %rax
movq %rax, 0x18(%rdi)
movl %ecx, 0x20(%rdi)
addl $-0x1, %ecx
jb 0x7c95
xorl %eax, %eax
movq $0x0, 0x18(%rdi)
popq %rbp
retq
xorl %eax, %eax
retq
movq 0x18(%rdi), %rcx
movl 0x20(%rdi), %edx
decl %edx
incq %rcx
movl $0x2401, %esi           # imm = 0x2401
movzbl -0x1(%rcx), %r8d
cmpl $0xd, %r8d
ja 0x7ce2
btl %r8d, %esi
jb 0x7cf9
movq %rcx, 0x18(%rdi)
movl %edx, 0x20(%rdi)
incq %rcx
addl $-0x1, %edx
jb 0x7cd1
movq $0x0, 0x18(%rdi)
cmpl $0x0, 0x20(%rdi)
je 0x7d06
movq 0x18(%rdi), %rcx
movb $0x0, (%rcx)
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x7d16
incq %rcx
movq %rcx, 0x18(%rdi)
decl 0x20(%rdi)
jne 0x7cbb
jmp 0x7cb3
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/patch.cpp
// Function: PatchSurface::FillPatch(int, int, int, int, LightMapVertex*)
void PatchSurface::FillPatch(int controlx,int controly,int sizex,int sizey,LightMapVertex *p)
{
  int stepx = (sizex-1) / (controlx-1);
  for (int u = 0; u < sizex; u += stepx)
  {
  	FillCurve(controly, sizey,sizex,p+u);
  }
  for (int v = 0; v < sizey; v++)
  {
  	FillCurve(controlx, sizex, 1, p + v * sizex);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x30(%rbp)
movl %ecx, %r14d
movq %rsi, -0x38(%rbp)
testl %ecx, %ecx
jle 0x817d
movl %edx, %edi
leal -0x1(%r14), %eax
movq -0x38(%rbp), %rcx
decl %ecx
cltd
idivl %ecx
cltq
movl %r14d, %ecx
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
leaq (,%rax,8), %rax
leaq (%rax,%rax,4), %rax
movq %rax, -0x40(%rbp)
xorl %r12d, %r12d
movq -0x30(%rbp), %rbx
movl %edi, %esi
movl %r8d, %edx
movl %r14d, %ecx
movl %r8d, %r13d
movq %rbx, %r8
movq %r14, %r15
movl %edi, %r14d
callq 0x8316
movl %r14d, %edi
movq %r15, %r14
movl %r13d, %r8d
addq -0x50(%rbp), %r12
addq -0x40(%rbp), %rbx
cmpq -0x48(%rbp), %r12
jl 0x814d
testl %r8d, %r8d
movq -0x38(%rbp), %r13
movq -0x30(%rbp), %r15
jle 0x81b3
movslq %r14d, %rax
movl %r8d, %ebx
shlq $0x3, %rax
leaq (%rax,%rax,4), %r12
movl %r13d, %esi
movl %r14d, %edx
movl $0x1, %ecx
movq %r15, %r8
callq 0x8316
addq %r12, %r15
decq %rbx
jne 0x8198
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/patch.cpp
// Function: PatchSurface::FindLevel(Vector3d<float> const&, Vector3d<float> const&, Vector3d<float> const&) const
int PatchSurface::FindLevel(const Vector3d<float> &cv0,
                            const Vector3d<float> &cv1,
                            const Vector3d<float> &cv2) const
{
  int level;
  Vector3d<float> a,b,dist;

  Vector3d<float> v0 = cv0; // init control points.
  Vector3d<float> v1 = cv1;
  Vector3d<float> v2 = cv2;

  /* Subdivide on the left until tolerance is reached */
  for (level=0; level <MAXMESHLEVEL-1; level++)
  {
	  /* Subdivide on the left */
    a.Lerp(v0,v1,0.5f);
    b.Lerp(v1,v2,0.5f);
    v2.Lerp(a,b,0.5f);

	  /* Find distance moved */
    dist = v2-v1;

    float dist2 = dist.x*dist.x + dist.y*dist.y + dist.z*dist.z;
    if ( dist2 < MINDIST ) break;

	  /* Insert new middle vertex */
    v1 = a;
  }

  return level;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss (%rsi), %xmm0
movss 0x4(%rsi), %xmm1
movss 0x8(%rsi), %xmm2
movss (%rdx), %xmm3
movss 0x4(%rdx), %xmm4
movss 0x8(%rdx), %xmm5
movss (%rcx), %xmm6
movss 0x4(%rcx), %xmm7
movss 0x8(%rcx), %xmm8
xorl %eax, %eax
movss 0xa980(%rip), %xmm9     # 0x12bb8
movss 0xa97b(%rip), %xmm10    # 0x12bbc
movaps %xmm5, %xmm11
movaps %xmm4, %xmm12
movaps %xmm3, %xmm13
subss %xmm0, %xmm3
subss %xmm1, %xmm4
subss %xmm2, %xmm5
mulss %xmm9, %xmm3
mulss %xmm9, %xmm4
mulss %xmm9, %xmm5
addss %xmm0, %xmm3
addss %xmm1, %xmm4
addss %xmm2, %xmm5
subss %xmm13, %xmm6
subss %xmm12, %xmm7
subss %xmm11, %xmm8
mulss %xmm9, %xmm6
mulss %xmm9, %xmm7
mulss %xmm9, %xmm8
addss %xmm13, %xmm6
addss %xmm12, %xmm7
addss %xmm11, %xmm8
subss %xmm3, %xmm6
subss %xmm4, %xmm7
subss %xmm5, %xmm8
mulss %xmm9, %xmm6
mulss %xmm9, %xmm7
mulss %xmm9, %xmm8
addss %xmm3, %xmm6
addss %xmm4, %xmm7
addss %xmm5, %xmm8
movaps %xmm6, %xmm14
subss %xmm13, %xmm14
movaps %xmm7, %xmm13
subss %xmm12, %xmm13
movaps %xmm8, %xmm12
subss %xmm11, %xmm12
mulss %xmm13, %xmm13
mulss %xmm14, %xmm14
addss %xmm13, %xmm14
mulss %xmm12, %xmm12
addss %xmm14, %xmm12
ucomiss %xmm12, %xmm10
ja 0x8314
incl %eax
cmpl $0x4, %eax
jne 0x8241
movl $0x4, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/./vformat.h
// Function: LightMapVertex::Lerp(LightMapVertex const&, LightMapVertex const&, float)
void Lerp(const LightMapVertex &a,const LightMapVertex &b,float p)
  {
    mPos.Lerp(a.mPos,b.mPos,p);
    mTexel1.Lerp(a.mTexel1,b.mTexel1,p);
    mTexel2.Lerp(a.mTexel2,b.mTexel2,p);
    mColor.Lerp(a.mColor,b.mColor,p);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, -0x1c(%rbp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x852c
movss 0xc(%rbx), %xmm2
subss 0xc(%r14), %xmm2
movss %xmm2, 0xc(%r15)
movss 0x10(%rbx), %xmm1
subss 0x10(%r14), %xmm1
movss -0x1c(%rbp), %xmm0
mulss %xmm0, %xmm2
movss %xmm2, 0xc(%r15)
mulss %xmm0, %xmm1
movss %xmm1, 0x10(%r15)
addss 0xc(%r14), %xmm2
movss %xmm2, 0xc(%r15)
addss 0x10(%r14), %xmm1
movss %xmm1, 0x10(%r15)
movss 0x14(%rbx), %xmm2
subss 0x14(%r14), %xmm2
movss %xmm2, 0x14(%r15)
movss 0x18(%rbx), %xmm1
subss 0x18(%r14), %xmm1
mulss %xmm0, %xmm2
movss %xmm2, 0x14(%r15)
mulss %xmm0, %xmm1
movss %xmm1, 0x18(%r15)
addss 0x14(%r14), %xmm2
movss %xmm2, 0x14(%r15)
addss 0x18(%r14), %xmm1
movss %xmm1, 0x18(%r15)
addq $0x1c, %r15
addq $0x1c, %r14
addq $0x1c, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x852c
nop
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: QuakeHeader::SetHeader(void const*)
bool QuakeHeader::SetHeader(const void *mem)  // returns true if valid quake header.
{
  const int *ids = (const int *) mem;
  #define BSPHEADERID  (*(int*)"IBSP")
  #define BSPVERSION 46
  if ( ids[0] != BSPHEADERID ) return false;
  if ( ids[1] != BSPVERSION ) return false;
  mId      = ids[0];
  mVersion = ids[1];
  const QuakeLump *lump = (const QuakeLump *) &ids[2];
  for (int i=0; i<NUM_LUMPS; i++) mLumps[i] = *lump++;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x50534249, (%rsi)     # imm = 0x50534249
jne 0x8a72
cmpl $0x2e, 0x4(%rsi)
jne 0x8a72
movl $0x50534249, (%rdi)     # imm = 0x50534249
movl 0x4(%rsi), %eax
movl %eax, 0x4(%rdi)
movl $0x1, %eax
movq (%rsi,%rax,8), %rcx
movq %rcx, (%rdi,%rax,8)
incq %rax
cmpq $0x12, %rax
jne 0x8a5d
movb $0x1, %al
jmp 0x8a74
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: Quake3BSP::ReadFaces(void const*)
void Quake3BSP::ReadFaces(const void *mem)
{
  assert( mOk );
  int lsize;
  int lcount;
  const int *faces = (const int *) mHeader.LumpInfo(Q3_FACES,mem,lsize,lcount);
  assert( lsize == sizeof(int)*26 );

  mFaces.clear();
  mFaces.reserve( lcount );

  for (int i=0; i<lcount; i++)
  {
    QuakeFace f(faces);

    mFaces.push_back(f);

    faces+=26;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
cmpb $0x0, (%rdi)
je 0x8b25
movq %rsi, %rdx
movq %rdi, %r15
addq $0x18, %rdi
leaq -0x28(%rbp), %r14
leaq -0x24(%rbp), %r8
movl $0xd, %esi
movq %r14, %rcx
callq 0x970a
cmpl $0x68, (%r14)
jne 0x8b44
movq %rax, %rbx
leaq 0xa8(%r15), %r14
movq 0xa8(%r15), %rax
cmpq %rax, 0xb0(%r15)
je 0x8adb
movq %rax, 0xb0(%r15)
movslq -0x24(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xa994
testq %r15, %r15
jle 0x8b15
leaq -0x94(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x98c6
movq %r14, %rdi
movq %r12, %rsi
callq 0xaa2c
addq $0x68, %rbx
decl %r15d
jne 0x8af6
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa0f1(%rip), %rdi      # 0x12c1d
leaq 0xa0ee(%rip), %rsi      # 0x12c21
leaq 0xa301(%rip), %rcx      # 0x12e3b
movl $0x171, %edx            # imm = 0x171
callq 0x2180
leaq 0xa318(%rip), %rdi      # 0x12e63
leaq 0xa0cf(%rip), %rsi      # 0x12c21
leaq 0xa2e2(%rip), %rcx      # 0x12e3b
movl $0x175, %edx            # imm = 0x175
callq 0x2180
nop
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: Quake3BSP::ReadElements(void const*)
void Quake3BSP::ReadElements(const void *mem)
{
  assert( mOk );
  int lsize;
  int lcount;
  // LUMP_DRAWINDEXES
  const int *elements = (const int *) mHeader.LumpInfo(Q3_ELEMS,mem,lsize,lcount);
  assert( lsize == sizeof(int) );

  mElements.clear();
  mElements.reserve( lcount );

  for (int i=0; i<lcount; i++)
  {
    unsigned short ic = (unsigned short)(*elements);
    mElements.push_back(ic);
    elements++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpb $0x0, (%rdi)
je 0x8c2e
movq %rsi, %rdx
movq %rdi, %rbx
addq $0x18, %rdi
leaq -0x34(%rbp), %r15
leaq -0x30(%rbp), %r8
movl $0xb, %esi
movq %r15, %rcx
callq 0x970a
cmpl $0x4, (%r15)
jne 0x8c4d
movq %rax, %r14
leaq 0xf0(%rbx), %r15
movq 0xf0(%rbx), %rax
cmpq %rax, 0xf8(%rbx)
je 0x8bc8
movq %rax, 0xf8(%rbx)
movslq -0x30(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xab86
testq %r12, %r12
jle 0x8c1f
movl %r12d, %r13d
xorl %r12d, %r12d
movzwl (%r14,%r12,4), %eax
movw %ax, -0x2a(%rbp)
movq 0xf8(%rbx), %rsi
cmpq 0x100(%rbx), %rsi
je 0x8c0b
movw %ax, (%rsi)
addq $0x2, %rsi
movq %rsi, 0xf8(%rbx)
jmp 0x8c17
movq %r15, %rdi
leaq -0x2a(%rbp), %rdx
callq 0xba3a
incq %r12
cmpl %r12d, %r13d
jne 0x8be2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9fe8(%rip), %rdi      # 0x12c1d
leaq 0x9fe5(%rip), %rsi      # 0x12c21
leaq 0xa2b1(%rip), %rcx      # 0x12ef4
movl $0x1cf, %edx            # imm = 0x1CF
callq 0x2180
leaq 0xa2cb(%rip), %rdi      # 0x12f1f
leaq 0x9fc6(%rip), %rsi      # 0x12c21
leaq 0xa292(%rip), %rcx      # 0x12ef4
movl $0x1d4, %edx            # imm = 0x1D4
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: Quake3BSP::ReadVertices(void const*)
void Quake3BSP::ReadVertices(const void *mem)
{
  assert( mOk );
  int lsize;
  int lcount;
  const int *vertices = (const int *) mHeader.LumpInfo(Q3_VERTS,mem,lsize,lcount);
  assert( lsize == sizeof(int)*11 );

  mVertices.clear();
  mVertices.reserve( lcount );

  mBound.InitMinMax();

  for (int i=0; i<lcount; i++)
  {
    QuakeVertex v(vertices);

    #define RECIP (1.0f/45.0f)

    v.mPos.x*=RECIP;
    v.mPos.y*=-RECIP;
    v.mPos.z*=RECIP;

    mBound.MinMax(v.mPos);
    mVertices.push_back(v);
    vertices+=11;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpb $0x0, (%rdi)
je 0x8ddc
movq %rsi, %rdx
movq %rdi, %rbx
addq $0x18, %rdi
leaq -0x5c(%rbp), %r15
leaq -0x2c(%rbp), %r8
movl $0xa, %esi
movq %r15, %rcx
callq 0x970a
cmpl $0x2c, (%r15)
jne 0x8dfb
movq %rax, %r14
leaq 0xc0(%rbx), %r15
movq 0xc0(%rbx), %rax
cmpq %rax, 0xc8(%rbx)
je 0x8cd0
movq %rax, 0xc8(%rbx)
movslq -0x2c(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xaa64
movaps 0x9efa(%rip), %xmm0     # 0x12be0
movups %xmm0, 0x108(%rbx)
movabsq $-0x319194d7319194d8, %rax # imm = 0xCE6E6B28CE6E6B28
movq %rax, 0x118(%rbx)
testq %r12, %r12
jle 0x8dcd
addq $0x108, %rbx            # imm = 0x108
leaq -0x58(%rbp), %r13
movss (%r14), %xmm0
movss %xmm0, -0x58(%rbp)
movss 0x4(%r14), %xmm1
movss %xmm1, -0x54(%rbp)
movss 0x8(%r14), %xmm2
movss %xmm2, -0x50(%rbp)
movss 0xc(%r14), %xmm3
movss %xmm3, -0x4c(%rbp)
movss 0x10(%r14), %xmm3
movss %xmm3, -0x48(%rbp)
movss 0x14(%r14), %xmm3
movss %xmm3, -0x44(%rbp)
movss 0x18(%r14), %xmm3
movss %xmm3, -0x40(%rbp)
movss 0x1c(%r14), %xmm3
movss %xmm3, -0x3c(%rbp)
movss 0x20(%r14), %xmm3
movss %xmm3, -0x38(%rbp)
movss 0x24(%r14), %xmm3
movss %xmm3, -0x34(%rbp)
movl 0x28(%r14), %eax
movl %eax, -0x30(%rbp)
movss 0x9e72(%rip), %xmm3     # 0x12c00
mulss %xmm3, %xmm0
movss %xmm0, -0x58(%rbp)
mulss 0x9e65(%rip), %xmm1     # 0x12c04
movss %xmm1, -0x54(%rbp)
mulss %xmm3, %xmm2
movss %xmm2, -0x50(%rbp)
movq %rbx, %rdi
callq 0xb7e6
movq %r15, %rdi
movq %r13, %rsi
callq 0xaafc
addq $0x2c, %r14
decl %r12d
jne 0x8d12
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9e3a(%rip), %rdi      # 0x12c1d
leaq 0x9e37(%rip), %rsi      # 0x12c21
leaq 0xa08a(%rip), %rcx      # 0x12e7b
movl $0x186, %edx            # imm = 0x186
callq 0x2180
leaq 0xa0a4(%rip), %rdi      # 0x12ea6
leaq 0x9e18(%rip), %rsi      # 0x12c21
leaq 0xa06b(%rip), %rcx      # 0x12e7b
movl $0x18a, %edx            # imm = 0x18A
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: Quake3BSP::ReadShaders(void const*)
void Quake3BSP::ReadShaders(const void *mem)
{
  assert( mOk );
  int lsize;
  int lcount;

  const unsigned char *smem = (const unsigned char *) mHeader.LumpInfo(Q3_SHADERREFS,mem,lsize,lcount);

  mShaders.clear();
  mShaders.reserve( lcount );

  for (int i=0; i<lcount; i++)
  {
    ShaderReference s(smem);
    mShaders.push_back(s);
    smem+=lsize;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpb $0x0, (%rdi)
je 0x9153
movq %rsi, %rdx
movq %rdi, %rbx
addq $0x18, %rdi
leaq -0x30(%rbp), %rcx
leaq -0x2c(%rbp), %r8
movl $0x1, %esi
callq 0x970a
movq %rax, %r14
leaq 0xd8(%rbx), %rax
movq %rax, -0x38(%rbp)
movq 0xd8(%rbx), %rax
cmpq %rax, 0xe0(%rbx)
je 0x90bd
movq %rax, 0xe0(%rbx)
movslq -0x2c(%rbp), %r12
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0xa8c6
testq %r12, %r12
jle 0x9144
movslq -0x30(%rbp), %r15
addq $0x40, %r14
leaq -0x80(%rbp), %r13
movups -0x40(%r14), %xmm0
movups -0x30(%r14), %xmm1
movups -0x20(%r14), %xmm2
movups -0x10(%r14), %xmm3
movaps %xmm3, -0x50(%rbp)
movaps %xmm2, -0x60(%rbp)
movaps %xmm1, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movq (%r14), %rax
movq %rax, -0x40(%rbp)
movq 0xe0(%rbx), %rsi
cmpq 0xe8(%rbx), %rsi
je 0x9130
movl $0x12, %ecx
movq %rsi, %rdi
movq %r13, %rsi
rep  movsl (%rsi), %es:(%rdi)
addq $0x48, 0xe0(%rbx)
jmp 0x913c
movq -0x38(%rbp), %rdi
movq %r13, %rdx
callq 0xad3c
addq %r15, %r14
decl %r12d
jne 0x90de
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9ac3(%rip), %rdi      # 0x12c1d
leaq 0x9ac0(%rip), %rsi      # 0x12c21
leaq 0x9ac3(%rip), %rcx      # 0x12c2b
movl $0x66, %edx
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: Quake3BSP::BuildVertexBuffers()
void Quake3BSP::BuildVertexBuffers(void)
{
  mMesh = 0;
  mMesh = new VertexMesh;

  QuakeFaceVector::iterator i;
  for (i=mFaces.begin(); i!=mFaces.end(); ++i)
  {
    (*i).Build(mElements,mVertices,mShaders,mLmPrefix,mName,mCodeName,*mMesh);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 0x120(%rdi)
movl $0x58, %edi
callq 0x2220
leaq 0x9a11(%rip), %rcx      # 0x12bb2
movq %rcx, 0x8(%rax)
leaq 0x18(%rax), %rcx
movl $0x0, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rcx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %r14, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movabsq $0x4e6e6b284e6e6b28, %rcx # imm = 0x4E6E6B284E6E6B28
movq %rcx, 0x40(%rax)
movaps 0x9a15(%rip), %xmm0     # 0x12bf0
movups %xmm0, 0x48(%rax)
movq %rax, 0x120(%rbx)
movq 0xa8(%rbx), %r14
cmpq 0xb0(%rbx), %r14
je 0x924d
leaq 0xf0(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0xc0(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0xd8(%rbx), %r13
leaq 0x1f0(%rbx), %r15
leaq 0x10(%rbx), %r12
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %r13, %rcx
movq %r15, %r8
pushq 0x120(%rbx)
pushq %r12
callq 0x9bd6
addq $0x10, %rsp
addq $0x6c, %r14
cmpq 0xb0(%rbx), %r14
jne 0x921e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: Quake3BSP::ReadPlanes(void const*)
void Quake3BSP::ReadPlanes(const void *mem)
{
  assert( mOk );
  int lsize;
  int lcount;
  const dplane_t *planes = (const dplane_t *) mHeader.LumpInfo(Q3_PLANES,mem,lsize,lcount);

  mPlanes.assign(planes,planes+lcount);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, (%rdi)
je 0x92af
movq %rsi, %rdx
movq %rdi, %rbx
addq $0x18, %rdi
leaq -0x18(%rbp), %rcx
leaq -0x14(%rbp), %r14
movl $0x2, %esi
movq %r14, %r8
callq 0x970a
addq $0x128, %rbx            # imm = 0x128
movslq (%r14), %rdx
shlq $0x4, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xae9e
leaq 0x9967(%rip), %rdi      # 0x12c1d
leaq 0x9964(%rip), %rsi      # 0x12c21
leaq 0x99f2(%rip), %rcx      # 0x12cb6
movl $0xde, %edx
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: Quake3BSP::ReadLeaves(void const*)
void Quake3BSP::ReadLeaves(const void *mem)
{
  assert( mOk );
  int lsize;
  int lcount;
  const dleaf_t *nodes= (const dleaf_t *) mHeader.LumpInfo(Q3_LEAFS,mem,lsize,lcount);


  mLeaves.assign(nodes,nodes+lcount);
  assert(mLeaves.size() == lcount);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, (%rdi)
je 0x9348
movq %rsi, %rdx
movq %rdi, %rbx
addq $0x18, %rdi
leaq -0x18(%rbp), %rcx
leaq -0x14(%rbp), %r14
movl $0x4, %esi
movq %r14, %r8
callq 0x970a
leaq 0x1b8(%rbx), %rdi
movslq (%r14), %r14
leaq (%r14,%r14,2), %rdx
shlq $0x4, %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0xb0fc
movq 0x1c0(%rbx), %rax
subq 0x1b8(%rbx), %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq %r14, %rcx
jne 0x9367
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x98ce(%rip), %rdi      # 0x12c1d
leaq 0x98cb(%rip), %rsi      # 0x12c21
leaq 0x99aa(%rip), %rcx      # 0x12d07
movl $0xf6, %edx
callq 0x2180
leaq 0x99c2(%rip), %rdi      # 0x12d30
leaq 0x98ac(%rip), %rsi      # 0x12c21
leaq 0x998b(%rip), %rcx      # 0x12d07
movl $0xfd, %edx
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: Quake3BSP::ReadLeafSurfaces(void const*)
void Quake3BSP::ReadLeafSurfaces(const void *mem)
{
  assert( mOk );
  int lsize;
  int lcount;
  const int *nodes= (const int *) mHeader.LumpInfo(Q3_LFACES,mem,lsize,lcount);


  mLeafSurfaces.assign(nodes,nodes+lcount);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, (%rdi)
je 0x93d6
movq %rsi, %rdx
movq %rdi, %rbx
addq $0x18, %rdi
leaq -0x18(%rbp), %rcx
leaq -0x14(%rbp), %r14
movl $0x5, %esi
movq %r14, %r8
callq 0x970a
addq $0x158, %rbx            # imm = 0x158
movslq (%r14), %rcx
leaq (%rax,%rcx,4), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xb23a
leaq 0x9840(%rip), %rdi      # 0x12c1d
leaq 0x983d(%rip), %rsi      # 0x12c21
leaq 0x995e(%rip), %rcx      # 0x12d49
movl $0x104, %edx            # imm = 0x104
callq 0x2180
nop
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: Quake3BSP::ReadNodes(void const*)
void Quake3BSP::ReadNodes(const void *mem)
{
  assert( mOk );
  int lsize;
  int lcount;
  const dnode_t *nodes= (const dnode_t *) mHeader.LumpInfo(Q3_NODES,mem,lsize,lcount);


  mNodes.assign(nodes,nodes+lcount);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, (%rdi)
je 0x944a
movq %rsi, %rdx
movq %rdi, %rbx
addq $0x18, %rdi
leaq -0x18(%rbp), %rcx
leaq -0x14(%rbp), %r14
movl $0x3, %esi
movq %r14, %r8
callq 0x970a
addq $0x140, %rbx            # imm = 0x140
movslq (%r14), %rcx
leaq (%rcx,%rcx,8), %rcx
leaq (%rax,%rcx,4), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xafbe
leaq 0x97cc(%rip), %rdi      # 0x12c1d
leaq 0x97c9(%rip), %rsi      # 0x12c21
leaq 0x9880(%rip), %rcx      # 0x12cdf
movl $0xe9, %edx
callq 0x2180
nop
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: Quake3BSP::ReadEntities(void const*)
void Quake3BSP::ReadEntities(const void *mem)
{
  assert( mOk );
  int lsize;
  int lcount;
  
  const char *elements = (const char *) mHeader.LumpInfo(Q3_ENTITIES,mem,lsize,lcount);
  assert( lsize == sizeof(char) );

  mEntities.clear();

  const char *estart=elements;
  const char *p=estart;
  int level=0;
  for (int i=0; i<lcount; i++)
  {
	 if (*p == '{') {
		 level++;
		 if (level == 1) estart = p+1;
	 } else if (*p == '}') {
		 level--;
		 if (level == 0) {
			EntityReference *e=new EntityReference(estart,p-estart-1);

		    mEntities.push_back(*e);
			estart = p+1;
		 }
	 }
	 p++;

  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpb $0x0, (%rdi)
je 0x9549
movq %rsi, %rdx
movq %rdi, %rbx
addq $0x18, %rdi
leaq -0x3c(%rbp), %r15
leaq -0x2c(%rbp), %r8
xorl %esi, %esi
movq %r15, %rcx
callq 0x970a
cmpl $0x1, (%r15)
jne 0x9568
movq %rax, %r14
movq 0x1d0(%rbx), %rsi
addq $0x1d0, %rbx            # imm = 0x1D0
movq %rbx, %rdi
callq 0xbb5c
cmpl $0x0, -0x2c(%rbp)
jle 0x953a
movq %r14, %r12
incq %r12
leal -0x1(%r14), %eax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
xorl %r13d, %r13d
movzbl -0x1(%r12), %ecx
cmpl $0x7d, %ecx
je 0x94f7
cmpl $0x7b, %ecx
jne 0x952e
testl %eax, %eax
leal 0x1(%rax), %eax
cmoveq %r12, %r14
jmp 0x952e
decl %eax
jne 0x952e
movl $0x20, %edi
callq 0x2220
movq %rax, %r15
movq -0x38(%rbp), %rax
leal (%rax,%r13), %edx
subl %r14d, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xac70
movq %rbx, %rdi
movq %r15, %rsi
callq 0xacc8
xorl %eax, %eax
movq %r12, %r14
incl %r13d
incq %r12
cmpl -0x2c(%rbp), %r13d
jl 0x94dc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x96cd(%rip), %rdi      # 0x12c1d
leaq 0x96ca(%rip), %rsi      # 0x12c21
leaq 0x9b17(%rip), %rcx      # 0x13075
movl $0x2bd, %edx            # imm = 0x2BD
callq 0x2180
leaq 0x9b31(%rip), %rdi      # 0x130a0
leaq 0x96ab(%rip), %rsi      # 0x12c21
leaq 0x9af8(%rip), %rcx      # 0x13075
movl $0x2c2, %edx            # imm = 0x2C2
callq 0x2180
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x23c0
nop
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: QuakeNode::QuakeNode(int const*)
QuakeNode::QuakeNode(const int *node)
{
  const dnode_t *n = (const dnode_t*) node;

  mPlane = node[0];
  mLeftChild = node[1];
  mRightChild = node[2];

  mBound.r1.x = float( node[3] );
  mBound.r1.y = float( node[4] );
  mBound.r1.z = float( node[5] );
  mBound.r2.x = float( node[6] );
  mBound.r2.y = float( node[7] );
  mBound.r2.z = float( node[8] );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0xa4(%rdi)
movq $0x0, 0xb4(%rdi)
movl (%rsi), %eax
movl %eax, 0x98(%rdi)
movl 0x4(%rsi), %eax
movl %eax, 0x9c(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0xa0(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0xc(%rsi), %xmm0
movss %xmm0, 0xa4(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0x10(%rsi), %xmm0
movss %xmm0, 0xa8(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0x14(%rsi), %xmm0
movss %xmm0, 0xac(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0x18(%rsi), %xmm0
movss %xmm0, 0xb0(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0x1c(%rsi), %xmm0
movss %xmm0, 0xb4(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0x20(%rsi), %xmm0
movss %xmm0, 0xb8(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/vlenhart[P]q3bsp/q3bsp.cpp
// Function: QuakeLeaf::QuakeLeaf(int const*)
QuakeLeaf::QuakeLeaf(const int *node)
{
  const dleaf_t *n = (const dleaf_t*) node;

  mCluster = node[0];
  mArea    = node[1];

  mBound.r1.x = float( node[2] );
  mBound.r1.y = float( node[3] );
  mBound.r1.z = float( node[4] );

  mBound.r2.x = float( node[5] );
  mBound.r2.y = float( node[6] );
  mBound.r2.z = float( node[7] );

  mFirstFace      = node[8];
  mFaceCount      = node[9];
  mFirstUnknown   = node[10];
  mNumberUnknowns = node[11];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movl (%rsi), %eax
movl %eax, (%rdi)
movl 0x4(%rsi), %eax
movl %eax, 0x4(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0x8(%rsi), %xmm0
movss %xmm0, 0x8(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0xc(%rsi), %xmm0
movss %xmm0, 0xc(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0x10(%rsi), %xmm0
movss %xmm0, 0x10(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0x14(%rsi), %xmm0
movss %xmm0, 0x14(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0x18(%rsi), %xmm0
movss %xmm0, 0x18(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0x1c(%rsi), %xmm0
movss %xmm0, 0x1c(%rdi)
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
movl 0x24(%rsi), %eax
movl %eax, 0x24(%rdi)
movl 0x28(%rsi), %eax
movl %eax, 0x28(%rdi)
movl 0x2c(%rsi), %eax
movl %eax, 0x2c(%rdi)
popq %rbp
retq
nop