LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::WriteAsciiFile(char const*)
int R3SurfelScene::
WriteAsciiFile(const char *filename)
{
  // Open file
  FILE *fp;
  if (!(fp = fopen(filename, "w"))) {
    RNFail("Unable to open file %s\n", filename);
    return 0;
  }

  // Write ascii stream
  int status = WriteAsciiStream(fp);

  // Close file
  fclose(fp);

  // Return status
  return status;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x183aaa(%rip), %rsi    # 0x1a6efe
callq 0x13690
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0x23481
movq 0x20(%rsp), %rsi
leaq 0x181036(%rip), %rdi    # 0x1a44a6
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x34(%rsp)
jmp 0x234aa
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x150(%rax)
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x13560
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::ReadAsciiString(_IO_FILE*, char*)
static int 
ReadAsciiString(FILE *fp, char *buffer)
{
  // Read string
  if (fscanf(fp, "%s", buffer) != (unsigned int) 1) {
    RNFail("Unable to read name\n");
    return 0;
  }

  // Restore space characters
  char *bufferp = buffer;
  while (*bufferp) {
    if (*bufferp == '^') *bufferp = '\t';
    if (*bufferp == '&') *bufferp = '\n';
    if (*bufferp == '+') *bufferp = ' ';
    bufferp++;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x180bf4(%rip), %rsi    # 0x1a75c3
movb $0x0, %al
callq 0x13a10
cmpl $0x1, %eax
je 0x269f3
leaq 0x17e017(%rip), %rdi    # 0x1a49f9
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x24(%rsp)
jmp 0x26a5e
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x26a56
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x26a1c
movq 0x8(%rsp), %rax
movb $0x9, (%rax)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x26, %eax
jne 0x26a31
movq 0x8(%rsp), %rax
movb $0xa, (%rax)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x26a46
movq 0x8(%rsp), %rax
movb $0x20, (%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x269fd
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::WriteAsciiString(_IO_FILE*, char const*)
static int 
WriteAsciiString(FILE *fp, const char *name)
{
  // Copy name
  char buffer[1024];
  if (name) strncpy(buffer, name, 1023);
  else strncpy(buffer, "None", 1023);

  // Replace space characters
  char *bufferp = buffer;
  while (*bufferp) {
    if (*bufferp == '\t') *bufferp = '^';
    if (*bufferp == '\n') *bufferp = '&';
    if (*bufferp == ' ') *bufferp = '+';
    bufferp++;
  }

  // Write string
  fprintf(fp, "%s", buffer);

  // Restore space characters
  bufferp = buffer;
  while (*bufferp) {
    if (*bufferp == '^') *bufferp = '\t';
    if (*bufferp == '&') *bufferp = '\n';
    if (*bufferp == '+') *bufferp = ' ';
    bufferp++;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x428, %rsp            # imm = 0x428
movq %rdi, 0x420(%rsp)
movq %rsi, 0x418(%rsp)
cmpq $0x0, 0x418(%rsp)
je 0x2917b
leaq 0x10(%rsp), %rdi
movq 0x418(%rsp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x132a0
jmp 0x29191
leaq 0x10(%rsp), %rdi
leaq 0x17b37d(%rip), %rsi    # 0x1a4504
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x132a0
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x291f4
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x291ba
movq 0x8(%rsp), %rax
movb $0x5e, (%rax)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x291cf
movq 0x8(%rsp), %rax
movb $0x26, (%rax)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x291e4
movq 0x8(%rsp), %rax
movb $0x2b, (%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2919b
movq 0x420(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x17e3bb(%rip), %rsi    # 0x1a75c3
movb $0x0, %al
callq 0x13810
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x29272
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x29238
movq 0x8(%rsp), %rax
movb $0x9, (%rax)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x26, %eax
jne 0x2924d
movq 0x8(%rsp), %rax
movb $0xa, (%rax)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x29262
movq 0x8(%rsp), %rax
movb $0x20, (%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x29219
movl $0x1, %eax
addq $0x428, %rsp            # imm = 0x428
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::ReadBinaryFile(char const*)
int R3SurfelScene::
ReadBinaryFile(const char *filename)
{
  // Open file
  FILE *fp;
  if (!(fp = fopen(filename, "r"))) {
    RNFail("Unable to open file %s\n", filename);
    return 0;
  }

  // Read binary stream
  int status = ReadBinaryStream(fp);

  // Close file
  fclose(fp);

  // Return status
  return status;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1820af(%rip), %rsi    # 0x1ab353
callq 0x13690
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0x292d1
movq 0x20(%rsp), %rsi
leaq 0x17b1e6(%rip), %rdi    # 0x1a44a6
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x34(%rsp)
jmp 0x292fa
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x120(%rax)
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x13560
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::R3SurfelScene::WriteBinaryFile(char const*)
int R3SurfelScene::
WriteBinaryFile(const char *filename)
{
  // Open file
  FILE *fp;
  if (!(fp = fopen(filename, "w"))) {
    RNFail("Unable to open file %s\n", filename);
    return 0;
  }

  // Write binary stream
  int status = WriteBinaryStream(fp);

  // Close file
  fclose(fp);

  // Return status
  return status;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x17dbca(%rip), %rsi    # 0x1a6efe
callq 0x13690
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
jne 0x29361
movq 0x20(%rsp), %rsi
leaq 0x17b156(%rip), %rdi    # 0x1a44a6
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x34(%rsp)
jmp 0x2938a
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x158(%rax)
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x13560
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::ReadBinaryString(_IO_FILE*, char*, int)
static int 
ReadBinaryString(FILE *fp, char *name, int size = 256)
{
  // Copy name
  if (fread(name, sizeof(char), size, fp) != (unsigned int) size) {
    RNFail("Unable to read name from binary file\n");
    return 0;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %esi
callq 0x13860
movl 0xc(%rsp), %ecx
cmpq %rcx, %rax
je 0x2c79c
leaq 0x178283(%rip), %rdi    # 0x1a4a0e
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x24(%rsp)
jmp 0x2c7a4
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::ReadBinaryInteger(_IO_FILE*, int*)
static int 
ReadBinaryInteger(FILE *fp, int *value)
{
  // Read value
  if (fread(value, sizeof(int), 1, fp) != (unsigned int) 1) {
    RNFail("Unable to read integer from binary file\n");
    return 0;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x13860
cmpq $0x1, %rax
je 0x2c7f3
leaq 0x178252(%rip), %rdi    # 0x1a4a34
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x14(%rsp)
jmp 0x2c7fb
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::ReadBinaryDouble(_IO_FILE*, double*)
static int 
ReadBinaryDouble(FILE *fp, double *value)
{
  // Read value
  if (fread(value, sizeof(double), 1, fp) != (unsigned int) 1) {
    RNFail("Unable to read integer from binary file\n");
    return 0;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x13860
cmpq $0x1, %rax
je 0x2c853
leaq 0x1781f2(%rip), %rdi    # 0x1a4a34
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x14(%rsp)
jmp 0x2c85b
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::WriteBinaryString(_IO_FILE*, char const*, int)
static int 
WriteBinaryString(FILE *fp, const char *name, int size = 256)
{
  // Copy name
  char buffer[1024] = { '\0' };
  if (size > 1024) size = 1024;
  if (name) strncpy(buffer, name, size-1);
  else strncpy(buffer, "None", size-1);
  if (fwrite(buffer, sizeof(char), size, fp) != (unsigned int) size) {
    RNFail("Unable to write name to binary file\n");
    return 0;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x428, %rsp            # imm = 0x428
movq %rdi, 0x418(%rsp)
movq %rsi, 0x410(%rsp)
movl %edx, 0x40c(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x132c0
cmpl $0x400, 0x40c(%rsp) # imm = 0x400
jle 0x2ee75
movl $0x400, 0x40c(%rsp) # imm = 0x400
cmpq $0x0, 0x410(%rsp)
je 0x2ee9f
movq %rsp, %rdi
movq 0x410(%rsp), %rsi
movl 0x40c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x132a0
jmp 0x2eebb
movq %rsp, %rdi
movl 0x40c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rdx
leaq 0x17564e(%rip), %rsi    # 0x1a4504
callq 0x132a0
movq %rsp, %rdi
movslq 0x40c(%rsp), %rdx
movq 0x418(%rsp), %rcx
movl $0x1, %esi
callq 0x13a80
movl 0x40c(%rsp), %ecx
cmpq %rcx, %rax
je 0x2eeff
leaq 0x175b72(%rip), %rdi    # 0x1a4a5d
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x424(%rsp)
jmp 0x2ef0a
movl $0x1, 0x424(%rsp)
movl 0x424(%rsp), %eax
addq $0x428, %rsp            # imm = 0x428
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::WriteBinaryInteger(_IO_FILE*, int)
static int 
WriteBinaryInteger(FILE *fp, int value)
{
  // Write value
  if (fwrite(&value, sizeof(int), 1, fp) != (unsigned int) 1) {
    RNFail("Unable to write integer to binary file\n");
    return 0;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x13a80
cmpq $0x1, %rax
je 0x2ef64
leaq 0x175b2f(%rip), %rdi    # 0x1a4a82
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x14(%rsp)
jmp 0x2ef6c
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelScene.cpp
// Function: gaps::WriteBinaryDouble(_IO_FILE*, double)
static int 
WriteBinaryDouble(FILE *fp, double value)
{
  // Write value
  if (fwrite(&value, sizeof(double), 1, fp) != (unsigned int) 1) {
    RNFail("Unable to write integer to binary file\n");
    return 0;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq 0x8(%rsp), %rcx
movq %rsp, %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x13a80
cmpq $0x1, %rax
je 0x2efc3
leaq 0x175ad0(%rip), %rdi    # 0x1a4a82
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x14(%rsp)
jmp 0x2efcb
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/./R3SurfelDatabase.h
// Function: gaps::R3SurfelDatabase::ReadBlock(gaps::R3SurfelBlock*)
inline int R3SurfelDatabase::
ReadBlock(R3SurfelBlock *block)
{
  // Check whether block needs to be read
  if (block->file_read_count == 0) {
    if (!InternalReadBlock(block, fp, swap_endian)) return 0;
  }

  // Increment reference count
  block->file_read_count++;

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0xb4(%rax)
jne 0x31191
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rdi), %rdx
movl 0x28(%rdi), %ecx
movq (%rdi), %rax
callq *0x88(%rax)
cmpl $0x0, %eax
jne 0x3118f
movl $0x0, 0x24(%rsp)
jmp 0x311ad
jmp 0x31191
movq 0x10(%rsp), %rax
movl 0xb4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xb4(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/./R3SurfelDatabase.h
// Function: gaps::R3SurfelDatabase::ReleaseBlock(gaps::R3SurfelBlock*)
inline int R3SurfelDatabase::
ReleaseBlock(R3SurfelBlock *block)
{
  // Check whether block needs to be written
  if (block->file_read_count == 1) {
    if (!InternalReleaseBlock(block, fp, swap_endian)) return 0;
  }

  // Decrement reference count
  block->file_read_count--;

  // Check if delete pending
  if (block->file_read_count == 0) {
    if (block->flags[R3_SURFEL_BLOCK_DELETE_PENDING_FLAG]) {
      RemoveBlock(block);
      delete block;
    }
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x1, 0xb4(%rax)
jne 0x31214
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rdi), %rdx
movl 0x28(%rdi), %ecx
movq (%rdi), %rax
callq *0x90(%rax)
cmpl $0x0, %eax
jne 0x31212
movl $0x0, 0x34(%rsp)
jmp 0x312ab
jmp 0x31214
movq 0x20(%rsp), %rax
movl 0xb4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xb4(%rax)
movq 0x20(%rsp), %rax
cmpl $0x0, 0xb4(%rax)
jne 0x312a3
movq 0x20(%rsp), %rax
addq $0x88, %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x1b970
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x31a20
cmpl $0x0, %eax
je 0x312a1
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3129f
movq (%rsp), %rdi
callq 0x4a1c0
movq (%rsp), %rdi
movl $0xc8, %esi
callq 0x13580
jmp 0x312a1
jmp 0x312a3
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/./R3SurfelBlock.h
// Function: gaps::R3SurfelBlock::SurfelPosition(int) const
inline R3Point R3SurfelBlock::
SurfelPosition(int surfel_index) const
{
  // Return position of kth surfel
  R3Surfel& surfel = surfels[surfel_index];
  return R3Point(position_origin.X() + surfel.PX(),
                 position_origin.Y() + surfel.PY(),
                 position_origin.Z() + surfel.PZ());
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq (%rdi), %rax
movslq 0x54(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x48(%rsp)
addq $0x10, %rdi
callq 0x187b0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x189b0
movq 0x10(%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
addq $0x10, %rdi
callq 0x187c0
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x189d0
movq 0x10(%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
addq $0x10, %rdi
callq 0x187a0
movsd %xmm0, 0x20(%rsp)
movq 0x48(%rsp), %rdi
callq 0x189e0
movsd 0x20(%rsp), %xmm2
movq 0x28(%rsp), %rdi
movsd 0x30(%rsp), %xmm1
movaps %xmm0, %xmm3
movsd 0x38(%rsp), %xmm0
cvtss2sd %xmm3, %xmm3
addsd %xmm3, %xmm2
callq 0xf8350
movq 0x40(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreatePointSet(gaps::R3SurfelPointSet*, gaps::R3SurfelConstraint const*)
R3SurfelPointSet *
CreatePointSet(R3SurfelPointSet *pointset, 
  const R3SurfelConstraint *constraint)
{
  // Create point set
  R3SurfelPointSet *result = new R3SurfelPointSet();
  if (constraint) result->InsertPoints(pointset, *constraint);
  else result->InsertPoints(pointset);
  if (result->NPoints() == 0) { delete result; return NULL; }
  return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl $0x60, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x55df0
jmp 0x3216a
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x321b2
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x60(%rax)
jmp 0x321c2
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x60, %esi
callq 0x13580
jmp 0x3220b
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x28(%rsp), %rdi
callq 0x18700
cmpl $0x0, %eax
jne 0x321f7
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x321ec
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x40(%rsp)
jmp 0x32201
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x13970
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreatePointSet(gaps::R3SurfelScene*, gaps::R3SurfelNode*, gaps::R3SurfelConstraint const*)
R3SurfelPointSet *
CreatePointSet(R3SurfelScene *scene, 
  R3SurfelNode *source_node,
  const R3SurfelConstraint *constraint)
{
  // Check tree
  R3SurfelTree *tree = scene->Tree();
  if (!tree) return NULL;

  // Check source node
  if (!source_node) source_node = tree->RootNode();

  // Create point set
  R3SurfelPointSet *pointset = new R3SurfelPointSet();
  if (!pointset) {
    RNFail("Unable to allocate point set\n");
    return NULL;
  }

  // Insert nodes 
  InsertPoints(pointset, tree, source_node, constraint);

  // Check result
  if (pointset->NPoints() == 0) { 
    delete pointset; 
    return NULL; 
  }

  // Return point set
  return pointset;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x16ce0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x32258
movq $0x0, 0x50(%rsp)
jmp 0x3232d
cmpq $0x0, 0x40(%rsp)
jne 0x3226f
movq 0x30(%rsp), %rdi
callq 0x31030
movq %rax, 0x40(%rsp)
movl $0x60, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x55df0
jmp 0x3228b
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x322d5
leaq 0x1720a4(%rip), %rdi    # 0x1a4348
movb $0x0, %al
callq 0x1464b0
movq $0x0, 0x50(%rsp)
jmp 0x3232d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x60, %esi
callq 0x13580
jmp 0x32337
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x32350
movq 0x28(%rsp), %rdi
callq 0x18700
cmpl $0x0, %eax
jne 0x32323
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x32318
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x50(%rsp)
jmp 0x3232d
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x13970
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::InsertPoints(gaps::R3SurfelPointSet*, gaps::R3SurfelTree*, gaps::R3SurfelNode*, gaps::R3SurfelConstraint const*)
static int
InsertPoints(R3SurfelPointSet *pointset, 
  R3SurfelTree *tree, R3SurfelNode *node,
  const R3SurfelConstraint *constraint)
{
  // Check node
  if (constraint && !constraint->Check(node)) return 0;

  // Check if leaf node
  if (node->NParts() == 0) {
    // Insert blocks
    for (int i = 0; i < node->NBlocks(); i++) {
      R3SurfelBlock *block = node->Block(i);
      if (constraint) pointset->InsertPoints(block, *constraint);
      else pointset->InsertPoints(block);
    }
  }
  else {
    // Consider parts
    for (int i = 0; i < node->NParts(); i++) {
      R3SurfelNode *part = node->Part(i);
      InsertPoints(pointset, tree, part, constraint);
    }
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x32392
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x0, %eax
jne 0x32392
movl $0x0, 0x54(%rsp)
jmp 0x3247f
movq 0x38(%rsp), %rdi
callq 0x31660
cmpl $0x0, %eax
jne 0x32418
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
callq 0x186b0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x32416
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x186d0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x323f7
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x30(%rax)
jmp 0x32407
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x32409
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x323a9
jmp 0x32477
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x31660
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x32475
movq 0x38(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x43680
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x32350
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x32420
jmp 0x32477
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreatePointGraph(gaps::R3SurfelScene*, gaps::R3SurfelNode*, gaps::R3SurfelConstraint const*, int, double)
R3SurfelPointGraph *
CreatePointGraph(R3SurfelScene *scene, 
  R3SurfelNode *source_node, const R3SurfelConstraint *constraint, 
  int max_neighbors, RNLength max_neighbor_distance)
{
  // Create point graph with all surfels satisfying constraint
  R3SurfelPointSet *pointset = CreatePointSet(scene, source_node, constraint);
  if (!pointset) return NULL;
  R3SurfelPointGraph *graph = new R3SurfelPointGraph(*pointset, max_neighbors, max_neighbor_distance);
  delete pointset;
  return graph;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movsd %xmm0, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x32220
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x33959
movq $0x0, 0x60(%rsp)
jmp 0x339d4
movl $0x80, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rsi
movl 0x44(%rsp), %edx
movsd 0x38(%rsp), %xmm0
callq 0x5d300
jmp 0x33984
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x339a9
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x339d4
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x80, %esi
callq 0x13580
jmp 0x339de
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x13970
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreateBlock(gaps::R3SurfelScene*, gaps::R3SurfelPointSet*, int)
R3SurfelBlock *
CreateBlock(R3SurfelScene *scene, R3SurfelPointSet *pointset, 
  RNBoolean copy_surfels)
{
  // Get convenient variables
  if (pointset->NPoints() == 0) return NULL;
  R3SurfelTree *tree = scene->Tree();
  if (!tree) return NULL;
  R3SurfelDatabase *database = tree->Database();
  if (!database) return NULL;

  // Create block with copy of points
  R3SurfelBlock *block = new R3SurfelBlock(pointset);

  // Update properties
  block->UpdateProperties();

  // Insert block into database
  database->InsertBlock(block);

  // Remove and delete pointset from other blocks ???
  // tree->RemoveAndDeletePoints(scene, pointset);

  // Return block
  return block;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
callq 0x18700
cmpl $0x0, %eax
jne 0x33c0f
movq $0x0, 0x50(%rsp)
jmp 0x33cc6
movq 0x48(%rsp), %rdi
callq 0x16ce0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x33c34
movq $0x0, 0x50(%rsp)
jmp 0x33cc6
movq 0x30(%rsp), %rdi
callq 0x16d10
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x33c56
movq $0x0, 0x50(%rsp)
jmp 0x33cc6
movl $0xc8, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rsi
callq 0x48200
jmp 0x33c77
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4c380
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x33cc6
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0xc8, %esi
callq 0x13580
jmp 0x33cd0
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x13970
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreateBlock(gaps::R3SurfelScene*, gaps::R3SurfelNode*, gaps::R3SurfelConstraint const*, int)
R3SurfelBlock *
CreateBlock(R3SurfelScene *scene, 
  R3SurfelNode *source_node, const R3SurfelConstraint *constraint, 
  RNBoolean copy_surfels)
{
  // Create point set
  R3SurfelPointSet *pointset = CreatePointSet(scene, source_node, constraint);
  if (!pointset) return NULL;

  // Create block
  R3SurfelBlock *block = CreateBlock(scene, pointset);

  // Delete point set
  delete pointset;

  // Return block
  return block;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x32220
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x33d23
movq $0x0, 0x40(%rsp)
jmp 0x33d5e
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x33be0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x33d54
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::RemoveEmptyObjects(gaps::R3SurfelScene*)
int
RemoveEmptyObjects(R3SurfelScene *scene)
{
  // Find empty subtrees of objects
  RNArray<R3SurfelObject *> deletable_subtrees;
  for (int i = 0; i < scene->NObjects(); i++) {
    R3SurfelObject *object = scene->Object(i);
    if (object == scene->RootObject()) continue;
    R3SurfelObject *parent = object->Parent();
    if (parent && !parent->HasSurfels(TRUE)) continue;
    if (object->HasSurfels(TRUE)) continue;
    deletable_subtrees.Insert(object);
  }

  // Delete subtrees
  for (int i = 0; i < deletable_subtrees.NEntries(); i++) {
    R3SurfelObject *object = deletable_subtrees.Kth(i);
    RemoveSubtree(scene, object);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x1b920
movl $0x0, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x40(%rsp)
movq 0x90(%rsp), %rdi
callq 0x16c20
movl %eax, 0x44(%rsp)
jmp 0x344ff
movl 0x40(%rsp), %eax
movl 0x44(%rsp), %ecx
cmpl %ecx, %eax
jge 0x3460c
movq 0x90(%rsp), %rdi
movl 0x7c(%rsp), %esi
callq 0x185f0
movq %rax, 0x38(%rsp)
jmp 0x34527
movq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x90(%rsp), %rdi
callq 0x31050
movq %rax, 0x30(%rsp)
jmp 0x3454f
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq %rcx, %rax
jne 0x34583
jmp 0x345fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x1b9e0
jmp 0x3469a
movq 0x60(%rsp), %rdi
callq 0x312c0
movq %rax, 0x20(%rsp)
jmp 0x34594
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x345c6
movq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x19c90
movl %eax, 0x1c(%rsp)
jmp 0x345bb
movl 0x1c(%rsp), %eax
cmpl $0x0, %eax
jne 0x345c6
jmp 0x345fc
movq 0x60(%rsp), %rdi
movl $0x1, %esi
callq 0x19c90
movl %eax, 0x18(%rsp)
jmp 0x345db
movl 0x18(%rsp), %eax
cmpl $0x0, %eax
je 0x345e6
jmp 0x345fc
movq 0x60(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x1be70
jmp 0x345fa
jmp 0x345fc
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x344e4
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x10(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x16d50
movl %eax, 0x14(%rsp)
jmp 0x3462f
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0x34680
movl 0x54(%rsp), %esi
leaq 0x80(%rsp), %rdi
callq 0x18840
movq %rax, 0x8(%rsp)
jmp 0x34653
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x90(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x346b0
jmp 0x34671
jmp 0x34673
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x34614
leaq 0x80(%rsp), %rdi
callq 0x1b9e0
movl $0x1, %eax
addq $0x98, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x13970
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::RemoveSubtree(gaps::R3SurfelScene*, gaps::R3SurfelObject*)
static int
RemoveSubtree(R3SurfelScene *scene, R3SurfelObject *object)
{
  // Check object
  if (!object) return 0;
  if (object == scene->RootObject()) return 1;
  
  // Remove parts
  for (int i = 0; i < object->NParts(); i++) {
    R3SurfelObject *part = object->Part(i);
    if (!RemoveSubtree(scene, part)) return 0;
  }

  // Delete object
  scene->RemoveObject(object);
  delete object;

  // Return success
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x346d3
movl $0x0, 0x44(%rsp)
jmp 0x34798
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x31050
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x34701
movl $0x1, 0x44(%rsp)
jmp 0x34798
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1bb10
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x34765
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x1bb30
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x346b0
cmpl $0x0, %eax
jne 0x34756
movl $0x0, 0x44(%rsp)
jmp 0x34798
jmp 0x34758
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x34709
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x34790
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::RemoveDisconnectedObjects(gaps::R3SurfelScene*)
int
RemoveDisconnectedObjects(R3SurfelScene *scene)
{
  // Find subtrees of objects disconnected from root
  RNArray<R3SurfelObject *> deletable_subtrees;
  for (int i = 0; i < scene->NObjects(); i++) {
    R3SurfelObject *object = scene->Object(i);
    if (object == scene->RootObject()) continue;
    if (object->Parent()) continue;
    deletable_subtrees.Insert(object);
  }

  // Delete subtrees
  for (int i = 0; i < deletable_subtrees.NEntries(); i++) {
    R3SurfelObject *object = deletable_subtrees.Kth(i);
    RemoveSubtree(scene, object);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1b920
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x80(%rsp), %rdi
callq 0x16c20
movl %eax, 0x3c(%rsp)
jmp 0x347ec
movl 0x38(%rsp), %eax
movl 0x3c(%rsp), %ecx
cmpl %ecx, %eax
jge 0x348ab
movq 0x80(%rsp), %rdi
movl 0x6c(%rsp), %esi
callq 0x185f0
movq %rax, 0x30(%rsp)
jmp 0x34814
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x80(%rsp), %rdi
callq 0x31050
movq %rax, 0x28(%rsp)
jmp 0x3483c
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq %rcx, %rax
jne 0x3486a
jmp 0x3489b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1b9e0
jmp 0x34930
movq 0x50(%rsp), %rdi
callq 0x312c0
movq %rax, 0x18(%rsp)
jmp 0x3487b
movq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0x34888
jmp 0x3489b
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x1be70
jmp 0x34899
jmp 0x3489b
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x347d1
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x10(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x16d50
movl %eax, 0x14(%rsp)
jmp 0x348cb
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0x34919
movl 0x4c(%rsp), %esi
leaq 0x70(%rsp), %rdi
callq 0x18840
movq %rax, 0x8(%rsp)
jmp 0x348ec
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x346b0
jmp 0x3490a
jmp 0x3490c
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x348b3
leaq 0x70(%rsp), %rdi
callq 0x1b9e0
movl $0x1, %eax
addq $0x88, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x13970
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::RemoveEmptyNodes(gaps::R3SurfelTree*, gaps::R3SurfelNode*)
static int
RemoveEmptyNodes(R3SurfelTree *tree, R3SurfelNode *node)
{
  // Check node
  if (!node) return 0;
  if (node == tree->RootNode()) return 1;
  
  // Remove empty parts
  for (int i = 0; i < node->NParts(); i++) {
    R3SurfelNode *part = node->Part(i);
    if (!RemoveEmptyNodes(tree, part)) return 0;
  }

  // Check if node is empty
  if (node->NParts() > 0) return 1;
  if (node->NBlocks() > 0) return 1;

  // Delete node
  tree->RemoveNode(node);
  delete node;

  // Return success
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x349c3
movl $0x0, 0x44(%rsp)
jmp 0x34ab9
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x31030
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x349f1
movl $0x1, 0x44(%rsp)
jmp 0x34ab9
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
callq 0x31660
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x34a55
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x43680
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x349a0
cmpl $0x0, %eax
jne 0x34a46
movl $0x0, 0x44(%rsp)
jmp 0x34ab9
jmp 0x34a48
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x349f9
movq 0x30(%rsp), %rdi
callq 0x31660
cmpl $0x0, %eax
jle 0x34a6e
movl $0x1, 0x44(%rsp)
jmp 0x34ab9
movq 0x30(%rsp), %rdi
callq 0x186b0
cmpl $0x0, %eax
jle 0x34a87
movl $0x1, 0x44(%rsp)
jmp 0x34ab9
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x62370
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x34ab1
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CullScans(gaps::R3SurfelScene*, gaps::R3SurfelConstraint const*)
int
CullScans(R3SurfelScene *scene, const R3SurfelConstraint *constraint)
{
  // Check inputs
  if (!scene) return 0;
  if (!constraint) return 0;

  // Find all scans to delete
  RNArray<R3SurfelScan *> delete_scans;
  for (int i = 0; i < scene->NScans(); i++) {
    R3SurfelScan *scan = scene->Scan(i);
    if (constraint->Check(scan->Viewpoint()) != R3_SURFEL_CONSTRAINT_FAIL) continue;
    delete_scans.Insert(scan);
  }

  // Delete scans
  for (int i = 0; i < delete_scans.NEntries(); i++) {
    R3SurfelScan *scan = delete_scans.Kth(i);
    delete scan;
  }
  
  // Return success
  return 1;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
cmpq $0x0, 0x88(%rsp)
jne 0x34f12
movl $0x0, 0x94(%rsp)
jmp 0x35096
cmpq $0x0, 0x80(%rsp)
jne 0x34f2d
movl $0x0, 0x94(%rsp)
jmp 0x35096
leaq 0x70(%rsp), %rdi
callq 0x30580
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x88(%rsp), %rdi
callq 0x16ca0
movl %eax, 0x3c(%rsp)
jmp 0x34f5a
movl 0x38(%rsp), %eax
movl 0x3c(%rsp), %ecx
cmpl %ecx, %eax
jge 0x3500e
movq 0x88(%rsp), %rdi
movl 0x6c(%rsp), %esi
callq 0x307d0
movq %rax, 0x30(%rsp)
jmp 0x34f82
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
callq 0x31bd0
movq %rax, 0x28(%rsp)
jmp 0x34faa
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movl %eax, 0x1c(%rsp)
jmp 0x34fc3
movl 0x1c(%rsp), %eax
cmpl $0x0, %eax
je 0x34feb
jmp 0x34ffe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x305f0
jmp 0x350a5
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x30ef0
jmp 0x34ffc
jmp 0x34ffe
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x34f3f
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x16d50
movl %eax, 0x18(%rsp)
jmp 0x3502e
movl 0x14(%rsp), %eax
movl 0x18(%rsp), %ecx
cmpl %ecx, %eax
jge 0x35081
movl 0x4c(%rsp), %esi
leaq 0x70(%rsp), %rdi
callq 0x31630
movq %rax, 0x8(%rsp)
jmp 0x3504f
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x35072
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x35074
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x35016
movl $0x1, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x305f0
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x13970
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CullImages(gaps::R3SurfelScene*, gaps::R3SurfelConstraint const*)
int
CullImages(R3SurfelScene *scene, const R3SurfelConstraint *constraint)
{
  // Check inputs
  if (!scene) return 0;
  if (!constraint) return 0;

  // Find all images to delete
  RNArray<R3SurfelImage *> delete_images;
  for (int i = 0; i < scene->NImages(); i++) {
    R3SurfelImage *image = scene->Image(i);
    if (constraint->Check(image->Viewpoint()) != R3_SURFEL_CONSTRAINT_FAIL) continue;
    delete_images.Insert(image);
  }

  // Delete images
  for (int i = 0; i < delete_images.NEntries(); i++) {
    R3SurfelImage *image = delete_images.Kth(i);
    delete image;
  }
  
  // Return success
  return 1;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
cmpq $0x0, 0x88(%rsp)
jne 0x350e2
movl $0x0, 0x94(%rsp)
jmp 0x35266
cmpq $0x0, 0x80(%rsp)
jne 0x350fd
movl $0x0, 0x94(%rsp)
jmp 0x35266
leaq 0x70(%rsp), %rdi
callq 0x30590
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x88(%rsp), %rdi
callq 0x16cc0
movl %eax, 0x3c(%rsp)
jmp 0x3512a
movl 0x38(%rsp), %eax
movl 0x3c(%rsp), %ecx
cmpl %ecx, %eax
jge 0x351de
movq 0x88(%rsp), %rdi
movl 0x6c(%rsp), %esi
callq 0x30800
movq %rax, 0x30(%rsp)
jmp 0x35152
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
callq 0x30940
movq %rax, 0x28(%rsp)
jmp 0x3517a
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movl %eax, 0x1c(%rsp)
jmp 0x35193
movl 0x1c(%rsp), %eax
cmpl $0x0, %eax
je 0x351bb
jmp 0x351ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x305e0
jmp 0x35275
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x30f40
jmp 0x351cc
jmp 0x351ce
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x3510f
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x16d50
movl %eax, 0x18(%rsp)
jmp 0x351fe
movl 0x14(%rsp), %eax
movl 0x18(%rsp), %ecx
cmpl %ecx, %eax
jge 0x35251
movl 0x4c(%rsp), %esi
leaq 0x70(%rsp), %rdi
callq 0x31e20
movq %rax, 0x8(%rsp)
jmp 0x3521f
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x35242
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x35244
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x351e6
movl $0x1, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x305e0
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x13970
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CullScene(gaps::R3SurfelScene*, gaps::R3SurfelConstraint const*)
int
CullScene(R3SurfelScene *scene, const R3SurfelConstraint *constraint)
{
  // Cull scan
  if (!CullScans(scene, constraint)) return 0;

  // Cull images
  if (!CullImages(scene, constraint)) return 0;

  // Cull surfels
  if (!CullSurfels(scene, constraint)) return 0;

  // Return success
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x34ee0
cmpl $0x0, %eax
jne 0x3565a
movl $0x0, 0x14(%rsp)
jmp 0x3569c
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x350b0
cmpl $0x0, %eax
jne 0x35677
movl $0x0, 0x14(%rsp)
jmp 0x3569c
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x35280
cmpl $0x0, %eax
jne 0x35694
movl $0x0, 0x14(%rsp)
jmp 0x3569c
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreateObject(gaps::R3SurfelScene*, gaps::R3SurfelObject*, char const*)
R3SurfelObject *
CreateObject(R3SurfelScene *scene, 
  R3SurfelObject *parent_object, const char *object_name)
{
  // Get parent object
  if (!parent_object) parent_object = scene->RootObject();

  // Create object
  R3SurfelObject *object = new R3SurfelObject(object_name);
    
  // Insert object into scene
  scene->InsertObject(object, parent_object);

  // Update properties
  object->UpdateProperties();

  // Return object
  return object;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x3574a
movq 0x30(%rsp), %rdi
callq 0x31050
movq %rax, 0x28(%rsp)
movl $0xf8, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rsi
callq 0x189f0
jmp 0x3576a
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x18(%rsp), %rdi
callq 0x1b880
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0xf8, %esi
callq 0x13580
movq 0x10(%rsp), %rdi
callq 0x13970
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::RemoveParts(gaps::R3SurfelScene*, gaps::R3SurfelObject*)
int
RemoveParts(R3SurfelScene *scene, R3SurfelObject *object)
{
  // Copy array of parts
  RNArray<R3SurfelObject *> parts;
  for (int i = 0; i < object->NParts(); i++) {
    R3SurfelObject *part = object->Part(i);
    parts.Insert(part);
  }
  
  // Delete parts
  for (int i = 0; i < parts.NEntries(); i++) {
    R3SurfelObject *part = parts.Kth(i);
    RemoveParts(scene, part);
    scene->RemoveObject(part);
    delete part;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1b920
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
callq 0x1bb10
movl %eax, 0x24(%rsp)
jmp 0x36738
movl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
cmpl %ecx, %eax
jge 0x367a0
movq 0x68(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x1bb30
movq %rax, 0x18(%rsp)
jmp 0x36759
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x1be70
jmp 0x36774
jmp 0x36776
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x36720
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1b9e0
jmp 0x36850
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x16d50
movl %eax, 0x14(%rsp)
jmp 0x367c0
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0x3683c
movl 0x34(%rsp), %esi
leaq 0x58(%rsp), %rdi
callq 0x18840
movq %rax, 0x8(%rsp)
jmp 0x367e1
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x36700
jmp 0x367fc
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x36811
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3682a
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3682c
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x367a8
leaq 0x58(%rsp), %rdi
callq 0x1b9e0
movl $0x1, %eax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x13970
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::SplitObject(gaps::R3SurfelObject*, gaps::R3SurfelPointSet*, gaps::R3SurfelObject**, gaps::R3SurfelObject**)
int
SplitObject(R3SurfelObject *object, R3SurfelPointSet *pointset,
  R3SurfelObject **resultA, R3SurfelObject **resultB)
{
  // Read blocks
  object->ReadBlocks();

  // Set marks
  object->SetMarks(FALSE);
  pointset->SetMarks(TRUE);

  // Create constraint
  R3SurfelMultiConstraint constraint;
  R3SurfelMarkConstraint mark_constraint(TRUE, FALSE);
  R3SurfelObjectConstraint object_constraint(object);
  constraint.InsertConstraint(&mark_constraint);
  constraint.InsertConstraint(&object_constraint);

  // Split object
  int status = SplitObject(object, &constraint, resultA, resultB);

  // Release blocks
  object->ReleaseBlocks();

  // Return status
  return status;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x10(%rsp)
callq 0x1ade0
movl 0x10(%rsp), %esi
movq 0x80(%rsp), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
movq 0x78(%rsp), %rdi
movq (%rdi), %rax
movq 0xa8(%rax), %rax
movl $0x1, %esi
movl %esi, 0xc(%rsp)
callq *%rax
leaq 0x50(%rsp), %rdi
callq 0x53f90
movl 0xc(%rsp), %esi
movl 0x10(%rsp), %edx
leaq 0x40(%rsp), %rdi
callq 0x53e40
jmp 0x368de
movq 0x80(%rsp), %rsi
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
callq 0x536d0
jmp 0x368f4
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x53ff0
jmp 0x36905
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x53ff0
jmp 0x36916
movq 0x80(%rsp), %rdi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x50(%rsp), %rsi
callq 0x369e0
movl %eax, 0x8(%rsp)
jmp 0x36938
movl 0x8(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0x1ae50
jmp 0x36951
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x43a30
leaq 0x40(%rsp), %rdi
callq 0x43a40
leaq 0x50(%rsp), %rdi
callq 0x43a50
movl 0x4(%rsp), %eax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x369c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x369bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x43a30
leaq 0x40(%rsp), %rdi
callq 0x43a40
leaq 0x50(%rsp), %rdi
callq 0x43a50
movq 0x38(%rsp), %rdi
callq 0x13970
nopl (%rax)