LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2cy.tab.c
// Function: yytnamerr
static YYPTRDIFF_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      YYPTRDIFF_T yyn = 0;
      char const *yyp = yystr;
      for (;;)
        switch (*++yyp)
          {
          case '\'':
          case ',':
            goto do_not_strip_quotes;

          case '\\':
            if (*++yyp != '\\')
              goto do_not_strip_quotes;
            else
              goto append;

          append:
          default:
            if (yyres)
              yyres[yyn] = *yyp;
            yyn++;
            break;

          case '"':
            if (yyres)
              yyres[yyn] = '\0';
            return yyn;
          }
    do_not_strip_quotes: ;
    }

  if (yyres)
    return yystpcpy (yyres, yystr) - yyres;
  else
    return yystrlen (yystr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x142b4
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x28(%rbp)
movsbl 0x1(%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x22, %eax
je 0x14290
jmp 0x1422c
movl -0x2c(%rbp), %eax
subl $0x27, %eax
je 0x1424a
jmp 0x14236
movl -0x2c(%rbp), %eax
subl $0x2c, %eax
je 0x1424a
jmp 0x14240
movl -0x2c(%rbp), %eax
subl $0x5c, %eax
je 0x1424c
jmp 0x1426a
jmp 0x142b2
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl 0x1(%rax), %eax
cmpl $0x5c, %eax
je 0x14266
jmp 0x142b2
jmp 0x14268
jmp 0x1426a
cmpq $0x0, -0x10(%rbp)
je 0x14282
movq -0x28(%rbp), %rax
movb (%rax), %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x142ad
cmpq $0x0, -0x10(%rbp)
je 0x142a3
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x142e2
jmp 0x14210
jmp 0x142b4
cmpq $0x0, -0x10(%rbp)
je 0x142d5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14420
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x142e2
movq -0x18(%rbp), %rdi
callq 0x2090
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2cy.tab.c
// Function: yypcontext_expected_tokens
static int
yypcontext_expected_tokens (const yypcontext_t *yyctx,
                            yysymbol_kind_t yyarg[], int yyargn)
{
  /* Actual size of YYARG. */
  int yycount = 0;
  int yyn = yypact[+*yyctx->yyssp];
  if (!yypact_value_is_default (yyn))
    {
      /* Start YYX at -YYN if negative to avoid negative indexes in
         YYCHECK.  In other words, skip the first -YYN actions for
         this state because they are default actions.  */
      int yyxbegin = yyn < 0 ? -yyn : 0;
      /* Stay within bounds of both yycheck and yytname.  */
      int yychecklim = YYLAST - yyn + 1;
      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
      int yyx;
      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
        if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror
            && !yytable_value_is_error (yytable[yyx + yyn]))
          {
            if (!yyarg)
              ++yycount;
            else if (yycount == yyargn)
              return 0;
            else
              yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx);
          }
    }
  if (yyarg && yycount == 0 && 0 < yyargn)
    yyarg[0] = YYSYMBOL_YYEMPTY;
  return yycount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0x4016(%rip), %rax      # 0x18330
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $-0x3f, -0x24(%rbp)
je 0x143ef
cmpl $0x0, -0x24(%rbp)
jge 0x1433b
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x14342
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x14342
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x85, %eax
subl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x17, -0x2c(%rbp)
jge 0x14364
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x1436e
movl $0x17, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1436e
movl -0x3c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x143ed
movl -0x34(%rbp), %eax
addl -0x24(%rbp), %eax
movslq %eax, %rcx
leaq 0x412e(%rip), %rax      # 0x184c0
movsbl (%rax,%rcx), %eax
cmpl -0x34(%rbp), %eax
jne 0x143e0
cmpl $0x1, -0x34(%rbp)
je 0x143e0
cmpq $0x0, -0x18(%rbp)
jne 0x143b3
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x143de
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x143c4
movl $0x0, -0x4(%rbp)
jmp 0x14413
movl -0x34(%rbp), %edx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x143de
jmp 0x143e0
jmp 0x143e2
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1437a
jmp 0x143ef
cmpq $0x0, -0x18(%rbp)
je 0x1440d
cmpl $0x0, -0x20(%rbp)
jne 0x1440d
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
jge 0x1440d
movq -0x18(%rbp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2cy.tab.c
// Function: yystpcpy
static char *
yystpcpy (char *yydest, const char *yysrc)
{
  char *yyd = yydest;
  const char *yys = yysrc;

  while ((*yyd++ = *yys++) != '\0')
    continue;

  return yyd - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x14468
jmp 0x1443c
movq -0x18(%rbp), %rax
addq $-0x1, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/net/forward.c
// Function: open_udp_socket
int open_udp_socket(char *hostname, char *port){

	memset(&hints, 0, sizeof(struct addrinfo));
	hints.ai_family = AF_UNSPEC;    /* Allow IPv4 or IPv6 */
	hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
	hints.ai_flags = 0;
	hints.ai_protocol = 0;


	//Create the socket
	int error = getaddrinfo(hostname, port, &hints, &result);
	if(error != 0){
		perror("Failed to create socket");
		return -1;
	}

	for(rp = result; rp != NULL; rp = rp->ai_next){
		sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
		if(sock == -1)
			continue;

		if(connect(sock, rp->ai_addr, rp->ai_addrlen) == 0)
			break;                  /* Success */

		close(sock);

	}

	if(rp == NULL){
		perror("Bind failed");
		return -1;
	}

	freeaddrinfo(result);

	return 0;

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0x2e83(%rip), %rdi      # 0x4098
xorl %esi, %esi
movl $0x30, %edx
callq 0x1060
movl $0x0, 0x2e71(%rip)      # 0x409c
movl $0x2, 0x2e6b(%rip)      # 0x40a0
movl $0x0, 0x2e59(%rip)      # 0x4098
movl $0x0, 0x2e5b(%rip)      # 0x40a4
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x2e3e(%rip), %rdx      # 0x4098
leaq 0x2e67(%rip), %rcx      # 0x40c8
callq 0x10c0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x128a
leaq 0xd8c(%rip), %rdi       # 0x2004
callq 0x10a0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1353
movq 0x2e37(%rip), %rax      # 0x40c8
movq %rax, 0x2e38(%rip)      # 0x40d0
cmpq $0x0, 0x2e30(%rip)      # 0x40d0
je 0x131f
movq 0x2e27(%rip), %rax      # 0x40d0
movl 0x4(%rax), %edi
movq 0x2e1d(%rip), %rax      # 0x40d0
movl 0x8(%rax), %esi
movq 0x2e13(%rip), %rax      # 0x40d0
movl 0xc(%rax), %edx
callq 0x10f0
movl %eax, 0x2e0d(%rip)      # 0x40d8
cmpl $-0x1, 0x2e06(%rip)     # 0x40d8
jne 0x12d6
jmp 0x1308
movl 0x2dfc(%rip), %edi      # 0x40d8
movq 0x2ded(%rip), %rax      # 0x40d0
movq 0x18(%rax), %rsi
movq 0x2de2(%rip), %rax      # 0x40d0
movl 0x10(%rax), %edx
callq 0x10b0
cmpl $0x0, %eax
jne 0x12fd
jmp 0x131f
movl 0x2dd5(%rip), %edi      # 0x40d8
callq 0x1070
movq 0x2dc1(%rip), %rax      # 0x40d0
movq 0x28(%rax), %rax
movq %rax, 0x2db6(%rip)      # 0x40d0
jmp 0x1298
cmpq $0x0, 0x2da9(%rip)      # 0x40d0
jne 0x133f
leaq 0xcec(%rip), %rdi       # 0x201c
callq 0x10a0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1353
movq 0x2d82(%rip), %rdi      # 0x40c8
callq 0x10e0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/net/forward.c
// Function: send_data
int send_data(int len, char* data){

	//send the message to server
	int bytesSent = write(sock, data, len);
	if(bytesSent != len){
		perror("Mismatch in number of bytes sent");
		fprintf(stderr, "Send %d bytes\n", bytesSent);
		return -1;
	}

	return 0;

}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x2d55(%rip), %edi      # 0x40d8
movq 0x8(%rsp), %rsi
movslq 0x10(%rsp), %rdx
callq 0x1040
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x10(%rsp), %eax
je 0x13d2
leaq 0xc81(%rip), %rdi       # 0x2028
callq 0x10a0
movq 0x2c45(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl 0x4(%rsp), %edx
leaq 0xc88(%rip), %rsi       # 0x2049
movb $0x0, %al
callq 0x1080
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x13da
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/net/forward.c
// Function: main
int main(int argc, char **argv){

	if(argc < 3){
		printf("Usage: %s hostname port\n", argv[0]);
		return -1;
	}

	char buffer[1000];

	bool running = true;

	// Hostname, Port
	if(open_udp_socket(argv[1], argv[2]) == -1){
		perror("Error creating socket");
		return -1;
	}

	while(running){

		char len1, len2;
		len1 = getc(stdin);
		len2 = getc(stdin);

		if(feof(stdin)){
			printf("stdin closed\n");
			break;
		}

		unsigned short len;

		int count;

		len = (((unsigned char)len1)<<8) + ((unsigned char)len2);

		if(len > 1000){
			fprintf(stderr, "Buffer to small for packet!\n");
			break;
		}

		fread(buffer, sizeof(char), len, stdin);
		/*
		int i;
		for(i = 0; i < len; i++){
			int byte = getc(stdin);
			buffer[i] = (unsigned char)byte;
		}*/

		// Standard log
		fprintf(stdout, "Sending Packet Length: %d\n", ((int)len));

		if(send_data(len, buffer) == -1){
			fprintf(stderr, "Failed to send data to client via udp\n");
			break;
		}

	}

	close_udp_socket();

	return 0;

}

// Assembly:
subq $0x408, %rsp            # imm = 0x408
movl $0x0, 0x404(%rsp)
movl %edi, 0x400(%rsp)
movq %rsi, 0x3f8(%rsp)
cmpl $0x3, 0x400(%rsp)
jge 0x1444
movq 0x3f8(%rsp), %rax
movq (%rax), %rsi
leaq 0xc2b(%rip), %rdi       # 0x2058
movb $0x0, %al
callq 0x1050
movl $0xffffffff, 0x404(%rsp) # imm = 0xFFFFFFFF
jmp 0x159b
movb $0x1, 0xf(%rsp)
movq 0x3f8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x3f8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x1200
cmpl $-0x1, %eax
jne 0x1487
leaq 0xbff(%rip), %rdi       # 0x2071
callq 0x10a0
movl $0xffffffff, 0x404(%rsp) # imm = 0xFFFFFFFF
jmp 0x159b
jmp 0x1489
testb $0x1, 0xf(%rsp)
je 0x158b
movq 0x2b3d(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x10d0
movb %al, 0xe(%rsp)
movq 0x2b2a(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x10d0
movb %al, 0xd(%rsp)
movq 0x2b17(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1090
cmpl $0x0, %eax
je 0x14e1
leaq 0xbb2(%rip), %rdi       # 0x2087
movb $0x0, %al
callq 0x1050
jmp 0x158b
movzbl 0xe(%rsp), %eax
shll $0x8, %eax
movzbl 0xd(%rsp), %ecx
addl %ecx, %eax
movw %ax, 0xa(%rsp)
movzwl 0xa(%rsp), %eax
cmpl $0x3e8, %eax            # imm = 0x3E8
jle 0x151b
movq 0x2af0(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xb83(%rip), %rsi       # 0x2095
movb $0x0, %al
callq 0x1080
jmp 0x158b
leaq 0x10(%rsp), %rdi
movzwl 0xa(%rsp), %eax
movl %eax, %edx
movq 0x2aaa(%rip), %rax      # 0x3fd8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x1030
movq 0x2a8e(%rip), %rax      # 0x3fd0
movq (%rax), %rdi
movzwl 0xa(%rsp), %edx
leaq 0xb61(%rip), %rsi       # 0x20b2
movb $0x0, %al
callq 0x1080
movzwl 0xa(%rsp), %edi
leaq 0x10(%rsp), %rsi
callq 0x1370
cmpl $-0x1, %eax
jne 0x1586
movq 0x2a85(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xb50(%rip), %rsi       # 0x20cd
movb $0x0, %al
callq 0x1080
jmp 0x158b
jmp 0x1489
callq 0x1360
movl $0x0, 0x404(%rsp)
movl 0x404(%rsp), %eax
addq $0x408, %rsp            # imm = 0x408
retq
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/invtsc.c
// Function: main
int main(int argc, char **argv)
{
    benchmark_gettimeofday();
    benchmark_gettimeofday_fast();

    setup_tsc();
    benchmark_tsc();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x11b0
callq 0x1210
callq 0x13b0
callq 0x12e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/invtsc.c
// Function: benchmark_gettimeofday
static void benchmark_gettimeofday(void)
{
    uint64_t us_start;
    uint64_t us_end;
    uint64_t loops = 0;

    us_start = get_us_gettimeofday();
    us_end = us_start + 1000000ULL;

    while(get_us_gettimeofday() < us_end)
        loops++;

    printf("Timer loops finished with gettimeofday(): %ld\n", loops);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x18(%rbp)
callq 0x1340
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf4240, %rax          # imm = 0xF4240
movq %rax, -0x10(%rbp)
callq 0x1340
cmpq -0x10(%rbp), %rax
jae 0x11f0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11d7
movq -0x18(%rbp), %rsi
leaq 0xe09(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/invtsc.c
// Function: benchmark_gettimeofday_fast
static void benchmark_gettimeofday_fast(void)
{
    struct timeval tv_start;
    struct timeval tv_end;
    struct timeval tv;
    uint64_t loops = 0;

    assert(!gettimeofday(&tv_start, NULL));
    tv_end = tv_start;
    tv_end.tv_sec += 1;

    while(1) {
        assert(!gettimeofday(&tv, NULL));
        if ((tv.tv_sec >= tv_end.tv_sec) && (tv.tv_usec >= tv_end.tv_usec))
            break;

        loops++;
    }

    printf("Timer loops finished with optimized gettimeofday(): %ld\n", loops);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq $0x0, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1040
cmpl $0x0, %eax
jne 0x1234
jmp 0x1253
leaq 0xe3d(%rip), %rdi       # 0x2078
leaq 0xe0a(%rip), %rsi       # 0x204c
movl $0x17, %edx
leaq 0xe49(%rip), %rcx       # 0x2097
callq 0x1050
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1040
cmpl $0x0, %eax
jne 0x1283
jmp 0x12a2
leaq 0xda9(%rip), %rdi       # 0x2033
leaq 0xdbb(%rip), %rsi       # 0x204c
movl $0x1c, %edx
leaq 0xdfa(%rip), %rcx       # 0x2097
callq 0x1050
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x12b8
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jl 0x12b8
jmp 0x12c6
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x126f
movq -0x38(%rbp), %rsi
leaq 0xded(%rip), %rdi       # 0x20be
movb $0x0, %al
callq 0x1030
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/invtsc.c
// Function: benchmark_tsc
static void benchmark_tsc(void)
{
    uint64_t tsc_start;
    uint64_t tsc_end;
    uint64_t loops = 0;

    tsc_start = rdtsc();
    tsc_end = tsc_start + tsc_per_sec;

    while(rdtsc() < tsc_end)
        loops++;

    printf("Timer loops finished with TSC: %ld\n", loops);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x18(%rbp)
callq 0x1390
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x2d4c(%rip), %rcx      # 0x4050
addq (%rcx), %rax
movq %rax, -0x10(%rbp)
callq 0x1390
cmpq -0x10(%rbp), %rax
jae 0x1324
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x130b
movq -0x18(%rbp), %rsi
leaq 0xdc8(%rip), %rdi       # 0x20f7
movb $0x0, %al
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/tsc.c
// Function: setup_tsc
void setup_tsc(void)
{
    uint64_t before, after;
    uint64_t before_tod, after_tod;

    before_tod = get_us_gettimeofday();
    before = rdtsc();

    usleep(10);

    after_tod = get_us_gettimeofday();
    after = rdtsc();

    tsc_per_sec = ((after - before) * 1000000ULL) / (after_tod - before_tod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x1410
movq %rax, -0x18(%rbp)
callq 0x1460
movq %rax, -0x8(%rbp)
movl $0xa, %edi
callq 0x1060
callq 0x1410
movq %rax, -0x20(%rbp)
callq 0x1460
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq -0x8(%rbp), %rax
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
movq -0x20(%rbp), %rcx
subq -0x18(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, 0x2c47(%rip)      # 0x4050
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_create
void bst_create(BST *ptree) {
	printf("Data: \t  ");
	srand((unsigned) time(NULL ));
//	srand(100);
	int data[100];
	for (int i = 0; i < 100; i++) {
		data[i] = i;
	}
	for (int i = 0; i < 100; i++) {
		int j = rand() % 100;
		int tmp = data[i];
		data[i] = data[j];
		data[j] = tmp;
	}
	for (int i = 0; i < BST_MAX; ++i) {
		int x = data[i];
		bst_insert(x, ptree);
		printf("%3d ", x);
	}
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
leaq 0x1e2e(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
movl %eax, %edi
callq 0x1070
movl %eax, %edi
callq 0x1060
movl $0x0, -0x1a4(%rbp)
cmpl $0x64, -0x1a4(%rbp)
jge 0x1225
movl -0x1a4(%rbp), %ecx
movslq -0x1a4(%rbp), %rax
movl %ecx, -0x1a0(%rbp,%rax,4)
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a4(%rbp)
jmp 0x11f7
movl $0x0, -0x1a8(%rbp)
cmpl $0x64, -0x1a8(%rbp)
jge 0x12a0
callq 0x10b0
movl $0x64, %ecx
cltd
idivl %ecx
movl %edx, -0x1ac(%rbp)
movslq -0x1a8(%rbp), %rax
movl -0x1a0(%rbp,%rax,4), %eax
movl %eax, -0x1b0(%rbp)
movslq -0x1ac(%rbp), %rax
movl -0x1a0(%rbp,%rax,4), %ecx
movslq -0x1a8(%rbp), %rax
movl %ecx, -0x1a0(%rbp,%rax,4)
movl -0x1b0(%rbp), %ecx
movslq -0x1ac(%rbp), %rax
movl %ecx, -0x1a0(%rbp,%rax,4)
movl -0x1a8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a8(%rbp)
jmp 0x122f
movl $0x0, -0x1b4(%rbp)
cmpl $0xa, -0x1b4(%rbp)
jge 0x12fb
movslq -0x1b4(%rbp), %rax
movl -0x1a0(%rbp,%rax,4), %eax
movl %eax, -0x1b8(%rbp)
movl -0x1b8(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x1320
movl -0x1b8(%rbp), %esi
leaq 0x1d2b(%rip), %rdi      # 0x300e
movb $0x0, %al
callq 0x1040
movl -0x1b4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1b4(%rbp)
jmp 0x12aa
leaq 0x1f4a(%rip), %rdi      # 0x324c
movb $0x0, %al
callq 0x1040
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_insert
BST bst_insert(int value, BST *ptree) {
	assert(ptree!=NULL);

	if (*ptree == NULL ) {
		*ptree = makeNode(value);
//		printf("Insert \t%4d\n", (*ptree)->value, *ptree);
		return *ptree;
	}

	BST tree = *ptree;
	if (value < tree->value) {
		return bst_insert(value, &(tree->left));
	} else if (value > tree->value) {
		return bst_insert(value, &(tree->right));
	} else {
		return NULL ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1338
jmp 0x1357
leaq 0x1cd4(%rip), %rdi      # 0x3013
leaq 0x1cd9(%rip), %rsi      # 0x301f
movl $0x59, %edx
leaq 0x1cd3(%rip), %rcx      # 0x3025
callq 0x1050
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1380
movl -0xc(%rbp), %edi
callq 0x1450
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13d5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x13ac
movl -0xc(%rbp), %edi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x1320
movq %rax, -0x8(%rbp)
jmp 0x13d5
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x13cd
movl -0xc(%rbp), %edi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x1320
movq %rax, -0x8(%rbp)
jmp 0x13d5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_clear
void bst_clear(BST tree) {
	if (tree != NULL ) {
		bst_clear(tree->left);
		bst_clear(tree->right);
		free(tree);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1416
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x13e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x13e0
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: makeNode
static TreeNode* makeNode(int value) {
	TreeNode* node = (TreeNode*) malloc(sizeof(TreeNode));
	if (node != NULL ) {
		node->value = value;
		node->left = NULL;
		node->right = NULL;
		//printf("makeNode: %d [0x%x]\n", value, node);
	}
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x20, %edi
callq 0x1080
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1491
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_delete
TreeNode* bst_delete(int value, BST tree) {
	TreeNode *tmpNode;
	if (tree == NULL ) {
		return NULL;
	}
	if (value < tree->value) {
		tree->left = bst_delete(value, tree->left);
	} else if (value > tree->value) {
		tree->right = bst_delete(value, tree->right);
	} else if (tree->left && tree->right) {
		tmpNode = bst_findMin(tree->right);
		tree->value = tmpNode->value;
		tree->right = bst_delete(tree->value, tree->right);
	} else {
		tmpNode = tree;
		if (tree->left == NULL ) {
			tree = tree->right;
		} else if (tree->right == NULL ) {
			tree = tree->left;
		}
		free(tmpNode);
	}
	return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x14c3
movq $0x0, -0x8(%rbp)
jmp 0x15bb
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x14ee
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x14a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x15b3
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x1519
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x14a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x15b1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x156c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x156c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x15d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x14a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x15af
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x158d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x15a6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x15a4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x15a6
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x15b1
jmp 0x15b3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_findMin
TreeNode* bst_findMin(BST tree) {
	if (tree != NULL ) {
		while (tree->left != NULL ) {
			tree = tree->left;
		}
	}
	return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15fc
jmp 0x15e1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x15fa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x15e1
jmp 0x15fc
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_depth
int bst_depth(BST tree) {
	if (tree == NULL ) {
		return 0;
	}
	int lh, rh;
	lh = bst_depth(tree->left);
	rh = bst_depth(tree->right);
	return (lh > rh ? lh : rh) + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x162c
movl $0x0, -0x4(%rbp)
jmp 0x166b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1610
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1610
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x165c
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1662
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_search
TreeNode* bst_search(int value, BST tree) {
	if (tree == NULL ) {
		return NULL ;
	} else if (value == tree->value) {
		return tree;
	} else if (value < tree->value) {
		return bst_search(value, tree->left);
	} else {
		return bst_search(value, tree->right);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16f0
movq $0x0, -0x8(%rbp)
jmp 0x173a
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1705
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x173a
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1726
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x16d0
movq %rax, -0x8(%rbp)
jmp 0x173a
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x16d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_find
TreeNode* bst_find(int value, BST tree) {
//	return bst_search(value, tree);
	while (tree != NULL && value != tree->value) {
		if (value < tree->value) {
			tree = tree->left;
		} else {
			tree = tree->right;
		}
	}
	return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x1776
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x177f
jmp 0x17a6
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1798
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x17a4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x175b
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_successor
TreeNode* bst_successor(BST node) {
	assert(node!=NULL);
	if (node->right != NULL ) {
		return bst_findMin(node);
	}
	// 后继必须存在parent指针才能查找
	TreeNode* t = node->parent;
	while (t != NULL && node == t->right) {
		node = t;
		t = t->parent;
	}
	return t ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x17c5
jmp 0x17e4
leaq 0x1874(%rip), %rdi      # 0x3040
leaq 0x184c(%rip), %rsi      # 0x301f
movl $0xb5, %edx
leaq 0x186c(%rip), %rcx      # 0x304b
callq 0x1050
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x17fe
movq -0x10(%rbp), %rdi
callq 0x15d0
movq %rax, -0x8(%rbp)
jmp 0x184f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x1828
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1831
jmp 0x1847
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x180a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_findMax
TreeNode* bst_findMax(BST tree) {
	if (tree == NULL ) {
		return NULL ;
	}
	if (tree->right == NULL ) {
		return tree;
	} else {
		return bst_findMax(tree->right);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x187d
movq $0x0, -0x8(%rbp)
jmp 0x18a3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1892
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x18a3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1860
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_preOrder
void bst_preOrder(BST tree) {
	if (tree != NULL ) {
		show(tree);
		bst_preOrder(tree->left);
		bst_preOrder(tree->right);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x18e6
movq -0x8(%rbp), %rdi
callq 0x18f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x18b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x18b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_inOrder
void bst_inOrder(BST tree) {
	if (tree != NULL ) {
		bst_inOrder(tree->left);
		show(tree);
		bst_inOrder(tree->right);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1956
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1920
movq -0x8(%rbp), %rdi
callq 0x18f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1920
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_postOrder
void bst_postOrder(BST tree) {
	if (tree != NULL ) {
		bst_postOrder(tree->left);
		bst_postOrder(tree->right);
		show(tree);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1996
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1960
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1960
movq -0x8(%rbp), %rdi
callq 0x18f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_preOrderIter
void bst_preOrderIter(BST tree) {
	Stack s = stack_create(STATCK_MAX);
	while (tree != NULL || !stack_isEmpty(s)) {
		if (tree != NULL ) {
			show(tree);
			stack_push(tree, s);
			tree = tree->left;
		} else {
			tree = (BST) stack_top(s);
			stack_pop(s);
			tree = tree->right;
		}
	}
	stack_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x14, %edi
callq 0x1db0
movq %rax, -0x10(%rbp)
movb $0x1, %al
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
jne 0x19da
movq -0x10(%rbp), %rdi
callq 0x1ec0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x19e3
jmp 0x1a32
cmpq $0x0, -0x8(%rbp)
je 0x1a0e
movq -0x8(%rbp), %rdi
callq 0x18f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f50
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a30
movq -0x10(%rbp), %rdi
callq 0x1fb0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ee0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x19ba
movq -0x10(%rbp), %rdi
callq 0x1e30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_postOrderIter
void bst_postOrderIter(BST tree) {
	Stack s = stack_create(STATCK_MAX);
	BST p = tree;
	BST q = NULL;
	while (p != NULL || !stack_isEmpty(s))  //栈空时结束
	{
		while (p != NULL ) {
			stack_push(p, s);
			p = p->left;
		}
		p = stack_top(s);
		if (p->right == NULL || p->right == q) {
			show(p);
			q = stack_top(s);
			stack_pop(s);
			p = NULL;
		} else {
			p = p->right;
		}
	}
	stack_destroy(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x14, %edi
callq 0x1db0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
jne 0x1b4a
movq -0x10(%rbp), %rdi
callq 0x1ec0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1b56
jmp 0x1bda
jmp 0x1b58
cmpq $0x0, -0x18(%rbp)
je 0x1b7a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f50
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1b58
movq -0x10(%rbp), %rdi
callq 0x1fb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1ba0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x1bc9
movq -0x18(%rbp), %rdi
callq 0x18f0
movq -0x10(%rbp), %rdi
callq 0x1fb0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ee0
movq $0x0, -0x18(%rbp)
jmp 0x1bd5
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1b2a
movq -0x10(%rbp), %rdi
callq 0x1e30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: bst_levelOrderIter
void bst_levelOrderIter(BST tree) {
	assert(tree!=NULL);
	Queue queue = queue_create(STATCK_MAX);
	queue_enqueue(tree, queue);
	while (!queue_isEmpty(queue)) {
		BST p = queue_dequeue(queue);
		show(p);
		if (p->left != NULL ) {
			queue_enqueue(p->left, queue);
		}
		if (p->right != NULL ) {
			queue_enqueue(p->right, queue);
		}
	}
	queue_destroy(queue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c05
jmp 0x1c24
leaq 0x1408(%rip), %rdi      # 0x3014
leaq 0x140c(%rip), %rsi      # 0x301f
movl $0x12f, %edx            # imm = 0x12F
leaq 0x1449(%rip), %rcx      # 0x3068
callq 0x1050
movl $0x14, %edi
callq 0x2170
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2310
movq -0x10(%rbp), %rdi
callq 0x20d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1c56
jmp 0x1ca6
movq -0x10(%rbp), %rdi
callq 0x23b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x18f0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1c88
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2310
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1ca4
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2310
jmp 0x1c3f
movq -0x10(%rbp), %rdi
callq 0x21f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/bst.c
// Function: main
int main(int argc, char **argv) {
	// 强制刷新缓冲区
	setvbuf(stdout, 0, _IONBF, 0);
	BST tree=NULL;
	bst_create(&tree);
	printf("\nPreOrder Rec: ");
	bst_preOrder(tree);
	printf("\nPreOrder Cir: ");
	bst_preOrderIter(tree);
	printf("\n\nInOrder Rec:  ");
	bst_inOrder(tree);
	printf("\nInOrder Cir:  ");
	bst_inOrderIter(tree);
	printf("\n\nPostOrder Rec:");
	bst_postOrder(tree);
	printf("\nPostOrder Cir:");
	bst_postOrderIter(tree);
	printf("\nLevelOrder:   ");
	bst_levelOrderIter(tree);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3303(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %edx
movq %rcx, %rsi
callq 0x1090
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x11c0
leaq 0x137c(%rip), %rdi      # 0x3085
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x18b0
leaq 0x1375(%rip), %rdi      # 0x3095
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x19a0
leaq 0x136e(%rip), %rdi      # 0x30a5
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1920
leaq 0x1368(%rip), %rdi      # 0x30b6
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1a50
leaq 0x1361(%rip), %rdi      # 0x30c6
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1960
leaq 0x135b(%rip), %rdi      # 0x30d7
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1b00
leaq 0x1354(%rip), %rdi      # 0x30e7
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1bf0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/stack.c
// Function: stack_create
Stack stack_create(int size)
{
    Stack s;
    s=(Stack)malloc(sizeof(StackNode));
    if(s==NULL)
    {
        fatal("stack malloc failed.");
    }
    s->next=NULL;
    return s;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x1080
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1ddc
leaq 0x1320(%rip), %rdi      # 0x30f7
callq 0x1e00
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/stack.c
// Function: stack_push
void stack_push(void *data, Stack s)
{
	PStackNode newNode;
    newNode=(PStackNode)malloc(sizeof(StackNode));
    if(newNode==NULL)
    {
        fatal("new node malloc failed");
    }
    newNode->data=data;
    newNode->next=s->next;
    s->next=newNode;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x1080
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1f81
leaq 0x11ba(%rip), %rdi      # 0x3136
callq 0x1e00
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/stack.c
// Function: stack_print
void stack_print(Stack s){
    assert(s!=NULL);
    if(stack_isEmpty(s)){
        printf("stack is empty.\n");
        return;
    }
    
    printf("stack: ");
    PStackNode node=s->next;
    while(node!=NULL){
        printf("%d ", node->data);
        node=node->next;
    }
    printf("\n");
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2005
jmp 0x2024
leaq 0x1100(%rip), %rdi      # 0x310c
leaq 0x1101(%rip), %rsi      # 0x3114
movl $0x53, %edx
leaq 0x1150(%rip), %rcx      # 0x316f
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1ec0
cmpl $0x0, %eax
je 0x2042
leaq 0x114e(%rip), %rdi      # 0x3187
movb $0x0, %al
callq 0x1040
jmp 0x2094
leaq 0x114f(%rip), %rdi      # 0x3198
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2086
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x112f(%rip), %rdi      # 0x31a0
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x205c
leaq 0x11bf(%rip), %rdi      # 0x324c
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/queue.c
// Function: queue_clear
void queue_clear(Queue q) {
	assert(q!=NULL);
	q->size = 0;
	q->front = 1;
	q->end = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2125
jmp 0x2144
leaq 0x1088(%rip), %rdi      # 0x31b4
leaq 0x1089(%rip), %rsi      # 0x31bc
movl $0x19, %edx
leaq 0x1085(%rip), %rcx      # 0x31c4
callq 0x1050
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/queue.c
// Function: queue_create
Queue queue_create(int maxSize) {
	Queue q;
	q = (Queue) malloc(sizeof(struct QueueRecord));
	if (q == NULL ) {
		queue_fatal("queue malloc failed.");
	}
	q->data = malloc(sizeof(void*) * maxSize);
	q->capacity = maxSize;
	if (q->data == NULL ) {
		queue_fatal("data array malloc failed.");
	}
	queue_clear(q);
	return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x1080
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x219c
leaq 0x1045(%rip), %rdi      # 0x31dc
callq 0x20a0
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1080
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x21d4
leaq 0x1022(%rip), %rdi      # 0x31f1
callq 0x20a0
movq -0x10(%rbp), %rdi
callq 0x2110
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/queue.c
// Function: queue_print
void queue_print(Queue q) {
	assert(q!=NULL);
	if (queue_isEmpty(q)) {
		printf("queue is empty.\n");
		return;
	}
	for (int i = q->front; i < (q->front + q->size); i++) {

		int cursor = i;
		if (cursor >= q->capacity) {
			cursor = i - q->capacity;
		}
		printf("%d ", q->data[cursor]);
	}

	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2255
jmp 0x2274
leaq 0xf58(%rip), %rdi       # 0x31b4
leaq 0xf59(%rip), %rsi       # 0x31bc
movl $0x35, %edx
leaq 0xfb6(%rip), %rcx       # 0x3225
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x20d0
cmpl $0x0, %eax
je 0x2292
leaq 0xfb4(%rip), %rdi       # 0x323d
movb $0x0, %al
callq 0x1040
jmp 0x2305
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq -0x8(%rbp), %rdx
addl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x22f7
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x22ce
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xebb(%rip), %rdi       # 0x31a0
movb $0x0, %al
callq 0x1040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x229c
leaq 0xf4e(%rip), %rdi       # 0x324c
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/queue.c
// Function: queue_enqueue
void queue_enqueue(void* value, Queue q) {
	assert(q!=NULL);
	if (queue_isFull(q)) {
		queue_fatal("queue is full.");
	}
	q->size++;
	if (++q->end == q->capacity) {
		q->end = 0;
	}
	q->data[q->end] = value;
//	BST t= (BST)q->data[q->end];
//	printf("[queue_enqueue %d]\n", t->value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2329
jmp 0x2348
leaq 0xe84(%rip), %rdi       # 0x31b4
leaq 0xe85(%rip), %rsi       # 0x31bc
movl $0x47, %edx
leaq 0xf0b(%rip), %rcx       # 0x324e
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x20f0
cmpl $0x0, %eax
je 0x2362
leaq 0xf13(%rip), %rdi       # 0x3270
callq 0x20a0
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x238f
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch4/bst/queue.c
// Function: queue_dequeue
void* queue_dequeue(Queue q) {
	assert(q!=NULL);
	if (queue_isEmpty(q)) {
		queue_fatal("queue is empty.");
	}
	q->size--;
	void* tmp = q->data[q->front];
	if (++q->front == q->capacity) {
		q->front = 0;
	}
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x23c5
jmp 0x23e4
leaq 0xde8(%rip), %rdi       # 0x31b4
leaq 0xde9(%rip), %rsi       # 0x31bc
movl $0x55, %edx
leaq 0xea0(%rip), %rcx       # 0x327f
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x20d0
cmpl $0x0, %eax
je 0x23fe
leaq 0xea1(%rip), %rdi       # 0x329a
callq 0x20a0
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x2443
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/donnabad/curve25519-donnabad.c
// Function: swap_conditional
static void
swap_conditional(limb a[19], limb b[19], limb iswap) {
  unsigned i;
#if 0
  const s32 swap = (s32) -iswap;

  for (i = 0; i < 10; ++i) {
    const s32 x = swap & ( ((s32)a[i]) ^ ((s32)b[i]) );
    a[i] = ((s32)a[i]) ^ x;
    b[i] = ((s32)b[i]) ^ x;
  }
#endif

  // didactical timing leak
  if (iswap==1) {
    for (i = 0; i < 10; ++i) {
      s32 tmp = (s32)a[i];
      a[i] = b[i];
      b[i] = tmp;
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
cmpq $0x1, -0x18(%rsp)
jne 0x3652
movl $0x0, -0x1c(%rsp)
cmpl $0xa, -0x1c(%rsp)
jae 0x3650
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movslq -0x20(%rsp), %rdx
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x35ff
jmp 0x3652
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch3/eatyguy3.c
// Function: set_color
int set_color(lua_State *L) {
  const char *b_or_f = lua_tostring(L, 1);
  int color = lua_tonumber(L, 2);
  char cmd[1024];
  snprintf(cmd, 1024, "tput seta%s %d", b_or_f, color);
  system(cmd);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x67e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6660
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
leaq -0x420(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
movl $0x400, %esi            # imm = 0x400
leaq 0x2e7f8(%rip), %rdx     # 0x34081
movb $0x0, %al
callq 0x5190
leaq -0x420(%rbp), %rdi
callq 0x5160
xorl %eax, %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw (%rax,%rax)