LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: operator,(ROperation const&, ROperation const&)
ROperation operator,(const ROperation& op1,const ROperation& op2)
{ROperation resultat;
resultat.op=Juxt;resultat.mmb1=new ROperation(op1);
resultat.mmb2=new ROperation(op2);
return resultat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x1c150
movq -0x40(%rbp), %rdi
movl $0x1, 0x24(%rdi)
movl $0x58, %edi
callq 0x5400
movq %rax, -0x38(%rbp)
jmp 0x1d9a3
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d0a0
jmp 0x1d9b2
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl $0x58, %edi
callq 0x5400
movq %rax, -0x50(%rbp)
jmp 0x1d9ce
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d0a0
jmp 0x1d9dd
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x30(%rax)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1da44
jmp 0x1da3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1da4e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1da4e
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1da4e
movq -0x40(%rbp), %rdi
callq 0x1ce40
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1ce40
movq -0x28(%rbp), %rdi
callq 0x5720
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: operator+(ROperation const&, ROperation const&)
ROperation operator+(const ROperation& op1,const ROperation& op2)
{
if(op1.op==Num&&op2.op==Num)return op1.ValC+op2.ValC;
if(op1==0.)return op2;if(op2==0.)return op1;
if(op1.op==Opp)return op2-*(op1.mmb2);if(op2.op==Opp)return op1-*(op2.mmb2);
ROperation resultat;
resultat.op=Add;resultat.mmb1=new ROperation(op1);
resultat.mmb2=new ROperation(op2);
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 %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x24(%rax)
jne 0x1dab3
movq -0x18(%rbp), %rax
cmpl $0x2, 0x24(%rax)
jne 0x1dab3
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x18(%rbp), %rax
addsd 0x38(%rax), %xmm0
callq 0x1d200
jmp 0x1dc17
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1d3f0
cmpl $0x0, %eax
je 0x1dad6
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d0a0
jmp 0x1dc17
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1d3f0
cmpl $0x0, %eax
je 0x1daf9
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d0a0
jmp 0x1dc17
movq -0x10(%rbp), %rax
cmpl $0x6, 0x24(%rax)
jne 0x1db1d
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x1dc30
jmp 0x1dc17
movq -0x18(%rbp), %rax
cmpl $0x6, 0x24(%rax)
jne 0x1db41
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x1dc30
jmp 0x1dc17
movq -0x40(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x1c150
movq -0x40(%rbp), %rax
movl $0x4, 0x24(%rax)
movl $0x58, %edi
callq 0x5400
movq %rax, -0x48(%rbp)
jmp 0x1db69
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d0a0
jmp 0x1db78
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl $0x58, %edi
callq 0x5400
movq %rax, -0x50(%rbp)
jmp 0x1db94
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d0a0
jmp 0x1dba3
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x30(%rax)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1dc0a
jmp 0x1dc01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1dc0c
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1dc0c
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1dc0c
movq -0x40(%rbp), %rdi
callq 0x1ce40
jmp 0x1dc17
movq -0x40(%rbp), %rdi
callq 0x1ce40
jmp 0x1dc21
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: operator-(ROperation const&, ROperation const&)
ROperation operator-(const ROperation& op1,const ROperation& op2)
{
if(op1.op==Num&&op2.op==Num)return op1.ValC-op2.ValC;
if(op1==0.)return -op2;if(op2==0.)return op1;
if(op1.op==Opp)return -(op2+*(op1.mmb2));if(op2.op==Opp)return op1+*(op2.mmb2);
ROperation resultat;
resultat.op=Sub;resultat.mmb1=new ROperation(op1);
resultat.mmb2=new ROperation(op2);
return resultat;
}

// 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
cmpl $0x2, 0x24(%rax)
jne 0x1dc8f
movq -0x18(%rbp), %rax
cmpl $0x2, 0x24(%rax)
jne 0x1dc8f
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x38(%rax), %xmm0
callq 0x1d200
jmp 0x1de65
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1d3f0
cmpl $0x0, %eax
je 0x1dcb5
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d840
jmp 0x1de65
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1d3f0
cmpl $0x0, %eax
je 0x1dcdb
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d0a0
jmp 0x1de65
movq -0x10(%rbp), %rax
cmpl $0x6, 0x24(%rax)
jne 0x1dd3e
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1da60
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x1d840
jmp 0x1dd16
leaq -0x70(%rbp), %rdi
callq 0x1ce40
jmp 0x1de65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1ce40
jmp 0x1de75
movq -0x18(%rbp), %rax
cmpl $0x6, 0x24(%rax)
jne 0x1dd65
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x1da60
jmp 0x1de65
movq -0x90(%rbp), %rdi
movb $0x0, -0x7d(%rbp)
callq 0x1c150
movq -0x90(%rbp), %rax
movl $0x5, 0x24(%rax)
movl $0x58, %edi
callq 0x5400
movq %rax, -0xa0(%rbp)
jmp 0x1dd96
movq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d0a0
jmp 0x1dda8
movq -0x90(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl $0x58, %edi
callq 0x5400
movq %rax, -0xa8(%rbp)
jmp 0x1ddcd
movq -0xa8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d0a0
jmp 0x1dddf
movq -0x90(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, 0x30(%rax)
movb $0x1, -0x7d(%rbp)
testb $0x1, -0x7d(%rbp)
jne 0x1de55
jmp 0x1de49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x1de57
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1de57
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1de57
movq -0x90(%rbp), %rdi
callq 0x1ce40
jmp 0x1de65
movq -0x90(%rbp), %rdi
callq 0x1ce40
jmp 0x1de75
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x5720
nop
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: operator^(ROperation const&, ROperation const&)
ROperation operator^(const ROperation& op1,const ROperation& op2)
{if(op1==0.)return 0.;
if(op2==0.)return 1.;
if(op2==1.)return op1;
ROperation resultat;
resultat.op=Pow;resultat.mmb1=new ROperation(op1);
resultat.mmb2=new ROperation(op2);
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 %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1d3f0
cmpl $0x0, %eax
je 0x1e4b1
movq -0x40(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1d200
jmp 0x1e5d6
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x1d3f0
cmpl $0x0, %eax
je 0x1e4d8
movq -0x40(%rbp), %rdi
movsd 0x28c6a(%rip), %xmm0    # 0x47138
callq 0x1d200
jmp 0x1e5d6
movq -0x18(%rbp), %rdi
movsd 0x28c54(%rip), %xmm0    # 0x47138
callq 0x1d3f0
cmpl $0x0, %eax
je 0x1e500
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d0a0
jmp 0x1e5d6
movq -0x40(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x1c150
movq -0x40(%rbp), %rax
movl $0x9, 0x24(%rax)
movl $0x58, %edi
callq 0x5400
movq %rax, -0x48(%rbp)
jmp 0x1e528
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d0a0
jmp 0x1e537
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl $0x58, %edi
callq 0x5400
movq %rax, -0x50(%rbp)
jmp 0x1e553
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d0a0
jmp 0x1e562
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x30(%rax)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1e5c9
jmp 0x1e5c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1e5cb
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1e5cb
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1e5cb
movq -0x40(%rbp), %rdi
callq 0x1ce40
jmp 0x1e5d6
movq -0x40(%rbp), %rdi
callq 0x1ce40
jmp 0x1e5e0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5720
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ApplyOperator(int, ROperation**, ROperation (*)(ROperation const&, ROperation const&))
ROperation ApplyOperator(int n,ROperation**pops,ROperation (*func)(const ROperation&,const ROperation&))
{
  if(n<=0)return ErrVal;
  if(n==1)return *pops[0];
  if(n==2)return (*func)(*pops[0],*pops[1]);
  return (*func)(*pops[0],ApplyOperator(n-1,pops+1,func));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x1edba
movq -0x98(%rbp), %rdi
movsd 0x28ba8(%rip), %xmm0    # 0x47958
callq 0x1d200
jmp 0x1ee73
cmpl $0x1, -0xc(%rbp)
jne 0x1edd8
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x1d0a0
jmp 0x1ee73
cmpl $0x2, -0xc(%rbp)
jne 0x1edfc
movq -0x98(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rsi
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdx
callq *%rax
jmp 0x1ee73
movq -0x20(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movq -0x18(%rbp), %rdx
movq (%rdx), %rax
movq %rax, -0xb0(%rbp)
movl -0xc(%rbp), %esi
decl %esi
addq $0x8, %rdx
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1ed70
movq -0x98(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rax
callq *%rax
jmp 0x1ee4e
leaq -0x78(%rbp), %rdi
callq 0x1ce40
jmp 0x1ee73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1ce40
jmp 0x1ee83
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x5720
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: RFunction::operator()(ROperation const&)
ROperation RFunction::operator()(const ROperation& op)
{
  /* Code to use to replace explcitly instead of using a pointer to
     if(nvars!=op.NMembers()||type==-1||type==0)return ErrVal;
     ROperation op2=*pop;int i;
     RVar**ppvar2=new PRVar[nvars];char s[11]="";
     for(i=0;i<nvars;i++){
     sprintf(s,";var%i;",i);
     ppvar2[i]=new RVar(s,NULL);
     op2=op2.Substitute(*ppvar[i],(ROperation)*ppvar2[i]);
     }
     for(i=0;i<nvars;i++){
     op2=op2.Substitute(*ppvar2[i],op.NthMember(i+1));
     delete ppvar2[i];
     }
     delete[]ppvar2;
     return op2;
  */
  ROperation op2;op2.op=Fun;op2.pfunc=this;op2.mmb2=new ROperation(op);
  return op2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%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 0x1c150
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movl $0x16, 0x24(%rdi)
movq %rax, 0x50(%rdi)
movl $0x58, %edi
callq 0x5400
movq %rax, -0x38(%rbp)
jmp 0x1eee3
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d0a0
jmp 0x1eef2
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x30(%rax)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1ef3d
jmp 0x1ef34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1ef47
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x1ef47
movq -0x40(%rbp), %rdi
callq 0x1ce40
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1ce40
movq -0x28(%rbp), %rdi
callq 0x5720
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: SearchCorOpenbracket(char*, int)
int SearchCorOpenbracket(char*s,int n)  //Searchs the corresponding bracket of an opening bracket
{if(n>=(int)strlen(s)-1)return -1;
int i,c=1;
for(i=n+1;s[i];i++){
	if(s[i]=='(')c++;else if(s[i]==')')c--;
	if(!c)return i;
  };
return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51c0
movq %rax, %rcx
movl -0x20(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x1f114
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f18c
movl $0x1, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1f185
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
jne 0x1f14e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f16a
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x29, %eax
jne 0x1f168
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f16a
cmpl $0x0, -0x1c(%rbp)
jne 0x1f178
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f18c
jmp 0x1f17a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f124
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: SearchCorClosebracket(char*, int)
int SearchCorClosebracket(char*s,int n)  //Searchs the corresponding bracket of a closing bracket
{if(n<1)return -1;
int i,c=1;
for(i=n-1;i>=0;i--){
	if(s[i]==')')c++;else if(s[i]=='(')c--;
	if(!c)return i;
  };
return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x1f1ba
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f22a
movl $0x1, -0x1c(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x1f223
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x29, %eax
jne 0x1f1ec
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f208
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
jne 0x1f206
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f208
cmpl $0x0, -0x1c(%rbp)
jne 0x1f216
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f22a
jmp 0x1f218
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f1ca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: SearchOperator(char*, ROperator)
int SearchOperator(char*s,ROperator op)
{
  char opc;
  switch(op){
  case ErrOp:case Num:case Var:return -1;
  case Juxt:opc=',';break;
  case Add:opc='+';break;
  case Sub:opc='-';break;
  case Mult:opc='*';break;
  case Div:opc='/';break;
  case Pow:opc='^';break;
  case NthRoot:opc='#';break;
  case E10:opc='E';break;
  default:return -1;
  };
  int i;
  for(i=(int)strlen(s)-1;i>=0;i--){
    if(s[i]==opc&&(op!=Sub||(i&&s[i-1]==')')))return i;
    if(s[i]==')'){i=SearchCorClosebracket(s,i);if(i==-1)return -1;};
  };
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x15, %rax
ja 0x1f29c
movq -0x28(%rbp), %rax
leaq 0x2879d(%rip), %rcx     # 0x479f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f343
movb $0x2c, -0x15(%rbp)
jmp 0x1f2a8
movb $0x2b, -0x15(%rbp)
jmp 0x1f2a8
movb $0x2d, -0x15(%rbp)
jmp 0x1f2a8
movb $0x2a, -0x15(%rbp)
jmp 0x1f2a8
movb $0x2f, -0x15(%rbp)
jmp 0x1f2a8
movb $0x5e, -0x15(%rbp)
jmp 0x1f2a8
movb $0x23, -0x15(%rbp)
jmp 0x1f2a8
movb $0x45, -0x15(%rbp)
jmp 0x1f2a8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f343
movq -0x10(%rbp), %rdi
callq 0x51c0
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1f33c
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x15(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1f2fb
cmpl $0x5, -0x14(%rbp)
jne 0x1f2f3
cmpl $0x0, -0x1c(%rbp)
je 0x1f2fb
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x29, %eax
jne 0x1f2fb
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f343
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x29, %eax
jne 0x1f32c
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1f1a0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x1f32a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f343
jmp 0x1f32c
jmp 0x1f32e
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f2b7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: IsVar(char const*, int, int, RVar**)
int IsVar(const char*s,int n,int nvar,PRVar*ppvar)
{
  if(n<0||n>(int)strlen(s))return 0;
  int i;int l=0;
  for(i=0;i<nvar;i++)if(CompStr(s,n,(*(ppvar+i))->name))l=max(l,strlen((*(ppvar+i))->name));
  return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x1f5c5
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51c0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jle 0x1f5ce
movl $0x0, -0x4(%rbp)
jmp 0x1f63d
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1f637
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdx
callq 0x1b1f0
cmpb $0x0, %al
je 0x1f62a
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x51c0
movl -0x30(%rbp), %edi
movl %eax, %esi
callq 0x1f560
movl %eax, -0x28(%rbp)
jmp 0x1f62c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1f5dc
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: IsFunction(char const*, int)
int IsFunction(const char*s,int n)
{
  if(CompStr(s,n,"sin")||CompStr(s,n,"cos")||CompStr(s,n,"exp")
     ||CompStr(s,n,"tan")||CompStr(s,n,"log")||CompStr(s,n,"atg")
     ||CompStr(s,n,"abs"))return 3;
  if(CompStr(s,n,"tg")||CompStr(s,n,"ln"))return 2;
  if(CompStr(s,n,"sqrt")||CompStr(s,n,"asin")||CompStr(s,n,"atan")||
     CompStr(s,n,"acos"))return 4;
  if(CompStr(s,n,"arcsin")||CompStr(s,n,"arccos")||CompStr(s,n,"arctan"))return 6;
  if(CompStr(s,n,"arctg"))return 5;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x284cc(%rip), %rdx     # 0x47b39
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f704
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x284bb(%rip), %rdx     # 0x47b43
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f704
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x28481(%rip), %rdx     # 0x47b20
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f704
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x28488(%rip), %rdx     # 0x47b3e
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f704
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x28457(%rip), %rdx     # 0x47b24
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f704
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x28444(%rip), %rdx     # 0x47b28
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f704
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x28431(%rip), %rdx     # 0x47b2c
callq 0x1b1f0
cmpb $0x0, %al
je 0x1f710
movl $0x3, -0x4(%rbp)
jmp 0x1f824
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x2840b(%rip), %rdx     # 0x47b29
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f73e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x283fb(%rip), %rdx     # 0x47b30
callq 0x1b1f0
cmpb $0x0, %al
je 0x1f74a
movl $0x2, -0x4(%rbp)
jmp 0x1f824
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x283db(%rip), %rdx     # 0x47b33
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f7a6
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x283c9(%rip), %rdx     # 0x47b38
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f7a6
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x283b7(%rip), %rdx     # 0x47b3d
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f7a6
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x283a5(%rip), %rdx     # 0x47b42
callq 0x1b1f0
cmpb $0x0, %al
je 0x1f7af
movl $0x4, -0x4(%rbp)
jmp 0x1f824
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x2838a(%rip), %rdx     # 0x47b47
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f7f4
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x2837a(%rip), %rdx     # 0x47b4e
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1f7f4
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x2836a(%rip), %rdx     # 0x47b55
callq 0x1b1f0
cmpb $0x0, %al
je 0x1f7fd
movl $0x6, -0x4(%rbp)
jmp 0x1f824
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x28351(%rip), %rdx     # 0x47b5c
callq 0x1b1f0
cmpb $0x0, %al
je 0x1f81d
movl $0x5, -0x4(%rbp)
jmp 0x1f824
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: IsFunction(char const*, int, int, RFunction**)
int IsFunction(const char*s,int n,int nfunc,PRFunction*ppfunc)
	//Not recognized if a user-defined function is eg "sine" ie begins like
	//a standard function
	//IF PATCHED TO DO OTHERWISE, SHOULD BE PATCHED TOGETHER WITH THE
	//PARSER BELOW which treats standard functions before user-defined ones
{
  int l=IsFunction(s,n);
  if(l)return l;
  int i;l=0;
  for(i=0;i<nfunc;i++)if(CompStr(s,n,ppfunc[i]->name))l=max(l,strlen(ppfunc[i]->name));
  return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1f650
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x1f863
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f8da
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1f8d4
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x80(%rax), %rdx
callq 0x1b1f0
cmpb $0x0, %al
je 0x1f8c7
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x80(%rax), %rdi
callq 0x51c0
movl -0x2c(%rbp), %edi
movl %eax, %esi
callq 0x1f560
movl %eax, -0x24(%rbp)
jmp 0x1f8c9
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1f871
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: IsolateVars(char*&, int, RVar**, int, RFunction**)
void IsolateVars(char*&s,int nvar,PRVar*ppvar,int nfunc,PRFunction*ppfunc)//Deletes the old string
{
  int i,j;
  i=0;
  for(i=0;s[i];i++){
    if(s[i]=='('){i=SearchCorOpenbracket(s,i);if(i==-1)return;continue;};
    if(((j=IsVar(s,i,nvar,ppvar))>IsFunction(s,i,nfunc,ppfunc))||((CompStr(s,i,"pi")||CompStr(s,i,"PI")||CompStr(s,i,"Pi"))&&(j=2))){
      InsStr(s,i,'(');InsStr(s,i+j+1,')');i+=j+1;continue;};
    if(IsFunction(s,i,nfunc,ppfunc)){i+=IsFunction(s,i,nfunc,ppfunc)-1;if(!s[i])return;continue;};
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1fb30
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
jne 0x1fa03
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0x1f0e0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x1f9fe
jmp 0x1fb30
jmp 0x1fb22
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x1f590
movl %eax, -0x34(%rbp)
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x1f830
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jg 0x1fa9b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
leaq 0x28113(%rip), %rdx     # 0x47b62
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1fa8c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
leaq 0x280fc(%rip), %rdx     # 0x47b65
callq 0x1b1f0
cmpb $0x0, %al
jne 0x1fa8c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
leaq 0x280e5(%rip), %rdx     # 0x47b68
callq 0x1b1f0
cmpb $0x0, %al
je 0x1fad1
movl $0x2, -0x30(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x1fa9b
jmp 0x1fad1
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl $0x28, %edx
callq 0x1b040
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
addl -0x30(%rbp), %esi
addl $0x1, %esi
movl $0x29, %edx
callq 0x1b040
movl -0x30(%rbp), %eax
addl $0x1, %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1fb22
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x1f830
cmpl $0x0, %eax
je 0x1fb20
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x1f830
subl $0x1, %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x1fb1e
jmp 0x1fb30
jmp 0x1fb22
jmp 0x1fb22
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1f9b8
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: IsolateNumbers(char*&, int, RVar**, int, RFunction**)
void IsolateNumbers(char*&s,int nvar,RVar**ppvar,int nfunc,RFunction**ppfunc)//Deletes the old string
{
  int i=0,i2=0,ind=0,t1=0,t2=0;
  for(i=0;s[i];i++){
    if(ind&&!IsNumeric(s[i])){ind=0;InsStr(s,i2,'(');i++;InsStr(s,i,')');continue;};
		t1=IsVar(s,i,nvar,ppvar);t2=IsFunction(s,i,nfunc,ppfunc);
    if(t1||t2){i+=max(t1,t2)-1;continue;};
    if(s[i]=='('){i=SearchCorOpenbracket(s,i);if(i==-1)return;continue;};
    if(!ind&&IsNumeric(s[i])){i2=i;ind=1;};
  };
if(ind)InsStr(s,i2,'(');i++;InsStr(s,i,')');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1fcad
cmpl $0x0, -0x34(%rbp)
je 0x1fbee
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1eff0
cmpb $0x0, %al
jne 0x1fbee
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %esi
movl $0x28, %edx
callq 0x1b040
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl $0x29, %edx
callq 0x1b040
jmp 0x1fc9f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x1f590
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x1f830
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x38(%rbp)
jne 0x1fc2c
cmpl $0x0, -0x3c(%rbp)
je 0x1fc42
movl -0x38(%rbp), %edi
movl -0x3c(%rbp), %esi
callq 0x1f560
subl $0x1, %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1fc9f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
jne 0x1fc72
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0x1f0e0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x1fc70
jmp 0x1fcde
jmp 0x1fc9f
cmpl $0x0, -0x34(%rbp)
jne 0x1fc9d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1eff0
cmpb $0x0, %al
je 0x1fc9d
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x1fc9f
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1fb84
cmpl $0x0, -0x34(%rbp)
je 0x1fcc4
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %esi
movl $0x28, %edx
callq 0x1b040
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl $0x29, %edx
callq 0x1b040
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: operator==(RFunction const&, RFunction const&)
int operator==(const RFunction& f1,const RFunction& f2)
{
  if(f1.type!=f2.type)return 0;
  if(f1.type==-1)return 1; // Nonfunction==nonfunction
  if(f1.type==0)return (f1.pfuncval==f2.pfuncval&&EqStr(f1.name,f2.name));
  if(f1.op!=f2.op)return 0;
  if(!EqStr(f1.name,f2.name))return 0;
  if(f1.nvars!=f2.nvars)return 0;
  int i;
  for(i=0;i<f1.nvars;i++)if(!(*f1.ppvar[i]==*f2.ppvar[i]))return 0;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
movsbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
je 0x218c0
movl $0x0, -0x4(%rbp)
jmp 0x219f1
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $-0x1, %eax
jne 0x218d9
movl $0x1, -0x4(%rbp)
jmp 0x219f1
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x21930
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x1d(%rbp)
jne 0x21920
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rsi
callq 0x1b160
cmpb $0x0, %al
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x219f1
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0x1d640
cmpl $0x0, %eax
je 0x21956
movl $0x0, -0x4(%rbp)
jmp 0x219f1
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rsi
callq 0x1b160
cmpb $0x0, %al
jne 0x2197e
movl $0x0, -0x4(%rbp)
jmp 0x219f1
movq -0x10(%rbp), %rax
movl 0x70(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x70(%rcx), %eax
je 0x21997
movl $0x0, -0x4(%rbp)
jmp 0x219f1
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x70(%rcx), %eax
jge 0x219ea
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1d5f0
cmpl $0x0, %eax
jne 0x219dd
movl $0x0, -0x4(%rbp)
jmp 0x219f1
jmp 0x219df
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2199e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::ContainVar(RVar const&) const
signed char ROperation::ContainVar(const RVar& varp) const
{if(op==Var){if(EqStr(pvar->name,varp.name)&&pvar->pval==varp.pval)
	return 1;else return 0;};
if(mmb1!=NULL&&mmb1->ContainVar(varp))return 1;
if(mmb2!=NULL&&mmb2->ContainVar(varp))return 1;
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x3, 0x24(%rax)
jne 0x21a5b
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x1b160
cmpb $0x0, %al
je 0x21a55
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x21a55
movb $0x1, -0x1(%rbp)
jmp 0x21aab
movb $0x0, -0x1(%rbp)
jmp 0x21aab
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x21a81
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21a00
cmpb $0x0, %al
je 0x21a81
movb $0x1, -0x1(%rbp)
jmp 0x21aab
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x21aa7
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21a00
cmpb $0x0, %al
je 0x21aa7
movb $0x1, -0x1(%rbp)
jmp 0x21aab
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::ContainFuncNoRec(RFunction const&) const
signed char ROperation::ContainFuncNoRec(const RFunction& func) const // No recursive test on subfunctions
{if(op==Fun){if(*pfunc==func)
  return 1;else return 0;}
 if(mmb1!=NULL&&mmb1->ContainFuncNoRec(func))return 1;
 if(mmb2!=NULL&&mmb2->ContainFuncNoRec(func))return 1;
 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x16, 0x24(%rax)
jne 0x21b00
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21890
cmpl $0x0, %eax
je 0x21afa
movb $0x1, -0x1(%rbp)
jmp 0x21b50
movb $0x0, -0x1(%rbp)
jmp 0x21b50
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x21b26
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21ac0
cmpb $0x0, %al
je 0x21b26
movb $0x1, -0x1(%rbp)
jmp 0x21b50
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x21b4c
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21ac0
cmpb $0x0, %al
je 0x21b4c
movb $0x1, -0x1(%rbp)
jmp 0x21b50
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::ContainFunc(RFunction const&) const
signed char ROperation::ContainFunc(const RFunction& func) const // Recursive test on subfunctions
{
  if(containfuncflag)return 0;
  if(op==Fun&&*pfunc==func)return 1;
  containfuncflag=1;
  if(op==Fun)if(pfunc->op.ContainFunc(func)){containfuncflag=0;return 1;}
  if(mmb1!=NULL&&mmb1->ContainFunc(func)){containfuncflag=0;return 1;}
  if(mmb2!=NULL&&mmb2->ContainFunc(func)){containfuncflag=0;return 1;}
  containfuncflag=0;return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpb $0x0, 0x20(%rax)
je 0x21b87
movb $0x0, -0x1(%rbp)
jmp 0x21c4f
movq -0x20(%rbp), %rax
cmpl $0x16, 0x24(%rax)
jne 0x21bb0
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21890
cmpl $0x0, %eax
je 0x21bb0
movb $0x1, -0x1(%rbp)
jmp 0x21c4f
movq -0x20(%rbp), %rax
movb $0x1, 0x20(%rax)
cmpl $0x16, 0x24(%rax)
jne 0x21be7
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x21b60
cmpb $0x0, %al
je 0x21be5
movq -0x20(%rbp), %rax
movb $0x0, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x21c4f
jmp 0x21be7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x21c15
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21b60
cmpb $0x0, %al
je 0x21c15
movq -0x20(%rbp), %rax
movb $0x0, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x21c4f
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x21c43
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21b60
cmpb $0x0, %al
je 0x21c43
movq -0x20(%rbp), %rax
movb $0x0, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x21c4f
movq -0x20(%rbp), %rax
movb $0x0, 0x20(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::HasError(ROperation const*) const
signed char ROperation::HasError(const ROperation*pop) const
{
  if(op==ErrOp)return 1;
  if(op==Fun&&pfunc->type==1&&pfunc->op==*(pop==NULL?this:pop))return 1;
  if(op==Fun&&pfunc->type==1&&pfunc->op.HasError((pop==NULL?this:pop)))return 1;
  if(mmb1!=NULL&&mmb1->HasError((pop==NULL?this:pop)))return 1;
  if(mmb2!=NULL&&mmb2->HasError((pop==NULL?this:pop)))return 1;
  if(op==Fun&&pfunc->type==-1)return 1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x24(%rax)
jne 0x21c87
movb $0x1, -0x1(%rbp)
jmp 0x21df7
movq -0x20(%rbp), %rax
cmpl $0x16, 0x24(%rax)
jne 0x21ce6
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movsbl 0x8(%rax), %eax
cmpl $0x1, %eax
jne 0x21ce6
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x21cc3
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x21ccb
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1d430
cmpl $0x0, %eax
je 0x21ce6
movb $0x1, -0x1(%rbp)
jmp 0x21df7
movq -0x20(%rbp), %rax
cmpl $0x16, 0x24(%rax)
jne 0x21d44
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movsbl 0x8(%rax), %eax
cmpl $0x1, %eax
jne 0x21d44
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
addq $0x18, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x21d22
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x21d2a
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x21c60
cmpb $0x0, %al
je 0x21d44
movb $0x1, -0x1(%rbp)
jmp 0x21df7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x21d8b
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x21d6c
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x21d74
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x21c60
cmpb $0x0, %al
je 0x21d8b
movb $0x1, -0x1(%rbp)
jmp 0x21df7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x21dd2
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x21db3
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x21dbb
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x21c60
cmpb $0x0, %al
je 0x21dd2
movb $0x1, -0x1(%rbp)
jmp 0x21df7
movq -0x20(%rbp), %rax
cmpl $0x16, 0x24(%rax)
jne 0x21df3
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movsbl 0x8(%rax), %eax
cmpl $-0x1, %eax
jne 0x21df3
movb $0x1, -0x1(%rbp)
jmp 0x21df7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::Substitute(RVar const&, ROperation const&) const
ROperation ROperation::Substitute(const RVar& var,const ROperation& rop) const // Replaces variable var with expression rop
{
  if(!ContainVar(var))return *this;
  if(op==Var)return rop;
  ROperation r;
  r.op=op;r.pvar=pvar;r.pvarval=pvarval;r.ValC=ValC;r.pfunc=pfunc;
  if(mmb1!=NULL)r.mmb1=new ROperation(mmb1->Substitute(var,rop));else r.mmb1=NULL;
  if(mmb2!=NULL)r.mmb2=new ROperation(mmb2->Substitute(var,rop));else r.mmb2=NULL;
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x18(%rbp), %rsi
callq 0x21a00
cmpb $0x0, %al
jne 0x2211a
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x1d0a0
jmp 0x2227b
movq -0x40(%rbp), %rax
cmpl $0x3, 0x24(%rax)
jne 0x22136
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d0a0
jmp 0x2227b
movq -0x50(%rbp), %rdi
movb $0x0, -0x21(%rbp)
callq 0x1c150
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %rax
movl 0x24(%rax), %edx
movl %edx, 0x24(%rcx)
movq 0x40(%rax), %rdx
movq %rdx, 0x40(%rcx)
movq 0x48(%rax), %rdx
movq %rdx, 0x48(%rcx)
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0x38(%rcx)
movq 0x50(%rax), %rdx
movq %rdx, 0x50(%rcx)
cmpq $0x0, 0x28(%rax)
je 0x221e3
movl $0x58, %edi
callq 0x5400
movq %rax, -0x58(%rbp)
jmp 0x2218a
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x220d0
jmp 0x221a5
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x221ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x22270
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x22270
movq -0x50(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x2224f
movl $0x58, %edi
callq 0x5400
movq %rax, -0x60(%rbp)
jmp 0x2220a
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x220d0
jmp 0x22225
movq -0x50(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x30(%rax)
jmp 0x2225b
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x58, %esi
callq 0x5410
jmp 0x22270
movq -0x50(%rbp), %rax
movq $0x0, 0x30(%rax)
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x2226e
movq -0x50(%rbp), %rdi
callq 0x1ce40
jmp 0x2227b
movq -0x50(%rbp), %rdi
callq 0x1ce40
jmp 0x22285
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5720
nop
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: Multiplication(double*&)
void  Multiplication(double*&p)
{if(fabsl(*p)<sqrtminfloat){*--p=0;return;};
if(*p==ErrVal||fabsl(*p)>sqrtmaxfloat){*(--p)=ErrVal;return;};
if(fabsl(*(--p))<sqrtminfloat){*p=0;return;};
if(*p==ErrVal||fabsl(*p)>sqrtmaxfloat){*p=ErrVal;return;};
*p*=(*(p+1));}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm1
movaps 0x22186(%rip), %xmm0    # 0x47b10
pand %xmm0, %xmm1
movsd 0x372da(%rip), %xmm0    # 0x5cc70
ucomisd %xmm1, %xmm0
jbe 0x259ba
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rax)
jmp 0x25ac6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd 0x21f8b(%rip), %xmm1    # 0x47958
ucomisd %xmm1, %xmm0
jne 0x259d7
jp 0x259d7
jmp 0x259f7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movaps 0x22127(%rip), %xmm1    # 0x47b10
pand %xmm1, %xmm0
ucomisd 0x37273(%rip), %xmm0    # 0x5cc68
jbe 0x25a1a
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, (%rcx)
movsd 0x21f48(%rip), %xmm0    # 0x47958
movsd %xmm0, -0x8(%rax)
jmp 0x25ac6
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, (%rcx)
movsd -0x8(%rax), %xmm1
movaps 0x220d9(%rip), %xmm0    # 0x47b10
pand %xmm0, %xmm1
movsd 0x3722d(%rip), %xmm0    # 0x5cc70
ucomisd %xmm1, %xmm0
jbe 0x25a59
movq -0x8(%rbp), %rax
movq (%rax), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x25ac6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd 0x21eec(%rip), %xmm1    # 0x47958
ucomisd %xmm1, %xmm0
jne 0x25a76
jp 0x25a76
jmp 0x25a96
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movaps 0x22088(%rip), %xmm1    # 0x47b10
pand %xmm1, %xmm0
ucomisd 0x371d4(%rip), %xmm0    # 0x5cc68
jbe 0x25aab
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x21eb3(%rip), %xmm0    # 0x47958
movsd %xmm0, (%rax)
jmp 0x25ac6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: Division(double*&)
void  Division(double*&p)
{if(fabsl(*p)<sqrtminfloat||*p==ErrVal||fabsl(*p)>sqrtmaxfloat)
	{*(--p)=ErrVal;return;};
if(fabsl(*(--p))<sqrtminfloat)*p=0;else if(*p==ErrVal||fabsl(*p)>sqrtmaxfloat)
	{*p=ErrVal;return;};
*p/=(*(p+1));}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm1
movaps 0x22026(%rip), %xmm0    # 0x47b10
pand %xmm0, %xmm1
movsd 0x3717a(%rip), %xmm0    # 0x5cc70
ucomisd %xmm1, %xmm0
ja 0x25b39
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd 0x21e49(%rip), %xmm1    # 0x47958
ucomisd %xmm1, %xmm0
jne 0x25b19
jp 0x25b19
jmp 0x25b39
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movaps 0x21fe5(%rip), %xmm1    # 0x47b10
pand %xmm1, %xmm0
ucomisd 0x37131(%rip), %xmm0    # 0x5cc68
jbe 0x25b5c
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, (%rcx)
movsd 0x21e06(%rip), %xmm0    # 0x47958
movsd %xmm0, -0x8(%rax)
jmp 0x25c0e
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, (%rcx)
movsd -0x8(%rax), %xmm1
movaps 0x21f97(%rip), %xmm0    # 0x47b10
pand %xmm0, %xmm1
movsd 0x370eb(%rip), %xmm0    # 0x5cc70
ucomisd %xmm1, %xmm0
jbe 0x25b9b
movq -0x8(%rbp), %rax
movq (%rax), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x25bef
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd 0x21daa(%rip), %xmm1    # 0x47958
ucomisd %xmm1, %xmm0
jne 0x25bb8
jp 0x25bb8
jmp 0x25bd8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movaps 0x21f46(%rip), %xmm1    # 0x47b10
pand %xmm1, %xmm0
ucomisd 0x37092(%rip), %xmm0    # 0x5cc68
jbe 0x25bed
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x21d71(%rip), %xmm0    # 0x47958
movsd %xmm0, (%rax)
jmp 0x25c0e
jmp 0x25bef
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
popq %rbp
retq
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: Puissance(double*&)
void  Puissance(double*&p)
{double v2=*p--,v1=*p;
if(!v1){*p=0;return;};
if(v2==ErrVal||v1==ErrVal||fabsl(v2*logl(fabsl(v1)))>DBL_MAX_EXP){*p=ErrVal;return;};
*p=((v1>0||!fmodl(v2,1))?powl(v1,v2):ErrVal);}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, (%rcx)
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x25c69
jp 0x25c69
movq -0x8(%rbp), %rax
movq (%rax), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x25d4d
movsd -0x10(%rbp), %xmm0
movsd 0x21ce2(%rip), %xmm1    # 0x47958
ucomisd %xmm1, %xmm0
jne 0x25c80
jp 0x25c80
jmp 0x25cdb
movsd -0x18(%rbp), %xmm0
movsd 0x21ccb(%rip), %xmm1    # 0x47958
ucomisd %xmm1, %xmm0
jne 0x25c97
jp 0x25c97
jmp 0x25cdb
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movaps 0x21e63(%rip), %xmm1    # 0x47b10
pand %xmm1, %xmm0
callq 0x5350
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
mulsd %xmm1, %xmm0
movaps 0x21e47(%rip), %xmm1    # 0x47b10
pand %xmm1, %xmm0
movsd 0x21ca3(%rip), %xmm1    # 0x47978
ucomisd %xmm1, %xmm0
jbe 0x25cf0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x21c6e(%rip), %xmm0    # 0x47958
movsd %xmm0, (%rax)
jmp 0x25d4d
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
ja 0x25d18
movsd -0x10(%rbp), %xmm0
movl $0x1, %edi
callq 0x273e0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x25d2e
jp 0x25d2e
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x5710
movsd %xmm0, -0x28(%rbp)
jmp 0x25d3d
movsd 0x21c22(%rip), %xmm0    # 0x47958
movsd %xmm0, -0x28(%rbp)
jmp 0x25d3d
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)