LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x1
popq %rbx
leal -0x1(%r14), %eax
cmpl $0xa, %eax
ja 0xdb05
leaq 0x13e84(%rip), %rcx     # 0x2197c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x2c
jmp 0xdb25
cmpl $0x15, %r14d
jne 0xdb6c
pushq $0x45
jmp 0xdb25
pushq $0x23
jmp 0xdb25
pushq $0x2d
jmp 0xdb25
pushq $0x2a
jmp 0xdb25
pushq $0x2b
jmp 0xdb25
pushq $0x2f
jmp 0xdb25
pushq $0x5e
popq %rbp
movq %r15, %rdi
callq 0x4150
testl %eax, %eax
jle 0xdb6c
leal -0x1(%rax), %esi
movl %esi, %ecx
movsbl (%r15,%rcx), %ecx
cmpl %ecx, %ebp
jne 0xdb54
cmpl $0x5, %r14d
jne 0xdb6a
testl %esi, %esi
je 0xdb54
movl %eax, %eax
cmpb $0x29, -0x2(%r15,%rax)
je 0xdb6a
movl %esi, %eax
cmpb $0x29, %cl
jne 0xdb2e
movq %r15, %rdi
callq 0xdaa8
cmpl $-0x1, %eax
jne 0xdb2e
jmp 0xdb6c
movl %esi, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4150
testq %rax, %rax
je 0xdc53
movq %rax, %r15
leaq (%r14,%rax), %r12
cmpb $0x28, (%r14)
jne 0xdbc7
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0xda55
cltq
decq %r15
cmpq %rax, %r15
jne 0xdbc9
leaq 0x1(%r14), %rdi
decq %r12
movb $0x1, %bpl
jmp 0xdbcc
xorl %ebp, %ebp
movq %r14, %rdi
cmpq %r12, %rdi
je 0xdc3d
cmpb $0x20, (%rdi)
jne 0xdbf0
leaq 0x1(%rdi), %rax
cmpq %r12, %rdi
jae 0xdbe7
cmpb $0x20, (%rdi)
movq %rax, %rdi
je 0xdbd6
decq %rax
movb $0x1, %bpl
movq %rax, %rdi
cmpq %r12, %rdi
je 0xdc3d
cmpb $0x20, -0x1(%r12)
jne 0xdc14
movq %r12, %rax
movb $0x1, %bpl
cmpq %rdi, %r12
jbe 0xdc17
leaq -0x1(%rax), %r12
cmpb $0x20, -0x1(%rax)
je 0xdbfd
jmp 0xdc17
movq %r12, %rax
movb $0x0, (%rax)
callq 0xbac0
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xdc2f
callq 0x43e0
movq %r14, (%rbx)
testb %bpl, %bpl
jne 0xdb87
jmp 0xdc53
movq %r14, %rdi
callq 0x43e0
pushq $0x1
popq %rdi
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_O2/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 %r12d, %r12d
testl %esi, %esi
js 0xdc8b
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %r15
callq 0x4150
cmpl %ebp, %eax
jge 0xdc9d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
testl %r14d, %r14d
cmovlel %ebx, %r14d
xorl %r12d, %r12d
cmpq %rbx, %r14
je 0xdc8b
movq (%rsp), %rax
movq (%rax,%rbx,8), %rax
movq (%rax), %r13
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0xbb9a
testb %al, %al
je 0xdcdc
movq %r13, %rdi
callq 0x4150
cmpl %eax, %r12d
cmovgl %r12d, %eax
movl %eax, %r12d
incq %rbx
jmp 0xdca9
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13d98(%rip), %rdx     # 0x21a89
callq 0xbb9a
pushq $0x3
popq %rbp
testb %al, %al
jne 0xde84
leaq 0x13d8b(%rip), %rdx     # 0x21a93
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13d4f(%rip), %rdx     # 0x21a70
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13d54(%rip), %rdx     # 0x21a8e
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13d21(%rip), %rdx     # 0x21a74
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13d0c(%rip), %rdx     # 0x21a78
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13cf7(%rip), %rdx     # 0x21a7c
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13cdb(%rip), %rdx     # 0x21a79
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
pushq $0x2
popq %rbp
testb %al, %al
jne 0xde84
leaq 0x13cc6(%rip), %rdx     # 0x21a80
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13cb0(%rip), %rdx     # 0x21a83
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
pushq $0x4
popq %rbp
testb %al, %al
jne 0xde84
leaq 0x13c99(%rip), %rdx     # 0x21a88
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13c85(%rip), %rdx     # 0x21a8d
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13c75(%rip), %rdx     # 0x21a92
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13c65(%rip), %rdx     # 0x21a97
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
pushq $0x6
popq %rbp
testb %al, %al
jne 0xde84
leaq 0x13c54(%rip), %rdx     # 0x21a9e
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13c46(%rip), %rdx     # 0x21aa5
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
testb %al, %al
jne 0xde84
leaq 0x13c38(%rip), %rdx     # 0x21aac
movq %r14, %rdi
movl %ebx, %esi
callq 0xbb9a
movzbl %al, %eax
leal (%rax,%rax,4), %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
callq 0xdce1
movl %eax, %r12d
testl %eax, %eax
je 0xdebf
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, (%rsp)
xorl %ebx, %ebx
testl %ebp, %ebp
cmovlel %ebx, %ebp
xorl %r12d, %r12d
cmpq %rbx, %rbp
je 0xdead
movq %rbp, %r14
movq %r13, %rbp
movq (%r13,%rbx,8), %rax
movq 0x80(%rax), %r13
movq (%rsp), %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0xbb9a
testb %al, %al
je 0xdf09
movq %r13, %rdi
callq 0x4150
cmpl %eax, %r12d
cmovgl %r12d, %eax
movl %eax, %r12d
incq %rbx
movq %rbp, %r13
movq %r14, %rbp
jmp 0xdecd
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe01a
testl %eax, %eax
je 0xe048
movq %rbx, %rdi
movl %r13d, %esi
movl %r15d, %edx
movq 0x8(%rsp), %rcx
callq 0xdc64
movl %eax, %r14d
movq %rbx, %rdi
movl %r13d, %esi
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rcx
callq 0xde8b
cmpl %eax, %r14d
jg 0xdff6
movl %eax, %ebp
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x13b03(%rip), %rdx     # 0x21ab2
callq 0xbb9a
pushq $0x2
popq %rcx
movl %ecx, %r14d
testb %al, %al
jne 0xdff6
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x13aea(%rip), %rdx     # 0x21ab5
callq 0xbb9a
pushq $0x2
popq %rcx
movl %ecx, %r14d
testb %al, %al
jne 0xdff6
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x13ad1(%rip), %rdx     # 0x21ab8
callq 0xbb9a
pushq $0x2
popq %rcx
movl %ecx, %r14d
testb %al, %al
je 0xe035
movq %r12, %rdi
movl %r13d, %esi
pushq $0x28
popq %rdx
callq 0xbae3
addl %r14d, %r13d
incl %r13d
movq %r12, %rdi
movl %r13d, %esi
pushq $0x29
popq %rdx
callq 0xbae3
jmp 0xe02d
movq %rbx, %rdi
movl %r13d, %esi
callq 0xda55
movl %eax, %r13d
cmpl $-0x1, %eax
je 0xe048
incl %r13d
jmp 0xdf55
testl %ebp, %ebp
je 0xe02d
addl %ebp, %r13d
decl %r13d
movslq %r13d, %rax
cmpb $0x0, (%rbx,%rax)
jne 0xe02d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
movl %esi, 0x10(%rsp)
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x0, 0xc(%rsp)
xorl %r13d, %r13d
movq (%rbx), %r15
movslq %r14d, %rax
movb (%r15,%rax), %r12b
testb %r12b, %r12b
je 0xe16b
testl %r13d, %r13d
je 0xe0dd
leal -0x3a(%r12), %eax
cmpb $-0xa, %al
setae %al
cmpb $0x2e, %r12b
sete %cl
orb %al, %cl
jne 0xe0dd
movq %rbx, %rdi
movl 0xc(%rsp), %esi
pushq $0x28
popq %rdx
callq 0xbae3
incl %r14d
movq %rbx, %rdi
movl %r14d, %esi
pushq $0x29
popq %rdx
callq 0xbae3
xorl %r13d, %r13d
jmp 0xe163
movq %r15, %rdi
movl %r14d, %esi
movl 0x10(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0xdc64
movl %eax, %ebp
movq %r15, %rdi
movl %r14d, %esi
movl 0x14(%rsp), %edx
movq 0x20(%rsp), %rcx
callq 0xde8b
movl %eax, %ecx
orl %ebp, %ecx
je 0xe11a
cmpl %eax, %ebp
cmovgl %ebp, %eax
addl %eax, %r14d
decl %r14d
jmp 0xe163
cmpb $0x28, %r12b
jne 0xe135
movq %r15, %rdi
movl %r14d, %esi
callq 0xda55
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0xe163
jmp 0xe19e
testl %r13d, %r13d
je 0xe140
pushq $0x1
popq %r13
jmp 0xe163
leal -0x30(%r12), %eax
cmpb $0xa, %al
setb %al
cmpb $0x2e, %r12b
sete %cl
orb %al, %cl
movl 0xc(%rsp), %eax
cmovnel %r14d, %eax
movl %eax, 0xc(%rsp)
movzbl %cl, %r13d
incl %r14d
jmp 0xe088
testl %r13d, %r13d
je 0xe17f
pushq $0x28
popq %rdx
movq %rbx, %rdi
movl 0xc(%rsp), %esi
callq 0xbae3
incl %r14d
pushq $0x29
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xbae3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzbl 0x8(%rdi), %eax
xorl %ebx, %ebx
cmpb 0x8(%rsi), %al
jne 0xf21e
pushq $0x1
popq %rbp
cmpl $0xff, %eax
je 0xf21c
movq %rsi, %r14
movq %rdi, %r15
testl %eax, %eax
jne 0xf1bb
movq 0x10(%r15), %rax
cmpq 0x10(%r14), %rax
jne 0xf21e
movq 0x80(%r15), %rdi
movq 0x80(%r14), %rsi
callq 0xbb58
movzbl %al, %ebx
jmp 0xf21e
leaq 0x18(%r15), %rdi
leaq 0x18(%r14), %rsi
callq 0xcc9d
testl %eax, %eax
jne 0xf21e
movq 0x80(%r15), %rdi
movq 0x80(%r14), %rsi
callq 0xbb58
testb %al, %al
je 0xf21e
movl 0x70(%r15), %r12d
cmpl 0x70(%r14), %r12d
jne 0xf21e
movq 0x78(%r15), %r15
movq 0x78(%r14), %r14
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
xorl %ebx, %ebx
cmpq %r13, %r12
je 0xf21c
movq (%r15,%r13,8), %rdi
movq (%r14,%r13,8), %rsi
callq 0xcc7c
incq %r13
testl %eax, %eax
jne 0xf201
jmp 0xf21e
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf261
movq 0x40(%r14), %r14
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0xbb58
testb %al, %al
je 0xf293
movq 0x8(%r14), %rax
cmpq 0x8(%rbx), %rax
jne 0xf293
movb $0x1, %al
jmp 0xf295
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0xf27a
movq %rbx, %rsi
callq 0xf230
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xf295
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0xf293
movq %rbx, %rsi
callq 0xf230
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xf295
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf2bc
movq 0x50(%r14), %rdi
movq %rbx, %rsi
callq 0xf167
jmp 0xf2f0
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0xf2d5
movq %rbx, %rsi
callq 0xf29e
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xf2f0
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0xf2ee
movq %rbx, %rsi
callq 0xf29e
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xf2f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf301
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x16, 0x24(%rdi)
jne 0xf346
movq 0x50(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf167
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
jne 0xf382
movb $0x1, 0x20(%rbx)
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf2f8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xf37e
jmp 0xf34a
movb $0x1, 0x20(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xf363
movq %r14, %rsi
callq 0xf2f8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xf37e
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xf37c
movq %r14, %rsi
callq 0xf2f8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xf37e
xorl %eax, %eax
movb $0x0, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf425
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x16, %eax
jne 0xf3eb
movq 0x50(%rbx), %r15
movb $0x1, %bpl
cmpb $0x1, 0x8(%r15)
jne 0xf3ed
addq $0x18, %r15
testq %r14, %r14
movq %r14, %rsi
cmoveq %rbx, %rsi
movq %r15, %rdi
callq 0xcb95
movb $0x1, %bpl
testl %eax, %eax
jne 0xf428
testq %r14, %r14
movq %r14, %rsi
cmoveq %rbx, %rsi
movq %r15, %rdi
callq 0xf388
movb $0x1, %bpl
testb %al, %al
jne 0xf428
jmp 0xf3ed
xorl %ebp, %ebp
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xf409
testq %r14, %r14
movq %r14, %rsi
cmoveq %rbx, %rsi
callq 0xf388
testb %al, %al
jne 0xf425
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xf435
testq %r14, %r14
cmoveq %rbx, %r14
movq %r14, %rsi
callq 0xf388
testb %al, %al
je 0xf435
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testb %bpl, %bpl
je 0xf447
movq 0x50(%rbx), %rax
cmpb $-0x1, 0x8(%rax)
movb $0x1, %bpl
je 0xf428
xorl %ebp, %ebp
jmp 0xf428
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf489
movq 0x50(%r14), %r12
cmpb $0x1, 0x8(%r12)
jne 0xf489
addq $0x18, %r12
movq %r12, %rdi
callq 0xf126
cmpl $0x2, %eax
jge 0xf4df
cmpl $0x1, %ebp
je 0xf4a6
cmpl $0x1, %r15d
jne 0xf4ba
cmpl $0x2, %ebp
jl 0xf4ba
movq 0x30(%r14), %r14
testq %r14, %r14
je 0xf4ba
decl %ebp
jmp 0xf462
cmpl $0x1, %r15d
jne 0xf4cf
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0xf4ba
movq %rbx, %rdi
jmp 0xf4d5
movsd 0x1240e(%rip), %xmm0    # 0x218d0
movq %rbx, %rdi
callq 0xca6e
jmp 0xf56e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc9b6
jmp 0xf56e
movl $0x88, %edi
callq 0x4320
movq %rax, %r15
movq %rsp, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xf44c
movq 0x50(%r14), %rax
movl 0x70(%rax), %edx
movq 0x78(%rax), %rcx
movq %rsp, %rsi
movq %r15, %rdi
callq 0xc00a
movq %rsp, %rdi
callq 0xc8b8
movq 0x50(%r14), %rax
movq 0x80(%rax), %r12
movq %r12, %rdi
callq 0x4150
leaq 0xa(%rax), %rdi
callq 0x4040
movq %rax, %r13
leaq 0x12584(%rip), %rsi     # 0x21ac1
movq %rax, %rdi
movq %r12, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x40a0
movq %r15, %rdi
movq %r13, %rsi
callq 0xc1e0
movq %r13, %rdi
callq 0x43e0
movq 0x30(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd96c
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 0xc8b8
jmp 0xf590
movq %rax, %rbx
movl $0x88, %esi
movq %r15, %rdi
callq 0x4330
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf230
testb %al, %al
je 0xf5dc
cmpl $0x3, 0x24(%r12)
jne 0xf5ec
movq %rbx, %rdi
movq %r14, %rsi
jmp 0xf5e2
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc9b6
jmp 0xf67b
movq %rbx, %rdi
callq 0xc3a0
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 0xf643
pushq $0x58
popq %rdi
callq 0x4320
movq %rax, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xf5a6
jmp 0xf646
xorl %r13d, %r13d
movq %r13, 0x28(%rbx)
movq 0x30(%r12), %r13
testq %r13, %r13
je 0xf676
pushq $0x58
popq %rdi
callq 0x4320
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xf5a6
movq %r12, 0x30(%rbx)
jmp 0xf67b
andq $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
pushq $0x58
popq %rsi
movq %r12, %rdi
jmp 0xf6a1
movq %rax, %r14
pushq $0x58
popq %rsi
movq %r13, %rdi
callq 0x4330
jmp 0xf6ab
movq %rax, %r14
movq %rbx, %rdi
callq 0xc8b8
movq %r14, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10777(%rip), %xmm2    # 0x21a60
andpd %xmm0, %xmm2
movsd 0x105fb(%rip), %xmm1    # 0x218f0
ucomisd %xmm2, %xmm1
jbe 0x11308
leaq -0x8(%rax), %rcx
movq %rcx, (%rdi)
andq $0x0, -0x8(%rax)
retq
addq $-0x8, %rax
ucomisd 0x105bc(%rip), %xmm0    # 0x218d0
movq %rax, (%rdi)
jne 0x1131b
jnp 0x1135f
ucomisd 0x105c5(%rip), %xmm2    # 0x218e8
ja 0x1135f
movsd (%rax), %xmm2
movapd 0x1072f(%rip), %xmm3    # 0x21a60
andpd %xmm2, %xmm3
ucomisd %xmm3, %xmm1
jbe 0x11340
andq $0x0, (%rax)
retq
ucomisd 0x10588(%rip), %xmm2    # 0x218d0
jne 0x1134c
jnp 0x1135f
ucomisd 0x10594(%rip), %xmm3    # 0x218e8
ja 0x1135f
mulsd %xmm2, %xmm0
movsd %xmm0, (%rax)
retq
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x106e4(%rip), %xmm2    # 0x21a60
andpd %xmm0, %xmm2
addq $-0x8, %rax
ucomisd 0x1055c(%rip), %xmm2    # 0x218e8
movq %rax, (%rdi)
movsd 0x10539(%rip), %xmm1    # 0x218d0
ja 0x113f3
movsd 0x1054f(%rip), %xmm3    # 0x218f0
ucomisd %xmm2, %xmm3
ja 0x113f3
ucomisd 0x10521(%rip), %xmm0    # 0x218d0
jne 0x113b3
jnp 0x113f3
movsd (%rax), %xmm2
movapd 0x106a1(%rip), %xmm4    # 0x21a60
andpd %xmm2, %xmm4
xorpd %xmm5, %xmm5
ucomisd %xmm4, %xmm3
ja 0x113eb
movsd 0x104fb(%rip), %xmm1    # 0x218d0
ucomisd %xmm1, %xmm2
jne 0x113dd
jnp 0x113f3
ucomisd 0x10503(%rip), %xmm4    # 0x218e8
movapd %xmm2, %xmm5
ja 0x113f3
divsd %xmm0, %xmm5
movapd %xmm5, %xmm1
movsd %xmm1, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11418
jnp 0x11482
movsd (%rcx), %xmm2
ucomisd 0x104ac(%rip), %xmm2    # 0x218d0
jne 0x11428
jnp 0x11473
ucomisd 0x104a0(%rip), %xmm1    # 0x218d0
jne 0x11434
jnp 0x11473
movq %rdi, %rbx
movapd %xmm1, %xmm0
andpd 0x1061d(%rip), %xmm0    # 0x21a60
movapd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x4290
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm0
andpd 0x105fa(%rip), %xmm0    # 0x21a60
ucomisd 0x1048a(%rip), %xmm0    # 0x218f8
jbe 0x11488
movq (%rbx), %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movq %rcx, (%rax)
jmp 0x114df
andq $0x0, (%rax)
jmp 0x114df
xorpd %xmm0, %xmm0
movapd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x114cb
movsd 0xfc60(%rip), %xmm1     # 0x21100
movapd %xmm2, %xmm0
callq 0x4430
movsd 0x8(%rsp), %xmm2
movapd 0x10(%rsp), %xmm1
ucomisd 0x10443(%rip), %xmm0    # 0x21900
jne 0x114c1
jnp 0x114cb
movsd 0x10407(%rip), %xmm0    # 0x218d0
jmp 0x114d8
movapd %xmm1, %xmm0
movapd %xmm2, %xmm1
callq 0x45b0
movq (%rbx), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11505
jnp 0x1155b
ucomisd 0x103c3(%rip), %xmm1    # 0x218d0
jne 0x11511
jnp 0x1155b
movsd (%rcx), %xmm2
ucomisd 0x103b3(%rip), %xmm2    # 0x218d0
jne 0x11521
jnp 0x1155b
movq %rdi, %rbx
movapd 0x10534(%rip), %xmm0    # 0x21a60
movapd %xmm1, (%rsp)
andpd %xmm1, %xmm0
movapd %xmm2, 0x10(%rsp)
callq 0x4290
movapd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
movsd 0x103b6(%rip), %xmm1    # 0x21908
ucomisd %xmm0, %xmm1
jbe 0x1156d
movq (%rbx), %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movq %rcx, (%rax)
jmp 0x115ee
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jae 0x115c7
movsd 0x10359(%rip), %xmm1    # 0x218d8
movapd (%rsp), %xmm0
callq 0x4430
andpd 0x104cf(%rip), %xmm0    # 0x21a60
ucomisd 0xfb67(%rip), %xmm0     # 0x21100
jne 0x115df
jp 0x115df
movapd 0x10(%rsp), %xmm0
xorpd 0xfb85(%rip), %xmm0     # 0x21130
movsd 0xfb4d(%rip), %xmm1     # 0x21100
divsd (%rsp), %xmm1
callq 0x45b0
xorpd 0xfb6b(%rip), %xmm0     # 0x21130
jmp 0x115e7
movsd 0xfb31(%rip), %xmm1     # 0x21100
divsd (%rsp), %xmm1
movapd %xmm2, %xmm0
callq 0x45b0
jmp 0x115e7
movsd 0x102e9(%rip), %xmm0    # 0x218d0
movq (%rbx), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10459(%rip), %xmm2    # 0x21a60
andpd %xmm1, %xmm2
movsd 0x102dd(%rip), %xmm0    # 0x218f0
ucomisd %xmm2, %xmm0
jbe 0x11627
leaq -0x8(%rax), %rcx
movq %rcx, (%rbx)
andq $0x0, -0x8(%rax)
jmp 0x1169d
addq $-0x8, %rax
ucomisd 0x1029d(%rip), %xmm1    # 0x218d0
movq %rax, (%rbx)
jne 0x1163a
jnp 0x11690
ucomisd 0x102ce(%rip), %xmm2    # 0x21910
ja 0x11690
movsd (%rax), %xmm3
movapd 0x10410(%rip), %xmm2    # 0x21a60
andpd %xmm3, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x11660
andq $0x0, (%rax)
jmp 0x11676
ucomisd 0x10268(%rip), %xmm3    # 0x218d0
jne 0x1166c
jnp 0x11690
ucomisd 0x10274(%rip), %xmm2    # 0x218e8
ja 0x11690
movsd 0x10262(%rip), %xmm0    # 0x218e0
callq 0x45b0
movq (%rbx), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x1169d
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: BCSimple(void (**&)(double*&), void (**)(double*&), double**&, double**, double*&, double*, RFunction**&, RFunction**, void (*)(double*&))
void BCSimple(pfoncld*&pf,pfoncld*pf1,double**&pv,double**pv1,
	double*&pp,double*pp1,RFunction**&prf,RFunction**prf1,pfoncld f)
{
  pfoncld*pf3,*pf4=pf1;long n;
  for(n=0;*pf4!=NULL;pf4++,n++);
  pf=new pfoncld[n+2];
  for(pf4=pf1,pf3=pf;*pf4!=NULL;pf3++,pf4++)*pf3=*pf4;
  *pf3++=f;*pf3=NULL;//delete[]pf1;
  double**pv3,**pv4=pv1;
  for(n=0;*pv4!=NULL;pv4++,n++);
  pv=new double*[n+1];
  for(pv3=pv,pv4=pv1;*pv4!=NULL;pv3++,pv4++)*pv3=*pv4;
  *pv3=NULL;//delete[]pv1;
  double*pp3,*pp4=pp1;
  for(n=0;*pp4!=ErrVal;pp4++,n++);
  pp=new double[n+1];
  for(pp3=pp,pp4=pp1;*pp4!=ErrVal;pp3++,pp4++)*pp3=0;
  *pp3=ErrVal;//delete[]pp1;
  RFunction**prf3,**prf4=prf1;
  for(n=0;*prf4!=NULL;prf4++,n++);
  prf=new RFunction*[n+1];
  for(prf3=prf,prf4=prf1;*prf4!=NULL;prf3++,prf4++)*prf3=*prf4;
  *prf3=NULL;//delete[]prf1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
pushq $0x10
popq %rdi
movq 0x48(%rsp), %r14
xorl %eax, %eax
cmpq $0x0, (%r13,%rax,8)
je 0x11c8f
incq %rax
addq $0x8, %rdi
jmp 0x11c7e
movabsq $0x1ffffffffffffffe, %rcx # imm = 0x1FFFFFFFFFFFFFFE
decq %rcx
cmpq %rcx, %rax
pushq $-0x1
popq %rax
cmovaq %rax, %rdi
callq 0x4040
movq %rax, (%rbp)
xorl %ecx, %ecx
movq (%r13,%rcx), %rdx
testq %rdx, %rdx
je 0x11cc5
movq %rdx, (%rax,%rcx)
addq $0x8, %rcx
jmp 0x11cb1
movq 0x50(%rsp), %rdx
movq %rdx, (%rax,%rcx)
andq $0x0, 0x8(%rax,%rcx)
xorl %eax, %eax
movq %r15, %rcx
movabsq $0x1ffffffffffffffe, %r13 # imm = 0x1FFFFFFFFFFFFFFE
pushq $-0x1
popq %rbp
cmpq $0x0, (%rcx)
je 0x11cf5
addq $0x8, %rcx
incq %rax
jmp 0x11ce6
cmpq %r13, %rax
leaq 0x8(,%rax,8), %rdi
cmovaq %rbp, %rdi
callq 0x4040
movq %rax, (%r12)
xorl %ecx, %ecx
movq (%r15,%rcx), %rdx
testq %rdx, %rdx
je 0x11d22
movq %rdx, (%rax,%rcx)
addq $0x8, %rcx
jmp 0x11d0f
andq $0x0, (%rax,%rcx)
xorl %eax, %eax
movq %rbx, %rcx
movsd (%rcx), %xmm0
ucomisd 0xfb98(%rip), %xmm0     # 0x218d0
jne 0x11d3c
jnp 0x11d45
addq $0x8, %rcx
incq %rax
jmp 0x11d2c
cmpq %r13, %rax
leaq 0x8(,%rax,8), %rdi
cmovaq %rbp, %rdi
callq 0x4040
movsd 0xfb6f(%rip), %xmm1     # 0x218d0
movq (%rsp), %rcx
movq %rax, (%rcx)
xorl %ecx, %ecx
movsd (%rbx,%rcx), %xmm0
ucomisd %xmm1, %xmm0
jne 0x11d77
jnp 0x11d82
andq $0x0, (%rax,%rcx)
addq $0x8, %rcx
jmp 0x11d6a
movabsq $0x7fefffffffffffff, %rdx # imm = 0x7FEFFFFFFFFFFFFF
movq %rdx, (%rax,%rcx)
xorl %eax, %eax
movq %r14, %rcx
cmpq $0x0, (%rcx)
je 0x11da4
addq $0x8, %rcx
incq %rax
jmp 0x11d95
cmpq %r13, %rax
leaq 0x8(,%rax,8), %rdi
cmovaq %rbp, %rdi
callq 0x4040
movq 0x40(%rsp), %rcx
movq %rax, (%rcx)
xorl %ecx, %ecx
movq (%r14,%rcx), %rdx
testq %rdx, %rdx
je 0x11dd5
movq %rdx, (%rax,%rcx)
addq $0x8, %rcx
jmp 0x11dc2
andq $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x100e0(%rip), %rsi     # 0x220d0
callq 0x4390
testq %rax, %rax
je 0x12021
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x1203b
movq %rax, %rbx
movq %r13, %rdi
callq 0x4310
movq %rbx, %rax
jmp 0x12031
leaq 0x100ab(%rip), %rax     # 0x220d3
movq %rax, 0x1d3a1(%rip)     # 0x2f3d0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x120b6
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x120c5
movq %rax, %r14
testq %rax, %rax
je 0x120a1
movl 0xb8(%rsp), %eax
subl 0xc0(%rsp), %eax
movslq %eax, %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x4370
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_O2/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, %r14
movq %rdx, %r15
movq %rsi, %r12
callq 0x136f2
movq %rax, (%rsp)
testq %rax, %rax
je 0x1218c
cmpl $0x0, 0x1d2e3(%rip)     # 0x2f3d8
je 0x1218c
movslq (%r12), %rax
movl (%r15), %edx
testl %ebx, %ebx
jne 0x12109
movl (%r14), %ebx
movl %edx, %esi
sarl %esi
xorl %edi, %edi
testl %ebx, %ebx
movl $0x0, %r8d
cmovgl %ebx, %r8d
movslq %ebx, %r9
testl %eax, %eax
movl $0x0, %r10d
cmovgl %eax, %r10d
testl %esi, %esi
cmovlel %edi, %esi
decl %edx
imull %eax, %edx
movq %rax, %r11
imulq %r9, %r11
movq (%rsp), %rbx
cmpq %rsi, %rdi
je 0x1218c
movslq %edx, %r14
imulq %r9, %r14
addq (%rsp), %r14
movq %rbx, %r15
xorl %r12d, %r12d
cmpq %r10, %r12
je 0x12182
xorl %r13d, %r13d
cmpq %r13, %r8
je 0x12177
movb (%r15,%r13), %bpl
movb (%r14,%r13), %cl
movb %cl, (%r15,%r13)
movb %bpl, (%r14,%r13)
incq %r13
jmp 0x1215d
incq %r12
addq %r9, %r14
addq %r9, %r15
jmp 0x12155
incq %rdi
subl %eax, %edx
addq %r11, %rbx
jmp 0x1213f
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_O2/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__start_callbacks(stbi__context*, stbi_io_callbacks*, void*)
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
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rdi)
movups (%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movq %rdx, 0x28(%rdi)
movabsq $0x8000000001, %rax     # imm = 0x8000000001
movq %rax, 0x30(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, 0xc8(%rdi)
callq 0x17a72
movq 0xc0(%rbx), %rax
movq %rax, 0xd0(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0xfb27(%rip), %rsi      # 0x220d0
callq 0x4390
testq %rax, %rax
je 0x125da
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x125f4
movq %rax, %rbx
movq %r13, %rdi
callq 0x4310
movq %rbx, %rax
jmp 0x125ea
leaq 0xfaf2(%rip), %rax      # 0x220d3
movq %rax, 0x1cde8(%rip)     # 0x2f3d0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rax)
andl $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 0x1268a
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
leaq 0xf9eb(%rip), %rsi      # 0x220d0
callq 0x4390
testq %rax, %rax
je 0x12708
movq %rax, %rbx
movq %rax, %rdi
callq 0x12711
movl %eax, %ebp
movq %rbx, %rdi
callq 0x4310
movl %ebp, %eax
jmp 0x1270a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4420
testq %rax, %rax
je 0x1280b
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movslq %r15d, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
pushq $0x1
popq %rcx
movq %rax, %rsi
movl %ebp, %edx
movl %ecx, %r8d
callq 0x12822
testl %eax, %eax
je 0x12801
testq %rbx, %rbx
je 0x1281b
movl 0x20(%rsp), %ecx
movq 0x28(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x1280d
movq 0x28(%rsp), %rdi
callq 0x43a0
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rsp), %rax
jmp 0x1280d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4420
testq %rax, %rax
je 0x12ed1
movq %rsp, %rdi
movq %r15, (%rdi)
movslq %r12d, %rcx
addq %r15, %rcx
movq %rcx, 0x8(%rdi)
pushq $0x1
popq %rcx
movq %rax, %rsi
movl %r14d, %edx
movl %ebp, %r8d
callq 0x12822
testl %eax, %eax
je 0x12ec7
testq %rbx, %rbx
je 0x12ee3
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x12ed3
movq 0x20(%rsp), %rdi
callq 0x43a0
xorl %eax, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rax
jmp 0x12ed3
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4420
testq %rax, %rax
je 0x12f9c
movq %rsp, %rdi
movq %r14, (%rdi)
movslq %ebp, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
pushq $0x1
popq %rcx
movq %rax, %rsi
movl $0x4000, %edx           # imm = 0x4000
xorl %r8d, %r8d
callq 0x12822
testl %eax, %eax
je 0x12f92
testq %rbx, %rbx
je 0x12faa
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x12f9e
movq 0x20(%rsp), %rdi
callq 0x43a0
xorl %eax, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
movq 0x20(%rsp), %rax
jmp 0x12f9e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13054
movl %eax, %ecx
shrl $0xa, %eax
andl $0x1f, %eax
imull $0xff, %eax, %eax
movw $0x1f, %si
xorl %edx, %edx
divw %si
movb %al, (%rbx)
movl %ecx, %eax
shrl $0x5, %eax
andl $0x1f, %eax
imull $0xff, %eax, %eax
xorl %edx, %edx
divw %si
movb %al, 0x1(%rbx)
andl $0x1f, %ecx
imull $0xff, %ecx, %eax
xorl %edx, %edx
divw %si
movb %al, 0x2(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf03f(%rip), %rsi      # 0x220d0
callq 0x4390
testq %rax, %rax
je 0x130bd
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x130d9
movl %eax, %ebx
movq %r12, %rdi
callq 0x4310
movl %ebx, %eax
jmp 0x130cd
leaq 0xf00f(%rip), %rax      # 0x220d3
movq %rax, 0x1c305(%rip)     # 0x2f3d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_info_from_file
STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
{
   int r;
   stbi__context s;
   long pos = ftell(f);
   stbi__start_file(&s, f);
   r = stbi__info_main(&s,x,y,comp);
   fseek(f,pos,SEEK_SET);
   return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x4030
movq %rax, %r13
movq %rsp, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x120b6
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x13140
movl %eax, %ebx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4370
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq