LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::addFile(BaseFile*)
void Directory::addFile(BaseFile* file)
{
	if (!childExists(file->getName()))
	{
		this->children.push_back(file);
		if (Directory* dir = dynamic_cast<Directory*>(file))
			dir->parent = this;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, -0x20(%rbp)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3954
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbd50
movl %eax, %r14d
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xbcd6
callq 0x31a0
testb %r14b, %r14b
jne 0xbd2b
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0xbcf3
movq -0x20(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x30(%rbx)
jmp 0xbd00
leaq 0x28(%rbx), %rdi
leaq -0x20(%rbp), %rdx
callq 0xc626
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xbd20
leaq 0x7060(%rip), %rsi      # 0x12d70
leaq 0x7069(%rip), %rdx      # 0x12d80
xorl %ecx, %ecx
callq 0x31f0
jmp 0xbd22
xorl %eax, %eax
testq %rax, %rax
je 0xbd2b
movq %rbx, 0x40(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xbd47
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::childExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Directory::childExists(std::string name)
{
	for (BaseFile* child : this->children)
		if (child->getName().compare(name) == 0)
			return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x30(%rbp)
movq 0x28(%rdi), %r13
movq 0x30(%rdi), %rbx
cmpq %rbx, %r13
setne %r14b
je 0xbdc8
leaq -0x40(%rbp), %r15
movq (%r13), %rax
movq %r15, -0x50(%rbp)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x3954
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x3040
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0xbdb6
callq 0x31a0
testl %r12d, %r12d
je 0xbdc8
addq $0x8, %r13
cmpq %rbx, %r13
setne %r14b
jne 0xbd7a
andb $0x1, %r14b
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0xbdef
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::getSize()
int Directory::getSize()
{
	int size = 0;
	for (BaseFile* child : this->children)
		size += child->getSize();
	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r14
movq 0x30(%rdi), %r15
xorl %ebx, %ebx
cmpq %r15, %r14
je 0xc06b
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
addl %eax, %ebx
addq $0x8, %r14
jmp 0xc056
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::childDirectoryExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Directory::childDirectoryExists(std::string name)
{
	for (BaseFile* child : this->children)
		if (child->getName().compare(name) == 0)
		{
			if (dynamic_cast<Directory*>(child))
				return true;
			return false;
		}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x40(%rbp)
movq 0x28(%rdi), %r12
movq 0x30(%rdi), %rax
movq %rax, -0x38(%rbp)
cmpq %rax, %r12
je 0xc456
leaq -0x50(%rbp), %r14
movl %eax, -0x2c(%rbp)
movq (%r12), %r15
movq %r14, -0x60(%rbp)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x3954
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
callq 0x3040
movl %eax, %r13d
movq -0x60(%rbp), %rdi
movq %r14, %rbx
cmpq %r14, %rdi
je 0xc41e
callq 0x31a0
testl %r13d, %r13d
jne 0xc444
movq %r15, %rdi
leaq 0x6943(%rip), %rsi      # 0x12d70
leaq 0x694c(%rip), %rdx      # 0x12d80
xorl %ecx, %ecx
callq 0x31f0
testq %rax, %rax
setne %al
movl %eax, -0x2c(%rbp)
testl %r13d, %r13d
je 0xc45a
addq $0x8, %r12
cmpq -0x38(%rbp), %r12
movq %rbx, %r14
jne 0xc3df
xorl %eax, %eax
jmp 0xc45d
movl -0x2c(%rbp), %eax
andb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0xc47f
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/talyerushalmy[P]SimpleFileSystem/src/Files.cpp
// Function: Directory::getChildByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
BaseFile* Directory::getChildByName(std::string name)
{
	for (BaseFile* child : this->children)
		if (child->getName().compare(name) == 0)
			return child;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x38(%rbp)
movq 0x28(%rdi), %r13
movq 0x30(%rdi), %rax
movq %rax, -0x30(%rbp)
cmpq %rax, %r13
je 0xc501
leaq -0x48(%rbp), %r14
movq (%r13), %r15
movq %r14, -0x58(%rbp)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x3954
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0x3040
movl %eax, %r12d
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0xc4ee
callq 0x31a0
testl %r12d, %r12d
cmoveq %r15, %rbx
je 0xc503
addq $0x8, %r13
cmpq -0x30(%rbp), %r13
jne 0xc4b2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0xc526
callq 0x31a0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/jmmccracken[P]PAI/ccmsrc.cpp
// Function: Pcorr(double*, double*, int)
double Pcorr(double dX[],double dY[],int iXY_length){

    double dEX = 0,  //expectation value of X
           dEY = 0,  //expectation value of Y
           dEXdelta,  //distance from mean for point in X
           dEYdelta,  //distance from mean for point in Y
           dSX = 0,  //variance of X
           dSY = 0,  //variance of Y
           dSXY = 0,  //covariance of X and Y
           dCovNorm;  //normalization factor for the covariance

    for(int iter = 0;iter < iXY_length;iter++ ){
        dEX += dX[iter];
        dEY += dY[iter];
    }

    dEX /= iXY_length;
    dEY /= iXY_length;

    for(int iter = 0;iter < iXY_length;iter++ ){
        dEXdelta = dX[iter]-dEX;
        dEYdelta = dY[iter]-dEY;
        dSX += dEXdelta*dEXdelta;
        dSY += dEYdelta*dEYdelta;
        dSXY += dEXdelta*dEYdelta;
    }

    dCovNorm = sqrt(dSX*dSY);
    if( dCovNorm == 0 ){
        dCovNorm = nan("");
        fprintf(stderr, "Warning in Pcorr(): division by zero\n");
    }

    return(dSXY/dCovNorm);
}

// Assembly:
xorpd %xmm7, %xmm7
movl %edx, %eax
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
testl %edx, %edx
jle 0x41ac
xorl %ecx, %ecx
addsd (%rdi,%rcx,8), %xmm1
addsd (%rsi,%rcx,8), %xmm2
incq %rcx
cmpq %rcx, %rax
jne 0x419a
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x420b
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
divsd %xmm0, %xmm1
divsd %xmm0, %xmm2
xorpd %xmm7, %xmm7
xorl %ecx, %ecx
xorpd %xmm3, %xmm3
xorpd %xmm0, %xmm0
movsd (%rdi,%rcx,8), %xmm4
subsd %xmm1, %xmm4
movsd (%rsi,%rcx,8), %xmm5
subsd %xmm2, %xmm5
movapd %xmm4, %xmm6
mulsd %xmm4, %xmm6
addsd %xmm6, %xmm0
mulsd %xmm5, %xmm4
mulsd %xmm5, %xmm5
addsd %xmm5, %xmm3
addsd %xmm4, %xmm7
incq %rcx
cmpq %rcx, %rax
jne 0x41d1
mulsd %xmm3, %xmm0
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4224
sqrtsd %xmm0, %xmm0
jmp 0x4237
movsd %xmm7, -0x10(%rbp)
callq 0x3140
xorpd %xmm1, %xmm1
movsd -0x10(%rbp), %xmm7
ucomisd %xmm1, %xmm0
jne 0x423f
jnp 0x424e
divsd %xmm0, %xmm7
movapd %xmm7, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq -0x18(%rbp), %rbx
movq %rbx, %rdi
movsd %xmm7, -0x10(%rbp)
callq 0x3859
movsd -0x10(%rbp), %xmm7
movsd (%rbx), %xmm0
jmp 0x423f
// File: /workspace/github_cpp_makefile_star2_O1/jmmccracken[P]PAI/ccmsrc.cpp
// Function: iMode(int*, int)
int iMode(int iA[],int iAlength){

    int iRepetitions[iAlength];

    for(int iter = 0; iter < iAlength;iter++ ){
        iRepetitions[iter] = 0;
        for(int iter2 = 0;iter2 < iAlength;iter2++ ){
            if( iA[iter2] == iA[iter] ){
                iRepetitions[iter]++;
            }
        }
    }

    int iMaxIter = 0,
        iCurrentRepCount = iRepetitions[0];
    for (int iter = 1;iter < iAlength;iter++ ){
        if( iRepetitions[iter] > iCurrentRepCount ){
            iMaxIter = iter;
            iCurrentRepCount = iRepetitions[iter];
        }
    }

    return( iA[iMaxIter] );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
movq %rsp, %rcx
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
subq %rdx, %rcx
movq %rcx, %rsp
testl %esi, %esi
jle 0x4529
xorl %edx, %edx
movl $0x0, (%rcx,%rdx,4)
movl (%rdi,%rdx,4), %r8d
xorl %r9d, %r9d
cmpl %r8d, (%rdi,%r9,4)
jne 0x4519
incl (%rcx,%rdx,4)
incq %r9
cmpq %r9, %rax
jne 0x4510
incq %rdx
cmpq %rax, %rdx
jne 0x4502
xorl %edx, %edx
cmpl $0x2, %esi
jl 0x4552
movl (%rcx), %esi
movl $0x1, %r8d
movl (%rcx,%r8,4), %r9d
cmpl %esi, %r9d
cmovgl %r8d, %edx
cmovgl %r9d, %esi
incq %r8
cmpq %r8, %rax
jne 0x4538
movslq %edx, %rdx
movl (%rdi,%rdx,4), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jmmccracken[P]PAI/ccmsrc.cpp
// Function: eDist(double*, double*, int)
double eDist(double dX[],double dY[],int iXY_length){

    double dRunningSum = 0;

    for(int iter = 0; iter < iXY_length; iter++ ){
        dRunningSum += (dX[iter]-dY[iter])*(dX[iter]-dY[iter]);
    }

    return(sqrt(dRunningSum));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x4588
movl %edx, %eax
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm2
subsd (%rsi,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x456e
ucomisd %xmm1, %xmm0
jb 0x4594
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x3140
// File: /workspace/github_cpp_makefile_star2_O1/jmmccracken[P]PAI/ccmsrc.cpp
// Function: FindAndCheckIndex(double*, int, double, int*, int)
int FindAndCheckIndex(double dValues2BCompared[],int iValues2BCompared_length,double dValue2Compare,int iIndices2Check[],int iIndices2Check_length){

    bool bUniqueIndex = true,
         bFoundMatch = false;

    for(int iter = 0;iter < iValues2BCompared_length;iter++ ){
        if( dValues2BCompared[iter] == dValue2Compare ){
            bFoundMatch = true;
        }
        if( bFoundMatch ){
            bUniqueIndex = true;
            for(int iIndexCheckStep = 0;iIndexCheckStep < iIndices2Check_length;iIndexCheckStep++ ){
                bUniqueIndex &= (iter != iIndices2Check[iIndexCheckStep]);
            }
            if( bUniqueIndex ){
                return(iter);
            }
        }
        bFoundMatch = false;
    }

    fprintf(stderr, "Error in FindAndCheckIndex(): no match was found, so an index of -1 will be returned\n");
    return(-1);
}

// Assembly:
testl %esi, %esi
jle 0x45df
movl %esi, %esi
movl %ecx, %r8d
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x45d7
jp 0x45d7
testl %ecx, %ecx
jle 0x45ee
movb $0x1, %r9b
xorl %r10d, %r10d
movl (%rdx,%r10,4), %r11d
cmpq %r11, %rax
setne %r11b
andb %r11b, %r9b
incq %r10
cmpq %r10, %r8
jne 0x45bc
testb %r9b, %r9b
jne 0x45ee
incq %rax
cmpq %rsi, %rax
jne 0x45a5
pushq %rbp
movq %rsp, %rbp
callq 0x390c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]codecon/src/golf.cc
// Function: solve(std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>> const&, unsigned int, unsigned int, unsigned int)
auto solve(const std::vector<std::vector<unsigned>>& map, unsigned target,
           unsigned position, unsigned steps) -> unsigned {
  if (steps > 0u) {
    return std::accumulate(
        std::begin(map[position]), std::end(map[position]), 0u,
        [&map, target, steps](unsigned acc, unsigned newPos) {
          return acc + solve(map, target, newPos, steps - 1);
        });
  }
  if (position == target) {
    return 1u;
  }
  return 0u;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %ecx, %ecx
je 0x130c
movl %ecx, %ebp
movq %rdi, %r14
movl %edx, %eax
movq (%rdi), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r12
movq 0x8(%rcx,%rax,8), %r13
cmpq %r13, %r12
je 0x1317
decl %ebp
xorl %r15d, %r15d
movl (%r12), %edx
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %ecx
callq 0x12bc
addl %eax, %r15d
addq $0x4, %r12
cmpq %r13, %r12
jne 0x12ee
jmp 0x131a
xorl %r15d, %r15d
cmpl %ebx, %edx
sete %r15b
jmp 0x131a
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::QueryProcessor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
QueryProcessor::QueryProcessor(string query) {
    JSONPathParser::updateQueryAutomaton(query, this->qa);
    this->mOutput.clear();
    this->mNumMatches = 0;
    this->mText = new char[MAX_TEXT_LENGTH];
    init(); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x750(%rdi), %rax
xorl %ecx, %ecx
movabsq $0x6c0000006c, %rdx     # imm = 0x6C0000006C
movl $0x49c, %edi            # imm = 0x49C
xorl %r8d, %r8d
movq %rdx, -0x4(%rax,%r8)
addq $0x74, %r8
cmpq $0x488, %r8             # imm = 0x488
jne 0x16605
movl $0x1, 0xb6c(%rbx,%rcx)
movb $0x0, 0xb7c(%rbx,%rcx)
addq %rdi, %rcx
addq %rdi, %rax
cmpq $0xe678, %rcx           # imm = 0xE678
jne 0x16602
movl $0xffffffff, 0xed5c(%rbx) # imm = 0xFFFFFFFF
movl $0x0, 0xeef0(%rbx)
movl $0x1, 0x6e0(%rbx)
leaq 0xef10(%rbx), %r15
movq %r15, 0xef00(%rbx)
movq $0x0, 0xef08(%rbx)
movb $0x0, 0xef10(%rbx)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2582c
leaq 0x6e0(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1617c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x166b8
callq 0x26000
xorl %eax, %eax
movq %rax, 0xef08(%rbx)
movq 0xef00(%rbx), %rcx
movb $0x0, (%rcx)
movq %rax, 0xeef8(%rbx)
movl $0x2710, %edi           # imm = 0x2710
callq 0x26d40
movq %rax, 0x6d0(%rbx)
movq %rbx, %rdi
callq 0x16728
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1670e
callq 0x26000
jmp 0x1670e
movq %rax, %r14
movq 0xef00(%rbx), %rdi
cmpq %r15, %rdi
je 0x1671f
callq 0x26000
movq %r14, %rdi
callq 0x13720
nop
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::init()
void QueryProcessor::init() {
    structural_table =
        _mm256_setr_epi8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '{', 0, '}', 0, 0,
                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '{', 0, '}', 0, 0);
    struct_mask = _mm256_set1_epi8(0x20);
    // vectors for structural characters
    v_quote = _mm256_set1_epi8(0x22);
    v_colon = _mm256_set1_epi8(0x3a);
    v_escape = _mm256_set1_epi8(0x5c);
    v_lbrace = _mm256_set1_epi8(0x7b);
    v_rbrace = _mm256_set1_epi8(0x7d);
    v_comma = _mm256_set1_epi8(0x2c);
    v_lbracket = _mm256_set1_epi8(0x5b);
    v_rbracket = _mm256_set1_epi8(0x5d);
    // some global variables among internal functions
    top_word = -1;
    prev_iter_ends_odd_backslash = 0ULL;
    prev_iter_inside_quote = 0ULL;
    even_bits = 0x5555555555555555ULL;
    odd_bits = ~even_bits;
    start_id = 0;
    cb_mask = 0, colon_mask = 0, comma_mask = 0; mask = 0;
    colonbit = 0; quotebit = 0; commabit = 0; bracketbit = 0;
    cur_word = false;
    top_word = -1;
    cur_pos = 0; 
    this->mOutput.clear();
}

// Assembly:
vbroadcastf128 0xad95f(%rip), %ymm0 # ymm0 = mem[0,1,0,1]
vbroadcastsd 0xad906(%rip), %ymm1 # 0xc4040
vmovaps %ymm0, 0x120(%rdi)
vmovaps %ymm1, 0x100(%rdi)
vbroadcastsd 0xad8f5(%rip), %ymm0 # 0xc4048
vmovaps %ymm0, 0x140(%rdi)
vbroadcastsd 0xad8ec(%rip), %ymm0 # 0xc4050
vmovaps %ymm0, 0x160(%rdi)
vbroadcastsd 0xad8e3(%rip), %ymm0 # 0xc4058
vbroadcastsd 0xad8e2(%rip), %ymm1 # 0xc4060
vmovaps %ymm0, 0x180(%rdi)
vmovaps %ymm1, 0x1a0(%rdi)
vbroadcastsd 0xad8d1(%rip), %ymm0 # 0xc4068
vmovaps %ymm0, 0x1c0(%rdi)
vbroadcastsd 0xad8c8(%rip), %ymm0 # 0xc4070
vmovaps %ymm0, 0x1e0(%rdi)
vbroadcastsd 0xad8bf(%rip), %ymm0 # 0xc4078
vbroadcastsd 0xad8be(%rip), %ymm1 # 0xc4080
vmovaps %ymm0, 0x200(%rdi)
vmovaps %ymm1, 0x220(%rdi)
movq $-0x1, 0x270(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x240(%rdi)
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
movq %rax, 0x250(%rdi)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x258(%rdi)
xorl %eax, %eax
movq %rax, 0x88(%rdi)
vxorps %xmm1, %xmm1, %xmm1
vmovups %ymm1, 0x278(%rdi)
vmovups %ymm1, 0x281(%rdi)
vmovaps %xmm0, 0x2b0(%rdi)
movq %rax, 0x2c0(%rdi)
movq %rax, 0x2a8(%rdi)
movq %rax, 0xef08(%rdi)
movq 0xef00(%rdi), %rax
movb $0x0, (%rax)
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::setRecordText(char*, long)
void QueryProcessor::setRecordText(char* rec_text, long length) {
    this->mRecord = rec_text;
    this->mRecordLength = length;
    this->mNumTmpWords = length / 32;
    this->mNumWords = length / 64; 
}

// Assembly:
movq %rsi, 0x2c8(%rdi)
movq %rdx, 0x2d0(%rdi)
leaq 0x1f(%rdx), %rax
leaq 0x3f(%rdx), %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rax
cmovnsq %rdx, %rcx
sarq $0x5, %rax
movq %rax, 0x2d8(%rdi)
sarq $0x6, %rcx
movq %rcx, 0x2e0(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_colon(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_colon(bitmap& bm) {
    unsigned long colonbit0, colonbit;
    colonbit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_colon));
    colonbit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_colon));
    bm.colonbit = (colonbit << 32) | colonbit0;
    bm.colonbit = bm.colonbit & (~str_mask);
}

// Assembly:
vmovdqa 0x160(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpmovmskb %ymm1, %eax
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, (%rsi)
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, (%rsi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_comma(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_comma(bitmap& bm) {
    unsigned long commabit0, commabit;
    commabit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_comma));
    commabit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_comma));
    bm.commabit = (commabit << 32) | commabit0;
    bm.commabit = bm.commabit & (~str_mask);
}

// Assembly:
vmovdqa 0x1e0(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpmovmskb %ymm1, %eax
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, 0x8(%rsi)
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, 0x8(%rsi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_lbrace(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_lbrace(bitmap& bm) {
    unsigned long lbracebit0, lbracebit;
    lbracebit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_lbrace));
    lbracebit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_lbrace));
    bm.lbracebit = (lbracebit << 32) | lbracebit0;
    bm.lbracebit = bm.lbracebit & (~str_mask);
}

// Assembly:
vmovdqa 0x1a0(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpmovmskb %ymm1, %eax
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, 0x10(%rsi)
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, 0x10(%rsi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_rbrace(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_rbrace(bitmap& bm) {
    unsigned long rbracebit0, rbracebit;
    rbracebit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_rbrace));
    rbracebit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_rbrace));
    bm.rbracebit = (rbracebit << 32) | rbracebit0;
    bm.rbracebit = bm.rbracebit & (~str_mask);
}

// Assembly:
vmovdqa 0x1c0(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpmovmskb %ymm1, %eax
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, 0x18(%rsi)
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, 0x18(%rsi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_lbracket(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_lbracket(bitmap& bm) {
    unsigned long lbracketbit0, lbracketbit;
    lbracketbit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_lbracket));
    lbracketbit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_lbracket));
    bm.lbracketbit = (lbracketbit << 32) | lbracketbit0;
    bm.lbracketbit = bm.lbracketbit & (~str_mask);
}

// Assembly:
vmovdqa 0x200(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpmovmskb %ymm1, %eax
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, 0x20(%rsi)
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, 0x20(%rsi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::build_bitmap_rbracket(bitmap&)
__attribute__((always_inline)) void QueryProcessor::build_bitmap_rbracket(bitmap& bm) {
    unsigned long rbracketbit0, rbracketbit;
    rbracketbit0 = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text0, v_rbracket));
    rbracketbit = (unsigned)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v_text, v_rbracket));
    bm.rbracketbit = (rbracketbit << 32) | rbracketbit0;
    bm.rbracketbit = bm.rbracketbit & (~str_mask);
}

// Assembly:
vmovdqa 0x220(%rdi), %ymm0
vpcmpeqb 0xa0(%rdi), %ymm0, %ymm1
vpmovmskb %ymm1, %eax
vpcmpeqb 0xc0(%rdi), %ymm0, %ymm0
vpmovmskb %ymm0, %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, 0x28(%rsi)
movq (%rdi), %rax
notq %rax
andq %rcx, %rax
movq %rax, 0x28(%rsi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::get_interval(long&, unsigned long&)
__attribute__((always_inline)) IntervalInfo QueryProcessor::get_interval(long& pos, unsigned long& bitmap) {
    IntervalInfo itv_info;
    int relative_pos = pos % 64;
    unsigned long w_start = (1UL << relative_pos);
    unsigned long mask_start = w_start ^ (w_start - 1);
    bitmap = bitmap & (~mask_start);
    if (bitmap) {
        unsigned long w_end = bitmap & (-bitmap);
        unsigned long w_interval = (w_end - w_start) | w_end;
        itv_info.intervalbit = w_interval & (~mask_start);
        itv_info.is_complete = true;
    } else {
        // include the last character inside the word (incomplete interval)
        unsigned long w_end = (1UL << 63);
        unsigned long w_interval = (w_end - w_start) | w_end;
        itv_info.intervalbit = w_interval & (~mask_start);
        itv_info.is_complete = false;
    }
    return itv_info;
}

// Assembly:
movq (%rsi), %rcx
leal 0x3f(%rcx), %eax
testq %rcx, %rcx
cmovnsl %ecx, %eax
andl $0xc0, %eax
subl %eax, %ecx
movl $0x1, %edi
shlq %cl, %rdi
movq %rdi, %rax
negq %rax
movq %rax, %rsi
btcq %rcx, %rsi
movq (%rdx), %rcx
andq %rsi, %rcx
movq %rcx, (%rdx)
je 0x16d43
movq %rcx, %rdx
negq %rdx
andq %rcx, %rdx
movq %rdx, %rax
subq %rdi, %rax
orq %rdx, %rax
movb $0x1, %dl
jmp 0x16d4a
btsq $0x3f, %rax
xorl %edx, %edx
andq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::next_interval(unsigned long&)
__attribute__((always_inline)) IntervalInfo QueryProcessor::next_interval(unsigned long& bitmap) {
    IntervalInfo itv_info;
    unsigned long w_start = bitmap & (-bitmap);
    bitmap = bitmap & (bitmap - 1);
    if (bitmap) {
        unsigned long w_end = bitmap & (-bitmap);
        unsigned long w_interval = (w_end - w_start) | w_end;
        itv_info.intervalbit = w_interval;
        itv_info.is_complete = true;
    } else {
        // include the last character inside the word (incomplete interval)
        unsigned long w_end = (1UL << 63);
        unsigned long w_interval = (w_end - w_start) | w_end;
        itv_info.intervalbit = w_interval;
        itv_info.is_complete = false;
    }
    return itv_info;
}

// Assembly:
movq (%rsi), %rcx
leaq -0x1(%rcx), %rdx
andq %rcx, %rdx
movq %rdx, %rax
negq %rax
andq %rdx, %rax
movq %rdx, (%rsi)
negq %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
cmovbq %rax, %rsi
setb %dl
movq %rcx, %rdi
negq %rdi
andq %rcx, %rdi
subq %rdi, %rax
orq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::get_position(unsigned long&, int)
__attribute__((always_inline)) long QueryProcessor::get_position(unsigned long& bitmap, int number) {
    while (number > 1) {
        bitmap = bitmap & (bitmap - 1);
        --number;
    }
    unsigned long pos = top_word * 64 + __builtin_ctzll(bitmap);
    return pos;
}

// Assembly:
cmpl $0x2, %edx
jl 0x16dbd
movq (%rsi), %rax
incl %edx
movq %rax, %rcx
decq %rax
andq %rcx, %rax
decl %edx
cmpl $0x2, %edx
jg 0x16daa
movq %rax, (%rsi)
movq 0x270(%rdi), %rcx
shlq $0x6, %rcx
bsfq (%rsi), %rax
orq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::hasMoreElements(long&)
__attribute__((always_inline)) bool QueryProcessor::hasMoreElements(long& pos) {
    while (mRecord[pos] == ' ' || mRecord[pos] == '\n' || mRecord[pos] == '\r') ++pos;
    ++pos;
    while (mRecord[pos] == ' ' || mRecord[pos] == '\n' || mRecord[pos] == '\r') ++pos; 
    if (mRecord[pos] == ']') {
        return false;
    }
    if (mRecord[pos] == ',') ++pos;
    while (mRecord[pos] == ' ' || mRecord[pos] == '\n' || mRecord[pos] == '\r') ++pos;
    return true;
}

// Assembly:
movq 0x2c8(%rdi), %rax
movq (%rsi), %rdx
incq %rdx
movabsq $0x100002400, %rcx      # imm = 0x100002400
movzbl -0x1(%rax,%rdx), %edi
cmpq $0x20, %rdi
ja 0x18bdd
btq %rdi, %rcx
jae 0x18bdd
movq %rdx, (%rsi)
incq %rdx
jmp 0x18bbb
btq %rdi, %rcx
jae 0x18bea
incq %rdx
movq %rdx, (%rsi)
movzbl (%rax,%rdx), %edi
cmpq $0x20, %rdi
jbe 0x18bd4
cmpb $0x5d, %dil
je 0x18c19
cmpb $0x2c, %dil
jne 0x18bfc
incq %rdx
movq %rdx, (%rsi)
movq (%rsi), %rdx
incq %rdx
movzbl -0x1(%rax,%rdx), %r8d
cmpq $0x20, %r8
ja 0x18c19
btq %r8, %rcx
jae 0x18c19
movq %rdx, (%rsi)
jmp 0x18bff
cmpb $0x5d, %dil
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::hasMoreAttributes(long&)
__attribute__((always_inline)) bool QueryProcessor::hasMoreAttributes(long& pos) {
    // if current character is blank, skip this character until meeting a non-blank character
    while (mRecord[pos] == ' ') ++pos;
    ++pos;
    while (mRecord[pos] == ' ') {
        ++pos;
    }
    if (mRecord[pos] == '}') {
        return false;
    }
    if (mRecord[pos] == ',') ++pos;
    while (mRecord[pos] == ' ' || mRecord[pos] == '\n') ++pos; 
    return true;
}

// Assembly:
movq 0x2c8(%rdi), %rax
movq (%rsi), %rcx
cmpb $0x20, (%rax,%rcx)
jne 0x19d6b
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsi)
cmpb $0x20, 0x1(%rax,%rcx)
movq %rdx, %rcx
je 0x19d58
jmp 0x19d6e
movq %rcx, %rdx
incq %rdx
movq %rdx, (%rsi)
movb (%rax,%rdx), %cl
incq %rdx
cmpb $0x20, %cl
je 0x19d71
cmpb $0x7d, %cl
je 0x19da6
cmpb $0x2c, %cl
jne 0x19d8c
movq %rdx, (%rsi)
movq (%rsi), %rdx
incq %rdx
movzbl -0x1(%rax,%rdx), %edi
cmpl $0x20, %edi
je 0x19da1
cmpl $0xa, %edi
jne 0x19da6
movq %rdx, (%rsi)
jmp 0x19d8f
cmpb $0x7d, %cl
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::runQuery[abi:cxx11](Record*)
string QueryProcessor::runQuery(Record* rec) {
    setRecordText(rec->text + rec->rec_start_pos, rec->rec_length);
    init();
    long cur_pos = 0;
    char ch = getNextNonEmptyCharacter(cur_pos);
    bitmap bm;
    if (ch == '{' && qa.typeExpectedInObj() != NONE)
        object(cur_pos, bm);
    else if(ch == '[' && qa.typeExpectedInArr() != NONE)
        array(cur_pos, bm);
    return mOutput;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq 0x10(%rdx), %rcx
addq 0x8(%rdx), %rax
movq %rax, 0x2c8(%rsi)
movq %rcx, 0x2d0(%rsi)
leaq 0x1f(%rcx), %rax
leaq 0x3f(%rcx), %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rax
cmovnsq %rcx, %rdx
sarq $0x5, %rax
movq %rax, 0x2d8(%rsi)
sarq $0x6, %rdx
movq %rdx, 0x2e0(%rsi)
movq %rsi, %rdi
callq 0x16728
movq $0x0, 0x8(%rsp)
movq 0x2c8(%r14), %rcx
movb (%rcx), %al
cmpb $0x20, %al
jne 0x25775
movl $0x1, %edx
movq %rdx, 0x8(%rsp)
movb (%rcx,%rdx), %al
incq %rdx
cmpb $0x20, %al
je 0x25766
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x26(%rsp)
vmovups %ymm0, 0x10(%rsp)
cmpb $0x5b, %al
je 0x257b3
movzbl %al, %ecx
cmpl $0x7b, %ecx
jne 0x257fd
movslq 0x6e0(%r14), %rcx
testq %rcx, %rcx
je 0x257e8
imulq $0x49c, %rcx, %rcx      # imm = 0x49C
cmpl $0x6c, 0x2b0(%r14,%rcx)
jne 0x257e8
cmpb $0x5b, %al
jne 0x257fd
movslq 0x6e0(%r14), %rax
testq %rax, %rax
je 0x257d1
imulq $0x49c, %rax, %rax      # imm = 0x49C
cmpl $0x6c, 0x2b4(%r14,%rax)
je 0x257fd
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
vzeroupper
callq 0x209dc
jmp 0x257fd
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
vzeroupper
callq 0x1dc78
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0xef00(%r14), %rsi
movq 0xef08(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
vzeroupper
callq 0x2582c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/src/RecordLoader.cpp
// Function: RecordLoader::loadSingleRecord(char*)
Record* RecordLoader::loadSingleRecord(char* file_path) {
    unsigned long size;
    FILE* fp = fopen (file_path,"rb");
    if (fp == NULL) {
        return NULL;
    }
    fseek (fp, 0, SEEK_END);
    size = ftell(fp);
    rewind(fp);
    void* p;
    if (posix_memalign(&p, 64, (size + MAX_PAD)*sizeof(char)) != 0) {
        cout<<"Fail to allocate memory space for input record."<<endl;
    }
    char* record_text = (char*) p;
    size_t load_size = fread (record_text, 1, size, fp);
    if (load_size == 0) {
        cout<<"Fail to load the input record into memory"<<endl;
    }
    int remain = 64 - (size % 64);
    int counter = 0;
    // pad the input data where its size can be divided by 64
    while (counter < remain)
    {
        record_text[size+counter] = 'd';
        counter++;
    }
    record_text[size+counter]='\0';
    fclose(fp);
    // only one single record
    Record* record = new Record();
    record->text = record_text;
    record->rec_start_pos = 0;
    record->rec_length = strlen(record_text);
    return record;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x9e845(%rip), %rsi     # 0xc4110
callq 0x13240
testq %rax, %rax
je 0x25a17
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x131a0
movq %rbx, %rdi
callq 0x130f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x13470
leaq 0x40(%r14), %rdx
movq %rsp, %rdi
movl $0x40, %esi
callq 0x13130
testl %eax, %eax
je 0x25955
leaq 0xd8b66(%rip), %r15     # 0xfe480
leaq 0x9e7f2(%rip), %rsi     # 0xc4113
movl $0x2f, %edx
movq %r15, %rdi
callq 0x8eac0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x6fc10
movsbl %al, %esi
movq %r15, %rdi
callq 0x8e5c0
movq %rax, %rdi
callq 0x8db90
movq (%rsp), %r15
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x13530
testq %rax, %rax
jne 0x259b4
leaq 0xd8b08(%rip), %r12     # 0xfe480
leaq 0x9e7c4(%rip), %rsi     # 0xc4143
movl $0x29, %edx
movq %r12, %rdi
callq 0x8eac0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x6fc10
movsbl %al, %esi
movq %r12, %rdi
callq 0x8e5c0
movq %rax, %rdi
callq 0x8db90
movl %r14d, %r12d
andl $0x3f, %r12d
movl $0x40, %edx
subl %r12d, %edx
addq %r15, %r14
movq %r14, %rdi
movl $0x64, %esi
callq 0x130e0
subq %r12, %r14
movb $0x0, 0x40(%r14)
movq %rbx, %rdi
callq 0x13610
movl $0x20, %edi
callq 0x26d00
movq %rax, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rax)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb $0x1, 0x18(%rbx)
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x13370
movq %rax, 0x10(%rbx)
jmp 0x25a19
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/AutomataLab[P]JSONSki/example/example2.cpp
// Function: main
int main() {
    char* file_path = "../dataset/bestbuy_sample_large_record.json";
    Record* rec = RecordLoader::loadSingleRecord(file_path);
    if (rec == NULL) {
        cout<<"record loading fails."<<endl;
        return -1;
    }

    QueryProcessor processor("$.products[*].categoryPath[1:3].name");
    string output = processor.runQuery(rec);
    cout<<"matches are: "<<output<<endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
andq $-0x20, %rsp
subq $0xef80, %rsp           # imm = 0xEF80
leaq 0x9e3d3(%rip), %rdi     # 0xc41d6
callq 0x258bc
testq %rax, %rax
je 0x25edc
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9e3f4(%rip), %rsi     # 0xc4218
leaq 0x9e411(%rip), %rdx     # 0xc423c
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x25f70
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x165dc
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x25e54
callq 0x26000
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
movq %rbx, %rdx
callq 0x256f4
leaq 0xd8615(%rip), %rdi     # 0xfe480
leaq 0x9e3cb(%rip), %rsi     # 0xc423d
movl $0xd, %edx
callq 0x8eac0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0xd85f4(%rip), %rdi     # 0xfe480
callq 0x8eac0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6fc10
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8e5c0
movq %rax, %rdi
callq 0x8db90
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25ece
callq 0x26000
leaq 0x40(%rsp), %rdi
callq 0x16854
xorl %eax, %eax
jmp 0x25f23
leaq 0xd859d(%rip), %rbx     # 0xfe480
leaq 0x9e318(%rip), %rsi     # 0xc4202
movl $0x15, %edx
movq %rbx, %rdi
callq 0x8eac0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6fc10
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8e5c0
movq %rax, %rdi
callq 0x8db90
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x25f5d
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x25f67
callq 0x26000
jmp 0x25f67
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25f5d
callq 0x26000
leaq 0x40(%rsp), %rdi
callq 0x16854
movq %rbx, %rdi
callq 0x13720
nop
// File: /workspace/github_cpp_makefile_star2_O1/eschwabe[P]interview-practice/src/stablesort.cpp
// Function: stablesort(int*, int)
void stablesort(int array[], int length) {
    for(int idx = 0; idx < length-1; idx++) {
        int target = idx;
        for(int tidx = idx; tidx < length; tidx++) {
            if( array[target] > array[tidx] ) {
                target = tidx;
            }
        }
        std::cout << target << std::endl;
        int val = array[target];
        memmove(array+idx+1, array+idx, (target-idx)*sizeof(int));
        array[idx] = val;
    }
}

// Assembly:
cmpl $0x2, %esi
jl 0x12a2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r13d
decl %ebx
xorl %r15d, %r15d
movl %r15d, %ebp
cmpq %r13, %r15
jae 0x1226
movq %r15, %rax
movl %r15d, %ecx
movslq %ecx, %rdx
movl (%r14,%rdx,4), %edx
movl %eax, %ebp
cmpl (%r14,%rax,4), %edx
jg 0x121c
movl %ecx, %ebp
incq %rax
movl %ebp, %ecx
cmpq %rax, %r13
jne 0x120b
movq 0x2dab(%rip), %rdi      # 0x3fd8
movl %ebp, %esi
callq 0x10a0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r12, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movslq %ebp, %rax
movl (%r14,%rax,4), %ebp
leaq (%r14,%r15,4), %rsi
leaq (%r14,%r15,4), %r12
addq $0x4, %r12
subl %r15d, %eax
movslq %eax, %rdx
shlq $0x2, %rdx
movq %r12, %rdi
callq 0x1090
movl %ebp, -0x4(%r12)
incq %r15
cmpq %rbx, %r15
jne 0x11fd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eschwabe[P]interview-practice/src/stablesort.cpp
// Function: main
int main()
{
    int array[10] = {3,4,5,23,7,21,4,7,1,87};
    for(auto a : array) {
        std::cout << a << " ";
    }
    std::cout << std::endl;
    stablesort(array, 10);
    for(auto a : array) {
        std::cout << a << " ";
    }
    std::cout << std::endl;
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movaps 0xd6d(%rip), %xmm0      # 0x2020
movaps %xmm0, 0x10(%rsp)
movaps 0xd51(%rip), %xmm0      # 0x2010
movaps %xmm0, (%rsp)
movabsq $0x5700000001, %rax     # imm = 0x5700000001
movq %rax, 0x20(%rsp)
xorl %r15d, %r15d
movq 0x2cfc(%rip), %rbx      # 0x3fd8
leaq 0xd55(%rip), %r14       # 0x2038
movl (%rsp,%r15), %esi
movq %rbx, %rdi
callq 0x10a0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1070
addq $0x4, %r15
cmpq $0x28, %r15
jne 0x12e3
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rsp, %rdi
movl $0xa, %esi
callq 0x11dc
xorl %r15d, %r15d
leaq 0xcf1(%rip), %r14       # 0x2038
movl (%rsp,%r15), %esi
movq %rbx, %rdi
callq 0x10a0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1070
addq $0x4, %r15
cmpq $0x28, %r15
jne 0x1347
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/yaansz[P]just-a-terminal/terminal.cpp
// Function: BuiltInCommands::help(char**)
int BuiltInCommands::help(char** args) { 
    cout << "*****************" << endl; 
    cout << "List of builtins commands" << endl; 
     
     for (const auto &p : this->commands) { 
        cout << p.first << endl;
    }

    cout << "*****************" << endl; 

    return 0;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x596a(%rip), %rbx      # 0x7fd0
leaq 0x2a1c(%rip), %rsi      # 0x5089
movl $0x11, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x2995(%rip), %rsi      # 0x503d
movl $0x19, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x273a
movq 0x58e0(%rip), %r12      # 0x7fd0
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %r12, %rdi
callq 0x21f0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
cmpq %r14, %rax
jne 0x26f0
leaq 0x2948(%rip), %rsi      # 0x5089
movl $0x11, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yaansz[P]just-a-terminal/terminal.cpp
// Function: BuiltInCommands::execute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char**)
int BuiltInCommands::execute(const string cmd, char** args) 
{
    if(this->commands.find(cmd) != this->commands.end()) {
        #ifdef DEBUG
        cout << "Executing command: " << cmd << endl;
        #endif
        return this->commands.at(cmd)(args);
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x3c58
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x27d5
movq %r15, %rdi
movq %r14, %rsi
callq 0x31e4
movq %rbx, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x27e5
leaq -0x20(%rbp), %rsi
movq %rax, %rdi
callq *0x18(%rax)
jmp 0x27da
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/yaansz[P]just-a-terminal/terminal.cpp
// Function: execute(BuiltInCommands, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char**)
int execute(BuiltInCommands bic, const string cmd, char** args) 
{   
    int bic_return = bic.execute(cmd, args);
    // found in built in
    if(bic_return == 0) return 0;
    else if(bic_return == -1) return bic_return;

    #ifdef DEBUG
    cout << "bic_return: " << bic_return << endl;
    #endif

    pid_t pid = fork();
    
    if(pid == -1)
        cout << "Error to fork" << endl;

    // Running child proccess
    else if(pid == 0) {
        
        #ifdef DEBUG
        cout << "Path: " << std::filesystem::current_path() << endl; 
        cout << ":" << cmd.c_str() << ":" << endl;
        cout << ":" << args[1] << ":" << endl;
        #endif

        if(execvp(cmd.c_str(), args) < 0) {
            perror("error");
            cout << "Error to exec the command" << endl;
        }
        // Killing it 🤬😡😡😠
        exit(0);
    // Wait until the child process is killed
    } else {
        wait(NULL);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x38f4
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2792
movl %eax, %r15d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2848
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movl %r15d, %eax
incl %eax
cmpl $0x2, %eax
jae 0x2864
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
cmpl $-0x1, %eax
je 0x287e
testl %eax, %eax
je 0x28c5
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x2220
jmp 0x2852
movq 0x574b(%rip), %rbx      # 0x7fd0
leaq 0x27cb(%rip), %rsi      # 0x5057
movl $0xd, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
xorl %r15d, %r15d
jmp 0x2852
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2150
testl %eax, %eax
jns 0x28d9
callq 0x2320
xorl %edi, %edi
callq 0x2200
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x28f8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/yaansz[P]just-a-terminal/terminal.cpp
// Function: blank(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int blank(string str) {
    const char * cstr = str.c_str();
    
    for(int i = 0; i < str.length(); i++) {
        if (cstr[i] != ' ')
            return 0;
    }
    return 1;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
sete %dl
je 0x2936
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
cmpb $0x20, (%rcx)
jne 0x2935
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x292f
leaq 0x1(%rdx), %rsi
cmpb $0x20, (%rcx,%rdx)
je 0x291d
cmpq %rdx, %rax
setbe %dl
popq %rbp
movzbl %dl, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/yaansz[P]just-a-terminal/terminal.cpp
// Function: split(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&)
vector<string> split(const string& str, const string& delim)
{
    vector<string> tokens;
    size_t prev = 0, pos = 0;
    do
    {
        pos = str.find(delim, prev);
        if (pos == string::npos) pos = str.length();
        string token = str.substr(prev, pos-prev);
        if (!token.empty()) tokens.push_back(token);
        prev = pos + delim.length();
    }
    while (pos < str.length() && prev < str.length());
    return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
xorl %r13d, %r13d
leaq -0x50(%rbp), %r12
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %r13, %rdx
callq 0x22d0
movq %rax, %rbx
cmpq $-0x1, %rax
jne 0x2989
movq 0x8(%r15), %rbx
movq %rbx, %rcx
subq %r13, %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x21d0
cmpq $0x0, -0x48(%rbp)
je 0x29b0
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x3242
movq 0x8(%r14), %r13
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x29cd
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq 0x8(%r15), %rax
cmpq %rax, %rbx
jae 0x29de
addq %rbx, %r13
cmpq %rax, %r13
jb 0x296a
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x2a12
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x2a12
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x328e
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/Wheatwizard[P]Waldo/Atom.cpp
// Function: Atom::operator+(Atom&) const
Atom Atom::operator+(Atom& other) const {
	if (this->type == other.type) {
		return Atom(this->type, this->value + other.value);
	} else {
		//TODO throw an error
		throw 10; // this should stop it from generating a warning
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl (%rsi), %eax
cmpl (%rdx), %eax
jne 0x2704
movq %rdi, %rbx
movl 0x4(%rdx), %ecx
addl 0x4(%rsi), %ecx
movl %eax, (%rdi)
movl %ecx, 0x4(%rdi)
leaq 0x8(%rdi), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x3b48
addq $0x10, %r15
cmpq $0x40, %r15
jne 0x26e0
movq $0x0, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x4, %edi
callq 0x2090
movl $0xa, (%rax)
movq 0x5885(%rip), %rsi      # 0x7fa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x21b0
nop