LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Pyboon[P]sage/./Eigen/src/Core/PermutationMatrix.h
// Function: Eigen::PermutationMatrix<-1, -1, int>& Eigen::PermutationBase<Eigen::PermutationMatrix<-1, -1, int>>::operator=<Eigen::Transpositions<-1, -1, int>>(Eigen::TranspositionsBase<Eigen::Transpositions<-1, -1, int>> const&)
Derived& operator=(const TranspositionsBase<OtherDerived>& tr)
    {
      setIdentity(tr.size());
      for(Index k=size()-1; k>=0; --k)
        applyTranspositionOnTheRight(k,tr.coeff(k));
      return derived();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49bc0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x5ae10
movq -0x20(%rbp), %rdi
callq 0x5ae40
subq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x5adf8
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5af60
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq (%rax), %rdx
callq 0x5ae70
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5adbe
movq -0x20(%rbp), %rdi
callq 0x5af90
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Pyboon[P]sage/./Eigen/src/LU/PartialPivLU.h
// Function: void Eigen::PartialPivLU<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>::_solve_impl<Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<std::complex<double>>, Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>, Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>(Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<std::complex<double>>, Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>> const&, Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>&) const
EIGEN_DEVICE_FUNC
    void _solve_impl(const RhsType &rhs, DstType &dst) const {
     /* The decomposition PA = LU can be rewritten as A = P^{-1} L U.
      * So we proceed as follows:
      * Step 1: compute c = Pb.
      * Step 2: replace c by the solution x to Lx = c.
      * Step 3: replace c by the solution x to Ux = c.
      */

      eigen_assert(rhs.rows() == m_lu.rows());

      // Step 1
      dst = permutationP() * rhs;

      // Step 2
      m_lu.template triangularView<UnitLower>().solveInPlace(dst);

      // Step 3
      m_lu.template triangularView<Upper>().solveInPlace(dst);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5bb10
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x13af0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jne 0x5ba50
jmp 0x5ba6f
leaq 0x242c8(%rip), %rdi     # 0x7fd1f
leaq 0x1dfd0(%rip), %rsi     # 0x79a2e
movl $0xea, %edx
leaq 0x242cf(%rip), %rcx     # 0x7fd39
callq 0x94c0
movq -0x58(%rbp), %rdi
callq 0x5bb80
movq %rax, %rsi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x5bb30
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5bbe0
movq -0x58(%rbp), %rdi
callq 0x5bc10
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x5bc40
movq -0x58(%rbp), %rdi
callq 0x5bc70
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x5bca0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Pyboon[P]sage/./Eigen/src/Core/DenseCoeffsBase.h
// Function: Eigen::DenseCoeffsBase<Eigen::Matrix<bool, -1, 1, 0, -1, 1>, 1>::operator[](long)
Scalar&
    operator[](Index index)
    {
      EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime,
                          THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD)
      eigen_assert(index >= 0 && index < size());
      return coeffRef(index);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
jl 0x5c535
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x5d500
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x5c53e
jmp 0x5c540
jmp 0x5c55f
leaq 0x131ee(%rip), %rdi     # 0x6f735
leaq 0x12671(%rip), %rsi     # 0x6ebbf
movl $0x198, %edx            # imm = 0x198
leaq 0x23eae(%rip), %rcx     # 0x80408
callq 0x94c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5d630
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::facePoint(HEFace*)
HEVert* Mesh::facePoint(HEFace *face)
{

    if(face->avg != nullptr)
        return face->avg;

    HEVert *fp = vertPool.new_element();
    
    HEEdge* temp = face->edge->next;

    fp->pos = v3(0, 0, 0);
    
    while(true)
    {

        fp->pos = fp->pos + temp->vert->pos;

        if(temp == face->edge)
            break;
        temp = temp->next;
    }

    fp->pos = fp->pos * 0.25f;
    
    face->avg = fp;
    return face->avg;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3ea6
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0x3f8e
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x6290
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x24(%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x5fd0
movq 0x38(%rsp), %rax
movq 0x24(%rsp), %rcx
movq %rcx, (%rax)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rax
movq (%rax), %rdx
leaq 0x18(%rsp), %rdi
callq 0x65d0
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movl 0x20(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x3f2c
jmp 0x3f3c
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x3ef0
movq 0x38(%rsp), %rsi
movss 0x8127(%rip), %xmm0     # 0xc070
movss %xmm0, 0x8(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x6640
movq 0x38(%rsp), %rax
movq 0xc(%rsp), %rcx
movq %rcx, (%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::edgePoint(HEEdge*)
HEVert* Mesh::edgePoint(HEEdge *edge)
{

    if(edge->ePt != nullptr)
        return edge->ePt;

    if(edge->pair->ePt != nullptr)
        return edge->pair->ePt;

    HEVert *newV = vertPool.new_element();
    
    HEVert *fp1 = facePoint(edge->face);
    HEVert *fp2 = facePoint(edge->pair->face);
    
    newV->pos = (edge->vert->pos + edge->next->vert->pos + fp1->pos + fp2->pos) * 0.25f;

    edge->ePt = newV;
    
    return edge->ePt;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3fd7
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x40dd
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x3ffe
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x40dd
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3e70
movq 0x8(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x3e70
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rsi
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdx
leaq 0x18(%rsp), %rdi
callq 0x65d0
movq 0x50(%rsp), %rdx
leaq 0x24(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x65d0
movq 0x48(%rsp), %rdx
leaq 0x30(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x65d0
movss 0x7fdd(%rip), %xmm0     # 0xc070
movss %xmm0, 0x14(%rsp)
leaq 0x3c(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x6640
movq 0x58(%rsp), %rax
movq 0x3c(%rsp), %rcx
movq %rcx, (%rax)
movl 0x44(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::splitEdges(HEEdge*)
void Mesh::splitEdges(HEEdge *edge)
{

    HEEdge *temp;
    if(edge->next->split)
        temp = edge->next->next;
    else
        temp = edge->next;

    while(true)
    {
        splitEdge(temp);

        if(temp == edge)
            break;

        while(temp != edge && temp->split)
            temp = temp->next;

    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
testb $0x1, 0x3c(%rax)
je 0x43fb
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x4409
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x440b
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4180
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x4428
jmp 0x4464
jmp 0x442a
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x18(%rsp), %rcx
movb %al, 0x7(%rsp)
je 0x4448
movq 0x10(%rsp), %rax
movb 0x3c(%rax), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x4452
jmp 0x4462
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x442a
jmp 0x440b
addq $0x28, %rsp
retq
nopl (%rax)
// File: eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::getVB()
v3* Mesh::getVB()
{
    v3* VB = new v3[fCount*eStep];
    for(int i = 0; i < fCount; i++)
    {

        HEEdge *temp = facePool[i]->edge;
        for(int j = 0; j < eStep; j++)
        {
            VB[i*eStep + j] = temp->vert->pos;
            
            temp = temp->next;
        }
    }
    return VB;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movl 0x60(%rcx), %eax
imull 0x64(%rcx), %eax
cltq
movq %rax, 0x28(%rsp)
movl $0xc, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rsp)
cmpq $0x0, %rax
je 0x58dc
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
imulq $0xc, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x66a0
jmp 0x58c4
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq $0xc, %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x58b3
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
movl $0x0, 0x48(%rsp)
movq 0x20(%rsp), %rcx
movl 0x48(%rsp), %eax
cmpl 0x60(%rcx), %eax
jge 0x59ab
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
movl 0x48(%rsp), %esi
callq 0x64b0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl 0x64(%rcx), %eax
jge 0x5999
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rax
movq (%rax), %rcx
movq 0x58(%rsp), %rax
movl 0x48(%rsp), %edx
imull 0x64(%rsi), %edx
addl 0x3c(%rsp), %edx
movslq %edx, %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x5922
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x21e0
jmp 0x59b5
jmp 0x599b
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x58ee
movq 0x58(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x22a0
nop
// File: eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::getUV()
v2* Mesh::getUV()
{
    v2* UV = new v2[fCount*eStep];
    for(int i = 0; i < fCount; i++)
    {

        HEEdge *temp = facePool[i]->edge;
        for(int j = 0; j < eStep; j++)
        {
            UV[i*eStep + j] = temp->uv;
 
            temp = temp->next;
        }
    }
    return UV;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movl 0x60(%rcx), %eax
imull 0x64(%rcx), %eax
cltq
movq %rax, 0x28(%rsp)
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rsp)
cmpq $0x0, %rax
je 0x5a5c
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rdx
shlq $0x3, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6750
jmp 0x5a44
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x5a33
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
movl $0x0, 0x48(%rsp)
movq 0x20(%rsp), %rcx
movl 0x48(%rsp), %eax
cmpl 0x60(%rcx), %eax
jge 0x5b1d
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
movl 0x48(%rsp), %esi
callq 0x64b0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl 0x64(%rcx), %eax
jge 0x5b0b
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x58(%rsp), %rax
movl 0x48(%rsp), %ecx
imull 0x64(%rsi), %ecx
addl 0x3c(%rsp), %ecx
movslq %ecx, %rcx
movq 0x28(%rdx), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x5aa2
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x21e0
jmp 0x5b27
jmp 0x5b0d
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x5a6e
movq 0x58(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::getNormals()
v3* Mesh::getNormals()
{
    v3* N = new v3[fCount*eStep];
    for(int i = 0; i < fCount; i++)
    {

        HEEdge *temp = facePool[i]->edge;
        for(int j = 0; j < eStep; j++)
        {
            N[i*eStep + j] = temp->norm;
            temp = temp->next;
        }
    }
    return N;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movl 0x60(%rcx), %eax
imull 0x64(%rcx), %eax
cltq
movq %rax, 0x28(%rsp)
movl $0xc, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x30(%rsp)
cmpq $0x0, %rax
je 0x5bdc
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
imulq $0xc, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x66a0
jmp 0x5bc4
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
addq $0xc, %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x5bb3
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
movl $0x0, 0x48(%rsp)
movq 0x20(%rsp), %rcx
movl 0x48(%rsp), %eax
cmpl 0x60(%rcx), %eax
jge 0x5ca9
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
movl 0x48(%rsp), %esi
callq 0x64b0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl 0x64(%rcx), %eax
jge 0x5c97
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rcx
movq 0x58(%rsp), %rax
movl 0x48(%rsp), %edx
imull 0x64(%rsi), %edx
addl 0x3c(%rsp), %edx
movslq %edx, %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movq 0x30(%rcx), %rdx
movq %rdx, (%rax)
movl 0x38(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x5c22
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x21e0
jmp 0x5cb3
jmp 0x5c99
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x5bee
movq 0x58(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x22a0
nopl (%rax)
// File: eliebe-5[P]Catmull-clark-subdivision/./memorypool.h
// Function: Memorypool<HEVert>::new_element()
inline T* Memorypool<T>::new_element()
{
	if (next_element*sizeof(T) >> BITSHIFT == nr_of_blocks)
		allocate_new_block();

	uint element = next_element;

	next_element++;
    
	return get_element_ref(element);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rcx), %eax
shlq $0x5, %rax
shrq $0xe, %rax
movl 0x18(%rcx), %ecx
cmpq %rcx, %rax
jne 0x62be
movq (%rsp), %rdi
callq 0x9680
movq (%rsp), %rdi
movl 0x1c(%rdi), %eax
movl %eax, 0xc(%rsp)
movl 0x1c(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rdi)
movl 0xc(%rsp), %esi
callq 0x9ee0
addq $0x18, %rsp
retq
// File: eliebe-5[P]Catmull-clark-subdivision/./halfedge.h
// Function: v3::operator*(v3 const&) const
inline v3 operator*(const v3& cross) const
    {
        v3 r(
            this->y*cross.z - cross.y*this->z,
            this->z*cross.x - cross.z*this->x,
            this->x*cross.y - cross.x*this->y
            );
        return r;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x10(%rsp), %rcx
movss 0x8(%rcx), %xmm2
movq 0x10(%rsp), %rcx
movss 0x4(%rcx), %xmm1
mulss 0x8(%rax), %xmm1
movd %xmm1, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss 0x8(%rax), %xmm1
movq 0x10(%rsp), %rcx
movss (%rcx), %xmm3
movq 0x10(%rsp), %rcx
movss 0x8(%rcx), %xmm2
mulss (%rax), %xmm2
movd %xmm2, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm2
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
movss (%rax), %xmm2
movq 0x10(%rsp), %rcx
movss 0x4(%rcx), %xmm4
movq 0x10(%rsp), %rcx
movss (%rcx), %xmm3
mulss 0x4(%rax), %xmm3
movd %xmm3, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm3
mulss %xmm4, %xmm2
addss %xmm3, %xmm2
callq 0x5fd0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: eliebe-5[P]Catmull-clark-subdivision/./memorypool.h
// Function: Memorypool<HEVert>::get_element_ref(unsigned int)
inline T * Memorypool<T>::get_element_ref(uint index)
{
    if (index >= next_element)
		throw std::out_of_range("Out of range\n");
    
	uint block_index = index*sizeof(T) >> BITSHIFT;
	uint element_index = (index & (BLOCKSIZE/sizeof(T) - 1));
	return &(blocks[block_index][element_index]);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jb 0x9f52
movl $0x10, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x219f(%rip), %rsi      # 0xc0ba
callq 0x2070
jmp 0x9f22
movq (%rsp), %rdi
movq 0x70ab(%rip), %rsi      # 0x10fd8
movq 0x709c(%rip), %rdx      # 0x10fd0
callq 0x2290
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x2150
jmp 0x9f93
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %eax
shlq $0x5, %rax
shrq $0xe, %rax
movl %eax, 0x18(%rsp)
movl 0x2c(%rsp), %eax
andq $0x1ff, %rax            # imm = 0x1FF
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x7220
movq (%rax), %rax
movl 0x14(%rsp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x22a0
nopl (%rax)
// File: eliebe-5[P]Catmull-clark-subdivision/./halfedge.h
// Function: HEEdge::HEEdge()
HEEdge()
    {
        split = false;
        vert = nullptr;
        pair = nullptr;
        face = nullptr;
        next = nullptr;
        ePt = nullptr;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x28, %rdi
callq 0x6750
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x66a0
movq 0x8(%rsp), %rax
movb $0x0, 0x3c(%rax)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
addq $0x18, %rsp
retq
nop
// File: noizebox[P]zipfsong/zipfsong.cpp
// Function: parse_songs(int, std::vector<Song, std::allocator<Song>>&)
void parse_songs(int songs, std::vector<Song>& song_list)
{
    song_list.reserve(songs);
    std::string input;
    for (int i = 1 ; i <= songs ; i++)
    {
        std::getline(std::cin, input);
        int pos = input.find(" ");
        int64_t listens = atol(input.substr(0, pos).c_str());
        song_list.emplace_back(std::string_view(input).substr(pos + 1), listens * i);
    }
    return;
}

// Assembly:
subq $0xd8, %rsp
movl %edi, 0xd4(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
movslq 0xd4(%rsp), %rsi
callq 0x28d0
leaq 0xa8(%rsp), %rdi
callq 0x21b0
movl $0x1, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
cmpl 0xd4(%rsp), %eax
jg 0x2562
movq 0x8bd2(%rip), %rdi      # 0xafe0
leaq 0xa8(%rsp), %rsi
callq 0x2040
jmp 0x241d
leaq 0x5be9(%rip), %rsi      # 0x800d
xorl %eax, %eax
movl %eax, %edx
movq %rdx, 0x38(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x2250
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movl %eax, 0x90(%rsp)
movslq 0x90(%rsp), %rcx
leaq 0x68(%rsp), %rdi
callq 0x2150
jmp 0x2464
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2090
movq %rax, %rdi
callq 0x2190
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x20e0
movq 0x10(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x2170
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movl 0x90(%rsp), %eax
incl %eax
movslq %eax, %rsi
leaq 0x48(%rsp), %rdi
movq $-0x1, %rdx
callq 0x2aa0
movq %rdx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
jmp 0x24e4
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x58(%rsp)
movq %rax, 0x60(%rsp)
movq 0x88(%rsp), %rax
movslq 0xa4(%rsp), %rcx
imulq %rcx, %rax
movq %rax, 0x40(%rsp)
leaq 0x58(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x2a10
jmp 0x2527
jmp 0x2529
movl 0xa4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa4(%rsp)
jmp 0x23f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x20e0
jmp 0x2577
leaq 0xa8(%rsp), %rdi
callq 0x20e0
addq $0xd8, %rsp
retq
movq 0x98(%rsp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: eschwabe[P]interview-practice/src/stringpermutations.cpp
// Function: perm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
void perm(string str, size_t rotate) {
    if(str.size() <= rotate) {
        cout << str << endl;
    }
    else {
        for(size_t idx = rotate; idx < str.size(); idx++) {
            string rstr = str;
            char tmp = rstr[rotate];
            rstr[rotate] = rstr[idx];
            rstr[idx] = tmp;
            perm(rstr, rotate+1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x20f0
cmpq -0x10(%rbp), %rax
ja 0x2416
movq -0x78(%rbp), %rsi
movq 0x5bdb(%rip), %rdi      # 0x7fd8
callq 0x2160
movq %rax, %rdi
movq 0x5bbc(%rip), %rsi      # 0x7fc8
callq 0x2190
jmp 0x2564
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x20f0
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x2562
movq -0x78(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2090
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2280
movq %rax, -0x88(%rbp)
jmp 0x246c
movq -0x88(%rbp), %rax
movb (%rax), %al
movb %al, -0x39(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2280
movq %rax, -0x98(%rbp)
jmp 0x248e
movq -0x98(%rbp), %rax
movb (%rax), %al
movb %al, -0xa1(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2280
movq %rax, -0xa0(%rbp)
jmp 0x24b3
movq -0xa0(%rbp), %rax
movb -0xa1(%rbp), %cl
movb %cl, (%rax)
movb -0x39(%rbp), %al
movb %al, -0xb1(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2280
movq %rax, -0xb0(%rbp)
jmp 0x24e1
movq -0xb0(%rbp), %rax
movb -0xb1(%rbp), %cl
movb %cl, (%rax)
leaq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2090
jmp 0x24ff
movq -0x10(%rbp), %rsi
incq %rsi
leaq -0x70(%rbp), %rdi
callq 0x23d0
jmp 0x2511
leaq -0x70(%rbp), %rdi
callq 0x20d0
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x241e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2557
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20d0
leaq -0x38(%rbp), %rdi
callq 0x20d0
jmp 0x256d
jmp 0x2564
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2230
nopw %cs:(%rax,%rax)
// File: smuething[P]dune-cxx11/24-move-semantics.cc
// Function: main
int main()
{
  A a(3);
  A a2(std::move(a));
  A a3(4);
  a3 = std::move(a2);
  assert(a._i == -1);
  assert(a2._i == -1);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x11e0
leaq -0xc(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x1230
leaq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x11e0
leaq -0x10(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x1290
cmpl $-0x1, -0x8(%rbp)
jne 0x118d
jmp 0x11ac
leaq 0xe70(%rip), %rdi       # 0x2004
leaq 0xe74(%rip), %rsi       # 0x200f
movl $0x2c, %edx
leaq 0xe7d(%rip), %rcx       # 0x2024
callq 0x1030
cmpl $-0x1, -0xc(%rbp)
jne 0x11b4
jmp 0x11d3
leaq 0xe74(%rip), %rdi       # 0x202f
leaq 0xe4d(%rip), %rsi       # 0x200f
movl $0x2d, %edx
leaq 0xe56(%rip), %rcx       # 0x2024
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: smuething[P]dune-cxx11/24-move-semantics.cc
// Function: A::operator=(A&&)
A& operator=(A&& a)
  {
    _i = a._i;
    assert(a._i > 0);
    a._i = -1;
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x12bb
jmp 0x12da
leaq 0xd8e(%rip), %rdi       # 0x2050
leaq 0xd46(%rip), %rsi       # 0x200f
movl $0x1d, %edx
leaq 0xd84(%rip), %rcx       # 0x2059
callq 0x1030
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0xffffffff, (%rcx)     # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
// File: Falldog[P]dcinja/src/dcinja.cpp
// Function: parse_delimiters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto parse_delimiters(const std::string& s) -> std::pair<std::string, std::string> {
    auto pos = s.find(' ');
    if (pos == std::string::npos) {
        return std::make_pair(s, s);
    }
    return std::make_pair(s.substr(0, pos), s.substr(pos + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb790
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0xc291
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x10f60
jmp 0xc318
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
incq %rdx
leaq -0x58(%rbp), %rdi
movq $-0x1, %rcx
callq 0xb5b0
jmp 0xc2c3
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x10fa0
jmp 0xc2d6
leaq -0x58(%rbp), %rdi
callq 0xbb98
leaq -0x38(%rbp), %rdi
callq 0xbb98
jmp 0xc318
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xc30d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xbb98
leaq -0x38(%rbp), %rdi
callq 0xbb98
jmp 0xc325
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xba60
nop
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::merge_patch(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>> const&)
void merge_patch(const basic_json& apply_patch)
    {
        if (apply_patch.is_object())
        {
            if (!is_object())
            {
                *this = object();
            }
            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
            {
                if (it.value().is_null())
                {
                    erase(it.key());
                }
                else
                {
                    operator[](it.key()).merge_patch(it.value());
                }
            }
        }
        else
        {
            *this = apply_patch;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4a990
testb $0x1, %al
jne 0x12120
jmp 0x1220a
movq -0x88(%rbp), %rdi
callq 0x4a990
testb $0x1, %al
jne 0x12163
leaq -0x30(%rbp), %rdi
callq 0xb2420
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xb23d0
movq -0x88(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12800
leaq -0x20(%rbp), %rdi
callq 0x12460
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x71d10
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x71d40
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x71d70
testb $0x1, %al
jne 0x12190
jmp 0x12208
leaq -0x50(%rbp), %rdi
callq 0xb2440
movq %rax, %rdi
callq 0x6a560
testb $0x1, %al
jne 0x121a7
jmp 0x121c1
leaq -0x50(%rbp), %rdi
callq 0xb25a0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0xb2460
jmp 0x121f8
leaq -0x50(%rbp), %rdi
callq 0xb25a0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x126a0
movq %rax, -0x90(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xb2440
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x120f0
jmp 0x121fa
leaq -0x50(%rbp), %rdi
callq 0x74a50
jmp 0x12170
jmp 0x12230
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x4bc70
movq -0x88(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x12800
leaq -0x80(%rbp), %rdi
callq 0x12460
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
reference operator[](const typename object_t::key_type& key)
    {
        // implicitly convert null value to an empty object
        if (is_null())
        {
            m_type = value_t::object;
            m_value.object = create<object_t>();
            assert_invariant();
        }

        // operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            return m_value.object->operator[](key);
        }

        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x6a560
testb $0x1, %al
jne 0x126c6
jmp 0x126df
movq -0x70(%rbp), %rax
movb $0x1, (%rax)
callq 0x549a0
movq -0x70(%rbp), %rdi
movq %rax, 0x8(%rdi)
callq 0x44cc0
movq -0x70(%rbp), %rdi
callq 0x4a990
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x126f2
jmp 0x1270c
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x51200
addq $0x90, %rsp
popq %rbp
retq
movb $0x1, -0x65(%rbp)
movl $0x20, %edi
callq 0xb2c0
movq -0x70(%rbp), %rdi
movq %rax, -0x88(%rbp)
callq 0x50ae0
movq %rax, -0x80(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xba70
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x10b90
jmp 0x1274e
leaq 0xb3bd6(%rip), %rsi     # 0xc632b
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x34d50
jmp 0x12764
movq -0x88(%rbp), %rdi
movl $0x131, %esi            # imm = 0x131
leaq -0x30(%rbp), %rdx
callq 0x50990
jmp 0x1277b
movq -0x88(%rbp), %rdi
movb $0x0, -0x65(%rbp)
leaq 0x1096ab(%rip), %rsi    # 0x11be38
leaq 0x3e3ec(%rip), %rdx     # 0x50b80
callq 0xb9f0
jmp 0x127fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x127d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x127cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbb98
leaq -0x50(%rbp), %rdi
callq 0xbb98
leaq -0x51(%rbp), %rdi
callq 0xb600
testb $0x1, -0x65(%rbp)
jne 0x127e6
jmp 0x127f2
movq -0x88(%rbp), %rdi
callq 0xb460
jmp 0x127f4
movq -0x60(%rbp), %rdi
callq 0xba60
nopl (%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::operator=(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>)
basic_json& operator=(basic_json other) noexcept (
        std::is_nothrow_move_constructible<value_t>::value&&
        std::is_nothrow_move_assignable<value_t>::value&&
        std::is_nothrow_move_constructible<json_value>::value&&
        std::is_nothrow_move_assignable<json_value>::value
    )
    {
        // check that passed value is valid
        other.assert_invariant();

        using std::swap;
        swap(m_type, other.m_type);
        swap(m_value, other.m_value);

        assert_invariant();
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x44cc0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x7e470
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x7e4a0
movq -0x18(%rbp), %rdi
callq 0x44cc0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::key() const
const typename object_t::key_type& key() const
    {
        JSON_ASSERT(m_object != nullptr);

        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
        {
            return m_it.object_iterator->first;
        }

        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, (%rax)
je 0x1293c
jmp 0x1295b
leaq 0xb1fa6(%rip), %rdi     # 0xc48e9
leaq 0xb0023(%rip), %rsi     # 0xc296d
movl $0x2c74, %edx           # imm = 0x2C74
leaq 0xb5ad9(%rip), %rcx     # 0xc842f
callq 0xb410
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x4a990
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12971
jmp 0x12984
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x50090
addq $0x60, %rsp
popq %rbp
retq
movb $0x1, -0x3d(%rbp)
movl $0x20, %edi
callq 0xb2c0
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xba70
movq -0x50(%rbp), %rdx
leaq 0xb5b0e(%rip), %rsi     # 0xc84bc
leaq -0x28(%rbp), %rdi
callq 0x10b90
jmp 0x129b9
movq -0x58(%rbp), %rdi
movl $0xcf, %esi
leaq -0x28(%rbp), %rdx
callq 0x50110
jmp 0x129cd
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x1093f4(%rip), %rsi    # 0x11bdd0
leaq 0x3d87d(%rip), %rdx     # 0x50260
callq 0xb9f0
jmp 0x12a32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x12a0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xbb98
leaq -0x29(%rbp), %rdi
callq 0xb600
testb $0x1, -0x3d(%rbp)
jne 0x12a1e
jmp 0x12a27
movq -0x58(%rbp), %rdi
callq 0xb460
jmp 0x12a29
movq -0x38(%rbp), %rdi
callq 0xba60
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Falldog[P]dcinja/src/include/nlohmann/json.hpp
// Function: nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::operator++()
iter_impl& operator++()
    {
        JSON_ASSERT(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
            {
                std::advance(m_it.object_iterator, 1);
                break;
            }

            case value_t::array:
            {
                std::advance(m_it.array_iterator, 1);
                break;
            }

            default:
            {
                ++m_it.primitive_iterator;
                break;
            }
        }

        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x12a5c
jmp 0x12a7b
leaq 0xb1e86(%rip), %rdi     # 0xc48e9
leaq 0xaff03(%rip), %rsi     # 0xc296d
movl $0x2b54, %edx           # imm = 0x2B54
leaq 0xb5934(%rip), %rcx     # 0xc83aa
callq 0xb410
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
subb $0x1, %al
je 0x12a96
jmp 0x12a8d
movb -0x11(%rbp), %al
subb $0x2, %al
je 0x12aaa
jmp 0x12ac2
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x74af0
jmp 0x12ad3
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x74b40
jmp 0x12ad3
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x74b90
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Environment::set_expression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void set_expression(const std::string &open, const std::string &close) {
    lexer_config.expression_open = open;
    lexer_config.expression_open_force_lstrip = open + "-";
    lexer_config.expression_close = close;
    lexer_config.expression_close_force_rstrip = "-" + close;
    lexer_config.update_open_chars();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rsi
addq $0x40, %rdi
addq $0xc0, %rdi
callq 0xb070
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq 0xaf8c6(%rip), %rdx     # 0xc2655
callq 0x27a30
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
addq $0xe0, %rdi
leaq -0x38(%rbp), %rsi
callq 0xb6f0
leaq -0x38(%rbp), %rdi
callq 0xbb98
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0xb070
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq 0xaf879(%rip), %rsi     # 0xc2655
callq 0x1ce80
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
addq $0x120, %rdi            # imm = 0x120
leaq -0x58(%rbp), %rsi
callq 0xb6f0
leaq -0x58(%rbp), %rdi
callq 0xbb98
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
callq 0x2ebc0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Environment::set_statement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void set_statement(const std::string &open, const std::string &close) {
    lexer_config.statement_open = open;
    lexer_config.statement_open_no_lstrip = open + "+";
    lexer_config.statement_open_force_lstrip = open + "-";
    lexer_config.statement_close = close;
    lexer_config.statement_close_force_rstrip = "-" + close;
    lexer_config.update_open_chars();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq -0x10(%rbp), %rsi
addq $0x40, %rdi
callq 0xb070
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq 0xaf7f6(%rip), %rdx     # 0xc2651
callq 0x27a30
movq -0x80(%rbp), %rdi
addq $0x40, %rdi
addq $0x20, %rdi
leaq -0x38(%rbp), %rsi
callq 0xb6f0
leaq -0x38(%rbp), %rdi
callq 0xbb98
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
leaq 0xaf7c8(%rip), %rdx     # 0xc2655
callq 0x27a30
movq -0x80(%rbp), %rdi
addq $0x40, %rdi
addq $0x40, %rdi
leaq -0x58(%rbp), %rsi
callq 0xb6f0
leaq -0x58(%rbp), %rdi
callq 0xbb98
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rdi
addq $0x60, %rdi
callq 0xb070
movq -0x18(%rbp), %rdx
leaq -0x78(%rbp), %rdi
leaq 0xaf781(%rip), %rsi     # 0xc2655
callq 0x1ce80
movq -0x80(%rbp), %rdi
addq $0x40, %rdi
addq $0x80, %rdi
leaq -0x78(%rbp), %rsi
callq 0xb6f0
leaq -0x78(%rbp), %rdi
callq 0xbb98
movq -0x80(%rbp), %rdi
addq $0x40, %rdi
callq 0x2ebc0
addq $0x80, %rsp
popq %rbp
retq
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Lexer::start(std::basic_string_view<char, std::char_traits<char>>)
void start(nonstd::string_view input) {
    m_in = input;
    tok_start = 0;
    pos = 0;
    state = State::Text;
    minus_state = MinusState::Number;

    // Consume byte order mark (BOM) for UTF-8
    if (inja::string_view::starts_with(m_in, "\xEF\xBB\xBF")) {
      m_in = m_in.substr(3);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movl $0x0, 0x8(%rax)
movl $0x1, 0xc(%rax)
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
leaq 0x8f7e4(%rip), %rsi     # 0xc27d9
callq 0x31e20
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x36700
testb $0x1, %al
jne 0x33015
jmp 0x3304d
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0x36790
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Parser::get_next_token()
void get_next_token() {
    if (have_peek_tok) {
      tok = peek_tok;
      have_peek_tok = false;
    } else {
      tok = lexer.scan();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x78(%rax)
je 0x3309c
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rcx
movq %rcx, 0x48(%rax)
movq 0x68(%rax), %rcx
movq %rcx, 0x50(%rax)
movq 0x70(%rax), %rcx
movq %rcx, 0x58(%rax)
movb $0x0, 0x78(%rax)
jmp 0x330c9
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x369d0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x58(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Token::describe[abi:cxx11]() const
std::string describe() const {
    switch (kind) {
    case Kind::Text:
      return "<text>";
    case Kind::LineStatementClose:
      return "<eol>";
    case Kind::Eof:
      return "<eof>";
    default:
      return static_cast<std::string>(text);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x34de9
jmp 0x34dce
movl -0x2c(%rbp), %eax
subl $0x4, %eax
je 0x34e34
jmp 0x34dd8
movl -0x2c(%rbp), %eax
subl $0x22, %eax
je 0x34e7f
jmp 0x34ec4
leaq -0x11(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xba70
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x91296(%rip), %rsi     # 0xc609b
callq 0x10b90
jmp 0x34e0c
leaq -0x11(%rbp), %rdi
callq 0xb600
jmp 0x34f12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0xb600
jmp 0x34f1c
leaq -0x25(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xba70
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x91252(%rip), %rsi     # 0xc60a2
callq 0x10b90
jmp 0x34e57
leaq -0x25(%rbp), %rdi
callq 0xb600
jmp 0x34f12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0xb600
jmp 0x34f1c
leaq -0x26(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xba70
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x9120d(%rip), %rsi     # 0xc60a8
callq 0x10b90
jmp 0x34ea2
leaq -0x26(%rbp), %rdi
callq 0xb600
jmp 0x34f12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0xb600
jmp 0x34f1c
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
leaq -0x27(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xba70
movq -0x48(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x31e70
jmp 0x34ef0
leaq -0x27(%rbp), %rdi
callq 0xb600
jmp 0x34f12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x27(%rbp), %rdi
callq 0xb600
jmp 0x34f1c
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xba60
nopw %cs:(%rax,%rax)
nop
// File: Falldog[P]dcinja/src/include/inja/inja.hpp
// Function: inja::Lexer::clear_final_line_if_whitespace(std::basic_string_view<char, std::char_traits<char>>)
static nonstd::string_view clear_final_line_if_whitespace(nonstd::string_view text) {
    nonstd::string_view result = text;
    while (!result.empty()) {
      char ch = result.back();
      if (ch == ' ' || ch == '\t') {
        result.remove_suffix(1);
      } else if (ch == '\n' || ch == '\r') {
        break;
      } else {
        return text;
      }
    }
    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x37660
xorb $-0x1, %al
testb $0x1, %al
jne 0x375e1
jmp 0x37639
leaq -0x30(%rbp), %rdi
callq 0x380e0
movb (%rax), %al
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x20, %eax
je 0x37601
movsbl -0x31(%rbp), %eax
cmpl $0x9, %eax
jne 0x37611
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x38110
jmp 0x37637
movsbl -0x31(%rbp), %eax
cmpl $0xa, %eax
je 0x37623
movsbl -0x31(%rbp), %eax
cmpl $0xd, %eax
jne 0x37625
jmp 0x37639
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x37649
jmp 0x375d0
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)