LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
decq %rbx
movb 0x1(%rbx), %al
incq %rbx
andb $-0x40, %al
negb %al
jo 0x2e32
cmpb $0x0, (%rbx)
je 0x2eb7
addq $0x78, %r15
xorl %r13d, %r13d
movq %rbx, %r12
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2f92
movl %eax, %ebp
cmpl %eax, %r13d
setg %al
testl %ebp, %ebp
setne %cl
testb %cl, %al
jne 0x2e88
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2f92
cmpl $-0x1, %eax
je 0x2ea9
xorl %r14d, %r14d
movq %rbx, 0x8(%rsp)
testb %r14b, %r14b
je 0x2ebc
movb 0x1(%r12), %al
incq %r12
andb $-0x40, %al
negb %al
jo 0x2e92
cmpb $0x0, (%r12)
jne 0x2e4d
jmp 0x2ec1
testl %ebp, %ebp
cmoveq %r12, %rbx
movb $0x1, %r14b
movl %ebp, %r13d
jmp 0x2e8d
movq %rbx, %r12
jmp 0x2ec1
movq 0x8(%rsp), %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rsi, %rbx
movq %rdi, %r15
movb 0x1(%rbx), %al
incq %rbx
andb $-0x40, %al
negb %al
jo 0x2ee2
addq $0x78, %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2f92
testl %eax, %eax
jne 0x2f18
movq %r14, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2f92
cmpl $-0x1, %eax
je 0x2f26
movb 0x1(%rbx), %al
incq %rbx
andb $-0x40, %al
negb %al
jo 0x2f18
jmp 0x2ef2
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdi, %r14
movl 0x8(%r8), %r12d
movq %rcx, %rdi
movq %r8, %rcx
callq 0x3008
movq (%rbx), %r15
addq %r12, %r15
movq 0x8(%rbx), %rsi
leaq 0xf0(%r14), %rbx
subq %r12, %rsi
incq %rsi
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
movq %rbx, %rdi
callq 0x31f8
addq $0x78, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x30e8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %edx, %eax
movl 0x8(%rdi), %r8d
movq (%rdi), %rcx
movzbl (%rsi), %edi
movl $0xffffff, %edx         # imm = 0xFFFFFF
movl (%rcx,%r8,4), %r8d
andl %edx, %r8d
addl %edi, %r8d
movl (%rcx,%r8,4), %r10d
movl %r10d, %r9d
shrl $0x18, %r9d
cmpl %edi, %r9d
jne 0x3002
movl %r9d, %r11d
andl %edx, %r10d
movl (%rcx,%r10,4), %r10d
movl %r10d, %r9d
andl %edx, %r9d
cmpl $0x1000000, %r10d       # imm = 0x1000000
cmovael %r11d, %r9d
jb 0x3003
cmpb $0x1, %dil
sbbq $-0x1, %rsi
movl %r8d, %r8d
movzbl (%rsi), %edi
movl (%rcx,%r8,4), %r8d
andl %edx, %r8d
addl %edi, %r8d
movl (%rcx,%r8,4), %r10d
movl %r10d, %r11d
shrl $0x18, %r11d
cmpl %edi, %r11d
je 0x2fbd
retq
movl %r9d, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x8(%r12), %r13d
movq %r15, %rcx
cmpq %r14, %r15
je 0x3035
movzbl (%r15), %edx
incq %r15
jmp 0x3037
xorl %edx, %edx
movq (%r12), %rax
movl %r13d, %esi
movl (%rax,%rsi,4), %r13d
movl $0xffffff, %esi         # imm = 0xFFFFFF
andl %esi, %r13d
addl %edx, %r13d
movl (%rax,%r13,4), %edx
movl %edx, %esi
shrl $0x18, %esi
movzbl -0x1(%r15), %edi
cmpl %edi, %esi
jne 0x3098
andl $0xffffff, %edx         # imm = 0xFFFFFF
movl (%rax,%rdx,4), %ebp
cmpq $0xffffff, %rbp         # imm = 0xFFFFFF
ja 0x308e
movl %ebp, %esi
andl $0x3ffff, %esi          # imm = 0x3FFFF
addq 0x10(%r12), %rsi
movl %ebp, %edx
shrl $0x12, %edx
movq %rbx, %rdi
callq 0x2040
movq %r15, %rcx
cmpl $0x1000000, %ebp        # imm = 0x1000000
jae 0x3027
jmp 0x30d0
movb (%r15), %al
andb $-0x40, %al
negb %al
jno 0x30bc
movq %r15, %rax
leaq 0x1(%rax), %rdx
cmpq %r14, %rax
cmovneq %rdx, %r15
cmovneq %rdx, %rax
movb (%rax), %dl
andb $-0x40, %dl
negb %dl
jo 0x30a4
movq 0x8(%rbx), %rsi
movq %r15, %r8
subq %rcx, %r8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2140
cmpq %r14, %r15
jne 0x301f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rdx, %rbx
movq %rdi, %r15
xorl %eax, %eax
movl $0xffffff, %r13d        # imm = 0xFFFFFF
movq %rsi, %r12
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %rsi, (%rsp)
movq %r12, %rcx
subq %rsi, %rcx
movl 0x8(%r15), %r11d
movl %ecx, %edx
movq (%r15), %rdi
movl %r11d, %r9d
movzbl (%r12), %r8d
cmpl $0x1, %r8d
sbbq $-0x1, %r12
movl (%rdi,%r9,4), %r11d
andl %r13d, %r11d
addl %r8d, %r11d
movl (%rdi,%r11,4), %r8d
movl %r8d, %r9d
shrl $0x18, %r9d
movzbl -0x1(%r12), %r10d
cmpl %r10d, %r9d
jne 0x3189
andl %r13d, %r8d
movl (%rdi,%r8,4), %edi
cmpl %r13d, %edi
ja 0x317f
testl %eax, %eax
cmovel %ecx, %ebp
incl %eax
movq %r12, %r14
subq %rsi, %r14
cmpl %r14d, %ecx
jae 0x317f
movl %r14d, %r8d
movq %rdx, %r9
movq (%rbx), %r10
movb %dil, (%r10,%r9)
incq %r9
cmpq %r8, %r9
jb 0x3170
cmpl $0x1000000, %edi        # imm = 0x1000000
jae 0x3119
jmp 0x31ad
cmpl $0x2, %eax
jb 0x31a2
movq %r15, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
movl %r14d, %r8d
callq 0x3362
movq (%rsp), %rsi
xorl %eax, %eax
jmp 0x31ad
testb %cl, %cl
je 0x31ad
incq %r12
movb (%r12), %cl
movl %ecx, %edx
andb $-0x40, %dl
negb %dl
jo 0x31a6
cmpb $0x0, (%r12)
jne 0x310d
cmpl $0x2, %eax
jb 0x31e8
movq %r15, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
movl %r14d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3362
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl %r8d, %ecx
je 0x33c8
pushq %rbp
pushq %r14
pushq %rbx
leal 0x1(%rcx), %eax
movl %r8d, %r11d
cmpl %r8d, %eax
jae 0x33bc
leal -0x1(%r8), %edi
movl %ecx, %r9d
movq %rax, %r10
movl %r8d, %r11d
movl %r9d, %r9d
movq (%rdx), %rbx
movb (%rbx,%r9), %bpl
movb (%rbx,%r10), %r14b
cmpb %r14b, %bpl
jbe 0x33b1
movb %r14b, (%rbx,%r9)
movb %bpl, (%rbx,%r10)
movb (%rsi,%r9), %r11b
movb (%rsi,%r10), %bl
movb %bl, (%rsi,%r9)
movb %r11b, (%rsi,%r10)
movl %r10d, %r11d
incq %r10
incl %r9d
cmpl %r9d, %edi
jne 0x3383
cmpl %r11d, %r8d
movl %r11d, %r8d
jne 0x336e
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %r15
callq 0x2e16
cmpb $0x0, (%rax)
je 0x34b6
movq %rax, %r13
leaq 0x90(%r15), %r12
movq 0x98(%r15), %rdx
movq %rax, %r8
subq %rbp, %r8
movq %r12, %rdi
xorl %esi, %esi
movq %rbp, %rcx
callq 0x2140
cmpb $0x0, (%r13)
movq %rbx, (%rsp)
je 0x34b2
leaq 0xb0(%r15), %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2ed4
movq %rax, %rbx
movq $0x0, 0xb8(%r15)
movq 0xb0(%r15), %rax
movb $0x0, (%rax)
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq (%rsp), %rcx
movq %rbp, %r8
callq 0x2f30
movq 0xb0(%r15), %rsi
movq %r15, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x34c8
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2e16
movq %rax, %r13
movq 0x98(%r15), %rsi
movq %rax, %r8
subq %rbx, %r8
movq %r12, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x2140
cmpb $0x0, (%r13)
jne 0x3429
movq (%r12), %rbp
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0xf0(%rdi), %rax
leaq 0xd0(%rdi), %rcx
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
cmpb $0x0, (%rsi)
je 0x3526
movq %rdi, %r14
addq $0x30, %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3536
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x350e
movq 0x18(%rsp), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdx, %rcx
leaq 0x10(%rdi), %rax
leaq 0x18(%rdi), %rdx
movq 0x10(%rdi), %r9
cmpb $0x0, (%r9)
movq 0x18(%rdi), %r10
movq %r9, %r8
cmoveq %r10, %r8
sete %r11b
movb (%r8), %bl
andb $-0x40, %bl
negb %bl
jno 0x38ac
testb $0x1, %r11b
je 0x3894
cmpb $0x0, (%r10)
je 0x389a
incq %r10
movq %r10, (%rdx)
jmp 0x389a
incq %r9
movq %r9, (%rax)
cmpb $0x0, (%r9)
sete %r11b
movq %r10, %r8
je 0x3876
movq %r9, %r8
jmp 0x3876
movq %r9, %r14
subq (%rdi), %r14
addq %r10, %r14
subq 0x8(%rdi), %r14
leal -0x1(%r14), %ebx
movq 0x20(%rdi), %r12
movq (%r12), %r15
movq 0x8(%r12), %r12
subq %r15, %r12
cmpq %rbx, %r12
jbe 0x38d8
movb (%r15,%rbx), %bl
jmp 0x38da
xorl %ebx, %ebx
movl %r14d, %r14d
cmpq %r14, %r12
jbe 0x38e8
movb (%r15,%r14), %bpl
jmp 0x38ea
xorl %ebp, %ebp
movl %ebx, %r14d
orb %sil, %r14b
jne 0x38f7
testb %bpl, %bpl
jne 0x3929
cmpb %sil, %bpl
jbe 0x3901
cmpb %bpl, %bl
jb 0x392d
testb %bpl, %bpl
je 0x3929
movq %rax, %r8
testb %r11b, %r11b
je 0x391e
cmpb $0x0, (%r10)
movq %r10, %r9
movq %rdx, %r8
je 0x385f
incq %r9
movq %r9, (%r8)
jmp 0x385f
xorl %eax, %eax
jmp 0x3941
movq 0x28(%rdi), %rdi
movq 0x8(%rdi), %rsi
subq %rcx, %r8
xorl %edx, %edx
callq 0x2140
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r8
movb (%r8), %bpl
movq 0x8(%rsi), %rsi
subq %rdx, %r8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2140
testb %bpl, %bpl
je 0x3979
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r8
cmpb $0x0, (%r8)
jne 0x398b
movq 0x18(%r14), %r8
movq 0x8(%rbx), %rsi
subq %rcx, %r8
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2170
leaq 0x30(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x2260
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x22f0
movq (%rsp), %r14
movq %r14, %rdi
callq 0x20e0
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movl $0x1, %ecx
callq 0x34a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b0b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
movq 0x3496(%rip), %rsi      # 0x5fa8
leaq 0x20(%rsp), %rdi
callq 0x2190
leaq 0xa0(%rsp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b5c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
jmp 0x2b5c
jmp 0x2b59
movq %rax, %rbx
movq 0x3445(%rip), %rsi      # 0x5fa8
leaq 0x20(%rsp), %rdi
callq 0x2190
leaq 0xa0(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10008, %rsp          # imm = 0x10008
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movl $0x10001, %edx          # imm = 0x10001
movq %r15, %rdi
xorl %esi, %esi
callq 0x2120
movq %rbx, %rdi
movq %r15, %rsi
movl $0x10000, %edx          # imm = 0x10000
movl $0x1, %ecx
callq 0x329c
movq 0x8(%r14), %r12
movq %r15, %rdi
callq 0x20e0
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x22e0
movq %rbx, %rax
addq $0x10008, %rsp          # imm = 0x10008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x107a(%rip), %rdx      # 0x40a7
leaq 0x10(%rsp), %r15
movl $0xff, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2310
movq 0x20(%rbx), %rdi
leaq 0x8(%rbx), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0x2290
testl %eax, %eax
je 0x30ab
cmpb $0x1, 0x1dc(%rbx)
jne 0x31a0
movl %eax, %ebp
movq 0x2f82(%rip), %r14      # 0x5ff0
leaq 0x1035(%rip), %rsi      # 0x40aa
movl $0x1d, %edx
movq %r14, %rdi
callq 0x2260
movq 0x40(%rbx), %r15
testq %r15, %r15
je 0x3112
movq %r15, %rdi
callq 0x20e0
movq 0x2f52(%rip), %rdi      # 0x5ff0
movq %r15, %rsi
movq %rax, %rdx
callq 0x2260
jmp 0x312a
movb $0x1, 0x14(%rbx)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2060
movl %eax, 0x10(%rbx)
testl %eax, %eax
js 0x30e8
leaq 0xc(%rsp), %rcx
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x2350
jmp 0x31a4
cmpb $0x1, 0x1dc(%rbx)
jne 0x31a4
movq 0x2ef4(%rip), %rdi      # 0x5ff0
leaq 0xfd3(%rip), %rsi       # 0x40d6
movl $0x25, %edx
callq 0x2260
jmp 0x31a4
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2320
movq 0x2ebf(%rip), %r14      # 0x5ff0
leaq 0xf90(%rip), %rsi       # 0x40c8
movl $0xd, %edx
movq %r14, %rdi
callq 0x2260
movl %ebp, %edi
callq 0x22b0
testq %rax, %rax
je 0x3170
movq %rax, %r15
movq %rax, %rdi
callq 0x20e0
movq 0x2e8d(%rip), %rdi      # 0x5ff0
movq %r15, %rsi
movq %rax, %rdx
callq 0x2260
jmp 0x3188
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2320
movq 0x2e61(%rip), %rdi      # 0x5ff0
leaq 0x10ca(%rip), %rsi      # 0x4260
movl $0x1, %edx
callq 0x2260
movb $0x0, 0x14(%rbx)
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x327c
movl %esi, %ebx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x70(%r14)
movaps %xmm0, 0x60(%r14)
movaps %xmm0, 0x50(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
leal 0x3f(%rbx), %eax
testl %esi, %esi
cmovnsl %esi, %eax
movl %eax, %esi
andl $-0x40, %esi
movl %ebx, %ecx
subl %esi, %ecx
movl $0x1, %esi
shlq %cl, %rsi
sarl $0x6, %eax
cltq
orq %rsi, 0x10(%rsp,%rax,8)
movq %rsp, %r15
movaps %xmm0, (%r15)
movl %edx, %eax
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
incl %ebx
movl %ebx, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x21f0
movl %eax, %ebp
testl %eax, %eax
jns 0x326c
callq 0x2040
cmpl $0x4, (%rax)
je 0x324b
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe79(%rip), %rdi       # 0x40fc
leaq 0xe7e(%rip), %rsi       # 0x4108
leaq 0xe88(%rip), %rcx       # 0x4119
movl $0x2b, %edx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
testl %edx, %edx
jle 0x3605
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
movl %edx, 0x8(%rsp)
movl %edx, %ebp
movl 0x10(%rbx), %edi
movl %ebp, %edx
movq %r15, %rsi
movl $0x4000, %ecx           # imm = 0x4000
callq 0x2100
movq %rax, %r13
cmpb $0x1, 0x1dc(%rbx)
jne 0x3564
movl $0x5, %edx
movq 0x2afd(%rip), %r12      # 0x5ff0
movq %r12, %rdi
leaq 0xd1f(%rip), %rsi       # 0x421c
callq 0x2260
movq %r12, %rdi
movl %r13d, %esi
callq 0x2330
movq %r15, 0x10(%rsp)
movq %rax, %r12
movl $0xa, %edx
movq %rax, %rdi
leaq 0xcfe(%rip), %rsi       # 0x4222
callq 0x2260
movq %r12, %rdi
movl 0x8(%rsp), %esi
callq 0x2330
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r12, %rdi
movq 0x10(%rsp), %r15
callq 0x2030
movq %rax, %rdi
callq 0x2160
testl %r13d, %r13d
js 0x357e
je 0x359c
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r15
subl %r13d, %ebp
addl %r13d, %r14d
jmp 0x3588
callq 0x2040
cmpl $0x4, (%rax)
jne 0x35b8
testl %ebp, %ebp
jle 0x3597
cmpb $0x0, 0xc(%rsp)
je 0x34c9
movl %r14d, %r14d
jmp 0x35e5
movl 0x10(%rbx), %edi
movq $-0x1, %r14
testl %edi, %edi
jle 0x35e5
callq 0x2370
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
jmp 0x35e5
movq %rax, %r13
cmpb $0x1, 0x1dc(%rbx)
je 0x35f7
cmpl $0x0, (%r13)
jle 0x3624
movl 0x10(%rbx), %edi
testl %edi, %edi
jle 0x35de
callq 0x2370
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
movslq (%r13), %r14
negq %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc2f(%rip), %rdi       # 0x422d
callq 0x21d0
jmp 0x35c4
leaq 0xbca(%rip), %rdi       # 0x41d6
leaq 0xaf5(%rip), %rsi       # 0x4108
leaq 0xbc5(%rip), %rcx       # 0x41df
movl $0x61, %edx
callq 0x2150
leaq 0xba1(%rip), %rdi       # 0x41cc
leaq 0xad6(%rip), %rsi       # 0x4108
leaq 0xba6(%rip), %rcx       # 0x41df
movl $0x6b, %edx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x38, %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 0x3008
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rsi
movl $0x0, 0x4(%rsi)
movl 0x10(%rbx), %edi
movl 0x10(%rax), %edx
callq 0x2050
testl %eax, %eax
js 0x38ac
cmpb $0x1, 0x1dc(%rbx)
jne 0x3872
movq 0x27cc(%rip), %r14      # 0x5ff0
leaq 0xa84(%rip), %rsi       # 0x42af
movl $0x1b, %edx
movq %r14, %rdi
callq 0x2260
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
movq %r14, %rdi
callq 0x2260
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2160
movl 0x10(%rbx), %edi
movl $0xff, %esi
callq 0x2240
testl %eax, %eax
jns 0x38a4
cmpb $0x1, 0x1dc(%rbx)
jne 0x38a4
movq 0x275d(%rip), %rdi      # 0x5ff0
leaq 0xa31(%rip), %rsi       # 0x42cb
movl $0x10, %edx
callq 0x2260
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x9ee(%rip), %rdi       # 0x42a1
callq 0x21d0
jmp 0x3814
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2090
testl %eax, %eax
js 0x391d
movl %eax, %ebp
movl $0x1e0, %edi            # imm = 0x1E0
callq 0x2220
movq %rax, %rbx
movq 0x20(%r14), %rsi
movl 0x18(%r14), %edx
movzbl 0x1dc(%r14), %r8d
movq %rax, %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2bee
movl %ebp, 0x10(%rbx)
movb $0x1, 0x14(%rbx)
jmp 0x3941
cmpb $0x1, 0x1dc(%r14)
jne 0x393f
movq 0x26c2(%rip), %rdi      # 0x5ff0
leaq 0x9a7(%rip), %rsi       # 0x42dc
movl $0x10, %edx
callq 0x2260
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 0x2230
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %r14d
movl $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq 0x8(%rsi), %rdi
leaq 0x6a26(%rip), %r15      # 0x8d4f
movq %r15, %rsi
callq 0x2170
testl %eax, %eax
sete -0x20(%rbp)
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x2170
testl %eax, %eax
sete -0x1f(%rbp)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x2170
testl %eax, %eax
sete -0x1e(%rbp)
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x2170
testl %eax, %eax
sete -0x1d(%rbp)
cmpl $0x6, %r14d
jl 0x237b
movq 0x28(%rbx), %rax
movq %rax, -0x28(%rbp)
movq 0xbd8e(%rip), %rdi      # 0xe110
callq 0x75e2
movq %rax, %rbx
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x23b4
movq %rbx, %rdi
callq 0x6329
movq %rbx, %rdi
callq 0x6388
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2457
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2476
movq %rax, %r15
cmpb $0x1, 0x8(%rbx)
jne 0x23e4
movq %r15, %rdi
callq 0x24f0
cmpb $0x1, 0x9(%rbx)
jne 0x2424
movq 0xbd27(%rip), %rdi      # 0xe118
leaq 0x6502(%rip), %rsi      # 0x88fa
callq 0x2130
movq %rax, %r12
testq %rax, %rax
jne 0x2427
leaq 0x64f0(%rip), %rdi      # 0x88fc
leaq 0x64a8(%rip), %rsi      # 0x88bb
leaq 0x64bc(%rip), %rcx      # 0x88d6
movl $0x92, %edx
callq 0x20b0
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x266c
cmpb $0x1, 0x9(%rbx)
jne 0x244e
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 0x67fc(%rip), %rdi      # 0x8c5a
leaq 0x6456(%rip), %rsi      # 0x88bb
leaq 0x646a(%rip), %rcx      # 0x88d6
movl $0x84, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24d1
movq %rdi, %rbx
movq (%rdi), %rax
xorl %r14d, %r14d
testq %rax, %rax
je 0x249c
incq %r14
movq 0x18(%rax), %rax
jmp 0x248e
callq 0x384a
movq %rax, %r15
movl $0x30, %esi
movq %r14, %rdi
callq 0x20c0
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3889
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6782(%rip), %rdi      # 0x8c5a
leaq 0x63dc(%rip), %rsi      # 0x88bb
leaq 0x66ab(%rip), %rcx      # 0x8b91
movl $0x2ce, %edx            # imm = 0x2CE
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
testq %rdi, %rdi
je 0x264d
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2635
leaq 0x67ec(%rip), %r13      # 0x8d0b
xorl %r15d, %r15d
movq %r15, %r14
movq %r13, %r15
movq (%rbx), %rax
movq %r14, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %r12
movq (%rax,%r12), %rsi
leaq 0x67b3(%rip), %rdi      # 0x8cf4
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rax
movq 0x18(%rax,%r12), %rsi
leaq 0x67a4(%rip), %rdi      # 0x8cfb
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rax
cmpq $0x0, 0x18(%rax,%r12)
movq %r14, -0x38(%rbp)
movq %r12, -0x30(%rbp)
je 0x25b2
addq %r12, %rax
leaq (%r14,%r14,2), %r12
shlq $0x4, %r12
movq %rax, %rdi
xorl %r13d, %r13d
movq 0x8(%rdi), %rax
movq (%rax,%r13,8), %r14
movq %r14, %rsi
callq 0x332a
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x2040
incq %r13
movq (%rbx), %rax
leaq (%rax,%r12), %rdi
cmpq 0x18(%rax,%r12), %r13
jb 0x2582
movq -0x30(%rbp), %r14
movq 0x20(%rax,%r14), %rsi
leaq 0x6752(%rip), %rdi      # 0x8d14
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rdi
movq 0x18(%rdi,%r14), %r12
movq 0x20(%rdi,%r14), %rax
addq %r12, %rax
cmpq %rax, %r12
movq %r15, %r13
movq -0x38(%rbp), %r15
jae 0x2628
addq %r14, %rdi
movq 0x8(%rdi), %rax
movq (%rax,%r12,8), %r14
movq %r14, %rsi
callq 0x332a
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x2040
incq %r12
movq (%rbx), %rax
leaq (%r15,%r15,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
movq 0x20(%rax,%rcx), %rdx
addq 0x18(%rax,%rcx), %rdx
cmpq %rdx, %r12
jb 0x25e8
incq %r15
cmpq 0x8(%rbx), %r15
jb 0x2522
movl $0xa, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2160
leaq 0x62fc(%rip), %rdi      # 0x8950
leaq 0x6260(%rip), %rsi      # 0x88bb
leaq 0x6672(%rip), %rcx      # 0x8cd4
movl $0x36d, %edx            # imm = 0x36D
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x118, %rsp            # imm = 0x118
testq %rdi, %rdi
je 0x276b
movq %rsi, %rbx
testq %rsi, %rsi
je 0x278a
movq %rcx, %r14
testq %rcx, %rcx
je 0x27a9
movq %rdx, %r15
movq (%rdi), %r13
leaq -0x140(%rbp), %r12
movl $0x118, %edx            # imm = 0x118
movq %r12, %rdi
xorl %esi, %esi
callq 0x20a0
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x27c8
movq %r12, %rdi
callq 0x2883
movq %r12, %rdi
callq 0x28f2
cmpq $0x0, 0x8(%rbx)
je 0x2710
xorl %r12d, %r12d
leaq -0x140(%rbp), %r15
movq 0x20(%r13), %rdi
movq %r15, %rsi
callq 0x29aa
addq $0x30, -0x138(%rbp)
movq 0x18(%r13), %r13
incq %r12
cmpq 0x8(%rbx), %r12
jb 0x26ef
leaq -0x140(%rbp), %r15
movq %r15, %rdi
callq 0x2a43
movq %r15, %rdi
callq 0x4d3e
leaq -0x118(%rbp), %r12
movq %r12, %rdi
callq 0x4efd
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b01
movq %rbx, %rdi
callq 0x2c30
movq %rbx, %rdi
callq 0x2140
movq %r12, %rdi
callq 0x5117
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x64e8(%rip), %rdi      # 0x8c5a
leaq 0x6142(%rip), %rsi      # 0x88bb
leaq 0x61db(%rip), %rcx      # 0x895b
movl $0xb2, %edx
callq 0x20b0
leaq 0x61bf(%rip), %rdi      # 0x8950
leaq 0x6123(%rip), %rsi      # 0x88bb
leaq 0x61bc(%rip), %rcx      # 0x895b
movl $0xb3, %edx
callq 0x20b0
leaq 0x61a6(%rip), %rdi      # 0x8956
leaq 0x6104(%rip), %rsi      # 0x88bb
leaq 0x619d(%rip), %rcx      # 0x895b
movl $0xb4, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2826
testq %rsi, %rsi
je 0x2845
testq %rcx, %rcx
je 0x2864
movq %rdi, %rbx
movq %rsi, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq $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 0x4f16
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4d98
leaq 0x60d8(%rip), %rdi      # 0x8905
leaq 0x6087(%rip), %rsi      # 0x88bb
leaq 0x60d3(%rip), %rcx      # 0x890e
movl $0x9f, %edx
callq 0x20b0
leaq 0x6104(%rip), %rdi      # 0x8950
leaq 0x6068(%rip), %rsi      # 0x88bb
leaq 0x60b4(%rip), %rcx      # 0x890e
movl $0xa0, %edx
callq 0x20b0
leaq 0x60eb(%rip), %rdi      # 0x8956
leaq 0x6049(%rip), %rsi      # 0x88bb
leaq 0x6095(%rip), %rcx      # 0x890e
movl $0xa1, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28ac
movq 0x10(%rbx), %rcx
leaq 0x60fc(%rip), %rdi      # 0x8999
movl $0x2c, %esi
movl $0x1, %edx
callq 0x21f0
movq (%rbx), %rsi
leaq 0x6110(%rip), %rdi      # 0x89c6
callq 0x2cc8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4a77
movl $0x3c, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3e74
movq %rbx, %rdi
movl $0x7, %esi
xorl %edx, %edx
callq 0x3e74
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4cc9
// File: /workspace/github_cpp_makefile_star2_O1/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmStdFunctions(Compiler*)
void WriteAsmStdFunctions(Compiler* compiler)
{
    assert(compiler);

    ElfFileWriter* writer = &compiler->writer;

    memcpy(writer->buffer + writer->offset, byte_code_print, sizeof(byte_code_print));
    compiler->print_offset = writer->offset;
    writer->offset += sizeof(byte_code_print);

    memcpy(writer->buffer + writer->offset, byte_code_scan, sizeof(byte_code_scan));
    compiler->scan_offset = writer->offset;
    writer->offset += sizeof(byte_code_scan);

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "%s", nasm_print_func);
        fprintf(compiler->file, "%s", nasm_scan_func);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x298b
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
addq 0x30(%rbx), %rdi
leaq 0x575d(%rip), %rsi      # 0x8070
movl $0x66, %edx
callq 0x20d0
movq 0x30(%rbx), %rdi
movq %rdi, 0x108(%rbx)
addq $0x66, %rdi
movq %rdi, 0x30(%rbx)
addq 0x28(%rbx), %rdi
leaq 0x57a5(%rip), %rsi      # 0x80e0
movl $0x5c, %edx
callq 0x20d0
movq 0x30(%rbx), %rax
movq %rax, 0x110(%rbx)
addq $0x5c, %rax
movq %rax, 0x30(%rbx)
cmpb $0x1, 0x20(%rbx)
jne 0x2984
movq 0x10(%rbx), %rsi
movq 0xb7bf(%rip), %rdi      # 0xe128
callq 0x2120
movq 0x10(%rbx), %rsi
movq 0xb7b7(%rip), %rdi      # 0xe130
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2120
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5f73(%rip), %rdi      # 0x8905
leaq 0x5f22(%rip), %rsi      # 0x88bb
leaq 0x6090(%rip), %rcx      # 0x8a30
movl $0xf9, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O1/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmFunc(Node*, Compiler*)
void WriteAsmFunc(Node* node, Compiler* compiler)
{
    ASSERT_COMPILER;

    WriteFuncDecl(compiler, FUNC);

    WritePushR64  (compiler, RBP);
    WriteMovR64R64(compiler, RBP, RSP);
    WriteSubR64Num(compiler, RSP, FUNC->num_vars * sizeof(int64_t));

    WriteAsmCompound(node->left->right, compiler);

    WriteMovR64R64(compiler, RSP, RBP);
    WritePopR64   (compiler, RBP);
    WriteRet      (compiler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
movq %rbx, %rdi
callq 0x4c5d
movq %rbx, %rdi
movl $0x5, %esi
callq 0x440d
movq %rbx, %rdi
movl $0x5, %esi
movl $0x4, %edx
callq 0x3bb8
movq 0x8(%rbx), %rax
movl 0x20(%rax), %edx
shll $0x3, %edx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x41a1
movq 0x18(%r14), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x2a18
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x2da4
movq 0x20(%r14), %r14
jmp 0x2a01
movq %rbx, %rdi
movl $0x4, %esi
movl $0x5, %edx
callq 0x3bb8
movq %rbx, %rdi
movl $0x5, %esi
callq 0x45a6
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4bf5
// File: /workspace/github_cpp_makefile_star2_O1/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmStdData(Compiler*)
void WriteAsmStdData(Compiler* compiler)
{
    assert(compiler);

    int data_segment_offset = InitDataSegment(&compiler->writer);

    memcpy(compiler->writer.buffer + compiler->writer.offset, byte_code_std_data, sizeof(byte_code_std_data));
    compiler->writer.offset += sizeof(byte_code_std_data);

    SetInt(&compiler->writer, start_virtual_offset + data_segment_offset, offset_to_set_data + compiler->print_offset);
    SetInt(&compiler->writer, start_virtual_offset + data_segment_offset, offset_to_set_data + compiler->scan_offset);

    if (compiler->asm_listing_required)
    {
        fprintf(compiler->file, "%s", asm_data);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2ae2
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x4e58
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rdx
movaps 0x56cc(%rip), %xmm0     # 0x8140
movups %xmm0, (%rcx,%rdx)
movw $0x20, 0x10(%rcx,%rdx)
addq $0x12, 0x30(%rbx)
leal 0x400000(%rax), %r15d
movq 0x108(%rbx), %rdx
addq $0x2, %rdx
movq %r14, %rdi
movl %r15d, %esi
callq 0x507d
movq 0x110(%rbx), %rdx
addq $0x2, %rdx
movq %r14, %rdi
movl %r15d, %esi
callq 0x507d
cmpb $0x1, 0x20(%rbx)
jne 0x2ad7
movq 0x10(%rbx), %rsi
movq 0xb670(%rip), %rdi      # 0xe138
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2120
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e1c(%rip), %rdi      # 0x8905
leaq 0x5dcb(%rip), %rsi      # 0x88bb
leaq 0x5f5f(%rip), %rcx      # 0x8a56
movl $0x10e, %edx            # imm = 0x10E
callq 0x20b0