LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/zakimjz[P]SLEUTH/./timetrack.h
// Function: TimeTracker::Stop()
double Stop() {
     double st, en;
     if (!running) return(-1.0);
     else {
        gettimeofday(&stop_time, (struct timezone *)0);
        st = start_time.tv_sec + (start_time.tv_usec/microsec);
        en = stop_time.tv_sec + (stop_time.tv_usec/microsec);
        running=false;
        return (double)(en - st);
     }
  }

// Assembly:
cmpb $0x1, 0x20(%rdi)
jne 0x69e5
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
xorl %esi, %esi
callq 0x22d0
cvtsi2sdq (%rbx), %xmm0
cvtsi2sdq 0x8(%rbx), %xmm1
movsd 0x276c(%rip), %xmm2     # 0x9128
divsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sdq 0x10(%rbx), %xmm3
xorps %xmm0, %xmm0
cvtsi2sdq 0x18(%rbx), %xmm0
divsd %xmm2, %xmm0
addsd %xmm3, %xmm0
subsd %xmm1, %xmm0
movb $0x0, 0x20(%rbx)
popq %rbx
retq
movsd 0x2733(%rip), %xmm0     # 0x9120
retq
// File: /workspace/github_cpp_makefile_star2_O3/zakimjz[P]SLEUTH/./eqclass.h
// Function: Eqnode::add_list(int, std::vector<int, std::allocator<int>>&, int, ival&, int, bool)
void add_list(int c, vector<int> &pscope, int lit, ival &ivl, 
                 int d, bool i=false)
   {
//       if (tlist.size() > 0){
//          idnode *idn = &tlist.back();
//          vector<int> ps = pscope;
//          ps.push_back(lit);
//          if (idn->cid == c && 
//              idn->itscope == ivl && 
//              idn->parscope == ps) return;
//       }
      
      tlist.push_back(idnode(c, pscope, lit, ivl, d, i));
   }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
