LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreateObjectProperty(gaps::R3SurfelObject*, int)
R3SurfelObjectProperty *CreateObjectProperty(
  R3SurfelObject *object, int property_type)
{
  // Get scene
  R3SurfelScene *scene = object->Scene();
  if (!scene) return NULL;

  // Return current property, if already exists
  R3SurfelObjectProperty *property = object->FindObjectProperty(property_type);
  if (property) return property;

  // Create object property
  property = new R3SurfelObjectProperty(property_type, object);
  if (!property) return NULL;

  // Insert object property into scene
  scene->InsertObjectProperty(property);

  // Return property
  return property;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rdi
callq 0x43a90
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x371a2
movq $0x0, 0x40(%rsp)
jmp 0x3724d
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x19a40
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x371cc
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x3724d
movl $0x30, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %esi
movq 0x38(%rsp), %rdx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x6d830
jmp 0x371f7
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x37233
movq $0x0, 0x40(%rsp)
jmp 0x3724d
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x30, %esi
callq 0x13580
jmp 0x37257
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x13970
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::RemoveObjectProperty(gaps::R3SurfelObject*, int)
int RemoveObjectProperty(
  R3SurfelObject *object, int property_type)
{
  // Get scene
  R3SurfelScene *scene = object->Scene();
  if (!scene) return 0;

  // Return current property, if already exists
  R3SurfelObjectProperty *property = object->FindObjectProperty(property_type);
  if (!property) return 0;

  // Remove object property from object
  scene->RemoveObjectProperty(property);

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x43a90
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x3729e
movl $0x0, 0x24(%rsp)
jmp 0x372d8
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x19a40
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x372c1
movl $0x0, 0x24(%rsp)
jmp 0x372d8
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq (%rdi), %rax
callq *0x48(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreateLabel(gaps::R3SurfelScene*, gaps::R3SurfelLabel*, char const*, int, int, gaps::RNRgb const&)
R3SurfelLabel *
CreateLabel(R3SurfelScene *scene, R3SurfelLabel *parent_label,
  const char *label_name, int identifier, int key, const RNRgb& color)
{
  // Create label
  R3SurfelLabel *label = new R3SurfelLabel(label_name);
  if (!label) {
    RNFail("Unable to allocate label\n");
    return NULL;
  }

  // Set label properties
  if (identifier >= 0) label->SetIdentifier(identifier);
  if (key >= 0) label->SetAssignmentKeystroke(key);
  if ((color.R() >= 0) && (color.G() >= 0) && (color.B() >=0)) label->SetColor(color);
         
  // Find parent label
  if (!parent_label) parent_label = scene->RootLabel();

  // Insert label into scene
  scene->InsertLabel(label, parent_label);

  // Return label
  return label;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movl %r8d, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movl $0x98, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0x700b0
jmp 0x378a2
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x378f2
leaq 0x16d299(%rip), %rdi    # 0x1a4b54
movb $0x0, %al
callq 0x1464b0
movq $0x0, 0x50(%rsp)
jmp 0x3799d
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x98, %esi
callq 0x13580
jmp 0x379a7
cmpl $0x0, 0x34(%rsp)
jl 0x37908
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %esi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0x0, 0x30(%rsp)
jl 0x3791e
movq 0x20(%rsp), %rdi
movl 0x30(%rsp), %esi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x28(%rsp), %rdi
callq 0x31b50
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x37967
movq 0x28(%rsp), %rdi
callq 0x31b60
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x37967
movq 0x28(%rsp), %rdi
callq 0x31b70
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x37967
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
cmpq $0x0, 0x40(%rsp)
jne 0x3797e
movq 0x48(%rsp), %rdi
callq 0x31070
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x13970
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::RemoveParts(gaps::R3SurfelScene*, gaps::R3SurfelLabel*)
int
RemoveParts(R3SurfelScene *scene, R3SurfelLabel *label)
{
  // Copy array of parts
  RNArray<R3SurfelLabel *> parts;
  for (int i = 0; i < label->NParts(); i++) {
    R3SurfelLabel *part = label->Part(i);
    parts.Insert(part);
  }
  
  // Delete parts
  for (int i = 0; i < parts.NEntries(); i++) {
    R3SurfelLabel *part = parts.Kth(i);
    RemoveParts(scene, part);
    scene->RemoveLabel(part);
    delete part;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x30550
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
callq 0x30c50
movl %eax, 0x24(%rsp)
jmp 0x37a48
movl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
cmpl %ecx, %eax
jge 0x37ab0
movq 0x68(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x30c70
movq %rax, 0x18(%rsp)
jmp 0x37a69
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x30ae0
jmp 0x37a84
jmp 0x37a86
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x37a30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x30620
jmp 0x37b60
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x16d50
movl %eax, 0x14(%rsp)
jmp 0x37ad0
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0x37b4c
movl 0x34(%rsp), %esi
leaq 0x58(%rsp), %rdi
callq 0x312d0
movq %rax, 0x8(%rsp)
jmp 0x37af1
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x37a10
jmp 0x37b0c
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
jmp 0x37b21
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x37b3a
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x37b3c
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x37ab8
leaq 0x58(%rsp), %rdi
callq 0x30620
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::OrderSurfelIdentifiers(gaps::R3SurfelScene*)
int
OrderSurfelIdentifiers(R3SurfelScene *scene)
{
  // Get surfel tree
  R3SurfelTree *tree = scene->Tree();
  if (!tree) {
    RNFail("Scene has no surfel tree\n");
    return 0;
  }    

  // Get surfel database
  R3SurfelDatabase *database = tree->Database();
  if (!database) {
    RNFail("Scene has no surfel database\n");
    return 0;
  }

  // Set identifer of every surfel in database ordered from 1 to N
  unsigned int identifier = 0;
  for (int i = 0; i < database->NBlocks(); i++) {
    R3SurfelBlock *block = database->Block(i);
    block->SetMaxIdentifier(0);
    database->ReadBlock(block);
    for (int j = 0; j < block->NSurfels(); j++) 
      block->SetSurfelIdentifier(j, ++identifier);
    block->SetMaxIdentifier(identifier);
    database->ReleaseBlock(block);
  }

  // Update database max identifier
  database->SetMaxIdentifier(identifier);

  // Return success
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x16ce0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x38ccb
leaq 0x16be79(%rip), %rdi    # 0x1a4b30
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x44(%rsp)
jmp 0x38de8
movq 0x30(%rsp), %rdi
callq 0x16d10
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x38cfd
leaq 0x16bf7e(%rip), %rdi    # 0x1a4c67
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0x44(%rsp)
jmp 0x38de8
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x16d20
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x38dd2
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x31a50
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x43af0
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x31140
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1c0e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x38da5
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x24(%rsp), %edx
addl $0x1, %edx
movl %edx, 0x24(%rsp)
callq 0x4b8f0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x38d63
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x43af0
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x311c0
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x38d0d
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x43b10
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::CreateConnectedPointSet(gaps::R3SurfelPointGraph*, gaps::R3Point const&)
R3SurfelPointSet *
CreateConnectedPointSet(R3SurfelPointGraph *graph, const R3Point& center)
{
  // Find seed point (closest to center)
  int seed_index = -1;
  RNLength seed_distance = FLT_MAX;
  for (int i = 0; i < graph->NPoints(); i++) {
    R3SurfelPoint *point = graph->Point(i);
    RNLength distance = R3SquaredDistance(point->Position(), center);
    if (distance < seed_distance) {
      seed_distance = distance;
      seed_index = i;
    }
  }     

  // Check seed index
  if (seed_index < 0) return NULL;

  // Return connected component
  return CreateConnectedPointSet(graph, seed_index);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl $0xffffffff, 0x4c(%rsp) # imm = 0xFFFFFFFF
movsd 0x16a8c2(%rip), %xmm0   # 0x1a4190
movsd %xmm0, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x58(%rsp), %rdi
callq 0x43e20
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x39967
movq 0x58(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x43e40
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x18730
movq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x8e7b0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm1
movsd 0x40(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x39955
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x4c(%rsp)
jmp 0x39957
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x398dc
cmpl $0x0, 0x4c(%rsp)
jge 0x39979
movq $0x0, 0x60(%rsp)
jmp 0x3998c
movq 0x58(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x39590
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreateConnectedPointSet(gaps::R3SurfelPointSet*, double, double, double)
R3SurfelPointSet *
CreateConnectedPointSet(R3SurfelPointSet *pointset, 
  RNScalar min_volume, RNScalar max_volume, RNLength max_spacing)
{
  // Create grid
  R3Grid *grid = CreateGrid(pointset, max_spacing);
  if (!grid) return NULL;

  // Find largest connected component
  if (!MaskToLargestConnectedComponent(grid, 0.5, min_volume, max_volume)) { 
    delete grid; 
    return NULL; 
  }

  // Create connnected point set
  R3SurfelGridConstraint constraint(grid);
  R3SurfelPointSet *connected_pointset = CreatePointSet(pointset, &constraint);

  // Delete grid
  delete grid;

  // Return connected point set
  return connected_pointset;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movsd %xmm0, 0x90(%rsp)
movsd %xmm1, 0x88(%rsp)
movsd %xmm2, 0x80(%rsp)
movq 0x98(%rsp), %rdi
movsd 0x80(%rsp), %xmm0
movl $0x400, %esi            # imm = 0x400
callq 0x39b40
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
jne 0x39a03
movq $0x0, 0xa0(%rsp)
jmp 0x39b17
movq 0x78(%rsp), %rdi
movsd 0x90(%rsp), %xmm1
movsd 0x88(%rsp), %xmm2
movsd 0x16a736(%rip), %xmm0   # 0x1a4158
callq 0x39f60
cmpl $0x0, %eax
jne 0x39a66
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x39a55
movq 0x20(%rsp), %rdi
callq 0xe0050
movq 0x20(%rsp), %rdi
movl $0x250, %esi            # imm = 0x250
callq 0x13580
movq $0x0, 0xa0(%rsp)
jmp 0x39b17
movq 0x78(%rsp), %rsi
leaq 0x1c2ad6(%rip), %rax    # 0x1fc548
movsd (%rax), %xmm0
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x4, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
xorps %xmm2, %xmm2
movaps %xmm2, %xmm1
callq 0x518c0
movq 0x10(%rsp), %rsi
movq 0x98(%rsp), %rdi
callq 0x32140
movq %rax, 0x18(%rsp)
jmp 0x39ab1
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x39ae4
movq 0x8(%rsp), %rdi
callq 0xe0050
movq 0x8(%rsp), %rdi
movl $0x250, %esi            # imm = 0x250
callq 0x13580
movq 0x38(%rsp), %rax
movq %rax, 0xa0(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x43fc0
jmp 0x39b17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x43fc0
jmp 0x39b27
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x13970
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreateConnectedPointSet(gaps::R3SurfelPointSet*, gaps::R3Point const&, double, double, double, int)
R3SurfelPointSet *
CreateConnectedPointSet(R3SurfelPointSet *pointset, const R3Point &seed_position,
  RNScalar min_volume, RNScalar max_volume, RNLength grid_spacing, int max_grid_resolution)
{
  // Create grid
  R3Grid *grid = CreateGrid(pointset, grid_spacing, max_grid_resolution);
  if (!grid) return NULL;

  // Find largest connected component
  if (!MaskToSelectedConnectedComponent(grid, 0.5, seed_position, min_volume, max_volume)) { 
    delete grid; 
    return NULL; 
  }

  // Create connnected point set
  R3SurfelGridConstraint constraint(grid);
  R3SurfelPointSet *connected_pointset = CreatePointSet(pointset, &constraint);

  // Delete grid
  delete grid;

  // Return connected point set
  return connected_pointset;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movsd %xmm0, 0x98(%rsp)
movsd %xmm1, 0x90(%rsp)
movsd %xmm2, 0x88(%rsp)
movl %edx, 0x84(%rsp)
movq 0xa8(%rsp), %rdi
movsd 0x88(%rsp), %xmm0
movl 0x84(%rsp), %esi
callq 0x39b40
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
jne 0x3a304
movq $0x0, 0xb0(%rsp)
jmp 0x3a420
movq 0x78(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movsd 0x98(%rsp), %xmm1
movsd 0x90(%rsp), %xmm2
movsd 0x169e2d(%rip), %xmm0   # 0x1a4158
callq 0x3a440
cmpl $0x0, %eax
jne 0x3a36f
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x3a35e
movq 0x20(%rsp), %rdi
callq 0xe0050
movq 0x20(%rsp), %rdi
movl $0x250, %esi            # imm = 0x250
callq 0x13580
movq $0x0, 0xb0(%rsp)
jmp 0x3a420
movq 0x78(%rsp), %rsi
leaq 0x1c21cd(%rip), %rax    # 0x1fc548
movsd (%rax), %xmm0
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x4, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
xorps %xmm2, %xmm2
movaps %xmm2, %xmm1
callq 0x518c0
movq 0x10(%rsp), %rsi
movq 0xa8(%rsp), %rdi
callq 0x32140
movq %rax, 0x18(%rsp)
jmp 0x3a3ba
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3a3ed
movq 0x8(%rsp), %rdi
callq 0xe0050
movq 0x8(%rsp), %rdi
movl $0x250, %esi            # imm = 0x250
callq 0x13580
movq 0x38(%rsp), %rax
movq %rax, 0xb0(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x43fc0
jmp 0x3a420
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x43fc0
jmp 0x3a430
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x13970
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreateGrid(gaps::R3SurfelScene*, gaps::R3SurfelNode*, gaps::R3SurfelConstraint const*, double, int)
R3Grid *
CreateGrid(R3SurfelScene *scene, 
  R3SurfelNode *source_node, const R3SurfelConstraint *constraint,
  RNLength grid_spacing, int max_resolution)
{
  // Create point set
  R3SurfelPointSet *pointset = CreatePointSet(scene, source_node, constraint);
  if (!pointset) return NULL;

  // Create grid
  R3Grid *grid = CreateGrid(pointset, grid_spacing, max_resolution);
  if (!grid) { delete pointset; return NULL; }

  // Delete pointset
  delete pointset;

  // Return grid
  return grid;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x32220
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x3b409
movq $0x0, 0x50(%rsp)
jmp 0x3b475
movq 0x20(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movl 0x2c(%rsp), %esi
callq 0x39b40
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x3b450
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3b445
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x50(%rsp)
jmp 0x3b475
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3b46b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreateNormals(gaps::R3SurfelPointSet*, int, double)
R3Vector *
CreateNormals(R3SurfelPointSet *pointset, 
  int max_neighbors, RNLength max_neighbor_distance)
{
#if 0
  // Sorry
  RNAbort("CreateNormals has been deprecated.  Use UpdateNormals instead.");
  return NULL;
#else
  // Create graph
  R3SurfelPointGraph *graph = new R3SurfelPointGraph(*pointset, max_neighbors, max_neighbor_distance);
  if (!graph) {
    RNFail("Unable to create graph\n");
    return NULL;
  }

  // Compute normals
  R3Vector *normals = CreateNormals(graph);

  // Delete graph
  delete graph;

  // Return normals
  return normals;
#endif
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movsd %xmm0, 0x38(%rsp)
movl $0x80, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rsi
movl 0x44(%rsp), %edx
movsd 0x38(%rsp), %xmm0
callq 0x5d300
jmp 0x3c72e
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x3c778
leaq 0x168573(%rip), %rdi    # 0x1a4cba
movb $0x0, %al
callq 0x1464b0
movq $0x0, 0x50(%rsp)
jmp 0x3c7ae
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x80, %esi
callq 0x13580
jmp 0x3c7b8
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x3c000
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3c7a4
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x13970
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreateNodeSet(gaps::R3SurfelScene*, gaps::R3SurfelNode*, gaps::R3SurfelConstraint const*, gaps::R3Point const&, double, double, double, double)
R3SurfelNodeSet *
CreateNodeSet(R3SurfelScene *scene, 
  R3SurfelNode *source_node, const R3SurfelConstraint *constraint,
  const R3Point& xycenter, RNLength xyradius,
  RNScalar center_resolution, RNScalar perimeter_resolution,
  RNScalar focus_exponent)
{
  // Get tree variables
  R3SurfelTree *tree = scene->Tree();
  if (!tree) return NULL;

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

  // Create node set
  R3SurfelNodeSet *nodeset = new R3SurfelNodeSet();
  if (!nodeset) {
    RNFail("Unable to allocate node set\n");
    return NULL;
  }

  // Insert nodes
  InsertNodes(nodeset, tree, source_node, constraint, xycenter, xyradius,
    center_resolution, perimeter_resolution, focus_exponent);

  // Return node set
  return nodeset;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x40(%rsp)
movsd %xmm2, 0x38(%rsp)
movsd %xmm3, 0x30(%rsp)
movq 0x68(%rsp), %rdi
callq 0x16ce0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x3c825
movq $0x0, 0x70(%rsp)
jmp 0x3c8e2
cmpq $0x0, 0x60(%rsp)
jne 0x3c83c
movq 0x28(%rsp), %rdi
callq 0x31030
movq %rax, 0x60(%rsp)
movl $0x68, %edi
callq 0x13570
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x610b0
jmp 0x3c858
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x3c8a2
leaq 0x168461(%rip), %rdi    # 0x1a4cd2
movb $0x0, %al
callq 0x1464b0
movq $0x0, 0x70(%rsp)
jmp 0x3c8e2
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x68, %esi
callq 0x13580
jmp 0x3c8ec
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %r8
movsd 0x48(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
movsd 0x30(%rsp), %xmm3
callq 0x3c900
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x13970
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CreateObjectSet(gaps::R3SurfelScene*, gaps::R3SurfelConstraint const*)
R3SurfelObjectSet *
CreateObjectSet(R3SurfelScene *scene, 
  const R3SurfelConstraint *constraint)
{
  // Create object set
  R3SurfelObjectSet *objectset = new R3SurfelObjectSet();
  if (!objectset) {
    RNFail("Unable to allocate object set\n");
    return NULL;
  }

  // Construct object set
  for (int i = 0; i < scene->NObjects(); i++) {
    R3SurfelObject *object = scene->Object(i);
    if (constraint && !constraint->Check(object)) continue;
    objectset->InsertObject(object);
  }


  // Return object set
  return objectset;
}

// 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, 0x8(%rsp)
callq 0x6d050
jmp 0x3cc9a
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x3ccea
leaq 0x16803c(%rip), %rdi    # 0x1a4cef
movb $0x0, %al
callq 0x1464b0
movq $0x0, 0x40(%rsp)
jmp 0x3cd67
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x60, %esi
callq 0x13580
jmp 0x3cd71
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x38(%rsp), %rdi
callq 0x16c20
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x3cd5d
movq 0x38(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x185f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x3cd40
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x0, %eax
jne 0x3cd40
jmp 0x3cd50
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3ccf2
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x13970
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::EstimateSupportPlane(gaps::R3SurfelScene*, gaps::R3SurfelNode*, gaps::R3SurfelConstraint const*, double, double*)
R3Plane 
EstimateSupportPlane(R3SurfelScene *scene, 
  R3SurfelNode *source_node, const R3SurfelConstraint *constraint,
  RNLength accuracy, RNScalar *npoints)
{
  // Get points 
  R3SurfelPointSet *pointset = CreatePointSet(scene, source_node, constraint);
  if (!pointset) { 
    if (npoints) *npoints = 0;
    return R3null_plane; 
  }

  // Estimate support plane 
  R3Plane plane = EstimateSupportPlane(pointset, accuracy, npoints);

  // Delete points
  delete pointset;

  // Return plane
  return plane;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x32220
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x3d0d8
cmpq $0x0, 0x28(%rsp)
je 0x3d0c5
movq 0x28(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rdi
leaq 0x5c0c0f(%rip), %rsi    # 0x5fdce0
callq 0xf5990
jmp 0x3d10f
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movsd 0x30(%rsp), %xmm0
movq 0x28(%rsp), %rdx
callq 0x32cf0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3d10d
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3d10f
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::EstimateSupportZ(gaps::R3SurfelScene*, gaps::R3Point const&, double, double, double*)
RNCoord
EstimateSupportZ(R3SurfelScene *scene, 
  const R3Point& center, RNLength radius,
  RNLength accuracy, RNScalar *npoints)
{
 // Get points 
  R3SurfelCylinderConstraint cylinder_constraint(center, radius);
  R3SurfelPointSet *pointset = CreatePointSet(scene, NULL, &cylinder_constraint);
  if (!pointset) { 
    if (npoints) *npoints = 0;
    return -1; 
  }

  // Estimate support Z 
  R3Plane plane = EstimateSupportPlane(pointset, accuracy, npoints);
  RNScalar z = -(center[0]*plane[0] + center[1]*plane[1] + plane[3]) / plane[2];

  // Delete points
  delete pointset;

  // Return support z
  return z;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movsd %xmm0, 0xe8(%rsp)
movsd %xmm1, 0xe0(%rsp)
movq %rdx, 0xd8(%rsp)
movq 0xf0(%rsp), %rsi
movsd 0xe8(%rsp), %xmm0
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movsd 0x166f41(%rip), %xmm1   # 0x1a4188
movsd 0x166f41(%rip), %xmm2   # 0x1a4190
callq 0x50f30
movq 0x50(%rsp), %rdx
movq 0xf8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x32220
movq %rax, 0x58(%rsp)
jmp 0x3d271
movq 0x58(%rsp), %rax
movq %rax, 0x98(%rsp)
cmpq $0x0, 0x98(%rsp)
jne 0x3d2ec
cmpq $0x0, 0xd8(%rsp)
je 0x3d2cb
movq 0xd8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x3d2cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x43600
jmp 0x3d460
movsd 0x166ead(%rip), %xmm0   # 0x1a4180
movsd %xmm0, 0x100(%rsp)
movl $0x1, 0x88(%rsp)
jmp 0x3d442
movq 0x98(%rsp), %rsi
movsd 0xe0(%rsp), %xmm0
movq 0xd8(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x32cf0
jmp 0x3d311
movq 0xf0(%rsp), %rdi
xorl %esi, %esi
callq 0x1bba0
movsd %xmm0, 0x48(%rsp)
jmp 0x3d328
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x43580
movq %rax, 0x40(%rsp)
jmp 0x3d33b
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0xf0(%rsp), %rdi
movl $0x1, %esi
callq 0x1bba0
movsd %xmm0, 0x38(%rsp)
jmp 0x3d364
leaq 0x68(%rsp), %rdi
movl $0x1, %esi
callq 0x43580
movq %rax, 0x28(%rsp)
jmp 0x3d37a
movsd 0x30(%rsp), %xmm2
movsd 0x48(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movq 0x28(%rsp), %rax
movsd (%rax), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x68(%rsp), %rdi
movl $0x3, %esi
callq 0x43580
movq %rax, 0x20(%rsp)
jmp 0x3d3bd
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd (%rax), %xmm1
addsd %xmm1, %xmm0
movaps 0x167749(%rip), %xmm1   # 0x1a4b20
pxor %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x68(%rsp), %rdi
movl $0x2, %esi
callq 0x43580
movq %rax, 0x10(%rsp)
jmp 0x3d3f7
movq 0x10(%rsp), %rax
movsd 0x8(%rsp), %xmm0
divsd (%rax), %xmm0
movsd %xmm0, 0x60(%rsp)
movq 0x98(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3d428
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x100(%rsp)
movl $0x1, 0x88(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x43600
movsd 0x100(%rsp), %xmm0
addq $0x108, %rsp            # imm = 0x108
retq
movq 0x90(%rsp), %rdi
callq 0x13970
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::FitSupportPlane(gaps::R3SurfelPointSet*, double, double*)
R3Plane
FitSupportPlane(R3SurfelPointSet *pointset,
  RNLength accuracy, RNScalar *npoints)
{
  // Estimate support plane
  R3Plane plane = EstimateSupportPlane(pointset, accuracy, npoints);

  // Create a set of points near plane
  R3SurfelPlaneConstraint constraint(plane, FALSE, TRUE, FALSE, 5 * accuracy);
  R3SurfelPointSet *plane_pointset = CreatePointSet(pointset, &constraint);

  // Fit plane to pointset
  if (plane_pointset->NPoints() > 3) {
    plane = FitPlane(plane_pointset);
    if (npoints) *npoints = plane_pointset->NPoints();
  }

  // Delete point set
  delete plane_pointset;

  // Return plane
  return plane;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movsd %xmm0, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq 0xb8(%rsp), %rsi
movsd 0xb0(%rsp), %xmm0
movq 0xa8(%rsp), %rdx
callq 0x32cf0
movq 0x18(%rsp), %rsi
movsd 0xb0(%rsp), %xmm0
movsd 0x16760f(%rip), %xmm1   # 0x1a4ae8
mulsd %xmm1, %xmm0
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x1, %ecx
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x516a0
movq 0x20(%rsp), %rsi
movq 0xb8(%rsp), %rdi
callq 0x32140
movq %rax, 0x28(%rsp)
jmp 0x3d510
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x18700
movl %eax, 0xc(%rsp)
jmp 0x3d52a
movl 0xc(%rsp), %eax
cmpl $0x3, %eax
jle 0x3d5a2
movq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x3cd80
jmp 0x3d544
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x44240
jmp 0x3d555
cmpq $0x0, 0xa8(%rsp)
je 0x3d5a0
movq 0x60(%rsp), %rdi
callq 0x18700
movl %eax, 0x8(%rsp)
jmp 0x3d570
movl 0x8(%rsp), %eax
cvtsi2sd %eax, %xmm0
movq 0xa8(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x3d5a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x44280
jmp 0x3d5d2
jmp 0x3d5a2
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3d5bb
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x68(%rsp), %rdi
callq 0x44280
movq 0x10(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x13970
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::FitSupportPlane(gaps::R3SurfelScene*, gaps::R3SurfelNode*, gaps::R3SurfelConstraint const*, double, double*)
R3Plane 
FitSupportPlane(R3SurfelScene *scene, 
  R3SurfelNode *source_node, const R3SurfelConstraint *constraint,
  RNLength accuracy, RNScalar *npoints)
{
  // Fit support plane for points within cylinder
  R3SurfelPointSet *pointset = CreatePointSet(scene, source_node, constraint);
  R3Plane plane = FitSupportPlane(pointset, accuracy, npoints);
  delete pointset;
  return plane;
}

// 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)
movq %rcx, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x32220
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
movsd 0x30(%rsp), %xmm0
movq 0x28(%rsp), %rdx
callq 0x3d470
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x3d65e
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::EstimateOrientedBBox(gaps::R3SurfelObject*)
R3OrientedBox 
EstimateOrientedBBox(R3SurfelObject *object)
{
  // Check object
  if (!object) return R3null_oriented_box;
  
  // Get pointset
  R3SurfelPointSet *pointset = object->PointSet(TRUE);
  if (!pointset) return R3null_oriented_box;

  // Compute oriented box
  R3OrientedBox obb = EstimateOrientedBBox(pointset);

  // Delete pointset
  delete pointset;
           
  // Return oriented box
  return obb;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x3e096
movq 0x8(%rsp), %rdi
leaq 0x1bf041(%rip), %rsi    # 0x1fd0d0
callq 0xc7980
jmp 0x3e10d
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorps %xmm0, %xmm0
callq 0x19ad0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x3e0c8
movq 0x8(%rsp), %rdi
leaq 0x1bf00f(%rip), %rsi    # 0x1fd0d0
callq 0xc7980
jmp 0x3e10d
movq 0x8(%rsp), %rdi
movb $0x0, 0x1f(%rsp)
movq 0x20(%rsp), %rsi
callq 0x3dc20
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3e0f5
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x3e10b
movq 0x8(%rsp), %rdi
callq 0x1bd00
jmp 0x3e10d
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::CompareSurfelPlanarGridDatas(void const*, void const*)
static int 
CompareSurfelPlanarGridDatas(const void *data1, const void *data2)
{
  SurfelPlanarGridData *grid_data1 = (SurfelPlanarGridData *) data1;
  SurfelPlanarGridData *grid_data2 = (SurfelPlanarGridData *) data2;
  if (grid_data1->weight > grid_data2->weight) return -1;
  else if (grid_data1->weight < grid_data2->weight) return 1;
  else return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movsd 0x68(%rax), %xmm0
movq -0x28(%rsp), %rax
ucomisd 0x68(%rax), %xmm0
jbe 0x3f69e
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x3f6ca
movq -0x20(%rsp), %rax
movsd 0x68(%rax), %xmm1
movq -0x28(%rsp), %rax
movsd 0x68(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3f6c2
movl $0x1, -0x4(%rsp)
jmp 0x3f6ca
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::ClosestImage(gaps::R3SurfelScene*, gaps::R3Point const&)
R3SurfelImage *
ClosestImage(R3SurfelScene *scene, const R3Point& query_position)
{
  // Check scene
  if (!scene) return NULL;
  
  // Search for closest image
  RNScalar best_dd = FLT_MAX;
  R3SurfelImage *best_image = NULL;
  for (int i = 0; i < scene->NImages(); i++) {
    R3SurfelImage *image = scene->Image(i);
    RNScalar dd = R3SquaredDistance(image->Viewpoint(), query_position);
    if (dd < best_dd) {
      best_image = image;
      best_dd = dd;
    }
  }

  // Return closest image
  return best_image;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x42f14
movq $0x0, 0x40(%rsp)
jmp 0x42fc3
movsd 0x161274(%rip), %xmm0   # 0x1a4190
movsd %xmm0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x38(%rsp), %rdi
callq 0x16cc0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x42fb9
movq 0x38(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x30800
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x30940
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x8e7b0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x42fa7
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0x42fa9
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x42f33
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3SurfelUtils.cpp
// Function: gaps::XYDistance(gaps::R3Point const&, gaps::R3Box const&)
RNLength 
XYDistance(const R3Point& point, const R3Box& box)
{
  // Find axial distances in XY plane
  RNLength dx, dy;
  if (RNIsGreater(point.X(), box.XMax())) dx = point.X() - box.XMax();
  else if (RNIsLess(point.X(), box.XMin())) dx = box.XMin()- point.X();
  else dx = 0.0;
  if (RNIsGreater(point.Y(), box.YMax())) dy = point.Y() - box.YMax();
  else if (RNIsLess(point.Y(), box.YMin())) dy = box.YMin()- point.Y();
  else dy = 0.0;
    
  // Return distance in XY between point and closest point in box 
  if (dy == 0.0) return dx;
  else if (dx == 0.0) return dy;
  else return sqrt(dx*dx + dy*dy);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x187b0
movsd %xmm0, 0x38(%rsp)
movq 0x50(%rsp), %rdi
callq 0x44e00
movaps %xmm0, %xmm1
movsd 0x38(%rsp), %xmm0
leaq 0x1b9410(%rip), %rax    # 0x1fc548
movsd (%rax), %xmm2
callq 0x44e60
cmpl $0x0, %eax
je 0x43175
movq 0x58(%rsp), %rdi
callq 0x187b0
movsd %xmm0, 0x30(%rsp)
movq 0x50(%rsp), %rdi
callq 0x44e00
movaps %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
jmp 0x431e7
movq 0x58(%rsp), %rdi
callq 0x187b0
movsd %xmm0, 0x28(%rsp)
movq 0x50(%rsp), %rdi
callq 0x446e0
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
leaq 0x1b93a9(%rip), %rax    # 0x1fc548
movsd (%rax), %xmm2
callq 0x44e90
cmpl $0x0, %eax
je 0x431dc
movq 0x50(%rsp), %rdi
callq 0x446e0
movsd %xmm0, 0x20(%rsp)
movq 0x58(%rsp), %rdi
callq 0x187b0
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
jmp 0x431e5
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
jmp 0x431e7
movq 0x58(%rsp), %rdi
callq 0x187c0
movsd %xmm0, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0x44e20
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
leaq 0x1b9337(%rip), %rax    # 0x1fc548
movsd (%rax), %xmm2
callq 0x44e60
cmpl $0x0, %eax
je 0x4324e
movq 0x58(%rsp), %rdi
callq 0x187c0
movsd %xmm0, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x44e20
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x432be
movq 0x58(%rsp), %rdi
callq 0x187c0
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x44700
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
leaq 0x1b92d0(%rip), %rax    # 0x1fc548
movsd (%rax), %xmm2
callq 0x44e90
cmpl $0x0, %eax
je 0x432b3
movq 0x50(%rsp), %rdi
callq 0x44700
movsd %xmm0, (%rsp)
movq 0x58(%rsp), %rdi
callq 0x187c0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x432bc
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x432be
movsd 0x40(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x432dd
jp 0x432dd
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
jmp 0x43327
movsd 0x48(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x432fc
jp 0x432fc
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
jmp 0x43327
movsd 0x48(%rsp), %xmm0
movsd 0x48(%rsp), %xmm2
movsd 0x40(%rsp), %xmm1
mulsd 0x40(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x13420
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3Surfel.cpp
// Function: gaps::R3Surfel::R3Surfel()
R3Surfel::
R3Surfel(void)
  : timestamp(0),
    identifier(0),
    attribute(0),
    depth(0),
    elevation(0),
    flags(0)
{
  // Set everything
  SetPosition(0, 0, 0);
  SetNormal(0, 0, 0);
  SetTangent(0, 0, 0);
  SetRadius(0);
  SetColor(0, 0, 0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rdi)
movl $0x0, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
movw $0x0, 0x28(%rdi)
movw $0x0, 0x2a(%rdi)
movb $0x0, 0x2f(%rdi)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x44cd0
movq 0x8(%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x47830
movq 0x8(%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x47900
movq 0x8(%rsp), %rdi
xorps %xmm0, %xmm0
callq 0x479d0
movq 0x8(%rsp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x47a50
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3Surfel.cpp
// Function: gaps::R3Surfel::R3Surfel(float, float, float, unsigned char, unsigned char, unsigned char, int)
R3Surfel::
R3Surfel(float x, float y, float z, 
  unsigned char r, unsigned char g, unsigned char b, 
  RNBoolean aerial)
  : timestamp(0),
    identifier(0),
    attribute(0),
    depth(0),
    elevation(0),
    flags(0)
{
  // Set everything
  SetPosition(x, y, z);
  SetNormal(0, 0, 0);
  SetTangent(0, 0, 0);
  SetRadius(0);
  SetColor(r, g, b);
  SetAerial(aerial);
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, 0x20(%rsp)
movss %xmm0, 0x1c(%rsp)
movss %xmm1, 0x18(%rsp)
movss %xmm2, 0x14(%rsp)
movb %dl, 0x13(%rsp)
movb %cl, 0x12(%rsp)
movb %al, 0x11(%rsp)
movl %r8d, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rdi)
movl $0x0, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
movw $0x0, 0x28(%rdi)
movw $0x0, 0x2a(%rdi)
movb $0x0, 0x2f(%rdi)
movss 0x1c(%rsp), %xmm0
movss 0x18(%rsp), %xmm1
movss 0x14(%rsp), %xmm2
callq 0x44cd0
movq (%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x47830
movq (%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x47900
movq (%rsp), %rdi
xorps %xmm0, %xmm0
callq 0x479d0
movq (%rsp), %rdi
movb 0x13(%rsp), %cl
movb 0x12(%rsp), %al
movzbl %cl, %esi
movzbl %al, %edx
movzbl 0x11(%rsp), %ecx
callq 0x47a50
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x44d50
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3Surfel.cpp
// Function: gaps::R3Surfel::R3Surfel(float, float, float, float, float, float, float, unsigned char, unsigned char, unsigned char, unsigned char)
R3Surfel::
R3Surfel(float x, float y, float z, float nx, float ny, float nz,
  float radius, unsigned char r, unsigned char g, unsigned char b, 
  unsigned char flags)
  : timestamp(0),
    identifier(0),
    attribute(0),
    depth(0),
    elevation(0),
    flags(flags)
{
  // Set everything
  SetPosition(x, y, z);
  SetNormal(nx, ny, nz);
  SetTangent(0, 0, 0);
  SetRadius(radius);
  SetColor(r, g, b);
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movss %xmm1, 0x28(%rsp)
movss %xmm2, 0x24(%rsp)
movss %xmm3, 0x20(%rsp)
movss %xmm4, 0x1c(%rsp)
movss %xmm5, 0x18(%rsp)
movss %xmm6, 0x14(%rsp)
movb %sil, 0x13(%rsp)
movb %dl, 0x12(%rsp)
movb %cl, 0x11(%rsp)
movb %al, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rdi)
movl $0x0, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
movw $0x0, 0x28(%rdi)
movw $0x0, 0x2a(%rdi)
movb 0x10(%rsp), %al
movb %al, 0x2f(%rdi)
movss 0x2c(%rsp), %xmm0
movss 0x28(%rsp), %xmm1
movss 0x24(%rsp), %xmm2
callq 0x44cd0
movq 0x8(%rsp), %rdi
movss 0x20(%rsp), %xmm0
movss 0x1c(%rsp), %xmm1
movss 0x18(%rsp), %xmm2
callq 0x47830
movq 0x8(%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x47900
movq 0x8(%rsp), %rdi
movss 0x14(%rsp), %xmm0
callq 0x479d0
movq 0x8(%rsp), %rdi
movb 0x13(%rsp), %cl
movb 0x12(%rsp), %al
movzbl %cl, %esi
movzbl %al, %edx
movzbl 0x11(%rsp), %ecx
callq 0x47a50
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3Surfel.cpp
// Function: gaps::R3Surfel::R3Surfel(float, float, float, float, float, float, float, float, float, float, float, unsigned char, unsigned char, unsigned char, float, unsigned int, unsigned char)
R3Surfel::
R3Surfel(float x, float y, float z,
  float nx, float ny, float nz,
  float tx, float ty, float tz,
  float radius0, float radius1,
  unsigned char r, unsigned char g, unsigned char b, 
  float timestamp, unsigned int identifier,
  unsigned char flags)
  : timestamp(timestamp),
    identifier(identifier),
    attribute(0),
    depth(0),
    elevation(0),
    flags(flags)
{
  // Set everything
  SetPosition(x, y, z);
  SetNormal(nx, ny, nz);
  SetTangent(tx, ty, tz);
  SetRadius(0, radius0);
  SetRadius(1, radius1);
  SetColor(r, g, b);
}

// Assembly:
subq $0x48, %rsp
movb %r9b, %al
movss 0x68(%rsp), %xmm8
movss 0x60(%rsp), %xmm8
movss 0x58(%rsp), %xmm8
movss 0x50(%rsp), %xmm8
movq %rdi, 0x40(%rsp)
movss %xmm0, 0x3c(%rsp)
movss %xmm1, 0x38(%rsp)
movss %xmm2, 0x34(%rsp)
movss %xmm3, 0x30(%rsp)
movss %xmm4, 0x2c(%rsp)
movss %xmm5, 0x28(%rsp)
movss %xmm6, 0x24(%rsp)
movss %xmm7, 0x20(%rsp)
movb %sil, 0x1f(%rsp)
movb %dl, 0x1e(%rsp)
movb %cl, 0x1d(%rsp)
movl %r8d, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movss 0x68(%rsp), %xmm0
movss %xmm0, 0xc(%rdi)
movl 0x18(%rsp), %eax
movl %eax, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
movw $0x0, 0x28(%rdi)
movw $0x0, 0x2a(%rdi)
movb 0x17(%rsp), %al
movb %al, 0x2f(%rdi)
movss 0x3c(%rsp), %xmm0
movss 0x38(%rsp), %xmm1
movss 0x34(%rsp), %xmm2
callq 0x44cd0
movq 0x8(%rsp), %rdi
movss 0x30(%rsp), %xmm0
movss 0x2c(%rsp), %xmm1
movss 0x28(%rsp), %xmm2
callq 0x47830
movq 0x8(%rsp), %rdi
movss 0x24(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
movss 0x50(%rsp), %xmm2
callq 0x47900
movq 0x8(%rsp), %rdi
movss 0x58(%rsp), %xmm0
xorl %esi, %esi
callq 0x47a90
movq 0x8(%rsp), %rdi
movss 0x60(%rsp), %xmm0
movl $0x1, %esi
callq 0x47a90
movq 0x8(%rsp), %rdi
movb 0x1f(%rsp), %cl
movb 0x1e(%rsp), %al
movzbl %cl, %esi
movzbl %al, %edx
movzbl 0x1d(%rsp), %ecx
callq 0x47a50
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Surfels/R3Surfel.cpp
// Function: gaps::R3Surfel::R3Surfel(float, float, float, float, float, float, float, float, float, float, float, float, float, unsigned char, unsigned char, unsigned char, float, unsigned int, unsigned char)
R3Surfel::
R3Surfel(float x, float y, float z,
  float nx, float ny, float nz,
  float tx, float ty, float tz,
  float radius0, float radius1,
  float depth, float elevation,
  unsigned char r, unsigned char g, unsigned char b, 
  float timestamp, unsigned int identifier,
  unsigned char flags)
  : timestamp(timestamp),
    identifier(identifier),
    attribute(0),
    depth(0),
    elevation(0),
    flags(flags)
{
  // Set everything
  SetPosition(x, y, z);
  SetNormal(nx, ny, nz);
  SetTangent(tx, ty, tz);
  SetRadius(0, radius0);
  SetRadius(1, radius1);
  SetDepth(depth);
  SetElevation(elevation);
  SetColor(r, g, b);
}

// Assembly:
subq $0x48, %rsp
movb %r9b, %al
movss 0x78(%rsp), %xmm8
movss 0x70(%rsp), %xmm8
movss 0x68(%rsp), %xmm8
movss 0x60(%rsp), %xmm8
movss 0x58(%rsp), %xmm8
movss 0x50(%rsp), %xmm8
movq %rdi, 0x40(%rsp)
movss %xmm0, 0x3c(%rsp)
movss %xmm1, 0x38(%rsp)
movss %xmm2, 0x34(%rsp)
movss %xmm3, 0x30(%rsp)
movss %xmm4, 0x2c(%rsp)
movss %xmm5, 0x28(%rsp)
movss %xmm6, 0x24(%rsp)
movss %xmm7, 0x20(%rsp)
movb %sil, 0x1f(%rsp)
movb %dl, 0x1e(%rsp)
movb %cl, 0x1d(%rsp)
movl %r8d, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movss 0x78(%rsp), %xmm0
movss %xmm0, 0xc(%rdi)
movl 0x18(%rsp), %eax
movl %eax, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
movw $0x0, 0x28(%rdi)
movw $0x0, 0x2a(%rdi)
movb 0x17(%rsp), %al
movb %al, 0x2f(%rdi)
movss 0x3c(%rsp), %xmm0
movss 0x38(%rsp), %xmm1
movss 0x34(%rsp), %xmm2
callq 0x44cd0
movq 0x8(%rsp), %rdi
movss 0x30(%rsp), %xmm0
movss 0x2c(%rsp), %xmm1
movss 0x28(%rsp), %xmm2
callq 0x47830
movq 0x8(%rsp), %rdi
movss 0x24(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
movss 0x50(%rsp), %xmm2
callq 0x47900
movq 0x8(%rsp), %rdi
movss 0x58(%rsp), %xmm0
xorl %esi, %esi
callq 0x47a90
movq 0x8(%rsp), %rdi
movss 0x60(%rsp), %xmm0
movl $0x1, %esi
callq 0x47a90
movq 0x8(%rsp), %rdi
movss 0x68(%rsp), %xmm0
callq 0x47b10
movq 0x8(%rsp), %rdi
movss 0x70(%rsp), %xmm0
callq 0x47b90
movq 0x8(%rsp), %rdi
movb 0x1f(%rsp), %cl
movb 0x1e(%rsp), %al
movzbl %cl, %esi
movzbl %al, %edx
movzbl 0x1d(%rsp), %ecx
callq 0x47a50
addq $0x48, %rsp
retq
nopw (%rax,%rax)