LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: srajangarg[P]raytracer/src/core/SceneGroup.cpp
// Function: SceneGroup::computeLight(LightInfo&, int)
bool
SceneGroup::computeLight(LightInfo & ld, int time)  /* get light parameters */
{
  if (light_ == NULL)
    return false;
  else
    ld = light_->getLight(time);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x8a18
movb $0x0, -0x1(%rbp)
jmp 0x8a3d
movq -0x68(%rbp), %rax
movq 0x48(%rax), %rsi
movl -0x1c(%rbp), %edx
leaq -0x60(%rbp), %rdi
callq 0x8f00
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8fe0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneGroup.cpp
// Function: SceneGroup::computeCamera(CameraInfo&, int)
bool
SceneGroup::computeCamera(CameraInfo & cam, int time)  /* get camera frustum */
{
  if (camera_ == NULL)
    return false;
  else
    cam = camera_->getCamera(time);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, 0x50(%rax)
jne 0x8a78
movb $0x0, -0x1(%rbp)
jmp 0x8aa2
movq -0x60(%rbp), %rax
movq 0x50(%rax), %rsi
movl -0x1c(%rbp), %edx
leaq -0x58(%rbp), %rdi
callq 0x9040
movq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x38, %edx
callq 0x5370
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/SceneData.hpp
// Function: ParametricLight::~ParametricLight()
~ParametricLight()
    {
      delete type_;
      delete color_;
      delete falloff_;
      delete angularFalloff_;
      delete deadDistance_;
      delete offset_;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x8b8b
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8bb4
movq -0x20(%rbp), %rdi
callq 0x91f0
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0x5410
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x8bd0
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8bec
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x8c08
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x8c24
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneData.hpp
// Function: ParametricMaterial::getMaterial(int)
MaterialInfo getMaterial(int time)
    {
      return MaterialInfo(RGB_->getColor(time),
                          coefficients_[0]->getValue(time),
                          coefficients_[1]->getValue(time),
                          coefficients_[2]->getValue(time),
                          coefficients_[3]->getValue(time),
                          coefficients_[4]->getValue(time),
                          coefficients_[5]->getValue(time),
                          coefficients_[6]->getValue(time));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq (%rax), %rsi
movl -0x14(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0x9510
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x78(%rbp), %rax
movsd %xmm0, -0x40(%rbp)
movq 0x10(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x78(%rbp), %rax
movsd %xmm0, -0x68(%rbp)
movq 0x18(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x78(%rbp), %rax
movsd %xmm0, -0x60(%rbp)
movq 0x20(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x78(%rbp), %rax
movsd %xmm0, -0x58(%rbp)
movq 0x28(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x78(%rbp), %rax
movsd %xmm0, -0x50(%rbp)
movq 0x30(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x78(%rbp), %rax
movsd %xmm0, -0x48(%rbp)
movq 0x38(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x70(%rbp), %rdi
movsd -0x68(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
movsd -0x58(%rbp), %xmm3
movsd -0x50(%rbp), %xmm4
movsd -0x48(%rbp), %xmm5
movaps %xmm0, %xmm6
movsd -0x40(%rbp), %xmm0
leaq -0x30(%rbp), %rsi
callq 0x95a0
movq -0x38(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneData.hpp
// Function: ParametricLight::getLight(int)
LightInfo getLight(int time)
    {
      return LightInfo((int)type_->getValue(time),
                       color_->getColor(time), falloff_->getValue(time),
                       angularFalloff_->getValue(time), deadDistance_->getValue(time),
                       offset_->getValue(time));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x68(%rbp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, -0x54(%rbp)
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0x9510
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x68(%rbp), %rax
movsd %xmm0, -0x40(%rbp)
movq 0x18(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x68(%rbp), %rax
movsd %xmm0, -0x50(%rbp)
movq 0x20(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x68(%rbp), %rax
movsd %xmm0, -0x48(%rbp)
movq 0x28(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %esi
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x40(%rbp), %xmm0
leaq -0x30(%rbp), %rdx
callq 0x9700
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneData.hpp
// Function: ParametricCamera::getCamera(int)
CameraInfo getCamera(int time)
    {
      return CameraInfo(((int)perspective_->getValue(time) != 0),
                        frustum_[0]->getValue(time),
                        frustum_[1]->getValue(time),
                        frustum_[2]->getValue(time),
                        frustum_[3]->getValue(time),
                        frustum_[4]->getValue(time),
                        frustum_[5]->getValue(time));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq (%rax), %rdi
cvtsi2sdl -0xc(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x58(%rbp), %rax
cvttsd2si %xmm0, %ecx
cmpl $0x0, %ecx
setne %cl
movb %cl, -0x49(%rbp)
movq 0x8(%rax), %rdi
cvtsi2sdl -0xc(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x58(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movq 0x10(%rax), %rdi
cvtsi2sdl -0xc(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x58(%rbp), %rax
movsd %xmm0, -0x40(%rbp)
movq 0x18(%rax), %rdi
cvtsi2sdl -0xc(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x58(%rbp), %rax
movsd %xmm0, -0x38(%rbp)
movq 0x20(%rax), %rdi
cvtsi2sdl -0xc(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x58(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movq 0x28(%rax), %rdi
cvtsi2sdl -0xc(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x58(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq 0x30(%rax), %rdi
cvtsi2sdl -0xc(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movb -0x49(%rbp), %al
movq -0x48(%rbp), %rdi
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x30(%rbp), %xmm3
movsd -0x28(%rbp), %xmm4
movaps %xmm0, %xmm5
movsd -0x20(%rbp), %xmm0
movzbl %al, %esi
andl $0x1, %esi
callq 0x9780
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/SceneInfo.hpp
// Function: MaterialInfo::MaterialInfo(RGB, double, double, double, double, double, double, double)
MaterialInfo(RGB color, const double ka, const double kd, const double ks, const double ksp, const double ksm, const double kt, const double ktn)
  : color(color)
  {
    k[MAT_MA] = ka;
    k[MAT_MD] = kd;
    k[MAT_MS] = ks;
    k[MAT_MSP] = ksp;
    k[MAT_MSM] = ksm;
    k[MAT_MT] = kt;
    k[MAT_MTN] = ktn;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movsd %xmm5, -0x40(%rbp)
movsd %xmm6, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x38, %rdi
callq 0x9680
movq -0x50(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x28(%rax)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/Types.hpp
// Function: RGB::operator=(RGB const&)
inline RGB & RGB::operator =(RGB const & c)
{
  c_[RED] = c.c_[RED];
  c_[GREEN] = c.c_[GREEN];
  c_[BLUE] = c.c_[BLUE];
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneInfo.hpp
// Function: CameraInfo::CameraInfo(bool, double, double, double, double, double, double)
CameraInfo(bool perspective, double l, double r, double b, double t, double n = 1, double f = 100)
  : perspective(perspective)
  {
    sides[FRUS_LEFT] = l;
    sides[FRUS_RIGHT] = r;
    sides[FRUS_BOTTOM] = b;
    sides[FRUS_TOP] = t;
    sides[FRUS_NEAR] = n;
    sides[FRUS_FAR] = f;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movsd %xmm5, -0x40(%rbp)
movq -0x8(%rbp), %rax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x28(%rax)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneInstance.cpp
// Function: SceneInstance::SceneInstance()
SceneInstance::SceneInstance()
{
  name_ = "unassigned";
  color_ = NULL;
  lod_ = NULL;
  child_ = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x51e7d(%rip), %rax     # 0x5b848
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x20(%rbp)
callq 0x55a0
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0x9da0
movq -0x20(%rbp), %rdi
leaq 0x3d725(%rip), %rsi     # 0x4711c
callq 0x5580
jmp 0x99fe
movq -0x30(%rbp), %rax
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9dc0
movq -0x20(%rbp), %rdi
callq 0x5290
movq -0x10(%rbp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneInstance.cpp
// Function: SceneInstance::~SceneInstance()
SceneInstance::~SceneInstance()
{
  delete color_;
  delete lod_;

  for (vector<Transform *>::iterator it = transforms_.begin(); it != transforms_.end(); ++it)
    delete *it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x51dcd(%rip), %rcx     # 0x5b838
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x9a97
movq -0x20(%rbp), %rdi
callq 0x91f0
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0x5410
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x9ac0
movq -0x30(%rbp), %rdi
callq 0x9e20
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x5410
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x9e50
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x9ec0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9e80
testb $0x1, %al
jne 0x9af5
jmp 0x9b22
leaq -0x10(%rbp), %rdi
callq 0x9ef0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x9b15
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x9b17
leaq -0x10(%rbp), %rdi
callq 0x9f10
jmp 0x9ad1
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x9dc0
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x5290
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneInstance.cpp
// Function: SceneInstance::computeColor(RGB&, int)
bool SceneInstance::computeColor(RGB & color, int time)
{
  if (color_ == NULL)
    return false;
  else
    color = color_->getColor(time);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, 0x40(%rax)
jne 0x9bf8
movb $0x0, -0x1(%rbp)
jmp 0x9c1d
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rsi
movl -0x1c(%rbp), %edx
leaq -0x38(%rbp), %rdi
callq 0x9510
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x96c0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneInstance.cpp
// Function: SceneInstance::computeLOD(int&, int)
bool SceneInstance::computeLOD(int & lod, int time)
{
  if (lod_ == NULL)
    return false;
  else
    lod = lod_->getLod(time);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x9c58
movb $0x0, -0x1(%rbp)
jmp 0x9c74
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x9f30
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/SceneInstance.cpp
// Function: SceneInstance::computeTransform(Mat4&, int)
bool SceneInstance::computeTransform(Mat4 & mat, int time)
{
  mat = identity3D();

  if (transforms_.empty())
    return false;
  else
  {
    for (vector<Transform *>::reverse_iterator it = transforms_.rbegin(); it != transforms_.rend(); ++it)
    {
      mat = mat * (**it).getMatrix(time);
    }
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x9f60
movq -0x18(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xa020
movq -0x1b8(%rbp), %rdi
addq $0x28, %rdi
callq 0xa090
testb $0x1, %al
jne 0x9cd3
jmp 0x9cdc
movb $0x0, -0x1(%rbp)
jmp 0x9d8d
movq -0x1b8(%rbp), %rsi
addq $0x28, %rsi
leaq -0xa8(%rbp), %rdi
callq 0xa0d0
movq -0x1b8(%rbp), %rsi
addq $0x28, %rsi
leaq -0xb0(%rbp), %rdi
callq 0xa150
leaq -0xa8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0xa120
testb $0x1, %al
jne 0x9d23
jmp 0x9d87
movq -0x18(%rbp), %rax
movq %rax, -0x1c0(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xb280
movq (%rax), %rsi
movl -0x1c(%rbp), %edx
movq (%rsi), %rax
leaq -0x1b0(%rbp), %rdi
callq *(%rax)
movq -0x1c0(%rbp), %rsi
leaq -0x130(%rbp), %rdi
leaq -0x1b0(%rbp), %rdx
callq 0xa1a0
movq -0x18(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0xa020
leaq -0xa8(%rbp), %rdi
callq 0xb2b0
jmp 0x9cf3
jmp 0x9d89
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/Algebra3.hpp
// Function: identity3D()
inline Mat4 identity3D()
{ return Mat4(Vec4(1.0, 0.0, 0.0, 0.0),
              Vec4(0.0, 1.0, 0.0, 0.0),
              Vec4(0.0, 0.0, 1.0, 0.0),
              Vec4(0.0, 0.0, 0.0, 1.0)); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
movsd 0x3d1ac(%rip), %xmm0    # 0x47138
xorps %xmm3, %xmm3
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0xb390
leaq -0x48(%rbp), %rdi
xorps %xmm3, %xmm3
movsd 0x3d18f(%rip), %xmm1    # 0x47138
movaps %xmm3, %xmm0
movaps %xmm3, %xmm2
callq 0xb390
leaq -0x68(%rbp), %rdi
xorps %xmm3, %xmm3
movsd 0x3d175(%rip), %xmm2    # 0x47138
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
callq 0xb390
leaq -0x88(%rbp), %rdi
xorps %xmm2, %xmm2
movsd 0x3d158(%rip), %xmm3    # 0x47138
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xb390
movq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rcx
leaq -0x88(%rbp), %r8
callq 0xb3e0
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::SceneLoader(Scene&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
SceneLoader::SceneLoader(Scene & scene, string file)
{
  err = &cout;
  scene.root_ = new SceneInstance();
  root = scene.root_;
  root->name_ = "toplevel";
  buildScene(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x12770
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x70(%rbp)
callq 0x12790
movq -0x58(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x68(%rbp)
callq 0x127b0
movq -0x58(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x60(%rbp)
callq 0x8ab0
movq -0x58(%rbp), %rax
movq 0x5067b(%rip), %rcx     # 0x5bfc8
movq %rcx, 0x90(%rax)
movl $0x58, %edi
callq 0x5400
movq %rax, -0x50(%rbp)
jmp 0xb964
movq -0x50(%rbp), %rdi
callq 0x99b0
jmp 0xb96f
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x98(%rax)
movq 0x98(%rax), %rdi
addq $0x8, %rdi
leaq 0x3b832(%rip), %rsi     # 0x471d0
callq 0x5580
jmp 0xb9a5
movq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x51b0
jmp 0xb9b4
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xba50
jmp 0xb9c3
leaq -0x48(%rbp), %rdi
callq 0x5290
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xba14
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0xba14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5290
movq -0x60(%rbp), %rdi
callq 0x8ad0
movq -0x68(%rbp), %rdi
callq 0x127d0
movq -0x70(%rbp), %rdi
callq 0x127f0
movq -0x58(%rbp), %rdi
callq 0x12810
movq -0x20(%rbp), %rdi
callq 0x5720
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::~SceneLoader()
SceneLoader::~SceneLoader()
{
  for (map<string, SceneGroup *>::iterator it = groups.begin();
       it != groups.end(); ++it)
  {
    delete it->second;
  }

  for (map<string, ParametricMaterial *>::iterator it = materials.begin();
       it != materials.end(); ++it)
  {
    delete it->second;
  }

  for (vector<SceneInstance *>::iterator it = instances.begin(); it != instances.end(); ++it)
  {
    delete *it;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
callq 0x12870
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x128d0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x128a0
testb $0x1, %al
jne 0xc655
jmp 0xc683
leaq -0x10(%rbp), %rdi
callq 0x12900
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xc676
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xc678
leaq -0x10(%rbp), %rdi
callq 0x12920
jmp 0xc631
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
callq 0x12950
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
callq 0x129b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12980
testb $0x1, %al
jne 0xc6b8
jmp 0xc6f3
leaq -0x20(%rbp), %rdi
callq 0x129e0
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xc6e6
movq -0x50(%rbp), %rdi
callq 0x12a00
movq -0x50(%rbp), %rdi
movl $0x40, %esi
callq 0x5410
jmp 0xc6e8
leaq -0x20(%rbp), %rdi
callq 0x12a80
jmp 0xc694
movq -0x40(%rbp), %rdi
addq $0x78, %rdi
callq 0x12ab0
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
addq $0x78, %rdi
callq 0x12b20
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12ae0
testb $0x1, %al
jne 0xc728
jmp 0xc755
leaq -0x30(%rbp), %rdi
callq 0x12b50
movq (%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xc748
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xc74a
leaq -0x30(%rbp), %rdi
callq 0x12b70
jmp 0xc704
movq -0x40(%rbp), %rdi
addq $0x78, %rdi
callq 0x8ad0
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
callq 0x127d0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x127f0
movq -0x40(%rbp), %rdi
callq 0x12810
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::buildEndlineTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SceneLoader::buildEndlineTable(string filename)
{
  ifstream file(filename.c_str());
  string line;

  while (getline( file, line ))
    endlineTable.push_back(file.tellg());

  endlineTable.push_back(file.tellg());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rsi, -0x280(%rbp)
movq %rdi, %rax
movq -0x280(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x278(%rbp)
callq 0x51a0
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x5760
leaq -0x238(%rbp), %rdi
callq 0x55a0
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x50e0
movq %rax, -0x288(%rbp)
jmp 0xc800
movq -0x288(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5500
movb %al, -0x289(%rbp)
jmp 0xc81e
movb -0x289(%rbp), %al
testb $0x1, %al
jne 0xc82d
jmp 0xc8de
movq -0x278(%rbp), %rax
movq %rax, -0x2a8(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x5700
movq %rdx, -0x2a0(%rbp)
movq %rax, -0x298(%rbp)
jmp 0xc857
movq -0x2a0(%rbp), %rax
movq -0x298(%rbp), %rcx
movq %rcx, -0x258(%rbp)
movq %rax, -0x250(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x12bc0
movq %rax, -0x2b0(%rbp)
jmp 0xc888
movq -0x2a8(%rbp), %rdi
movq -0x2b0(%rbp), %rax
movl %eax, -0x248(%rbp)
leaq -0x248(%rbp), %rsi
callq 0x12b90
jmp 0xc8aa
jmp 0xc7e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x5290
leaq -0x218(%rbp), %rdi
callq 0x5120
jmp 0xc97c
movq -0x278(%rbp), %rax
movq %rax, -0x2c8(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x5700
movq %rdx, -0x2c0(%rbp)
movq %rax, -0x2b8(%rbp)
jmp 0xc908
movq -0x2c0(%rbp), %rax
movq -0x2b8(%rbp), %rcx
movq %rcx, -0x270(%rbp)
movq %rax, -0x268(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x12bc0
movq %rax, -0x2d0(%rbp)
jmp 0xc939
movq -0x2c8(%rbp), %rdi
movq -0x2d0(%rbp), %rax
movl %eax, -0x25c(%rbp)
leaq -0x25c(%rbp), %rsi
callq 0x12b90
jmp 0xc95b
leaq -0x238(%rbp), %rdi
callq 0x5290
leaq -0x218(%rbp), %rdi
callq 0x5120
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
movq -0x240(%rbp), %rdi
callq 0x5720
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::curPos(std::ostream&, int)
void SceneLoader::curPos(ostream & out, int g)
{
  int line = 1;
  int lastg = 0;

  for (vector<int>::iterator it = endlineTable.begin(); it != endlineTable.end(); ++it)
  {
    if (*it > g)
    {
      out << "line: " << line << " char: " << (g - lastg - 1);
      return;
    }

    lastg = *it;
    line ++;
  }

  out << "line: " << line << " char: " << (g - lastg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x1, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x12be0
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
callq 0x12c50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12c10
testb $0x1, %al
jne 0xc9e2
jmp 0xca54
leaq -0x28(%rbp), %rdi
callq 0x12c80
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0xca2f
movq -0x10(%rbp), %rdi
leaq 0x3a7dc(%rip), %rsi     # 0x471d9
callq 0x53e0
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x56f0
movq %rax, %rdi
leaq 0x3a7c9(%rip), %rsi     # 0x471e0
callq 0x53e0
movq %rax, %rdi
movl -0x14(%rbp), %esi
subl -0x1c(%rbp), %esi
subl $0x1, %esi
callq 0x56f0
jmp 0xca8c
leaq -0x28(%rbp), %rdi
callq 0x12c80
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12ca0
jmp 0xc9c2
movq -0x10(%rbp), %rdi
leaq 0x3a77a(%rip), %rsi     # 0x471d9
callq 0x53e0
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x56f0
movq %rax, %rdi
leaq 0x3a767(%rip), %rsi     # 0x471e0
callq 0x53e0
movq %rax, %rdi
movl -0x14(%rbp), %esi
subl -0x1c(%rbp), %esi
callq 0x56f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::getString[abi:cxx11](std::istream&)
string SceneLoader::getString(istream & str)
{
  string ret;
  char temp;
  str >> temp; // get rid of white space, get to first char
  str.putback(temp);

  while (str.get(temp))
  {
    if ((temp >= 'a' && temp <= 'z')
        || (temp >= 'A' && temp <= 'Z')
        || (temp >= '0' && temp <= '9')
        || (temp == '_'))
    {
      ret += temp;
    }
    else if (temp == '#')
    {
      string no;
      getline(str, no);

      if (ret.empty())
        return getString(str);
      else
        return ret;
    }
    else
    {
      str.putback(temp);
      break;
    }
  }

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x55a0
movq -0x18(%rbp), %rdi
leaq -0x39(%rbp), %rsi
callq 0x5530
jmp 0xcae8
movq -0x18(%rbp), %rdi
movsbl -0x39(%rbp), %esi
callq 0x5790
jmp 0xcaf7
jmp 0xcaf9
movq -0x18(%rbp), %rdi
leaq -0x39(%rbp), %rsi
callq 0x5590
movq %rax, -0x98(%rbp)
jmp 0xcb0f
movq -0x98(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5500
movb %al, -0x99(%rbp)
jmp 0xcb2d
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0xcb3c
jmp 0xcc4c
movsbl -0x39(%rbp), %eax
cmpl $0x61, %eax
jl 0xcb4e
movsbl -0x39(%rbp), %eax
cmpl $0x7a, %eax
jle 0xcb7b
movsbl -0x39(%rbp), %eax
cmpl $0x41, %eax
jl 0xcb60
movsbl -0x39(%rbp), %eax
cmpl $0x5a, %eax
jle 0xcb7b
movsbl -0x39(%rbp), %eax
cmpl $0x30, %eax
jl 0xcb72
movsbl -0x39(%rbp), %eax
cmpl $0x39, %eax
jle 0xcb7b
movsbl -0x39(%rbp), %eax
cmpl $0x5f, %eax
jne 0xcba0
movsbl -0x39(%rbp), %esi
leaq -0x38(%rbp), %rdi
callq 0x52a0
jmp 0xcb8a
jmp 0xcc47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xcc7c
movsbl -0x39(%rbp), %eax
cmpl $0x23, %eax
jne 0xcc36
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x55a0
movq -0xa8(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x50e0
jmp 0xcbcf
leaq -0x38(%rbp), %rdi
callq 0x5690
testb $0x1, %al
jne 0xcbde
jmp 0xcc14
movq -0x80(%rbp), %rsi
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rdx
callq 0xcaa0
jmp 0xcbf4
movl $0x1, -0x74(%rbp)
jmp 0xcc2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5290
jmp 0xcc7c
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5270
movl $0x1, -0x74(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5290
jmp 0xcc63
movq -0x18(%rbp), %rdi
movsbl -0x39(%rbp), %esi
callq 0x5790
jmp 0xcc45
jmp 0xcc4c
jmp 0xcaf9
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5270
movl $0x1, -0x74(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5290
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x5290
movq -0x48(%rbp), %rdi
callq 0x5720
nop
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::getQuoted[abi:cxx11](std::istream&)
string SceneLoader::getQuoted(istream & str)
{
  string ret;
  char temp;
  str >> temp;

  if (temp != '"')
  {
    *err << "expected opening \" at ";
    curPos(*err, str.tellg());
    *err << endl;
  }

  getline(str, ret, '"');
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x55a0
movq -0x18(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
callq 0x5530
jmp 0xccd2
movsbl -0x1a(%rbp), %eax
cmpl $0x22, %eax
je 0xcd80
movq -0x48(%rbp), %rax
movq 0x90(%rax), %rdi
leaq 0x3a4f7(%rip), %rsi     # 0x471e8
callq 0x53e0
jmp 0xccf8
movq -0x48(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5700
movq %rdx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
jmp 0xcd1a
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x12bc0
movq %rax, -0x78(%rbp)
jmp 0xcd39
movq -0x70(%rbp), %rsi
movq -0x48(%rbp), %rdi
movq -0x78(%rbp), %rax
movl %eax, %edx
callq 0xc990
jmp 0xcd4e
movq -0x48(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x4f250(%rip), %rsi     # 0x5bfb0
callq 0x5440
jmp 0xcd67
jmp 0xcd80
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5290
jmp 0xcdb4
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdi
movl $0x22, %edx
callq 0x5770
jmp 0xcd94
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xcda7
movq -0x58(%rbp), %rdi
callq 0x5290
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5720
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::readCommand(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool SceneLoader::readCommand(istream & str, string & name)
{
  name = getString(str);

  if (name.empty())
  {
    *err << "error: expected command but did not find one at ";
    curPos(*err, str.tellg());
    *err << endl;
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xcaa0
movq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x54d0
leaq -0x40(%rbp), %rdi
callq 0x5290
movq -0x20(%rbp), %rdi
callq 0x5690
testb $0x1, %al
jne 0xce0e
jmp 0xce7a
movq -0x58(%rbp), %rax
movq 0x90(%rax), %rdi
leaq 0x3a3df(%rip), %rsi     # 0x471ff
callq 0x53e0
movq -0x58(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5700
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12bc0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
movl %eax, %edx
callq 0xc990
movq -0x58(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x4f141(%rip), %rsi     # 0x5bfb0
callq 0x5440
movb $0x0, -0x1(%rbp)
jmp 0xce7e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::findOpenParen(std::istream&)
bool SceneLoader::findOpenParen(istream & str)
{
  char temp;
  string line;

  while (str >> temp)
  {
    if (temp == '(')
      return true;
    else if (temp == '#')
      getline(str, line);
    else
    {
      *err << "error: unexpected char " << temp << " at ";
      curPos(*err, str.tellg());
      *err << endl;
      return false;
    }
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x55a0
movq -0x18(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x5530
movq %rax, -0x70(%rbp)
jmp 0xcec7
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5500
movb %al, -0x71(%rbp)
jmp 0xcedf
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xceeb
jmp 0xd01e
movsbl -0x19(%rbp), %eax
cmpl $0x28, %eax
jne 0xcf1e
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0xd029
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5290
jmp 0xd040
movsbl -0x19(%rbp), %eax
cmpl $0x23, %eax
jne 0xcf3b
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x50e0
jmp 0xcf36
jmp 0xd017
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rdi
leaq 0x3a2e3(%rip), %rsi     # 0x47230
callq 0x53e0
movq %rax, -0x80(%rbp)
jmp 0xcf58
movq -0x80(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x54a0
movq %rax, -0x88(%rbp)
jmp 0xcf6e
movq -0x88(%rbp), %rdi
leaq 0x3a27e(%rip), %rsi     # 0x471fa
callq 0x53e0
jmp 0xcf83
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5700
movq %rdx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
jmp 0xcfae
movq -0x98(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x12bc0
movq %rax, -0xa8(%rbp)
jmp 0xcfd6
movq -0xa0(%rbp), %rsi
movq -0x68(%rbp), %rdi
movq -0xa8(%rbp), %rax
movl %eax, %edx
callq 0xc990
jmp 0xcff1
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x4efad(%rip), %rsi     # 0x5bfb0
callq 0x5440
jmp 0xd00a
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0xd029
jmp 0xd019
jmp 0xceb4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5290
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5720
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::findOpenOrClosedParen(std::istream&)
int SceneLoader::findOpenOrClosedParen(istream & str)
{
  char temp;
  string line;

  while (str >> temp)
  {
    if (temp == '(')
      return OPEN;
    else if (temp == '#')
      getline(str, line);
    else if (temp == ')')
    {
      str.putback(temp);
      return CLOSED;
    }
    else
    {
      *err << "error: unexpected char " << temp << " at ";
      curPos(*err, str.tellg());
      *err << endl;
      return false;
    }
  }

  return ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x55a0
movq -0x18(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x5530
movq %rax, -0x70(%rbp)
jmp 0xd087
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5500
movb %al, -0x71(%rbp)
jmp 0xd09f
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xd0ab
jmp 0xd20f
movsbl -0x19(%rbp), %eax
cmpl $0x28, %eax
jne 0xd0e1
movl $0x0, -0x4(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0xd21d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5290
jmp 0xd232
movsbl -0x19(%rbp), %eax
cmpl $0x23, %eax
jne 0xd0fe
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x50e0
jmp 0xd0f9
jmp 0xd208
movsbl -0x19(%rbp), %eax
cmpl $0x29, %eax
jne 0xd129
movq -0x18(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x5790
jmp 0xd116
movl $0x1, -0x4(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0xd21d
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rdi
leaq 0x3a0f5(%rip), %rsi     # 0x47230
callq 0x53e0
movq %rax, -0x80(%rbp)
jmp 0xd146
movq -0x80(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x54a0
movq %rax, -0x88(%rbp)
jmp 0xd15c
movq -0x88(%rbp), %rdi
leaq 0x3a090(%rip), %rsi     # 0x471fa
callq 0x53e0
jmp 0xd171
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5700
movq %rdx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
jmp 0xd19c
movq -0x98(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x12bc0
movq %rax, -0xa8(%rbp)
jmp 0xd1c4
movq -0xa0(%rbp), %rsi
movq -0x68(%rbp), %rdi
movq -0xa8(%rbp), %rax
movl %eax, %edx
callq 0xc990
jmp 0xd1df
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x4edbf(%rip), %rsi     # 0x5bfb0
callq 0x5440
jmp 0xd1f8
movl $0x0, -0x4(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0xd21d
jmp 0xd20a
jmp 0xd074
movl $0x2, -0x4(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5290
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5720
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::findCloseParen(std::istream&)
bool SceneLoader::findCloseParen(istream & str)
{
  char temp;
  string line;
  int close = 0;

  while (str >> temp)
  {
    if (temp == '#')
      getline(str, line);

    if (temp == '(')
      close++;

    if (temp == ')')
      close--;

    if (close < 0)
      return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x55a0
movl $0x0, -0x44(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x5530
movq %rax, -0x60(%rbp)
jmp 0xd273
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5500
movb %al, -0x61(%rbp)
jmp 0xd28b
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0xd294
jmp 0xd301
movsbl -0x19(%rbp), %eax
cmpl $0x23, %eax
jne 0xd2c5
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x50e0
jmp 0xd2ac
jmp 0xd2c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5290
jmp 0xd320
movsbl -0x19(%rbp), %eax
cmpl $0x28, %eax
jne 0xd2d7
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x29, %eax
jne 0xd2e9
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jge 0xd2fc
movb $0x1, -0x1(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0xd30c
jmp 0xd260
movb $0x0, -0x1(%rbp)
movl $0x1, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5290
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5720
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::getValues(std::istream&, std::vector<ParametricValue*, std::allocator<ParametricValue*>>&)
int SceneLoader::getValues(istream & str, vector<ParametricValue *> & vals)
{
  ParametricValue * val;

  while ( (val = getValue(str)) != NULL )
  {
    vals.push_back(val);
  }

  return int(vals.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd390
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xd372
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12cc0
jmp 0xd34c
movq -0x18(%rbp), %rdi
callq 0x12d30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::getName(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool SceneLoader::getName(istream & str, string type, string & name)
{
  name = getString(str);

  if (name.empty())
  {
    *err << "Couldn't read " << type << " name at ";
    errLine(str.tellg());
    return false;
  }

  if (groups[name] != NULL)
  {
    *err << "Illegal re-use of name \"" << name << "\" at ";
    errLine(str.tellg());
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x70(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0xcaa0
movq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x54d0
leaq -0x48(%rbp), %rdi
callq 0x5290
movq -0x28(%rbp), %rdi
callq 0x5690
testb $0x1, %al
jne 0xecb9
jmp 0xed16
movq -0x70(%rbp), %rax
movq 0x90(%rax), %rdi
leaq 0x3871b(%rip), %rsi     # 0x473e6
callq 0x53e0
movq -0x78(%rbp), %rsi
movq %rax, %rdi
callq 0x53c0
movq %rax, %rdi
leaq 0x389c3(%rip), %rsi     # 0x476a9
callq 0x53e0
movq -0x18(%rbp), %rdi
callq 0x5700
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x12bc0
movq -0x70(%rbp), %rdi
movl %eax, %esi
callq 0xd8e0
movb $0x0, -0x1(%rbp)
jmp 0xed8e
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rsi
callq 0x12fe0
cmpq $0x0, (%rax)
je 0xed8a
movq -0x70(%rbp), %rax
movq 0x90(%rax), %rdi
leaq 0x386b6(%rip), %rsi     # 0x473f5
callq 0x53e0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x53c0
movq %rax, %rdi
leaq 0x3849f(%rip), %rsi     # 0x471f9
callq 0x53e0
movq -0x18(%rbp), %rdi
callq 0x5700
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x12bc0
movq -0x70(%rbp), %rdi
movl %eax, %esi
callq 0xd8e0
movb $0x0, -0x1(%rbp)
jmp 0xed8e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::setMaterialDefaults(ParametricMaterial*)
void SceneLoader::setMaterialDefaults(ParametricMaterial * n)
{
  if (n->RGB_ == NULL)
  {
    n->RGB_ = new ParametricColor();
    n->RGB_->color_[0] = new ConstValue(0);
    n->RGB_->color_[1] = new ConstValue(0);
    n->RGB_->color_[2] = new ConstValue(0);
  }

  for (int i = 0; i < 7; i++)
  {
    if (n->coefficients_[i] == NULL)
      n->coefficients_[i] = new ConstValue(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xeee5
movl $0x18, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x132f0
jmp 0xedd9
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x10, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
callq 0x12f80
jmp 0xee02
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movl $0x10, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
callq 0x12f80
jmp 0xee2e
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movl $0x10, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
callq 0x12f80
jmp 0xee5b
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xeee5
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x5410
jmp 0xef62
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x5410
jmp 0xef62
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x5410
jmp 0xef62
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x5410
jmp 0xef62
movl $0x0, -0x20(%rbp)
cmpl $0x7, -0x20(%rbp)
jge 0xef5c
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, 0x8(%rax,%rcx,8)
jne 0xef4f
movl $0x10, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
callq 0x12f80
jmp 0xef20
movq -0x48(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
jmp 0xef4f
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x5410
jmp 0xef62
jmp 0xef51
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xeeec
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5720
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::setSphereDefaults(SceneGroup*)
void SceneLoader::setSphereDefaults(SceneGroup * n)
{
  if (n->sphere_->material_ == NULL)
  {
    n->sphere_->material_ = new ParametricMaterial();
    setMaterialDefaults(n->sphere_->material_);
  }

  if (n->sphere_->radius_ == NULL)
  {
    n->sphere_->radius_ = new ConstValue(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0xfc45
movl $0x40, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x13640
jmp 0xfc02
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xeda0
jmp 0xfc45
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x40, %esi
callq 0x5410
jmp 0xfca9
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, (%rax)
jne 0xfca3
movl $0x10, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movsd 0x374c9(%rip), %xmm0    # 0x47138
callq 0x12f80
jmp 0xfc76
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, (%rax)
jmp 0xfca3
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x5410
jmp 0xfca9
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5720
nopw %cs:(%rax,%rax)