LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ahupowerdns[P]mcounter/./mcounter.hh
// Function: UnsharedCounterStructParent<(anonymous namespace)::mystruct>::moveChild(UnsharedCounterStruct<(anonymous namespace)::mystruct> const*, UnsharedCounterStruct<(anonymous namespace)::mystruct>*)
void UnsharedCounterStructParent<T>::moveChild(const UnsharedCounterStruct<T>* from, UnsharedCounterStruct<T>* to)
{
  std::lock_guard<std::mutex> l(d_mutex);

  auto iter = d_children.find(const_cast<UnsharedCounterStruct<T>*>(from));
  if(iter == d_children.end())
    throw std::runtime_error("attempt to move unknown child");
  d_children.erase(iter);
  d_children.insert(to);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x78(%rbp)
addq $0x38, %rsi
leaq -0x20(%rbp), %rdi
callq 0x226b0
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x36910
movq %rax, -0x70(%rbp)
jmp 0x367f7
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x35bc0
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x36940
testb $0x1, %al
jne 0x3681f
jmp 0x36885
movl $0x10, %edi
callq 0x61f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq 0x3e7d(%rip), %rsi      # 0x3a6b7
callq 0x6170
jmp 0x36841
movq -0x80(%rbp), %rdi
movq 0x1a7a4(%rip), %rsi     # 0x50ff0
movq 0x1a765(%rip), %rdx     # 0x50fb8
callq 0x67a0
jmp 0x36902
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x368f0
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x6300
jmp 0x368f0
movq -0x78(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
callq 0x36970
movq %rax, -0x88(%rbp)
jmp 0x368a3
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x34430
movb %dl, -0x91(%rbp)
movq %rax, -0x90(%rbp)
jmp 0x368ca
movb -0x91(%rbp), %al
movq -0x90(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x227d0
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x227d0
movq -0x38(%rbp), %rdi
callq 0x6800
nopw %cs:(%rax,%rax)
// File: ekinakyurek[P]bilsoz/src/main.cpp
// Function: join(char**, int, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string join(char* arr[], int n, char c, string s) {
   for (int i = 1; i < n; ++i) {
      s += arr[i];
      if (i < n-1)
         s += c;
   }
   transform(s.begin(), s.end(), s.begin(), ::tolower);
   return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %r8, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq %r8, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x41d36
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x21a0
movl -0x24(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x41d29
movq -0x60(%rbp), %rdi
movsbl -0x15(%rbp), %esi
callq 0x20f0
jmp 0x41d2b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x41cf2
movq -0x60(%rbp), %rdi
callq 0x2170
movq -0x60(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x20c0
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x2170
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x21268(%rip), %rcx     # 0x62fd8
callq 0x41f50
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, -0x48(%rbp)
callq 0x20d0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: ekinakyurek[P]bilsoz/src/main.cpp
// Function: main
int main(int argc, char *argv[]){
  if (argc > 1)
  {
    unordered_map<string, string>::iterator iter = BilSoz::dict.find(join(argv,argc,' ',""));
    if (iter != BilSoz::dict.end())
    {
      cout << iter->second << endl;
    }else{
      cout << "bu kelime sözlükte bulunamadı." << endl;
    }
    return 0;
  }
  cout << "lütfen aramak istediğiniz kelimeyi yazıp tekrar çalıştırın." << endl;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x41f0a
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x84(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x22b0
movq -0x80(%rbp), %rdx
leaq 0xeed2(%rip), %rsi      # 0x50cb1
leaq -0x58(%rbp), %rdi
callq 0x3fd70
jmp 0x41dea
movl -0x84(%rbp), %edx
movq -0x90(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x20, %ecx
leaq -0x58(%rbp), %r8
callq 0x41cc0
jmp 0x41e0b
leaq 0x2137e(%rip), %rdi     # 0x63190
leaq -0x38(%rbp), %rsi
callq 0x41fd0
movq %rax, -0x98(%rbp)
jmp 0x41e24
movq -0x98(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20e0
leaq -0x58(%rbp), %rdi
callq 0x20e0
leaq -0x59(%rbp), %rdi
callq 0x2200
leaq 0x2133f(%rip), %rdi     # 0x63190
callq 0x42030
movq %rax, -0x78(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x42000
testb $0x1, %al
jne 0x41e6d
jmp 0x41edf
leaq -0x18(%rbp), %rdi
callq 0x42060
movq %rax, %rsi
addq $0x20, %rsi
movq 0x2114c(%rip), %rdi     # 0x62fd0
callq 0x2190
movq %rax, %rdi
movq 0x2112d(%rip), %rsi     # 0x62fc0
callq 0x21e0
jmp 0x41f01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x41ed4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x41ecb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20e0
leaq -0x58(%rbp), %rdi
callq 0x20e0
leaq -0x59(%rbp), %rdi
callq 0x2200
jmp 0x41f3f
movq 0x210ea(%rip), %rdi     # 0x62fd0
leaq 0x14957(%rip), %rsi     # 0x56844
callq 0x21b0
movq %rax, %rdi
movq 0x210c4(%rip), %rsi     # 0x62fc0
callq 0x21e0
movl $0x0, -0x4(%rbp)
jmp 0x41f33
movq 0x210bf(%rip), %rdi     # 0x62fd0
leaq 0x1494e(%rip), %rsi     # 0x56866
callq 0x21b0
movq %rax, %rdi
movq 0x21099(%rip), %rsi     # 0x62fc0
callq 0x21e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x22a0
nopl (%rax,%rax)
// File: aleperno[P]Datos/main.cpp
// Function: show(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::vector<float, std::allocator<float>>, std::vector<float, std::allocator<float>>, std::vector<float, std::allocator<float>>)
void show(vector<string> l0, vector<float> l1, vector<float> l2, vector<float> l3) {
	if ((l1.size()!=l2.size()) && (l1.size()!=l3.size()))
		return;
	for (unsigned int i=0; i<l1.size(); i++) {
		cout << l0[i] << "\t| " << l1[i] << "\t| "<<l2[i]<< "\t| "<<l3[i]<< "\n";
	}
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x4eb0
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x4eb0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x4a3b
movq -0x48(%rbp), %rdi
callq 0x4eb0
movq -0x40(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x4eb0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x4a3b
jmp 0x4b39
movl $0x0, -0x24(%rbp)
movq -0x48(%rbp), %rdi
movl -0x24(%rbp), %eax
movq %rax, -0x68(%rbp)
callq 0x4eb0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x4b26
movq -0x50(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4e10
movq %rax, %rsi
movq 0x1e55e(%rip), %rdi     # 0x22fd8
callq 0x42a0
movq %rax, %rdi
leaq 0x12589(%rip), %rsi     # 0x17012
callq 0x42d0
movq -0x48(%rbp), %rdi
movq %rax, -0x80(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4ed0
movq -0x80(%rbp), %rdi
movss (%rax), %xmm0
callq 0x4220
movq %rax, %rdi
leaq 0x1255b(%rip), %rsi     # 0x17012
callq 0x42d0
movq -0x38(%rbp), %rdi
movq %rax, -0x78(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4ed0
movq -0x78(%rbp), %rdi
movss (%rax), %xmm0
callq 0x4220
movq %rax, %rdi
leaq 0x1252d(%rip), %rsi     # 0x17012
callq 0x42d0
movq -0x40(%rbp), %rdi
movq %rax, -0x70(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4ed0
movq -0x70(%rbp), %rdi
movss (%rax), %xmm0
callq 0x4220
movq %rax, %rdi
leaq 0x12831(%rip), %rsi     # 0x17344
callq 0x42d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4a42
movq 0x1e4ab(%rip), %rdi     # 0x22fd8
movq 0x1e494(%rip), %rsi     # 0x22fc8
callq 0x4310
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aleperno[P]Datos/Parser.cpp
// Function: Parser::loadSwearingChars(char*)
void Parser::loadSwearingChars(char* filename) {
	std::fstream f(filename);
	if(f.is_open()) {
		char c;
		while (!f.eof()) { // &&
			f.get(c);
			if (c != '\n')
				this->swearingChars.push_back(c);
		}
		f.close();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x240(%rbp)
movl $0x8, %edi
movl $0x10, %esi
callq 0x6610
movq -0x240(%rbp), %rsi
movl %eax, %edx
leaq -0x220(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x4400
movq -0x238(%rbp), %rdi
callq 0x4520
movb %al, -0x22e(%rbp)
jmp 0x5318
movb -0x22e(%rbp), %al
testb $0x1, %al
jne 0x5327
jmp 0x53c8
jmp 0x5329
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x4590
movb %al, -0x249(%rbp)
jmp 0x5349
movb -0x249(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5357
jmp 0x53b8
leaq -0x220(%rbp), %rdi
leaq -0x22d(%rbp), %rsi
callq 0x4430
jmp 0x536c
movsbl -0x22d(%rbp), %eax
cmpl $0xa, %eax
je 0x53b3
movq -0x248(%rbp), %rdi
addq $0x48, %rdi
leaq -0x22d(%rbp), %rsi
callq 0x6630
jmp 0x5391
jmp 0x53b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x40c0
jmp 0x53dd
jmp 0x5329
leaq -0x220(%rbp), %rdi
callq 0x4070
jmp 0x53c6
jmp 0x53c8
leaq -0x220(%rbp), %rdi
callq 0x40c0
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x4550
nopl (%rax)
// File: aleperno[P]Datos/Parser.cpp
// Function: Parser::noFrontSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Parser::noFrontSpaces(string line) {
	string aux = line;
	while ((line[0] == '\n') || (line[0] == ' ')){
		aux.erase(0,1);
		line = aux;
	}
	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x48(%rbp)
movq %rsi, %rax
movq -0x48(%rbp), %rsi
movq %rdi, -0x40(%rbp)
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x4130
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x45f0
movq %rax, -0x50(%rbp)
jmp 0x55b6
movq -0x50(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x51(%rbp)
je 0x55ea
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x45f0
movq %rax, -0x60(%rbp)
jmp 0x55da
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x55f3
jmp 0x562f
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x40d0
jmp 0x5607
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x4050
jmp 0x5616
jmp 0x55a3
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x41a0
jmp 0x564c
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5642
movq -0x40(%rbp), %rdi
callq 0x41a0
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
// File: aleperno[P]Datos/Parser.cpp
// Function: Parser::tokenizeColumns(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> Parser::tokenizeColumns(string line){
	vector<string> parts;
	boost::split(parts, line, boost::is_any_of(this->columnDelimeter));

	for (unsigned int i=0; i< parts.size(); i++){
		if (parts[i].size()==0)
			parts.erase(parts.begin()+i);
		parts[i] = noFrontSpaces(parts[i]);
	}

	return parts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0xc8(%rbp)
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x6720
movq -0xb0(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0x6810
jmp 0x56b9
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movl $0x1, %ecx
callq 0x6740
jmp 0x56d7
leaq -0x38(%rbp), %rdi
callq 0x6860
movl $0x0, -0x48(%rbp)
movq -0xc0(%rbp), %rdi
movl -0x48(%rbp), %eax
movq %rax, -0xd0(%rbp)
callq 0x4df0
movq %rax, %rcx
movq -0xd0(%rbp), %rax
cmpq %rcx, %rax
jae 0x5851
movq -0xc0(%rbp), %rdi
movl -0x48(%rbp), %eax
movl %eax, %esi
callq 0x4e10
movq %rax, %rdi
callq 0x41f0
cmpq $0x0, %rax
jne 0x57b3
movq -0xc0(%rbp), %rdi
callq 0x6920
movq %rax, -0x60(%rbp)
movl -0x48(%rbp), %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
callq 0x6950
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6990
movq -0xc0(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x68b0
movq %rax, -0xd8(%rbp)
jmp 0x577b
movq -0xd8(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x57b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5877
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6860
jmp 0x5877
movq -0xc0(%rbp), %rdi
movl -0x48(%rbp), %eax
movl %eax, %esi
callq 0x4e10
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
callq 0x4130
jmp 0x57d5
movq -0xb0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x5570
jmp 0x57f1
movq -0xc0(%rbp), %rdi
movl -0x48(%rbp), %eax
movl %eax, %esi
callq 0x4e10
movq %rax, %rdi
leaq -0x88(%rbp), %rsi
callq 0x43a0
leaq -0x88(%rbp), %rdi
callq 0x41a0
leaq -0xa8(%rbp), %rdi
callq 0x41a0
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x56e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x41a0
jmp 0x5877
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5867
movq -0xc0(%rbp), %rdi
callq 0x69d0
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x69d0
movq -0x40(%rbp), %rdi
callq 0x4550
nopl (%rax)
// File: aleperno[P]Datos/Parser.cpp
// Function: Parser::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> Parser::tokenize(string line, string newDelimiters){
	vector<string> parts;
	boost::split(parts, line, boost::is_any_of(newDelimiters));

	for (unsigned int i=0; i< parts.size(); i++){
		if (parts[i].size()==0)
			parts.erase(parts.begin()+i);
		parts[i] = noFrontSpaces(parts[i]);
	}
	return parts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xd8(%rbp)
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x6720
movq -0xb8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x6810
jmp 0x5db0
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movl $0x1, %ecx
callq 0x6740
jmp 0x5dce
leaq -0x40(%rbp), %rdi
callq 0x6860
movl $0x0, -0x50(%rbp)
movq -0xd0(%rbp), %rdi
movl -0x50(%rbp), %eax
movq %rax, -0xe0(%rbp)
callq 0x4df0
movq %rax, %rcx
movq -0xe0(%rbp), %rax
cmpq %rcx, %rax
jae 0x5f48
movq -0xd0(%rbp), %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
callq 0x4e10
movq %rax, %rdi
callq 0x41f0
cmpq $0x0, %rax
jne 0x5eaa
movq -0xd0(%rbp), %rdi
callq 0x6920
movq %rax, -0x68(%rbp)
movl -0x50(%rbp), %eax
movl %eax, %esi
leaq -0x68(%rbp), %rdi
callq 0x6950
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x6990
movq -0xd0(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x68b0
movq %rax, -0xe8(%rbp)
jmp 0x5e72
movq -0xe8(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x5eaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5f6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6860
jmp 0x5f6e
movq -0xd0(%rbp), %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
callq 0x4e10
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x4130
jmp 0x5ecc
movq -0xc0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
callq 0x5570
jmp 0x5ee8
movq -0xd0(%rbp), %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
callq 0x4e10
movq %rax, %rdi
leaq -0x90(%rbp), %rsi
callq 0x43a0
leaq -0x90(%rbp), %rdi
callq 0x41a0
leaq -0xb0(%rbp), %rdi
callq 0x41a0
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x5dde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x41a0
jmp 0x5f6e
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x5f5e
movq -0xd0(%rbp), %rdi
callq 0x69d0
movq -0xc8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd0(%rbp), %rdi
callq 0x69d0
movq -0x48(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
// File: aleperno[P]Datos/Parser.cpp
// Function: Parser::lastLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Parser::lastLine(string line) {
	vector<string> lines = this->tokenize(line, "\n.");
	while (lines[lines.size()-1].size() == 0) {
		lines.pop_back();
	}

	string l = lines[lines.size()-1];
	return noFrontSpaces(l);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xf0(%rbp)
movq %rsi, %rax
movq -0xf0(%rbp), %rsi
movq %rdi, -0xe8(%rbp)
movq %rdi, %rcx
movq %rcx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4130
leaq -0x71(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x4560
movq -0xd0(%rbp), %rdx
leaq 0x11057(%rip), %rsi     # 0x17052
leaq -0x70(%rbp), %rdi
callq 0x4420
jmp 0x6006
movq -0xd8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
callq 0x5d50
jmp 0x6020
leaq -0x70(%rbp), %rdi
callq 0x41a0
leaq -0x71(%rbp), %rdi
callq 0x4330
leaq -0x50(%rbp), %rdi
callq 0x41a0
leaq -0x30(%rbp), %rdi
callq 0x4df0
movq %rax, %rsi
subq $0x1, %rsi
leaq -0x30(%rbp), %rdi
callq 0x4e10
movq %rax, %rdi
callq 0x41f0
cmpq $0x0, %rax
jne 0x60ad
leaq -0x30(%rbp), %rdi
callq 0x6c60
jmp 0x603b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x6096
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x41a0
leaq -0x71(%rbp), %rdi
callq 0x4330
leaq -0x50(%rbp), %rdi
callq 0x41a0
jmp 0x6194
leaq -0x30(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x4df0
movq -0xf8(%rbp), %rdi
movq %rax, %rsi
decq %rsi
callq 0x4e10
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
callq 0x4130
jmp 0x60e0
leaq -0xc8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x4130
jmp 0x60f5
movq -0xd8(%rbp), %rsi
movq -0xe8(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x5570
jmp 0x6111
leaq -0xc8(%rbp), %rdi
callq 0x41a0
leaq -0xa8(%rbp), %rdi
callq 0x41a0
leaq -0x30(%rbp), %rdi
callq 0x69d0
movq -0xe0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x618b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x617f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x41a0
leaq -0xa8(%rbp), %rdi
callq 0x41a0
leaq -0x30(%rbp), %rdi
callq 0x69d0
movq -0x80(%rbp), %rdi
callq 0x4550
nopl (%rax)
// File: aleperno[P]Datos/Parser.cpp
// Function: Parser::isSwearing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool Parser::isSwearing(string word, int minChars) {
	bool s = false;
	int counter = 0;

	for (unsigned int i=0; i< word.size(); i++) {
		for (unsigned int j=0; j< this->swearingChars.size(); j++) {
			if (word[i] == this->swearingChars[j])
				counter ++;
		}
	}
	if (counter >= minChars)
		s = true;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x15(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0x40(%rbp)
callq 0x41f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x6271
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movq %rax, -0x48(%rbp)
addq $0x48, %rdi
callq 0x4e30
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x6261
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x45f0
movq -0x30(%rbp), %rdi
movsbl (%rax), %eax
movl %eax, -0x4c(%rbp)
addq $0x48, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4e50
movq %rax, %rcx
movl -0x4c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x6254
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6256
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x61f8
jmp 0x6263
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x61d1
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x627d
movb $0x1, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: aleperno[P]Datos/Parser.cpp
// Function: Parser::noSwearing(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
vector<string> Parser::noSwearing(vector<string> tokens) {

	for (unsigned int i=0; i< tokens.size(); i++){
		if (this->isSwearing(tokens[i], 3)) // cantidad de chars extraños para considerarlo un insulto
			tokens.erase(tokens.begin()+i);
		//tokens[i] = noFrontSpaces(parts[i]);
	}

	return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x90(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x98(%rbp)
callq 0x4df0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x63b6
movq -0x90(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x4e10
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4130
movq -0x78(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movl $0x3, %edx
callq 0x61a0
movb %al, -0x99(%rbp)
jmp 0x6335
leaq -0x40(%rbp), %rdi
callq 0x41a0
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x634a
jmp 0x63a6
movq -0x90(%rbp), %rdi
callq 0x6920
movq %rax, -0x68(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
leaq -0x68(%rbp), %rdi
callq 0x6950
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x6990
movq -0x90(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x68b0
movq %rax, -0x70(%rbp)
jmp 0x63a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41a0
jmp 0x63d6
jmp 0x63a8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x62cb
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x6c90
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4550
nop
// File: aleperno[P]Datos/Parser.cpp
// Function: Parser::isFractionScore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Parser::isFractionScore(string s) {
	int counter  = 0;
	for (unsigned int i=0; i< s.size(); i++) {
		if (s[i]=='/')
			counter ++;
	}

	return (counter==1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x41f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x644a
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x45f0
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x643d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x643f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6402
cmpl $0x1, -0x14(%rbp)
sete %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: aleperno[P]Datos/Parser.cpp
// Function: Parser::fractionScore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
float Parser::fractionScore(string s) {
	float f = 0.5;
	if (isFractionScore(s)){
		vector<string> fs = tokenize(s, "/");
		if (fs.size()==2) {
			std::string::size_type sz;
			float f_aux = 0.0;//std::stof(fs[0], &sz)/std::stof(fs[1], &sz);
			if ((f_aux >= 0)&&(f_aux <= 1)) {
				f = f_aux;
			}
		}
	}

	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl $0x3f000000, -0x14(%rbp) # imm = 0x3F000000
leaq -0x38(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x4130
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x63e0
movb %al, -0xb5(%rbp)
jmp 0x64b7
leaq -0x38(%rbp), %rdi
callq 0x41a0
movb -0xb5(%rbp), %al
testb $0x1, %al
jne 0x64cf
jmp 0x65f9
movq -0xd0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x4130
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x4560
movq -0xd8(%rbp), %rdx
leaq 0x10b50(%rip), %rsi     # 0x17050
leaq -0xa0(%rbp), %rdi
callq 0x4420
jmp 0x650e
movq -0xc8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
callq 0x5d50
jmp 0x652b
leaq -0xa0(%rbp), %rdi
callq 0x41a0
leaq -0xa1(%rbp), %rdi
callq 0x4330
leaq -0x80(%rbp), %rdi
callq 0x41a0
leaq -0x60(%rbp), %rdi
callq 0x4df0
cmpq $0x2, %rax
jne 0x65f0
xorps %xmm0, %xmm0
movss %xmm0, -0xb4(%rbp)
movss -0xb4(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x65ee
movss 0x10ab2(%rip), %xmm0    # 0x17034
ucomiss -0xb4(%rbp), %xmm0
jb 0x65ee
movss -0xb4(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x65ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41a0
jmp 0x6607
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x65d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x41a0
leaq -0xa1(%rbp), %rdi
callq 0x4330
leaq -0x80(%rbp), %rdi
callq 0x41a0
jmp 0x6607
jmp 0x65f0
leaq -0x60(%rbp), %rdi
callq 0x69d0
movss -0x14(%rbp), %xmm0
addq $0xe0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4550
// File: aleperno[P]Datos/HashingPerceptron.cpp
// Function: HashingPerceptron::dot_product(std::vector<unsigned int, std::allocator<unsigned int>>)
float HashingPerceptron::dot_product(vector<unsigned int> vec)
{
	float count = 0;
	for (unsigned int i = 0; i < vec.size(); i++)
	{
		count += this->weights[vec[i]];
	}
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0xfb20
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xedb7
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0xfb40
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x4ed0
movss (%rax), %xmm0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xed5b
movss -0x14(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::groups_collection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::add_group(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
bool add_group(const std::string& group_name, const std::set<T>& set)
   {
      const auto itr = groups.find(group_name);

      if (itr != groups.end())
      {
         return false;
      }

      groups[group_name] = set;
      return true;
   }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x30(%rsp), %rsi
callq 0x11c8e0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x11c930
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x11c910
testb $0x1, %al
jne 0x119be0
jmp 0x119be7
movb $0x0, 0x47(%rsp)
jmp 0x119c12
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
callq 0x11c960
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x11ca50
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::create<double>::operator()(exprtk::type_store<double>::parameter_list)
inline T operator() (parameter_list_t parameters) override
   {
      const std::string group_name = to_str(string_t(parameters[0]));

      if (
           !groups_.contains(group_name) &&
           !groups_.add_group(group_name, {})
         )
      {
         return T(0);
      }

      auto ptr = groups_.get(group_name);
      const std::size_t ptr_size = sizeof(ptr);
      T result = T(0);

      std::memcpy(reinterpret_cast<char*>(&result ),
                  reinterpret_cast<char*>(&ptr),
                  ptr_size);

      return result;
   }

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rsi, 0x118(%rsp)
movq %rdi, 0x110(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0xd8(%rsp)
leaq 0x118(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x11f950
movq %rax, %rsi
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x11f980
movq 0x30(%rsp), %rsi
leaq 0xf0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x11f8b0
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
addq $0x48, %rdi
movb $0x0, 0x8f(%rsp)
callq 0x11f9b0
movb %al, 0x4f(%rsp)
jmp 0x11e7f2
movb 0x4f(%rsp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x2f(%rsp)
jne 0x11e86d
jmp 0x11e803
movq 0x38(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
leaq 0x90(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x119b10
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movb $0x1, 0x8f(%rsp)
leaq 0xf0(%rsp), %rsi
callq 0x119b90
movb %al, 0x2e(%rsp)
jmp 0x11e863
movb 0x2e(%rsp), %al
xorb $-0x1, %al
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
movb %al, 0x17(%rsp)
testb $0x1, 0x8f(%rsp)
jne 0x11e881
jmp 0x11e88e
leaq 0x90(%rsp), %rdi
callq 0x11bdf0
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x11e898
jmp 0x11e8ff
xorps %xmm0, %xmm0
movsd %xmm0, 0x120(%rsp)
movl $0x1, 0x88(%rsp)
jmp 0x11e9a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x11e9c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
testb $0x1, 0x8f(%rsp)
jne 0x11e8ed
jmp 0x11e8fa
leaq 0x90(%rsp), %rdi
callq 0x11bdf0
jmp 0x11e9c5
movq 0x38(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x111110
jmp 0x11e921
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x11f9e0
movq %rax, (%rsp)
jmp 0x11e936
leaq 0x60(%rsp), %rdi
callq 0x1117b8
movq (%rsp), %rax
movq %rax, 0x80(%rsp)
movq $0x8, 0x58(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x120(%rsp)
movl $0x1, 0x88(%rsp)
jmp 0x11e9a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x1117b8
jmp 0x11e9c5
leaq 0xf0(%rsp), %rdi
callq 0x1117b8
movsd 0x120(%rsp), %xmm0
addq $0x128, %rsp            # imm = 0x128
retq
leaq 0xf0(%rsp), %rdi
callq 0x1117b8
movq 0xd0(%rsp), %rdi
callq 0x111450
nop
// File: ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::groups_collection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ptr_t get(const std::string group_name)
   {
      auto itr = groups.find(group_name);
      if (itr == groups.end())
      {
         return nullptr;
      }
      return &(itr->second);
   }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x11c8e0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x11c930
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x11cbf0
testb $0x1, %al
jne 0x11fa26
jmp 0x11fa31
movq $0x0, 0x30(%rsp)
jmp 0x11fa44
leaq 0x18(%rsp), %rdi
callq 0x11fd00
addq $0x20, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::contains<double>::process(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, exprtk::type_store<double>::parameter_list&) const
inline T process(const strgrps_cllctn::set_t& set, parameter_list_t& parameters) const
   {
      for (std::size_t i = 1; i < parameters.size(); ++i)
      {
         if (set.count(to_str(string_t(parameters[i]))))
         {
            return T(1);
         }
      }

      return T(0);
   }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq $0x1, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x78(%rsp), %rdi
callq 0x11ff60
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x1201a9
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x11f950
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x11f980
movq 0x8(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x11f8b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1201d0
movq %rax, 0x20(%rsp)
jmp 0x120152
leaq 0x50(%rsp), %rdi
callq 0x1117b8
movq 0x20(%rsp), %rax
cmpq $0x0, %rax
je 0x120194
movsd 0x329ea1(%rip), %xmm0   # 0x44a010
movsd %xmm0, 0x90(%rsp)
jmp 0x1201b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1117b8
jmp 0x1201c6
jmp 0x120196
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x1200d5
xorps %xmm0, %xmm0
movsd %xmm0, 0x90(%rsp)
movsd 0x90(%rsp), %xmm0
addq $0x98, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x111450
// File: ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::get<double>::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, exprtk::type_store<double>::parameter_list)
inline T operator() (std::string& result, parameter_list_t parameters) override
   {
      const auto ptr = scalar_t(parameters[0])();
      const int index = static_cast<int>(scalar_t(parameters[1])());

      assert(ptr != T(0));

      auto& set = *make_set_handle<strgrps_cllctn::set_t>(ptr);

      if (
           (index >= 0) &&
           (static_cast<std::size_t>(index) >= set.size())
         )
      {
         return T(0);
      }

      auto itr = set.begin();
      std::advance(itr,index);
      result = *itr;
      return T(1);
   }

// Assembly:
subq $0x68, %rsp
movq %rdx, 0x58(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x11f950
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x11fdd0
leaq 0x38(%rsp), %rdi
callq 0x11fdf0
movsd (%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movq $0x1, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x11f950
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x11fdd0
leaq 0x20(%rsp), %rdi
callq 0x11fdf0
cvttsd2si (%rax), %eax
movl %eax, 0x2c(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0x11fe00
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x2c(%rsp)
jl 0x120604
movslq 0x2c(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x1204f0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jb 0x120604
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rsp)
jmp 0x120646
movq 0x10(%rsp), %rdi
callq 0x120660
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %esi
leaq 0x8(%rsp), %rdi
callq 0x120690
leaq 0x8(%rsp), %rdi
callq 0x1206e0
movq %rax, %rsi
movq 0x48(%rsp), %rdi
callq 0x111740
movsd 0x3299d0(%rip), %xmm0   # 0x44a010
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::erase<double>::process(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, exprtk::type_store<double>::parameter_list&)
inline T process(strgrps_cllctn::set_t& set, parameter_list_t& parameters)
   {
      std::size_t count = 0;
      for (std::size_t i = 1; i < parameters.size(); ++i)
      {
         count += set.erase(to_str(string_t(parameters[i])));
      }

      return T(count);
   }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq $0x0, 0x78(%rsp)
movq $0x1, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rdi
callq 0x11ff60
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x1209ba
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x11f950
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x11f980
movq 0x8(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x11f8b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x120a00
movq %rax, 0x20(%rsp)
jmp 0x120974
movq 0x20(%rsp), %rax
addq 0x78(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1117b8
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x1208f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1117b8
jmp 0x1209ea
movaps 0x3296ef(%rip), %xmm1   # 0x44a0b0
movq 0x78(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x3296ed(%rip), %xmm1   # 0x44a0c0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
addq $0x98, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x111450
nopw %cs:(%rax,%rax)
nop
// File: yayuntian[P]user_agent/test_ua.cpp
// Function: TestUserAgent()
void TestUserAgent() {
    UserAgent ua;
    for (auto p : uastrings) {
        Parse(ua, p.ua, p.ua.size());

        if (p.expected != format(ua)) {
            fprintf(stderr, "Test: %s\ngot:      %s\nexpected: %s\n",
                    p.title.c_str(), format(ua).c_str(), p.expected.c_str());
            exit(1);
        }
    }
    printf("Test %ld Case OK.\n", uastrings.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
leaq -0x128(%rbp), %rdi
callq 0x136a0
leaq 0x7f87a(%rip), %rax     # 0x92518
movq %rax, -0x130(%rbp)
leaq 0x7f86c(%rip), %rdi     # 0x92518
callq 0x13710
movq %rax, -0x138(%rbp)
leaq 0x7f859(%rip), %rdi     # 0x92518
callq 0x13740
movq %rax, -0x140(%rbp)
leaq -0x138(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x13770
testb $0x1, %al
jne 0x12ce7
jmp 0x12ead
leaq -0x138(%rbp), %rdi
callq 0x137b0
movq %rax, %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x137d0
jmp 0x12d04
leaq -0x180(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
callq 0x81c0
jmp 0x12d19
leaq -0x180(%rbp), %rdi
callq 0x8350
movl %eax, %edx
leaq -0x128(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x14bd0
jmp 0x12d3c
leaq -0x1d0(%rbp), %rdi
callq 0x89e8
leaq -0x160(%rbp), %rax
movq %rax, -0x218(%rbp)
leaq -0x1f0(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x12620
jmp 0x12d6b
movq -0x218(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x13870
movb %al, -0x219(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x89e8
movb -0x219(%rbp), %al
testb $0x1, %al
jne 0x12d9f
jmp 0x12e82
movq 0x7f222(%rip), %rax     # 0x91fc8
movq (%rax), %rax
movq %rax, -0x230(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x81a0
movq %rax, -0x228(%rbp)
leaq -0x210(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x12620
jmp 0x12dd8
leaq -0x210(%rbp), %rdi
callq 0x81a0
movq %rax, -0x238(%rbp)
leaq -0x1a0(%rbp), %rdi
addq $0x40, %rdi
callq 0x81a0
movq -0x230(%rbp), %rdi
movq -0x228(%rbp), %rdx
movq -0x238(%rbp), %rcx
movq %rax, %r8
leaq 0x575bc(%rip), %rsi     # 0x6a3d6
movb $0x0, %al
callq 0x86c0
leaq -0x210(%rbp), %rdi
callq 0x89e8
movl $0x1, %edi
callq 0x85a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x12ee1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x12e9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x89e8
jmp 0x12e9f
leaq -0x1a0(%rbp), %rdi
callq 0x134a0
leaq -0x138(%rbp), %rdi
callq 0x138a0
jmp 0x12ccb
leaq -0x1a0(%rbp), %rdi
callq 0x134a0
jmp 0x12ee1
leaq 0x7f664(%rip), %rdi     # 0x92518
callq 0x138c0
movq %rax, %rsi
leaq 0x57537(%rip), %rdi     # 0x6a3fa
xorl %eax, %eax
callq 0x8070
jmp 0x12ecc
leaq -0x128(%rbp), %rdi
callq 0x138f0
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
leaq -0x128(%rbp), %rdi
callq 0x138f0
movq -0x1a8(%rbp), %rdi
callq 0x88a0
nopl (%rax)
// File: yayuntian[P]user_agent/test_ua.cpp
// Function: BenchmarkUserAgent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void BenchmarkUserAgent(string str, int loop) {

    printf("loop cout: %u\n", loop);
    int i;
    struct timeval start, end;
    UserAgent ua;

    gettimeofday(&start, NULL);
    for (i = 0; i < loop; i++) {
        Parse(ua, str, str.size());
        if (i == 0) echo_ua(ua);
    }
    gettimeofday(&end, NULL);

    long time_cost = ((end.tv_sec - start.tv_sec) * 1000000 + \
            end.tv_usec - start.tv_usec);
    printf("cost time: %ld us, %.2f pps\n", time_cost, loop / (time_cost * 1.0) * 1000000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x198(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x574ea(%rip), %rdi     # 0x6a40d
movb $0x0, %al
callq 0x8070
leaq -0x158(%rbp), %rdi
callq 0x136a0
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8790
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x12ffa
movq -0x198(%rbp), %rsi
leaq -0x178(%rbp), %rdi
callq 0x81c0
jmp 0x12f6b
movq -0x198(%rbp), %rdi
callq 0x8350
movl %eax, %edx
leaq -0x158(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x14bd0
jmp 0x12f8e
leaq -0x178(%rbp), %rdi
callq 0x89e8
cmpl $0x0, -0x10(%rbp)
jne 0x12fea
leaq -0x158(%rbp), %rdi
callq 0x14ee0
jmp 0x12fae
jmp 0x12fea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
jmp 0x13074
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x89e8
jmp 0x13074
jmp 0x12fec
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12f4a
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x8790
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
subq %rsi, %rax
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
addq %rdx, %rax
subq %rcx, %rax
movq %rax, -0x190(%rbp)
movq -0x190(%rbp), %rsi
cvtsi2sdl -0xc(%rbp), %xmm0
cvtsi2sd %rsi, %xmm1
divsd %xmm1, %xmm0
movsd 0x52fbd(%rip), %xmm1    # 0x66008
mulsd %xmm1, %xmm0
leaq 0x573c6(%rip), %rdi     # 0x6a41c
movb $0x1, %al
callq 0x8070
jmp 0x1305f
leaq -0x158(%rbp), %rdi
callq 0x138f0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
leaq -0x158(%rbp), %rdi
callq 0x138f0
movq -0x180(%rbp), %rdi
callq 0x88a0
nopl (%rax)
// File: yayuntian[P]user_agent/userAgent.cpp
// Function: getSubStr(char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void getSubStr(char *sub, const string ua, int start, int end) {
    size_t len = end - start;
    if (len > 0) {
        const char *p = ua.c_str();
        strncpy(sub, p + start, len);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
cltq
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x14682
movq -0x30(%rbp), %rdi
callq 0x81a0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x8240
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yayuntian[P]user_agent/userAgent.cpp
// Function: readUtil(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int, char*, int&, char, bool)
void readUtil(string& ua, int ua_len, char *buf, int& index, char delimiter, bool cat) {
    int catalan = 0;
    int i = index;

    for (; i < ua_len; i++) {
        if (ua[i] == delimiter) {
            if (catalan == 0) {
                getSubStr(buf, ua, index, i);
                index = i + 1;
                return;
            }
            catalan--;
        } else if (cat && ua[i] == '(') {
            catalan++;
        }
    }
    getSubStr(buf, ua, index, i);
    index = i + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %r8d, -0x8c(%rbp)
movq %rcx, %rax
movl -0x8c(%rbp), %ecx
movq %rax, -0x88(%rbp)
movq %rdx, %rax
movq -0x88(%rbp), %rdx
movq %rax, -0x80(%rbp)
movl %esi, %eax
movq -0x80(%rbp), %rsi
movl %eax, -0x74(%rbp)
movq %rdi, %r8
movl -0x74(%rbp), %edi
movb %r9b, %al
movq %r8, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x147af
movq -0x8(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x89b0
movsbl (%rax), %eax
movsbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
jne 0x14779
cmpl $0x0, -0x28(%rbp)
jne 0x1476e
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x81c0
movq -0x98(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %edx
movl -0x2c(%rbp), %ecx
leaq -0x50(%rbp), %rsi
callq 0x14630
leaq -0x50(%rbp), %rdi
callq 0x89e8
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x147f5
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1479f
testb $0x1, -0x22(%rbp)
je 0x1479d
movq -0x8(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x89b0
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x1479d
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1479f
jmp 0x147a1
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x146f9
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x81c0
movq -0xa0(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %edx
movl -0x2c(%rbp), %ecx
leaq -0x70(%rbp), %rsi
callq 0x14630
leaq -0x70(%rbp), %rdi
callq 0x89e8
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0xa0, %rsp
popq %rbp
retq
nop