LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/symbol.c
// Function: list_sym
void list_sym() {
	refknt = locknt = symknt = 0;
	fprintf(file_lst, "\nErrors detected in %d line", errcount);
	if (errcount != 1) fprintf(file_lst, "s");
	fprintf(file_lst, ".\n\f\n");
	fprintf(file_lst, " value name                            ");
	if (prnxref) fprintf(file_lst, "cross reference");
	fprintf(file_lst, "\n");
	if (root_symtab) output_symbol(root_symtab);
	fprintf(file_lst,
	        "\n\nMemory used to store %d local symbols: %d. bytes.", locknt,
	        26 * locknt);
	fprintf(file_lst,
	        "\n\nMemory used to store %d permanent symbols: %d. bytes.",
	        symknt - locknt, SYMBLKSZ * symblk + symbol_ptr - locknt * 26);
	if (!prnxref) return;
	fprintf(file_lst,
	        "\n\nMemory used for cross reference table: %ld. bytes.",
	        (long)refknt * (long)sizeof(struct xrfr));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %eax, %eax
movl %eax, 0x5666(%rip)      # 0xe650
movl %eax, 0x5664(%rip)      # 0xe654
movl %eax, 0x5662(%rip)      # 0xe658
leaq 0x4a93(%rip), %rbx      # 0xda90
movq (%rbx), %rdi
leaq 0x4811(%rip), %r14      # 0xd818
movl (%r14), %edx
leaq 0x1c9a(%rip), %rsi      # 0xacab
xorl %eax, %eax
callq 0x1140
cmpl $0x1, (%r14)
je 0x902b
movq (%rbx), %rsi
movl $0x73, %edi
callq 0x1110
movq (%rbx), %rcx
leaq 0x1c92(%rip), %rdi      # 0xacc7
movl $0x4, %esi
movl $0x1, %edx
callq 0x1210
movq (%rbx), %rcx
leaq 0x1c7e(%rip), %rdi      # 0xaccc
movl $0x27, %esi
movl $0x1, %edx
callq 0x1210
leaq 0x48f8(%rip), %r14      # 0xd95c
cmpl $0x0, (%r14)
je 0x9083
movq (%rbx), %rcx
leaq 0x18bb(%rip), %rdi      # 0xa92f
movl $0xf, %esi
movl $0x1, %edx
callq 0x1210
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1110
leaq 0x4a19(%rip), %rax      # 0xdab0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x90a4
callq 0x8e6f
movq (%rbx), %rdi
movl 0x55a7(%rip), %edx      # 0xe654
leal (%rdx,%rdx,4), %eax
leal (%rax,%rax,4), %ecx
addl %edx, %ecx
leaq 0x1c38(%rip), %rsi      # 0xacf4
xorl %eax, %eax
callq 0x1140
movq (%rbx), %rdi
movl 0x5584(%rip), %edx      # 0xe650
movl 0x5582(%rip), %eax      # 0xe654
subl %eax, %edx
movl 0x45be(%rip), %esi      # 0xd698
shll $0xc, %esi
imull $-0x1a, %eax, %ecx
addl 0x45b6(%rip), %ecx      # 0xd69c
addl %esi, %ecx
leaq 0x1c39(%rip), %rsi      # 0xad28
xorl %eax, %eax
callq 0x1140
cmpl $0x0, (%r14)
je 0x911f
movq (%rbx), %rdi
movslq 0x5552(%rip), %rdx      # 0xe658
shlq $0x4, %rdx
leaq 0x1c4f(%rip), %rsi      # 0xad60
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1140
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mist64[P]cbm6502asm/src/symbol.c
// Function: clear_local
void clear_local() { /* increment the local symbol block number */
	int i;
	for (i = 0; i < 4; i++) {
		if (++lbn[i] <= 'Z') return;
		lbn[i] = 'A';
	}
}

// Assembly:
xorl %eax, %eax
leaq 0x46ec(%rip), %rcx      # 0xd81c
movb (%rcx,%rax), %dl
incb %dl
movb %dl, (%rcx,%rax)
cmpb $0x5b, %dl
jl 0x914a
movb $0x41, (%rcx,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x9130
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/trivia0v2/ref/encrypt.c
// Function: load_SC
u64 load64(const u8 *Bytes)
{int i; u64 temp, 
Block=0;
Block = Bytes[0];
for(i = 1; i <8; i++) {Block <<= 8; Block = (Block)^(u64)(Bytes[i]);} return Block;}

// Assembly:
movzbl (%rsi), %eax
movl $0x1, %ecx
movq %rax, %r8
shlq $0x8, %r8
movzbl (%rsi,%rcx), %eax
orq %r8, %rax
incq %rcx
cmpq $0x8, %rcx
jne 0x12f5
movq %rax, (%rdi)
movzbl 0x8(%rsi), %eax
movq $-0x7, %rcx
movq %rax, %r8
shlq $0x8, %r8
movzbl 0x10(%rsi,%rcx), %eax
orq %r8, %rax
incq %rcx
jne 0x131a
movq %rax, 0x8(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%rdi)
movq $0x3800000, 0x20(%rdi)  # imm = 0x3800000
movq $0x0, 0x28(%rdi)
movzbl (%rdx), %eax
movl $0x1, %ecx
movq %rax, %rsi
shlq $0x8, %rsi
movzbl (%rdx,%rcx), %eax
orq %rsi, %rax
incq %rcx
cmpq $0x8, %rcx
jne 0x1353
movq %rax, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_05/any.c
// Function: main
int main(void)
{
  char str1[MAXSTR] = "xxxabcabc";
  char str2[MAXSTR] = "cbaa";

  printf("%d", any(str1, str2));

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movq %rsp, %r14
xorl %ebx, %ebx
movl $0x3e8, %edx            # imm = 0x3E8
movq %r14, %rdi
xorl %esi, %esi
callq 0x1040
movl $0x61616263, (%r14)     # imm = 0x61616263
leaq 0x1(%rsp), %rax
movb $0x78, %cl
leaq 0xe91(%rip), %rdx       # 0x2010
movb $0x63, %dil
movq %rax, %rsi
cmpb %dil, %cl
je 0x11a7
movb (%rsi), %dil
incq %rsi
testb %dil, %dil
jne 0x1185
movb 0x1(%rbx,%rdx), %cl
incq %rbx
cmpq $0x9, %rbx
jne 0x117f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x124a(%rip), %rdi      # 0x23f8
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_05/any.c
// Function: any
int any(char str1[], char str2[])
{
  int i, j;
  for (i = 0; str1[i] != '\0'; ++i)
  {
    for (j = 0; str2[j] != '\0'; ++j)
    {
      if (str1[i] == str2[j])
      {
        return i;
      }
    }
  }

  return -1;
}

// Assembly:
movb (%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x11fd
movb (%rsi), %dl
incq %rsi
xorl %r8d, %r8d
movq %rsi, %r9
movl %edx, %r10d
testb %dl, %dl
je 0x11f1
cmpb %r10b, %cl
je 0x11fe
movb (%r9), %r10b
incq %r9
testb %r10b, %r10b
jne 0x11e1
movb 0x1(%rdi,%r8), %cl
incq %r8
testb %cl, %cl
jne 0x11d7
retq
movl %r8d, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/test/test_log.c
// Function: main
int main(int argc,char **argv)
{
	if (argc != 3) {
		help();
		return -1;
	}
	LOG_compBinFile(argv[1],argv[2],28*28*500*sizeof(float));
	
	
	return 0;
}

// Assembly:
pushq %rax
cmpl $0x3, %edi
jne 0x1222
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rsi
movl $0x17ed00, %edx         # imm = 0x17ED00
callq 0x1762
xorl %eax, %eax
jmp 0x123f
leaq 0x1ddb(%rip), %rdi      # 0x3004
callq 0x10d0
leaq 0x1ddd(%rip), %rdi      # 0x3012
callq 0x10d0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/log.c
// Function: LOG_writeBlobToBinFile
int LOG_writeBlobToBinFile(char *binFile,BLOB_s *pBlob)
{
	int fd = open(binFile,O_RDWR | O_CREAT,0666);
	CHECK_EXPR_RET(fd < 0,-1);

	BLOB_DATA_TYPE *pData = BLOB_data(pBlob);

	int writeSize = sizeof(BLOB_DATA_TYPE)*pBlob->count;
	int nwrite = write(fd,&pData[0],writeSize);
	CHECK_EXPR_RET(nwrite != writeSize,-1);

	close(fd);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl $0x42, %esi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x1080
testl %eax, %eax
js 0x1718
movl %eax, %ebx
movq %r14, %rdi
callq 0x1fdc
movl 0x30(%r14), %ecx
shll $0x3, %ecx
movslq %ecx, %r14
movl %ebx, %edi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1050
cmpl %eax, %r14d
jne 0x1734
movl %ebx, %edi
callq 0x10e0
xorl %eax, %eax
jmp 0x175a
leaq 0x1921(%rip), %rdi      # 0x3040
leaq 0x1930(%rip), %rsi      # 0x3056
leaq 0x195f(%rip), %rdx      # 0x308c
movl $0x57, %ecx
jmp 0x174e
leaq 0x1905(%rip), %rdi      # 0x3040
leaq 0x1914(%rip), %rsi      # 0x3056
leaq 0x1943(%rip), %rdx      # 0x308c
movl $0x5d, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_create
int BLOB_create(BLOB_s **pBlob,
						unsigned long numSize,
						unsigned long channelSize, 
						unsigned long heightSize,
						unsigned long widthSize,
						BOOL bShape)
{
	unsigned long counts = 0;
	CHECK_EXPR_RET(numSize <= 0,-1);
	CHECK_EXPR_RET(channelSize <= 0,-1);
	CHECK_EXPR_RET(heightSize <= 0,-1);
	CHECK_EXPR_RET(widthSize <= 0,-1);

	CHECK_EXPR_RET(pBlob == NULL,-1);

	*pBlob = (BLOB_s *)malloc(sizeof(BLOB_s));
	CHECK_EXPR_RET(*pBlob == NULL,-1);

	(*pBlob)->numSize = numSize;
	(*pBlob)->widthSize = widthSize;
	(*pBlob)->heightSize = heightSize;
	(*pBlob)->channelSize = channelSize;
	
	counts = (*pBlob)->numSize * (*pBlob)->channelSize *\
				(*pBlob)->heightSize * (*pBlob)->widthSize;
	
	(*pBlob)->pady = 0;
	(*pBlob)->padx = 0;
	(*pBlob)->count = counts;
	if (bShape == TRUE) {
		BLOB_shape(*pBlob);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x19f5
movq %rdx, %r15
testq %rdx, %rdx
je 0x1a14
movq %rcx, %r14
testq %rcx, %rcx
je 0x1a30
movq %r8, %r12
testq %r8, %r8
je 0x1a4c
movq %rdi, %rbp
testq %rdi, %rdi
je 0x1a68
movl %r9d, %ebx
movq %rsi, %r13
movl $0x40, %edi
callq 0x10a0
movq %rax, (%rbp)
testq %rax, %rax
je 0x1a84
movq %r13, 0x10(%rax)
movq %r12, 0x28(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
imulq %r13, %r15
imulq %r12, %r14
imulq %r15, %r14
movq $0x0, 0x38(%rax)
movq %r14, 0x30(%rax)
xorl %ebp, %ebp
cmpb $0x1, %bl
jne 0x1aaa
movq %rax, %rdi
callq 0x1abb
jmp 0x1aaa
leaq 0x1644(%rip), %rdi      # 0x3040
leaq 0x16fa(%rip), %rsi      # 0x30fd
leaq 0x16fa(%rip), %rdx      # 0x3104
movl $0xc, %ecx
jmp 0x1a9e
leaq 0x1625(%rip), %rdi      # 0x3040
leaq 0x16db(%rip), %rsi      # 0x30fd
leaq 0x16db(%rip), %rdx      # 0x3104
movl $0xd, %ecx
jmp 0x1a9e
leaq 0x1609(%rip), %rdi      # 0x3040
leaq 0x16bf(%rip), %rsi      # 0x30fd
leaq 0x16bf(%rip), %rdx      # 0x3104
movl $0xe, %ecx
jmp 0x1a9e
leaq 0x15ed(%rip), %rdi      # 0x3040
leaq 0x16a3(%rip), %rsi      # 0x30fd
leaq 0x16a3(%rip), %rdx      # 0x3104
movl $0xf, %ecx
jmp 0x1a9e
leaq 0x15d1(%rip), %rdi      # 0x3040
leaq 0x1687(%rip), %rsi      # 0x30fd
leaq 0x1687(%rip), %rdx      # 0x3104
movl $0x11, %ecx
jmp 0x1a9e
leaq 0x15b5(%rip), %rdi      # 0x3040
leaq 0x166b(%rip), %rsi      # 0x30fd
leaq 0x166b(%rip), %rdx      # 0x3104
movl $0x14, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_shape
int BLOB_shape(BLOB_s *pBlob)
{
	CHECK_EXPR_RET(pBlob == NULL,-1);
	pBlob->data = (BLOB_DATA_TYPE *)malloc(sizeof(BLOB_DATA_TYPE)*pBlob->count);
	memset(pBlob->data,0,pBlob->count * sizeof(BLOB_DATA_TYPE));
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1aec
movq %rdi, %rbx
movq 0x30(%rdi), %r14
shlq $0x3, %r14
movq %r14, %rdi
callq 0x10a0
movq %rax, 0x8(%rbx)
xorl %ebx, %ebx
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1070
jmp 0x1b12
leaq 0x154d(%rip), %rdi      # 0x3040
leaq 0x1603(%rip), %rsi      # 0x30fd
leaq 0x1641(%rip), %rdx      # 0x3142
movl $0x65, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_createAddPad
int BLOB_createAddPad(BLOB_s **pBlob,
						unsigned long numSize,
						unsigned long channelSize, 
						unsigned long heightSize,
						unsigned long widthSize,
						BOOL bShape,int pady,int padx)
{
	int ret = BLOB_create(pBlob,numSize,channelSize,heightSize+pady*2,widthSize+padx*2,bShape);
	CHECK_EXPR_RET(ret != 0,-1);

	BLOB_s *blob = *pBlob;
	blob->pady = pady;
	blob->padx = padx;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x28(%rsp), %r14d
movl 0x20(%rsp), %r15d
leal (%r15,%r15), %eax
cltq
addq %rax, %rcx
leal (%r14,%r14), %eax
cltq
addq %rax, %r8
callq 0x1954
testl %eax, %eax
je 0x1b71
leaq 0x14f0(%rip), %rdi      # 0x3040
leaq 0x15a6(%rip), %rsi      # 0x30fd
leaq 0x15b2(%rip), %rdx      # 0x3110
movl $0x30, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1b7e
movq (%rbx), %rax
movl %r15d, 0x38(%rax)
movl %r14d, 0x3c(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_shapeAddPad
int BLOB_shapeAddPad(BLOB_s *pDataSrc,BLOB_s *pData,int pady,int padx)
{
	CHECK_EXPR_RET(pDataSrc == NULL,-1);
	CHECK_EXPR_RET(pData == NULL,-1);
	CHECK_EXPR_RET(pady > pDataSrc->heightSize,-1);
	CHECK_EXPR_RET(padx > pDataSrc->widthSize,-1);
	
	BLOB_DATA_PTR(pDataSrc,ptrDataSrc);
	BLOB_DATA_PTR(pData,ptrData);
	for (int i_num = 0;i_num < pData->numSize;i_num++) {	
		for (int i_channel = 0;i_channel  < pData->channelSize;i_channel++) {
			for (int i_height = 0;i_height < pData->heightSize - pady;i_height++) {	
				for (int i_width = 0;i_width < pData->widthSize - padx;i_width++) {	
					ptrData[i_num][i_channel][i_height + pady][i_width + padx] = 
						ptrDataSrc[i_num][i_channel][i_height][i_width];	
				
				}
			}
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
je 0x1d0e
testq %rsi, %rsi
je 0x1d15
movl %ecx, %eax
movq %rdi, %r10
movslq %edx, %rdx
movq 0x20(%rdi), %r8
movl $0x3d, %ecx
movq %rdx, 0x10(%rsp)
cmpq %rdx, %r8
jb 0x1d1a
cltq
movq 0x28(%r10), %r9
movl $0x3e, %ecx
cmpq %rax, %r9
jb 0x1d1a
movq 0x10(%rsi), %rcx
movq %rcx, 0x28(%rsp)
testq %rcx, %rcx
je 0x1d0a
movq %r8, %rdi
movq 0x8(%r10), %rcx
movq %rcx, 0x8(%rsp)
movq 0x18(%rsi), %r8
movq 0x28(%rsi), %rbx
movq 0x20(%rsi), %r11
movq %r11, %r15
movq 0x10(%rsp), %rdx
subq %rdx, %r15
movq %rbx, %r12
subq %rax, %r12
movq %rbx, %rcx
imulq %rdx, %rcx
leaq (,%rax,8), %rdx
leaq (%rdx,%rcx,8), %rcx
addq 0x8(%rsi), %rcx
movq %rcx, (%rsp)
movq %rbx, %rcx
movq %r11, 0x40(%rsp)
imulq %r11, %rcx
movq %rcx, %rdx
movq %r8, %rsi
imulq %r8, %rdx
shlq $0x3, %rdx
movq %rdx, 0x20(%rsp)
shlq $0x3, %rcx
movq %rcx, 0x38(%rsp)
leaq (,%rbx,8), %rcx
movq %rdi, %r11
imulq %r9, %r11
movq 0x18(%r10), %rdx
imulq %r11, %rdx
shlq $0x3, %rdx
movq %rdx, 0x18(%rsp)
shlq $0x3, %r11
shlq $0x3, %r9
xorl %edi, %edi
movq %rdi, 0x30(%rsp)
testq %rsi, %rsi
je 0x1ce4
movq 0x8(%rsp), %rbp
movq (%rsp), %rdx
xorl %edi, %edi
movq 0x40(%rsp), %r8
cmpq 0x10(%rsp), %r8
je 0x1cd4
movq %rbp, %r10
movq %rdx, %r13
xorl %r8d, %r8d
cmpq %rax, %rbx
je 0x1cc6
xorl %r14d, %r14d
movsd (%r10,%r14,8), %xmm0
movsd %xmm0, (%r13,%r14,8)
incq %r14
cmpq %r14, %r12
jne 0x1cb1
incq %r8
addq %rcx, %r13
addq %r9, %r10
cmpq %r15, %r8
jne 0x1ca9
incq %rdi
addq 0x38(%rsp), %rdx
addq %r11, %rbp
cmpq %rsi, %rdi
jne 0x1c94
movq 0x30(%rsp), %rdi
incq %rdi
movq 0x20(%rsp), %rdx
addq %rdx, (%rsp)
movq 0x18(%rsp), %rdx
addq %rdx, 0x8(%rsp)
cmpq 0x28(%rsp), %rdi
jne 0x1c7f
xorl %eax, %eax
jmp 0x1d3b
movl $0x3b, %ecx
jmp 0x1d1a
movl $0x3c, %ecx
leaq 0x131f(%rip), %rdi      # 0x3040
leaq 0x13d5(%rip), %rsi      # 0x30fd
leaq 0x13f3(%rip), %rdx      # 0x3122
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_shapeLike
int BLOB_shapeLike(BLOB_s *pDataSrc,BLOB_s **pData)
{
	CHECK_EXPR_RET(pDataSrc == NULL,-1);
	CHECK_EXPR_RET(pData == NULL,-1);

	*pData = (BLOB_s *)malloc(sizeof(BLOB_s));
	CHECK_EXPR_RET(*pData == NULL,-1);

	memcpy(*pData,pDataSrc,sizeof(BLOB_s));
	
	BLOB_shape(*pData);
	
	return 0;	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1d9a
movq %rsi, %r14
testq %rsi, %rsi
je 0x1db6
movq %rdi, %rbx
movl $0x40, %edi
callq 0x10a0
movq %rax, (%r14)
testq %rax, %rax
je 0x1dd2
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x30(%rbx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq %rax, %rdi
callq 0x1abb
xorl %eax, %eax
jmp 0x1df8
leaq 0x129f(%rip), %rdi      # 0x3040
leaq 0x1355(%rip), %rsi      # 0x30fd
leaq 0x1384(%rip), %rdx      # 0x3133
movl $0x55, %ecx
jmp 0x1dec
leaq 0x1283(%rip), %rdi      # 0x3040
leaq 0x1339(%rip), %rsi      # 0x30fd
leaq 0x1368(%rip), %rdx      # 0x3133
movl $0x56, %ecx
jmp 0x1dec
leaq 0x1267(%rip), %rdi      # 0x3040
leaq 0x131d(%rip), %rsi      # 0x30fd
leaq 0x134c(%rip), %rdx      # 0x3133
movl $0x59, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_shapeByPtr
int BLOB_shapeByPtr(BLOB_s *pBlob,BLOB_DATA_TYPE *pData,int len)
{
	CHECK_EXPR_RET(pData == NULL,-1);
	CHECK_EXPR_RET(pBlob == NULL,-1);
	CHECK_EXPR_RET(len != pBlob->count,-1);
	
	BLOB_shape(pBlob);
	BLOB_DATA_PTR(pBlob,ptr);
	int k = 0;
	for (int i_num = 0;i_num < pBlob->numSize;i_num++) {	
		for (int i_channel = 0;i_channel  < pBlob->channelSize;i_channel++) {
			for (int i_height = 0;i_height < pBlob->heightSize;i_height++) {	
				for (int i_width = 0;i_width < pBlob->widthSize;i_width++) {	
					ptr[i_num][i_channel][i_height][i_width] = pData[k++];	
				}
			}
		}
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x1f07
movq %rdi, %r14
testq %rdi, %rdi
je 0x1f0e
movslq %edx, %rax
movq 0x30(%r14), %r15
movl $0x6f, %ecx
cmpq %rax, %r15
jne 0x1f13
movq %rsi, %rbx
shlq $0x3, %r15
movq %r15, %rdi
callq 0x10a0
movq %rax, 0x8(%r14)
xorl %ebp, %ebp
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1070
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1f34
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rsi
movq 0x8(%r14), %rdi
movq %rsi, %r8
imulq %rdx, %r8
movq %r8, %rax
imulq %rcx, %rax
shlq $0x3, %rax
movq %rax, 0x8(%rsp)
shlq $0x3, %r8
leaq (,%rsi,8), %r10
xorl %r11d, %r11d
xorl %ebp, %ebp
testq %rcx, %rcx
je 0x1ef4
movq %rdi, %r14
xorl %r15d, %r15d
testq %rdx, %rdx
je 0x1ee9
movq %r14, %r12
xorl %r13d, %r13d
testq %rsi, %rsi
je 0x1ede
movslq %ebp, %rax
leaq (%rbx,%rax,8), %r9
xorl %eax, %eax
movsd (%r9,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
incq %rax
cmpq %rax, %rsi
jne 0x1ec8
addl %eax, %ebp
incq %r13
addq %r10, %r12
cmpq %rdx, %r13
jne 0x1eba
incq %r15
addq %r8, %r14
cmpq %rcx, %r15
jne 0x1eaf
incq %r11
addq 0x8(%rsp), %rdi
cmpq 0x10(%rsp), %r11
jne 0x1ea4
xorl %ebp, %ebp
jmp 0x1f34
movl $0x6d, %ecx
jmp 0x1f13
movl $0x6e, %ecx
leaq 0x1126(%rip), %rdi      # 0x3040
leaq 0x11dc(%rip), %rsi      # 0x30fd
leaq 0x1225(%rip), %rdx      # 0x314d
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_printPara
void BLOB_printPara(BLOB_s *pBolb)
{	
	printf("num:     %ld\n",pBolb->numSize);
	printf("channel: %ld\n",pBolb->channelSize);
	printf("height:  %ld\n",pBolb->heightSize);
	printf("width:   %ld\n",pBolb->widthSize);
	printf("size:    %ld\n",pBolb->count);
	printf("bytes:   %ld\n",pBolb->count*sizeof(BLOB_DATA_TYPE));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
leaq 0x11e7(%rip), %rdi      # 0x315d
xorl %eax, %eax
callq 0x1030
movq 0x18(%rbx), %rsi
leaq 0x11e3(%rip), %rdi      # 0x316b
xorl %eax, %eax
callq 0x1030
movq 0x20(%rbx), %rsi
leaq 0x11df(%rip), %rdi      # 0x3179
xorl %eax, %eax
callq 0x1030
movq 0x28(%rbx), %rsi
leaq 0x11db(%rip), %rdi      # 0x3187
xorl %eax, %eax
callq 0x1030
movq 0x30(%rbx), %rsi
leaq 0x11d7(%rip), %rdi      # 0x3195
xorl %eax, %eax
callq 0x1030
movq 0x30(%rbx), %rsi
shlq $0x3, %rsi
leaq 0x11cf(%rip), %rdi      # 0x31a3
xorl %eax, %eax
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_print
void BLOB_print(BLOB_s *pBlob)
{
	CHECK_EXPR_RET_VOID(pBlob==NULL);
	
	unsigned long batches = 1/*pBlob->batches*/;
	unsigned long width = pBlob->widthSize;
	unsigned long height = pBlob->heightSize;
	unsigned long num = pBlob->numSize;
	unsigned long channels = pBlob->channelSize;
	
	BLOB_DATA_PTR(pBlob,ptr);
	for (int i_channel = 0;i_channel  < channels;i_channel++) {
		for (int i_batch = 0;i_batch < batches;i_batch++) {
			for (int i_num = 0;i_num < num;i_num++) {	
				for (int i_height = 0;i_height < height;i_height++) {	
					for (int i_width = 0;i_width < width;i_width++) {	
						printf("%lf ",ptr[i_num][i_channel][i_height+pBlob->pady][i_width+pBlob->padx]);	
					}
					printf(" ");
				}
				printf("  ");
			}
			printf("\n");
		}
		printf(" ");
	}
}

// Assembly:
testq %rdi, %rdi
je 0x2199
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x218a
movq 0x28(%rbx), %r13
movq 0x20(%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x40(%rsp)
movq 0x10(%rbx), %rcx
movq %rcx, 0x28(%rsp)
movq %rax, %rcx
imulq %r13, %rcx
movq %rcx, 0x38(%rsp)
movq %rax, 0x30(%rsp)
imulq 0x20(%rsp), %rax
imulq %r13, %rax
movq %rax, 0x48(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x215e
movq 0x38(%rsp), %rax
imulq 0x8(%rsp), %rax
movq 0x40(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
movq %rax, 0x50(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2138
movq 0x48(%rsp), %rax
imulq 0x10(%rsp), %rax
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax,8), %r12
movq $0x0, 0x18(%rsp)
testq %r13, %r13
leaq 0x10db(%rip), %r14      # 0x31bc
je 0x211a
movslq 0x18(%rsp), %rbp
xorl %r15d, %r15d
movslq 0x38(%rbx), %rax
addq %rbp, %rax
imulq %r13, %rax
leaq (%r12,%rax,8), %rax
movl 0x3c(%rbx), %ecx
addl %r15d, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1030
incq %r15
cmpq %r15, %r13
jne 0x20eb
movl $0x20, %edi
callq 0x10b0
movq 0x18(%rsp), %rcx
incq %rcx
movq %rcx, 0x18(%rsp)
cmpq 0x30(%rsp), %rcx
jne 0x20d7
leaq 0x1082(%rip), %rdi      # 0x31c1
xorl %eax, %eax
callq 0x1030
movq 0x10(%rsp), %rcx
incq %rcx
movq %rcx, 0x10(%rsp)
cmpq 0x28(%rsp), %rcx
jne 0x20b2
movl $0xa, %edi
callq 0x10b0
movl $0x20, %edi
callq 0x10b0
movq 0x8(%rsp), %rcx
incq %rcx
movq %rcx, 0x8(%rsp)
cmpq 0x20(%rsp), %rcx
jne 0x2084
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xea0(%rip), %rdi       # 0x3040
leaq 0xf56(%rip), %rsi       # 0x30fd
leaq 0x1003(%rip), %rdx      # 0x31b1
movl $0xae, %ecx
xorl %eax, %eax
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/deepika9294[P]Threading-Library/one-one/test/spin.c
// Function: main
int main() {
	dthread_t th1, th2, th3, th4; 
	int a1,a2,a3,a4;
    dthread_init();
    printf("\n\n");

	a1 = dthread_create(&th1, thread1, NULL);
	a2 = dthread_create(&th2, thread2, NULL);
	a3 = dthread_create(&th3, thread3, NULL);
	a4 = dthread_create(&th4, thread4, NULL);
	if(a1 != 0 || a2 != 0 || a3 !=0 || a4 != 0) {
		printf("Error in creation \n");
		return 0;
	}
	sleep(2);
	run = 0;
	dthread_join(th1, NULL);
	dthread_join(th2, NULL);
	dthread_join(th2, NULL);
	dthread_join(th2, NULL);

	if(c == c1 + c2 + c3 + c4) {
		printf(GREEN "**PASSED**: Spin lock test for race problem between 4 threads\n" NONE);
	}
	else {
		printf(RED "**FAILED**: Spin lock test for race problem between 4 threads\n" NONE);
	}

    // printf("\n%ld %ld %ld %ld %ld %ld\n", c, c1+c2+c3+c4 , c1, c2, c3, c4);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0x122c
leaq 0x7a0(%rip), %rdi       # 0x20d9
callq 0x1050
leaq -0x145(%rip), %rsi      # 0x1800
leaq -0x28(%rbp), %rdi
xorl %edx, %edx
callq 0x1320
movl %eax, %r15d
leaq -0x112(%rip), %rsi      # 0x1848
leaq -0x20(%rbp), %rdi
xorl %edx, %edx
callq 0x1320
movl %eax, %ebx
leaq -0xde(%rip), %rsi       # 0x1890
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x1320
movl %eax, %r14d
leaq -0xab(%rip), %rsi       # 0x18d8
leaq -0x30(%rbp), %rdi
xorl %edx, %edx
callq 0x1320
testl %r15d, %r15d
jne 0x1a0f
testl %ebx, %ebx
jne 0x1a0f
testl %r14d, %r14d
jne 0x1a0f
testl %eax, %eax
jne 0x1a0f
movl $0x2, %edi
callq 0x1100
movq $0x0, 0x26e3(%rip) # 0x4098
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x14b0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x14b0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x14b0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x14b0
movq 0x26e8(%rip), %rax      # 0x40d0
addq 0x26d9(%rip), %rax      # 0x40c8
addq 0x26e2(%rip), %rax      # 0x40d8
addq 0x26e3(%rip), %rax      # 0x40e0
cmpq %rax, 0x26bc(%rip)      # 0x40c0
jne 0x1a1d
leaq 0x634(%rip), %rdi       # 0x2041
jmp 0x1a24
leaq 0x6c5(%rip), %rdi       # 0x20db
callq 0x1050
jmp 0x1a2b
leaq 0x669(%rip), %rdi       # 0x208d
xorl %eax, %eax
callq 0x1090
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/adelciotto[P]scg/examples/transform.c
// Function: main
int main(int arcg, char *argv[]) {
    scg_config_t config = scg_config_new_default();
    config.video.title = "SCG Example: Transform";

    scg_app_t app;
    scg_app_init(&app, config);

    scg_image_t *image = scg_image_new_from_bmp("assets/ball.bmp");
    if (image == NULL) {
        return -1;
    }

    while (scg_app_process_events(&app)) {
        draw(app.draw_target, image, app.elapsed_time);

        scg_app_present(&app);
    }

    scg_image_free(image);
    scg_app_free(&app);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movabsq $0x1e000000280, %rax    # imm = 0x1E000000280
movq %rax, 0x28(%rsp)
movl $0x1, 0x38(%rsp)
xorl %eax, %eax
movb %al, 0x3c(%rsp)
movl $0x1010101, 0x3d(%rsp)  # imm = 0x1010101
movb %al, 0x44(%rsp)
movl $0x40, 0x48(%rsp)
leaq 0x1082(%rip), %rax      # 0x659c
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x50(%rsp), %rdi
callq 0x3e81
leaq 0x1066(%rip), %rdi      # 0x65b3
callq 0x2925
testq %rax, %rax
je 0x5613
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x49dc
testb %al, %al
je 0x55f4
movl (%rbx), %ebp
movl 0x4(%rbx), %r15d
leaq 0x50(%rsp), %r14
movq 0x88(%rsp), %rdi
movl 0x4(%rdi), %ecx
imull (%rdi), %ecx
testl %ecx, %ecx
jle 0x55a4
movq 0x10(%rdi), %rax
movl %ecx, %ecx
xorl %edx, %edx
movl $0xff008080, (%rax,%rdx,4) # imm = 0xFF008080
incq %rdx
cmpq %rdx, %rcx
jne 0x5595
movss 0x58(%rsp), %xmm0
movl (%rdi), %eax
movl 0x4(%rdi), %esi
movl $0x2, 0x18(%rdi)
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
subl %r15d, %edx
movl %esi, %ecx
shrl $0x1f, %ecx
addl %esi, %ecx
sarl %ecx
subl %ebp, %ecx
movq %rbx, %rsi
movss 0xa60(%rip), %xmm1      # 0x6038
movaps %xmm1, %xmm2
callq 0x2fe3
movq %r14, %rdi
callq 0x4b28
movq %r14, %rdi
callq 0x49dc
testb %al, %al
jne 0x557b
movq 0x10(%rbx), %rdi
callq 0x2290
movq %rbx, %rdi
callq 0x2290
leaq 0x50(%rsp), %rdi
callq 0x4ff7
xorl %eax, %eax
jmp 0x5618
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cgaebel[P]pipe/pipe.c
// Function: pipe_consumer_free
void pipe_consumer_free(pipe_consumer_t* handle)
{
    pipe_t* p = PIPIFY(handle);
    size_t new_consumer_refcount;

    mutex_lock(&p->end_lock);
        new_consumer_refcount = --p->consumer_refcount;
    mutex_unlock(&p->end_lock);

    if(unlikely(new_consumer_refcount == 0))
    {
        size_t producer_refcount;

        mutex_lock(&p->begin_lock);
            producer_refcount = p->producer_refcount;
        mutex_unlock(&p->begin_lock);

        // If there are still producers, wake them up if they're waiting on
        // room to free up from a consumer. Otherwise, since we're the last
        // handle altogether, we can free the pipe.
        if(likely(producer_refcount > 0))
            cond_broadcast(&p->just_popped);
        else
            deallocate(p);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x70(%rdi), %r14
movq %r14, %rdi
callq 0x1140
decq 0x40(%rbx)
setne %r15b
movq %r14, %rdi
callq 0x10e0
testb %r15b, %r15b
je 0x1a17
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x12a3
jmp 0x1a0c
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_try_accept
static int xpsocket_try_accept(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   XPSocket *ps = xpsocket_new(L);

   ps->s = accept(me->s, NULL, NULL);
   if (ps->s == -1) {
      return pushError(L, isRetry(errno) ? "retry" : NULL);
   }

   // Linux: accepted socket does not inherit file status (the nerve!)
   if (setNonBlocking(ps->s, 1) == -1) {
      (void) close(ps->s);
      ps->s = -1;
      return pushError(L, NULL);
   }

   return 1;  // success => return new socket
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1bfd8(%rip), %rdx     # 0x1f950
leaq 0x136c6(%rip), %rcx     # 0x17045
movl $0x1, %ebp
movl $0x1, %esi
callq 0x47de
movq %rax, %r15
leaq 0x136ac(%rip), %rdx     # 0x17044
movl $0x4, %esi
movq %rbx, %rdi
callq 0x43db
movq %rax, %r14
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl (%r15), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3380
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x39e6
movl %eax, %edi
movl $0x1, %esi
callq 0x4389
cmpl $-0x1, %eax
jne 0x3a20
movl (%r14), %edi
callq 0x31c0
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
xorl %esi, %esi
jmp 0x3a13
callq 0x3060
movl (%rax), %eax
leaq 0x137ff(%rip), %rsi     # 0x171f3
cmpl $0x4, %eax
je 0x3a13
cmpl $0xb, %eax
je 0x3a13
cmpl $0x73, %eax
je 0x3a13
xorl %esi, %esi
cmpl $0x72, %eax
leaq 0x137e4(%rip), %rax     # 0x171f3
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x434a
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: addrFromString
static int addrFromString(struct sockaddr_in *psin, const char *psz)
{
   unsigned nums[4] = {0};
   unsigned port = 0;
   size_t i;

   for (i=0; ; ++i) {
      if (!*psz) {
         break;
      }
      if (*psz == ':') {
         psz = scanNum(psz+1, &port);
         break;
      }
      if (i >= ARRAY_LENGTH(nums)) {
         return -1;
      }
      psz = scanNum(psz, &nums[i]);
      if (*psz == '.') {
         ++psz;
      }
   }

   // TODO: syntax validation
   // TODO: range validation

   // POSIX fail: I can find no specifications or docs (POSIX, Linux,
   // MacOS) that indicate to zero the unused fields, but trial and error
   // indicates that it is necessary (at least on MacOS).
   ZERO_REC(*psin);

   if (i > 1) nums[0] *= 0x1000000;
   if (i > 2) nums[1] *= 0x10000;
   if (i > 3) nums[2] *= 0x100;

   // POSIX fail: Port and addr are typed as numbers *yet* stored in network
   // byte order, requiring htons/htonl (still...).
   psin->sin_family = AF_INET;
   psin->sin_addr.s_addr = htonl(nums[0] + nums[1] + nums[2] + nums[3]);
   psin->sin_port = htons(port);
   return 0;
}

// Assembly:
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rsp)
xorl %eax, %eax
movzbl (%rsi), %ecx
testl %ecx, %ecx
je 0x3d8e
cmpl $0x3a, %ecx
je 0x3d66
cmpq $0x4, %rax
je 0x3ddc
movsbl %cl, %edx
addl $-0x30, %edx
xorl %ecx, %ecx
cmpl $0x9, %edx
ja 0x3d52
xorl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
leal (%rdx,%rcx,2), %ecx
movsbl 0x1(%rsi), %edx
incq %rsi
addl $-0x30, %edx
cmpl $0xa, %edx
jb 0x3d3d
movl %ecx, -0x18(%rsp,%rax,4)
xorl %ecx, %ecx
cmpb $0x2e, (%rsi)
sete %cl
addq %rcx, %rsi
incq %rax
jmp 0x3d18
movsbl 0x1(%rsi), %edx
addl $-0x30, %edx
xorl %ecx, %ecx
cmpl $0x9, %edx
ja 0x3d90
addq $0x2, %rsi
leal (%rcx,%rcx,4), %ecx
leal (%rdx,%rcx,2), %ecx
movsbl (%rsi), %edx
addl $-0x30, %edx
incq %rsi
cmpl $0xa, %edx
jb 0x3d78
jmp 0x3d90
xorl %ecx, %ecx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq $0x2, %rax
jb 0x3da1
shll $0x18, -0x18(%rsp)
cmpq $0x3, %rax
jb 0x3dac
shll $0x10, -0x14(%rsp)
cmpq $0x4, %rax
jb 0x3db7
shll $0x8, -0x10(%rsp)
movw $0x2, (%rdi)
movl -0x14(%rsp), %eax
addl -0x18(%rsp), %eax
addl -0x10(%rsp), %eax
addl -0xc(%rsp), %eax
bswapl %eax
movl %eax, 0x4(%rdi)
rolw $0x8, %cx
movw %cx, 0x2(%rdi)
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_socket
static int xpio_socket(lua_State *L)
{
   XPSocket *me = xpsocket_new(L);
   const char *typeName = luaL_checkstring(L, 1);
   int type;

   if (0 == strcmp(typeName, "TCP")) {
      type = SOCK_STREAM;
   } else if (0 == strcmp(typeName, "UDP")) {
      type = SOCK_DGRAM;
   } else {
      lua_pushnil(L);
      lua_pushstring(L, "xpio: unsupported socket type");
      return 2;
   }

   me->s = socket(AF_INET, type, 0);
   if (me->s == -1) {
      return pushError(L, NULL);
   }

   // Note: *me and me->s will be cleaned up when userdata is collected

   if (setNonBlocking(me->s, 1) == -1) {
      return pushError(L, NULL);
   }

   return 1;   // success => return userdata
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x13250(%rip), %rdx     # 0x17044
movl $0x4, %esi
callq 0x43db
movq %rax, %r14
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x7b05
movq %rax, %r12
leaq 0x132b6(%rip), %rsi     # 0x170dc
movq %rax, %rdi
callq 0x3230
testl %eax, %eax
je 0x3e64
leaq 0x132a7(%rip), %rsi     # 0x170e0
movq %r12, %rdi
callq 0x3230
testl %eax, %eax
je 0x3e5e
movq %rbx, %rdi
callq 0x630a
leaq 0x13290(%rip), %rsi     # 0x170e4
movq %rbx, %rdi
callq 0x63c2
jmp 0x3ea0
movl $0x2, %r15d
movl $0x2, %ebp
movl $0x2, %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x3450
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x3ea7
movl $0x1, %ebp
movl %eax, %edi
movl $0x1, %esi
callq 0x4389
cmpl $-0x1, %eax
jne 0x3eb1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x434a
movl $0x2, %ebp
jmp 0x3eb1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x434a
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_tqueue
static int xpio_tqueue(lua_State *L)
{
   XPQueue *me = XPIO_NEWOBJECT(L, XPQueue);

   me->pfds = 0;
   me->nfds = 0;

   lua_createtable(L, 2, 0);             // uservalue
   lua_newtable(L);
   lua_rawseti(L, -2, XPQUEUE_READ);     // uservalue[1] = readers
   lua_newtable(L);
   lua_rawseti(L, -2, XPQUEUE_WRITE);    // uservalue[2] = writers
   lua_newtable(L);
   lua_rawseti(L, -2, XPQUEUE_CHILD);    // uservalue[2] = childWaiters
   lua_setuservalue(L, -2);

   return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x13169(%rip), %rdx     # 0x17030
movl $0x10, %esi
callq 0x43db
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x676c
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x676c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x69b9
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x676c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x69b9
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x676c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x3, %edx
callq 0x69b9
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b31
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_fdopen
static int xpio_fdopen(lua_State *L)
{
   XPSocket *ps = xpsocket_new(L);

   // dup() creates a descriptor for the xpsocket to own (and close on
   // finalization). This avoids one xpsocket unpredictably closing a
   // descriptor used by another xpsocket.
   ps->s = dup((int) checkUInt(L, 1));
   if (ps->s == -1) {
      return pushError(L, NULL);
   }
   return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x13071(%rip), %rdx     # 0x17044
movl $0x4, %esi
callq 0x43db
movq %rax, %r14
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x44f1
movl %eax, %edi
callq 0x3180
movl %eax, (%r14)
cmpl $-0x1, %eax
jne 0x4016
movq %rbx, %rdi
xorl %esi, %esi
callq 0x434a
movl $0x2, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio__nextfd
static int xpio__nextfd(lua_State *L)
{
   struct rlimit rl;
   int fd = 0;
   int flags;
   int fdMax = -1;

   fd = tointegerDefault(L, 2, -1) + 1;

   if (fdMax < 0) {
      if (getrlimit(RLIMIT_NOFILE, &rl) < 0) {
         return luaL_error(L, "xpio: getrlimit failed");
      }
      // rlim_max is negative in OSX => use rlim_cur ?
      fdMax = rl.rlim_max - 1;
      if (fdMax < 0) {
         fdMax = rl.rlim_cur - 1;
      }
   }

   for (; fd <= fdMax; ++fd) {
      flags = fcntl(fd, F_GETFD);
      if (flags >= 0 && (flags & FD_CLOEXEC) == 0) {
         lua_pushinteger(L, fd);
         return 1;
      }
   }

   lua_pushnil(L);
   return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movl $0x2, %esi
movq %r15, %rdx
callq 0x60c9
movq %rax, %r14
movl (%r15), %ebp
leaq 0x8(%rsp), %rsi
movl $0x7, %edi
callq 0x33f0
testl %eax, %eax
js 0x431f
cmpl $0x1, %ebp
movl $0x0, %ebp
sbbl %ebp, %ebp
orl %r14d, %ebp
movl 0x8(%rsp), %r14d
movl 0x10(%rsp), %eax
decl %eax
decl %r14d
testl %eax, %eax
cmovnsl %eax, %r14d
cmpl %ebp, %r14d
cmovlel %ebp, %r14d
cmpl %ebp, %r14d
je 0x4332
incl %ebp
movl %ebp, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x30e0
testl $0x80000001, %eax       # imm = 0x80000001
jne 0x42f6
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x6333
jmp 0x433a
leaq 0x12e62(%rip), %rsi     # 0x17188
movq %rbx, %rdi
xorl %eax, %eax
callq 0x75d0
jmp 0x433f
movq %rbx, %rdi
callq 0x630a
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: setNonBlocking
static int setNonBlocking(int fd, int bOn)
{
   int flagsAdd = 0;
   int flagsRemove = 0;

   if (bOn) {
      flagsAdd = O_NONBLOCK;
   } else {
      flagsRemove = O_NONBLOCK;
   }

   return fcntl_mod_FL(fd, flagsAdd, flagsRemove);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movl $0x3, %esi
xorl %eax, %eax
callq 0x30e0
cmpl $-0x1, %eax
je 0x43cf
xorl %ecx, %ecx
testl %ebp, %ebp
setne %cl
movl %ecx, %edx
shll $0xb, %edx
negl %ecx
orl $0xfffff7ff, %ecx       # imm = 0xFFFFF7FF
andl %ecx, %eax
orl %edx, %eax
movl %ebx, %edi
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_newObject
static void *xpio_newObject(lua_State *L, size_t size, const char *mtName)
{
   void *pv;

   lua_getfield(L, lua_upvalueindex(1), mtName);
   pv = xlua_newObject(L, -1, size);
   lua_remove(L, -2);

   return pv;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x666b
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5c0e
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6fec
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5e15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6a83
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5c94
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_pair
static int xpio_pair(lua_State *L, int nPairType)
{
   XPSocket *psA = xpsocket_new(L);
   XPSocket *psB = xpsocket_new(L);
   int spOut[2];
   int n, err;

   if (nPairType == PAIR_PIPE) {
      err = pipe(spOut);
   } else {
      err = socketpair(AF_UNIX, SOCK_STREAM, 0, spOut);
   }

   if (err) {
      return pushError(L, NULL);
   }

   psA->s = spOut[0];
   psB->s = spOut[1];

   for (n = 0; n <= 1; ++n) {
      if (setNonBlocking(spOut[n], 1) == -1) {
         return pushError(L, NULL);
      }
   }

   return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x12bf4(%rip), %r15     # 0x17044
movl $0x4, %esi
movq %r15, %rdx
callq 0x43db
movq %rax, %r14
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, (%rax)
movl $0x4, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x43db
movq %rax, %r15
movl %r12d, (%rax)
cmpl $0x1, %ebp
jne 0x4490
leaq 0x8(%rsp), %rdi
callq 0x31d0
jmp 0x44a6
leaq 0x8(%rsp), %rcx
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3290
testl %eax, %eax
je 0x44c1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x434a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rsp), %eax
movl %eax, (%r14)
movl 0xc(%rsp), %eax
movl %eax, (%r15)
xorl %r14d, %r14d
movl 0x8(%rsp,%r14,4), %edi
movl $0x1, %esi
callq 0x4389
cmpl $-0x1, %eax
je 0x44aa
incq %r14
cmpq $0x1, %r14
je 0x44d2
jmp 0x44b4
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: checkUInt
static unsigned checkUInt(lua_State *L, int ndx)
{
   lua_Number num = luaL_checknumber(L, ndx);
   if (! (num >= 0)) {
      return luaL_error(L, "xpio: invalid argument #%d", ndx);
   }
   if (num > UINT_MAX) {
      return UINT_MAX;
   }
   return (unsigned) num;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x7bfc
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x4523
leaq 0x12bf2(%rip), %rsi     # 0x17102
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x75d0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd 0x12ae0(%rip), %xmm0    # 0x17010
ja 0x4537
cvttsd2si %xmm0, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: readStringArray
static char **readStringArray(lua_State *L, int ndxArray)
{
   int numStrings = lengthOf(L, ndxArray);
   char **ptrs = (char**) calloc(numStrings + 1, sizeof(char*));
   if (!ptrs) {
      return NULL;
   }

   int offset = 0;
   for (offset = 0; offset < numStrings; ++offset) {
      lua_rawgeti(L, ndxArray, offset+1);
      size_t len;
      const char *pc = lua_tolstring(L, -1, &len);
      ptrs[offset] = pc ? strdup(pc) : NULL;
      lua_pop(L, 1);
      if (! ptrs[offset]) {
         break;
      }
   }

   return ptrs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x461a
movl %eax, %r15d
leal 0x1(%r15), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x3220
xorl %r13d, %r13d
testq %rax, %rax
je 0x45cc
movq %rax, %r12
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r13, %r15
je 0x45cf
leal 0x1(%r13), %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x66f1
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rsp, %rdx
callq 0x6188
testq %rax, %rax
je 0x45af
movq %rax, %rdi
callq 0x3400
movq %rax, %rbp
jmp 0x45b1
xorl %ebp, %ebp
movq %rbp, (%r12,%r13,8)
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5c43
incq %r13
testq %rbp, %rbp
jne 0x457a
jmp 0x45cf
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: handleSIGCHLD
static void handleSIGCHLD(int sig)
{
   int n;
   int oldErrno = errno;
   //printf("SIGCHLD!\n");
   do {
      n = write(sigchldPipe[1], "\1", 1);
   } while (n == -1 && errno == EINTR);
   errno = oldErrno;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x3060
movq %rax, %rbx
movl (%rax), %ebp
leaq 0x12b90(%rip), %r14     # 0x17186
movl 0x1bc48(%rip), %edi     # 0x20244
movl $0x1, %edx
movq %r14, %rsi
callq 0x30f0
cmpl $-0x1, %eax
jne 0x4613
cmpl $0x4, (%rbx)
je 0x45f6
movl %ebp, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: lengthOf
static int lengthOf(lua_State *L, int ndx)
{
   int len;
   lua_len(L, ndx);
   len = lua_tointeger(L, -1);
   lua_pop(L, 1);
   return len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6fa9
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x60c9
movq %rax, %r14
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5c43
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpproc_dtor
static int xpproc_dtor(lua_State *L)
{
   XPProc *me = XLUA_CAST(L, 1, XPProc);

   // dequeue from global list
   SLL_DEQUEUE(me, gpHeadProc, XPProc, next);

   if (me->pid) {
      (void) kill(me->pid, SIGKILL);
      me->pid = 0;
   }
   return 0;
}

// Assembly:
pushq %rbx
leaq 0x1b268(%rip), %rdx     # 0x1f8c0
leaq 0x129ca(%rip), %rcx     # 0x17029
movl $0x1, %esi
callq 0x47de
movq %rax, %rbx
leaq 0x1bbdd(%rip), %rax     # 0x20250
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
je 0x4689
cmpq %rbx, %rax
jne 0x4673
movq (%rbx), %rax
movq %rax, (%rcx)
movl 0x8(%rbx), %edi
testl %edi, %edi
je 0x46a1
movl $0x9, %esi
callq 0x32a0
movl $0x0, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpproc_kill
static int xpproc_kill(lua_State *L)
{
   XPProc *me = XLUA_CAST(L, 1, XPProc);

   if (me->pid <= 0) {
      return pushError(L, "process not running");
   }

   if (kill(me->pid, SIGKILL) == -1) {
      return pushError(L, NULL);
   }

   lua_pushboolean(L, 1);  // success
   return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b20e(%rip), %rdx     # 0x1f8c0
leaq 0x12970(%rip), %rcx     # 0x17029
movl $0x1, %esi
callq 0x47de
movl 0x8(%rax), %edi
testl %edi, %edi
jle 0x46ed
movl $0x9, %esi
callq 0x32a0
cmpl $-0x1, %eax
je 0x46f9
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x658d
jmp 0x4708
leaq 0x12aeb(%rip), %rsi     # 0x171df
movq %rbx, %rdi
jmp 0x46fe
movq %rbx, %rdi
xorl %esi, %esi
callq 0x434a
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpproc_try_wait
static int xpproc_try_wait(lua_State *L)
{
   XPProc *me = XLUA_CAST(L, 1, XPProc);

   if (me->pid > 0) {
      lua_pushnil(L);
      lua_pushstring(L, "retry");
      //printf("... try_wait(%d) --> retry\n", me->pid);
      return 2;
   }

   //printf("... try_wait() --> %x\n", me->status);
   if (WIFEXITED(me->status)) {
      lua_pushstring(L, "exit");
      lua_pushinteger(L, WEXITSTATUS(me->status));
      return 2;
   } else if (WIFSIGNALED(me->status)) {
      lua_pushstring(L, "signal");
      lua_pushinteger(L, WSTOPSIG(me->status));
      return 2;
   } else {
      // exit status not ready
      return pushError(L, "retry");
   }

   // should not happen
   return pushError(L, "xpio: unexpected waitpid() result");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b1a1(%rip), %rdx     # 0x1f8c0
leaq 0x12903(%rip), %rcx     # 0x17029
movl $0x1, %esi
callq 0x47de
cmpl $0x0, 0x8(%rax)
jle 0x474f
movq %rbx, %rdi
callq 0x630a
leaq 0x12aae(%rip), %rsi     # 0x171f3
movq %rbx, %rdi
callq 0x63c2
jmp 0x479f
movq %rax, %r14
movl 0xc(%rax), %eax
andl $0x7f, %eax
je 0x4772
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x4790
leaq 0x12a8e(%rip), %rsi     # 0x171fe
jmp 0x4779
leaq 0x12a80(%rip), %rsi     # 0x171f9
movq %rbx, %rdi
callq 0x63c2
movzbl 0xd(%r14), %esi
movq %rbx, %rdi
callq 0x6333
jmp 0x479f
leaq 0x12a5c(%rip), %rsi     # 0x171f3
movq %rbx, %rdi
callq 0x434a
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq