LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cgame/cgame.c
// Function: draw_screen
static void draw_screen(void)
{
  int i;

  erase();

  box(stdscr, '|', '-');

  for (i = 0; i < AMOUNT_OF_MONEY; i++)
    if (! money[i].taken)
      draw_object(&money[i]);
  for (i = 0; i < AMOUNT_OF_MINES; i++)
    draw_object(&mines[i]);
  for (i = 0; i < AMOUNT_OF_CRATES; i++)
    draw_object(&crates[i]);
  draw_object(&player);
  draw_object(&enemy);

  move(player.y, player.x);

  refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x2709(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1050
movq 0x26fa(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movl $0x7c, %edx
movl $0x2d, %r8d
xorl %r9d, %r9d
movl %edx, %esi
movl %r8d, %ecx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x1070
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0x1959
movslq -0x4(%rbp), %rcx
leaq 0x27c8(%rip), %rax      # 0x40f0
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x10(%rax)
jne 0x194c
movslq -0x4(%rbp), %rax
leaq 0x27b0(%rip), %rdi      # 0x40f0
imulq $0x14, %rax, %rax
addq %rax, %rdi
callq 0x1eb0
jmp 0x194e
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1917
movl $0x0, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jge 0x1988
movslq -0x4(%rbp), %rax
leaq 0x292f(%rip), %rdi      # 0x42a0
imulq $0x14, %rax, %rax
addq %rax, %rdi
callq 0x1eb0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1960
movl $0x0, -0x4(%rbp)
cmpl $0x5, -0x4(%rbp)
jge 0x19b7
movslq -0x4(%rbp), %rax
leaq 0x29d0(%rip), %rdi      # 0x4370
imulq $0x14, %rax, %rax
addq %rax, %rdi
callq 0x1eb0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x198f
leaq 0x2712(%rip), %rdi      # 0x40d0
callq 0x1eb0
leaq 0x28ba(%rip), %rdi      # 0x4284
callq 0x1eb0
movq 0x2602(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movl 0x26f1(%rip), %esi      # 0x40d0
movl 0x26ef(%rip), %edx      # 0x40d4
callq 0x1130
movq 0x25e7(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cgame/cgame.c
// Function: direction_to_player
static direction_t direction_to_player(void)
{
  int y, x;

  y = enemy.y - player.y;
  x = enemy.x - player.x;

  if ((x < 0) && ((x <= (-y)) || (x >= y)) &&
     ((x <= y)                || (x >= (-y))))
    return DIRECTION_RIGHT;
  if ((x > 0) && ((x <= y) || (x >= (-y))) &&
     ((x <= (-y))          || (x >= y)))
    return DIRECTION_LEFT;
  if (y > 0)
    return DIRECTION_UP;
  if (y < 0)
    return DIRECTION_DOWN;

  return DIRECTION_NONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x25ea(%rip), %eax      # 0x4284
subl 0x2430(%rip), %eax      # 0x40d0
movl %eax, -0x8(%rbp)
movl 0x25df(%rip), %eax      # 0x4288
subl 0x2425(%rip), %eax      # 0x40d4
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x1ce9
movl -0xc(%rbp), %eax
xorl %ecx, %ecx
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jle 0x1ccc
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x1ce9
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x1ce0
movl -0xc(%rbp), %eax
xorl %ecx, %ecx
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jl 0x1ce9
movl $0x2, -0x4(%rbp)
jmp 0x1d45
cmpl $0x0, -0xc(%rbp)
jle 0x1d20
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x1d03
movl -0xc(%rbp), %eax
xorl %ecx, %ecx
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jl 0x1d20
movl -0xc(%rbp), %eax
xorl %ecx, %ecx
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jle 0x1d17
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x1d20
movl $0x1, -0x4(%rbp)
jmp 0x1d45
cmpl $0x0, -0x8(%rbp)
jle 0x1d2f
movl $0x3, -0x4(%rbp)
jmp 0x1d45
cmpl $0x0, -0x8(%rbp)
jge 0x1d3e
movl $0x4, -0x4(%rbp)
jmp 0x1d45
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cgame/cgame.c
// Function: random_direction
static direction_t random_direction(void)
{
  switch (random() % 4) {
  case 0:
    return DIRECTION_LEFT;
  case 1:
    return DIRECTION_RIGHT;
  case 2:
    return DIRECTION_UP;
  case 3:
    return DIRECTION_DOWN;
  }
  return DIRECTION_NONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1100
movq %rax, %rdx
addq $0x3, %rdx
testq %rax, %rax
movq %rax, %rcx
cmovsq %rdx, %rcx
andq $-0x4, %rcx
subq %rcx, %rax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x1db7
movq -0x10(%rbp), %rax
leaq 0x35a(%rip), %rcx       # 0x20e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x1dbe
movl $0x2, -0x4(%rbp)
jmp 0x1dbe
movl $0x3, -0x4(%rbp)
jmp 0x1dbe
movl $0x4, -0x4(%rbp)
jmp 0x1dbe
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cgame/cgame.c
// Function: find_empty_spot
static void find_empty_spot(int *y, int *x)
{
  do {
    move((random() % (GAME_ROWS - 2)) + 1, (random() % (GAME_COLS - 2)) + 1);
  } while ((inch() & A_CHARTEXT) != ' ');
  getyx(stdscr, *y, *x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x21f1(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x1100
movl $0x16, %ecx
cqto
idivq %rcx
addq $0x1, %rdx
movl %edx, %eax
movl %eax, -0x14(%rbp)
callq 0x1100
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x4e, %ecx
cqto
idivq %rcx
addq $0x1, %rdx
callq 0x1130
movq 0x21ac(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1120
andl $0xff, %eax
cmpl $0x20, %eax
jne 0x1de0
xorl %eax, %eax
movq 0x2191(%rip), %rcx      # 0x3fd8
cmpq (%rcx), %rax
je 0x1e5e
movq 0x2185(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x1e68
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x24(%rbp)
jmp 0x1e68
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
movq 0x215e(%rip), %rcx      # 0x3fd8
cmpq (%rcx), %rax
je 0x1e92
movq 0x2152(%rip), %rax      # 0x3fd8
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x1e9c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rbp)
jmp 0x1e9c
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cgame/cgame.c
// Function: draw_object
static void draw_object(object_t *object)
{
  if (object->attributes != 0 && has_colors())
    wattrset(stdscr, object->attributes);
  mvaddch(object->y, object->x, object->symbol);
  if (object->attributes != 0 && has_colors())
    wattrset(stdscr, A_NORMAL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x1ee7
callq 0x1030
testb $0x1, %al
jne 0x1ed1
jmp 0x1ee7
movq 0x2100(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x1040
movq 0x20ea(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x1130
cmpl $-0x1, %eax
jne 0x1f0a
jmp 0x1f21
movq 0x20c7(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movsbl 0x8(%rax), %esi
callq 0x1140
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x1f47
callq 0x1030
testb $0x1, %al
jne 0x1f36
jmp 0x1f47
movq 0x209b(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/cgame/cgame.c
// Function: move_object_actual
static void move_object_actual(object_t *object, direction_t direction)
{
  switch (direction) {
  case DIRECTION_LEFT:
    object->x--;
    break;
  case DIRECTION_RIGHT:
    object->x++;
    break;
  case DIRECTION_UP:
    object->y--;
    break;
  case DIRECTION_DOWN:
    object->y++;
    break;
  default:
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x1fb7
movq -0x18(%rbp), %rax
leaq 0x17e(%rip), %rcx       # 0x20f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x1fb9
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x1fb9
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x1fb9
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1fb9
jmp 0x1fb9
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/mkptyfl.c
// Function: raw
int
raw(int fd)
{
	struct termios tio;
	if(tcgetattr(fd, &tio) < 0) return -1;
	tiosaved = tio;
	cfmakeraw(&tio);
	if(tcsetattr(fd, TCSAFLUSH, &tio) < 0) return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq -0x44(%rbp), %rsi
callq 0x1110
cmpl $0x0, %eax
jge 0x12b5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12f9
leaq 0x3248(%rip), %rdi      # 0x4504
leaq -0x44(%rbp), %rsi
movl $0x3c, %edx
callq 0x10e0
leaq -0x44(%rbp), %rdi
callq 0x10f0
movl -0x8(%rbp), %edi
movl $0x2, %esi
leaq -0x44(%rbp), %rdx
callq 0x1120
cmpl $0x0, %eax
jge 0x12f2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12f9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/mkptyfl.c
// Function: putfl
void
putfl(int c, int fd)
{
	char s[10];

	c = ucase*0100 + (c&0177);
	c = fl2ascii[c];
	switch(c){
	case -1: return;
	case FlColor:
		color = !color;
		if(color == 0){
			sprintf(s, "\e[39;49m");
			write(fd, s, 8);
		}else{
			sprintf(s, "\e[31m");
			write(fd, s, 5);
		}
		break;
	case FlStop:
		break;
	case FlUCase:
		ucase = 1;
		break;
	case FlLCase:
		ucase = 0;
		break;
	case FlNull:
		break;
	default:
		if(c == '\n'){
			s[0] = '\r';
			s[1] = '\n';
			write(fd, s, 2);
		}else{
			s[0] = c;
			write(fd, s, 1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x31dc(%rip), %eax      # 0x4540
shll $0x6, %eax
movl -0x4(%rbp), %ecx
andl $0x7f, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2d83(%rip), %rax      # 0x4100
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x6, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x1437
movq -0x20(%rbp), %rax
leaq 0xc61(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x1471
cmpl $0x0, 0x318c(%rip)      # 0x4544
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x317c(%rip)      # 0x4544
cmpl $0x0, 0x3175(%rip)      # 0x4544
jne 0x13f6
leaq -0x12(%rbp), %rdi
leaq 0xc40(%rip), %rsi       # 0x201c
movb $0x0, %al
callq 0x1160
movl -0x8(%rbp), %edi
leaq -0x12(%rbp), %rsi
movl $0x8, %edx
callq 0x1060
jmp 0x1419
leaq -0x12(%rbp), %rdi
leaq 0xc24(%rip), %rsi       # 0x2025
movb $0x0, %al
callq 0x1160
movl -0x8(%rbp), %edi
leaq -0x12(%rbp), %rsi
movl $0x5, %edx
callq 0x1060
jmp 0x1471
jmp 0x1471
movl $0x1, 0x3119(%rip)      # 0x4540
jmp 0x1471
movl $0x0, 0x310d(%rip)      # 0x4540
jmp 0x1471
jmp 0x1471
cmpl $0xa, -0x4(%rbp)
jne 0x1458
movb $0xd, -0x12(%rbp)
movb $0xa, -0x11(%rbp)
movl -0x8(%rbp), %edi
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq 0x1060
jmp 0x146f
movl -0x4(%rbp), %eax
movb %al, -0x12(%rbp)
movl -0x8(%rbp), %edi
leaq -0x12(%rbp), %rsi
movl $0x1, %edx
callq 0x1060
jmp 0x1471
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/mkptyfl.c
// Function: putascii
void
putascii(int c, int fd, int localfd)
{
	char s[2];
	int n;
	c = ascii2fl[c];
	if(c < 0)
		return;
	n = 0;
	if(c & 0300){
		if(c & 0100 && ucase)
			s[n++] = 075;
		else if(c & 0200 && !ucase)
			s[n++] = 071;
	}
	s[n++] = c & 077;
	write(fd, s, n);

// local echo
int i;
for(i = 0; i < n; i++)
	putfl(s[i], localfd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2e64(%rip), %rax      # 0x4300
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x14ad
jmp 0x1569
movl $0x0, -0x14(%rbp)
movl -0x4(%rbp), %eax
andl $0xc0, %eax
cmpl $0x0, %eax
je 0x1515
movl -0x4(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x14e9
cmpl $0x0, 0x306d(%rip)      # 0x4540
je 0x14e9
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
cltq
movb $0x3d, -0xe(%rbp,%rax)
jmp 0x1513
movl -0x4(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x1511
cmpl $0x0, 0x3043(%rip)      # 0x4540
jne 0x1511
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
cltq
movb $0x39, -0xe(%rbp,%rax)
jmp 0x1513
jmp 0x1515
movl -0x4(%rbp), %eax
andl $0x3f, %eax
movb %al, %cl
movl -0x14(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
cltq
movb %cl, -0xe(%rbp,%rax)
movl -0x8(%rbp), %edi
leaq -0xe(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1060
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1569
movslq -0x18(%rbp), %rax
movsbl -0xe(%rbp,%rax), %edi
movl -0xc(%rbp), %esi
callq 0x1350
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1545
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/mkptyfl.c
// Function: readwrite
void
readwrite(int ttyin, int ttyout, int ptyin, int ptyout)
{
	int n;
	struct pollfd pfd[2];
	char c;

	pfd[0].fd = ptyin;
	pfd[0].events = POLLIN;
	pfd[1].fd = ttyin;
	pfd[1].events = POLLIN;
	while(pfd[0].fd != -1){
		n = poll(pfd, 2, -1);
		if(n < 0){
			perror("error poll");
			return;
		}
		if(n == 0)
			return;
		if(pfd[0].revents & POLLHUP)
			nanosleep(&hupslp, NULL);
		/* read from pty, write to tty */
		if(pfd[0].revents & POLLIN){
			if(n = read(ptyin, &c, 1), n <= 0)
				return;
			else{
				c &= 077;
				putfl(c, ttyout);
				SLEEP;
			}
		}
		/* read from tty, write to pty */
		if(pfd[1].revents & POLLIN){
			if(n = read(ttyin, &c, 1), n <= 0)
				return;
			else{
				c &= 0177;	// needed?
				if(c == 035)
					return;
				putascii(c, ptyout, ttyout);
				SLEEP;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
movw $0x1, -0x2c(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x28(%rbp)
movw $0x1, -0x24(%rbp)
cmpl $-0x1, -0x30(%rbp)
je 0x168d
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1100
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x15d3
leaq 0xa62(%rip), %rdi       # 0x202b
callq 0x1140
jmp 0x168d
cmpl $0x0, -0x14(%rbp)
jne 0x15de
jmp 0x168d
movswl -0x2a(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x15fa
leaq 0x2aff(%rip), %rdi      # 0x40f0
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
movswl -0x2a(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x163a
movl -0xc(%rbp), %edi
leaq -0x31(%rbp), %rsi
movl $0x1, %edx
callq 0x10b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x1622
jmp 0x168d
movsbl -0x31(%rbp), %eax
andl $0x3f, %eax
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x1350
jmp 0x163a
movswl -0x22(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1688
movl -0x4(%rbp), %edi
leaq -0x31(%rbp), %rsi
movl $0x1, %edx
callq 0x10b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x1662
jmp 0x168d
movsbl -0x31(%rbp), %eax
andl $0x7f, %eax
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x1d, %eax
jne 0x1677
jmp 0x168d
movsbl -0x31(%rbp), %edi
movl -0x10(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x1480
jmp 0x1688
jmp 0x159c
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/mkptyfl.c
// Function: main
int
main(int argc, char *argv[])
{
	int fd;
	int slv;
	const char *ptylink;

	ptylink = NULL;
	if(argc > 1)
		ptylink = argv[1];

	fd = posix_openpt(O_RDWR);
	if(fd < 0)
		return 1;
	if(grantpt(fd) < 0)
		return 2;
	if(unlockpt(fd) < 0)
		return 3;

	if(ptylink){
		unlink(ptylink);
		if(symlink(ptsname(fd), ptylink) < 0)
			fprintf(stderr, "Error: %s\n", strerror(errno));
	}

	printf("%s\n", ptsname(fd));

	slv = open(ptsname(fd), O_RDWR);
	if(slv < 0)
		return 4;
	raw(slv);
	close(slv);

	raw(0);

	readwrite(0, 1, fd, fd);
	close(fd);

	printf("\e[39;49m");
	reset(0);

	if(ptylink)
		unlink(ptylink);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x16d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x2, %edi
callq 0x1180
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x16ef
movl $0x1, -0x4(%rbp)
jmp 0x181a
movl -0x14(%rbp), %edi
callq 0x1150
cmpl $0x0, %eax
jge 0x1708
movl $0x2, -0x4(%rbp)
jmp 0x181a
movl -0x14(%rbp), %edi
callq 0x10c0
cmpl $0x0, %eax
jge 0x1721
movl $0x3, -0x4(%rbp)
jmp 0x181a
cmpq $0x0, -0x20(%rbp)
je 0x177b
movq -0x20(%rbp), %rdi
callq 0x1050
movl -0x14(%rbp), %edi
callq 0x1030
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x1080
cmpl $0x0, %eax
jge 0x1779
movq 0x28a7(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1040
movl (%rax), %edi
callq 0x1170
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x8c4(%rip), %rsi       # 0x2036
movb $0x0, %al
callq 0x10d0
jmp 0x177b
movl -0x14(%rbp), %edi
callq 0x1030
movq %rax, %rsi
leaq 0x8b0(%rip), %rdi       # 0x203d
movb $0x0, %al
callq 0x1070
movl -0x14(%rbp), %edi
callq 0x1030
movq %rax, %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x1130
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x17bd
movl $0x4, -0x4(%rbp)
jmp 0x181a
movl -0x18(%rbp), %edi
callq 0x1290
movl -0x18(%rbp), %edi
callq 0x10a0
xorl %edi, %edi
callq 0x1290
movl -0x14(%rbp), %edx
movl -0x14(%rbp), %ecx
xorl %edi, %edi
movl $0x1, %esi
callq 0x1570
movl -0x14(%rbp), %edi
callq 0x10a0
leaq 0x827(%rip), %rdi       # 0x201c
movb $0x0, %al
callq 0x1070
xorl %edi, %edi
callq 0x1310
cmpq $0x0, -0x20(%rbp)
je 0x1813
movq -0x20(%rbp), %rdi
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/s3/main.c
// Function: readtests
static void
readtests(struct wire_requestqueue * Q, const char * bucket)
{

	/* GET with a large buffer. */
	opdone = 0;
	if (proto_s3_request_get(Q, bucket, "s3-testfile", 100,
	    callback_get, NULL) ||
	    events_spin(&opdone)) {
		warn0("GET failed");
		exit(1);
	}

	/* GET with a small buffer. */
	opdone = 0;
	if (proto_s3_request_get(Q, bucket, "s3-testfile", 10,
	    callback_get, NULL) ||
	    events_spin(&opdone)) {
		warn0("GET failed");
		exit(1);
	}

	/* RANGE. */
	opdone = 0;
	if (proto_s3_request_range(Q, bucket, "s3-testfile", 6, 5,
	    callback_range, NULL) ||
	    events_spin(&opdone)) {
		warn0("RANGE failed");
		exit(1);
	}

	/* HEAD. */
	opdone = 0;
	if (proto_s3_request_head(Q, bucket, "s3-testfile",
	    callback_head, NULL) ||
	    events_spin(&opdone)) {
		warn0("HEAD failed");
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, 0x10f0a(%rip)     # 0x13574
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0xb9de(%rip), %rdx      # 0xe057
movl $0x64, %ecx
leaq 0x2ab(%rip), %r8        # 0x2930
xorl %eax, %eax
movl %eax, %r9d
callq 0x55c0
cmpl $0x0, %eax
jne 0x26a5
leaq 0x10ed9(%rip), %rdi     # 0x13574
callq 0x2dc0
cmpl $0x0, %eax
je 0x26ca
jmp 0x26a7
leaq 0xb9b5(%rip), %rdi      # 0xe063
movb $0x0, %al
callq 0x4fd0
callq 0x20a0
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x22d0
movl $0x0, 0x10ea0(%rip)     # 0x13574
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0xb974(%rip), %rdx      # 0xe057
movl $0xa, %ecx
leaq 0x241(%rip), %r8        # 0x2930
xorl %eax, %eax
movl %eax, %r9d
callq 0x55c0
cmpl $0x0, %eax
jne 0x270f
leaq 0x10e6f(%rip), %rdi     # 0x13574
callq 0x2dc0
cmpl $0x0, %eax
je 0x2734
jmp 0x2711
leaq 0xb94b(%rip), %rdi      # 0xe063
movb $0x0, %al
callq 0x4fd0
callq 0x20a0
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x22d0
movl $0x0, 0x10e36(%rip)     # 0x13574
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0xb90a(%rip), %rdx      # 0xe057
movl $0x6, %ecx
movl $0x5, %r8d
leaq 0x261(%rip), %r9        # 0x29c0
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x59b0
cmpl $0x0, %eax
jne 0x2784
leaq 0x10dfa(%rip), %rdi     # 0x13574
callq 0x2dc0
cmpl $0x0, %eax
je 0x27a9
jmp 0x2786
leaq 0xb8e1(%rip), %rdi      # 0xe06e
movb $0x0, %al
callq 0x4fd0
callq 0x20a0
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x22d0
movl $0x0, 0x10dc1(%rip)     # 0x13574
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0xb895(%rip), %rdx      # 0xe057
leaq 0x287(%rip), %rcx       # 0x2a50
xorl %eax, %eax
movl %eax, %r8d
callq 0x5de0
cmpl $0x0, %eax
jne 0x27e9
leaq 0x10d95(%rip), %rdi     # 0x13574
callq 0x2dc0
cmpl $0x0, %eax
je 0x280e
jmp 0x27eb
leaq 0xb889(%rip), %rdi      # 0xe07b
movb $0x0, %al
callq 0x4fd0
callq 0x20a0
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x22d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/s3/main.c
// Function: putfile
static void
putfile(struct wire_requestqueue * Q, const char * bucket)
{

	/* PUT the object. */
	opdone = 0;
	if (proto_s3_request_put(Q, bucket, "s3-testfile", 11,
	    (const uint8_t *)"hello world", callback_put, NULL) ||
	    events_spin(&opdone)) {
		warn0("PUT failed");
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, 0x10d3a(%rip)     # 0x13574
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0xb80e(%rip), %rdx      # 0xe057
movl $0xb, %ecx
leaq 0xb8d2(%rip), %r8       # 0xe127
leaq 0x234(%rip), %r9        # 0x2a90
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x5210
cmpl $0x0, %eax
jne 0x2881
leaq 0x10cfd(%rip), %rdi     # 0x13574
callq 0x2dc0
cmpl $0x0, %eax
je 0x28a6
jmp 0x2883
leaq 0xb8a9(%rip), %rdi      # 0xe133
movb $0x0, %al
callq 0x4fd0
callq 0x20a0
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x22d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/s3/main.c
// Function: deletefile
static void
deletefile(struct wire_requestqueue * Q, const char * bucket)
{

	/* DELETE the object. */
	opdone = 0;
	if (proto_s3_request_delete(Q, bucket, "s3-testfile",
	    callback_delete, NULL) ||
	    events_spin(&opdone)) {
		warn0("DELETE failed");
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, 0x10caa(%rip)     # 0x13574
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0xb77e(%rip), %rdx      # 0xe057
leaq 0x1f0(%rip), %rcx       # 0x2ad0
xorl %eax, %eax
movl %eax, %r8d
callq 0x60d0
cmpl $0x0, %eax
jne 0x2900
leaq 0x10c7e(%rip), %rdi     # 0x13574
callq 0x2dc0
cmpl $0x0, %eax
je 0x2925
jmp 0x2902
leaq 0xb846(%rip), %rdi      # 0xe14f
movb $0x0, %al
callq 0x4fd0
callq 0x20a0
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x22d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/s3/main.c
// Function: callback_get
static int
callback_get(void * cookie, int failed, size_t len, const uint8_t * buf)
{

	(void)cookie; /* UNUSED */

	/* Print status. */
	printf("GET failed = %d len = %zd\n", failed, (ssize_t)len);

	/* Print data. */
	if (buf != NULL) {
		printf("GET data = >>>");
		fwrite(buf, len, 1, stdout);
		printf("<<<\n");
	} else {
		printf("GET data = NULL\n");
	}

	/* We're done. */
	opdone = 1;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0xb732(%rip), %rdi      # 0xe087
movb $0x0, %al
callq 0x2150
cmpq $0x0, -0x20(%rbp)
je 0x299d
leaq 0xb738(%rip), %rdi      # 0xe0a2
movb $0x0, %al
callq 0x2150
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x10650(%rip), %rax     # 0x12fd0
movq (%rax), %rcx
movl $0x1, %edx
callq 0x22f0
leaq 0xb71d(%rip), %rdi      # 0xe0b1
movb $0x0, %al
callq 0x2150
jmp 0x29ab
leaq 0xb712(%rip), %rdi      # 0xe0b6
movb $0x0, %al
callq 0x2150
movl $0x1, 0x10bbf(%rip)     # 0x13574
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/s3/main.c
// Function: callback_range
static int
callback_range(void * cookie, int failed, size_t buflen, const uint8_t * buf)
{

	(void)cookie; /* UNUSED */

	/* Print status. */
	printf("RANGE failed = %d buflen = %zd\n", failed, (ssize_t)buflen);

	/* Print data. */
	if (buf != NULL) {
		printf("RANGE data = >>>");
		fwrite(buf, buflen, 1, stdout);
		printf("<<<\n");
	} else {
		printf("RANGE data = NULL\n");
	}

	/* We're done. */
	opdone = 1;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0xb6e2(%rip), %rdi      # 0xe0c7
movb $0x0, %al
callq 0x2150
cmpq $0x0, -0x20(%rbp)
je 0x2a2d
leaq 0xb6ed(%rip), %rdi      # 0xe0e7
movb $0x0, %al
callq 0x2150
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x105c0(%rip), %rax     # 0x12fd0
movq (%rax), %rcx
movl $0x1, %edx
callq 0x22f0
leaq 0xb68d(%rip), %rdi      # 0xe0b1
movb $0x0, %al
callq 0x2150
jmp 0x2a3b
leaq 0xb6c4(%rip), %rdi      # 0xe0f8
movb $0x0, %al
callq 0x2150
movl $0x1, 0x10b2f(%rip)     # 0x13574
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_03/strcat.c
// Function: main
int main(void)
{
  char s[100] = "This is the first string";
  char t[] = ", this second string!";

  strcat_ptr(s, t);

  puts(s);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0xea3(%rip), %rsi       # 0x2010
movl $0x64, %edx
callq 0x1040
movq 0xf02(%rip), %rax       # 0x2080
movq %rax, -0x90(%rbp)
movq 0xefc(%rip), %rax       # 0x2088
movq %rax, -0x88(%rbp)
movl 0xef7(%rip), %eax       # 0x2090
movl %eax, -0x80(%rbp)
movw 0xef1(%rip), %ax        # 0x2094
movw %ax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x11d0
leaq -0x70(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_03/strcat.c
// Function: strcat_ptr
void strcat_ptr(char *s, char *t)
{
  // Find the end of s
  while (*s)
      ++s;

  // copy t to the end of s
  while (*s++ = *t++)
    ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x11f3
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x11dc
jmp 0x11f5
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %al, (%rcx)
cmpb $0x0, %al
je 0x121d
jmp 0x11f5
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/dcshift/dcshift.c
// Function: writeCommentOut
void writeCommentOut(FILE *in, FILE *out)
    {
    int ch;

    while((ch = fgetc(in)) && (ch != EOF) && ch != '\n')
        {
        fprintf(out,"%c",ch);

        continue;
        }
    fprintf(out,"\n");      
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10c0
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x135d
xorl %eax, %eax
cmpl $-0x1, -0x14(%rbp)
movb %al, -0x15(%rbp)
je 0x135d
cmpl $0xa, -0x14(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1366
jmp 0x137d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x3c9d(%rip), %rsi      # 0x5011
movb $0x0, %al
callq 0x1110
jmp 0x1330
movq -0x10(%rbp), %rdi
leaq 0x40e1(%rip), %rsi      # 0x5469
movb $0x0, %al
callq 0x1110
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/dcshift/dcshift.c
// Function: commentHandler
static void commentHandler(FILE *in, FILE *out)
    {
    int ch, count = 0;
    char s[512] = "";

    char *token = NULL;

    ch = fgetc(in);

    if(ch == 'a')
        {

        while(ch != '\n')
            {
            s[count++] = ch;
            ch = fgetc(in);
            }

        s[count] = '\0';

        token = strtok(s," ");

        fprintf(stderr,"%s\n",token);

        token = strtok(NULL, " ");

        fprintf(stderr,"%s\n",token);

        attenuation = (float)atoi(token);

        }
    else
        {
        ungetc(ch,in);
        outputComment(in,out);
        }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x220(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x10b0
movq $0x0, -0x228(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10c0
movl %eax, -0x14(%rbp)
cmpl $0x61, -0x14(%rbp)
jne 0x1896
jmp 0x17d0
cmpl $0xa, -0x14(%rbp)
je 0x17fd
movl -0x14(%rbp), %eax
movb %al, %cl
movl -0x18(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
cltq
movb %cl, -0x220(%rbp,%rax)
movq -0x8(%rbp), %rdi
callq 0x10c0
movl %eax, -0x14(%rbp)
jmp 0x17d0
movslq -0x18(%rbp), %rax
movb $0x0, -0x220(%rbp,%rax)
leaq -0x220(%rbp), %rdi
leaq 0x3c3d(%rip), %rsi      # 0x5454
callq 0x11a0
movq %rax, -0x228(%rbp)
movq 0x67ce(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x228(%rbp), %rdx
leaq 0x3c3c(%rip), %rsi      # 0x5477
movb $0x0, %al
callq 0x1110
xorl %eax, %eax
movl %eax, %edi
leaq 0x3c07(%rip), %rsi      # 0x5454
callq 0x11a0
movq %rax, -0x228(%rbp)
movq 0x6798(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x228(%rbp), %rdx
leaq 0x3c06(%rip), %rsi      # 0x5477
movb $0x0, %al
callq 0x1110
movq -0x228(%rbp), %rdi
callq 0x11d0
cvtsi2ss %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x689c(%rip)     # 0x8130
jmp 0x18af
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x1160
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x37d0
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/MD.c
// Function: main
int main(int argc, char* argv[]){
    char lines[argc+1][255];
    predealLine(argc, argv, lines);
    if(strcmp(lines[0],"MD")==0||strcmp(lines[0],"md")==0){
        for(int i=1;i<argc;i++){
            if(access(lines[i],R_OK)){
                char cm[255]="./";
                strcat(cm, lines[i]);
                mkdir(lines[i],S_IRWXU|S_IRGRP|S_IROTH);
            }
            else{
                printf("%s", lines[0]);
                printf("不能创建文件夹: %s :\n", lines[i]);
                printf("文件已经存在或权限不允许!\n");
            }
        }
    }
    else{
        printf("%s: ", lines[0]);
        printf("error\n");
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %rdx    # imm = 0x1FFFFFFFFF0
andq %rdx, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x138(%rbp)
movq %rdx, %rsp
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x11c0
movq -0x138(%rbp), %rdi
leaq 0xc36(%rip), %rsi       # 0x2004
callq 0x1070
cmpl $0x0, %eax
je 0x13f4
movq -0x138(%rbp), %rdi
leaq 0xc21(%rip), %rsi       # 0x2007
callq 0x1070
cmpl $0x0, %eax
jne 0x14e6
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x14e4
movq -0x138(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0xff, %rax, %rax
addq %rax, %rdi
movl $0x4, %esi
callq 0x1090
cmpl $0x0, %eax
je 0x148e
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
movl $0xff, %edx
callq 0x1060
movq -0x138(%rbp), %rsi
movb $0x2e, -0x130(%rbp)
movb $0x2f, -0x12f(%rbp)
leaq -0x130(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0xff, %rax, %rax
addq %rax, %rsi
callq 0x10a0
movq -0x138(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0xff, %rax, %rax
addq %rax, %rdi
movl $0x1e4, %esi            # imm = 0x1E4
callq 0x1030
jmp 0x14d4
movq -0x138(%rbp), %rsi
leaq 0xb6e(%rip), %rdi       # 0x200a
movb $0x0, %al
callq 0x1050
movq -0x138(%rbp), %rsi
movslq -0x24(%rbp), %rax
imulq $0xff, %rax, %rax
addq %rax, %rsi
leaq 0xb4e(%rip), %rdi       # 0x200d
movb $0x0, %al
callq 0x1050
leaq 0xb5d(%rip), %rdi       # 0x202a
movb $0x0, %al
callq 0x1050
jmp 0x14d6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x13fb
jmp 0x1509
movq -0x138(%rbp), %rsi
leaq 0xb5d(%rip), %rdi       # 0x2051
movb $0x0, %al
callq 0x1050
leaq 0xb54(%rip), %rdi       # 0x2056
movb $0x0, %al
callq 0x1050
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/aes.c
// Function: aes_crypt_ctr
int aes_crypt_ctr(aes_context *ctx,
        size_t length,
        size_t *nc_off,
        unsigned char nonce_counter[16],
        unsigned char stream_block[16],
        const unsigned char *input,
        unsigned char *output) {
    int c, i, cb;
    size_t n = *nc_off;

    while (length--) {
        if (n == 0) {
            aes_crypt_ecb(ctx, AES_ENCRYPT, nonce_counter, stream_block);

            i = 15;
            do {
                nonce_counter[i]++;
                cb = nonce_counter[i] == 0;
            } while (i-- && cb);

        }
        c = *input++;
        *output++ = (unsigned char) (c ^ stream_block[n]);

        n = (n + 1) & 0x0F;
    }

    *nc_off = n;

    return ( 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0x316d
cmpq $0x0, -0x48(%rbp)
jne 0x311f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x1be0
movl $0xf, -0x38(%rbp)
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
addb $0x1, %dl
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
je 0x3116
cmpl $0x0, -0x3c(%rbp)
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x30cc
jmp 0x311f
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %cl
movq 0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rbp)
movb %cl, (%rax)
movq -0x48(%rbp), %rax
addq $0x1, %rax
andq $0xf, %rax
movq %rax, -0x48(%rbp)
jmp 0x308f
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/sha1.c
// Function: sha1_starts
void sha1_starts(sha1_context *ctx) {
    ctx->total[0] = 0;
    ctx->total[1] = 0;

    ctx->state[0] = 0x67452301;
    ctx->state[1] = 0xEFCDAB89;
    ctx->state[2] = 0x98BADCFE;
    ctx->state[3] = 0x10325476;
    ctx->state[4] = 0xC3D2E1F0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x67452301, 0x10(%rax) # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, %ecx       # imm = 0xEFCDAB89
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x98badcfe, %ecx       # imm = 0x98BADCFE
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x10325476, 0x28(%rax) # imm = 0x10325476
movq -0x8(%rbp), %rax
movl $0xc3d2e1f0, %ecx       # imm = 0xC3D2E1F0
movq %rcx, 0x30(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/sha1.c
// Function: sha1_update
void sha1_update(sha1_context *ctx, const unsigned char *input, size_t ilen) {
    size_t fill;
    unsigned long left;

    if (ilen <= 0)
        return;

    left = ctx->total[0] & 0x3F;
    fill = 64 - left;

    ctx->total[0] += (unsigned long) ilen;
    ctx->total[0] &= 0xFFFFFFFF;

    if (ctx->total[0] < (unsigned long) ilen)
        ctx->total[1]++;

    if (left && ilen >= fill) {
        memcpy((void *) (ctx->buffer + left),
                (void *) input, fill);
        sha1_process(ctx, ctx->buffer);
        input += fill;
        ilen -= fill;
        left = 0;
    }

    while (ilen >= 64) {
        sha1_process(ctx, input);
        input += 64;
        ilen -= 64;
    }

    if (ilen > 0) {
        memcpy((void *) (ctx->buffer + left),
                (void *) input, ilen);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
ja 0x3200
jmp 0x3309
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
movq %rax, -0x28(%rbp)
movl $0x40, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x325b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x32b9
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x32b9
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10e0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
callq 0x3310
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
jmp 0x32bb
cmpq $0x40, -0x18(%rbp)
jb 0x32e9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3310
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
subq $0x40, %rax
movq %rax, -0x18(%rbp)
jmp 0x32bb
cmpq $0x0, -0x18(%rbp)
jbe 0x3309
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/sha1.c
// Function: sha1
void sha1(const unsigned char *input, size_t ilen, unsigned char output[20]) {
    sha1_context ctx;

    sha1_starts(&ctx);
    sha1_update(&ctx, input, ilen);
    sha1_finish(&ctx, output);

    memset(&ctx, 0, sizeof ( sha1_context));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x3180
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x110(%rbp), %rdi
callq 0x31e0
movq -0x18(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x6ff0
leaq -0x110(%rbp), %rdi
xorl %esi, %esi
movl $0xf8, %edx
callq 0x1090
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/sha1.c
// Function: sha1_hmac_starts
void sha1_hmac_starts(sha1_context *ctx, const unsigned char *key, size_t keylen) {
    size_t i;
    unsigned char sum[20];

    if (keylen > 64) {
        sha1(key, keylen, sum);
        keylen = 20;
        key = sum;
    }

    memset(ctx->ipad, 0x36, 64);
    memset(ctx->opad, 0x5C, 64);

    for (i = 0; i < keylen; i++) {
        ctx->ipad[i] = (unsigned char) (ctx->ipad[i] ^ key[i]);
        ctx->opad[i] = (unsigned char) (ctx->opad[i] ^ key[i]);
    }

    sha1_starts(ctx);
    sha1_update(ctx, ctx->ipad, 64);

    memset(sum, 0, sizeof ( sum));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x40, -0x18(%rbp)
jbe 0x732c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x7280
movq $0x14, -0x18(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movl $0x36, %esi
movl $0x40, %edx
callq 0x1090
movq -0x8(%rbp), %rdi
addq $0xb8, %rdi
movl $0x5c, %esi
movl $0x40, %edx
callq 0x1090
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x73d5
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl 0x78(%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, 0x78(%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl 0xb8(%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, 0xb8(%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7365
movq -0x8(%rbp), %rdi
callq 0x3180
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x78, %rsi
movl $0x40, %edx
callq 0x31e0
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x1090
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/sha1.c
// Function: sha1_hmac_finish
void sha1_hmac_finish(sha1_context *ctx, unsigned char output[20]) {
    unsigned char tmpbuf[20];

    sha1_finish(ctx, tmpbuf);
    sha1_starts(ctx);
    sha1_update(ctx, ctx->opad, 64);
    sha1_update(ctx, tmpbuf, 20);
    sha1_finish(ctx, output);

    memset(tmpbuf, 0, sizeof ( tmpbuf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6ff0
movq -0x8(%rbp), %rdi
callq 0x3180
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xb8, %rsi
movl $0x40, %edx
callq 0x31e0
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x14, %edx
callq 0x31e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6ff0
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x1090
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/sha1.c
// Function: sha1_hmac
void sha1_hmac(const unsigned char *key, size_t keylen,
        const unsigned char *input, size_t ilen,
        unsigned char output[20]) {
    sha1_context ctx;

    sha1_hmac_starts(&ctx, key, keylen);
    sha1_hmac_update(&ctx, input, ilen);
    sha1_hmac_finish(&ctx, output);

    memset(&ctx, 0, sizeof ( sha1_context));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x120(%rbp), %rdi
callq 0x72f0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x120(%rbp), %rdi
callq 0x7410
movq -0x28(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x7440
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0xf8, %edx
callq 0x1090
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/des.c
// Function: des_key_check_key_parity
int des_key_check_key_parity(const unsigned char key[DES_KEY_SIZE]) {
    int i;

    for (i = 0; i < DES_KEY_SIZE; i++)
        if (key[i] != odd_parity_table[key[i] / 2])
            return ( 1);

    return ( 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x7635
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
movslq %ecx, %rdx
leaq 0x8c89(%rip), %rcx      # 0x102a0
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x7628
movl $0x1, -0x4(%rbp)
jmp 0x763c
jmp 0x762a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x75df
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/des.c
// Function: des_key_check_weak
int des_key_check_weak(const unsigned char key[DES_KEY_SIZE]) {
    int i;

    for (i = 0; i < WEAK_KEY_COUNT; i++)
        if (memcmp(weak_key_table[i], key, DES_KEY_SIZE) == 0)
            return ( 1);

    return ( 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x76a5
movslq -0x14(%rbp), %rcx
leaq 0x8cb0(%rip), %rax      # 0x10320
shlq $0x3, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rax), %rax
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x7698
movl $0x1, -0x4(%rbp)
jmp 0x76ac
jmp 0x769a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x765f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/des.c
// Function: des_setkey_dec
int des_setkey_dec(des_context *ctx, const unsigned char key[DES_KEY_SIZE]) {
    int i;

    des_setkey(ctx->sk, key);

    for (i = 0; i < 16; i += 2) {
        SWAP(ctx->sk[i ], ctx->sk[30 - i]);
        SWAP(ctx->sk[i + 1], ctx->sk[31 - i]);
    }

    return ( 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
callq 0x76f0
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x7d20
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x1e, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movl 0x4(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, 0x4(%rax,%rcx,4)
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movl $0x1e, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, 0x4(%rax,%rcx,4)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl $0x1f, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movl 0x4(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, 0x4(%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl $0x1f, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, 0x4(%rax,%rcx,4)
movl $0x0, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x7c68
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zecoxao[P]ps3_decrypt_tools/lib/des.c
// Function: des3_set2key_enc
int des3_set2key_enc(des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 2]) {
    uint32_t sk[96];

    des3_set2key(ctx->sk, sk, key);
    memset(sk, 0, sizeof ( sk));

    return ( 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
leaq -0x190(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x7d80
leaq -0x190(%rbp), %rdi
xorl %esi, %esi
movl $0x180, %edx            # imm = 0x180
callq 0x1090
xorl %eax, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopl (%rax)