LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lvandeve[P]lodepng/lodepng_benchmark.cpp
// Function: assertTrue(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assertTrue(bool value, const std::string& message = "") {
  if(!value) {
    std::cout << "Error: expected true." << std::endl;
    std::cout << "Message: " << message << std::endl;
    std::exit(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
testb $0x1, -0x1(%rbp)
jne 0x1af44
movq 0xf0e7(%rip), %rdi      # 0x29fd8
leaq 0x8b48(%rip), %rsi      # 0x23a40
callq 0x2150
movq %rax, %rdi
movq 0xf0b9(%rip), %rsi      # 0x29fc0
callq 0x21a0
movq 0xf0c5(%rip), %rdi      # 0x29fd8
leaq 0x8b3c(%rip), %rsi      # 0x23a56
callq 0x2150
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2120
movq %rax, %rdi
movq 0xf08b(%rip), %rsi      # 0x29fc0
callq 0x21a0
movl $0x1, %edi
callq 0x2200
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lvandeve[P]lodepng/lodepng_benchmark.cpp
// Function: getFilePart(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string getFilePart(const std::string& path) {
  if(path.empty()) return "";
  int slash = path.size() - 1;
  while(slash >= 0 && path[(size_t)slash] != '/') slash--;
  return path.substr((size_t)(slash + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22d0
testb $0x1, %al
jne 0x1be0a
jmp 0x1be4f
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2300
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x8030(%rip), %rsi      # 0x23e56
callq 0x2250
jmp 0x1be2d
leaq -0x11(%rbp), %rdi
callq 0x21b0
jmp 0x1beb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x21b0
jmp 0x1bebe
movq -0x10(%rbp), %rdi
callq 0x20e0
subq $0x1, %rax
movl %eax, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x28(%rbp)
movb %al, -0x41(%rbp)
jl 0x1be83
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x21c0
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1be8c
jmp 0x1be97
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1be5f
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x28(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq $-0x1, %rcx
callq 0x2190
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22f0
nopw (%rax,%rax)
// File: lvandeve[P]lodepng/lodepng_benchmark.cpp
// Function: showHelp(int, char**)
void showHelp(int argc, char *argv[]) {
  (void)argc;
  std::cout << "Usage: " << argv[0] << " png_filenames... [OPTIONS...] [--dumpdir directory]" << std::endl;
  std::cout << "Options:" << std::endl;
  std::cout << "  -h: show this help" << std::endl;
  std::cout << "  -v: verbose" << std::endl;
  std::cout << "  -d: decode only" << std::endl;
  std::cout << "  -e: encode only" << std::endl;
  std::cout << "  -o: decode on original images rather than encoded ones (always true if -d without -e)" << std::endl;
  std::cout << "  -m: apply modifications to encoder and decoder settings, the modification itself must be implemented or changed in the benchmark source code (search for apply_mods in the code, for encode and for decode)" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xdb82(%rip), %rdi      # 0x29fd8
leaq 0x76ea(%rip), %rsi      # 0x23b47
callq 0x2150
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x76d4(%rip), %rsi      # 0x23b4f
callq 0x2150
movq %rax, %rdi
movq 0xdb36(%rip), %rsi      # 0x29fc0
callq 0x21a0
movq 0xdb42(%rip), %rdi      # 0x29fd8
leaq 0x76e7(%rip), %rsi      # 0x23b84
callq 0x2150
movq %rax, %rdi
movq 0xdb14(%rip), %rsi      # 0x29fc0
callq 0x21a0
movq 0xdb20(%rip), %rdi      # 0x29fd8
leaq 0x76ce(%rip), %rsi      # 0x23b8d
callq 0x2150
movq %rax, %rdi
movq 0xdaf2(%rip), %rsi      # 0x29fc0
callq 0x21a0
movq 0xdafe(%rip), %rdi      # 0x29fd8
leaq 0x76c1(%rip), %rsi      # 0x23ba2
callq 0x2150
movq %rax, %rdi
movq 0xdad0(%rip), %rsi      # 0x29fc0
callq 0x21a0
movq 0xdadc(%rip), %rdi      # 0x29fd8
leaq 0x76ad(%rip), %rsi      # 0x23bb0
callq 0x2150
movq %rax, %rdi
movq 0xdaae(%rip), %rsi      # 0x29fc0
callq 0x21a0
movq 0xdaba(%rip), %rdi      # 0x29fd8
leaq 0x769d(%rip), %rsi      # 0x23bc2
callq 0x2150
movq %rax, %rdi
movq 0xda8c(%rip), %rsi      # 0x29fc0
callq 0x21a0
movq 0xda98(%rip), %rdi      # 0x29fd8
leaq 0x768d(%rip), %rsi      # 0x23bd4
callq 0x2150
movq %rax, %rdi
movq 0xda6a(%rip), %rsi      # 0x29fc0
callq 0x21a0
movq 0xda76(%rip), %rdi      # 0x29fd8
leaq 0x76c3(%rip), %rsi      # 0x23c2c
callq 0x2150
movq %rax, %rdi
movq 0xda48(%rip), %rsi      # 0x29fc0
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lvandeve[P]lodepng/lodepng_benchmark.cpp
// Function: void assertEquals<int, unsigned int>(int const&, unsigned int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assertEquals(const T& expected, const U& actual, const std::string& message = "") {
  if(expected != (T)actual) {
    std::cout << "Error: Not equal! Expected " << expected << " got " << actual << "." << std::endl;
    std::cout << "Message: " << message << std::endl;
    std::exit(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x1d8aa
movq 0xc7bb(%rip), %rdi      # 0x29fd8
leaq 0x668d(%rip), %rsi      # 0x23eb1
callq 0x2150
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x22e0
movq %rax, %rdi
leaq 0x668c(%rip), %rsi      # 0x23ecd
callq 0x2150
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x2230
movq %rax, %rdi
leaq 0x61f6(%rip), %rsi      # 0x23a54
callq 0x2150
movq %rax, %rdi
movq 0xc753(%rip), %rsi      # 0x29fc0
callq 0x21a0
movq 0xc75f(%rip), %rdi      # 0x29fd8
leaq 0x61d6(%rip), %rsi      # 0x23a56
callq 0x2150
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2120
movq %rax, %rdi
movq 0xc725(%rip), %rsi      # 0x29fc0
callq 0x21a0
movl $0x1, %edi
callq 0x2200
addq $0x20, %rsp
popq %rbp
retq
// File: wenleix[P]EdgePPR/src/ParamGraph.cpp
// Function: ParamGraph::SetWeight(double*)
void ParamGraph::SetWeight(double param[7]) {
	for (int i = 0; i < numVertex; i++) {
		ParamVertex *v = GetVertex(i);
		for (int j = 0; j < v->outDeg; j++) {
			ParamEdge *e = &(v->outEdge[j]);
			int etype = e->GetIntEType();
			e->weight = param[etype] / v->outEdgeTypeCount[etype];
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x42a7
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3910
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x4297
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4460
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
cvtsi2sdl 0x40(%rax,%rcx,4), %xmm1
divsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4235
jmp 0x4299
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x420f
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: wenleix[P]EdgePPR/include/ParamGraph.h
// Function: ParamGraph::ParamGraph()
ParamGraph() {
    	numVertex = -1;
    	numEdge = -1;
    	vertexList = NULL;
    	edgeList = NULL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: wenleix[P]EdgePPR/src/PPRCommon.cpp
// Function: WriteVector(double*, int, char*, char*)
void WriteVector(double *pprValue, int size, char* filename, char* suffix) {
	char fullname[1000];
	sprintf(fullname, "%s.%s", filename, suffix);

	if (strcmp(suffix, "txt") == 0) {
		FILE *f = fopen(fullname, "w");
		fprintf(f, "%d\n", size);
		for (int i = 0; i < size; i++)
			fprintf(f, "%.8lf\n", pprValue[i]);
		fclose(f);
	} else if (strcmp(suffix, "bin") == 0) {
		FILE *f = fopen(fullname, "wb");
		fwrite(&size, sizeof(int), 1, f);
		fwrite(pprValue, sizeof(double), size, f);
		fclose(f);
	} else {
		assert(false);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x325c(%rip), %rsi      # 0x84cc
movb $0x0, %al
callq 0x2060
movq -0x20(%rbp), %rdi
leaq 0x2e73(%rip), %rsi      # 0x80f5
callq 0x2270
cmpl $0x0, %eax
jne 0x531e
leaq -0x410(%rbp), %rdi
leaq 0x32db(%rip), %rsi      # 0x8579
callq 0x2220
movq %rax, -0x418(%rbp)
movq -0x418(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x31bd(%rip), %rsi      # 0x8478
movb $0x0, %al
callq 0x2280
movl $0x0, -0x41c(%rbp)
movl -0x41c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x530d
movq -0x418(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x41c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x3286(%rip), %rsi      # 0x857b
movb $0x1, %al
callq 0x2280
movl -0x41c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x41c(%rbp)
jmp 0x52cc
movq -0x418(%rbp), %rdi
callq 0x2180
jmp 0x53af
movq -0x20(%rbp), %rdi
leaq 0x2dc8(%rip), %rsi      # 0x80f1
callq 0x2270
cmpl $0x0, %eax
jne 0x538e
leaq -0x410(%rbp), %rdi
leaq 0x3241(%rip), %rsi      # 0x8582
callq 0x2220
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rcx
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2360
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
movq -0x428(%rbp), %rcx
movl $0x8, %esi
callq 0x2360
movq -0x428(%rbp), %rdi
callq 0x2180
jmp 0x53ad
leaq 0x31de(%rip), %rdi      # 0x8573
leaq 0x3158(%rip), %rsi      # 0x84f4
movl $0xc5, %edx
leaq 0x31dd(%rip), %rcx      # 0x8585
callq 0x20f0
jmp 0x53af
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopl (%rax,%rax)
// File: wenleix[P]EdgePPR/src/PPRCommon.cpp
// Function: L1(double*, double*, int)
double L1(double *trueprv, double *estprv, int n) {
	double diff = 0.0, sum = 0.0;
	for (int i = 0; i < n; i++) {
		diff += fabs(trueprv[i] - estprv[i]);
		sum += trueprv[i];
	}

	return diff / sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x543f
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movaps 0x2fe1(%rip), %xmm1     # 0x83f0
pand %xmm1, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x53e6
movsd -0x20(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/lex.yy.cpp
// Function: yy_try_NUL_trans(int)
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 >= 76 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 75);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x68e2a(%rip), %rax     # 0x723d8
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x43adf(%rip), %rax     # 0x4d0a0
cmpw $0x0, (%rax,%rcx,2)
je 0x95dc
movl -0x4(%rbp), %eax
movl %eax, 0x68e13(%rip)     # 0x723e4
movq -0x10(%rbp), %rax
movq %rax, 0x68e0c(%rip)     # 0x723e8
jmp 0x95de
movslq -0x4(%rbp), %rcx
leaq 0x43c97(%rip), %rax     # 0x4d280
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x43b43(%rip), %rax     # 0x4d140
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x9633
movslq -0x4(%rbp), %rcx
leaq 0x43d0f(%rip), %rax     # 0x4d320
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x4c, -0x4(%rbp)
jl 0x9631
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x43d95(%rip), %rax     # 0x4d3c0
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x95de
movslq -0x4(%rbp), %rcx
leaq 0x43c42(%rip), %rax     # 0x4d280
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x43d9e(%rip), %rax     # 0x4d3f0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x4b, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x9675
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x967b
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: yyerror(char const*, int)
void yyerror(const char *msg, int lineno)
{
	has_err = true;
	++err_cnt;
	if (err_cnt > err_max)
	{
		fprintf(stderr, "Too many errors, aborted.\n");
		exit(1);
	}
	fprintf(stderr, "error happens near line %d: %s\n", lineno, msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x67dda(%rip), %rax     # 0x724b0
movb $0x1, (%rax)
movl 0x67d21(%rip), %eax     # 0x72400
addl $0x1, %eax
movl %eax, 0x67d18(%rip)     # 0x72400
cmpl $0x28, 0x67d11(%rip)    # 0x72400
jle 0xa713
movq 0x678e0(%rip), %rax     # 0x71fd8
movq (%rax), %rdi
leaq 0x433eb(%rip), %rsi     # 0x4daed
movb $0x0, %al
callq 0x54e0
movl $0x1, %edi
callq 0x5400
movq 0x678be(%rip), %rax     # 0x71fd8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rcx
leaq 0x433dd(%rip), %rsi     # 0x4db08
movb $0x0, %al
callq 0x54e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::str2op(char const*)
op_t str2op(const char *s)
{
	switch (s[0])
	{
	case '+': return ADD;
	case '-': return SUB;
	case '*': return MUL;
	case '/': return DIV;
	case '%': return MOD;
	case '&': return AND;
	case '|': return OR;
	case '<':
		if (s[1] == '=')
			return LE;
		return L;
	case '>':
		if (s[1] == '=')
			return GE;
		return G;
	case '!':
		if (s[1] == '=')
			return NE;
		return NOT;
	default: return NONE;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5b, %eax
ja 0xa85a
movq -0x18(%rbp), %rax
leaq 0x42fec(%rip), %rcx     # 0x4d798
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x7, -0x4(%rbp)
jmp 0xa861
movl $0x8, -0x4(%rbp)
jmp 0xa861
movl $0xa, -0x4(%rbp)
jmp 0xa861
movl $0xb, -0x4(%rbp)
jmp 0xa861
movl $0xc, -0x4(%rbp)
jmp 0xa861
movl $0xd, -0x4(%rbp)
jmp 0xa861
movl $0xe, -0x4(%rbp)
jmp 0xa861
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0xa813
movl $0x4, -0x4(%rbp)
jmp 0xa861
movl $0x6, -0x4(%rbp)
jmp 0xa861
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0xa832
movl $0x3, -0x4(%rbp)
jmp 0xa861
movl $0x5, -0x4(%rbp)
jmp 0xa861
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0xa851
movl $0x2, -0x4(%rbp)
jmp 0xa861
movl $0xf, -0x4(%rbp)
jmp 0xa861
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::str2dtype(char const*)
data_t str2dtype(const char *s)
{
	if (!strcmp(s, "int"))
		return INT;
	else if (!strcmp(s, "void"))
		return VOID;
	else
		return (data_t)-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x42437(%rip), %rsi     # 0x4ccbe
callq 0x54d0
cmpl $0x0, %eax
jne 0xa89a
movl $0x1, -0x4(%rbp)
jmp 0xa8bf
movq -0x10(%rbp), %rdi
leaq 0x43283(%rip), %rsi     # 0x4db28
callq 0x54d0
cmpl $0x0, %eax
jne 0xa8b8
movl $0x0, -0x4(%rbp)
jmp 0xa8bf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::str2num(char const*, int)
int str2num(const char *s, int base)
{
	int len = strlen(s);
	int val = 0;
	for (int i = 0; i < len; i++)
	{
		if (s[i] >= '0' && s[i] <= '9')
			val = val * base + (s[i] - '0');
		else if (s[i] >= 'a' && s[i] <= 'f')
			val = val * base + (s[i] - 'a') + 10;
		else if (s[i] >= 'A' && s[i] <= 'F')
			val = val * base + (s[i] - 'A') + 10;
		else
			return -1;
	}
	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5180
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xa9e8
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0xa947
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0xa947
movl -0x1c(%rbp), %eax
imull -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa9d8
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0xa989
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x66, %eax
jg 0xa989
movl -0x1c(%rbp), %eax
imull -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
subl $0x61, %ecx
addl %ecx, %eax
addl $0xa, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa9d6
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0xa9cb
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x46, %eax
jg 0xa9cb
movl -0x1c(%rbp), %eax
imull -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
subl $0x41, %ecx
addl %ecx, %eax
addl $0xa, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa9d4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa9ee
jmp 0xa9d6
jmp 0xa9d8
jmp 0xa9da
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xa8f9
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::vardef_node::set_shape(sysY_AST::exp_node*)
void vardef_node::set_shape(exp_node *first_dim)
{
	size = 1;
	if (is_pt)
		dim.push_back(0);
	while (first_dim)
	{
		first_dim->reduce();
		size_t temp = first_dim->num;
		if (first_dim->exp_type != EXP_NUM || first_dim->num <= 0)
		{
			yyerror("array size in delaration must be a positive constant int");
			temp = 1;
		}
		size *= temp;
		dim.push_back(temp);
		first_dim = first_dim->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, 0xa4(%rax)
testb $0x1, 0xa0(%rax)
je 0xafb3
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
movl $0x0, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x131f0
jmp 0xafb5
cmpq $0x0, -0x10(%rbp)
je 0xb04e
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x10(%rbp), %rax
movslq 0x94(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x98(%rax)
jne 0xaff3
movq -0x10(%rbp), %rax
cmpl $0x0, 0x94(%rax)
jg 0xb010
leaq 0x67376(%rip), %rax     # 0x72370
movl (%rax), %esi
leaq 0x42b52(%rip), %rdi     # 0x4db55
callq 0xa6c0
movq $0x1, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
movslq 0xa4(%rdi), %rax
imulq %rcx, %rax
movl %eax, 0xa4(%rdi)
addq $0x70, %rdi
movq -0x20(%rbp), %rax
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x131f0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xafb5
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::funcdef_node::funcdef_node(char const*, sysY_AST::data_t, sysY_AST::node_basic*)
funcdef_node::funcdef_node(
	const char *_name, data_t _ret_type, node_basic *_blk)
{
	blk = _blk;
	name = string(_name);
	dbg_printf("def a func named %s\n", _name);
	ret_type = _ret_type;
	add_ret(blk != nullptr);
	gen_code();
	temp_id = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x8720
movq -0x70(%rbp), %rdi
leaq 0x651b6(%rip), %rax     # 0x713d8
movq %rax, (%rdi)
addq $0x40, %rdi
movq %rdi, -0x80(%rbp)
callq 0x54c0
movq -0x70(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x78(%rbp)
callq 0x13a10
movq -0x70(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5620
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x8780
jmp 0xc277
movq -0x70(%rbp), %rdi
addq $0x40, %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0x88(%rbp)
callq 0x5410
movq -0x88(%rbp), %rdi
callq 0x56c0
leaq -0x41(%rbp), %rdi
callq 0x5370
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0x60(%rdi)
movq 0x68(%rdi), %rax
testq %rax, %rax
setne %al
movzbl %al, %esi
callq 0xc330
jmp 0xc2c2
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0xc2d0
movl $0x0, 0x6612e(%rip)     # 0x72408
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x5370
jmp 0xc306
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movq -0x78(%rbp), %rdi
callq 0x13a30
movq -0x80(%rbp), %rdi
callq 0x56c0
movq -0x70(%rbp), %rdi
callq 0x131c0
movq -0x50(%rbp), %rdi
callq 0x5610
nopw (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::funcdef_node::add_ret(bool)
void funcdef_node::add_ret(bool is_append)
{
	dbg_printf("add ret is_append: %d\n", is_append);
	now_func_name = name;
	auto has_ret_val = (func_table[name].ret_type == INT);
	ret_stmt_node *ret_stmt;
	if (has_ret_val)
		ret_stmt = new ret_stmt_node(new exp_node(EXP_NUM, "", 0));
	else
		ret_stmt = new ret_stmt_node(nullptr);
	if (is_append)
		blk->code += ret_stmt->code;
	else
		blk = ret_stmt;
	now_func_name = "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
addq $0x40, %rsi
leaq 0x6611e(%rip), %rdi     # 0x72478
callq 0x5050
movq -0x58(%rbp), %rsi
addq $0x40, %rsi
leaq 0x660d2(%rip), %rdi     # 0x72440
callq 0x13a90
cmpl $0x1, 0x50(%rax)
sete %al
andb $0x1, %al
movb %al, -0xa(%rbp)
testb $0x1, -0xa(%rbp)
je 0xc492
movl $0x48, %edi
callq 0x5300
movq %rax, -0x68(%rbp)
movb $0x1, -0x4b(%rbp)
movl $0xa0, %edi
callq 0x5300
movq %rax, -0x60(%rbp)
jmp 0xc3ab
movb $0x1, -0x4a(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5620
movq -0x70(%rbp), %rdx
leaq 0x42899(%rip), %rsi     # 0x4ec60
leaq -0x48(%rbp), %rdi
callq 0x8780
jmp 0xc3d2
movq -0x60(%rbp), %rdi
xorl %r8d, %r8d
movl %r8d, %r9d
movl $0x2, %esi
leaq -0x48(%rbp), %rdx
movl %r8d, %ecx
callq 0xef50
jmp 0xc3ef
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
movb $0x0, -0x4a(%rbp)
callq 0xeb30
jmp 0xc402
movq -0x68(%rbp), %rax
movb $0x0, -0x4b(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x56c0
leaq -0x49(%rbp), %rdi
callq 0x5370
jmp 0xc4d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xc477
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xc456
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x56c0
leaq -0x49(%rbp), %rdi
callq 0x5370
testb $0x1, -0x4a(%rbp)
jne 0xc467
jmp 0xc475
movq -0x60(%rbp), %rdi
movl $0xa0, %esi
callq 0x5320
jmp 0xc477
testb $0x1, -0x4b(%rbp)
jne 0xc47f
jmp 0xc48d
movq -0x68(%rbp), %rdi
movl $0x48, %esi
callq 0x5320
jmp 0xc520
movl $0x48, %edi
callq 0x5300
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xeb30
jmp 0xc4b1
movq -0x78(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xc4d7
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x5320
jmp 0xc520
testb $0x1, -0x9(%rbp)
je 0xc4f8
movq -0x58(%rbp), %rax
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
movq 0x68(%rax), %rdi
addq $0x18, %rdi
callq 0x5440
jmp 0xc504
movq -0x58(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x68(%rax)
leaq 0x65f6d(%rip), %rdi     # 0x72478
leaq 0x4274e(%rip), %rsi     # 0x4ec60
callq 0x54b0
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5610
nopl (%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::stmt_node::stmt_node(sysY_AST::node_basic*)
stmt_node::stmt_node(node_basic *_child)
{
	child = _child;
	if (blk_id == 1) // in the function
		last_stmt = this;
	gen_code();
	dbg_printf("create a stmt_node...\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x8720
movq -0x28(%rbp), %rax
leaq 0x64570(%rip), %rcx     # 0x713e8
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x6560a(%rip), %rax     # 0x72498
cmpl $0x1, (%rax)
jne 0xce9e
movq -0x28(%rbp), %rax
movq %rax, 0x65572(%rip)     # 0x72410
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0xceac
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x131c0
movq -0x18(%rbp), %rdi
callq 0x5610
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::assign_stmt_node::assign_stmt_node(sysY_AST::exp_node*, sysY_AST::exp_node*)
assign_stmt_node::assign_stmt_node(exp_node *_lval, exp_node *_assign_exp)
{
	lval = _lval;
	assign_exp = _assign_exp;
	if (lval->exp_type != EXP_ARRAY && lval->exp_type != EXP_VAR)
		yyerror("expression is not assignable");

	assign_exp->reduce();
	if (lval->exp_type == EXP_ARRAY)
		assign_exp->new_temp();
	gen_code();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xce50
movq -0x30(%rbp), %rax
leaq 0x64490(%rip), %rcx     # 0x71410
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq 0x40(%rax), %rax
cmpl $0x4, 0x98(%rax)
je 0xcfca
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x1, 0x98(%rax)
je 0xcfca
leaq 0x653b4(%rip), %rax     # 0x72370
movl (%rax), %esi
leaq 0x40c7d(%rip), %rdi     # 0x4dc42
callq 0xa6c0
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0xcfdd
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x4, 0x98(%rax)
jne 0xd01a
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xd001
jmp 0xd01a
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x13fe0
jmp 0xd02e
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0xd028
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5610
nopw (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::exp_stmt_node::gen_code()
void exp_stmt_node::gen_code()
{
	if (exp_stmt->exp_type == EXP_FUNC_CALL)
	{
		auto func_exp_stmt = static_cast<func_call_exp_node *>(exp_stmt);
		func_entry query;
		find_func(func_exp_stmt->sysy_func_name, query);
		if (query.ret_type == INT)
		{
			exp_stmt->new_temp();
			code = exp_stmt->code;
		}
		else
		{
			code = exp_stmt->code;
			code += "\t" + exp_stmt->eeyore_name + "\n";
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq 0x40(%rax), %rax
cmpl $0x3, 0x98(%rax)
jne 0xd3f6
movq -0xc0(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x13ac0
movq -0xc8(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0x1c5b0
jmp 0xd2d3
cmpl $0x1, -0x18(%rbp)
jne 0xd31f
movq -0xc0(%rbp), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xd2ef
movq -0xc0(%rbp), %rdi
movq 0x40(%rdi), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x5050
jmp 0xd309
jmp 0xd3e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xd3eb
movq -0xc0(%rbp), %rdi
movq 0x40(%rdi), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x5050
jmp 0xd339
movq -0xc0(%rbp), %rax
movq 0x40(%rax), %rdx
addq $0x70, %rdx
leaq 0x41910(%rip), %rsi     # 0x4ec5f
leaq -0xb8(%rbp), %rdi
callq 0x12d60
jmp 0xd35d
leaq 0x408dc(%rip), %rdx     # 0x4dc40
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x12d10
jmp 0xd379
movq -0xc0(%rbp), %rdi
addq $0x18, %rdi
leaq -0x98(%rbp), %rsi
callq 0x5440
jmp 0xd392
leaq -0x98(%rbp), %rdi
callq 0x56c0
leaq -0xb8(%rbp), %rdi
callq 0x56c0
jmp 0xd3e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xd3d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x56c0
leaq -0xb8(%rbp), %rdi
callq 0x56c0
jmp 0xd3eb
leaq -0x68(%rbp), %rdi
callq 0x13fa0
jmp 0xd3f6
leaq -0x68(%rbp), %rdi
callq 0x13fa0
jmp 0xd3ff
addq $0xd0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x5610
nopl (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::if_stmt_node::update(sysY_AST::cond_exp_node*, sysY_AST::node_basic*, sysY_AST::node_basic*)
void if_stmt_node::update(
	cond_exp_node *_cond, node_basic *_true_stmt, node_basic *_false_stmt)
{
	cond = _cond;
	true_stmt = _true_stmt;
	false_stmt = _false_stmt;
	has_else = (false_stmt != nullptr);
	if (!has_else)
	{
		cond->true_label = true_label = fall_label;
		cond->false_label = false_label = new_label();
	}
	else
	{
		cond->true_label = true_label = new_label();
		cond->false_label = false_label = new_label();
	}
	cond->traverse();
	gen_code();
	fall_label = old_fall_label;
}

// 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)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x50(%rax)
cmpq $0x0, 0x50(%rax)
setne %cl
andb $0x1, %cl
movb %cl, 0x64(%rax)
testb $0x1, 0x64(%rax)
jne 0xd4dd
movq -0x28(%rbp), %rax
movl 0x64f66(%rip), %ecx     # 0x7241c
movl %ecx, 0x58(%rax)
movq 0x40(%rax), %rax
movl %ecx, 0xb0(%rax)
callq 0xcef0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x5c(%rax)
movq 0x40(%rax), %rax
movl %ecx, 0xb4(%rax)
jmp 0xd50d
callq 0xcef0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x58(%rax)
movq 0x40(%rax), %rax
movl %ecx, 0xb0(%rax)
callq 0xcef0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x5c(%rax)
movq 0x40(%rax), %rax
movl %ecx, 0xb4(%rax)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0xd540
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x28(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, 0x64eec(%rip)     # 0x7241c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::while_stmt_node::while_stmt_node()
while_stmt_node::while_stmt_node()
{
	old_start_label = while_start_label;
	old_fall_label = fall_label;
	old_next_label = while_next_label;
	while_start_label = new_label();
	fall_label = new_label();
	while_next_label = new_label();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xce50
movq -0x10(%rbp), %rax
leaq 0x63010(%rip), %rcx     # 0x71488
addq $0x10, %rcx
movq %rcx, (%rax)
movl 0x63f9b(%rip), %ecx     # 0x72420
movl %ecx, 0x5c(%rax)
movl 0x63f8e(%rip), %ecx     # 0x7241c
movl %ecx, 0x54(%rax)
movl 0x63f8d(%rip), %ecx     # 0x72424
movl %ecx, 0x58(%rax)
callq 0xcef0
movl %eax, 0x63f7b(%rip)     # 0x72420
callq 0xcef0
movl %eax, 0x63f6c(%rip)     # 0x7241c
callq 0xcef0
movl %eax, 0x63f69(%rip)     # 0x72424
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::while_stmt_node::update(sysY_AST::cond_exp_node*, sysY_AST::node_basic*, sysY_AST::node_basic*)
void while_stmt_node::update(
	cond_exp_node *_cond, node_basic *_true_stmt, node_basic *_next_stmt)
{
	cond = _cond;
	true_stmt = _true_stmt;
	cond->true_label = true_label = fall_label;
	cond->false_label = while_next_label;
	cond->traverse();
	gen_code();
	fall_label = old_fall_label;
	while_start_label = old_start_label;
	while_next_label = old_next_label;
}

// 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)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x48(%rax)
movl 0x63f16(%rip), %edx     # 0x7241c
movl %edx, 0x50(%rax)
movq 0x40(%rax), %rcx
movl %edx, 0xb0(%rcx)
movl 0x63f0b(%rip), %edx     # 0x72424
movq 0x40(%rax), %rcx
movl %edx, 0xb4(%rcx)
movq 0x40(%rax), %rdi
callq 0xd540
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x28(%rbp), %rax
movl 0x54(%rax), %ecx
movl %ecx, 0x63eda(%rip)     # 0x7241c
movl 0x5c(%rax), %ecx
movl %ecx, 0x63ed5(%rip)     # 0x72420
movl 0x58(%rax), %eax
movl %eax, 0x63ed0(%rip)     # 0x72424
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::goto_stmt_node::gen_code()
void goto_stmt_node::gen_code()
{
	if (is_break)
		code = "\tgoto l" + to_string(while_next_label) + "\n";
	else
		code = "\tgoto l" + to_string(while_start_label) + "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
testb $0x1, 0x3c(%rax)
je 0xea4e
movl 0x63a7a(%rip), %esi     # 0x72424
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x13410
movq -0xe8(%rbp), %rdx
leaq 0x3f29a(%rip), %rsi     # 0x4dc62
leaq -0x48(%rbp), %rdi
callq 0x14000
jmp 0xe9d3
leaq 0x3f266(%rip), %rdx     # 0x4dc40
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x12d10
jmp 0xe9e9
movq -0xe0(%rbp), %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x5410
leaq -0x28(%rbp), %rdi
callq 0x56c0
leaq -0x48(%rbp), %rdi
callq 0x56c0
leaq -0x68(%rbp), %rdi
callq 0x56c0
jmp 0xeb10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xea40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x56c0
leaq -0x68(%rbp), %rdi
callq 0x56c0
jmp 0xeb19
movl 0x639cc(%rip), %esi     # 0x72420
leaq -0xd8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x13410
movq -0xf0(%rbp), %rdx
leaq 0x3f1ed(%rip), %rsi     # 0x4dc62
leaq -0xb8(%rbp), %rdi
callq 0x14000
jmp 0xea83
leaq 0x3f1b6(%rip), %rdx     # 0x4dc40
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x12d10
jmp 0xea9f
movq -0xe0(%rbp), %rdi
addq $0x18, %rdi
leaq -0x98(%rbp), %rsi
callq 0x5410
leaq -0x98(%rbp), %rdi
callq 0x56c0
leaq -0xb8(%rbp), %rdi
callq 0x56c0
leaq -0xd8(%rbp), %rdi
callq 0x56c0
jmp 0xeb10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xeb02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x56c0
leaq -0xd8(%rbp), %rdi
callq 0x56c0
jmp 0xeb19
addq $0xf0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x5610
nopw %cs:(%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::ret_stmt_node::gen_code()
void ret_stmt_node::gen_code()
{
	if (ret_val)
	{
		code = ret_val->code;
		code += "\treturn " + ret_val->eeyore_name + "\n";
		dbg_printf("gen_code in ret_stmt...ret_val:%s\n",
			ret_val->eeyore_name.c_str());
	}
	else
		code += "\treturn\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, 0x40(%rax)
je 0xef1f
movq -0x60(%rbp), %rdi
movq 0x40(%rdi), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x5050
movq -0x60(%rbp), %rax
movq 0x40(%rax), %rdx
addq $0x70, %rdx
leaq 0x3ee29(%rip), %rsi     # 0x4dcd0
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x12d60
movq -0x68(%rbp), %rsi
leaq 0x3ed81(%rip), %rdx     # 0x4dc40
leaq -0x28(%rbp), %rdi
callq 0x12d10
jmp 0xeeca
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x5440
jmp 0xeedd
leaq -0x28(%rbp), %rdi
callq 0x56c0
leaq -0x48(%rbp), %rdi
callq 0x56c0
jmp 0xef33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xef14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x56c0
leaq -0x48(%rbp), %rdi
callq 0x56c0
jmp 0xef39
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
leaq 0x3edab(%rip), %rsi     # 0x4dcd9
callq 0x52e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5610
nopw %cs:(%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::exp_node::exp_node(sysY_AST::exp_t, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, sysY_AST::op_t, sysY_AST::exp_node*)
exp_node::exp_node(exp_t _exp_type, const string &_sysy_name, int _num,
	op_t _op, exp_node *_child)
{
	exp_type = _exp_type;
	sysy_name = _sysy_name;
	child = _child;
	num = _num;
	op = _op;
	reduce();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x8720
movq -0x48(%rbp), %rdi
leaq 0x6258a(%rip), %rax     # 0x71510
movq %rax, (%rdi)
movq $0x0, 0x40(%rdi)
addq $0x50, %rdi
movq %rdi, -0x40(%rbp)
callq 0x54c0
movq -0x48(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x50(%rbp)
callq 0x54c0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movl $0x0, 0x90(%rax)
movl $0x0, 0x94(%rax)
movl $0x0, 0x9c(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x98(%rax)
movq -0x18(%rbp), %rsi
callq 0x5050
jmp 0xefe9
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, 0x48(%rdi)
movl -0x1c(%rbp), %eax
movl %eax, 0x94(%rdi)
movl -0x20(%rbp), %eax
movl %eax, 0x90(%rdi)
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0xf012
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x56c0
movq -0x40(%rbp), %rdi
callq 0x56c0
movq -0x48(%rbp), %rdi
callq 0x131c0
movq -0x30(%rbp), %rdi
callq 0x5610
nopl (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::exp_node::reduce()
void exp_node::reduce()
{
	if (exp_type == EXP_NUM)
	{
		eeyore_name = to_string(num);
		dbg_printf("eeyore_name in exp_node: %s\n", eeyore_name.c_str());
	}
	else if (exp_type == EXP_VAR)
	{
		var_entry query;
		find_var(sysy_name, query);
		eeyore_name = query.eeyore_name;
		if (query.is_const && query.dim.size() == 0) // a const
		{
			exp_type = EXP_NUM;
			eeyore_name = to_string(query.val[0]);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
cmpl $0x2, 0x98(%rax)
jne 0xf49b
movq -0xd8(%rbp), %rax
movl 0x94(%rax), %esi
leaq -0x28(%rbp), %rdi
callq 0x13410
movq -0xd8(%rbp), %rdi
addq $0x70, %rdi
leaq -0x28(%rbp), %rsi
callq 0x5410
leaq -0x28(%rbp), %rdi
callq 0x56c0
jmp 0xf595
movq -0xd8(%rbp), %rax
cmpl $0x1, 0x98(%rax)
jne 0xf593
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x13220
movq -0xd8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
addq $0x50, %rdi
callq 0x1c4c0
jmp 0xf4db
movq -0xd8(%rbp), %rdi
addq $0x70, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x5050
jmp 0xf4f4
testb $0x1, -0x5f(%rbp)
je 0xf587
leaq -0xa0(%rbp), %rdi
addq $0x48, %rdi
callq 0x12cf0
cmpq $0x0, %rax
jne 0xf587
movq -0xd8(%rbp), %rax
movl $0x2, 0x98(%rax)
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x136c0
movl (%rax), %esi
leaq -0xd0(%rbp), %rdi
callq 0x13410
jmp 0xf542
movq -0xd8(%rbp), %rdi
addq $0x70, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x5410
leaq -0xd0(%rbp), %rdi
callq 0x56c0
jmp 0xf587
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x13530
jmp 0xf59e
leaq -0xa0(%rbp), %rdi
callq 0x13530
jmp 0xf595
addq $0xe0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x5610
nopw (%rax,%rax)
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::arith_exp_node::arith_exp_node(sysY_AST::op_t, sysY_AST::exp_node*, sysY_AST::exp_node*)
arith_exp_node::arith_exp_node(op_t _op, exp_node *_left, exp_node *_right) :
	exp_node(EXP_TEMP, "", 0, _op), left(_left), right(_right)
{
	assert(op != NONE && op != AND && op != OR);
	if (!is_cond && op == NOT)
		yyerror("operator '!' should only appear in condition expression");
	if (left->exp_type == EXP_PTR || (right && right->exp_type == EXP_PTR))
		yyerror("pointer cannot be in an expression");
	reduce();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5620
movq -0x60(%rbp), %rdx
leaq 0x3e689(%rip), %rsi     # 0x4ec60
leaq -0x40(%rbp), %rdi
callq 0x8780
jmp 0x105e2
movq -0x68(%rbp), %rdi
movl -0xc(%rbp), %r8d
xorl %ecx, %ecx
movl %ecx, %r9d
leaq -0x40(%rbp), %rdx
movl %ecx, %esi
callq 0xef50
jmp 0x105fc
leaq -0x40(%rbp), %rdi
callq 0x56c0
leaq -0x41(%rbp), %rdi
callq 0x5370
movq -0x68(%rbp), %rax
leaq 0x60f47(%rip), %rcx     # 0x71560
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0xa0(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0xa8(%rax)
testb $0x1, 0x61dc7(%rip)     # 0x72404
jne 0x10691
movq -0x68(%rbp), %rax
cmpl $0xf, 0x90(%rax)
jne 0x10691
leaq 0x61d1d(%rip), %rax     # 0x72370
movl (%rax), %esi
leaq 0x3d6e5(%rip), %rdi     # 0x4dd41
callq 0xa6c0
jmp 0x10691
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x10686
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x56c0
leaq -0x41(%rbp), %rdi
callq 0x5370
jmp 0x10706
movq -0x68(%rbp), %rax
movq 0xa0(%rax), %rax
cmpl $0x6, 0x98(%rax)
je 0x106c7
movq -0x68(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x106dc
movq -0x68(%rbp), %rax
movq 0xa8(%rax), %rax
cmpl $0x6, 0x98(%rax)
jne 0x106dc
leaq 0x61ca2(%rip), %rax     # 0x72370
movl (%rax), %esi
leaq 0x3d6a2(%rip), %rdi     # 0x4dd79
callq 0xa6c0
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x106eb
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x14050
movq -0x50(%rbp), %rdi
callq 0x5610
nop
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::func_call_exp_node::check_ret_type(sysY_AST::exp_node*)
void func_call_exp_node::check_ret_type(exp_node *func_exp)
{
	if (func_exp->exp_type != EXP_FUNC_CALL) // not a function call
		return;
	auto func_call_exp = static_cast<func_call_exp_node *>(func_exp);
	func_entry query;
	find_func(func_call_exp->sysy_func_name, query);
	if (query.ret_type != INT)
	{
		string msg;
		msg = "function '" + func_call_exp->sysy_func_name +
			"' has no return value";
		yyerror(msg.c_str());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x98(%rax)
je 0x12471
jmp 0x12595
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x13ac0
movq -0xe0(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0x1c5b0
jmp 0x124a2
cmpl $0x1, -0x18(%rbp)
je 0x1258c
leaq -0x98(%rbp), %rdi
callq 0x54c0
movq -0x10(%rbp), %rdx
addq $0xb8, %rdx
leaq 0x3b7a9(%rip), %rsi     # 0x4dc73
leaq -0xd8(%rbp), %rdi
callq 0x12d60
jmp 0x124d8
leaq 0x3b975(%rip), %rdx     # 0x4de54
leaq -0xb8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x12d10
jmp 0x124f4
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x5410
leaq -0xb8(%rbp), %rdi
callq 0x56c0
leaq -0xd8(%rbp), %rdi
callq 0x56c0
leaq -0x98(%rbp), %rdi
callq 0x5160
movq %rax, %rdi
leaq 0x5fe3b(%rip), %rax     # 0x72370
movl (%rax), %esi
callq 0xa6c0
leaq -0x98(%rbp), %rdi
callq 0x56c0
jmp 0x1258c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1259e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1257e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x56c0
leaq -0x98(%rbp), %rdi
callq 0x56c0
jmp 0x1259e
leaq -0x68(%rbp), %rdi
callq 0x13fa0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x13fa0
movq -0x70(%rbp), %rdi
callq 0x5610
// File: lhydave[P]SysYCompilerLab/front/node.cpp
// Function: sysY_AST::func_call_exp_node::reduce()
void func_call_exp_node::reduce()
{
	if (!sysy_name.empty())
		return;
	for (auto i : params)
		code += i->code;
	dbg_printf("reduce size: %lu\n", params.size());
	for (auto i : params)
	{
		dbg_printf("real params: %s\n", i->eeyore_name.c_str());
		code += "\tparam " + i->eeyore_name + "\n";
	}
	eeyore_name = "call f_" + sysy_func_name;
	sysy_name = "?func_call";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
addq $0x50, %rdi
callq 0x55b0
testb $0x1, %al
jne 0x125dc
jmp 0x127aa
movq -0xc0(%rbp), %rax
addq $0xa0, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12f00
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12f30
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12f60
testb $0x1, %al
jne 0x1261a
jmp 0x1264d
leaq -0x18(%rbp), %rdi
callq 0x12fa0
movq -0xc0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x5440
leaq -0x18(%rbp), %rdi
callq 0x13030
jmp 0x12607
movq -0xc0(%rbp), %rax
addq $0xa0, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x12f00
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x12f30
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x12f60
testb $0x1, %al
jne 0x1268e
jmp 0x1274f
leaq -0x38(%rbp), %rdi
callq 0x12fa0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdx
addq $0x70, %rdx
leaq 0x3b7bd(%rip), %rsi     # 0x4de6a
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x12d60
movq -0xc8(%rbp), %rsi
leaq 0x3b572(%rip), %rdx     # 0x4dc40
leaq -0x68(%rbp), %rdi
callq 0x12d10
jmp 0x126d9
movq -0xc0(%rbp), %rdi
addq $0x18, %rdi
leaq -0x68(%rbp), %rsi
callq 0x5440
jmp 0x126ef
leaq -0x68(%rbp), %rdi
callq 0x56c0
leaq -0x88(%rbp), %rdi
callq 0x56c0
leaq -0x38(%rbp), %rdi
callq 0x13030
jmp 0x12678
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x12741
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x56c0
leaq -0x88(%rbp), %rdi
callq 0x56c0
jmp 0x127b3
movq -0xc0(%rbp), %rdx
addq $0xb8, %rdx
leaq -0xb8(%rbp), %rdi
leaq 0x3b715(%rip), %rsi     # 0x4de80
callq 0x12d60
movq -0xc0(%rbp), %rdi
addq $0x70, %rdi
leaq -0xb8(%rbp), %rsi
callq 0x5410
leaq -0xb8(%rbp), %rdi
callq 0x56c0
movq -0xc0(%rbp), %rdi
addq $0x50, %rdi
leaq 0x3b6cd(%rip), %rsi     # 0x4de72
callq 0x54b0
addq $0xd0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x5610
nop