LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: openInputWaveFile
waveFile openInputWaveFile(const char* fileName, int* sampleRate, int* numChannels) {
  waveFile file;
  FILE* soundFile = fopen(fileName, "rb");

  if (soundFile == NULL) {
    fprintf(stderr, "Unable to open wave file %s for reading\n", fileName);
    return NULL;
  }
  file = (waveFile)calloc(1, sizeof(struct waveFileStruct));
  file->soundFile = soundFile;
  file->isInput = 1;
  if (!readHeader(file)) {
    closeFile(file);
    return NULL;
  }
  *sampleRate = file->sampleRate;
  *numChannels = file->numChannels;
  return file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1561(%rip), %rsi      # 0x5050
callq 0x1190
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3b25
movq 0x44f2(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x153f(%rip), %rsi      # 0x5053
movb $0x0, %al
callq 0x10f0
movq $0x0, -0x8(%rbp)
jmp 0x3b91
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x28(%rbp), %rdi
callq 0x3ba0
cmpl $0x0, %eax
jne 0x3b70
movq -0x28(%rbp), %rdi
callq 0x3d70
movq $0x0, -0x8(%rbp)
jmp 0x3b91
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: closeFile
static void closeFile(waveFile file) {
  FILE* soundFile = file->soundFile;

  if (soundFile != NULL) {
    fclose(soundFile);
    file->soundFile = NULL;
  }
  free(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3da4
movq -0x10(%rbp), %rdi
callq 0x1090
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: openOutputWaveFile
waveFile openOutputWaveFile(const char* fileName, int sampleRate, int numChannels) {
  waveFile file;
  FILE* soundFile = fopen(fileName, "wb");

  if (soundFile == NULL) {
    fprintf(stderr, "Unable to open wave file %s for writing\n", fileName);
    return NULL;
  }
  file = (waveFile)calloc(1, sizeof(struct waveFileStruct));
  file->soundFile = soundFile;
  file->sampleRate = sampleRate;
  file->numChannels = numChannels;
  writeHeader(file, sampleRate, numChannels);
  if (file->failed) {
    closeFile(file);
    return NULL;
  }
  return file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x129f(%rip), %rsi      # 0x507c
callq 0x1190
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3e13
movq 0x4204(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x127d(%rip), %rsi      # 0x507f
movb $0x0, %al
callq 0x10f0
movq $0x0, -0x8(%rbp)
jmp 0x3e79
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3e90
movq -0x20(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x3e71
movq -0x20(%rbp), %rdi
callq 0x3d70
movq $0x0, -0x8(%rbp)
jmp 0x3e79
movq -0x20(%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/waywardgeek[P]sonic/wave.c
// Function: writeHeader
static void writeHeader(waveFile file, int sampleRate, int numChannels) {
  /* write the wav file per the wav file format */
  writeString(file, "RIFF"); /* 00 - RIFF */
  /* We have to fseek and overwrite this later when we close the file because */
  /* we don't know how big it is until then. */
  writeInt(file,
           36 /* + dataLength */); /* 04 - how big is the rest of this file? */
  writeString(file, "WAVE");       /* 08 - WAVE */
  writeString(file, "fmt ");       /* 12 - fmt */
  writeInt(file, 16);              /* 16 - size of this chunk */
  writeShort(
      file,
      1); /* 20 - what is the audio format? 1 for PCM = Pulse Code Modulation */
  writeShort(file,
             numChannels);    /* 22 - mono or stereo? 1 or 2?  (or 5 or ???) */
  writeInt(file, sampleRate); /* 24 - samples per second (numbers per second) */
  writeInt(file, sampleRate * 2); /* 28 - bytes per second */
  writeShort(file, 2); /* 32 - # of bytes in one sample, for all channels */
  writeShort(
      file, 16); /* 34 - how many bits in a sample(number)?  usually 16 or 24 */
  writeString(file, "data"); /* 36 - data */
  writeInt(file, 0);         /* 40 - how big is this data chunk */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x123b(%rip), %rsi      # 0x50e8
callq 0x45c0
movq -0x8(%rbp), %rdi
movl $0x24, %esi
callq 0x40a0
movq -0x8(%rbp), %rdi
leaq 0x1222(%rip), %rsi      # 0x50ed
callq 0x45c0
movq -0x8(%rbp), %rdi
leaq 0x1217(%rip), %rsi      # 0x50f2
callq 0x45c0
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x40a0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4600
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movswl %ax, %esi
callq 0x4600
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x40a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
shll %esi
callq 0x40a0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x4600
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x4600
movq -0x8(%rbp), %rdi
leaq 0x1226(%rip), %rsi      # 0x5172
callq 0x45c0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x40a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: closeWaveFile
int closeWaveFile(waveFile file) {
  FILE* soundFile = file->soundFile;
  int passed = 1;

  if (!file->isInput) {
    if (fseek(soundFile, 4, SEEK_SET) != 0) {
      fprintf(stderr, "Failed to seek on input file.\n");
      passed = 0;
    } else {
      /* Now update the file to have the correct size. */
      writeInt(file, file->bytesWritten - 8);
      if (file->failed) {
        fprintf(stderr, "Failed to write wave file size.\n");
        passed = 0;
      }
      if (fseek(soundFile, 40, SEEK_SET) != 0) {
        fprintf(stderr, "Failed to seek on input file.\n");
        passed = 0;
      } else {
        /* Now update the file to have the correct size. */
        writeInt(file, file->bytesWritten - 48);
        if (file->failed) {
          fprintf(stderr, "Failed to write wave file size.\n");
          passed = 0;
        }
      }
    }
  }
  closeFile(file);
  return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x408a
movq -0x10(%rbp), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x1160
cmpl $0x0, %eax
je 0x3fd6
movq 0x403f(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x10e5(%rip), %rsi      # 0x50a8
movb $0x0, %al
callq 0x10f0
movl $0x0, -0x14(%rbp)
jmp 0x4088
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
subl $0x8, %esi
callq 0x40a0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x4012
movq 0x3ffe(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x10c3(%rip), %rsi      # 0x50c7
movb $0x0, %al
callq 0x10f0
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
xorl %edx, %edx
callq 0x1160
cmpl $0x0, %eax
je 0x4048
movq 0x3fca(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x1070(%rip), %rsi      # 0x50a8
movb $0x0, %al
callq 0x10f0
movl $0x0, -0x14(%rbp)
jmp 0x4086
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
subl $0x30, %esi
callq 0x40a0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x4084
movq 0x3f8c(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x1051(%rip), %rsi      # 0x50c7
movb $0x0, %al
callq 0x10f0
movl $0x0, -0x14(%rbp)
jmp 0x4086
jmp 0x4088
jmp 0x408a
movq -0x8(%rbp), %rdi
callq 0x3d70
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: writeInt
static void writeInt(waveFile file, int value) {
  char bytes[4];
  int i;

  for (i = 0; i < 4; i++) {
    bytes[i] = value;
    value >>= 8;
  }
  writeBytes(file, bytes, 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x40dd
movl -0xc(%rbp), %eax
movb %al, %cl
movslq -0x14(%rbp), %rax
movb %cl, -0x10(%rbp,%rax)
movl -0xc(%rbp), %eax
sarl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x40b6
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x4350
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: readFromWaveFile
int readFromWaveFile(waveFile file, short* buffer, int maxSamples) {
  int i, bytesRead, samplesRead;
  int bytePos = 0;
  unsigned char bytes[WAVE_BUF_LEN];
  short sample;

  if (maxSamples * file->numChannels * 2 > WAVE_BUF_LEN) {
    maxSamples = WAVE_BUF_LEN / (file->numChannels * 2);
  }
  bytesRead = readBytes(file, bytes, maxSamples * file->numChannels * 2);
  samplesRead = bytesRead / (file->numChannels * 2);
  for (i = 0; i < samplesRead * file->numChannels; i++) {
    sample = bytes[bytePos++];
    sample |= (unsigned int)bytes[bytePos++] << 8;
    *buffer++ = sample;
  }
  return samplesRead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
imull (%rcx), %eax
shll %eax
cmpl $0x1000, %eax           # imm = 0x1000
jle 0x4143
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shll %ecx
movl $0x1000, %eax           # imm = 0x1000
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1030(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
imull (%rax), %edx
shll %edx
callq 0x4200
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
shll %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull (%rdx), %ecx
cmpl %ecx, %eax
jge 0x41f3
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
cltq
movzbl -0x1030(%rbp,%rax), %eax
movw %ax, -0x1032(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
cltq
movzbl -0x1030(%rbp,%rax), %ecx
shll $0x8, %ecx
movswl -0x1032(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x1032(%rbp)
movw -0x1032(%rbp), %cx
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x10(%rbp)
movw %cx, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x417a
movl -0x20(%rbp), %eax
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: writeToWaveFile
int writeToWaveFile(waveFile file, short* buffer, int numSamples) {
  int i;
  int bytePos = 0;
  unsigned char bytes[WAVE_BUF_LEN];
  short sample;
  int total = numSamples * file->numChannels;

  for (i = 0; i < total; i++) {
    if (bytePos == WAVE_BUF_LEN) {
      writeBytes(file, bytes, bytePos);
      bytePos = 0;
    }
    sample = buffer[i];
    bytes[bytePos++] = sample;
    bytes[bytePos++] = sample >> 8;
  }
  if (bytePos != 0) {
    writeBytes(file, bytes, bytePos);
  }
  return !file->failed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
imull (%rcx), %eax
movl %eax, -0x1028(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1028(%rbp), %eax
jge 0x4314
cmpl $0x1000, -0x1c(%rbp)    # imm = 0x1000
jne 0x42b6
movq -0x8(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x4350
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x1022(%rbp)
movw -0x1022(%rbp), %ax
movb %al, %cl
movl -0x1c(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
cltq
movb %cl, -0x1020(%rbp,%rax)
movswl -0x1022(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movl -0x1c(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
cltq
movb %cl, -0x1020(%rbp,%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4284
cmpl $0x0, -0x1c(%rbp)
je 0x432d
movq -0x8(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x4350
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: writeBytes
static void writeBytes(waveFile file, void* bytes, int length) {
  size_t bytesWritten;

  if (file->failed) {
    return;
  }
  bytesWritten = fwrite(bytes, sizeof(char), length, file->soundFile);
  if (bytesWritten != length) {
    fprintf(stderr, "Unable to write to output file");
    file->failed = 1;
  }
  file->bytesWritten += bytesWritten;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x436f
jmp 0x43cf
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x11a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
je 0x43bd
movq 0x3c57(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0xe5d(%rip), %rsi       # 0x5208
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: expectString
static void expectString(waveFile file, char* expectedString) {
  char buf[11]; /* Be sure that we never call with a longer string */
  int length = strlen(expectedString);

  if (length > 10) {
    fprintf(stderr, "Internal error: expected string too long\n");
    file->failed = 1;
  } else {
    readExactBytes(file, buf, length);
    buf[length] = '\0';
    if (strcmp(expectedString, buf)) {
      fprintf(stderr, "Unsupported wave file format: Expected '%s', got '%s;\n",
          expectedString, buf);
      file->failed = 1;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movl %eax, -0x20(%rbp)
cmpl $0xa, -0x20(%rbp)
jle 0x4427
movq 0x3bef(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0xd64(%rip), %rsi       # 0x5177
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movl $0x1, 0x14(%rax)
jmp 0x447f
movq -0x8(%rbp), %rdi
leaq -0x1b(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x4550
movslq -0x20(%rbp), %rax
movb $0x0, -0x1b(%rbp,%rax)
movq -0x10(%rbp), %rdi
leaq -0x1b(%rbp), %rsi
callq 0x10e0
cmpl $0x0, %eax
je 0x447d
movq 0x3b9f(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq -0x1b(%rbp), %rcx
leaq 0xd36(%rip), %rsi       # 0x51a1
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movl $0x1, 0x14(%rax)
jmp 0x447f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: readInt
static int readInt(waveFile file) {
  unsigned char bytes[4];
  int value = 0, i;

  readExactBytes(file, bytes, 4);
  for (i = 3; i >= 0; i--) {
    value <<= 8;
    value |= bytes[i];
  }
  return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x4550
movl $0x3, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x44e5
movl -0x10(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x10(%rbp)
movslq -0x14(%rbp), %rax
movzbl -0xc(%rbp,%rax), %eax
orl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x44bc
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: readShort
static int readShort(waveFile file) {
  unsigned char bytes[2];
  int value = 0, i;

  readExactBytes(file, bytes, 2);
  for (i = 1; i >= 0; i--) {
    value <<= 8;
    value |= bytes[i];
  }
  return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xa(%rbp), %rsi
movl $0x2, %edx
callq 0x4550
movl $0x1, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x4545
movl -0x10(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x10(%rbp)
movslq -0x14(%rbp), %rax
movzbl -0xa(%rbp,%rax), %eax
orl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x451c
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: readExactBytes
static void readExactBytes(waveFile file, void* bytes, int length) {
  int numRead;

  if (file->failed) {
    return;
  }
  numRead = fread(bytes, sizeof(char), length, file->soundFile);
  if (numRead != length) {
    fprintf(stderr, "Failed to read requested bytes from input file\n");
    file->failed = 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x456f
jmp 0x45b7
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x1070
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x45b7
movq 0x3a5d(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0xc33(%rip), %rsi       # 0x51d8
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movl $0x1, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/wave.c
// Function: writeShort
static void writeShort(waveFile file, short value) {
  char bytes[2];
  int i;

  for (i = 0; i < 2; i++) {
    bytes[i] = value;
    value >>= 8;
  }
  writeBytes(file, bytes, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x2, -0x10(%rbp)
jge 0x4644
movw -0xa(%rbp), %ax
movb %al, %cl
movslq -0x10(%rbp), %rax
movb %cl, -0xc(%rbp,%rax)
movswl -0xa(%rbp), %eax
sarl $0x8, %eax
movw %ax, -0xa(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x461a
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
movl $0x2, %edx
callq 0x4350
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lacework-dev[P]strace_lab_PUBLIC/./src/example_3.c
// Function: main
int main(int argc, char *argv[])
{
	
	struct sockaddr_in serv_addr;
    // while true loop so the parent process doesn't die.
    while (1)  {
        int sock = socket(AF_INET, SOCK_STREAM, 0);

        serv_addr.sin_family = AF_INET;
        serv_addr.sin_port = htons(PORT);

        inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr);
        connect(sock, (struct sockaddr *) &serv_addr, sizeof (serv_addr));
		write(sock, payload, payload_len);

        sleep(3);
        close(sock);
    }

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1090
movl %eax, -0x24(%rbp)
movw $0x2, -0x20(%rbp)
movl $0x1f40, %edi           # imm = 0x1F40
callq 0x1040
movw %ax, -0x1e(%rbp)
leaq -0x20(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
leaq 0xe12(%rip), %rsi       # 0x2004
callq 0x1060
movl -0x24(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x1070
movl -0x24(%rbp), %edi
movl 0x7007(%rip), %eax      # 0x8218
movl %eax, %edx
leaq 0x2e46(%rip), %rsi      # 0x4060
callq 0x1030
movl $0x3, %edi
callq 0x1080
movl -0x24(%rbp), %edi
callq 0x1050
jmp 0x11b6
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/check.h
// Function: check_impl
static void
check_impl (int condition,
            const char * file,
            int line,
            const char * format, ...)
{
  va_list args;
  va_start(args, format) ;
  if (! condition) {
    fprintf(stderr, "%s:%d: check failed: ", file, line) ;
    vfprintf(stderr, format, args) ;
    fprintf(stderr, "\n") ;
    exit (1) ;
  }
  va_end(args) ;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x1acc
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %edi, 0xe4(%rsp)
movq %rsi, 0xd8(%rsp)
movl %edx, 0xd4(%rsp)
movq %rcx, 0xc8(%rsp)
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
cmpl $0x0, 0xe4(%rsp)
jne 0x1b8e
movq 0x24cb(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0xd8(%rsp), %rdx
movl 0xd4(%rsp), %ecx
leaq 0x5a1(%rip), %rsi       # 0x20e7
movb $0x0, %al
callq 0x1050
movq 0x24a4(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0xc8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x1090
movq 0x2485(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x568(%rip), %rsi       # 0x20e5
movb $0x0, %al
callq 0x1050
movl $0x1, %edi
callq 0x10a0
addq $0xe8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/body.c
// Function: bodies_collide
bool bodies_collide(struct body *a, struct body *b)
{
	d3d_scalar touch_dist = a->radius + b->radius;
	if (fabs(a->pos.x - b->pos.x) < touch_dist
	 && fabs(a->pos.y - b->pos.y) < touch_dist) {
		a->health -= b->damage;
		b->health -= a->damage;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x28(%rbp), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x28(%rbp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm1
movaps 0xe94c(%rip), %xmm0     # 0x11010
pand %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2741
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x28(%rbp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm1
movaps 0xe91a(%rip), %xmm0     # 0x11010
pand %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2741
movq -0x28(%rbp), %rax
movsd 0x20(%rax), %xmm1
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x20(%rbp), %rax
movsd 0x20(%rax), %xmm1
movq -0x28(%rbp), %rax
movsd 0x18(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
movb $0x1, -0x11(%rbp)
jmp 0x2745
movb $0x0, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/d3d.c
// Function: texture_size
static size_t texture_size(size_t width, size_t height)
{
	size_t pixels_size = width * height * sizeof(d3d_pixel);
	if (pixels_size / sizeof(d3d_pixel) / width != height) return 0;
	size_t base = offsetof(d3d_texture, pixels);
	size_t size = base + pixels_size;
	if (base > size) return 0;
	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
shlq $0x0, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x0, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
cmpq -0x18(%rbp), %rax
je 0x2c7d
movq $0x0, -0x8(%rbp)
jmp 0x2cad
movq $0x10, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x2ca5
movq $0x0, -0x8(%rbp)
jmp 0x2cad
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/d3d.c
// Function: d3d_new_texture
d3d_texture *d3d_new_texture(size_t width, size_t height, d3d_pixel fill)
{
	if (width < 1) width = 1;
	if (height < 1) height = 1;
	size_t size = texture_size(width, height);
	if (size == 0) return NULL;
	d3d_texture *txtr = d3d_malloc(size);
	if (!txtr) return NULL;
	txtr->width = width;
	txtr->height = height;
	for (size_t i = 0; i < width * height; ++i) {
		txtr->pixels[i] = fill;
	}
	return txtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
cmpq $0x1, -0x10(%rbp)
jae 0x2d84
movq $0x1, -0x10(%rbp)
cmpq $0x1, -0x18(%rbp)
jae 0x2d93
movq $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c40
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2db5
movq $0x0, -0x8(%rbp)
jmp 0x2e29
movq -0x28(%rbp), %rdi
callq 0x2750
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2dd3
movq $0x0, -0x8(%rbp)
jmp 0x2e29
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jae 0x2e21
movb -0x19(%rbp), %dl
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movb %dl, 0x10(%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2df2
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/d3d.c
// Function: d3d_new_board
d3d_board *d3d_new_board(size_t width, size_t height, const d3d_block_s *fill)
{
	size_t size = offsetof(d3d_board, blocks);
	size_t blocks_size = width * height * sizeof(d3d_block_s *);
	if (width != 0 && blocks_size / sizeof(d3d_block_s *) / width != height)
		return NULL;
	CHECKED_ADD(size, blocks_size);
	d3d_board *board = d3d_malloc(size);
	if (!board) return NULL;
	board->width = width;
	board->height = height;
	static const d3d_block_s empty_block = {{ NULL, NULL, NULL, NULL,
		NULL, NULL }};
	if (!fill) fill = &empty_block;
	for (size_t i = 0; i < width * height; ++i) {
		board->blocks[i] = fill;
	}
	return board;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x10, -0x28(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2e97
movq -0x30(%rbp), %rax
shrq $0x3, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
cmpq -0x18(%rbp), %rax
je 0x2e97
movq $0x0, -0x8(%rbp)
jmp 0x2f4c
jmp 0x2e99
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x2ebc
movq $0x0, -0x8(%rbp)
jmp 0x2f4c
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2750
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x2ee2
movq $0x0, -0x8(%rbp)
jmp 0x2f4c
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x2f0b
leaq 0xe1c9(%rip), %rax      # 0x110d0
movq %rax, -0x20(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jae 0x2f44
movq -0x20(%rbp), %rdx
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x2f13
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/d3d.c
// Function: d3d_draw
void d3d_draw(
	d3d_camera *cam,
	d3d_vec_s cam_pos,
	d3d_scalar cam_facing,
	const d3d_board *board,
	size_t n_sprites,
	const d3d_sprite_s sprites[])
{
	if (cam_pos.x > (d3d_scalar)0.0 && cam_pos.y > (d3d_scalar)0.0
	 && cam_pos.x < board->width && cam_pos.y < board->height) {
		// Canonicalize camera direction:
		cam_facing = fmod(cam_facing, 2 * PI);
		if (cam_facing < (d3d_scalar)0.0) cam_facing += 2 * PI;
		for (size_t x = 0; x < cam->width; ++x) {
			draw_column(cam, cam_pos, cam_facing, board, x);
		}
		draw_sprites(cam, cam_pos, cam_facing, n_sprites, sprites);
	} else {
		empty_camera_pixels(cam);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x30cb
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x30cb
movsd -0x20(%rbp), %xmm1
movq -0x38(%rbp), %rax
movq (%rax), %xmm0
movaps 0xe0b1(%rip), %xmm2     # 0x11070
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0xe0b5(%rip), %xmm2     # 0x11080
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x30cb
movsd -0x18(%rbp), %xmm1
movq -0x38(%rbp), %rax
movq 0x8(%rax), %xmm0
movaps 0xe077(%rip), %xmm2     # 0x11070
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0xe07b(%rip), %xmm2     # 0x11080
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x30cb
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0xe000(%rip), %xmm0     # 0x11030
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x21c0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x3065
movsd 0xdfd5(%rip), %xmm0     # 0x11030
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x30a9
movq -0x28(%rbp), %rdi
movsd -0x30(%rbp), %xmm2
movq -0x38(%rbp), %rsi
movq -0x50(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x30e0
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x306d
movq -0x28(%rbp), %rdi
movsd -0x30(%rbp), %xmm2
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x3840
jmp 0x30d4
movq -0x28(%rbp), %rdi
callq 0x2cc0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/d3d.c
// Function: invert_dir
static d3d_direction invert_dir(d3d_direction dir)
{
	switch(dir) {
	case D3D_DPOSX: return D3D_DNEGX;
	case D3D_DPOSY: return D3D_DNEGY;
	case D3D_DNEGX: return D3D_DPOSX;
	case D3D_DNEGY: return D3D_DPOSY;
	default: return dir;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x445c
movq -0x10(%rbp), %rax
leaq 0xcc81(%rip), %rcx      # 0x110b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2, -0x4(%rbp)
jmp 0x4462
movl $0x3, -0x4(%rbp)
jmp 0x4462
movl $0x0, -0x4(%rbp)
jmp 0x4462
movl $0x1, -0x4(%rbp)
jmp 0x4462
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/d3d.c
// Function: move_dir
static void move_dir(d3d_direction dir, size_t *x, size_t *y)
{
	switch(dir) {
	case D3D_DPOSX: ++*x; break;
	case D3D_DPOSY: ++*y; break;
	case D3D_DNEGX: --*x; break;
	case D3D_DNEGY: --*y; break;
	default: break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x44e0
movq -0x20(%rbp), %rax
leaq 0xcc29(%rip), %rcx      # 0x110c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x44e2
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x44e2
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x44e2
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x44e2
jmp 0x44e2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/d3d.c
// Function: compar_sprite_order
static int compar_sprite_order(const void *a, const void *b)
{
	d3d_scalar dist_a = *(d3d_scalar *)a, dist_b = *(d3d_scalar *)b;
	if (dist_a > dist_b) return 1;
	if (dist_a < dist_b) return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x452b
movl $0x1, -0x4(%rbp)
jmp 0x454b
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4544
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x454b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/d3d.c
// Function: angle_diff
static d3d_scalar angle_diff(d3d_scalar a1, d3d_scalar a2)
{
	d3d_scalar diff = a1 - a2;
	if (diff > PI) return -2 * PI + diff;
	if (diff < -PI) return -diff - 2 * PI;
	return diff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0xc4fe(%rip), %xmm1     # 0x11058
ucomisd %xmm1, %xmm0
jbe 0x4b74
movsd 0xc500(%rip), %xmm0     # 0x11068
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4bbc
movsd 0xc4e4(%rip), %xmm0     # 0x11060
ucomisd -0x20(%rbp), %xmm0
jbe 0x4bb2
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0xc489(%rip), %xmm1     # 0x11030
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4bbc
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/do-ts3d-game.c
// Function: load_save_state
static int load_save_state(struct save_state *save,
	const char *state_file, struct logger *log)
{
	FILE *from = fopen(state_file, "r");
	// from closed by save_state_init:
	if (from && !save_state_init(save, from, log)) return 0;
	logger_printf(log, LOGGER_ERROR,
		"Unable to load save state from %s\n", state_file);
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xc209(%rip), %rsi      # 0x113f8
callq 0x2160
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x521e
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xf2e0
cmpl $0x0, %eax
jne 0x521e
movl $0x0, -0x4(%rbp)
jmp 0x5240
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x4, %esi
leaq 0xbf80(%rip), %rdx      # 0x111b2
movb $0x0, %al
callq 0xa260
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/do-ts3d-game.c
// Function: load_menu_state
static int load_menu_state(struct menu_state *state, const char *data_dir,
	struct logger *log)
{
	// Screen area not yet initialized:
	state->area = (struct screen_area) { 0, 0, 1, 1 };
	int ret = menu_init(&state->menu, data_dir, &state->area, log);
	state->initialized = !ret;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x48, %rdx
movq -0x18(%rbp), %rcx
callq 0xc7b0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
setne %cl
xorb $-0x1, %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/do-ts3d-game.c
// Function: load_title_state
static int load_title_state(struct title_state *state, struct loader *ldr)
{
	struct map *map = load_map(ldr, TITLE_SCREEN_MAP_NAME);
	if (!map) return -1;
	// Screen area not yet initialized:
	state->area = (struct screen_area) { 0, 0, 1, 1 };
	state->cam = camera_with_dims(state->area.width, state->area.height);
	state->t = 0.0;
	state->board = map->board;
	state->color_map = loader_color_map(ldr);
	state->initialized = true;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xbeea(%rip), %rsi      # 0x111d5
callq 0xb730
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5307
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5393
movq -0x10(%rbp), %rax
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x1, -0x28(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x105c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x9d80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/do-ts3d-game.c
// Function: write_save_state
static int write_save_state(struct save_state *save, const char *state_file,
	struct logger *log, struct menu *menu)
{
	FILE *to = fopen(state_file, "w");
	int ret = 0;
	if (!to || save_state_write(save, to)) {
		int errnum = errno;
		FILE *print = logger_get_output(log, LOGGER_ERROR);
		if (print) {
			logger_printf(log, LOGGER_ERROR,
				"Failed to write state information to %s: %s\n",
				state_file, strerror(errnum));
			logger_printf(log, LOGGER_ERROR,
				"The information is below. Copy this to %s or"
				" to another location (see ts3d -h output):\n",
				state_file);
			save_state_write(save, print);
		}
		menu_set_message(menu, "SAVE ERROR!! QUIT NOW AND READ LOG!");
		beep();
		ret = -1;
	}
	if (to) fclose(to);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xbaa8(%rip), %rsi      # 0x111db
callq 0x2160
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5760
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xf5b0
cmpl $0x0, %eax
je 0x57fd
callq 0x2320
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0xa040
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x57e1
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x30(%rbp), %edi
callq 0x2260
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq %rax, %r8
movl $0x4, %esi
leaq 0xba2b(%rip), %rdx      # 0x111dd
movb $0x0, %al
callq 0xa260
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
leaq 0xba3d(%rip), %rdx      # 0x1120a
movb $0x0, %al
callq 0xa260
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xf5b0
movq -0x20(%rbp), %rdi
leaq 0xba76(%rip), %rsi      # 0x11262
callq 0xcff0
callq 0x2170
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x28(%rbp)
je 0x580d
movq -0x28(%rbp), %rdi
callq 0x23f0
movl -0x2c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/ent.c
// Function: parse_frame
static void parse_frame(struct json_node *node, struct ent_frame *frame,
	struct loader *ldr)
{
	char *txtr_name = NULL;
	frame->duration = 1;
	switch (node->kind) {
	case JN_STRING:
		txtr_name = node->d.str;
		node->taken = true;
		break;
	case JN_LIST:
		if (node->d.list.n_vals < 1
		 || node->d.list.vals[0].kind != JN_STRING) break;
		txtr_name = node->d.list.vals[0].d.str;
		node->d.list.vals[0].taken = true;
		if (node->d.list.n_vals < 2
		 || node->d.list.vals[1].kind != JN_NUMBER) break;
		frame->duration = node->d.list.vals[1].d.num;
		break;
	default:
		break;
	}
	if (!txtr_name || !(frame->txtr = load_texture(ldr, txtr_name)))
		frame->txtr = loader_empty_texture(ldr);
	free(txtr_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x3, %eax
je 0x5edc
jmp 0x5eb8
movl -0x24(%rbp), %eax
subl $0x4, %eax
jne 0x5f45
jmp 0x5ec6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x4(%rax)
jmp 0x5f47
movq -0x8(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jb 0x5ef4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x4, (%rax)
je 0x5ef6
jmp 0x5f47
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
cmpq $0x2, 0x8(%rax)
jb 0x5f2b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x5, 0x20(%rax)
je 0x5f2d
jmp 0x5f47
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cvttsd2si 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x5f47
jmp 0x5f47
cmpq $0x0, -0x20(%rbp)
je 0x5f68
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x95d0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x5f7b
movq -0x18(%rbp), %rdi
callq 0x9ca0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x2580
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/ent.c
// Function: ent_type_free
void ent_type_free(struct ent_type *ent)
{
	if (!ent) return;
	free(ent->name);
	free(ent->frames);
	free(ent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5fa5
jmp 0x5fc7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2580
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2580
movq -0x8(%rbp), %rdi
callq 0x2580
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/ent.c
// Function: ents_init
void ents_init(struct ents *ents, size_t cap)
{
	ents->ents = xmalloc(cap * sizeof(*ents->ents));
	ents->sprites = xmalloc(cap * sizeof(*ents->sprites));
	ents->num = 0;
	ents->cap = cap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
imulq $0x60, -0x10(%rbp), %rdi
callq 0x10b80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
imulq $0x30, -0x10(%rbp), %rdi
callq 0x10b80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/ent.c
// Function: ents_add
ent_id ents_add(struct ents *ents, struct ent_type *type, enum team team,
	const d3d_vec_s *pos)
{
	size_t old_num = ents->num;
	size_t old_cap = ents->cap;
	struct ent *ent = GROWE(ents->ents, ents->num, ents->cap);
	if (ents->cap != old_cap) {
		ents->sprites = xrealloc(ents->sprites, ents->cap
			* sizeof(*ents->sprites));
	}
	ent_init(ent, type, team, &ents->sprites[old_num], pos);
	return ents->num - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movq -0x8(%rbp), %rdx
addq $0x18, %rdx
movl $0x60, %ecx
callq 0x6700
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x30(%rbp), %rax
je 0x6140
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x30, 0x18(%rax), %rsi
callq 0x10d00
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
imulq $0x30, -0x28(%rbp), %rax
addq %rax, %rcx
movq -0x20(%rbp), %r8
callq 0x6180
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/ent.c
// Function: ent_init
static void ent_init(struct ent *ent, struct ent_type *type, enum team team,
	d3d_sprite_s *sprite, const d3d_vec_s *pos)
{
	ent->vel.x = ent->vel.y = 0;
	ent->type = type;
	ent->team = type->team_override == TEAM_INVALID ?
		team : type->team_override;
	ent->worth = 0;
	ent->lifetime = type->lifetime;
	ent->frame = type->random_start_frame ? rand() % type->n_frames : 0;
	ent->frame_duration = type->frames[0].duration;
	ent->body.pos = *pos;
	ent->body.radius = type->width / 2;
	ent->body.health = type->health;
	ent->body.damage = type->damage;
	sprite->txtr = type->frames[0].txtr;
	sprite->transparent = TRANSPARENT_PIXEL;
	sprite->scale.x = type->width;
	sprite->scale.y = type->height;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x5c(%rax)
jne 0x61d0
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x61da
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x40(%rax)
je 0x6220
callq 0x24a0
cltq
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movq %rdx, -0x38(%rbp)
jmp 0x6228
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x6228
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd 0xade0(%rip), %xmm1     # 0x11050
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x48(%rax)
movq -0x10(%rbp), %rax
movsd 0x60(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x50(%rax)
movq -0x10(%rbp), %rax
movsd 0x68(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movb $-0x1, 0x28(%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)