LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq -0xa(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xa(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xa(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %esi
leaq 0x6fbd(%rip), %rdi      # 0xcd5a
movb $0x0, %al
callq 0x1090
movzwl -0xa(%rbp), %eax
cmpl $0x0, %eax
jle 0x5f42
movw $0x0, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5f40
movq -0x8(%rbp), %rcx
leaq -0xe(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xe(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xe(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %esi
leaq 0x6d13(%rip), %rdi      # 0xcb1b
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x10(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x10(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x10(%rbp)
movzwl -0x10(%rbp), %esi
leaq 0x6f1f(%rip), %rdi      # 0xcd6f
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x12(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x12(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x12(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %esi
leaq 0x716c(%rip), %rdi      # 0xd004
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x14(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x14(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x14(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x14(%rbp)
movzwl -0x14(%rbp), %esi
leaq 0x6e9d(%rip), %rdi      # 0xcd7d
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x16(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x16(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x16(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x16(%rbp)
movzwl -0x16(%rbp), %esi
leaq 0x6da6(%rip), %rdi      # 0xccce
movb $0x0, %al
callq 0x1090
movw -0xc(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x5db7
jmp 0x5f42
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq -0xa(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xa(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xa(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %esi
leaq 0x6df8(%rip), %rdi      # 0xcd95
movb $0x0, %al
callq 0x1090
movzwl -0xa(%rbp), %eax
cmpl $0x0, %eax
jle 0x6142
movw $0x0, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6140
movq -0x8(%rbp), %rcx
leaq -0xe(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xe(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xe(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %esi
leaq 0x6b13(%rip), %rdi      # 0xcb1b
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x10(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x10(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x10(%rbp)
movzwl -0x10(%rbp), %esi
leaq 0x6d1f(%rip), %rdi      # 0xcd6f
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x12(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x12(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x12(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %esi
leaq 0x6f6c(%rip), %rdi      # 0xd004
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x14(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x14(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x14(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x14(%rbp)
movzwl -0x14(%rbp), %esi
leaq 0x6bfb(%rip), %rdi      # 0xccdb
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x16(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x16(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x16(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x16(%rbp)
movzwl -0x16(%rbp), %esi
leaq 0x6ba6(%rip), %rdi      # 0xccce
movb $0x0, %al
callq 0x1090
movw -0xc(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x5fb7
jmp 0x6142
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq -0xa(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xa(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xa(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %esi
leaq 0x6ce1(%rip), %rdi      # 0xcf6e
movb $0x0, %al
callq 0x1090
movzwl -0xa(%rbp), %eax
cmpl $0x0, %eax
jle 0x642a
movw $0x0, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6428
movq -0x8(%rbp), %rcx
leaq -0xe(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xe(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xe(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %esi
leaq 0x6c93(%rip), %rdi      # 0xcf8b
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x10(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x10(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x10(%rbp)
movzwl -0x10(%rbp), %esi
leaq 0x6c67(%rip), %rdi      # 0xcfa7
movb $0x0, %al
callq 0x1090
movzwl -0x10(%rbp), %eax
cmpl $0x0, %eax
jle 0x6415
movzwl -0x10(%rbp), %edx
movl %edx, %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movl %edx, %ecx
leal 0xf(%rcx,%rcx), %ecx
andl $-0x10, %ecx
movl %ecx, %edx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movw $0x0, -0x22(%rbp)
movzwl -0x22(%rbp), %eax
movzwl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x640e
movq -0x30(%rbp), %rdi
movzwl -0x22(%rbp), %eax
shlq %rax
addq %rax, %rdi
movq -0x8(%rbp), %rcx
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movq -0x30(%rbp), %rax
movzwl -0x22(%rbp), %ecx
movzwl (%rax,%rcx,2), %ecx
shll $0x8, %ecx
andl $0xff00, %ecx           # imm = 0xFF00
movzwl -0x22(%rbp), %edx
movzwl (%rax,%rdx,2), %edx
sarl $0x8, %edx
andl $0xff, %edx
orl %edx, %ecx
movw %cx, %dx
movzwl -0x22(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movzwl -0x22(%rbp), %esi
movzwl -0x22(%rbp), %ecx
movzwl (%rax,%rcx,2), %edx
leaq 0x6bd0(%rip), %rdi      # 0xcfc6
movb $0x0, %al
callq 0x1090
movw -0x22(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x22(%rbp)
jmp 0x6383
movq -0x18(%rbp), %rax
movq %rax, %rsp
jmp 0x6417
movw -0xc(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x62a7
jmp 0x642a
movq %rbp, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x9(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1050
movzbl -0x9(%rbp), %esi
leaq 0x6b89(%rip), %rdi      # 0xcfe5
movb $0x0, %al
callq 0x1090
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jle 0x6523
movb $0x0, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6521
movq -0x8(%rbp), %rcx
leaq -0xc(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xc(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xc(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %esi
leaq 0x6b3f(%rip), %rdi      # 0xd004
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0xe(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xe(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xe(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %esi
leaq 0x67a6(%rip), %rdi      # 0xccb3
movb $0x0, %al
callq 0x1090
movb -0xa(%rbp), %al
addb $0x1, %al
movb %al, -0xa(%rbp)
jmp 0x6474
jmp 0x6523
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x9(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1050
movzbl -0x9(%rbp), %esi
leaq 0x5975(%rip), %rdi      # 0xcbd1
xorl %eax, %eax
callq 0x1090
movzbl -0x9(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x8, %rax
ja 0x733e
movq -0x18(%rbp), %rax
leaq 0x41a4(%rip), %rcx      # 0xb424
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x733e
jmp 0x733e
jmp 0x733e
jmp 0x733e
jmp 0x733e
jmp 0x733e
jmp 0x733e
movq -0x8(%rbp), %rcx
leaq -0xc(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xc(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xc(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %esi
leaq 0x58ef(%rip), %rdi      # 0xcbdc
movb $0x0, %al
callq 0x1090
jmp 0x733e
movq -0x8(%rbp), %rcx
leaq -0xe(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xe(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xe(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %esi
leaq 0x58b8(%rip), %rdi      # 0xcbef
movb $0x0, %al
callq 0x1090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x9(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1050
movzbl -0x9(%rbp), %esi
leaq 0x59b1(%rip), %rdi      # 0xcdbd
movb $0x0, %al
callq 0x1090
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jle 0x7441
movb $0x0, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jge 0x743f
movq -0x8(%rbp), %rdi
callq 0x7350
movb -0xa(%rbp), %al
addb $0x1, %al
movb %al, -0xa(%rbp)
jmp 0x7420
jmp 0x7441
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq -0xa(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xa(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xa(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %esi
leaq 0x5f3e(%rip), %rdi      # 0xd3db
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0xc(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0xc(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xc(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %esi
leaq 0x59f6(%rip), %rdi      # 0xcedb
movb $0x0, %al
callq 0x1090
movzwl -0xc(%rbp), %eax
cmpl $0x0, %eax
jle 0x7568
movw $0x0, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
movzwl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x7566
movq -0x8(%rbp), %rcx
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x10(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x10(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x10(%rbp)
movzwl -0x10(%rbp), %esi
leaq 0x59b2(%rip), %rdi      # 0xcefa
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x7ea0
movw -0xe(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xe(%rbp)
jmp 0x74fb
jmp 0x7568
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x11(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1100
movq -0x8(%rbp), %rdi
callq 0x1080
movw %ax, -0x14(%rbp)
movw -0x14(%rbp), %ax
movw %ax, -0x16(%rbp)
movzwl -0x16(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x16(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x16(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x16(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x1100
movw $0x0, -0x18(%rbp)
movzwl -0x18(%rbp), %eax
movzwl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jge 0x8397
movq -0x8(%rbp), %rax
movzwl -0x18(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x19(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1100
movw -0x18(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x18(%rbp)
jmp 0x835a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movw $0x0, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x992b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl -0xa(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x991b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl -0xa(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl -0xa(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
jmp 0x991d
movw -0xa(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x98d2
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x994c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/CheneyThinker[P]jbyte/src/jbyte_field.c
// Function: generator_fields
void generator_fields(FILE* pWriteFile) {
  u2 fields_count_value = 0x0000;
  PUT_U2(fields_count, fields_count_value)
  for (u2 fields_count_index = 0; fields_count_index < fields_count_value; fields_count_index++) {
    //PUT_U2(access_flags)
    //PUT_U2(name_index)
    //PUT_U2(descriptor_index)
    //attributes(pReadFile, constant_pool);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movw $0x0, -0xa(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0xc(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
leaq -0xc(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x1100
movw $0x0, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jge 0x99d2
jmp 0x99c4
movw -0xe(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xe(%rbp)
jmp 0x99b6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x12(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x12(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x12(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %esi
leaq 0x3a99(%rip), %rdi      # 0xd4ca
movb $0x0, %al
callq 0x1090
movzwl -0x12(%rbp), %eax
cmpl $0x0, %eax
jle 0x9b53
movw $0x0, -0x14(%rbp)
movzwl -0x14(%rbp), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jge 0x9b51
movq -0x8(%rbp), %rcx
leaq -0x16(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x16(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x16(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x16(%rbp)
movzwl -0x16(%rbp), %esi
leaq 0x3217(%rip), %rdi      # 0xccb3
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x18(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x18(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x18(%rbp)
movzwl -0x18(%rbp), %esi
leaq 0x3520(%rip), %rdi      # 0xd004
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x1a(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x1a(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x1a(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x1a(%rbp)
movzwl -0x1a(%rbp), %esi
leaq 0x3251(%rip), %rdi      # 0xcd7d
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1330
movw -0x14(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x14(%rbp)
jmp 0x9a4b
jmp 0x9b53
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x12(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x12(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x12(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %esi
leaq 0x2e7d(%rip), %rdi      # 0xd4de
movb $0x0, %al
callq 0x1090
movzwl -0x12(%rbp), %eax
cmpl $0x0, %eax
jle 0xa783
movw $0x0, -0x14(%rbp)
movzwl -0x14(%rbp), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jge 0xa781
movq -0x8(%rbp), %rcx
leaq -0x16(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x16(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x16(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x16(%rbp)
movzwl -0x16(%rbp), %esi
leaq 0x25e7(%rip), %rdi      # 0xccb3
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x18(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x18(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x18(%rbp)
movzwl -0x18(%rbp), %esi
leaq 0x28f0(%rip), %rdi      # 0xd004
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rcx
leaq -0x1a(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1050
movzwl -0x1a(%rbp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movzwl -0x1a(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, -0x1a(%rbp)
movzwl -0x1a(%rbp), %esi
leaq 0x2621(%rip), %rdi      # 0xcd7d
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1330
movw -0x14(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x14(%rbp)
jmp 0xa67b
jmp 0xa783
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x280c(%rip), %rsi      # 0xd581
callq 0x1040
cmpl $0x0, %eax
jne 0xad90
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xa790
movl %eax, -0x4(%rbp)
jmp 0xadc3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x27ed(%rip), %rsi      # 0xd58c
callq 0x1040
cmpl $0x0, %eax
jne 0xadba
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xab00
movl %eax, -0x4(%rbp)
jmp 0xadc3
jmp 0xadbc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/des/des.c
// Function: permutation
void permutation(uint64_t *data, bool initial)
{
  uint64_t dtmp = 0;
  for(int i=0; i<64; i++)
  {
    if(initial)
      addbit(&dtmp, *data, IP[i] -1, i);
    else
      addbit(&dtmp, *data, IP_1[i] -1, i);
  }
  *data = dtmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x40, -0x1c(%rbp)
jge 0x12be
testb $0x1, -0x9(%rbp)
je 0x1289
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movslq -0x1c(%rbp), %rcx
leaq 0xd9f(%rip), %rax       # 0x2010
movq (%rax,%rcx,8), %rax
subq $0x1, %rax
movl %eax, %edx
movl -0x1c(%rbp), %ecx
leaq -0x18(%rbp), %rdi
callq 0x11e0
jmp 0x12b1
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movslq -0x1c(%rbp), %rcx
leaq 0xf75(%rip), %rax       # 0x2210
movq (%rax,%rcx,8), %rax
subq $0x1, %rax
movl %eax, %edx
movl -0x1c(%rbp), %ecx
leaq -0x18(%rbp), %rdi
callq 0x11e0
jmp 0x12b3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1253
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/des/des.c
// Function: key_convert
uint64_t key_convert(const char *key)
{ 
  if(strlen(key)>9)
    return 0; 
  uint64_t keyval = 0;
  for(int i=0;i < 8;i++){
    keyval = (keyval<<8)|key[i];
  }
  if(key_parity_verify(keyval))
    return keyval;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1050
cmpq $0x9, %rax
jbe 0x17a5
movq $0x0, -0x8(%rbp)
jmp 0x1802
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x17e1
movq -0x18(%rbp), %rax
shlq $0x8, %rax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbq (%rcx,%rdx), %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17b4
movq -0x18(%rbp), %rdi
callq 0x1810
testb $0x1, %al
jne 0x17f0
jmp 0x17fa
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1802
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/des/des.c
// Function: key_parity_verify
static bool key_parity_verify(uint64_t key)
{
  int parity_bit = 0; // parity helper

  for(int i=0; i<64; i++)
  {
    // test parity bit (8th bit)
    if(i%8 == 7)
    {
      if(parity_bit == 0) {
        // test if 8th bit != 0
        if( ((key<<i) & FIRSTBIT) != (uint64_t)0) {
          if( ((key<<i) & FIRSTBIT) != (uint64_t)0){         
            printf("parity error at bit #%i\n", i+1);
            return false;
          }
        } 
      } else {
        if( ((key<<i)&FIRSTBIT) != FIRSTBIT) {
          if( ((key<<i)&FIRSTBIT) != FIRSTBIT) {
            printf("parity error at bit #%i\n", i+1);
            return false;
          }
        }
      }
      parity_bit = 0;
    }
    else {
      if( ((key<<i) & FIRSTBIT) == FIRSTBIT) {
        parity_bit = parity_bit == 0 ? 1:0;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x40, -0x18(%rbp)
jge 0x1967
movl -0x18(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x7, %edx
jne 0x191c
cmpl $0x0, -0x14(%rbp)
jne 0x18a9
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
shlq %cl, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq %rcx, %rax
cmpq $0x0, %rax
je 0x18a7
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
shlq %cl, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq %rcx, %rax
cmpq $0x0, %rax
je 0x18a5
movl -0x18(%rbp), %esi
addl $0x1, %esi
leaq 0x21bb(%rip), %rdi      # 0x3a50
movb $0x0, %al
callq 0x1070
movb $0x0, -0x1(%rbp)
jmp 0x1967
jmp 0x18a7
jmp 0x1913
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
shlq %cl, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq %rcx, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, %rax
je 0x1911
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
shlq %cl, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq %rcx, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, %rax
je 0x190f
movl -0x18(%rbp), %esi
addl $0x1, %esi
leaq 0x214e(%rip), %rdi      # 0x3a50
movb $0x0, %al
callq 0x1070
movb $0x0, -0x1(%rbp)
jmp 0x1967
jmp 0x1911
jmp 0x1913
movl $0x0, -0x14(%rbp)
jmp 0x1957
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
shlq %cl, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq %rcx, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, %rax
jne 0x1955
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x1957
jmp 0x1959
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x182a
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/des/des.c
// Function: encrypt
void encrypt(FILE *ifile, FILE *ofile, uint64_t key)
{
  size_t size;
  uint64_t data;
  uint64_t sub_key[ROUNDS]={0};
  get_subkey(key, sub_key);

  while((size = fread(&data,1,8, ifile)) > 0)
  {
    if(size != 8)
      data = data << (8*(8-size));

    permutation(&data, true);
    for(int i=0;i< ROUNDS;i++)
      rounds(&data, sub_key[i]);

    permutation(&data, false);

    if(size != 8)
      data = data<< (8*(8-size));

    fwrite(&data, 1, size, ofile);
    data = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x1080
movq -0x18(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1aa0
movq -0x8(%rbp), %rcx
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0x1030
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jbe 0x1a95
cmpq $0x8, -0x20(%rbp)
je 0x19fe
movq -0x28(%rbp), %rax
movl $0x8, %ecx
subq -0x20(%rbp), %rcx
shlq $0x3, %rcx
shlq %cl, %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x1230
movl $0x0, -0xb4(%rbp)
cmpl $0x10, -0xb4(%rbp)
jge 0x1a48
movslq -0xb4(%rbp), %rax
movq -0xb0(%rbp,%rax,8), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1580
movl -0xb4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0x1a16
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x1230
cmpq $0x8, -0x20(%rbp)
je 0x1a72
movq -0x28(%rbp), %rax
movl $0x8, %ecx
subq -0x20(%rbp), %rcx
shlq $0x3, %rcx
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x10d0
movq $0x0, -0x28(%rbp)
jmp 0x19ba
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/des/des.c
// Function: get_subkey
static void get_subkey(uint64_t key, uint64_t sub_key[])
{
  sub_key[0] = key;
  uint64_t nxt_key;

  for(int i =0; i<ROUNDS; i++)
  {
    key_schedule(&sub_key[i], &nxt_key, i);
    if(i != 15)
      sub_key[i+1] = nxt_key;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x1b0b
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl -0x1c(%rbp), %edx
leaq -0x18(%rbp), %rsi
callq 0x12d0
cmpl $0xf, -0x1c(%rbp)
je 0x1afe
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1b00
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1ac2
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/des/des.c
// Function: decrypt
void decrypt(FILE *ifile, FILE *ofile, uint64_t key)
{
  size_t size;
  uint64_t data;
  uint64_t sub_key[ROUNDS]={0};
  get_subkey(key, sub_key);

  while((size = fread(&data,1,8, ifile)) > 0)
  {
    data = (data<<32) + (data>>32);
    for(int i=ROUNDS-1; i >=0; i--)
      rounds(&data, sub_key[i]);

    permutation(&data, false);

    if(size != 8)
      data = data<< (8*(8-size));

    fwrite(&data, 1, size, ofile);
    data = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x1080
movq -0x18(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1aa0
movq -0x8(%rbp), %rcx
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0x1030
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jbe 0x1c1f
movq -0x28(%rbp), %rax
shlq $0x20, %rax
movq -0x28(%rbp), %rcx
shrq $0x20, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0xf, -0xb4(%rbp)
cmpl $0x0, -0xb4(%rbp)
jl 0x1bd2
movslq -0xb4(%rbp), %rax
movq -0xb0(%rbp,%rax,8), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1580
movl -0xb4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0x1ba0
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x1230
cmpq $0x8, -0x20(%rbp)
je 0x1bfc
movq -0x28(%rbp), %rax
movl $0x8, %ecx
subq -0x20(%rbp), %rcx
shlq $0x3, %rcx
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x10d0
movq $0x0, -0x28(%rbp)
jmp 0x1b5a
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/des/des/main.c
// Function: help
static void help(int status)
{
  if(status == EXIT_SUCCESS)
  {
    fprintf(stdout,"Usage: des -i <filename> -o <filename> -k <key> -t <task>\n"
        "encrypt or decrypt with DES...\n"
        "-k, --key=KEY      64 bits key\n"
        "-t, --task         'e' for encryption or 'd' for decryption\n"
        "-o, --output=FILE  write result to FILE\n"
        "-i, --input=FILE   read from the FILE\n"
        "--help         display this help\n");
  }
  else
  {
    fprintf(stderr, "Try './des --help' for more information.\n");
  }
  exit(status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x1eeb
movq 0x40f8(%rip), %rax      # 0x5fd0
movq (%rax), %rdi
leaq 0x1c9f(%rip), %rsi      # 0x3b81
movb $0x0, %al
callq 0x1090
jmp 0x1f03
movq 0x4106(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x1da9(%rip), %rsi      # 0x3ca5
movb $0x0, %al
callq 0x1090
movl -0x4(%rbp), %edi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/warning.c
// Function: main
int main(int argc, char **argv, char **envp) {
    int param_opt;
    char *ip = "121.189.57.82"; /* warning.or.kr */
    while ((param_opt = getopt(argc, argv, "i:h")) != -1) {
        switch (param_opt) {
            case 'i':
                ip = optarg;
                break;
            case 'h':
                showhelp(argv[0]);
                exit(0);
            case '?':
                showhelp(argv[0]);
                exit(1);
        }
    }

    if (optind == argc) {
        showhelp(argv[0]);
        exit(1);
    }

    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(80);
    serverAddr.sin_addr.s_addr = inet_addr(ip);
    vector = &serverAddr;

    clee_init();
    clee_set_trigger(syscall_entry, onSyscallEntry);
    clee(argv[optind], argv + optind, envp, next_syscall, NULL, 0);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x198f(%rip), %rax      # 0x8e90
movq %rax, -0x28(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x198b(%rip), %rdx      # 0x8e9e
callq 0x31f0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x757c
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0x3f, %eax
je 0x7564
jmp 0x752d
movl -0x3c(%rbp), %eax
subl $0x68, %eax
je 0x7551
jmp 0x7537
movl -0x3c(%rbp), %eax
subl $0x69, %eax
jne 0x757a
jmp 0x7541
movq 0x4a98(%rip), %rax      # 0xbfe0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x757a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7630
xorl %edi, %edi
callq 0x3210
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7630
movl $0x1, %edi
callq 0x3210
jmp 0x7505
movq 0x4a55(%rip), %rax      # 0xbfd8
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x75a0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7630
movl $0x1, %edi
callq 0x3210
movw $0x2, -0x38(%rbp)
movl $0x50, %edi
callq 0x3090
movw %ax, -0x36(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3140
movl %eax, -0x34(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, 0x4d4d(%rip)      # 0xc318
movb $0x0, %al
callq 0x3350
xorl %edi, %edi
leaq 0x95(%rip), %rsi        # 0x7670
callq 0x3da0
movq -0x10(%rbp), %rax
movq 0x49ed(%rip), %rcx      # 0xbfd8
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq 0x49db(%rip), %rax      # 0xbfd8
movslq (%rax), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
movl $0x4, %ecx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x3430
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/seojangho[P]clee/warning.c
// Function: onSyscallEntry
void onSyscallEntry() {
    if (clee_syscall_num() == 42) {
        struct sockaddr_in original;
        clee_read((void*)clee_get_arg(1), &original, sizeof(struct sockaddr_in));
        printf("connecting to %s -> ", inet_ntoa(original.sin_addr));
        printf("manipulating request to %s\n", inet_ntoa(vector->sin_addr));
        clee_write(vector, (void*)clee_get_arg(1), sizeof(struct sockaddr_in));
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, %al
callq 0x3bc0
cmpq $0x2a, %rax
jne 0x76ff
movl $0x1, %edi
callq 0x3c30
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
movl $0x10, %edx
callq 0x40b0
movl -0xc(%rbp), %edi
callq 0x3070
movq %rax, %rsi
leaq 0x189e(%rip), %rdi      # 0x8f50
movb $0x0, %al
callq 0x30a0
movq 0x4c58(%rip), %rax      # 0xc318
movl 0x4(%rax), %edi
callq 0x3070
movq %rax, %rsi
leaq 0x1893(%rip), %rdi      # 0x8f65
movb $0x0, %al
callq 0x30a0
movq 0x4c38(%rip), %rax      # 0xc318
movq %rax, -0x18(%rbp)
movl $0x1, %edi
callq 0x3c30
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x4140
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp11.c
// Function: usage
void
usage(void)
{
	fprintf(stderr, "usage: %s [-p port] [-s time(ms)] [-d] server\n", argv0);
	fprintf(stderr, "\tserver: host running pdp-10\n");
	fprintf(stderr, "\t-p: pdp-10 port; default 1110\n");
	fprintf(stderr, "\t-s: sleep (ms); default=0\n");
	fprintf(stderr, "\t-d: write debug log\n");
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x25fcd(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
movq 0x34433(%rip), %rdx     # 0x37468
leaq 0x1d0b7(%rip), %rsi     # 0x200f3
movb $0x0, %al
callq 0x2140
movq 0x25fae(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
leaq 0x1d0ce(%rip), %rsi     # 0x20122
movb $0x0, %al
callq 0x2140
movq 0x25f96(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
leaq 0x1d0d4(%rip), %rsi     # 0x20140
movb $0x0, %al
callq 0x2140
movq 0x25f7e(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
leaq 0x1d0dc(%rip), %rsi     # 0x20160
movb $0x0, %al
callq 0x2140
movq 0x25f66(%rip), %rax     # 0x28ff8
movq (%rax), %rdi
leaq 0x1d0e0(%rip), %rsi     # 0x2017c
movb $0x0, %al
callq 0x2140
xorl %edi, %edi
callq 0x22a0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: xgp_char
void
xgp_char(XGP *xgp, uint8 data)
{
	if(data == 0x00) {
		xgp->mode = xgp_command;
	} else {
		xgp->cnt = data;
		xgp->mode = xgp_char_data;
	}	  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0x3768
movq -0x8(%rbp), %rax
leaq 0x35e(%rip), %rcx       # 0x3ac0
movq %rcx, 0x38(%rax)
jmp 0x3786
movzbl -0x9(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0x3ce(%rip), %rcx       # 0x3b50
movq %rcx, 0x38(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: datob_xgp
int
datob_xgp(Bus *bus, void *dev)
{
	XGP *xgp = dev;
	word d, m;

	d = bus->data;
	m = bus->addr&1 ? ~0377 : 0377;
	switch(bus->addr&~1){
	case XCR:
		return 0;
	case MAR:
		return 0;
	case XSR:
		return 0;
	case XCUT:
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movw 0xc(%rax), %ax
movw %ax, -0x22(%rbp)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %al
testb $0x1, %al
movl $0xff00, %ecx           # imm = 0xFF00
movl $0xff, %eax
cmovnel %ecx, %eax
movw %ax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
andl $-0x2, %eax
addl $0xfffc0bc0, %eax       # imm = 0xFFFC0BC0
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x6, %eax
ja 0x381c
movq -0x30(%rbp), %rax
leaq 0x1c9d5(%rip), %rcx     # 0x201c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x3823
movl $0x0, -0x4(%rbp)
jmp 0x3823
movl $0x0, -0x4(%rbp)
jmp 0x3823
movl $0x0, -0x4(%rbp)
jmp 0x3823
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: dati_xgp
int
dati_xgp(Bus *bus, void *dev)
{
	XGP *xgp = dev;

	switch(bus->addr){
	case XCR:
		bus->data = xgp->xcr;
		return 0;
	case MAR:
		bus->data = xgp->mar;
		return 0;
	case XSR:
		bus->data = xgp->xsr;
		return 0;
	case XCUT:
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl $0xfffc0bc0, %eax       # imm = 0xFFFC0BC0
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x6, %eax
ja 0x38c3
movq -0x28(%rbp), %rax
leaq 0x1c97a(%rip), %rcx     # 0x201e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movw 0x28(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0xc(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x38ca
movq -0x20(%rbp), %rax
movw 0x2a(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0xc(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x38ca
movq -0x20(%rbp), %rax
movw 0x2c(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0xc(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x38ca
movl $0x0, -0x4(%rbp)
jmp 0x38ca
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: xgp_done
void
xgp_done(XGP *xgp, uint16 errors)
{
	xgp->xcr |= FDONE;
	xgp->xcr &= ~FGO;
	xgp->go = xgp_idle;
	if(errors) {
		xgp->xcr |= FERR;
		xgp->xsr |= errors;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x28(%rax), %ecx
orl $0x80, %ecx
movw %cx, 0x28(%rax)
movq -0x8(%rbp), %rax
movzwl 0x28(%rax), %ecx
andl $-0x2, %ecx
movw %cx, 0x28(%rax)
movq -0x8(%rbp), %rax
leaq -0x47b(%rip), %rcx      # 0x3490
movq %rcx, 0x30(%rax)
cmpw $0x0, -0xa(%rbp)
je 0x393a
movq -0x8(%rbp), %rax
movzwl 0x28(%rax), %ecx
orl $0x8000, %ecx           # imm = 0x8000
movw %cx, 0x28(%rax)
movzwl -0xa(%rbp), %edx
movq -0x8(%rbp), %rax
movzwl 0x2c(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x2c(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: xgp_output
void
xgp_output(XGP *xgp, uint8 data, int n)
{
	int m = 1;
	while(n-- > 0) {
		print_dot(data & m);
		m <<= 1;
		xgp->dots++;
		if(xgp->dots >= MAX_WIDTH) {
			xgp_done(xgp, FOS);
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x0, %eax
jle 0x39ac
movzbl -0x9(%rbp), %edi
andl -0x14(%rbp), %edi
callq 0x9500
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
movq -0x8(%rbp), %rax
cmpl $0x6c0, 0x48(%rax)      # imm = 0x6C0
jl 0x39aa
movq -0x8(%rbp), %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x38d0
jmp 0x39ac
jmp 0x395c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: xgp_vector
void
xgp_vector(XGP *xgp, uint8 data)
{
	if(data == 0)
		xgp->cnt++;
	else
		xgp->cnt = 0;

	if(xgp->cnt == 2)
		xgp->mode = xgp_char;

	if(data == 0)
		return;

	while(data > 8) {
		xgp_output(xgp, xgp->bw, 8);
		data -= 8;
		if(xgp->xcr & FDONE)
			return;
	}
	xgp_output(xgp, xgp->bw, data);

	xgp->bw ^= 0xFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0x3a1d
movq -0x8(%rbp), %rax
movw 0x40(%rax), %cx
addw $0x1, %cx
movw %cx, 0x40(%rax)
jmp 0x3a27
movq -0x8(%rbp), %rax
movw $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movzwl 0x40(%rax), %eax
cmpl $0x2, %eax
jne 0x3a43
movq -0x8(%rbp), %rax
leaq -0x2ff(%rip), %rcx      # 0x3740
movq %rcx, 0x38(%rax)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0x3a4e
jmp 0x3ab7
jmp 0x3a50
movzbl -0x9(%rbp), %eax
cmpl $0x8, %eax
jle 0x3a8f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x8, %edx
movzbl 0x42(%rax), %esi
callq 0x3940
movzbl -0x9(%rbp), %eax
subl $0x8, %eax
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x28(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x3a8d
jmp 0x3ab7
jmp 0x3a50
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movb 0x42(%rax), %al
movzbl -0x9(%rbp), %edx
movzbl %al, %esi
callq 0x3940
movq -0x8(%rbp), %rax
movzbl 0x42(%rax), %ecx
xorl $0xff, %ecx
movb %cl, 0x42(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: xgp_command
void
xgp_command(XGP *xgp, uint8 data)
{
	switch(data) {
	case 0x00:
		xgp->mode = xgp_vector;
		xgp->cnt = 0;
		xgp->bw = 0;
		break;
	case 0x01:
		xgp_done(xgp, 0);
		break;
	case 0x02:
		xgp->mode = xgp_image;
		break;
	default:
		xgp_done(xgp, FBCB);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x3af3
jmp 0x3adf
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x3b16
jmp 0x3ae9
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x3b23
jmp 0x3b34
movq -0x8(%rbp), %rax
leaq -0x10e(%rip), %rcx      # 0x39f0
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x42(%rax)
jmp 0x3b42
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x38d0
jmp 0x3b42
movq -0x8(%rbp), %rax
leaq -0x16e(%rip), %rcx      # 0x39c0
movq %rcx, 0x38(%rax)
jmp 0x3b42
movq -0x8(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x38d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)