LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/arachsys[P]containers/mount.c
// Function: bindnode
static void bindnode(char *src, char *dst) {
  int fd;

  if ((fd = open(dst, O_WRONLY | O_CREAT, 0600)) >= 0)
    close(fd);
  if (mount(src, dst, NULL, MS_BIND, NULL) < 0)
    errx(EXIT_FAILURE, "Failed to bind %s into new /dev filesystem", src);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x41, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x23f0
testl %eax, %eax
js 0x3dc6
movl %eax, %edi
callq 0x2210
movl $0x1000, %ecx           # imm = 0x1000
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2180
testl %eax, %eax
js 0x3de7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x19c1(%rip), %rsi      # 0x57af
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/arachsys[P]containers/mount.c
// Function: enterroot
void enterroot(void) {
  if (syscall(__NR_pivot_root, ".", "dev/tmp") < 0)
    errx(EXIT_FAILURE, "Failed to pivot into new root filesystem");

  if (chdir("/dev/tmp") >= 0) {
    while (*root == '/')
      root++;
    rmdir(root);
  }

  root = NULL;

  if (chdir("/") < 0 || umount2("/dev/tmp", MNT_DETACH) < 0)
    errx(EXIT_FAILURE, "Failed to detach old root filesystem");
  else
    rmdir("/dev/tmp");
}

// Assembly:
pushq %rax
leaq 0x18d1(%rip), %rsi      # 0x56d6
leaq 0x18f6(%rip), %rdx      # 0x5702
movl $0x9b, %edi
xorl %eax, %eax
callq 0x22b0
testq %rax, %rax
js 0x3e95
leaq 0x18dd(%rip), %rdi      # 0x5701
callq 0x2190
testl %eax, %eax
js 0x3e4f
movq 0x448c(%rip), %rdi      # 0x82c0
cmpb $0x2f, (%rdi)
jne 0x3e4a
cmpb $0x2f, 0x1(%rdi)
leaq 0x1(%rdi), %rdi
je 0x3e39
movq %rdi, 0x4476(%rip)      # 0x82c0
callq 0x2160
movq $0x0, 0x4466(%rip) # 0x82c0
leaq 0x18a9(%rip), %rdi      # 0x570a
callq 0x2190
testl %eax, %eax
js 0x3e8c
leaq 0x1890(%rip), %rdi      # 0x5701
movl $0x2, %esi
callq 0x2120
testl %eax, %eax
js 0x3e8c
leaq 0x187b(%rip), %rdi      # 0x5701
popq %rax
jmp 0x2160
leaq 0x1879(%rip), %rsi      # 0x570c
jmp 0x3e9c
leaq 0x183c(%rip), %rsi      # 0x56d8
movl $0x1, %edi
xorl %eax, %eax
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/arachsys[P]containers/mount.c
// Function: mountproc
void mountproc(void) {
  mode_t mask;

  mask = umask(0);
  mkdir("proc" , 0755);
  umask(mask);

  if (mount("proc", "proc", "proc", 0, NULL) < 0)
    errx(EXIT_FAILURE, "Failed to mount /proc in new root filesystem");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x22d0
movl %eax, %ebx
leaq 0x1875(%rip), %r14      # 0x5731
movq %r14, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x20b0
movl %ebx, %edi
callq 0x22d0
movq %r14, %rdi
movq %r14, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2180
testl %eax, %eax
js 0x3eef
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1840(%rip), %rsi      # 0x5736
movl $0x1, %edi
xorl %eax, %eax
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/arachsys[P]containers/mount.c
// Function: mountsys
void mountsys(void) {
  mode_t mask;

  mask = umask(0);
  mkdir("sys" , 0755);
  umask(mask);

  if (mount("sysfs", "sys", "sysfs", 0, NULL) < 0)
    errx(EXIT_FAILURE, "Failed to mount /sys in new root filesystem");
  mount("cgroup2", "sys/fs/cgroup", "cgroup2", 0, NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x22d0
movl %eax, %ebx
leaq 0x184d(%rip), %r14      # 0x5763
movq %r14, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x20b0
movl %ebx, %edi
callq 0x22d0
leaq 0x1836(%rip), %rdi      # 0x5767
movq %r14, %rsi
movq %rdi, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2180
testl %eax, %eax
js 0x3f67
leaq 0x1855(%rip), %rsi      # 0x57a1
leaq 0x1846(%rip), %rdi      # 0x5799
movq %rdi, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2180
leaq 0x17ff(%rip), %rsi      # 0x576d
movl $0x1, %edi
xorl %eax, %eax
callq 0x21b0
nop
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/converters/mksimtape/mksimtape.c
// Function: error
static VOID error(PCHAR mes, ...)
{	va_list ap;

	fprintf(stderr, "%s: ", progname);

	va_start(ap, mes);
	vfprintf(stderr, mes, ap);
	va_end(ap);

	fputc('\n', stderr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1193
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x2e56(%rip), %r15      # 0x3ff0
movq (%r15), %rdi
movq 0x2f04(%rip), %rdx      # 0x40a8
leaq 0xf41(%rip), %rsi       # 0x20ec
xorl %eax, %eax
callq 0x10a0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x10f0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1090
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/converters/mksimtape/mksimtape.c
// Function: putusage
static VOID putusage(VOID)
{	PCHAR *p = (PCHAR *) helpinfo;
	PCHAR q;

	for(;;) {
		q = *p++;
		if(*q == '\0') break;

		fprintf(stderr, q, progname, DEFBLKSIZE);
		fputc('\n', stderr);
	}
	fprintf(stderr, "\nThis is version %d.%d\n", VERSION, EDIT);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xf08(%rip), %rsi       # 0x2109
leaq 0x2b90(%rip), %r15      # 0x3d98
movq 0x2de1(%rip), %r14      # 0x3ff0
pushq $0xa
popq %rbx
movq (%r14), %rdi
movq 0x2e8c(%rip), %rdx      # 0x40a8
movl $0x2800, %ecx           # imm = 0x2800
xorl %eax, %eax
callq 0x10a0
movq (%r14), %rsi
movl %ebx, %edi
callq 0x1090
movq (%r15), %rsi
addq $0x8, %r15
cmpb $0x0, (%rsi)
jne 0x1212
movq (%r14), %rdi
leaq 0xea9(%rip), %rsi       # 0x20f1
pushq $0x1
popq %rdx
xorl %ecx, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x10a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/converters/mksimtape/mksimtape.c
// Function: tape_mark
static BOOL tape_mark(VOID)
{	INT n;
	UCHAR sbuf[4] = { 0,0,0,0 };

	n = fwrite(sbuf, 1, 4, stdout);
	if(n != 4) {
		error("Error writing to tape image");
		return(FALSE);
	}

	return(TRUE);
}

// Assembly:
pushq %rax
leaq 0x4(%rsp), %rdi
movl $0x0, (%rdi)
movq 0x29e6(%rip), %rax      # 0x3fd0
movq (%rax), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x1110
cmpl $0x4, %eax
jne 0x1603
popq %rax
retq
leaq 0xac6(%rip), %rdi       # 0x20d0
xorl %eax, %eax
popq %rcx
jmp 0x1130
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: generator_attributes
void generator_attributes(FILE* pWriteFile) {
  PUT_U2(attributes_count, 0x0001)
  PUT_U2(attribute_name_index, 0x0011)
  PUT_U4(attribute_length, 0x00000002)
  PUT_U2(sourcefile_index, 0x0001)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movw $0x100, %r14w           # imm = 0x100
leaq -0x16(%rbp), %rdi
movw %r14w, (%rdi)
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1120
leaq -0x14(%rbp), %rdi
movw $0x1100, (%rdi)         # imm = 0x1100
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1120
leaq -0x1c(%rbp), %rdi
movl $0x2000000, (%rdi)      # imm = 0x2000000
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1120
leaq -0x12(%rbp), %rdi
movw %r14w, (%rdi)
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1120
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: InnerClasses_attribute
void InnerClasses_attribute(FILE* pReadFile) {
  PRINTF_U2(number_of_classes)
  if (number_of_classes > 0) {
    for (u2 number_of_classes_index = 0; number_of_classes_index < number_of_classes; number_of_classes_index++) {
      PRINTF_U2(inner_class_info_index)
      PRINTF_U2(outer_class_info_index)
      PRINTF_U2(inner_name_index)
      PRINTF_U2(inner_class_access_flags)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x32(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r12d
movl %r12d, %r15d
rolw $0x8, %r15w
movw %r15w, (%r14)
movzwl %r15w, %esi
leaq 0x576e(%rip), %rdi      # 0x959d
xorl %eax, %eax
callq 0x10b0
testw %r12w, %r12w
je 0x3f2e
cmpw $0x2, %r15w
movl $0x1, %r14d
cmovael %r15d, %r14d
leaq 0x579c(%rip), %r15      # 0x95f2
leaq -0x2a(%rbp), %r12
leaq 0x57a9(%rip), %r13      # 0x960a
movl $0x1, %esi
movl $0x2, %edx
leaq -0x30(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x30(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x30(%rbp)
movzwl %ax, %esi
leaq 0x5729(%rip), %rdi      # 0x95b6
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2e(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2e(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2e(%rbp)
movzwl %ax, %esi
leaq 0x5714(%rip), %rdi      # 0x95d4
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2c(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2c(%rbp)
movzwl %ax, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl %ax, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x10b0
decw %r14w
jne 0x3e61
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: SourceDebugExtension_attribute
void SourceDebugExtension_attribute(FILE* pReadFile, u4 attribute_length) {
  u1 debug_extension[attribute_length];
  for (u4 attribute_length_index = 0; attribute_length_index < attribute_length; attribute_length_index++) {
    fread(&debug_extension[attribute_length_index], 1, sizeof(u1), pReadFile);
    printf("debug_extension[%04x]: %02x\n", attribute_length_index, debug_extension[attribute_length_index]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rsp, %r13
leaq 0xf(%r12), %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
testl %esi, %esi
je 0x40aa
movq %rdi, %rbx
leaq 0x55f7(%rip), %r14      # 0x966d
xorl %r15d, %r15d
leaq (%r15,%r13), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1080
movzbl (%r13,%r15), %edx
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x10b0
incq %r15
cmpq %r15, %r12
jne 0x4079
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: LineNumberTable_attribute
void LineNumberTable_attribute(FILE* pReadFile) {
  PRINTF_U2(line_number_table_length)
  if (line_number_table_length > 0) {
    for (u2 line_number_table_length_index = 0; line_number_table_length_index < line_number_table_length; line_number_table_length_index++) {
      PRINTF_U2(start_pc)
      PRINTF_U2(line_number)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x2e(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r12d
movl %r12d, %r15d
rolw $0x8, %r15w
movw %r15w, (%r14)
movzwl %r15w, %esi
leaq 0x558c(%rip), %rdi      # 0x968a
xorl %eax, %eax
callq 0x10b0
testw %r12w, %r12w
je 0x4193
cmpw $0x2, %r15w
movl $0x1, %r14d
cmovael %r15d, %r14d
leaq 0x5359(%rip), %r15      # 0x947e
leaq -0x2a(%rbp), %r12
leaq 0x557a(%rip), %r13      # 0x96aa
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2c(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2c(%rbp)
movzwl %ax, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl %ax, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x10b0
decw %r14w
jne 0x4130
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: LocalVariableTable_attribute
void LocalVariableTable_attribute(FILE* pReadFile) {
  PRINTF_U2(local_variable_table_length)
  if (local_variable_table_length > 0) {
    for (u2 local_variable_table_length_index = 0; local_variable_table_length_index < local_variable_table_length; local_variable_table_length_index++) {
      PRINTF_U2(start_pc)
      PRINTF_U2(length)
      PRINTF_U2(name_index)
      PRINTF_U2(descriptor_index)
      PRINTF_U2(index)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x34(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r12d
movl %r12d, %r15d
rolw $0x8, %r15w
movw %r15w, (%r14)
movzwl %r15w, %esi
leaq 0x54d3(%rip), %rdi      # 0x96bd
xorl %eax, %eax
callq 0x10b0
testw %r12w, %r12w
je 0x431c
cmpw $0x2, %r15w
movl $0x1, %r12d
cmovael %r15d, %r12d
leaq 0x54cf(%rip), %r13      # 0x96e0
leaq -0x2a(%rbp), %r14
leaq 0x5415(%rip), %r15      # 0x9631
movl $0x1, %esi
movl $0x2, %edx
leaq -0x32(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x32(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x32(%rbp)
movzwl %ax, %esi
leaq 0x5236(%rip), %rdi      # 0x947e
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x30(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x30(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x30(%rbp)
movzwl %ax, %esi
leaq 0x5457(%rip), %rdi      # 0x96d2
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2e(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2e(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2e(%rbp)
movzwl %ax, %esi
leaq 0x56b9(%rip), %rdi      # 0x9967
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2c(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2c(%rbp)
movzwl %ax, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl %ax, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
decw %r12w
jne 0x421c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: LocalVariableTypeTable_attribute
void LocalVariableTypeTable_attribute(FILE* pReadFile) {
  PRINTF_U2(local_variable_type_table_length)
  if (local_variable_type_table_length > 0) {
    for (u2 local_variable_type_table_length_index = 0; local_variable_type_table_length_index < local_variable_type_table_length; local_variable_type_table_length_index++) {
      PRINTF_U2(start_pc)
      PRINTF_U2(length)
      PRINTF_U2(name_index)
      PRINTF_U2(signature_index)
      PRINTF_U2(index)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x34(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r12d
movl %r12d, %r15d
rolw $0x8, %r15w
movw %r15w, (%r14)
movzwl %r15w, %esi
leaq 0x5385(%rip), %rdi      # 0x96f8
xorl %eax, %eax
callq 0x10b0
testw %r12w, %r12w
je 0x44a5
cmpw $0x2, %r15w
movl $0x1, %r12d
cmovael %r15d, %r12d
leaq 0x52a4(%rip), %r13      # 0x963e
leaq -0x2a(%rbp), %r14
leaq 0x528c(%rip), %r15      # 0x9631
movl $0x1, %esi
movl $0x2, %edx
leaq -0x32(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x32(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x32(%rbp)
movzwl %ax, %esi
leaq 0x50ad(%rip), %rdi      # 0x947e
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x30(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x30(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x30(%rbp)
movzwl %ax, %esi
leaq 0x52ce(%rip), %rdi      # 0x96d2
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2e(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2e(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2e(%rbp)
movzwl %ax, %esi
leaq 0x5530(%rip), %rdi      # 0x9967
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2c(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2c(%rbp)
movzwl %ax, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl %ax, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
decw %r12w
jne 0x43a5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: BootstrapMethods_attribute
void BootstrapMethods_attribute(FILE* pReadFile) {
  PRINTF_U2(num_bootstrap_methods)
  if (num_bootstrap_methods > 0) {
    for (u2 num_bootstrap_methods_index = 0; num_bootstrap_methods_index < num_bootstrap_methods; num_bootstrap_methods_index++) {
      PRINTF_U2(bootstrap_method_ref)
      PRINTF_U2(num_bootstrap_arguments)
      PRINTF_U2_ARRAY(num_bootstrap_arguments, bootstrap_arguments)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x36(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r12d
movl %r12d, %r15d
rolw $0x8, %r15w
movw %r15w, (%r14)
movzwl %r15w, %esi
leaq 0x5389(%rip), %rdi      # 0x98d1
xorl %eax, %eax
callq 0x10b0
testw %r12w, %r12w
je 0x466c
cmpw $0x2, %r15w
movl $0x1, %eax
cmovael %r15d, %eax
movl %eax, -0x30(%rbp)
leaq 0x53b8(%rip), %r14      # 0x9929
xorl %r13d, %r13d
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2c(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2c(%rbp)
movzwl %ax, %esi
leaq 0x534e(%rip), %rdi      # 0x98ee
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2a(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %r15d
movl %r15d, %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl %ax, %r12d
leaq 0x5332(%rip), %rdi      # 0x990a
movl %r12d, %esi
xorl %eax, %eax
callq 0x10b0
testw %r15w, %r15w
je 0x465e
movl %r13d, -0x34(%rbp)
movq %rsp, -0x40(%rbp)
leal 0xf(,%r12,2), %eax
andl $-0x10, %eax
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
cmpw $0x2, %r12w
movl $0x1, %eax
cmovael %r12d, %eax
movzwl %ax, %r13d
xorl %r12d, %r12d
movl $0x1, %esi
movl $0x2, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r15), %eax
rolw $0x8, %ax
movw %ax, (%r15)
movzwl %ax, %edx
movq %r14, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x10b0
incl %r12d
addq $0x2, %r15
decq %r13
jne 0x4619
movq -0x40(%rbp), %rsp
movl -0x34(%rbp), %r13d
incl %r13d
cmpw -0x30(%rbp), %r13w
jne 0x4574
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: MethodParameters_attribute
void MethodParameters_attribute(FILE* pReadFile) {
  PRINTF_U1(parameters_count)
  if (parameters_count > 0) {
    for (u1 parameters_count_index = 0; parameters_count_index < parameters_count; parameters_count_index++) {
      PRINTF_U2(name_index)
      PRINTF_U2(access_flags)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x2d(%rbp), %r14
movl $0x1, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzbl (%r14), %r14d
leaq 0x5298(%rip), %rdi      # 0x9948
movl %r14d, %esi
xorl %eax, %eax
callq 0x10b0
testl %r14d, %r14d
je 0x4733
leaq 0x52a1(%rip), %r12      # 0x9967
leaq -0x2a(%rbp), %r13
leaq 0x4f45(%rip), %r15      # 0x9616
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2c(%rbp), %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2c(%rbp)
movzwl %ax, %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
movq %r13, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl %ax, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
decb %r14b
jne 0x46d1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: verification_type_info
void verification_type_info(FILE* pReadFile) {
  PRINTF_U1(tag)
  switch (tag) {
    case 0x00:
      break;
    case 0x01:
      break;
    case 0x02:
      break;
    case 0x03:
      break;
    case 0x04:
      break;
    case 0x05:
      break;
    case 0x06:
      break;
    case 0x07:
      {
        PRINTF_U2(cpool_index)
      }
      break;
    case 0x08:
      {
        PRINTF_U2(offset)
      }
      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x11(%rbp), %r14
movl $0x1, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzbl (%r14), %r14d
leaq 0x44b0(%rip), %rdi      # 0x9534
movl %r14d, %esi
xorl %eax, %eax
callq 0x10b0
cmpl $0x8, %r14d
je 0x50cb
cmpl $0x7, %r14d
jne 0x5101
leaq -0x16(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movw %ax, (%r14)
movzwl %ax, %esi
leaq 0x4476(%rip), %rdi      # 0x953f
jmp 0x50fa
leaq -0x14(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movw %ax, (%r14)
movzwl %ax, %esi
leaq 0x4458(%rip), %rdi      # 0x9552
xorl %eax, %eax
callq 0x10b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: parameter_annotations
void parameter_annotations(FILE* pReadFile) {
  PRINTF_U1(num_parameters)
  if (num_parameters > 0) {
    for (u1 num_parameters_index = 0; num_parameters_index < num_parameters; num_parameters_index++) {
      annotations(pReadFile);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x11(%rbp), %r14
movl $0x1, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzbl (%r14), %r14d
leaq 0x4567(%rip), %rdi      # 0x9720
movl %r14d, %esi
xorl %eax, %eax
callq 0x10b0
testl %r14d, %r14d
je 0x51d5
movq %rbx, %rdi
callq 0x510a
decb %r14b
jne 0x51c8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: annotation
void annotation(FILE* pReadFile) {
  PRINTF_U2(type_index)
  PRINTF_U2(num_element_value_pairs)
  if (num_element_value_pairs > 0) {
    for (u2 num_element_value_pairs_index = 0; num_element_value_pairs_index < num_element_value_pairs; num_element_value_pairs_index++) {
      PRINTF_U2(element_name_index)
      element_value(pReadFile);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x26(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movw %ax, (%r14)
movzwl %ax, %esi
leaq 0x4f4c(%rip), %rdi      # 0xa16b
xorl %eax, %eax
callq 0x10b0
leaq -0x24(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r12d
movl %r12d, %r15d
rolw $0x8, %r15w
movw %r15w, (%r14)
movzwl %r15w, %esi
leaq 0x45e4(%rip), %rdi      # 0x983e
xorl %eax, %eax
callq 0x10b0
testw %r12w, %r12w
je 0x52bd
cmpw $0x2, %r15w
movl $0x1, %r12d
cmovael %r15d, %r12d
leaq -0x22(%rbp), %r14
leaq 0x45dc(%rip), %r15      # 0x985d
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl -0x22(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x22(%rbp)
movzwl %ax, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
movq %rbx, %rdi
callq 0x589f
decw %r12w
jne 0x5281
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: element_value
void element_value(FILE* pReadFile) {
  PRINTF_U1(tag)
  switch (tag) {
    case 'B':
    case 'C':
    case 'D':
    case 'F':
    case 'I':
    case 'J':
    case 'S':
    case 'Z':
    case 's':
      {
        PRINTF_U2(const_value_index)
      }
      break;
    case 'e':
      {
        PRINTF_U2(type_name_index)
        PRINTF_U2(const_name_index)
      }
      break;
    case 'c':
      {
        PRINTF_U2(class_info_index)
      }
      break;
    case '@':
      {
        annotation(pReadFile);
      }
      break;
    case '[':
      {
        PRINTF_U2(num_values)
        if (num_values > 0) {
          for (u2 num_values_index = 0; num_values_index < num_values; num_values_index++) {
            element_value(pReadFile);
          }
        }
      }
      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x21(%rbp), %r14
movl $0x1, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzbl (%r14), %r14d
leaq 0x3c5f(%rip), %rdi      # 0x9534
movl %r14d, %esi
xorl %eax, %eax
callq 0x10b0
cmpl $0x52, %r14d
jg 0x591a
cmpl $0x45, %r14d
jg 0x59a2
leal -0x42(%r14), %eax
cmpl $0x3, %eax
jb 0x59c5
cmpl $0x40, %r14d
jne 0x59fb
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x51de
cmpl $0x62, %r14d
jg 0x59b3
cmpl $0x53, %r14d
je 0x59c5
cmpl $0x5a, %r14d
je 0x59c5
cmpl $0x5b, %r14d
jne 0x59fb
leaq -0x24(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r12d
movl %r12d, %r15d
rolw $0x8, %r15w
movw %r15w, (%r14)
movzwl %r15w, %esi
leaq 0x3f49(%rip), %rdi      # 0x98bf
xorl %eax, %eax
callq 0x10b0
testw %r12w, %r12w
je 0x59fb
cmpw $0x2, %r15w
movl $0x1, %r14d
cmovael %r15d, %r14d
movq %rbx, %rdi
callq 0x589f
decw %r14w
jne 0x5992
jmp 0x59fb
leal -0x49(%r14), %eax
cmpl $0x2, %eax
jb 0x59c5
cmpl $0x46, %r14d
je 0x59c5
jmp 0x59fb
cmpl $0x63, %r14d
je 0x5a08
cmpl $0x65, %r14d
je 0x5a39
cmpl $0x73, %r14d
jne 0x59fb
leaq -0x2c(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movw %ax, (%r14)
movzwl %ax, %esi
leaq 0x3e83(%rip), %rdi      # 0x9877
xorl %eax, %eax
callq 0x10b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x26(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movw %ax, (%r14)
movzwl %ax, %esi
leaq 0x3b85(%rip), %rdi      # 0x95bc
jmp 0x59f4
leaq -0x2a(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movw %ax, (%r14)
movzwl %ax, %esi
leaq 0x3e28(%rip), %rdi      # 0x9890
xorl %eax, %eax
callq 0x10b0
leaq -0x28(%rbp), %r14
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movw %ax, (%r14)
movzwl %ax, %esi
leaq 0x3e09(%rip), %rdi      # 0x98a7
jmp 0x59f4
nop
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_cp.c
// Function: addConstantUtf8
void addConstantUtf8(u1* utf8_value, FILE* pWriteFile) {
  PUT_U1(tag, CONSTANT_UTF8_TAG)
  u2 utf8_length = (u2) strlen(utf8_value);
  PUT_U2(length, utf8_length)
  for (u2 utf8_length_index = 0; utf8_length_index < utf8_length; utf8_length_index++) {
    PUT_U1(bytes, utf8_value[utf8_length_index])
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
callq 0x10c0
movq %r14, %rdi
callq 0x10a0
movq %rax, %r15
rolw $0x8, %ax
leaq -0x22(%rbp), %rdi
movw %ax, (%rdi)
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1120
testw %r15w, %r15w
je 0x5d6d
movzwl %r15w, %r15d
xorl %r12d, %r12d
movsbl (%r14,%r12), %edi
movq %rbx, %rsi
callq 0x10c0
incq %r12
cmpq %r12, %r15
jne 0x5d58
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_cp.c
// Function: free_constant_pool
void free_constant_pool(pcp_info pcp) {
  for (u2 constant_pool_count_index = 0; constant_pool_count_index < pcp->constant_pool_count; constant_pool_count_index++) {
    if (pcp->constant_pool[constant_pool_count_index]) {
      free(pcp->constant_pool[constant_pool_count_index]);
      pcp->constant_pool[constant_pool_count_index] = NULL;
    }
  }
  if (pcp->constant_pool) {
    free(pcp->constant_pool);
    pcp->constant_pool = NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpw $0x0, 0x8(%rdi)
je 0x698d
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6981
callq 0x1030
movq (%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
movzwl 0x8(%rbx), %eax
cmpq %rax, %r14
jb 0x6965
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x69a1
callq 0x1030
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_field.c
// Function: analyzer_fields
void analyzer_fields(FILE* pReadFile, u1** constant_pool) {
  PRINTF_U2(fields_count)
  if (fields_count > 0) {
    for (u2 fields_count_index = 0; fields_count_index < fields_count; fields_count_index++) {
      PRINTF_U2(access_flags)
      PRINTF_U2(name_index)
      PRINTF_U2(descriptor_index)
      analyzer_attributes(pReadFile, constant_pool);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x30(%rbp), %r15
movl $0x1, %esi
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x1080
movzwl (%r15), %r13d
movl %r13d, %r12d
rolw $0x8, %r12w
movw %r12w, (%r15)
movzwl %r12w, %esi
leaq 0x383f(%rip), %rdi      # 0xa258
xorl %eax, %eax
callq 0x10b0
testw %r13w, %r13w
je 0x6aed
cmpw $0x2, %r12w
movl $0x1, %r15d
cmovael %r12d, %r15d
leaq -0x2a(%rbp), %r12
leaq 0x2c9c(%rip), %r13      # 0x96e0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2e(%rbp), %rdi
movq %r14, %rcx
callq 0x1080
movzwl -0x2e(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2e(%rbp)
movzwl %ax, %esi
leaq 0x2ba6(%rip), %rdi      # 0x9616
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2c(%rbp), %rdi
movq %r14, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2c(%rbp)
movzwl %ax, %esi
leaq 0x2ec4(%rip), %rdi      # 0x9967
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl %ax, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x10b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12b3
decw %r15w
jne 0x6a44
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_method.c
// Function: analyzer_methods
void analyzer_methods(FILE* pReadFile, u1** constant_pool) {
  PRINTF_U2(methods_count)
  if (methods_count > 0) {
    for (u2 methods_count_index = 0; methods_count_index < methods_count; methods_count_index++) {
      PRINTF_U2(access_flags)
      PRINTF_U2(name_index)
      PRINTF_U2(descriptor_index)
      analyzer_attributes(pReadFile, constant_pool);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x30(%rbp), %r15
movl $0x1, %esi
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x1080
movzwl (%r15), %r13d
movl %r13d, %r12d
rolw $0x8, %r12w
movw %r12w, (%r15)
movzwl %r12w, %esi
leaq 0x32a1(%rip), %rdi      # 0xa26c
xorl %eax, %eax
callq 0x10b0
testw %r13w, %r13w
je 0x709f
cmpw $0x2, %r12w
movl $0x1, %r15d
cmovael %r12d, %r15d
leaq -0x2a(%rbp), %r12
leaq 0x26ea(%rip), %r13      # 0x96e0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2e(%rbp), %rdi
movq %r14, %rcx
callq 0x1080
movzwl -0x2e(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2e(%rbp)
movzwl %ax, %esi
leaq 0x25f4(%rip), %rdi      # 0x9616
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
leaq -0x2c(%rbp), %rdi
movq %r14, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2c(%rbp)
movzwl %ax, %esi
leaq 0x2912(%rip), %rdi      # 0x9967
xorl %eax, %eax
callq 0x10b0
movl $0x1, %esi
movl $0x2, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl %ax, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x10b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12b3
decw %r15w
jne 0x6ff6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte_generator.c
// Function: jbyte_generator
int jbyte_generator(int argc, char** argv) {
  FILE* pWriteFile = fopen(argv[2], "w+b");
  if (pWriteFile != NULL) {
    PUT_U4(magic, MAGIC)
    PUT_U2(minor_version, 0x0000)
    PUT_U2(major_version, JDK13)
    generator_constant_pool(pWriteFile);
    PUT_U2(access_flags, ACC_PUBLIC | ACC_SUPER)
    PUT_U2(this_class, 0x0012)
    PUT_U2(super_class, 0x0013)
    u2 interfaces_count_value = 0x0000;
    PUT_U2(interfaces_count, interfaces_count_value)
    for (u2 interfaces_count_index = 0; interfaces_count_index < interfaces_count_value; interfaces_count_index++) {
      //PUT_U2(interfaces, )
    }
    generator_fields(pWriteFile);
    generator_methods(pWriteFile);
    generator_attributes(pWriteFile);
  }
  fclose(pWriteFile);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rdi
leaq 0x2fca(%rip), %rsi      # 0xa30b
callq 0x1100
movq %rax, %rbx
testq %rax, %rax
je 0x7434
leaq -0x1c(%rbp), %r14
movl $0xbebafeca, (%r14)     # imm = 0xBEBAFECA
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1120
xorl %r15d, %r15d
movw %r15w, (%r14)
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1120
movw $0x3900, (%r14)         # imm = 0x3900
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1120
movq %rbx, %rdi
callq 0x5aa4
movw $0x2100, (%r14)         # imm = 0x2100
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1120
movw $0x1200, (%r14)         # imm = 0x1200
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1120
movw $0x1300, (%r14)         # imm = 0x1300
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1120
movw %r15w, (%r14)
leaq -0x1c(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1120
movq %rbx, %rdi
callq 0x69a8
movq %rbx, %rdi
callq 0x6afc
movq %rbx, %rdi
callq 0x122c
movq %rbx, %rdi
callq 0x1090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/CheneyThinker[P]jbyte/src/jbyte.c
// Function: main
int main(int argc, char** argv)
{
  if (!strcasecmp(argv[1], "--analyzer")) {
    return jbyte_analyzer(argc, argv);
  } else if (!strcasecmp(argv[1], "--generator")) {
    return jbyte_generator(argc, argv);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movq 0x8(%rsi), %r15
leaq 0x2ea8(%rip), %rsi      # 0xa30f
movq %r15, %rdi
callq 0x1050
testl %eax, %eax
je 0x7493
leaq 0x2ea0(%rip), %rsi      # 0xa31a
movq %r15, %rdi
callq 0x1050
testl %eax, %eax
je 0x74a8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x70b0
movl %r14d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x732c
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/redis-cli.c
// Function: sdscatcolor
sds sdscatcolor(sds o, char *s, size_t len, char *color) {
    if (!isColorTerm()) return sdscatlen(o,s,len);

    int bold = strstr(color,"bold") != NULL;
    int ccode = 37; /* Defaults to white. */
    if (strstr(color,"red")) ccode = 31;
    else if (strstr(color,"red")) ccode = 31;
    else if (strstr(color,"green")) ccode = 32;
    else if (strstr(color,"yellow")) ccode = 33;
    else if (strstr(color,"blue")) ccode = 34;
    else if (strstr(color,"magenta")) ccode = 35;
    else if (strstr(color,"cyan")) ccode = 36;
    else if (strstr(color,"white")) ccode = 37;

    o = sdscatfmt(o,"\033[%i;%i;49m",bold,ccode);
    o = sdscatlen(o,s,len);
    o = sdscat(o,"\033[0m");
    return o;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1a33c
testl %eax, %eax
je 0x1a474
leaq 0x2d93f(%rip), %rsi     # 0x47cd5
movq %r12, %rdi
callq 0x116d0
xorl %ebp, %ebp
testq %rax, %rax
setne %bpl
leaq 0x2d92c(%rip), %rsi     # 0x47cda
movq %r12, %rdi
callq 0x116d0
movl $0x1f, %ecx
testq %rax, %rax
jne 0x1a43c
leaq 0x2d917(%rip), %rsi     # 0x47cde
movq %r12, %rdi
callq 0x116d0
movl $0x20, %ecx
testq %rax, %rax
jne 0x1a43c
leaq 0x2d904(%rip), %rsi     # 0x47ce4
movq %r12, %rdi
callq 0x116d0
movl $0x21, %ecx
testq %rax, %rax
jne 0x1a43c
leaq 0x2d8f2(%rip), %rsi     # 0x47ceb
movq %r12, %rdi
callq 0x116d0
movl $0x22, %ecx
testq %rax, %rax
jne 0x1a43c
leaq 0x2d8de(%rip), %rsi     # 0x47cf0
movq %r12, %rdi
callq 0x116d0
movl $0x23, %ecx
testq %rax, %rax
jne 0x1a43c
leaq 0x2d8cd(%rip), %rsi     # 0x47cf8
movq %r12, %rdi
callq 0x116d0
xorl %ecx, %ecx
cmpq $0x1, %rax
adcl $0x24, %ecx
leaq 0x2d8c0(%rip), %rsi     # 0x47d03
movq %r15, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x22cc2
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x227dd
leaq 0x2f74a(%rip), %rsi     # 0x49bae
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x228ad
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x227dd
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/redis-cli.c
// Function: sdsCatColorizedLdbReply
sds sdsCatColorizedLdbReply(sds o, char *s, size_t len) {
    char *color = "white";

    if (strstr(s,"<debug>")) color = "bold";
    if (strstr(s,"<redis>")) color = "green";
    if (strstr(s,"<reply>")) color = "cyan";
    if (strstr(s,"<error>")) color = "red";
    if (strstr(s,"<hint>")) color = "bold";
    if (strstr(s,"<value>") || strstr(s,"<retval>")) color = "magenta";
    if (len > 4 && isdigit(s[3])) {
        if (s[1] == '>') color = "yellow"; /* Current line. */
        else if (s[2] == '#') color = "bold"; /* Break point. */
    }
    return sdscatcolor(o,s,len,color);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2d891(%rip), %rsi     # 0x47d36
movq %r14, %rdi
callq 0x116d0
testq %rax, %rax
jne 0x1a56a
leaq 0x2d872(%rip), %rsi     # 0x47d2f
movq %r14, %rdi
callq 0x116d0
movq %rax, (%rsp)
leaq 0x2d857(%rip), %rsi     # 0x47d27
movq %r14, %rdi
callq 0x116d0
movq %rax, %r12
leaq 0x2d83d(%rip), %rsi     # 0x47d1f
movq %r14, %rdi
callq 0x116d0
movq %rax, %rbp
leaq 0x2d823(%rip), %rsi     # 0x47d17
movq %r14, %rdi
callq 0x116d0
movq %rax, %r13
leaq 0x2d809(%rip), %rsi     # 0x47d0f
movq %r14, %rdi
callq 0x116d0
testq %rax, %rax
leaq 0x2d7e5(%rip), %rax     # 0x47cfd
leaq 0x2d7b6(%rip), %rcx     # 0x47cd5
cmovneq %rcx, %rax
testq %r13, %r13
leaq 0x2d7b1(%rip), %rdx     # 0x47cde
cmoveq %rax, %rdx
testq %rbp, %rbp
leaq 0x2d7bd(%rip), %rax     # 0x47cf8
cmoveq %rdx, %rax
testq %r12, %r12
leaq 0x2d791(%rip), %r12     # 0x47cda
cmoveq %rax, %r12
cmpq $0x0, (%rsp)
cmovneq %rcx, %r12
leaq 0x2d7e1(%rip), %rsi     # 0x47d3e
movq %r14, %rdi
callq 0x116d0
testq %rax, %rax
je 0x1a571
leaq 0x2d77f(%rip), %r12     # 0x47cf0
cmpq $0x5, %rbx
jb 0x1a5ab
callq 0x11720
movq (%rax), %rax
movsbq 0x3(%r14), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x1a5ab
cmpb $0x3e, 0x1(%r14)
jne 0x1a59b
leaq 0x2d74b(%rip), %r12     # 0x47ce4
jmp 0x1a5ab
cmpb $0x23, 0x2(%r14)
leaq 0x2d72e(%rip), %rax     # 0x47cd5
cmoveq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a36e
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/redis-cli.c
// Function: cliSetPreferences
void cliSetPreferences(char **argv, int argc, int interactive) {
    if (!strcasecmp(argv[0],":set") && argc >= 2) {
        if (!strcasecmp(argv[1],"hints")) pref.hints = 1;
        else if (!strcasecmp(argv[1],"nohints")) pref.hints = 0;
        else {
            printf("%sunknown redis-cli preference '%s'\n",
                interactive ? "" : ".redisclirc: ",
                argv[1]);
        }
    } else {
        printf("%sunknown redis-cli internal command '%s'\n",
            interactive ? "" : ".redisclirc: ",
            argv[0]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %r14
leaq 0x2d765(%rip), %rsi     # 0x47d47
movq %r14, %rdi
callq 0x11080
cmpl $0x2, %ebp
jl 0x1a63a
testl %eax, %eax
jne 0x1a63a
movq 0x8(%r15), %r14
leaq 0x2d750(%rip), %rsi     # 0x47d4e
movq %r14, %rdi
callq 0x11080
testl %eax, %eax
je 0x1a669
leaq 0x2d73b(%rip), %rsi     # 0x47d4c
movq %r14, %rdi
callq 0x11080
testl %eax, %eax
je 0x1a672
testl %ebx, %ebx
leaq 0x2d753(%rip), %rax     # 0x47d79
leaq 0x2ec33(%rip), %rsi     # 0x49260
cmoveq %rax, %rsi
leaq 0x2d71c(%rip), %rdi     # 0x47d54
jmp 0x1a655
testl %ebx, %ebx
leaq 0x2d736(%rip), %rax     # 0x47d79
leaq 0x2ec16(%rip), %rsi     # 0x49260
cmoveq %rax, %rsi
leaq 0x2d732(%rip), %rdi     # 0x47d87
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11200
movb $0x1, 0x45dc8(%rip)     # 0x60438
jmp 0x1a679
movb $0x0, 0x45dbf(%rip)     # 0x60438
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/redis-cli.c
// Function: cliLoadPreferences
void cliLoadPreferences(void) {
    sds rcfile = getDotfilePath(REDIS_CLI_RCFILE_ENV,REDIS_CLI_RCFILE_DEFAULT);
    if (rcfile == NULL) return;
    FILE *fp = fopen(rcfile,"r");
    char buf[1024];

    if (fp) {
        while(fgets(buf,sizeof(buf),fp) != NULL) {
            sds *argv;
            int argc;

            argv = sdssplitargs(buf,&argc);
            if (argc > 0) cliSetPreferences(argv,argc,0);
            sdsfreesplitres(argv,argc);
        }
        fclose(fp);
    }
    sdsfree(rcfile);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
leaq 0x2d717(%rip), %rdi     # 0x47db2
leaq 0x2d720(%rip), %rsi     # 0x47dc2
callq 0x1a74d
testq %rax, %rax
je 0x1a73c
movq %rax, %rbx
leaq 0x2d80c(%rip), %rsi     # 0x47ec6
movq %rax, %rdi
callq 0x113f0
testq %rax, %rax
je 0x1a734
movq %rax, %r14
leaq 0x10(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdx
callq 0x11340
testq %rax, %rax
je 0x1a72c
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x23b0c
movq %rax, %r13
movl 0xc(%rsp), %esi
testl %esi, %esi
jle 0x1a70b
movq %r13, %rdi
xorl %edx, %edx
callq 0x1a5ca
movl 0xc(%rsp), %esi
movq %r13, %rdi
callq 0x23906
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x11340
testq %rax, %rax
jne 0x1a6eb
movq %r14, %rdi
callq 0x111c0
movq %rbx, %rdi
callq 0x22043
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/redis-cli.c
// Function: getDotfilePath
static sds getDotfilePath(char *envoverride, char *dotfilename) {
    char *path = NULL;
    sds dotPath = NULL;

    /* Check the env for a dotfile override. */
    path = getenv(envoverride);
    if (path != NULL && *path != '\0') {
        if (!strcmp("/dev/null", path)) {
            return NULL;
        }

        /* If the env is set, return it. */
        dotPath = sdsnew(path);
    } else {
        char *home = getenv("HOME");
        if (home != NULL && *home != '\0') {
            /* If no override is set use $HOME/<dotfilename>. */
            dotPath = sdscatprintf(sdsempty(), "%s/%s", home, dotfilename);
        }
    }
    return dotPath;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x11050
testq %rax, %rax
je 0x1a788
movq %rax, %r14
cmpb $0x0, (%rax)
je 0x1a788
leaq 0x2d730(%rip), %rdi     # 0x47e9d
movq %r14, %rsi
callq 0x11390
testl %eax, %eax
je 0x1a7c4
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21fd2
leaq 0x2d718(%rip), %rdi     # 0x47ea7
callq 0x11050
testq %rax, %rax
je 0x1a7c4
movq %rax, %r14
cmpb $0x0, (%rax)
je 0x1a7c4
callq 0x21faf
leaq 0x2d6ff(%rip), %rsi     # 0x47eac
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22c3e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/src/redis-cli.c
// Function: showLatencyDistSamples
void showLatencyDistSamples(struct distsamples *samples, long long tot) {
    int j;

     /* We convert samples into a index inside the palette
     * proportional to the percentage a given bucket represents.
     * This way intensity of the different parts of the spectrum
     * don't change relative to the number of requests, which avoids to
     * pollute the visualization with non-latency related info. */
    printf("\033[38;5;0m"); /* Set foreground color to black. */
    for (j = 0; ; j++) {
        int coloridx =
            ceil((float) samples[j].count / tot * (spectrum_palette_size-1));
        int color = spectrum_palette[coloridx];
        printf("\033[48;5;%dm%c", (int)color, samples[j].character);
        samples[j].count = 0;
        if (samples[j].max == 0) break; /* Last sample. */
    }
    printf("\033[0m\n");
    fflush(stdout);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2d5ef(%rip), %rdi     # 0x47dce
xorl %eax, %eax
callq 0x11200
cvtsi2ss %r14, %xmm0
movss %xmm0, 0x4(%rsp)
addq $0x10, %rbx
leaq 0x2d5dc(%rip), %r14     # 0x47dd8
xorps %xmm1, %xmm1
cvtsi2ssq -0x8(%rbx), %xmm1
divss 0x4(%rsp), %xmm1
movl 0x45c2b(%rip), %eax     # 0x6043c
decl %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
callq 0x11350
cvttss2si %xmm0, %eax
movq 0x45c12(%rip), %rcx     # 0x60440
cltq
movl (%rcx,%rax,4), %esi
movl (%rbx), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x11200
movq $0x0, -0x8(%rbx)
cmpq $0x0, -0x10(%rbx)
leaq 0x18(%rbx), %rbx
jne 0x1a7fc
leaq 0x2f355(%rip), %rdi     # 0x49bae
callq 0x110e0
movq 0x4375b(%rip), %rax     # 0x5dfc0
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11480