LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/event_fout.c
// Function: event_handler_fout_snprintf
static int event_handler_fout_snprintf(char **s, size_t *n, size_t *ret_len, int repl_delim, const char *fmt, ...) {
    int len, i;
    va_list vl;
    char *c;

    va_start(vl, fmt);
    len = vsnprintf(*s, *n, fmt, vl);
    va_end(vl);

    if (len < 0 || (size_t)len >= *n) {
        log_error("event_handler_fout_snprintf: Not enough space in buffer; truncating\n");
        return PHPSPY_ERR | PHPSPY_ERR_BUF_FULL;
    }

    if (repl_delim) {
        for (i = 0; i < len; i++) { /* TODO optimize */
            c = *s + i;
            if (*c == opt_trace_delim || *c == opt_frame_delim) {
                *c = '?';
            }
        }
    }

    *s += len;
    *n -= len;
    *ret_len = (size_t)len;

    return PHPSPY_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x2d9b1
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
leaq -0x50(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x28, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x60f0
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rax
cmpl $0x0, -0x34(%rbp)
jl 0x2da24
movslq -0x34(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x2da3e
leaq 0x7b66(%rip), %rdi      # 0x35591
movb $0x0, %al
callq 0x9cc0
movl $0x5, -0x4(%rbp)
jmp 0x2dadb
cmpl $0x0, -0x24(%rbp)
je 0x2daa5
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x2daa3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
leaq 0xc8c2(%rip), %rcx      # 0x3a335
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x2da8f
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
leaq 0xc8ac(%rip), %rcx      # 0x3a334
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x2da96
movq -0x58(%rbp), %rax
movb $0x3f, (%rax)
jmp 0x2da98
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2da4b
jmp 0x2daa5
movl -0x34(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movslq -0x34(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movslq -0x34(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/event_fout.c
// Function: event_handler_fout_write
static int event_handler_fout_write(event_handler_fout_udata_t *udata) {
    int rv;
    ssize_t write_len;

    rv = PHPSPY_OK;
    write_len = (udata->cur - udata->buf);

    if (write_len < 1) {
        /* nothing to write */
        return rv;
    }

    if (udata->use_mutex) {
        pthread_mutex_lock(&event_handler_fout_mutex);
    }

    if (write(udata->fd, udata->buf, write_len) != write_len) {
        log_error("event_handler_fout: Write failed (%s)\n", errno != 0 ? strerror(errno) : "partial");
        rv = PHPSPY_ERR;
    }

    if (udata->use_mutex) {
        pthread_mutex_unlock(&event_handler_fout_mutex);
    }

    return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x2db2c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2dbbd
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x2db42
leaq 0xef73(%rip), %rdi      # 0x3cab0
callq 0x6600
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x6120
cmpq -0x20(%rbp), %rax
je 0x2dba1
callq 0x6060
cmpl $0x0, (%rax)
je 0x2db7b
callq 0x6060
movl (%rax), %edi
callq 0x65b0
movq %rax, -0x28(%rbp)
jmp 0x2db88
leaq 0x7a07(%rip), %rax      # 0x35589
movq %rax, -0x28(%rbp)
jmp 0x2db88
movq -0x28(%rbp), %rsi
leaq 0x79cf(%rip), %rdi      # 0x35562
movb $0x0, %al
callq 0x9cc0
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x2dbb7
leaq 0xeefe(%rip), %rdi      # 0x3cab0
callq 0x63d0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/event_callgrind.c
// Function: event_handler_callgrind
int event_handler_callgrind(struct trace_context_s *context, int event_type) {
    callgrind_udata_t *udata;

    udata = (callgrind_udata_t*)context->event_udata;
    if (!udata && event_type != PHPSPY_TRACE_EVENT_INIT) {
        return 1;
    }
    switch (event_type) {
        case PHPSPY_TRACE_EVENT_INIT:
            udata = calloc(1, sizeof(callgrind_udata_t));
            if (callgrind_open(&udata->fout) != 0) {
                free(udata);
                return 1;
            }
            context->event_udata = udata;
            break;
        case PHPSPY_TRACE_EVENT_STACK_BEGIN:
            udata->self_len = 0;
            break;
        case PHPSPY_TRACE_EVENT_FRAME:
            callgrind_ingest_frame(udata, context);
            break;
        case PHPSPY_TRACE_EVENT_STACK_END:
            callgrind_digest_stack(udata);
            memcpy(udata->prev,     udata->self,     sizeof(trace_loc_t) * udata->self_len);
            memcpy(udata->prev_str, udata->self_str, PHPSPY_STR_SIZE * udata->self_len);
            udata->prev_len = udata->self_len;
            udata->self_len = 0;
            break;
        case PHPSPY_TRACE_EVENT_DEINIT:
            callgrind_dump(udata);
            callgrind_free(udata);
            free(udata);
            break;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x790(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2dc07
cmpl $0x0, -0x14(%rbp)
je 0x2dc07
movl $0x1, -0x4(%rbp)
jmp 0x2dd42
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x9, %rax
ja 0x2dd3b
movq -0x28(%rbp), %rax
leaq 0x7a11(%rip), %rcx      # 0x35634
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, %edi
movl $0x42018, %esi          # imm = 0x42018
callq 0x62f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x42008, %rdi          # imm = 0x42008
callq 0x2dd50
cmpl $0x0, %eax
je 0x2dc69
movq -0x20(%rbp), %rdi
callq 0x6050
movl $0x1, -0x4(%rbp)
jmp 0x2dd42
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x790(%rax)
jmp 0x2dd3b
movq -0x20(%rbp), %rax
movl $0x0, 0x42000(%rax)
jmp 0x2dd3b
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2de20
jmp 0x2dd3b
movq -0x20(%rbp), %rdi
callq 0x2ded0
movq -0x20(%rbp), %rdi
addq $0x19000, %rdi          # imm = 0x19000
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq 0x42000(%rax), %rax
imulq $0x320, %rax, %rdx      # imm = 0x320
callq 0x6360
movq -0x20(%rbp), %rdi
addq $0x3a000, %rdi          # imm = 0x3A000
movq -0x20(%rbp), %rsi
addq $0x32000, %rsi          # imm = 0x32000
movq -0x20(%rbp), %rax
movl 0x42000(%rax), %eax
shll $0x8, %eax
movslq %eax, %rdx
callq 0x6360
movq -0x20(%rbp), %rax
movl 0x42000(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x42004(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x42000(%rax)
jmp 0x2dd3b
movq -0x20(%rbp), %rdi
callq 0x306d0
movq -0x20(%rbp), %rdi
callq 0x313f0
movq -0x20(%rbp), %rdi
callq 0x6050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/event_callgrind.c
// Function: callgrind_open
static int callgrind_open(FILE **fout) {
    /* TODO consolidate -o -O -E flags as `-o fn` == "fn[.pid].(out|err) */
    int tfd;
    tfd = -1;
    if (strcmp(opt_path_output, "-") == 0) {
        tfd = dup(STDOUT_FILENO);
        *fout = fdopen(tfd, "w");
    } else {
        *fout = fopen(opt_path_output, "w");
    }
    if (!*fout) {
        perror("fopen");
        if (tfd != -1) close(tfd);
        return 1;
    }
    setvbuf(*fout, NULL, _IOLBF, PIPE_BUF);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
leaq 0xc5ce(%rip), %rax      # 0x3a338
movq (%rax), %rdi
leaq 0x4d86(%rip), %rsi      # 0x32afa
callq 0x6310
cmpl $0x0, %eax
jne 0x2dda6
movl $0x1, %edi
callq 0x6200
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
leaq 0x6ec8(%rip), %rsi      # 0x34c5d
callq 0x6430
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2ddc6
leaq 0xc58b(%rip), %rax      # 0x3a338
movq (%rax), %rdi
leaq 0x6ea6(%rip), %rsi      # 0x34c5d
callq 0x6510
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2ddf3
leaq 0x6e88(%rip), %rdi      # 0x34c5f
callq 0x6520
cmpl $-0x1, -0x14(%rbp)
je 0x2ddea
movl -0x14(%rbp), %edi
callq 0x6260
movl $0x1, -0x4(%rbp)
jmp 0x2de14
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
movl $0x1000, %ecx           # imm = 0x1000
callq 0x6460
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/event_callgrind.c
// Function: callgrind_ingest_frame
static void callgrind_ingest_frame(callgrind_udata_t *udata, struct trace_context_s *context) {
    if (udata->self_len >= MAX_STACK_DEPTH) {
        log_error("callgrind_ingest_frame: Exceeded max stack depth (%d); truncating\n", MAX_STACK_DEPTH);
        return;
    }
    memcpy(&udata->self[udata->self_len], &context->event.frame.loc, sizeof(trace_loc_t));
    callgrind_sprint_loc(udata->self_str[udata->self_len], &context->event.frame.loc);
    udata->self_len += 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x80, 0x42000(%rax)
jl 0x2de55
leaq 0x78c5(%rip), %rdi      # 0x3570c
movl $0x80, %esi
movb $0x0, %al
callq 0x9cc0
jmp 0x2debd
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0x42000(%rax), %rax
imulq $0x320, %rax, %rax      # imm = 0x320
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movl $0x320, %edx            # imm = 0x320
callq 0x6360
movq -0x8(%rbp), %rdi
addq $0x32000, %rdi          # imm = 0x32000
movq -0x8(%rbp), %rax
movslq 0x42000(%rax), %rax
shlq $0x8, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x31950
movq -0x8(%rbp), %rax
movl 0x42000(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x42000(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/event_callgrind.c
// Function: callgrind_sprint_loc
static void callgrind_sprint_loc(char *str, trace_loc_t *loc) {
    int len;
    len = snprintf(str, PHPSPY_STR_SIZE,
        "%.*s%s%.*s %.*s:%d",
        (int)loc->class_len, loc->class,
        loc->class_len > 0 ? "::" : "",
        (int)loc->func_len, loc->func,
        (int)loc->file_len, loc->file,
        loc->lineno
    );
    if (len >= PHPSPY_STR_SIZE) {
        log_error("callgrind_sprint_loc: Exceeded max loc len (%d); truncating\n", PHPSPY_STR_SIZE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x308(%rax), %rax
movl %eax, %ecx
movq -0x20(%rbp), %r8
addq $0x100, %r8             # imm = 0x100
movq -0x20(%rbp), %rax
movq 0x308(%rax), %rdx
leaq 0x311b(%rip), %r9       # 0x34aac
leaq 0x3b36(%rip), %rax      # 0x354ce
cmpq $0x0, %rdx
cmovaq %rax, %r9
movq -0x20(%rbp), %rax
movq 0x300(%rax), %rax
movl %eax, %r14d
movq -0x20(%rbp), %rbx
movq -0x20(%rbp), %rax
movq 0x310(%rax), %rax
movl %eax, %r11d
movq -0x20(%rbp), %r10
addq $0x200, %r10            # imm = 0x200
movq -0x20(%rbp), %rax
movl 0x318(%rax), %eax
movl $0x100, %esi            # imm = 0x100
leaq 0x3ada(%rip), %rdx      # 0x354bb
movl %r14d, (%rsp)
movq %rbx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movb $0x0, %al
callq 0x61d0
movl %eax, -0x24(%rbp)
cmpl $0x100, -0x24(%rbp)     # imm = 0x100
jl 0x31a1e
leaq 0x3d3d(%rip), %rdi      # 0x3574f
movl $0x100, %esi            # imm = 0x100
movb $0x0, %al
callq 0x9cc0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/DASedit.c
// Function: Print_Seq
void Print_Seq(char *target, int tlen)
{ static int letter[4] = { 'a', 'c', 'g', 't' };
  int i;

  for (i = 0; i < tlen; i++)
    { if (i%100 == 0 && i != 0)
        printf("\n");
      printf("%c",letter[(int) target[i]]);
    }
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2434
movl -0x10(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x2402
cmpl $0x0, -0x10(%rbp)
je 0x2402
leaq 0x24b0c(%rip), %rdi     # 0x26f07
movb $0x0, %al
callq 0x20f0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x28d58(%rip), %rax     # 0x2b170
movl (%rax,%rcx,4), %esi
leaq 0x23bf6(%rip), %rdi     # 0x26018
movb $0x0, %al
callq 0x20f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x23d6
leaq 0x24acc(%rip), %rdi     # 0x26f07
movb $0x0, %al
callq 0x20f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/emmett1[P]st/st.c
// Function: utf8strchr
char *
utf8strchr(char *s, Rune u)
{
	Rune r;
	size_t i, j, len;

	len = strlen(s);
	for (i = 0, j = 0; i < len; i += j) {
		if (!(j = utf8decode(&s[i], &r, len - i)))
			break;
		if (r == u)
			return &(s[i]);
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5320
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x8d31
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rdx
subq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rsi
callq 0x8d50
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x8d0b
jmp 0x8d31
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x8d21
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8d39
jmp 0x8d23
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8cdc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/components.c
// Function: process_traversed
int		process_traversed(t_vect *edgs)
{
	int num = 0;

	qsort(edgs->tab, edgs->used, sizeof(int), cmp_int);
	for (int i = 0; i < edgs->used; i++)
		if (i == 0 || edgs->tab[i] != edgs->tab[i-1])
			num++;
	free(edgs->tab);
	free(edgs);
	return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x4, %edx
leaq 0x3f2(%rip), %rcx       # 0x15d0
callq 0x1050
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1237
cmpl $0x0, -0x10(%rbp)
je 0x1221
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl -0x10(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x122a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x122c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11ea
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/components.c
// Function: init_component
t_component *init_component()
{
	t_component *new = (t_component*)malloc(sizeof(t_component));
	t_vect *l = (t_vect*)malloc(sizeof(t_vect));

	init_vector(l);
	new->vrx_nb = 0;
	new->edg_nb = 0;
	new->list = l;
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x1080
movq %rax, -0x8(%rbp)
movl $0x18, %edi
callq 0x1080
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2200
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/components.c
// Function: classify_component
void	classify_component(t_component *c)
{
	if (c->edg_nb > c->vrx_nb)
		c->type = 2;
	else if (c->edg_nb == 0)
		c->type = 0;
	else
		c->type = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jle 0x14e5
movq -0x8(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x1509
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x14fc
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x1507
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x1509
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/components.c
// Function: add_component
void	add_component(t_graph *g, t_component *c)
{
	if (g->head == NULL)
	{
		g->head = c;
		g->tail = c;
		c->next = NULL;
	}
	else
	{
		g->tail->next = c;
		c->next = NULL;
		g->tail = c;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x154d
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x1575
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/components.c
// Function: get_component
void	get_component(t_graph *g, int src, int cycl)
{
	t_component *new = init_component();

	fill_component(src,g,new, cycl);
	classify_component(new);
	add_component(g, new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
callq 0x1260
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x10(%rbp), %ecx
callq 0x12c0
movq -0x18(%rbp), %rdi
callq 0x14c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1510
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/create_graph.c
// Function: get_dimensions
int		get_dimensions(t_graph *new)
{
	int n,m;

	scanf("%d %d", &n, &m);
	if (!valid_dimensions(n,m,new))
	{
		free(new);
		return 0;
	}
	if (!init_adj(new))
		return 0;
	if (!(new->visited = (int*)malloc(sizeof(int) * new->vertx)))
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1901(%rip), %rdi      # 0x3004
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0x1090
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x2110
cmpl $0x0, %eax
jne 0x1738
movq -0x10(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x177e
movq -0x10(%rbp), %rdi
callq 0x15f0
cmpl $0x0, %eax
jne 0x174f
movl $0x0, -0x4(%rbp)
jmp 0x177e
movq -0x10(%rbp), %rax
movslq 0x2c(%rax), %rdi
shlq $0x2, %rdi
callq 0x1080
movq -0x10(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x1777
movl $0x0, -0x4(%rbp)
jmp 0x177e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/freeing.c
// Function: free_components
void	free_components(t_graph *g)
{
	t_component *tmp;
	t_component *tmp1;

	tmp = g->head;
	while (tmp != NULL)
	{
		tmp1 = tmp->next;
		free(tmp->list->tab);
		free(tmp->list);
		free(tmp);
		tmp = tmp1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1a89
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1a48
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/freeing.c
// Function: free_graph
void	free_graph(t_graph *g)
{
	free(g->visited);
	for (int i = 0; i < g->vertx; i++)
	{
		free(g->adj[i].tab);
		free(g->rev_adj[i].tab);
	}
	free(g->adj);
	free(g->rev_adj);
	free_components(g);
	free(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x1afc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ab0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1a30
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/main_scc.c
// Function: generate_graph
t_graph *generate_graph()
{
	t_graph *new = (t_graph*)malloc(sizeof(t_graph));
	new->head = NULL;
	new->tail = NULL;
	new->components = 0;
	if (!get_dimensions(new))
		error(WRONG_INPUT);
	if (!get_edges(new))
		error(WRONG_EDGE);
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x38, %edi
callq 0x1080
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x16f0
cmpl $0x0, %eax
jne 0x1b7e
xorl %edi, %edi
callq 0x19f0
movq -0x8(%rbp), %rdi
callq 0x18d0
cmpl $0x0, %eax
jne 0x1b96
movl $0x1, %edi
callq 0x19f0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/main_scc.c
// Function: dfs
void	dfs(int x, t_graph *g, t_stack *out)
{
	t_stack	*stk = (t_stack*)malloc(sizeof(t_stack));
	stk->size = 0;
	int tag;
	int top;

	push(stk,x);
	while (stk->size > 0)
	{
		tag = 0;
		top = stk->top->val;
		g->visited[top] = 1;
		for (int i = 0; i < g->adj[top].used; i++)
		{
			if (g->visited[g->adj[top].tab[i]] == 0)
			{
				push(stk, g->adj[top].tab[i]);
				tag = 1;
			}
		}
		if (!tag)
		{
			push(out, top);
			pop(stk);
		}
	}
	free(stk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x10, %edi
callq 0x1080
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x2080
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x1cb6
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x28(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x28(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x10(%rcx), %rax
jae 0x1c96
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x28(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movslq -0x2c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x1c89
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x2080
movl $0x1, -0x24(%rbp)
jmp 0x1c8b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1c16
cmpl $0x0, -0x24(%rbp)
jne 0x1cb1
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x2080
movq -0x20(%rbp), %rdi
callq 0x1ff0
jmp 0x1bd9
movq -0x20(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/main_scc.c
// Function: first_pass
t_stack	*first_pass(t_graph *g)
{
	t_stack	*out = (t_stack*)malloc(sizeof(t_stack));
	out->size = 0;
	memset(g->visited,0,sizeof(int)*g->vertx);
	for (int i = 0; i < g->vertx; i++)
	{
		if (g->visited[i] == 0)
			dfs(i, g, out);
	}
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x1080
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x2c(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1070
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x1d53
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x1d46
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1ba0
jmp 0x1d48
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d18
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/main_scc.c
// Function: second_pass
void	second_pass(t_graph *g, t_stack *stk)
{
	memset(g->visited,0,sizeof(int)*g->vertx);
	while (stk->size > 0)
	{
		if (g->visited[stk->top->val] == 0)
			get_component(g,stk->top->val,++g->components);
		pop(stk);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x2c(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1070
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x1dda
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x1dcf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
addl $0x1, %edx
movl %edx, 0x28(%rax)
callq 0x1580
movq -0x10(%rbp), %rdi
callq 0x1ff0
jmp 0x1d8b
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/main_scc.c
// Function: main
int main()
{
	t_graph *g;
	g = generate_graph();
	find_scc(g);
	print_components(g);
	free_graph(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1b30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1de0
movq -0x8(%rbp), %rdi
callq 0x1e60
movq -0x8(%rbp), %rdi
callq 0x1a90
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_scc/print_component.c
// Function: print_components
void	print_components(t_graph *g)
{
	t_component *tmp = g->head;

	if (g->components == 1)
		printf(BOLDWHITE "There is 1 strongly connected component:\n" RESET);
	else
		printf(BOLDWHITE "There are %d strongly connected components:\n" RESET, g->components);
	while (tmp != NULL)
	{
		if (tmp->type == 0)
		{
			printf(CYAN "A simple vertex and contains:\n" RESET);
			printf("%d\n", tmp->list->tab[0] + 1);
		}
		else if (tmp->type == 1)
		{
			printf(CYAN "A cycle of length %d and contains:\n" RESET,tmp->vrx_nb);
			for (int i = 0 ; i < tmp->list->used; i++)
				printf("%d ", tmp->list->tab[i] + 1);
			puts("");
		}
		else
		{
			printf(CYAN "A complex strong component with %d edges and %d vertices and contains:\n" RESET, tmp->edg_nb, tmp->vrx_nb);
			for (int i = 0 ; i < tmp->list->used; i++)
				printf("%d ", tmp->list->tab[i] + 1);
			puts("");
		}
		tmp = tmp->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x1e92
leaq 0x11c3(%rip), %rdi      # 0x304c
movb $0x0, %al
callq 0x1060
jmp 0x1ea7
movq -0x8(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0x11e3(%rip), %rdi      # 0x3083
movb $0x0, %al
callq 0x1060
jmp 0x1ea9
cmpq $0x0, -0x10(%rbp)
je 0x1fe0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1eee
leaq 0x11f8(%rip), %rdi      # 0x30bd
movb $0x0, %al
callq 0x1060
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl (%rax), %esi
addl $0x1, %esi
leaq 0x1203(%rip), %rdi      # 0x30e5
movb $0x0, %al
callq 0x1060
jmp 0x1fcf
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x1f60
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
leaq 0x11e3(%rip), %rdi      # 0x30e9
movb $0x0, %al
callq 0x1060
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1f52
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
addl $0x1, %esi
leaq 0x11d6(%rip), %rdi      # 0x3116
movb $0x0, %al
callq 0x1060
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f14
leaq 0x10c3(%rip), %rdi      # 0x301c
callq 0x1040
jmp 0x1fcd
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
leaq 0x11a5(%rip), %rdi      # 0x311a
movb $0x0, %al
callq 0x1060
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1fc1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %esi
addl $0x1, %esi
leaq 0x1167(%rip), %rdi      # 0x3116
movb $0x0, %al
callq 0x1060
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1f83
leaq 0x1054(%rip), %rdi      # 0x301c
callq 0x1040
jmp 0x1fcf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1ea9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/calculator.c
// Function: SetVariable
static int SetVariable(CalcVar *var)
{
    const char *fmtI = ParseFormat("%lg");
    ShowInfo("\n t=");
    Sread(stdin, -1, fmtI, &(var->t));
    ShowInfo("\n x=");
    Sread(stdin, -1, fmtI, &(var->x));
    ShowInfo("\n y=");
    Sread(stdin, -1, fmtI, &(var->y));
    ShowInfo("\n z=");
    Sread(stdin, -1, fmtI, &(var->z));
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x24a33(%rip), %rdi     # 0x27bd6
callq 0xbbc0
movq %rax, -0x10(%rbp)
leaq 0x21919(%rip), %rdi     # 0x24acc
movb $0x0, %al
callq 0xbcf0
movq 0x2be17(%rip), %rax     # 0x2efd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0xc1e0
leaq 0x218f2(%rip), %rdi     # 0x24ad1
movb $0x0, %al
callq 0xbcf0
movq 0x2bdeb(%rip), %rax     # 0x2efd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0xc1e0
leaq 0x218c7(%rip), %rdi     # 0x24ad6
movb $0x0, %al
callq 0xbcf0
movq 0x2bdbb(%rip), %rax     # 0x2efd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0xc1e0
leaq 0x2189c(%rip), %rdi     # 0x24adb
movb $0x0, %al
callq 0xbcf0
movq 0x2bd8b(%rip), %rax     # 0x2efd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
addq $0x18, %rcx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0xc1e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/calculator.c
// Function: ShowCalcManual
static void ShowCalcManual(void)
{
    ShowInfo("\n            Calculator User Manual\n");
    ShowInfo("Operators:   +, -, *, /, x^y, exp(x), ln(x), lg(x), abs(x), sin(x), cos(x), tan(x)\n");
    ShowInfo("             x, y are numbers or variables or expressions; angle should be radian;\n");
    ShowInfo("Variables:   t, x, y, z, ans, pi;\n");
    ShowInfo("Parenthesis: (), [], {}\n");
    ShowInfo("Example:     1.5*sin(-pi/6)-[cos(pi/3)]^2+ln{exp[5*lg(abs(-100))]} = 9\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x21700(%rip), %rdi     # 0x2497b
movb $0x0, %al
callq 0xbcf0
leaq 0x21717(%rip), %rdi     # 0x249a0
movb $0x0, %al
callq 0xbcf0
leaq 0x2175d(%rip), %rdi     # 0x249f4
movb $0x0, %al
callq 0xbcf0
leaq 0x217a3(%rip), %rdi     # 0x24a48
movb $0x0, %al
callq 0xbcf0
leaq 0x217b8(%rip), %rdi     # 0x24a6b
movb $0x0, %al
callq 0xbcf0
leaq 0x217c3(%rip), %rdi     # 0x24a84
movb $0x0, %al
callq 0xbcf0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/calculator.c
// Function: PushOperator
static int PushOperator(Operator *oprt, const char op)
{
    if ((oprt->top - oprt->bom) >= oprt->size) {
        ShowWarning("operator stack is overflowing...");
        return 1;
    }
    *oprt->top = op;
    ++(oprt->top);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rcx
cmpq %rcx, %rax
jl 0x3dd8
leaq 0x20a89(%rip), %rdi     # 0x24851
movb $0x0, %al
callq 0xbb20
movl $0x1, -0x4(%rbp)
jmp 0x3dfc
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/calculator.c
// Function: ExtractFirstFloat
static Real ExtractFirstFloat(char **pstr)
{
    const char *fmtI = ParseFormat("%lg");
    char *str = *pstr;
    Real oprd = 0.0;
    Sscanf(str, 1, fmtI, &oprd);
    while (IsDigit(*str)) {
        ++str;
    }
    if (IsDot(*str)) {
        ++str;
    }
    while (IsDigit(*str)) {
        ++str;
    }
    *pstr = str;
    return oprd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x23d53(%rip), %rdi     # 0x27bd6
callq 0xbbc0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
leaq -0x20(%rbp), %rcx
movb $0x0, %al
callq 0xc110
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x3e30
cmpl $0x0, %eax
je 0x3ed6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3eb7
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x4860
cmpl $0x0, %eax
je 0x3ef3
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3ef5
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x3e30
cmpl $0x0, %eax
je 0x3f14
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3ef5
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/calculator.c
// Function: PushOperand
static int PushOperand(Operand *oprd, const Real op)
{
    if ((oprd->top - oprd->bom) >= oprd->size) {
        ShowWarning("operand stack is overflowing...");
        return 1;
    }
    *oprd->top = op;
    ++(oprd->top);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rcx
cmpq %rcx, %rax
jl 0x3f7b
leaq 0x20907(%rip), %rdi     # 0x24872
movb $0x0, %al
callq 0xbb20
movl $0x1, -0x4(%rbp)
jmp 0x3fa3
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/calculator.c
// Function: ExtractConstant
static Real ExtractConstant(const CalcVar *var, char **pstr)
{
    char *str = *pstr;
    Real oprd = 0.0;
    switch (*str) {
        case 'u':
            oprd = var->t;
            ++str;
            break;
        case 'x':
            oprd = var->x;
            ++str;
            break;
        case 'y':
            oprd = var->y;
            ++str;
            break;
        case 'z':
            oprd = var->z;
            ++str;
            break;
        case 'p':
            oprd = var->pi;
            ++str;
            break;
        case 'q':
            oprd = var->ans;
            ++str;
            break;
        default:
            ShowWarning("undefined constant value");
            break;
    }
    *pstr = str;
    return oprd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
addl $-0x70, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0xa, %eax
ja 0x412a
movq -0x28(%rbp), %rax
leaq 0x2010d(%rip), %rcx     # 0x24184
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4138
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4138
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4138
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4138
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4138
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4138
leaq 0x20761(%rip), %rdi     # 0x24892
movb $0x0, %al
callq 0xbb20
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/calculator.c
// Function: PopOperator
static int PopOperator(Operator *oprt, char *pop)
{
    if (oprt->top == oprt->bom) {
        ShowWarning("no sufficient operators in expression...");
        return 1;
    }
    --(oprt->top);
    *pop = *oprt->top;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x42c8
leaq 0x20609(%rip), %rdi     # 0x248c1
movb $0x0, %al
callq 0xbb20
movl $0x1, -0x4(%rbp)
jmp 0x42ef
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/calculator.c
// Function: PopOperand
static int PopOperand(Operand *oprd, Real *pop)
{
    if (oprd->top == oprd->bom) {
        ShowWarning("no sufficient operands in expression...");
        return 1;
    }
    --(oprd->top);
    *pop = *oprd->top;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x43d8
leaq 0x20522(%rip), %rdi     # 0x248ea
movb $0x0, %al
callq 0xbb20
movl $0x1, -0x4(%rbp)
jmp 0x4403
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x8, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/calculator.c
// Function: DoBinary
static int DoBinary(const Real oprdy, const char toprt, const Real oprdx, Real *pcoprd)
{
    const Real zero = 0.0;
    switch(toprt)
    {
        case '+':
            *pcoprd = oprdy + oprdx;
            break;
        case '-':
            *pcoprd = oprdy - oprdx;
            break;
        case '*':
            *pcoprd = oprdy * oprdx;
            break;
        case '/':
            if (zero == oprdx) {
                ShowWarning("divide by zero");
                *pcoprd = zero;
                return 1;
            }
            *pcoprd = oprdy / oprdx;
            break;
        case '^':
            *pcoprd = pow(oprdy, oprdx);
            break;
        default:
            *pcoprd = zero;
            return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
movsd %xmm0, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movsbl -0x11(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x2a, %eax
je 0x466f
jmp 0x4612
movl -0x34(%rbp), %eax
subl $0x2b, %eax
je 0x4641
jmp 0x461c
movl -0x34(%rbp), %eax
subl $0x2d, %eax
je 0x4658
jmp 0x4626
movl -0x34(%rbp), %eax
subl $0x2f, %eax
je 0x4683
jmp 0x4630
movl -0x34(%rbp), %eax
subl $0x5e, %eax
je 0x46c5
jmp 0x46de
movsd -0x10(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x46f2
movsd -0x10(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x46f2
movsd -0x10(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x46f2
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jne 0x46b1
jp 0x46b1
leaq 0x202d6(%rip), %rdi     # 0x2496c
movb $0x0, %al
callq 0xbb20
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x46f9
movsd -0x10(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x46f2
movsd -0x10(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x2070
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x46f2
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x46f9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/calculator.c
// Function: QueryIndex
static int QueryIndex(const char op)
{
    int i = 0;
    switch(op) {
        case '+':
            i = 0; break;
        case '-':
            i = 1; break;
        case '*':
            i = 2; break;
        case '/':
            i = 3; break;
        case '^':
            i = 4; break;
        case 'e':
            i = 5; break;
        case 'n':
            i = 6; break;
        case 'g':
            i = 7; break;
        case 'a':
            i = 8; break;
        case 's':
            i = 9; break;
        case 'c':
            i = 10; break;
        case 't':
            i = 11; break;
        case '(':
            i = 12; break;
        case ')':
            i = 13; break;
        case '[':
            i = 14; break;
        case ']':
            i = 15; break;
        case '{':
            i = 16; break;
        case '}':
            i = 17; break;
        case '\0':
            i = 18; break;
        default:
            ShowWarning("unidentified operator");
            break;
    }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x0, -0x8(%rbp)
movsbl -0x1(%rbp), %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x7d, %eax
ja 0x4999
movq -0x10(%rbp), %rax
leaq 0x1f92d(%rip), %rcx     # 0x24200
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x8(%rbp)
jmp 0x49a7
movl $0x1, -0x8(%rbp)
jmp 0x49a7
movl $0x2, -0x8(%rbp)
jmp 0x49a7
movl $0x3, -0x8(%rbp)
jmp 0x49a7
movl $0x4, -0x8(%rbp)
jmp 0x49a7
movl $0x5, -0x8(%rbp)
jmp 0x49a7
movl $0x6, -0x8(%rbp)
jmp 0x49a7
movl $0x7, -0x8(%rbp)
jmp 0x49a7
movl $0x8, -0x8(%rbp)
jmp 0x49a7
movl $0x9, -0x8(%rbp)
jmp 0x49a7
movl $0xa, -0x8(%rbp)
jmp 0x49a7
movl $0xb, -0x8(%rbp)
jmp 0x49a7
movl $0xc, -0x8(%rbp)
jmp 0x49a7
movl $0xd, -0x8(%rbp)
jmp 0x49a7
movl $0xe, -0x8(%rbp)
jmp 0x49a7
movl $0xf, -0x8(%rbp)
jmp 0x49a7
movl $0x10, -0x8(%rbp)
jmp 0x49a7
movl $0x11, -0x8(%rbp)
jmp 0x49a7
movl $0x12, -0x8(%rbp)
jmp 0x49a7
leaq 0x1ff0b(%rip), %rdi     # 0x248ab
movb $0x0, %al
callq 0xbb20
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/case_loader.c
// Function: LoadCaseData
void LoadCaseData(Time *time, Space *space, Model *model)
{
    ReadCaseSettingData(time, space, model);
    ReadGeometrySettingData(&(space->geo));
    WriteVerifyData(time, space, model);
    CheckCaseSettingData(time, space, model);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6000
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x7200
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7330
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7e00
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/case_loader.c
// Function: ReadGeometrySettingData
static void ReadGeometrySettingData(Geometry *const geo)
{
    const char *fname = "artracfd.geo";
    FILE *fp = Fopen(fname, "r");
    String str = {'\0'}; /* store the current read line */
    int nentry = 0; /* entry count */
    while (NULL != fgets(str, sizeof str, fp)) {
        ParseCommand(str);
        if (0 == strncmp(str, "count begin", sizeof str)) {
            ++nentry;
            Sread(fp, 1, "%d", &(geo->sphN));
            Sread(fp, 1, "%d", &(geo->stlN));
            break;
        }
    }
    fclose(fp);
    if (1 != nentry) {
        ShowError("missing or repeated sections: %s, entry: %d", fname, nentry);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1ef5f(%rip), %rax     # 0x26175
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2059e(%rip), %rsi     # 0x277c3
callq 0xbf90
movq %rax, -0x18(%rbp)
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x20d0
movl $0x0, -0xe4(%rbp)
leaq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xc8, %esi
callq 0x2110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x72ee
leaq -0xe0(%rbp), %rdi
callq 0xb940
leaq -0xe0(%rbp), %rdi
leaq 0x1fb80(%rip), %rsi     # 0x26e08
movl $0xc8, %edx
callq 0x2050
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x72e9
movl -0xe4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xe4(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
movl $0x1, %esi
leaq 0x21ba5(%rip), %rdx     # 0x28e66
movb $0x0, %al
callq 0xc1e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movl $0x1, %esi
leaq 0x21b86(%rip), %rdx     # 0x28e66
movb $0x0, %al
callq 0xc1e0
jmp 0x72ee
jmp 0x724b
movq -0x18(%rbp), %rdi
callq 0x2080
movl $0x1, %eax
cmpl -0xe4(%rbp), %eax
je 0x731c
movq -0x10(%rbp), %rsi
movl -0xe4(%rbp), %edx
leaq 0x1fb36(%rip), %rdi     # 0x26e4b
movb $0x0, %al
callq 0xbbd0
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)