LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdc5e
movl $0x16, 0x24(%rbx)
movq %r15, 0x50(%rbx)
movl $0x58, %edi
callq 0x4310
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xe2ba
movq %r15, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x58, %esi
movq %r15, %rdi
callq 0x4320
jmp 0xf819
movq %rax, %r14
movq %rbx, %rdi
callq 0xe18c
movq %r14, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf902
movslq %ebx, %rax
addq %r14, %rax
incq %rax
movl $0x1, %ecx
movzbl (%rax), %edx
cmpl $0x28, %edx
je 0xf8f5
cmpl $0x29, %edx
je 0xf8f1
testl %edx, %edx
jne 0xf8f7
jmp 0xf902
decl %ecx
jmp 0xf8f7
incl %ecx
incl %ebx
incq %rax
testl %ecx, %ecx
jne 0xf8de
jmp 0xf907
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf944
movl %esi, %ecx
movl $0x1, %edx
testq %rcx, %rcx
jle 0xf944
movzbl -0x1(%rdi,%rcx), %esi
cmpl $0x28, %esi
je 0xf939
cmpl $0x29, %esi
jne 0xf93b
incl %edx
jmp 0xf93b
decl %edx
decq %rcx
testl %edx, %edx
jne 0xf921
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %eax
cmpl $0xa, %eax
ja 0xf96d
leaq 0x1cfef(%rip), %rcx     # 0x2c94c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2c, %ebp
jmp 0xf9a5
cmpl $0x15, %ebx
jne 0xfa23
movl $0x45, %ebp
jmp 0xf9a5
movl $0x23, %ebp
jmp 0xf9a5
movl $0x2d, %ebp
jmp 0xf9a5
movl $0x2a, %ebp
jmp 0xf9a5
movl $0x2b, %ebp
jmp 0xf9a5
movl $0x2f, %ebp
jmp 0xf9a5
movl $0x5e, %ebp
movq %r14, %rdi
callq 0x4170
movq %rax, %rcx
testl %ecx, %ecx
jle 0xfa23
leal -0x1(%rcx), %edx
movsbl (%r14,%rdx), %eax
cmpl %eax, %ebp
jne 0xf9d3
cmpl $0x5, %ebx
jne 0xfa2a
testl %edx, %edx
je 0xf9d3
movl %ecx, %esi
cmpb $0x29, -0x2(%r14,%rsi)
je 0xfa2a
cmpb $0x29, %al
jne 0xfa1d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl $0x1, %ecx
je 0xfa16
movl $0x1, %ecx
testq %rdx, %rdx
jle 0xfa11
movzbl -0x1(%r14,%rdx), %esi
cmpl $0x28, %esi
je 0xfa04
cmpl $0x29, %esi
jne 0xfa06
incl %ecx
jmp 0xfa06
decl %ecx
decq %rdx
testl %ecx, %ecx
jne 0xf9eb
movl %edx, %esi
jmp 0xfa16
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %esi, %edx
cmpl $-0x1, %esi
je 0xfa2c
movl %edx, %ecx
testl %edx, %edx
jg 0xf9b4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xfa2c
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 (%rbx), %r14
movq %r14, %rdi
callq 0x4170
testq %rax, %rax
je 0xfb0d
movq %rax, %r15
leaq (%r14,%rax), %r12
cmpb $0x28, (%r14)
jne 0xfa7f
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0xf8bc
cltq
decq %r15
cmpq %rax, %r15
jne 0xfa81
leaq 0x1(%r14), %rdi
decq %r12
movb $0x1, %bpl
jmp 0xfa84
xorl %ebp, %ebp
movq %r14, %rdi
cmpq %r12, %rdi
je 0xfaf5
cmpb $0x20, (%rdi)
jne 0xfaa8
leaq 0x1(%rdi), %rax
cmpq %r12, %rdi
jae 0xfa9f
cmpb $0x20, (%rdi)
movq %rax, %rdi
je 0xfa8e
decq %rax
movb $0x1, %bpl
movq %rax, %rdi
cmpq %r12, %rdi
je 0xfaf5
cmpb $0x20, -0x1(%r12)
jne 0xfacc
movq %r12, %rax
movb $0x1, %bpl
cmpq %rdi, %r12
jbe 0xfacf
leaq -0x1(%rax), %r12
cmpb $0x20, -0x1(%rax)
je 0xfab5
jmp 0xfacf
movq %r12, %rax
movb $0x0, (%rax)
callq 0xd1e5
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xfae7
callq 0x43d0
movq %r14, (%rbx)
testb %bpl, %bpl
jne 0xfa3c
jmp 0xfb0d
movq %r14, %rdi
callq 0x43d0
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_O1/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 0xfb8e
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 0xfb8e
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 0xd2ee
testb %al, %al
je 0xfb86
movq %r12, %rdi
callq 0x4170
cmpl %eax, %r15d
cmovgl %r15d, %eax
movl %eax, %r15d
incq %rbx
cmpq %rbx, %r13
jne 0xfb58
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_O1/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 0x1ceb9(%rip), %rdx     # 0x2ca69
callq 0xd2ee
movl $0x3, %ebp
testb %al, %al
jne 0xfd4b
leaq 0x1ceaa(%rip), %rdx     # 0x2ca73
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1ce6e(%rip), %rdx     # 0x2ca50
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1ce73(%rip), %rdx     # 0x2ca6e
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1ce40(%rip), %rdx     # 0x2ca54
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1ce2b(%rip), %rdx     # 0x2ca58
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1ce16(%rip), %rdx     # 0x2ca5c
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1cdfa(%rip), %rdx     # 0x2ca59
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
movl $0x2, %ebp
testb %al, %al
jne 0xfd4b
leaq 0x1cde3(%rip), %rdx     # 0x2ca60
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1cdcd(%rip), %rdx     # 0x2ca63
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
movl $0x4, %ebp
testb %al, %al
jne 0xfd4b
leaq 0x1cdb4(%rip), %rdx     # 0x2ca68
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1cda0(%rip), %rdx     # 0x2ca6d
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1cd90(%rip), %rdx     # 0x2ca72
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1cd80(%rip), %rdx     # 0x2ca77
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
movl $0x6, %ebp
testb %al, %al
jne 0xfd4b
leaq 0x1cd6d(%rip), %rdx     # 0x2ca7e
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1cd5f(%rip), %rdx     # 0x2ca85
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
testb %al, %al
jne 0xfd4b
leaq 0x1cd51(%rip), %rdx     # 0x2ca8c
movq %r14, %rdi
movl %ebx, %esi
callq 0xd2ee
movzbl %al, %eax
leal (%rax,%rax,4), %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfba0
movl %eax, %r15d
testl %eax, %eax
jne 0xfdc1
testl %r12d, %r12d
jle 0xfdbe
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 0xd2ee
testb %al, %al
je 0xfdb4
movq %r12, %rdi
callq 0x4170
cmpl %eax, %r15d
cmovgl %r15d, %eax
movl %eax, %r15d
incq %rbx
cmpq %rbx, %r13
jne 0xfd82
jmp 0xfdc1
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_O1/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 0xfecf
testl %eax, %eax
je 0xfefe
movq %rbx, %rdi
movl %r13d, %esi
movl %r15d, %edx
movq 0x8(%rsp), %rcx
callq 0xfb1e
movl %eax, %ebp
movq %rbx, %rdi
movl %r13d, %esi
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rcx
callq 0xfd52
cmpl %eax, %ebp
jg 0xfea7
movl %eax, %r14d
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x1cc25(%rip), %rdx     # 0x2ca92
callq 0xd2ee
movl $0x2, %ebp
testb %al, %al
jne 0xfea7
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x1cc0d(%rip), %rdx     # 0x2ca95
callq 0xd2ee
testb %al, %al
jne 0xfea7
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x1cbfa(%rip), %rdx     # 0x2ca98
callq 0xd2ee
testb %al, %al
je 0xfeea
movq %r12, %rdi
movl %r13d, %esi
movl $0x28, %edx
callq 0xd208
addl %ebp, %r13d
incl %r13d
movq %r12, %rdi
movl %r13d, %esi
movl $0x29, %edx
callq 0xd208
jmp 0xfee2
movq %rbx, %rdi
movl %r13d, %esi
callq 0xf8bc
movl %eax, %r13d
cmpl $-0x1, %eax
je 0xfefe
incl %r13d
jmp 0xfe14
testl %r14d, %r14d
je 0xfee2
addl %r14d, %r13d
decl %r13d
movslq %r13d, %rax
cmpb $0x0, (%rbx,%rax)
jne 0xfee2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq (%rdi), %r14
movb (%r14), %r13b
testb %r13b, %r13b
je 0x10045
xorl %r12d, %r12d
movl $0x0, 0xc(%rsp)
xorl %ebp, %ebp
testl %r12d, %r12d
je 0xff8f
leal -0x3a(%r13), %eax
cmpb $-0xa, %al
setae %al
cmpb $0x2e, %r13b
sete %cl
orb %al, %cl
jne 0xff8f
movq %rbx, %rdi
movl 0xc(%rsp), %esi
movl $0x28, %edx
callq 0xd208
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
movl $0x29, %edx
callq 0xd208
xorl %r12d, %r12d
movl %ebp, %r15d
jmp 0xfffa
movq %r14, %rdi
movl %ebp, %esi
movl 0x10(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0xfb1e
movl %eax, %r15d
movq %r14, %rdi
movl %ebp, %esi
movl 0x14(%rsp), %edx
movq 0x20(%rsp), %rcx
callq 0xfd52
movl %eax, %ecx
orl %r15d, %ecx
je 0xffcf
cmpl %eax, %r15d
cmovgl %r15d, %eax
leal (%rax,%rbp), %r15d
decl %r15d
jmp 0xfffa
cmpb $0x28, %r13b
jne 0xffec
movq %r14, %rdi
movl %ebp, %esi
callq 0xf8bc
movl %eax, %r15d
cmpl $-0x1, %eax
jne 0xfffa
jmp 0x10088
testl %r12d, %r12d
je 0x10013
movl %ebp, %r15d
movl $0x1, %r12d
movslq %r15d, %rbp
movq (%rbx), %r14
movb 0x1(%r14,%rbp), %r13b
incq %rbp
testb %r13b, %r13b
jne 0xff4c
jmp 0x10039
leal -0x30(%r13), %eax
cmpb $0xa, %al
setb %al
cmpb $0x2e, %r13b
sete %cl
orb %al, %cl
movl 0xc(%rsp), %eax
cmovnel %ebp, %eax
movl %eax, 0xc(%rsp)
movzbl %cl, %r12d
jmp 0xff8a
testl %r12d, %r12d
sete %al
addl $0x2, %r15d
jmp 0x10055
movb $0x1, %al
movl $0x0, 0xc(%rsp)
movl $0x1, %r15d
testb %al, %al
jne 0x1006a
movq %rbx, %rdi
movl 0xc(%rsp), %esi
movl $0x28, %edx
callq 0xd208
movq %rbx, %rdi
movl %r15d, %esi
movl $0x29, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd208
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x111f4
cmpl $0xff, %eax
je 0x111ef
movq %rsi, %r14
movq %rdi, %r15
testl %eax, %eax
jne 0x11182
movq 0x10(%r15), %rax
cmpq 0x10(%r14), %rax
jne 0x111f4
movq 0x80(%r15), %rdi
movq 0x80(%r14), %rsi
callq 0xd2a8
movzbl %al, %ebx
jmp 0x111f4
leaq 0x18(%r15), %rdi
leaq 0x18(%r14), %rsi
callq 0xe5d0
testl %eax, %eax
jne 0x111f4
movq 0x80(%r15), %rdi
movq 0x80(%r14), %rsi
callq 0xd2a8
testb %al, %al
je 0x111f4
movl 0x70(%r15), %r12d
cmpl 0x70(%r14), %r12d
jne 0x111f4
testl %r12d, %r12d
jle 0x111ef
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 0x111f4
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0xd2a8
testb %al, %al
je 0x111f4
incq %r13
cmpq %r13, %r12
jne 0x111c6
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11231
movq 0x40(%r14), %r14
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0xd2a8
testb %al, %al
je 0x11263
movq 0x8(%r14), %rax
cmpq 0x8(%rbx), %rax
jne 0x11263
movb $0x1, %al
jmp 0x11265
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x1124a
movq %rbx, %rsi
callq 0x11200
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x11265
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x11263
movq %rbx, %rsi
callq 0x11200
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x11265
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1128c
movq 0x50(%r14), %rdi
movq %rbx, %rsi
callq 0x1112f
jmp 0x112c0
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x112a5
movq %rbx, %rsi
callq 0x1126e
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x112c0
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x112be
movq %rbx, %rsi
callq 0x1126e
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x112c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x112d1
xorl %eax, %eax
retq
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x24(%rdi), %ebp
cmpl $0x16, %ebp
jne 0x1131a
movq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x1112f
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
jne 0x11356
movb $0x1, 0x20(%rbx)
cmpl $0x16, %ebp
jne 0x1131e
movq 0x50(%rbx), %rdi
addq $0x18, %rdi
movq %r14, %rsi
callq 0x112c8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x11352
jmp 0x1131e
movb $0x1, 0x20(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x11337
movq %r14, %rsi
callq 0x112c8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x11352
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x11350
movq %r14, %rsi
callq 0x112c8
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x11352
xorl %eax, %eax
movb $0x0, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %ebp
movb $0x1, %bl
testl %ebp, %ebp
je 0x1140b
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x16, %ebp
jne 0x1139c
movq 0x50(%r14), %rdi
cmpb $0x1, 0x8(%rdi)
jne 0x1139c
addq $0x18, %rdi
testq %r15, %r15
movq %r15, %rsi
cmoveq %r14, %rsi
callq 0xe4b8
testl %eax, %eax
jne 0x1140b
cmpl $0x16, %ebp
jne 0x113c2
movq 0x50(%r14), %rdi
cmpb $0x1, 0x8(%rdi)
jne 0x113c2
addq $0x18, %rdi
testq %r15, %r15
movq %r15, %rsi
cmoveq %r14, %rsi
callq 0x1135c
testb %al, %al
jne 0x1140b
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x113de
testq %r15, %r15
movq %r15, %rsi
cmoveq %r14, %rsi
callq 0x1135c
testb %al, %al
jne 0x1140b
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x113fa
testq %r15, %r15
cmoveq %r14, %r15
movq %r15, %rsi
callq 0x1135c
testb %al, %al
jne 0x1140b
cmpl $0x16, %ebp
jne 0x11409
movq 0x50(%r14), %rax
cmpb $-0x1, 0x8(%rax)
je 0x1140b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11459
movq 0x50(%r14), %r12
cmpb $0x1, 0x8(%r12)
jne 0x11459
addq $0x18, %r12
movq %r12, %rdi
callq 0x110ec
cmpl $0x2, %eax
jge 0x114da
cmpl $0x1, %ebp
je 0x11476
cmpl $0x1, %r15d
jne 0x1148a
cmpl $0x2, %ebp
jl 0x1148a
movq 0x30(%r14), %r14
testq %r14, %r14
je 0x1148a
decl %ebp
jmp 0x1142e
cmpl $0x1, %r15d
jne 0x114ca
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0x1148a
movq %rbx, %rdi
jmp 0x114d0
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 0xdc5e
jmp 0x1156a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe2ba
jmp 0x1156a
movl $0x88, %edi
callq 0x4310
movq %rax, %r15
movq %rsp, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x11418
movq 0x50(%r14), %rax
movl 0x70(%rax), %edx
movq 0x78(%rax), %rcx
movq %rsp, %rsi
movq %r15, %rdi
callq 0xd85c
movq %rsp, %rdi
callq 0xe18c
movq 0x50(%r14), %r13
movq 0x80(%r13), %rdi
callq 0x4170
leaq 0xa(%rax), %rdi
callq 0x4040
movq %rax, %r12
movq 0x80(%r13), %rdx
leaq 0x1b565(%rip), %rsi     # 0x2caa1
movq %rax, %rdi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x40b0
movq %r15, %rdi
movq %r12, %rsi
callq 0xda38
movq %r12, %rdi
callq 0x43d0
movq 0x30(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf78e
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 0xe18c
jmp 0x1158c
movq %rax, %rbx
movl $0x88, %esi
movq %r15, %rdi
callq 0x4320
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11200
testb %al, %al
je 0x115d8
cmpl $0x3, 0x24(%r12)
jne 0x115e8
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x115de
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe2ba
jmp 0x116b9
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 0xdc5e
movl 0x24(%r12), %eax
movl %eax, 0x24(%rbx)
movq 0x40(%r12), %rax
movq %rax, 0x40(%rbx)
movq 0x48(%r12), %rax
movq %rax, 0x48(%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 0x1167c
movl $0x58, %edi
callq 0x4310
movq %rax, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x115a2
jmp 0x1167f
xorl %r13d, %r13d
movq %r13, 0x28(%rbx)
movq 0x30(%r12), %r13
testq %r13, %r13
je 0x116b1
movl $0x58, %edi
callq 0x4310
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x115a2
movq %r12, 0x30(%rbx)
jmp 0x116b9
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 0x116e3
movq %rax, %r14
movl $0x58, %esi
movq %r13, %rdi
callq 0x4320
jmp 0x116ed
movq %rax, %r14
movq %rbx, %rdi
callq 0xe18c
movq %r14, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x192c3(%rip), %xmm2    # 0x2ca40
andpd %xmm0, %xmm2
movsd 0x1912f(%rip), %xmm1    # 0x2c8b8
ucomisd %xmm2, %xmm1
jbe 0x1379f
leaq -0x8(%rax), %rcx
movq %rcx, (%rdi)
movq $0x0, -0x8(%rax)
retq
addq $-0x8, %rax
ucomisd 0x190fd(%rip), %xmm0    # 0x2c8a8
movq %rax, (%rdi)
jne 0x137b2
jnp 0x137f9
ucomisd 0x190f6(%rip), %xmm2    # 0x2c8b0
ja 0x137f9
movsd (%rax), %xmm2
movapd 0x19278(%rip), %xmm3    # 0x2ca40
andpd %xmm2, %xmm3
ucomisd %xmm3, %xmm1
jbe 0x137da
movq $0x0, (%rax)
retq
ucomisd 0x190c6(%rip), %xmm2    # 0x2c8a8
jne 0x137e6
jnp 0x137f9
ucomisd 0x190c2(%rip), %xmm3    # 0x2c8b0
ja 0x137f9
mulsd %xmm2, %xmm0
movsd %xmm0, (%rax)
retq
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movsd (%rcx), %xmm1
movapd 0x1922a(%rip), %xmm3    # 0x2ca40
andpd %xmm1, %xmm3
ucomisd 0x1908e(%rip), %xmm3    # 0x2c8b0
leaq -0x8(%rcx), %rax
movq %rax, (%rdi)
movsd 0x19077(%rip), %xmm0    # 0x2c8a8
ja 0x1388f
movsd 0x1907d(%rip), %xmm2    # 0x2c8b8
ucomisd %xmm3, %xmm2
ja 0x1388f
ucomisd 0x1905f(%rip), %xmm1    # 0x2c8a8
jne 0x1384d
jnp 0x1388f
movsd (%rax), %xmm3
movapd 0x191e7(%rip), %xmm1    # 0x2ca40
andpd %xmm3, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x1386c
movq $0x0, (%rax)
jmp 0x13886
movsd 0x19034(%rip), %xmm0    # 0x2c8a8
ucomisd %xmm0, %xmm3
jne 0x1387c
jnp 0x1388f
ucomisd 0x1902c(%rip), %xmm1    # 0x2c8b0
ja 0x1388f
movsd -0x8(%rcx), %xmm0
divsd (%rcx), %xmm0
movsd %xmm0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
leaq -0x8(%rax), %rcx
movq %rcx, (%rdi)
movsd -0x8(%rax), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x138b4
jnp 0x13924
movq %rdi, %rbx
movsd (%rax), %xmm2
ucomisd 0x18fe5(%rip), %xmm2    # 0x2c8a8
jne 0x138c7
jnp 0x13912
ucomisd 0x18fd9(%rip), %xmm1    # 0x2c8a8
jne 0x138d3
jnp 0x13912
movapd %xmm1, %xmm0
andpd 0x19161(%rip), %xmm0    # 0x2ca40
movapd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x4290
movsd 0x8(%rsp), %xmm2
movapd 0x10(%rsp), %xmm1
mulsd %xmm2, %xmm0
andpd 0x19138(%rip), %xmm0    # 0x2ca40
ucomisd 0x18fb0(%rip), %xmm0    # 0x2c8c0
jbe 0x1392d
movq (%rbx), %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movq %rcx, (%rax)
jmp 0x1397e
movq $0x0, (%rcx)
jmp 0x1397e
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
ja 0x1396a
movsd 0x18801(%rip), %xmm1    # 0x2c140
movapd %xmm2, %xmm0
callq 0x4410
movsd 0x8(%rsp), %xmm2
movapd 0x10(%rsp), %xmm1
ucomisd 0x187fc(%rip), %xmm0    # 0x2c158
jne 0x13960
jnp 0x1396a
movsd 0x18f40(%rip), %xmm0    # 0x2c8a8
jmp 0x13977
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_O1/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, %rbx
movq (%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, (%rdi)
movsd -0x8(%rax), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movsd 0x18efd(%rip), %xmm0    # 0x2c8a8
jne 0x139b3
jnp 0x13a8d
ucomisd 0x18eed(%rip), %xmm1    # 0x2c8a8
jne 0x139c3
jnp 0x13a8d
movsd (%rax), %xmm2
ucomisd 0x18ed9(%rip), %xmm2    # 0x2c8a8
jne 0x139d7
jnp 0x13a8d
movapd 0x19061(%rip), %xmm0    # 0x2ca40
movapd %xmm1, (%rsp)
andpd %xmm1, %xmm0
movapd %xmm2, 0x10(%rsp)
callq 0x4290
movapd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
movsd 0x18ec3(%rip), %xmm1    # 0x2c8c8
ucomisd %xmm0, %xmm1
jbe 0x13a15
movsd 0x18e95(%rip), %xmm0    # 0x2c8a8
jmp 0x13a8d
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jae 0x13a77
movsd 0x18ea9(%rip), %xmm1    # 0x2c8d0
movapd (%rsp), %xmm0
callq 0x4410
andpd 0x19007(%rip), %xmm0    # 0x2ca40
ucomisd 0x186ff(%rip), %xmm0    # 0x2c140
movsd 0x18e5f(%rip), %xmm0    # 0x2c8a8
jne 0x13a8d
jp 0x13a8d
movapd 0x10(%rsp), %xmm0
xorpd 0x18fd5(%rip), %xmm0    # 0x2ca30
movsd 0x186dd(%rip), %xmm1    # 0x2c140
divsd (%rsp), %xmm1
callq 0x45b0
xorpd 0x18fbb(%rip), %xmm0    # 0x2ca30
jmp 0x13a8d
movsd 0x186c1(%rip), %xmm1    # 0x2c140
divsd (%rsp), %xmm1
movapd %xmm2, %xmm0
callq 0x45b0
movq (%rbx), %rax
movsd %xmm0, (%rax)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %xmm2
movapd 0x18f93(%rip), %xmm1    # 0x2ca40
andpd %xmm2, %xmm1
movsd 0x18dff(%rip), %xmm0    # 0x2c8b8
leaq -0x8(%rax), %rcx
ucomisd %xmm1, %xmm0
jbe 0x13ad0
movq %rcx, (%rbx)
movq $0x0, -0x8(%rax)
jmp 0x13b49
ucomisd 0x18dd0(%rip), %xmm2    # 0x2c8a8
movq %rcx, (%rbx)
jne 0x13adf
jnp 0x13b3c
ucomisd 0x18df1(%rip), %xmm1    # 0x2c8d8
ja 0x13b3c
movsd (%rcx), %xmm2
movapd 0x18f4b(%rip), %xmm1    # 0x2ca40
andpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x13b08
movq $0x0, (%rcx)
jmp 0x13b1e
ucomisd 0x18d98(%rip), %xmm2    # 0x2c8a8
jne 0x13b14
jnp 0x13b3c
ucomisd 0x18d94(%rip), %xmm1    # 0x2c8b0
ja 0x13b3c
movsd (%rax), %xmm1
movsd 0x18db6(%rip), %xmm0    # 0x2c8e0
callq 0x45b0
movq (%rbx), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x13b49
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
movq %rax, (%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18adc(%rip), %rsi     # 0x2d110
callq 0x4380
testq %rax, %rax
je 0x14665
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x1467f
movq %rax, %rbx
movq %r13, %rdi
callq 0x4300
movq %rbx, %rax
jmp 0x14675
leaq 0x18aa7(%rip), %rax     # 0x2d113
movq %rax, 0x23d3d(%rip)     # 0x383b0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x23caa(%rip), %rsi     # 0x38350
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rdx
callq 0x14877
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x14703
movq %rax, %r14
testq %rax, %rax
je 0x146ee
movl 0xb8(%rsp), %eax
subl 0xc0(%rsp), %eax
movslq %eax, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x4360
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_O1/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 0x16071
movq %rax, (%rsp)
testq %rax, %rax
je 0x147b9
cmpl $0x0, 0x23c85(%rip)     # 0x383b8
je 0x147b9
movl (%r12), %ecx
testl %ebx, %ebx
jne 0x14744
movl (%r15), %ebx
movl %ecx, %edi
sarl %edi
testl %edi, %edi
jle 0x147b9
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 0x147ac
movslq %ecx, %r14
imulq %rsi, %r14
addq (%rsp), %r14
movq %r11, %r15
xorl %r12d, %r12d
testl %ebx, %ebx
jle 0x1479e
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 0x14786
incq %r12
addq %rsi, %r14
addq %rsi, %r15
cmpq %rdx, %r12
jne 0x1477f
incq %r10
subl %edx, %ecx
addq %r9, %r11
cmpq %rax, %r10
jne 0x1476a
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_O1/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 %r14
pushq %rbx
pushq %rax
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), %r14
movq %r14, 0xc8(%rdi)
movq %rdx, %rdi
movq %r14, %rsi
movl $0x80, %edx
callq *0x10(%rbx)
testl %eax, %eax
je 0x148d1
movq %r14, 0xb8(%rbx)
cltq
addq %r14, %rax
movq %rax, 0xc0(%rbx)
jmp 0x148ee
movl $0x0, 0x30(%rbx)
movq %r14, 0xb8(%rbx)
leaq 0x39(%rbx), %rax
movq %rax, 0xc0(%rbx)
movb $0x0, 0x38(%rbx)
movq 0xc0(%rbx), %rax
movq %rax, 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x184ec(%rip), %rsi     # 0x2d110
callq 0x4380
testq %rax, %rax
je 0x14c67
movq %rax, %r12
leaq 0x23718(%rip), %rsi     # 0x38350
movq %rsp, %rbp
movq %rbp, %rdi
movq %rax, %rdx
callq 0x14877
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x1495b
movq %rax, %rbx
movq %r12, %rdi
callq 0x4300
jmp 0x14c77
leaq 0x184a5(%rip), %rax     # 0x2d113
movq %rax, 0x2373b(%rip)     # 0x383b0
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_O1/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 0x14d2f
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x182fc(%rip), %rsi     # 0x2d110
callq 0x4380
testq %rax, %rax
je 0x14e4c
movq %rax, %rbx
leaq 0x23528(%rip), %rsi     # 0x38350
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x14877
movq %r14, %rdi
callq 0x14d2f
movl %eax, %ebp
movq %rbx, %rdi
callq 0x4300
jmp 0x14e4e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4400
testq %rax, %rax
je 0x14f64
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 0x14f74
testl %eax, %eax
je 0x14f5a
testq %rbx, %rbx
je 0x14f53
movl 0x20(%rsp), %eax
subl 0x28(%rsp), %eax
movl %eax, (%rbx)
movq 0x28(%rsp), %rax
jmp 0x14f66
movq 0x28(%rsp), %rdi
callq 0x4390
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4400
testq %rax, %rax
je 0x15a5b
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 0x14f74
testl %eax, %eax
je 0x15a51
testq %rbx, %rbx
je 0x15a4a
movl 0x18(%rsp), %eax
subl 0x20(%rsp), %eax
movl %eax, (%rbx)
movq 0x20(%rsp), %rax
jmp 0x15a5d
movq 0x20(%rsp), %rdi
callq 0x4390
xorl %eax, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4400
testq %rax, %rax
je 0x15b25
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 0x14f74
testl %eax, %eax
je 0x15b1b
testq %rbx, %rbx
je 0x15b14
movl 0x18(%rsp), %eax
subl 0x20(%rsp), %eax
movl %eax, (%rbx)
movq 0x20(%rsp), %rax
jmp 0x15b27
movq 0x20(%rsp), %rdi
callq 0x4390
xorl %eax, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15be7
movl %eax, %ecx
shrl $0xa, %ecx
andl $0x1f, %ecx
movl %eax, %edx
shrl $0x5, %edx
andl $0x1f, %edx
andl $0x1f, %eax
movl %ecx, %esi
shll $0x8, %esi
subl %ecx, %esi
imulq $0x8421085, %rsi, %rcx  # imm = 0x8421085
shrq $0x20, %rcx
movb %cl, (%rbx)
movl %edx, %ecx
shll $0x8, %ecx
subl %edx, %ecx
imulq $0x8421085, %rcx, %rcx  # imm = 0x8421085
shrq $0x20, %rcx
movb %cl, 0x1(%rbx)
movl %eax, %ecx
shll $0x8, %ecx
subl %eax, %ecx
imulq $0x8421085, %rcx, %rax  # imm = 0x8421085
shrq $0x20, %rax
movb %al, 0x2(%rbx)
popq %rbx
retq