LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movw $0x0, -0x8(%rbp)
leaq 0x2745(%rip), %rax      # 0x12590
movq %rax, -0x10(%rbp)
cmpl $0x80, -0x4(%rbp)
jae 0xfe61
movl -0x4(%rbp), %eax
movw %ax, -0x8(%rbp)
jmp 0xfed0
cmpl $0x10000, -0x4(%rbp)    # imm = 0x10000
jae 0xfece
movzwl -0x6(%rbp), %eax
cmpl $0x1b5, %eax            # imm = 0x1B5
jne 0xfece
movw $0x0, -0x8(%rbp)
movzwl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl $0x80, %ecx
movb %al, -0x11(%rbp)
jge 0xfea3
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl -0x8(%rbp), %edx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xfeac
jmp 0xfebc
jmp 0xfeae
movw -0x8(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x8(%rbp)
jmp 0xfe7b
movzwl -0x8(%rbp), %eax
addl $0x80, %eax
andl $0xff, %eax
movw %ax, -0x8(%rbp)
jmp 0xfed0
movw -0x8(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lb3361[P]dosfs/ffunicode.c
// Function: ff_oem2uni
WCHAR ff_oem2uni (	/* Returns Unicode character in UTF-16, zero on error */
	WCHAR	oem,	/* OEM code to be converted */
	WORD	cp		/* Code page for the conversion */
)
{
	WCHAR c = 0;
	const WCHAR *p = CVTBL(uc, FF_CODE_PAGE);


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

	} else {			/* Extended char */
		if (cp == FF_CODE_PAGE) {	/* Is it a valid code page? */
			if (oem < 0x100) c = p[oem - 0x80];
		}
	}

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movw $0x0, -0x6(%rbp)
leaq 0x2691(%rip), %rax      # 0x12590
movq %rax, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x80, %eax
jge 0xff18
movw -0x2(%rbp), %ax
movw %ax, -0x6(%rbp)
jmp 0xff4b
movzwl -0x4(%rbp), %eax
cmpl $0x1b5, %eax            # imm = 0x1B5
jne 0xff49
movzwl -0x2(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
jge 0xff47
movq -0x10(%rbp), %rax
movzwl -0x2(%rbp), %ecx
subl $0x80, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x6(%rbp)
jmp 0xff49
jmp 0xff4b
movw -0x6(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xa99(%rip), %rdi       # 0xf04c
callq 0xe070
leaq 0xaa4(%rip), %rdi       # 0xf063
callq 0xe070
movq -0x8(%rbp), %rsi
leaq 0xab2(%rip), %rdi       # 0xf081
movb $0x0, %al
callq 0xe0b0
leaq 0xabd(%rip), %rdi       # 0xf09a
callq 0xe070
leaq 0xac3(%rip), %rdi       # 0xf0ac
callq 0xe070
leaq 0xad9(%rip), %rdi       # 0xf0ce
callq 0xe070
leaq 0xb2b(%rip), %rdi       # 0xf12c
callq 0xe070
leaq 0xb3c(%rip), %rdi       # 0xf149
callq 0xe070
leaq 0xb71(%rip), %rdi       # 0xf18a
callq 0xe070
leaq 0xb85(%rip), %rdi       # 0xf1aa
callq 0xe070
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb5ad(%rip), %rax      # 0x19bf0
movq (%rax), %rdi
leaq 0xf91(%rip), %rsi       # 0xf5de
callq 0xe130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe684
movq 0x4994(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0xb582(%rip), %rax      # 0x19bf0
movq (%rax), %rdx
leaq 0x2bb1(%rip), %rsi      # 0x11229
movb $0x0, %al
callq 0xe0e0
callq 0xe030
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xe110
movq -0x10(%rbp), %rdi
callq 0xe0f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xe110
movslq -0x14(%rbp), %rdi
callq 0xe100
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0xe080
movq -0x10(%rbp), %rdi
callq 0xe090
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x1040
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x11ad
leaq 0xe65(%rip), %rdi       # 0x2004
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1216
xorl %edi, %edi
movq $-0x10, %rsi
movl $0x2, %edx
callq 0x1040
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x11e0
leaq 0xe41(%rip), %rdi       # 0x2013
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1216
xorl %edi, %edi
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x1050
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x120f
movq -0x10(%rbp), %rsi
movsbl -0x5(%rbp), %edx
leaq 0xe27(%rip), %rdi       # 0x202f
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x7e0, %rsp            # imm = 0x7E0
movl $0x0, -0x4(%rbp)
leaq -0x7e0(%rbp), %rdi
leaq 0xe80(%rip), %rsi       # 0x2010
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x1060
leaq -0x3f0(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11f0
leaq -0x3f0(%rbp), %rsi
leaq 0x123f(%rip), %rdi      # 0x23f8
movb $0x0, %al
callq 0x1040
leaq -0x3f0(%rbp), %rdi
leaq -0x7e0(%rbp), %rsi
callq 0x12a0
movl %eax, %esi
leaq 0x1220(%rip), %rdi      # 0x23fc
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x15(%rbp)
jle 0x122f
callq 0x1050
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x15(%rbp)
je 0x122f
cmpl $0xa, -0x14(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1238
jmp 0x125d
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1206
cmpl $0xa, -0x14(%rbp)
jne 0x127d
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq %rax, %rsi
leaq 0x1154(%rip), %rdi      # 0x2417
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rdi
callq 0x1030
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1371
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
je 0x1323
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x132c
jmp 0x1342
jmp 0x132e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x12ed
cmpl $0x0, -0x24(%rbp)
jle 0x1361
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1361
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1378
jmp 0x1363
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12d6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x9ce7(%rip), %rax      # 0xb004
movq %rax, -0x18(%rbp)
leaq 0x9ce6(%rip), %rax      # 0xb00e
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1342
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2b40
jmp 0x1344
movq 0xccad(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x9cc0(%rip), %rsi      # 0xb019
movb $0x0, %al
callq 0x1140
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x15d0
cmpl $0x0, %eax
jne 0x1396
jmp 0x1378
leaq 0x9cbe(%rip), %rdi      # 0xb03d
movb $0x0, %al
callq 0x2e50
callq 0x1060
movl $0x0, (%rax)
jmp 0x1462
movq 0xcc5b(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x9c6e(%rip), %rsi      # 0xb019
movb $0x0, %al
callq 0x1140
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x15d0
cmpl $0x0, %eax
je 0x13e5
jmp 0x13ca
leaq 0x9c85(%rip), %rdi      # 0xb056
movb $0x0, %al
callq 0x2e50
callq 0x1060
movl $0x0, (%rax)
jmp 0x1462
movq 0xcc0c(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x9c69(%rip), %rsi      # 0xb063
movb $0x0, %al
callq 0x1140
movq 0xcbf0(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
leaq 0x9c55(%rip), %rsi      # 0xb06b
movb $0x0, %al
callq 0x1140
movq 0xcbd4(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x9c49(%rip), %rsi      # 0xb077
movb $0x0, %al
callq 0x1140
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1470
cmpl $0x0, %eax
je 0x1449
jmp 0x1462
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x11d0
movl $0x1, %edi
callq 0x11d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/aws/main.c
// Function: s3_headers
static int
s3_headers(const char * key_id, const char * key_secret)
{
	const char * region = "reg";
	const char * method = "method";
	const char * bucket = "bucket";
	const char * path = "path";
	const char * body = "body";
	char * amz_content;
	char * amz_date;
	char * auth;

	/* Generate a header. */
	if (aws_sign_s3_headers(key_id, key_secret, region, method, bucket,
	    path, (const uint8_t *)body, strlen(body), &amz_content,
	    &amz_date, &auth)) {
		warn0("aws_sign_s3_headers");
		goto err0;
	}

	/* This computed value doesn't change. */
	fprintf(stderr, "content:\t%s\n", amz_content);

	/* The date and auth change, so they're not great for testing. */

	/* Clean up. */
	free(amz_content);
	free(amz_date);
	free(auth);

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
leaq 0x9c02(%rip), %rax      # 0xb08f
movq %rax, -0x30(%rbp)
leaq 0x9bfb(%rip), %rax      # 0xb093
movq %rax, -0x38(%rbp)
leaq 0x9bf7(%rip), %rax      # 0xb09a
movq %rax, -0x40(%rbp)
leaq 0x9bf3(%rip), %rax      # 0xb0a1
movq %rax, -0x48(%rbp)
leaq 0x9bed(%rip), %rax      # 0xb0a6
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x50(%rbp), %r14
movq -0x50(%rbp), %rdi
callq 0x10a0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %r8
movq -0x70(%rbp), %r9
movq %rax, %rbx
leaq -0x58(%rbp), %r11
leaq -0x60(%rbp), %r10
leaq -0x68(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x19d0
cmpl $0x0, %eax
je 0x1572
jmp 0x1557
leaq 0x9b4d(%rip), %rdi      # 0xb0ab
movb $0x0, %al
callq 0x2e50
callq 0x1060
movl $0x0, (%rax)
jmp 0x15b2
movq 0xca7f(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq -0x58(%rbp), %rdx
leaq 0x9b38(%rip), %rsi      # 0xb0bf
movb $0x0, %al
callq 0x1140
movq -0x58(%rbp), %rdi
callq 0x1030
movq -0x60(%rbp), %rdi
callq 0x1030
movq -0x68(%rbp), %rdi
callq 0x1030
movl $0x0, -0x14(%rbp)
jmp 0x15b9
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1fd0, %rsp           # imm = 0x1FD0
movl $0x0, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x80(%rbp), %rdi
movl $0x64, %esi
callq 0x12d0
cmpl $-0x1, %eax
je 0x121d
callq 0x10b0
movq (%rax), %rax
movsbl -0x80(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x121b
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1400
movq %rax, -0x10(%rbp)
jmp 0x11da
leaq -0x1fc0(%rbp), %rdi
xorl %esi, %esi
movl $0x1f40, %edx           # imm = 0x1F40
callq 0x1060
leaq -0x1fc0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14e0
leaq -0x1fc0(%rbp), %rdi
movq 0x2e2a(%rip), %rdx      # 0x4078
subq $0x1, %rdx
xorl %eax, %eax
movl %eax, %esi
leaq 0x3f3(%rip), %rcx       # 0x1650
callq 0x1550
movq $0x0, -0x1fc8(%rbp)
movq -0x1fc8(%rbp), %rax
cmpq 0x2dfd(%rip), %rax      # 0x4078
jae 0x12c3
movq -0x1fc8(%rbp), %rax
movq -0x1fc0(%rbp,%rax,8), %rax
movl 0x8(%rax), %esi
movq -0x1fc8(%rbp), %rax
movq -0x1fc0(%rbp,%rax,8), %rax
movq (%rax), %rdx
leaq 0xd5c(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
movq -0x1fc8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1fc8(%rbp)
jmp 0x126d
xorl %eax, %eax
addq $0x1fd0, %rsp           # imm = 0x1FD0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x16f0
movq 0x2cf5(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10a0
movl %eax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $-0x1, -0x18(%rbp)
je 0x131f
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
callq 0x10b0
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x1356
cmpl $0x5f, -0x18(%rbp)
je 0x1356
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13f5
jmp 0x1358
callq 0x10b0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x2c75(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10a0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x18(%rbp)
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x1396
xorl %eax, %eax
cmpl $0x5f, -0x18(%rbp)
movb %al, -0x29(%rbp)
jne 0x13a7
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x13b0
jmp 0x13cd
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x1358
movl -0x18(%rbp), %edi
movq 0x2c09(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x1090
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x145d
movl $0x20, %edi
callq 0x1080
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x14d0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x1070
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x1484
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x14ce
cmpl $0x0, -0x14(%rbp)
jge 0x14a8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1400
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x14cc
cmpl $0x0, -0x14(%rbp)
jle 0x14ca
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1400
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x14cc
jmp 0x14ce
jmp 0x14d0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1547
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x14e0
cmpq $0x3e8, 0x2b65(%rip) # imm = 0x3E8
jae 0x1536
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x2b54(%rip), %rcx      # 0x4078
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x2b46(%rip)      # 0x4078
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x14e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: tree_node_cmp
int tree_node_cmp(const struct tree_node *node_p_1, const struct tree_node *node_p_2)
{
  if (node_p_1->count > node_p_2->count)
  {
    return -1;
  }
  else if (node_p_1->count < node_p_2->count)
  {
    return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x1675
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1697
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x168e
movl $0x1, -0x4(%rbp)
jmp 0x1697
jmp 0x1690
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1080
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16d9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x17e9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x17a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x82f(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x17a0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/ecc/bch.c
// Function: pack_poly
static void pack_poly(const struct bch_def *def, bch_poly_t poly, uint8_t *ecc)
{
	int i;

	for (i = 0; i < def->ecc_bytes; i++) {
		ecc[i] = ~poly;
		poly >>= 8;
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x1248
movq -0x10(%rsp), %rax
xorq $-0x1, %rax
movb %al, %dl
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x1207
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movslq -0x24(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0x12f8
movq -0x10(%rsp), %rax
movslq -0x24(%rsp), %rcx
movzbl (%rax,%rcx), %eax
xorl $0xff, %eax
cltq
xorq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0x28(%rsp)
cmpl $0x8, -0x28(%rsp)
jge 0x12e6
movq -0x20(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x12cc
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
xorq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
shrq %rax
movq %rax, -0x20(%rsp)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x12a3
jmp 0x12e8
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x1270
movq -0x20(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x1c(%rsp)
jl 0x13c3
movq -0x18(%rsp), %rax
shlq $0x8, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movzbl (%rax,%rcx), %eax
xorl $0xff, %eax
cltq
orq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x1382
movq -0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
andq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/ecc/bch.c
// Function: bch_repair
void bch_repair(const struct bch_def *bch,
		uint8_t *chunk, size_t len, uint8_t *ecc)
{
	const bch_poly_t remainder = unpack_poly(bch, ecc);
	const int chunk_bits = len << 3;
	gf13_elem_t syns[BCH_MAX_SYNS];
	gf13_elem_t sigma[MAX_POLY];
	gf13_elem_t x;
	int i;

	/* Compute syndrome vector */
	x = 2;
	for (i = 0; i < bch->syns; i++) {
		syns[i] = syndrome(bch, chunk, len, remainder, x);
		x = gf13_mulx(x);
	}

	/* Compute sigma */
	berlekamp_massey(syns, bch->syns, sigma);

	/* Each root of sigma corresponds to an error location. Correct
	 * errors in the chunk data first.
	 */
	x = 1;
	for (i = 0; i < chunk_bits; i++) {
		if (!poly_eval(sigma, x))
			chunk[i >> 3] ^= 1 << (i & 7);
		x = gf13_divx(x);
	}

	/* Then correct errors in the ECC data */
	for (i = 0; i < bch->degree; i++) {
		if (!poly_eval(sigma, x))
			ecc[i >> 3] ^= 1 << (i & 7);
		x = gf13_divx(x);
	}
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x1360
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
shlq $0x3, %rax
movl %eax, 0x4c(%rsp)
movw $0x2, 0xe(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x70(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x148d
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x50(%rsp), %rcx
movzwl 0xe(%rsp), %r8d
callq 0x1590
movw %ax, %cx
movslq 0x8(%rsp), %rax
movw %cx, 0x30(%rsp,%rax,2)
movzwl 0xe(%rsp), %edi
callq 0x16d0
movw %ax, 0xe(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1438
leaq 0x30(%rsp), %rdi
movq 0x70(%rsp), %rax
movl (%rax), %esi
leaq 0x10(%rsp), %rdx
callq 0x1710
movw $0x1, 0xe(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x1513
leaq 0x10(%rsp), %rdi
movzwl 0xe(%rsp), %esi
callq 0x1970
cmpw $0x0, %ax
jne 0x14f7
movl 0x8(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movq 0x68(%rsp), %rax
movl 0x8(%rsp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movzwl 0xe(%rsp), %edi
callq 0x1a10
movw %ax, 0xe(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x14b2
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x70(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x1580
leaq 0x10(%rsp), %rdi
movzwl 0xe(%rsp), %esi
callq 0x1970
cmpw $0x0, %ax
jne 0x1564
movl 0x8(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movq 0x58(%rsp), %rax
movl 0x8(%rsp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movzwl 0xe(%rsp), %edi
callq 0x1a10
movw %ax, 0xe(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x151b
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/ecc/bch.c
// Function: syndrome
static gf13_elem_t syndrome(const struct bch_def *bch,
			    const uint8_t *chunk,
			    size_t len,
			    bch_poly_t remainder,
			    gf13_elem_t x)
{
	gf13_elem_t y = 0;
	gf13_elem_t t = 1;
	int i;

	for (i = 0; i < len; i++) {
		uint8_t c = chunk[i] ^ 0xff;
		int j;

		for (j = 0; j < 8; j++) {
			if (c & 1)
				y ^= t;

			c >>= 1;
			t = gf13_mul(t, x);
		}
	}

	for (i = 0; i < bch->degree; i++) {
		if (remainder & 1)
			y ^= t;

		remainder >>= 1;
		t = gf13_mul(t, x);
	}

	return y;
}

// Assembly:
subq $0x38, %rsp
movw %r8w, %ax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movw %ax, 0x16(%rsp)
movw $0x0, 0x14(%rsp)
movw $0x1, 0x12(%rsp)
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x165c
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx), %eax
xorl $0xff, %eax
movb %al, 0xb(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jge 0x164a
movzbl 0xb(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x161b
movzwl 0x12(%rsp), %ecx
movzwl 0x14(%rsp), %eax
xorl %ecx, %eax
movw %ax, 0x14(%rsp)
movzbl 0xb(%rsp), %eax
sarl %eax
movb %al, 0xb(%rsp)
movw 0x12(%rsp), %ax
movzwl %ax, %edi
movzwl 0x16(%rsp), %esi
callq 0x1a50
movw %ax, 0x12(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x15f6
jmp 0x164c
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x15c7
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x16c3
movq 0x18(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1692
movzwl 0x12(%rsp), %ecx
movzwl 0x14(%rsp), %eax
xorl %ecx, %eax
movw %ax, 0x14(%rsp)
movq 0x18(%rsp), %rax
shrq %rax
movq %rax, 0x18(%rsp)
movw 0x12(%rsp), %ax
movzwl %ax, %edi
movzwl 0x16(%rsp), %esi
callq 0x1a50
movw %ax, 0x12(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1664
movw 0x14(%rsp), %ax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movw %si, %ax
movq %rdi, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movw $0x0, 0x6(%rsp)
movw 0xe(%rsp), %ax
movw %ax, 0x4(%rsp)
movl $0x0, 0x8(%rsp)
cmpl $0x10, 0x8(%rsp)
jge 0x1a01
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, 0x2(%rsp)
cmpw $0x0, 0x2(%rsp)
je 0x19dd
movw 0x2(%rsp), %ax
movzwl %ax, %edi
movzwl 0x4(%rsp), %esi
callq 0x1a50
movzwl %ax, %ecx
movzwl 0x6(%rsp), %eax
xorl %ecx, %eax
movw %ax, 0x6(%rsp)
movw 0x4(%rsp), %ax
movzwl %ax, %edi
movzwl 0xe(%rsp), %esi
callq 0x1a50
movw %ax, 0x4(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x199a
movw 0x6(%rsp), %ax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movw %dx, %ax
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movw %ax, 0x16(%rsp)
movl %ecx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
jge 0x1be8
movl 0xc(%rsp), %eax
addl 0x10(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, 0x6(%rsp)
cmpl $0x0, 0x8(%rsp)
jl 0x1ba6
cmpl $0x10, 0x8(%rsp)
jl 0x1ba8
jmp 0x1bdb
cmpw $0x0, 0x6(%rsp)
jne 0x1bb2
jmp 0x1bdb
movw 0x6(%rsp), %ax
movzwl %ax, %edi
movzwl 0x16(%rsp), %esi
callq 0x1a50
movzwl %ax, %esi
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movzwl (%rax,%rcx,2), %edx
xorl %esi, %edx
movw %dx, (%rax,%rcx,2)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1b72
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movl $0x0, 0x4(%rsp)
xorl %edi, %edi
callq 0x1030
leaq 0x401(%rip), %rdi       # 0x2008
callq 0x1c40
leaq 0x40d(%rip), %rdi       # 0x2020
callq 0x1c40
leaq 0x419(%rip), %rdi       # 0x2038
callq 0x1c40
leaq 0x425(%rip), %rdi       # 0x2050
callq 0x1c40
xorl %eax, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x220(%rsp)
movq 0x220(%rsp), %rax
movl (%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
leaq 0x8406(%rip), %rdi      # 0xa070
movb $0x0, %al
callq 0x1040
leaq 0x10(%rsp), %rdi
movl $0xff, %esi
movl $0x208, %edx            # imm = 0x208
callq 0x1060
movq 0x220(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1cd0
movl $0x0, 0xc(%rsp)
cmpl $0xa, 0xc(%rsp)
jge 0x1cc0
movq 0x220(%rsp), %rdi
callq 0x1d60
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1c9f
addq $0x228, %rsp            # imm = 0x228
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x8(%rsp), %rcx
addq $0x200, %rcx            # imm = 0x200
movl $0x200, %edx            # imm = 0x200
callq 0x1300
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x1d0b
jmp 0x1d2a
leaq 0x8369(%rip), %rdi      # 0xa07b
leaq 0x8365(%rip), %rsi      # 0xa07e
movl $0x3e, %edx
leaq 0x8365(%rip), %rcx      # 0xa08a
callq 0x1050
movl $0x0, 0x4(%rsp)
cmpl $0x14, 0x4(%rsp)
jge 0x1d55
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1de0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1d32
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/bch.c
// Function: test_random_block
static void test_random_block(const struct bch_def *def)
{
	uint8_t block[TEST_CHUNK_SIZE];
	int i;

	for (i = 0; i < BCH_CHUNK_SIZE; i++)
		block[i] = random();

	bch_generate(def, block, BCH_CHUNK_SIZE, block + BCH_CHUNK_SIZE);
	test_properties(def, block);
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x220(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x200, 0xc(%rsp)       # imm = 0x200
jge 0x1d9e
callq 0x1090
movb %al, %cl
movslq 0xc(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1d77
movq 0x220(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x10(%rsp), %rcx
addq $0x200, %rcx            # imm = 0x200
movl $0x200, %edx            # imm = 0x200
callq 0x11a0
movq 0x220(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1cd0
addq $0x228, %rsp            # imm = 0x228
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/bch.c
// Function: flip_test
static void flip_test(const struct bch_def *def,
		      const uint8_t *good)
{
	uint8_t bad[TEST_CHUNK_SIZE];
	int i;

	memcpy(bad, good, sizeof(bad));

	for (i = 0; i < def->syns; i += 2)
		flip_one_bit(bad, TEST_CHUNK_SIZE);

	if (bch_verify(def, bad, BCH_CHUNK_SIZE, bad + BCH_CHUNK_SIZE) < 0) {
		bch_repair(def, bad, BCH_CHUNK_SIZE, bad + BCH_CHUNK_SIZE);
		i = bch_verify(def, bad, BCH_CHUNK_SIZE, bad + BCH_CHUNK_SIZE);
		assert(!i);
	}

	i = memcmp(good, bad, BCH_CHUNK_SIZE);
	assert(!i);
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x218(%rsp), %rsi
movl $0x208, %edx            # imm = 0x208
callq 0x1080
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x220(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x1e42
leaq 0x10(%rsp), %rdi
movl $0x208, %esi            # imm = 0x208
callq 0x1f30
movl 0xc(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xc(%rsp)
jmp 0x1e16
movq 0x220(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x10(%rsp), %rcx
addq $0x200, %rcx            # imm = 0x200
movl $0x200, %edx            # imm = 0x200
callq 0x1300
cmpl $0x0, %eax
jge 0x1ede
movq 0x220(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x10(%rsp), %rcx
addq $0x200, %rcx            # imm = 0x200
movl $0x200, %edx            # imm = 0x200
callq 0x13f0
movq 0x220(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x10(%rsp), %rcx
addq $0x200, %rcx            # imm = 0x200
movl $0x200, %edx            # imm = 0x200
callq 0x1300
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1ebd
jmp 0x1edc
leaq 0x81b7(%rip), %rdi      # 0xa07b
leaq 0x81b3(%rip), %rsi      # 0xa07e
movl $0x31, %edx
leaq 0x81f1(%rip), %rcx      # 0xa0c8
callq 0x1050
jmp 0x1ede
movq 0x218(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x1070
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1f02
jmp 0x1f21
leaq 0x8172(%rip), %rdi      # 0xa07b
leaq 0x816e(%rip), %rsi      # 0xa07e
movl $0x35, %edx
leaq 0x81ac(%rip), %rcx      # 0xa0c8
callq 0x1050
addq $0x228, %rsp            # imm = 0x228
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/bch.c
// Function: flip_one_bit
static void flip_one_bit(uint8_t *b, int size)
{
	const int which = random() % (size * 8);
	const int byte = which >> 3;
	const uint8_t bit = 1 << (which & 7);

	b[byte] ^= bit;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
callq 0x1090
movl 0xc(%rsp), %ecx
shll $0x3, %ecx
movslq %ecx, %rcx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
sarl $0x3, %eax
movl %eax, 0x4(%rsp)
movl 0x8(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %eax
shll %cl, %eax
movb %al, 0x3(%rsp)
movzbl 0x3(%rsp), %esi
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x7e0, %rsp            # imm = 0x7E0
movl $0x0, -0x4(%rbp)
leaq -0x3f0(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11f0
leaq -0x3f0(%rbp), %rsi
leaq 0x112f(%rip), %rdi      # 0x22b0
movb $0x0, %al
callq 0x1030
leaq -0x7e0(%rbp), %rdi
leaq -0x3f0(%rbp), %rsi
callq 0x1290
leaq -0x7e0(%rbp), %rsi
leaq 0x110a(%rip), %rdi      # 0x22b3
movb $0x0, %al
callq 0x1030
leaq -0x7e0(%rbp), %rdi
leaq -0x3f0(%rbp), %rsi
callq 0x14f0
leaq -0x7e0(%rbp), %rsi
leaq 0x10df(%rip), %rdi      # 0x22b0
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
jae 0x1236
callq 0x1040
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x15(%rbp)
je 0x1236
cmpl $0xa, -0x14(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x123f
jmp 0x125a
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1206
cmpl $0xa, -0x14(%rbp)
jne 0x127a
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12ac
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1650
jmp 0x12ae
cmpl $0x2, -0x8(%rbp)
je 0x12ce
movq 0x2d3d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd3f(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1100
jmp 0x132d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x13c0
cmpl $0x0, %eax
je 0x12ee
jmp 0x132d
movq -0x20(%rbp), %rsi
leaq 0xdab(%rip), %rdi       # 0x20a4
movb $0x0, %al
callq 0x10b0
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10a0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1340
movq -0x20(%rbp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1150
movl $0x1, %edi
callq 0x1150
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryancdotorg[P]bloomslice/pcalc.c
// Function: log2i
uint8_t log2i(uint64_t v) {
    static const uint64_t b[] = {
        0xaaaaaaaaaaaaaaaa,
        0xcccccccccccccccc,
        0xf0f0f0f0f0f0f0f0,
        0xff00ff00ff00ff00,
        0xffff0000ffff0000,
        0xffffffff00000000
    };
    register uint64_t r = (v & b[0]) != 0;
    r |= ((v & b[5]) != 0) << 5;
    r |= ((v & b[4]) != 0) << 4;
    r |= ((v & b[3]) != 0) << 3;
    r |= ((v & b[2]) != 0) << 2;
    r |= ((v & b[1]) != 0) << 1;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq 0xefd(%rip), %rax       # 0x2060
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
andq 0xf08(%rip), %rax       # 0x2088
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
shll $0x5, %eax
cltq
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
andq 0xedc(%rip), %rax       # 0x2080
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
shll $0x4, %eax
cltq
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
andq 0xeb0(%rip), %rax       # 0x2078
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
shll $0x3, %eax
cltq
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
andq 0xe84(%rip), %rax       # 0x2070
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
shll $0x2, %eax
cltq
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
andq 0xe58(%rip), %rax       # 0x2068
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
shll %eax
cltq
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x4460
cmpl $0x0, %eax
jne 0x44a2
movl $0x0, 0x14(%rsp)
jmp 0x44f1
movq 0x8(%rsp), %rdi
callq 0x4500
cmpl $0x0, %eax
jne 0x44df
movq 0x8(%rsp), %rdi
callq 0x4510
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x4560
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x44e9
jp 0x44e9
movl $0x1, 0x14(%rsp)
jmp 0x44f1
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)