LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %r9d, %r9d
movq %rsp, %rax
movq %r9, 0x4(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r9, 0x20(%rax)
movl %esi, (%rax)
movq (%rdx), %rdx
movq %rdx, 0x4(%rax)
movl %ecx, 0x28(%rax)
movb %r8b, 0x2c(%rax)
movq %rax, %rsi
callq 0x6cea
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6a9d
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 0x6abd
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
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 0x3e1a
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x6ca8
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rbx)
jmp 0x6cb5
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x3ef0
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 0x6ce1
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movslq %esi, %rax
movq (%rdi), %rsi
cmpq $0x0, (%rsi,%rax,8)
je 0x7b98
movq %rdx, %rbx
leaq 0x1c(%rsp), %rdx
movl %ecx, (%rdx)
movq (%rsi,%rax,8), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x8198
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%r14), %rax
setne %bpl
je 0x7b9a
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x7ab4
testb %al, %al
jne 0x7b9a
movq %rsp, %r14
movq %r14, %rdi
callq 0x6ba0
movq (%rsp), %rax
cmpq 0x30(%rsp), %rax
setne %bpl
je 0x7b9a
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x7ab4
testb %al, %al
je 0x7b6f
jmp 0x7b9a
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8380
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xe352
leaq 0x460d6(%rip), %rsi     # 0x54400
leaq 0x4610f(%rip), %rdx     # 0x54440
xorl %ecx, %ecx
callq 0x84f0
testq %rax, %rax
je 0xe384
movq 0x28(%rax), %rcx
testq %rcx, %rcx
jne 0xe34a
movq 0x18(%rax), %rcx
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x8210
movq %rax, %rbx
leaq 0x33da5(%rip), %rsi     # 0x4210b
movq %rax, %rdi
callq 0x82b0
movq 0x46bdb(%rip), %rsi     # 0x54f50
movq 0x46bf4(%rip), %rdx     # 0x54f70
movq %rbx, %rdi
callq 0x8730
callq 0x87e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x8330
movq %r14, %rdi
callq 0x8760
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8380
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
xorpd %xmm0, %xmm0
cmpl $0x3, %ecx
jl 0x29761
decl %ecx
movq %rcx, %rdx
shlq $0x4, %rdx
xorl %esi, %esi
movsd (%rax,%rsi), %xmm1
movsd 0x8(%rax,%rsi), %xmm2
mulsd 0x10(%rax,%rsi), %xmm2
mulsd 0x18(%rax,%rsi), %xmm1
subsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rsi
cmpq %rsi, %rdx
jne 0x29707
movl %ecx, %ecx
shlq $0x4, %rcx
movsd (%rax,%rcx), %xmm1
movsd 0x8(%rax,%rcx), %xmm2
mulsd (%rax), %xmm2
mulsd 0x8(%rax), %xmm1
subsd %xmm2, %xmm1
addsd %xmm1, %xmm0
andpd 0x198d7(%rip), %xmm0    # 0x43030
mulsd 0x198df(%rip), %xmm0    # 0x43040
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8380
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 0x2bbcf
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 0x2bb88
movsd %xmm4, (%rdx)
movapd %xmm4, %xmm1
movsd 0x18(%rax,%rdi), %xmm4
ucomisd %xmm4, %xmm2
jbe 0x2bb9d
movsd %xmm4, 0x60(%rbx)
movapd %xmm4, %xmm2
movsd 0x10(%rax,%rdi), %xmm4
ucomisd %xmm0, %xmm4
jbe 0x2bbb1
movsd %xmm4, (%rsi)
movapd %xmm4, %xmm0
movsd 0x18(%rax,%rdi), %xmm4
ucomisd %xmm3, %xmm4
jbe 0x2bbc6
movsd %xmm4, 0x70(%rbx)
movapd %xmm4, %xmm3
addq $0x10, %rdi
cmpq %rdi, %rcx
jne 0x2bb74
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8380
movq 0x58(%rbx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x32a8f
incl %eax
movq 0x48(%rcx), %rcx
jmp 0x32a82
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8380
movsd -0x18(%rbp), %xmm3
movsd -0x20(%rbp), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm3, %xmm0
movsd 0xd39f(%rip), %xmm0     # 0x431c8
addsd %xmm3, %xmm0
movsd 0xd33b(%rip), %xmm1     # 0x43170
addsd %xmm2, %xmm1
jbe 0x35e56
ucomisd %xmm2, %xmm3
ja 0x35e5c
movapd -0x10(%rbp), %xmm2
cmplepd %xmm2, %xmm0
cmplepd %xmm1, %xmm2
andpd %xmm0, %xmm2
jmp 0x35e6f
ucomisd %xmm3, %xmm2
jae 0x35e41
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_O1/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 0x8380
movsd 0x7312(%rip), %xmm0     # 0x41008
movapd %xmm0, %xmm1
cmpl $0x4, %r15d
jl 0x39d26
movsd 0x18(%rbx), %xmm1
cvtsi2sd %r12d, %xmm2
subsd %xmm2, %xmm1
cmpl $0x7, %r15d
jg 0x39d1e
mulsd 0x9324(%rip), %xmm1     # 0x43040
jmp 0x39d26
addsd 0x9422(%rip), %xmm1     # 0x43148
andl $0x3, %r15d
je 0x39d5e
xorps %xmm2, %xmm2
cvtsi2sd %r14d, %xmm2
cmpl $0x1, %r15d
jne 0x39d4d
movsd 0x10(%rbx), %xmm0
subsd %xmm2, %xmm0
mulsd 0x92f5(%rip), %xmm0     # 0x43040
jmp 0x39d5e
movsd 0x10(%rbx), %xmm0
subsd %xmm2, %xmm0
addsd 0x93ea(%rip), %xmm0     # 0x43148
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8380
movl $0x1, %eax
leal -0x41(%rbx), %ecx
cmpl $0x15, %ecx
jbe 0x3f3e1
addl $-0x61, %ebx
cmpl $0x15, %ebx
ja 0x3f40d
leaq 0x3fc8(%rip), %rcx      # 0x433a0
movslq (%rcx,%rbx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
leaq 0x3f60(%rip), %rdx      # 0x43348
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x2, %eax
jmp 0x3f40f
movl $0x4, %eax
jmp 0x3f40f
movl $0x6, %eax
jmp 0x3f40f
movl $0x7, %eax
jmp 0x3f40f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x766(%rip), %xmm2      # 0xc018
ucomiss %xmm0, %xmm2
jbe 0xb8d5
movsd 0x811(%rip), %xmm0      # 0xc0d0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
jmp 0xb913
addsd %xmm1, %xmm1
addsd 0x747(%rip), %xmm1      # 0xc028
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd 0x749(%rip), %xmm0      # 0xc040
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd 0x735(%rip), %xmm0      # 0xc048
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6eb(%rip), %xmm1      # 0xc018
addsd %xmm2, %xmm2
ucomiss %xmm0, %xmm1
jbe 0xb97a
movsd %xmm2, -0x10(%rbp)
movsd 0x75d(%rip), %xmm0      # 0xc0a0
mulsd %xmm2, %xmm0
callq 0x1040
mulsd 0x6ec(%rip), %xmm0      # 0xc040
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
addsd 0x6d2(%rip), %xmm0      # 0xc038
mulsd 0x70a(%rip), %xmm0      # 0xc078
callq 0x10c0
mulsd -0x8(%rbp), %xmm0
jmp 0xb9cc
addsd 0x6b6(%rip), %xmm2      # 0xc038
movsd %xmm2, -0x10(%rbp)
movsd 0x6b9(%rip), %xmm0      # 0xc048
addsd %xmm2, %xmm0
mulsd 0x70d(%rip), %xmm0      # 0xc0a8
callq 0x1040
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd 0x6ce(%rip), %xmm0      # 0xc080
callq 0x10c0
mulsd -0x8(%rbp), %xmm0
addsd 0x69c(%rip), %xmm0      # 0xc060
mulsd 0x674(%rip), %xmm0      # 0xc040
cvtsd2ss %xmm0, %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x632(%rip), %xmm1      # 0xc018
ucomiss %xmm0, %xmm1
jbe 0xba38
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 0x641(%rip), %xmm0      # 0xc058
mulsd %xmm1, %xmm0
callq 0x1040
movsd -0x10(%rbp), %xmm1
mulsd -0x8(%rbp), %xmm0
subsd %xmm0, %xmm1
mulsd 0x60a(%rip), %xmm1      # 0xc040
jmp 0xbab6
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
addsd 0x5f0(%rip), %xmm0      # 0xc038
movsd 0x5f8(%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 0x5d5(%rip), %xmm0      # 0xc058
mulsd %xmm1, %xmm0
callq 0x1040
movsd 0x5b4(%rip), %xmm1      # 0xc048
mulsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
subsd %xmm0, %xmm2
subsd %xmm2, %xmm1
movsd 0x592(%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_O1/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 0x540(%rip), %xmm1      # 0xc0d8
ucomisd %xmm0, %xmm1
jbe 0xbbbb
movsd 0x592(%rip), %xmm1      # 0xc138
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x58a(%rip), %xmm1      # 0xc140
jmp 0xbc4b
movsd 0x51d(%rip), %xmm1      # 0xc0e0
ucomisd %xmm0, %xmm1
jbe 0xbbef
movsd 0x54f(%rip), %xmm1      # 0xc120
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x547(%rip), %xmm0      # 0xc128
addsd %xmm1, %xmm0
addsd 0x543(%rip), %xmm0      # 0xc130
jmp 0xbc47
movsd 0x4f1(%rip), %xmm1      # 0xc0e8
ucomisd %xmm0, %xmm1
jbe 0xbc23
movsd 0x503(%rip), %xmm1      # 0xc108
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x4fb(%rip), %xmm0      # 0xc110
addsd %xmm1, %xmm0
addsd 0x4f7(%rip), %xmm0      # 0xc118
jmp 0xbc47
movsd 0x4c5(%rip), %xmm1      # 0xc0f0
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x4bd(%rip), %xmm0      # 0xc0f8
addsd %xmm1, %xmm0
addsd 0x4b9(%rip), %xmm0      # 0xc100
movapd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3b1(%rip), %xmm2      # 0xc018
addsd %xmm0, %xmm0
ucomiss %xmm1, %xmm2
jbe 0xbc9b
movsd 0x3d0(%rip), %xmm1      # 0xc048
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0xbac3
movsd 0x3bb(%rip), %xmm1      # 0xc048
subsd %xmm0, %xmm1
mulsd 0x3a7(%rip), %xmm1      # 0xc040
jmp 0xbcbc
addsd 0x395(%rip), %xmm0      # 0xc038
callq 0xbac3
movapd %xmm0, %xmm1
movsd 0x38c(%rip), %xmm0      # 0xc040
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7f60
movq 0x8(%r14), %rsi
movq %rsp, %rdi
callq 0x32e30
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x8260
leaq 0x60(%rsp), %rdi
callq 0x9c0c
movl $0x1, %ebx
testb %al, %al
je 0x7e9d
movq 0x10(%r14), %rsi
leaq 0x60(%rsp), %rdi
callq 0xa3e8
xorb $0x1, %al
movzbl %al, %ebx
leaq 0x2b8(%rsp), %r14
movq %r14, %rdi
callq 0x8142
movq -0x20(%r14), %rdi
leaq 0x2a8(%rsp), %rax
cmpq %rax, %rdi
je 0x7ece
movq 0x2a8(%rsp), %rsi
incq %rsi
callq 0x72c0
movq 0x400ab(%rip), %rax     # 0x47f80
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 0x80b2
leaq 0x68(%rsp), %rdi
callq 0x80fa
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f38
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x72c0
leaq 0x3eda1(%rip), %rax     # 0x46ce0
leaq 0x30(%rsp), %rcx
movq %rax, -0x20(%rcx)
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x7f6d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x72c0
jmp 0x7f6d
movq (%r14), %rdi
callq 0x7dac
movl $0x1, %ebx
movl %ebx, %eax
addq $0x2f8, %rsp            # imm = 0x2F8
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0x7f9a
movq %rdx, %r14
movq %rax, %rbx
jmp 0x7fa2
movq %rdx, %r14
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x7ffc
movq %rsp, %rdi
callq 0x8070
cmpl $0x1, %r14d
jne 0x7ff4
movq %rbx, %rdi
callq 0x7130
movq %rax, %rbx
movq 0x3ffe6(%rip), %rdi     # 0x47fa0
leaq 0x2e055(%rip), %rsi     # 0x36016
movl $0x7, %edx
callq 0x7340
movq 0x3ffce(%rip), %rdi     # 0x47fa0
movq %rbx, %rsi
callq 0x72a0
movq %rax, %rdi
callq 0x7160
callq 0x7480
jmp 0x7f68
movq %rax, %rbx
callq 0x7480
movq %rbx, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xce16
movq %rax, %r15
testq %rax, %rax
jne 0xa981
leaq 0x8(%rsp), %rdx
movq %r14, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcf2e
testq %r15, %r15
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb356
leaq 0x238(%rbx), %r15
leaq 0x38(%rbx), %r12
leaq 0x2ae59(%rip), %rsi     # 0x36147
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 0x2bd86(%rip), %rcx     # 0x370cf
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_O1/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 0x2ad71(%rip), %rsi     # 0x3613e
movq %rsp, %r15
movq %r15, %rdi
callq 0xb963
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb2c4
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb3fe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
movl 0x290(%rbx), %eax
leal (%r14,%r14), %ecx
subl %eax, %ecx
andl $0x3, %ecx
leal (%rax,%r14,2), %eax
addl %ecx, %eax
movw %ax, 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 0xb442
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
movq %rbx, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O1/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, (%rsp)
movq 0xa8(%rsi), %r13
movq 0xb0(%rsi), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %r13
sete %r15b
je 0x1c656
movq %rdx, %r14
movq (%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq (%r13), %rbp
movq 0x8(%r13), %r12
testq %r12, %r12
je 0x1c596
movq 0x2ba14(%rip), %rax     # 0x47f98
cmpb $0x0, (%rax)
je 0x1c590
incl 0x8(%r12)
jmp 0x1c596
lock
incl 0x8(%r12)
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rbp), %rsi
movq 0x18(%rbp), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0xc014
movq 0x8(%r14), %rdx
cmpq 0x20(%rsp), %rdx
jne 0x1c5d9
testq %rdx, %rdx
je 0x1c5dd
movq 0x18(%rsp), %rsi
movq (%r14), %rdi
callq 0x72e0
testl %eax, %eax
sete %bl
jmp 0x1c5df
xorl %ebx, %ebx
jmp 0x1c5df
movb $0x1, %bl
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1c5fb
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x72c0
testb %bl, %bl
je 0x1c62e
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, (%rdi)
movq 0x30(%rbp), %rsi
movq 0x38(%rbp), %rdx
addq %rsi, %rdx
callq 0xc014
testq %r12, %r12
je 0x1c628
movq %r12, %rdi
callq 0x81ea
testb %bl, %bl
je 0x1c63b
jmp 0x1c650
testq %r12, %r12
je 0x1c63b
movq %r12, %rdi
callq 0x81ea
addq $0x10, %r13
cmpq 0x10(%rsp), %r13
sete %r15b
jne 0x1c570
jmp 0x1c656
testb $0x1, %r15b
je 0x1c670
movq (%rsp), %rdi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x1aa67(%rip), %rdx     # 0x370cf
movq %rdx, %rsi
callq 0xc0a4
movq (%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1c685
movq %rax, %rbx
testq %r12, %r12
je 0x1c695
movq %r12, %rdi
callq 0x81ea
movq %rbx, %rdi
callq 0x74f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33270
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
leaq 0x290ff(%rip), %rax     # 0x46ce0
movq %rax, (%r15)
movq 0x10(%r15), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1dbff
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x72c0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x19306(%rip), %rsi     # 0x36f16
leaq 0x19304(%rip), %rdx     # 0x36f1b
movq %rsp, %rdi
callq 0xc0a4
movq %rsp, %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x3494f
movl %eax, %r15d
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1dc48
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
testb %r15b, %r15b
je 0x1dcd7
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x18f63(%rip), %rsi     # 0x36bc1
leaq 0x18f5d(%rip), %rdx     # 0x36bc2
callq 0xc0a4
movq %rsp, %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x3494f
movl %eax, %r14d
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1dc93
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
movl %r14d, %eax
xorb $0x1, %al
orb %bpl, %al
jne 0x1dcda
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x19285(%rip), %rsi     # 0x36f2f
leaq 0x192ae(%rip), %rdx     # 0x36f5f
callq 0xc0a4
movl 0x8(%rbx), %esi
movq %rsp, %rdi
callq 0x34811
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1dcd7
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 0x1dcf2
jmp 0x1dd0d
jmp 0x1dcf2
jmp 0x1dd0d
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1dd10
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
jmp 0x1dd10
movq %rax, %rbx
movq %rbx, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33270
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
leaq 0x28f9b(%rip), %rax     # 0x46ce0
movq %rax, (%r15)
movq 0x10(%r15), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1dd63
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x72c0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x191b2(%rip), %rsi     # 0x36f26
leaq 0x191b3(%rip), %rdx     # 0x36f2e
movq %rsp, %rdi
callq 0xc0a4
movq %rsp, %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x3494f
movl %eax, %r15d
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1ddac
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
testb %r15b, %r15b
je 0x1de3b
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x18dff(%rip), %rsi     # 0x36bc1
leaq 0x18df9(%rip), %rdx     # 0x36bc2
callq 0xc0a4
movq %rsp, %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x3494f
movl %eax, %r14d
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1ddf7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
movl %r14d, %eax
xorb $0x1, %al
orb %bpl, %al
jne 0x1de3e
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x19152(%rip), %rsi     # 0x36f60
leaq 0x1917e(%rip), %rdx     # 0x36f93
callq 0xc0a4
movl 0x8(%rbx), %esi
movq %rsp, %rdi
callq 0x34811
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1de3b
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 0x1de56
jmp 0x1de71
jmp 0x1de56
jmp 0x1de71
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1de74
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x72c0
jmp 0x1de74
movq %rax, %rbx
movq %rbx, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33270
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbp)
leaq 0x2733c(%rip), %rax     # 0x46ce0
movq %rax, (%r14)
movq 0x10(%r14), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1f9c2
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 0x1160e
testb %al, %al
je 0x1fa31
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x171cf(%rip), %rsi     # 0x36bc1
leaq 0x171c9(%rip), %rdx     # 0x36bc2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc0a4
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x3494f
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1fa33
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x72c0
jmp 0x1fa33
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 0x1fa5e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x72c0
movq %rbx, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13e7c(%rip), %r13     # 0x46ce0
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 0x33310
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 0x32f41
jmp 0x32f34
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x70a0
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x32f55
movq (%rbp), %rsi
incq %rsi
callq 0x72c0
movq %r13, 0x10(%rbx)
movq 0x20(%rbx), %rdi
cmpq %r12, %rdi
je 0x32f6e
movq (%r12), %rsi
incq %rsi
callq 0x72c0
movq %r15, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22e2(%rip), %rsi      # 0x360b9
movq %r14, %rdi
callq 0x70c0
testl %eax, %eax
je 0x33e73
leaq 0x3af0(%rip), %rsi      # 0x378de
movq %r14, %rdi
callq 0x70c0
testl %eax, %eax
je 0x33e8a
leaq 0x27ef(%rip), %rsi      # 0x365f4
movq %r14, %rdi
callq 0x70c0
testl %eax, %eax
je 0x33ea1
leaq 0x2a86(%rip), %rsi      # 0x368a2
movq %r14, %rdi
callq 0x70c0
testl %eax, %eax
je 0x33eb8
leaq 0x2ba0(%rip), %rsi      # 0x369d3
movq %r14, %rdi
callq 0x70c0
testl %eax, %eax
je 0x33ecf
leaq 0x2b8b(%rip), %rsi      # 0x369d5
movq %r14, %rdi
callq 0x70c0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x33ee6
leaq 0x3267(%rip), %rdx      # 0x370cf
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x33ef7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3a5d(%rip), %rsi      # 0x378de
leaq 0x3a57(%rip), %rdx      # 0x378df
jmp 0x33ef4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2221(%rip), %rsi      # 0x360b9
leaq 0x221b(%rip), %rdx      # 0x360ba
jmp 0x33ef4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x29f3(%rip), %rsi      # 0x368a2
leaq 0x29ed(%rip), %rdx      # 0x368a3
jmp 0x33ef4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x272e(%rip), %rsi      # 0x365f4
leaq 0x2728(%rip), %rdx      # 0x365f5
jmp 0x33ef4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2af8(%rip), %rsi      # 0x369d5
leaq 0x2af2(%rip), %rdx      # 0x369d6
jmp 0x33ef4
leaq 0x2ae6(%rip), %rsi      # 0x369d3
leaq 0x2ae0(%rip), %rdx      # 0x369d4
movq %rbx, %rdi
callq 0xc0a4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
movq 0x8(%rdx), %r13
cmpq %r13, %r12
sete %r15b
je 0x3434e
movq %rsi, %r14
movq (%r12), %rax
movq %rax, (%rbx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x342b8
movq 0x13cee(%rip), %rcx     # 0x47f98
cmpb $0x0, (%rcx)
je 0x342b4
incl 0x8(%rax)
jmp 0x342b8
lock
incl 0x8(%rax)
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 0xc014
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x342ff
testq %rdx, %rdx
je 0x34303
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x72e0
testl %eax, %eax
sete %bpl
jmp 0x34306
xorl %ebp, %ebp
jmp 0x34306
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x34322
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x72c0
testb %bpl, %bpl
jne 0x34348
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x34335
callq 0x81ea
addq $0x10, %r12
cmpq %r13, %r12
sete %r15b
jne 0x3428e
jmp 0x3434e
testb $0x1, %r15b
je 0x34354
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 0x34377
callq 0x81ea
movq %r14, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
movq 0x8(%rdx), %r13
cmpq %r13, %r12
sete %r15b
je 0x34467
movq %rsi, %r14
movq (%r12), %rax
movq %rax, (%rbx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x343d1
movq 0x13bd5(%rip), %rcx     # 0x47f98
cmpb $0x0, (%rcx)
je 0x343cd
incl 0x8(%rax)
jmp 0x343d1
lock
incl 0x8(%rax)
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 0xc014
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x34418
testq %rdx, %rdx
je 0x3441c
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x72e0
testl %eax, %eax
sete %bpl
jmp 0x3441f
xorl %ebp, %ebp
jmp 0x3441f
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3443b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x72c0
testb %bpl, %bpl
jne 0x34461
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3444e
callq 0x81ea
addq $0x10, %r12
cmpq %r13, %r12
sete %r15b
jne 0x343a7
jmp 0x34467
testb $0x1, %r15b
je 0x3446d
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 0x34490
callq 0x81ea
movq %r14, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
movq 0x8(%rdx), %r13
cmpq %r13, %r12
sete %r15b
je 0x34580
movq %rsi, %r14
movq (%r12), %rax
movq %rax, (%rbx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x344ea
movq 0x13abc(%rip), %rcx     # 0x47f98
cmpb $0x0, (%rcx)
je 0x344e6
incl 0x8(%rax)
jmp 0x344ea
lock
incl 0x8(%rax)
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 0xc014
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x34531
testq %rdx, %rdx
je 0x34535
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x72e0
testl %eax, %eax
sete %bpl
jmp 0x34538
xorl %ebp, %ebp
jmp 0x34538
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x34554
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x72c0
testb %bpl, %bpl
jne 0x3457a
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x34567
callq 0x81ea
addq $0x10, %r12
cmpq %r13, %r12
sete %r15b
jne 0x344c0
jmp 0x34580
testb $0x1, %r15b
je 0x34586
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 0x345a9
callq 0x81ea
movq %r14, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
movq 0x8(%rdx), %r13
cmpq %r13, %r12
sete %r15b
je 0x34699
movq %rsi, %r14
movq (%r12), %rax
movq %rax, (%rbx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x34603
movq 0x139a3(%rip), %rcx     # 0x47f98
cmpb $0x0, (%rcx)
je 0x345ff
incl 0x8(%rax)
jmp 0x34603
lock
incl 0x8(%rax)
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 0xc014
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x3464a
testq %rdx, %rdx
je 0x3464e
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x72e0
testl %eax, %eax
sete %bpl
jmp 0x34651
xorl %ebp, %ebp
jmp 0x34651
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3466d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x72c0
testb %bpl, %bpl
jne 0x34693
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x34680
callq 0x81ea
addq $0x10, %r12
cmpq %r13, %r12
sete %r15b
jne 0x345d9
jmp 0x34699
testb $0x1, %r15b
je 0x3469f
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 0x346c2
callq 0x81ea
movq %r14, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O1/rfotino[P]consolite-compiler/src/util.cpp
// Function: getLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<LabelStatement>, std::allocator<std::shared_ptr<LabelStatement>>> const&)
std::shared_ptr<LabelStatement> getLabel(
      const std::string& name,
      const std::vector<std::shared_ptr<LabelStatement>>& labels) {
  for (auto label : labels) {
    if (label->name() == name) {
      return label;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdx), %r12
movq 0x8(%rdx), %r13
cmpq %r13, %r12
sete %r15b
je 0x347b2
movq %rsi, %r14
movq (%r12), %rax
movq %rax, (%rbx)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x3471c
movq 0x1388a(%rip), %rcx     # 0x47f98
cmpb $0x0, (%rcx)
je 0x34718
incl 0x8(%rax)
jmp 0x3471c
lock
incl 0x8(%rax)
movq (%rbx), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xc014
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x34763
testq %rdx, %rdx
je 0x34767
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x72e0
testl %eax, %eax
sete %bpl
jmp 0x3476a
xorl %ebp, %ebp
jmp 0x3476a
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x34786
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x72c0
testb %bpl, %bpl
jne 0x347ac
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x34799
callq 0x81ea
addq $0x10, %r12
cmpq %r13, %r12
sete %r15b
jne 0x346f2
jmp 0x347b2
testb $0x1, %r15b
je 0x347b8
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 0x347db
callq 0x81ea
movq %r14, %rdi
callq 0x74f0
// File: /workspace/github_cpp_makefile_star2_O1/rfotino[P]consolite-compiler/src/util.cpp
// Function: error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void _error(const std::string& msg, int lineNum) {
  // TODO: It would be nice to have error messages that showed you
  // the source line and pointed to the token causing an error.
  std::cerr << "Error:";
  if (0 < lineNum) {
    std::cerr << lineNum << ":";
  }
  std::cerr << " " << msg << std::endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x137c7(%rip), %rdi     # 0x47fe8
leaq 0x3dc2(%rip), %rsi      # 0x385ea
movl $0x6, %edx
callq 0x7340
testl %ebp, %ebp
jle 0x34858
movq 0x137ab(%rip), %rdi     # 0x47fe8
movl %ebp, %esi
callq 0x74d0
leaq 0x3dad(%rip), %rsi      # 0x385f8
movl $0x1, %edx
movq %rax, %rdi
callq 0x7340
movq 0x13789(%rip), %r14     # 0x47fe8
leaq 0x18df(%rip), %rsi      # 0x36145
movl $0x1, %edx
movq %r14, %rdi
callq 0x7340
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %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
popq %rbx
popq %r14
popq %rbp
jmp 0x71f0