LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ff.c
// Function: f_utime
FRESULT f_utime (
	const TCHAR* path,	/* Pointer to the file/directory name */
	const FILINFO* fno	/* Pointer to the timestamp to be set */
)
{
	FRESULT res;
	DIR dj;
	FATFS *fs;
	DEF_NAMBUF


	res = mount_volume(&path, &fs, FA_WRITE);	/* Get logical drive */
	if (res == FR_OK) {
		dj.obj.fs = fs;
		INIT_NAMBUF(fs);
		res = follow_path(&dj, path);	/* Follow the file path */
		if (res == FR_OK && (dj.fn[NSFLAG] & (NS_DOT | NS_NONAME))) res = FR_INVALID_NAME;	/* Check object validity */
		if (res == FR_OK) {
#if FF_FS_EXFAT
			if (fs->fs_type == FS_EXFAT) {
				st_dword(fs->dirbuf + XDIR_ModTime, (DWORD)fno->fdate << 16 | fno->ftime);
				res = store_xdir(&dj);
			} else
#endif
			{
				st_dword(dj.dir + DIR_ModTime, (DWORD)fno->fdate << 16 | fno->ftime);
				fs->wflag = 1;
			}
			if (res == FR_OK) {
				res = sync_fs(fs);
			}
		}
		FREE_NAMBUF();
	}

	LEAVE_FF(fs, res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rsi, %r14
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsp, %rsi
pushq $0x2
popq %rdx
movq %rax, %rdi
callq 0x473a
testl %eax, %eax
jne 0x8218
movq (%rsp), %rbx
leaq 0x10(%rsp), %r15
movq %rbx, (%r15)
leaq 0x70(%rsp), %rax
movq %rax, 0x10(%rbx)
leaq 0x270(%rsp), %rax
movq %rax, 0x18(%rbx)
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x50b1
movl %eax, %ecx
xorl %edx, %edx
testb $-0x60, 0x53(%r15)
sete %sil
pushq $0x6
popq %rax
cmovel %edx, %eax
testl %ecx, %ecx
sete %dl
cmovnel %ecx, %eax
andb %sil, %dl
cmpb $0x1, %dl
jne 0x8218
cmpb $0x4, (%rbx)
jne 0x81f1
movq 0x18(%rbx), %rcx
movzwl 0x8(%r14), %eax
movzwl 0xa(%r14), %edx
movb %dl, 0xc(%rcx)
movb %dh, 0xd(%rcx)
movb %al, 0xe(%rcx)
movb %ah, 0xf(%rcx)
leaq 0x10(%rsp), %rdi
callq 0x59d7
testl %eax, %eax
jne 0x8218
jmp 0x8210
movq 0x50(%rsp), %rcx
movzwl 0x8(%r14), %eax
movzwl 0xa(%r14), %edx
movb %dl, 0x16(%rcx)
movb %dh, 0x17(%rcx)
movb %al, 0x18(%rcx)
movb %ah, 0x19(%rcx)
movb $0x1, 0x3(%rbx)
movq %rbx, %rdi
callq 0x68ea
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ff.c
// Function: test_gpt_header
static int test_gpt_header (	/* 0:Invalid, 1:Valid */
	const BYTE* gpth			/* Pointer to the GPT header */
)
{
	UINT i;
	DWORD bcc;


	if (mem_cmp(gpth + GPTH_Sign, "EFI PART" "\0\0\1\0" "\x5C\0\0", 16)) return 0;	/* Check sign, version (1.0) and length (92) */
	for (i = 0, bcc = 0xFFFFFFFF; i < 92; i++) {		/* Check header BCC */
		bcc = crc32(bcc, i - GPTH_Bcc < 4 ? 0 : gpth[i]);
	}
	if (~bcc != ld_dword(gpth + GPTH_Bcc)) return 0;
	if (ld_dword(gpth + GPTH_PteSize) != SZ_GPTE) return 0;	/* Table entry size (must be SZ_GPTE bytes) */
	if (ld_dword(gpth + GPTH_PtNum) > 128) return 0;	/* Table size (must be 128 entries or less) */

	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x25a4(%rip), %rsi      # 0xc4b8
pushq $0x10
popq %rdx
callq 0x9f7d
xorl %ecx, %ecx
testl %eax, %eax
jne 0x9f6f
pushq $-0x1
popq %rax
xorl %r14d, %r14d
cmpq $0x5c, %r14
je 0x9f50
movl %r14d, %ecx
andl $0x7c, %ecx
cmpl $0x10, %ecx
jne 0x9f3d
xorl %ecx, %ecx
jmp 0x9f41
movb (%rbx,%r14), %cl
movzbl %cl, %esi
movl %eax, %edi
callq 0xaca5
incq %r14
jmp 0x9f28
xorl 0x10(%rbx), %eax
xorl %ecx, %ecx
cmpl $-0x1, %eax
jne 0x9f6f
cmpl $0x80, 0x54(%rbx)
jne 0x9f6f
xorl %ecx, %ecx
cmpl $0x81, 0x50(%rbx)
setb %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ff.c
// Function: mem_cmp
static int mem_cmp (const void* dst, const void* src, UINT cnt)	/* ZR:same, NZ:different */
{
	const BYTE *d = (const BYTE *)dst, *s = (const BYTE *)src;
	int r = 0;

	do {
		r = *d++ - *s++;
	} while (--cnt && r == 0);

	return r;
}

// Assembly:
decl %edx
xorl %eax, %eax
movb (%rdi,%rax), %cl
movb (%rsi,%rax), %r8b
cmpl %eax, %edx
je 0x9f94
incq %rax
cmpb %r8b, %cl
je 0x9f81
movzbl %cl, %eax
movzbl %r8b, %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ff.c
// Function: f_fdisk
FRESULT f_fdisk (
	BYTE pdrv,			/* Physical drive number */
	const LBA_t ptbl[],	/* Pointer to the size table for each partitions */
	void* work			/* Pointer to the working buffer (null: use heap memory) */
)
{
	BYTE *buf = (BYTE*)work;
	DSTATUS stat;


	stat = disk_initialize(pdrv);
	if (stat & STA_NOINIT) return FR_NOT_READY;
	if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
#if FF_USE_LFN == 3
	if (!buf) buf = ff_memalloc(FF_MAX_SS);	/* Use heap memory for working buffer */
#endif
	if (!buf) return FR_NOT_ENOUGH_CORE;

	LEAVE_MKFS(create_partition(pdrv, ptbl, 0x07, buf));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
callq 0x27d7
testb $0x1, %al
jne 0xa4cb
testb $0x4, %al
jne 0xa4cf
testq %rbx, %rbx
je 0xa4d3
movzbl %bpl, %edi
pushq $0x7
popq %rdx
movq %r14, %rsi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x9f9e
pushq $0x3
jmp 0xa4d5
pushq $0xa
jmp 0xa4d5
pushq $0x11
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ff.c
// Function: check_fs
static UINT check_fs (	/* 0:FAT VBR, 1:exFAT VBR, 2:Not FAT and valid BS, 3:Not FAT and invalid BS, 4:Disk error */
	FATFS* fs,			/* Filesystem object */
	LBA_t sect			/* Sector to load and check if it is an FAT-VBR or not */
)
{
	WORD w, sign;
	BYTE b;


	fs->wflag = 0; fs->winsect = (LBA_t)0 - 1;		/* Invaidate window */
	if (move_window(fs, sect) != FR_OK) return 4;	/* Load the boot sector */
	sign = ld_word(fs->win + BS_55AA);
#if FF_FS_EXFAT
	if (sign == 0xAA55 && !mem_cmp(fs->win + BS_JmpBoot, "\xEB\x76\x90" "EXFAT   ", 11)) return 1;	/* It is an exFAT VBR */
#endif
	b = fs->win[BS_JmpBoot];
	if (b == 0xEB || b == 0xE9 || b == 0xE8) {	/* Valid JumpBoot code? (short jump, near jump or near call) */
		if (sign == 0xAA55 && !mem_cmp(fs->win + BS_FilSysType32, "FAT32   ", 8)) return 0;	/* It is an FAT32 VBR */
		/* FAT volumes formatted with early MS-DOS lack boot signature and FAT string, so that we need to identify the FAT VBR without them. */
		w = ld_word(fs->win + BPB_BytsPerSec);
		if ((w & (w - 1)) == 0 && w >= FF_MIN_SS && w <= FF_MAX_SS) {	/* Properness of sector size */
			b = fs->win[BPB_SecPerClus];
			if (b != 0 && (b & (b - 1)) == 0						/* Properness of cluster size */
			&& (fs->win[BPB_NumFATs] == 1 || fs->win[BPB_NumFATs] == 2)	/* Properness of number of FATs */
			&& ld_word(fs->win + BPB_RootEntCnt) != 0				/* Properness of root entry count */
			&& ld_word(fs->win + BPB_FATSz16) != 0) {				/* Properness of FAT size */
				return 0;	/* Sector can be presumed an FAT VBR */
			}
		}
	}
	return sign == 0xAA55 ? 2 : 3;	/* Not an FAT VBR (valid or invalid BS) */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x3(%rdi)
orq $-0x1, 0x58(%rdi)
callq 0x5bf6
testl %eax, %eax
je 0xa4fc
pushq $0x4
popq %rax
jmp 0xa594
leaq 0x60(%rbx), %r14
movzwl 0x25e(%rbx), %ebp
cmpw $0xaa55, %bp            # imm = 0xAA55
jne 0xa524
leaq 0x1fb3(%rip), %rsi      # 0xc4c8
pushq $0xb
popq %rdx
movq %r14, %rdi
callq 0x9f7d
testl %eax, %eax
je 0xa599
movzbl (%r14), %eax
addl $0xffffff18, %eax       # imm = 0xFFFFFF18
cmpl $0x3, %eax
ja 0xa587
cmpl $0x2, %eax
je 0xa587
cmpw $0xaa55, %bp            # imm = 0xAA55
jne 0xa558
leaq 0xb2(%rbx), %rdi
leaq 0x1f9f(%rip), %rsi      # 0xc4eb
pushq $0x8
popq %rdx
callq 0x9f7d
testl %eax, %eax
je 0xa583
cmpw $0x200, 0x6b(%rbx)      # imm = 0x200
jne 0xa587
movb 0x6d(%rbx), %al
leal -0x1(%rax), %ecx
xorb %cl, %al
cmpb %cl, %al
jbe 0xa587
movb 0x70(%rbx), %al
decb %al
cmpb $0x1, %al
ja 0xa587
cmpw $0x0, 0x71(%rbx)
je 0xa587
cmpw $0x0, 0x76(%rbx)
je 0xa587
xorl %eax, %eax
jmp 0xa594
xorl %eax, %eax
cmpw $0xaa55, %bp            # imm = 0xAA55
sete %al
xorl $0x3, %eax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
jmp 0xa4f6
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ff.c
// Function: xname_sum
static WORD xname_sum (	/* Get check sum (to be used as hash) of the file name */
	const WCHAR* name	/* File name to be calculated */
)
{
	WCHAR chr;
	WORD sum = 0;


	while ((chr = *name++) != 0) {
		chr = (WCHAR)ff_wtoupper(chr);		/* File name needs to be up-case converted */
		sum = ((sum & 1) ? 0x8000 : 0) + (sum >> 1) + (chr & 0xFF);
		sum = ((sum & 1) ? 0x8000 : 0) + (sum >> 1) + (chr >> 8);
	}
	return sum;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
movl $0xff, %r14d
movzwl (%rbx), %edi
testl %edi, %edi
je 0xa878
addq $0x2, %rbx
callq 0xad7c
movzwl %bp, %ecx
movl %ecx, %edx
shll $0xf, %edx
shrl %ecx
orl %edx, %ecx
movl %eax, %edx
andl %r14d, %edx
leal (%rcx,%rax), %esi
shll $0xf, %esi
addl %ecx, %edx
shrl %edx
andl $0x7fff, %edx           # imm = 0x7FFF
shrl $0x8, %eax
andl %r14d, %eax
orl %esi, %eax
addl %edx, %eax
movl %eax, %ebp
jmp 0xa839
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ff.c
// Function: xdir_sum
static WORD xdir_sum (	/* Get checksum of the directoly entry block */
	const BYTE* dir		/* Directory entry block to be calculated */
)
{
	UINT i, szblk;
	WORD sum;


	szblk = (dir[XDIR_NumSec] + 1) * SZDIRE;	/* Number of bytes of the entry block */
	for (i = sum = 0; i < szblk; i++) {
		if (i == XDIR_SetSum) {	/* Skip 2-byte sum field */
			i++;
		} else {
			sum = ((sum & 1) ? 0x8000 : 0) + (sum >> 1) + dir[i];
		}
	}
	return sum;
}

// Assembly:
movzbl 0x1(%rdi), %ecx
shll $0x5, %ecx
addl $0x20, %ecx
xorl %r8d, %r8d
pushq $0x4
popq %rdx
xorl %eax, %eax
cmpl %ecx, %r8d
jae 0xa8cb
movl %r8d, %esi
movl %edx, %r8d
cmpl $0x2, %esi
je 0xa8a3
rorw %ax
movl %esi, %r8d
movzbl (%rdi,%r8), %r9d
addl %eax, %r9d
incl %esi
movl %esi, %r8d
movl %r9d, %eax
jmp 0xa8a3
retq
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ff.c
// Function: change_bitmap
static FRESULT change_bitmap (
	FATFS* fs,	/* Filesystem object */
	DWORD clst,	/* Cluster number to change from */
	DWORD ncl,	/* Number of clusters to be changed */
	int bv		/* bit value to be set (0 or 1) */
)
{
	BYTE bm;
	UINT i;
	LBA_t sect;


	clst -= 2;	/* The first bit corresponds to cluster #2 */
	sect = fs->bitbase + clst / 8 / SS(fs);	/* Sector address */
	i = clst / 8 % SS(fs);					/* Byte offset in the sector */
	bm = 1 << (clst % 8);					/* Bit mask in the byte */
	for (;;) {
		if (move_window(fs, sect++) != FR_OK) return FR_DISK_ERR;
		do {
			do {
				if (bv == (int)((fs->win[i] & bm) != 0)) return FR_INT_ERR;	/* Is the bit expected value? */
				fs->win[i] ^= bm;	/* Flip the bit */
				fs->wflag = 1;
				if (--ncl == 0) return FR_OK;	/* All bits processed? */
			} while (bm <<= 1);		/* Next bit */
			bm = 1;
		} while (++i < SS(fs));		/* Next byte */
		i = 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
leal -0x2(%rsi), %ecx
movl %ecx, %r13d
shrl $0x3, %r13d
movl %ecx, %r15d
shrl $0xc, %r15d
addq 0x50(%rdi), %r15
andl $0x1ff, %r13d           # imm = 0x1FF
andb $0x7, %cl
pushq $0x1
popq %r12
shll %cl, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5bf6
testl %eax, %eax
jne 0xaace
incq %r15
movb 0x60(%r14,%r13), %al
movzbl %al, %ecx
xorl %edx, %edx
testl %ecx, %r12d
setne %dl
cmpl %ebx, %edx
je 0xaab8
xorb %r12b, %al
movb %al, 0x60(%r14,%r13)
movb $0x1, 0x3(%r14)
decl %ebp
je 0xaabd
movzbl %r12b, %ecx
leal (%rcx,%rcx), %r12d
testb $0x7f, %cl
jne 0xaa76
incq %r13
pushq $0x1
popq %r12
cmpq $0x200, %r13            # imm = 0x200
jne 0xaa71
xorl %r13d, %r13d
jmp 0xaa5f
pushq $0x2
popq %rax
jmp 0xaabf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
jmp 0xaaba
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ff.c
// Function: sync_window
static FRESULT sync_window (	/* Returns FR_OK or FR_DISK_ERR */
	FATFS* fs			/* Filesystem object */
)
{
	FRESULT res = FR_OK;


	if (fs->wflag) {	/* Is the disk access window dirty? */
		if (disk_write(fs->pdrv, fs->win, fs->winsect, 1) == RES_OK) {	/* Write it back into the volume */
			fs->wflag = 0;	/* Clear window dirty flag */
			if (fs->winsect - fs->fatbase < fs->fsize) {	/* Is it in the 1st FAT? */
				if (fs->n_fats == 2) disk_write(fs->pdrv, fs->win, fs->winsect + fs->fsize, 1);	/* Reflect it to 2nd FAT if needed */
			}
		} else {
			res = FR_DISK_ERR;
		}
	}
	return res;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x0, 0x3(%rdi)
je 0xab2f
movq %rdi, %r14
movzbl 0x1(%rdi), %edi
leaq 0x60(%r14), %rbx
movq 0x58(%r14), %rdx
pushq $0x1
popq %rbp
movq %rbx, %rsi
movl %ebp, %ecx
callq 0x28af
testl %eax, %eax
jne 0xab31
movb $0x0, 0x3(%r14)
movq 0x58(%r14), %rdx
movq %rdx, %rcx
subq 0x38(%r14), %rcx
movl 0x2c(%r14), %eax
cmpq %rax, %rcx
jae 0xab2f
cmpb $0x2, 0x2(%r14)
jne 0xab2f
movzbl 0x1(%r14), %edi
addq %rax, %rdx
pushq $0x1
popq %rcx
movq %rbx, %rsi
callq 0x28af
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ff.c
// Function: crc32
static DWORD crc32 (	/* Returns next CRC value */
	DWORD crc,			/* Current CRC value */
	BYTE d				/* A byte to be processed */
)
{
	BYTE b;


	for (b = 1; b; b <<= 1) {
		crc ^= (d & b) ? 1 : 0;
		crc = (crc & 1) ? crc >> 1 ^ 0xEDB88320 : crc >> 1;
	}
	return crc;
}

// Assembly:
movl %edi, %eax
movb $0x1, %cl
testb %cl, %cl
je 0xacc9
testb %sil, %cl
sete %dl
xorb %al, %dl
shrl %eax
movl %eax, %edi
xorl $0xedb88320, %edi       # imm = 0xEDB88320
testb $0x1, %dl
cmovel %edi, %eax
addb %cl, %cl
jmp 0xaca9
retq
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ff.c
// Function: make_rand
static DWORD make_rand (
	DWORD seed,		/* Seed value */
	BYTE* buff,		/* Output buffer */
	UINT n			/* Data length */
)
{
	UINT r;


	if (seed == 0) seed = 1;
	do {
		for (r = 0; r < 8; r++) seed = seed & 1 ? seed >> 1 ^ 0xA3000000 : seed >> 1;	/* Shift 8 bits the 32-bit LFSR */
		*buff++ = (BYTE)seed;
	} while (--n);
	return seed;
}

// Assembly:
movl %edi, %eax
cmpl $0x1, %edi
adcl $0x0, %eax
pushq $0x10
popq %rcx
pushq $0x8
popq %rdx
movl %edx, %edi
subl $0x1, %edi
jb 0xacfa
movl %eax, %r8d
shrl %r8d
movl %r8d, %r9d
xorl $0xa3000000, %r9d       # imm = 0xA3000000
testb $0x1, %al
cmovel %r8d, %r9d
movl %r9d, %eax
jmp 0xacda
movb %al, (%rsi)
incq %rsi
decl %ecx
jne 0xacd8
retq
// File: /workspace/github_c_makefile_star2_O2/lb3361[P]dosfs/ffunicode.c
// Function: ff_uni2oem
WCHAR ff_uni2oem (	/* Returns OEM code character, zero on error */
	DWORD	uni,	/* UTF-16 encoded character to be converted */
	WORD	cp		/* Code page for the conversion */
)
{
	WCHAR c = 0;
	const WCHAR *p = CVTBL(uc, FF_CODE_PAGE);


	if (uni < 0x80) {	/* ASCII? */
		c = (WCHAR)uni;

	} else {			/* Non-ASCII */
		if (uni < 0x10000 && cp == FF_CODE_PAGE) {	/* Is it in BMP and valid code page? */
			for (c = 0; c < 0x80 && uni != p[c]; c++) ;
			c = (c + 0x80) & 0xFF;
		}
	}

	return c;
}

// Assembly:
movl %edi, %eax
cmpl $0x7f, %edi
jbe 0xad43
cmpl $0x10000, %eax          # imm = 0x10000
setae %cl
cmpw $0x1b5, %si             # imm = 0x1B5
setne %dl
orb %cl, %dl
jne 0xad41
leaq 0x182a(%rip), %rdx      # 0xc550
xorl %ecx, %ecx
cmpq $0x80, %rcx
je 0xad41
movzwl (%rdx), %esi
cmpl %eax, %esi
je 0xad44
incq %rcx
addq $0x2, %rdx
jmp 0xad28
xorl %eax, %eax
retq
xorl $0x80, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/stickyPiston[P]ti-basic-compiler/src/main.c
// Function: openHelp
void openHelp(char *command) {
  puts("tic: TI-BASIC compiler");
  puts("Command line interface usage:");
  printf("%s <input file> <flags>\n", command);
  puts("\nAvailable flags:");
  puts(" -o: Specify the output file path");
  puts(" -i: Ignore whitespace characters, tabs and whitespaces will not be added to the final binary");
  puts(" -d: Enable disassembly mode");
  puts(" -n: Specify the name of the program when sent to the calculator");
  puts(" -h, --help: Show the help page");
  puts(" -l, --lang: Select a language, choices are: nl, en, se");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb73(%rip), %rdi       # 0xf031
callq 0xe070
leaq 0xb7e(%rip), %rdi       # 0xf048
callq 0xe070
leaq 0xb90(%rip), %rdi       # 0xf066
movq %rbx, %rsi
xorl %eax, %eax
callq 0xe0b0
leaq 0xb98(%rip), %rdi       # 0xf07f
callq 0xe070
leaq 0xb9e(%rip), %rdi       # 0xf091
callq 0xe070
leaq 0xbb4(%rip), %rdi       # 0xf0b3
callq 0xe070
leaq 0xc06(%rip), %rdi       # 0xf111
callq 0xe070
leaq 0xc17(%rip), %rdi       # 0xf12e
callq 0xe070
leaq 0xc4c(%rip), %rdi       # 0xf16f
callq 0xe070
leaq 0xc60(%rip), %rdi       # 0xf18f
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe070
nop
// File: /workspace/github_c_makefile_star2_O2/stickyPiston[P]ti-basic-compiler/src/tic.c
// Function: readFile
int readFile(char **out) {
  FILE *fp = fopen(inputFile, "r");
  if (fp == NULL) {
    fprintf(stderr, "Could not open %s\n", inputFile);
    abort();
  } 

  // Read all bytes from the source file
  fseek(fp, 0, SEEK_END);
  int filesize = ftell(fp);
  fseek(fp, 0, SEEK_SET);

  *out = malloc(filesize);
  fread(*out, filesize, 1, fp);

  fclose(fp);
  
  return filesize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xb6a0(%rip), %r15      # 0x19bf0
movq (%r15), %rdi
leaq 0x1069(%rip), %rsi      # 0xf5c3
callq 0xe130
testq %rax, %rax
je 0xe5c0
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0xe110
movq %rbx, %rdi
callq 0xe0f0
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe110
movslq %r15d, %r15
movq %r15, %rdi
callq 0xe100
movq %rax, (%r14)
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0xe080
movq %rbx, %rdi
callq 0xe090
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x4a31(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq (%r15), %rdx
leaq 0x2c3a(%rip), %rsi      # 0x1120e
xorl %eax, %eax
callq 0xe0e0
callq 0xe040
// File: /workspace/github_c_makefile_star2_O2/stickyPiston[P]ti-basic-compiler/src/tic.c
// Function: disassemble
void disassemble() {
  unsigned char *bytes = NULL;
  int filesize = readFile((char **)&bytes);

  for (int i = 74; i < filesize - 2; i++) {
    for (int j = 0; stringTable[j][lang] != NULL; j++) {
      if (bytes[i] == 0x5c || bytes[i] == 0x5d || bytes[i] == 0x5e || bytes[i] == 0x60 || bytes[i] == 0x61 || bytes[i] == 0xaa || bytes[i] == 0xef || bytes[i] == 0x62 || bytes[i] == 0x63 || bytes[i] == 0x7e || bytes[i] == 0xbb) {
        uint16_t twobytevalue = bytes[i] << 8;
        twobytevalue |= bytes[++i];
        if (functionTable[j].opcode == twobytevalue) {
          printf("%s", stringTable[j][lang]);
        }
      } else {
        if (functionTable[j].opcode == bytes[i]) {
          if (strcmp(stringTable[j][lang], "\n") != 0)
            printf("%s", stringTable[j][lang]);
        }
      }
    }
  }

  puts("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x38(%rbp), %r14
andq $0x0, (%r14)
movq %r14, %rdi
callq 0xe53c
addl $-0x2, %eax
movl %eax, -0x2c(%rbp)
pushq $0x4a
popq %rbx
movq (%r14), %r15
leaq 0xb1e8(%rip), %r12      # 0x19be8
cmpl -0x2c(%rbp), %ebx
jge 0xeaa8
leaq 0x6a60(%rip), %r14      # 0x15470
leaq 0x46a9(%rip), %r13      # 0x130c0
movl (%r12), %eax
movq (%r14,%rax,8), %rsi
testq %rsi, %rsi
je 0xeaa1
movslq %ebx, %rax
movzbl (%r15,%rax), %ecx
leal -0x5c(%rcx), %edx
cmpl $0x22, %edx
ja 0xea75
movabsq $0x4000000f7, %rdi      # imm = 0x4000000F7
btq %rdx, %rdi
jae 0xea75
shll $0x8, %ecx
movzbl 0x1(%r15,%rax), %edx
incq %rax
orl %ecx, %edx
movzwl (%r13), %ecx
movl %eax, %ebx
cmpl %ecx, %edx
jne 0xea6b
leaq 0x27e1(%rip), %rdi      # 0x11245
xorl %eax, %eax
callq 0xe0b0
addq $0xc, %r13
addq $0x18, %r14
jmp 0xea17
cmpl $0xaa, %ecx
je 0xea44
cmpl $0xef, %ecx
je 0xea44
cmpl $0xbb, %ecx
je 0xea44
cmpw %cx, (%r13)
jne 0xea6b
cmpb $0xa, (%rsi)
jne 0xea5d
cmpb $0x0, 0x1(%rsi)
jne 0xea5d
jmp 0xea6b
incl %ebx
jmp 0xea00
pushq $0xa
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe030
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_02/lseek.c
// Function: main
int main(void)
{
	char c;
	off_t pos;
	int ret;

	/* Check if the file is lseek()-able */
	ret = lseek(STDIN_FILENO, 0, SEEK_CUR);
	if (ret < 0) {
		perror("cannot lseek()");
		return -1;
	}

	/* Move the offset to position -16 (16 bytes from the end of
	 * the file).
	 */
	pos = lseek(STDIN_FILENO, -16, SEEK_END);
	if (pos < 0) {
		perror("cannot move to position -16");
		return -1;
	}
	
	/* Read and then print out the data */
	ret = read(STDIN_FILENO, &c, 1);
	if (ret == 1)
		printf("file@%ld=%c\n", pos, c);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
pushq $0x1
popq %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x1040
testl %eax, %eax
js 0x11c5
xorl %ebx, %ebx
pushq $-0x10
popq %rsi
pushq $0x2
popq %rdx
xorl %edi, %edi
callq 0x1040
testq %rax, %rax
js 0x11ce
movq %rax, %r14
leaq 0x7(%rsp), %rsi
pushq $0x1
popq %rdx
xorl %edi, %edi
callq 0x1050
cmpl $0x1, %eax
jne 0x11dd
movsbl 0x7(%rsp), %edx
leaq 0xe78(%rip), %rdi       # 0x202f
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1030
jmp 0x11dd
leaq 0xe38(%rip), %rdi       # 0x2004
jmp 0x11d5
leaq 0xe3e(%rip), %rdi       # 0x2013
callq 0x1060
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_01/strindex.c
// Function: main
int main(void)
{
  char line[MAXLEN];
  char pattern[MAXLEN] = "example";

  get_line(line, MAXLEN);
  printf("%s\n", line);

  printf("Pattern found at index %d\n", strindex(line, pattern));

  return 0;
}

// Assembly:
pushq %rbx
subq $0x3f0, %rsp            # imm = 0x3F0
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11b6
movq %rbx, %rdi
callq 0x1030
leaq 0xe7d(%rip), %rsi       # 0x2010
movq %rbx, %rdi
callq 0x11fd
leaq 0x1256(%rip), %rdi      # 0x23f8
movl %eax, %esi
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_01/strindex.c
// Function: get_line
int get_line(char line[], int lim)
{
  int i = 0, c;

  while (lim > 0 && (c = getchar()) != EOF && c != '\n')
  {
    line[i++] = c;
    --lim;
  }

  if (c == '\n')
  {
    line[i++] = c;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
testl %ebp, %ebp
jle 0x11e0
callq 0x1060
cmpl $-0x1, %eax
je 0x11e0
cmpl $0xa, %eax
je 0x11e0
movb %al, (%rbx,%r14)
incq %r14
decl %ebp
jmp 0x11c2
cmpl $0xa, %eax
jne 0x11f1
movb $0xa, (%rbx,%r14)
leal 0x1(%r14), %eax
movl %eax, %r14d
movslq %r14d, %rax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_01/strindex.c
// Function: strindex
int strindex(char source[], char pattern[])
{
  int i, j, k;

  printf("line len: %lu\n", strlen(source));

  for (i = strlen(source); i >= 0; --i)
  {
    for (j = i, k = 0; pattern[k] != '\0' && source[j] == pattern[k]; ++j, ++k)
      ;

    if (k > 0 && pattern[k] == '\0')
    {
      return i;
    }
  }

  return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1040
leaq 0x1200(%rip), %rdi      # 0x2413
movq %rax, %rsi
xorl %eax, %eax
callq 0x1050
movq %r14, %rdi
callq 0x1040
movq %rax, %rcx
pushq $-0x1
popq %rax
testl %ecx, %ecx
js 0x1255
movl %ecx, %edx
addq %r14, %rdx
xorl %esi, %esi
movb (%rbx,%rsi), %dil
testb %dil, %dil
je 0x124a
cmpb %dil, (%rdx,%rsi)
jne 0x124f
incq %rsi
jmp 0x1236
testq %rsi, %rsi
jne 0x1253
decl %ecx
jmp 0x122b
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/aws/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * filename_bad = "/dev/null";
	const char * filename_good = "format.key";
	char * key_id;
	char * key_secret;

	WARNP_INIT;
	(void)argc; /* UNUSED */

	/* Generate a failure. */
	fprintf(stderr, "---- Trying to find AWS keys in %s\n", filename_bad);
	if (!aws_readkeys(filename_bad, &key_id, &key_secret)) {
		warn0("That should have failed!");
		goto err0;
	}

	/* Read key info from real file. */
	fprintf(stderr, "---- Trying to find AWS keys in %s\n", filename_good);
	if (aws_readkeys(filename_good, &key_id, &key_secret)) {
		warn0("aws_readkeys");
		goto err0;
	}

	/* Display key info. */
	fprintf(stderr, "id:\t%s\n", key_id);
	fprintf(stderr, "secret:\t%s\n", key_secret);

	/* Generate a header. */
	fprintf(stderr, "---- Generate a header\n");
	if (s3_headers(key_id, key_secret))
		goto err0;

	/* Clean up */
	free(key_id);
	free(key_secret);

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1330
callq 0x23e4
movq 0x6cc1(%rip), %r14      # 0x7ff8
movq (%r14), %rdi
leaq 0x3cd8(%rip), %rsi      # 0x5019
leaq 0x3cbc(%rip), %rbx      # 0x5004
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1140
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x14b0
testl %eax, %eax
je 0x149d
movq (%r14), %rdi
leaq 0x3ca5(%rip), %rsi      # 0x5019
leaq 0x3c93(%rip), %rbx      # 0x500e
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1140
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x14b0
testl %eax, %eax
jne 0x14a6
movq (%r14), %rdi
movq 0x8(%rsp), %rdx
leaq 0x3cb7(%rip), %rsi      # 0x5063
xorl %eax, %eax
callq 0x1140
movq (%r14), %rdi
movq (%rsp), %rdx
leaq 0x3caa(%rip), %rsi      # 0x506b
xorl %eax, %eax
callq 0x1140
movq (%r14), %rcx
leaq 0x3ca5(%rip), %rdi      # 0x5077
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
subq $0x8, %rsp
leaq 0x20(%rsp), %rax
leaq 0x28(%rsp), %r10
leaq 0x18(%rsp), %r11
leaq 0x3ca6(%rip), %rbx      # 0x50a6
leaq 0x3c88(%rip), %rdx      # 0x508f
leaq 0x3c85(%rip), %rcx      # 0x5093
leaq 0x3c85(%rip), %r8       # 0x509a
leaq 0x3c85(%rip), %r9       # 0x50a1
pushq %rax
pushq %r10
pushq %r11
pushq $0x4
pushq %rbx
callq 0x17bc
addq $0x30, %rsp
testl %eax, %eax
jne 0x147f
movq (%r14), %rdi
movq 0x10(%rsp), %rdx
leaq 0x3c7f(%rip), %rsi      # 0x50bf
xorl %eax, %eax
callq 0x1140
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x20(%rsp), %rdi
callq 0x1030
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x11e0
leaq 0x3c25(%rip), %rdi      # 0x50ab
xorl %eax, %eax
callq 0x25f0
callq 0x1060
andl $0x0, (%rax)
pushq $0x1
popq %rdi
callq 0x11e0
leaq 0x3b99(%rip), %rdi      # 0x503d
jmp 0x1486
leaq 0x3ba9(%rip), %rdi      # 0x5056
jmp 0x1486
nop
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: main
int main(void)
{
  struct tree_node *tree_root = NULL;
  char word[MAX_WORD_LEN];

  while (get_word(word, MAX_WORD_LEN) != EOF)
  {
    if (isalpha(word[0]))
    {
      tree_root = add_to_tree(tree_root, word);
    }
  }

  struct tree_node *tree_node_list[MAX_NR_OF_NODES] = {NULL};
  copy_tree_to_array(tree_node_list, tree_root);

  quick_sort((void **)tree_node_list, 0, nr_of_nodes - 1, (int (*)(void *, void *))tree_node_cmp);

  for (size_t i = 0; i < nr_of_nodes; ++i)
  {
    printf("%4d %s\n", tree_node_list[i]->count, tree_node_list[i]->word);
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1fb0, %rsp           # imm = 0x1FB0
xorl %ebx, %ebx
movq %rsp, %r14
pushq $0x64
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x1277
cmpl $-0x1, %eax
je 0x1202
callq 0x10b0
movq (%rax), %rax
movsbq (%rsp), %rcx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x11cf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1333
movq %rax, %rbx
jmp 0x11cf
leaq 0x70(%rsp), %r14
movl $0x1f40, %edx           # imm = 0x1F40
movq %r14, %rdi
xorl %esi, %esi
callq 0x1060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13ab
movq 0x2e50(%rip), %rdx      # 0x4078
decq %rdx
leaq 0x260(%rip), %rcx       # 0x1492
movq %r14, %rdi
xorl %esi, %esi
callq 0x13f2
leaq 0xdc1(%rip), %rbx       # 0x2004
xorl %r14d, %r14d
cmpq 0x2e2b(%rip), %r14      # 0x4078
jae 0x1269
movq 0x70(%rsp,%r14,8), %rax
movl 0x8(%rax), %esi
movq (%rax), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1050
incq %r14
jmp 0x1246
xorl %eax, %eax
addq $0x1fb0, %rsp           # imm = 0x1FB0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: get_word
int get_word(char *word, int max_word_len)
{
  skip_blanks();

  int c = getc(stdin);
  size_t i = 0;

  if (c != EOF)
  {
    word[i++] = c;
  }

  if (!isalpha(c) && c != '_')
  {
    word[i] = '\0';
    return c;
  }

  while ((isalnum(c = getc(stdin)) || c == '_') && i < max_word_len)
  {
    word[i++] = c;
  }
  ungetc(c, stdin);
  word[i] = '\0';

  return word[0];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
callq 0x14c9
movq 0x2d4b(%rip), %r12      # 0x3fe0
movq (%r12), %rdi
callq 0x10a0
movl %eax, %r15d
cmpl $-0x1, %eax
je 0x12af
movb %r15b, (%rbx)
pushq $0x1
popq %r13
jmp 0x12b2
xorl %r13d, %r13d
callq 0x10b0
movq %rax, %r14
movq (%rax), %rbp
cmpl $0x5f, %r15d
je 0x12d9
movslq %r15d, %rax
movzwl (%rbp,%rax,2), %eax
andl $0x400, %eax            # imm = 0x400
jne 0x12d9
movb $0x0, (%rbx,%r13)
jmp 0x1321
movslq 0x4(%rsp), %r15
movq (%r12), %rdi
callq 0x10a0
movslq %eax, %rcx
testb $0x8, (%rbp,%rcx,2)
sete %dl
cmpl $0x5f, %ecx
setne %cl
testb %dl, %cl
jne 0x130d
cmpq %r15, %r13
jae 0x130d
movb %al, (%rbx,%r13)
incq %r13
movq (%r14), %rbp
jmp 0x12de
movq (%r12), %rsi
movl %eax, %edi
callq 0x1090
movb $0x0, (%rbx,%r13)
movsbl (%rbx), %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: add_to_tree
struct tree_node *add_to_tree(struct tree_node *node_p, char *word)
{
  int cond;

  if (node_p == NULL)
  {
    node_p = (struct tree_node *)malloc(sizeof(struct tree_node));
    node_p->word = str_dup(word);
    node_p->count = 1;
    node_p->left = node_p->right = NULL;
  }
  else if ((cond = strcmp(word, node_p->word)) == 0)
  {
    node_p->count++;
  }
  else if (cond < 0)
  {
    node_p->left = add_to_tree(node_p->left, word);
  }
  else if (cond > 0)
  {
    node_p->right = add_to_tree(node_p->right, word);
  }

  return node_p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x1365
movq %rdi, %rbx
movq (%rdi), %rsi
movq %r14, %rdi
callq 0x1070
testl %eax, %eax
je 0x138b
jns 0x1390
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x1333
movq %rax, 0x10(%rbx)
jmp 0x13a0
pushq $0x20
popq %rdi
callq 0x1080
movq %rax, %rbx
movq %r14, %rdi
callq 0x14a4
movq %rax, (%rbx)
movl $0x1, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
jmp 0x13a0
incl 0x8(%rbx)
jmp 0x13a0
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1333
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: copy_tree_to_array
void copy_tree_to_array(struct tree_node *arr[], struct tree_node *tree_node_p)
{
  if (tree_node_p != NULL)
  {
    copy_tree_to_array(arr, tree_node_p->left);
    if (nr_of_nodes < MAX_NR_OF_NODES)
    {
      arr[nr_of_nodes++] = tree_node_p;
    }
    copy_tree_to_array(arr, tree_node_p->right);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rbx, %rbx
je 0x13ea
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x13ab
movq 0x2cab(%rip), %rax      # 0x4078
cmpq $0x3e7, %rax            # imm = 0x3E7
ja 0x13e4
leaq 0x1(%rax), %rcx
movq %rcx, 0x2c98(%rip)      # 0x4078
movq %rbx, (%r14,%rax,8)
movq 0x18(%rbx), %rbx
jmp 0x13b5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: str_dup
char *str_dup(char *src)
{
  char *dest = (char *)malloc(strlen(src) + 1);
  if (dest != NULL)
  {
    strcpy(dest, src);
  }
  return dest;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1040
leaq 0x1(%rax), %rdi
callq 0x1080
testq %rax, %rax
je 0x14c7
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1030
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: print_tree
void print_tree(struct tree_node *node_p)
{
  if (node_p != NULL)
  {
    print_tree(node_p->left);
    printf("%4d %s\n", node_p->count, node_p->word);
    print_tree(node_p->right);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xae4(%rip), %r14       # 0x2004
testq %rbx, %rbx
je 0x1544
movq 0x10(%rbx), %rdi
callq 0x1512
movl 0x8(%rbx), %esi
movq (%rbx), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1050
movq 0x18(%rbx), %rbx
jmp 0x1520
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/ecc/bch.c
// Function: chunk_remainder
static bch_poly_t chunk_remainder(const struct bch_def *def,
				  const uint8_t *chunk, size_t len)
{
	bch_poly_t remainder = 0;
	int i;

	for (i = 0; i < len; i++) {
		int j;

		remainder ^= chunk[i] ^ 0xff;

		for (j = 0; j < 8; j++) {
			if (remainder & 1)
				remainder ^= def->generator;
			remainder >>= 1;
		}
	}

	return remainder;
}

// Assembly:
xorl %ecx, %ecx
pushq $0x8
popq %r8
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x1208
movzbl (%rsi,%rcx), %r10d
xorq %rax, %r10
xorq $0xff, %r10
movl %r8d, %r9d
movq %r10, %rax
subl $0x1, %r9d
jb 0x1203
testb $0x1, %al
je 0x11fe
xorq 0x8(%rdi), %rax
shrq %rax
jmp 0x11f0
incq %rcx
jmp 0x11d6
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/ecc/bch.c
// Function: unpack_poly
static bch_poly_t unpack_poly(const struct bch_def *def, const uint8_t *ecc)
{
	bch_poly_t poly = 0;
	int i;

	for (i = def->ecc_bytes - 1; i >= 0; i--) {
		poly <<= 8;
		poly |= ecc[i] ^ 0xff;
	}

	poly &= ((1LL << def->degree) - 1);
	return poly;
}

// Assembly:
movl 0x14(%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
jle 0x125a
shlq $0x8, %rax
movzbl -0x1(%rsi,%rcx), %edx
decq %rcx
xorq $0xff, %rdx
orq %rdx, %rax
jmp 0x123e
movb 0x10(%rdi), %cl
pushq $-0x1
popq %rdx
shlq %cl, %rdx
notq %rdx
andq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/ecc/bch.c
// Function: poly_eval
static gf13_elem_t poly_eval(const gf13_elem_t *s, gf13_elem_t x)
{
	int i;
	gf13_elem_t sum = 0;
	gf13_elem_t t = x;

	for (i = 0; i < MAX_POLY; i++) {
		const gf13_elem_t c = s[i];

		if (c)
			sum ^= gf13_mul(c, t);

		t = gf13_mul(t, x);
	}

	return sum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
xorl %r12d, %r12d
movzwl %ax, %ebp
xorl %r14d, %r14d
cmpq $0x10, %r12
je 0x161f
movzwl (%rbx,%r12,2), %ecx
movzwl %ax, %r15d
testw %cx, %cx
je 0x1610
movzwl %cx, %edi
movl %r15d, %esi
callq 0x1657
xorl %eax, %r14d
movl %r15d, %edi
movl %ebp, %esi
callq 0x1657
incq %r12
jmp 0x15ee
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/ecc/bch.c
// Function: poly_add
static void poly_add(gf13_elem_t *dst, const gf13_elem_t *src,
		     gf13_elem_t c, int shift)
{
	int i;

	for (i = 0; i < MAX_POLY; i++) {
		int p = i + shift;
		gf13_elem_t v = src[i];

		if (p < 0 || p >= MAX_POLY)
			continue;
		if (!v)
			continue;

		dst[p] ^= gf13_mul(v, c);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movslq %ecx, %r14
leaq (%rdi,%r14,2), %r15
xorl %r12d, %r12d
movzwl %dx, %ebp
cmpq $0x10, %r12
je 0x16d3
leaq (%r14,%r12), %rcx
movzwl (%rbx,%r12,2), %eax
cmpq $0x10, %rcx
setae %cl
testw %ax, %ax
sete %dl
orb %cl, %dl
jne 0x16ce
movzwl %ax, %edi
movl %ebp, %esi
callq 0x1657
xorw %ax, (%r15,%r12,2)
incq %r12
jmp 0x169f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/tests/bch.c
// Function: main
int main(void)
{
	srandom(0);
	test_code(&bch_1bit);
	test_code(&bch_2bit);
	test_code(&bch_3bit);
	test_code(&bch_4bit);

	return 0;
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x1030
leaq 0x91d(%rip), %rdi       # 0x2008
callq 0x1718
leaq 0x929(%rip), %rdi       # 0x2020
callq 0x1718
leaq 0x935(%rip), %rdi       # 0x2038
callq 0x1718
leaq 0x941(%rip), %rdi       # 0x2050
callq 0x1718
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/tests/bch.c
// Function: test_code
static void test_code(const struct bch_def *def)
{
	uint8_t block[TEST_CHUNK_SIZE];
	int i;

	printf("nbits: %d\n", def->syns / 2);

	memset(block, 0xff, sizeof(block));
	test_properties(def, block);

	for (i = 0; i < 10; i++)
		test_random_block(def);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
movq %rdi, %rbx
movl (%rdi), %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
leaq 0x8936(%rip), %rdi      # 0xa070
xorl %r12d, %r12d
movl %eax, %esi
xorl %eax, %eax
callq 0x1040
leaq 0x210(%rsp), %r14
movl $0x208, %edx            # imm = 0x208
movq %r14, %rdi
movl $0xff, %esi
callq 0x1060
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17ca
leaq 0x200(%rsp), %r14
movq %rsp, %r15
cmpl $0xa, %r12d
je 0x17b9
xorl %r13d, %r13d
cmpq $0x200, %r13            # imm = 0x200
je 0x1796
callq 0x1080
movb %al, (%rsp,%r13)
incq %r13
jmp 0x177f
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x119c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17ca
incl %r12d
jmp 0x1776
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/tests/bch.c
// Function: test_properties
static void test_properties(const struct bch_def *def,
			    const uint8_t *block)
{
	int i;

	i = bch_verify(def, block, BCH_CHUNK_SIZE, block + BCH_CHUNK_SIZE);
	assert(!i);

	for (i = 0; i < 20; i++)
		flip_test(def, block);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x200(%rsi), %rcx
movl $0x200, %edx            # imm = 0x200
callq 0x1209
testl %eax, %eax
jne 0x190e
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
movl $0x1040, %r13d          # imm = 0x1040
pushq $0x1
popq %r15
movq %rbx, 0x8(%rsp)
cmpl $0x14, %ebp
je 0x18c6
movl $0x208, %edx            # imm = 0x208
movq %rdi, %r12
movq %rbx, %rsi
callq 0x1070
xorl %ebx, %ebx
cmpl (%r14), %ebx
jge 0x1855
callq 0x1080
cqto
idivq %r13
movq %rdx, %rcx
movl %ecx, %eax
sarl $0x3, %eax
andb $0x7, %cl
movl %r15d, %edx
shll %cl, %edx
cltq
xorb %dl, 0x10(%rsp,%rax)
addl $0x2, %ebx
jmp 0x182b
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r12, %rsi
leaq 0x210(%rsp), %rcx
callq 0x1209
testl %eax, %eax
jns 0x18a3
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r12, %rsi
leaq 0x210(%rsp), %rbx
movq %rbx, %rcx
callq 0x126a
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x1209
testl %eax, %eax
jne 0x18f1
movl $0x200, %edx            # imm = 0x200
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1090
testl %eax, %eax
jne 0x18d8
movq %r12, %rdi
incl %ebp
jmp 0x1810
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x879c(%rip), %rdi      # 0xa07b
leaq 0x8798(%rip), %rsi      # 0xa07e
leaq 0x87db(%rip), %rcx      # 0xa0c8
pushq $0x35
jmp 0x1908
leaq 0x8783(%rip), %rdi      # 0xa07b
leaq 0x877f(%rip), %rsi      # 0xa07e
leaq 0x87c2(%rip), %rcx      # 0xa0c8
pushq $0x31
popq %rdx
callq 0x1050
leaq 0x8766(%rip), %rdi      # 0xa07b
leaq 0x8762(%rip), %rsi      # 0xa07e
leaq 0x8767(%rip), %rcx      # 0xa08a
pushq $0x3e
jmp 0x1908
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_02/escape.c
// Function: main
int main(void)
{
  char src[MAXLEN];
  char dest[MAXLEN];

  get_line(src, MAXLEN);
  printf("%s", src);

  escape(dest, src);
  printf("%s\n", dest);

  unescape(dest, src);
  printf("%s", dest);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x7e0, %rsp            # imm = 0x7E0
leaq 0x3f0(%rsp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11ce
leaq 0xedc(%rip), %r14       # 0x2060
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x121b
movq %r15, %rdi
callq 0x1030
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1287
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1040
xorl %eax, %eax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_02/escape.c
// Function: get_line
int get_line(char line[], unsigned int limit)
{
  int i, c;
  for (i = 0; i < limit - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
  {
    line[i] = c;
  }

  if (c == '\n')
  {
    line[i++] = c;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
decl %r14d
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x11ff
callq 0x1050
cmpl $-0x1, %eax
je 0x11fc
cmpl $0xa, %eax
je 0x11fc
movb %al, (%rbx,%r15)
incq %r15
jmp 0x11df
movl %r15d, %r14d
cmpl $0xa, %eax
jne 0x120e
movl %r14d, %eax
incl %r14d
movb $0xa, (%rbx,%rax)
movslq %r14d, %rax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/readpass_file/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * filename;
	char * passwd;

	WARNP_INIT;

	/* Process arguments. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_readpass_file FILENAME\n");
		goto err0;
	}
	filename = argv[1];

	/* Read passphrase. */
	if (readpass_file(&passwd, filename))
		goto err0;

	/* Print passphrase. */
	printf("%s\n", passwd);

	/* Clean up. */
	insecure_memzero(passwd, strlen(passwd));
	free(passwd);

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x12c1
callq 0x1534
cmpl $0x2, %ebp
je 0x12ea
movq 0x2d2b(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd2d(%rip), %rdi       # 0x2004
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x1180
pushq $0x1
popq %rdi
callq 0x1170
movq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x1348
testl %eax, %eax
jne 0x12e2
movq (%rsp), %rdi
callq 0x1070
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x10b0
leaq 0x2dd2(%rip), %rcx      # 0x40e8
movq (%rcx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *%rcx
movq (%rsp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1170
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: is_integer
int is_integer(pointer p) {
  if (!is_number(p))
    return 0;
  if (num_is_integer(p) || (double) ivalue(p) == rvalue(p))
    return 1;
  return 0;
}

// Assembly:
movl (%rdi), %ecx
andl $0x1f, %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
jne 0x4469
pushq $0x1
popq %rax
cmpb $0x0, 0x8(%rdi)
je 0x446a
retq
movsd 0x10(%rdi), %xmm0
cvttsd2si %xmm0, %rcx
cvtsi2sd %rcx, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4481
jnp 0x4469
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: get_cell
static pointer get_cell(scheme * sc, pointer a, pointer b) {
  pointer cell = get_cell_x(sc, a, b);
  /* For right now, include "a" and "b" in "cell" so that gc doesn't
     think they are garbage. */
  /* Tentatively record it as a pair so gc understands it. */
  typeflag(cell) = T_PAIR;
  car(cell) = a;
  cdr(cell) = b;
  push_recent_alloc(sc, cell, sc->NIL);
  return cell;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x6114
movq %rax, %r12
movl $0x5, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0x90(%r15), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x61a7
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: mk_foreign_func
pointer mk_foreign_func(scheme * sc, foreign_func f) {
  pointer x = get_cell(sc, sc->NIL, sc->NIL);

  typeflag(x) = (T_FOREIGN | T_ATOM);
  x->_object._ff = f;
  return (x);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x90(%rdi), %rdx
movq %rdx, %rsi
callq 0x4617
movl $0x4008, (%rax)         # imm = 0x4008
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: mk_character
INTERFACE pointer mk_character(scheme * sc, int c) {
  pointer x = get_cell(sc, sc->NIL, sc->NIL);

  typeflag(x) = (T_CHARACTER | T_ATOM);
  ivalue_unchecked(x) = c;
  set_num_integer(x);
  return (x);
}

// Assembly:
pushq %rbx
movl %esi, %ebx
movq 0x90(%rdi), %rdx
movq %rdx, %rsi
callq 0x4617
movl $0x4009, (%rax)         # imm = 0x4009
movslq %ebx, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: mk_integer
INTERFACE pointer mk_integer(scheme * sc, long num) {
  pointer x = get_cell(sc, sc->NIL, sc->NIL);

  typeflag(x) = (T_NUMBER | T_ATOM);
  ivalue_unchecked(x) = num;
  set_num_integer(x);
  return (x);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x90(%rdi), %rdx
movq %rdx, %rsi
callq 0x4617
movl $0x4002, (%rax)         # imm = 0x4002
movq %rbx, 0x10(%rax)
movb $0x1, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: mk_real
INTERFACE pointer mk_real(scheme * sc, double n) {
  pointer x = get_cell(sc, sc->NIL, sc->NIL);

  typeflag(x) = (T_NUMBER | T_ATOM);
  rvalue_unchecked(x) = n;
  set_num_real(x);
  return (x);
}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
movq 0x90(%rdi), %rdx
movq %rdx, %rsi
callq 0x4617
movl $0x4002, (%rax)         # imm = 0x4002
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movb $0x0, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: mk_counted_string
INTERFACE pointer mk_counted_string(scheme * sc, const char *str, int len) {
  char *s;
  pointer x = get_cell(sc, sc->NIL, sc->NIL);
  typeflag(x) = (T_STRING | T_ATOM);
  s = store_string(sc, len, str);
  strvalue(x) = s;
  strlength(x) = IS_ASCII(*s) ? len : UTFSTR_LEN_GET(s);
  return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
movq 0x90(%rdi), %rdx
movq %rdx, %rsi
callq 0x4617
movq %rax, %r14
movl $0x4001, (%rax)         # imm = 0x4001
movq %r12, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x4773
movq %rax, 0x8(%r14)
cmpb $0x0, (%rax)
jns 0x4760
movl (%rax), %ebx
shrl $0x8, %ebx
andl $0x7fffff, %ebx         # imm = 0x7FFFFF
movl %ebx, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq