LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rdi)
movl $0x0, 0x34(%rdi)
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
movq %rax, 0x38(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movb $0x0, 0x20(%rdi)
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
callq 0xd888
movl $0x16, 0x24(%rbx)
movq %r15, 0x50(%rbx)
movl $0x58, %edi
callq 0x4300
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xdeaa
movq %r15, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x58, %esi
movq %r15, %rdi
callq 0x4310
jmp 0xf3fd
movq %rax, %r14
movq %rbx, %rdi
callq 0xdd92
movq %r14, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x4170
decl %eax
cmpl %ebx, %eax
jle 0xf4e6
movslq %ebx, %rax
addq %r14, %rax
incq %rax
movl $0x1, %ecx
movzbl (%rax), %edx
cmpl $0x28, %edx
je 0xf4d9
cmpl $0x29, %edx
je 0xf4d5
testl %edx, %edx
jne 0xf4db
jmp 0xf4e6
decl %ecx
jmp 0xf4db
incl %ecx
incl %ebx
incq %rax
testl %ecx, %ecx
jne 0xf4c2
jmp 0xf4eb
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %esi, %esi
jle 0xf528
movl %esi, %ecx
movl $0x1, %edx
testq %rcx, %rcx
jle 0xf528
movzbl -0x1(%rdi,%rcx), %esi
cmpl $0x28, %esi
je 0xf51d
cmpl $0x29, %esi
jne 0xf51f
incl %edx
jmp 0xf51f
decl %edx
decq %rcx
testl %edx, %edx
jne 0xf505
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r15
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leal -0x1(%r14), %eax
cmpl $0xa, %eax
ja 0xf55b
leaq 0x1c3d1(%rip), %rcx     # 0x2b91c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2c, %ebp
jmp 0xf594
cmpl $0x15, %r14d
jne 0xf5fa
movl $0x45, %ebp
jmp 0xf594
movl $0x23, %ebp
jmp 0xf594
movl $0x2d, %ebp
jmp 0xf594
movl $0x2a, %ebp
jmp 0xf594
movl $0x2b, %ebp
jmp 0xf594
movl $0x2f, %ebp
jmp 0xf594
movl $0x5e, %ebp
movq %r15, %rdi
callq 0x4170
testl %eax, %eax
jle 0xf5fa
leal -0x1(%rax), %ecx
movsbl (%r15,%rcx), %edx
cmpl %edx, %ebp
jne 0xf5c0
cmpl $0x5, %r14d
jne 0xf5f8
testl %ecx, %ecx
je 0xf5fa
movl %eax, %eax
cmpb $0x29, -0x2(%r15,%rax)
je 0xf5f8
cmpb $0x29, %dl
jne 0xf5f0
testl %ecx, %ecx
je 0xf5fa
movl $0x1, %eax
testq %rcx, %rcx
jle 0xf5fa
movzbl -0x1(%r15,%rcx), %edx
cmpl $0x28, %edx
je 0xf5e7
cmpl $0x29, %edx
jne 0xf5e9
incl %eax
jmp 0xf5e9
decl %eax
decq %rcx
testl %eax, %eax
jne 0xf5ce
movl %ecx, %eax
testl %ecx, %ecx
jg 0xf5a0
jmp 0xf5fa
movl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: SimplifyStr(char*&)
void SimplifyStr(char*&s) //Warning : deletes the old string
{if(!strlen(s))return;
char*s1=s,*s2=s+strlen(s);signed char ind=0;
if(s1[0]=='('&&SearchCorOpenbracket(s1,0)==s2-s1-1){
	s1++;s2--;ind=1;}
if(s1==s2)
{
	delete[]s;
	s=new char[1]; // ISO C++ forbids initialization in array new
	s[0]=0;
	return;
}
if(s1[0]==' '){ind=1;while(s1[0]==' '&&s1<s2)s1++;}
if(s1==s2)
{
	delete[]s;
	s=new char[1]; // ISO C++ forbids initialization in array new
	s[0]=0;
	return;
}
if(*(s2-1)==' '){ind=1;while(s2>s1&&*(s2-1)==' ')s2--;}
*s2=0;
s1=CopyStr(s1);delete[]s;s=s1;
if(ind)SimplifyStr(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
callq 0x4170
testq %rax, %rax
je 0xf6e3
movq %rax, %r15
leaq (%r14,%rax), %r12
cmpb $0x28, (%r14)
jne 0xf655
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0xf4a0
cltq
decq %r15
cmpq %rax, %r15
jne 0xf657
leaq 0x1(%r14), %rdi
decq %r12
movb $0x1, %bpl
jmp 0xf65a
xorl %ebp, %ebp
movq %r14, %rdi
cmpq %r12, %rdi
je 0xf6cb
cmpb $0x20, (%rdi)
jne 0xf67e
leaq 0x1(%rdi), %rax
cmpq %r12, %rdi
jae 0xf675
cmpb $0x20, (%rdi)
movq %rax, %rdi
je 0xf664
decq %rax
movb $0x1, %bpl
movq %rax, %rdi
cmpq %r12, %rdi
je 0xf6cb
cmpb $0x20, -0x1(%r12)
jne 0xf6a2
movq %r12, %rax
movb $0x1, %bpl
cmpq %rdi, %r12
jbe 0xf6a5
leaq -0x1(%rax), %r12
cmpb $0x20, -0x1(%rax)
je 0xf68b
jmp 0xf6a5
movq %r12, %rax
movb $0x0, (%rax)
callq 0xce11
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xf6bd
callq 0x43c0
movq %r14, (%rbx)
testb %bpl, %bpl
jne 0xf615
jmp 0xf6e3
movq %r14, %rdi
callq 0x43c0
movl $0x1, %edi
callq 0x4040
movq %rax, (%rbx)
movb $0x0, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
xorl %r15d, %r15d
testl %esi, %esi
js 0xf764
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
callq 0x4170
cmpl %ebp, %eax
setl %al
testl %r12d, %r12d
setle %cl
orb %al, %cl
jne 0xf764
movl %r12d, %r13d
xorl %ebx, %ebx
xorl %r15d, %r15d
movq (%rsp), %rax
movq (%rax,%rbx,8), %rax
movq (%rax), %r12
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xcf19
testb %al, %al
je 0xf75c
movq %r12, %rdi
callq 0x4170
cmpl %eax, %r15d
cmovgl %r15d, %eax
movl %eax, %r15d
incq %rbx
cmpq %rbx, %r13
jne 0xf72e
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x1c2a3(%rip), %rdx     # 0x2ba29
callq 0xcf19
movl $0x3, %ebp
testb %al, %al
jne 0xf921
leaq 0x1c294(%rip), %rdx     # 0x2ba33
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c258(%rip), %rdx     # 0x2ba10
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c25d(%rip), %rdx     # 0x2ba2e
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c22a(%rip), %rdx     # 0x2ba14
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c215(%rip), %rdx     # 0x2ba18
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c200(%rip), %rdx     # 0x2ba1c
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c1e4(%rip), %rdx     # 0x2ba19
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
movl $0x2, %ebp
testb %al, %al
jne 0xf921
leaq 0x1c1cd(%rip), %rdx     # 0x2ba20
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c1b7(%rip), %rdx     # 0x2ba23
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
movl $0x4, %ebp
testb %al, %al
jne 0xf921
leaq 0x1c19e(%rip), %rdx     # 0x2ba28
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c18a(%rip), %rdx     # 0x2ba2d
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c17a(%rip), %rdx     # 0x2ba32
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c16a(%rip), %rdx     # 0x2ba37
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
movl $0x6, %ebp
testb %al, %al
jne 0xf921
leaq 0x1c157(%rip), %rdx     # 0x2ba3e
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c149(%rip), %rdx     # 0x2ba45
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
testb %al, %al
jne 0xf921
leaq 0x1c13b(%rip), %rdx     # 0x2ba4c
movq %r14, %rdi
movl %ebx, %esi
callq 0xcf19
movzbl %al, %eax
leal (%rax,%rax,4), %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
callq 0xf776
movl %eax, %r15d
testl %eax, %eax
jne 0xf997
testl %r12d, %r12d
jle 0xf994
movl %r12d, %r13d
xorl %ebx, %ebx
xorl %r15d, %r15d
movq (%rsp), %rax
movq (%rax,%rbx,8), %rax
movq 0x80(%rax), %r12
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xcf19
testb %al, %al
je 0xf98a
movq %r12, %rdi
callq 0x4170
cmpl %eax, %r15d
cmovgl %r15d, %eax
movl %eax, %r15d
incq %rbx
cmpq %rbx, %r13
jne 0xf958
jmp 0xf997
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movl %ecx, 0x4(%rsp)
movq %rdx, 0x8(%rsp)
movl %esi, %r15d
movq %rdi, %r12
xorl %r13d, %r13d
movq (%r12), %rbx
movslq %r13d, %rax
movzbl (%rbx,%rax), %eax
cmpl $0x28, %eax
je 0xfaa5
testl %eax, %eax
je 0xfad4
movq %rbx, %rdi
movl %r13d, %esi
movl %r15d, %edx
movq 0x8(%rsp), %rcx
callq 0xf6f4
movl %eax, %ebp
movq %rbx, %rdi
movl %r13d, %esi
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rcx
callq 0xf928
cmpl %eax, %ebp
jg 0xfa7d
movl %eax, %r14d
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x1c00f(%rip), %rdx     # 0x2ba52
callq 0xcf19
movl $0x2, %ebp
testb %al, %al
jne 0xfa7d
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x1bff7(%rip), %rdx     # 0x2ba55
callq 0xcf19
testb %al, %al
jne 0xfa7d
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x1bfe4(%rip), %rdx     # 0x2ba58
callq 0xcf19
testb %al, %al
je 0xfac0
movq %r12, %rdi
movl %r13d, %esi
movl $0x28, %edx
callq 0xce34
addl %ebp, %r13d
incl %r13d
movq %r12, %rdi
movl %r13d, %esi
movl $0x29, %edx
callq 0xce34
jmp 0xfab8
movq %rbx, %rdi
movl %r13d, %esi
callq 0xf4a0
movl %eax, %r13d
cmpl $-0x1, %eax
je 0xfad4
incl %r13d
jmp 0xf9ea
testl %r14d, %r14d
je 0xfab8
addl %r14d, %r13d
decl %r13d
movslq %r13d, %rax
cmpb $0x0, (%rbx,%rax)
jne 0xfab8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movl %ecx, 0x14(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, %r15
movq (%rdi), %rbx
movb (%rbx), %r13b
testb %r13b, %r13b
je 0xfc53
movl %esi, %ebp
movq %r15, 0x8(%rsp)
xorl %r12d, %r12d
movl $0x0, 0x4(%rsp)
xorl %eax, %eax
movl %eax, %r14d
testl %r12d, %r12d
je 0xfb45
leal -0x3a(%r13), %eax
cmpb $-0xa, %al
setae %al
cmpb $0x2e, %r13b
sete %cl
orb %al, %cl
je 0xfbe5
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq 0x18(%rsp), %rcx
callq 0xf6f4
movl %eax, %r15d
movq %rbx, %rdi
movl %r14d, %esi
movl 0x14(%rsp), %edx
movq 0x20(%rsp), %rcx
callq 0xf928
movl %eax, %ecx
orl %r15d, %ecx
jne 0xfb9a
cmpb $0x28, %r13b
je 0xfba9
testl %r12d, %r12d
je 0xfbc1
incl %r14d
movslq %r14d, %rax
movb (%rbx,%rax), %r13b
movl $0x1, %r12d
testb %r13b, %r13b
jne 0xfb28
jmp 0xfc38
cmpl %eax, %r15d
cmovgl %r15d, %eax
addl %eax, %r14d
decl %r14d
jmp 0xfc14
movq %rbx, %rdi
movl %r14d, %esi
callq 0xf4a0
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0xfc14
jmp 0xfc77
leal -0x30(%r13), %eax
cmpb $0xa, %al
setb %al
cmpb $0x2e, %r13b
sete %cl
orb %al, %cl
movl 0x4(%rsp), %eax
cmovnel %r14d, %eax
movl %eax, 0x4(%rsp)
movzbl %cl, %r12d
jmp 0xfc14
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl 0x4(%rsp), %esi
movl $0x28, %edx
callq 0xce34
incl %r14d
movq %rbx, %rdi
movl %r14d, %esi
movl $0x29, %edx
callq 0xce34
movq (%rbx), %rbx
xorl %r12d, %r12d
movslq %r14d, %rax
movb 0x1(%rbx,%rax), %r13b
incq %rax
testb %r13b, %r13b
jne 0xfb25
addl $0x2, %r14d
testl %r12d, %r12d
movq 0x8(%rsp), %r15
jne 0xfc40
jmp 0xfc59
incl %r14d
movq 0x8(%rsp), %r15
movq %r15, %rdi
movl 0x4(%rsp), %esi
movl $0x28, %edx
callq 0xce34
jmp 0xfc59
movl $0x1, %r14d
movq %r15, %rdi
movl %r14d, %esi
movl $0x29, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xce34
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movzbl 0x8(%rdi), %eax
xorl %ebx, %ebx
cmpb 0x8(%rsi), %al
jne 0x10e08
cmpl $0xff, %eax
je 0x10e03
movq %rsi, %r14
movq %rdi, %r15
testl %eax, %eax
jne 0x10d96
movq 0x10(%r15), %rax
cmpq 0x10(%r14), %rax
jne 0x10e08
movq 0x80(%r15), %rdi
movq 0x80(%r14), %rsi
callq 0xced3
movzbl %al, %ebx
jmp 0x10e08
leaq 0x18(%r15), %rdi
leaq 0x18(%r14), %rsi
callq 0xe1b8
testl %eax, %eax
jne 0x10e08
movq 0x80(%r15), %rdi
movq 0x80(%r14), %rsi
callq 0xced3
testb %al, %al
je 0x10e08
movl 0x70(%r15), %r12d
cmpl 0x70(%r14), %r12d
jne 0x10e08
testl %r12d, %r12d
jle 0x10e03
movq 0x78(%r15), %r15
movq 0x78(%r14), %r14
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%r15,%r13,8), %rax
movq (%r14,%r13,8), %rcx
movq 0x8(%rax), %rdx
cmpq 0x8(%rcx), %rdx
jne 0x10e08
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0xced3
testb %al, %al
je 0x10e08
incq %r13
cmpq %r13, %r12
jne 0x10dda
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x3, 0x24(%rdi)
jne 0x10e45
movq 0x40(%r14), %r14
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0xced3
testb %al, %al
je 0x10e77
movq 0x8(%r14), %rax
cmpq 0x8(%rbx), %rax
jne 0x10e77
movb $0x1, %al
jmp 0x10e79
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x10e5e
movq %rbx, %rsi
callq 0x10e14
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x10e79
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x10e77
movq %rbx, %rsi
callq 0x10e14
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x10e79
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x16, 0x24(%rdi)
jne 0x10ea0
movq 0x50(%r14), %rdi
movq %rbx, %rsi
callq 0x10d43
jmp 0x10ed4
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x10eb9
movq %rbx, %rsi
callq 0x10e82
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x10ed4
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x10ed2
movq %rbx, %rsi
callq 0x10e82
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x10ed4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpb $0x0, 0x20(%rdi)
je 0x10ee5
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x16, 0x24(%rdi)
jne 0x10f2a
movq 0x50(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x10d43
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
jne 0x10f66
movb $0x1, 0x20(%rbx)
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x10edc
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x10f62
jmp 0x10f2e
movb $0x1, 0x20(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x10f47
movq %r14, %rsi
callq 0x10edc
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x10f62
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x10f60
movq %r14, %rsi
callq 0x10edc
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x10f62
xorl %eax, %eax
movb $0x0, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x24(%rdi), %eax
testl %eax, %eax
je 0x11009
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x16, %eax
jne 0x10fcf
movq 0x50(%rbx), %r15
movb $0x1, %bpl
cmpb $0x1, 0x8(%r15)
jne 0x10fd1
addq $0x18, %r15
testq %r14, %r14
movq %r14, %rsi
cmoveq %rbx, %rsi
movq %r15, %rdi
callq 0xe0a0
movb $0x1, %bpl
testl %eax, %eax
jne 0x1100c
testq %r14, %r14
movq %r14, %rsi
cmoveq %rbx, %rsi
movq %r15, %rdi
callq 0x10f6c
movb $0x1, %bpl
testb %al, %al
jne 0x1100c
jmp 0x10fd1
xorl %ebp, %ebp
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x10fed
testq %r14, %r14
movq %r14, %rsi
cmoveq %rbx, %rsi
callq 0x10f6c
testb %al, %al
jne 0x11009
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x11019
testq %r14, %r14
cmoveq %rbx, %r14
movq %r14, %rsi
callq 0x10f6c
testb %al, %al
je 0x11019
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testb %bpl, %bpl
je 0x1102b
movq 0x50(%rbx), %rax
cmpb $-0x1, 0x8(%rax)
movb $0x1, %bpl
je 0x1100c
xorl %ebp, %ebp
jmp 0x1100c
nop
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: ROperation::NthMember(int) const
ROperation ROperation::NthMember(int n) const
{
  PRFunction prf;
  if(op==Fun&&pfunc->type==1&&pfunc->op.NMembers()>1){
    prf=new RFunction(pfunc->op.NthMember(n),pfunc->nvars,pfunc->ppvar);
    char*s=new char[strlen(pfunc->name)+10];
    sprintf(s,"(%s_%i)",pfunc->name,n);prf->SetName(s);delete[]s;
    return(*prf)(*mmb2);
  }
  if(n==1){
    if(op!=Juxt)return *this; else if(mmb1!=NULL)return *mmb1;else return ErrVal;
  };
  if(op!=Juxt)return ErrVal;
  if(n>1&&mmb2!=NULL)return mmb2->NthMember(n-1);
  return ErrVal;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x24(%r14), %r15d
cmpl $0x16, %r15d
jne 0x11071
movq 0x50(%r14), %r12
cmpb $0x1, 0x8(%r12)
jne 0x11071
addq $0x18, %r12
movq %r12, %rdi
callq 0x10d00
cmpl $0x2, %eax
jge 0x110f2
cmpl $0x1, %ebp
je 0x1108e
cmpl $0x1, %r15d
jne 0x110a2
cmpl $0x2, %ebp
jl 0x110a2
movq 0x30(%r14), %r14
testq %r14, %r14
je 0x110a2
decl %ebp
jmp 0x11046
cmpl $0x1, %r15d
jne 0x110e2
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0x110a2
movq %rbx, %rdi
jmp 0x110e8
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rbx)
movl $0x0, 0x34(%rbx)
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
movq %rax, 0x38(%rbx)
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movb $0x0, 0x20(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x0, 0x50(%rbx)
movq %rbx, %rdi
callq 0xd888
jmp 0x11181
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdeaa
jmp 0x11181
movl $0x88, %edi
callq 0x4300
movq %rax, %r15
movq %rsp, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x11030
movq 0x50(%r14), %rax
movl 0x70(%rax), %edx
movq 0x78(%rax), %rcx
movq %rsp, %rsi
movq %r15, %rdi
callq 0xd47a
movq %rsp, %rdi
callq 0xdd92
movq 0x50(%r14), %rax
movq 0x80(%rax), %r12
movq %r12, %rdi
callq 0x4170
leaq 0xa(%rax), %rdi
callq 0x4040
movq %rax, %r13
leaq 0x1a911(%rip), %rsi     # 0x2ba61
movq %rax, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r13, %rsi
callq 0xd662
movq %r13, %rdi
callq 0x43c0
movq 0x30(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf372
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xdd92
jmp 0x111a3
movq %rax, %rbx
movl $0x88, %esi
movq %r15, %rdi
callq 0x4310
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x10e14
testb %al, %al
je 0x111ee
cmpl $0x3, 0x24(%r12)
jne 0x111fe
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x111f4
movq %rbx, %rdi
movq %r12, %rsi
callq 0xdeaa
jmp 0x112c7
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rbx)
movl $0x0, 0x34(%rbx)
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
movq %rax, 0x38(%rbx)
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movb $0x0, 0x20(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x0, 0x50(%rbx)
movq %rbx, %rdi
callq 0xd888
movl 0x24(%r12), %eax
movl %eax, 0x24(%rbx)
movups 0x40(%r12), %xmm0
movups %xmm0, 0x40(%rbx)
movsd 0x38(%r12), %xmm0
movsd %xmm0, 0x38(%rbx)
movq 0x50(%r12), %rax
movq %rax, 0x50(%rbx)
movq 0x28(%r12), %rbp
testq %rbp, %rbp
je 0x1128a
movl $0x58, %edi
callq 0x4300
movq %rax, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x111b8
jmp 0x1128d
xorl %r13d, %r13d
movq %r13, 0x28(%rbx)
movq 0x30(%r12), %r13
testq %r13, %r13
je 0x112bf
movl $0x58, %edi
callq 0x4300
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x111b8
movq %r12, 0x30(%rbx)
jmp 0x112c7
movq $0x0, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x58, %esi
movq %r12, %rdi
jmp 0x112f1
movq %rax, %r14
movl $0x58, %esi
movq %r13, %rdi
callq 0x4310
jmp 0x112fb
movq %rax, %r14
movq %rbx, %rdi
callq 0xdd92
movq %r14, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rax
movsd (%rax), %xmm0
movapd 0x186f4(%rip), %xmm2    # 0x2ba00
andpd %xmm0, %xmm2
movsd 0x18568(%rip), %xmm1    # 0x2b880
ucomisd %xmm2, %xmm1
jbe 0x1332e
leaq -0x8(%rax), %rcx
movq %rcx, (%rdi)
movq $0x0, -0x8(%rax)
retq
addq $-0x8, %rax
ucomisd 0x18536(%rip), %xmm0    # 0x2b870
movq %rax, (%rdi)
jne 0x13341
jnp 0x13388
ucomisd 0x1852f(%rip), %xmm2    # 0x2b878
ja 0x13388
movsd (%rax), %xmm2
movapd 0x186a9(%rip), %xmm3    # 0x2ba00
andpd %xmm2, %xmm3
ucomisd %xmm3, %xmm1
jbe 0x13369
movq $0x0, (%rax)
retq
ucomisd 0x184ff(%rip), %xmm2    # 0x2b870
jne 0x13375
jnp 0x13388
ucomisd 0x184fb(%rip), %xmm3    # 0x2b878
ja 0x13388
mulsd %xmm2, %xmm0
movsd %xmm0, (%rax)
retq
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rax
movsd (%rax), %xmm0
movapd 0x1865b(%rip), %xmm2    # 0x2ba00
andpd %xmm0, %xmm2
addq $-0x8, %rax
ucomisd 0x184c3(%rip), %xmm2    # 0x2b878
movq %rax, (%rdi)
movsd 0x184b0(%rip), %xmm1    # 0x2b870
ja 0x1341c
movsd 0x184b6(%rip), %xmm3    # 0x2b880
ucomisd %xmm2, %xmm3
ja 0x1341c
ucomisd 0x18498(%rip), %xmm0    # 0x2b870
jne 0x133dc
jnp 0x1341c
movsd (%rax), %xmm2
movapd 0x18618(%rip), %xmm4    # 0x2ba00
andpd %xmm2, %xmm4
xorpd %xmm5, %xmm5
ucomisd %xmm4, %xmm3
ja 0x13414
movsd 0x18472(%rip), %xmm1    # 0x2b870
ucomisd %xmm1, %xmm2
jne 0x13406
jnp 0x1341c
ucomisd 0x1846a(%rip), %xmm4    # 0x2b878
movapd %xmm2, %xmm5
ja 0x1341c
divsd %xmm0, %xmm5
movapd %xmm5, %xmm1
movsd %xmm1, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movq (%rdi), %rcx
leaq -0x8(%rcx), %rax
movq %rax, (%rdi)
movsd -0x8(%rcx), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x13441
jnp 0x134ab
movsd (%rcx), %xmm2
ucomisd 0x18423(%rip), %xmm2    # 0x2b870
jne 0x13451
jnp 0x1349c
ucomisd 0x18417(%rip), %xmm1    # 0x2b870
jne 0x1345d
jnp 0x1349c
movq %rdi, %rbx
movapd %xmm1, %xmm0
andpd 0x18594(%rip), %xmm0    # 0x2ba00
movapd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x4280
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm0
andpd 0x18571(%rip), %xmm0    # 0x2ba00
ucomisd 0x183f1(%rip), %xmm0    # 0x2b888
jbe 0x134b4
movq (%rbx), %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movq %rcx, (%rax)
jmp 0x1350b
movq $0x0, (%rax)
jmp 0x1350b
xorpd %xmm0, %xmm0
movapd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x134f7
movsd 0x17c7c(%rip), %xmm1    # 0x2b148
movapd %xmm2, %xmm0
callq 0x4400
movsd 0x8(%rsp), %xmm2
movapd 0x10(%rsp), %xmm1
ucomisd 0x183a7(%rip), %xmm0    # 0x2b890
jne 0x134ed
jnp 0x134f7
movsd 0x1837b(%rip), %xmm0    # 0x2b870
jmp 0x13504
movapd %xmm1, %xmm0
movapd %xmm2, %xmm1
callq 0x45a0
movq (%rbx), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: RacineN(double*&)
void  RacineN(double*&p)
{double v2=*p--,v1=*p;
if(v1==ErrVal||v2==ErrVal||!v1||v2*logl(fabsl(v1))<DBL_MIN_EXP){*p=ErrVal;return;};
if(v2>=0){*p=powl(v2,1/v1);return;};
*p=((fabsl(fmodl(v1,2))==1)?-powl(-v2,1/v1):ErrVal);}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rcx
leaq -0x8(%rcx), %rax
movq %rax, (%rdi)
movsd -0x8(%rcx), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x13531
jnp 0x13587
ucomisd 0x18337(%rip), %xmm1    # 0x2b870
jne 0x1353d
jnp 0x13587
movsd (%rcx), %xmm2
ucomisd 0x18327(%rip), %xmm2    # 0x2b870
jne 0x1354d
jnp 0x13587
movq %rdi, %rbx
movapd 0x184a8(%rip), %xmm0    # 0x2ba00
movapd %xmm1, (%rsp)
andpd %xmm1, %xmm0
movapd %xmm2, 0x10(%rsp)
callq 0x4280
movapd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
movsd 0x1831a(%rip), %xmm1    # 0x2b898
ucomisd %xmm0, %xmm1
jbe 0x13599
movq (%rbx), %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movq %rcx, (%rax)
jmp 0x1361a
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jae 0x135f3
movsd 0x182f5(%rip), %xmm1    # 0x2b8a0
movapd (%rsp), %xmm0
callq 0x4400
andpd 0x18443(%rip), %xmm0    # 0x2ba00
ucomisd 0x17b83(%rip), %xmm0    # 0x2b148
jne 0x1360b
jp 0x1360b
movapd 0x10(%rsp), %xmm0
xorpd 0x17b89(%rip), %xmm0    # 0x2b160
movsd 0x17b69(%rip), %xmm1    # 0x2b148
divsd (%rsp), %xmm1
callq 0x45a0
xorpd 0x17b6f(%rip), %xmm0    # 0x2b160
jmp 0x13613
movsd 0x17b4d(%rip), %xmm1    # 0x2b148
divsd (%rsp), %xmm1
movapd %xmm2, %xmm0
callq 0x45a0
jmp 0x13613
movsd 0x1825d(%rip), %xmm0    # 0x2b870
movq (%rbx), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: Puiss10(double*&)
void  Puiss10(double*&p)
{if(fabsl(*p)<sqrtminfloat){*(--p)=0;return;};
if(*p==ErrVal||fabsl(*p)>DBL_MAX_10_EXP){*(--p)=ErrVal;return;};
if(fabsl(*(--p))<sqrtminfloat)*p=0;else if(*p==ErrVal||fabsl(*p)>sqrtmaxfloat)
{*p=ErrVal;return;};
*p*=pow10l(*(p+1));}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movsd (%rax), %xmm1
movapd 0x183cd(%rip), %xmm2    # 0x2ba00
andpd %xmm1, %xmm2
movsd 0x18241(%rip), %xmm0    # 0x2b880
ucomisd %xmm2, %xmm0
jbe 0x13656
leaq -0x8(%rax), %rcx
movq %rcx, (%rbx)
movq $0x0, -0x8(%rax)
jmp 0x136cf
addq $-0x8, %rax
ucomisd 0x1820e(%rip), %xmm1    # 0x2b870
movq %rax, (%rbx)
jne 0x13669
jnp 0x136c2
ucomisd 0x18237(%rip), %xmm2    # 0x2b8a8
ja 0x136c2
movsd (%rax), %xmm3
movapd 0x18381(%rip), %xmm2    # 0x2ba00
andpd %xmm3, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x13692
movq $0x0, (%rax)
jmp 0x136a8
ucomisd 0x181d6(%rip), %xmm3    # 0x2b870
jne 0x1369e
jnp 0x136c2
ucomisd 0x181d2(%rip), %xmm2    # 0x2b878
ja 0x136c2
movsd 0x18200(%rip), %xmm0    # 0x2b8b0
callq 0x45a0
movq (%rbx), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x136cf
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_load
STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
{
   FILE *f = stbi__fopen(filename, "rb");
   unsigned char *result;
   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
   result = stbi_load_from_file(f,x,y,comp,req_comp);
   fclose(f);
   return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x17f9c(%rip), %rsi     # 0x2c1d0
callq 0x4370
testq %rax, %rax
je 0x14265
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x1427f
movq %rax, %rbx
movq %r13, %rdi
callq 0x42f0
movq %rbx, %rax
jmp 0x14275
leaq 0x17f67(%rip), %rax     # 0x2c1d3
movq %rax, 0x2311d(%rip)     # 0x37390
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_load_from_file
STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *result;
   stbi__context s;
   stbi__start_file(&s,f);
   result = stbi__load_flip(&s,x,y,comp,req_comp);
   if (result) {
      // need to 'unget' all the characters in the IO buffer
      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
   }
   return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x142fc
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x1437b
movq %rax, %r14
testq %rax, %rax
je 0x142e7
movl 0xb8(%rsp), %eax
subl 0xc0(%rsp), %eax
movslq %eax, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x4350
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__load_flip(stbi__context*, int*, int*, int*, int)
static unsigned char *stbi__load_flip(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *result = stbi__load_main(s, x, y, comp, req_comp);

   if (stbi__vertically_flip_on_load && result != NULL) {
      int w = *x, h = *y;
      int depth = req_comp ? req_comp : *comp;
      int row,col,z;
      stbi_uc temp;

      // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once
      for (row = 0; row < (h>>1); row++) {
         for (col = 0; col < w; col++) {
            for (z = 0; z < depth; z++) {
               temp = result[(row * w + col) * depth + z];
               result[(row * w + col) * depth + z] = result[((h - row - 1) * w + col) * depth + z];
               result[((h - row - 1) * w + col) * depth + z] = temp;
            }
         }
      }
   }

   return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
callq 0x15d6c
movq %rax, (%rsp)
testq %rax, %rax
je 0x14431
cmpl $0x0, 0x22fed(%rip)     # 0x37398
je 0x14431
movl (%r12), %ecx
testl %ebx, %ebx
jne 0x143bc
movl (%r15), %ebx
movl %ecx, %edi
sarl %edi
testl %edi, %edi
jle 0x14431
movslq (%r14), %rdx
movslq %ebx, %rsi
movl %edi, %eax
movl %esi, %r8d
decl %ecx
imull %edx, %ecx
movq %rsi, %r9
imulq %rdx, %r9
xorl %r10d, %r10d
movq (%rsp), %r11
testl %edx, %edx
jle 0x14424
movslq %ecx, %r14
imulq %rsi, %r14
addq (%rsp), %r14
movq %r11, %r15
xorl %r12d, %r12d
testl %ebx, %ebx
jle 0x14416
xorl %r13d, %r13d
movb (%r15,%r13), %bpl
movb (%r14,%r13), %dil
movb %dil, (%r15,%r13)
movb %bpl, (%r14,%r13)
incq %r13
cmpq %r13, %r8
jne 0x143fe
incq %r12
addq %rsi, %r14
addq %rsi, %r15
cmpq %rdx, %r12
jne 0x143f7
incq %r10
subl %edx, %ecx
addq %r9, %r11
cmpq %rax, %r10
jne 0x143e2
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_loadf
STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
{
   float *result;
   FILE *f = stbi__fopen(filename, "rb");
   if (!f) return stbi__errpf("can't fopen", "Unable to open file");
   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
   fclose(f);
   return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
leaq 0x178fb(%rip), %rsi     # 0x2c1d0
callq 0x4370
testq %rax, %rax
je 0x14911
movq %rax, %r12
movq %rsp, %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x142fc
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x145a2
movq %rax, %rbx
movq %r12, %rdi
callq 0x42f0
jmp 0x14921
leaq 0x178bb(%rip), %rax     # 0x2c1d3
movq %rax, 0x22a71(%rip)     # 0x37390
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_is_hdr_from_memory
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
{
   #ifndef STBI_NO_HDR
   stbi__context s;
   stbi__start_mem(&s,buffer,len);
   return stbi__hdr_test(&s);
   #else
   STBI_NOTUSED(buffer);
   STBI_NOTUSED(len);
   return 0;
   #endif
}

// Assembly:
subq $0xd8, %rsp
movq %rsp, %rax
movq $0x0, 0x10(%rax)
movl $0x0, 0x30(%rax)
movq %rdi, 0xc8(%rax)
movq %rdi, 0xb8(%rax)
movslq %esi, %rcx
addq %rdi, %rcx
movq %rcx, 0xd0(%rax)
movq %rcx, 0xc0(%rax)
movq %rax, %rdi
callq 0x149d2
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_is_hdr
STBIDEF int      stbi_is_hdr          (char const *filename)
{
   FILE *f = stbi__fopen(filename, "rb");
   int result=0;
   if (f) {
      result = stbi_is_hdr_from_file(f);
      fclose(f);
   }
   return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
leaq 0x1771d(%rip), %rsi     # 0x2c1d0
callq 0x4370
testq %rax, %rax
je 0x14ae4
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x142fc
movq %r14, %rdi
callq 0x149d2
movl %eax, %ebp
movq %rbx, %rdi
callq 0x42f0
jmp 0x14ae6
xorl %ebp, %ebp
movl %ebp, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_is_hdr_from_callbacks
static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
{
   s->io = *c;
   s->io_user_data = user;
   s->buflen = sizeof(s->buffer_start);
   s->read_from_callbacks = 1;
   s->img_buffer_original = s->buffer_start;
   stbi__refill_buffer(s);
   s->img_buffer_original_end = s->img_buffer_end;
}

// Assembly:
pushq %rbx
subq $0xe0, %rsp
movq 0x10(%rdi), %rax
leaq 0x40(%rsp), %rbx
movq %rax, -0x18(%rbx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rbx)
movq %rsi, -0x10(%rbx)
movabsq $0x8000000001, %rax     # imm = 0x8000000001
movq %rax, -0x8(%rbx)
movq %rbx, 0x90(%rbx)
movq %rsi, %rdi
movq %rbx, %rsi
movl $0x80, %edx
callq *-0x28(%rbx)
testl %eax, %eax
je 0x14b6b
cltq
addq %rbx, %rax
jmp 0x14b7b
leaq 0x41(%rsp), %rax
movl $0x0, -0x9(%rax)
movb $0x0, -0x1(%rax)
leaq 0x8(%rsp), %rdi
movq %rbx, 0xb8(%rdi)
movq %rax, 0xc0(%rdi)
movq %rax, 0xd0(%rdi)
callq 0x149d2
addq $0xe0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_zlib_decode_malloc_guesssize
STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(initial_size);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer + len;
   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %rdi
callq 0x43f0
testq %rax, %rax
je 0x14c4d
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movslq %r15d, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
movl %ebp, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x14c64
testl %eax, %eax
je 0x14c43
testq %rbx, %rbx
je 0x14c5d
movl 0x20(%rsp), %ecx
movq 0x28(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x14c4f
movq 0x28(%rsp), %rdi
callq 0x4380
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rsp), %rax
jmp 0x14c4f
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_zlib_decode_malloc_guesssize_headerflag
STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(initial_size);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer + len;
   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %r8d, %ebp
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
movslq %edx, %rdi
callq 0x43f0
testq %rax, %rax
je 0x1572b
movq %rsp, %rdi
movq %r15, (%rdi)
movslq %r12d, %rcx
addq %r15, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
movl %r14d, %edx
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x14c64
testl %eax, %eax
je 0x15721
testq %rbx, %rbx
je 0x1573d
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x1572d
movq 0x20(%rsp), %rdi
callq 0x4380
xorl %eax, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rax
jmp 0x1572d
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_zlib_decode_noheader_malloc
STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(16384);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer+len;
   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x4000, %edi           # imm = 0x4000
callq 0x43f0
testq %rax, %rax
je 0x157fa
movq %rsp, %rdi
movq %r14, (%rdi)
movslq %ebp, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
movl $0x4000, %edx           # imm = 0x4000
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x14c64
testl %eax, %eax
je 0x157f0
testq %rbx, %rbx
je 0x15808
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x157fc
movq 0x20(%rsp), %rdi
callq 0x4380
xorl %eax, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
movq 0x20(%rsp), %rax
jmp 0x157fc
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__tga_read_rgb16(stbi__context*, unsigned char*)
void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
{
   stbi__uint16 px = stbi__get16le(s);
   stbi__uint16 fiveBitMask = 31;
   // we have 3 channels with 5bits each
   int r = (px >> 10) & fiveBitMask;
   int g = (px >> 5) & fiveBitMask;
   int b = px & fiveBitMask;
   // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
   out[0] = (r * 255)/31;
   out[1] = (g * 255)/31;
   out[2] = (b * 255)/31;

   // some people claim that the most significant bit might be used for alpha
   // (possibly if an alpha-bit is set in the "image descriptor byte")
   // but that only made 16bit test images completely translucent..
   // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x158c8
movl %eax, %ecx
shrl $0xa, %ecx
andl $0x1f, %ecx
movl %ecx, %edx
shll $0x8, %edx
subl %ecx, %edx
movl $0xffff, %ecx           # imm = 0xFFFF
andl %ecx, %edx
imull $0x2109, %edx, %edx     # imm = 0x2109
shrl $0x12, %edx
movb %dl, (%rbx)
movl %eax, %edx
shrl $0x5, %edx
andl $0x1f, %edx
movl %edx, %esi
shll $0x8, %esi
subl %edx, %esi
andl %ecx, %esi
imull $0x2109, %esi, %edx     # imm = 0x2109
shrl $0x12, %edx
movb %dl, 0x1(%rbx)
andl $0x1f, %eax
movl %eax, %edx
shll $0x8, %edx
subl %eax, %edx
andl %ecx, %edx
imull $0x2109, %edx, %eax     # imm = 0x2109
shrl $0x12, %eax
movb %al, 0x2(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_info
STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
{
    FILE *f = stbi__fopen(filename, "rb");
    int result;
    if (!f) return stbi__err("can't fopen", "Unable to open file");
    result = stbi_info_from_file(f, x, y, comp);
    fclose(f);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x16805(%rip), %rsi     # 0x2c1d0
callq 0x4370
testq %rax, %rax
je 0x159f7
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x15a13
movl %eax, %ebx
movq %r12, %rdi
callq 0x42f0
movl %ebx, %eax
jmp 0x15a07
leaq 0x167d5(%rip), %rax     # 0x2c1d3
movq %rax, 0x2198b(%rip)     # 0x37390
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq