LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ricbit[P]dlx/cover_refactor.cc
// Function: ExactCover::solve(int)
void solve(int level) {
    if (header[0].rlink == 0) {
      count++;
      return;
    }
    int item = best_item();
    cover(item);
    solution[level] = nodes[item].dlink;
    for (auto& option = solution[level]; option != item; option = nodes[option].dlink) {
      try_option(option);
      solve(level + 1);
      rewind_option(option);
    }
    uncover(item);
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3780
cmpl $0x0, 0x4(%rax)
jne 0x7632
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rax)
jmp 0x7709
movq 0x8(%rsp), %rdi
callq 0x7710
movq 0x8(%rsp), %rdi
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %esi
callq 0x77e0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movslq 0x18(%rsp), %rsi
callq 0x4040
movq 0x8(%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
addq $0x38, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4060
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, (%rax)
addq $0x38, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4060
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
cmpl 0x18(%rsp), %eax
je 0x76fb
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %esi
callq 0x78b0
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
callq 0x75f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %esi
callq 0x78e0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x10(%rsp), %rax
movslq (%rax), %rsi
callq 0x4040
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
jmp 0x7699
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x7910
addq $0x28, %rsp
retq
nop
// File: ricbit[P]dlx/cover_refactor.cc
// Function: void ExactCover::option_right<ExactCover::hide(int)::'lambda'(int)>(int, ExactCover::hide(int)::'lambda'(int))
void option_right(int option, T action) {
    for (auto p = option + 1; p != option;) {
      if (nodes[p].top <= 0) {
        p = nodes[p].ulink;
      } else {
        action(p);
        p++;
      }
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
je 0x7a90
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movslq 0x10(%rsp), %rsi
callq 0x4040
cmpl $0x0, (%rax)
jg 0x7a75
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movslq 0x10(%rsp), %rsi
callq 0x4040
movl 0x4(%rax), %eax
movl %eax, 0x10(%rsp)
jmp 0x7a8e
movl 0x10(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x7aa0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x7a37
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ricbit[P]dlx/cover_refactor.cc
// Function: ExactCover::hide(int)::'lambda'(int)::operator()(int) const
void hide(int p) {
    option_right(p, [&](int q) {
      auto x = nodes[q].top;
      auto u = nodes[q].ulink;
      auto d = nodes[q].dlink;
      nodes[u].dlink = d;
      nodes[d].ulink = u;
      nodes[x].top--;
    });
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4040
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x18(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4040
movq 0x8(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4040
movq 0x8(%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
addq $0x18, %rdi
movslq 0x14(%rsp), %rsi
callq 0x4040
movl (%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x8(%rax)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x18, %rdi
movslq 0x10(%rsp), %rsi
callq 0x4040
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x4(%rax)
addq $0x18, %rdi
movslq 0x18(%rsp), %rsi
callq 0x4040
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ricbit[P]dlx/cover_refactor.cc
// Function: void ExactCover::option_left<ExactCover::rewind_option(int)::'lambda'(int)>(int, ExactCover::rewind_option(int)::'lambda'(int))
void option_left(int option, T action) {
    for (auto p = option - 1; p != option;) {
      if (nodes[p].top <= 0) {
        p = nodes[p].dlink;
      } else {
        action(p);
        p--;
      }
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
je 0x7cc0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movslq 0x10(%rsp), %rsi
callq 0x4040
cmpl $0x0, (%rax)
jg 0x7ca5
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movslq 0x10(%rsp), %rsi
callq 0x4040
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
jmp 0x7cbe
movl 0x10(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x7cd0
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x7c67
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ricbit[P]dlx/cover_refactor.cc
// Function: ExactCover::unhide(int)::'lambda'(int)::operator()(int) const
void unhide(int p) {
    option_left(p, [&](int q) {
      auto x = nodes[q].top;
      auto u = nodes[q].ulink;
      auto d = nodes[q].dlink;
      nodes[u].dlink = q;
      nodes[d].ulink = q;
      nodes[x].top++;
    });
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4040
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x18(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4040
movq 0x8(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4040
movq 0x8(%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, (%rsp)
addq $0x18, %rdi
movslq 0x14(%rsp), %rsi
callq 0x4040
movl (%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x8(%rax)
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x18, %rdi
movslq 0x10(%rsp), %rsi
callq 0x4040
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x4(%rax)
addq $0x18, %rdi
movslq 0x18(%rsp), %rsi
callq 0x4040
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::CleanUp()
void RegEx::CleanUp() {
	for(int i = 0; i < (int)m_NFATable.size(); ++i) {
		delete m_NFATable[i];
	}
	m_NFATable.clear();

	for(int i = 0; i < (int)m_DFATable.size(); ++i)
		delete m_DFATable[i];
	m_DFATable.clear();

	m_nNextStateID = 0;

	while(!m_CharacterClassStack.empty())
		m_CharacterClassStack.pop();

	while(!m_ExpressionStack.empty())
		m_ExpressionStack.pop();

	m_InputSet.clear();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0xa5d0
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x7195
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xa5f0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x7188
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x718a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x714b
movq -0x18(%rbp), %rdi
callq 0xa610
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x18, %rdi
callq 0xa5d0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x71f7
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa5f0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x71ea
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x71ec
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x71a5
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0xa610
movq -0x18(%rbp), %rax
movl $0x0, 0x14c(%rax)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xa630
xorb $-0x1, %al
testb $0x1, %al
jne 0x7227
jmp 0x7236
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xa650
jmp 0x7212
jmp 0x7238
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
callq 0xa670
xorb $-0x1, %al
testb $0x1, %al
jne 0x7250
jmp 0x7262
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
callq 0xa690
jmp 0x7238
movq -0x18(%rbp), %rdi
addq $0xd0, %rdi
callq 0xa6b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::IsMetaChar(char)
bool RegEx::IsMetaChar( char inputCh ) {
	return(( inputCh == CLOSURE )      || 
		   ( inputCh == OR )           || 
		   ( inputCh == OPEN_PAREN )   || 
		   ( inputCh == CLOSE_PAREN )  || 
		   ( inputCh == PLUS_CLOSURE ) ||
		   ( inputCh == FALSE_CONCAT ) ||
		   ( inputCh == OPTIONAL ));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x2a, %ecx
movb %al, -0xa(%rbp)
je 0x72ef
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x7c, %ecx
movb %al, -0xa(%rbp)
je 0x72ef
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x28, %ecx
movb %al, -0xa(%rbp)
je 0x72ef
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x29, %ecx
movb %al, -0xa(%rbp)
je 0x72ef
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x2b, %ecx
movb %al, -0xa(%rbp)
je 0x72ef
movsbl -0x9(%rbp), %ecx
movb $0x1, %al
cmpl $0x26, %ecx
movb %al, -0xa(%rbp)
je 0x72ef
movsbl -0x9(%rbp), %eax
cmpl $0x3f, %eax
sete %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::PopTable(std::vector<RegExState*, std::allocator<RegExState*>>&)
bool RegEx::PopTable(Table  &NFATable) {
	if(m_CharacterClassStack.size()>0) {
		NFATable = m_CharacterClassStack.top();
		m_CharacterClassStack.pop();
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x30, %rdi
callq 0xa6d0
cmpq $0x0, %rax
jbe 0x73c3
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0xa6f0
movq %rax, %rsi
movq -0x18(%rbp), %rdi
callq 0xa710
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0xa650
movb $0x1, -0x1(%rbp)
jmp 0x73c7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::Concatenate()
bool RegEx::Concatenate() {

    Table  LeftTable, RightTable;
    if(!PopTable(RightTable) || !PopTable(LeftTable))
		return false;

	(*(LeftTable.rbegin()))->AddTransition(EPSILON, (*(RightTable.begin())));
	LeftTable.insert(LeftTable.end(), RightTable.begin(), RightTable.end());
	m_CharacterClassStack.push(LeftTable);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa470
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xa470
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x7370
movb %al, -0x89(%rbp)
jmp 0x742e
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x743a
jmp 0x745e
movq -0xa0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7370
movb %al, -0xa1(%rbp)
jmp 0x7452
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x7491
jmp 0x745e
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x758c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa530
leaq -0x28(%rbp), %rdi
callq 0xa530
jmp 0x75ac
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xa960
movq -0xb8(%rbp), %rdi
callq 0xa9b0
movq %rax, -0xb0(%rbp)
jmp 0x74ba
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa9e0
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xaa10
movq -0xc0(%rbp), %rdi
movq (%rax), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x13ec0
jmp 0x74f7
leaq -0x28(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xaae0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xab10
leaq -0x40(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xa9e0
movq -0xd8(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0xaae0
movq -0xd0(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0xaa30
movq %rax, -0xc8(%rbp)
jmp 0x755d
movq -0xa0(%rbp), %rdi
movq -0xc8(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x30, %rdi
leaq -0x28(%rbp), %rsi
callq 0xab50
jmp 0x7581
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa530
leaq -0x28(%rbp), %rdi
callq 0xa530
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x33a0
nopw %cs:(%rax,%rax)
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::PushOnCharacterStack(char)
void RegEx::PushOnCharacterStack(char chInput) {

	RegExState *s0 = new RegExState(m_nNextStateID++);
	RegExState *s1 = new RegExState(m_nNextStateID++);

	s0->AddTransition(chInput, s1);

	Table NewSubTable;
	NewSubTable.push_back(s0);
	NewSubTable.push_back(s1);
	m_CharacterClassStack.push(NewSubTable);

	m_InputSet.insert(chInput);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x78, %edi
callq 0x3250
movq %rax, %rdi
movq -0x68(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x60(%rbp)
movl 0x14c(%rax), %esi
movl %esi, %ecx
incl %ecx
movl %ecx, 0x14c(%rax)
callq 0xab80
jmp 0x760c
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x78, %edi
callq 0x3250
movq %rax, %rdi
movq -0x68(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movl 0x14c(%rax), %esi
movl %esi, %ecx
incl %ecx
movl %ecx, 0x14c(%rax)
callq 0xab80
jmp 0x7643
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movsbl -0x9(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x13ec0
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xa470
movq -0x78(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
jmp 0x7678
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xabe0
jmp 0x7687
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
leaq -0x48(%rbp), %rsi
callq 0xab50
jmp 0x769a
movq -0x68(%rbp), %rdi
addq $0xd0, %rdi
leaq -0x9(%rbp), %rsi
callq 0xac50
movb %dl, -0x81(%rbp)
movq %rax, -0x80(%rbp)
jmp 0x76ba
movb -0x81(%rbp), %al
movq -0x80(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa530
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x78, %esi
callq 0x3260
jmp 0x772a
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x78, %esi
callq 0x3260
jmp 0x772a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa530
movq -0x20(%rbp), %rdi
callq 0x33a0
nopw %cs:(%rax,%rax)
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::Move(char, std::set<RegExState*, std::less<RegExState*>, std::allocator<RegExState*>>, std::set<RegExState*, std::less<RegExState*>, std::allocator<RegExState*>>&)
void RegEx::Move(char chInput, std::set<RegExState*> NFAState, std::set<RegExState*> &Result) {

	Result.clear();
	StateIterator iter;
	for(iter = NFAState.begin(); iter != NFAState.end(); ++iter) {
		Table States;
		(*iter)->GetTransition(chInput, States);
		for(int index = 0; index < (int)States.size(); ++index){
			Result.insert(States[index]);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x78(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaed0
leaq -0x28(%rbp), %rdi
callq 0xaf20
movq -0x78(%rbp), %rdi
callq 0xaf40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x78(%rbp), %rdi
callq 0xafa0
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xaf70
testb $0x1, %al
jne 0x862b
jmp 0x86fc
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xa470
leaq -0x28(%rbp), %rdi
callq 0xb000
movq -0x80(%rbp), %rdx
movq (%rax), %rdi
movsbl -0x9(%rbp), %esi
callq 0x13fd0
jmp 0x8653
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x84(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa5d0
movq %rax, %rcx
movl -0x84(%rbp), %eax
cmpl %ecx, %eax
jge 0x86e5
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movslq -0x60(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa5f0
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0xb190
movb %dl, -0x91(%rbp)
movq %rax, -0x90(%rbp)
jmp 0x86af
movb -0x91(%rbp), %al
movq -0x90(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x865a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa530
jmp 0x8705
leaq -0x50(%rbp), %rdi
callq 0xa530
leaq -0x28(%rbp), %rdi
callq 0xb030
jmp 0x8608
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x33a0
nop
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::Compile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool RegEx::Compile(std::string strRegEx) {

	while ( strRegEx.find( "[" ) != std::string::npos ) {
		strRegEx = PreProcessBracket(strRegEx);
	}

	m_InfixRegEx = const_cast<char*>(strRegEx.c_str());
	CleanUp();
	
	if(!ConstructThompsonNFA())
		return false;	

	PopTable( m_NFATable);
	m_NFATable[m_NFATable.size() - 1 ]->m_bAcceptingState = true;
	
	ConvertNFAtoDFA();
	MinimizeDFA();
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x78(%rbp), %rdi
leaq 0xd045(%rip), %rsi      # 0x165cf
xorl %eax, %eax
movl %eax, %edx
callq 0x3400
cmpq $-0x1, %rax
je 0x95f5
movq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x30d0
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x91a0
jmp 0x95bd
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x32f0
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq -0x58(%rbp), %rdi
callq 0x3140
jmp 0x957f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3140
jmp 0x9671
movq -0x78(%rbp), %rdi
callq 0x30c0
movq -0x70(%rbp), %rdi
movq %rax, 0x140(%rdi)
callq 0x7130
movq -0x70(%rbp), %rdi
callq 0x9680
testb $0x1, %al
jne 0x9621
movb $0x0, -0x1(%rbp)
jmp 0x9663
movq -0x70(%rbp), %rsi
movq %rsi, %rdi
callq 0x7370
movq -0x70(%rbp), %rdi
callq 0xa5d0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xa5f0
movq -0x70(%rbp), %rdi
movq (%rax), %rax
movb $0x1, 0x6c(%rax)
callq 0x8710
movq -0x70(%rbp), %rdi
callq 0x9190
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x33a0
nopw (%rax,%rax)
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::ConstructThompsonNFA()
bool RegEx::ConstructThompsonNFA() {
	CovertToPostfix();
	for(int i = 0; i < (int)m_PostStrRegEx.size(); ++i) {
		char curChar = m_PostStrRegEx[i];
		if ( IsInput( curChar )) {
			PushOnCharacterStack( curChar );
		} else if ( IsMetaChar( curChar ) ) {
			switch ( curChar ) {
				case CLOSURE:
					Closure();
					break;
				case PLUS_CLOSURE:
					ClosurePlus();
					break;
				case OPTIONAL:
					ClosureOptional();
					break;
				case OR:
					Or();
					break;
				case FALSE_CONCAT:
					Concatenate();
					break;
			}
		}		
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x9c20
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0x120, %rdi            # imm = 0x120
callq 0x3190
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x9794
movq -0x18(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movslq -0xc(%rbp), %rsi
callq 0x3410
movq -0x18(%rbp), %rdi
movb (%rax), %al
movb %al, -0xd(%rbp)
movsbl -0xd(%rbp), %esi
callq 0x7300
testb $0x1, %al
jne 0x96f0
jmp 0x9702
movq -0x18(%rbp), %rdi
movsbl -0xd(%rbp), %esi
callq 0x75c0
jmp 0x9784
movq -0x18(%rbp), %rdi
movsbl -0xd(%rbp), %esi
callq 0x7280
testb $0x1, %al
jne 0x9715
jmp 0x9782
movsbl -0xd(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x26, %eax
je 0x9777
jmp 0x9723
movl -0x20(%rbp), %eax
subl $0x2a, %eax
je 0x974b
jmp 0x972d
movl -0x20(%rbp), %eax
subl $0x2b, %eax
je 0x9756
jmp 0x9737
movl -0x20(%rbp), %eax
subl $0x3f, %eax
je 0x9761
jmp 0x9741
movl -0x20(%rbp), %eax
subl $0x7c, %eax
je 0x976c
jmp 0x9780
movq -0x18(%rbp), %rdi
callq 0x7c60
jmp 0x9780
movq -0x18(%rbp), %rdi
callq 0x79a0
jmp 0x9780
movq -0x18(%rbp), %rdi
callq 0x7740
jmp 0x9780
movq -0x18(%rbp), %rdi
callq 0x7f30
jmp 0x9780
movq -0x18(%rbp), %rdi
callq 0x73e0
jmp 0x9782
jmp 0x9784
jmp 0x9786
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x96a0
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool RegEx::Match(std::string strText) {
	m_strText = strText;
	RegExState *pState = m_DFATable[0];
	std::vector<RegExState*>  Transition;
	for(int i = 0; i < (int)m_strText.size(); ++i) {
		char CurrChar = m_strText[i];		
		pState->GetTransition(CurrChar, Transition);
		if ( Transition.empty())
			return false;
		pState = Transition[0];
		if ( pState->m_bAcceptingState )
			return true;
		
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x100, %rdi            # imm = 0x100
callq 0x3040
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa5f0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa470
movl $0x0, -0x3c(%rbp)
movq -0x58(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, -0x5c(%rbp)
addq $0x100, %rdi            # imm = 0x100
callq 0x3190
movq %rax, %rcx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jge 0x98b4
movq -0x58(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movslq -0x3c(%rbp), %rsi
callq 0x3410
movq %rax, -0x68(%rbp)
jmp 0x982a
movq -0x68(%rbp), %rax
movb (%rax), %al
movb %al, -0x3d(%rbp)
movq -0x20(%rbp), %rdi
movsbl -0x3d(%rbp), %esi
leaq -0x38(%rbp), %rdx
callq 0x13fd0
jmp 0x9846
leaq -0x38(%rbp), %rdi
callq 0xb290
testb $0x1, %al
jne 0x9855
jmp 0x9879
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x98bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa530
jmp 0x98d3
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa5f0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x6c(%rax)
je 0x98a4
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x98bf
jmp 0x98a6
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x97ec
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa530
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x33a0
nopl (%rax)
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::PreProcessLiterals()
int RegEx::PreProcessLiterals() {
  if (m_CurPreProcChar == '\0') 
	  return -1;
  if (m_CurPreProcChar == '\\') {
    m_CurPreProcChar = *(m_InfixRegEx++);
    if (m_CurPreProcChar == '\0') 
		return -1;
    m_PostStrRegEx += m_CurPreProcChar;
    m_CurPreProcChar = *(m_InfixRegEx++);
  } else if (strchr("()|*+?", m_CurPreProcChar) == NULL) { 
    if (m_CurPreProcChar == '&')
		m_PostStrRegEx += "\\&";
    else 
		m_PostStrRegEx += m_CurPreProcChar;

    m_CurPreProcChar = *(m_InfixRegEx++);
  } else if (m_CurPreProcChar == '(') {
    m_CurPreProcChar = *(m_InfixRegEx++);
    PreProcessOr();
    if (m_CurPreProcChar != ')') 
		return -1;
    m_CurPreProcChar = *(m_InfixRegEx++);
  } else
		return -1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl 0x148(%rax), %eax
cmpl $0x0, %eax
jne 0x990c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9a9c
movq -0x18(%rbp), %rax
movsbl 0x148(%rax), %eax
cmpl $0x5c, %eax
jne 0x9994
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x140(%rax)
movb (%rcx), %cl
movb %cl, 0x148(%rax)
movsbl 0x148(%rax), %eax
cmpl $0x0, %eax
jne 0x9955
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9a9c
movq -0x18(%rbp), %rdi
movb 0x148(%rdi), %al
addq $0x120, %rdi            # imm = 0x120
movsbl %al, %esi
callq 0x3150
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x140(%rax)
movb (%rcx), %cl
movb %cl, 0x148(%rax)
jmp 0x9a95
movq -0x18(%rbp), %rax
movsbl 0x148(%rax), %esi
leaq 0xcc2f(%rip), %rdi      # 0x165d5
callq 0x30a0
cmpq $0x0, %rax
jne 0x9a16
movq -0x18(%rbp), %rax
movsbl 0x148(%rax), %eax
cmpl $0x26, %eax
jne 0x99da
movq -0x18(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
leaq 0xcc09(%rip), %rsi      # 0x165dc
callq 0x3230
jmp 0x99f3
movq -0x18(%rbp), %rdi
movb 0x148(%rdi), %al
addq $0x120, %rdi            # imm = 0x120
movsbl %al, %esi
callq 0x3150
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x140(%rax)
movb (%rcx), %cl
movb %cl, 0x148(%rax)
jmp 0x9a93
movq -0x18(%rbp), %rax
movsbl 0x148(%rax), %eax
cmpl $0x28, %eax
jne 0x9a88
movq -0x18(%rbp), %rdi
movq 0x140(%rdi), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x140(%rdi)
movb (%rax), %al
movb %al, 0x148(%rdi)
callq 0x9ab0
movq -0x18(%rbp), %rax
movsbl 0x148(%rax), %eax
cmpl $0x29, %eax
je 0x9a65
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9a9c
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x140(%rax)
movb (%rcx), %cl
movb %cl, 0x148(%rax)
jmp 0x9a91
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9a9c
jmp 0x9a93
jmp 0x9a95
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::PreProcessOr()
int RegEx::PreProcessOr() {
	PrePreprocessConcatenation();
	while (m_CurPreProcChar == '|') {
		m_CurPreProcChar = *(m_InfixRegEx++);
		PrePreprocessConcatenation();
		m_PostStrRegEx += "|";
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x9bc0
movq -0x10(%rbp), %rax
movsbl 0x148(%rax), %eax
cmpl $0x7c, %eax
jne 0x9b18
movq -0x10(%rbp), %rdi
movq 0x140(%rdi), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x140(%rdi)
movb (%rax), %al
movb %al, 0x148(%rdi)
callq 0x9bc0
movq -0x10(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
leaq 0xcac2(%rip), %rsi      # 0x165d3
callq 0x3230
jmp 0x9ac9
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::PreProcessClosure()
int RegEx::PreProcessClosure() {
	PreProcessLiterals();
	while (m_CurPreProcChar != '\0' && strchr("*+?",m_CurPreProcChar) != NULL) {
		m_PostStrRegEx += m_CurPreProcChar;
		m_CurPreProcChar = *(m_InfixRegEx++);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x98e0
movq -0x10(%rbp), %rax
movsbl 0x148(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x9b6f
movq -0x10(%rbp), %rax
movsbl 0x148(%rax), %esi
leaq 0xca78(%rip), %rdi      # 0x165d8
callq 0x30a0
cmpq $0x0, %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x9b78
jmp 0x9bb4
movq -0x10(%rbp), %rdi
movb 0x148(%rdi), %al
addq $0x120, %rdi            # imm = 0x120
movsbl %al, %esi
callq 0x3150
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x140(%rax)
movb (%rcx), %cl
movb %cl, 0x148(%rax)
jmp 0x9b39
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: davinash[P]regex/src/regex.cpp
// Function: RegEx::PrePreprocessConcatenation()
int RegEx::PrePreprocessConcatenation(void) {
	PreProcessClosure();
	while (strchr(")|*+?", m_CurPreProcChar) == NULL) { 
		PreProcessClosure();
		m_PostStrRegEx += "&";
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x9b20
movq -0x10(%rbp), %rax
movsbl 0x148(%rax), %esi
leaq 0xc9eb(%rip), %rdi      # 0x165d6
callq 0x30a0
cmpq $0x0, %rax
jne 0x9c18
movq -0x10(%rbp), %rdi
callq 0x9b20
movq -0x10(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
leaq 0xc9cc(%rip), %rsi      # 0x165dd
callq 0x3230
jmp 0x9bd9
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: davinash[P]regex/src/regexstate.cpp
// Function: RegExState::RegExState(std::set<RegExState*, std::less<RegExState*>, std::allocator<RegExState*>>, int)
RegExState::RegExState(std::set<RegExState*> NFAState, int nID) {
	m_NFAStates = NFAState;
	m_nStateID = nID;
	m_bAcceptingState = false;
	m_GroupID = 0;
	StateIterator iter;
	for(iter = NFAState.begin(); iter != NFAState.end(); ++iter) {
		if((*iter)->m_bAcceptingState) {
			m_bAcceptingState = true;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq 0xc0a2(%rip), %rax      # 0x1fd98
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x50(%rbp)
callq 0xb220
movq -0x60(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x58(%rbp)
callq 0xc660
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xaef0
jmp 0x13d26
movq -0x60(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x68(%rax)
movb $0x0, 0x6c(%rax)
movl $0x0, 0x70(%rax)
leaq -0x30(%rbp), %rdi
callq 0xaf20
movq -0x48(%rbp), %rdi
callq 0xaf40
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rdi
callq 0xafa0
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xaf70
testb $0x1, %al
jne 0x13d79
jmp 0x13dc2
leaq -0x30(%rbp), %rdi
callq 0xb000
movq (%rax), %rax
testb $0x1, 0x6c(%rax)
je 0x13db5
movq -0x60(%rbp), %rax
movb $0x1, 0x6c(%rax)
jmp 0x13db5
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x142e0
movq -0x50(%rbp), %rdi
callq 0xb270
jmp 0x13dc8
jmp 0x13db7
leaq -0x30(%rbp), %rdi
callq 0xb030
jmp 0x13d59
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33a0
nopw %cs:(%rax,%rax)
// File: davinash[P]regex/src/regexstate.cpp
// Function: RegExState::operator=(RegExState const&)
RegExState& RegExState::operator=(const RegExState& other) { 
	this->m_Transition	= other.m_Transition; 
	this->m_nStateID	= other.m_nStateID;
	this->m_NFAStates	= other.m_NFAStates;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x14560
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, 0x68(%rdi)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0xaef0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davinash[P]regex/src/regexstate.cpp
// Function: RegExState::RemoveTransition(RegExState*)
void RegExState::RemoveTransition(RegExState* pState) {
	std::multimap<char, RegExState*>::iterator iter;
	for(iter = m_Transition.begin(); iter != m_Transition.end();) {
		RegExState *toState = iter->second;
		if(toState == pState)
			m_Transition.erase(iter++);
		else 
			++iter;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x14360
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
callq 0x14380
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
callq 0x143e0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x143b0
testb $0x1, %al
jne 0x13f6e
jmp 0x13fc2
leaq -0x18(%rbp), %rdi
callq 0x14410
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x13fb7
movq -0x48(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x14470
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x14430
movq %rax, -0x40(%rbp)
jmp 0x13fc0
leaq -0x18(%rbp), %rdi
callq 0x144b0
jmp 0x13f4a
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: davinash[P]regex/src/regexstate.cpp
// Function: RegExState::GetTransition(char, std::vector<RegExState*, std::allocator<RegExState*>>&)
void RegExState::GetTransition(char inputCh, Table &States) {
	States.clear();
	std::multimap<char, RegExState*>::iterator iter;
	for(iter = m_Transition.lower_bound(inputCh); iter != m_Transition.upper_bound(inputCh); ++iter) {
		RegExState *pState = iter->second;
		States.push_back(pState);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa610
leaq -0x20(%rbp), %rdi
callq 0x14360
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
leaq -0x9(%rbp), %rsi
callq 0x144e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
leaq -0x9(%rbp), %rsi
callq 0x14510
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x143b0
testb $0x1, %al
jne 0x14045
jmp 0x1406e
leaq -0x20(%rbp), %rdi
callq 0x14410
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xabe0
leaq -0x20(%rbp), %rdi
callq 0x144b0
jmp 0x1401d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davinash[P]regex/src/regexstate.cpp
// Function: RegExState::IsDeadEnd()
bool RegExState::IsDeadEnd() {
	if(m_bAcceptingState)
		return false;
	if(m_Transition.empty())
		return true;
	std::multimap<char, RegExState*>::iterator iter;
	for(iter=m_Transition.begin(); iter!=m_Transition.end(); ++iter){
		RegExState *toState = iter->second;
		if(toState != this)
			return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x6c(%rax)
je 0x140c3
movb $0x0, -0x1(%rbp)
jmp 0x14157
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x14540
testb $0x1, %al
jne 0x140d6
jmp 0x140dc
movb $0x1, -0x1(%rbp)
jmp 0x14157
leaq -0x18(%rbp), %rdi
callq 0x14360
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x14380
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x143e0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x143b0
testb $0x1, %al
jne 0x14122
jmp 0x14153
leaq -0x18(%rbp), %rdi
callq 0x14410
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq 0x8(%rcx), %rcx
movq %rcx, -0x30(%rbp)
cmpq %rax, -0x30(%rbp)
je 0x14146
movb $0x0, -0x1(%rbp)
jmp 0x14157
jmp 0x14148
leaq -0x18(%rbp), %rdi
callq 0x144b0
jmp 0x140fe
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davinash[P]regex/src/regexstate.cpp
// Function: RegExState::operator==(RegExState const&)
bool RegExState::operator==(const RegExState& other) {
	if(m_NFAStates.empty())
		return(m_nStateID == other.m_nStateID);
	else 
		return(m_NFAStates == other.m_NFAStates);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
callq 0xb430
testb $0x1, %al
jne 0x14197
jmp 0x141af
movq -0x20(%rbp), %rax
movl 0x68(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x68(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x141c9
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0xb3d0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davinash[P]regex/src/regexstate.cpp
// Function: RegExState::getStringID[abi:cxx11]()
std::string RegExState::getStringID(){
	std::string result;
	std::stringstream out;
	//if(m_bAcceptingState){
	//	out << "{" << m_nStateID << "}";
	//} else {
		out << m_nStateID;
	//}
	return out.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3320
leaq -0x1b8(%rbp), %rdi
callq 0x31a0
jmp 0x14226
movq -0x1d0(%rbp), %rax
leaq -0x1a8(%rbp), %rdi
movl 0x68(%rax), %esi
callq 0x3390
jmp 0x1423e
movq -0x1e0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x3240
jmp 0x14253
leaq -0x1b8(%rbp), %rdi
callq 0x31c0
leaq -0x30(%rbp), %rdi
callq 0x3140
movq -0x1d8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x142aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x31c0
leaq -0x30(%rbp), %rdi
callq 0x3140
movq -0x1c0(%rbp), %rdi
callq 0x33a0
nop
// File: ADAPTLab[P]MuDBSCAN/vectorc.cpp
// Function: vector_init(vectorc*, VECTORTYPE)
void vector_init(vectorc* v, VECTORTYPE type)
{
    v->capacity = VECTOR_INIT_CAPACITY;
    v->total = 0;
    v->type = type;

    switch (v->type)
    {
        case GROUP:
            v->doubleItems = NULL;
            v->intItems = NULL;
            v->groupItems = (Group*)calloc(v->capacity, sizeof(Group));
            // assert(v->groupItems != NULL);
        break;


        case DOUBLE:
            v->intItems = NULL;
            v->groupItems = NULL;
            v->doubleItems = (double*)calloc(v->capacity, sizeof(double));
            // assert(v->doubleItems != NULL);
        break;

        case INTEGER:
            v->doubleItems = NULL;
            v->groupItems = NULL;
            v->intItems = (int*)calloc(v->capacity, sizeof(int));
            // assert(v->intItems != NULL);
        break;

        // default:
        //     fprintf(stderr, "In VECTOR_INIT(): Pass in a valid type\n");
        //     exit(-1);
        // break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x4, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0xa236
jmp 0xa1b3
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0xa1ca
jmp 0xa1bd
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0xa200
jmp 0xa26a
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rdi
movl $0x8, %esi
callq 0x9400
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa26a
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rdi
movl $0x8, %esi
callq 0x9400
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xa26a
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rdi
movl $0x4, %esi
callq 0x9400
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: ADAPTLab[P]MuDBSCAN/vectorc.cpp
// Function: vector_add(vectorc*, void*)
void vector_add(vectorc* v, void* item)
{
    int item1;
    double d;
    Group g;
    if(v->capacity == 0)
    {
        VECTOR_INIT(v, v->type);
    }
    if (v->capacity == v->total)
        vector_resize_internal(v, v->capacity*2);
    
    switch(v->type)
    {
        case INTEGER:
            item1 = *((int*)item);
            v->intItems[v->total++] = item1;
            break;

        case DOUBLE:
            d = *((double*)item);
            v->doubleItems[v->total++] = d;
            break;

        case GROUP:
            g = ((Group)item);
            v->groupItems[v->total++] = g;
            break;

        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xa70a
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %esi
callq 0xa170
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jne 0xa72c
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
shll %esi
callq 0xa560
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0xa753
jmp 0xa73c
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0xa7b1
jmp 0xa746
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0xa77e
jmp 0xa7dc
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x24(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x24(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xa7de
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x24(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x24(%rdx)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0xa7de
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x24(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x24(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xa7de
jmp 0xa7de
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ADAPTLab[P]MuDBSCAN/vectorc.cpp
// Function: vector_free(vectorc*)
void vector_free(vectorc* v)
{
    int i;
    v->total = 0;
    v->capacity = 0;
    switch(v->type)
    {
        case INTEGER:
            free(v->intItems);
            break;

        case DOUBLE:
            free(v->doubleItems);
            break;

        case GROUP:
            for(i=0;i<v->total;i++)
            {
                free(v->groupItems[i]);
            }
            free(v->groupItems);
            break;
            
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0xa836
jmp 0xa822
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0xa854
jmp 0xa82c
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0xa845
jmp 0xa894
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x97c0
jmp 0xa896
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x97c0
jmp 0xa896
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jge 0xa886
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x97c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa85b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x97c0
jmp 0xa896
jmp 0xa896
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ADAPTLab[P]MuDBSCAN/Data.cpp
// Function: unionFindMerge(dataHdr*, int, int, data*, data*)
void unionFindMerge(DataHdr dataList, int root1, int root2, Data dataroot1, Data dataroot2)
{
    // root1 = dataroot1->id;
    // root2 = dataroot2->id;
    int root;
    while(dataroot1->parentId != dataroot2->parentId)
    {
        if(dataroot1->parentId < dataroot2->parentId)
        {
            // Find top most point of the tree that dataroot1 belongs to. Store that number in the variable root
            if(dataroot1->parentId == root1)
            {
                dataroot1->parentId = dataroot2->parentId;
                root = dataroot2->parentId;
                break;
            }

            // splicing compression technique
            int z = dataroot1->parentId;
            dataroot1->parentId = dataroot2->parentId;
            root1 = z;
            dataroot1 = dataList->dataClstElem + root1;
        }
        else
        {
            if(dataroot2->parentId == root2)
            {
                dataroot2->parentId = dataroot1->parentId;
                root = dataroot1->parentId;
                break;
            }

            // splicing compressio technique
            int z = dataroot2->parentId;
            dataroot2->parentId = dataroot1->parentId;                
            root2 = z;
            dataroot2 = dataList->dataClstElem + root2;
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x14(%rcx), %eax
je 0xf2aa
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0xf24a
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xf213
movq -0x20(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0xf2aa
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x28(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xf2a5
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0xf270
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0xf2aa
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xf1c6
popq %rbp
retq
nopl (%rax)
// File: ADAPTLab[P]MuDBSCAN/Data.cpp
// Function: initDataHdr(int)
DataHdr initDataHdr(int size)
{   
    DataHdr dataHdrInfo = (DataHdr)calloc(1, sizeof(struct dataHdr));
    // assert(dataHdrInfo != NULL);

    dataHdrInfo->uiCnt = 0;
    dataHdrInfo->localCnt = 0;
    dataHdrInfo->dataClstElem=(Data)calloc(size, sizeof(struct data));
    // assert(dataHdrInfo->dataClstElem!=NULL);

    return dataHdrInfo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x9400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movslq -0x4(%rbp), %rdi
movl $0x40, %esi
callq 0x9400
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)