LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/baileywjohnson[P]mpi-matrix-mult/MyMPI.c
// Function: print_submatrix
void print_submatrix (
   void       **a,       /* OUT - Doubly-subscripted array */
   MPI_Datatype dtype,   /* OUT - Type of array elements */
   int          rows,    /* OUT - Matrix rows */
   int          cols)    /* OUT - Matrix cols */
{
   int i, j;

   for (i = 0; i < rows; i++) {
      for (j = 0; j < cols; j++) {
         if (dtype == MPI_DOUBLE)
            printf ("%6.3f ", ((double **)a)[i][j]);
         else {
            if (dtype == MPI_FLOAT)
               printf ("%6.3f ", ((float **)a)[i][j]);
            else if (dtype == MPI_INT)
               printf ("%6d ", ((int **)a)[i][j]);
         }
      }
      putchar ('\n');
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
testl %edx, %edx
jle 0x2ba1
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %eax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %ebx
movq 0x34ae(%rip), %rbp      # 0x5fd0
xorl %r12d, %r12d
cmpl $0x0, 0xc(%rsp)
jle 0x2b8d
xorl %r13d, %r13d
cmpq %rbp, %r14
je 0x2b5e
cmpq 0x34a5(%rip), %r14      # 0x5fe0
je 0x2b6a
cmpq 0x3464(%rip), %r14      # 0x5fa8
jne 0x2b85
movq (%r15,%r12,8), %rax
movl (%rax,%r13,4), %esi
leaq 0x1660(%rip), %rdi      # 0x41b5
xorl %eax, %eax
callq 0x1050
jmp 0x2b85
movq (%r15,%r12,8), %rax
movsd (%rax,%r13,8), %xmm0
jmp 0x2b77
movq (%r15,%r12,8), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r13,4), %xmm0
leaq 0x1630(%rip), %rdi      # 0x41ae
movb $0x1, %al
callq 0x1050
incq %r13
cmpq %r13, %rbx
jne 0x2b2f
movl $0xa, %edi
callq 0x1090
incq %r12
cmpq 0x10(%rsp), %r12
jne 0x2b25
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/baileywjohnson[P]mpi-matrix-mult/MyMPI.c
// Function: print_subvector
void print_subvector (
   void        *a,       /* IN - Array pointer */
   MPI_Datatype dtype,   /* IN - Array type */
   int          n)       /* IN - Array size */
{
   int i;

   for (i = 0; i < n; i++) {
      if (dtype == MPI_DOUBLE)
         printf ("%6.3f ", ((double *)a)[i]);
      else {
         if (dtype == MPI_FLOAT)
            printf ("%6.3f ", ((float *)a)[i]);
         else if (dtype == MPI_INT)
            printf ("%6d \n", ((int *)a)[i]); // WMJ added /n
      }
   }
}

// Assembly:
testl %edx, %edx
jle 0x2c39
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r13d
movq 0x33fd(%rip), %rbp      # 0x5fd0
movq 0x3406(%rip), %r12      # 0x5fe0
xorl %r15d, %r15d
cmpq %rbp, %rbx
je 0x2c04
cmpq %r12, %rbx
je 0x2c0c
cmpq 0x33ba(%rip), %rbx      # 0x5fa8
jne 0x2c23
movl (%r14,%r15,4), %esi
leaq 0x15bf(%rip), %rdi      # 0x41ba
xorl %eax, %eax
callq 0x1050
jmp 0x2c23
movsd (%r14,%r15,8), %xmm0
jmp 0x2c15
xorps %xmm0, %xmm0
cvtss2sd (%r14,%r15,4), %xmm0
leaq 0x1592(%rip), %rdi      # 0x41ae
movb $0x1, %al
callq 0x1050
incq %r15
cmpq %r15, %r13
jne 0x2bdd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/baileywjohnson[P]mpi-matrix-mult/MyMPI.c
// Function: print_col_striped_matrix
void print_col_striped_matrix (
   void       **a,       /* IN - 2D array */
   MPI_Datatype dtype,   /* IN - Type of matrix elements */
   int          m,       /* IN - Matrix rows */
   int          n,       /* IN - Matrix cols */
   MPI_Comm     comm)    /* IN - Communicator */
{
   // WMJ MPI_Status status;     /* Result of receive */
   int        datum_size; /* Bytes per matrix element */
   void      *buffer;     /* Enough room to hold 1 row */
   int        i; //  WMJ , j;
   int        id;         /* Process rank */
   int        p;          /* Number of processes */
   int*       rec_count;  /* Elements received per proc */
   int*       rec_disp;   /* Offset of each proc's block */

   MPI_Comm_rank (comm, &id);
   MPI_Comm_size (comm, &p);
   datum_size = get_size (dtype);
   create_mixed_xfer_arrays (id, p, n, &rec_count,&rec_disp);

   if (!id)
      buffer = my_malloc (id, n*datum_size);

   for (i = 0; i < m; i++) {
      MPI_Gatherv (a[i], BLOCK_SIZE(id,p,n), dtype, buffer,
         rec_count, rec_disp, dtype, 0, MPI_COMM_WORLD);
      if (!id) {
         print_subvector (buffer, dtype, n);
         putchar ('\n');
      }
   }
   free (rec_count);
   free (rec_disp);
   if (!id) {
      free (buffer);
      putchar ('\n');
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movl %ecx, %ebx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
movq %rsp, %rsi
movq %r8, %rdi
callq 0x1170
leaq 0x4(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1b74
movl %eax, %ebp
movq %rsp, %r12
movl (%r12), %edi
movl (%r13), %esi
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl %ebx, %edx
callq 0x1c66
cmpl $0x0, (%r12)
jne 0x2f1c
imull %ebx, %ebp
xorl %edi, %edi
movl %ebp, %esi
callq 0x1be6
movq %rax, %r12
testl %r15d, %r15d
jle 0x2fac
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rbp
movl %r15d, %r15d
xorl %r13d, %r13d
movq 0x20(%rsp), %rax
movq (%rax,%r13,8), %rdi
movl (%rsp), %ecx
leal 0x1(%rcx), %eax
imull %ebx, %eax
movl 0x4(%rsp), %r8d
cltd
idivl %r8d
movl %eax, %esi
imull %ebx, %ecx
movl %ecx, %eax
cltd
idivl %r8d
subl %eax, %esi
subq $0x8, %rsp
movq %r14, %rdx
movq %r12, %rcx
movq 0x20(%rsp), %r8
movq %rbp, %r9
pushq 0x305e(%rip)            # 0x5fd8
pushq $0x0
pushq %r14
callq 0x1200
addq $0x20, %rsp
cmpl $0x0, (%rsp)
jne 0x2fa4
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2bb0
movl $0xa, %edi
callq 0x1090
incq %r13
cmpq %r13, %r15
jne 0x2f3a
movq 0x10(%rsp), %rdi
callq 0x10f0
movq 0x8(%rsp), %rdi
callq 0x10f0
cmpl $0x0, (%rsp)
jne 0x2fd8
movq %r12, %rdi
callq 0x10f0
movl $0xa, %edi
callq 0x1090
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/baileywjohnson[P]mpi-matrix-mult/MyMPI.c
// Function: print_replicated_vector
void print_replicated_vector (
   void        *v,      /* IN - Address of vector */
   MPI_Datatype dtype,  /* IN - Vector element type */
   int          n,      /* IN - Elements in vector */
   MPI_Comm     comm)   /* IN - Communicator */
{
   int id;              /* Process rank */

   MPI_Comm_rank (comm, &id);
   
   if (!id) {
      print_subvector (v, dtype, n);
      printf ("\n\n");
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
movq %rcx, %rdi
movq %r12, %rsi
callq 0x1170
cmpl $0x0, (%r12)
jne 0x3448
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2bb0
leaq 0xd7b(%rip), %rdi       # 0x41be
callq 0x1060
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/8-Synchronization/pthread_race_condition.c
// Function: do_your_job
void *do_your_job(void *input)
{
	int number = *((int *) input);
	int i = 0;

	printf("Thread %d: starts execution.\n", number);

	while(1)
	{

		if(shared < max)		// the shared counter
		{
			shared++;		// writing shared variables
			i++;
			printf("Thread %d: shared = %d.\n", number, shared);
		}
		else
		{
			break;
		}

		sleep(rand() % 2);	// forced context switching
	}

	printf("Thread %d: termination: I'm responsible for %d updates.\n", number, i);

	pthread_exit(0);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl (%rdi), %ebx
leaq 0xd3b(%rip), %rdi       # 0x2004
xorl %ebp, %ebp
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
movl 0x2dee(%rip), %edx      # 0x40c8
cmpl 0x2dec(%rip), %edx      # 0x40cc
jge 0x1327
leaq 0xd39(%rip), %r14       # 0x2022
xorl %ebp, %ebp
incl %edx
movl %edx, 0x2dd5(%rip)      # 0x40c8
incl %ebp
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
callq 0x1100
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
andl $-0x2, %ecx
subl %ecx, %eax
movl %eax, %edi
callq 0x10f0
movl 0x2da9(%rip), %edx      # 0x40c8
cmpl 0x2da7(%rip), %edx      # 0x40cc
jl 0x12eb
leaq 0xd0d(%rip), %rdi       # 0x203b
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1030
xorl %edi, %edi
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/8-Synchronization/pthread_race_condition.c
// Function: main
int main(int argc, char *argv[])
{
	pthread_t *tid;		/* the thread identifiers */
	int thread_num;		/* the total number of threads created */
	int *id, i;

	if(argc != 3)
	{
		fprintf(stderr, "usage: %s [max value] [num of threads]\n", argv[0]);
		exit(1);
	}

	if(atoi(argv[1]) < 0)
	{
		fprintf(stderr, "1st argument must be non-negative\n");
		exit(1);
	}

	if(atoi(argv[2]) < 0)
	{
		fprintf(stderr, "Second argument must be > 0\n");
		exit(1);
	}

/* variable initialization */

	srand(time(NULL));
	max = atoi(argv[1]);
	thread_num = atoi(argv[2]);

	printf("Number of threads created = %d\n", thread_num);
	if( (tid = (pthread_t *) malloc(sizeof(pthread_t) * thread_num)) == NULL)
	{
		perror("malloc()");
		exit(1);
	}

	if( (id = (int *) malloc(sizeof(int) * thread_num)) == NULL)
	{
		perror("malloc()");
		exit(1);
	}

/* create the threads */

	for(i = 0; i < thread_num; i++)
	{
		id[i] = i;
		if(pthread_create(&tid[i], NULL, do_your_job, &id[i]) != 0)
		{
			perror("pthread_create");
			exit(0);
		}
	}

/* now wait for the thread to exit */

	for(i = 0; i < thread_num; i++)
		pthread_join(tid[i], NULL);

/* free the memory */


	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x3, %edi
jne 0x1454
movq 0x8(%rbx), %rdi
callq 0x10b0
testl %eax, %eax
js 0x145c
movq 0x10(%rbx), %rdi
callq 0x10b0
testl %eax, %eax
js 0x1461
xorl %edi, %edi
callq 0x1060
movl %eax, %edi
callq 0x1040
movq 0x8(%rbx), %rdi
callq 0x10b0
movl %eax, 0x2d36(%rip)      # 0x40cc
movq 0x10(%rbx), %rdi
callq 0x10b0
movl %eax, %ebp
leaq 0xd34(%rip), %rdi       # 0x20dc
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
movslq %ebp, %r13
leaq (,%r13,8), %rdi
callq 0x1080
testq %rax, %rax
je 0x1466
movq %rax, %rbx
leaq (,%r13,4), %rdi
callq 0x1080
testq %rax, %rax
je 0x146b
movl %ebp, 0x4(%rsp)
testl %ebp, %ebp
jle 0x1421
movq %rax, %r14
xorl %ebp, %ebp
leaq -0x13b(%rip), %r15      # 0x12bc
movq %rbx, %r12
movl %ebp, (%r14)
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1090
testl %eax, %eax
jne 0x144f
incq %rbp
addq $0x8, %r12
addq $0x4, %r14
cmpq %rbp, %r13
jne 0x13fa
cmpl $0x0, 0x4(%rsp)
jle 0x143e
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
xorl %esi, %esi
callq 0x10e0
incq %r14
cmpq %r14, %r13
jne 0x142b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1147
movq %rbx, %rdi
callq 0x1120
callq 0x11aa
callq 0x1185
callq 0x1170
callq 0x115b
// File: /workspace/github_c_makefile_star2_O1/nmmmnu[P]HM2/test_hm_disktable.c
// Function: dump_file
static int dump_file(const char *filename, const char *keytofind){
	hm_disktable_t *mmf = hm_disktable_opena(filename);

	if (mmf == NULL){
		printf("Can not open file\n");
		exit(1);
	}

	hm_disktable_it_t *it = hm_disktable_it_open(mmf);
	if (it == NULL){
		printf("No memory\n");
		exit(1);
	}

	const hm_pair_t *pair;
	uint64_t i = 0;
	for(pair = hm_disktable_it_first(it); pair; pair = hm_disktable_it_next(it)){
		_print_pair(pair);

		++i;

		if (i >= 10)
			break;
	}

	hm_disktable_it_close(it);

	hm_disktable_close(mmf);
	free(mmf);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x195b
testq %rax, %rax
je 0x15c3
movq %rax, %rbx
movq %rax, %rdi
callq 0x1a6d
testq %rax, %rax
je 0x15cc
movq %rax, %r14
movq %rax, %rdi
callq 0x1a96
testq %rax, %rax
je 0x15a6
movl $0xa, %r15d
movq %rax, %rdi
callq 0x15e2
decq %r15
je 0x15a6
movq %r14, %rdi
callq 0x1aba
testq %rax, %rax
jne 0x158c
movq %r14, %rdi
callq 0x1a91
movq %rbx, %rdi
callq 0x1999
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
leaq 0x1b7d(%rip), %rdi      # 0x3147
jmp 0x15d3
leaq 0x1b6a(%rip), %rdi      # 0x313d
callq 0x1040
movl $0x1, %edi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O1/nmmmnu[P]HM2/test_hm_disktable.c
// Function: print_pair
static void _print_pair(const hm_pair_t *pair){
	if (pair){
		printf("Pair is %s\n", hm_pair_valid(pair, NULL) ? "valid" : "invalid" );
		printf("Pair checksum is %s\n", hm_pair_checksumvalid(pair) ? "valid" : "invalid" );
		printf("---begin---\n");
		hm_pair_printf(pair);
		printf("----end----\n");
	}else{
		printf("Not Found\n");
	}
}

// Assembly:
testq %rdi, %rdi
je 0x165f
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x1820
testl %eax, %eax
leaq 0x1ad6(%rip), %r15      # 0x30d5
leaq 0x1ad1(%rip), %r14      # 0x30d7
movq %r14, %rsi
cmoveq %r15, %rsi
leaq 0x1ab5(%rip), %rdi      # 0x30c9
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
callq 0x1826
testl %eax, %eax
cmoveq %r15, %r14
leaq 0x1aad(%rip), %rdi      # 0x30dd
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x1b22(%rip), %rdi      # 0x3163
callq 0x1040
movq %rbx, %rdi
callq 0x1883
leaq 0x1b1a(%rip), %rdi      # 0x316f
popq %rbx
popq %r14
popq %r15
jmp 0x1040
leaq 0x1af3(%rip), %rdi      # 0x3159
jmp 0x1040
nop
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_09/setjmp_simple.c
// Function: main
int main(int argc, char *argv[])
{
	jmp_buf env;
	int ret;

	ret = setjmp(env);
	printf("setjmp() returned %d\n", ret);
	if (ret)
		return 0;

	longjmp(env, 1);

	printf("never printed!\n");

	return 0;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rsp, %rdi
callq 0x1040
movl %eax, %ebx
leaq 0xe8f(%rip), %rdi       # 0x2004
xorl %eax, %eax
movl %ebx, %esi
callq 0x1030
testl %ebx, %ebx
je 0x118d
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbx
retq
movq %rsp, %rdi
movl $0x1, %esi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/Zarh[P]regps3iso/main.c
// Function: GetExtension
char *GetExtension(char *path)
{
    int n = strlen(path);
    int m = n;

    while(m > 1 && path[m] != '.' && path[m] != '/') m--;
    
	
    if(strcmp(&path[m], ".0")==0 || strcmp(&path[m], ".66600")==0) { // splitted
       m--;
       while(m > 1 && path[m] != '.' && path[m] != '/') m--; 
    }
	
	if(strcasecmp(&path[m], ".bin")==0) {
		if(strcasecmp(&path[m-7], ".header.bin")==0) {
			m-=7;	
		}
	}
  
    if(path[m] == '.') return &path[m];

    return &path[n];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4010f8
movq %rax, %r14
movl %r14d, %r12d
cmpl $0x2, %r14d
jl 0x401b88
movl %r12d, %eax
movb (%rbx,%rax), %al
andb $-0x2, %al
cmpb $0x2e, %al
je 0x401b88
leal -0x1(%r12), %eax
cmpl $0x2, %r12d
movl %eax, %r12d
jg 0x401b68
movl $0x1, %r12d
movslq %r12d, %r15
addq %rbx, %r15
leaq 0xdda82(%rip), %rsi     # 0x4df617
movq %r15, %rdi
callq 0x4010c8
testl %eax, %eax
je 0x401bb4
leaq 0xc146c(%rip), %rsi     # 0x4c3014
movq %r15, %rdi
callq 0x4010c8
testl %eax, %eax
jne 0x401be7
movl %r12d, %eax
cmpl $0x2, %r12d
movl $0x2, %ecx
cmovll %r12d, %ecx
decl %ecx
decq %rax
cmpl $0x3, %r12d
jl 0x401be4
movl %eax, %edx
movb (%rbx,%rdx), %dl
andb $-0x2, %dl
decl %r12d
decq %rax
cmpb $0x2e, %dl
jne 0x401bc9
jmp 0x401be7
movl %ecx, %r12d
movslq %r12d, %r15
leaq (%rbx,%r15), %rdi
leaq 0xc142d(%rip), %rsi     # 0x4c3022
callq 0x401098
testl %eax, %eax
jne 0x401c1c
leal -0x7(%r15), %r12d
leaq (%r15,%rbx), %rdi
addq $-0x7, %rdi
leaq 0xc140a(%rip), %rsi     # 0x4c301b
callq 0x401098
testl %eax, %eax
cmovnel %r15d, %r12d
movslq %r12d, %rcx
movslq %r14d, %rax
addq %rbx, %rax
cmpb $0x2e, (%rbx,%rcx)
leaq (%rbx,%rcx), %rcx
cmoveq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Zarh[P]regps3iso/main.c
// Function: do_task
void do_task(char *path_in, u8 task)
{
	DIR *d;
	struct dirent *dir;
	
	char path[512];
	strcpy(path, path_in);
	int l = strlen(path);
	int i;
	
	for(i=0;i<l;i++){
		if(path[i]=='\\') path[i]='/';
	}
	
	if( is_dir(path) ) {
		d = opendir(path);
		if(d==NULL) return;
		
		while ((dir = readdir(d))) {
			if(!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, "..")) continue;		
			
			char temp[512];
			sprintf(temp, "%s/%s", path, dir->d_name);
			
			if(is_dir(temp)) do_task(temp, task);
			else {
				
				char *ext = GetExtension(temp);
				if( strcasecmp(ext, ".header.bin") == 0 || strcasecmp(ext, ".iso") == 0) {
					do_it(temp, task);
				}
			}
		}
		closedir(d);
	} else {
		do_it(path, task);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp            # imm = 0x498
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0x401020
movq %rbx, %rdi
callq 0x4010f8
testl %eax, %eax
jle 0x403274
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpb $0x5c, 0x90(%rsp,%rcx)
jne 0x40326c
movb $0x2f, 0x90(%rsp,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x40325a
leaq 0x90(%rsp), %rdi
leaq 0x290(%rsp), %rbx
movq %rbx, %rsi
callq 0x465030
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rbx), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4033a7
leaq 0x90(%rsp), %rdi
callq 0x4644c0
testq %rax, %rax
je 0x4033b8
movq %rax, %rbx
movq %rax, %rdi
callq 0x464720
testq %rax, %rax
je 0x40339d
movq %rax, %r12
leaq 0xbff20(%rip), %r14     # 0x4c31f3
leaq 0xbff18(%rip), %r15     # 0x4c31f2
leaq 0x290(%rsp), %r13
movzbl %bpl, %ebp
addq $0x13, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x4010c8
testl %eax, %eax
je 0x403389
movq %r12, %rdi
movq %r15, %rsi
callq 0x4010c8
testl %eax, %eax
je 0x403389
movq %r13, %rdi
leaq 0xbfedf(%rip), %rsi     # 0x4c31f5
leaq 0x90(%rsp), %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x40e170
movq %r13, %rdi
movq %rsp, %rsi
callq 0x465030
movl 0x18(%rsp), %eax
movl $0xf000, %ecx           # imm = 0xF000
andl %ecx, %eax
movq %r13, %rdi
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x403351
movl %ebp, %esi
callq 0x403221
jmp 0x403389
callq 0x401b4c
movq %rax, %r12
movq %rax, %rdi
leaq 0xbfcb8(%rip), %rsi     # 0x4c301b
callq 0x401098
testl %eax, %eax
je 0x40337f
movq %r12, %rdi
leaq 0xbfeed(%rip), %rsi     # 0x4c3263
callq 0x401098
testl %eax, %eax
jne 0x403389
movq %r13, %rdi
movl %ebp, %esi
callq 0x4031e2
movq %rbx, %rdi
callq 0x464720
movq %rax, %r12
testq %rax, %rax
jne 0x4032e6
movq %rbx, %rdi
callq 0x4646f0
jmp 0x4033b8
movzbl %bpl, %esi
leaq 0x90(%rsp), %rdi
callq 0x4031e2
addq $0x498, %rsp            # imm = 0x498
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Zarh[P]regps3iso/main.c
// Function: main
int main (int argc, char **argv)
{	
	if(argc==1) print_help();
	
	u8 task = do_fixps3iso_region;
	verbose=0;
	
	int args = 1;
	if(strcmp(argv[args], "verbose") == 0){
		verbose=1;
		args++;
	}
	
	if(strcmp(argv[args], "do_read_region_info") == 0){
		task=do_read_region_info;
		args++;
	} else
	if(strcmp(argv[args], "do_get_plain_files") == 0){
		task=do_get_plain_files;
		args++;
	} else
	if(strcmp(argv[args], "do_get_enc_files") == 0){
		task=do_get_enc_files;
		args++;
	} else
	if(strcmp(argv[args], "do_fixps3iso_region") == 0){
		task=do_fixps3iso_region;
		args++;
	}
	
	u32 i;
	for(i=args;i<argc;i++) {
		do_task(argv[i], task);
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1, %edi
je 0x4034a2
movq %rsi, %rbx
movl %edi, %ebp
movb $0x0, 0xf3fe9(%rip)     # 0x4f73d0
movq 0x8(%rsi), %rdi
leaq 0xbfe09(%rip), %rsi     # 0x4c31fb
callq 0x4010c8
xorl %r15d, %r15d
testl %eax, %eax
sete 0xf3fcd(%rip)           # 0x4f73d0
sete %r15b
incl %r15d
movq (%rbx,%r15,8), %r14
leaq 0xbfdee(%rip), %rsi     # 0x4c3203
movq %r14, %rdi
callq 0x4010c8
movl $0x1, %r12d
testl %eax, %eax
je 0x403469
leaq 0xbfde9(%rip), %rsi     # 0x4c3217
movq %r14, %rdi
callq 0x4010c8
testl %eax, %eax
je 0x40346d
leaq 0xbfde9(%rip), %rsi     # 0x4c322a
movq %r14, %rdi
callq 0x4010c8
testl %eax, %eax
je 0x403471
leaq 0xbfde7(%rip), %rsi     # 0x4c323b
movq %r14, %rdi
callq 0x4010c8
xorl %r12d, %r12d
testl %eax, %eax
sete %r12b
movb $0x3, %al
jmp 0x403473
xorl %eax, %eax
jmp 0x403473
movb $0x1, %al
jmp 0x403473
movb $0x2, %al
addl %r12d, %r15d
cmpl %ebp, %r15d
jae 0x403497
movl %r15d, %r14d
movl %ebp, %r15d
movzbl %al, %ebp
movq (%rbx,%r14,8), %rdi
movl %ebp, %esi
callq 0x403221
incq %r14
cmpq %r14, %r15
jne 0x403484
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbfda6(%rip), %rdi     # 0x4c324f
callq 0x41d320
xorl %edi, %edi
callq 0x40d570
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Zarh[P]regps3iso/iso.c
// Function: strcpy_malloc
char *strcpy_malloc(char *STR_DEFAULT)
{
	if(STR_DEFAULT==NULL) return NULL;
	u32 size = strlen(STR_DEFAULT)+1;
	char *STR = malloc(size+1);
	if(STR==NULL) return NULL;
	memset(STR, 0, size+1);
	memcpy(STR, STR_DEFAULT, size);
	return STR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x40350d
movq %rdi, %rbx
callq 0x4010f8
movq %rax, %r14
leal 0x2(%rax), %r15d
movq %r15, %rdi
callq 0x42abd0
testq %rax, %rax
je 0x40350d
movq %rax, %r12
incl %r14d
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4010b8
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x401048
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Zarh[P]regps3iso/iso.c
// Function: UTF16_to_UTF8
static void UTF16_to_UTF8(u16 *stw, u8 *stb)
{
    while(SWAP_BE(stw[0])) {
        if((SWAP_BE(stw[0]) & 0xFF80) == 0) {
            *(stb++) = SWAP_BE(stw[0]) & 0xFF;   // utf16 00000000 0xxxxxxx utf8 0xxxxxxx
        } else if((SWAP_BE(stw[0]) & 0xF800) == 0) { // utf16 00000yyy yyxxxxxx utf8 110yyyyy 10xxxxxx
            *(stb++) = ((SWAP_BE(stw[0])>>6) & 0xFF) | 0xC0; *(stb++) = (SWAP_BE(stw[0]) & 0x3F) | 0x80;
        } else if((SWAP_BE(stw[0]) & 0xFC00) == 0xD800 && (SWAP_BE(stw[1]) & 0xFC00) == 0xDC00 ) { // utf16 110110ww wwzzzzyy 110111yy yyxxxxxx (wwww = uuuuu - 1) 
                                                                             // utf8 1111000uu 10uuzzzz 10yyyyyy 10xxxxxx  
            *(stb++)= (((SWAP_BE(stw[0]) + 64)>>8) & 0x3) | 0xF0; *(stb++)= (((SWAP_BE(stw[0])>>2) + 16) & 0x3F) | 0x80; 
            *(stb++)= ((SWAP_BE(stw[0])>>4) & 0x30) | 0x80 | ((SWAP_BE(stw[1])<<2) & 0xF); *(stb++)= (SWAP_BE(stw[1]) & 0x3F) | 0x80;
            stw++;
        } else { // utf16 zzzzyyyy yyxxxxxx utf8 1110zzzz 10yyyyyy 10xxxxxx
            *(stb++)= ((SWAP_BE(stw[0])>>12) & 0xF) | 0xE0; *(stb++)= ((SWAP_BE(stw[0])>>6) & 0x3F) | 0x80; *(stb++)= (SWAP_BE(stw[0]) & 0x3F) | 0x80;
        } 
        
        stw++;
    }
    
    *stb= 0;
}

// Assembly:
movzwl 0xf3b72(%rip), %edx     # 0x4f7c20
leaq 0xf332b(%rip), %rax     # 0x4f73e0
testw %dx, %dx
je 0x4041b8
leaq 0xf3b5b(%rip), %rcx     # 0x4f7c20
testl $0x80ff, %edx           # imm = 0x80FF
je 0x404157
testb $-0x8, %dl
je 0x40418b
movl %edx, %esi
andl $0xfc, %esi
cmpl $0xd8, %esi
jne 0x40415e
movzwl 0x2(%rcx), %esi
andl $0xfc, %esi
cmpl $0xdc, %esi
jne 0x40415e
rolw $0x8, %dx
addl $0x40, %edx
shrl $0x8, %edx
andb $0x3, %dl
orb $-0x10, %dl
movb %dl, (%rax)
movzwl (%rcx), %edx
shrl $0xa, %edx
addb $0x10, %dl
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x1(%rax)
movzwl (%rcx), %edx
movzwl 0x2(%rcx), %esi
movb 0x3(%rcx), %dil
addq $0x2, %rcx
shll $0x4, %edx
andl $0x30, %edx
shrl $0x6, %esi
andl $0xc, %esi
orl %edx, %esi
orb $-0x80, %sil
movb %sil, 0x2(%rax)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x3(%rax)
addq $0x4, %rax
jmp 0x4041a7
movb %dh, (%rax)
incq %rax
jmp 0x4041a7
shrb $0x4, %dl
orb $-0x20, %dl
movb %dl, (%rax)
movzwl (%rcx), %edx
rolw $0x8, %dx
shrl $0x6, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x1(%rax)
movb 0x1(%rcx), %dl
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x2(%rax)
addq $0x3, %rax
jmp 0x4041a7
rolw $0x8, %dx
shrl $0x6, %edx
orb $-0x40, %dl
movb %dl, (%rax)
movb 0x1(%rcx), %dl
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x1(%rax)
addq $0x2, %rax
movzwl 0x2(%rcx), %edx
addq $0x2, %rcx
testw %dx, %dx
jne 0x4040c5
movb $0x0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/Zarh[P]regps3iso/iso.c
// Function: get_iso_path
static void get_iso_path(char *path, int indx) 
{
    char aux[0x420];

    path[0] = 0;

    if(!indx) {path[0] = '/'; path[1] = 0; return;}

    while(1) {
        strcpy(aux, directory_iso2[indx].name);
        strcat(aux, path);
        strcpy(path, aux);
       
        indx = directory_iso2[indx].parent - 1;
        if(indx == 0) break;     
    }

}

// Assembly:
movb $0x0, 0xf363d(%rip)     # 0x4f7800
testl %edi, %edi
je 0x404227
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq 0xf4244(%rip), %r15     # 0x4f8420
movq %rsp, %rbx
leaq 0xf361a(%rip), %r14     # 0x4f7800
movslq %edi, %r12
shlq $0x4, %r12
movq 0x8(%r15,%r12), %rsi
movq %rbx, %rdi
callq 0x401020
movq %rbx, %rdi
movq %r14, %rsi
callq 0x401060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x401020
movl (%r15,%r12), %edi
decl %edi
jne 0x4041e6
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movw $0x2f, 0xf35d0(%rip)    # 0x4f7800
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O1/eiselekd[P]MinimalLisp/l.c
// Function: main
int
main(int argc, char **argv) 
{
    ctx cctx; 
    FILE *f; char *m = 0, *lft; long l, val; int c, ad = 1, i; 
    v *cl = mkCons(0,0), *v, *n, *r;
    memset(&cctx, 0, sizeof(cctx));
    
    if (argv[1] && (f = fopen(argv[1],"r"))) {
        fseek(f, 0, SEEK_END); 
        l = ftell(f);
        fseek(f, 0, SEEK_SET); 
        m = (char *)malloc(l+1);
        fread(m, 1, l, f);
        m[l] = 0;
        fclose(f);
        printf("%s", m);
    }
    v = scan(&cctx, m);
    
    print(&cctx, stderr, v ); printf("\n");

    l_init(&cctx) ;
    
    evlist(&cctx, v, cctx.env);
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl $0x18, %edi
callq 0x10f0
andb $-0x10, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movaps %xmm0, -0x30(%rbp)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2bdb
leaq 0x65e(%rip), %rsi       # 0x31c7
callq 0x1140
testq %rax, %rax
je 0x2bdb
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1130
movq %rbx, %rdi
callq 0x10c0
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1130
leaq 0x1(%r15), %rdi
callq 0x10f0
movq %rax, %r14
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1050
movb $0x0, (%r14,%r15)
movq %rbx, %rdi
callq 0x1060
leaq 0x552(%rip), %rdi       # 0x3121
movq %r14, %rsi
xorl %eax, %eax
callq 0x1080
jmp 0x2bde
xorl %r14d, %r14d
leaq -0x30(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x272c
movq %rax, %rbx
movq 0x2401(%rip), %rax      # 0x4ff8
movq (%rax), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x191b
movl $0xa, %edi
callq 0x1030
movq %r15, %rdi
callq 0x2a6a
testq %rbx, %rbx
je 0x2c3c
leaq -0x30(%rbp), %r14
movq 0x8(%r14), %r15
movq 0x8(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x200a
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x2c24
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0x9/main_test.c
// Function: main
int main(void)
{
	int fail = 0;
	int i = 0;

	printf("===============================\n");
	printf("Programming Pearls: Chapter 0x9\n");
	printf("===============================\n");

	if (test_find_first_10(&i))
		fail++;
	if (test_find_first_1000(&i))
		fail++;
	if (test_find_first1000(&i))
		fail++;
	if (test_find_first1023_512(&i))
		fail++;
	if (test_find_first1023_1000(&i))
		fail++;
	if (test_find_first_flat_1023(&i))
		fail++;

	return fail;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0xeae(%rip), %r14       # 0x2024
movq %r14, %rdi
callq 0x1030
leaq 0xe7f(%rip), %rdi       # 0x2004
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1248
xorl %r14d, %r14d
testl %eax, %eax
setne %r14b
movq %rbx, %rdi
callq 0x1367
leal 0x1(%r14), %ebp
testl %eax, %eax
cmovel %r14d, %ebp
movq %rbx, %rdi
callq 0x1478
cmpl $0x1, %eax
sbbl $-0x1, %ebp
movq %rbx, %rdi
callq 0x1610
cmpl $0x1, %eax
sbbl $-0x1, %ebp
movq %rbx, %rdi
callq 0x1721
cmpl $0x1, %eax
sbbl $-0x1, %ebp
movq %rbx, %rdi
callq 0x1898
cmpl $0x1, %eax
sbbl $-0x1, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0x9/find_first.c
// Function: find_first
int find_first(int v, const int x[], int n)
{
	int l, u;

	l = -1, u = n;
	while (l+1 != u) {
		int m = (l+u)/2;

		if (x[m] < v)
			l = m;
		else
			u = m;
	}

	if (u >= n || x[u] != v)
		return -1;
	return u;
}

// Assembly:
movl %edx, %ecx
testl %edx, %edx
je 0x122f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %edx, %r8d
leal (%r8,%rax), %r9d
movl %r9d, %ecx
shrl $0x1f, %ecx
addl %r9d, %ecx
sarl %ecx
movslq %ecx, %r9
cmpl %edi, (%rsi,%r9,4)
jge 0x1223
movl %ecx, %eax
movl %r8d, %ecx
leal 0x1(%rax), %r9d
movl %ecx, %r8d
cmpl %ecx, %r9d
jne 0x1206
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %edx, %ecx
jge 0x1246
movslq %ecx, %rax
cmpl %edi, (%rsi,%rax,4)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0x9/find_first_test.c
// Function: generate_array
static void generate_array(int x[], int n, enum dup_pos p, int count)
{
	int i, value, start;

	for (i = 0; i < n; i++)
		x[i] = i;
	if (count == 1)
		goto out;

	/* create duplicate */
	switch (p) {
	case DUPLICATE_FRONT:
		value = x[0];
		start = 0;
		break;
	case DUPLICATE_MIDDLE:
		value = x[(n-1)/2];
		start = (n-count)/2;
		break;
	case DUPLICATE_BACK:
		value = x[n-1];
		start = n-count;
		break;
	}
	for (i = 0; i < count; i++)
		x[start+i] = value;
out:
	dump_array(x, n);
}

// Assembly:
testl %esi, %esi
jle 0x130d
movl %esi, %eax
xorl %r8d, %r8d
movl %r8d, (%rdi,%r8,4)
incq %r8
cmpq %r8, %rax
jne 0x1301
cmpl $0x1, %ecx
je 0x1366
cmpl $0x2, %edx
je 0x1340
cmpl $0x1, %edx
je 0x1327
testl %edx, %edx
jne 0x134c
movl (%rdi), %eax
xorl %r8d, %r8d
jmp 0x134c
leal -0x1(%rsi), %eax
shrl %eax
movl (%rdi,%rax,4), %eax
subl %ecx, %esi
movl %esi, %r8d
shrl $0x1f, %r8d
addl %esi, %r8d
sarl %r8d
jmp 0x134c
movslq %esi, %rax
movl -0x4(%rdi,%rax,4), %eax
subl %ecx, %esi
movl %esi, %r8d
testl %ecx, %ecx
jle 0x1366
movslq %r8d, %rdx
movl %ecx, %ecx
leaq (%rdi,%rdx,4), %rdx
xorl %esi, %esi
movl %eax, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x135b
retq
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0x9/find_first1000.c
// Function: find_first1000
int find_first1000(int t, const int x[])
{
	int l, i, p;

	i = 512;
	l = -1;
	if (x[511] < t)
		l = 1000-512;
	while (i != 1) {
		i /= 2;
		if (x[l+i] < t)
			l += i;
	}
	p = l+1;
	if (p == 1000 || x[p] != t)
		p = -1;

	return p;
}

// Assembly:
xorl %ecx, %ecx
cmpl %edi, 0x7fc(%rsi)
setge %cl
negl %ecx
orl $0x1e8, %ecx            # imm = 0x1E8
movl $0x200, %edx            # imm = 0x200
movl %edx, %r8d
shrl $0x1f, %r8d
addl %edx, %r8d
sarl %r8d
leal (%r8,%rcx), %eax
movslq %eax, %r9
cmpl %edi, (%rsi,%r9,4)
jl 0x1454
movl %ecx, %eax
andl $-0x2, %edx
movl %eax, %ecx
cmpl $0x2, %edx
movl %r8d, %edx
jne 0x1438
incl %eax
cmpl $0x3e8, %eax            # imm = 0x3E8
je 0x1472
movslq %eax, %rcx
cmpl %edi, (%rsi,%rcx,4)
je 0x1477
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0x9/find_first1023.c
// Function: find_first1023
int find_first1023(int t, const int x[], unsigned int nr)
{
	int l, i, p;

	assert(512 <= nr && nr < 1024);

	i = 512;
	l = -1;
	if (x[511] < t)
		l = nr-512;
	while (i != 1) {
		i /= 2;
		if (x[l+i] < t)
			l += i;
	}
	p = l+1;
	if (p >= nr || x[p] != t)
		p = -1;
	return p;
}

// Assembly:
movl %edx, %eax
andl $0xfffffe00, %eax       # imm = 0xFFFFFE00
cmpl $0x200, %eax            # imm = 0x200
jne 0x15ef
leal -0x200(%rdx), %eax
cmpl %edi, 0x7fc(%rsi)
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmovll %eax, %r8d
movl $0x200, %ecx            # imm = 0x200
movl %ecx, %r9d
shrl $0x1f, %r9d
addl %ecx, %r9d
sarl %r9d
leal (%r9,%r8), %eax
movslq %eax, %r10
cmpl %edi, (%rsi,%r10,4)
jl 0x15ce
movl %r8d, %eax
andl $-0x2, %ecx
movl %eax, %r8d
cmpl $0x2, %ecx
movl %r9d, %ecx
jne 0x15b1
incl %eax
cmpl %edx, %eax
jae 0x15e9
movl %eax, %ecx
cmpl %edi, (%rsi,%rcx,4)
je 0x15ee
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
pushq %rax
leaq 0xba3(%rip), %rdi       # 0x219a
leaq 0xbb3(%rip), %rsi       # 0x21b1
leaq 0xbbd(%rip), %rcx       # 0x21c2
movl $0xb, %edx
callq 0x1050
nop
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0x9/find_first1023_test.c
// Function: generate_array1023
static void generate_array1023(int x[], unsigned int nr, enum dup_pos p, int count)
{
	int i, value, start;

	for (i = 0; i < nr; i++)
		x[i] = i;

	/* create duplicate */
	switch (p) {
	case DUPLICATE_FRONT:
		value = x[0];
		start = 0;
		break;
	case DUPLICATE_MIDDLE:
		value = x[(nr-1)/2];
		start = (nr-count)/2;
		break;
	case DUPLICATE_BACK:
		value = x[nr-1];
		start = nr-count;
		break;
	}
	for (i = 0; i < count; i++)
		x[start+i] = value;

	dump_array1023(x, nr);
}

// Assembly:
testl %esi, %esi
je 0x16db
movl %esi, %eax
xorl %r8d, %r8d
movl %r8d, (%rdi,%r8,4)
incq %r8
cmpq %r8, %rax
jne 0x16cf
cmpl $0x2, %edx
je 0x16fd
cmpl $0x1, %edx
je 0x16ef
testl %edx, %edx
jne 0x1706
movl (%rdi), %eax
xorl %esi, %esi
jmp 0x1706
leal -0x1(%rsi), %eax
shrl %eax
movl (%rdi,%rax,4), %eax
subl %ecx, %esi
shrl %esi
jmp 0x1706
movslq %esi, %rax
movl -0x4(%rdi,%rax,4), %eax
subl %ecx, %esi
testl %ecx, %ecx
jle 0x1720
movslq %esi, %rdx
movl %ecx, %ecx
leaq (%rdi,%rdx,4), %rdx
xorl %esi, %esi
movl %eax, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x1715
retq
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0x9/find_first_flat.c
// Function: find_first_flat
int find_first_flat(int t, const int x[], int nr)
{
	int l = -1;

	if (x[l+512] < t) l  = nr-512;
	if (x[l+256] < t) l += 256;
	if (x[l+128] < t) l += 128;
	if (x[l+64]  < t) l += 64;
	if (x[l+32]  < t) l += 32;
	if (x[l+16]  < t) l += 16;
	if (x[l+8]   < t) l += 8;
	if (x[l+4]   < t) l += 4;
	if (x[l+2]   < t) l += 2;
	if (x[l+1]   < t) l += 1;

	if (l+1 >= nr || x[l+1] != t)
		return -1;
	return l+1;
}

// Assembly:
cmpl %edi, 0x7fc(%rsi)
leal -0x200(%rdx), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovgel %eax, %ecx
movslq %ecx, %r8
addl $0x100, %ecx            # imm = 0x100
cmpl %edi, 0x400(%rsi,%r8,4)
cmovll %ecx, %r8d
movslq %r8d, %rcx
subl $-0x80, %r8d
cmpl %edi, 0x200(%rsi,%rcx,4)
cmovll %r8d, %ecx
movslq %ecx, %r8
addl $0x40, %ecx
cmpl %edi, 0x100(%rsi,%r8,4)
cmovll %ecx, %r8d
movslq %r8d, %rcx
addl $0x20, %r8d
cmpl %edi, 0x80(%rsi,%rcx,4)
cmovll %r8d, %ecx
movslq %ecx, %r8
addl $0x10, %ecx
cmpl %edi, 0x40(%rsi,%r8,4)
cmovll %ecx, %r8d
movslq %r8d, %rcx
addl $0x8, %r8d
cmpl %edi, 0x20(%rsi,%rcx,4)
cmovll %r8d, %ecx
movslq %ecx, %r8
addl $0x4, %ecx
cmpl %edi, 0x10(%rsi,%r8,4)
cmovll %ecx, %r8d
movslq %r8d, %r9
addl $0x2, %r8d
cmpl %edi, 0x8(%rsi,%r9,4)
cmovll %r8d, %r9d
movslq %r9d, %rcx
incl %r9d
cmpl %edi, 0x4(%rsi,%rcx,4)
cmovll %r9d, %ecx
incl %ecx
cmpl %edx, %ecx
jge 0x1896
movslq %ecx, %rax
cmpl %edi, (%rsi,%rax,4)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/niho[P]elmc/src/elmc.c
// Function: main
int main (int argc, char **argv) {
    if (argc <= 1) {
        print_usage();
    } else if (strcmp(argv[1], "-v") == 0) {
        print_version();
    } else {
        return handle_script(&argv[1]);
    } 
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jg 0x1351
leaq 0xbccb(%rip), %rdi      # 0xd007
leaq 0xbd77(%rip), %rsi      # 0xd0ba
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10b0
jmp 0x1400
movq 0x8(%rsi), %rbx
leaq 0xbca8(%rip), %rsi      # 0xd004
movq %rbx, %rdi
callq 0x1120
testl %eax, %eax
je 0x138e
leaq 0xc174(%rip), %rsi      # 0xd4e3
movq %rbx, %rdi
callq 0x1120
testl %eax, %eax
je 0x13b8
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3160
movq (%r14), %rdi
jmp 0x13d7
leaq 0xbd2a(%rip), %rdi      # 0xd0bf
leaq 0xbd2b(%rip), %rsi      # 0xd0c7
leaq 0xbd2b(%rip), %rdx      # 0xd0ce
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10b0
movl $0xa, %edi
callq 0x1030
jmp 0x1400
movq 0x11c21(%rip), %rax     # 0x12fe0
movq (%rax), %rsi
leaq 0xbd0b(%rip), %rdi      # 0xd0d4
movq %rsp, %rbx
movq %rbx, %rdx
callq 0x30f1
movq (%rbx), %rdi
testl %eax, %eax
je 0x13ed
callq 0x245f
movq (%rsp), %rdi
callq 0x1f89
xorl %ebx, %ebx
jmp 0x1400
callq 0x31ca
movq (%rsp), %rdi
callq 0x31da
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/niho[P]elmc/src/east.c
// Function: elm_ast_new
elm_ast_t *elm_ast_new(int tag, elm_ast_val_t *contents) {
    elm_ast_t *node = malloc(sizeof(elm_ast_t));
    node->tag = tag;
    node->contents = contents;
    node->children_num = 0;
    node->children = NULL;
    return node;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x20, %edi
callq 0x1170
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/niho[P]elmc/src/east.c
// Function: elm_ast_add_child
elm_ast_t *elm_ast_add_child(elm_ast_t *r, elm_ast_t *a) {
    r->children_num++;
    r->children = realloc(r->children, sizeof(elm_ast_t*) * r->children_num);
    r->children[r->children_num-1] = a;
    return r;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x10(%rdi), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x10(%rdi)
movq 0x18(%rdi), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x11a0
movq %rax, 0x18(%r14)
movslq 0x10(%r14), %rcx
movq %rbx, -0x8(%rax,%rcx,8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/niho[P]elmc/src/east.c
// Function: elm_ast_expr
elm_ast_val_t *elm_ast_expr(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_EXPR, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x20, %edi
callq 0x1170
movq %rax, %r14
movl $0x7, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movl $0x0, 0x10(%r14)
movq %rax, 0x18(%r14)
testl %ebp, %ebp
jle 0x1610
movslq 0x10(%r14), %r12
movq 0x18(%r14), %rax
movl %ebp, %r13d
leaq 0x8(,%r12,8), %r15
movq (%rbx), %rbp
movq %rax, %rdi
movq %r15, %rsi
callq 0x11a0
movq %rbp, -0x8(%rax,%r15)
addq $0x8, %rbx
incl %r12d
addq $0x8, %r15
decq %r13
jne 0x15e5
movl %r12d, 0x10(%r14)
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/niho[P]elmc/src/east.c
// Function: elm_ast_list
elm_ast_val_t *elm_ast_list(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_LIST, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x20, %edi
callq 0x1170
movq %rax, %r14
movl $0x8, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movl $0x0, 0x10(%r14)
movq %rax, 0x18(%r14)
testl %ebp, %ebp
jle 0x16c2
movslq 0x10(%r14), %r12
movq 0x18(%r14), %rax
movl %ebp, %r13d
leaq 0x8(,%r12,8), %r15
movq (%rbx), %rbp
movq %rax, %rdi
movq %r15, %rsi
callq 0x11a0
movq %rbp, -0x8(%rax,%r15)
addq $0x8, %rbx
incl %r12d
addq $0x8, %r15
decq %r13
jne 0x1697
movl %r12d, 0x10(%r14)
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/niho[P]elmc/src/east.c
// Function: elm_ast_list_cons
elm_ast_val_t *elm_ast_list_cons(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_LIST, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_t *nx = (elm_ast_t *)xs[x];
        if (nx->tag == ELM_AST_LIST) {
            for (int y = 0; y < nx->children_num; y++) {
                elm_ast_add_child(node, nx->children[y]);
            }
            elm_ast_delete_no_children(nx);
        } else {
            elm_ast_add_child(node, xs[x]);
        }
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movl %edi, %ebp
movl $0x20, %edi
callq 0x1170
movq %rax, %r12
movl $0x8, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movl $0x0, 0x10(%r12)
movq %rax, 0x18(%r12)
testl %ebp, %ebp
jle 0x17e8
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r14, 0x18(%rsp)
movq %r12, 0x10(%rsp)
movq %r13, 0x8(%rsp)
movq (%r14,%rbp,8), %r15
cmpl $0x8, (%r15)
jne 0x17b3
cmpl $0x0, 0x10(%r15)
jle 0x17a9
movslq 0x10(%r12), %r13
movl %r13d, %eax
movq %rax, 0x20(%rsp)
movq 0x18(%r12), %rax
leaq 0x8(,%r13,8), %r12
shlq $0x3, %r13
xorl %ebx, %ebx
movq 0x18(%r15), %rcx
movq (%rcx,%rbx,8), %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0x11a0
movq %rax, %rcx
addq %r13, %rcx
movq %r14, (%rcx,%rbx,8)
incq %rbx
movslq 0x10(%r15), %rcx
addq $0x8, %r12
cmpq %rcx, %rbx
jl 0x175c
movq 0x20(%rsp), %rcx
addl %ebx, %ecx
movq 0x10(%rsp), %r12
movl %ecx, 0x10(%r12)
movq %rax, 0x18(%r12)
movq 0x18(%rsp), %r14
movq 0x8(%rsp), %r13
movq %r15, %rdi
callq 0x17fa
jmp 0x17dc
movslq 0x10(%r12), %rbx
leaq 0x1(%rbx), %rax
movl %eax, 0x10(%r12)
movq 0x18(%r12), %rdi
leaq 0x8(,%rbx,8), %rsi
callq 0x11a0
movq %rax, 0x18(%r12)
movq %r15, (%rax,%rbx,8)
incq %rbp
cmpq %r13, %rbp
jne 0x172b
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/niho[P]elmc/src/east.c
// Function: elm_ast_tuple_cons
elm_ast_val_t *elm_ast_tuple_cons(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_TUPLE, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_t *nx = (elm_ast_t *)xs[x];
        if (nx->tag == ELM_AST_TUPLE) {
            for (int y = 0; y < nx->children_num; y++) {
                elm_ast_add_child(node, nx->children[y]);
            }
            elm_ast_delete_no_children(nx);
        } else {
            elm_ast_add_child(node, xs[x]);
        }
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movl %edi, %ebp
movl $0x20, %edi
callq 0x1170
movq %rax, %r12
movl $0x9, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movl $0x0, 0x10(%r12)
movq %rax, 0x18(%r12)
testl %ebp, %ebp
jle 0x19b6
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r14, 0x18(%rsp)
movq %r12, 0x10(%rsp)
movq %r13, 0x8(%rsp)
movq (%r14,%rbp,8), %r15
cmpl $0x9, (%r15)
jne 0x1981
cmpl $0x0, 0x10(%r15)
jle 0x1977
movslq 0x10(%r12), %r13
movl %r13d, %eax
movq %rax, 0x20(%rsp)
movq 0x18(%r12), %rax
leaq 0x8(,%r13,8), %r12
shlq $0x3, %r13
xorl %ebx, %ebx
movq 0x18(%r15), %rcx
movq (%rcx,%rbx,8), %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0x11a0
movq %rax, %rcx
addq %r13, %rcx
movq %r14, (%rcx,%rbx,8)
incq %rbx
movslq 0x10(%r15), %rcx
addq $0x8, %r12
cmpq %rcx, %rbx
jl 0x192a
movq 0x20(%rsp), %rcx
addl %ebx, %ecx
movq 0x10(%rsp), %r12
movl %ecx, 0x10(%r12)
movq %rax, 0x18(%r12)
movq 0x18(%rsp), %r14
movq 0x8(%rsp), %r13
movq %r15, %rdi
callq 0x17fa
jmp 0x19aa
movslq 0x10(%r12), %rbx
leaq 0x1(%rbx), %rax
movl %eax, 0x10(%r12)
movq 0x18(%r12), %rdi
leaq 0x8(,%rbx,8), %rsi
callq 0x11a0
movq %rax, 0x18(%r12)
movq %r15, (%rax,%rbx,8)
incq %rbp
cmpq %r13, %rbp
jne 0x18f9
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/niho[P]elmc/src/east.c
// Function: elm_ast_if
elm_ast_val_t *elm_ast_if(int i, elm_ast_val_t **xs) {
    assert(i == 6);
    elm_ast_t *node = elm_ast_new(ELM_AST_IF, NULL);
    elm_ast_add_child(node, xs[1]);
    elm_ast_add_child(node, xs[3]);
    elm_ast_add_child(node, xs[5]);
    free(xs[0]);
    free(xs[2]);
    free(xs[4]);
    return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x6, %edi
jne 0x1a80
movq %rsi, %rbx
movl $0x20, %edi
callq 0x1170
movq %rax, %r14
movl $0xa, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movl $0x0, 0x10(%r14)
movq %rax, 0x18(%r14)
movq 0x8(%rbx), %r15
movl $0x1, 0x10(%r14)
movl $0x8, %edi
callq 0x1170
movq %rax, 0x18(%r14)
movq %r15, (%rax)
movq 0x18(%rbx), %r15
movl $0x2, 0x10(%r14)
movl $0x10, %esi
movq %rax, %rdi
callq 0x11a0
movq %rax, 0x18(%r14)
movq %r15, 0x8(%rax)
movq 0x28(%rbx), %r15
movl $0x3, 0x10(%r14)
movl $0x18, %esi
movq %rax, %rdi
callq 0x11a0
movq %rax, 0x18(%r14)
movq %r15, 0x10(%rax)
movq (%rbx), %rdi
callq 0x1230
movq 0x10(%rbx), %rdi
callq 0x1230
movq 0x20(%rbx), %rdi
callq 0x1230
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb69e(%rip), %rdi      # 0xd125
leaq 0xb69e(%rip), %rsi      # 0xd12c
leaq 0xb69e(%rip), %rcx      # 0xd133
movl $0x7c, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/niho[P]elmc/src/east.c
// Function: elm_ast_case
elm_ast_val_t *elm_ast_case(int i, elm_ast_val_t **xs) {
    assert(i == 4);
    //assert(((elm_ast_t *)(xs[1]))->tag == ELM_AST_EXPR);
    assert(((elm_ast_t *)(xs[3]))->tag == ELM_AST_CASE);
    
    elm_ast_t *node = elm_ast_new(ELM_AST_CASE, NULL);
    elm_ast_add_child(node, xs[1]);
    
    elm_ast_t *branches = (elm_ast_t *)xs[3];
    for (int x = 0; x < branches->children_num; x++) {
        elm_ast_add_child(node, branches->children[x]);
    } 
    
    free(xs[0]);
    free(xs[2]);
    elm_ast_delete_no_children(xs[3]);
    
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x4, %edi
jne 0x1ba5
movq %rsi, %rbx
movq 0x18(%rsi), %r12
cmpl $0xb, (%r12)
jne 0x1bc4
movl $0x20, %edi
callq 0x1170
movq %rax, %r14
movl $0xb, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movl $0x0, 0x10(%r14)
movq %rax, 0x18(%r14)
movq 0x8(%rbx), %r15
movl $0x1, 0x10(%r14)
movl $0x8, %edi
callq 0x1170
movq %rax, 0x18(%r14)
movq %r15, (%rax)
cmpl $0x0, 0x10(%r12)
jle 0x1b79
movq %rbx, 0x10(%rsp)
movslq 0x10(%r14), %rbp
movl %ebp, %eax
movq %rax, 0x8(%rsp)
movq 0x18(%r14), %rax
leaq 0x8(,%rbp,8), %r15
shlq $0x3, %rbp
xorl %r13d, %r13d
movq 0x18(%r12), %rcx
movq (%rcx,%r13,8), %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x11a0
movq %rax, %rcx
addq %rbp, %rcx
movq %rbx, (%rcx,%r13,8)
incq %r13
movslq 0x10(%r12), %rcx
addq $0x8, %r15
cmpq %rcx, %r13
jl 0x1b35
movq 0x8(%rsp), %rcx
addl %r13d, %ecx
movl %ecx, 0x10(%r14)
movq %rax, 0x18(%r14)
movq 0x10(%rsp), %rbx
movq (%rbx), %rdi
callq 0x1230
movq 0x10(%rbx), %rdi
callq 0x1230
movq 0x18(%rbx), %rdi
callq 0x17fa
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb5b8(%rip), %rdi      # 0xd164
leaq 0xb579(%rip), %rsi      # 0xd12c
leaq 0xb5b1(%rip), %rcx      # 0xd16b
movl $0x88, %edx
callq 0x10c0
leaq 0xb5d3(%rip), %rdi      # 0xd19e
leaq 0xb55a(%rip), %rsi      # 0xd12c
leaq 0xb592(%rip), %rcx      # 0xd16b
movl $0x8a, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/niho[P]elmc/src/east.c
// Function: elm_ast_branches
elm_ast_val_t *elm_ast_branches(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_CASE, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x20, %edi
callq 0x1170
movq %rax, %r14
movl $0xb, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movl $0x0, 0x10(%r14)
movq %rax, 0x18(%r14)
testl %ebp, %ebp
jle 0x1c5a
movslq 0x10(%r14), %r12
movq 0x18(%r14), %rax
movl %ebp, %r13d
leaq 0x8(,%r12,8), %r15
movq (%rbx), %rbp
movq %rax, %rdi
movq %r15, %rsi
callq 0x11a0
movq %rbp, -0x8(%rax,%r15)
addq $0x8, %rbx
incl %r12d
addq $0x8, %r15
decq %r13
jne 0x1c2f
movl %r12d, 0x10(%r14)
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq