LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2fb4
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 0x3184
addq $0x78, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3074
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movzbl (%rsi), %edi
movl $0xffffff, %r8d         # imm = 0xFFFFFF
andl (%rcx,%rax,4), %r8d
addl %edi, %r8d
movl (%rcx,%r8,4), %r8d
movl %r8d, %eax
shrl $0x18, %eax
cmpl %edi, %eax
jne 0x2fb1
andl $0xffffff, %r8d         # imm = 0xFFFFFF
movl (%rcx,%r8,4), %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jb 0x2fb3
cmpb $0x1, %dil
sbbq $-0x1, %rsi
movzbl (%rsi), %edi
jmp 0x2f81
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rcx
movq %rdi, %r15
movl $0xffffff, %ebp         # imm = 0xFFFFFF
movq %rsi, %r12
movl 0x8(%r15), %esi
movq (%r15), %rax
cmpq %r14, %r12
je 0x2fe6
movzbl (%r12), %edx
incq %r12
jmp 0x2fe8
xorl %edx, %edx
movl %esi, %esi
movl (%rax,%rsi,4), %esi
andl %ebp, %esi
addl %edx, %esi
movl (%rax,%rsi,4), %edx
movl %edx, %edi
shrl $0x18, %edi
movzbl -0x1(%r12), %r8d
cmpl %r8d, %edi
jne 0x302f
andl $0xffffff, %edx         # imm = 0xFFFFFF
movl (%rax,%rdx,4), %edx
cmpq $0xffffff, %rdx         # imm = 0xFFFFFF
ja 0x2fd7
movl %edx, %esi
andl $0x3ffff, %esi          # imm = 0x3FFFF
addq 0x10(%r15), %rsi
shrl $0x12, %edx
movq %rbx, %rdi
callq 0x2040
jmp 0x305f
movb (%r12), %al
movl %eax, %edx
andb $-0x40, %dl
negb %dl
jno 0x304b
cmpq %r14, %r12
je 0x3033
movb 0x1(%r12), %al
incq %r12
jmp 0x3033
movq 0x8(%rbx), %rsi
movq %r12, %r8
subq %rcx, %r8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2140
movq %r12, %rcx
cmpq %r14, %r12
jne 0x2fd0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3115
andl %r13d, %r8d
movl (%rdi,%r8,4), %edi
cmpl %r13d, %edi
ja 0x310b
testl %eax, %eax
cmovel %ecx, %ebp
incl %eax
movq %r12, %r14
subq %rsi, %r14
cmpl %r14d, %ecx
jae 0x3132
movl %r14d, %r8d
movq %rdx, %r9
movq (%rbx), %r10
movb %dil, (%r10,%r9)
incq %r9
cmpq %r8, %r9
jb 0x30fc
cmpl $0x1000000, %edi        # imm = 0x1000000
jae 0x30a5
jmp 0x3132
cmpl $0x2, %eax
jb 0x312e
movq %r15, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
movl %r14d, %r8d
callq 0x32fe
movq (%rsp), %rsi
xorl %eax, %eax
jmp 0x3132
movb (%r12), %cl
movl %ecx, %edx
andb $-0x40, %dl
negb %dl
jno 0x3149
movb 0x1(%r12), %cl
incq %r12
jmp 0x3136
testb %cl, %cl
jne 0x3099
cmpl $0x2, %eax
jb 0x3174
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 0x32fe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x336f
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
leal 0x1(%rcx), %eax
movl %ecx, %edi
notl %edi
movl %r8d, %r11d
cmpl %r8d, %eax
jae 0x3361
leal (%rdi,%r8), %r9d
movq %rax, %r10
movl %ecx, %ebx
movl %r8d, %r11d
movl %ebx, %ebx
movq (%rdx), %r14
movb (%r14,%rbx), %bpl
movb (%r14,%r10), %r15b
cmpb %r15b, %bpl
jbe 0x3356
movb %r15b, (%r14,%rbx)
movb %bpl, (%r14,%r10)
movb (%rsi,%rbx), %r11b
movb (%rsi,%r10), %bpl
movb %bpl, (%rsi,%rbx)
movb %r11b, (%rsi,%r10)
movl %r10d, %ebx
movl %r10d, %r11d
jmp 0x3359
movl %r10d, %ebx
incq %r10
decl %r9d
jne 0x3324
cmpl %r11d, %r8d
movl %r11d, %r8d
jne 0x3310
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2e14
cmpb $0x0, (%rax)
je 0x345c
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 0x3458
leaq 0xb0(%r15), %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2eb0
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 0x2f0c
movq 0xb0(%r15), %rsi
movq %r15, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x346e
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2e14
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 0x33cf
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_O3/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 %rdx, %rax
leaq 0xf0(%rdi), %rcx
leaq 0xd0(%rdi), %rdx
movq %rsi, (%rsp)
movq %rax, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
cmpb $0x0, (%rsi)
je 0x34d4
movq %rdi, %r14
addq $0x30, %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x34de
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x34b7
movq 0x18(%rsp), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
leaq 0x10(%rdi), %rax
leaq 0x18(%rdi), %rdx
movq (%rdi), %r9
movq 0x8(%rdi), %r10
movq 0x20(%rdi), %r11
movq (%rax), %rbx
movb (%rbx), %r15b
testb %r15b, %r15b
movq (%rdx), %r14
movq %rbx, %r8
cmoveq %r14, %r8
sete %bpl
jmp 0x37d8
testb $0x1, %bpl
je 0x37b4
cmpb $0x0, (%r14)
movq %rdx, %rcx
jne 0x37ba
jmp 0x37c9
movq %rbx, %r14
movq %rax, %rcx
incq %r14
movq %r14, (%rcx)
movq (%rax), %rbx
movb (%rbx), %r15b
movq (%rdx), %r14
movq %r14, %r8
testb %r15b, %r15b
sete %bpl
je 0x37d8
movq %rbx, %r8
movb (%r8), %cl
andb $-0x40, %cl
negb %cl
jo 0x37a3
movq %rbx, %r15
subq %r9, %r15
addq %r14, %r15
subq %r10, %r15
leal -0x1(%r15), %r12d
movq (%r11), %r13
movq 0x8(%r11), %rcx
subq %r13, %rcx
cmpq %r12, %rcx
jbe 0x3808
movb (%r13,%r12), %r12b
jmp 0x380b
xorl %r12d, %r12d
movl %r15d, %r15d
cmpq %r15, %rcx
jbe 0x3855
movb (%r13,%r15), %cl
movl %r12d, %r15d
orb %sil, %r15b
jne 0x3824
testb %cl, %cl
jne 0x3855
cmpb %sil, %cl
jbe 0x382e
cmpb %cl, %r12b
jb 0x3859
testb %cl, %cl
je 0x3855
movq %rax, %rcx
testb %bpl, %bpl
je 0x384a
cmpb $0x0, (%r14)
movq %r14, %rbx
movq %rdx, %rcx
je 0x378a
incq %rbx
movq %rbx, (%rcx)
jmp 0x378a
xorl %eax, %eax
jmp 0x3871
movq 0x28(%rdi), %rdi
movq 0x8(%rdi), %rsi
movq (%rsp), %rcx
subq %rcx, %r8
xorl %edx, %edx
callq 0x2140
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x38af
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r8
cmpb $0x0, (%r8)
jne 0x38c1
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_O3/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 0x1076(%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 0x30af
cmpb $0x1, 0x1dc(%rbx)
jne 0x31a4
movl %eax, %ebp
movq 0x2f7e(%rip), %r14      # 0x5ff0
leaq 0x1031(%rip), %rsi      # 0x40aa
movl $0x1d, %edx
movq %r14, %rdi
callq 0x2260
movq 0x40(%rbx), %r15
testq %r15, %r15
je 0x3116
movq %r15, %rdi
callq 0x20e0
movq 0x2f4e(%rip), %rdi      # 0x5ff0
movq %r15, %rsi
movq %rax, %rdx
callq 0x2260
jmp 0x312e
movb $0x1, 0x14(%rbx)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2060
movl %eax, 0x10(%rbx)
testl %eax, %eax
js 0x30ec
leaq 0xc(%rsp), %rcx
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x2350
jmp 0x31a8
cmpb $0x1, 0x1dc(%rbx)
jne 0x31a8
movq 0x2ef0(%rip), %rdi      # 0x5ff0
leaq 0xfcf(%rip), %rsi       # 0x40d6
movl $0x25, %edx
callq 0x2260
jmp 0x31a8
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2320
movq 0x2ebb(%rip), %r14      # 0x5ff0
leaq 0xf8c(%rip), %rsi       # 0x40c8
movl $0xd, %edx
movq %r14, %rdi
callq 0x2260
movl %ebp, %edi
callq 0x22b0
testq %rax, %rax
je 0x3174
movq %rax, %r15
movq %rax, %rdi
callq 0x20e0
movq 0x2e89(%rip), %rdi      # 0x5ff0
movq %r15, %rsi
movq %rax, %rdx
callq 0x2260
jmp 0x318c
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2320
movq 0x2e5d(%rip), %rdi      # 0x5ff0
leaq 0x10c6(%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_O3/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 0x360c
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 0x3566
movl $0x5, %edx
movq 0x2afb(%rip), %r12      # 0x5ff0
movq %r12, %rdi
leaq 0xd1d(%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 0xcfc(%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 0x3580
je 0x35a3
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r15
subl %r13d, %ebp
addl %r13d, %r14d
jmp 0x358f
callq 0x2040
movq %rax, %r13
movl (%rax), %eax
cmpl $0x4, %eax
jne 0x35bf
testl %ebp, %ebp
jle 0x359e
cmpb $0x0, 0xc(%rsp)
je 0x34cb
movl %r14d, %r14d
jmp 0x35e8
movl 0x10(%rbx), %edi
movq $-0x1, %r14
testl %edi, %edi
jle 0x35e8
callq 0x2370
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
jmp 0x35e8
cmpb $0x1, 0x1dc(%rbx)
je 0x35fa
testl %eax, %eax
jle 0x362b
movl 0x10(%rbx), %edi
testl %edi, %edi
jle 0x35e3
callq 0x2370
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
movl (%r13), %eax
negl %eax
movslq %eax, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc2c(%rip), %rdi       # 0x422d
callq 0x21d0
movl (%r13), %eax
jmp 0x35c8
leaq 0xbc3(%rip), %rdi       # 0x41d6
leaq 0xaee(%rip), %rsi       # 0x4108
leaq 0xbbe(%rip), %rcx       # 0x41df
movl $0x61, %edx
callq 0x2150
leaq 0xb9a(%rip), %rdi       # 0x41cc
leaq 0xacf(%rip), %rsi       # 0x4108
leaq 0xb9f(%rip), %rcx       # 0x41df
movl $0x6b, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/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 0x300c
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 0x38b2
cmpb $0x1, 0x1dc(%rbx)
jne 0x3878
movq 0x27c6(%rip), %r14      # 0x5ff0
leaq 0xa7e(%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 0x38aa
cmpb $0x1, 0x1dc(%rbx)
jne 0x38aa
movq 0x2757(%rip), %rdi      # 0x5ff0
leaq 0xa2b(%rip), %rsi       # 0x42cb
movl $0x10, %edx
callq 0x2260
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x9e8(%rip), %rdi       # 0x42a1
callq 0x21d0
jmp 0x381a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3923
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 0x3947
cmpb $0x1, 0x1dc(%r14)
jne 0x3945
movq 0x26bc(%rip), %rdi      # 0x5ff0
leaq 0x9a1(%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_O3/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
movq $0x0, -0x18(%rbp)
movq 0x8(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x231f
cmpb $0x0, 0x1(%rax)
sete %al
jmp 0x2321
xorl %eax, %eax
movb %al, -0x10(%rbp)
movq 0x10(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x2336
cmpb $0x0, 0x1(%rax)
sete %al
jmp 0x2338
xorl %eax, %eax
movb %al, -0xf(%rbp)
movq 0x18(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x234d
cmpb $0x0, 0x1(%rax)
sete %al
jmp 0x234f
xorl %eax, %eax
movb %al, -0xe(%rbp)
movq 0x20(%rsi), %rax
cmpb $0x31, (%rax)
jne 0x2364
cmpb $0x0, 0x1(%rax)
sete %al
jmp 0x2366
xorl %eax, %eax
movb %al, -0xd(%rbp)
cmpl $0x6, %edi
jl 0x2376
movq 0x28(%rsi), %rax
movq %rax, -0x18(%rbp)
movq 0xbd93(%rip), %rdi      # 0xe110
callq 0x7556
movq %rax, %rbx
leaq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x23ac
movq %rbx, %rdi
callq 0x628a
movq %rbx, %rdi
callq 0x62e9
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244f
movq %rsi, %rbx
movq %rdi, %r14
callq 0x246e
movq %rax, %r15
cmpb $0x1, 0x8(%rbx)
jne 0x23dc
movq %r15, %rdi
callq 0x24e8
cmpb $0x1, 0x9(%rbx)
jne 0x241c
movq 0xbd2f(%rip), %rdi      # 0xe118
leaq 0x650a(%rip), %rsi      # 0x88fa
callq 0x2130
movq %rax, %r12
testq %rax, %rax
jne 0x241f
leaq 0x64f8(%rip), %rdi      # 0x88fc
leaq 0x64b0(%rip), %rsi      # 0x88bb
leaq 0x64c4(%rip), %rcx      # 0x88d6
movl $0x92, %edx
callq 0x20b0
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2679
cmpb $0x1, 0x9(%rbx)
jne 0x2446
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 0x6804(%rip), %rdi      # 0x8c5a
leaq 0x645e(%rip), %rsi      # 0x88bb
leaq 0x6472(%rip), %rcx      # 0x88d6
movl $0x84, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24c9
movq %rdi, %rbx
movq (%rdi), %rax
xorl %r14d, %r14d
testq %rax, %rax
je 0x2494
incq %r14
movq 0x18(%rax), %rax
jmp 0x2486
callq 0x3771
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 0x37aa
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x678a(%rip), %rdi      # 0x8c5a
leaq 0x63e4(%rip), %rsi      # 0x88bb
leaq 0x66b3(%rip), %rcx      # 0x8b91
movl $0x2ce, %edx            # imm = 0x2CE
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x265a
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2642
movq (%rbx), %rax
xorl %r13d, %r13d
movq %r13, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %r14
movq (%rax,%r14), %rsi
leaq 0x67c8(%rip), %rdi      # 0x8cf4
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rax
movq 0x18(%rax,%r14), %rsi
leaq 0x67b9(%rip), %rdi      # 0x8cfb
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rax
cmpq $0x0, 0x18(%rax,%r14)
movq %r13, -0x30(%rbp)
movq %r14, -0x38(%rbp)
je 0x25ab
addq %r14, %rax
leaq (,%r13,2), %r12
addq %r13, %r12
shlq $0x4, %r12
movq %rax, %rdi
xorl %r13d, %r13d
leaq 0x6790(%rip), %r15      # 0x8d0b
movq 0x8(%rdi), %rax
movq (%rax,%r13,8), %r14
movq %r14, %rsi
callq 0x32d6
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 0x257b
movq -0x38(%rbp), %r14
movq 0x20(%rax,%r14), %rsi
leaq 0x6759(%rip), %rdi      # 0x8d14
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rax
movq 0x18(%rax,%r14), %r12
movq 0x20(%rax,%r14), %rcx
addq %r12, %rcx
cmpq %rcx, %r12
jae 0x2631
addq %r14, %rax
movq %rax, %rdi
leaq 0x6727(%rip), %r15      # 0x8d0b
movq -0x30(%rbp), %r13
movq 0x8(%rdi), %rax
movq (%rax,%r12,8), %r14
movq %r14, %rsi
callq 0x32d6
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x2040
incq %r12
movq (%rbx), %rax
leaq (,%r13,2), %rcx
addq %r13, %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
movq 0x20(%rax,%rcx), %rdx
addq 0x18(%rax,%rcx), %rdx
cmpq %rdx, %r12
jb 0x25e8
jmp 0x2635
movq -0x30(%rbp), %r13
incq %r13
cmpq 0x8(%rbx), %r13
jb 0x2516
movl $0xa, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2160
leaq 0x62ef(%rip), %rdi      # 0x8950
leaq 0x6253(%rip), %rsi      # 0x88bb
leaq 0x6665(%rip), %rcx      # 0x8cd4
movl $0x36d, %edx            # imm = 0x36D
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2778
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2797
movq %rcx, %r14
testq %rcx, %rcx
je 0x27b6
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 0x27d5
movq %r12, %rdi
callq 0x2890
movq %r12, %rdi
callq 0x28ff
cmpq $0x0, 0x8(%rbx)
je 0x271d
xorl %r12d, %r12d
leaq -0x140(%rbp), %r15
movq 0x20(%r13), %rdi
movq %r15, %rsi
callq 0x29b7
addq $0x30, -0x138(%rbp)
movq 0x18(%r13), %r13
incq %r12
cmpq 0x8(%rbx), %r12
jb 0x26fc
leaq -0x140(%rbp), %r15
movq %r15, %rdi
callq 0x2a50
movq %r15, %rdi
callq 0x4c6a
leaq -0x118(%rbp), %r12
movq %r12, %rdi
callq 0x4e29
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b0e
movq %rbx, %rdi
callq 0x2c3d
movq %rbx, %rdi
callq 0x2140
movq %r12, %rdi
callq 0x5043
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x64db(%rip), %rdi      # 0x8c5a
leaq 0x6135(%rip), %rsi      # 0x88bb
leaq 0x61ce(%rip), %rcx      # 0x895b
movl $0xb2, %edx
callq 0x20b0
leaq 0x61b2(%rip), %rdi      # 0x8950
leaq 0x6116(%rip), %rsi      # 0x88bb
leaq 0x61af(%rip), %rcx      # 0x895b
movl $0xb3, %edx
callq 0x20b0
leaq 0x6199(%rip), %rdi      # 0x8956
leaq 0x60f7(%rip), %rsi      # 0x88bb
leaq 0x6190(%rip), %rcx      # 0x895b
movl $0xb4, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2833
testq %rsi, %rsi
je 0x2852
testq %rcx, %rcx
je 0x2871
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 0x4e42
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4cc4
leaq 0x60cb(%rip), %rdi      # 0x8905
leaq 0x607a(%rip), %rsi      # 0x88bb
leaq 0x60c6(%rip), %rcx      # 0x890e
movl $0x9f, %edx
callq 0x20b0
leaq 0x60f7(%rip), %rdi      # 0x8950
leaq 0x605b(%rip), %rsi      # 0x88bb
leaq 0x60a7(%rip), %rcx      # 0x890e
movl $0xa0, %edx
callq 0x20b0
leaq 0x60de(%rip), %rdi      # 0x8956
leaq 0x603c(%rip), %rsi      # 0x88bb
leaq 0x6088(%rip), %rcx      # 0x890e
movl $0xa1, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28b9
movq 0x10(%rbx), %rcx
leaq 0x60ef(%rip), %rdi      # 0x8999
movl $0x2c, %esi
movl $0x1, %edx
callq 0x21f0
movq (%rbx), %rsi
leaq 0x6103(%rip), %rdi      # 0x89c6
callq 0x2cd5
movq %rbx, %rdi
movq %rax, %rsi
callq 0x49a3
movl $0x3c, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3da0
movq %rbx, %rdi
movl $0x7, %esi
xorl %edx, %edx
callq 0x3da0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4bf5
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2998
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
addq 0x30(%rbx), %rdi
leaq 0x5750(%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 0x5798(%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 0x2991
movq 0x10(%rbx), %rsi
movq 0xb7b2(%rip), %rdi      # 0xe128
callq 0x2120
movq 0x10(%rbx), %rsi
movq 0xb7aa(%rip), %rdi      # 0xe130
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2120
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5f66(%rip), %rdi      # 0x8905
leaq 0x5f15(%rip), %rsi      # 0x88bb
leaq 0x6083(%rip), %rcx      # 0x8a30
movl $0xf9, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4b89
movq %rbx, %rdi
movl $0x5, %esi
callq 0x4339
movq %rbx, %rdi
movl $0x5, %esi
movl $0x4, %edx
callq 0x3ae4
movq 0x8(%rbx), %rax
movl 0x20(%rax), %edx
shll $0x3, %edx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x40cd
movq 0x18(%r14), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x2a25
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x2d78
movq 0x20(%r14), %r14
jmp 0x2a0e
movq %rbx, %rdi
movl $0x4, %esi
movl $0x5, %edx
callq 0x3ae4
movq %rbx, %rdi
movl $0x5, %esi
callq 0x44d2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4b21
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2aef
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x4d84
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rdx
movaps 0x56bf(%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 0x4fa9
movq 0x110(%rbx), %rdx
addq $0x2, %rdx
movq %r14, %rdi
movl %r15d, %esi
callq 0x4fa9
cmpb $0x1, 0x20(%rbx)
jne 0x2ae4
movq 0x10(%rbx), %rsi
movq 0xb663(%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 0x5e0f(%rip), %rdi      # 0x8905
leaq 0x5dbe(%rip), %rsi      # 0x88bb
leaq 0x5f52(%rip), %rcx      # 0x8a56
movl $0x10e, %edx            # imm = 0x10E
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteByteCodeToFile(Compiler*, BackEndInfo*)
void WriteByteCodeToFile(Compiler* compiler, BackEndInfo* info)
{
    assert(compiler);
    assert(info);

    const char* output_file_name = DEFAULT_OUTPUT_FILE_NAME;

    if (info->output_file != nullptr)
    {
        output_file_name = info->output_file;
    }

    FILE* output = fopen(output_file_name, "w");
    assert(output && "Can't create output file");

    char chmod_str[chmod_str_len] = "";
    sprintf(chmod_str, "chmod +x %s", output_file_name);
    system(chmod_str);

    fwrite(compiler->writer.buffer, compiler->writer.offset, sizeof(char), output);
    fclose(output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
testq %rdi, %rdi
je 0x2be0
testq %rsi, %rsi
je 0x2bff
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
jne 0x2b44
movq 0xb5dc(%rip), %r15      # 0xe120
leaq 0x5daf(%rip), %rsi      # 0x88fa
movq %r15, %rdi
callq 0x2130
testq %rax, %rax
je 0x2c1e
movq %rax, %r14
xorps %xmm0, %xmm0
leaq -0xa0(%rbp), %r12
movaps %xmm0, 0x70(%r12)
movaps %xmm0, 0x60(%r12)
movaps %xmm0, 0x50(%r12)
movaps %xmm0, 0x40(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x5e85(%rip), %rsi      # 0x8a24
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2060
movq %r12, %rdi
callq 0x20e0
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rcx
callq 0x21f0
movq %r14, %rdi
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2100
leaq 0x5d1e(%rip), %rdi      # 0x8905
leaq 0x5ccd(%rip), %rsi      # 0x88bb
leaq 0x5dd6(%rip), %rcx      # 0x89cb
movl $0xe2, %edx
callq 0x20b0
leaq 0x5d50(%rip), %rdi      # 0x8956
leaq 0x5cae(%rip), %rsi      # 0x88bb
leaq 0x5db7(%rip), %rcx      # 0x89cb
movl $0xe3, %edx
callq 0x20b0
leaq 0x5dda(%rip), %rdi      # 0x89ff
leaq 0x5c8f(%rip), %rsi      # 0x88bb
leaq 0x5d98(%rip), %rcx      # 0x89cb
movl $0xed, %edx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: DestructNameTable(NameTable*)
void DestructNameTable(NameTable* table)
{
    assert(table);

    for (size_t i = 0; i < table->num_func; ++i)
    {
        free(table->functions[i].vars);
    }
    
    free(table->functions);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2c8a
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2c78
movl $0x8, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2140
incq %r15
addq $0x30, %r14
cmpq 0x8(%rbx), %r15
jb 0x2c5f
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2140
leaq 0x5cbf(%rip), %rdi      # 0x8950
leaq 0x5c23(%rip), %rsi      # 0x88bb
leaq 0x5f16(%rip), %rcx      # 0x8bb5
movl $0x2dd, %edx            # imm = 0x2DD
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: FindFunc(char const*, NameTable*)
Function* FindFunc(const char* name, NameTable* table)
{
    assert(name);

    for (size_t i = 0; i < table->num_func; ++i)
    {
        if (strcmp(table->functions[i].name, name) == 0)
        {
            return table->functions + i;
        }
    }

    printf("error : unknown function : '%s'\n", name);

    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2d2d
movq %rdi, %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x2d0b
movq (%rsi), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2170
testl %eax, %eax
je 0x2d1f
addq $0x30, %r14
decq %r15
jne 0x2cf3
leaq 0x5e0e(%rip), %rdi      # 0x8b20
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2040
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x781c(%rip), %rdi      # 0xa550
leaq 0x5b80(%rip), %rsi      # 0x88bb
leaq 0x5db0(%rip), %rcx      # 0x8af2
movl $0x28c, %edx            # imm = 0x28C
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmCompound(Node*, Compiler*)
void WriteAsmCompound(Node* node, Compiler* compiler)
{
    if (node == nullptr)
    {
        return;
    }

    ASSERT_COMPILER;

    while (node != nullptr)
    {
        WriteAsmStatement(node->left, compiler);
        node = node->right;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x2d77
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x2d78
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x2d5e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/back-end/compiling.cpp
// Function: WriteAsmStatement(Node*, Compiler*)
void WriteAsmStatement(Node* node, Compiler* compiler)
{
    ASSERT_COMPILER;

    switch (node->type)
    {
        case DECL_TYPE :
        {
            WriteAsmAssignment(node, compiler);
            break;
        }
        case ADECL_TYPE :
        {
            WriteAsmArrayDeclaration(node, compiler);
            break;
        }
        case ASSG_TYPE :
        {
            WriteAsmAssignment(node, compiler);
            break;
        }
        case JUMP_TYPE :
        {
            if (!FUNC->is_void)
            {
                WriteAsmExpression(node->right, compiler);
                WritePopR64(compiler, RAX);
            }

            WriteMovR64R64(compiler, RSP, RBP);
            WritePopR64   (compiler, RBP);
            WriteRet      (compiler);
            break;
        }
        case COND_TYPE :
        {
            WriteAsmCondition(node, compiler);
            break;
        }
        case LOOP_TYPE :
        {
            WriteAsmLoop(node, compiler);
            break;
        }
        case CALL_TYPE :
        {
            WriteAsmCall(node, compiler);
            break;
        }
        default :
        {
            printf("I am here, but I shouldn't, line = %d\n", __LINE__);
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl (%rdi), %eax
decl %eax
cmpl $0xc, %eax
ja 0x2da8
movq %rsi, %rbx
leaq 0x528f(%rip), %rcx      # 0x8020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2e46
leaq 0x5cc8(%rip), %rdi      # 0x8a77
movl $0x172, %esi            # imm = 0x172
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x320a
movq 0x8(%rbx), %rax
cmpb $0x0, 0x10(%rax)
jne 0x2def
movq 0x20(%rdi), %rdi
movq %rbx, %rsi
callq 0x2f77
movq %rbx, %rdi
xorl %esi, %esi
callq 0x44d2
movq %rbx, %rdi
movl $0x4, %esi
movl $0x5, %edx
callq 0x3ae4
movq %rbx, %rdi
movl $0x5, %esi
callq 0x44d2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4b21
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2f10
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2fd0
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3121