LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__zexpand(stbi__zbuf*, char*, int)
static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
{
   char *q;
   int cur, limit, old_limit;
   z->zout = zout;
   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
   cur   = (int) (z->zout     - z->zout_start);
   limit = old_limit = (int) (z->zout_end - z->zout_start);
   while (cur + n > limit)
      limit *= 2;
   q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
   STBI_NOTUSED(old_limit);
   if (q == NULL) return stbi__err("outofmem", "Out of memory");
   z->zout_start = q;
   z->zout       = q + cur;
   z->zout_end   = q + limit;
   return 1;
}

// Assembly:
movq %rsi, 0x18(%rdi)
cmpl $0x0, 0x30(%rdi)
je 0x1abe4
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
subq %rdi, %r14
movl 0x28(%rbx), %eax
subl %edi, %eax
addl %r14d, %edx
movl %eax, %ecx
leal (%rcx,%rcx), %eax
cmpl %ecx, %edx
jg 0x1abb1
movslq %ecx, %r15
movq %r15, %rsi
callq 0x4530
testq %rax, %rax
je 0x1abf5
movq %rax, 0x20(%rbx)
movslq %r14d, %rcx
addq %rax, %rcx
movq %rcx, 0x18(%rbx)
addq %rax, %r15
movq %r15, 0x28(%rbx)
pushq $0x1
popq %rax
jmp 0x1ac05
leaq 0x7d59(%rip), %rax      # 0x22944
movq %rax, 0x147de(%rip)     # 0x2f3d0
xorl %eax, %eax
retq
leaq 0x75cd(%rip), %rax      # 0x221c9
movq %rax, 0x147cd(%rip)     # 0x2f3d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__zhuffman_decode(stbi__zbuf*, stbi__zhuffman*)
stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
{
   int b,s;
   if (a->num_bits < 16) stbi__fill_bits(a);
   b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
   if (b) {
      s = b >> 9;
      a->code_buffer >>= s;
      a->num_bits -= s;
      return b & 511;
   }
   return stbi__zhuffman_decode_slowpath(a, z);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0xf, 0x10(%rdi)
jg 0x1ac23
movq %rbx, %rdi
callq 0x1ab34
movl 0x14(%rbx), %edx
movl %edx, %eax
andl $0x1ff, %eax            # imm = 0x1FF
movzwl (%r14,%rax,2), %eax
testl %eax, %eax
je 0x1ac4d
movl %eax, %ecx
shrl $0x9, %ecx
shrl %cl, %edx
movl %edx, 0x14(%rbx)
subl %ecx, 0x10(%rbx)
andl $0x1ff, %eax            # imm = 0x1FF
jmp 0x1acf1
movl %edx, %eax
rolw $0x8, %ax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xf0f, %esi            # imm = 0xF0F
andl %esi, %ecx
andl %esi, %eax
shll $0x4, %eax
orl %ecx, %eax
movl $0x3333, %ecx           # imm = 0x3333
movl %eax, %esi
andl %ecx, %esi
shrl $0x2, %eax
andl %ecx, %eax
leal (%rax,%rsi,4), %eax
movl $0x5555, %ecx           # imm = 0x5555
movl %eax, %esi
andl %ecx, %esi
shrl %eax
andl %ecx, %eax
leal (%rax,%rsi,2), %esi
xorl %eax, %eax
movq %rax, %rcx
incq %rax
cmpl %esi, 0x448(%r14,%rcx,4)
jle 0x1ac89
cmpq $0x7, %rax
jne 0x1aca4
pushq $-0x1
popq %rax
jmp 0x1acf1
movb $0x7, %cl
subb %al, %cl
shrl %cl, %esi
movzwl 0x412(%r14,%rax,2), %ecx
subq %rcx, %rsi
movzwl 0x476(%r14,%rax,2), %edi
addq %rsi, %rdi
movzbl 0x484(%r14,%rdi), %ecx
addq $-0x9, %rcx
cmpq %rax, %rcx
jne 0x1acf9
leaq 0x9(%rax), %rcx
shrl %cl, %edx
movl %edx, 0x14(%rbx)
movl 0x10(%rbx), %ecx
subl %eax, %ecx
addl $-0x9, %ecx
movl %ecx, 0x10(%rbx)
movzwl 0x5a4(%r14,%rdi,2), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7c72(%rip), %rdi      # 0x22972
leaq 0x7592(%rip), %rsi      # 0x22299
leaq 0x7c74(%rip), %rcx      # 0x22982
movl $0xe0a, %edx            # imm = 0xE0A
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__linear_to_rgbe(unsigned char*, float*)
void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
{
   int exponent;
   float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2]));

   if (maxcomp < 1e-32f) {
      rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
   } else {
      float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp;

      rgbe[0] = (unsigned char)(linear[0] * normalize);
      rgbe[1] = (unsigned char)(linear[1] * normalize);
      rgbe[2] = (unsigned char)(linear[2] * normalize);
      rgbe[3] = (unsigned char)(exponent + 128);
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movss (%rsi), %xmm1
movss 0x4(%rsi), %xmm2
maxss 0x8(%rsi), %xmm2
movaps %xmm1, %xmm0
maxss %xmm2, %xmm0
movss 0x76e1(%rip), %xmm2     # 0x229e4
ucomiss %xmm0, %xmm2
jbe 0x1b312
andw $0x0, (%rbx)
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x1b36c
movq %rsi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rdi
movss %xmm1, 0x8(%rsp)
movss %xmm0, 0x4(%rsp)
callq 0x40c0
movb (%r15), %al
mulss 0x76af(%rip), %xmm0     # 0x229e8
divss 0x4(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
movb %cl, (%rbx)
movss 0x4(%r14), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
movb %cl, 0x1(%rbx)
mulss 0x8(%r14), %xmm0
cvttss2si %xmm0, %ecx
addb $-0x80, %al
movb %al, 0x3(%rbx)
movb %cl, 0x2(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__write_run_data(stbi__write_context*, int, unsigned char)
void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)
{
   unsigned char lengthbyte = STBIW_UCHAR(length+128);
   STBIW_ASSERT(length+128 <= 255);
   s->func(s->context, &lengthbyte, 1);
   s->func(s->context, &databyte, 1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb %dl, 0x7(%rsp)
leal -0x80(%rsi), %eax
movb %al, 0x6(%rsp)
cmpl $0x80, %esi
jge 0x1b3b9
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x6(%rsp), %rsi
pushq $0x1
popq %rbp
movl %ebp, %edx
callq *(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x7(%rsp), %rsi
movl %ebp, %edx
callq *(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7ba0(%rip), %rdi      # 0x22f60
leaq 0x7bab(%rip), %rsi      # 0x22f72
leaq 0x7bc1(%rip), %rcx      # 0x22f8f
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__write_dump_data(stbi__write_context*, int, unsigned char*)
void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
{
   unsigned char lengthbyte = STBIW_UCHAR(length);
   STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
   s->func(s->context, &lengthbyte, 1);
   s->func(s->context, data, length);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movb %bpl, 0xf(%rsp)
cmpl $0x81, %esi
jge 0x1b417
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0xf(%rsp), %rsi
pushq $0x1
popq %rdx
callq *(%rbx)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq *(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7bb7(%rip), %rdi      # 0x22fd5
leaq 0x7b4d(%rip), %rsi      # 0x22f72
leaq 0x7bb7(%rip), %rcx      # 0x22fe3
movl $0x1fd, %edx            # imm = 0x1FD
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbi_write_hdr_core(stbi__write_context*, int, int, int, float*)
static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)
{
   if (y <= 0 || x <= 0 || data == NULL)
      return 0;
   else {
      // Each component is stored separately. Allocate scratch space for full output scanline.
      unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
      int i, len;
      char buffer[128];
      char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
      s->func(s->context, header, sizeof(header)-1);

      len = sprintf(buffer, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
      s->func(s->context, buffer, len);

      for(i=0; i < y; i++)
         stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*i*x);
      STBIW_FREE(scratch);
      return 1;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %ecx, %ebp
movl %edx, %ebx
testl %edx, %edx
setle %al
testl %esi, %esi
setle %cl
orb %al, %cl
movq %r8, 0x18(%rsp)
testq %r8, %r8
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x1b7c7
movl %esi, %r14d
movq %rdi, %r15
leal (,%r14,4), %edi
callq 0x4420
movq %rax, 0x10(%rsp)
leaq 0x7a8b(%rip), %rsi      # 0x231c0
pushq $0x42
popq %rcx
leaq 0x20(%rsp), %rax
movq %rax, %rdi
rep  movsb (%rsi), %es:(%rdi)
movq 0x8(%r15), %rdi
pushq $0x41
popq %rdx
movq %rax, %rsi
callq *(%r15)
leaq 0x7a0e(%rip), %rsi      # 0x23164
xorl %r13d, %r13d
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movl %ebx, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x40a0
movq 0x8(%r15), %rdi
movq %r12, %rsi
movl %eax, %edx
movl %ebx, 0xc(%rsp)
movq %r14, %rbx
movq %r15, %r14
callq *(%r15)
movl %ebp, %r15d
movq %rbx, %r12
imull %ebx, %ebp
movl 0xc(%rsp), %ebx
subq $0x1, %rbx
jb 0x1b7ba
movslq %r13d, %r13
movq 0x18(%rsp), %rax
leaq (%rax,%r13,4), %r8
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
movq 0x10(%rsp), %rcx
callq 0x1b436
addl %ebp, %r13d
jmp 0x1b790
movq 0x10(%rsp), %rdi
callq 0x43a0
pushq $0x1
popq %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// 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_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1bf50
movl -0x8(%rax), %ecx
leal 0x1(,%rcx,2), %ebp
jmp 0x1bf53
pushq $0x2
popq %rbp
leaq -0x8(%rax), %rdi
testq %rax, %rax
cmoveq %rax, %rdi
imull %ebp, %esi
movslq %esi, %rsi
addq $0x8, %rsi
callq 0x4530
testq %rax, %rax
je 0x1bf8f
cmpq $0x0, (%rbx)
jne 0x1bf7c
andl $0x0, 0x4(%rax)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, (%rbx)
movl %ebp, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5091(%rip), %rdi      # 0x21027
leaq 0x6fd5(%rip), %rsi      # 0x22f72
leaq 0x71f1(%rip), %rcx      # 0x23195
movl $0x29b, %edx            # imm = 0x29B
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// 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, STBIW_UCHAR(*bitbuffer));
      *bitbuffer >>= 8;
      *bitcount -= 8;
   }
   return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rax
movq %rsp, %r15
movq %rdi, (%r15)
movl (%rdx), %ecx
pushq $0x1
popq %rbp
cmpl $0x8, %ecx
jl 0x1c00c
testq %rax, %rax
je 0x1bfde
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jl 0x1bff2
movq %r15, %rdi
movl %ebp, %esi
callq 0x1bf36
movq (%rsp), %rax
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movb (%r14), %sil
movl %edx, -0x4(%rax)
movslq %ecx, %rcx
movb %sil, (%rax,%rcx)
shrl $0x8, (%r14)
movl (%rbx), %ecx
addl $-0x8, %ecx
movl %ecx, (%rbx)
jmp 0x1bfc9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__zhash(unsigned char*)
static unsigned int stbiw__zhash(unsigned char *data)
{
   stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
   hash ^= hash << 3;
   hash += hash >> 5;
   hash ^= hash << 4;
   hash += hash >> 17;
   hash ^= hash << 25;
   hash += hash >> 6;
   return hash;
}

// Assembly:
movzwl (%rdi), %eax
movzbl 0x2(%rdi), %ecx
shll $0x10, %ecx
orl %eax, %ecx
leal (,%rcx,8), %eax
xorl %ecx, %eax
movl %eax, %ecx
shrl $0x5, %ecx
addl %eax, %ecx
movl %ecx, %eax
shll $0x4, %eax
xorl %ecx, %eax
movl %eax, %ecx
shrl $0x11, %ecx
addl %eax, %ecx
movl %ecx, %edx
shll $0x19, %edx
xorl %ecx, %edx
movl %edx, %eax
shrl $0x6, %eax
addl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__zlib_countm(unsigned char*, unsigned char*, int)
static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)
{
   int i;
   for (i=0; i < limit && i < 258; ++i)
      if (a[i] != b[i]) break;
   return i;
}

// Assembly:
movslq %edx, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jge 0x1c06f
cmpq $0x101, %rax            # imm = 0x101
ja 0x1c06f
movb (%rdi,%rax), %dl
cmpb (%rsi,%rax), %dl
jne 0x1c06f
incq %rax
jmp 0x1c055
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__zlib_bitrev(int, int)
static int stbiw__zlib_bitrev(int code, int codebits)
{
   int res=0;
   while (codebits--) {
      res = (res << 1) | (code & 1);
      code >>= 1;
   }
   return res;
}

// Assembly:
xorl %eax, %eax
subl $0x1, %esi
jb 0x1c083
movl %edi, %ecx
andl $0x1, %ecx
leal (%rcx,%rax,2), %eax
sarl %edi
jmp 0x1c072
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbi_write_png
STBIWDEF 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 == NULL) 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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %r9d, %r10d
movl %ecx, %eax
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %r14
leaq 0xc(%rsp), %r9
movq %r8, %rdi
movl %r10d, %esi
movl %eax, %r8d
callq 0x1c084
testq %rax, %rax
je 0x1c6e9
movq %rax, %rbx
leaq 0x6a36(%rip), %rsi      # 0x230ef
movq %r14, %rdi
callq 0x4390
testq %rax, %rax
je 0x1c6ed
movq %rax, %r14
movslq 0xc(%rsp), %rdx
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
callq 0x4640
movq %r14, %rdi
callq 0x4310
pushq $0x1
popq %rbp
jmp 0x1c6ef
xorl %ebp, %ebp
jmp 0x1c6f7
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x43a0
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbi_write_png_to_func
STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
{
   int len;
   unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (png == NULL) return 0;
   func(context, png, len);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x30(%rsp), %esi
leaq 0xc(%rsp), %r9
movq %rax, %rdi
callq 0x1c084
testq %rax, %rax
je 0x1c746
movq %rax, %r15
movl 0xc(%rsp), %edx
movq %r14, %rdi
movq %rax, %rsi
callq *%rbx
movq %r15, %rdi
callq 0x43a0
pushq $0x1
popq %rax
jmp 0x1c748
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__outfile(stbi__write_context*, int, int, int, int, int, int, void*, int, int, char const*, ...)
static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)
{
   if (y < 0 || x < 0) {
      return 0;
   } else {
      va_list v;
      va_start(v, fmt);
      stbiw__writefv(s, fmt, v);
      va_end(v);
      stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono);
      return 1;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
testb %al, %al
je 0x1c7a7
movaps %xmm0, 0x80(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm3, 0xb0(%rsp)
movaps %xmm4, 0xc0(%rsp)
movaps %xmm5, 0xd0(%rsp)
movaps %xmm6, 0xe0(%rsp)
movaps %xmm7, 0xf0(%rsp)
movl %r8d, %eax
orl %ecx, %eax
js 0x1c89c
movl %r9d, %r12d
movl %r8d, %r13d
movl %ecx, %ebp
movq %rdi, %rbx
movq 0x160(%rsp), %rsi
leaq 0x50(%rsp), %rax
leaq 0x30(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x168(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000030, %rax     # imm = 0x3000000030
movq %rax, (%rdx)
callq 0x1c8b0
andl $0x0, 0xc(%rsp)
testl %r13d, %r13d
jle 0x1c897
movl 0x150(%rsp), %r14d
movl 0x140(%rsp), %r15d
movslq %r12d, %r12
xorl %eax, %eax
testl %ebp, %ebp
cmovgl %ebp, %eax
movq %rax, 0x18(%rsp)
movl %r13d, %eax
movslq %ebp, %rcx
leaq -0x1(%rax), %rbp
imulq %r12, %rcx
imulq %rcx, %rbp
addq 0x148(%rsp), %rbp
negq %rcx
movq %rcx, 0x10(%rsp)
subq $0x1, %rax
jb 0x1c897
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %r13
movq %rbp, 0x20(%rsp)
subq $0x1, %r13
jb 0x1c874
movq %rbx, %rdi
movl %r12d, %esi
movl %r14d, %edx
movl %r15d, %ecx
movq %rbp, %r8
callq 0x1c9da
addq %r12, %rbp
jmp 0x1c855
movq 0x8(%rbx), %rdi
leaq 0xc(%rsp), %rsi
movl 0x158(%rsp), %edx
callq *(%rbx)
movq 0x20(%rsp), %rbp
addq 0x10(%rsp), %rbp
movq 0x28(%rsp), %rax
jmp 0x1c840
pushq $0x1
popq %rax
jmp 0x1c89e
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__writefv(stbi__write_context*, char const*, __va_list_tag*)
static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v)
{
   while (*fmt) {
      switch (*fmt++) {
         case ' ': break;
         case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int));
                     s->func(s->context,&x,1);
                     break; }
         case '2': { int x = va_arg(v,int);
                     unsigned char b[2];
                     b[0] = STBIW_UCHAR(x);
                     b[1] = STBIW_UCHAR(x>>8);
                     s->func(s->context,b,2);
                     break; }
         case '4': { stbiw_uint32 x = va_arg(v,int);
                     unsigned char b[4];
                     b[0]=STBIW_UCHAR(x);
                     b[1]=STBIW_UCHAR(x>>8);
                     b[2]=STBIW_UCHAR(x>>16);
                     b[3]=STBIW_UCHAR(x>>24);
                     s->func(s->context,b,4);
                     break; }
         default:
            STBIW_ASSERT(0);
            return;
      }
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x2
popq %r12
leaq 0x1(%rsp), %rbp
pushq $0x1
popq %r13
movzbl (%r14), %eax
testl %eax, %eax
je 0x1c9ac
incq %r14
cmpl $0x20, %eax
je 0x1c8d1
cmpl $0x34, %eax
je 0x1c924
cmpl $0x32, %eax
je 0x1c90e
cmpl $0x31, %eax
jne 0x1c9bb
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x1c962
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x1c96e
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x1c93a
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x1c946
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x1c986
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x1c992
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movzwl (%rax), %eax
movw %ax, 0x2(%rsp)
movq 0x8(%r15), %rdi
leaq 0x2(%rsp), %rsi
movl %r12d, %edx
callq *(%r15)
jmp 0x1c8d1
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %al
movb %al, 0x1(%rsp)
movq 0x8(%r15), %rdi
movq %rbp, %rsi
movl %r13d, %edx
callq *(%r15)
jmp 0x1c8d1
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%r15), %rdi
leaq 0x4(%rsp), %rsi
pushq $0x4
popq %rdx
callq *(%r15)
jmp 0x1c8d1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f31(%rip), %rdi      # 0x228f3
leaq 0x65a9(%rip), %rsi      # 0x22f72
leaq 0x673a(%rip), %rcx      # 0x2310a
movl $0x109, %edx            # imm = 0x109
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__write_pixel(stbi__write_context*, int, int, int, int, unsigned char*)
static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)
{
   unsigned char bg[3] = { 255, 0, 255}, px[3];
   int k;

   if (write_alpha < 0)
      s->func(s->context, &d[comp - 1], 1);

   switch (comp) {
      case 1:
         s->func(s->context,d,1);
         break;
      case 2:
         if (expand_mono)
            stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp
         else
            s->func(s->context, d, 1);  // monochrome TGA
         break;
      case 4:
         if (!write_alpha) {
            // composite against pink background
            for (k = 0; k < 3; ++k)
               px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255;
            stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]);
            break;
         }
         /* FALLTHROUGH */
      case 3:
         stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]);
         break;
   }
   if (write_alpha > 0)
      s->func(s->context, &d[comp - 1], 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
leal -0x1(%r15), %eax
cmpl $0x3, %eax
ja 0x1ca4f
leaq 0x6029(%rip), %rdx      # 0x22a28
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
testl %ecx, %ecx
je 0x1ca1e
movb (%r14), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movb %al, 0x1(%rsi)
movb %al, 0x2(%rsi)
jmp 0x1ca46
movq 0x8(%rbx), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
jmp 0x1ca4d
testl %ebp, %ebp
je 0x1ca71
movb 0x2(%r14), %al
movb (%r14), %cl
movb 0x1(%r14), %dl
leaq 0x15(%rsp), %rsi
movb %al, (%rsi)
movb %dl, 0x1(%rsi)
movb %cl, 0x2(%rsi)
movq 0x8(%rbx), %rdi
pushq $0x3
popq %rdx
callq *(%rbx)
testl %ebp, %ebp
jle 0x1ca66
movq 0x8(%rbx), %rdi
movslq %r15d, %rax
leaq (%r14,%rax), %rsi
decq %rsi
pushq $0x1
popq %rdx
callq *(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl 0x3(%r14), %ecx
xorl %esi, %esi
leaq 0x60d5(%rip), %rdi      # 0x22b54
movl $0xff, %r8d
cmpq $0x3, %rsi
je 0x1caab
movzbl (%rsi,%rdi), %r9d
movzbl (%r14,%rsi), %eax
subl %r9d, %eax
imull %ecx, %eax
cltd
idivl %r8d
addb %r9b, %al
movb %al, 0xc(%rsp,%rsi)
incq %rsi
jmp 0x1ca85
movb 0xe(%rsp), %al
movb 0xc(%rsp), %cl
movb 0xd(%rsp), %dl
leaq 0x12(%rsp), %rsi
jmp 0x1ca3e
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/Frame.cpp
// Function: Frame::setColor(Sample const&, RGB)
void
Frame::setColor(Sample const & s, RGB c)
{
  c.clip(0, 1);

  int xi = (int)std::floor(s.x() * image.width());
  int yi = (int)std::floor((1 - s.y()) * image.height());

  unsigned char * pixel = image.pixel(yi, xi);
  pixel[0] = c.getBMPR(0, 1);
  pixel[1] = c.getBMPG(0, 1);
  pixel[2] = c.getBMPB(0, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movsd 0x4547(%rip), %xmm1     # 0x21100
xorps %xmm0, %xmm0
movq %rdx, %rdi
callq 0x1cc9a
movl 0x8(%r14), %ebp
cvtsi2sd %ebp, %xmm0
mulsd (%r15), %xmm0
callq 0x4560
cvttsd2si %xmm0, %r12d
movsd 0x451d(%rip), %xmm1     # 0x21100
subsd 0x8(%r15), %xmm1
cvtsi2sdl 0xc(%r14), %xmm0
mulsd %xmm1, %xmm0
callq 0x4560
cvttsd2si %xmm0, %ecx
movq 0x18(%r14), %rax
imull %ebp, %ecx
addl %r12d, %ecx
movslq 0x10(%r14), %rdx
movslq %ecx, %rcx
imulq %rdx, %rcx
movsd 0x65ef(%rip), %xmm0     # 0x23208
movsd (%rbx), %xmm1
mulsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %edx
movb %dl, (%rax,%rcx)
movsd 0x8(%rbx), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %edx
movb %dl, 0x1(%rax,%rcx)
mulsd 0x10(%rbx), %xmm0
addsd %xmm2, %xmm0
cvttsd2si %xmm0, %edx
movb %dl, 0x2(%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/Lights.cpp
// Function: AreaLight::getShadowRays(Vec3 const&, bool&) const
vector<Ray>
AreaLight::getShadowRays(Vec3 const & position, bool & use_dist) const
{
  use_dist = true;
  vector<Ray> v;

  // generated rays from position to all the offset point lights
  for (double i = -1; i < 2; i++)
    for (double j = -1; j < 2; j++)
        for (double k = -1; k < 2; k++)
          v.push_back(Ray::fromOriginAndEnd(position, pos_ 
                                          + Vec3(i*offset_, j*offset_, k*offset_)));
  return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb $0x1, (%rcx)
andq $0x0, 0x10(%rdi)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movsd 0x60bf(%rip), %xmm1     # 0x23230
leaq 0x40(%rsp), %r12
movsd 0x475a(%rip), %xmm0     # 0x218d8
ucomisd %xmm1, %xmm0
jbe 0x1d27f
movapd %xmm1, 0x10(%rsp)
movsd 0x609a(%rip), %xmm1     # 0x23230
movsd 0x473a(%rip), %xmm0     # 0x218d8
ucomisd %xmm1, %xmm0
jbe 0x1d26c
movapd 0x10(%rsp), %xmm0
movapd %xmm1, 0x20(%rsp)
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movapd %xmm0, 0x30(%rsp)
movsd 0x606a(%rip), %xmm1     # 0x23230
movsd 0x470a(%rip), %xmm0     # 0x218d8
ucomisd %xmm1, %xmm0
jbe 0x1d259
movsd 0x38(%r15), %xmm0
movsd %xmm1, 0x8(%rsp)
mulsd %xmm0, %xmm1
addsd 0x50(%r15), %xmm1
movsd 0x10(%r14), %xmm2
subsd %xmm2, %xmm1
movsd %xmm2, 0x50(%rsp)
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd 0x30(%rsp), %xmm0
movupd 0x40(%r15), %xmm2
addpd %xmm0, %xmm2
movupd (%r14), %xmm0
subpd %xmm0, %xmm2
movapd %xmm0, 0x40(%rsp)
movupd %xmm2, 0x58(%rsp)
movsd %xmm1, 0x68(%rsp)
movapd 0x600b(%rip), %xmm0     # 0x23240
movapd %xmm0, 0x70(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1d59e
movsd 0x8(%rsp), %xmm1
addsd 0x3eac(%rip), %xmm1     # 0x21100
jmp 0x1d1c6
movapd 0x20(%rsp), %xmm1
addsd 0x3e99(%rip), %xmm1     # 0x21100
jmp 0x1d196
movapd 0x10(%rsp), %xmm1
addsd 0x3e86(%rip), %xmm1     # 0x21100
jmp 0x1d176
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d47a
movq %r14, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/Primitives.cpp
// Function: Primitive::Primitive(RGB const&, Material const&, Mat4 const&)
Primitive::Primitive(RGB const & c, Material const & m, Mat4 const & modelToWorld)
{
  c_ = c;
  m_ = m;
  modelToWorld_ = modelToWorld;
  worldToModel_ = modelToWorld.inverse();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rcx, %rbx
leaq 0x1156a(%rip), %rax     # 0x2ec88
movq %rax, (%rdi)
leaq 0x8(%rdi), %rax
leaq 0x88(%rdi), %r14
andq $0x0, 0x118(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x108(%rdi)
movsd (%rsi), %xmm0
movsd %xmm0, 0x108(%rdi)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x110(%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x118(%rdi)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm0, 0x120(%rdi)
movups %xmm1, 0x130(%rdi)
movq %rax, %rdi
movq %rcx, %rsi
callq 0x61ac
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1e0b4
movq %r14, %rdi
movq %r15, %rsi
callq 0x61ac
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/Primitives.cpp
// Function: Sphere::intersect(Ray&) const
bool
Sphere::intersect(Ray & ray) const
{
  Vec3 s, d;
  double dis, t;

  Ray new_ray = ray;
  new_ray.transform(worldToModel_);
  s = new_ray.start();
  d = new_ray.direction();

  dis = ((d*s)*(d*s)) - (d.length2() * (s.length2() - r_*r_));

  if (dis < 0)
    return false;

  dis = std::sqrt(dis);
  t = ((-d*s) - dis)/d.length2();

  if (t < -EPS)
    t = ((-d*s) + dis)/d.length2();

  if (t > EPS and ray.minT() > t)
  {
    ray.setMinT(t);
    return true;
  }

  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movups (%rsi), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movups 0x10(%rsi), %xmm0
movaps %xmm0, 0x10(%r15)
movups 0x20(%rsi), %xmm0
movaps %xmm0, 0x20(%r15)
movups 0x30(%rsi), %xmm0
movaps %xmm0, 0x30(%r15)
leaq 0x88(%rdi), %rsi
movq %r15, %rdi
callq 0x1e2ca
movsd (%r15), %xmm7
movsd 0x8(%r15), %xmm2
movsd 0x10(%r15), %xmm1
movsd 0x18(%r15), %xmm5
movsd 0x20(%r15), %xmm3
movsd 0x28(%r15), %xmm6
movapd %xmm2, %xmm8
mulsd %xmm3, %xmm8
movapd %xmm5, %xmm0
mulsd %xmm7, %xmm0
addsd %xmm8, %xmm0
movapd %xmm6, %xmm9
mulsd %xmm1, %xmm9
addsd %xmm9, %xmm0
mulsd %xmm3, %xmm3
movapd %xmm5, %xmm4
mulsd %xmm5, %xmm4
addsd %xmm3, %xmm4
mulsd %xmm6, %xmm6
addsd %xmm4, %xmm6
mulsd %xmm2, %xmm2
movapd %xmm7, %xmm3
mulsd %xmm7, %xmm3
addsd %xmm2, %xmm3
mulsd %xmm1, %xmm1
addsd %xmm3, %xmm1
movsd 0x140(%r14), %xmm2
mulsd %xmm2, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm6, %xmm1
mulsd %xmm0, %xmm0
subsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1d8ca
xorl %eax, %eax
jmp 0x1d97a
ucomisd %xmm1, %xmm0
jb 0x1d8d6
sqrtsd %xmm0, %xmm0
jmp 0x1d919
movapd %xmm5, 0x20(%rsp)
movsd %xmm6, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm8, 0x8(%rsp)
movsd %xmm9, (%rsp)
callq 0x4280
movsd (%rsp), %xmm9
movsd 0x8(%rsp), %xmm8
movsd 0x10(%rsp), %xmm7
movsd 0x18(%rsp), %xmm6
movapd 0x20(%rsp), %xmm5
xorpd 0x380f(%rip), %xmm5     # 0x21130
mulsd %xmm7, %xmm5
subsd %xmm8, %xmm5
subsd %xmm9, %xmm5
movapd %xmm5, %xmm1
subsd %xmm0, %xmm1
divsd %xmm6, %xmm1
addsd %xmm0, %xmm5
movapd %xmm1, %xmm0
cmpltsd 0x59f4(%rip), %xmm0     # 0x23340
divsd %xmm6, %xmm5
andpd %xmm0, %xmm5
andnpd %xmm1, %xmm0
orpd %xmm5, %xmm0
xorl %eax, %eax
ucomisd 0x59e2(%rip), %xmm0     # 0x23348
jbe 0x1d97a
movsd 0x30(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1d97a
movsd %xmm0, 0x30(%rbx)
movb $0x1, %al
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/Primitives.cpp
// Function: Sphere::calculateNormal(Vec3 const&) const
Vec3
Sphere::calculateNormal(Vec3 const & position) const
{ 
  // norm is the point's position in the model coordinates
  Vec3 norm = worldToModel_ * position;
  // restoring the normal back to the world coordinates
  return Vec3(worldToModel_.transpose() * Vec4(norm, 0), 3).normalize();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
addq $0x88, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e3bb
leaq 0x88(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1e4d4
movaps (%r15), %xmm0
leaq 0x40(%rsp), %rdx
movaps %xmm0, (%rdx)
movsd 0x10(%r15), %xmm0
movsd %xmm0, 0x10(%rdx)
andq $0x0, 0x18(%rdx)
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x1e40c
movaps (%r14), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x10(%rdi)
callq 0xa1b2
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/Algebra3.hpp
// Function: operator*(Mat4 const&, Vec4 const&)
inline Vec4 operator * (Mat4 const & a, Vec4 const & v)
{
#define ALG3_ROWCOL(i) a.v[i].n[0]*v.n[0] + a.v[i].n[1]*v.n[1] \
                     + a.v[i].n[2]*v.n[2] + a.v[i].n[3]*v.n[3]
  return Vec4(ALG3_ROWCOL(0), ALG3_ROWCOL(1), ALG3_ROWCOL(2), ALG3_ROWCOL(3));
#undef ALG3_ROWCOL // (i)
}

// Assembly:
movq %rdi, %rax
movupd (%rdx), %xmm3
movupd 0x8(%rdx), %xmm5
movupd 0x10(%rdx), %xmm0
movupd (%rsi), %xmm9
movupd 0x8(%rsi), %xmm10
movupd 0x10(%rsi), %xmm8
movupd 0x18(%rsi), %xmm7
movupd 0x40(%rsi), %xmm4
movupd 0x48(%rsi), %xmm6
movupd 0x50(%rsi), %xmm1
movupd 0x58(%rsi), %xmm2
movhpd 0x28(%rsi), %xmm10      # xmm10 = xmm10[0],mem[0]
unpcklpd %xmm5, %xmm5            # xmm5 = xmm5[0,0]
mulpd %xmm5, %xmm10
movhpd 0x20(%rsi), %xmm9       # xmm9 = xmm9[0],mem[0]
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm3, %xmm9
movhpd 0x30(%rsi), %xmm8       # xmm8 = xmm8[0],mem[0]
addpd %xmm10, %xmm9
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm0, %xmm8
addpd %xmm9, %xmm8
movhpd 0x38(%rsi), %xmm7       # xmm7 = xmm7[0],mem[0]
movsd 0x18(%rdx), %xmm9
unpcklpd %xmm9, %xmm9            # xmm9 = xmm9[0,0]
mulpd %xmm9, %xmm7
addpd %xmm8, %xmm7
movhpd 0x68(%rsi), %xmm6       # xmm6 = xmm6[0],mem[0]
movhpd 0x60(%rsi), %xmm4       # xmm4 = xmm4[0],mem[0]
movhpd 0x70(%rsi), %xmm1       # xmm1 = xmm1[0],mem[0]
movhpd 0x78(%rsi), %xmm2       # xmm2 = xmm2[0],mem[0]
movupd %xmm7, (%rdi)
mulpd %xmm5, %xmm6
mulpd %xmm3, %xmm4
addpd %xmm6, %xmm4
mulpd %xmm0, %xmm1
addpd %xmm4, %xmm1
mulpd %xmm9, %xmm2
addpd %xmm1, %xmm2
movupd %xmm2, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/Algebra3.hpp
// Function: Mat4::transpose() const
inline Mat4 Mat4::transpose() const
{
  return Mat4(Vec4(v[0][0], v[1][0], v[2][0], v[3][0]),
              Vec4(v[0][1], v[1][1], v[2][1], v[3][1]),
              Vec4(v[0][2], v[1][2], v[2][2], v[3][2]),
              Vec4(v[0][3], v[1][3], v[2][3], v[3][3]));
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movsd (%rsi), %xmm0
movsd 0x20(%rsi), %xmm1
movsd 0x40(%rsi), %xmm2
movsd 0x60(%rsi), %xmm3
leaq 0x60(%rsp), %rsi
movsd %xmm0, (%rsi)
movsd %xmm1, 0x8(%rsi)
movsd %xmm2, 0x10(%rsi)
movsd %xmm3, 0x18(%rsi)
movsd 0x8(%rax), %xmm0
movsd 0x28(%rax), %xmm1
movsd 0x48(%rax), %xmm2
movsd 0x68(%rax), %xmm3
leaq 0x40(%rsp), %rdx
movsd %xmm0, (%rdx)
movsd %xmm1, 0x8(%rdx)
movsd %xmm2, 0x10(%rdx)
movsd %xmm3, 0x18(%rdx)
movsd 0x10(%rax), %xmm0
movsd 0x30(%rax), %xmm1
movsd 0x50(%rax), %xmm2
movsd 0x70(%rax), %xmm3
leaq 0x20(%rsp), %rcx
movsd %xmm0, (%rcx)
movsd %xmm1, 0x8(%rcx)
movsd %xmm2, 0x10(%rcx)
movsd %xmm3, 0x18(%rcx)
movsd 0x18(%rax), %xmm0
movsd 0x38(%rax), %xmm1
movsd 0x58(%rax), %xmm2
movsd 0x78(%rax), %xmm3
movq %rsp, %r8
movsd %xmm0, (%r8)
movsd %xmm1, 0x8(%r8)
movsd %xmm2, 0x10(%r8)
movsd %xmm3, 0x18(%r8)
callq 0x64c6
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/Algebra3.hpp
// Function: Vec3::Vec3(Vec4 const&)
inline Vec3::Vec3(Vec4 const & v)  // caller should avoid divide-by-zero, the test here is not foolproof
{
  n[0] = v.n[0];
  n[1] = v.n[1];
  n[2] = v.n[2];

  if (v.n[3] != 0)  // dangerous test!
  {
    n[0] /= v.n[3];
    n[1] /= v.n[3];
    n[2] /= v.n[3];
  }
}

// Assembly:
movsd (%rsi), %xmm2
movsd %xmm2, (%rdi)
movsd 0x8(%rsi), %xmm1
movsd %xmm1, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rsi), %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm3
jne 0x1e725
jnp 0x1e741
divsd %xmm3, %xmm2
movsd %xmm2, (%rdi)
divsd 0x18(%rsi), %xmm1
movsd %xmm1, 0x8(%rdi)
divsd 0x18(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/View.cpp
// Function: View::getSample(int, int, int, Sample&) const
void
View::getSample(int pixel_x, int pixel_y, int ray_index, Sample & s) const
{
  // Some random jitter to break up patterns
  double jitter_x = 0.25 * (std::rand() / (double)RAND_MAX);
  double jitter_y = 0.25 * (std::rand() / (double)RAND_MAX);

  double pixel_sub_x = (ray_index % rays_per_pixel_edge_ + 0.5 + jitter_x) / (double)rays_per_pixel_edge_;
  double pixel_sub_y = (ray_index / rays_per_pixel_edge_ + 0.5 + jitter_y) / (double)rays_per_pixel_edge_;

  s.setX((pixel_x + pixel_sub_x) / (double)pixels_wide_);
  s.setY((pixel_y + pixel_sub_y) / (double)pixels_high_);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
callq 0x40f0
movl %eax, %r13d
callq 0x40f0
movl %eax, %ecx
movl 0x88(%r14), %esi
cvtsi2sd %esi, %xmm0
movl %ebp, %eax
cltd
movd %r15d, %xmm1
movd %r12d, %xmm2
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
cvtdq2pd %xmm2, %xmm1
movd %r13d, %xmm2
movd %ecx, %xmm3
punpckldq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
cvtdq2pd %xmm2, %xmm2
divpd 0x4b19(%rip), %xmm2     # 0x23390
mulpd 0x4b21(%rip), %xmm2     # 0x233a0
idivl %esi
movd %eax, %xmm3
movd %edx, %xmm4
punpckldq %xmm3, %xmm4    # xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1]
cvtdq2pd %xmm4, %xmm3
addpd 0x4b17(%rip), %xmm3     # 0x233b0
addpd %xmm2, %xmm3
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
cvtdq2pd 0x80(%r14), %xmm2
divpd %xmm0, %xmm3
addpd %xmm1, %xmm3
divpd %xmm2, %xmm3
movupd %xmm3, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/World.cpp
// Function: World::intersect(Ray&) const
Primitive *
World::intersect(Ray & r) const
{
  Primitive * intersecting = NULL;
    
  // iterate over primitives to find a smaller intersection
  for (auto it = primitivesBegin(); it != primitivesEnd(); it++)
  	if ((*it)->intersect(r))
  		intersecting = *it;

  return intersecting;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
xorl %r15d, %r15d
cmpq 0x10(%r14), %r12
je 0x1eb20
movq (%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
testb %al, %al
je 0x1eb1a
movq (%r12), %r15
addq $0x8, %r12
jmp 0x1eaff
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/main.cpp
// Function: traceRay(Ray&, int)
RGB
traceRay(Ray & ray, int depth)
{   
  if (depth > max_trace_depth)
    return RGB(0, 0, 0);

  auto z = world->intersect(ray);

  if (z != NULL) {

    // intersection point
    auto pos = ray.getPos(ray.minT());
    // get color at that point
    auto col = getShadedColor(*z, pos, ray);

    // reflection
    Ray refl = getReflectedRay(z, pos, ray);
    col += z->getMaterial().getMR() * z->getColor() * traceRay(refl, depth+1);

    // refraction
    if (z->getMaterial().getMT() > 0)
    {
      Ray refr = getRefractedRay(z, pos, ray);
      col += z->getMaterial().getMT() * traceRay(refr, depth+1);
    }

    return col;
  }
    
  return RGB(0, 0, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
cmpl %edx, 0xfe5a(%rip)      # 0x2f3b0
jl 0x1f6a6
movl %edx, %ebp
movq %rsi, %r14
movq 0xffe0(%rip), %rdi      # 0x2f548
callq 0x1eaea
testq %rax, %rax
je 0x1f6a6
movq %rax, %r15
movsd 0x30(%r14), %xmm0
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x202ca
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1ef28
leaq 0xb8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x202fa
cvtss2sd 0x134(%r15), %xmm1
movsd 0x118(%r15), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
incl %ebp
movupd 0x108(%r15), %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x1f53c
movapd 0x10(%rsp), %xmm1
mulpd (%r12), %xmm1
movsd (%rsp), %xmm0
mulsd 0x10(%r12), %xmm0
leaq 0x70(%rsp), %rsi
movapd %xmm1, (%rsi)
movsd %xmm0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x2029c
movss 0x138(%r15), %xmm0
xorpd %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x1f6b1
leaq 0x70(%rsp), %r12
leaq 0x38(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x203c7
cvtss2sd 0x138(%r15), %xmm0
movaps %xmm0, (%rsp)
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x1f53c
movsd 0x10(%r14), %xmm0
movapd (%rsp), %xmm1
mulsd %xmm1, %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd (%r14), %xmm1
leaq 0x20(%rsp), %rsi
movapd %xmm1, (%rsi)
movsd %xmm0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x2029c
jmp 0x1f6b1
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/main.cpp
// Function: getReflectedRay(Primitive*, Vec3&, Ray&)
inline Ray
getReflectedRay(Primitive *z, Vec3 &pos, Ray &ray)
{
  Vec3 r, n, i;
  n = z->calculateNormal(pos);
  i = ray.direction();
  r = i - 2*((i * n) * n);
  return Ray::fromOriginAndDirection(pos + EPS*r, r);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsp, %r12
movq %r12, %rdi
callq *0x18(%rax)
movsd 0x10(%r12), %xmm2
movapd (%r12), %xmm3
movupd 0x18(%r15), %xmm0
movsd 0x28(%r15), %xmm1
movapd %xmm3, %xmm4
mulpd %xmm0, %xmm4
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
movapd %xmm0, %xmm5
mulsd %xmm3, %xmm5
addsd %xmm4, %xmm5
movapd %xmm1, %xmm4
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
mulsd %xmm4, %xmm2
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm3, %xmm4
addpd %xmm4, %xmm4
addsd %xmm2, %xmm2
subpd %xmm4, %xmm0
subsd %xmm2, %xmm1
movapd 0x30b5(%rip), %xmm2     # 0x23430
mulpd %xmm0, %xmm2
movsd 0x3071(%rip), %xmm3     # 0x233f8
mulsd %xmm1, %xmm3
movupd (%r14), %xmm4
addsd 0x10(%r14), %xmm3
addpd %xmm2, %xmm4
movupd %xmm4, (%rbx)
movsd %xmm3, 0x10(%rbx)
movupd %xmm0, 0x18(%rbx)
movsd %xmm1, 0x28(%rbx)
movaps 0x2e8c(%rip), %xmm0     # 0x23240
movups %xmm0, 0x30(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/main.cpp
// Function: getRefractedRay(Primitive*, Vec3&, Ray&)
inline Ray
getRefractedRay(Primitive *z, Vec3 &pos, Ray &ray)
{
  Vec3 r, n, u;
  double cost1, cost2, to_mu, fr_mu;

  u = ray.direction();
  u.normalize();
  n = z->calculateNormal(pos);

  // is the ray entering the primitve or leaving it?
  if (ray.mu() < 1 + EPS) {
    to_mu = z->getMaterial().getMTN();
    fr_mu = 1;
  } else {
    to_mu = 1;
    fr_mu = z->getMaterial().getMTN();
    n = -n;
  }

  // refraction formulas
  cost1 = - (u * n);
  cost2 = sqrt(1 - ((fr_mu/to_mu) * (fr_mu/to_mu) * (1 - cost1*cost1)));
  r = (fr_mu/to_mu)*u + (((cost1 * fr_mu)/to_mu) - cost2)*n;

  return Ray::fromOriginAndDirection(pos + EPS*r, r, std::numeric_limits<double>::infinity(), to_mu);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movups 0x18(%rcx), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movsd 0x28(%rcx), %xmm0
movsd %xmm0, 0x10(%rdi)
callq 0xa1b2
movq (%r12), %rax
leaq 0x70(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0x18(%rax)
movapd (%r13), %xmm3
movsd 0x2fe1(%rip), %xmm0     # 0x23400
ucomisd 0x38(%r15), %xmm0
movsd 0x10(%r13), %xmm4
cvtss2sd 0x13c(%r12), %xmm6
movsd 0xcc3(%rip), %xmm0      # 0x21100
jbe 0x20447
movaps %xmm6, %xmm5
movaps %xmm0, %xmm6
jmp 0x2045f
movapd 0xce1(%rip), %xmm1      # 0x21130
xorpd %xmm1, %xmm3
xorpd %xmm1, %xmm4
movsd 0xca1(%rip), %xmm5      # 0x21100
movapd %xmm3, %xmm1
unpckhpd %xmm3, %xmm1            # xmm1 = xmm1[1],xmm3[1]
mulsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
movapd 0xc9f(%rip), %xmm8      # 0x21130
xorpd %xmm1, %xmm8
movaps %xmm6, %xmm7
divsd %xmm5, %xmm7
mulsd %xmm1, %xmm1
movaps %xmm0, %xmm2
subsd %xmm1, %xmm2
movapd %xmm7, %xmm1
mulsd %xmm7, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x204c8
sqrtsd %xmm0, %xmm0
jmp 0x20515
movapd %xmm3, 0x60(%rsp)
movapd %xmm4, 0x50(%rsp)
movsd %xmm5, 0x18(%rsp)
movaps %xmm6, 0x40(%rsp)
movapd %xmm7, 0x30(%rsp)
movapd %xmm8, 0x20(%rsp)
callq 0x4280
movapd 0x20(%rsp), %xmm8
movapd 0x30(%rsp), %xmm7
movaps 0x40(%rsp), %xmm6
movsd 0x18(%rsp), %xmm5
movapd 0x50(%rsp), %xmm4
movapd 0x60(%rsp), %xmm3
movsd 0x10(%rsp), %xmm1
mulsd %xmm7, %xmm1
mulsd %xmm8, %xmm6
divsd %xmm5, %xmm6
subsd %xmm0, %xmm6
mulsd %xmm6, %xmm4
addsd %xmm1, %xmm4
movsd 0x2ebc(%rip), %xmm0     # 0x233f8
mulsd %xmm4, %xmm0
addsd 0x10(%r14), %xmm0
unpcklpd %xmm7, %xmm7            # xmm7 = xmm7[0,0]
mulpd (%rsp), %xmm7
unpcklpd %xmm6, %xmm6            # xmm6 = xmm6[0,0]
mulpd %xmm6, %xmm3
addpd %xmm7, %xmm3
movapd 0x2ecd(%rip), %xmm1     # 0x23430
mulpd %xmm3, %xmm1
movupd (%r14), %xmm2
addpd %xmm1, %xmm2
movupd %xmm2, (%rbx)
movsd %xmm0, 0x10(%rbx)
movupd %xmm3, 0x18(%rbx)
movsd %xmm4, 0x28(%rbx)
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq %rax, 0x30(%rbx)
movsd %xmm5, 0x38(%rbx)
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::ClientsForProcessList(std::vector<net::Address, std::allocator<net::Address>> const&)
UdpClientMap ClientsForProcessList(const ProcessList& processes) {
  UdpClientMap clients(processes.size());
  for (auto const& addr : processes) {
    clients.emplace(addr, std::make_shared<udp::Client>(addr, kAckTimeout));
  }
  return clients;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rcx
leaq 0x6(%rsp), %r8
movq %rax, %rsi
movq %r14, %rdx
callq 0x7322
movq (%r15), %r12
movq 0x8(%r15), %rbp
leaq 0x10(%rsp), %r15
leaq 0xc614(%rip), %r13      # 0x12120
cmpq %rbp, %r12
je 0x5b3b
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x6d99
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x7788
movq %r15, %rdi
callq 0x708e
addq $0x28, %r12
jmp 0x5b0c
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x5b5d
movq %rax, %r14
movq %r15, %rdi
callq 0x708e
movq %rbx, %rdi
callq 0x7114
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/nvanbenschoten[P]total-order-multicast/src/process.cc
// Function: process::RandomUint32()
uint32_t RandomUint32() {
  // Static thread local to avoid expensive initialization cost on every call,
  // while maintaining thread safety.
  static thread_local std::random_device r;
  static thread_local std::seed_seq seed{r(), r(), r(), r(), r()};
  static thread_local std::default_random_engine random_engine(seed);

  std::uniform_int_distribution<uint32_t> distribution(0, UINT32_MAX);
  return distribution(random_engine);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x0, %fs:-0x58
je 0x5bcc
cmpb $0x0, %fs:-0x38
je 0x5c08
cmpb $0x0, %fs:-0x28
je 0x5c91
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
leaq 0xc(%rsp), %rdi
movq %rax, (%rdi)
movq %fs:0x0, %rax
leaq -0x30(%rax), %rsi
callq 0x6e9c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %fs:0x0, %rax
leaq -0x13e0(%rax), %rbx
movq %rbx, %rdi
callq 0x6dba
leaq 0x1225(%rip), %rdi      # 0x6e10
leaq 0x1678e(%rip), %rdx     # 0x1c380
movq %rbx, %rsi
callq 0x5610
movb $0x1, %fs:-0x58
jmp 0x5b81
movq %fs:0x0, %r15
leaq -0x13e0(%r15), %rbx
movq %rbx, %rdi
callq 0x54a0
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x54a0
movl %eax, 0x4(%r14)
movq %rbx, %rdi
callq 0x54a0
movl %eax, 0x8(%r14)
movq %rbx, %rdi
callq 0x54a0
movl %eax, 0xc(%r14)
movq %rbx, %rdi
callq 0x54a0
movl %eax, 0x10(%r14)
leaq -0x50(%r15), %rbx
pushq $0x5
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e20
leaq 0x1222(%rip), %rdi      # 0x6e96
leaq 0x16705(%rip), %rdx     # 0x1c380
movq %rbx, %rsi
callq 0x5610
movb $0x1, %fs:-0x38
jmp 0x5b8c
movq %fs:0x0, %rax
leaq -0x50(%rax), %rsi
leaq -0x30(%rax), %rdi
callq 0x7de8
movb $0x1, %fs:-0x28
jmp 0x5b9b