LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Leeheng86[P]word2vec/word2vec.c
// Function: IsNextIElementsEnd(std::__detail::_Node_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, false, true>, int)
bool IsNextIElementsEnd(std::unordered_map<std::string, std::vector<std::string> >::iterator it, int i) {
    std::unordered_map<std::string, std::vector<std::string> >::iterator itt = it;
    for (int j = 0; j <= i; j++) {
        if (itt == umap.end()) {
            return true;
        }
        itt++;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x68e9
leaq 0xdcd3(%rip), %rdi      # 0x14580
callq 0x8540
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8510
testb $0x1, %al
jne 0x68c9
jmp 0x68cf
movb $0x1, -0x1(%rbp)
jmp 0x68ed
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x8570
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x689e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Leeheng86[P]word2vec/word2vec.c
// Function: append(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void append(std::vector<std::string> &v, std::string node) {
  if (discard == 0) {
    v.push_back(node);
  } else if (discard == 1 && !left_node.count(node)) {
    v.push_back(node);
  } else if (discard == 2 && !right_node.count(node)) {
    v.push_back(node);
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0xdc61(%rip)      # 0x1457c
jne 0x692c
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x8460
jmp 0x698a
cmpl $0x1, 0xdc49(%rip)      # 0x1457c
jne 0x695a
movq -0x18(%rbp), %rsi
leaq 0xdc78(%rip), %rdi      # 0x145b8
callq 0x85a0
cmpq $0x0, %rax
jne 0x695a
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x8460
jmp 0x6988
cmpl $0x2, 0xdc1b(%rip)      # 0x1457c
jne 0x6986
movq -0x18(%rbp), %rsi
leaq 0xdc7a(%rip), %rdi      # 0x145e8
callq 0x85a0
cmpq $0x0, %rax
jne 0x6986
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x8460
jmp 0x6988
jmp 0x698a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Leeheng86[P]word2vec/word2vec.c
// Function: join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void join(std::vector<std::string> &v, char c, std::string &s) {
  s.clear();
  for (std::vector<std::string>::const_iterator it = v.begin();
          it != v.end();
          it++) {
      s += *it;
      if (it != v.end() - 1) {
        s += c;
      }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33a0
movq -0x8(%rbp), %rdi
callq 0x8600
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8630
movq -0x8(%rbp), %rdi
callq 0x86b0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8670
testb $0x1, %al
jne 0x69e9
jmp 0x6a55
leaq -0x20(%rbp), %rdi
callq 0x86e0
movq %rax, %rsi
movq -0x18(%rbp), %rdi
callq 0x3380
movq -0x8(%rbp), %rdi
callq 0x86b0
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x8700
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8670
testb $0x1, %al
jne 0x6a30
jmp 0x6a3f
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x31a0
jmp 0x6a41
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x8740
movq %rax, -0x48(%rbp)
jmp 0x69c9
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/analyze.c
// Function: buildSymtab
void buildSymtab(TreeNode * syntaxTree)
{
  registerIO();

  insertNode(syntaxTree, 0);
  printSymTab(listing);
  typeCheck(syntaxTree);
  mainCheck(syntaxTree);
  /*
  if (TraceAnalyze)
  { fprintf(listing,"\nSymbol table:\n\n");
    printSymTab(listing);
  }
  */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1340
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x1540
leaq 0xcefd(%rip), %rax      # 0xe210
movq (%rax), %rdi
callq 0x6ff0
movq -0x8(%rbp), %rdi
callq 0x1910
movq -0x8(%rbp), %rdi
callq 0x20e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/analyze.c
// Function: mainCheck
static void mainCheck(TreeNode *t)
{
  if(t == NULL)
    {
      printError(t, "Main", "There is no main function.");
      return;
    }
  for(; t->sibling; t=t->sibling);
  if(t->nodeKind != FunctionDeclarationK
     || strcmp(t->attr.funcDecl._var->attr.ID, "main") != 0)
    {
      printError(t, "Main", "Main function must be declared at the very last of program.");
      return;
    }

  if(t->attr.funcDecl.type_spec->attr.TOK != VOID)
    {
      printError(t, "Type", "Main function must be type void");
      return;
    }
  if(t->attr.funcDecl.params != NULL)
    {
      printError(t, "Main", "Main function cannot have parameter.");
      return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2111
movq -0x8(%rbp), %rdi
leaq 0x742a(%rip), %rsi      # 0x9528
leaq 0x7428(%rip), %rdx      # 0x952d
movb $0x0, %al
callq 0x21d0
jmp 0x21be
jmp 0x2113
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x212c
jmp 0x211f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2113
movq -0x8(%rbp), %rax
cmpl $0x3, 0xc(%rax)
jne 0x2153
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x73ff(%rip), %rsi      # 0x9548
callq 0x1110
cmpl $0x0, %eax
je 0x216e
movq -0x8(%rbp), %rdi
leaq 0x73ca(%rip), %rsi      # 0x9528
leaq 0x73e8(%rip), %rdx      # 0x954d
movb $0x0, %al
callq 0x21d0
jmp 0x21be
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x109, 0x20(%rax)      # imm = 0x109
je 0x219a
movq -0x8(%rbp), %rdi
leaq 0x6f2e(%rip), %rsi      # 0x90b8
leaq 0x73f8(%rip), %rdx      # 0x9589
movb $0x0, %al
callq 0x21d0
jmp 0x21be
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x21be
movq -0x8(%rbp), %rdi
leaq 0x7378(%rip), %rsi      # 0x9528
leaq 0x73f2(%rip), %rdx      # 0x95a9
movb $0x0, %al
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/analyze.c
// Function: printError
static void printError(TreeNode * t, const char *error_type, const char *fmt, ...)
{
  va_list args;
  fprintf(listing, "%s error at line %d: ", error_type, t->lineno);

  va_start(args, fmt);
  vfprintf(listing, fmt, args);
  va_end(args);

  fprintf(listing, "\n");
  Error = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x2208
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xbfe0(%rip), %rax      # 0xe210
movq %rax, -0xf0(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x7382(%rip), %rsi      # 0x95ce
xorl %eax, %eax
movb %al, -0xe1(%rbp)
callq 0x1120
movq -0xf0(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, -0x20(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1190
movq -0xf0(%rbp), %rcx
movb -0xe1(%rbp), %al
movq (%rcx), %rdi
leaq 0x7540(%rip), %rsi      # 0x97e8
callq 0x1120
leaq 0xbf50(%rip), %rax      # 0xe204
movl $0x1, (%rax)
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/analyze.c
// Function: registerSymbol
static int registerSymbol(TreeNode *regNode, TreeNode *varNode, SymbolInfo * symbolInfo)
{
  int is_cur_scope;
  if (st_lookup(varNode->attr.ID, &is_cur_scope) == NULL || !is_cur_scope)
    {
      /* not yet in table, so treat as new definition */
      st_register(varNode->attr.ID, varNode->lineno, symbolInfo);
      varNode->nodeType = symbolInfo->nodeType;
      varNode->symbolInfo = symbolInfo;
      return TRUE;
    }
  else /* redeclaration */
    {
      printError(varNode, "Declaration", "Redeclaration of symbol \"%s\"", varNode->attr.ID);
      varNode->nodeType = ErrorT;
      return FALSE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x24(%rbp), %rsi
callq 0x6ef0
cmpq $0x0, %rax
je 0x2711
cmpl $0x0, -0x24(%rbp)
jne 0x274b
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x20(%rbp), %rdx
callq 0x6ab0
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x277e
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0x6d8a(%rip), %rsi      # 0x94e8
leaq 0x6d8f(%rip), %rdx      # 0x94f4
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/analyze.c
// Function: tokenToExpType
static ExpType tokenToExpType (TokenType token)
{
  switch (token)
    {
    case INT:
      return IntT;
    case VOID:
      return VoidT;
    default:
      DONT_OCCUR_PRINT;
      return ErrorT;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x107, %eax            # imm = 0x107
je 0x27b2
jmp 0x27a6
movl -0xc(%rbp), %eax
subl $0x109, %eax            # imm = 0x109
je 0x27bb
jmp 0x27c4
movl $0x4, -0x4(%rbp)
jmp 0x27cb
movl $0x3, -0x4(%rbp)
jmp 0x27cb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/analyze.c
// Function: referSymbol
static void referSymbol(TreeNode *varNode)
{
  int is_cur_scope;
  SymbolInfo * symbolInfo;
  if ((symbolInfo = st_lookup(varNode->attr.ID, &is_cur_scope)) == NULL) /* undeclared V/P/F */
    {
      printError(varNode, "Declaration", "Undeclared symbol \"%s\"", varNode->attr.ID);
    }
  else
    {
      /* already in table, so ignore location,
       *
       * add line number of use only */
      st_refer(varNode->attr.ID, varNode->lineno);
      varNode->nodeType = symbolInfo->nodeType;
      varNode->symbolInfo = symbolInfo;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0xc(%rbp), %rsi
callq 0x6ef0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x281a
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0x6cde(%rip), %rsi      # 0x94e8
leaq 0x6d00(%rip), %rdx      # 0x9511
movb $0x0, %al
callq 0x21d0
jmp 0x2847
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x6d80
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/./build/cm.lex.c
// Function: yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 66 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 65);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x9d92(%rip), %rax      # 0xe170
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x598f(%rip), %rax      # 0x9d80
cmpw $0x0, (%rax,%rcx,2)
je 0x440c
movl -0x4(%rbp), %eax
movl %eax, 0x9d7b(%rip)      # 0xe17c
movq -0x10(%rbp), %rax
movq %rax, 0x9d74(%rip)      # 0xe180
jmp 0x440e
movslq -0x4(%rbp), %rcx
leaq 0x5b07(%rip), %rax      # 0x9f20
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x59e3(%rip), %rax      # 0x9e10
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x4463
movslq -0x4(%rbp), %rcx
leaq 0x5b6f(%rip), %rax      # 0x9fb0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x42, -0x4(%rbp)
jl 0x4461
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x5be5(%rip), %rax      # 0xa040
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x440e
movslq -0x4(%rbp), %rcx
leaq 0x5ab2(%rip), %rax      # 0x9f20
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x5bee(%rip), %rax      # 0xa070
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x41, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x44a5
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x44ab
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/symtab.c
// Function: st_push_scope
int st_push_scope(void)
{
  if (cur_scope_level + 1 >= MAX_SCOPE_LEVEL)
    return -1;

  valid_hash_arr_base[++cur_scope_level] = valid_hash_arr_cnt;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x78c6(%rip), %eax      # 0xe220
addl $0x1, %eax
cmpl $0x64, %eax
jl 0x696b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6994
movl 0x78b3(%rip), %edx      # 0xe224
movl 0x78a9(%rip), %eax      # 0xe220
addl $0x1, %eax
movl %eax, 0x78a0(%rip)      # 0xe220
movslq %eax, %rcx
leaq 0x78a6(%rip), %rax      # 0xe230
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/symtab.c
// Function: st_pop_scope
int st_pop_scope(void)
{
  if (cur_scope_level - 1 < 0)
    return -1;

  int i;
  for (i = valid_hash_arr_base[cur_scope_level];
       i < valid_hash_arr_cnt; ++i)
    {
      int h = valid_hash_arr[i];
      BucketList l = hashTable[h];
      
      while ((l != NULL) && l->scope_level >= cur_scope_level)
        {
          struct BucketListRec *tmp = l;
          l = l->next;

          free(tmp);
        }
      hashTable[h] = l;
    }

  valid_hash_arr_cnt = valid_hash_arr_base[cur_scope_level--];

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x7872(%rip), %eax      # 0xe220
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x69c2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6a9c
movslq 0x7857(%rip), %rcx      # 0xe220
leaq 0x7860(%rip), %rax      # 0xe230
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x7845(%rip), %eax      # 0xe224
jge 0x6a71
movslq -0x8(%rbp), %rcx
leaq 0x79d0(%rip), %rax      # 0xe3c0
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x1b23f(%rip), %rax     # 0x21c40
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x6a28
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
cmpl 0x77fe(%rip), %eax      # 0xe220
setge %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6a31
jmp 0x6a50
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x6a09
movq -0x18(%rbp), %rdx
movslq -0xc(%rbp), %rcx
leaq 0x1b1e1(%rip), %rax     # 0x21c40
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x69d6
movl 0x77a9(%rip), %eax      # 0xe220
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x779e(%rip)      # 0xe220
movslq %eax, %rcx
leaq 0x77a4(%rip), %rax      # 0xe230
movl (%rax,%rcx,4), %eax
movl %eax, 0x778f(%rip)      # 0xe224
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/symtab.c
// Function: hash
static int hash ( char * key )
{ int temp = 0;
  int i = 0;
  while (key[i] != '\0')
  { temp = ((temp << SHIFT) + key[i]) % SIZE;
    ++i;
  }
  return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x6d71
movl -0xc(%rbp), %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0xd3, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6d36
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/symtab.c
// Function: st_refer
void st_refer(char * name, int lineno)
{
  assert(name != NULL);

  int h = hash(name);
  BucketList l =  hashTable[h];

  while (l != NULL && strcmp(name,l->name) != 0)
    l = l->next;

  assert(l != NULL);

  LineList t = l->lines;
  while (t->next != NULL) 
    t = t->next;
  MALLOC(t->next, sizeof(struct LineListRec));
  t->next->lineno = lineno;
  t->next->next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6d98
jmp 0x6db7
leaq 0x3c1f(%rip), %rdi      # 0xa9be
leaq 0x3c25(%rip), %rsi      # 0xa9cb
movl $0x74, %edx
leaq 0x3c9b(%rip), %rcx      # 0xaa4d
callq 0x10e0
movq -0x8(%rbp), %rdi
callq 0x6d20
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rcx
leaq 0x1ae72(%rip), %rax     # 0x21c40
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x6dfb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x1110
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6e04
jmp 0x6e12
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6dd6
cmpq $0x0, -0x18(%rbp)
je 0x6e1b
jmp 0x6e3a
leaq 0x3c46(%rip), %rdi      # 0xaa68
leaq 0x3ba2(%rip), %rsi      # 0xa9cb
movl $0x7c, %edx
leaq 0x3c18(%rip), %rcx      # 0xaa4d
callq 0x10e0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6e5f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6e46
jmp 0x6e61
movl $0x10, %edi
callq 0x1160
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6ecb
leaq 0x7388(%rip), %rax      # 0xe210
movq (%rax), %rdi
leaq 0x252f(%rip), %rsi      # 0x93c1
leaq 0x3b32(%rip), %rdx      # 0xa9cb
movl $0x81, %ecx
leaq 0x3bcd(%rip), %r8       # 0xaa72
movb $0x0, %al
callq 0x1120
leaq 0x2548(%rip), %rdi      # 0x93fb
leaq 0x3b11(%rip), %rsi      # 0xa9cb
movl $0x81, %edx
leaq 0x3b87(%rip), %rcx      # 0xaa4d
callq 0x10e0
jmp 0x6ecd
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/symtab.c
// Function: st_lookup
SymbolInfo* st_lookup ( char * name, int * is_cur_scope /* 0 or 1 */ )
{
  int h = hash(name);
  BucketList l =  hashTable[h];

  while ((l != NULL) && (strcmp(name,l->name) != 0))
    {
      l = l->next;
    }

  if (l != NULL)
    {
      *is_cur_scope = (cur_scope_level == l->scope_level);
    }

  return l ? l->symbolInfo : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d20
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x1ad29(%rip), %rax     # 0x21c40
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x6f44
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x1110
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6f4d
jmp 0x6f5b
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6f1f
cmpq $0x0, -0x20(%rbp)
je 0x6f7d
movl 0x72b8(%rip), %eax      # 0xe220
movq -0x20(%rbp), %rcx
cmpl 0x20(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x6f92
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x6f9a
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x6f9a
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/symtab.c
// Function: set_data_type
DATA_TYPE 
set_data_type (TokenType op)
{
  switch (op)
    {
    case INT:
      return DT_INT;
      break;
    case VOID:
      return DT_VOID;
      break;
    default:
      DONT_OCCUR_PRINT;
      return DT_INVALID;
      break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x107, %eax            # imm = 0x107
je 0x6fd2
jmp 0x6fc6
movl -0xc(%rbp), %eax
subl $0x109, %eax            # imm = 0x109
je 0x6fdb
jmp 0x6fe4
movl $0x1, -0x4(%rbp)
jmp 0x6feb
movl $0x0, -0x4(%rbp)
jmp 0x6feb
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: addSibling
TreeNode*
addSibling(TreeNode *origin, TreeNode *follow)
{
  if (origin != NULL) {
    TreeNode *t = origin;
    while (t->sibling != NULL) t = t->sibling;
    t->sibling = follow;
  }
  else {
    origin = follow;
  }
  return origin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x773f
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7732
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x771b
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x7747
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: allocateTreeNode
TreeNode*
allocateTreeNode(void)
{
  TreeNode *t = calloc(1, sizeof(TreeNode));
  if (t == NULL)
    {
      fprintf(listing,
              "Out of memory error at line %d\n",
              lineno);
    }
  else
    {
      t->sibling = NULL;
      t->lineno = lineno;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x40, %esi
callq 0x1100
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7795
leaq 0x6a97(%rip), %rax      # 0xe210
movq (%rax), %rdi
leaq 0x6a75(%rip), %rax      # 0xe1f8
movl (%rax), %edx
leaq 0x3597(%rip), %rsi      # 0xad23
movb $0x0, %al
callq 0x1120
jmp 0x77b0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
leaq 0x6a51(%rip), %rax      # 0xe1f8
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newVariableDeclarationNode
TreeNode*
newVariableDeclarationNode(TreeNode *type_specifier,
                           TreeNode *_var)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = VariableDeclarationK;
      t->attr.varDecl.type_spec = type_specifier;
      t->attr.varDecl._var = _var;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x7750
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7803
movq -0x18(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newArrayDeclarationNode
TreeNode*
newArrayDeclarationNode(TreeNode *type_specifier,
                        TreeNode *_var,
                        TreeNode *_num)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = ArrayDeclarationK;
      t->attr.arrDecl.type_spec = type_specifier;
      t->attr.arrDecl._var = _var;
      t->attr.arrDecl._num = _num;

    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x7750
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7863
movq -0x20(%rbp), %rax
movl $0x2, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newFunctionDeclarationNode
TreeNode*
newFunctionDeclarationNode(TreeNode *type_specifier,
                           TreeNode *_var,
                           TreeNode *params,
                           TreeNode *compound_stmt)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = FunctionDeclarationK;
      t->attr.funcDecl.type_spec = type_specifier;
      t->attr.funcDecl._var = _var;
      t->attr.funcDecl.params = params;
      t->attr.funcDecl.cmpd_stmt = compound_stmt;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x7750
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x78d3
movq -0x28(%rbp), %rax
movl $0x3, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newVariableParameterNode
TreeNode*
newVariableParameterNode(TreeNode *type_specifier,
                         TreeNode *_var)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = VariableParameterK;
      t->attr.varParam.type_spec = type_specifier;
      t->attr.varParam._var = _var;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x7750
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7923
movq -0x18(%rbp), %rax
movl $0x4, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newCompoundStatementNode
TreeNode*
newCompoundStatementNode(TreeNode *local_declarations, // nullable
                         TreeNode *statement_list) // nullable
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = CompoundStatementK;
      t->attr.cmpdStmt.local_decl = local_declarations;
      t->attr.cmpdStmt.stmt_list = statement_list;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x7750
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x79c3
movq -0x18(%rbp), %rax
movl $0x6, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newExpressionStatementNode
TreeNode*
newExpressionStatementNode(TreeNode *expression) // nullable
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = ExpressionStatementK;
      t->attr.exprStmt.expr = expression;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x7750
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7a03
movq -0x10(%rbp), %rax
movl $0x7, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newReturnStatementNode
TreeNode*
newReturnStatementNode(TreeNode *expression) // nullable
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = ReturnStatementK;
      t->attr.retStmt.expr = expression;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x7750
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7af3
movq -0x10(%rbp), %rax
movl $0xa, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newAssignExpressionNode
TreeNode*
newAssignExpressionNode(TreeNode *var,
                        TreeNode *expression)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = AssignExpressionK;
      t->attr.assignStmt._var = var;
      t->attr.assignStmt.expr = expression;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x7750
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7b43
movq -0x18(%rbp), %rax
movl $0xb, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newAdditiveExpressionNode
TreeNode*
newAdditiveExpressionNode(TreeNode *left_expression,
                          TreeNode *addop,
                          TreeNode *right_expression)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = AdditiveExpressionK;
      t->attr.addExpr.lexpr = left_expression;
      t->attr.addExpr.op = addop;
      t->attr.addExpr.rexpr = right_expression;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x7750
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7c03
movq -0x20(%rbp), %rax
movl $0xd, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newMultiplicativeExpressionNode
TreeNode*
newMultiplicativeExpressionNode(TreeNode *left_expression,
                                TreeNode *mulop,
                                TreeNode *right_expression)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = MultiplicativeExpressionK;
      t->attr.multExpr.lexpr = left_expression;
      t->attr.multExpr.op = mulop;
      t->attr.multExpr.rexpr = right_expression;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x7750
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7c63
movq -0x20(%rbp), %rax
movl $0xe, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newCallNode
TreeNode*
newCallNode(TreeNode *_var,
            TreeNode *args) // nullable
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = CallK;
      t->attr.call._var = _var;
      t->attr.call.expr_list = args;
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x7750
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7d03
movq -0x18(%rbp), %rax
movl $0x11, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newVariableNode
TreeNode *
newVariableNode(char *_ID)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = VariableK;
      t->attr.ID = copyString(_ID);
    }
  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x7750
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7d4b
movq -0x10(%rbp), %rax
movl $0xf, 0xc(%rax)
movq -0x8(%rbp), %rdi
callq 0x7d60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: copyString
char*
copyString(char * s)
{
  size_t n;
  char * t;
  if (s==NULL) return NULL;
  n = strlen(s)+1;
  MALLOC(t, n);
  strcpy(t,s);
  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7d80
movq $0x0, -0x8(%rbp)
jmp 0x7e06
movq -0x10(%rbp), %rdi
callq 0x10b0
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7def
leaq 0x6464(%rip), %rax      # 0xe210
movq (%rax), %rdi
leaq 0x160b(%rip), %rsi      # 0x93c1
leaq 0x2f86(%rip), %rdx      # 0xad43
movl $0x1df, %ecx            # imm = 0x1DF
leaq 0x2f81(%rip), %r8       # 0xad4a
movb $0x0, %al
callq 0x1120
leaq 0x1624(%rip), %rdi      # 0x93fb
leaq 0x2f65(%rip), %rsi      # 0xad43
movl $0x1df, %edx            # imm = 0x1DF
leaq 0x2f6b(%rip), %rcx      # 0xad55
callq 0x10e0
jmp 0x7df1
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1060
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newConstantNode
TreeNode *
newConstantNode(char *_NUM)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = ConstantK;
      t->attr.NUM = atoi(_NUM);
    }

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x7750
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7e49
movq -0x10(%rbp), %rax
movl $0x12, 0xc(%rax)
movq -0x8(%rbp), %rdi
callq 0x11a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: newTokenTypeNode
TreeNode *
newTokenTypeNode(TokenType token)
{
  TreeNode * t = allocateTreeNode();
  if (t != NULL)
    {
      t->nodeKind = TokenTypeK;
      t->attr.TOK = token;
    }

  return t;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x7750
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7e90
movq -0x10(%rbp), %rax
movl $0x13, 0xc(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/util.c
// Function: operatorString
static const char *
operatorString(TokenType op)
{
  if(op == INT) return "int";
  if(op == VOID) return "void";

  if(op == PLUS) return "+";
  if(op == MINUS) return "-";
  if(op == TIMES) return "*";
  if(op == OVER) return "/";

  if(op == LT) return "<";
  if(op == LE) return "<=";
  if(op == GT) return ">";
  if(op == GE) return ">=";
  if(op == EQ) return "==";
  if(op == NE) return "!=";

  return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
cmpl $0x107, -0xc(%rbp)      # imm = 0x107
jne 0x8710
leaq 0x2424(%rip), %rax      # 0xab2b
movq %rax, -0x8(%rbp)
jmp 0x881c
cmpl $0x109, -0xc(%rbp)      # imm = 0x109
jne 0x8729
leaq 0xe84(%rip), %rax       # 0x95a4
movq %rax, -0x8(%rbp)
jmp 0x881c
cmpl $0x10b, -0xc(%rbp)      # imm = 0x10B
jne 0x8742
leaq 0x2a1f(%rip), %rax      # 0xb158
movq %rax, -0x8(%rbp)
jmp 0x881c
cmpl $0x10c, -0xc(%rbp)      # imm = 0x10C
jne 0x875b
leaq 0x2a08(%rip), %rax      # 0xb15a
movq %rax, -0x8(%rbp)
jmp 0x881c
cmpl $0x10d, -0xc(%rbp)      # imm = 0x10D
jne 0x8774
leaq 0x29f1(%rip), %rax      # 0xb15c
movq %rax, -0x8(%rbp)
jmp 0x881c
cmpl $0x10e, -0xc(%rbp)      # imm = 0x10E
jne 0x878d
leaq 0x29da(%rip), %rax      # 0xb15e
movq %rax, -0x8(%rbp)
jmp 0x881c
cmpl $0x10f, -0xc(%rbp)      # imm = 0x10F
jne 0x87a3
leaq 0x29c3(%rip), %rax      # 0xb160
movq %rax, -0x8(%rbp)
jmp 0x881c
cmpl $0x110, -0xc(%rbp)      # imm = 0x110
jne 0x87b9
leaq 0x29af(%rip), %rax      # 0xb162
movq %rax, -0x8(%rbp)
jmp 0x881c
cmpl $0x111, -0xc(%rbp)      # imm = 0x111
jne 0x87cf
leaq 0x299c(%rip), %rax      # 0xb165
movq %rax, -0x8(%rbp)
jmp 0x881c
cmpl $0x112, -0xc(%rbp)      # imm = 0x112
jne 0x87e5
leaq 0x2988(%rip), %rax      # 0xb167
movq %rax, -0x8(%rbp)
jmp 0x881c
cmpl $0x113, -0xc(%rbp)      # imm = 0x113
jne 0x87fb
leaq 0x2975(%rip), %rax      # 0xb16a
movq %rax, -0x8(%rbp)
jmp 0x881c
cmpl $0x114, -0xc(%rbp)      # imm = 0x114
jne 0x8811
leaq 0x2962(%rip), %rax      # 0xb16d
movq %rax, -0x8(%rbp)
jmp 0x881c
leaq 0x1a3e(%rip), %rax      # 0xa256
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cl_scan.c
// Function: citrusleaf_scan
extern cl_rv
citrusleaf_scan(cl_cluster *asc, char *ns, char *set, cl_bin *bins, int n_bins, bool get_key, citrusleaf_get_many_cb cb, void *udata, bool nobindata)
{
	if (n_bins != 0) {
		cf_error("citrusleaf get many: does not yet support bin-specific requests");
	}

	uint info=0;
	if (nobindata == true) {
		info = (CL_MSG_INFO1_READ | CL_MSG_INFO1_NOBINDATA);
	} else {
		info = CL_MSG_INFO1_READ; 
	}

	return( do_scan_monte( asc, NULL, info, 0, ns, set, bins,n_bins, 100, cb, udata, NULL ) );
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movl %r9d, %eax
movq %rcx, 0x38(%rsp)
movq %rdx, %rcx
movq 0x38(%rsp), %rdx
movq %rcx, 0x40(%rsp)
movq %rsi, %rcx
movq 0x40(%rsp), %rsi
movq %rcx, 0x48(%rsp)
movq %rdi, %r9
movq 0x48(%rsp), %rdi
movb %al, %cl
movb 0xa0(%rsp), %al
movq 0x98(%rsp), %r10
movq 0x90(%rsp), %r10
movq %r9, 0x78(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %r8d, 0x5c(%rsp)
andb $0x1, %cl
movb %cl, 0x5b(%rsp)
andb $0x1, %al
movb %al, 0x5a(%rsp)
cmpl $0x0, 0x5c(%rsp)
je 0x11de0
movq 0x11209(%rip), %rax     # 0x22fc8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x11dde
movq 0x111d2(%rip), %rax     # 0x22fa0
movq (%rax), %rcx
xorl %edi, %edi
leaq 0xbc6d(%rip), %rsi      # 0x1da47
movb $0x0, %al
callq *%rcx
jmp 0x11de0
movl $0x0, 0x54(%rsp)
movb 0x5a(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x11e00
movl $0x21, 0x54(%rsp)
jmp 0x11e08
movl $0x1, 0x54(%rsp)
movq 0x78(%rsp), %rdi
movl 0x54(%rsp), %edx
movq 0x70(%rsp), %r8
movq 0x68(%rsp), %r9
movq 0x60(%rsp), %rbx
movl 0x5c(%rsp), %r11d
movq 0x90(%rsp), %r10
movq 0x98(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %ecx, %ecx
movq %rbx, (%rsp)
movl %r11d, 0x8(%rsp)
movl $0x64, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
callq 0x11e70
addq $0x80, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cl_scan.c
// Function: citrusleaf_scan_node
extern cl_rv
citrusleaf_scan_node (cl_cluster *asc, char *node_name, char *ns, char *set, cl_bin *bins, int n_bins, bool nobindata, uint8_t scan_pct,
		citrusleaf_get_many_cb cb, void *udata, cl_scan_parameters *scan_param)
{

	if (n_bins != 0) {
		cf_error("citrusleaf get many: does not yet support bin-specific requests");
	}

	uint info=0;
	if (nobindata == true) {
		info = (CL_MSG_INFO1_READ | CL_MSG_INFO1_NOBINDATA);
	} else {
		info = CL_MSG_INFO1_READ; 
	}

	cl_scan_parameters default_scan_param;
	if (scan_param == NULL) {
		cl_scan_parameters_set_default(&default_scan_param);
		scan_param = &default_scan_param;
	}
		
	return( do_scan_monte( asc, node_name, info, 0, ns, set, bins, n_bins, scan_pct, cb, udata, scan_param ) ); 
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movb 0x98(%rsp), %al
movb 0x90(%rsp), %al
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movl %r9d, 0x44(%rsp)
andb $0x1, %al
movb %al, 0x43(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x12a51
movq 0x10598(%rip), %rax     # 0x22fc8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x12a4f
movq 0x10561(%rip), %rax     # 0x22fa0
movq (%rax), %rcx
xorl %edi, %edi
leaq 0xaffc(%rip), %rsi      # 0x1da47
movb $0x0, %al
callq *%rcx
jmp 0x12a51
movl $0x0, 0x3c(%rsp)
movb 0x43(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x12a71
movl $0x21, 0x3c(%rsp)
jmp 0x12a79
movl $0x1, 0x3c(%rsp)
cmpq $0x0, 0xb0(%rsp)
jne 0x12a9b
leaq 0x30(%rsp), %rdi
callq 0x12b10
leaq 0x30(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movl 0x3c(%rsp), %edx
movq 0x58(%rsp), %r8
movq 0x50(%rsp), %r9
movq 0x48(%rsp), %r14
movl 0x44(%rsp), %ebp
movb 0x98(%rsp), %bl
movq 0xa0(%rsp), %r11
movq 0xa8(%rsp), %r10
movq 0xb0(%rsp), %rax
xorl %ecx, %ecx
movq %r14, (%rsp)
movl %ebp, 0x8(%rsp)
movzbl %bl, %ebx
movl %ebx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x11e70
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/../include/citrusleaf/citrusleaf.h
// Function: cl_scan_parameters_set_default
static inline void
cl_scan_parameters_set_default(cl_scan_parameters *cl_scan_p)
{
	cl_scan_p->fail_on_cluster_change = false;
	cl_scan_p->concurrent_nodes = false;
	cl_scan_p->threads_per_node = 1;	// not honored currently
	cl_scan_p->priority = CL_SCAN_PRIORITY_AUTO;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, (%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movb $0x1, 0x9(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x4(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_average.c
// Function: cf_average_create
cf_average *
cf_average_create(uint32_t initial_size, uint32_t flags)
{
	cf_average *a;

	a = (cf_average*)malloc(sizeof(cf_average) + (sizeof(uint64_t) * initial_size) );
	if (!a)	return(0);
	
	a->flags = flags;
	a->n_points = 0;
	a->points_sum = 0;

	return(a);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
movl %esi, 0x8(%rsp)
movl 0xc(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
addq $0x10, %rdi
callq 0x6720
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x15fe5
movq $0x0, 0x10(%rsp)
jmp 0x1600f
movl 0x8(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq (%rsp), %rax
movl $0x0, 0x4(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_average.c
// Function: cf_average_add
int
cf_average_add(cf_average *a, uint64_t value)
{

	int rv = 0;
	
	a->points_sum += value;
	a->n_points++;
	
	return(rv);
	
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_average.c
// Function: cf_average_calculate
double
cf_average_calculate(cf_average *a, bool clear)
{

	
	if (a->n_points == 0) {
		return(0.0);
	}
	
	double avg = ((double)a->points_sum) / ((double)a->n_points);

	if (clear) 	{
		a->n_points = 0;
		a->points_sum = 0;
	}
	
	return(avg);
}

// Assembly:
movb %sil, %al
movq %rdi, -0x10(%rsp)
andb $0x1, %al
movb %al, -0x11(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x160b4
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x1611e
movq -0x10(%rsp), %rax
movq 0x8(%rax), %xmm0
movaps 0x816b(%rip), %xmm1     # 0x1e230
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x816f(%rip), %xmm1     # 0x1e240
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movl 0x4(%rax), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rsp)
testb $0x1, -0x11(%rsp)
je 0x16112
movq -0x10(%rsp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movsd -0x20(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_hist.c
// Function: cf_bits_find_last_set
int
cf_bits_find_last_set(uint32_t v)
{

	int r;
	uint32_t t, tt;
	
	if ((tt = v >> 16))
		r = (t = tt >> 8) ? (24 + cf_LogTable256[t]) : (16 + cf_LogTable256[tt]);
	else
		r = (t = v >> 8) ? (8 + cf_LogTable256[t]) : cf_LogTable256[v];
	return (r);
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
movl %eax, -0x10(%rsp)
cmpl $0x0, %eax
je 0x163b0
movl -0x10(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, %eax
je 0x1638e
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x7f0f(%rip), %rax      # 0x1e290
movsbl (%rax,%rcx), %eax
addl $0x18, %eax
movl %eax, -0x14(%rsp)
jmp 0x163a6
movl -0x10(%rsp), %eax
movl %eax, %ecx
leaq 0x7ef5(%rip), %rax      # 0x1e290
movsbl (%rax,%rcx), %eax
addl $0x10, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x8(%rsp)
jmp 0x163f7
movl -0x4(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, %eax
je 0x163da
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x7ec3(%rip), %rax      # 0x1e290
movsbl (%rax,%rcx), %eax
addl $0x8, %eax
movl %eax, -0x18(%rsp)
jmp 0x163ef
movl -0x4(%rsp), %eax
movl %eax, %ecx
leaq 0x7ea9(%rip), %rax      # 0x1e290
movsbl (%rax,%rcx), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nopl (%rax)