addq $0x10, %rbx
movzbl 0x50(%rsp), %eax
movl %eax, (%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6c4a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6ce0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x6a4b
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x21e0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x6a6d
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O3/zakimjz[P]SLEUTH/./eqclass.h
// Function: Eqnode::add_list(int, ival&, int, bool)
void add_list(int c, ival &it, int d, bool i=false)
   {
//       if (tlist.size() > 0){
//          idnode *idn = &tlist.back();
//          if (idn->cid == c && idn->itscope == it) return;
//       }
      
      tlist.push_back(idnode(c,it,d,i));
   }

// Assembly:
pushq %rbx
subq $0x30, %rsp
addq $0x10, %rdi
xorps %xmm0, %xmm0
movq %rsp, %rax
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movl %esi, (%rax)
movq (%rdx), %rdx
movq %rdx, 0x4(%rax)
movl %ecx, 0x28(%rax)
movb %r8b, 0x2c(%rax)
movq %rax, %rsi
callq 0x6ce0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6ac0
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21e0
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6ae0
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/zakimjz[P]SLEUTH/./idlist.h
// Function: idnode::idnode(int, std::vector<int, std::allocator<int>>&, int, ival&, int, bool)
idnode(int c, vector<int> &pscope, int lit, ival &ivl, int d, 
          bool i=false){
      cid = c;
      itscope = ivl;
      parscope = pscope;
      parscope.push_back(lit);      
      depth = d;
      induced = i;
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %ecx, %r15d
movq %rdi, %rbx
movl %ecx, 0x4(%rsp)
xorl %eax, %eax
movq %rax, 0x4(%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rax, 0x20(%rdi)
movl %esi, (%rdi)
movq (%r8), %rax
movq %rax, 0x4(%rdi)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x3db6
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x6c9e
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rbx)
jmp 0x6cab
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x3e9a
movb 0x30(%rsp), %al
movl %ebp, 0x28(%rbx)
movb %al, 0x2c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6cd7
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O3/zakimjz[P]SLEUTH/hashtable.cpp
// Function: FreqHT::find(int, std::vector<int, std::allocator<int>>&, int)
bool FreqHT::find(int iter, vector<int> &cand, int hval)
{
   if (chtable[iter] == NULL) return false;

   int hres = chtable[iter]->hash_funct()(hval);   
   cHTFind p = chtable[iter]->equal_range(hres);
   
   //cout << "FIND " << hres << " xx  " << cand << endl;
   cHTable::iterator hi = p.first;
   for (; hi!=p.second; hi++){
      if (eqcmp(&cand, (*hi).second)) return true;
   }
   return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movslq %esi, %rax
movq (%rdi), %rdx
movq (%rdx,%rax,8), %rsi
testq %rsi, %rsi
je 0x7f24
leaq 0x4(%rsp), %rdx
movl %ecx, (%rdx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x881a
movq (%r14), %r12
movq 0x10(%r14), %r14
cmpq %r14, %r12
je 0x7f24
movq 0x10(%rsp), %r15
movq 0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x7e3d
testb %al, %al
jne 0x7f28
movl %eax, %ecx
movq (%r12), %rax
testq %rax, %rax
jne 0x7f1a
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdi
movslq 0x8(%r12), %rax
subq %rsi, %rdi
sarq $0x3, %rdi
xorl %edx, %edx
divq %rdi
incq %rdx
cmpq %rdi, %rdx
jae 0x7f18
movq (%rsi,%rdx,8), %rax
testq %rax, %rax
je 0x7f05
jmp 0x7f1a
xorl %eax, %eax
movq %rax, %r12
cmpq %r14, %rax
jne 0x7ed0
jmp 0x7f2a
xorl %ecx, %ecx
jmp 0x7f2a
movb $0x1, %cl
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/cxxopts.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const& cxxopts::OptionValue::as<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>() const
const T&
    as() const
    {
      if (m_value == nullptr) {
        throw std::domain_error("No value");
      }

#ifdef CXXOPTS_NO_RTTI
      return static_cast<const values::standard_value<T>&>(*m_value).get();
#else
      return dynamic_cast<const values::standard_value<T>&>(*m_value).get();
#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x8390
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xdfa6
leaq 0x45482(%rip), %rsi     # 0x53400
leaq 0x454bb(%rip), %rdx     # 0x53440
xorl %ecx, %ecx
callq 0x8500
testq %rax, %rax
je 0xdfd8
movq 0x28(%rax), %rcx
testq %rcx, %rcx
jne 0xdf9e
movq 0x18(%rax), %rcx
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x8210
movq %rax, %rbx
leaq 0x33151(%rip), %rsi     # 0x4110b
movq %rax, %rdi
callq 0x82b0
movq 0x45f87(%rip), %rsi     # 0x53f50
movq 0x45fa0(%rip), %rdx     # 0x53f70
movq %rbx, %rdi
callq 0x8740
callq 0x87f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x8340
movq %r14, %rdi
callq 0x8770
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/src/ConvexHull.cpp
// Function: HullArea(std::vector<Point, std::allocator<Point>> const&)
double HullArea(const vector<Point> &points)
{
double A = 0.0;
int n = points.size();

    if ( n < 3) return 0.0;
    for (int i = 0; i < n - 1; i++)
    {
        A += points[i].x*points[i+1].y - points[i+1].x*points[i].y;
    }
    //  Then close the polygon, last point is the first one.
    A += points[n-1].x*points[0].y - points[0].x*points[n-1].y;
    A = fabs(A);
	return A/2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8390
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
xorpd %xmm0, %xmm0
cmpl $0x3, %ecx
jl 0x29577
decl %ecx
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm1
leaq 0x18(%rax), %rdx
movq %rcx, %rsi
movapd %xmm1, %xmm3
movapd %xmm2, %xmm4
movsd -0x8(%rdx), %xmm5
movsd (%rdx), %xmm6
mulsd %xmm5, %xmm3
mulsd %xmm6, %xmm4
subsd %xmm3, %xmm4
addsd %xmm4, %xmm0
addq $0x10, %rdx
movapd %xmm6, %xmm3
movapd %xmm5, %xmm4
decq %rsi
jne 0x29526
shlq $0x4, %rcx
mulsd 0x8(%rax,%rcx), %xmm2
mulsd (%rax,%rcx), %xmm1
subsd %xmm2, %xmm1
addsd %xmm1, %xmm0
andpd 0x18ac1(%rip), %xmm0    # 0x42030
mulsd 0x18ac9(%rip), %xmm0    # 0x42040
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::ReCalcBoundingBox()
void Polygon::ReCalcBoundingBox()
{
    BoundingBox.A = _Vertices[0];
    BoundingBox.B = _Vertices[0];
    for ( int i = 1; i < nVertices - 1; i++)
    {
        if ( _Vertices[i].x < BoundingBox.A.x ) BoundingBox.A.x = _Vertices[i].x ;
        if ( _Vertices[i].y < BoundingBox.A.y ) BoundingBox.A.y = _Vertices[i].y ;
        if ( _Vertices[i].x > BoundingBox.B.x ) BoundingBox.B.x = _Vertices[i].x ;
        if ( _Vertices[i].y > BoundingBox.B.y ) BoundingBox.B.y = _Vertices[i].y ;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8390
movq 0x10(%rbx), %rax
movups (%rax), %xmm0
movups %xmm0, 0x58(%rbx)
movupd (%rax), %xmm0
movupd %xmm0, 0x68(%rbx)
movl 0x8(%rbx), %ecx
cmpl $0x3, %ecx
jl 0x2b611
leaq 0x58(%rbx), %rdx
leaq 0x68(%rbx), %rsi
decl %ecx
movsd 0x68(%rbx), %xmm0
movsd 0x58(%rbx), %xmm1
movsd 0x60(%rbx), %xmm2
movsd 0x70(%rbx), %xmm3
shlq $0x4, %rcx
addq $-0x10, %rcx
xorl %edi, %edi
movsd 0x10(%rax,%rdi), %xmm4
ucomisd %xmm4, %xmm1
jbe 0x2b5ca
movsd %xmm4, (%rdx)
movapd %xmm4, %xmm1
movsd 0x18(%rax,%rdi), %xmm4
ucomisd %xmm4, %xmm2
jbe 0x2b5df
movsd %xmm4, 0x60(%rbx)
movapd %xmm4, %xmm2
movsd 0x10(%rax,%rdi), %xmm4
ucomisd %xmm0, %xmm4
jbe 0x2b5f3
movsd %xmm4, (%rsi)
movapd %xmm4, %xmm0
movsd 0x18(%rax,%rdi), %xmm4
ucomisd %xmm3, %xmm4
jbe 0x2b608
movsd %xmm4, 0x70(%rbx)
movapd %xmm4, %xmm3
addq $0x10, %rdi
cmpq %rdi, %rcx
jne 0x2b5b6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::NbChildren(NSVGpath*)
int SvgDoc::NbChildren(NSVGpath *path)
{
int nb = 0;

    for ( NSVGpath *child = path->child; child != NULL; child = child->next)
    {
        nb++;
    }
    return nb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x8390
movq 0x58(%rbx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x31df1
incl %eax
movq 0x48(%rcx), %rcx
jmp 0x31de4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: CheckOKAngles(double, double, double)
bool CheckOKAngles(double alpha, double beta, double a)
{
    //  First case, alpha is negative
    if ( alpha < 0 )
    {
        if ( beta < alpha )
        {
            //  Beta is also < 0
            //  In this case, OK if a >= alpha or a <= beta
            return (a >= alpha - angle_precision || a <= beta + angle_precision);
        }
        //  For all other cases, OK if a is betwen alpha and beta
        return (a >= alpha - angle_precision && a <= beta + angle_precision);
    }
    else
    {
    //  Alpha is positive.
        if ( beta >= alpha )
        {
            //  In this case beta is also positive, OK between alpha and beta
            return ( a >= alpha - angle_precision && a <= beta + angle_precision);
        }
        //  All other cases, NOK is between beta and alpha, so OK if >= alpha or <= beta
        return ( a >= alpha - angle_precision || a <= beta + angle_precision );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movaps %xmm2, -0x10(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
callq 0x8390
movsd -0x18(%rbp), %xmm3
movsd -0x20(%rbp), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm3, %xmm0
movsd 0xd0df(%rip), %xmm0     # 0x42260
addsd %xmm3, %xmm0
movsd 0xd07b(%rip), %xmm1     # 0x42208
addsd %xmm2, %xmm1
jbe 0x351ae
ucomisd %xmm2, %xmm3
ja 0x351b4
movapd -0x10(%rbp), %xmm2
cmplepd %xmm2, %xmm0
cmplepd %xmm1, %xmm2
andpd %xmm0, %xmm2
jmp 0x351c7
ucomisd %xmm3, %xmm2
jae 0x35199
movapd -0x10(%rbp), %xmm2
cmplepd %xmm2, %xmm0
cmplepd %xmm1, %xmm2
orpd %xmm0, %xmm2
movd %xmm2, %eax
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::ComputeRefPoint(int, int, int)
Point SvgDoc::ComputeRefPoint(int FirstPos, int xSize, int ySize)
{
Point A;

    if ( FirstPos < CenterLeft)     //  Top
    {
        A.y = MARGIN_PAGE;
    }
    else if ( FirstPos < BottomLeft )
    {
        A.y = (SheetSizeY - ySize)/2;       //  Sheet center
    }
    else
    {
        A.y = SheetSizeY - ySize - MARGIN_PAGE;           //  Bottom
    }
    if ( (FirstPos &3) == 0 )     //  Left
    {
        A.x = MARGIN_PAGE;
    }
    else if ( (FirstPos &3) == 1 )     //  Center ?
    {
        A.x = (SheetSizeX - xSize)/2;       //  Sheet center
    }
    else
    {
        A.x = SheetSizeX - xSize - MARGIN_PAGE;           //  Right
    }
    return A;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x8390
movsd 0x701a(%rip), %xmm0     # 0x40008
movapd %xmm0, %xmm1
cmpl $0x4, %r15d
jl 0x3901e
movsd 0x18(%rbx), %xmm1
cvtsi2sd %r12d, %xmm2
subsd %xmm2, %xmm1
cmpl $0x7, %r15d
ja 0x39016
mulsd 0x902c(%rip), %xmm1     # 0x42040
jmp 0x3901e
addsd 0x91c2(%rip), %xmm1     # 0x421e0
andl $0x3, %r15d
je 0x39056
xorps %xmm2, %xmm2
cvtsi2sd %r14d, %xmm2
cmpl $0x1, %r15d
jne 0x39045
movsd 0x10(%rbx), %xmm0
subsd %xmm2, %xmm0
mulsd 0x8ffd(%rip), %xmm0     # 0x42040
jmp 0x39056
movsd 0x10(%rbx), %xmm0
subsd %xmm2, %xmm0
addsd 0x918a(%rip), %xmm0     # 0x421e0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__xformPremultiply(double*, double*)
static void nsvg__xformPremultiply(double* t, double* s)
{
	double s2[6];
	memcpy(s2, s, sizeof(double)*6);
	nsvg__xformMultiply(s2, t);
	memcpy(t, s2, sizeof(double)*6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8390
movsd 0x28(%r14), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movupd (%rbx), %xmm0
movupd 0x10(%rbx), %xmm3
movupd 0x20(%rbx), %xmm4
mulpd %xmm3, %xmm2
movsd 0x20(%r14), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
addpd %xmm4, %xmm1
movsd (%r14), %xmm2
movsd 0x8(%r14), %xmm4
movsd 0x10(%r14), %xmm5
movsd 0x18(%r14), %xmm6
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm3, %xmm4
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm0, %xmm2
addpd %xmm4, %xmm2
movupd %xmm2, (%rbx)
unpcklpd %xmm6, %xmm6            # xmm6 = xmm6[0,0]
mulpd %xmm3, %xmm6
unpcklpd %xmm5, %xmm5            # xmm5 = xmm5[0,0]
mulpd %xmm0, %xmm5
addpd %xmm6, %xmm5
movupd %xmm5, 0x10(%rbx)
movupd %xmm1, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__getArgsPerElement(char)
static int nsvg__getArgsPerElement(char cmd)
{
	switch (cmd) {
		case 'v':
		case 'V':
		case 'h':
		case 'H':
			return 1;
		case 'm':
		case 'M':
		case 'l':
		case 'L':
		case 't':
		case 'T':
			return 2;
		case 'q':
		case 'Q':
		case 's':
		case 'S':
			return 4;
		case 'c':
		case 'C':
			return 6;
		case 'a':
		case 'A':
			return 7;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x8390
movl $0x1, %eax
leal -0x41(%rbx), %ecx
cmpl $0x15, %ecx
jbe 0x3e4c1
addl $-0x61, %ebx
cmpl $0x15, %ebx
ja 0x3e4ed
leaq 0x3f88(%rip), %rcx      # 0x42440
movslq (%rcx,%rbx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
leaq 0x3f20(%rip), %rdx      # 0x423e8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x2, %eax
jmp 0x3e4ef
movl $0x4, %eax
jmp 0x3e4ef
movl $0x6, %eax
jmp 0x3e4ef
movl $0x7, %eax
jmp 0x3e4ef
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/krig[P]easing/./easing.hpp
// Function: float easing::quinticInOut<float>(float)
T quinticInOut(T t) {
		if (t < 0.5) {
			return 16. * t * t * t * t * t;
		} else {
			T f = ((2. * t) - 2.);
			return  0.5 * f * f * f * f * f + 1.;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cvtss2sd %xmm0, %xmm1
movss 0x62c(%rip), %xmm2      # 0xc018
ucomiss %xmm0, %xmm2
jbe 0xba0f
movsd 0x6d7(%rip), %xmm0      # 0xc0d0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
jmp 0xba4d
addsd %xmm1, %xmm1
addsd 0x60d(%rip), %xmm1      # 0xc028
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd 0x60f(%rip), %xmm0      # 0xc040
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd 0x5fb(%rip), %xmm0      # 0xc048
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/krig[P]easing/./easing.hpp
// Function: float easing::elasticInOut<float>(float)
T elasticInOut(T t) {
		if (t < 0.5) {
			return 0.5 * sin(13. * M_PI_2 * (2. * t)) * pow(2., 10. * ((2. * t) - 1.));
		} else {
			return 0.5 * (sin(-13. * M_PI_2 * ((2. * t - 1) + 1)) * pow(2., -10. * (2. * t - 1.)) + 2.);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cvtss2sd %xmm0, %xmm2
movss 0x5b1(%rip), %xmm1      # 0xc018
addsd %xmm2, %xmm2
ucomiss %xmm0, %xmm1
jbe 0xbab4
movsd %xmm2, -0x10(%rbp)
movsd 0x623(%rip), %xmm0      # 0xc0a0
mulsd %xmm2, %xmm0
callq 0x1040
mulsd 0x5b2(%rip), %xmm0      # 0xc040
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
addsd 0x598(%rip), %xmm0      # 0xc038
mulsd 0x5d0(%rip), %xmm0      # 0xc078
callq 0x10c0
mulsd -0x8(%rbp), %xmm0
jmp 0xbb06
addsd 0x57c(%rip), %xmm2      # 0xc038
movsd %xmm2, -0x10(%rbp)
movsd 0x57f(%rip), %xmm0      # 0xc048
addsd %xmm2, %xmm0
mulsd 0x5d3(%rip), %xmm0      # 0xc0a8
callq 0x1040
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd 0x594(%rip), %xmm0      # 0xc080
callq 0x10c0
mulsd -0x8(%rbp), %xmm0
addsd 0x562(%rip), %xmm0      # 0xc060
mulsd 0x53a(%rip), %xmm0      # 0xc040
cvtsd2ss %xmm0, %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/krig[P]easing/./easing.hpp
// Function: float easing::backInOut<float>(float)
T backInOut(T t) {
		if (t < 0.5) {
			const T f = 2. * t;
			return 0.5 * (f * f * f - f * sin(f * M_PI));
		} else {
			const T f = (1. - (2.*t - 1.));
			return 0.5 * (1. - (f * f * f - f * sin(f * M_PI))) + 0.5;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss 0x4f8(%rip), %xmm1      # 0xc018
ucomiss %xmm0, %xmm1
jbe 0xbb72
addss %xmm0, %xmm0
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
movsd %xmm1, -0x10(%rbp)
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd %xmm1, -0x8(%rbp)
movsd 0x507(%rip), %xmm0      # 0xc058
mulsd %xmm1, %xmm0
callq 0x1040
movsd -0x10(%rbp), %xmm1
mulsd -0x8(%rbp), %xmm0
subsd %xmm0, %xmm1
mulsd 0x4d0(%rip), %xmm1      # 0xc040
jmp 0xbbf0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
addsd 0x4b6(%rip), %xmm0      # 0xc038
movsd 0x4be(%rip), %xmm1      # 0xc048
subsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
movsd %xmm1, -0x10(%rbp)
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd %xmm1, -0x8(%rbp)
movsd 0x49b(%rip), %xmm0      # 0xc058
mulsd %xmm1, %xmm0
callq 0x1040
movsd 0x47a(%rip), %xmm1      # 0xc048
mulsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
subsd %xmm0, %xmm2
subsd %xmm2, %xmm1
movsd 0x458(%rip), %xmm0      # 0xc040
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/krig[P]easing/./easing.hpp
// Function: float easing::bounceOut<float>(float)
T bounceOut(T t) {
		if (t < 4. / 11.) {
			return (121. * t * t) / 16.;
		} else if (t < 8. / 11.) {
			return (363. / 40. * t * t) - (99 / 10. * t) + 17 / 5.;
		} else if (t < 9. / 10.) {
			return (4356. / 361. * t * t) - (35442. / 1805. * t) + 16061. / 1805.;
		} else {
			return (54. / 5. * t * t) - (513. / 25. * t) + 268. / 25.;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cvtss2sd %xmm0, %xmm0
movsd 0x406(%rip), %xmm1      # 0xc0d8
ucomisd %xmm0, %xmm1
jbe 0xbcf5
movsd 0x458(%rip), %xmm1      # 0xc138
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x450(%rip), %xmm1      # 0xc140
jmp 0xbd85
movsd 0x3e3(%rip), %xmm1      # 0xc0e0
ucomisd %xmm0, %xmm1
jbe 0xbd29
movsd 0x415(%rip), %xmm1      # 0xc120
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x40d(%rip), %xmm0      # 0xc128
addsd %xmm1, %xmm0
addsd 0x409(%rip), %xmm0      # 0xc130
jmp 0xbd81
movsd 0x3b7(%rip), %xmm1      # 0xc0e8
ucomisd %xmm0, %xmm1
jbe 0xbd5d
movsd 0x3c9(%rip), %xmm1      # 0xc108
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x3c1(%rip), %xmm0      # 0xc110
addsd %xmm1, %xmm0
addsd 0x3bd(%rip), %xmm0      # 0xc118
jmp 0xbd81
movsd 0x38b(%rip), %xmm1      # 0xc0f0
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x383(%rip), %xmm0      # 0xc0f8
addsd %xmm1, %xmm0
addsd 0x37f(%rip), %xmm0      # 0xc100
movapd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/krig[P]easing/./easing.hpp
// Function: float easing::bounceInOut<float>(float)
T bounceInOut(T t) {
		if (t < 0.5) {
			return 0.5 * bounceIn(t * 2.);
		} else {
			return 0.5 * bounceOut(t * 2. - 1.) + 0.5;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movaps %xmm0, %xmm1
cvtss2sd %xmm0, %xmm0
movss 0x277(%rip), %xmm2      # 0xc018
addsd %xmm0, %xmm0
ucomiss %xmm1, %xmm2
jbe 0xbdd5
movsd 0x296(%rip), %xmm1      # 0xc048
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0xbbfd
movsd 0x281(%rip), %xmm1      # 0xc048
subsd %xmm0, %xmm1
mulsd 0x26d(%rip), %xmm1      # 0xc040
jmp 0xbdf6
addsd 0x25b(%rip), %xmm0      # 0xc038
callq 0xbbfd
movapd %xmm0, %xmm1
movsd 0x252(%rip), %xmm0      # 0xc040
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/compiler.cpp
// Function: main
int main(int argc, char **argv) {
  if (3 != argc) {
    usage(argv[0]);
    return 1;
  }

  try {
    // Creates a stream of tokens from the input file
    Tokenizer tokenizer(argv[1]);
    // Parses the tokens into an abstract syntax tree
    Parser parser(&tokenizer);
    if (!parser.parse()) {
      return 1;
    }
    // Compiles the syntax tree to the output file
    if (!parser.output(argv[2])) {
      return 1;
    }
  } catch (char const *error) {
    std::cout << "Error: " << error << std::endl;
    return 1;
  }

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2f8, %rsp            # imm = 0x2F8
movq %rsi, %r14
cmpl $0x3, %edi
jne 0x7da0
movq 0x8(%r14), %rsi
movq %rsp, %rdi
callq 0x327bc
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x80ac
leaq 0x60(%rsp), %rdi
callq 0x99bc
movl $0x1, %ebx
testb %al, %al
je 0x7cdd
movq 0x10(%r14), %rsi
leaq 0x60(%rsp), %rdi
callq 0xa190
xorb $0x1, %al
movzbl %al, %ebx
leaq 0x2b8(%rsp), %r14
movq %r14, %rdi
callq 0x7f8e
movq -0x20(%r14), %rdi
leaq 0x2a8(%rsp), %rax
cmpq %rax, %rdi
je 0x7d0e
movq 0x2a8(%rsp), %rsi
incq %rsi
callq 0x72c0
movq 0x3f26b(%rip), %rax     # 0x46f80
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0xa0(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x98(%rsp,%rcx)
callq 0x7250
leaq 0x190(%rsp), %rdi
callq 0x70f0
leaq 0x80(%rsp), %rdi
callq 0x7ef2
leaq 0x68(%rsp), %rdi
callq 0x7f40
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d78
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x72c0
leaq 0x3df91(%rip), %rax     # 0x45d10
leaq 0x30(%rsp), %rcx
movq %rax, -0x20(%rcx)
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x7dad
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x72c0
jmp 0x7dad
movq (%r14), %rdi
callq 0x7bec
movl $0x1, %ebx
movl %ebx, %eax
addq $0x2f8, %rsp            # imm = 0x2F8
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0x7dda
movq %rdx, %r14
movq %rax, %rbx
jmp 0x7de2
movq %rdx, %r14
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x7e3c
movq %rsp, %rdi
callq 0x7eb0
cmpl $0x1, %r14d
jne 0x7e34
movq %rbx, %rdi
callq 0x7130
movq %rax, %rbx
movq 0x3f1a6(%rip), %rdi     # 0x46fa0
leaq 0x2d215(%rip), %rsi     # 0x35016
movl $0x7, %edx
callq 0x7340
movq 0x3f18e(%rip), %rdi     # 0x46fa0
movq %rbx, %rsi
callq 0x72a0
movq %rax, %rdi
callq 0x7160
callq 0x7480
jmp 0x7da8
movq %rax, %rbx
callq 0x7480
movq %rbx, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/parser.cpp
// Function: Parser::addLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Parser::addLabel(const std::string& label) {
  if (this->hasLabel(label)) {
    return false;
  }
  _assignedLabels.insert(label);
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x258, %r14            # imm = 0x258
movq %r14, %rdi
callq 0xcb6c
movq %rax, %r15
testq %rax, %rax
jne 0xa729
leaq 0x8(%rsp), %rdx
movq %r14, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcc84
testq %r15, %r15
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/parser.cpp
// Function: Parser::writeln(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Parser::writeln(const std::string& line) {
  // If there is a pending PUSH instruction, first write it
  // to the outfile.
  if (!_pendingPushReg.empty()) {
    _outfile << "        PUSH " << _pendingPushReg << std::endl;
    _pendingPushReg = "";
  }
  // Then write the new line.
  _outfile << line << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x240(%rdi)
je 0xb084
leaq 0x238(%rbx), %r15
leaq 0x38(%rbx), %r12
leaq 0x2a12b(%rip), %rsi     # 0x35147
movl $0xd, %edx
movq %r12, %rdi
callq 0x7340
movq 0x238(%rbx), %rsi
movq 0x240(%rbx), %rdx
movq %r12, %rdi
callq 0x7340
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x7290
movsbl %al, %esi
movq %r12, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x71f0
movq 0x240(%rbx), %rdx
leaq 0x2b058(%rip), %rcx     # 0x360cf
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x7450
addq $0x38, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x7340
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x71f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/parser.cpp
// Function: Parser::writeData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void Parser::writeData(const std::string& data, int dataLength) {
  this->writeln("        " + data);
  _bytePos += dataLength * DATA_SIZE;
  while (0 != _bytePos % INST_SIZE) {
    _bytePos++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2a043(%rip), %rsi     # 0x3513e
movq %rsp, %r15
movq %r15, %rdi
callq 0xb692
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaff2
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb12c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
movl 0x290(%rbx), %eax
movl %r14d, %ecx
addl %r14d, %ecx
leal (%rax,%r14,2), %edx
subl %eax, %ecx
andl $0x3, %ecx
addl %edx, %ecx
movw %cx, 0x290(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb172
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
movq %rbx, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: FunctionToken::toAsmLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string FunctionToken::toAsmLabel(const std::string& srcLabel) {
  for (auto label : _labels) {
    if (srcLabel == label->name()) {
      return label->getAsmLabel();
    }
  }
  return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq 0xa8(%rsi), %rbp
movq 0xb0(%rsi), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %rbp
je 0x1c061
movq %rdx, %r15
movq (%rbp), %r12
movq 0x8(%rbp), %r14
testq %r14, %r14
je 0x1bfd4
movq 0x2afd4(%rip), %rax     # 0x46f98
cmpb $0x0, (%rax)
je 0x1bfcf
incl 0x8(%r14)
jmp 0x1bfd4
lock
incl 0x8(%r14)
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%r12), %rsi
movq 0x18(%r12), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0xbd58
movq 0x8(%r15), %rdx
cmpq 0x20(%rsp), %rdx
jne 0x1c01c
movq 0x18(%rsp), %r13
testq %rdx, %rdx
je 0x1c025
movq (%r15), %rdi
movq %r13, %rsi
callq 0x72e0
testl %eax, %eax
sete %bl
jmp 0x1c027
movq 0x18(%rsp), %r13
xorl %ebx, %ebx
jmp 0x1c027
movb $0x1, %bl
leaq 0x28(%rsp), %rax
cmpq %rax, %r13
je 0x1c041
movq 0x28(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x72c0
testb %bl, %bl
jne 0x1c081
testq %r14, %r14
je 0x1c052
movq %r14, %rdi
callq 0x8036
addq $0x10, %rbp
cmpq 0x10(%rsp), %rbp
jne 0x1bfb0
movq 0x8(%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1a05b(%rip), %rdx     # 0x360cf
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xbdee
jmp 0x1c0af
movq 0x8(%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x30(%r12), %rsi
movq 0x38(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xbd58
testq %r14, %r14
je 0x1c0af
movq %r14, %rdi
callq 0x8036
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1c0c3
movq %rax, %rbx
testq %r14, %r14
je 0x1c0d3
movq %r14, %rdi
callq 0x8036
movq %rbx, %rdi
callq 0x74f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: BreakStatement::parse(Tokenizer*, bool)
bool BreakStatement::parse(Tokenizer *tokenizer, bool inLoop) {
  _lineNum = tokenizer->peekNext().line();
  if (!_expect(tokenizer, "break")) {
    return false;
  } else if (!_expect(tokenizer, ";")) {
    return false;
  } else if (!inLoop) {
    _error("Must be within a loop statement to use 'break;'.", _lineNum);
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x32bec
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
leaq 0x2873b(%rip), %rax     # 0x45d10
movq %rax, (%r15)
movq 0x10(%r15), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1d5f3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x72c0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x18912(%rip), %rsi     # 0x35f16
leaq 0x18910(%rip), %rdx     # 0x35f1b
movq %rsp, %rdi
callq 0xbdee
movq %rsp, %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x342b6
movl %eax, %r15d
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d63c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
testb %r15b, %r15b
je 0x1d6cb
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1856f(%rip), %rsi     # 0x35bc1
leaq 0x18569(%rip), %rdx     # 0x35bc2
callq 0xbdee
movq %rsp, %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x342b6
movl %eax, %r14d
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d687
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
movl %r14d, %eax
xorb $0x1, %al
orb %bpl, %al
jne 0x1d6ce
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x18891(%rip), %rsi     # 0x35f2f
leaq 0x188ba(%rip), %rdx     # 0x35f5f
callq 0xbdee
movl 0x8(%rbx), %esi
movq %rsp, %rdi
callq 0x34178
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d6cb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d6e6
jmp 0x1d701
jmp 0x1d6e6
jmp 0x1d701
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d704
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
jmp 0x1d704
movq %rax, %rbx
movq %rbx, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: ContinueStatement::parse(Tokenizer*, bool)
bool ContinueStatement::parse(Tokenizer *tokenizer, bool inLoop) {
  _lineNum = tokenizer->peekNext().line();
  if (!_expect(tokenizer, "continue")) {
    return false;
  } else if (!_expect(tokenizer, ";")) {
    return false;
  } else if (!inLoop) {
    _error("Must be within a loop statement to use 'continue;'.", _lineNum);
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x32bec
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
leaq 0x285d7(%rip), %rax     # 0x45d10
movq %rax, (%r15)
movq 0x10(%r15), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1d757
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x72c0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x187be(%rip), %rsi     # 0x35f26
leaq 0x187bf(%rip), %rdx     # 0x35f2e
movq %rsp, %rdi
callq 0xbdee
movq %rsp, %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x342b6
movl %eax, %r15d
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d7a0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
testb %r15b, %r15b
je 0x1d82f
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1840b(%rip), %rsi     # 0x35bc1
leaq 0x18405(%rip), %rdx     # 0x35bc2
callq 0xbdee
movq %rsp, %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x342b6
movl %eax, %r14d
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d7eb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
movl %r14d, %eax
xorb $0x1, %al
orb %bpl, %al
jne 0x1d832
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1875e(%rip), %rsi     # 0x35f60
leaq 0x1878a(%rip), %rdx     # 0x35f93
callq 0xbdee
movl 0x8(%rbx), %esi
movq %rsp, %rdi
callq 0x34178
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d82f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d84a
jmp 0x1d865
jmp 0x1d84a
jmp 0x1d865
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d868
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
jmp 0x1d868
movq %rax, %rbx
movq %rbx, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: ExprStatement::parse(Tokenizer*, std::vector<std::shared_ptr<FunctionToken>, std::allocator<std::shared_ptr<FunctionToken>>> const&, std::vector<std::shared_ptr<GlobalVarToken>, std::allocator<std::shared_ptr<GlobalVarToken>>> const&, std::vector<std::shared_ptr<ParamToken>, std::allocator<std::shared_ptr<ParamToken>>> const&, std::vector<std::shared_ptr<LocalVarToken>, std::allocator<std::shared_ptr<LocalVarToken>>> const&)
bool ExprStatement::parse(
      Tokenizer *tokenizer,
      const std::vector<std::shared_ptr<FunctionToken>>& functions,
      const std::vector<std::shared_ptr<GlobalVarToken>>& globals,
      const std::vector<std::shared_ptr<ParamToken>>& parameters,
      const std::vector<std::shared_ptr<LocalVarToken>>& localVars) {
  _lineNum = tokenizer->peekNext().line();
  // An expression statement is just an expression followed by a semicolon.
  if (!_expr.parse(tokenizer, functions, globals, parameters, localVars)) {
    return false;
  }
  if (!_expect(tokenizer, ";")) {
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, (%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %rbp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x32bec
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbp)
leaq 0x26a90(%rip), %rax     # 0x45d10
movq %rax, (%r14)
movq 0x10(%r14), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1f29e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x72c0
addq $0x10, %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq (%rsp), %r9
callq 0x1131a
testb %al, %al
je 0x1f30d
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x168f3(%rip), %rsi     # 0x35bc1
leaq 0x168ed(%rip), %rdx     # 0x35bc2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xbdee
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x342b6
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1f30f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x72c0
jmp 0x1f30f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1f33a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x72c0
movq %rbx, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/tokenizer.cpp
// Function: Tokenizer::Tokenizer(char*)
Tokenizer::Tokenizer(char *filename) : _offset(0), _lineNum(1),
                                       _hasNext(false) {
  std::ifstream inputStream(filename);
  inputStream.seekg(0, std::ios::end);
  _data.reserve(inputStream.tellg());
  inputStream.seekg(0, std::ios::beg);
  _data.assign(std::istreambuf_iterator<char>(inputStream),
               std::istreambuf_iterator<char>());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, (%rdi)
xorl %eax, %eax
movb %al, 0x8(%rdi)
movl $0xffffffff, 0x18(%rdi) # imm = 0xFFFFFFFF
leaq 0x13520(%rip), %r13     # 0x45d10
movq %r13, 0x10(%rdi)
leaq 0x30(%rdi), %r12
movq %r12, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %r14
leaq 0x50(%rdi), %rbp
movq %rbp, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x20(%rsp), %rdi
movl $0x8, %edx
callq 0x7520
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x73c0
leaq 0x20(%rsp), %rdi
callq 0x74e0
movq %r14, %rdi
movq %rax, %rsi
callq 0x7460
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x73c0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
movq 0x108(%rsp,%rax), %rcx
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
addq %rsi, %rdx
movq $0x0, 0x10(%rsp)
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x32c82
leaq 0x20(%rsp), %rdi
callq 0x70a0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x328cd
jmp 0x328c0
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x70a0
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x328e1
movq (%rbp), %rsi
incq %rsi
callq 0x72c0
movq %r13, 0x10(%rbx)
movq 0x20(%rbx), %rdi
cmpq %r12, %rdi
je 0x328fa
movq (%r12), %rsi
incq %rsi
callq 0x72c0
movq %r15, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/util.cpp
// Function: otherParen(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string otherParen(const std::string& paren) {
  if ("(" == paren) {
    return ")";
  } else if (")" == paren) {
    return "(";
  } else if ("[" == paren) {
    return "]";
  } else if ("]" == paren) {
    return "[";
  } else if ("{" == paren) {
    return "}";
  } else if ("}" == paren) {
    return "{";
  }
  return "";
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1931(%rip), %rsi      # 0x350b9
movq %r14, %rdi
callq 0x70c0
testl %eax, %eax
je 0x33824
leaq 0x313f(%rip), %rsi      # 0x368de
movq %r14, %rdi
callq 0x70c0
testl %eax, %eax
je 0x3383b
leaq 0x1e3e(%rip), %rsi      # 0x355f4
movq %r14, %rdi
callq 0x70c0
testl %eax, %eax
je 0x33852
leaq 0x20d5(%rip), %rsi      # 0x358a2
movq %r14, %rdi
callq 0x70c0
testl %eax, %eax
je 0x33869
leaq 0x21ef(%rip), %rsi      # 0x359d3
movq %r14, %rdi
callq 0x70c0
testl %eax, %eax
je 0x33880
leaq 0x21da(%rip), %rsi      # 0x359d5
movq %r14, %rdi
callq 0x70c0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x33897
leaq 0x28b6(%rip), %rdx      # 0x360cf
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x338a8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x30ac(%rip), %rsi      # 0x368de
leaq 0x30a6(%rip), %rdx      # 0x368df
jmp 0x338a5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1870(%rip), %rsi      # 0x350b9
leaq 0x186a(%rip), %rdx      # 0x350ba
jmp 0x338a5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2042(%rip), %rsi      # 0x358a2
leaq 0x203c(%rip), %rdx      # 0x358a3
jmp 0x338a5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1d7d(%rip), %rsi      # 0x355f4
leaq 0x1d77(%rip), %rdx      # 0x355f5
jmp 0x338a5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2147(%rip), %rsi      # 0x359d5
leaq 0x2141(%rip), %rdx      # 0x359d6
jmp 0x338a5
leaq 0x2135(%rip), %rsi      # 0x359d3
leaq 0x212f(%rip), %rdx      # 0x359d4
movq %rbx, %rdi
callq 0xbdee
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/util.cpp
// Function: getParameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<ParamToken>, std::allocator<std::shared_ptr<ParamToken>>> const&)
std::shared_ptr<ParamToken> getParameter(
      const std::string& name,
      const std::vector<std::shared_ptr<ParamToken>>& parameters) {
  for (auto param : parameters) {
    if (param->name() == name) {
      return param;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
cmpq %rbp, %r13
je 0x33cdd
movq %rsi, %r14
movq (%r13), %rax
movq %rax, (%rbx)
movq 0x8(%r13), %rcx
movq %rcx, 0x8(%rbx)
testq %rcx, %rcx
je 0x33c4f
movq 0x1335a(%rip), %rdx     # 0x46f98
cmpb $0x0, (%rdx)
je 0x33c48
incl 0x8(%rcx)
jmp 0x33c4f
lock
incl 0x8(%rcx)
movq (%rbx), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x70(%rax), %rsi
movq 0x78(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xbd58
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x33c96
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0x33ca0
movq (%r14), %rsi
movq %r12, %rdi
callq 0x72e0
testl %eax, %eax
sete %r15b
jmp 0x33ca3
movq 0x8(%rsp), %r12
xorl %r15d, %r15d
jmp 0x33ca3
movb $0x1, %r15b
leaq 0x18(%rsp), %rax
cmpq %rax, %r12
je 0x33cbd
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x72c0
testb %r15b, %r15b
jne 0x33ce3
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x33cd0
callq 0x8036
addq $0x10, %r13
cmpq %rbp, %r13
jne 0x33c23
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x33d06
callq 0x8036
movq %r14, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/util.cpp
// Function: getLocal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<LocalVarToken>, std::allocator<std::shared_ptr<LocalVarToken>>> const&)
std::shared_ptr<LocalVarToken> getLocal(
      const std::string& name,
      const std::vector<std::shared_ptr<LocalVarToken>>& locals) {
  for (auto local : locals) {
    if (local->name() == name) {
      return local;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
cmpq %rbp, %r13
je 0x33dec
movq %rsi, %r14
movq (%r13), %rax
movq %rax, (%rbx)
movq 0x8(%r13), %rcx
movq %rcx, 0x8(%rbx)
testq %rcx, %rcx
je 0x33d5e
movq 0x1324b(%rip), %rdx     # 0x46f98
cmpb $0x0, (%rdx)
je 0x33d57
incl 0x8(%rcx)
jmp 0x33d5e
lock
incl 0x8(%rcx)
movq (%rbx), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x70(%rax), %rsi
movq 0x78(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xbd58
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x33da5
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0x33daf
movq (%r14), %rsi
movq %r12, %rdi
callq 0x72e0
testl %eax, %eax
sete %r15b
jmp 0x33db2
movq 0x8(%rsp), %r12
xorl %r15d, %r15d
jmp 0x33db2
movb $0x1, %r15b
leaq 0x18(%rsp), %rax
cmpq %rax, %r12
je 0x33dcc
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x72c0
testb %r15b, %r15b
jne 0x33df2
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x33ddf
callq 0x8036
addq $0x10, %r13
cmpq %rbp, %r13
jne 0x33d32
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x33e15
callq 0x8036
movq %r14, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/util.cpp
// Function: getFunction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<FunctionToken>, std::allocator<std::shared_ptr<FunctionToken>>> const&)
std::shared_ptr<FunctionToken> getFunction(
      const std::string& name,
      const std::vector<std::shared_ptr<FunctionToken>>& functions) {
  for (auto func : functions) {
    if (func->name() == name) {
      return func;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
cmpq %rbp, %r13
je 0x33efb
movq %rsi, %r14
movq (%r13), %rax
movq %rax, (%rbx)
movq 0x8(%r13), %rcx
movq %rcx, 0x8(%rbx)
testq %rcx, %rcx
je 0x33e6d
movq 0x1313c(%rip), %rdx     # 0x46f98
cmpb $0x0, (%rdx)
je 0x33e66
incl 0x8(%rcx)
jmp 0x33e6d
lock
incl 0x8(%rcx)
movq (%rbx), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x58(%rax), %rsi
movq 0x60(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xbd58
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x33eb4
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0x33ebe
movq (%r14), %rsi
movq %r12, %rdi
callq 0x72e0
testl %eax, %eax
sete %r15b
jmp 0x33ec1
movq 0x8(%rsp), %r12
xorl %r15d, %r15d
jmp 0x33ec1
movb $0x1, %r15b
leaq 0x18(%rsp), %rax
cmpq %rax, %r12
je 0x33edb
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x72c0
testb %r15b, %r15b
jne 0x33f01
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x33eee
callq 0x8036
addq $0x10, %r13
cmpq %rbp, %r13
jne 0x33e41
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x33f24
callq 0x8036
movq %r14, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-compiler/src/util.cpp
// Function: getGlobal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<GlobalVarToken>, std::allocator<std::shared_ptr<GlobalVarToken>>> const&)
std::shared_ptr<GlobalVarToken> getGlobal(
     const std::string& name,
     const std::vector<std::shared_ptr<GlobalVarToken>>& globals) {
  for (auto global : globals) {
    if (global->name() == name) {
      return global;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
cmpq %rbp, %r13
je 0x3400a
movq %rsi, %r14
movq (%r13), %rax
movq %rax, (%rbx)
movq 0x8(%r13), %rcx
movq %rcx, 0x8(%rbx)
testq %rcx, %rcx
je 0x33f7c
movq 0x1302d(%rip), %rdx     # 0x46f98
cmpb $0x0, (%rdx)
je 0x33f75
incl 0x8(%rcx)
jmp 0x33f7c
lock
incl 0x8(%rcx)
movq (%rbx), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x70(%rax), %rsi
movq 0x78(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xbd58
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x33fc3
movq 0x8(%rsp), %r12
testq %rdx, %rdx
je 0x33fcd
movq (%r14), %rsi
movq %r12, %rdi
callq 0x72e0
testl %eax, %eax
sete %r15b
jmp 0x33fd0
movq 0x8(%rsp), %r12
xorl %r15d, %r15d
jmp 0x33fd0
movb $0x1, %r15b
leaq 0x18(%rsp), %rax
cmpq %rax, %r12
je 0x33fea
movq 0x18(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x72c0
testb %r15b, %r15b
jne 0x34010
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x33ffd
callq 0x8036
addq $0x10, %r13
cmpq %rbp, %r13
jne 0x33f50
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x34033
callq 0x8036
movq %r14, %rdi
callq 0x74f0