LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::ReleaseCategoryChannel()
int RGBDImage::
ReleaseCategoryChannel(void)
{
  // Check/update read count
  if (--category_resident_count > 0) return 1;

  // Write category channel before releasing it ???
  // if (!WriteCategoryChannels()) return 0;

  // Delete category channel
  if (NChannels() <= RGBD_CATEGORY_CHANNEL) return 0;
  if (!channels[RGBD_CATEGORY_CHANNEL]) return 0;
  delete channels[RGBD_CATEGORY_CHANNEL];
  channels[RGBD_CATEGORY_CHANNEL] = NULL;

  // Return success;
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0x200(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x200(%rcx)
cmpl $0x0, %eax
jle 0x2ee54
movl $0x1, 0x24(%rsp)
jmp 0x2eeec
movq 0x10(%rsp), %rdi
callq 0x30430
cmpl $0x4, %eax
jg 0x2ee6d
movl $0x0, 0x24(%rsp)
jmp 0x2eeec
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl $0x4, %esi
callq 0x277c0
cmpq $0x0, (%rax)
jne 0x2ee90
movl $0x0, 0x24(%rsp)
jmp 0x2eeec
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl $0x4, %esi
callq 0x277c0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2eeca
movq 0x8(%rsp), %rdi
callq 0xb3390
movq 0x8(%rsp), %rdi
movl $0xd0, %esi
callq 0x126e0
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl $0x4, %esi
callq 0x277c0
movq $0x0, (%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::ReleaseInstanceChannel()
int RGBDImage::
ReleaseInstanceChannel(void)
{
  // Check/update read count
  if (--instance_resident_count > 0) return 1;

  // Write instance channel before releasing it ???
  // if (!WriteInstanceChannels()) return 0;

  // Delete instance channel
  if (NChannels() <= RGBD_INSTANCE_CHANNEL) return 0;
  if (!channels[RGBD_INSTANCE_CHANNEL]) return 0;
  delete channels[RGBD_INSTANCE_CHANNEL];
  channels[RGBD_INSTANCE_CHANNEL] = NULL;

  // Return success;
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0x204(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x204(%rcx)
cmpl $0x0, %eax
jle 0x2ef34
movl $0x1, 0x24(%rsp)
jmp 0x2efcc
movq 0x10(%rsp), %rdi
callq 0x30430
cmpl $0x5, %eax
jg 0x2ef4d
movl $0x0, 0x24(%rsp)
jmp 0x2efcc
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl $0x5, %esi
callq 0x277c0
cmpq $0x0, (%rax)
jne 0x2ef70
movl $0x0, 0x24(%rsp)
jmp 0x2efcc
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl $0x5, %esi
callq 0x277c0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2efaa
movq 0x8(%rsp), %rdi
callq 0xb3390
movq 0x8(%rsp), %rdi
movl $0xd0, %esi
callq 0x126e0
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl $0x5, %esi
callq 0x277c0
movq $0x0, (%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::SetName(char const*)
void RGBDImage::
SetName(const char *name)
{
  // Set filename
  if (this->name) free(this->name);
  if (name && strcmp(name, "-")) this->name = RNStrdup(name);
  else this->name = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x1d0(%rax)
je 0x2f011
movq (%rsp), %rax
movq 0x1d0(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x8(%rsp)
je 0x2f049
movq 0x8(%rsp), %rdi
leaq 0x137328(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x2f049
movq 0x8(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x1d0(%rax)
jmp 0x2f058
movq (%rsp), %rax
movq $0x0, 0x1d0(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::SetColorFilename(char const*)
void RGBDImage::
SetColorFilename(const char *filename)
{
  // Set filename
  if (color_filename) free(color_filename);
  if (filename && strcmp(filename, "-")) color_filename = RNStrdup(filename);
  else color_filename = NULL;

  // Set name
  if (!name && filename) {
    char buffer[1024];
    strncpy(buffer, filename, 1023);
    char *startp = strrchr(buffer, '/');
    if (startp) startp++;
    else startp = buffer;
    char *endp = strrchr(startp, '.');
    if (endp) *endp = '\0';
    name = RNStrdup(startp);
  }
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
movq 0x430(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x1d8(%rax)
je 0x2f09f
movq 0x8(%rsp), %rax
movq 0x1d8(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x428(%rsp)
je 0x2f0e1
movq 0x428(%rsp), %rdi
leaq 0x137294(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x2f0e1
movq 0x428(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x1d8(%rax)
jmp 0x2f0f1
movq 0x8(%rsp), %rax
movq $0x0, 0x1d8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x1d0(%rax)
jne 0x2f19d
cmpq $0x0, 0x428(%rsp)
je 0x2f19d
leaq 0x20(%rsp), %rdi
movq 0x428(%rsp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x12350
leaq 0x20(%rsp), %rdi
movl $0x2f, %esi
callq 0x127a0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2f156
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2f160
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2e, %esi
callq 0x127a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2f184
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x1d0(%rax)
addq $0x438, %rsp            # imm = 0x438
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::SetDepthFilename(char const*)
void RGBDImage::
SetDepthFilename(const char *filename)
{
  // Set filename
  if (depth_filename) free(depth_filename);
  if (filename && strcmp(filename, "-")) depth_filename = RNStrdup(filename);
  else depth_filename = NULL;

  // Set name
  if (!name && filename && strcmp(filename, "-")) {
    char buffer[1024];
    strncpy(buffer, filename, 1023);
    char *startp = strrchr(buffer, '/');
    if (startp) startp++;
    else startp = buffer;
    char *endp = strrchr(startp, '.');
    if (endp) *endp = '\0';
    name = RNStrdup(startp);
  }
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
movq 0x430(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x1e0(%rax)
je 0x2f1ef
movq 0x8(%rsp), %rax
movq 0x1e0(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x428(%rsp)
je 0x2f231
movq 0x428(%rsp), %rdi
leaq 0x137144(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x2f231
movq 0x428(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x1e0(%rax)
jmp 0x2f241
movq 0x8(%rsp), %rax
movq $0x0, 0x1e0(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x1d0(%rax)
jne 0x2f30a
cmpq $0x0, 0x428(%rsp)
je 0x2f30a
movq 0x428(%rsp), %rdi
leaq 0x1370db(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x2f30a
leaq 0x20(%rsp), %rdi
movq 0x428(%rsp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x12350
leaq 0x20(%rsp), %rdi
movl $0x2f, %esi
callq 0x127a0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2f2c3
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2f2cd
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2e, %esi
callq 0x127a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2f2f1
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x1d0(%rax)
addq $0x438, %rsp            # imm = 0x438
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::SetCategoryFilename(char const*)
void RGBDImage::
SetCategoryFilename(const char *filename)
{
  // Set filename
  if (category_filename) free(category_filename);
  if (filename && strcmp(filename, "-")) category_filename = RNStrdup(filename);
  else category_filename = NULL;

  // Set name
  if (!name && filename && strcmp(filename, "-")) {
    char buffer[1024];
    strncpy(buffer, filename, 1023);
    char *startp = strrchr(buffer, '/');
    if (!startp) startp = buffer;
    char *endp = strrchr(startp, '.');
    if (endp) *endp = '\0';
    name = RNStrdup(startp);
  }
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
movq 0x430(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x1e8(%rax)
je 0x2f35f
movq 0x8(%rsp), %rax
movq 0x1e8(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x428(%rsp)
je 0x2f3a1
movq 0x428(%rsp), %rdi
leaq 0x136fd4(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x2f3a1
movq 0x428(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x1e8(%rax)
jmp 0x2f3b1
movq 0x8(%rsp), %rax
movq $0x0, 0x1e8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x1d0(%rax)
jne 0x2f466
cmpq $0x0, 0x428(%rsp)
je 0x2f466
movq 0x428(%rsp), %rdi
leaq 0x136f6b(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x2f466
leaq 0x20(%rsp), %rdi
movq 0x428(%rsp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x12350
leaq 0x20(%rsp), %rdi
movl $0x2f, %esi
callq 0x127a0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2f429
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2e, %esi
callq 0x127a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2f44d
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x1d0(%rax)
addq $0x438, %rsp            # imm = 0x438
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDImage.cpp
// Function: gaps::RGBDImage::SetInstanceFilename(char const*)
void RGBDImage::
SetInstanceFilename(const char *filename)
{
  // Set filename
  if (instance_filename) free(instance_filename);
  if (filename && strcmp(filename, "-")) instance_filename = RNStrdup(filename);
  else instance_filename = NULL;

  // Set name
  if (!name && filename) {
    char buffer[1024];
    strncpy(buffer, filename, 1023);
    char *startp = strrchr(buffer, '/');
    if (!startp) startp = buffer;
    char *endp = strrchr(startp, '.');
    if (endp) *endp = '\0';
    name = RNStrdup(startp);
  }
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
movq 0x430(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x1f0(%rax)
je 0x2f4af
movq 0x8(%rsp), %rax
movq 0x1f0(%rax), %rdi
callq 0x12870
cmpq $0x0, 0x428(%rsp)
je 0x2f4f1
movq 0x428(%rsp), %rdi
leaq 0x136e84(%rip), %rsi    # 0x16634d
callq 0x12a00
cmpl $0x0, %eax
je 0x2f4f1
movq 0x428(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x1f0(%rax)
jmp 0x2f501
movq 0x8(%rsp), %rax
movq $0x0, 0x1f0(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x1d0(%rax)
jne 0x2f599
cmpq $0x0, 0x428(%rsp)
je 0x2f599
leaq 0x20(%rsp), %rdi
movq 0x428(%rsp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x12350
leaq 0x20(%rsp), %rdi
movl $0x2f, %esi
callq 0x127a0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2f55c
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2e, %esi
callq 0x127a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2f580
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rdi
callq 0xdf690
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x1d0(%rax)
addq $0x438, %rsp            # imm = 0x438
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/./RGBDImage.h
// Function: gaps::RGBDImage::PixelChannelValue(int, int, int) const
inline RNScalar RGBDImage::
PixelChannelValue(int ix, int iy, int channel_index) const
{
  // Check channel
  if (!channels[channel_index]) {
    RNFail("RGBD Channel is not resident in memory -- cannot get value\n");
    return R2_GRID_UNKNOWN_VALUE;
  }
  
  // Return value in channel at pixel position
  return channels[channel_index]->GridValue(ix, iy);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
movl 0xc(%rsp), %esi
callq 0x1a2a0
cmpq $0x0, %rax
jne 0x3049f
leaq 0x136a31(%rip), %rdi    # 0x166eb9
movb $0x0, %al
callq 0xdf990
movsd 0x135b89(%rip), %xmm0   # 0x166020
movsd %xmm0, 0x20(%rsp)
jmp 0x304c6
movq (%rsp), %rdi
addq $0x18, %rdi
movl 0xc(%rsp), %esi
callq 0x1a2a0
movq %rax, %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x1a060
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RGBD/RGBDUtil.cpp
// Function: gaps::RGBDCreatePositionChannels(gaps::RGBDImage*, gaps::R2Grid&, gaps::R2Grid&, gaps::R2Grid&, int)
int RGBDCreatePositionChannels(RGBDImage *image,
  R2Grid& output_px_image, R2Grid& output_py_image, R2Grid& output_pz_image,
  RNBoolean world_coordinates)
{
  R4Matrix camera_to_world = R4identity_matrix;
  if (world_coordinates) camera_to_world = image->CameraToWorld().Matrix();
  return RGBDCreatePositionChannels(*(image->DepthChannel()),
    output_px_image, output_py_image, output_pz_image,
    image->Intrinsics(), camera_to_world);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movl %r8d, 0xa4(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x182005(%rip), %rsi    # 0x1b2970
callq 0x84270
cmpl $0x0, 0xa4(%rsp)
je 0x3099c
movq 0xc0(%rsp), %rdi
callq 0x22710
movq %rax, %rdi
callq 0x19ed0
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x86970
movq 0xc0(%rsp), %rdi
callq 0x303c0
movq %rax, (%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x226a0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rax, %r8
leaq 0x20(%rsp), %r9
callq 0x30a10
addq $0xc8, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Features::strictMode()
Features Features::strictMode() {
  Features features;
  features.allowComments_ = false;
  features.strictRoot_ = true;
  features.allowDroppedNullPlaceholders_ = false;
  features.allowNumericKeys_ = false;
  return features;
}

// Assembly:
pushq %rax
leaq 0x4(%rsp), %rdi
callq 0xdfb60
movb $0x0, 0x4(%rsp)
movb $0x1, 0x5(%rsp)
movb $0x0, 0x6(%rsp)
movb $0x0, 0x7(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Value&, bool)
bool
Reader::parse(const std::string& document, Value& root, bool collectComments) {
  document_ = document;
  const char* begin = document_.c_str();
  const char* end = begin + document_.length();
  return parse(begin, end, root, collectComments);
}

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rsi
addq $0xa0, %rdi
callq 0x12080
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
callq 0x12280
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0xa0, %rdi
callq 0x12a90
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rcx
movb 0x2f(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xdfeb0
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::parse(std::istream&, Json::Value&, bool)
bool Reader::parse(std::istream& sin, Value& root, bool collectComments) {
  // std::istream_iterator<char> begin(sin);
  // std::istream_iterator<char> end;
  // Those would allow streamed input from a file, if parse() were a
  // template function.

  // Since std::string is reference-counted, this at least does not
  // create an extra copy.
  std::string doc;
  std::getline(sin, doc, (char)EOF);
  return parse(doc, root, collectComments);
}

// Assembly:
subq $0x68, %rsp
movb %cl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x129f0
movq 0x10(%rsp), %rsi
movq 0x58(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x12cd0
jmp 0xe017a
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rdx
movzbl 0x4f(%rsp), %ecx
andl $0x1, %ecx
leaq 0x28(%rsp), %rsi
callq 0xdfe00
movb %al, 0x7(%rsp)
jmp 0xe019c
leaq 0x28(%rsp), %rdi
callq 0x12430
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x12430
movq 0x20(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::skipCommentTokens(Json::Reader::Token&)
void Reader::skipCommentTokens(Token& token) {
  if (features_.allowComments_) {
    do {
      readToken(token);
    } while (token.type_ == tokenComment);
  } else {
    readToken(token);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x108(%rax)
je 0xe09fc
jmp 0xe09e2
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xe1b20
movq 0x8(%rsp), %rax
cmpl $0xc, (%rax)
je 0xe09e2
jmp 0xe0a0a
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xe1b20
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::addError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Reader::Token&, char const*)
bool
Reader::addError(const std::string& message, Token& token, Location extra) {
  ErrorInfo info;
  info.token_ = token;
  info.message_ = message;
  info.extra_ = extra;
  errors_.push_back(info);
  return false;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xf93f0
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x30(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x12080
jmp 0xe0afc
movq 0x8(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
addq $0x50, %rdi
leaq 0x20(%rsp), %rsi
callq 0xf9410
jmp 0xe0b1b
leaq 0x20(%rsp), %rdi
callq 0x23160
xorl %eax, %eax
andb $0x1, %al
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x23160
movq 0x18(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::decodeNumber(Json::Reader::Token&)
bool Reader::decodeNumber(Token& token) {
  Value decoded;
  if (!decodeNumber(token, decoded))
    return false;
  currentValue().swapPayload(decoded);
  currentValue().setOffsetStart(token.start_ - begin_);
  currentValue().setOffsetLimit(token.end_ - begin_);
  return true;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x28(%rsp)
xorl %esi, %esi
callq 0xecc20
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x70(%rsp), %rsi
callq 0xe2aa0
movb %al, 0x37(%rsp)
jmp 0xe1776
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0xe17b2
jmp 0xe1780
movb $0x0, 0x87(%rsp)
movl $0x1, 0x38(%rsp)
jmp 0xe184e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xed680
jmp 0xe1869
movq 0x20(%rsp), %rdi
callq 0xe0bd0
movq %rax, 0x18(%rsp)
jmp 0xe17c3
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xe1a10
jmp 0xe17d4
movq 0x20(%rsp), %rdi
callq 0xe0bd0
movq %rax, 0x10(%rsp)
jmp 0xe17e5
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x70(%rsp), %rcx
movq 0x8(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0xe1b00
jmp 0xe1809
movq 0x20(%rsp), %rdi
callq 0xe0bd0
movq %rax, 0x8(%rsp)
jmp 0xe181a
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x70(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0xe1390
jmp 0xe183e
movb $0x1, 0x87(%rsp)
movl $0x1, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xed680
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::decodeString(Json::Reader::Token&)
bool Reader::decodeString(Token& token) {
  std::string decoded_string;
  if (!decodeString(token, decoded_string))
    return false;
  Value decoded(decoded_string);
  currentValue().swapPayload(decoded);
  currentValue().setOffsetStart(token.start_ - begin_);
  currentValue().setOffsetLimit(token.end_ - begin_);
  return true;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x129f0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x90(%rsp), %rsi
callq 0xe25c0
movb %al, 0x37(%rsp)
jmp 0xe18d0
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0xe1902
jmp 0xe18da
movb $0x0, 0xa7(%rsp)
movl $0x1, 0x60(%rsp)
jmp 0xe19db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xe19f6
leaq 0x38(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xed120
jmp 0xe1913
movq 0x20(%rsp), %rdi
callq 0xe0bd0
movq %rax, 0x18(%rsp)
jmp 0xe1924
movq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xe1a10
jmp 0xe1935
movq 0x20(%rsp), %rdi
callq 0xe0bd0
movq %rax, 0x10(%rsp)
jmp 0xe1946
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x90(%rsp), %rcx
movq 0x8(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0xe1b00
jmp 0xe196d
movq 0x20(%rsp), %rdi
callq 0xe0bd0
movq %rax, 0x8(%rsp)
jmp 0xe197e
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x90(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0xe1390
jmp 0xe19a5
movb $0x1, 0xa7(%rsp)
movl $0x1, 0x60(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xed680
jmp 0xe19db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xed680
jmp 0xe19f6
leaq 0x70(%rsp), %rdi
callq 0x12430
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
leaq 0x70(%rsp), %rdi
callq 0x12430
movq 0x68(%rsp), %rdi
callq 0x12c20
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::swapPayload(Json::Value&)
void Value::swapPayload(Value& other) {
  ValueType temp = type_;
  type_ = other.type_;
  other.type_ = temp;
  std::swap(value_, other.value_);
  int temp2 = allocated_;
  allocated_ = other.allocated_;
  other.allocated_ = temp2 & 0x1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movw 0x8(%rdi), %ax
andw $0xff, %ax
movzwl %ax, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
movw %ax, %cx
movw 0x8(%rdi), %ax
andw $0xff, %cx
andw $0xff00, %ax            # imm = 0xFF00
orw %cx, %ax
movw %ax, 0x8(%rdi)
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movw %cx, %dx
movw 0x8(%rax), %cx
andw $0xff, %dx
andw $0xff00, %cx            # imm = 0xFF00
orw %dx, %cx
movw %cx, 0x8(%rax)
movq 0x18(%rsp), %rsi
callq 0xfa120
movq 0x8(%rsp), %rax
movw 0x8(%rax), %cx
shrw $0x8, %cx
andw $0x1, %cx
movzwl %cx, %ecx
movl %ecx, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movw 0x8(%rcx), %cx
shrw $0x8, %cx
andw $0x1, %cx
movzwl %cx, %ecx
movw %cx, %dx
movw 0x8(%rax), %cx
andw $0x1, %dx
shlw $0x8, %dx
andw $0xfeff, %cx            # imm = 0xFEFF
orw %dx, %cx
movw %cx, 0x8(%rax)
movl 0x10(%rsp), %ecx
andl $0x1, %ecx
movq 0x18(%rsp), %rax
movw %cx, %dx
movw 0x8(%rax), %cx
andw $0x1, %dx
shlw $0x8, %dx
andw $0xfeff, %cx            # imm = 0xFEFF
orw %dx, %cx
movw %cx, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::skipSpaces()
void Reader::skipSpaces() {
  while (current_ != end_) {
    Char c = *current_;
    if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
      ++current_;
    else
      break;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0xe1d7b
movq -0x18(%rsp), %rax
movq 0xd0(%rax), %rax
movb (%rax), %al
movb %al, -0x9(%rsp)
movsbl -0x9(%rsp), %eax
cmpl $0x20, %eax
je 0xe1d5e
movsbl -0x9(%rsp), %eax
cmpl $0x9, %eax
je 0xe1d5e
movsbl -0x9(%rsp), %eax
cmpl $0xd, %eax
je 0xe1d5e
movsbl -0x9(%rsp), %eax
cmpl $0xa, %eax
jne 0xe1d77
movq -0x18(%rsp), %rax
movq 0xd0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xd0(%rax)
jmp 0xe1d79
jmp 0xe1d7b
jmp 0xe1d0f
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::readString()
bool Reader::readString() {
  Char c = 0;
  while (current_ != end_) {
    c = getNextChar();
    if (c == '\\')
      getNextChar();
    else if (c == '"')
      break;
  }
  return c == '"';
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb $0x0, 0xf(%rsp)
movq (%rsp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0xe1e2d
movq (%rsp), %rdi
callq 0xe1d80
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x5c, %eax
jne 0xe1e1d
movq (%rsp), %rdi
callq 0xe1d80
jmp 0xe1e2b
movsbl 0xf(%rsp), %eax
cmpl $0x22, %eax
jne 0xe1e29
jmp 0xe1e2d
jmp 0xe1e2b
jmp 0xe1de7
movsbl 0xf(%rsp), %eax
cmpl $0x22, %eax
sete %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::readComment()
bool Reader::readComment() {
  Location commentBegin = current_ - 1;
  Char c = getNextChar();
  bool successful = false;
  if (c == '*')
    successful = readCStyleComment();
  else if (c == '/')
    successful = readCppStyleComment();
  if (!successful)
    return false;

  if (collectComments_) {
    CommentPlacement placement = commentBefore;
    if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) {
      if (c != '*' || !containsNewLine(commentBegin, current_))
        placement = commentAfterOnSameLine;
    }

    addComment(commentBegin, current_, placement);
  }
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0xd0(%rdi), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
callq 0xe1d80
movb %al, 0xf(%rsp)
movb $0x0, 0xe(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x2a, %eax
jne 0xe1e8b
movq (%rsp), %rdi
callq 0xe2280
andb $0x1, %al
movb %al, 0xe(%rsp)
jmp 0xe1ea6
movsbl 0xf(%rsp), %eax
cmpl $0x2f, %eax
jne 0xe1ea4
movq (%rsp), %rdi
callq 0xe22f0
andb $0x1, %al
movb %al, 0xe(%rsp)
jmp 0xe1ea6
testb $0x1, 0xe(%rsp)
jne 0xe1eb7
movb $0x0, 0x27(%rsp)
jmp 0xe1f3e
movq (%rsp), %rax
testb $0x1, 0x10c(%rax)
je 0xe1f39
movq (%rsp), %rax
movl $0x0, 0x8(%rsp)
cmpq $0x0, 0xd8(%rax)
je 0xe1f20
movq (%rsp), %rax
movq 0xd8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xe2380
testb $0x1, %al
jne 0xe1f20
movsbl 0xf(%rsp), %eax
cmpl $0x2a, %eax
jne 0xe1f16
movq (%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0xd0(%rax), %rsi
callq 0xe2380
testb $0x1, %al
jne 0xe1f1e
movl $0x1, 0x8(%rsp)
jmp 0xe1f20
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0xd0(%rdi), %rdx
movl 0x8(%rsp), %ecx
callq 0xe23e0
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::match(char const*, int)
bool Reader::match(Location pattern, int patternLength) {
  if (end_ - current_ < patternLength)
    return false;
  int index = patternLength;
  while (index--)
    if (current_[index] != pattern[index])
      return false;
  current_ += patternLength;
  return true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x28(%rsp)
movq 0xc8(%rcx), %rax
movq 0xd0(%rcx), %rcx
subq %rcx, %rax
movslq -0x1c(%rsp), %rcx
cmpq %rcx, %rax
jge 0xe220a
movb $0x0, -0x1(%rsp)
jmp 0xe2276
movl -0x1c(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rsp)
cmpl $0x0, %eax
je 0xe2254
movq -0x28(%rsp), %rax
movq 0xd0(%rax), %rax
movslq -0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movslq -0x20(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xe2252
movb $0x0, -0x1(%rsp)
jmp 0xe2276
jmp 0xe2212
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %edx
movq 0xd0(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0xd0(%rax)
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::readCStyleComment()
bool Reader::readCStyleComment() {
  while (current_ != end_) {
    Char c = getNextChar();
    if (c == '*' && *current_ == '/')
      break;
  }
  return getNextChar() == '/';
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0xe22d4
movq (%rsp), %rdi
callq 0xe1d80
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x2a, %eax
jne 0xe22d2
movq (%rsp), %rax
movq 0xd0(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xe22d2
jmp 0xe22d4
jmp 0xe2292
movq (%rsp), %rdi
callq 0xe1d80
movsbl %al, %eax
cmpl $0x2f, %eax
sete %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::readCppStyleComment()
bool Reader::readCppStyleComment() {
  while (current_ != end_) {
    Char c = getNextChar();
    if (c == '\n')
      break;
    if (c == '\r') {
      // Consume DOS EOL. It will be normalized in addComment.
      if (current_ != end_ && *current_ == '\n')
        getNextChar();
      // Break on Moc OS 9 EOL.
      break;
    }
  }
  return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0xe236d
movq (%rsp), %rdi
callq 0xe1d80
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0xa, %eax
jne 0xe232f
jmp 0xe236d
movsbl 0xf(%rsp), %eax
cmpl $0xd, %eax
jne 0xe236b
movq (%rsp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0xe2369
movq (%rsp), %rax
movq 0xd0(%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xe2369
movq (%rsp), %rdi
callq 0xe1d80
jmp 0xe236d
jmp 0xe2302
movb $0x1, %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::containsNewLine(char const*, char const*)
static bool containsNewLine(Reader::Location begin, Reader::Location end) {
  for (; begin < end; ++begin)
    if (*begin == '\n' || *begin == '\r')
      return true;
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0xe23c9
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0xe23b0
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0xe23b7
movb $0x1, -0x1(%rsp)
jmp 0xe23ce
jmp 0xe23b9
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0xe238a
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::addComment(char const*, char const*, Json::CommentPlacement)
void
Reader::addComment(Location begin, Location end, CommentPlacement placement) {
  assert(collectComments_);
  const std::string& normalized = normalizeEOL(begin, end);
  if (placement == commentAfterOnSameLine) {
    assert(lastValue_ != 0);
    lastValue_->setComment(normalized, placement);
  } else {
    commentsBefore_ += normalized;
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0xe24a0
leaq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpl $0x1, 0x4c(%rsp)
jne 0xe245e
movq 0x8(%rsp), %rax
movq 0xe0(%rax), %rdi
movq 0x40(%rsp), %rsi
movl 0x4c(%rsp), %edx
callq 0xe0a10
jmp 0xe2442
jmp 0xe2478
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x12430
jmp 0xe2487
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
addq $0xe8, %rdi
callq 0x12910
jmp 0xe2476
jmp 0xe2478
leaq 0x20(%rsp), %rdi
callq 0x12430
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::normalizeEOL[abi:cxx11](char const*, char const*)
static std::string normalizeEOL(Reader::Location begin, Reader::Location end) {
  std::string normalized;
  normalized.reserve(static_cast<size_t>(end - begin));
  Reader::Location current = begin;
  while (current != end) {
    char c = *current++;
    if (c == '\r') {
      if (current != end && *current == '\n')
         // convert dos EOL
         ++current;
      // convert Mac EOL
      normalized += '\n';
    } else {
      normalized += c;
    }
  }
  return normalized;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
callq 0x129f0
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rax
subq %rax, %rsi
callq 0x12af0
jmp 0xe24e3
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0xe258c
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb (%rax), %al
movb %al, 0x1f(%rsp)
movsbl 0x1f(%rsp), %eax
cmpl $0xd, %eax
jne 0xe2574
movq 0x20(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0xe2561
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xe2561
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xe2561
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x12430
jmp 0xe25ac
movq 0x10(%rsp), %rdi
movl $0xa, %esi
callq 0x12450
jmp 0xe2572
jmp 0xe2587
movq 0x10(%rsp), %rdi
movsbl 0x1f(%rsp), %esi
callq 0x12450
jmp 0xe2585
jmp 0xe2587
jmp 0xe24ed
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0xe25a2
movq 0x10(%rsp), %rdi
callq 0x12430
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::recoverFromError(Json::Reader::TokenType)
bool Reader::recoverFromError(TokenType skipUntilToken) {
  size_t const errorCount = errors_.size();
  Token skip;
  for (;;) {
    if (!readToken(skip))
      errors_.resize(errorCount); // discard errors caused by recovery
    if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
      break;
  }
  errors_.resize(errorCount);
  return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x50, %rdi
callq 0xf9470
movq %rax, 0x20(%rsp)
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe1b20
testb $0x1, %al
jne 0xe2a68
movq (%rsp), %rdi
addq $0x50, %rdi
movq 0x20(%rsp), %rsi
callq 0xf9490
movl 0x8(%rsp), %eax
cmpl 0x2c(%rsp), %eax
je 0xe2a79
cmpl $0x0, 0x8(%rsp)
jne 0xe2a7b
jmp 0xe2a7d
jmp 0xe2a44
movq (%rsp), %rdi
addq $0x50, %rdi
movq 0x20(%rsp), %rsi
callq 0xf9490
xorl %eax, %eax
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::operator[](int)
Value& Value::operator[](int index) {
  JSON_ASSERT_MESSAGE(
      index >= 0,
      "in Json::Value::operator[](int index): index cannot be negative");
  return (*this)[ArrayIndex(index)];
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x1c0(%rsp)
movl %esi, 0x1bc(%rsp)
movq 0x1c0(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x1bc(%rsp)
jge 0xe3341
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x12980
movq (%rsp), %rdi
leaq 0x876ea(%rip), %rsi     # 0x16a9c4
callq 0x126b0
jmp 0xe32e1
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x12700
jmp 0xe32f2
leaq 0x10(%rsp), %rdi
callq 0xec480
jmp 0xe32fe
leaq 0x10(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xe3335
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x12430
leaq 0x40(%rsp), %rdi
callq 0x121a0
jmp 0xe335a
movq 0x8(%rsp), %rdi
movl 0x1bc(%rsp), %esi
callq 0xefce0
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq 0x38(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::decodeDouble(Json::Reader::Token&)
bool Reader::decodeDouble(Token& token) {
  Value decoded;
  if (!decodeDouble(token, decoded))
    return false;
  currentValue().swapPayload(decoded);
  currentValue().setOffsetStart(token.start_ - begin_);
  currentValue().setOffsetLimit(token.end_ - begin_);
  return true;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x28(%rsp)
xorl %esi, %esi
callq 0xecc20
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x70(%rsp), %rsi
callq 0xe3370
movb %al, 0x37(%rsp)
jmp 0xe3776
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0xe37b2
jmp 0xe3780
movb $0x0, 0x87(%rsp)
movl $0x1, 0x38(%rsp)
jmp 0xe384e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xed680
jmp 0xe3869
movq 0x20(%rsp), %rdi
callq 0xe0bd0
movq %rax, 0x18(%rsp)
jmp 0xe37c3
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xe1a10
jmp 0xe37d4
movq 0x20(%rsp), %rdi
callq 0xe0bd0
movq %rax, 0x10(%rsp)
jmp 0xe37e5
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x70(%rsp), %rcx
movq 0x8(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0xe1b00
jmp 0xe3809
movq 0x20(%rsp), %rdi
callq 0xe0bd0
movq %rax, 0x8(%rsp)
jmp 0xe381a
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x70(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0xe1390
jmp 0xe383e
movb $0x1, 0x87(%rsp)
movl $0x1, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xed680
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::getLocationLineAndColumn(char const*, int&, int&) const
void Reader::getLocationLineAndColumn(Location location,
                                      int& line,
                                      int& column) const {
  Location current = begin_;
  Location lastLineStart = current;
  line = 0;
  while (current < location && current != end_) {
    Char c = *current++;
    if (c == '\r') {
      if (*current == '\n')
        ++current;
      lastLineStart = current;
      ++line;
    } else if (c == '\n') {
      lastLineStart = current;
      ++line;
    }
  }
  // column & line start at 1
  column = int(location - lastLineStart) + 1;
  ++line;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x40(%rsp)
movq 0xc0(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movl $0x0, (%rax)
movq -0x28(%rsp), %rcx
xorl %eax, %eax
cmpq -0x10(%rsp), %rcx
movb %al, -0x41(%rsp)
jae 0xe41e9
movq -0x40(%rsp), %rcx
movq -0x28(%rsp), %rax
cmpq 0xc8(%rcx), %rax
setne %al
movb %al, -0x41(%rsp)
movb -0x41(%rsp), %al
testb $0x1, %al
jne 0xe41f3
jmp 0xe426e
movq -0x28(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rsp)
movb (%rax), %al
movb %al, -0x31(%rsp)
movsbl -0x31(%rsp), %eax
cmpl $0xd, %eax
jne 0xe4247
movq -0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xe422f
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xe4269
movsbl -0x31(%rsp), %eax
cmpl $0xa, %eax
jne 0xe4267
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xe4269
jmp 0xe41bf
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
subq %rcx, %rax
movl %eax, %ecx
addl $0x1, %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::getLocationLineAndColumn[abi:cxx11](char const*) const
std::string Reader::getLocationLineAndColumn(Location location) const {
  int line, column;
  getLocationLineAndColumn(location, line, column);
  char buffer[18 + 16 + 16 + 1];
  snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
  return buffer;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
leaq 0x7c(%rsp), %rdx
leaq 0x78(%rsp), %rcx
callq 0xe4180
movl 0x7c(%rsp), %ecx
movl 0x78(%rsp), %r8d
leaq 0x861ff(%rip), %rdx     # 0x16a4fa
xorl %eax, %eax
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x33, %esi
callq 0x12b30
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x12c30
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x22830
jmp 0xe4336
leaq 0x3f(%rsp), %rdi
callq 0x12760
movq 0x8(%rsp), %rax
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x12760
movq 0x30(%rsp), %rdi
callq 0x12c20
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::getStructuredErrors() const
std::vector<Reader::StructuredError> Reader::getStructuredErrors() const {
  std::vector<Reader::StructuredError> allErrors;
  for (Errors::const_iterator itError = errors_.begin();
       itError != errors_.end();
       ++itError) {
    const ErrorInfo& error = *itError;
    Reader::StructuredError structured;
    structured.offset_start = error.token_.start_ - begin_;
    structured.offset_limit = error.token_.end_ - begin_;
    structured.message = error.message_;
    allErrors.push_back(structured);
  }
  return allErrors;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0xf9740
movq 0x10(%rsp), %rsi
addq $0x50, %rsi
leaq 0x80(%rsp), %rdi
callq 0xf9520
movq 0x10(%rsp), %rsi
addq $0x50, %rsi
leaq 0x60(%rsp), %rdi
callq 0xf9580
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xf9550
testb $0x1, %al
jne 0xe47d1
jmp 0xe4886
leaq 0x80(%rsp), %rdi
callq 0xf95b0
movq %rax, 0x58(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf9750
movq 0x10(%rsp), %rcx
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rcx), %rdx
subq %rdx, %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq 0xc0(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rsi
addq $0x18, %rsi
leaq 0x38(%rsp), %rdi
callq 0x12080
jmp 0xe4837
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf9770
jmp 0xe4847
leaq 0x28(%rsp), %rdi
callq 0xf97e0
leaq 0x80(%rsp), %rdi
callq 0xf96f0
jmp 0xe47a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf97e0
movq (%rsp), %rdi
callq 0xf9800
jmp 0xe48ae
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0xe48a1
movq (%rsp), %rdi
callq 0xf9800
movq 0x8(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x12c20
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::pushError(Json::Value const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Reader::pushError(const Value& value, const std::string& message) {
  ptrdiff_t const length = end_ - begin_;
  if(value.getOffsetStart() > length
    || value.getOffsetLimit() > length)
    return false;
  Token token;
  token.type_ = tokenError;
  token.start_ = begin_ + value.getOffsetStart();
  token.end_ = end_ + value.getOffsetLimit();
  ErrorInfo info;
  info.token_ = token;
  info.message_ = message;
  info.extra_ = 0;
  errors_.push_back(info);
  return true;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq 0xa8(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0xc8(%rcx), %rax
movq 0xc0(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
callq 0xe4a50
cmpq 0x90(%rsp), %rax
jg 0xe4933
movq 0xa0(%rsp), %rdi
callq 0xe4a60
cmpq 0x90(%rsp), %rax
jle 0xe4940
movb $0x0, 0xb7(%rsp)
jmp 0xe4a2b
movq 0x18(%rsp), %rax
movl $0xd, 0x78(%rsp)
movq 0xc0(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
callq 0xe4a50
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x18(%rsp), %rax
addq %rdx, %rcx
movq %rcx, 0x80(%rsp)
movq 0xc8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rdi
callq 0xe4a60
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x88(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xf93f0
movq 0x88(%rsp), %rax
movq %rax, 0x40(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x12080
jmp 0xe49df
movq 0x18(%rsp), %rdi
movq $0x0, 0x68(%rsp)
addq $0x50, %rdi
leaq 0x30(%rsp), %rsi
callq 0xf9410
jmp 0xe49fd
movb $0x1, 0xb7(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x23160
jmp 0xe4a2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x23160
jmp 0xe4a3c
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Reader::pushError(Json::Value const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Value const&)
bool Reader::pushError(const Value& value, const std::string& message, const Value& extra) {
  ptrdiff_t const length = end_ - begin_;
  if(value.getOffsetStart() > length
    || value.getOffsetLimit() > length
    || extra.getOffsetLimit() > length)
    return false;
  Token token;
  token.type_ = tokenError;
  token.start_ = begin_ + value.getOffsetStart();
  token.end_ = begin_ + value.getOffsetLimit();
  ErrorInfo info;
  info.token_ = token;
  info.message_ = message;
  info.extra_ = begin_ + extra.getOffsetStart();
  errors_.push_back(info);
  return true;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq %rcx, 0xa0(%rsp)
movq 0xb8(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0xc8(%rcx), %rax
movq 0xc0(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x98(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xe4a50
cmpq 0x98(%rsp), %rax
jg 0xe4b02
movq 0xb0(%rsp), %rdi
callq 0xe4a60
cmpq 0x98(%rsp), %rax
jg 0xe4b02
movq 0xa0(%rsp), %rdi
callq 0xe4a60
cmpq 0x98(%rsp), %rax
jle 0xe4b0f
movb $0x0, 0xc7(%rsp)
jmp 0xe4c2e
movq 0x28(%rsp), %rax
movl $0xd, 0x80(%rsp)
movq 0xc0(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xe4a50
movq 0x18(%rsp), %rcx
movq %rax, %rdx
movq 0x28(%rsp), %rax
addq %rdx, %rcx
movq %rcx, 0x88(%rsp)
movq 0xc0(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xe4a60
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x90(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xf93f0
movq 0x90(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x80(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0xa8(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x12080
jmp 0xe4bb4
movq 0x28(%rsp), %rax
movq 0xc0(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
callq 0xe4a50
movq %rax, 0x10(%rsp)
jmp 0xe4bd9
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x78(%rsp)
addq $0x50, %rdi
leaq 0x40(%rsp), %rsi
callq 0xf9410
jmp 0xe4c00
movb $0x1, 0xc7(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x23160
jmp 0xe4c2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x23160
jmp 0xe4c3f
movb 0xc7(%rsp), %al
andb $0x1, %al
addq $0xc8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x12c20
nopl (%rax)