LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/sais.c
// Function: sais_int_bwt
int
sais_int_bwt(const int *T, int *U, int *A, int n, int k) {
  int i, pidx;
  if((T == NULL) || (U == NULL) || (A == NULL) || (n < 0) || (k <= 0)) { return -1; }
  if(n <= 1) { if(n == 1) { U[0] = T[0]; } return n; }
  pidx = sais_main(T, A, 0, n, k, sizeof(int), 1);
  if(pidx < 0) { return pidx; }
  U[0] = T[n - 1];
  for(i = 0; i < pidx; ++i) { U[i + 1] = A[i]; }
  for(i += 1; i < n; ++i) { U[i] = A[i]; }
  pidx += 1;
  return pidx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x35e3c
cmpq $0x0, -0x18(%rbp)
je 0x35e3c
cmpq $0x0, -0x20(%rbp)
je 0x35e3c
cmpl $0x0, -0x24(%rbp)
jl 0x35e3c
cmpl $0x0, -0x28(%rbp)
jg 0x35e48
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x35f2e
cmpl $0x1, -0x24(%rbp)
jg 0x35e6b
cmpl $0x1, -0x24(%rbp)
jne 0x35e60
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35f2e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
xorl %edx, %edx
movl $0x4, %r9d
movl $0x1, (%rsp)
callq 0x34ef0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0x35ea2
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35f2e
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x35eed
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x35ebf
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x35f1f
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x35ef6
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/server.c
// Function: getargs
void getargs(int *port, int *threads, int *buffers, int *alg, int argc, char *argv[])
{
    if (argc != 5) {
		if(argc != 6 || strcmp(argv[4], "SFF-BS")) {
			fprintf(stderr, "Usage: %s <port> <threads> <buffers> <schedalg> [N (for SFF-BS only)]\n", argv[0]);
			exit(1);
		}
    }
    *port = atoi(argv[1]);
    *threads = atoi(argv[2]);
    *buffers = atoi(argv[3]);
	if(strcasecmp(argv[4], "FIFO") == 0) {
		*alg = -2;
	}
	else if(strcasecmp(argv[4], "SFF") == 0) {
		*alg = -1;
	}
	else if(strcasecmp(argv[4], "SFF-BS") == 0 && atoi(argv[5]) > 0) {
		*alg = atoi(argv[5]);
	}
	else {
		fprintf(stderr, "Usage: %s <port> <threads> <buffers> <schedalg> [N (for SFF-BS only)]\n", argv[0]);
		exit(1);
	}
}

// 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)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x5, -0x24(%rbp)
je 0x2500
cmpl $0x6, -0x24(%rbp)
jne 0x24d5
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x2b4d(%rip), %rsi      # 0x5018
callq 0x21b0
cmpl $0x0, %eax
je 0x24fe
movq 0x5b1c(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
leaq 0x2b32(%rip), %rsi      # 0x501f
movb $0x0, %al
callq 0x21d0
movl $0x1, %edi
callq 0x2300
jmp 0x2500
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22b0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x22b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x22b0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x2b18(%rip), %rsi      # 0x5066
callq 0x2040
cmpl $0x0, %eax
jne 0x2567
movq -0x20(%rbp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
jmp 0x25fb
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x2af5(%rip), %rsi      # 0x506b
callq 0x2040
cmpl $0x0, %eax
jne 0x258c
movq -0x20(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x25f9
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x2a7d(%rip), %rsi      # 0x5018
callq 0x2040
cmpl $0x0, %eax
jne 0x25ce
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x22b0
cmpl $0x0, %eax
jle 0x25ce
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x22b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x25f7
movq 0x5a23(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
leaq 0x2a39(%rip), %rsi      # 0x501f
movb $0x0, %al
callq 0x21d0
movl $0x1, %edi
callq 0x2300
jmp 0x25f9
jmp 0x25fb
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/request.c
// Function: requestReadhdrs
void requestReadhdrs(rio_t *rp)
{
   char buf[MAXLINE];

   Rio_readlineb(rp, buf, MAXLINE);
   while (strcmp(buf, "\r\n")) {
      Rio_readlineb(rp, buf, MAXLINE);
   }
   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2010, %rsp           # imm = 0x2010
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2010(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x4530
leaq -0x2010(%rbp), %rdi
leaq 0x238c(%rip), %rsi      # 0x52ae
callq 0x21b0
cmpl $0x0, %eax
je 0x2f43
movq -0x8(%rbp), %rdi
leaq -0x2010(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x4530
jmp 0x2f14
addq $0x2010, %rsp           # imm = 0x2010
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/request.c
// Function: requestParseURI
int requestParseURI(char *uri, char *filename, char *cgiargs) 
{
   char *ptr;

   if (!strstr(uri, "cgi")) {
      // static
      strcpy(cgiargs, "");
      sprintf(filename, ".%s", uri);
      if (uri[strlen(uri)-1] == '/') {
         strcat(filename, "home.html");
      }
      return 1;
   } else {
      // dynamic
      ptr = index(uri, '?');
      if (ptr) {
         strcpy(cgiargs, ptr+1);
         *ptr = '\0';
      } else {
         strcpy(cgiargs, "");
      }
      sprintf(filename, ".%s", uri);
      return 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x21be(%rip), %rsi      # 0x512d
callq 0x2360
cmpq $0x0, %rax
jne 0x2fde
movq -0x20(%rbp), %rdi
leaq 0x232b(%rip), %rsi      # 0x52b0
callq 0x2060
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2198(%rip), %rsi      # 0x5131
movb $0x0, %al
callq 0x22f0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x2fd5
movq -0x18(%rbp), %rdi
leaq 0x2165(%rip), %rsi      # 0x5135
callq 0x22c0
movl $0x1, -0x4(%rbp)
jmp 0x303e
movq -0x10(%rbp), %rdi
movl $0x3f, %esi
callq 0x2160
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3011
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x2060
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
jmp 0x3021
movq -0x20(%rbp), %rdi
leaq 0x2294(%rip), %rsi      # 0x52b0
callq 0x2060
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2101(%rip), %rsi      # 0x5131
movb $0x0, %al
callq 0x22f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/request.c
// Function: requestGetFiletype
void requestGetFiletype(char *filename, char *filetype)
{
   if (strstr(filename, ".html")) 
      strcpy(filetype, "text/html");
   else if (strstr(filename, ".gif")) 
      strcpy(filetype, "image/gif");
   else if (strstr(filename, ".jpg")) 
      strcpy(filetype, "image/jpeg");
   else 
      strcpy(filetype, "test/plain");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x20ce(%rip), %rsi      # 0x5139
callq 0x2360
cmpq $0x0, %rax
je 0x3088
movq -0x10(%rbp), %rdi
leaq 0x20be(%rip), %rsi      # 0x513f
callq 0x2060
jmp 0x30ec
movq -0x8(%rbp), %rdi
leaq 0x20b6(%rip), %rsi      # 0x5149
callq 0x2360
cmpq $0x0, %rax
je 0x30b0
movq -0x10(%rbp), %rdi
leaq 0x20a5(%rip), %rsi      # 0x514e
callq 0x2060
jmp 0x30ea
movq -0x8(%rbp), %rdi
leaq 0x209d(%rip), %rsi      # 0x5158
callq 0x2360
cmpq $0x0, %rax
je 0x30d8
movq -0x10(%rbp), %rdi
leaq 0x208c(%rip), %rsi      # 0x515d
callq 0x2060
jmp 0x30e8
movq -0x10(%rbp), %rdi
leaq 0x2085(%rip), %rsi      # 0x5168
callq 0x2060
jmp 0x30ea
jmp 0x30ec
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/somethingnew2-0[P]CS537-P4/request.c
// Function: requestFileSize
long requestFileSize(int fd) {
	char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE];
    char filename[MAXLINE], cgiargs[MAXLINE];	
	struct stat s;

	recv(fd, buf, sizeof(buf), MSG_PEEK);
	
   	sscanf(buf, "%s %s %s\n", method, uri, version);

	requestParseURI(uri, filename, cgiargs);

	Stat(filename, &s);

	return (long)s.st_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0a0, %rsp           # imm = 0xC0A0
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq -0x2010(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
movl $0x2, %ecx
callq 0x2030
leaq -0x2010(%rbp), %rdi
leaq -0x4010(%rbp), %rdx
leaq -0x6010(%rbp), %rcx
leaq -0x8010(%rbp), %r8
leaq 0x1a50(%rip), %rsi      # 0x52ba
movb $0x0, %al
callq 0x2230
leaq -0x6010(%rbp), %rdi
leaq -0xa010(%rbp), %rsi
leaq -0xc010(%rbp), %rdx
callq 0x2f50
leaq -0xa010(%rbp), %rdi
leaq -0xc0a0(%rbp), %rsi
callq 0x3cf0
movq -0xc070(%rbp), %rax
addq $0xc0a0, %rsp           # imm = 0xC0A0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/floriangit[P]hdd_sound/disk.c
// Function: main
int main(int ac, char **av)
{
	char str[4096];
	char fstat[512];
	int fd;
	int ret;
	int val      = 0;
	int old_val  = 1;
	int diff     = 0;

	if(ac > 1) {
	    sprintf(fstat, "/sys/block/%s/stat", av[1]);
	} else {
	    strcpy(fstat, "/sys/block/sda/stat");
	}

	while(1) {
		usleep(1234);
		fd = open(fstat, O_RDONLY);
	
		if(fd < 3) {
			perror("open");
			return -1;
		}
	
		ret = read(fd, str, sizeof(str));
		if(ret == -1) {
			perror("read");
			return -1;
		}
		close(fd);

		char delim[] = " ";
		char *ptr = strtok(str, delim);
	
		for(int i = 0; ptr != NULL; i++) {
			if(i == 2 || i == 6) { /* 2 = READ, 6 = WRITE */
				val = atoi(ptr);
				diff = val - old_val;
				if(diff > 1024) {
					play(MEDIUM);
					old_val = val;
					break;
				}
				if(diff > 0) {
					play(SHORT);
					old_val = val;
					break;
				}
			}
			ptr = strtok(NULL, delim);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1240, %rsp           # imm = 0x1240
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x121c(%rbp)
movl $0x1, -0x1220(%rbp)
movl $0x0, -0x1224(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x128c
leaq -0x1210(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xd81(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1070
jmp 0x129f
leaq -0x1210(%rbp), %rdi
leaq 0xd7d(%rip), %rsi       # 0x2017
callq 0x10b0
jmp 0x12a1
movl $0x4d2, %edi            # imm = 0x4D2
callq 0x1080
leaq -0x1210(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1120
movl %eax, -0x1214(%rbp)
cmpl $0x3, -0x1214(%rbp)
jge 0x12e2
leaq 0xd5a(%rip), %rdi       # 0x202b
callq 0x10f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1415
movl -0x1214(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x1060
movl %eax, -0x1218(%rbp)
cmpl $-0x1, -0x1218(%rbp)
jne 0x1320
leaq 0xd21(%rip), %rdi       # 0x2030
callq 0x10f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1415
movl -0x1214(%rbp), %edi
callq 0x1030
movw 0xd03(%rip), %ax        # 0x2035
movw %ax, -0x1226(%rbp)
leaq -0x1010(%rbp), %rdi
leaq -0x1226(%rbp), %rsi
callq 0x10c0
movq %rax, -0x1230(%rbp)
movl $0x0, -0x1234(%rbp)
cmpq $0x0, -0x1230(%rbp)
je 0x1410
cmpl $0x2, -0x1234(%rbp)
je 0x137d
cmpl $0x6, -0x1234(%rbp)
jne 0x13e5
movq -0x1230(%rbp), %rdi
callq 0x1090
movl %eax, -0x121c(%rbp)
movl -0x121c(%rbp), %eax
subl -0x1220(%rbp), %eax
movl %eax, -0x1224(%rbp)
cmpl $0x400, -0x1224(%rbp)   # imm = 0x400
jle 0x13c5
movl $0x1, %edi
callq 0x1430
movl -0x121c(%rbp), %eax
movl %eax, -0x1220(%rbp)
jmp 0x1410
cmpl $0x0, -0x1224(%rbp)
jle 0x13e3
xorl %edi, %edi
callq 0x1430
movl -0x121c(%rbp), %eax
movl %eax, -0x1220(%rbp)
jmp 0x1410
jmp 0x13e5
leaq -0x1226(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x10c0
movq %rax, -0x1230(%rbp)
movl -0x1234(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1234(%rbp)
jmp 0x135d
jmp 0x12a1
movl -0x4(%rbp), %eax
addq $0x1240, %rsp           # imm = 0x1240
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/iget.c
// Function: main
int
main()
{
    static short source[10] = {
        1, 2, 3, 4, 5,
        6, 7, 8, 9, 10
    };
    short target[10];
    int i;
    int me;

    for (i = 0; i < 10; i += 1) {
        target[i] = 666;
    }

    shmem_init();
    me = shmem_my_pe();

    if (me == 1) {
        shmem_short_iget(target, source, 2, 1, 4, 0);
    }

    shmem_barrier_all();        /* sync sender and receiver */

    if (me == 1) {
        for (i = 0; i < 10; i += 1) {
            printf("PE %d: target[%d] = %hd, source[%d] = %hd\n",
                   me, i, target[i], i, source[i]);
        }
    }

    shmem_barrier_all();        /* sync before exiting */

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0xa, 0xc(%rsp)
jge 0x11c4
movslq 0xc(%rsp), %rax
movw $0x29a, 0x10(%rsp,%rax,2) # imm = 0x29A
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x11a4
callq 0x1070
callq 0x1050
movl %eax, 0x8(%rsp)
cmpl $0x1, 0x8(%rsp)
jne 0x11fd
leaq 0x10(%rsp), %rdi
leaq 0x2e7b(%rip), %rsi      # 0x4060
movl $0x2, %edx
movl $0x1, %ecx
movl $0x4, %r8d
xorl %r9d, %r9d
callq 0x1080
callq 0x1060
cmpl $0x1, 0x8(%rsp)
jne 0x125d
movl $0x0, 0xc(%rsp)
cmpl $0xa, 0xc(%rsp)
jge 0x125b
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movslq 0xc(%rsp), %rax
movswl 0x10(%rsp,%rax,2), %ecx
movl 0xc(%rsp), %r8d
movslq 0xc(%rsp), %rdi
leaq 0x2e25(%rip), %rax      # 0x4060
movswl (%rax,%rdi,2), %r9d
leaq 0xdbd(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1211
jmp 0x125d
callq 0x1060
callq 0x1040
xorl %eax, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_08/malloc.c
// Function: main
int main(int argc, char *argv[])
{
	size_t size;
	void *ptr, *nptr;

	/* Parse the command line */
	if (argc < 2) {
		fprintf(stderr,
			"usage: %s <size>\n", argv[0]);
		return -1;
	}
	size = atoi(argv[1]);

	/* Try memory allocation */
	ptr = malloc(size);
	if (ptr == NULL) {
		perror("malloc");
		return -1;
	}
	printf("malloc(%ld) returned %p\n", size, ptr);
	free(ptr);

	/* Try calloc) of doubled space and then realloc()
	 * of doubled-doubed space.
	 */
	ptr = calloc(2, size);
	if (ptr == NULL) {
		perror("malloc");
		return -1;
	}
	printf("calloc(2, %ld) returned %p\n", size, ptr);

	nptr = realloc(ptr, size * 2 * 2);
	if (ptr == NULL) {
		perror("malloc");
		return -1;
	}
	printf("realloc(%p, %ld) returned %p\n", ptr, size * 2 * 2, nptr);
	free(nptr);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x11f7
movq 0x2e25(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe20(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12fc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10a0
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1070
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1236
leaq 0xdf1(%rip), %rdi       # 0x2016
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12fc
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0xdd8(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1040
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rsi
movl $0x2, %edi
callq 0x1050
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1283
leaq 0xda1(%rip), %rdi       # 0x2016
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12fc
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0xda4(%rip), %rdi       # 0x2036
movb $0x0, %al
callq 0x1040
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
shlq %rsi
shlq %rsi
callq 0x1080
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12cc
leaq 0xd58(%rip), %rdi       # 0x2016
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12fc
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq %rdx
shlq %rdx
movq -0x28(%rbp), %rcx
leaq 0xd6d(%rip), %rdi       # 0x2052
movb $0x0, %al
callq 0x1040
movq -0x28(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/tst/dio.c
// Function: test_applyConfig_code
void test_applyConfig_code() {
    evmInit();
    const char config[] = "["
        "{"
            "\"address\":\"0x80d9b122dc3a16fdc41f96cf010ffe7e38d227c3\","
            "\"code\":\"0x383d3d39383df3\""
        "}"
    "]";
    applyConfig(config);

    uint64_t gas = 21019;
    address_t from;
    val_t val;
    val[0] = 0;
    val[1] = 0;
    val[2] = 0;
    address_t to = AddressFromHex42("0x80d9b122dc3a16fdc41f96cf010ffe7e38d227c3");
    data_t input;
    input.size = 0;

    result_t result = txCall(from, gas, to, val, input, NULL);
    op_t expected[] = {
         CODESIZE, RETURNDATASIZE, RETURNDATASIZE, CODECOPY,
         CODESIZE, RETURNDATASIZE, RETURN
    };
    assert(result.returnData.size == sizeof(expected));
    assert(memcmp(expected, result.returnData.content, result.returnData.size) == 0);
    assert(result.gasRemaining == 0);

    evmFinalize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movb $0x0, %al
callq 0x86a0
leaq -0x60(%rbp), %rdi
leaq 0x13ca3(%rip), %rsi     # 0x17010
movl $0x55, %edx
callq 0x31b0
leaq -0x60(%rbp), %rdi
callq 0x3df0
movq $0x521b, -0x68(%rbp)    # imm = 0x521B
movl $0x0, -0x8c(%rbp)
movl $0x0, -0x88(%rbp)
movl $0x0, -0x84(%rbp)
leaq -0xa0(%rbp), %rdi
leaq 0x140db(%rip), %rsi     # 0x1748f
addq $0x2, %rsi
callq 0x3500
movq $0x0, -0xb0(%rbp)
movq -0x68(%rbp), %rsi
leaq -0x8c(%rbp), %rdx
movq -0xb0(%rbp), %rcx
movq -0xa8(%rbp), %r8
leaq -0xf0(%rbp), %rdi
leaq -0x80(%rbp), %r10
leaq -0xa0(%rbp), %rax
xorl %r9d, %r9d
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x8(%rsp)
movl 0x10(%r10), %r10d
movl %r10d, 0x10(%rsp)
movq (%rax), %r10
movq %r10, 0x18(%rsp)
movq 0x8(%rax), %r10
movq %r10, 0x20(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x28(%rsp)
callq 0x9180
movl 0x141f6(%rip), %eax     # 0x17628
movl %eax, -0xf7(%rbp)
movw 0x141ed(%rip), %ax      # 0x1762c
movw %ax, -0xf3(%rbp)
movb 0x141e2(%rip), %al      # 0x1762e
movb %al, -0xf1(%rbp)
cmpq $0x7, -0xf0(%rbp)
jne 0x345e
jmp 0x347d
leaq 0x14055(%rip), %rdi     # 0x174ba
leaq 0x14079(%rip), %rsi     # 0x174e5
movl $0x20, %edx
leaq 0x14077(%rip), %rcx     # 0x174ef
callq 0x30e0
leaq -0xf7(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
callq 0x3160
cmpl $0x0, %eax
jne 0x349e
jmp 0x34bd
leaq 0x14067(%rip), %rdi     # 0x1750c
leaq 0x14039(%rip), %rsi     # 0x174e5
movl $0x21, %edx
leaq 0x14037(%rip), %rcx     # 0x174ef
callq 0x30e0
cmpq $0x0, -0xc0(%rbp)
jne 0x34c9
jmp 0x34e8
leaq 0x14085(%rip), %rdi     # 0x17555
leaq 0x1400e(%rip), %rsi     # 0x174e5
movl $0x22, %edx
leaq 0x1400c(%rip), %rcx     # 0x174ef
callq 0x30e0
movb $0x0, %al
callq 0x8bb0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/tst/dio.c
// Function: test_applyConfig_storage
void test_applyConfig_storage() {
    evmInit();

    const char config[] = "["
        "{"
            "\"address\":\"0x80d9b122dc3a16fdc41f96cf010ffe7e38d227c3\","
            "\"code\":\"0x5f545f52595ff3\","
            "\"storage\":{"
                "\"0x00\": \"0x12340000567800009abc0000def0\""
            "}"
        "}"
    "]";
    applyConfig(config);

    uint64_t gas = 23114;
    address_t from;
    val_t val;
    val[0] = 0;
    val[1] = 0;
    val[2] = 0;
    address_t to = AddressFromHex42("0x80d9b122dc3a16fdc41f96cf010ffe7e38d227c3");
    data_t input;
    input.size = 0;

    result_t result = txCall(from, gas, to, val, input, NULL);
    op_t expected[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x12, 0x34, 0x00, 0x00, 0x56, 0x78,
        0x00, 0x00, 0x9a, 0xbc, 0x00, 0x00, 0xde, 0xf0,
    };
    assert(result.returnData.size == sizeof(expected));
    assert(memcmp(expected, result.returnData.content, result.returnData.size) == 0);
    assert(result.gasRemaining == 0);

    evmFinalize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movb $0x0, %al
callq 0x86a0
leaq -0x90(%rbp), %rdi
leaq 0x13af0(%rip), %rsi     # 0x17070
movl $0x8a, %edx
callq 0x31b0
leaq -0x90(%rbp), %rdi
callq 0x3df0
movq $0x5a4a, -0x98(%rbp) # imm = 0x5A4A
movl $0x0, -0xbc(%rbp)
movl $0x0, -0xb8(%rbp)
movl $0x0, -0xb4(%rbp)
leaq -0xd0(%rbp), %rdi
leaq 0x13ec2(%rip), %rsi     # 0x1748f
addq $0x2, %rsi
callq 0x3500
movq $0x0, -0xe0(%rbp)
movq -0x98(%rbp), %rsi
leaq -0xbc(%rbp), %rdx
movq -0xe0(%rbp), %rcx
movq -0xd8(%rbp), %r8
leaq -0x120(%rbp), %rdi
leaq -0xb0(%rbp), %r10
leaq -0xd0(%rbp), %rax
xorl %r9d, %r9d
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x8(%rsp)
movl 0x10(%r10), %r10d
movl %r10d, 0x10(%rsp)
movq (%rax), %r10
movq %r10, 0x18(%rsp)
movq 0x8(%rax), %r10
movq %r10, 0x20(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x28(%rsp)
callq 0x9180
movq 0x13fee(%rip), %rax     # 0x17640
movq %rax, -0x140(%rbp)
movq 0x13fe8(%rip), %rax     # 0x17648
movq %rax, -0x138(%rbp)
movq 0x13fe2(%rip), %rax     # 0x17650
movq %rax, -0x130(%rbp)
movq 0x13fdc(%rip), %rax     # 0x17658
movq %rax, -0x128(%rbp)
cmpq $0x20, -0x120(%rbp)
jne 0x368f
jmp 0x36ae
leaq 0x13e24(%rip), %rdi     # 0x174ba
leaq 0x13e48(%rip), %rsi     # 0x174e5
movl $0x46, %edx
leaq 0x13ec5(%rip), %rcx     # 0x1756e
callq 0x30e0
leaq -0x140(%rbp), %rdi
movq -0x118(%rbp), %rsi
movq -0x120(%rbp), %rdx
callq 0x3160
cmpl $0x0, %eax
jne 0x36cf
jmp 0x36ee
leaq 0x13e36(%rip), %rdi     # 0x1750c
leaq 0x13e08(%rip), %rsi     # 0x174e5
movl $0x47, %edx
leaq 0x13e85(%rip), %rcx     # 0x1756e
callq 0x30e0
cmpq $0x0, -0xf0(%rbp)
jne 0x36fa
jmp 0x3719
leaq 0x13e54(%rip), %rdi     # 0x17555
leaq 0x13ddd(%rip), %rsi     # 0x174e5
movl $0x48, %edx
leaq 0x13e5a(%rip), %rcx     # 0x1756e
callq 0x30e0
movb $0x0, %al
callq 0x8bb0
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/tst/dio.c
// Function: test_applyConfig_balance
void test_applyConfig_balance() {
    evmInit();

    const char config[] = "["
        "{"
            "\"address\":\"0x80d9b122dc3a16fdc41f96cf010ffe7e38d227c3\","
            "\"code\":\"0x475f52595ff3\","
            "\"balance\":\"0x1234005678009abc00def0\""
        "}"
    "]";
    applyConfig(config);

    uint64_t gas = 21017;
    address_t from;
    val_t val;
    val[0] = 0;
    val[1] = 0;
    val[2] = 0;
    address_t to = AddressFromHex42("0x80d9b122dc3a16fdc41f96cf010ffe7e38d227c3");
    data_t input;
    input.size = 0;

    result_t result = txCall(from, gas, to, val, input, NULL);
    op_t expected[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x34, 0x00,
        0x56, 0x78, 0x00, 0x9a, 0xbc, 0x00, 0xde, 0xf0,
    };
    assert(result.returnData.size == sizeof(expected));
    assert(memcmp(expected, result.returnData.content, result.returnData.size) == 0);
    assert(result.gasRemaining == 0);

    evmFinalize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movb $0x0, %al
callq 0x86a0
leaq -0x80(%rbp), %rdi
leaq 0x139b3(%rip), %rsi     # 0x17100
movl $0x78, %edx
callq 0x31b0
leaq -0x80(%rbp), %rdi
callq 0x3df0
movq $0x5219, -0x88(%rbp) # imm = 0x5219
movl $0x0, -0xac(%rbp)
movl $0x0, -0xa8(%rbp)
movl $0x0, -0xa4(%rbp)
leaq -0xc0(%rbp), %rdi
leaq 0x13cf8(%rip), %rsi     # 0x1748f
addq $0x2, %rsi
callq 0x3500
movq $0x0, -0xd0(%rbp)
movq -0x88(%rbp), %rsi
leaq -0xac(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq -0xc8(%rbp), %r8
leaq -0x110(%rbp), %rdi
leaq -0xa0(%rbp), %r10
leaq -0xc0(%rbp), %rax
xorl %r9d, %r9d
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x8(%rsp)
movl 0x10(%r10), %r10d
movl %r10d, 0x10(%rsp)
movq (%rax), %r10
movq %r10, 0x18(%rsp)
movq 0x8(%rax), %r10
movq %r10, 0x20(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x28(%rsp)
callq 0x9180
movq 0x13e44(%rip), %rax     # 0x17660
movq %rax, -0x130(%rbp)
movq 0x13e3e(%rip), %rax     # 0x17668
movq %rax, -0x128(%rbp)
movq 0x13e38(%rip), %rax     # 0x17670
movq %rax, -0x120(%rbp)
movq 0x13e32(%rip), %rax     # 0x17678
movq %rax, -0x118(%rbp)
cmpq $0x20, -0x110(%rbp)
jne 0x3859
jmp 0x3878
leaq 0x13c5a(%rip), %rdi     # 0x174ba
leaq 0x13c7e(%rip), %rsi     # 0x174e5
movl $0x6b, %edx
leaq 0x13d1b(%rip), %rcx     # 0x1758e
callq 0x30e0
leaq -0x130(%rbp), %rdi
movq -0x108(%rbp), %rsi
movq -0x110(%rbp), %rdx
callq 0x3160
cmpl $0x0, %eax
jne 0x3899
jmp 0x38b8
leaq 0x13c6c(%rip), %rdi     # 0x1750c
leaq 0x13c3e(%rip), %rsi     # 0x174e5
movl $0x6c, %edx
leaq 0x13cdb(%rip), %rcx     # 0x1758e
callq 0x30e0
cmpq $0x0, -0xe0(%rbp)
jne 0x38c4
jmp 0x38e3
leaq 0x13c8a(%rip), %rdi     # 0x17555
leaq 0x13c13(%rip), %rsi     # 0x174e5
movl $0x6d, %edx
leaq 0x13cb0(%rip), %rcx     # 0x1758e
callq 0x30e0
movb $0x0, %al
callq 0x8bb0
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/tst/dio.c
// Function: test_applyConfig_construct
void test_applyConfig_construct() {
    evmInit();

    const char config[] = "["
        "{"
            "\"address\":\"0x80d9b122dc3a16fdc41f96cf010ffe7e38d227c3\","
            "\"construct\":\"tst/in/quine.evm\","
            "\"code\":\"0x383d3d39383df3\""
        "}"
    "]";
    applyConfig(config);

    uint64_t gas = 0x521b;
    address_t from;
    val_t val;
    val[0] = 0;
    val[1] = 0;
    val[2] = 0;
    address_t to = AddressFromHex42("0x80d9b122dc3a16fdc41f96cf010ffe7e38d227c3");
    data_t input;
    input.size = 0;

    result_t result = txCall(from, gas, to, val, input, NULL);
    op_t expected[] = {
        0x38, 0x3d, 0x3d, 0x39, 0x38, 0x3d, 0xf3
    };
    assert(result.returnData.size == sizeof(expected));
    assert(memcmp(expected, result.returnData.content, result.returnData.size) == 0);
    assert(result.gasRemaining == 0);

    evmFinalize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movb $0x0, %al
callq 0x86a0
leaq -0x80(%rbp), %rdi
leaq 0x13863(%rip), %rsi     # 0x17180
movl $0x74, %edx
callq 0x31b0
leaq -0x80(%rbp), %rdi
callq 0x3df0
movq $0x521b, -0x88(%rbp) # imm = 0x521B
movl $0x0, -0xac(%rbp)
movl $0x0, -0xa8(%rbp)
movl $0x0, -0xa4(%rbp)
leaq -0xc0(%rbp), %rdi
leaq 0x13b28(%rip), %rsi     # 0x1748f
addq $0x2, %rsi
callq 0x3500
movq $0x0, -0xd0(%rbp)
movq -0x88(%rbp), %rsi
leaq -0xac(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq -0xc8(%rbp), %r8
leaq -0x110(%rbp), %rdi
leaq -0xa0(%rbp), %r10
leaq -0xc0(%rbp), %rax
xorl %r9d, %r9d
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x8(%rsp)
movl 0x10(%r10), %r10d
movl %r10d, 0x10(%rsp)
movq (%rax), %r10
movq %r10, 0x18(%rsp)
movq 0x8(%rax), %r10
movq %r10, 0x20(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x28(%rsp)
callq 0x9180
movl 0x13c44(%rip), %eax     # 0x1762f
movl %eax, -0x117(%rbp)
movw 0x13c3b(%rip), %ax      # 0x17633
movw %ax, -0x113(%rbp)
movb 0x13c30(%rip), %al      # 0x17635
movb %al, -0x111(%rbp)
cmpq $0x7, -0x110(%rbp)
jne 0x3a17
jmp 0x3a36
leaq 0x13a9c(%rip), %rdi     # 0x174ba
leaq 0x13ac0(%rip), %rsi     # 0x174e5
movl $0x8c, %edx
leaq 0x13b7d(%rip), %rcx     # 0x175ae
callq 0x30e0
leaq -0x117(%rbp), %rdi
movq -0x108(%rbp), %rsi
movq -0x110(%rbp), %rdx
callq 0x3160
cmpl $0x0, %eax
jne 0x3a57
jmp 0x3a76
leaq 0x13aae(%rip), %rdi     # 0x1750c
leaq 0x13a80(%rip), %rsi     # 0x174e5
movl $0x8d, %edx
leaq 0x13b3d(%rip), %rcx     # 0x175ae
callq 0x30e0
cmpq $0x0, -0xe0(%rbp)
jne 0x3a82
jmp 0x3aa1
leaq 0x13acc(%rip), %rdi     # 0x17555
leaq 0x13a55(%rip), %rsi     # 0x174e5
movl $0x8e, %edx
leaq 0x13b12(%rip), %rcx     # 0x175ae
callq 0x30e0
movb $0x0, %al
callq 0x8bb0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/tst/dio.c
// Function: main
int main() {
    dioInit("bin/evm");

    test_applyConfig_code();
    test_applyConfig_storage();
    test_applyConfig_balance();
    test_applyConfig_construct();

    close(2);
    test_applyConfig_tests();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x13948(%rip), %rdi     # 0x175ee
callq 0x3dd0
callq 0x3350
callq 0x3560
callq 0x3730
callq 0x3900
movl $0x2, %edi
callq 0x3120
callq 0x3ac0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.6/critical-section.c
// Function: process_transaction
void* process_transaction(void* thread_args){
	struct transaction tr = *((struct transaction*)thread_args);

	int old_cancel_state;

	if(account_balances[tr.from_acct] < tr.dollars)
		return (void*)1;

	/* Begin critical section */

	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancel_state);

	/* Move the money */

	account_balances[tr.to_acct] += tr.dollars;
	account_balances[tr.from_acct] -= tr.dollars;

	/* End critical section */

	pthread_setcancelstate(old_cancel_state, NULL);

	return (void*)0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x1c(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x2ea8(%rip), %rax      # 0x4060
movss (%rax,%rcx,4), %xmm1
movss -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x11d2
movl $0x1, %eax
movq %rax, -0x8(%rbp)
jmp 0x123a
movl $0x1, %edi
leaq -0x20(%rbp), %rsi
callq 0x1030
movss -0x14(%rbp), %xmm0
movslq -0x18(%rbp), %rcx
leaq 0x2e70(%rip), %rax      # 0x4060
addss (%rax,%rcx,4), %xmm0
leaq 0x2e64(%rip), %rax      # 0x4060
movss %xmm0, (%rax,%rcx,4)
movss -0x14(%rbp), %xmm1
movslq -0x1c(%rbp), %rcx
leaq 0x2e4f(%rip), %rax      # 0x4060
movss (%rax,%rcx,4), %xmm0
subss %xmm1, %xmm0
leaq 0x2e3f(%rip), %rax      # 0x4060
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1030
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.6/critical-section.c
// Function: main
int main(){

	struct transaction transactions[] = {	{0, 1, 250.65},
											{7, 6, 150.25},
											{2, 9, 350.67},
											{5, 3, 150.77},
											{4, 1, 250.00}};

	int i;

	pthread_t threads_id[num_transactions];

	printf("Account balances before transactions\n");

	for(i = 0; i < num_accounts; ++i)
		printf("%d: %.2f\n", i, account_balances[i]);

	for(i = 0; i < num_transactions; ++i)
		pthread_create(&threads_id[i], NULL, &process_transaction, &transactions[i]);

	/* To demonstrate that threads are uncancelable */
	for(i = 0; i < num_transactions; ++i)
		pthread_cancel(threads_id[i]);

	for(i = 0; i < num_transactions; ++i)
		pthread_join(threads_id[i], NULL);

	printf("\nAccount balances before transactions\n");

	for(i = 0; i < num_accounts; ++i)
		printf("%d: %.2f\n", i, account_balances[i]);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0xdb3(%rip), %rsi       # 0x2020
movl $0x3c, %edx
callq 0x1050
movq %rsp, %rax
movq %rax, -0x50(%rbp)
leaq 0xde2(%rip), %rdi       # 0x2067
movb $0x0, %al
callq 0x1040
movl $0x0, -0x44(%rbp)
cmpl $0xa, -0x44(%rbp)
jge 0x12c9
movl -0x44(%rbp), %esi
movslq -0x44(%rbp), %rcx
leaq 0x2db9(%rip), %rax      # 0x4060
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xda5(%rip), %rdi       # 0x205c
movb $0x1, %al
callq 0x1040
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1293
movl $0x0, -0x44(%rbp)
cmpl $0x5, -0x44(%rbp)
jge 0x130f
movslq -0x44(%rbp), %rax
leaq -0x80(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
movslq -0x44(%rbp), %rax
leaq -0x40(%rbp), %rcx
imulq $0xc, %rax, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq -0x16f(%rip), %rdx      # 0x1190
callq 0x1060
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x12d0
movl $0x0, -0x44(%rbp)
cmpl $0x5, -0x44(%rbp)
jge 0x1335
movslq -0x44(%rbp), %rax
movq -0x80(%rbp,%rax,8), %rdi
callq 0x1080
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1316
movl $0x0, -0x44(%rbp)
cmpl $0x5, -0x44(%rbp)
jge 0x135f
movslq -0x44(%rbp), %rax
movq -0x80(%rbp,%rax,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1070
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x133c
leaq 0xd00(%rip), %rdi       # 0x2066
movb $0x0, %al
callq 0x1040
movl $0x0, -0x44(%rbp)
cmpl $0xa, -0x44(%rbp)
jge 0x13aa
movl -0x44(%rbp), %esi
movslq -0x44(%rbp), %rcx
leaq 0x2cd8(%rip), %rax      # 0x4060
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xcc4(%rip), %rdi       # 0x205c
movb $0x1, %al
callq 0x1040
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1374
movl $0x0, -0x4(%rbp)
movq -0x50(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_09/limits.c
// Function: res_n2v
int res_n2v(char *n)
{
	int i;
	for (i = 0; i < 7; i++)
		if (strcmp(rlimit_n[i], n) == 0)
			break;
	if (i >= 7)
		return -1;
	return rlimit_v[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x7, -0x14(%rbp)
jge 0x11e5
movslq -0x14(%rbp), %rcx
leaq 0x2ebc(%rip), %rax      # 0x4080
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x1040
cmpl $0x0, %eax
jne 0x11d8
jmp 0x11e5
jmp 0x11da
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11b3
cmpl $0x7, -0x14(%rbp)
jl 0x11f4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1205
movslq -0x14(%rbp), %rcx
leaq 0x2e61(%rip), %rax      # 0x4060
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/unixlab[P]cloudflare-udp-ping/udpserver.c
// Function: state_init
struct state *state_init(struct state *s)
{
	struct msghdr *msg = &s->msg;

	msg->msg_name = &s->src_addr;
	msg->msg_namelen = sizeof(s->src_addr);
	msg->msg_iov = &s->iovec;
	msg->msg_iovlen = 1;
	msg->msg_control = &s->pktinfo[0];
	msg->msg_controllen = sizeof(s->pktinfo);

	s->iovec.iov_base = &s->buffer[0];
	s->iovec.iov_len = MTU_SIZE;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x1c, 0x8(%rax)
movq -0x8(%rbp), %rcx
addq $0x7e0, %rcx            # imm = 0x7E0
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x1, 0x18(%rax)
movq -0x8(%rbp), %rcx
addq $0x7f0, %rcx            # imm = 0x7F0
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x1000, 0x28(%rax)     # imm = 0x1000
movq -0x8(%rbp), %rcx
addq $0x60, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x7e0(%rax)
movq -0x8(%rbp), %rax
movq $0x780, 0x7e8(%rax) # imm = 0x780
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/mutex-trie.c
// Function: new_leaf
struct trie_node * new_leaf(const char *string, size_t strlen, int32_t ip4_address) {
  struct trie_node *new_node = malloc(sizeof (struct trie_node));
  if (!new_node) {
    printf("WARNING: Node memory allocation failed.  Results may be bogus.\n");
    return NULL;
  }
  assert(strlen < 64);
  assert(strlen > 0);
  new_node->next = NULL;
  new_node->strlen = strlen;
  strncpy(new_node->key, string, strlen);
  new_node->key[strlen] = '\0';
  new_node->ip4_address = ip4_address;
  new_node->children = NULL;

  return new_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x58, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1373
leaq 0x2ca5(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x1090
movq $0x0, -0x8(%rbp)
jmp 0x141b
cmpq $0x40, -0x18(%rbp)
jae 0x137c
jmp 0x139b
leaq 0x2d62(%rip), %rdi      # 0x40e5
leaq 0x2cba(%rip), %rsi      # 0x4044
movl $0x27, %edx
leaq 0x2cbb(%rip), %rcx      # 0x4051
callq 0x10b0
cmpq $0x0, -0x18(%rbp)
jbe 0x13a4
jmp 0x13c3
leaq 0x2ce0(%rip), %rdi      # 0x408b
leaq 0x2c92(%rip), %rsi      # 0x4044
movl $0x28, %edx
leaq 0x2c93(%rip), %rcx      # 0x4051
callq 0x10b0
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1050
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, 0x18(%rax,%rcx)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/mutex-trie.c
// Function: squat_search
int squat_search(const char *string, size_t strlen, int32_t *ip4_address) {
  struct trie_node *found;
  int result = 0;
  // Skip strings of length 0
  if (strlen == 0)
  return result;
  found = _search(root, string, strlen);
  if (found && ip4_address)
  *ip4_address = found->ip4_address;
  result = (found != NULL);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x166a
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16b3
movq 0x4ae7(%rip), %rdi      # 0x6158
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1500
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x169d
cmpq $0x0, -0x20(%rbp)
je 0x169d
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/mutex-trie.c
// Function: search
int search(const char *string, size_t strlen, int32_t *ip4_address) {
  struct trie_node *found;
  //int rv;
  int result;

  // Skip strings of length 0
  if (strlen == 0)
  return 0;
  pthread_cleanup_push(cleanup_handler,&lock);
  // obtain the lock
  //rv =
  pthread_mutex_lock(&lock);
  // assert(rv == 0);
  found = _search(root, string, strlen);

  if (found && ip4_address)
  *ip4_address = found->ip4_address;

  result = (found != NULL);

  // Return the lock
  /**** NEW ***/
  pthread_cleanup_pop(1);
  //rv = pthread_mutex_unlock(&lock);
  //assert(rv == 0);

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16ea
movl $0x0, -0x4(%rbp)
jmp 0x17c6
jmp 0x16ec
leaq -0x3e3(%rip), %rax      # 0x1310
movq %rax, -0xa8(%rbp)
leaq 0x4a27(%rip), %rax      # 0x6128
movq %rax, -0xb0(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
callq 0x11d0
movl %eax, -0xb4(%rbp)
movslq -0xb4(%rbp), %rax
cmpq $0x0, %rax
je 0x1745
movq -0xa8(%rbp), %rax
movq -0xb0(%rbp), %rdi
callq *%rax
leaq -0xa0(%rbp), %rdi
callq 0x1140
leaq -0xa0(%rbp), %rdi
callq 0x11a0
leaq 0x49d0(%rip), %rdi      # 0x6128
callq 0x1200
movq 0x49f4(%rip), %rdi      # 0x6158
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1500
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1790
cmpq $0x0, -0x20(%rbp)
je 0x1790
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
jmp 0x17a2
jmp 0x17a4
leaq -0xa0(%rbp), %rdi
callq 0x10a0
movq -0xa8(%rbp), %rax
movq -0xb0(%rbp), %rdi
callq *%rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/mutex-trie.c
// Function: delete
int delete(const char *string, size_t strlen) {
            int result = 0;
            // Skip strings of length 0
            if (strlen != 0) {
              int rv;
              // Obtain the lock
              rv = pthread_mutex_lock(&lock);
              assert(rv == 0);
              // Attempt to delete the node.
              result = (NULL != _delete(root, string, strlen));

              // if squatting is allowed and a key was deleted.
              if (allow_squatting && result) {
                rv = pthread_mutex_unlock(&lock);
                assert(rv == 0);
                printf("Thread: %lu Node deleted, broadcasting %s\n", (long) pthread_self(), string);
                rv = pthread_cond_broadcast(&cv);
                // Check to see if the broadcasr was successful
                assert(rv == 0);
              } else {
                // Unlock
                rv = pthread_mutex_unlock(&lock);
                assert(rv == 0);
              }
            }
            return result;
          }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x248b
leaq 0x3dcf(%rip), %rdi      # 0x6128
callq 0x1200
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x2369
jmp 0x2388
leaq 0x1ebc(%rip), %rdi      # 0x422c
leaq 0x1ccd(%rip), %rsi      # 0x4044
movl $0x1a1, %edx            # imm = 0x1A1
leaq 0x1fdb(%rip), %rcx      # 0x435e
callq 0x10b0
movq 0x3dc9(%rip), %rdi      # 0x6158
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2050
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
leaq 0x3de2(%rip), %rax      # 0x6198
cmpl $0x0, (%rax)
je 0x2451
cmpl $0x0, -0x14(%rbp)
je 0x2451
leaq 0x3d58(%rip), %rdi      # 0x6128
callq 0x1120
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x23e0
jmp 0x23ff
leaq 0x1e45(%rip), %rdi      # 0x422c
leaq 0x1c56(%rip), %rsi      # 0x4044
movl $0x1a8, %edx            # imm = 0x1A8
leaq 0x1f64(%rip), %rcx      # 0x435e
callq 0x10b0
callq 0x1160
movq %rax, %rsi
movq -0x8(%rbp), %rdx
leaq 0x1f6d(%rip), %rdi      # 0x437f
movb $0x0, %al
callq 0x1090
leaq 0x3d48(%rip), %rdi      # 0x6168
callq 0x1070
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x2430
jmp 0x244f
leaq 0x1df5(%rip), %rdi      # 0x422c
leaq 0x1c06(%rip), %rsi      # 0x4044
movl $0x1ac, %edx            # imm = 0x1AC
leaq 0x1f14(%rip), %rcx      # 0x435e
callq 0x10b0
jmp 0x2489
leaq 0x3cd0(%rip), %rdi      # 0x6128
callq 0x1120
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x2468
jmp 0x2487
leaq 0x1dbd(%rip), %rdi      # 0x422c
leaq 0x1bce(%rip), %rsi      # 0x4044
movl $0x1b0, %edx            # imm = 0x1B0
leaq 0x1edc(%rip), %rcx      # 0x435e
callq 0x10b0
jmp 0x2489
jmp 0x248b
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stevenmherring[P]DNS/mutex-trie.c
// Function: print
void print() {
            int rv;
            // Obtain the lock
            rv = pthread_mutex_lock(&lock);
            assert(rv == 0);

            printf("Root is at %p\n", root);
            /* Do a simple depth-first search */
            if (root)
            _print(root, 0, 0);

            // Unlock
            rv = pthread_mutex_unlock(&lock);
            assert(rv == 0);
          }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3b29(%rip), %rdi      # 0x6128
callq 0x1200
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x260f
jmp 0x262e
leaq 0x1c16(%rip), %rdi      # 0x422c
leaq 0x1a27(%rip), %rsi      # 0x4044
movl $0x1d5, %edx            # imm = 0x1D5
leaq 0x1e87(%rip), %rcx      # 0x44b0
callq 0x10b0
movq 0x3b23(%rip), %rsi      # 0x6158
leaq 0x1e81(%rip), %rdi      # 0x44bd
movb $0x0, %al
callq 0x1090
cmpq $0x0, 0x3b0d(%rip)      # 0x6158
je 0x265d
movq 0x3b04(%rip), %rdi      # 0x6158
xorl %edx, %edx
movl %edx, %esi
callq 0x24a0
leaq 0x3ac4(%rip), %rdi      # 0x6128
callq 0x1120
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x2674
jmp 0x2693
leaq 0x1bb1(%rip), %rdi      # 0x422c
leaq 0x19c2(%rip), %rsi      # 0x4044
movl $0x1de, %edx            # imm = 0x1DE
leaq 0x1e22(%rip), %rcx      # 0x44b0
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/perftests/network-ssl/main.c
// Function: callback_write_test
static int
callback_write_test(void * cookie, ssize_t val)
{

	(void)cookie;

	/* We should have written a single byte, or received an error. */
	assert((val == 1) || (val == -1));

	/* An error occurred. */
	if (val == -1)
		return (-1);

	/* We can stop the event loop peacefully. */
	conndone = 1;

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
je 0x28ce
cmpq $-0x1, -0x18(%rbp)
jne 0x28d0
jmp 0x28ef
leaq 0x77d5(%rip), %rdi      # 0xa0ac
leaq 0x77e8(%rip), %rsi      # 0xa0c6
movl $0x17, %edx
leaq 0x77e3(%rip), %rcx      # 0xa0cd
callq 0x21a0
cmpq $-0x1, -0x18(%rbp)
jne 0x28ff
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2910
movl $0x1, 0xbbcb(%rip)      # 0xe4d4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp64-fast.c
// Function: mtgp64_init
int mtgp64_init(mtgp64_fast_t *mtgp64,
		const mtgp64_params_fast_t *para, uint64_t seed) {
    int rc;
    rc = alloc_state(mtgp64, para);
    if (rc) {
	return rc;
    }
    mtgp64->status->idx = mtgp64->status->size - 1;
    mtgp64_init_state(mtgp64->status->array, para, seed);
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1250
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x11f7
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x123e
movq 0x18(%rsp), %rax
movq 0x1b0(%rax), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq 0x18(%rsp), %rax
movq 0x1b0(%rax), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0x1b0(%rax), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1350
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)