LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/unf-test.cc
// Function: nfc_test(UNF::Normalizer&, 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>>>> const&)
bool nfc_test(UNF::Normalizer& norm, const std::vector<std::string>& ary) {
  return 
    NF_TEST(norm.nfc, ary[1], ary[0]) &&
    NF_TEST(norm.nfc, ary[1], ary[1]) &&
    NF_TEST(norm.nfc, ary[1], ary[2]) &&
    NF_TEST(norm.nfc, ary[3], ary[3]) &&
    NF_TEST(norm.nfc, ary[3], ary[4]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
movq 0x20(%rax), %r15
callq 0x2970
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x2503
movq (%r14), %rax
movq 0x20(%rax), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2970
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x2503
movq (%r14), %rax
movq 0x20(%rax), %r15
movq 0x40(%rax), %rsi
movq %rbx, %rdi
callq 0x2970
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x2503
movq (%r14), %rax
movq 0x60(%rax), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2970
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
je 0x250b
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq 0x60(%rax), %r14
movq 0x80(%rax), %rsi
movq %rbx, %rdi
callq 0x2970
movq %r14, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
sete %al
jmp 0x2505
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/unf-test.cc
// Function: nfkc_test(UNF::Normalizer&, 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>>>> const&)
bool nfkc_test(UNF::Normalizer& norm, const std::vector<std::string>& ary) {
  return 
    NF_TEST(norm.nfkc, ary[3], ary[0]) &&
    NF_TEST(norm.nfkc, ary[3], ary[1]) &&
    NF_TEST(norm.nfkc, ary[3], ary[2]) &&
    NF_TEST(norm.nfkc, ary[3], ary[3]) &&
    NF_TEST(norm.nfkc, ary[3], ary[4]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
movq 0x60(%rax), %r15
callq 0x297c
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x25c1
movq (%r14), %rax
movq 0x20(%rax), %rsi
movq 0x60(%rax), %r15
movq %rbx, %rdi
callq 0x297c
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x25c1
movq (%r14), %rax
movq 0x40(%rax), %rsi
movq 0x60(%rax), %r15
movq %rbx, %rdi
callq 0x297c
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x25c1
movq (%r14), %rax
movq 0x60(%rax), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x297c
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
je 0x25c9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq 0x60(%rax), %r14
movq 0x80(%rax), %rsi
movq %rbx, %rdi
callq 0x297c
movq %r14, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
sete %al
jmp 0x25c3
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/unf-test.cc
// Function: nf_test(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>>>> const&, UNF::Normalizer&, int)
bool nf_test(const std::vector<std::string>& ary, UNF::Normalizer& norm, int entry_id) {
  static const UNF::Normalizer::Form forms[] = {UNF::Normalizer::FORM_NFD, UNF::Normalizer::FORM_NFC,
						UNF::Normalizer::FORM_NFKD,UNF::Normalizer::FORM_NFKC};
  static const TEST_FN_T test_fn[] = {nfd_test, nfc_test, nfkd_test, nfkc_test};
  static const char* form_names[5] = {"NFD ", "NFC ", "NFKD", "NFKC"};

  for(int formid=0; formid < 4; formid++)
    if(test_fn[formid](norm, ary)==false) {
      std::cerr << "Failed(" << entry_id << "): " << form_names[formid] << std::endl;
      for(unsigned i=0; i < ary.size(); i++) 
	std::cerr << " " << ary[i] << "\t -> " << norm.normalize(ary[i].c_str(), forms[formid]) << std::endl;
      return false;
    }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0x65754(%rip), %r13     # 0x67d60
xorl %r15d, %r15d
movq %r15, %r12
cmpq $0x4, %r15
je 0x26fe
movq (%rsp), %rdi
movq %r14, %rsi
callq *(%r13)
leaq 0x1(%r12), %r15
addq $0x8, %r13
testb %al, %al
jne 0x260f
movq 0x659ad(%rip), %rdi     # 0x67fe8
leaq 0x1a02(%rip), %rsi      # 0x4044
callq 0x2110
movq %rax, %rdi
movl %ebp, %esi
callq 0x21a0
leaq 0x19f4(%rip), %rsi      # 0x404c
movq %rax, %rdi
callq 0x2110
leaq 0x65719(%rip), %rcx     # 0x67d80
movq -0x8(%rcx,%r15,8), %rsi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x2080
xorl %eax, %eax
movl %eax, %ebx
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x5, %rax
cmpq %rbx, %rax
jbe 0x26fe
movq 0x65951(%rip), %rdi     # 0x67fe8
leaq 0x19da(%rip), %rsi      # 0x4078
callq 0x2110
movq %rbx, %r13
shlq $0x5, %r13
movq (%r14), %rsi
addq %r13, %rsi
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
leaq 0x198e(%rip), %rsi      # 0x4050
callq 0x2110
movq %rax, %rbp
movq (%r14), %rax
movq (%rax,%r13), %rsi
leaq 0x1948(%rip), %rax      # 0x4020
movl -0x4(%rax,%r15,4), %edx
movq (%rsp), %rdi
callq 0x298a
movq %rbp, %rdi
movq %rax, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x2080
leal 0x1(%rbx), %eax
jmp 0x267e
cmpq $0x4, %r12
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::normalize(char const*, UNF::Normalizer::Form)
const char* normalize(const char* src, Form form) {
      switch(form) {
      case FORM_NFD:  return nfd(src);
      case FORM_NFC:  return nfc(src);
      case FORM_NFKD: return nfkd(src);
      case FORM_NFKC: return nfkc(src);
      default:        return src;
      }
    }

// Assembly:
cmpl $0x3, %edx
ja 0x29b5
movl %edx, %eax
leaq 0x166c(%rip), %rcx      # 0x4004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x295e
jmp 0x2966
jmp 0x297c
jmp 0x2970
movq %rsi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::decompose(char const*, UNF::Trie::NormalizationForm const&)
const char* decompose(const char* src, const Trie::NormalizationForm& nf) {
      const char* beg = next_invalid_char(src, nf);
      if(*beg=='\0')
	return src;
      
      buffer.assign(src, beg);
      do {
	const char* end = next_valid_starter(beg, nf);
	decompose_one(beg, end, nf, buffer);
	beg = next_invalid_char(end, nf);
	buffer.append(end, beg);
      } while(*beg!='\0');
      
      return buffer.c_str();      
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
callq 0x2b4e
cmpb $0x0, (%rax)
je 0x2b40
movq %rax, %r12
leaq 0x90(%r14), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2bd4
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2bea
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x2c3c
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2b4e
movq %rax, %r12
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2c70
cmpb $0x0, (%r12)
jne 0x2af2
movq (%r15), %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::next_invalid_char(char const*, UNF::Trie::NormalizationForm const&) const
const char* next_invalid_char(const char* src, const Trie::NormalizationForm& nf) const {
      int last_canonical_class = 0;
      const char* cur = Util::nearest_utf8_char_start_point(src);
      const char* starter = cur;
      
      for(; *cur != '\0'; cur = Util::nearest_utf8_char_start_point(cur+1)) {
	int canonical_class = ccc.get_class(cur);
	if(last_canonical_class > canonical_class && canonical_class != 0)
	  return starter;

	if(nf.quick_check(cur)==false)
	  return starter;

	if(canonical_class==0)
	  starter=cur;

	last_canonical_class = canonical_class;
      }
      return cur;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2c85
movq %rax, %r14
addq $0x78, %r15
xorl %r13d, %r13d
movq %rax, %r12
cmpb $0x0, (%r14)
je 0x2bc1
movq %r15, %rdi
movq %r14, %rsi
callq 0x2c9a
movl %eax, %ebp
cmpl %eax, %r13d
setg %al
testl %ebp, %ebp
setne %cl
testb %cl, %al
jne 0x2bbe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ca2
testb %al, %al
je 0x2bbe
testl %ebp, %ebp
cmoveq %r14, %r12
incq %r14
movq %r14, %rdi
callq 0x2c85
movq %rax, %r14
movl %ebp, %r13d
jmp 0x2b74
movq %r12, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::next_valid_starter(char const*, UNF::Trie::NormalizationForm const&) const
const char* next_valid_starter(const char* src, const Trie::NormalizationForm& nf) const {
      const char* cur = Util::nearest_utf8_char_start_point(src+1);
      while(ccc.get_class(cur)!=0 || nf.quick_check(cur)==false)
	cur = Util::nearest_utf8_char_start_point(cur+1);
      return cur;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
callq 0x2c85
movq %rax, %r15
addq $0x78, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2c9a
testl %eax, %eax
jne 0x2c23
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2ca2
testb %al, %al
jne 0x2c33
incq %r15
movq %r15, %rdi
callq 0x2c85
movq %rax, %r15
jmp 0x2c05
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::decompose_one(char const*, char const*, UNF::Trie::NormalizationForm const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void decompose_one(const char* beg, const char* end, const Trie::NormalizationForm& nf, std::string& buf) {
      unsigned last = buf.size();
      nf.decompose(Trie::RangeCharStream(beg,end), buf);
      char* bufbeg = const_cast<char*>(buf.data());
      canonical_combining_class_ordering(bufbeg+last, bufbeg+buf.size());
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdi, %r14
movl 0x8(%r8), %r15d
movq %rcx, %rdi
movq %r8, %rcx
callq 0x2cf6
movq (%rbx), %rdx
addq %rdx, %r15
addq 0x8(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2da4
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/trie/searcher.hh
// Function: UNF::Trie::Searcher::find_value(char const*, int) const
unsigned find_value(const char* key, int default_value) const {
	unsigned node_index=root;
	for(CharStream in(key);; in.read()) {
	  node_index = nodes[node_index].jump(in.peek());
	  if(nodes[node_index].check_char()==in.peek()) {
	    unsigned terminal_index = nodes[node_index].jump('\0'); 
	    if(nodes[terminal_index].check_char()=='\0') {
	      return nodes[terminal_index].value();
            }
	  } else
	    return default_value;
	}
      }

// Assembly:
movl 0x8(%rdi), %eax
movq (%rdi), %rcx
movl (%rcx,%rax,4), %edi
movzbl (%rsi), %r8d
andl $0xffffff, %edi         # imm = 0xFFFFFF
addl %r8d, %edi
movl (%rcx,%rdi,4), %edi
movl %edi, %eax
shrl $0x18, %eax
cmpl %r8d, %eax
jne 0x2cf2
movl %edi, %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl (%rcx,%rax,4), %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jb 0x2cf4
cmpb $0x1, %r8b
sbbq $-0x1, %rsi
jmp 0x2cbd
movl %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/trie/searcher.hh
// Function: UNF::Trie::NormalizationForm::decompose(UNF::Trie::RangeCharStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
void decompose(RangeCharStream in, std::string& buffer) const {
      loop_head:
	const char* beg = in.cur();

	for(unsigned node_index=root;;) {
	  node_index = nodes[node_index].jump(in.read());
	  if(nodes[node_index].check_char()==in.prev()) {
	    unsigned terminal_index = nodes[node_index].jump('\0');
	    if(nodes[terminal_index].check_char()=='\0') {
              word_append(buffer, value, nodes[terminal_index].value());
	      beg = in.cur();
	      break;
	    }
	  } else {
	    Util::eat_until_utf8_char_start_point(in);
	    buffer.append(beg, in.cur());
	    break;
	  }
	}  

	if(in.eos()==false)
	  goto loop_head;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rsp, %r15
movq %rsi, (%r15)
movq %rdx, 0x8(%r15)
movl $0xffffff, %ebp         # imm = 0xFFFFFF
movl 0x8(%r14), %esi
movq (%r14), %rcx
movq %r12, %rdi
cmpq %rdx, %rdi
je 0x2d39
leaq 0x1(%rdi), %r8
movq %r8, (%rsp)
movzbl (%rdi), %eax
movq %r8, %rdi
jmp 0x2d3b
xorl %eax, %eax
movl %esi, %esi
movl (%rcx,%rsi,4), %esi
andl %ebp, %esi
addl %eax, %esi
movl (%rcx,%rsi,4), %eax
movl %eax, %r8d
shrl $0x18, %r8d
movzbl -0x1(%rdi), %r9d
cmpl %r9d, %r8d
jne 0x2d71
andl %ebp, %eax
movl (%rcx,%rax,4), %eax
cmpl %ebp, %eax
ja 0x2d24
movq 0x10(%r14), %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x2dee
jmp 0x2d88
movq %r15, %rdi
callq 0x2e00
movq (%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2c70
movq (%rsp), %r12
movq 0x8(%rsp), %rdx
cmpq %rdx, %r12
jne 0x2d1a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/trie/searcher.hh
// Function: UNF::Trie::CanonicalCombiningClass::sort(char*, std::vector<unsigned char, std::allocator<unsigned char>>&) const
void sort(char* str, std::vector<unsigned char>& classes) const {
	CharStream in(str);
	unsigned sort_beg=0;
	unsigned sort_end=0;
	unsigned unicode_char_count=0;

      loop_head:
	unsigned beg = in.cur()-str;
	
	for(unsigned node_index=root;;){
	  node_index = nodes[node_index].jump(in.read());
	  
	  if(nodes[node_index].check_char()==in.prev()) {
	    unsigned terminal_index = nodes[node_index].jump('\0');
	    if(nodes[terminal_index].check_char()=='\0') {
	      if((unicode_char_count++)==0)
		sort_beg = beg;
	      sort_end = in.cur()-str;
	      
	      unsigned char klass = nodes[terminal_index].value();
	      for(unsigned i=beg; i < sort_end; i++) 
		classes[i] = klass;
 	      break;
	    }
	  } else {
	    if(unicode_char_count > 1)
	      bubble_sort(str, classes, sort_beg, sort_end);
	    unicode_char_count = 0;
	    break;
	  }
	} 
	Util::eat_until_utf8_char_start_point(in);

	if(in.eos()==false)
	  goto loop_head;

	if(unicode_char_count > 1)
	  bubble_sort(str, classes, sort_beg, sort_end);
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
xorl %r14d, %r14d
movl $0xffffff, %r13d        # imm = 0xFFFFFF
movq %rsi, %rax
xorl %r12d, %r12d
xorl %ebp, %ebp
movq %rsi, 0x10(%rsp)
subq %rsi, %rax
movl 0x8(%r15), %edx
movl %eax, %ecx
movq 0x8(%rsp), %r11
cmpb $0x0, (%r11)
je 0x2e7a
leaq 0x1(%r11), %rdi
movq %rdi, 0x8(%rsp)
movzbl (%r11), %r8d
movq %rdi, %r11
jmp 0x2e7d
xorl %r8d, %r8d
movq (%r15), %rdi
movl %edx, %edx
movl (%rdi,%rdx,4), %edx
andl %r13d, %edx
addl %r8d, %edx
movl (%rdi,%rdx,4), %r8d
movl %r8d, %r9d
shrl $0x18, %r9d
movzbl -0x1(%r11), %r10d
cmpl %r10d, %r9d
jne 0x2ee4
andl %r13d, %r8d
movl (%rdi,%r8,4), %edi
cmpl %r13d, %edi
ja 0x2ed6
subq %rsi, %r11
movl %r11d, %r12d
movl %r11d, %r10d
movq %rcx, %r8
cmpq %r10, %r8
jae 0x2ec9
movq (%rbx), %r9
movb %dil, (%r9,%r8)
incq %r8
jmp 0x2eb8
testl %r14d, %r14d
leal 0x1(%r14), %r8d
cmovel %eax, %ebp
movl %r8d, %r14d
cmpl $0x1000000, %edi        # imm = 0x1000000
jae 0x2e5d
jmp 0x2efd
cmpl $0x2, %r14d
jb 0x2efa
movq %r15, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0x30f0
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
callq 0x314c
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x2e54
cmpl $0x2, %r14d
jb 0x2f30
movq %r15, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0x30f0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/trie/searcher.hh
// Function: UNF::Trie::CanonicalCombiningClass::bubble_sort(char*, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int, unsigned int) const
void bubble_sort(char* str, std::vector<unsigned char>& canonical_classes, unsigned beg, unsigned end) const {
	for(unsigned limit=beg, next=end; limit != next;) {
	  limit = next;
	  for(unsigned i=beg+1; i < limit; i++)
	    if(canonical_classes[i-1] > canonical_classes[i]) {
	      std::swap(canonical_classes[i-1], canonical_classes[i]);
	      std::swap(str[i-1], str[i]);
	      next = i;
	    }
	}
      }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %r9d
movl %r8d, %eax
movl %ecx, %edi
cmpl %r8d, %r9d
je 0x3147
movq (%rdx), %r9
movl %edi, %ebx
leal 0x1(%rbx), %edi
cmpl %r8d, %edi
jae 0x313f
movl %ebx, %r10d
movb (%r9,%r10), %bpl
movl %edi, %r11d
movb (%r9,%r11), %r14b
movl %edi, %ebx
cmpb %r14b, %bpl
jbe 0x3106
movb %r14b, (%r9,%r10)
movb %bpl, (%r9,%r11)
movb (%rsi,%r10), %al
movb (%rsi,%r11), %r9b
movb %r9b, (%rsi,%r10)
movb %al, (%rsi,%r11)
movl %edi, %eax
jmp 0x3101
movl %r8d, %r9d
movl %eax, %r8d
jmp 0x30fa
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::compose(char const*, UNF::Trie::NormalizationForm const&, UNF::Trie::NormalizationForm const&)
const char* compose(const char* src, const Trie::NormalizationForm& nf, const Trie::NormalizationForm& nf_decomp) {
      const char* beg = next_invalid_char(src, nf);
      if(*beg=='\0')
	return src;
      
      buffer.assign(src, beg);
      while(*beg!='\0') {
	const char* end = next_valid_starter(beg, nf);
	buffer2.clear();
	decompose_one(beg, end, nf_decomp, buffer2);
	end = compose_one(buffer2.c_str(), end, buffer);
	beg = next_invalid_char(end, nf);
	buffer.append(end, beg);
      }

      return buffer.c_str();      
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
callq 0x2b4e
cmpb $0x0, (%rax)
je 0x3222
movq %rax, %rbp
leaq 0x90(%r15), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2bd4
leaq 0xb0(%r15), %r13
cmpb $0x0, (%rbp)
je 0x321e
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x2bea
andq $0x0, 0xb8(%r15)
movq %rax, %rbx
movq 0xb0(%r15), %rax
movb $0x0, (%rax)
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq (%rsp), %rcx
movq %r13, %r8
callq 0x2c3c
movq 0xb0(%r15), %rsi
movq %r15, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x3234
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2b4e
movq %rax, %rbp
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2c70
jmp 0x31a7
movq (%r12), %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::compose_one(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
const char* compose_one(const char* starter, const char* rest_starter, std::string& buf) {
      Trie::CharStreamForComposition in(starter, rest_starter, canonical_classes, buffer3);
      while(in.within_first())
	nf_c.compose(in, buf);
      return in.cur();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0xf0(%rdi), %rax
leaq 0xd0(%rdi), %rcx
movq %rsp, %r15
movq %rsi, (%r15)
movq %rdx, 0x8(%r15)
movq %rsi, 0x10(%r15)
movq %rdx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %rcx, 0x28(%r15)
addq $0x30, %r14
cmpb $0x0, (%rsi)
je 0x3289
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3298
movq 0x10(%rsp), %rsi
jmp 0x326f
movq 0x18(%rsp), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/trie/char_stream.hh
// Function: UNF::Trie::CharStreamForComposition::next_combining_char(unsigned char, char const*)
bool next_combining_char(unsigned char prev_class, const char* ppp) {
	while(Util::is_utf8_char_start_byte(peek()) == false)
	  read();
	
	unsigned char mid_class = get_prev_canonical_class();
	unsigned char cur_class = get_canonical_class();
	
	if(prev_class==0 && mid_class==0 && cur_class!=0)
	  return false;

	if(prev_class < cur_class && mid_class < cur_class) {
	  skipped.append(ppp, cur());
	  return true;
	} else {
	  if(cur_class != 0) {
	    read();
	    return next_combining_char(prev_class,ppp);
	  }
	  return false;
	}
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x10(%r14), %rax
cmpb $0x0, (%rax)
jne 0x34f6
movq 0x18(%r14), %rax
movb (%rax), %al
andb $-0x40, %al
negb %al
jo 0x3537
movq %r14, %rdi
callq 0x35ec
movl %eax, %r15d
movq %r14, %rdi
callq 0x346e
movl %r15d, %ecx
orb %bpl, %cl
sete %cl
testb %al, %al
setne %dl
testb %dl, %cl
jne 0x3541
cmpb %bpl, %al
setbe %cl
cmpb %al, %r15b
setae %dl
orb %cl, %dl
je 0x3545
testb %al, %al
je 0x3541
movq %r14, %rdi
callq 0x3494
jmp 0x34e9
xorl %eax, %eax
jmp 0x3560
movq 0x10(%r14), %rdx
movq 0x28(%r14), %rdi
cmpb $0x0, (%rdx)
jne 0x3556
movq 0x18(%r14), %rdx
movq %rbx, %rsi
callq 0x2c70
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/trie/char_stream.hh
// Function: UNF::Trie::CharStreamForComposition::append_read_char_to_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*) const
void append_read_char_to_str(std::string& s, const char* beg) const {
	if(eos1()==false) {
	  s.append(beg, cur());
	} else {
	  s.append(beg,  cur1);
	  s.append(beg2, cur());
	}
      }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movb (%rax), %bpl
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2c70
testb %bpl, %bpl
je 0x35cf
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
cmpb $0x0, (%rdx)
jne 0x35e0
movq 0x18(%r14), %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2c70
// File: /workspace/github_cpp_makefile_star2_O2/plasma-umass[P]simplesocket/./simplesocket.h
// Function: simplesocket& simplesocket::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
simplesocket& operator<<(TYPE t) {
    stringstream output;
    output << t;
    auto buf_str = output.str();
    auto buf = buf_str.c_str();
    write (buf, strlen(buf));
    return *this;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2140
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x21c0
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x22a0
movq (%rsp), %r14
movq %r14, %rdi
callq 0x20c0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2baa
movq %rsp, %rdi
callq 0x20d0
leaq 0x20(%rsp), %rdi
callq 0x2160
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20d0
jmp 0x2824
jmp 0x2821
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/plasma-umass[P]simplesocket/./simplesocket.h
// Function: simplesocket::operator>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
simplesocket& operator>>(string& t) {
    char buf[MAXBUF+1];
    memset (buf, 0, MAXBUF+1);
    read (buf, MAXBUF);
    t = buf;
    return *this;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10010, %rsp          # imm = 0x10010
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movl $0x10001, %edx          # imm = 0x10001
movq %r15, %rdi
xorl %esi, %esi
callq 0x2100
movq %r14, %rdi
movq %r15, %rsi
movl $0x10000, %edx          # imm = 0x10000
callq 0x2b0c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2320
movq %r14, %rax
addq $0x10010, %rsp          # imm = 0x10010
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/plasma-umass[P]simplesocket/simplesocket.cpp
// Function: simplesocket::resolve(addrinfo*)
void simplesocket::resolve (struct addrinfo * hint) {
  int err;
  int on = 1;
  
  char portStr[255];
  snprintf (portStr, sizeof(portStr), "%d", _port);
  
  if ((err = getaddrinfo (hostname(), portStr, hint, &_addresses)) != 0) {
    if (_debug)
      cerr << "Error in name resolution for " << name()
	   << ", with error " << gai_strerror(err) << "\n";
    _nameResolved = false;
    return;
  }
  
  _nameResolved = true;
  _socketfd = socket (AF_INET, SOCK_STREAM, 0);
  if (_socketfd < 0) {
    if (_debug)
      cerr << "SOCKET CREATION FAILURE... aborting.\n";
    return;
  }
  
  setsockopt (_socketfd, 
	      SOL_SOCKET,
	      SO_REUSEADDR, 
	      (void *) &on,
	      sizeof (on));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, 0xc(%rsp)
movl 0x18(%rdi), %ecx
leaq 0x14ce(%rip), %rdx      # 0x40a7
leaq 0x10(%rsp), %r15
movl $0xff, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x22d0
movq 0x20(%rbx), %rdi
leaq 0x8(%rbx), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0x2240
testl %eax, %eax
je 0x2c67
cmpb $0x1, 0x1dc(%rbx)
jne 0x2c61
movl %eax, %ebp
movq 0x33da(%rip), %rdi      # 0x5ff0
leaq 0x148d(%rip), %rsi      # 0x40aa
callq 0x21e0
movq 0x40(%rbx), %rsi
movq %rax, %rdi
callq 0x21e0
leaq 0x1493(%rip), %rsi      # 0x40c8
movq %rax, %rdi
callq 0x21e0
movq %rax, %r14
movl %ebp, %edi
callq 0x2270
movq %r14, %rdi
movq %rax, %rsi
callq 0x21e0
leaq 0x1607(%rip), %rsi      # 0x4260
movq %rax, %rdi
callq 0x21e0
movb $0x0, 0x14(%rbx)
jmp 0x2cb3
movb $0x1, 0x14(%rbx)
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2060
movl %eax, 0x10(%rbx)
testl %eax, %eax
js 0x2c97
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
leaq 0xc(%rsp), %rcx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x2300
jmp 0x2cb3
cmpb $0x1, 0x1dc(%rbx)
jne 0x2cb3
movq 0x3349(%rip), %rdi      # 0x5ff0
leaq 0x1428(%rip), %rsi      # 0x40d6
callq 0x21e0
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/plasma-umass[P]simplesocket/simplesocket.cpp
// Function: simplesocket::descriptorReady(int, int)
int simplesocket::descriptorReady (int fd, int timeout) {
  assert (timeout > 0);
  int ret = 0;
  fd_set rset;
  FD_ZERO(&rset);
  FD_SET(fd, &rset);
  struct timeval tv;
  memset(&tv, 0, sizeof(struct timeval));
  tv.tv_sec = timeout;
  tv.tv_usec = 0;
  do {
    ret = select(fd + 1, &rset, NULL, NULL, &tv);
  } while (ret < 0 && errno == EINTR);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
testl %edx, %edx
jle 0x2d64
movl %edx, %edi
movl %esi, %ebx
xorl %eax, %eax
cmpq $0x10, %rax
je 0x2d00
andq $0x0, 0x18(%rsp,%rax,8)
incq %rax
jmp 0x2cef
pushq $0x40
popq %rcx
movl %ebx, %eax
cltd
idivl %ecx
movslq %eax, %rdx
shll $0x6, %eax
movl %ebx, %ecx
subl %eax, %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
orq %rax, 0x18(%rsp,%rdx,8)
movl %edi, %eax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
incl %ebx
leaq 0x18(%rsp), %r15
movl %ebx, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x21d0
movl %eax, %ebp
testl %eax, %eax
jns 0x2d54
callq 0x2030
cmpl $0x4, (%rax)
je 0x2d33
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1391(%rip), %rdi      # 0x40fc
leaq 0x1396(%rip), %rsi      # 0x4108
leaq 0x13a0(%rip), %rcx      # 0x4119
pushq $0x2b
popq %rdx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O2/plasma-umass[P]simplesocket/simplesocket.cpp
// Function: simplesocket::recvNBytes(void*, int, bool)
ssize_t simplesocket::recvNBytes(void* data, int size, bool lessOk){
  if (size<=0) return 0;
  int ret, nRecv = 0;
  int toRecv = size;
  do{
    if (_timeout > 0){
      ret = descriptorReady (_socketfd, _timeout);
      if (ret < 0){
	assert(errno > 0 && errno!=EINTR);
	close();
	return -errno;
      } else if (ret == 0) return (ssize_t)TIMEOUT_ERR;
    }
    if (_debug) cerr << "Descriptor ready, reading .. " << endl;
    ret = recv(_socketfd, data, toRecv, 0);
    if (_debug) cerr << "Recv returned error of .. " << ret << endl;
    if (ret<0 && errno == EINTR) continue;
    else if (ret<0) {
      assert(errno > 0);
      close();
      return -errno;
    } else if (ret == 0)  {
      _seenEof = true; 
      close();
      /* Close your side, abort connection */
      break; /* Other side send a fin, tell caller */
      /* Break with whatever data we could receive */
    } else {
      data = (void*) ((unsigned long) data + ret);
      toRecv -= ret;
      nRecv += ret;
    }
  } while(toRecv > 0 && !lessOk);
  return nRecv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r13d, %r13d
testl %edx, %edx
jle 0x2e62
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movl 0x1d8(%rbx), %edx
testl %edx, %edx
jle 0x2dc3
movl 0x10(%rbx), %esi
callq 0x2cd8
testl %eax, %eax
js 0x2e66
je 0x2e92
cmpb $0x1, 0x1dc(%rbx)
jne 0x2de7
movq 0x321d(%rip), %rdi      # 0x5ff0
leaq 0x13b9(%rip), %rsi      # 0x4193
callq 0x21e0
movq %rax, %rdi
callq 0x20e0
movl 0x10(%rbx), %edi
movl %r15d, %edx
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x2090
movq %rax, %r14
cmpb $0x1, 0x1dc(%rbx)
jne 0x2e29
movq 0x31e6(%rip), %rdi      # 0x5ff0
leaq 0x13a0(%rip), %rsi      # 0x41b1
callq 0x21e0
movq %rax, %rdi
movl %r14d, %esi
callq 0x22e0
movq %rax, %rdi
callq 0x20e0
testl %r14d, %r14d
js 0x2e43
je 0x2e97
movl %r14d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r12
subl %r14d, %r15d
addl %r14d, %r13d
jmp 0x2e52
callq 0x2030
movq %rax, %r14
movl (%rax), %eax
cmpl $0x4, %eax
jne 0x2ea8
testl %r15d, %r15d
jle 0x2ea3
testb %bpl, %bpl
je 0x2da3
jmp 0x2ea3
xorl %eax, %eax
jmp 0x2eba
callq 0x2030
movq %rax, %r14
movl (%rax), %eax
testl %eax, %eax
jle 0x2e79
cmpl $0x4, %eax
jne 0x2eac
leaq 0x12c5(%rip), %rdi      # 0x4145
leaq 0x1281(%rip), %rsi      # 0x4108
leaq 0x12d1(%rip), %rcx      # 0x415f
pushq $0x42
jmp 0x2ee0
pushq $-0x2
popq %rax
jmp 0x2eba
movb $0x1, 0x15(%rbx)
movq %rbx, %rdi
callq 0x2cc2
movl %r13d, %eax
jmp 0x2eba
testl %eax, %eax
jle 0x2ec9
movq %rbx, %rdi
callq 0x2cc2
movslq (%r14), %rax
negq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12fc(%rip), %rdi      # 0x41cc
leaq 0x1231(%rip), %rsi      # 0x4108
leaq 0x1281(%rip), %rcx      # 0x415f
pushq $0x4c
popq %rdx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O2/plasma-umass[P]simplesocket/simplesocket.cpp
// Function: simplesocket::sendNBytes(unsigned char*, int, bool)
ssize_t simplesocket::sendNBytes (unsigned char* data, int size, bool lessOk) {
  int ret, nSent = 0;
  int toSend = size;
  assert (toSend>0);
  do {
    ret = ::send (_socketfd, data, toSend, MSG_NOSIGNAL);
    if (_debug) cerr << "sent " << ret << " bytes of " << size << endl;
    if ((ret < 0) && (errno == EINTR))
      continue; 
    else if (ret < 0){
      if (_debug) {
	perror ("Simplesocket error: ");
      }
      assert (errno > 0);
      close();
      return -errno;
    } else if (ret == 0) {
      close();
      return -1; /* Send shouldn't return 0 */
    } else {
      data += ret;
      toSend -= ret;
      nSent += ret;
    }
  } while (toSend > 0 && !lessOk);
  return nSent;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x2ff1
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
movl %edx, 0x4(%rsp)
movl %edx, %r14d
movl 0x10(%rbx), %edi
movl %r14d, %edx
movq %r15, %rsi
movl $0x4000, %ecx           # imm = 0x4000
callq 0x20f0
movq %rax, %r13
cmpb $0x1, 0x1dc(%rbx)
jne 0x2f6b
movq 0x30bf(%rip), %rdi      # 0x5ff0
leaq 0x12e4(%rip), %rsi      # 0x421c
callq 0x21e0
movq %rax, %rdi
movl %r13d, %esi
callq 0x22e0
movq %rax, %rdi
leaq 0x12d0(%rip), %rsi      # 0x4222
callq 0x21e0
movq %rax, %rdi
movl 0x4(%rsp), %esi
callq 0x22e0
movq %rax, %rdi
callq 0x20e0
testl %r13d, %r13d
js 0x2f85
je 0x2fa7
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r15
subl %r13d, %r14d
addl %r13d, %r12d
jmp 0x2f94
callq 0x2030
movq %rax, %r13
movl (%rax), %eax
cmpl $0x4, %eax
jne 0x2fb4
testl %r14d, %r14d
jle 0x2fa2
testb %bpl, %bpl
je 0x2f0b
movl %r12d, %eax
jmp 0x2fd0
movq %rbx, %rdi
callq 0x2cc2
pushq $-0x1
popq %rax
jmp 0x2fd0
cmpb $0x1, 0x1dc(%rbx)
je 0x2fdf
testl %eax, %eax
jle 0x300e
movq %rbx, %rdi
callq 0x2cc2
movslq (%r13), %rax
negq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1247(%rip), %rdi      # 0x422d
callq 0x21a0
movl (%r13), %eax
jmp 0x2fbd
leaq 0x11de(%rip), %rdi      # 0x41d6
leaq 0x1109(%rip), %rsi      # 0x4108
leaq 0x11d9(%rip), %rcx      # 0x41df
pushq $0x61
popq %rdx
callq 0x2130
leaq 0x11b7(%rip), %rdi      # 0x41cc
leaq 0x10ec(%rip), %rsi      # 0x4108
leaq 0x11bc(%rip), %rcx      # 0x41df
pushq $0x6b
jmp 0x3008
nop
// File: /workspace/github_cpp_makefile_star2_O2/plasma-umass[P]simplesocket/simplesocket.cpp
// Function: simplesocket::serve()
void simplesocket::serve (void) 
{
  struct addrinfo hint;
  memset ((void *) &hint, 0, sizeof(hint));
  hint.ai_flags = AI_PASSIVE;
  resolve (&hint);

  ((struct sockaddr_in*)(_addresses->ai_addr))->sin_addr.s_addr = htonl(INADDR_ANY);
  int r = bind (_socketfd,
		_addresses->ai_addr,
		_addresses->ai_addrlen);
  if (r < 0) {
    perror ("Bind failure.");
  }
  if (_debug) cerr << "waiting for a connection - " << _name << endl;
  r = listen (_socketfd, 255);
  if (r < 0) {
    if (_debug) cerr << "LISTEN FAILURE.\n";
  }
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movl $0x1, (%rsi)
callq 0x2bb4
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rsi
andl $0x0, 0x4(%rsi)
movl 0x10(%rbx), %edi
movl 0x10(%rax), %edx
callq 0x2040
testl %eax, %eax
js 0x3290
cmpb $0x1, 0x1dc(%rbx)
jne 0x325d
movq 0x2db3(%rip), %rdi      # 0x5ff0
leaq 0x106b(%rip), %rsi      # 0x42af
callq 0x21e0
leaq 0x40(%rbx), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
movl 0x10(%rbx), %edi
movl $0xff, %esi
callq 0x2210
testl %eax, %eax
jns 0x328a
cmpb $0x1, 0x1dc(%rbx)
jne 0x328a
movq 0x2d72(%rip), %rdi      # 0x5ff0
leaq 0x1046(%rip), %rsi      # 0x42cb
callq 0x21e0
addq $0x30, %rsp
popq %rbx
retq
leaq 0x100a(%rip), %rdi      # 0x42a1
callq 0x21a0
jmp 0x322d
// File: /workspace/github_cpp_makefile_star2_O2/plasma-umass[P]simplesocket/simplesocket.cpp
// Function: simplesocket::accept()
simplesocket * simplesocket::accept() {
  socklen_t len = sizeof(_addresses);
  int newfd = ::accept (_socketfd, _addresses->ai_addr, &len);
  if (newfd < 0) {
    if (_debug) cerr << "ACCEPT FAILURE.\n";
    return NULL;
  }
  simplesocket * newSock = new simplesocket (_hostname.c_str(), _port, -1, _debug);
  newSock->_socketfd = newfd;
  newSock->_nameResolved = true;
  return newSock;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0xc(%rsp), %rdx
movl $0x8, (%rdx)
movl 0x10(%rdi), %edi
movq 0x8(%r14), %rax
movq 0x18(%rax), %rsi
callq 0x2080
testl %eax, %eax
js 0x32fb
movl %eax, %ebp
movl $0x1e0, %edi            # imm = 0x1E0
callq 0x21f0
movq %rax, %rbx
movq 0x20(%r14), %rsi
movl 0x18(%r14), %edx
movzbl 0x1dc(%r14), %r8d
pushq $-0x1
popq %rcx
movq %rax, %rdi
callq 0x2886
movl %ebp, 0x10(%rbx)
movb $0x1, 0x14(%rbx)
jmp 0x331a
cmpb $0x1, 0x1dc(%r14)
jne 0x3318
movq 0x2ce4(%rip), %rdi      # 0x5ff0
leaq 0xfc9(%rip), %rsi       # 0x42dc
callq 0x21e0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x1e0, %esi            # imm = 0x1E0
movq %rbx, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/back-end_main.cpp
// Function: main
int main(int argc, char const* argv[])
{
    BackEndInfo info = {};
    info.nametable_dump_required      = (strcmp(argv[nametable_dump_flag_offset],      "1") == 0);
    info.asm_listing_required         = (strcmp(argv[asm_listing_flag_offset],         "1") == 0);
    info.speed_optimization_required  = (strcmp(argv[speed_optimization_flag_offset],  "1") == 0);
    info.memory_optimization_required = (strcmp(argv[memory_optimization_flag_offset], "1") == 0);

    if (argc - 1 > memory_optimization_flag_offset)
    {
        info.output_file = argv[memory_optimization_flag_offset + 1];
    }

    Tree* tree = GetTreeFromFile(tree_tmp_file);

    Compile(tree, &info);

    DestructTree(tree);
    DeleteTree(tree);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
andq $0x0, -0x18(%rbp)
movq 0x8(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x231c
cmpb $0x0, 0x1(%rax)
sete %al
jmp 0x231e
xorl %eax, %eax
movb %al, -0x10(%rbp)
movq 0x10(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x2333
cmpb $0x0, 0x1(%rax)
sete %al
jmp 0x2335
xorl %eax, %eax
movb %al, -0xf(%rbp)
movq 0x18(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x234a
cmpb $0x0, 0x1(%rax)
sete %al
jmp 0x234c
xorl %eax, %eax
movb %al, -0xe(%rbp)
movq 0x20(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x2361
cmpb $0x0, 0x1(%rax)
sete %al
jmp 0x2363
xorl %eax, %eax
movb %al, -0xd(%rbp)
cmpl $0x6, %edi
jl 0x2373
movq 0x28(%rsi), %rax
movq %rax, -0x18(%rbp)
movq 0xbd96(%rip), %rdi      # 0xe110
callq 0x71ca
movq %rax, %rbx
leaq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x23a8
movq %rbx, %rdi
callq 0x5fbe
movq %rbx, %rdi
callq 0x601b
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: Compile(Tree*, BackEndInfo*)
void Compile(Tree* tree, BackEndInfo* info)
{
    assert(tree);

    NameTable* table = MakeTableOfNames(tree);

    if (info->nametable_dump_required)
    {
        NameTableDump(table);
    }

    FILE* asm_file = nullptr;

    if (info->asm_listing_required)
    {
        asm_file = fopen(ASM_FILE_NAME, "w");
        assert(asm_file);
    }

    WriteAsmCode(tree, table, asm_file, info);

    if (info->asm_listing_required)
    {
        fclose(asm_file);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x244b
movq %rsi, %rbx
movq %rdi, %r14
callq 0x246a
movq %rax, %r15
cmpb $0x1, 0x8(%rbx)
jne 0x23d8
movq %r15, %rdi
callq 0x24d6
cmpb $0x1, 0x9(%rbx)
jne 0x2418
movq 0xbd33(%rip), %rdi      # 0xe118
leaq 0x650e(%rip), %rsi      # 0x88fa
callq 0x2130
movq %rax, %r12
testq %rax, %rax
jne 0x241b
leaq 0x64fc(%rip), %rdi      # 0x88fc
leaq 0x64b4(%rip), %rsi      # 0x88bb
leaq 0x64c8(%rip), %rcx      # 0x88d6
movl $0x92, %edx
callq 0x20b0
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x25ff
cmpb $0x1, 0x9(%rbx)
jne 0x2442
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6808(%rip), %rdi      # 0x8c5a
leaq 0x6462(%rip), %rsi      # 0x88bb
leaq 0x6476(%rip), %rcx      # 0x88d6
movl $0x84, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: MakeTableOfNames(Tree*)
NameTable* MakeTableOfNames(Tree* tree)
{
    assert(tree);

    size_t num_func = GetNumFunc(tree);

    NameTable* table = NewNameTable();
    table->functions = (Function*)calloc(num_func, sizeof(Function));
    table->num_func  = num_func;

    FillNameTable(table, tree);

    return table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x24b7
movq %rdi, %rbx
callq 0x3613
movq %rax, %r14
callq 0x3650
movq %rax, %r15
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x20c0
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3685
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x679c(%rip), %rdi      # 0x8c5a
leaq 0x63f6(%rip), %rsi      # 0x88bb
leaq 0x66c5(%rip), %rcx      # 0x8b91
movl $0x2ce, %edx            # imm = 0x2CE
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: NameTableDump(NameTable*)
void NameTableDump(NameTable* table)
{
    assert(table);

    for (size_t i = 0; i < table->num_func; ++i)
    {
        printf("\n%s :\n", table->functions[i].name);
        printf("\tparams(%lu) : ", table->functions[i].num_args);

        for (size_t j = 0; j < table->functions[i].num_args; ++j)
        {
            printf("%s[%d], ", table->functions[i].vars[j], GetVarOfs(table->functions + i, table->functions[i].vars[j]));
        }
        printf("\n\tvars(%lu) : ", table->functions[i].num_vars);

        for (size_t j = table->functions[i].num_args; j < table->functions[i].num_args + 
                                                          table->functions[i].num_vars; ++j)
        {
            printf("%s[%d], ", table->functions[i].vars[j], GetVarOfs(table->functions + i, table->functions[i].vars[j]));
        }
    }

    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x25e0
movq %rdi, %rbx
leaq 0x6814(%rip), %r12      # 0x8d0b
xorl %ecx, %ecx
cmpq 0x8(%rbx), %rcx
jae 0x25ca
movq (%rbx), %rax
movq %rcx, -0x30(%rbp)
imulq $0x30, %rcx, %r13
movq (%rax,%r13), %rsi
leaq 0x67db(%rip), %rdi      # 0x8cf4
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rax
movq 0x18(%rax,%r13), %rsi
leaq 0x67cc(%rip), %rdi      # 0x8cfb
xorl %eax, %eax
callq 0x2040
xorl %r15d, %r15d
movq (%rbx), %rax
leaq (%rax,%r13), %rdi
cmpq 0x18(%rax,%r13), %r15
jae 0x256b
movq 0x8(%rdi), %rax
movq (%rax,%r15,8), %r14
movq %r14, %rsi
callq 0x31ee
movq %r12, %rdi
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x2040
incq %r15
jmp 0x2539
movq 0x20(%rdi), %rsi
leaq 0x679e(%rip), %rdi      # 0x8d14
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rdi
movq 0x18(%rdi,%r13), %r15
movq 0x20(%rdi,%r13), %rax
addq 0x18(%rdi,%r13), %rax
cmpq %rax, %r15
jae 0x25be
addq %r13, %rdi
movq 0x8(%rdi), %rax
movq (%rax,%r15,8), %r14
movq %r14, %rsi
callq 0x31ee
movq %r12, %rdi
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x2040
incq %r15
movq (%rbx), %rdi
jmp 0x2585
movq -0x30(%rbp), %rcx
incq %rcx
jmp 0x24f9
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2160
leaq 0x6369(%rip), %rdi      # 0x8950
leaq 0x62cd(%rip), %rsi      # 0x88bb
leaq 0x66df(%rip), %rcx      # 0x8cd4
movl $0x36d, %edx            # imm = 0x36D
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmCode(Tree*, NameTable*, _IO_FILE*, BackEndInfo*)
void WriteAsmCode(Tree* tree, NameTable* table, FILE* file, BackEndInfo* info)
{
    assert(tree);
    assert(table);
    assert(info);

    Node* node = tree->root;

    Compiler compiler = {};

    InitCompiler(&compiler, table, file, info);
    WriteAsm_start(&compiler);
    WriteAsmStdFunctions(&compiler);

    for (size_t i = 0; i < table->num_func; ++i)
    {
        WriteAsmFunc(node->right, &compiler);

        compiler.function++;
        node = node->left;
    }

    WriteAsmStdData(&compiler);
    SetAllCalls(&compiler);
    SetElfHeaders(&compiler.writer);

    WriteByteCodeToFile(&compiler, info);

    DestructNameTable(table);
    DeleteNameTable(table);
    Destruct(&compiler.writer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
testq %rdi, %rdi
je 0x26f9
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2718
movq %rdx, -0x30(%rbp)
testq %rcx, %rcx
je 0x2737
movq %rcx, %r14
movq (%rdi), %r13
leaq -0x148(%rbp), %r15
xorl %r12d, %r12d
movl $0x118, %edx            # imm = 0x118
movq %r15, %rdi
xorl %esi, %esi
callq 0x20a0
movq %r15, %rdi
movq %rbx, %rsi
movq -0x30(%rbp), %rdx
movq %r14, -0x30(%rbp)
movq %r14, %rcx
callq 0x2756
movq %r15, %rdi
callq 0x280e
movq %r15, %rdi
callq 0x2875
cmpq 0x8(%rbx), %r12
jae 0x269d
movq 0x20(%r13), %rdi
movq %r15, %rsi
callq 0x2929
addq $0x30, -0x140(%rbp)
movq 0x18(%r13), %r13
incq %r12
jmp 0x267a
leaq -0x148(%rbp), %r15
movq %r15, %rdi
callq 0x29b5
movq %r15, %rdi
callq 0x4ac4
leaq -0x120(%rbp), %r12
movq %r12, %rdi
callq 0x4c83
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x2a73
movq %rbx, %rdi
callq 0x2ba0
movq %rbx, %rdi
callq 0x2140
movq %r12, %rdi
callq 0x4e97
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x655a(%rip), %rdi      # 0x8c5a
leaq 0x61b4(%rip), %rsi      # 0x88bb
leaq 0x624d(%rip), %rcx      # 0x895b
movl $0xb2, %edx
callq 0x20b0
leaq 0x6231(%rip), %rdi      # 0x8950
leaq 0x6195(%rip), %rsi      # 0x88bb
leaq 0x622e(%rip), %rcx      # 0x895b
movl $0xb3, %edx
callq 0x20b0
leaq 0x6218(%rip), %rdi      # 0x8956
leaq 0x6176(%rip), %rsi      # 0x88bb
leaq 0x620f(%rip), %rcx      # 0x895b
movl $0xb4, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: InitCompiler(Compiler*, NameTable*, _IO_FILE*, BackEndInfo*)
void InitCompiler(Compiler* compiler, NameTable* table, FILE* file, BackEndInfo* info)
{
    assert(compiler);
    assert(table);
    assert(info);

    compiler->table    = table;
    compiler->function = table->functions;
    compiler->file     = file;
    compiler->label    = 0;

    compiler->asm_listing_required         = info->asm_listing_required;
    compiler->speed_optimization_required  = info->speed_optimization_required;
    compiler->memory_optimization_required = info->memory_optimization_required;

    Construct(&compiler->writer);
    InitElf64(&compiler->writer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x27b1
testq %rsi, %rsi
je 0x27d0
testq %rcx, %rcx
je 0x27ef
movq %rdi, %rbx
movq %rsi, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb 0x9(%rcx), %al
movb %al, 0x20(%rdi)
movb 0xa(%rcx), %al
movb %al, 0x21(%rdi)
movb 0xb(%rcx), %al
movb %al, 0x22(%rdi)
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x4c9c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4b20
leaq 0x614d(%rip), %rdi      # 0x8905
leaq 0x60fc(%rip), %rsi      # 0x88bb
leaq 0x6148(%rip), %rcx      # 0x890e
movl $0x9f, %edx
callq 0x20b0
leaq 0x6179(%rip), %rdi      # 0x8950
leaq 0x60dd(%rip), %rsi      # 0x88bb
leaq 0x6129(%rip), %rcx      # 0x890e
movl $0xa0, %edx
callq 0x20b0
leaq 0x6160(%rip), %rdi      # 0x8956
leaq 0x60be(%rip), %rsi      # 0x88bb
leaq 0x610a(%rip), %rcx      # 0x890e
movl $0xa1, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsm_start(Compiler*)
void WriteAsm_start(Compiler* compiler)
{
    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "section .text\n"
                                "global _start\n\n"
                                "_start:      \n\t");
    }

    WriteCall     (compiler, FindFunc("main", compiler->table));
    WriteMovR64Num(compiler, RAX, 0x3c);
    WriteMovR64Num(compiler, RDI, 0x00);
    WriteSyscall  (compiler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0x2833
movq 0x10(%rbx), %rcx
leaq 0x6171(%rip), %rdi      # 0x8999
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x21f0
movq (%rbx), %rsi
leaq 0x6189(%rip), %rdi      # 0x89c6
callq 0x2c2e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4811
pushq $0x3c
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3c46
pushq $0x7
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3c46
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4a57