LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: srajangarg[P]raytracer/src/core/SceneLoader.cpp
// Function: SceneLoader::doRender(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool SceneLoader::doRender(istream & str, string & name)
{
  name = getString(str);

  if (name.empty())
  {
    *err << "Trying to render group without specifying a name at ";
    curPos(*err, str.tellg());
    *err << endl;
    return false;
  }

  if (groups[name] == NULL)
  {
    *err << "Trying to render group not found \"" << name << "\" at ";
    curPos(*err, str.tellg());
    *err << endl;
    return false;
  }

  root->child_ = groups[name];
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x68(%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 0x12621
jmp 0x12690
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rdi
leaq 0x3504b(%rip), %rsi     # 0x4767e
callq 0x53e0
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5700
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12bc0
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdi
movl %eax, %edx
callq 0xc990
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x4992e(%rip), %rsi     # 0x5bfb0
callq 0x5440
movb $0x0, -0x1(%rbp)
jmp 0x1275c
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x12fe0
cmpq $0x0, (%rax)
jne 0x12732
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rdi
leaq 0x34ff6(%rip), %rsi     # 0x476b3
callq 0x53e0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x53c0
movq %rax, %rdi
leaq 0x34b21(%rip), %rsi     # 0x471f9
callq 0x53e0
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5700
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x12bc0
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdi
movl %eax, %edx
callq 0xc990
movq -0x68(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x49889(%rip), %rsi     # 0x5bfb0
callq 0x5440
movb $0x0, -0x1(%rbp)
jmp 0x1275c
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0x12fe0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq (%rcx), %rcx
movq 0x98(%rax), %rax
movq %rcx, 0x50(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/ParametricValue.hpp
// Function: ExprValue::ExprValue(char const*)
ExprValue(const char * expr) : timevar_("t" , &time_), dgrvar_("dgr", &dgr_), expr_(expr)
    {
      vararray_[0] = &timevar_;
      vararray_[1] = &dgrvar_;
      op_ = ROperation ( expr_.c_str(), 2, vararray_ );
      time_ = 0;
      dgr_ = M_PI / 180.0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x142d0
movq -0x88(%rbp), %rdx
leaq 0x48af7(%rip), %rax     # 0x5b878
movq %rax, (%rdx)
movq %rdx, %rdi
addq $0x18, %rdi
movq %rdi, -0x80(%rbp)
addq $0x8, %rdx
leaq 0x35810(%rip), %rsi     # 0x485aa
callq 0x1b3e0
jmp 0x12da1
movq -0x88(%rbp), %rdx
movq %rdx, %rdi
addq $0x28, %rdi
movq %rdi, -0x90(%rbp)
addq $0x10, %rdx
leaq 0x34a8a(%rip), %rsi     # 0x4784b
callq 0x1b3e0
jmp 0x12dc8
movq -0x88(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x98(%rbp)
callq 0x1c150
jmp 0x12de1
movq -0x88(%rbp), %rax
addq $0xa0, %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5730
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
callq 0x13590
jmp 0x12e2c
leaq -0x1d(%rbp), %rdi
callq 0x5460
movq -0x88(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rdi, %rcx
addq $0x38, %rcx
movq %rcx, -0xb8(%rbp)
movq %rax, 0x38(%rdi)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x40(%rdi)
addq $0xa0, %rdi
callq 0x51a0
movq -0xb8(%rbp), %rcx
movq %rax, %rsi
xorl %r8d, %r8d
movl %r8d, %r9d
leaq -0x78(%rbp), %rdi
movl $0x2, %edx
callq 0x1fcf0
jmp 0x12e8c
movq -0x88(%rbp), %rdi
addq $0x48, %rdi
leaq -0x78(%rbp), %rsi
callq 0x1b550
jmp 0x12ea2
leaq -0x78(%rbp), %rdi
callq 0x1ce40
movq -0x88(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x342c6(%rip), %xmm0    # 0x47188
movsd %xmm0, 0x10(%rax)
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x12f64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x12f5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x12f4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x5460
jmp 0x12f43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x12f37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1ce40
movq -0xb0(%rbp), %rdi
callq 0x5290
movq -0x98(%rbp), %rdi
callq 0x1ce40
movq -0x90(%rbp), %rdi
callq 0x1b420
movq -0x80(%rbp), %rdi
callq 0x1b420
movq -0x88(%rbp), %rdi
callq 0x14430
movq -0x18(%rbp), %rdi
callq 0x5720
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/SceneData.hpp
// Function: Rotate::getMatrix(int)
Mat4 getMatrix(int time)
    {
      Vec3 ax;

      if (axis[2] == NULL) // 2D
      {
        ax = Vec3(0, 0, 1);
      }
      else
      {
        ax = Vec3(axis[0]->getValue(time),
                  axis[1]->getValue(time),
                  axis[2]->getValue(time));
      }

      return rotation3D(ax, angle->getValue(time));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6fc0
movq -0x80(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x14619
leaq -0x48(%rbp), %rdi
xorps %xmm1, %xmm1
movsd 0x32b36(%rip), %xmm2    # 0x47138
movaps %xmm1, %xmm0
callq 0x147b0
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x72d0
jmp 0x1468b
movq -0x80(%rbp), %rax
movq 0x10(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x80(%rbp), %rax
movsd %xmm0, -0x98(%rbp)
movq 0x18(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x80(%rbp), %rax
movsd %xmm0, -0xa0(%rbp)
movq 0x20(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movsd -0xa0(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x98(%rbp), %xmm0
leaq -0x60(%rbp), %rdi
callq 0x147b0
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x72d0
leaq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x71a0
movq -0x80(%rbp), %rax
movq 0x8(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x147f0
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneData.hpp
// Function: Translate::getMatrix(int)
Mat4 getMatrix(int time)
    {
      Vec3 tr;
      tr[0] = translate[0]->getValue(time);
      tr[1] = translate[1]->getValue(time);

      if (translate[2] == NULL)
        tr[2] = 0;
      else
        tr[2] = translate[2]->getValue(time);

      return translation3D(tr);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6fc0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movsd %xmm0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x7260
movsd -0x48(%rbp), %xmm0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movsd %xmm0, (%rcx)
movq 0x10(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movsd %xmm0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x7260
movsd -0x40(%rbp), %xmm0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movsd %xmm0, (%rcx)
cmpq $0x0, 0x18(%rax)
jne 0x15572
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x7260
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x155a1
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movsd %xmm0, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x7260
movsd -0x60(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15660
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/Algebra3.hpp
// Function: translation3D(Vec3 const&)
inline Mat4 translation3D(Vec3 const & v)
{ return Mat4(Vec4(1.0, 0.0, 0.0, v[0]),
              Vec4(0.0, 1.0, 0.0, v[1]),
              Vec4(0.0, 0.0, 1.0, v[2]),
              Vec4(0.0, 0.0, 0.0, 1.0)); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x15750
movaps %xmm0, %xmm3
leaq -0x30(%rbp), %rdi
movsd 0x31a9a(%rip), %xmm0    # 0x47138
xorps %xmm2, %xmm2
movaps %xmm2, %xmm1
callq 0xb390
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x15750
movaps %xmm0, %xmm3
leaq -0x50(%rbp), %rdi
xorps %xmm2, %xmm2
movsd 0x31a6f(%rip), %xmm1    # 0x47138
movaps %xmm2, %xmm0
callq 0xb390
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x15750
movaps %xmm0, %xmm3
leaq -0x70(%rbp), %rdi
xorps %xmm1, %xmm1
movsd 0x31a47(%rip), %xmm2    # 0x47138
movaps %xmm1, %xmm0
callq 0xb390
leaq -0x90(%rbp), %rdi
xorps %xmm2, %xmm2
movsd 0x31a2d(%rip), %xmm3    # 0x47138
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xb390
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
leaq -0x90(%rbp), %r8
callq 0xb3e0
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: srajangarg[P]raytracer/src/core/SceneData.hpp
// Function: Scale::getMatrix(int)
Mat4 getMatrix(int time)
    {
      Vec3 sc;
      sc[0] = scale[0]->getValue(time);
      sc[1] = scale[1]->getValue(time);

      if (scale[2] == NULL)
        sc[2] = 1;
      else
        sc[2] = scale[2]->getValue(time);

      return scaling3D(sc);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6fc0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movsd %xmm0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x7260
movsd -0x48(%rbp), %xmm0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movsd %xmm0, (%rcx)
movq 0x10(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movsd %xmm0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x7260
movsd -0x40(%rbp), %xmm0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movsd %xmm0, (%rcx)
cmpq $0x0, 0x18(%rax)
jne 0x15877
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x7260
movsd 0x318c7(%rip), %xmm0    # 0x47138
movsd %xmm0, (%rax)
jmp 0x158a6
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movsd %xmm0, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x7260
movsd -0x60(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15960
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/Algebra3.hpp
// Function: scaling3D(Vec3 const&)
inline Mat4 scaling3D(Vec3 const & scaleVector)
{ return Mat4(Vec4(scaleVector[0], 0.0, 0.0, 0.0),
              Vec4(0.0, scaleVector[1], 0.0, 0.0),
              Vec4(0.0, 0.0, scaleVector[2], 0.0),
              Vec4(0.0, 0.0, 0.0, 1.0)); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x15750
leaq -0x30(%rbp), %rdi
xorps %xmm3, %xmm3
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0xb390
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x15750
movaps %xmm0, %xmm1
leaq -0x50(%rbp), %rdi
xorps %xmm3, %xmm3
movaps %xmm3, %xmm0
movaps %xmm3, %xmm2
callq 0xb390
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x15750
movaps %xmm0, %xmm2
leaq -0x70(%rbp), %rdi
xorps %xmm3, %xmm3
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
callq 0xb390
leaq -0x90(%rbp), %rdi
xorps %xmm2, %xmm2
movsd 0x3173f(%rip), %xmm3    # 0x47138
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xb390
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
leaq -0x90(%rbp), %r8
callq 0xb3e0
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: MidStr(char const*, int, int)
char* MidStr(const char*s,int i1,int i2)
{
 if(i1<0||i2>=(int)strlen(s)||i1>i2){
	 char* cp = new char[1];
	 cp[0] = '\0';
	 return cp;
 }
 char*s1=new char[i2-i1+2];
 int i;
 for(i=i1;i<=i2;i++)s1[i-i1]=s[i];
 s1[i2-i1+1]=0;return s1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x1af39
movl -0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51c0
movq %rax, %rcx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jge 0x1af39
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x1af58
movl $0x1, %edi
callq 0x5050
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1afbd
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x5050
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x1afa1
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1af73
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
subl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: InsStr(char*&, int, char)
void InsStr(char*&s,int n,char c)// Warning : deletes the old string
{if(n<0||n>(int)strlen(s))return;
char*s1=new char[strlen(s)+2];
int i;
for(i=0;i<n;i++)s1[i]=s[i];
s1[n]=c;for(i=n+1;s[i-1];i++)s1[i]=s[i-1];
s1[i]=0;
delete[]s;s=s1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x1b076
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x51c0
movq %rax, %rcx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jle 0x1b07b
jmp 0x1b151
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x51c0
movq %rax, %rdi
addq $0x2, %rdi
callq 0x5050
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1b0ca
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b09e
movb -0xd(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1b120
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b0e1
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1b146
movq -0x28(%rbp), %rdi
callq 0x5520
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: DelStr(char*&, int)
void DelStr(char*&s,int n)//Deletes the old string
{char*s1=new char[strlen(s)];
int i;
for(i=0;i<n;i++)s1[i]=s[i];
for(i=n;s[i+1];i++)s1[i]=s[i+1];
s1[i]=0;
delete[]s;s=s1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x51c0
movq %rax, %rdi
callq 0x5050
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1b30a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b2de
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1b34f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b310
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1b375
movq -0x28(%rbp), %rdi
callq 0x5520
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::operator=(ROperation const&)
ROperation& ROperation::operator=(const ROperation& ROp)
{
  if(this==&ROp)return *this;
  Destroy();
  op=ROp.op;pvar=ROp.pvar;pvarval=ROp.pvarval;ValC=ROp.ValC;pfunc=ROp.pfunc;containfuncflag=0;pinstr=NULL;pvals=NULL;ppile=NULL;pfuncpile=NULL;
  if(ROp.mmb1!=NULL)mmb1=new ROperation(*(ROp.mmb1));else mmb1=NULL;
  if(ROp.mmb2!=NULL)mmb2=new ROperation(*(ROp.mmb2));else mmb2=NULL;
  BuildCode();
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x1b57b
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b6c3
movq -0x30(%rbp), %rdi
callq 0x1ce70
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq 0x48(%rcx), %rcx
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rcx
movsd 0x38(%rcx), %xmm0
movsd %xmm0, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq 0x50(%rcx), %rcx
movq %rcx, 0x50(%rax)
movb $0x0, 0x20(%rax)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1b642
movl $0x58, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x1d0a0
jmp 0x1b615
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x1b64e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1b6cd
movq -0x30(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1b6a6
movl $0x58, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x1d0a0
jmp 0x1b67c
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x30(%rax)
jmp 0x1b6b2
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1b6cd
movq -0x30(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x30(%rbp), %rdi
callq 0x1c1d0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5720
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: RFunction::RFunction(RFunction const&)
RFunction::RFunction(const RFunction& rfunc)
{
  if(this==&rfunc)return;
  type=rfunc.type;op=rfunc.op;
  pfuncval=rfunc.pfuncval;
  name=CopyStr(rfunc.name);
  nvars=rfunc.nvars;
  if(rfunc.ppvar!=NULL&&nvars){
    ppvar=new PRVar[nvars];
    int i;for(i=0;i<nvars;i++)ppvar[i]=rfunc.ppvar[i];
    buf=new double[nvars];
  }else {ppvar=NULL;buf=NULL;}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
callq 0x1c150
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x1b814
jmp 0x1b964
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x8(%rax), %al
movb %al, 0x8(%rdi)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x1b550
jmp 0x1b835
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x1afd0
movq %rax, -0x38(%rbp)
jmp 0x1b85b
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rcx
movl 0x70(%rcx), %ecx
movl %ecx, 0x70(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x1b951
movq -0x28(%rbp), %rax
cmpl $0x0, 0x70(%rax)
je 0x1b951
movq -0x28(%rbp), %rax
movslq 0x70(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x5050
movq %rax, -0x40(%rbp)
jmp 0x1b8ba
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x78(%rax)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x70(%rcx), %eax
jge 0x1b91b
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x78(%rcx), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x78(%rax), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1b8cd
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1ce40
jmp 0x1b96a
movq -0x28(%rbp), %rax
movslq 0x70(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x5050
movq %rax, -0x48(%rbp)
jmp 0x1b944
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x1b964
movq -0x28(%rbp), %rax
movq $0x0, 0x78(%rax)
movq $0x0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5720
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: RFunction::RFunction(ROperation const&, int, RVar**)
RFunction::RFunction(const ROperation& opp, int nvarsp,RVar**ppvarp):op(opp)
{
  type=1;name=new char[1];name[0]=0;
  nvars=nvarsp;
  if(nvars){
    ppvar=new PRVar[nvars];
    int i;for(i=0;i<nvars;i++)ppvar[i]=ppvarp[i];
    buf=new double[nvars];
  }else {ppvar=NULL;buf=NULL;}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d0a0
movq -0x40(%rbp), %rax
movb $0x1, 0x8(%rax)
movl $0x1, %edi
callq 0x5050
movq %rax, -0x38(%rbp)
jmp 0x1ba98
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x80(%rax)
movq 0x80(%rax), %rcx
movb $0x0, (%rcx)
movl -0x14(%rbp), %ecx
movl %ecx, 0x70(%rax)
cmpl $0x0, 0x70(%rax)
je 0x1bb7d
movq -0x40(%rbp), %rax
movslq 0x70(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x5050
movq %rax, -0x50(%rbp)
jmp 0x1baea
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x78(%rax)
movl $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl 0x70(%rcx), %eax
jge 0x1bb47
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x78(%rax), %rax
movslq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1bafd
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1ce40
jmp 0x1bb96
movq -0x40(%rbp), %rax
movslq 0x70(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x5050
movq %rax, -0x58(%rbp)
jmp 0x1bb70
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x1bb90
movq -0x40(%rbp), %rax
movq $0x0, 0x78(%rax)
movq $0x0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5720
nop
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: RFunction::operator=(RFunction const&)
RFunction& RFunction::operator=(const RFunction& rfunc)
{
  if(this==&rfunc)return *this;
  type=rfunc.type;op=rfunc.op;
  pfuncval=rfunc.pfuncval;
  delete[]name;
  name=CopyStr(rfunc.name);
  if(ppvar!=NULL)delete[]ppvar;
  ppvar=NULL;
  if(buf!=NULL)delete[]buf;
  buf=NULL;
  nvars=rfunc.nvars;
  if(type==1&&nvars){
    ppvar=new PRVar[nvars];buf=new double[nvars];
    int i;for(i=0;i<nvars;i++)ppvar[i]=rfunc.ppvar[i];
  }
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x1bc6b
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1bdff
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movb 0x8(%rax), %al
movb %al, 0x8(%rdi)
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x1b550
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x80(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1bcb4
movq -0x30(%rbp), %rdi
callq 0x5520
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x1afd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x80(%rax)
cmpq $0x0, 0x78(%rax)
je 0x1bcf6
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1bcf4
movq -0x38(%rbp), %rdi
callq 0x5520
jmp 0x1bcf6
movq -0x28(%rbp), %rax
movq $0x0, 0x78(%rax)
cmpq $0x0, (%rax)
je 0x1bd24
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1bd22
movq -0x40(%rbp), %rdi
callq 0x5520
jmp 0x1bd24
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rcx
movl 0x70(%rcx), %ecx
movl %ecx, 0x70(%rax)
movsbl 0x8(%rax), %eax
cmpl $0x1, %eax
jne 0x1bdf7
movq -0x28(%rbp), %rax
cmpl $0x0, 0x70(%rax)
je 0x1bdf7
movq -0x28(%rbp), %rax
movslq 0x70(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5050
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x78(%rax)
movslq 0x70(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5050
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x70(%rcx), %eax
jge 0x1bdf5
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x78(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x78(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1bdbe
jmp 0x1bdf7
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: RFunction::Val(double) const
double RFunction::Val(double x) const
{
  if(type==-1||nvars>=2)return ErrVal;
  if(type==0)return (*pfuncval)(x);
  double xb=*(*ppvar)->pval,y;
  *(*ppvar)->pval=x;  // Warning : could cause trouble if this value is used in a parallel process
  y=op.Val();
  *(*ppvar)->pval=xb;
  return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movsbl 0x8(%rax), %eax
cmpl $-0x1, %eax
je 0x1be9c
movq -0x30(%rbp), %rax
cmpl $0x2, 0x70(%rax)
jl 0x1beab
movsd 0x2bab4(%rip), %xmm0    # 0x47958
movsd %xmm0, -0x8(%rbp)
jmp 0x1bf2a
movq -0x30(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x1bece
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movsd -0x18(%rbp), %xmm0
callq *%rax
movsd %xmm0, -0x8(%rbp)
jmp 0x1bf2a
movq -0x30(%rbp), %rdi
movq 0x78(%rdi), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movq 0x78(%rdi), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movsd %xmm0, (%rax)
addq $0x18, %rdi
callq 0x1bf40
movq -0x30(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movq 0x78(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::Val() const
double ROperation::Val() const
{
  pfoncld*p1=pinstr;double**p2=pvals,*p3=ppile-1;PRFunction*p4=pfuncpile;
  for(;*p1!=NULL;p1++)
    if(*p1==&NextVal)*(++p3)=**(p2++);else
      if(*p1==&RFunc) ApplyRFunc(*(p4++),p3);
      else (**p1)(p3);
  return *p3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rcx
addq $-0x8, %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1c009
movq -0x10(%rbp), %rax
leaq 0xa234(%rip), %rcx      # 0x261c0
cmpq %rcx, (%rax)
jne 0x1bfbd
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x20(%rbp)
movsd %xmm0, 0x8(%rax)
jmp 0x1bff6
movq -0x10(%rbp), %rax
leaq 0xa208(%rip), %rcx      # 0x261d0
cmpq %rcx, (%rax)
jne 0x1bfea
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x28(%rbp)
movq (%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x27440
jmp 0x1bff4
movq -0x10(%rbp), %rax
leaq -0x20(%rbp), %rdi
callq *(%rax)
jmp 0x1bff6
jmp 0x1bff8
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x1bf73
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: RFunction::Val(double*) const
double RFunction::Val(double*pv) const
{
  if(type==-1)return ErrVal;
  if(type==0)return (*pfuncval)(*pv);
  double y;
  int i;
  for(i=0;i<nvars;i++){
    buf[i]=*ppvar[i]->pval;
    // Warning : could cause trouble if this value is used in a parallel process
    *ppvar[i]->pval=pv[i];
  }
  y=op.Val();
  for(i=0;i<nvars;i++)*ppvar[i]->pval=buf[i];
  return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movsbl 0x8(%rax), %eax
cmpl $-0x1, %eax
jne 0x1c053
movsd 0x2b90f(%rip), %xmm0    # 0x47958
movsd %xmm0, -0x8(%rbp)
jmp 0x1c13d
movq -0x30(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x1c07c
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
callq *%rax
movsd %xmm0, -0x8(%rbp)
jmp 0x1c13d
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x70(%rcx), %eax
jge 0x1c0df
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x8(%rcx), %rcx
movsd (%rcx), %xmm0
movq (%rax), %rcx
movslq -0x24(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x78(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1c083
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x1bf40
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x70(%rcx), %eax
jge 0x1c133
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movslq -0x24(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x78(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1c0f8
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::Destroy()
void ROperation::Destroy()
{
  if(mmb1!=NULL&&mmb2!=NULL&&mmb1!=mmb2){delete mmb1;delete mmb2;mmb1=NULL;mmb2=NULL;}
  else if(mmb1!=NULL){delete mmb1;mmb1=NULL;}else if(mmb2!=NULL){delete mmb2;mmb2=NULL;}
  if(pinstr!=NULL){delete[]pinstr;pinstr=NULL;}
  if(pvals!=NULL){
		if(op==ErrOp||op==Num)delete pvals[0];
		delete[]pvals;pvals=NULL;
	}
  if(ppile!=NULL){delete[]ppile;ppile=NULL;}
  if(pfuncpile!=NULL){delete[]pfuncpile;pfuncpile=NULL;}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x1cf13
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1cf13
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rax
cmpq 0x30(%rcx), %rax
je 0x1cf13
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1ced1
movq -0x18(%rbp), %rdi
callq 0x1ce40
movq -0x18(%rbp), %rdi
movl $0x58, %esi
callq 0x5410
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1cefa
movq -0x20(%rbp), %rdi
callq 0x1ce40
movq -0x20(%rbp), %rdi
movl $0x58, %esi
callq 0x5410
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
jmp 0x1cf99
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1cf55
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1cf47
movq -0x28(%rbp), %rdi
callq 0x1ce40
movq -0x28(%rbp), %rdi
movl $0x58, %esi
callq 0x5410
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x1cf97
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1cf95
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1cf89
movq -0x30(%rbp), %rdi
callq 0x1ce40
movq -0x30(%rbp), %rdi
movl $0x58, %esi
callq 0x5410
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
jmp 0x1cf97
jmp 0x1cf99
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1cfc8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1cfbd
movq -0x38(%rbp), %rdi
callq 0x5520
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1d033
movq -0x10(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0x1cfe7
movq -0x10(%rbp), %rax
cmpl $0x2, 0x24(%rax)
jne 0x1d00c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1d00a
movq -0x40(%rbp), %rdi
movl $0x8, %esi
callq 0x5410
jmp 0x1d00c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x1d027
movq -0x48(%rbp), %rdi
callq 0x5520
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1d065
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x1d059
movq -0x50(%rbp), %rdi
callq 0x5520
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1d097
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x1d08b
movq -0x58(%rbp), %rdi
callq 0x5520
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::ROperation(ROperation const&)
ROperation::ROperation(const ROperation&ROp)
{
  op=ROp.op;pvar=ROp.pvar;pvarval=ROp.pvarval;ValC=ROp.ValC;pfunc=ROp.pfunc;containfuncflag=0;pinstr=NULL;pvals=NULL;ppile=NULL;pfuncpile=NULL;
  if(ROp.mmb1!=NULL)mmb1=new ROperation(*(ROp.mmb1));else mmb1=NULL;
  if(ROp.mmb2!=NULL)mmb2=new ROperation(*(ROp.mmb2));else mmb2=NULL;
  BuildCode();
}

// 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), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movsd 0x38(%rcx), %xmm0
movsd %xmm0, 0x38(%rax)
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
movq %rcx, 0x50(%rax)
movb $0x0, 0x20(%rax)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1d16f
movl $0x58, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x1d0a0
jmp 0x1d145
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x1d17b
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1d1ee
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1d1d3
movl $0x58, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x1d0a0
jmp 0x1d1a9
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x30(%rax)
jmp 0x1d1df
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1d1ee
movq -0x28(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x28(%rbp), %rdi
callq 0x1c1d0
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::ROperation(double)
ROperation::ROperation(double x)
{
  if(x==ErrVal){op=ErrOp;mmb1=NULL;mmb2=NULL;ValC=ErrVal;}
  else if(x>=0){op=Num;mmb1=NULL;mmb2=NULL;ValC=x;}
  else{op=Opp;mmb1=NULL;mmb2=new ROperation(-x);ValC=ErrVal;}
  pvar=NULL;pvarval=NULL;pfunc=NULL;containfuncflag=0;pinstr=NULL;pvals=NULL;ppile=NULL;pfuncpile=NULL;
  BuildCode();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x2a732(%rip), %xmm1    # 0x47958
ucomisd %xmm1, %xmm0
jne 0x1d25b
jp 0x1d25b
movq -0x28(%rbp), %rax
movl $0x0, 0x24(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movsd 0x2a707(%rip), %xmm0    # 0x47958
movsd %xmm0, 0x38(%rax)
jmp 0x1d307
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1d290
movq -0x28(%rbp), %rax
movl $0x2, 0x24(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x38(%rax)
jmp 0x1d305
movq -0x28(%rbp), %rax
movl $0x6, 0x24(%rax)
movq $0x0, 0x28(%rax)
movl $0x58, %edi
callq 0x5400
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movaps 0x2a842(%rip), %xmm1    # 0x47b00
movsd -0x10(%rbp), %xmm0
pxor %xmm1, %xmm0
callq 0x1d200
jmp 0x1d2ce
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax)
movsd 0x2a676(%rip), %xmm0    # 0x47958
movsd %xmm0, 0x38(%rax)
jmp 0x1d305
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1d351
jmp 0x1d307
movq -0x28(%rbp), %rdi
movq $0x0, 0x40(%rdi)
movq $0x0, 0x48(%rdi)
movq $0x0, 0x50(%rdi)
movb $0x0, 0x20(%rdi)
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
callq 0x1c1d0
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: operator==(ROperation const&, ROperation const&)
int operator==(const ROperation& op1,const ROperation& op2)
{if(op1.op!=op2.op)return 0;
if(op1.op==Var)return(*(op1.pvar)==*(op2.pvar));
if(op1.op==Fun)return(op1.pfunc==op2.pfunc); // *op1.pfunc==*op2.pfunc could imply infinite loops in cases of self-dependence
if(op1.op==Num)return(op1.ValC==op2.ValC);
if(op1.mmb1==NULL&&op2.mmb1!=NULL)return 0;
if(op1.mmb2==NULL&&op2.mmb2!=NULL)return 0;
if(op2.mmb1==NULL&&op1.mmb1!=NULL)return 0;
if(op2.mmb2==NULL&&op1.mmb2!=NULL)return 0;
return(((op1.mmb1==NULL&&op2.mmb1==NULL)||(*(op1.mmb1)==*(op2.mmb1)))&&
	((op1.mmb2==NULL&&op2.mmb2==NULL)||(*(op1.mmb2)==*(op2.mmb2))));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x24(%rcx), %eax
je 0x1d45c
movl $0x0, -0x4(%rbp)
jmp 0x1d5e7
movq -0x10(%rbp), %rax
cmpl $0x3, 0x24(%rax)
jne 0x1d483
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x1d5f0
movl %eax, -0x4(%rbp)
jmp 0x1d5e7
movq -0x10(%rbp), %rax
cmpl $0x16, 0x24(%rax)
jne 0x1d4ad
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x50(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1d5e7
movq -0x10(%rbp), %rax
cmpl $0x2, 0x24(%rax)
jne 0x1d4de
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x38(%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1d5e7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1d500
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1d500
movl $0x0, -0x4(%rbp)
jmp 0x1d5e7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x1d522
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1d522
movl $0x0, -0x4(%rbp)
jmp 0x1d5e7
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1d544
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1d544
movl $0x0, -0x4(%rbp)
jmp 0x1d5e7
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x1d566
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1d566
movl $0x0, -0x4(%rbp)
jmp 0x1d5e7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1d57c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1d59d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x1d430
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x1d5dc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x1d5b8
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x30(%rcx)
movb %al, -0x1a(%rbp)
je 0x1d5d6
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x1d430
cmpl $0x0, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: operator!=(ROperation const&, ROperation const&)
int operator!=(const ROperation& op1,const ROperation& op2)
{
  if(op1.op!=op2.op)return 1;
  if(op1.op==Var)return(op1.pvar!=op2.pvar);
  if(op1.op==Fun)return(!(op1.pfunc==op2.pfunc)); // *op1.pfunc==*op2.pfunc could imply infinite loops in cases of self-dependence
  if(op1.op==Num)return(op1.ValC!=op2.ValC);
  if(op1.mmb1==NULL&&op2.mmb1!=NULL)return 1;
  if(op1.mmb2==NULL&&op2.mmb2!=NULL)return 1;
  if(op2.mmb1==NULL&&op1.mmb1!=NULL)return 1;
  if(op2.mmb2==NULL&&op1.mmb2!=NULL)return 1;
  return(((op1.mmb1!=NULL||op2.mmb1!=NULL)&&(*(op1.mmb1)!=*(op2.mmb1)))||
	 ((op1.mmb2!=NULL||op2.mmb2!=NULL)&&(*(op1.mmb2)!=*(op2.mmb2))));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x24(%rcx), %eax
je 0x1d66c
movl $0x1, -0x4(%rbp)
jmp 0x1d7fc
movq -0x10(%rbp), %rax
cmpl $0x3, 0x24(%rax)
jne 0x1d696
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x40(%rcx), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1d7fc
movq -0x10(%rbp), %rax
cmpl $0x16, 0x24(%rax)
jne 0x1d6c2
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x50(%rcx), %rax
sete %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1d7fc
movq -0x10(%rbp), %rax
cmpl $0x2, 0x24(%rax)
jne 0x1d6f3
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x38(%rax), %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1d7fc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1d715
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1d715
movl $0x1, -0x4(%rbp)
jmp 0x1d7fc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x1d737
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1d737
movl $0x1, -0x4(%rbp)
jmp 0x1d7fc
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1d759
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1d759
movl $0x1, -0x4(%rbp)
jmp 0x1d7fc
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x1d77b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1d77b
movl $0x1, -0x4(%rbp)
jmp 0x1d7fc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1d791
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1d7b2
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x1d640
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x1d7f1
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x1d7cd
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x30(%rcx)
movb %al, -0x1a(%rbp)
je 0x1d7eb
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x1d640
cmpl $0x0, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::operator-() const
ROperation ROperation::operator-() const
{if(op==Num)return -ValC;
ROperation resultat;
if(op==Opp)resultat=*mmb2;else{resultat.op=Opp;resultat.mmb2=new ROperation(*this);};
return resultat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x2, 0x24(%rax)
jne 0x1d897
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x1d200
jmp 0x1d945
movq -0x40(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x1c150
movq -0x30(%rbp), %rax
cmpl $0x6, 0x24(%rax)
jne 0x1d8d1
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x1b550
jmp 0x1d8c1
jmp 0x1d925
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1d93a
movq -0x40(%rbp), %rax
movl $0x6, 0x24(%rax)
movl $0x58, %edi
callq 0x5400
movq %rax, -0x48(%rbp)
jmp 0x1d8ec
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x1d0a0
jmp 0x1d8fb
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x30(%rax)
jmp 0x1d925
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1d93a
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1d938
movq -0x40(%rbp), %rdi
callq 0x1ce40
jmp 0x1d945
movq -0x40(%rbp), %rdi
callq 0x1ce40
jmp 0x1d94f
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5720
nopl (%rax,%rax)