LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: downSampleInput
static void downSampleInput(short *samples) {
  int numSamples = 2 * SONIC_MAX_PERIOD / SONIC_SKIP;
  int i, j;
  int value;
  short *downSamples = sonicStream.downSampleBuffer;

  for (i = 0; i < numSamples; i++) {
    value = 0;
    for (j = 0; j < SONIC_SKIP; j++) {
      value += *samples++;
    }
    value /= SONIC_SKIP;
    *downSamples++ = value;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x7b, -0xc(%rbp)
leaq 0x36b6(%rip), %rax      # 0x50ac
addq $0x478, %rax            # imm = 0x478
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1a77
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x1a46
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x8(%rbp)
movswl (%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a1d
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x20(%rbp)
movw %cx, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a07
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: overlapAdd
static void overlapAdd(int numSamples, short *out, short *rampDown, short *rampUp) {
  short *o;
  short *u;
  short *d;
  int t;

  o = out;
  u = rampUp;
  d = rampDown;
  for (t = 0; t < numSamples; t++) {
    *o = (*d * (numSamples - t) + *u * t) / numSamples;
    o++;
    d++;
    u++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1d24
movq -0x38(%rbp), %rax
movswl (%rax), %eax
movl -0x4(%rbp), %ecx
subl -0x3c(%rbp), %ecx
imull %ecx, %eax
movq -0x30(%rbp), %rcx
movswl (%rcx), %ecx
imull -0x3c(%rbp), %ecx
addl %ecx, %eax
cltd
idivl -0x4(%rbp)
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1cc2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/main_lite.c
// Function: main
int main(int argc, char** argv) {
  char* inFileName;
  char* outFileName;
  float speed = 1.0f;
  float volume = 1.0f;
  int xArg = 1;

  while (xArg < argc && *(argv[xArg]) == '-') {
    if (!strcmp(argv[xArg], "-s")) {
      xArg++;
      if (xArg < argc) {
        speed = atof(argv[xArg]);
        printf("Setting speed to %0.2fX\n", speed);
      }
    } else if (!strcmp(argv[xArg], "-v")) {
      xArg++;
      if (xArg < argc) {
        volume = atof(argv[xArg]);
        printf("Setting volume to %0.2f\n", volume);
      }
    }
    xArg++;
  }
  if (argc - xArg != 2) {
    usage();
  }
  inFileName = argv[xArg];
  outFileName = argv[xArg + 1];
  runSonic(inFileName, outFileName, speed, volume);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss 0x726(%rip), %xmm0      # 0x3004
movss %xmm0, -0x24(%rbp)
movss 0x719(%rip), %xmm0      # 0x3004
movss %xmm0, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x2d(%rbp)
jge 0x291c
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x2928
jmp 0x29fa
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8c4(%rip), %rsi       # 0x31ff
callq 0x10b0
cmpl $0x0, %eax
jne 0x2989
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2987
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1050
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x882(%rip), %rdi       # 0x3202
movb $0x1, %al
callq 0x1080
jmp 0x29ec
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x87f(%rip), %rsi       # 0x321b
callq 0x10b0
cmpl $0x0, %eax
jne 0x29ea
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x29e8
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1050
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x83d(%rip), %rdi       # 0x321e
movb $0x1, %al
callq 0x1080
jmp 0x29ea
jmp 0x29ec
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x28f7
movl -0x8(%rbp), %eax
subl -0x2c(%rbp), %eax
cmpl $0x2, %eax
je 0x2a0a
callq 0x2a50
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movss -0x24(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
callq 0x2a80
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/main_lite.c
// Function: usage
static void usage(void) {
  fprintf(
      stderr,
      "Usage: sonic_lite [OPTION]... infile outfile\n"
      "    -s speed   -- Set speed up factor.  2.0 means 2X faster.\n"
      "    -v volume  -- Scale volume by a constant factor.\n");
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x259d(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x7d2(%rip), %rsi       # 0x3237
movb $0x0, %al
callq 0x10c0
movl $0x1, %edi
callq 0x1110
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vi[P]simple_cbor_stream_parse/extract_strings.cpp
// Function: main
int main() {
    // Note; on Windows you should also set std::cin to binary mode
    std::ios::sync_with_stdio(false);
    
    MyHandler mh;
    if (!scsp::parse_from_istream(std::cin, mh)) {
        std::cerr << "Error" << std::endl;
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
xorl %edi, %edi
callq 0x2050
leaq -0x10(%rbp), %rdi
callq 0x2300
movq 0x5d22(%rip), %rdi      # 0x7fd8
leaq -0x10(%rbp), %rsi
callq 0x2670
testb $0x1, %al
jne 0x22ee
movq 0x5d26(%rip), %rdi      # 0x7ff0
leaq 0x2d33(%rip), %rsi      # 0x5004
callq 0x2080
movq %rax, %rdi
movq 0x5cd8(%rip), %rsi      # 0x7fb8
callq 0x20b0
movl $0x1, -0x4(%rbp)
jmp 0x22f5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: avi_write
static size_t avi_write (int fd, char *buf, size_t len)
{
   size_t n = 0;
   size_t r = 0;

   while (r < len) {
      n = write (fd, buf + r, len - r);
      if ((ssize_t)n < 0)
         return n;

      r += n;
   }
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x401a98
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
addq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x30(%rbp), %rdx
callq 0x48fb00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x401a8a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x401aa0
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x401a53
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_set_video
void AVI_set_video(avi_t *AVI, int width, int height, double fps, const char *compressor)
{
   /* may only be called if file is open for writing */

   if(AVI->mode==AVI_MODE_READ) return;

   AVI->width  = width;
   AVI->height = height;
   AVI->fps    = fps;

   if(strncmp(compressor, "RGB", 3)==0) {
     memset(AVI->compressor, 0, 4);
   } else {
     memcpy(AVI->compressor,compressor,4);
   }

   AVI->compressor[4] = 0;

   avi_update_header(AVI);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x401ad8
jmp 0x401b4c
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movslq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x20(%rbp), %rdi
leaq 0xe1517(%rip), %rsi     # 0x4e3020
movl $0x3, %edx
callq 0x4010b0
cmpl $0x0, %eax
jne 0x401b2e
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x4010e0
jmp 0x401b3b
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rdi
callq 0x401b60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_set_audio
void AVI_set_audio(avi_t *AVI, int channels, long rate, int bits, int format, long mp3rate)
{
   /* may only be called if file is open for writing */

   if(AVI->mode==AVI_MODE_READ) return;

   //inc audio tracks
   AVI->aptr=AVI->anum;
   ++AVI->anum;

   if(AVI->anum > AVI_MAX_TRACKS) {
     fprintf(stderr, "error - only %d audio tracks supported\n", AVI_MAX_TRACKS);
     exit(1);
   }

   AVI->track[AVI->aptr].a_chans = channels;
   AVI->track[AVI->aptr].a_rate  = rate;
   AVI->track[AVI->aptr].a_bits  = bits;
   AVI->track[AVI->aptr].a_fmt   = format;
   AVI->track[AVI->aptr].mp3rate = mp3rate;

   avi_update_header(AVI);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x4031be
jmp 0x4032cb
movq -0x8(%rbp), %rax
movl 0x438(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x43c(%rax)
movq -0x8(%rbp), %rax
movl 0x438(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x438(%rax)
movq -0x8(%rbp), %rax
cmpl $0x8, 0x438(%rax)
jle 0x403219
movq $0x526c68, %rax         # imm = 0x526C68
movq (%rax), %rdi
leaq 0xdfe21(%rip), %rsi     # 0x4e3024
movl $0x8, %edx
movb $0x0, %al
callq 0x435870
movl $0x1, %edi
callq 0x434710
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x60, %rax
movq -0x8(%rbp), %rdx
movslq 0x43c(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x60, %rax
movq -0x8(%rbp), %rdx
movslq 0x43c(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movslq -0x1c(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x60, %rax
movq -0x8(%rbp), %rdx
movslq 0x43c(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movslq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x60, %rax
movq -0x8(%rbp), %rdx
movslq 0x43c(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x60, %rax
movq -0x8(%rbp), %rdx
movslq 0x43c(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x401b60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: long2str
static void long2str(unsigned char *dst, int n)
{
   dst[0] = (n    )&0xff;
   dst[1] = (n>> 8)&0xff;
   dst[2] = (n>>16)&0xff;
   dst[3] = (n>>24)&0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_write_frame
int AVI_write_frame(avi_t *AVI, char *data, long bytes, int keyframe)
{
  unsigned long pos;

  if(AVI->mode==AVI_MODE_READ) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }

  pos = AVI->pos;

  if(avi_write_data(AVI,data,bytes,0,keyframe)) return -1;

  AVI->last_pos = pos;
  AVI->last_len = bytes;
  AVI->video_frames++;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x4033d6
movq $0x7, 0x125563(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40343f
movq -0x10(%rbp), %rax
movq 0x3e0(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %r8d
xorl %ecx, %ecx
callq 0x403450
cmpl $0x0, %eax
je 0x40340a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40343f
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x418(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x420(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: avi_write_data
static int avi_write_data(avi_t *AVI, char *data, unsigned long length, int audio, int keyframe)
{
   int n;

   unsigned char astr[5];

   /* Check for maximum file length */

   if ( (AVI->pos + 8 + length + 8 + (AVI->n_idx+1)*16) > AVI_MAX_LEN ) {
     AVI_errno = AVI_ERR_SIZELIM;
     return -1;
   }

   /* Add index entry */

   //set tag for current audio track
   sprintf((char *)astr, "0%1dwb", (int)(AVI->aptr+1));

   if(audio)
     n = avi_add_index_entry(AVI,astr,0x00,AVI->pos,length);
   else
     n = avi_add_index_entry(AVI,(unsigned char *)"00db",((keyframe)?0x10:0x0),AVI->pos,length);

   if(n) return -1;

   /* Output tag and data */

   if(audio)
     n = avi_add_chunk(AVI,astr,(unsigned char *)data,length);
   else
     n = avi_add_chunk(AVI,(unsigned char *)"00db",(unsigned char *)data,length);

   if (n) return -1;

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x3e0(%rax), %rax
addq $0x8, %rax
addq -0x20(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movq 0x3e8(%rcx), %rcx
addq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0xfefff7ff, %ecx       # imm = 0xFEFFF7FF
cmpq %rcx, %rax
jbe 0x4034b9
movq $0x1, 0x125483(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40359c
leaq -0x31(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x43c(%rax), %edx
addl $0x1, %edx
leaq 0xdfe30(%rip), %rsi     # 0x4e3301
movb $0x0, %al
callq 0x435ac0
cmpl $0x0, -0x24(%rbp)
je 0x403503
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x3e0(%rax), %rcx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x403660
movl %eax, -0x2c(%rbp)
jmp 0x403538
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %edx
xorl %eax, %eax
movl $0x10, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movslq %eax, %rdx
movq -0x10(%rbp), %rax
movq 0x3e0(%rax), %rcx
movq -0x20(%rbp), %r8
leaq 0xdfb8c(%rip), %rsi     # 0x4e30bc
callq 0x403660
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x403547
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40359c
cmpl $0x0, -0x24(%rbp)
je 0x403569
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl %eax, %ecx
callq 0x408050
movl %eax, -0x2c(%rbp)
jmp 0x403586
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl %eax, %ecx
leaq 0xdfb3e(%rip), %rsi     # 0x4e30bc
callq 0x408050
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x403595
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40359c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_dup_frame
int AVI_dup_frame(avi_t *AVI)
{
   if(AVI->mode==AVI_MODE_READ) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }

   if(AVI->last_pos==0) return 0; /* No previous real frame */
   if(avi_add_index_entry(AVI,(unsigned char *)"00db",0x10,AVI->last_pos,AVI->last_len)) return -1;
   AVI->video_frames++;
   AVI->must_use_index = 1;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x4035db
movq $0x7, 0x12535e(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x403650
movq -0x10(%rbp), %rax
cmpq $0x0, 0x418(%rax)
jne 0x4035f2
movl $0x0, -0x4(%rbp)
jmp 0x403650
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x418(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x420(%rax), %r8
leaq 0xdfaa9(%rip), %rsi     # 0x4e30bc
movl $0x10, %edx
callq 0x403660
cmpl $0x0, %eax
je 0x40362b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x403650
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x428(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: avi_add_index_entry
static int avi_add_index_entry(avi_t *AVI, unsigned char *tag, long flags, unsigned long pos, unsigned long len)
{
   void *ptr;

   if(AVI->n_idx>=AVI->max_idx) {
     ptr = realloc((void *)AVI->idx,(AVI->max_idx+4096)*16);

     if(ptr == 0) {
       AVI_errno = AVI_ERR_NO_MEM;
       return -1;
     }
     AVI->max_idx += 4096;
     AVI->idx = (unsigned char((*)[16]) ) ptr;
   }

   /* Add index entry */

   //   fprintf(stderr, "INDEX %s %ld %lu %lu\n", tag, flags, pos, len);

   memcpy(AVI->idx[AVI->n_idx],tag,4);
   long2str(AVI->idx[AVI->n_idx]+ 4,flags);
   long2str(AVI->idx[AVI->n_idx]+ 8, pos);
   long2str(AVI->idx[AVI->n_idx]+12, len);

   /* Update counter */

   AVI->n_idx++;

   if(len>AVI->max_len) AVI->max_len=len;

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x3f0(%rcx), %rax
jl 0x403704
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x3f0(%rax), %rsi
addq $0x1000, %rsi           # imm = 0x1000
shlq $0x4, %rsi
callq 0x4533b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x4036dc
movq $0x8, 0x125260(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4037e4
movq -0x10(%rbp), %rax
movq 0x3f0(%rax), %rcx
addq $0x1000, %rcx           # imm = 0x1000
movq %rcx, 0x3f0(%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x408(%rax)
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x3e8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0x4, %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x4032e0
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
callq 0x4032e0
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0xc, %rdi
movq -0x30(%rbp), %rax
movl %eax, %esi
callq 0x4032e0
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x3e8(%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jbe 0x4037dd
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_write_audio
int AVI_write_audio(avi_t *AVI, char *data, long bytes)
{
   if(AVI->mode==AVI_MODE_READ) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }

   if( avi_write_data(AVI,data,bytes,1,0) ) return -1;
   AVI->track[AVI->aptr].audio_bytes += bytes;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x403823
movq $0x7, 0x125116(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x403877
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x403450
cmpl $0x0, %eax
je 0x40384a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x403877
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq -0x10(%rbp), %rdx
movslq 0x43c(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_append_audio
int AVI_append_audio(avi_t *AVI, char *data, long bytes)
{

  long i, length, pos;
  unsigned char c[4];

  if(AVI->mode==AVI_MODE_READ) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }

  // update last index entry:

  --AVI->n_idx;
  length = str2ulong(AVI->idx[AVI->n_idx]+12);
  pos    = str2ulong(AVI->idx[AVI->n_idx]+8);

  //update;
  long2str(AVI->idx[AVI->n_idx]+12,length+bytes);

  ++AVI->n_idx;

  AVI->track[AVI->aptr].audio_bytes += bytes;

  //update chunk header
  lseek(AVI->fdes, pos+4, SEEK_SET);
  long2str(c, length+bytes);
  avi_write(AVI->fdes, (char *)c, 4);

  lseek(AVI->fdes, pos+8+length, SEEK_SET);

  i=PAD_EVEN(length + bytes);

  bytes = i - length;
  avi_write(AVI->fdes, data, bytes);
  AVI->pos = pos + 8 + i;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x4038b6
movq $0x7, 0x125086(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x403a3e
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x3e8(%rax)
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0xc, %rdi
callq 0x403a50
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0x8, %rdi
callq 0x403a50
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rax
shlq $0x4, %rax
addq %rax, %rdi
addq $0xc, %rdi
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x4032e0
movq -0x10(%rbp), %rax
movq 0x3e8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x3e8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq -0x10(%rbp), %rdx
movslq 0x43c(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %edi
movq -0x38(%rbp), %rsi
addq $0x4, %rsi
xorl %edx, %edx
callq 0x48fba0
leaq -0x3c(%rbp), %rdi
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x4032e0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %edi
leaq -0x3c(%rbp), %rsi
movl $0x4, %edx
callq 0x401a30
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %edi
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
addq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x48fba0
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
addq $0x1, %rax
andq $-0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x401a30
movq -0x38(%rbp), %rcx
addq $0x8, %rcx
addq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x3e0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_close
int AVI_close(avi_t *AVI)
{
   int ret, i;

   /* If the file was open for writing, the header and index still have
      to be written */

   if(AVI->mode == AVI_MODE_WRITE)
      ret = avi_close_output_file(AVI);
   else
      ret = 0;

   /* Even if there happened an error, we first clean up */

   close(AVI->fdes);
   if(AVI->idx) free(AVI->idx);
   if(AVI->video_index) free(AVI->video_index);
   //FIXME
   //if(AVI->audio_index) free(AVI->audio_index);
   if (AVI->bitmap_info_header)
     free(AVI->bitmap_info_header);
   for (i = 0; i < AVI->anum; i++) {
     if (AVI->wave_format_ex[i])
       free(AVI->wave_format_ex[i]);
     if (AVI->track[i].audio_chunks)
       free(AVI->track[i].audio_index);
   }
   free(AVI);

   return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x403bc5
movq -0x8(%rbp), %rdi
callq 0x403cd0
movl %eax, -0xc(%rbp)
jmp 0x403bcc
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %eax, %edi
callq 0x48fd00
movq -0x8(%rbp), %rax
cmpq $0x0, 0x408(%rax)
je 0x403bf8
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rdi
callq 0x453060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x410(%rax)
je 0x403c16
movq -0x8(%rbp), %rax
movq 0x410(%rax), %rdi
callq 0x453060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x440(%rax)
je 0x403c34
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rdi
callq 0x453060
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x438(%rcx), %eax
jge 0x403cb5
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, 0x448(%rax,%rcx,8)
je 0x403c72
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq 0x448(%rax,%rcx,8), %rdi
callq 0x453060
movq -0x8(%rbp), %rax
addq $0x60, %rax
movslq -0x10(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x38(%rax)
je 0x403ca8
movq -0x8(%rbp), %rax
addq $0x60, %rax
movslq -0x10(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x68(%rax), %rdi
callq 0x453060
jmp 0x403caa
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x403c3b
movq -0x8(%rbp), %rdi
callq 0x453060
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_open_input_file
avi_t *AVI_open_input_file(const char *filename, int getIndex)
{
  avi_t *AVI=NULL;

  /* Create avi_t structure */

  AVI = (avi_t *) malloc(sizeof(avi_t));
  if(AVI==NULL)
    {
      AVI_errno = AVI_ERR_NO_MEM;
      return 0;
    }
  memset((void *)AVI,0,sizeof(avi_t));

  AVI->mode = AVI_MODE_READ; /* open for reading */

  /* Open the file */

#ifdef WIN32
  AVI->fdes = open(filename,O_RDONLY|O_BINARY);
#else
  AVI->fdes = open(filename,O_RDONLY);
#endif
  if(AVI->fdes < 0)
    {
      AVI_errno = AVI_ERR_OPEN;
      free(AVI);
      return 0;
    }

  avi_parse_input_file(AVI, getIndex);

  AVI->aptr=0; //reset

  return AVI;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x488, %edi            # imm = 0x488
callq 0x452d20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4054f1
movq $0x8, 0x123449(%rip) # 0x528930
movq $0x0, -0x8(%rbp)
jmp 0x40556e
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x488, %edx            # imm = 0x488
callq 0x4010e0
movq -0x20(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x48f930
movslq %eax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jge 0x40554c
movq $0x2, 0x1233f7(%rip) # 0x528930
movq -0x20(%rbp), %rdi
callq 0x453060
movq $0x0, -0x8(%rbp)
jmp 0x40556e
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x405580
movq -0x20(%rbp), %rax
movl $0x0, 0x43c(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_open_fd
avi_t *AVI_open_fd(int fd, int getIndex)
{
  avi_t *AVI=NULL;

  /* Create avi_t structure */

  AVI = (avi_t *) malloc(sizeof(avi_t));
  if(AVI==NULL)
    {
      AVI_errno = AVI_ERR_NO_MEM;
      return 0;
    }
  memset((void *)AVI,0,sizeof(avi_t));

  AVI->mode = AVI_MODE_READ; /* open for reading */

  // file alread open
  AVI->fdes = fd;

  avi_parse_input_file(AVI, getIndex);

  AVI->aptr=0; //reset

  return AVI;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x488, %edi            # imm = 0x488
callq 0x452d20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x406d60
movq $0x8, 0x121bda(%rip) # 0x528930
movq $0x0, -0x8(%rbp)
jmp 0x406da9
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x488, %edx            # imm = 0x488
callq 0x4010e0
movq -0x18(%rbp), %rax
movq $0x1, 0x8(%rax)
movslq -0xc(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x405580
movq -0x18(%rbp), %rax
movl $0x0, 0x43c(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: avi_read
static size_t avi_read(int fd, char *buf, size_t len)
{
   size_t n = 0;
   size_t r = 0;

   while (r < len) {
      n = read (fd, buf + r, len - r);

      if ((ssize_t)n <= 0)
	  return r;
      r += n;
   }

   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x406e28
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
addq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x30(%rbp), %rdx
callq 0x48fa60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jg 0x406e1a
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x406e30
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x406de3
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_frame_size
long AVI_frame_size(avi_t *AVI, long frame)
{
   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->video_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   if(frame < 0 || frame >= AVI->video_frames) return 0;
   return(AVI->video_index[frame].len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x40715c
movq $0x7, 0x1217de(%rip) # 0x528930
movq $-0x1, -0x8(%rbp)
jmp 0x4071b9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x410(%rax)
jne 0x40717f
movq $0xd, 0x1217bb(%rip) # 0x528930
movq $-0x1, -0x8(%rbp)
jmp 0x4071b9
cmpq $0x0, -0x18(%rbp)
jl 0x407194
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jl 0x40719e
movq $0x0, -0x8(%rbp)
jmp 0x4071b9
movq -0x10(%rbp), %rax
movq 0x410(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_audio_size
long AVI_audio_size(avi_t *AVI, long frame)
{
  if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
  if(!AVI->track[AVI->aptr].audio_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

  if(frame < 0 || frame >= AVI->track[AVI->aptr].audio_chunks) return 0;
  return(AVI->track[AVI->aptr].audio_index[frame].len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4071ef
movq $0x7, 0x12174e(%rip) # 0x528930
movq $-0x1, -0x8(%rbp)
jmp 0x407288
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq -0x10(%rbp), %rcx
movslq 0x43c(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x68(%rax)
jne 0x407225
movq $0xd, 0x121715(%rip) # 0x528930
movq $-0x1, -0x8(%rbp)
jmp 0x407288
cmpq $0x0, -0x18(%rbp)
jl 0x407250
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x60, %rcx
movq -0x10(%rbp), %rdx
movslq 0x43c(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x38(%rcx), %rax
jl 0x40725a
movq $0x0, -0x8(%rbp)
jmp 0x407288
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq -0x10(%rbp), %rcx
movslq 0x43c(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x68(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_get_video_position
long AVI_get_video_position(avi_t *AVI, long frame)
{
   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->video_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   if(frame < 0 || frame >= AVI->video_frames) return 0;
   return(AVI->video_index[frame].pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4072bc
movq $0x7, 0x12167e(%rip) # 0x528930
movq $-0x1, -0x8(%rbp)
jmp 0x407319
movq -0x10(%rbp), %rax
cmpq $0x0, 0x410(%rax)
jne 0x4072df
movq $0xd, 0x12165b(%rip) # 0x528930
movq $-0x1, -0x8(%rbp)
jmp 0x407319
cmpq $0x0, -0x18(%rbp)
jl 0x4072f4
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jl 0x4072fe
movq $0x0, -0x8(%rbp)
jmp 0x407319
movq -0x10(%rbp), %rax
movq 0x410(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_seek_start
int AVI_seek_start(avi_t *AVI)
{
   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }

   lseek(AVI->fdes,AVI->movi_start,SEEK_SET);
   AVI->video_pos = 0;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x40734b
movq $0x7, 0x1215ee(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x407379
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
movq 0x430(%rax), %rsi
xorl %edx, %edx
callq 0x48fba0
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_set_video_position
int AVI_set_video_position(avi_t *AVI, long frame)
{
   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->video_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   if (frame < 0 ) frame = 0;
   AVI->video_pos = frame;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4073bb
movq $0x7, 0x12157e(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4073ff
movq -0x10(%rbp), %rax
cmpq $0x0, 0x410(%rax)
jne 0x4073dd
movq $0xd, 0x12155c(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4073ff
cmpq $0x0, -0x18(%rbp)
jge 0x4073ec
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_read_frame
long AVI_read_frame(avi_t *AVI, char *vidbuf, int *keyframe)
{
   long n;

   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->video_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   if(AVI->video_pos < 0 || AVI->video_pos >= AVI->video_frames) return -1;
   n = AVI->video_index[AVI->video_pos].len;

   *keyframe = (AVI->video_index[AVI->video_pos].key==0x10) ? 1:0;

   lseek(AVI->fdes, AVI->video_index[AVI->video_pos].pos, SEEK_SET);

   if (avi_read(AVI->fdes,vidbuf,n) != n)
   {
      AVI_errno = AVI_ERR_READ;
      return -1;
   }

   AVI->video_pos++;

   return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4074a7
movq $0x7, 0x121496(%rip) # 0x528930
movq $-0x1, -0x8(%rbp)
jmp 0x4075b8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x410(%rax)
jne 0x4074cd
movq $0xd, 0x121470(%rip) # 0x528930
movq $-0x1, -0x8(%rbp)
jmp 0x4075b8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jl 0x4074ea
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jl 0x4074f7
movq $-0x1, -0x8(%rbp)
jmp 0x4075b8
movq -0x10(%rbp), %rax
movq 0x410(%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, 0x50(%rcx), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x410(%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, 0x50(%rcx), %rcx
addq %rcx, %rax
movq (%rax), %rdx
xorl %ecx, %ecx
movl $0x1, %eax
cmpq $0x10, %rdx
cmovel %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
movq 0x410(%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, 0x50(%rcx), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0x48fba0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %edi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x406dc0
cmpq -0x28(%rbp), %rax
je 0x4075a0
movq $0x3, 0x12139a(%rip) # 0x528930
movq $-0x1, -0x8(%rbp)
jmp 0x4075b8
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_set_audio_position
int AVI_set_audio_position(avi_t *AVI, long byte)
{
   long n0, n1, n;

   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->track[AVI->aptr].audio_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   if(byte < 0) byte = 0;

   /* Binary search in the audio chunks */

   n0 = 0;
   n1 = AVI->track[AVI->aptr].audio_chunks;

   while(n0<n1-1)
   {
      n = (n0+n1)/2;
      if(AVI->track[AVI->aptr].audio_index[n].tot>byte)
         n1 = n;
      else
         n0 = n;
   }

   AVI->track[AVI->aptr].audio_posc = n0;
   AVI->track[AVI->aptr].audio_posb = byte - AVI->track[AVI->aptr].audio_index[n0].tot;

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4075fe
movq $0x7, 0x12133e(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40774f
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq -0x10(%rbp), %rcx
movslq 0x43c(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x68(%rax)
jne 0x407636
movq $0xd, 0x121306(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40774f
cmpq $0x0, -0x18(%rbp)
jge 0x407645
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq -0x10(%rbp), %rcx
movslq 0x43c(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x4076da
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq -0x10(%rbp), %rcx
movslq 0x43c(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x68(%rax), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jle 0x4076d0
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4076d8
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x40766f
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq -0x10(%rbp), %rdx
movslq 0x43c(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq -0x10(%rbp), %rdx
movslq 0x43c(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq 0x68(%rax), %rax
imulq $0x18, -0x20(%rbp), %rdx
addq %rdx, %rax
subq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq -0x10(%rbp), %rdx
movslq 0x43c(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x50(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_print_error
void AVI_print_error(char *str)
{
   int aerrno;

   aerrno = (AVI_errno>=0 && AVI_errno<num_avi_errors) ? AVI_errno : num_avi_errors-1;

   fprintf(stderr,"%s: %s\n",str,avi_errors[aerrno]);

   /* for the following errors, perror should report a more detailed reason: */

   if(AVI_errno == AVI_ERR_OPEN ||
      AVI_errno == AVI_ERR_READ ||
      AVI_errno == AVI_ERR_WRITE ||
      AVI_errno == AVI_ERR_WRITE_INDEX ||
      AVI_errno == AVI_ERR_CLOSE )
   {
      perror("REASON");
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x120a7c(%rip)    # 0x528930
jl 0x407ed6
movq 0x120a73(%rip), %rax    # 0x528930
movslq 0x11e324(%rip), %rcx    # 0x5261e8
cmpq %rcx, %rax
jge 0x407ed6
movq 0x120a60(%rip), %rax    # 0x528930
movq %rax, -0x18(%rbp)
jmp 0x407ee5
movl 0x11e30c(%rip), %eax    # 0x5261e8
subl $0x1, %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0xc(%rbp)
movq $0x526c68, %rax         # imm = 0x526C68
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movslq -0xc(%rbp), %rcx
leaq 0x11e26b(%rip), %rax    # 0x526170
movq (%rax,%rcx,8), %rcx
leaq 0xdb3da(%rip), %rsi     # 0x4e32ea
movb $0x0, %al
callq 0x435870
cmpq $0x2, 0x120a11(%rip)    # 0x528930
je 0x407f49
cmpq $0x3, 0x120a07(%rip)    # 0x528930
je 0x407f49
cmpq $0x4, 0x1209fd(%rip)    # 0x528930
je 0x407f49
cmpq $0x5, 0x1209f3(%rip)    # 0x528930
je 0x407f49
cmpq $0x6, 0x1209e9(%rip)    # 0x528930
jne 0x407f55
leaq 0xdb3a2(%rip), %rdi     # 0x4e32f2
callq 0x435cf0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_strerror
const char *AVI_strerror()
{
   int aerrno;

   aerrno = (AVI_errno>=0 && AVI_errno<num_avi_errors) ? AVI_errno : num_avi_errors-1;

   if(AVI_errno == AVI_ERR_OPEN ||
      AVI_errno == AVI_ERR_READ ||
      AVI_errno == AVI_ERR_WRITE ||
      AVI_errno == AVI_ERR_WRITE_INDEX ||
      AVI_errno == AVI_ERR_CLOSE )
   {
      sprintf(error_string,"%s - %s",avi_errors[aerrno],strerror(errno));
      return error_string;
   }
   else
   {
      return avi_errors[aerrno];
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x1209c0(%rip)    # 0x528930
jl 0x407f92
movq 0x1209b7(%rip), %rax    # 0x528930
movslq 0x11e268(%rip), %rcx    # 0x5261e8
cmpq %rcx, %rax
jge 0x407f92
movq 0x1209a4(%rip), %rax    # 0x528930
movq %rax, -0x18(%rbp)
jmp 0x407fa1
movl 0x11e250(%rip), %eax    # 0x5261e8
subl $0x1, %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0xc(%rbp)
cmpq $0x2, 0x120980(%rip)    # 0x528930
je 0x407fda
cmpq $0x3, 0x120976(%rip)    # 0x528930
je 0x407fda
cmpq $0x4, 0x12096c(%rip)    # 0x528930
je 0x407fda
cmpq $0x5, 0x120962(%rip)    # 0x528930
je 0x407fda
cmpq $0x6, 0x120958(%rip)    # 0x528930
jne 0x408022
movslq -0xc(%rbp), %rcx
leaq 0x11e18b(%rip), %rax    # 0x526170
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
callq 0x42de60
movl (%rax), %edi
callq 0x4554c0
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0x120979(%rip), %rdi    # 0x528980
leaq 0xdb2eb(%rip), %rsi     # 0x4e32f9
movb $0x0, %al
callq 0x435ac0
leaq 0x120964(%rip), %rax    # 0x528980
movq %rax, -0x8(%rbp)
jmp 0x408035
movslq -0xc(%rbp), %rcx
leaq 0x11e143(%rip), %rax    # 0x526170
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/avilib.c
// Function: avi_add_chunk
static int avi_add_chunk(avi_t *AVI, unsigned char *tag, unsigned char *data, int length)
{
   unsigned char c[8];

   /* Copy tag and length int c, so that we need only 1 write system call
      for these two values */

   memcpy(c,tag,4);
   long2str(c+4,length);

   /* Output tag, length and data, restore previous position
      if the write fails */

   length = PAD_EVEN(length);

   if( avi_write(AVI->fdes,(char *)c,8) != 8 ||
       avi_write(AVI->fdes,(char *)data,length) != length )
   {
      lseek(AVI->fdes,AVI->pos,SEEK_SET);
      AVI_errno = AVI_ERR_WRITE;
      return -1;
   }

   /* Update file position */

   AVI->pos += 8 + length;

   //fprintf(stderr, "pos=%lu %s\n", AVI->pos, tag);

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rdi
addq $0x4, %rdi
movl -0x24(%rbp), %esi
callq 0x4032e0
movl -0x24(%rbp), %eax
addl $0x1, %eax
andl $-0x2, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %edi
leaq -0x2c(%rbp), %rsi
movl $0x8, %edx
callq 0x401a30
cmpq $0x8, %rax
jne 0x4080c8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %edi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x401a30
movslq -0x24(%rbp), %rcx
cmpq %rcx, %rax
je 0x4080f7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
movq 0x3e0(%rax), %rsi
xorl %edx, %edx
callq 0x48fba0
movq $0x4, 0x120842(%rip) # 0x528930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x408119
movl -0x24(%rbp), %eax
addl $0x8, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x3e0(%rax), %rcx
movq %rcx, 0x3e0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)