LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/datastruct/doubleheap.c
// Function: doubleheap_free
void
doubleheap_free(struct doubleheap * H)
{

	/* Behave consistently with free(NULL). */
	if (H == NULL)
		return;

	doublelist_free(H->elems);
	free(H);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2d05
jmp 0x2d1a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2d20
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/7-Threading/pthread_game.c
// Function: read_input
void * read_input(void *nothing)
{
	int c;

	while(1)
	{
		if( (c = getchar()) == 0 )
		{
			printf("End of input. Bye\n");
			exit(1);
		}

		pthread_mutex_lock(&mutex);
		if(c != '\n')
		{
			global_input = c;
			while( getchar() != '\n');
		}
		pthread_cond_signal(&input_cond);
		pthread_mutex_unlock(&mutex);
	}
	pthread_exit(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1070
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x1261
leaq 0xdb4(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x10d0
leaq 0x2e50(%rip), %rdi      # 0x40b8
callq 0x1100
cmpl $0xa, -0xc(%rbp)
je 0x128a
movl -0xc(%rbp), %eax
movl %eax, 0x2e34(%rip)      # 0x40b0
callq 0x1070
cmpl $0xa, %eax
je 0x1288
jmp 0x127c
jmp 0x128a
leaq 0x2e4f(%rip), %rdi      # 0x40e0
callq 0x1060
leaq 0x2e1b(%rip), %rdi      # 0x40b8
callq 0x1090
jmp 0x123c
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/7-Threading/pthread_game.c
// Function: all_the_same
int all_the_same(int dice[])
{
	int i;
	for(i = 0; i < DICE_COUNT-1; i++)
		if(dice[i] != dice[i+1])
			break;

	if(i != DICE_COUNT-1)	// dice are not the same.
		return 0;
	else
		return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x12f1
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x12e4
jmp 0x12f1
jmp 0x12e6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12bf
cmpl $0x2, -0x14(%rbp)
je 0x1300
movl $0x0, -0x4(%rbp)
jmp 0x1307
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/7-Threading/pthread_game.c
// Function: display
void display(int dice[], int life, int point, int level)
{
	int i;
	system("clear");
	printf("+---+---+---+\n");
	for(i = 0; i < DICE_COUNT; i++)
		printf("| %d ", dice[i]);
	printf("|\n");
	printf("+---+---+---+\n");
	printf("[LIFE LEFT: %d]\t[POINTS: %2d]\t[LEVEL: %2d]\t[B/S/N]? ", life-1, point, level+1);
	fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
leaq 0xceb(%rip), %rdi       # 0x2017
callq 0x1030
leaq 0xce5(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1040
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0x1370
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xcce(%rip), %rdi       # 0x202c
movb $0x0, %al
callq 0x1040
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1346
leaq 0xcbb(%rip), %rdi       # 0x2032
movb $0x0, %al
callq 0x1040
leaq 0xc98(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1040
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
leaq 0xc93(%rip), %rdi       # 0x2035
movb $0x0, %al
callq 0x1040
movq 0x2c30(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/7-Threading/pthread_game.c
// Function: wait_for_input
int wait_for_input(int level)
{
	int wait_ret, input, timeout;
	struct timespec t;

	timeout = TIMEOUT_INIT - level;
	if(timeout < TIMEOUT_MIN)
		timeout = TIMEOUT_MIN;

	t.tv_sec = time(NULL) + timeout;
	t.tv_nsec = 0;

	pthread_mutex_lock(&mutex);

		if(global_input == 0)
		{
			wait_ret = pthread_cond_timedwait(&input_cond, &mutex, &t);
			if(wait_ret == ETIMEDOUT)
			{
				input = 0;
				sleep(1);
			}
			else
			{
				input = global_input;
			}
		}
		else
			input = global_input;

		global_input = 0;

	pthread_mutex_unlock(&mutex);

	return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x8, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x2, -0x10(%rbp)
jge 0x13e3
movl $0x2, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1080
movslq -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x2cb2(%rip), %rdi      # 0x40b8
callq 0x1100
cmpl $0x0, 0x2c9e(%rip)      # 0x40b0
jne 0x1452
leaq 0x2cc5(%rip), %rdi      # 0x40e0
leaq 0x2c96(%rip), %rsi      # 0x40b8
leaq -0x20(%rbp), %rdx
callq 0x10c0
movl %eax, -0x8(%rbp)
cmpl $0x6e, -0x8(%rbp)
jne 0x1447
movl $0x0, -0xc(%rbp)
movl $0x1, %edi
callq 0x10f0
jmp 0x1450
movl 0x2c63(%rip), %eax      # 0x40b0
movl %eax, -0xc(%rbp)
jmp 0x145b
movl 0x2c58(%rip), %eax      # 0x40b0
movl %eax, -0xc(%rbp)
movl $0x0, 0x2c4b(%rip)      # 0x40b0
leaq 0x2c4c(%rip), %rdi      # 0x40b8
callq 0x1090
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/7-Threading/pthread_game.c
// Function: display_intro
void display_intro()
{
	system("clear");
	printf(
		"BIG or SMALL\n"
		"------------\n\n"
		"- Three dices are thrown;\n"
		"- If their sum is less than 11, then type 's' (for small);\n"
		"- If their sum is greater than or equal to 11, then type 'b' (for big);\n"
		"- However, if three of them are the same, then type 'n' (for none);\n\n"
		"- You only have a limited time to input your answer;\n"
		"- Higher the score is, the faster the timeout becomes;\n\n"
		"Press enter to start the game. "
	);
	fflush(stdout);
	while(getchar() != '\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9ac(%rip), %rdi       # 0x2017
callq 0x1030
leaq 0xa1f(%rip), %rdi       # 0x2096
movb $0x0, %al
callq 0x1040
movq 0x295b(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10a0
callq 0x1070
cmpl $0xa, %eax
je 0x1699
jmp 0x168d
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/7-Threading/pthread_game.c
// Function: main
int main(void)
{
	pthread_t tid1, tid2;
	display_intro();
	pthread_create(&tid1, NULL, read_input, NULL);
	pthread_create(&tid2, NULL, game_play, NULL);
	pthread_join(tid1, NULL);
	pthread_join(tid2, NULL);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1660
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x493(%rip), %rdx      # 0x1230
movq %rcx, %rsi
callq 0x10b0
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x25a(%rip), %rdx      # 0x1480
movq %rcx, %rsi
callq 0x10b0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10e0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10e0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/lock2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	int fd = open(tmpfile, O_RDWR);

	assert(fd >= 0);

	while (1) {
		struct flock lck;

		lck.l_type = F_WRLCK;
		lck.l_whence = SEEK_SET;
		lck.l_start = 0;
		lck.l_len = 1;
		assert(fcntl(fd, F_SETLKW, &lck) == 0);

		lck.l_type = F_UNLCK;
		lck.l_whence = SEEK_SET;
		lck.l_start = 0;
		lck.l_len = 1;
		assert(fcntl(fd, F_SETLKW, &lck) == 0);

		(*iterations) += 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x30e9(%rip), %rdi      # 0x5180
movl $0x2, %esi
movb $0x0, %al
callq 0x1210
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x20ae
jmp 0x20cd
leaq 0x1209(%rip), %rdi      # 0x32be
leaq 0x11cf(%rip), %rsi      # 0x328b
movl $0x14, %edx
leaq 0x11fe(%rip), %rcx      # 0x32c6
callq 0x1130
jmp 0x20cf
movw $0x1, -0x38(%rbp)
movw $0x0, -0x36(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x1, -0x28(%rbp)
movl -0x14(%rbp), %edi
movl $0x7, %esi
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x10c0
cmpl $0x0, %eax
jne 0x2105
jmp 0x2124
leaq 0x11ed(%rip), %rdi      # 0x32f9
leaq 0x1178(%rip), %rsi      # 0x328b
movl $0x1d, %edx
leaq 0x11a7(%rip), %rcx      # 0x32c6
callq 0x1130
movw $0x2, -0x38(%rbp)
movw $0x0, -0x36(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x1, -0x28(%rbp)
movl -0x14(%rbp), %edi
movl $0x7, %esi
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x10c0
cmpl $0x0, %eax
jne 0x215a
jmp 0x2179
leaq 0x1198(%rip), %rdi      # 0x32f9
leaq 0x1123(%rip), %rsi      # 0x328b
movl $0x23, %edx
leaq 0x1152(%rip), %rcx      # 0x32c6
callq 0x1130
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x20cf
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/plasma.c
// Function: main
int main(int arcg, char *argv[]) {
    scg_config_t config = scg_config_new_default();
    config.video.title = "SCG Example: Plasma";

    scg_app_t app;
    scg_app_init(&app, config);

    scg_image_t *plasma_buffer =
        scg_image_new(PLASMA_BUFFER_WIDTH, PLASMA_BUFFER_HEIGHT);
    if (plasma_buffer == NULL) {
        return -1;
    }

    while (scg_app_process_events(&app)) {
        draw_plasma(plasma_buffer, app.elapsed_time);
        draw(app.draw_target, plasma_buffer, app.elapsed_time);

        scg_app_present(&app);
    }

    scg_image_free(plasma_buffer);
    scg_app_free(&app);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x49f0
leaq 0xeab(%rip), %rax       # 0x75c4
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xa0(%rbp), %rdi
callq 0x4a40
movl $0x80, %esi
movl %esi, %edi
callq 0x2b10
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x6769
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67d6
jmp 0x676b
leaq -0xa0(%rbp), %rdi
callq 0x56c0
testb $0x1, %al
jne 0x677d
jmp 0x67b7
movq -0xa8(%rbp), %rdi
movss -0x98(%rbp), %xmm0
callq 0x67f0
movq -0x68(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movss -0x98(%rbp), %xmm0
callq 0x6bb0
leaq -0xa0(%rbp), %rdi
callq 0x5810
jmp 0x676b
movq -0xa8(%rbp), %rdi
callq 0x4680
leaq -0xa0(%rbp), %rdi
callq 0x5cc0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/plasma.c
// Function: draw
static void draw(scg_image_t *draw_target, scg_image_t *plasma_buffer,
                 float32_t elapsed_time) {
    scg_image_clear(draw_target, SCG_COLOR_WHITE);

    int w = draw_target->width;
    int h = draw_target->height;
    int x = w / 2 - PLASMA_BUFFER_WIDTH / 2;
    int y = h / 2 - PLASMA_BUFFER_HEIGHT / 2;
    scg_image_draw_image_rotate(draw_target, plasma_buffer, x, y, elapsed_time);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movb $-0x1, -0x18(%rbp)
movb $-0x1, -0x17(%rbp)
movb $-0x1, -0x16(%rbp)
movb $-0x1, -0x15(%rbp)
movl -0x18(%rbp), %esi
callq 0x3110
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl $0x40, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl $0x40, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movss -0x14(%rbp), %xmm0
callq 0x31f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/2mg.cc
// Function: parse_opt(int, char*, argp_state*)
static error_t parse_opt(int key, char *arg, struct argp_state *state) {
  struct arguments *arguments = static_cast<struct arguments *>(state->input);
  switch (key) {
    case 'l':
      arguments->list = true;
      break;
    case ARGP_KEY_ARG:
      if (state->arg_num >= 1) {
        argp_usage(state);
      }
      arguments->diskimage = arg;
      break;
    case ARGP_KEY_END:
      if (state->arg_num < 1) {
        argp_usage(state);
      }
      break;
    default:
      return ARGP_ERR_UNKNOWN;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x6e6b
jmp 0x6e4b
movl -0x24(%rbp), %eax
subl $0x6c, %eax
je 0x6e61
jmp 0x6e55
movl -0x24(%rbp), %eax
subl $0x1000001, %eax        # imm = 0x1000001
je 0x6e8b
jmp 0x6ea0
movq -0x20(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x6ea9
movq -0x18(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jb 0x6e7e
movq -0x18(%rbp), %rdi
callq 0x63a0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6ea9
movq -0x18(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jae 0x6e9e
movq -0x18(%rbp), %rdi
callq 0x63a0
jmp 0x6ea9
movl $0x7, -0x4(%rbp)
jmp 0x6eb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/2mg.cc
// Function: readFilename[abi:cxx11](std::shared_ptr<TheHandle>, int)
static std::string readFilename(Handle h, int len) {
  static const char *digits = "0123456789abcdef";
  std::string r;
  for (int i = 0; i < len; i++) {
    uint8_t ch = h->r8();
    if (isalnum(ch) || ch == '_' || ch == '.' || ch == ' ') {
      r += static_cast<char>(ch);
    } else {
      r += 'x';
      uint8_t hi = ch >> 4;
      uint8_t lo = ch & 0xf;
      r += digits[hi];
      r += digits[lo];
    }
  }
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x6330
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6fd6
movq -0x48(%rbp), %rdi
callq 0x8550
movq %rax, %rdi
callq 0x98b0
movb %al, -0x49(%rbp)
jmp 0x6f14
movb -0x49(%rbp), %al
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %edi
callq 0x6230
cmpl $0x0, %eax
jne 0x6f43
movzbl -0x1d(%rbp), %eax
cmpl $0x5f, %eax
je 0x6f43
movzbl -0x1d(%rbp), %eax
cmpl $0x2e, %eax
je 0x6f43
movzbl -0x1d(%rbp), %eax
cmpl $0x20, %eax
jne 0x6f6e
movq -0x40(%rbp), %rdi
movsbl -0x1d(%rbp), %esi
callq 0x6140
jmp 0x6f52
jmp 0x6fc6
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6130
jmp 0x6ff3
movq -0x40(%rbp), %rdi
movl $0x78, %esi
callq 0x6140
jmp 0x6f7e
movq -0x40(%rbp), %rdi
movzbl -0x1d(%rbp), %eax
shrl $0x4, %eax
movb %al, -0x2d(%rbp)
movb -0x1d(%rbp), %al
andb $0xf, %al
movb %al, -0x2e(%rbp)
movq 0xa3a5(%rip), %rax      # 0x11340
movzbl -0x2d(%rbp), %ecx
movsbl (%rax,%rcx), %esi
callq 0x6140
jmp 0x6faa
movq -0x40(%rbp), %rdi
movq 0xa38b(%rip), %rax      # 0x11340
movzbl -0x2e(%rbp), %ecx
movsbl (%rax,%rcx), %esi
callq 0x6140
jmp 0x6fc4
jmp 0x6fc6
jmp 0x6fc8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6ef2
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x6fe9
movq -0x40(%rbp), %rdi
callq 0x6130
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6440
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/2mg.cc
// Function: printDateTime(unsigned short, unsigned short)
static void printDateTime(uint16_t date, uint16_t time) {
  std::cout << std::setfill('0')
            << std::setw(2) << ((date >> 9) & 0x7f) << "-"
            << std::setw(2) << ((date >> 5) & 0xf) << "-"
            << std::setw(2) << (date & 0x1f) << " "
            << std::setw(2) << ((time >> 8) & 0x1f) << ":"
            << std::setw(2) << (time & 0x3f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movl $0x30, %edi
callq 0x8c70
movb %al, -0x5(%rbp)
movq 0x9436(%rip), %rdi      # 0x10fd0
movzbl -0x5(%rbp), %esi
callq 0x63b0
movq %rax, -0x48(%rbp)
movl $0x2, %edi
callq 0x8c50
movq -0x48(%rbp), %rdi
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
callq 0x62b0
movq %rax, %rdi
movzwl -0x2(%rbp), %esi
sarl $0x9, %esi
andl $0x7f, %esi
callq 0x6410
movq %rax, %rdi
leaq 0x3557(%rip), %rsi      # 0xb133
callq 0x61e0
movq %rax, -0x40(%rbp)
movl $0x2, %edi
callq 0x8c50
movq -0x40(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
callq 0x62b0
movq %rax, %rdi
movzwl -0x2(%rbp), %esi
sarl $0x5, %esi
andl $0xf, %esi
callq 0x6410
movq %rax, %rdi
leaq 0x3519(%rip), %rsi      # 0xb133
callq 0x61e0
movq %rax, -0x38(%rbp)
movl $0x2, %edi
callq 0x8c50
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x62b0
movq %rax, %rdi
movzwl -0x2(%rbp), %esi
andl $0x1f, %esi
callq 0x6410
movq %rax, %rdi
leaq 0x347f(%rip), %rsi      # 0xb0d4
callq 0x61e0
movq %rax, -0x30(%rbp)
movl $0x2, %edi
callq 0x8c50
movq -0x30(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x62b0
movq %rax, %rdi
movzwl -0x4(%rbp), %esi
sarl $0x8, %esi
andl $0x1f, %esi
callq 0x6410
movq %rax, %rdi
leaq 0x34a2(%rip), %rsi      # 0xb135
callq 0x61e0
movq %rax, -0x28(%rbp)
movl $0x2, %edi
callq 0x8c50
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x62b0
movq %rax, %rdi
movzwl -0x4(%rbp), %esi
andl $0x3f, %esi
callq 0x6410
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/2mg.cc
// Function: dumpSapling(std::shared_ptr<TheHandle>, unsigned int, std::ostream&)
static void dumpSapling(Handle h, uint32_t len, std::ostream &f) {
  auto index = h->tell();
  while (len > 0) {
    h->seek(index);
    uint16_t blockid = h->r8();
    h->skip(255);
    blockid |= h->r8() << 8;
    uint32_t blen = std::min<uint32_t>(512, len);
    if (blockid && (blockid + 1) * 512 <= h->length) {
      h->seek(blockid * 512);
      dumpSeedling(h, blen, f);
    } else {
      f.seekp(blen, std::ios::cur);
    }
    len -= blen;
    index++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x8550
movq %rax, %rdi
callq 0x9760
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jbe 0x826d
movq -0x58(%rbp), %rdi
callq 0x8550
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x9b00
movq -0x58(%rbp), %rdi
callq 0x8550
movq %rax, %rdi
callq 0x98b0
movq -0x58(%rbp), %rdi
movzbl %al, %eax
movw %ax, -0x22(%rbp)
callq 0x8550
movq %rax, %rdi
movl $0xff, %esi
callq 0x9b20
movq -0x58(%rbp), %rdi
callq 0x8550
movq %rax, %rdi
callq 0x98b0
movzbl %al, %ecx
shll $0x8, %ecx
movzwl -0x22(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x22(%rbp)
movl $0x200, -0x2c(%rbp)     # imm = 0x200
leaq -0x2c(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x8ce0
movl (%rax), %eax
movl %eax, -0x28(%rbp)
cmpw $0x0, -0x22(%rbp)
je 0x823e
movq -0x58(%rbp), %rdi
movzwl -0x22(%rbp), %eax
addl $0x1, %eax
shll $0x9, %eax
cltq
movq %rax, -0x60(%rbp)
callq 0x8550
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq (%rcx), %rax
jg 0x823e
movq -0x58(%rbp), %rdi
callq 0x8550
movq %rax, %rdi
movzwl -0x22(%rbp), %eax
shll $0x9, %eax
movl %eax, %esi
callq 0x9b00
movq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x8650
movq -0x68(%rbp), %rdi
movl -0x28(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x80d0
jmp 0x821c
leaq -0x40(%rbp), %rdi
callq 0x85d0
jmp 0x8251
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x85d0
jmp 0x8273
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x61f0
movl -0x28(%rbp), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8128
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6440
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/handle.cc
// Function: TheHandle::TheHandle(char const*)
TheHandle::TheHandle(const char *filename) {
  data = pos = nullptr;
  std::ifstream f(filename, std::ios::in | std::ios::binary | std::ios::ate);
  if (!f.is_open()) {
    return;
  }
  length = f.tellg();
  data = new uint8_t[length];
  f.seekg(0, std::ios::beg);
  f.read(reinterpret_cast<char*>(data), length);
  f.close();
  pos = data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x258(%rbp)
movq $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x250(%rbp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x8cc0
movl %eax, %edi
movl $0x2, %esi
callq 0x8cc0
movq -0x250(%rbp), %rsi
movl %eax, %edx
leaq -0x218(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x6470
movq -0x248(%rbp), %rdi
callq 0x63c0
movb %al, -0x239(%rbp)
jmp 0x9504
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x9542
jmp 0x9510
movl $0x1, -0x228(%rbp)
jmp 0x9618
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x6070
jmp 0x962d
leaq -0x218(%rbp), %rdi
callq 0x6420
movq %rdx, -0x268(%rbp)
movq %rax, -0x260(%rbp)
jmp 0x955e
movq -0x268(%rbp), %rax
movq -0x260(%rbp), %rcx
movq %rcx, -0x238(%rbp)
movq %rax, -0x230(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x9ba0
movq %rax, -0x270(%rbp)
jmp 0x958f
movq -0x258(%rbp), %rax
movq -0x270(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x6030
movq %rax, -0x278(%rbp)
jmp 0x95b1
movq -0x258(%rbp), %rax
movq -0x278(%rbp), %rcx
movq %rcx, 0x8(%rax)
xorl %edx, %edx
movl %edx, %esi
leaq -0x218(%rbp), %rdi
callq 0x6310
jmp 0x95d5
movq -0x258(%rbp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rsi
leaq -0x218(%rbp), %rdi
callq 0x62d0
jmp 0x95f1
leaq -0x218(%rbp), %rdi
callq 0x6050
jmp 0x95ff
movq -0x258(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x6070
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x6440
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/handle.cc
// Function: TheHandle::TheHandle(std::vector<unsigned char, std::allocator<unsigned char>> const&)
TheHandle::TheHandle(const std::vector<uint8_t> &data) {
  length = data.size();
  this->data = new uint8_t[length];
  std::copy(data.begin(), data.end(), this->data);
  pos = this->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9bc0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x6030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x9c40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9c70
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9be0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/handle.cc
// Function: TheHandle::r32()
uint32_t TheHandle::r32() {
  uint32_t r = *pos++;
  r |= *pos++ << 8;
  r |= *pos++ << 16;
  r |= *pos++ << 24;
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movzbl (%rax), %eax
movl %eax, -0xc(%rbp)
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movzbl (%rax), %eax
shll $0x8, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movzbl (%rax), %eax
shll $0x10, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movzbl (%rax), %eax
shll $0x18, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/handle.cc
// Function: TheHandle::r24()
uint32_t TheHandle::r24() {
  uint32_t r = *pos++;
  r |= *pos++ << 8;
  r |= *pos++ << 16;
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movzbl (%rax), %eax
movl %eax, -0xc(%rbp)
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movzbl (%rax), %eax
shll $0x8, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movzbl (%rax), %eax
shll $0x10, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/handle.cc
// Function: TheHandle::rs[abi:cxx11]()
std::string TheHandle::rs() {
  std::string r;
  uint8_t len = *pos++;
  for (auto i = 0; i < len; i++) {
    r += static_cast<char>(*pos++);
  }
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6330
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movb (%rax), %al
movb %al, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movzbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jge 0x996a
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
incq %rdx
movq %rdx, 0x10(%rcx)
movsbl (%rax), %esi
callq 0x6140
jmp 0x9946
jmp 0x9948
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x991b
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x6130
jmp 0x9987
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x997d
movq -0x40(%rbp), %rdi
callq 0x6130
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6440
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/handle.cc
// Function: TheHandle::read[abi:cxx11](int)
std::string TheHandle::read(int32_t len) {
  std::string r;
  for (auto i = 0; i < len; i++) {
    r += static_cast<char>(*pos++);
  }
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x6330
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9a12
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
incq %rdx
movq %rdx, 0x10(%rcx)
movsbl (%rax), %esi
callq 0x6140
jmp 0x99ee
jmp 0x99f0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x99c6
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6130
jmp 0x9a2f
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x9a25
movq -0x48(%rbp), %rdi
callq 0x6130
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6440
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128otrpv2/ref/OTR.c
// Function: Setup
int Setup(const uint8 *skey)
{
	uint8 cst[16] = {0};

	KeySchedule(KeyLen, ENC, skey);
	Encryption(KeyLen, cst, J);
	mul2(J, J2); 
	mul2(J2, Q); /* Q = 4J */
	return SUCCESS;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
movq 0x10(%rsp), %rdx
movl $0x80, %edi
xorl %esi, %esi
callq 0x1090
movq %rsp, %rsi
movl $0x80, %edi
movq 0x3d90(%rip), %rdx      # 0x4fc8
callq 0x10f0
movq 0x3d84(%rip), %rdi      # 0x4fc8
movq 0x3da5(%rip), %rsi      # 0x4ff0
callq 0x1270
movq 0x3d99(%rip), %rdi      # 0x4ff0
movq 0x3d52(%rip), %rsi      # 0x4fb0
callq 0x1270
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/big5enc.c
// Function: read_big5
static void read_big5(charset_spec const *charset, long int input_chr,
		      charset_state *state,
		      void (*emit)(void *ctx, long int output), void *emitctx)
{
    UNUSEDARG(charset);

    /*
     * For reading Big5, state->s0 simply contains the single
     * stored lead byte when we are half way through a double-byte
     * character, or 0 if we aren't.
     */

    if (state->s0 == 0) {
	if (input_chr >= 0xA1 && input_chr <= 0xFE) {
	    /*
	     * Lead byte. Just store it.
	     */
	    state->s0 = input_chr;
	} else {
	    /*
	     * Anything else we pass straight through unchanged.
	     */
	    emit(emitctx, input_chr);
	}
    } else {
	/*
	 * We have a stored lead byte. We expect a valid followup
	 * byte.
	 */
	if ((input_chr >= 0x40 && input_chr <= 0x7E) ||
	    (input_chr >= 0xA1 && input_chr <= 0xFE)) {
	    emit(emitctx, big5_to_unicode(state->s0 - 0xA1, input_chr - 0x40));
	} else {
	    emit(emitctx, ERROR);
	}
	state->s0 = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x65af
cmpq $0xa1, -0x10(%rbp)
jl 0x659f
cmpq $0xfe, -0x10(%rbp)
jg 0x659f
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x65ad
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
jmp 0x6628
cmpq $0x40, -0x10(%rbp)
jl 0x65bd
cmpq $0x7e, -0x10(%rbp)
jle 0x65d1
cmpq $0xa1, -0x10(%rbp)
jl 0x660e
cmpq $0xfe, -0x10(%rbp)
jg 0x660e
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
subq $0xa1, %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
subq $0x40, %rax
movl %eax, %esi
callq 0x66f0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rax
callq *%rax
jmp 0x661d
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq *%rax
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/big5enc.c
// Function: write_big5
static int write_big5(charset_spec const *charset, long int input_chr,
		      charset_state *state,
		      void (*emit)(void *ctx, long int output), void *emitctx)
{
    UNUSEDARG(charset);
    UNUSEDARG(state);

    if (input_chr == -1)
	return TRUE;		       /* stateless; no cleanup required */

    if (input_chr < 0x80) {
	emit(emitctx, input_chr);
	return TRUE;
    } else {
	int r, c;
	if (unicode_to_big5(input_chr, &r, &c)) {
	    emit(emitctx, r + 0xA1);
	    emit(emitctx, c + 0x40);
	    return TRUE;
	} else {
	    return FALSE;
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x666c
movl $0x1, -0x4(%rbp)
jmp 0x66dc
cmpq $0x80, -0x18(%rbp)
jge 0x668d
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x66dc
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x6780
cmpl $0x0, %eax
je 0x66d5
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %ecx
addl $0xa1, %ecx
movslq %ecx, %rsi
callq *%rax
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x38(%rbp), %ecx
addl $0x40, %ecx
movslq %ecx, %rsi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x66dc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/big5set.c
// Function: unicode_to_big5
int unicode_to_big5(long int unicode, int *r, int *c)
{
    int rr, cc;
    long int uu;
    int i, j, k;

    i = -1;
    j = lenof(big5_backward);
    while (j - i > 1) {
	k = (i + j) / 2;
	rr = big5_backward[k].r;
	cc = big5_backward[k].c;
	uu = big5_forward[rr][cc];
	if (unicode > uu)
	    i = k;
	else if (unicode < uu)
	    j = k;
	else {
	    *r = rr;
	    *c = cc;
	    return 1;
	}
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0x3587, -0x38(%rbp)    # imm = 0x3587
movl -0x38(%rbp), %eax
subl -0x34(%rbp), %eax
cmpl $0x1, %eax
jle 0x684a
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0xf937(%rip), %rax      # 0x16100
movzbl (%rax,%rcx,2), %eax
movl %eax, -0x24(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0xf925(%rip), %rax      # 0x16100
movzbl 0x1(%rax,%rcx,2), %eax
movl %eax, -0x28(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x6cc2(%rip), %rax      # 0xd4b0
imulq $0x17e, %rcx, %rcx      # imm = 0x17E
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x6816
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x6845
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x6828
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x6843
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6851
jmp 0x6845
jmp 0x679e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/cns11643.c
// Function: cns11643_to_unicode
long int cns11643_to_unicode(int p, int r, int c)
{
    assert(p >= 0 && p < 7);
    assert(r >= 0 && r < 94);
    assert(c >= 0 && c < 94);
    return cns11643_forward((p*94+r)*94+c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x687f
cmpl $0x7, -0x4(%rbp)
jge 0x687f
jmp 0x689e
leaq 0x16388(%rip), %rdi     # 0x1cc0e
leaq 0x16391(%rip), %rsi     # 0x1cc1e
movl $0x32d9, %edx           # imm = 0x32D9
leaq 0x16390(%rip), %rcx     # 0x1cc29
callq 0x6050
cmpl $0x0, -0x8(%rbp)
jl 0x68ac
cmpl $0x5e, -0x8(%rbp)
jge 0x68ac
jmp 0x68cb
leaq 0x6ba6(%rip), %rdi      # 0xd459
leaq 0x16364(%rip), %rsi     # 0x1cc1e
movl $0x32da, %edx           # imm = 0x32DA
leaq 0x16363(%rip), %rcx     # 0x1cc29
callq 0x6050
cmpl $0x0, -0xc(%rbp)
jl 0x68d9
cmpl $0x5e, -0xc(%rbp)
jge 0x68d9
jmp 0x68f8
leaq 0x16371(%rip), %rdi     # 0x1cc51
leaq 0x16337(%rip), %rsi     # 0x1cc1e
movl $0x32db, %edx           # imm = 0x32DB
leaq 0x16336(%rip), %rcx     # 0x1cc29
callq 0x6050
imull $0x5e, -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
imull $0x5e, %eax, %eax
addl -0xc(%rbp), %eax
movslq %eax, %rcx
leaq 0x16361(%rip), %rax     # 0x1cc70
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x10(%rbp)
imull $0x5e, -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
imull $0x5e, %eax, %eax
addl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x10(%rbp), %eax
movslq %ecx, %rdx
leaq 0x4c2d6(%rip), %rcx     # 0x52c10
movl (%rcx,%rdx,4), %edx
imull $0x5e, -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
imull $0x5e, %ecx, %ecx
addl -0xc(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %edx
movl %edx, %ecx
andl $0x3, %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/cns11643.c
// Function: unicode_to_cns11643
int unicode_to_cns11643(long int unicode, int *p, int *r, int *c)
{
    int index, pp, rr, cc;
    long int uu;
    int i, j, k;

    i = -1;
    j = lenof(cns11643_backward);
    while (j - i > 1) {
	k = (i + j) / 2;
	index = cns11643_backward[k];
	uu = cns11643_forward(index);
	if (unicode > uu)
	    i = k;
	else if (unicode < uu)
	    j = k;
	else {
	    cc = index % 94;
	    rr = index / 94;
	    pp = rr / 94;
	    rr %= 94;
	    *p = pp;
	    *r = rr;
	    *c = cc;
	    return 1;
	}
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movl $0xbe2e, -0x48(%rbp)    # imm = 0xBE2E
movl -0x48(%rbp), %eax
subl -0x44(%rbp), %eax
cmpl $0x1, %eax
jle 0x6a94
movl -0x44(%rbp), %eax
addl -0x48(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x4c(%rbp)
movslq -0x4c(%rbp), %rcx
leaq 0x345f3(%rip), %rax     # 0x3afb0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0x162a1(%rip), %rax     # 0x1cc70
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x50(%rbp)
movl -0x2c(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x50(%rbp), %eax
movslq %ecx, %rdx
leaq 0x4c220(%rip), %rcx     # 0x52c10
movl (%rcx,%rdx,4), %edx
movl -0x2c(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %edx
movl %edx, %ecx
andl $0x3, %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jle 0x6a1f
movl -0x4c(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x6a8f
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0x6a31
movl -0x4c(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x6a8d
movl -0x2c(%rbp), %eax
movl $0x5e, %ecx
cltd
idivl %ecx
movl %edx, -0x38(%rbp)
movl -0x2c(%rbp), %eax
movl $0x5e, %ecx
cltd
idivl %ecx
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x5e, %ecx
cltd
idivl %ecx
movl %eax, -0x30(%rbp)
movl -0x34(%rbp), %eax
movl $0x5e, %ecx
cltd
idivl %ecx
movl %edx, -0x34(%rbp)
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x38(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6a9b
jmp 0x6a8f
jmp 0x6992
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/cp949.c
// Function: read_cp949
static void read_cp949(charset_spec const *charset, long int input_chr,
		       charset_state *state,
		       void (*emit)(void *ctx, long int output), void *emitctx)
{
    UNUSEDARG(charset);

    /*
     * For reading CP949, state->s0 simply contains the single
     * stored lead byte when we are half way through a double-byte
     * character, or 0 if we aren't.
     */

    if (state->s0 == 0) {
	if (input_chr >= 0x81 && input_chr <= 0xFE) {
	    /*
	     * Lead byte. Just store it.
	     */
	    state->s0 = input_chr;
	} else {
	    /*
	     * Anything else we pass straight through unchanged.
	     */
	    emit(emitctx, input_chr);
	}
    } else {
	/*
	 * We have a stored lead byte. We expect a valid followup
	 * byte.
	 */
	if ((input_chr >= 0x40 && input_chr <= 0xFF)) {
	    emit(emitctx, cp949_to_unicode(state->s0 - 0x80,
					   input_chr - 0x40));
	} else {
	    emit(emitctx, ERROR);
	}
	state->s0 = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6aff
cmpq $0x81, -0x10(%rbp)
jl 0x6aef
cmpq $0xfe, -0x10(%rbp)
jg 0x6aef
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6afd
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
jmp 0x6b67
cmpq $0x40, -0x10(%rbp)
jl 0x6b4d
cmpq $0xff, -0x10(%rbp)
jg 0x6b4d
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
subq $0x80, %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
subq $0x40, %rax
movl %eax, %esi
callq 0xabd0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rax
callq *%rax
jmp 0x6b5c
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq *%rax
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/cp949.c
// Function: write_cp949
static int write_cp949(charset_spec const *charset, long int input_chr,
		       charset_state *state,
		       void (*emit)(void *ctx, long int output),
		       void *emitctx)
{
    UNUSEDARG(charset);
    UNUSEDARG(state);

    if (input_chr == -1)
	return TRUE;		       /* stateless; no cleanup required */

    if (input_chr < 0x80) {
	emit(emitctx, input_chr);
	return TRUE;
    } else {
	int r, c;
	if (unicode_to_cp949(input_chr, &r, &c)) {
	    emit(emitctx, r + 0x80);
	    emit(emitctx, c + 0x40);
	    return TRUE;
	} else {
	    return FALSE;
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x6bac
movl $0x1, -0x4(%rbp)
jmp 0x6c1c
cmpq $0x80, -0x18(%rbp)
jge 0x6bcd
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x6c1c
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xac70
cmpl $0x0, %eax
je 0x6c15
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %ecx
addl $0x80, %ecx
movslq %ecx, %rsi
callq *%rax
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x38(%rbp), %ecx
addl $0x40, %ecx
movslq %ecx, %rsi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x6c1c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/euc.c
// Function: write_euc
static int write_euc(charset_spec const *charset, long int input_chr,
		     charset_state *state,
		     void (*emit)(void *ctx, long int output), void *emitctx)
{
    struct euc const *euc = (struct euc *)charset->data;
    unsigned long c;
    int cset, len;

    UNUSEDARG(state);

    if (input_chr == -1)
	return TRUE;		       /* stateless; no cleanup required */

    /* ASCII is the easy bit, and is always the same. */
    if (input_chr < 0x80) {
	emit(emitctx, input_chr);
	return TRUE;
    }

    c = euc->from_ucs(input_chr);
    if (!c) {
	return FALSE;
    }

    cset = c >> 28;
    len = euc->nchars[cset-1];
    c &= 0xFFFFFF;

    if (cset > 1)
	emit(emitctx, 0x8C + cset);    /* SS2/SS3 */

    while (len--)
	emit(emitctx, (c >> (8*len)) & 0xFF);
    return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x6e23
movl $0x1, -0x4(%rbp)
jmp 0x6eef
cmpq $0x80, -0x18(%rbp)
jge 0x6e47
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x6eef
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x6e6c
movl $0x0, -0x4(%rbp)
jmp 0x6eef
movq -0x40(%rbp), %rax
shrq $0x1c, %rax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rax
movl -0x44(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x48(%rbp)
movq -0x40(%rbp), %rax
andq $0xffffff, %rax         # imm = 0xFFFFFF
movq %rax, -0x40(%rbp)
cmpl $0x1, -0x44(%rbp)
jle 0x6eb4
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x44(%rbp), %ecx
addl $0x8c, %ecx
movslq %ecx, %rsi
callq *%rax
jmp 0x6eb6
movl -0x48(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x48(%rbp)
cmpl $0x0, %eax
je 0x6ee8
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x48(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rsi
andq $0xff, %rsi
callq *%rax
jmp 0x6eb6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/euc.c
// Function: euc_cn_to_ucs
static long int euc_cn_to_ucs(unsigned long state)
{
    switch (state >> 28) {
      case 1: return gb2312_to_unicode(((state >> 8) & 0xFF) - 0xA1,
				       ((state     ) & 0xFF) - 0xA1);
      default: return ERROR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x1c, %rax
subq $0x1, %rax
jne 0x6f4f
jmp 0x6f1c
movq -0x10(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %esi
callq 0x73d0
movq %rax, -0x8(%rbp)
jmp 0x6f57
movq $0xffff, -0x8(%rbp)     # imm = 0xFFFF
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/euc.c
// Function: euc_kr_to_ucs
static long int euc_kr_to_ucs(unsigned long state)
{
    switch (state >> 28) {
      case 1: return ksx1001_to_unicode(((state >> 8) & 0xFF) - 0xA1,
				       ((state     ) & 0xFF) - 0xA1);
      default: return ERROR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x1c, %rax
subq $0x1, %rax
jne 0x701f
jmp 0x6fec
movq -0x10(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %esi
callq 0xad50
movq %rax, -0x8(%rbp)
jmp 0x7027
movq $0xffff, -0x8(%rbp)     # imm = 0xFFFF
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/euc.c
// Function: euc_jp_to_ucs
static long int euc_jp_to_ucs(unsigned long state)
{
    switch (state >> 28) {
      case 1: return jisx0208_to_unicode(((state >> 8) & 0xFF) - 0xA1,
					 ((state     ) & 0xFF) - 0xA1);
      case 2:
	/*
	 * This is the top half of JIS X 0201. That means A1-DF map
	 * to FF61-FF9F, and nothing else is valid.
	 */
	{
	    int c = state & 0xFF;
	    if (c >= 0xA1 && c <= 0xDF)
		return c + (0xFF61 - 0xA1);
	    else
		return ERROR;
	}
	/* (no break needed since all control paths have returned) */
      case 3: return jisx0212_to_unicode(((state >> 8) & 0xFF) - 0xA1,
					 ((state     ) & 0xFF) - 0xA1);
      default: return ERROR;	       /* placate optimisers */
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x1c, %rax
movq %rax, -0x20(%rbp)
subq $0x1, %rax
je 0x70db
jmp 0x70c0
movq -0x20(%rbp), %rax
subq $0x2, %rax
je 0x710e
jmp 0x70cc
movq -0x20(%rbp), %rax
subq $0x3, %rax
je 0x7147
jmp 0x717a
movq -0x10(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %esi
callq 0xa8f0
movq %rax, -0x8(%rbp)
jmp 0x7182
movq -0x10(%rbp), %rax
andq $0xff, %rax
movl %eax, -0x14(%rbp)
cmpl $0xa1, -0x14(%rbp)
jl 0x713d
cmpl $0xdf, -0x14(%rbp)
jg 0x713d
movl -0x14(%rbp), %eax
addl $0xfec0, %eax           # imm = 0xFEC0
cltq
movq %rax, -0x8(%rbp)
jmp 0x7182
movq $0xffff, -0x8(%rbp)     # imm = 0xFFFF
jmp 0x7182
movq -0x10(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %esi
callq 0xaa60
movq %rax, -0x8(%rbp)
jmp 0x7182
movq $0xffff, -0x8(%rbp)     # imm = 0xFFFF
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)