LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: szmer[P]brill/./src/rules_scoretab.cpp
// Function: RulesScoreTab::inc_bad(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void RulesScoreTab::inc_bad(int rule_type, string cue1, string good_target) {
	// Compute the high and low bound for rules concerning this situation.
	long long rule_ind_lowbnd = rule_type * RULE_RANGE
			+ tag_index[ cue1 ] * tag_index.size()*tag_index.size()
			+ tag_index[ good_target ] * tag_index.size(); // here as the alter_tag
	long long rule_ind_hibnd = rule_type * RULE_RANGE
			+ tag_index[ cue1 ] * tag_index.size()*tag_index.size()
			+ tag_index[ good_target ] * tag_index.size()
			+ tag_index.size();

	inc_bad_general(rule_ind_lowbnd, rule_ind_hibnd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0xa8(%rbp)
movl %esi, %eax
movq -0xa8(%rbp), %rsi
movq %rsi, -0x80(%rbp)
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
imull $0x767ed6b, -0xc(%rbp), %eax # imm = 0x767ED6B
cltq
movq %rax, -0x90(%rbp)
addq $0x68, %rdi
callq 0xbd80
movq -0x40(%rbp), %rdi
movslq (%rax), %rax
movq %rax, -0xa0(%rbp)
addq $0x68, %rdi
callq 0xbf20
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0xa0(%rbp), %rax
imulq %rcx, %rax
movq %rax, -0x98(%rbp)
addq $0x68, %rdi
callq 0xbf20
movq -0x98(%rbp), %rcx
movq -0x60(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq -0x90(%rbp), %rax
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
addq $0x68, %rdi
callq 0xbd80
movq -0x40(%rbp), %rdi
movslq (%rax), %rax
movq %rax, -0x88(%rbp)
addq $0x68, %rdi
callq 0xbf20
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq -0x78(%rbp), %rax
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
imull $0x767ed6b, -0xc(%rbp), %eax # imm = 0x767ED6B
cltq
movq %rax, -0x58(%rbp)
addq $0x68, %rdi
callq 0xbd80
movq -0x40(%rbp), %rdi
movslq (%rax), %rax
movq %rax, -0x70(%rbp)
addq $0x68, %rdi
callq 0xbf20
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x70(%rbp), %rax
imulq %rcx, %rax
movq %rax, -0x68(%rbp)
addq $0x68, %rdi
callq 0xbf20
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq -0x58(%rbp), %rax
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
addq $0x68, %rdi
callq 0xbd80
movq -0x40(%rbp), %rdi
movslq (%rax), %rax
movq %rax, -0x50(%rbp)
addq $0x68, %rdi
callq 0xbf20
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq -0x48(%rbp), %rax
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
addq $0x68, %rdi
callq 0xbf20
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x79f0
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: szmer[P]brill/./src/rules_scoretab.cpp
// Function: RulesScoreTab::inc_bad_general(long long, long long)
void RulesScoreTab::inc_bad_general(long long rule_ind_lowbnd, long long rule_ind_hibnd) {
	long long exam_ind = rule_ind_lowbnd - 1;

	// Basically ascend to the highest index in the set, until we reach indices which are out of the
	// scope (.upper_bound() returns first larger value that is present in a set)
	while((exam_ind =
			* eligible_rules.upper_bound(exam_ind))
			< rule_ind_hibnd && exam_ind >= rule_ind_lowbnd
	) {

		tab[exam_ind].bad ++;

		if(tab[exam_ind].good - tab[exam_ind].bad <= 0)
			eligible_rules.erase(exam_ind);

		if(eligible_rules.size() == 0)
			throw "No good rules found";

		// We must avoid dereferencing .end() iterator in the loop condition:
		if(exam_ind == * eligible_rules.rbegin())
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq -0x20(%rbp), %rsi
callq 0xcac0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcb00
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x39(%rbp)
jge 0x7a56
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
setge %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x7a62
jmp 0x7b3e
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
leaq -0x20(%rbp), %rsi
callq 0xc930
movq -0x38(%rbp), %rdi
movl 0x8c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8c(%rax)
addq $0x38, %rdi
leaq -0x20(%rbp), %rsi
callq 0xc930
movq -0x38(%rbp), %rdi
movl 0x88(%rax), %eax
movl %eax, -0x40(%rbp)
addq $0x38, %rdi
leaq -0x20(%rbp), %rsi
callq 0xc930
movq %rax, %rcx
movl -0x40(%rbp), %eax
subl 0x8c(%rcx), %eax
cmpl $0x0, %eax
jg 0x7acf
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq -0x20(%rbp), %rsi
callq 0xcb20
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0xcb50
cmpq $0x0, %rax
jne 0x7b09
movl $0x8, %edi
callq 0x3140
movq %rax, %rdi
leaq 0x107d6(%rip), %rax     # 0x182cc
movq %rax, (%rdi)
movq 0x1b4c0(%rip), %rsi     # 0x22fc0
xorl %eax, %eax
movl %eax, %edx
callq 0x3470
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0xcb70
leaq -0x30(%rbp), %rdi
callq 0xcba0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq (%rcx), %rax
jne 0x7b39
jmp 0x7b3e
jmp 0x7a18
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: szmer[P]brill/./src/rules_scoretab.cpp
// Function: RulesScoreTab::get_winner()
Rule * RulesScoreTab::get_winner() {
	RuleScore * winner_score;
	winner_score = & tab[ *(eligible_rules.begin()) ];
	// Look for a winner (one with better score than all already known):
	for(set<long long>::iterator rls_pnt = eligible_rules.begin(); rls_pnt != eligible_rules.end(); rls_pnt++)
		if((tab[ *rls_pnt ].good - tab[ *rls_pnt ].bad) > (winner_score->good - winner_score->bad))
			winner_score = & tab[ *rls_pnt ];

	Rule * winner;
	winner = & winner_score->rule;

	return winner;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
callq 0xcc10
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xcb00
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xc930
movq -0x40(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x8, %rdi
callq 0xcc10
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0xcc70
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xcc40
testb $0x1, %al
jne 0xa65d
jmp 0xa70a
movq -0x40(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcb00
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xc930
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl 0x88(%rcx), %ecx
movl %ecx, -0x4c(%rbp)
addq $0x38, %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcb00
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xc930
movq %rax, %rcx
movl -0x4c(%rbp), %eax
subl 0x8c(%rcx), %eax
movq -0x10(%rbp), %rcx
movl 0x88(%rcx), %ecx
movq -0x10(%rbp), %rdx
subl 0x8c(%rdx), %ecx
cmpl %ecx, %eax
jle 0xa6f4
movq -0x40(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcb00
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0xc930
movq %rax, -0x10(%rbp)
jmp 0xa6f6
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xcca0
movq %rax, -0x30(%rbp)
jmp 0xa636
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: szmer[P]brill/Brill-train.cpp
// Function: print_usage()
void print_usage() {
  cout << "Usage: Brill-train CORPUS_FILE TAGSET_FILE [-o OUTPUT_FILE] [-m DESIRED_MARGIN]" << endl << "      [-r MAX_RULES]" << endl << endl;
  cout << "   CORPUS_FILE  should be in format: word\\tcorrect-tag\\n for each word-tag pair," << endl << "                with each sentence starting with one empty line." << endl;
  cout << "   TAGSET_FILE  should contain all the possible tags: tag\\n for each tag." << endl;
  cout << "   -o (OUTPUT_FILE)  will be overwritten." << endl << endl;
  cout << "   Ways to tell when to stop learning." << endl;
  cout << "   -m  is desired margin, as a fractional number, of improvement of the last" << endl << "       transformation comparing to the one step earlier." << endl;
  cout << "   -r  specifies how many rules should the trainer produce (default: 1000)." << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x188ad(%rip), %rdi     # 0x22fd8
leaq 0xdbae(%rip), %rsi      # 0x182e0
callq 0x3290
movq %rax, %rdi
movq 0x18877(%rip), %rsi     # 0x22fb8
callq 0x32e0
movq %rax, %rdi
leaq 0xdbe0(%rip), %rsi      # 0x18330
callq 0x3290
movq %rax, %rdi
movq 0x18859(%rip), %rsi     # 0x22fb8
callq 0x32e0
movq %rax, %rdi
movq 0x1884a(%rip), %rsi     # 0x22fb8
callq 0x32e0
movq 0x1885e(%rip), %rdi     # 0x22fd8
leaq 0xdbc4(%rip), %rsi      # 0x18345
callq 0x3290
movq %rax, %rdi
movq 0x18828(%rip), %rsi     # 0x22fb8
callq 0x32e0
movq %rax, %rdi
leaq 0xdbf7(%rip), %rsi      # 0x18396
callq 0x3290
movq %rax, %rdi
movq 0x1880a(%rip), %rsi     # 0x22fb8
callq 0x32e0
movq 0x1881e(%rip), %rdi     # 0x22fd8
leaq 0xdc16(%rip), %rsi      # 0x183d7
callq 0x3290
movq %rax, %rdi
movq 0x187e8(%rip), %rsi     # 0x22fb8
callq 0x32e0
movq 0x187fc(%rip), %rdi     # 0x22fd8
leaq 0xdc3e(%rip), %rsi      # 0x18421
callq 0x3290
movq %rax, %rdi
movq 0x187c6(%rip), %rsi     # 0x22fb8
callq 0x32e0
movq %rax, %rdi
movq 0x187b7(%rip), %rsi     # 0x22fb8
callq 0x32e0
movq 0x187cb(%rip), %rdi     # 0x22fd8
leaq 0xdc37(%rip), %rsi      # 0x1844b
callq 0x3290
movq %rax, %rdi
movq 0x18795(%rip), %rsi     # 0x22fb8
callq 0x32e0
movq 0x187a9(%rip), %rdi     # 0x22fd8
leaq 0xdc3c(%rip), %rsi      # 0x18472
callq 0x3290
movq %rax, %rdi
movq 0x18773(%rip), %rsi     # 0x22fb8
callq 0x32e0
movq %rax, %rdi
leaq 0xdc6b(%rip), %rsi      # 0x184bf
callq 0x3290
movq %rax, %rdi
movq 0x18755(%rip), %rsi     # 0x22fb8
callq 0x32e0
movq 0x18769(%rip), %rdi     # 0x22fd8
leaq 0xdc82(%rip), %rsi      # 0x184f8
callq 0x3290
movq %rax, %rdi
movq 0x18733(%rip), %rsi     # 0x22fb8
callq 0x32e0
popq %rbp
retq
nopl (%rax)
// File: szmer[P]brill/Brill-train.cpp
// Function: prepare_output_file(std::basic_ofstream<char, std::char_traits<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Corpus*)
void prepare_output_file(ofstream * out, string name, Corpus * corp) {
  if(name == "")
    return;

  out->open(name.c_str(), ofstream::trunc);

  for(map<string,string>::iterator i = corp->unigram_table.begin();
                                   i != corp->unigram_table.end(); i++)
    (*out) << i->first << ' ' << i->second << '\t';

  corp->unigram_table.clear();

  (*out) << "\n";
  out->flush();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xd874(%rip), %rsi      # 0x1812e
callq 0xcce0
testb $0x1, %al
jne 0xa8c5
jmp 0xa8ca
jmp 0xa9af
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x3100
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movl $0x20, %edx
callq 0x3050
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0xc260
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0xc2c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc290
testb $0x1, %al
jne 0xa921
jmp 0xa989
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc350
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
movq %rax, %rdi
movl $0x20, %esi
callq 0x3340
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc350
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x3270
movq %rax, %rdi
movl $0x9, %esi
callq 0x3340
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xc370
movq %rax, -0x30(%rbp)
jmp 0xa8fd
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0xcd10
movq -0x8(%rbp), %rdi
leaq 0xdba3(%rip), %rsi      # 0x18544
callq 0x3290
movq -0x8(%rbp), %rdi
callq 0x31c0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/compareDef.cc
// Function: main
int main()
{
	bool i = compare(0, 42); // uses less; i is -1

	// result depends on the isbns in item1 and item2
	Sales_data item1(cin), item2(cin);
	bool j = compare(item1, item2, compareIsbn);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x2a, -0x10(%rbp)
leaq -0xc(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1400
testl %eax, %eax
setne -0x5(%rbp)
movq 0x2c96(%rip), %rsi      # 0x3fe0
movq %rsi, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1680
movq -0x90(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1680
jmp 0x136c
leaq 0x14d(%rip), %rdx       # 0x14c0
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1460
movl %eax, -0x94(%rbp)
jmp 0x1388
movl -0x94(%rbp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x85(%rbp)
movl $0x0, -0x4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1540
leaq -0x48(%rbp), %rdi
callq 0x1540
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x13ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1540
leaq -0x48(%rbp), %rdi
callq 0x1540
movq -0x80(%rbp), %rdi
callq 0x1170
nopl (%rax)
// File: ruankotovich[P]TextCorrection-Trie/src/trie.hpp
// Function: trie::Trie_t::putIndividualWord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void putIndividualWord(std::string& str, const std::string& content)
    {
      TrieNode_t*currentRoot, *lastRoot;
      currentRoot = this->m_lambdaNode.get();

      wchar_t chart[str.size()];
      push_string_to_wchar(chart, str);

      for (unsigned int i = 0; i < wcslen(chart); i++) {

        unsigned int code = this->m_characterMap[chart[i]];

        lastRoot = currentRoot;
        currentRoot = currentRoot->getChild(code);
        if (!currentRoot) {
          currentRoot = lastRoot->insertNReturnChild(code);
        }
      }

      if (currentRoot != this->m_lambdaNode.get()) {

        if (!currentRoot->isEndOfWord()) {
          currentRoot->buildContent();
          currentRoot->setEndOfWord(true);
        }

        currentRoot->addValue(content);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x9570
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2120
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movq %rcx, %rax
movq %rsp, %rdx
movq %rdx, -0x30(%rbp)
leaq 0xf(,%rcx,4), %rcx
andq $-0x10, %rcx
movq %rsp, %rsi
subq %rcx, %rsi
movq %rsi, -0x80(%rbp)
movq %rsi, %rsp
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdx
callq 0x5f20
movl $0x0, -0x3c(%rbp)
movq -0x80(%rbp), %rdi
movl -0x3c(%rbp), %eax
movq %rax, -0x90(%rbp)
callq 0x2150
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x330c
movq -0x80(%rbp), %rax
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
movl -0x3c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
leaq -0x44(%rbp), %rsi
callq 0x95a0
movl (%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x95d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x32fc
movq -0x28(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x9650
movq %rax, -0x20(%rbp)
jmp 0x32fe
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3285
movq -0x88(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x9570
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
je 0x33ac
movq -0x20(%rbp), %rdi
callq 0x97d0
testb $0x1, %al
jne 0x3356
movq -0x20(%rbp), %rdi
callq 0x97e0
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9840
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x20b0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x9860
jmp 0x338a
leaq -0x68(%rbp), %rdi
callq 0x2100
jmp 0x33ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2100
jmp 0x33b8
movq -0x30(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ruankotovich[P]TextCorrection-Trie/src/trie.hpp
// Function: trie::Trie_t::searchKeyword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::pair<bool, std::vector<std::string>> searchKeyword(std::string& keyword)
    {
      std::transform(keyword.begin(), keyword.end(), keyword.begin(), ::tolower);
      wchar_t chart[keyword.size()];
      push_string_to_wchar(chart, keyword);

      TrieNode_t* currentNode = this->m_lambdaNode.get();

      for (unsigned int i = 0; i < wcslen(chart); i++) {
        currentNode = currentNode->getChild(m_characterMap[chart[i]]);

        if (currentNode == nullptr) {
          break;
        }
      }

      if (currentNode != nullptr) {
        if (currentNode->isEndOfWord()) {
          return { true, *currentNode->getValues() };
        }
      }

      return { false, this->m_emptyResponse };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
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, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2160
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2160
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x1d5c9(%rip), %rcx     # 0x20fd0
callq 0x53e0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2120
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movq %rcx, %rax
movq %rsp, %rdx
movq %rdx, -0x40(%rbp)
leaq 0xf(,%rcx,4), %rcx
andq $-0x10, %rcx
movq %rsp, %rsi
subq %rcx, %rsi
movq %rsi, -0x78(%rbp)
movq %rsi, %rsp
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdx
callq 0x5f20
movq -0x70(%rbp), %rdi
callq 0x9570
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x78(%rbp), %rdi
movl -0x54(%rbp), %eax
movq %rax, -0x90(%rbp)
callq 0x2150
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x3ad7
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rdi
movq -0x50(%rbp), %rcx
movq %rcx, -0x98(%rbp)
addq $0x8, %rdi
movl -0x54(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x95a0
movq -0x98(%rbp), %rdi
movl (%rax), %esi
callq 0x95d0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x3aca
jmp 0x3ad7
jmp 0x3acc
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x3a64
cmpq $0x0, -0x50(%rbp)
je 0x3b18
movq -0x50(%rbp), %rdi
callq 0x97d0
testb $0x1, %al
jne 0x3aed
jmp 0x3b16
movb $0x1, -0x59(%rbp)
movq -0x50(%rbp), %rdi
callq 0x10e10
movq -0x88(%rbp), %rdi
movq %rax, %rdx
leaq -0x59(%rbp), %rsi
callq 0x10e30
movl $0x1, -0x60(%rbp)
jmp 0x3b3e
jmp 0x3b18
movq -0x88(%rbp), %rdi
movq -0x70(%rbp), %rdx
movb $0x0, -0x61(%rbp)
addq $0xe0, %rdx
leaq -0x61(%rbp), %rsi
callq 0x10e30
movl $0x1, -0x60(%rbp)
movq -0x80(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nop
// File: ruankotovich[P]TextCorrection-Trie/src/trie.hpp
// Function: trie::Trie_t::addStopWords(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void addStopWords(const std::string& filename)
    {
      std::string currentLine;
      std::ifstream fileInputStream(filename);

      while (std::getline(fileInputStream, currentLine)) {
        std::transform(currentLine.begin(), currentLine.end(), currentLine.begin(), ::tolower);
        m_stopWords.insert(currentLine);
      }
    }

// Assembly:
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rdi, 0x2b0(%rsp)
movq %rsi, 0x2a8(%rsp)
movq 0x2b0(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x288(%rsp), %rdi
callq 0x2260
movq 0x2a8(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movl $0x8, %edx
callq 0x22d0
jmp 0x41cd
jmp 0x41cf
leaq 0x80(%rsp), %rdi
leaq 0x288(%rsp), %rsi
callq 0x2050
movq %rax, 0x30(%rsp)
jmp 0x41eb
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2230
movb %al, 0x2f(%rsp)
jmp 0x4205
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x4212
jmp 0x42db
leaq 0x288(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2160
movq 0x18(%rsp), %rdi
movq %rax, 0x68(%rsp)
callq 0x20e0
movq 0x18(%rsp), %rdi
movq %rax, 0x60(%rsp)
callq 0x2160
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x1cd73(%rip), %rcx     # 0x20fd0
callq 0x53e0
movq %rax, 0x20(%rsp)
jmp 0x4269
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
addq $0xa8, %rdi
leaq 0x288(%rsp), %rsi
callq 0x5470
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x4297
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movb %al, 0x48(%rsp)
jmp 0x41cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x42fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2060
jmp 0x42fd
leaq 0x80(%rsp), %rdi
callq 0x2060
leaq 0x288(%rsp), %rdi
callq 0x2100
addq $0x2b8, %rsp            # imm = 0x2B8
retq
leaq 0x288(%rsp), %rdi
callq 0x2100
movq 0x78(%rsp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
nop
// File: ruankotovich[P]TextCorrection-Trie/src/trie.hpp
// Function: trie::Trie_t::push_string_to_wchar(wchar_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void push_string_to_wchar(wchar_t* w, std::string& a)
    {
      setlocale(LC_ALL, "");
      const char* nw = a.c_str();
      mbsrtowcs(w, &nw, a.length(), NULL);
      w[a.length()] = 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x6, %edi
leaq 0x1011f(%rip), %rsi     # 0x1605e
callq 0x2190
movq 0x20(%rsp), %rdi
callq 0x20a0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2280
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x18(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
callq 0x21c0
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2280
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl $0x0, (%rax,%rcx,4)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ruankotovich[P]TextCorrection-Trie/src/trie.hpp
// Function: trie::TrieNode_t::getChild(unsigned int)
TrieNode_t* getChild(unsigned int value)
    {
      auto child = this->m_childrenMap.find(value);
      if (child != this->m_childrenMap.end()) {
        return child->second.get();
      }
      return nullptr;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x24(%rsp), %rsi
callq 0x9cf0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x9d40
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x9d20
testb $0x1, %al
jne 0x961a
jmp 0x9637
leaq 0x18(%rsp), %rdi
callq 0x9d70
movq %rax, %rdi
addq $0x8, %rdi
callq 0x9570
movq %rax, 0x30(%rsp)
jmp 0x9640
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ruankotovich[P]TextCorrection-Trie/src/trie.hpp
// Function: trie::TrieNode_t::insertNReturnChild(unsigned int)
TrieNode_t* insertNReturnChild(unsigned int value)
    {
      auto finder = this->m_childrenMap.find(value);

      if(finder != this->m_childrenMap.end()){
        return finder->second.get();
      }else{
        return this->m_childrenMap.emplace(value, std::unique_ptr<TrieNode_t>(new TrieNode_t(value))).first->second.get();
      }

    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x30(%rsp)
leaq 0x84(%rsp), %rsi
callq 0x9cf0
movq 0x30(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0x9d40
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x9d20
testb $0x1, %al
jne 0x96a9
jmp 0x96cc
leaq 0x78(%rsp), %rdi
callq 0x9d70
movq %rax, %rdi
addq $0x8, %rdi
callq 0x9570
movq %rax, 0x90(%rsp)
jmp 0x97b6
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x40, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movl 0x84(%rsp), %esi
callq 0x4140
jmp 0x96f9
movq 0x28(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xa070
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x84(%rsp), %rsi
callq 0xa020
movb %dl, 0x17(%rsp)
movq %rax, 0x18(%rsp)
jmp 0x972f
movb 0x17(%rsp), %al
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movb %al, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
movb 0x40(%rsp), %al
movb %al, 0x68(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x9d70
movq %rax, %rdi
addq $0x8, %rdi
callq 0x9570
movq %rax, 0x90(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x46b0
jmp 0x97b6
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movl $0x40, %esi
callq 0x21d0
jmp 0x97c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x46b0
jmp 0x97c6
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x2300
// File: ruankotovich[P]TextCorrection-Trie/src/trie.hpp
// Function: trie::TrieNode_t::getChildren()
std::vector<TrieNode_t*> getChildren()
    {
      std::vector<TrieNode_t*> nodes;
      for (auto &cur : this->m_childrenMap) {
        nodes.push_back(cur.second.get());
      }
      return nodes;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x57(%rsp)
callq 0xeb10
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xeb20
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x9d40
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x9d20
testb $0x1, %al
jne 0xb5bb
jmp 0xb614
leaq 0x40(%rsp), %rdi
callq 0xeb50
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x9570
movq (%rsp), %rdi
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0xeb70
jmp 0xb5ed
jmp 0xb5ef
leaq 0x40(%rsp), %rdi
callq 0xeba0
jmp 0xb5a6
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xb930
jmp 0xb633
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xb629
movq (%rsp), %rdi
callq 0xb930
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x2300
nopl (%rax)
// File: Silica[P]PSL/PSLc.cpp
// Function: compiled(_IO_FILE*)
bool compiled(FILE *exe)
{
	int i = sizeof(dword);
	fseek(exe, -i, SEEK_END);
	dword l;
	fread(&l, 1, sizeof(dword), exe);
	return l == 0xDEADC0DE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
subl -0xc(%rbp), %eax
movslq %eax, %rsi
movl $0x2, %edx
callq 0xc1f0
movq -0x8(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0xc230
movl $0xdeadc0de, %eax       # imm = 0xDEADC0DE
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Silica[P]PSL/PSLc.cpp
// Function: execute(_IO_FILE*, PSL::variable&)
void execute(FILE *exe, variable &arg)
{
	int i = sizeof(dword) * 2;
	fseek(exe, -i, SEEK_END);
	dword l;
	int end = ftell(exe);
	fread(&l, 1, sizeof(dword), exe);
	fseek(exe, l, SEEK_SET);
	PSLVM p;
	if (p.loadCompiledCode(exe, end - l))
		return;
	p.run(arg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
negl %eax
movslq %eax, %rsi
movl $0x2, %edx
callq 0xc1f0
movq -0x8(%rbp), %rdi
callq 0xc030
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0xc230
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0xc1f0
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xc930
movq -0x78(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x24(%rbp), %rdx
movq -0x20(%rbp), %rax
subq %rax, %rdx
callq 0xcee0
movl %eax, -0x6c(%rbp)
jmp 0xc77c
movl -0x6c(%rbp), %eax
cmpl $0x0, %eax
je 0xc7a4
movl $0x1, -0x60(%rbp)
jmp 0xc7c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xcec0
jmp 0xc7d9
movq -0x10(%rbp), %rdx
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xcfb0
jmp 0xc7b7
leaq -0x68(%rbp), %rdi
callq 0xd060
movl $0x0, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xcec0
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
// File: Silica[P]PSL/PSLc.cpp
// Function: main
int main(int argc, char **argv)
{
	FILE *exe = fopen(argv[0], "rb");
	if (!exe)
		return 1;

	if (!compiled(exe))
	{
		if (argc >= 2)
			compile(exe, argv[1]);
	}
	else
	{
		variable arg;
		for (int i = 0; i < argc; i++)
			arg[i] = argv[i];
		execute(exe, arg);
#if _WIN32
		getch();
#endif
	}

	fclose(exe);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x31ea4(%rip), %rsi     # 0x3e6b8
callq 0xc200
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc830
movl $0x1, -0x4(%rbp)
jmp 0xc90f
movq -0x18(%rbp), %rdi
callq 0xc690
testb $0x1, %al
jne 0xc859
cmpl $0x2, -0x8(%rbp)
jl 0xc854
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xc3d0
jmp 0xc8ff
leaq -0x20(%rbp), %rdi
callq 0xd090
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0xc8da
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %ecx, %edx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd0f0
jmp 0xc892
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xd150
jmp 0xc8a1
leaq -0x30(%rbp), %rdi
callq 0xd1c0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc869
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xc8f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd1c0
jmp 0xc8f4
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc6f0
jmp 0xc8e9
leaq -0x20(%rbp), %rdi
callq 0xd1c0
jmp 0xc8ff
leaq -0x20(%rbp), %rdi
callq 0xd1c0
jmp 0xc918
movq -0x18(%rbp), %rdi
callq 0xc1c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ddunbar[P]PDSample/PDSample.cpp
// Function: usage(char*)
void usage(char *app)
{
	printf(	"Usage: %s [-m] [-t] [-r <relax count=0>] [-M <multiplier=10>] [-N <minMaxThrows=1000>] <method> <radius> <output>\n", app);
	printf(	"	-m		maximize point set after sampling\n");
	printf(	"	-t		use tiled domain\n");
	printf(	"	-r		apply the specified number of relaxations after sampling (requires qvoronoi)\n");
	printf(	"	-M		set multiplier for DartThrowing and BestCandidate samplers\n");
	printf(	"	-N		set minimum number of maximum throws for DartThrowing sampler\n");
	printf(	"	available methods = {\n"
			"		DartThrowing, (uses multiplier and minMaxThrows)\n"
			"		BestCandidate, (uses multiplier)\n"
			"		Boundary, \n"
			"		Pure, \n"
			"		LinearPure, \n"
			"		Penrose, \n"
			"		Uniform" "}\n");

	exit(1);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rsi
leaq 0x131a0(%rip), %rdi     # 0x16060
movb $0x0, %al
callq 0x2040
leaq 0x13205(%rip), %rdi     # 0x160d3
movb $0x0, %al
callq 0x2040
leaq 0x1321f(%rip), %rdi     # 0x160fb
movb $0x0, %al
callq 0x2040
leaq 0x13228(%rip), %rdi     # 0x16112
movb $0x0, %al
callq 0x2040
leaq 0x1326d(%rip), %rdi     # 0x16165
movb $0x0, %al
callq 0x2040
leaq 0x132a0(%rip), %rdi     # 0x161a6
movb $0x0, %al
callq 0x2040
leaq 0x132d6(%rip), %rdi     # 0x161ea
movb $0x0, %al
callq 0x2040
movl $0x1, %edi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: ddunbar[P]PDSample/PDSampling.cpp
// Function: PDSampler::getTiled(Vec2)
Vec2 PDSampler::getTiled(Vec2 v)
{
	float x = v.x, y = v.y;

	if (isTiled) {
		if (x<-1) x += 2;
		else if (x>1) x -= 2;

		if (y<-1) y += 2;
		else if (y>1) y -= 2;
	}

	return Vec2(x,y);
}

// Assembly:
subq $0x28, %rsp
movlpd %xmm0, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movss 0x18(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
testb $0x1, 0x13d4(%rax)
je 0x3dff
movss 0x12763(%rip), %xmm0    # 0x164c4
ucomiss 0xc(%rsp), %xmm0
jbe 0x3d7e
movss 0x12750(%rip), %xmm0    # 0x164c0
addss 0xc(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x3dab
movss 0xc(%rsp), %xmm0
movss 0x1273c(%rip), %xmm1    # 0x164c8
ucomiss %xmm1, %xmm0
jbe 0x3da9
movss 0xc(%rsp), %xmm0
movss 0x12721(%rip), %xmm1    # 0x164c0
subss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x3dab
movss 0x12711(%rip), %xmm0    # 0x164c4
ucomiss 0x8(%rsp), %xmm0
jbe 0x3dd0
movss 0x126fe(%rip), %xmm0    # 0x164c0
addss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
jmp 0x3dfd
movss 0x8(%rsp), %xmm0
movss 0x126ea(%rip), %xmm1    # 0x164c8
ucomiss %xmm1, %xmm0
jbe 0x3dfb
movss 0x8(%rsp), %xmm0
movss 0x126cf(%rip), %xmm1    # 0x164c0
subss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
jmp 0x3dfd
jmp 0x3dff
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
leaq 0x20(%rsp), %rdi
callq 0x6b60
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: ddunbar[P]PDSample/PDSampling.cpp
// Function: PDSampler::getGridXY(Vec2&, int*, int*)
void PDSampler::getGridXY(Vec2 &v, int *gx_out, int *gy_out)
{
	int gx = *gx_out = (int) floor(.5*(v.x + 1)*m_gridSize);
	int gy = *gy_out = (int) floor(.5*(v.y + 1)*m_gridSize);
	if (gx<0 || gx>=m_gridSize || gy<0 || gy>=m_gridSize) {
		printf("Internal error, point outside grid was generated, ignoring.\n");
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rcx
movss 0x12679(%rip), %xmm0    # 0x164c8
addss (%rcx), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x121b9(%rip), %xmm0    # 0x16018
mulsd %xmm1, %xmm0
cvtsi2sdl 0x13b0(%rax), %xmm1
mulsd %xmm1, %xmm0
callq 0x22d0
movq 0x8(%rsp), %rax
cvttsd2si %xmm0, %ecx
movq 0x20(%rsp), %rdx
movl %ecx, (%rdx)
movl %ecx, 0x14(%rsp)
movq 0x28(%rsp), %rcx
movss 0x12633(%rip), %xmm0    # 0x164c8
addss 0x4(%rcx), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x12172(%rip), %xmm0    # 0x16018
mulsd %xmm1, %xmm0
cvtsi2sdl 0x13b0(%rax), %xmm1
mulsd %xmm1, %xmm0
callq 0x22d0
cvttsd2si %xmm0, %eax
movq 0x18(%rsp), %rcx
movl %eax, (%rcx)
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x3efa
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x13b0(%rcx), %eax
jge 0x3efa
cmpl $0x0, 0x10(%rsp)
jl 0x3efa
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x13b0(%rcx), %eax
jl 0x3f08
leaq 0x142b4(%rip), %rdi     # 0x181b5
movb $0x0, %al
callq 0x2040
addq $0x38, %rsp
retq
nopl (%rax)
// File: ddunbar[P]PDSample/PDSampling.cpp
// Function: PDSampler::addPoint(Vec2)
void PDSampler::addPoint(Vec2 pt)
{
	int i, gx, gy, *cell;

	points.push_back(pt);

	if (m_grid) {
		getGridXY(pt, &gx, &gy);
		cell = m_grid[gy*m_gridSize + gx];
		for (i=0; i<kMaxPointsPerCell; i++) {
			if (cell[i]==-1) {
				cell[i] = (int) points.size()-1;
				break;
			}
		}
		if (i==kMaxPointsPerCell) {
			printf("Internal error, overflowed max points per grid cell. Exiting.\n");
			exit(1);
		}
	}
}

// Assembly:
subq $0x38, %rsp
movlpd %xmm0, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x13b8, %rdi           # imm = 0x13B8
leaq 0x30(%rsp), %rsi
callq 0x6b90
movq 0x8(%rsp), %rax
cmpq $0x0, 0x13a8(%rax)
je 0x4004
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x1c(%rsp), %rcx
callq 0x3e20
movq 0x8(%rsp), %rdx
movq 0x13a8(%rdx), %rax
movl 0x1c(%rsp), %ecx
imull 0x13b0(%rdx), %ecx
addl 0x20(%rsp), %ecx
movslq %ecx, %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
cmpl $0x9, 0x24(%rsp)
jge 0x3fe3
movq 0x10(%rsp), %rax
movslq 0x24(%rsp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x3fd4
movq 0x8(%rsp), %rdi
addq $0x13b8, %rdi           # imm = 0x13B8
callq 0x3970
movl %eax, %edx
subl $0x1, %edx
movq 0x10(%rsp), %rax
movslq 0x24(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x3fe3
jmp 0x3fd6
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3f98
cmpl $0x9, 0x24(%rsp)
jne 0x4002
leaq 0x14201(%rip), %rdi     # 0x181f2
movb $0x0, %al
callq 0x2040
movl $0x1, %edi
callq 0x2200
jmp 0x4004
addq $0x38, %rsp
retq
nopl (%rax)
// File: ddunbar[P]PDSample/PDSampling.cpp
// Function: PDSampler::findClosestNeighbor(Vec2&, float)
float PDSampler::findClosestNeighbor(Vec2 &pt, float distance)
{
	if (!m_grid) {
		printf("Internal error, sampler cannot search without grid.\n");
		exit(1);
	}

	float closestSqrd = distance*distance;
	int i, j, k, gx, gy, N = (int) ceil(distance/m_gridCellSize);
	if (N>(m_gridSize>>1)) N = m_gridSize>>1;
	
	getGridXY(pt, &gx, &gy);
	for (j=-N; j<=N; j++) {
		for (i=-N; i<=N; i++) {
			int cx = (gx+i+m_gridSize)%m_gridSize;
			int cy = (gy+j+m_gridSize)%m_gridSize;
			int *cell = m_grid[cy*m_gridSize + cx];

			for (k=0; k<kMaxPointsPerCell; k++) {
				if (cell[k]==-1) {
					break;
				} else {
					float d = getDistanceSquared(pt, points[cell[k]]);

					if (d<closestSqrd)
						closestSqrd = d;
				}
			}
		}
	}

	return sqrt(closestSqrd);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movss %xmm0, 0x44(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x13a8(%rax)
jne 0x4290
leaq 0x13fb2(%rip), %rdi     # 0x18231
movb $0x0, %al
callq 0x2040
movl $0x1, %edi
callq 0x2200
movq 0x8(%rsp), %rax
movss 0x44(%rsp), %xmm0
mulss 0x44(%rsp), %xmm0
movss %xmm0, 0x40(%rsp)
movss 0x44(%rsp), %xmm0
divss 0x13b4(%rax), %xmm0
callq 0x6c00
movq 0x8(%rsp), %rcx
cvttss2si %xmm0, %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl 0x13b0(%rcx), %ecx
sarl %ecx
cmpl %ecx, %eax
jle 0x42e8
movq 0x8(%rsp), %rax
movl 0x13b0(%rax), %eax
sarl %eax
movl %eax, 0x28(%rsp)
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x2c(%rsp), %rcx
callq 0x3e20
xorl %eax, %eax
subl 0x28(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x28(%rsp), %eax
jg 0x444d
xorl %eax, %eax
subl 0x28(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jg 0x443b
movq 0x8(%rsp), %rcx
movl 0x30(%rsp), %eax
addl 0x3c(%rsp), %eax
addl 0x13b0(%rcx), %eax
cltd
idivl 0x13b0(%rcx)
movl %edx, 0x24(%rsp)
movl 0x2c(%rsp), %eax
addl 0x38(%rsp), %eax
addl 0x13b0(%rcx), %eax
cltd
idivl 0x13b0(%rcx)
movl %edx, %eax
movq 0x8(%rsp), %rdx
movl %eax, 0x20(%rsp)
movq 0x13a8(%rdx), %rax
movl 0x20(%rsp), %ecx
imull 0x13b0(%rdx), %ecx
addl 0x24(%rsp), %ecx
movslq %ecx, %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x34(%rsp)
cmpl $0x9, 0x34(%rsp)
jge 0x4429
movq 0x18(%rsp), %rax
movslq 0x34(%rsp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x43b9
jmp 0x4429
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
addq $0x13b8, %rdi           # imm = 0x13B8
movq 0x18(%rsp), %rax
movslq 0x34(%rsp), %rcx
movslq (%rax,%rcx,4), %rsi
callq 0x3990
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq %rax, %rdx
callq 0x6c40
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm1
movss 0x40(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4415
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x40(%rsp)
jmp 0x4417
jmp 0x4419
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x439c
jmp 0x442b
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x4323
jmp 0x443d
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x430b
movss 0x40(%rsp), %xmm0
callq 0x6d50
addq $0x58, %rsp
retq
nopl (%rax)
// File: ddunbar[P]PDSample/PDSampling.cpp
// Function: DartThrowing::complete()
void DartThrowing::complete()
{
	while (1) {
		int i, N = (int) points.size()*m_maxThrowsMult;
		if (N<m_minMaxThrows) N = m_minMaxThrows;

		for (i=0; i<N; i++) {
			Vec2 pt = randomPoint();

			findNeighbors(pt, 2*radius);

			if (!m_neighbors.size()) {
				addPoint(pt);
				break;
			}
		}

		if (i==N)
			break;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
addq $0x13b8, %rdi           # imm = 0x13B8
callq 0x3970
movq (%rsp), %rcx
imull 0x13dc(%rcx), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x13d8(%rcx), %eax
jge 0x53bb
movq (%rsp), %rax
movl 0x13d8(%rax), %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x543a
movq (%rsp), %rdi
callq 0x3cb0
movq (%rsp), %rdi
movlpd %xmm0, 0x10(%rsp)
movss 0x110d8(%rip), %xmm0    # 0x164c0
mulss 0x13d0(%rdi), %xmm0
leaq 0x10(%rsp), %rsi
callq 0x4010
movq (%rsp), %rdi
addq $0x1390, %rdi           # imm = 0x1390
callq 0x6d30
cmpq $0x0, %rax
jne 0x542b
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x3f10
jmp 0x543a
jmp 0x542d
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x53c3
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jne 0x5446
jmp 0x544b
jmp 0x5382
addq $0x28, %rsp
retq
// File: ddunbar[P]PDSample/PDSampling.cpp
// Function: BestCandidate::complete()
void BestCandidate::complete()
{
	for (int i=0; i<m_N; i++) {
		Vec2 best(0,0);
		float bestDistance = 0;
		int count = 1 + (int) points.size()*m_multiplier;

		for (int j=0; j<count; j++) {
			Vec2 pt = randomPoint();
			float closest = 2;

			closest = findClosestNeighbor(pt, 4*radius);
			if (j==0 || closest>bestDistance) {
				bestDistance = closest;
				best = pt;
			}
		}

		addPoint(best);
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x8(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl 0x13dc(%rcx), %eax
jge 0x5608
leaq 0x34(%rsp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x6b60
movq 0x8(%rsp), %rdi
xorps %xmm0, %xmm0
movss %xmm0, 0x30(%rsp)
addq $0x13b8, %rdi           # imm = 0x13B8
callq 0x3970
movq 0x8(%rsp), %rcx
imull 0x13d8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x55de
movq 0x8(%rsp), %rdi
callq 0x3cb0
movq 0x8(%rsp), %rdi
movlpd %xmm0, 0x20(%rsp)
movss 0x10f44(%rip), %xmm0    # 0x164c0
movss %xmm0, 0x1c(%rsp)
movss 0x10f42(%rip), %xmm0    # 0x164cc
mulss 0x13d0(%rdi), %xmm0
leaq 0x20(%rsp), %rsi
callq 0x4250
movss %xmm0, 0x1c(%rsp)
cmpl $0x0, 0x28(%rsp)
je 0x55b6
movss 0x1c(%rsp), %xmm0
ucomiss 0x30(%rsp), %xmm0
jbe 0x55cc
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x34(%rsp)
jmp 0x55ce
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x5555
movq 0x8(%rsp), %rdi
movq 0x34(%rsp), %rax
movq %rax, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x3f10
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x54fb
addq $0x48, %rsp
retq
nopl (%rax)
// File: ddunbar[P]PDSample/PDSampling.cpp
// Function: PenroseSampler::complete()
void PenroseSampler::complete()
{
	PenroseQuasisampler s((unsigned int) (9.1/(radius*radius)));
	std::vector<Point2D> pts = s.getSamplingPoints();

	for (std::vector<Point2D>::iterator it=pts.begin(); it!=pts.end(); it++ ) {
		Vec2 pt((float) it->x/50.f - 1.0f, (float) it->y/50.f - 1.0f);

		if (pointInDomain(pt)) {
			addPoint(pt);
		}
	}
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movss 0x13d0(%rax), %xmm0
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xfc1c(%rip), %xmm0     # 0x16460
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %esi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x7a00
movq 0x20(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x7a50
jmp 0x686f
leaq 0x60(%rsp), %rdi
callq 0x7b30
movq %rax, 0x48(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x7ba0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7b60
testb $0x1, %al
jne 0x68a5
jmp 0x6992
leaq 0x48(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7bd0
movq (%rsp), %rdi
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss 0xfc21(%rip), %xmm1     # 0x164e8
movss %xmm1, 0xc(%rsp)
divss %xmm1, %xmm0
movss 0xfbef(%rip), %xmm1     # 0x164c8
movss %xmm1, 0x10(%rsp)
subss %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
callq 0x7bd0
movss 0xc(%rsp), %xmm3
movss 0x10(%rsp), %xmm2
movss 0x14(%rsp), %xmm0
movsd 0x8(%rax), %xmm1
cvtsd2ss %xmm1, %xmm1
divss %xmm3, %xmm1
subss %xmm2, %xmm1
leaq 0x38(%rsp), %rdi
callq 0x6b60
jmp 0x691d
movq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3c30
testb $0x1, %al
jne 0x6932
jmp 0x697a
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x3f10
jmp 0x694e
jmp 0x697a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x69ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x7c20
jmp 0x69ae
jmp 0x697c
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x7be0
movq %rax, 0x28(%rsp)
jmp 0x687e
leaq 0x60(%rsp), %rdi
callq 0x7c20
leaq 0x78(%rsp), %rdi
callq 0x7c80
addq $0xa8, %rsp
retq
leaq 0x78(%rsp), %rdi
callq 0x7c80
movq 0x58(%rsp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: ddunbar[P]PDSample/./WeightedDiscretePDF.cpp
// Function: WeightedDiscretePDF<int>::insert(int, float)
void WeightedDiscretePDF<T>::insert(T item, float weight)
{
	WDPDF_Node<T> *p=0, *n=m_root;

	while (n) {
		if (n->leftIsRed() && n->rightIsRed())
			split(n);

		p = n;
		if (n->key==item) {
			throw std::domain_error("insert: argument(item) already in tree");
		} else {
			n = (item<n->key)?n->left:n->right;
		}
	}

	n = new WDPDF_Node<T>(item, weight, p);

	if (!p) {
		m_root = n;
	} else {
		if (item<p->key) {
			p->left = n;
		} else {
			p->right = n;
		}

		split(n);
	}

	propogateSumsUp(n);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movss %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x40(%rsp)
movq (%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x7174
movq 0x38(%rsp), %rdi
callq 0xf2c0
testb $0x1, %al
jne 0x70aa
jmp 0x70c9
movq 0x38(%rsp), %rdi
callq 0xf2e0
testb $0x1, %al
jne 0x70ba
jmp 0x70c9
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf300
movq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movl 0x20(%rax), %eax
cmpl 0x4c(%rsp), %eax
jne 0x7139
movl $0x10, %edi
callq 0x20a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq 0x11222(%rip), %rsi     # 0x1831f
callq 0x20e0
jmp 0x7104
movq 0x18(%rsp), %rdi
movq 0x18eb0(%rip), %rsi     # 0x1ffc0
movq 0x18eb9(%rip), %rdx     # 0x1ffd0
callq 0x22e0
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x2100
jmp 0x722e
movl 0x4c(%rsp), %eax
movq 0x38(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x7157
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x7165
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x708e
movl $0x30, %edi
callq 0x21a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl 0x4c(%rsp), %esi
movss 0x48(%rsp), %xmm0
movq 0x40(%rsp), %rdx
callq 0xf420
jmp 0x719f
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x71df
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x721a
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x30, %esi
callq 0x21b0
jmp 0x722e
movl 0x4c(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x71fd
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x720b
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf300
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf470
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x22f0
nopl (%rax,%rax)