LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: williewillus[P]panda_scratchpad/src/results/FileSystemTestResult.cpp
// Function: operator<<(std::ostream&, FileSystemTestResult::ErrorType)
ostream& operator<<(ostream& os, FileSystemTestResult::ErrorType err) {
  switch (err) {
    case FileSystemTestResult::kCheckNotRun:
      os << "fsck_not_run";
      break;
    case FileSystemTestResult::kClean:
      os << "fsck_no_errors";
      break;
    case FileSystemTestResult::kUnmountable:
      os << "unmountable_file_system";
      break;
    case FileSystemTestResult::kCheck:
      os << "fsck_error";
      break;
    case FileSystemTestResult::kFixed:
      os << "file_system_fixed";
      break;
    case FileSystemTestResult::kSnapshotRestore:
      os << "restoring_snapshot";
      break;
    case FileSystemTestResult::kBioWrite:
      os << "writing_crash_state";
      break;
    case FileSystemTestResult::kOther:
      os << "other_error";
      break;
    case FileSystemTestResult::kKernelMount:
      os << "kernel_mount";
      break;
    case FileSystemTestResult::kCheckUnfixed:
      os << "unfixed_fsck_errors";
      break;
    default:
      os.setstate(std::ios_base::failbit);
  }
  return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0xd134
jmp 0xd0af
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0xd149
jmp 0xd0bd
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0xd15e
jmp 0xd0cb
movl -0x10(%rbp), %eax
subl $0x4, %eax
je 0xd188
jmp 0xd0d9
movl -0x10(%rbp), %eax
subl $0x8, %eax
je 0xd173
jmp 0xd0e7
movl -0x10(%rbp), %eax
subl $0x10, %eax
je 0xd19a
jmp 0xd0f5
movl -0x10(%rbp), %eax
subl $0x20, %eax
je 0xd1ac
jmp 0xd103
movl -0x10(%rbp), %eax
subl $0x40, %eax
je 0xd1be
jmp 0xd111
movl -0x10(%rbp), %eax
subl $0x80, %eax
je 0xd1d0
jmp 0xd121
movl -0x10(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
je 0xd1e2
jmp 0xd1f4
movq -0x8(%rbp), %rdi
leaq 0x1776e(%rip), %rsi     # 0x248ad
callq 0x6520
jmp 0xd209
movq -0x8(%rbp), %rdi
leaq 0x17766(%rip), %rsi     # 0x248ba
callq 0x6520
jmp 0xd209
movq -0x8(%rbp), %rdi
leaq 0x17760(%rip), %rsi     # 0x248c9
callq 0x6520
jmp 0xd209
movq -0x8(%rbp), %rdi
leaq 0x17763(%rip), %rsi     # 0x248e1
callq 0x6520
jmp 0xd209
movq -0x8(%rbp), %rdi
leaq 0x17759(%rip), %rsi     # 0x248ec
callq 0x6520
jmp 0xd209
movq -0x8(%rbp), %rdi
leaq 0x17759(%rip), %rsi     # 0x248fe
callq 0x6520
jmp 0xd209
movq -0x8(%rbp), %rdi
leaq 0x1775a(%rip), %rsi     # 0x24911
callq 0x6520
jmp 0xd209
movq -0x8(%rbp), %rdi
leaq 0x176c1(%rip), %rsi     # 0x2488a
callq 0x6520
jmp 0xd209
movq -0x8(%rbp), %rdi
leaq 0x1774a(%rip), %rsi     # 0x24925
callq 0x6520
jmp 0xd209
movq -0x8(%rbp), %rdi
leaq 0x17745(%rip), %rsi     # 0x24932
callq 0x6520
jmp 0xd209
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x6380
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/results/SingleTestInfo.cpp
// Function: SingleTestInfo::GetTestResult() const
SingleTestInfo::ResultType SingleTestInfo::GetTestResult() const {
  if ((fs_test.GetError() == FileSystemTestResult::kClean ||
        fs_test.GetError() == FileSystemTestResult::kCheckNotRun)
      && data_test.GetError() == DataTestResult::kClean) {
    return SingleTestInfo::kPassed;
  } else if (fs_test.GetError() == FileSystemTestResult::kFixed
      && data_test.GetError() == DataTestResult::kClean) {
    return SingleTestInfo::kFsckFixed;
  } else if (fs_test.GetError() == FileSystemTestResult::kKernelMount) {
    return SingleTestInfo::kFsckRequired;
  }
  return SingleTestInfo::kFailed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x30, %rdi
callq 0xcfe0
cmpl $0x1, %eax
je 0xd2e4
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xcfe0
cmpl $0x0, %eax
jne 0xd2ff
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0xcdf0
cmpl $0x0, %eax
jne 0xd2ff
movl $0x0, -0x4(%rbp)
jmp 0xd354
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xcfe0
cmpl $0x4, %eax
jne 0xd32c
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0xcdf0
cmpl $0x0, %eax
jne 0xd32c
movl $0x1, -0x4(%rbp)
jmp 0xd354
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xcfe0
cmpl $0x80, %eax
jne 0xd349
movl $0x2, -0x4(%rbp)
jmp 0xd354
jmp 0xd34b
jmp 0xd34d
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/results/SingleTestInfo.cpp
// Function: SingleTestInfo::PrintResults(std::ostream&) const
void SingleTestInfo::PrintResults(ostream& os) const {
  os << "Test #" << test_num << ": " << GetTestResult() << ": ";
  data_test.PrintErrors(os);
  if (GetTestResult() == SingleTestInfo::kFailed &&
      fs_test.GetError() == FileSystemTestResult::kCheck) {
    os << fs_test.error_description << endl;
  } else {
    os << data_test.error_description << endl;
  }
  os << "\tfsck result: ";
  fs_test.PrintErrors(os);
  os << endl;
  os << "\tfsck output:" << endl << fs_test.fsck_result << endl << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x175d5(%rip), %rsi     # 0x24958
callq 0x6520
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x6630
movq %rax, %rdi
leaq 0x1842f(%rip), %rsi     # 0x257cf
callq 0x6520
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xd2b0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0xd4d0
movq %rax, %rdi
leaq 0x18408(%rip), %rsi     # 0x257cf
callq 0x6520
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xce10
movq -0x18(%rbp), %rdi
callq 0xd2b0
cmpl $0x3, %eax
jne 0xd41f
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xcfe0
cmpl $0x8, %eax
jne 0xd41f
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x30, %rsi
callq 0x64a0
movq %rax, %rdi
movq 0x27b80(%rip), %rsi     # 0x34f98
callq 0x6580
jmp 0xd43f
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rsi
callq 0x64a0
movq %rax, %rdi
movq 0x27b5e(%rip), %rsi     # 0x34f98
callq 0x6580
movq -0x10(%rbp), %rdi
leaq 0x17515(%rip), %rsi     # 0x2495f
callq 0x6520
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0xd000
movq -0x10(%rbp), %rdi
movq 0x27b2d(%rip), %rsi     # 0x34f98
callq 0x6580
movq -0x10(%rbp), %rdi
leaq 0x174f3(%rip), %rsi     # 0x2496e
callq 0x6520
movq %rax, %rdi
movq 0x27b0e(%rip), %rsi     # 0x34f98
callq 0x6580
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x30, %rsi
addq $0x20, %rsi
callq 0x64a0
movq %rax, %rdi
movq 0x27aeb(%rip), %rsi     # 0x34f98
callq 0x6580
movq %rax, %rdi
movq 0x27adc(%rip), %rsi     # 0x34f98
callq 0x6580
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/results/SingleTestInfo.cpp
// Function: operator<<(std::ostream&, SingleTestInfo::ResultType)
ostream& operator<<(ostream& os, SingleTestInfo::ResultType rt) {
  switch (rt) {
    case SingleTestInfo::kPassed:
      os << "PASSED";
      break;
    case SingleTestInfo::kFsckFixed:
      os << "FSCK_FIXED";
      break;
    case SingleTestInfo::kFsckRequired:
      os << "FSCK_REQUIRED";
      break;
    case SingleTestInfo::kFailed:
      os << "FAILED";
      break;
    default:
      os.setstate(std::ios_base::failbit);
  }
  return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0xd548
movq -0x18(%rbp), %rax
leaq 0x17451(%rip), %rcx     # 0x24948
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x17471(%rip), %rsi     # 0x2497c
callq 0x6520
jmp 0xd55d
movq -0x8(%rbp), %rdi
leaq 0x17466(%rip), %rsi     # 0x24983
callq 0x6520
jmp 0xd55d
movq -0x8(%rbp), %rdi
leaq 0x1745f(%rip), %rsi     # 0x2498e
callq 0x6520
jmp 0xd55d
movq -0x8(%rbp), %rdi
leaq 0x1745b(%rip), %rsi     # 0x2499c
callq 0x6520
jmp 0xd55d
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x6380
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/results/TestSuiteResult.cpp
// Function: TestSuiteResult::TallyResult(SingleTestInfo&, ResultSet&)
void TestSuiteResult::TallyResult(SingleTestInfo &done, ResultSet &set) {
  switch (done.GetTestResult()) {
    case SingleTestInfo::kPassed:
      ++set.num_passed;
      break;
    case SingleTestInfo::kFsckFixed:
      ++set.num_passed_fixed;
      break;
    case SingleTestInfo::kFsckRequired:
      ++set.fsck_required;
      break;
    case SingleTestInfo::kFailed:
      ++set.num_failed;

      switch (done.data_test.GetError()) {
        case DataTestResult::kOldFilePersisted:
          ++set.old_file_persisted;
          break;
        case DataTestResult::kFileMissing:
          ++set.file_missing;
          break;
        case DataTestResult::kFileDataCorrupted:
          ++set.file_data_corrupted;
          break;
        case DataTestResult::kFileMetadataCorrupted:
          ++set.file_metadata_corrupted;
          break;
        case DataTestResult::kIncorrectBlockCount:
          ++set.incorrect_block_count;
          break;    
        case DataTestResult::kOther:
          ++set.other;
          break;
        case DataTestResult::kAutoCheckFailed:
          ++set.auto_check_failed;
          break;
      }
      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd2b0
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0xd6d7
movq -0x20(%rbp), %rax
leaq 0x173ad(%rip), %rcx     # 0x249a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0xd6d7
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0xd6d7
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0xd6d7
movq -0x18(%rbp), %rax
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xcdf0
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3f, %eax
ja 0xd6d5
movq -0x28(%rbp), %rax
leaq 0x1734f(%rip), %rcx     # 0x249b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0xd6d5
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0xd6d5
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
jmp 0xd6d5
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0xd6d5
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0xd6d5
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0xd6d5
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0xd6d7
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/DiskMod.cpp
// Function: wrapper::DiskMod::GetSerializeSize()
uint64_t DiskMod::GetSerializeSize() {
  // mod_type, mod_opts, and a uint64_t for the size of the serialized mod.
  uint64_t res = (2 * sizeof(uint16_t)) + sizeof(uint64_t);

  if (mod_type == DiskMod::kCheckpointMod || mod_type == DiskMod::kSyncMod) {
    return res;
  }

  res += sizeof(bool);  // directory_mod.

  res += path.size() + 1;  // size() doesn't include null terminator.

  if (mod_type == DiskMod::kFsyncMod ||
      mod_type == DiskMod::kRemoveMod ||
      mod_type == DiskMod::kCreateMod) {
    return res;
  }

  if (mod_type == DiskMod::kSyncFileRangeMod ||
      mod_opts == DiskMod::kFallocateOpt ||
      mod_opts == DiskMod::kFallocateKeepSizeOpt ||
      mod_opts == DiskMod::kPunchHoleKeepSizeOpt ||
      mod_opts == DiskMod::kCollapseRangeOpt ||
      mod_opts == DiskMod::kZeroRangeOpt ||
      mod_opts == DiskMod::kZeroRangeKeepSizeOpt ||
      mod_opts == DiskMod::kInsertRangeOpt) {
    // Do not contain the data for the range, just the offset and length.
    res += 2 * sizeof(uint64_t);
    return res;
  }
  
  if (directory_mod) {
    res += directory_added_entry.size() + 1;  // Path changed in directory.
  } else {
    // Data changed, location of change, length of change.
    res += 2 * sizeof(uint64_t);
    return res + file_mod_len;
  }

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0xc, -0x18(%rbp)
cmpl $0x6, 0x20(%rax)
je 0xdb3c
movq -0x20(%rbp), %rax
cmpl $0x8, 0x20(%rax)
jne 0xdb49
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdc52
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
callq 0x63c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq $0x1, %rcx
addq -0x18(%rbp), %rcx
movq %rcx, -0x18(%rbp)
cmpl $0x7, 0x20(%rax)
je 0xdb8b
movq -0x20(%rbp), %rax
cmpl $0x5, 0x20(%rax)
je 0xdb8b
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xdb98
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdc52
movq -0x20(%rbp), %rax
cmpl $0x9, 0x20(%rax)
je 0xdbe8
movq -0x20(%rbp), %rax
cmpl $0x2, 0x24(%rax)
je 0xdbe8
movq -0x20(%rbp), %rax
cmpl $0x3, 0x24(%rax)
je 0xdbe8
movq -0x20(%rbp), %rax
cmpl $0x4, 0x24(%rax)
je 0xdbe8
movq -0x20(%rbp), %rax
cmpl $0x5, 0x24(%rax)
je 0xdbe8
movq -0x20(%rbp), %rax
cmpl $0x6, 0x24(%rax)
je 0xdbe8
movq -0x20(%rbp), %rax
cmpl $0x7, 0x24(%rax)
je 0xdbe8
movq -0x20(%rbp), %rax
cmpl $0x8, 0x24(%rax)
jne 0xdbfe
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdc52
movq -0x20(%rbp), %rax
testb $0x1, 0xb8(%rax)
je 0xdc29
movq -0x20(%rbp), %rdi
addq $0xe0, %rdi
callq 0x63c0
addq $0x1, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xdc4a
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq 0xd8(%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0xdc52
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/DiskMod.cpp
// Function: wrapper::DiskMod::SerializeHeader(char*, unsigned int, wrapper::DiskMod&)
int DiskMod::SerializeHeader(char *buf, const unsigned int buf_offset,
    DiskMod &dm) {
  buf = buf + buf_offset;
  uint16_t mod_type = htobe16((uint16_t) dm.mod_type);
  uint16_t mod_opts = htobe16((uint16_t) dm.mod_opts);
  memcpy(buf, &mod_type, sizeof(uint16_t));
  buf += sizeof(uint16_t);
  memcpy(buf, &mod_opts, sizeof(uint16_t));

  return 2 * sizeof(uint16_t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movzwl %ax, %edi
callq 0xe230
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movzwl %ax, %edi
callq 0xe230
movw %ax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movw -0x1a(%rbp), %cx
movw %cx, (%rax)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw -0x1c(%rbp), %cx
movw %cx, (%rax)
movl $0x4, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/DiskMod.cpp
// Function: wrapper::DiskMod::SerializeChangeHeader(char*, unsigned int, wrapper::DiskMod&)
int DiskMod::SerializeChangeHeader(char *buf,
    const unsigned int buf_offset, DiskMod &dm) {
  buf += buf_offset;
  unsigned int size = dm.path.size() + 1;
  // Add the path that was changed to the buffer.
  // size() doesn't include null-terminator.
  // TODO(ashmrtn): The below assumes 1 character per byte encoding.
  memcpy(buf, dm.path.c_str(), size);
  buf += size;

  // Add directory_mod to buffer.
  uint8_t mod_directory_mod = dm.directory_mod;
  memcpy(buf, &mod_directory_mod, sizeof(uint8_t));

  return size + sizeof(uint8_t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x63c0
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6220
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x6450
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movb 0xb8(%rax), %al
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rax
movb -0x1d(%rbp), %cl
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addq $0x1, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/DiskMod.cpp
// Function: wrapper::DiskMod::SerializeDataRange(char*, unsigned int, wrapper::DiskMod&)
int DiskMod::SerializeDataRange(char *buf, const unsigned int buf_offset,
    DiskMod &dm) {
  buf += buf_offset;
  // Add file_mod_location.
  uint64_t file_mod_location = htobe64(dm.file_mod_location);
  memcpy(buf, &file_mod_location, sizeof(uint64_t));
  buf += sizeof(uint64_t);

  // Add file_mod_len.
  uint64_t file_mod_len = htobe64(dm.file_mod_len);
  memcpy(buf, &file_mod_len, sizeof(uint64_t));
  buf += sizeof(uint64_t);

  if (dm.mod_type == DiskMod::kSyncFileRangeMod ||
      dm.mod_opts == DiskMod::kFallocateOpt ||
      dm.mod_opts == DiskMod::kFallocateKeepSizeOpt ||
      dm.mod_opts == DiskMod::kPunchHoleKeepSizeOpt ||
      dm.mod_opts == DiskMod::kCollapseRangeOpt ||
      dm.mod_opts == DiskMod::kZeroRangeOpt ||
      dm.mod_opts == DiskMod::kZeroRangeKeepSizeOpt ||
      dm.mod_opts == DiskMod::kInsertRangeOpt) {
    // kSyncFileRangeMod does not contain the data range, just the offset and
    // length.
    return 2 * sizeof(uint64_t);
  }

  // Add file_mod_data (non-null terminated).
  memcpy(buf, dm.file_mod_data.get(), dm.file_mod_len);

  return (2 * sizeof(uint64_t)) + dm.file_mod_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq 0xd0(%rax), %rdi
callq 0xdf10
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rdi
callq 0xdf10
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x9, 0x20(%rax)
je 0xe1d9
movq -0x20(%rbp), %rax
cmpl $0x2, 0x24(%rax)
je 0xe1d9
movq -0x20(%rbp), %rax
cmpl $0x3, 0x24(%rax)
je 0xe1d9
movq -0x20(%rbp), %rax
cmpl $0x4, 0x24(%rax)
je 0xe1d9
movq -0x20(%rbp), %rax
cmpl $0x5, 0x24(%rax)
je 0xe1d9
movq -0x20(%rbp), %rax
cmpl $0x6, 0x24(%rax)
je 0xe1d9
movq -0x20(%rbp), %rax
cmpl $0x7, 0x24(%rax)
je 0xe1d9
movq -0x20(%rbp), %rax
cmpl $0x8, 0x24(%rax)
jne 0xe1e2
movl $0x10, -0x4(%rbp)
jmp 0xe223
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
callq 0xf430
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rdx
callq 0x6450
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rax
addq $0x10, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/DiskMod.cpp
// Function: wrapper::DiskMod::Reset()
void DiskMod::Reset() {
  path.clear();
  mod_type = kCreateMod;
  mod_opts = kNoneOpt;
  memset(&post_mod_stats, 0, sizeof(struct stat));
  directory_mod = false;
  file_mod_data.reset();
  file_mod_location = 0;
  file_mod_len = 0;
  directory_added_entry.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x6600
movq -0x10(%rbp), %rdi
movl $0x0, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
addq $0x28, %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x6310
movq -0x10(%rbp), %rdi
movb $0x0, 0xb8(%rdi)
addq $0xc0, %rdi
callq 0xf4c0
movq -0x10(%rbp), %rdi
movq $0x0, 0xd0(%rdi)
movq $0x0, 0xd8(%rdi)
addq $0xe0, %rdi
callq 0x6600
addq $0x10, %rsp
popq %rbp
retq
nop
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::DefaultFsFns::FnPathExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool DefaultFsFns::FnPathExists(const std::string &pathname) {
  const int res = access(pathname.c_str(), F_OK);
  // TODO(ashmrtn): Should probably have some better way to handle errors.
  if (res != 0) {
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6220
movq %rax, %rdi
xorl %esi, %esi
callq 0x6840
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xfb12
movb $0x0, -0x1(%rbp)
jmp 0xfb16
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmMkdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int)
int RecordCmFsOps::CmMkdir(const string &pathname, const mode_t mode) {
  const int res = fns_->FnMkdir(pathname.c_str(), mode);
  if (res < 0) {
    return res;
  }

  DiskMod mod;
  mod.directory_mod = true;
  mod.path = pathname;
  mod.mod_type = DiskMod::kCreateMod;
  mod.mod_opts = DiskMod::kNoneOpt;

  mods_.push_back(mod);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x178(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0x170(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6220
movq %rax, -0x168(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0x68b0
movq -0x168(%rbp), %rsi
movq -0x160(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x6670
jmp 0xfd98
movq -0x170(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x17c(%rbp)
jmp 0xfdb7
leaq -0x40(%rbp), %rdi
callq 0x69d8
leaq -0x41(%rbp), %rdi
callq 0x6590
movl -0x17c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0xfe14
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfe9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xfe06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x69d8
leaq -0x41(%rbp), %rdi
callq 0x6590
jmp 0xfea7
leaq -0x158(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0xe650
movq -0x188(%rbp), %rdi
movb $0x1, -0xa0(%rbp)
movq -0x18(%rbp), %rsi
callq 0x6060
jmp 0xfe40
movq -0x178(%rbp), %rdi
movl $0x0, -0x138(%rbp)
movl $0x0, -0x134(%rbp)
addq $0x78, %rdi
leaq -0x158(%rbp), %rsi
callq 0x13df0
jmp 0xfe6d
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xbf60
jmp 0xfe9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xbf60
jmp 0xfea7
movl -0x4(%rbp), %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x68a0
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmOpen(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
int RecordCmFsOps::CmOpen(const string &pathname, const int flags) {
  // Will this make a new file or is this path a directory?
  const bool exists = fns_->FnPathExists(pathname.c_str());

  const int res = fns_->FnOpen(pathname.c_str(), flags);
  if (res < 0) {
    return res;
  }

  CmOpenCommon(res, pathname, exists, flags);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6220
movq %rax, -0x90(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x68b0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x6670
jmp 0x101a8
movq -0x98(%rbp), %rdi
movq (%rdi), %rax
movq 0x90(%rax), %rax
leaq -0x40(%rbp), %rsi
callq *%rax
movb %al, -0xa1(%rbp)
jmp 0x101c7
leaq -0x40(%rbp), %rdi
callq 0x69d8
leaq -0x41(%rbp), %rdi
callq 0x6590
movb -0xa1(%rbp), %cl
movq -0xa0(%rbp), %rax
andb $0x1, %cl
movb %cl, -0x1d(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6220
movq %rax, -0xb8(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x68b0
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x6670
jmp 0x10233
movq -0xc0(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq -0x78(%rbp), %rsi
callq *%rax
movl %eax, -0xc4(%rbp)
jmp 0x10252
leaq -0x78(%rbp), %rdi
callq 0x69d8
leaq -0x79(%rbp), %rdi
callq 0x6590
movl -0xc4(%rbp), %eax
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x58(%rbp)
jge 0x102da
movl -0x58(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x102ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x102a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x69d8
leaq -0x41(%rbp), %rdi
callq 0x6590
jmp 0x1030b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x102cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x69d8
leaq -0x79(%rbp), %rdi
callq 0x6590
jmp 0x1030b
movq -0xa0(%rbp), %rdi
movl -0x58(%rbp), %esi
movq -0x18(%rbp), %rdx
movb -0x1d(%rbp), %al
movl -0x1c(%rbp), %r8d
andb $0x1, %al
movzbl %al, %ecx
callq 0xfeb0
movl -0x58(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x68a0
nopw %cs:(%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmOpen(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, unsigned int)
int RecordCmFsOps::CmOpen(const string &pathname, const int flags,
    const mode_t mode) {
  // Will this make a new file or is this path a directory?
  const bool exists = fns_->FnPathExists(pathname.c_str());

  const int res = fns_->FnOpen2(pathname.c_str(), flags, mode);
  if (res < 0) {
    return res;
  }

  CmOpenCommon(res, pathname, exists, flags);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6220
movq %rax, -0x98(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x68b0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x6670
jmp 0x1038b
movq -0xa0(%rbp), %rdi
movq (%rdi), %rax
movq 0x90(%rax), %rax
leaq -0x48(%rbp), %rsi
callq *%rax
movb %al, -0xa9(%rbp)
jmp 0x103aa
leaq -0x48(%rbp), %rdi
callq 0x69d8
leaq -0x49(%rbp), %rdi
callq 0x6590
movb -0xa9(%rbp), %cl
movq -0xa8(%rbp), %rax
andb $0x1, %cl
movb %cl, -0x21(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6220
movq %rax, -0xc0(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x68b0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x6670
jmp 0x10419
movq -0xc8(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq -0x80(%rbp), %rsi
callq *%rax
movl %eax, -0xcc(%rbp)
jmp 0x1043b
leaq -0x80(%rbp), %rdi
callq 0x69d8
leaq -0x81(%rbp), %rdi
callq 0x6590
movl -0xcc(%rbp), %eax
movl %eax, -0x60(%rbp)
cmpl $0x0, -0x60(%rbp)
jge 0x104c9
movl -0x60(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x104ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1048d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x69d8
leaq -0x49(%rbp), %rdi
callq 0x6590
jmp 0x104fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x104bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x69d8
leaq -0x81(%rbp), %rdi
callq 0x6590
jmp 0x104fa
movq -0xa8(%rbp), %rdi
movl -0x60(%rbp), %esi
movq -0x18(%rbp), %rdx
movb -0x21(%rbp), %al
movl -0x1c(%rbp), %r8d
andb $0x1, %al
movzbl %al, %ecx
callq 0xfeb0
movl -0x60(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x68a0
nopw %cs:(%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmMmap(void*, unsigned long, int, int, int, long)
void * RecordCmFsOps::CmMmap(void *addr, const size_t length, const int prot,
    const int flags, const int fd, const off_t offset) {
  void *res = fns_->FnMmap(addr, length, prot, flags, fd, offset);
  if (res == (void*) -1) {
    return res;
  }

  if (!(prot & PROT_WRITE) || flags & MAP_PRIVATE || flags & MAP_ANON ||
      flags & MAP_ANONYMOUS) {
    // In these cases, the user cannot write to the mmap-ed region, the region
    // is not backed by a file, or the changes the user makes are not reflected
    // in the file, so we can just act like this never happened.
    return res;
  }

  // All other cases we actually need to keep track of the fact that we mmap-ed
  // this region.
  mmap_map_.insert({(long long) res,
      tuple<string, unsigned int, unsigned int>(
          fd_map_.at(fd), offset, length)});
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq 0x90(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
movq 0x10(%rbp), %r10
movq (%rdi), %rax
movq %r10, (%rsp)
callq *0x48(%rax)
movq %rax, -0x38(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x38(%rbp)
jne 0x10ce7
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10e13
movl -0x24(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x10d13
movl -0x28(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x10d13
movl -0x28(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x10d13
movl -0x28(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x10d20
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10e13
movq -0xc8(%rbp), %rdi
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0xd8(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x8, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x13ee0
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq 0x10(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x13f50
movq -0xd0(%rbp), %rdx
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x13f90
jmp 0x10d7e
movq -0xd8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x13f10
movb %dl, -0xe1(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0x10d9d
movb -0xe1(%rbp), %al
movq -0xe0(%rbp), %rcx
movq %rcx, -0xc0(%rbp)
movb %al, -0xb8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xc510
leaq -0xa0(%rbp), %rdi
callq 0x13fd0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10e13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x10e05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xc510
leaq -0xa0(%rbp), %rdi
callq 0x13fd0
jmp 0x10e20
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x68a0
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmMunmap(void*, unsigned long)
int RecordCmFsOps::CmMunmap(void *addr, const size_t length) {
  const int res = fns_->FnMunmap(addr, length);
  if (res < 0) {
    return res;
  }

  // TODO(ashmrtn): Assume that we always munmap with the same pointer and
  // length that we mmap-ed with. May not actually remove anything if the
  // mapping was not something that caused writes to be reflected in the
  // underlying file (i.e. the key wasn't present to begin with).
  mmap_map_.erase((long long int) addr);

  return res;
}

// 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
movq %rax, -0x38(%rbp)
movq 0x90(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *0x58(%rax)
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x11162
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11181
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x141a0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmClose(int)
int RecordCmFsOps::CmClose(const int fd) {
  const int res = fns_->FnClose(fd);

  if (res < 0) {
    return res;
  }

  fd_map_.erase(fd);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x90(%rax), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x68(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x115d8
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x115ef
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x14200
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmRename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int RecordCmFsOps::CmRename(const string &old_path, const string &new_path) {
  // check if there are any open files with the old path
  // change the file descriptors to point to the new path
  for (auto it = fd_map_.begin(); it != fd_map_.end(); it++) {
    string& open_fd_old_path = it->second;
    if (open_fd_old_path.compare(old_path) == 0) {
      fd_map_[it->first] = new_path;
      continue;
    }
    // if we are renaming a directory that is open; we want to
    // change the mapping of the open files in that directory
    auto found = open_fd_old_path.find(old_path);
    if ( found != std::string::npos) {
      fd_map_[it->first].replace(found, old_path.length(), new_path);
    }
  }
  return fns_->FnRename(old_path, new_path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x14230
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x14290
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14260
testb $0x1, %al
jne 0x11650
jmp 0x11726
leaq -0x20(%rbp), %rdi
callq 0x142c0
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6050
cmpl $0x0, %eax
jne 0x116aa
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x50(%rbp)
addq $0x8, %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x142c0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x141d0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x6060
jmp 0x11712
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x69c0
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x38(%rbp)
je 0x11710
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x142c0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x141d0
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6740
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x61f0
jmp 0x11712
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x142f0
movq %rax, -0x40(%rbp)
jmp 0x11629
movq -0x48(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x70(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmUnlink(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int RecordCmFsOps::CmUnlink(const string &pathname) {
  const int res = fns_->FnUnlink(pathname.c_str());
  if (res < 0) {
    return res;
  }

  DiskMod mod;
  mod.mod_type = DiskMod::kRemoveMod;
  mod.mod_opts = DiskMod::kNoneOpt;
  mod.path = pathname;
  mods_.push_back(mod);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x178(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0x170(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6220
movq %rax, -0x168(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0x68b0
movq -0x168(%rbp), %rsi
movq -0x160(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x6670
jmp 0x117b5
movq -0x170(%rbp), %rdi
movq (%rdi), %rax
movq 0x78(%rax), %rax
leaq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x17c(%rbp)
jmp 0x117d1
leaq -0x40(%rbp), %rdi
callq 0x69d8
leaq -0x41(%rbp), %rdi
callq 0x6590
movl -0x17c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x1182e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x118ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x11820
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x69d8
leaq -0x41(%rbp), %rdi
callq 0x6590
jmp 0x118ba
leaq -0x158(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0xe650
movq -0x188(%rbp), %rdi
movl $0x5, -0x138(%rbp)
movl $0x0, -0x134(%rbp)
movq -0x18(%rbp), %rsi
callq 0x6060
jmp 0x11867
movq -0x178(%rbp), %rdi
addq $0x78, %rdi
leaq -0x158(%rbp), %rsi
callq 0x13df0
jmp 0x11880
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xbf60
jmp 0x118ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xbf60
jmp 0x118ba
movl -0x4(%rbp), %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x68a0
nopw %cs:(%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmRemove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int RecordCmFsOps::CmRemove(const string &pathname) {
  const int res = fns_->FnRemove(pathname.c_str());
  if (res < 0) {
    return res;
  }

  DiskMod mod;
  mod.mod_type = DiskMod::kRemoveMod;
  mod.mod_opts = DiskMod::kNoneOpt;
  mod.path = pathname;
  mods_.push_back(mod);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x178(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0x170(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6220
movq %rax, -0x168(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0x68b0
movq -0x168(%rbp), %rsi
movq -0x160(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x6670
jmp 0x11935
movq -0x170(%rbp), %rdi
movq (%rdi), %rax
movq 0x80(%rax), %rax
leaq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x17c(%rbp)
jmp 0x11954
leaq -0x40(%rbp), %rdi
callq 0x69d8
leaq -0x41(%rbp), %rdi
callq 0x6590
movl -0x17c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x119b1
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11a31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x119a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x69d8
leaq -0x41(%rbp), %rdi
callq 0x6590
jmp 0x11a3d
leaq -0x158(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0xe650
movq -0x188(%rbp), %rdi
movl $0x5, -0x138(%rbp)
movl $0x0, -0x134(%rbp)
movq -0x18(%rbp), %rsi
callq 0x6060
jmp 0x119ea
movq -0x178(%rbp), %rdi
addq $0x78, %rdi
leaq -0x158(%rbp), %rsi
callq 0x13df0
jmp 0x11a03
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xbf60
jmp 0x11a31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xbf60
jmp 0x11a3d
movl -0x4(%rbp), %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x68a0
nopw %cs:(%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmFsync(int)
int RecordCmFsOps::CmFsync(const int fd) {
  const int res = fns_->FnFsync(fd);
  if (res < 0) {
    return res;
  }

  DiskMod mod;
  mod.mod_type = DiskMod::kFsyncMod;
  mod.mod_opts = DiskMod::kNoneOpt;
  mod.path = fd_map_.at(fd);
  mods_.push_back(mod);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x130(%rbp)
movq 0x90(%rax), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x98(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x11a94
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11b33
leaq -0x118(%rbp), %rdi
callq 0xe650
movq -0x130(%rbp), %rdi
movl $0x7, -0xf8(%rbp)
movl $0x0, -0xf4(%rbp)
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x13ee0
movq %rax, -0x138(%rbp)
jmp 0x11ad1
movq -0x138(%rbp), %rsi
leaq -0x118(%rbp), %rdi
callq 0x6060
jmp 0x11ae6
movq -0x130(%rbp), %rdi
addq $0x78, %rdi
leaq -0x118(%rbp), %rsi
callq 0x13df0
jmp 0x11aff
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x118(%rbp), %rdi
callq 0xbf60
jmp 0x11b33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x118(%rbp), %rdi
callq 0xbf60
jmp 0x11b3f
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x120(%rbp), %rdi
callq 0x68a0
nopl (%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmFdatasync(int)
int RecordCmFsOps::CmFdatasync(const int fd) {
  const int res = fns_->FnFdatasync(fd);
  if (res < 0) {
    return res;
  }

  DiskMod mod;
  mod.mod_type = DiskMod::kFsyncMod;
  mod.mod_opts = DiskMod::kNoneOpt;
  mod.path = fd_map_.at(fd);
  mods_.push_back(mod);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x130(%rbp)
movq 0x90(%rax), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0xa0(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x11b94
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11c33
leaq -0x118(%rbp), %rdi
callq 0xe650
movq -0x130(%rbp), %rdi
movl $0x7, -0xf8(%rbp)
movl $0x0, -0xf4(%rbp)
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x13ee0
movq %rax, -0x138(%rbp)
jmp 0x11bd1
movq -0x138(%rbp), %rsi
leaq -0x118(%rbp), %rdi
callq 0x6060
jmp 0x11be6
movq -0x130(%rbp), %rdi
addq $0x78, %rdi
leaq -0x118(%rbp), %rsi
callq 0x13df0
jmp 0x11bff
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x118(%rbp), %rdi
callq 0xbf60
jmp 0x11c33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x118(%rbp), %rdi
callq 0xbf60
jmp 0x11c3f
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x120(%rbp), %rdi
callq 0x68a0
nopl (%rax,%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmSync()
void RecordCmFsOps::CmSync() {
  fns_->FnSync();
  
  DiskMod mod;
  mod.mod_type = DiskMod::kSyncMod;
  mod.mod_opts = DiskMod::kNoneOpt;
  mods_.push_back(mod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
movq 0x90(%rax), %rdi
movq (%rdi), %rax
movq 0xa8(%rax), %rax
callq *%rax
leaq -0x108(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xe650
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rsi
movl $0x8, -0xe8(%rbp)
movl $0x0, -0xe4(%rbp)
addq $0x78, %rdi
callq 0x13df0
jmp 0x11cbd
leaq -0x108(%rbp), %rdi
callq 0xbf60
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0x108(%rbp), %rdi
callq 0xbf60
movq -0x110(%rbp), %rdi
callq 0x68a0
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmSyncFileRange(int, unsigned long, unsigned long, unsigned int)
int RecordCmFsOps::CmSyncFileRange(const int fd, size_t offset, size_t nbytes,
    unsigned int flags) {
  const int res = fns_->FnSyncFileRange(fd, offset, nbytes, flags);
  if (res < 0) {
    return res;
  }

  DiskMod mod;
  mod.mod_type = DiskMod::kSyncFileRangeMod;
  mod.mod_opts = DiskMod::kNoneOpt;
  mod.path = fd_map_.at(fd);
  const int post_stat_res = fns_->FnStat(fd_map_.at(fd), &mod.post_mod_stats);
  if (post_stat_res < 0) {
    // TODO(ashmrtn): Some sort of warning here?
    return post_stat_res;
  }
  mod.file_mod_location = offset;
  mod.file_mod_len = nbytes;
  mods_.push_back(mod);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movq 0x90(%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movq (%rdi), %rax
callq *0xb0(%rax)
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0x11d5c
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11e91
leaq -0x130(%rbp), %rdi
callq 0xe650
movq -0x150(%rbp), %rdi
movl $0x9, -0x110(%rbp)
movl $0x0, -0x10c(%rbp)
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x13ee0
movq %rax, -0x158(%rbp)
jmp 0x11d99
movq -0x158(%rbp), %rsi
leaq -0x130(%rbp), %rdi
callq 0x6060
jmp 0x11dae
movq -0x150(%rbp), %rdi
movq 0x90(%rdi), %rax
movq %rax, -0x168(%rbp)
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x13ee0
movq %rax, -0x160(%rbp)
jmp 0x11dd9
movq -0x160(%rbp), %rsi
movq -0x168(%rbp), %rdi
leaq -0x108(%rbp), %rdx
movq (%rdi), %rax
movq 0x88(%rax), %rax
callq *%rax
movl %eax, -0x16c(%rbp)
jmp 0x11e02
movl -0x16c(%rbp), %eax
movl %eax, -0x140(%rbp)
cmpl $0x0, -0x140(%rbp)
jge 0x11e4c
movl -0x140(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x144(%rbp)
jmp 0x11e85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0xbf60
jmp 0x11e9d
movq -0x150(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x78, %rdi
leaq -0x130(%rbp), %rsi
callq 0x13df0
jmp 0x11e75
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x144(%rbp)
leaq -0x130(%rbp), %rdi
callq 0xbf60
movl -0x4(%rbp), %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq -0x138(%rbp), %rdi
callq 0x68a0
nopl (%rax)
// File: williewillus[P]panda_scratchpad/src/wrapper/wrapper.cpp
// Function: wrapper::RecordCmFsOps::CmCheckpoint()
int RecordCmFsOps::CmCheckpoint() {
  const int res = fns_->CmCheckpoint();
  if (res < 0) {
    return res;
  }

  DiskMod mod;
  mod.mod_type = DiskMod::kCheckpointMod;
  mod.mod_opts = DiskMod::kNoneOpt;
  mods_.push_back(mod);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x130(%rbp)
movq 0x90(%rax), %rdi
movq (%rdi), %rax
callq *0xb8(%rax)
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x11eeb
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11f5f
leaq -0x118(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0xe650
movq -0x130(%rbp), %rdi
movq -0x138(%rbp), %rsi
movl $0x6, -0xf8(%rbp)
movl $0x0, -0xf4(%rbp)
addq $0x78, %rdi
callq 0x13df0
jmp 0x11f2b
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x118(%rbp), %rdi
callq 0xbf60
jmp 0x11f5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x118(%rbp), %rdi
callq 0xbf60
jmp 0x11f6b
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x120(%rbp), %rdi
callq 0x68a0
nopw (%rax,%rax)