LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/list.c
// Function: list_repr
char *list_repr(LakeList *list)
{
    char *s = malloc(2);
    s[0] = '(';
    s[1] = '\0';
    int i;
    char *s2;
    LakeVal *val;
    for (i = 0; i < LIST_N(list); ++i)
    {
        val = LIST_VAL(list, i);
        if (val == VAL(list))
        {
            s2 = strdup("[Circular]");
        }
        else
        {
            s2 = lake_repr(val);
        }
        s = lake_str_append(s, s2);
        free(s2);
        if (i != LIST_N(list) - 1) s = lake_str_append(s, " ");
    }
    return lake_str_append(s, ")");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rdi
callq 0x11a0
movq %rax, %r15
movw $0x28, (%rax)
xorl %ebp, %ebp
leaq 0x3375(%rip), %r14      # 0x63b7
leaq 0x2fc3(%rip), %r12      # 0x600c
cmpq %rbp, 0x18(%rbx)
jbe 0x30a3
movq 0x20(%rbx), %rax
movq (%rax,%rbp,8), %rdi
cmpq %rbx, %rdi
je 0x3063
callq 0x2a74
jmp 0x306b
movq %r14, %rdi
callq 0x1200
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
callq 0x131c
movq %rax, %r15
movq %r13, %rdi
callq 0x1030
movq 0x18(%rbx), %rax
decq %rax
cmpq %rax, %rbp
je 0x309e
movq %r15, %rdi
movq %r12, %rsi
callq 0x131c
movq %rax, %r15
incq %rbp
jmp 0x3049
leaq 0x330b(%rip), %rsi      # 0x63b5
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x131c
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/parse.c
// Function: parse_expr
LakeVal *parse_expr(LakeCtx *lake_ctx, char *s, size_t n)
{
    Ctx ctx = {s, n, 0, 0, lake_ctx};
    LakeVal *result = _parse_expr(&ctx);
    warn_trailing(&ctx);
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsp, %rbx
movq %rsi, (%rbx)
movq %rdx, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq %rdi, 0x20(%rbx)
movq %rbx, %rdi
callq 0x30fa
movq %rax, %r14
movq %rbx, %rdi
callq 0x35f7
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/parse.c
// Function: warn_trailing
static void warn_trailing(Ctx *ctx)
{
    maybe_spaces(ctx);
    /* don't warn about trailing comments */
    if (ctx->i < ctx->n && peek(ctx) != ';')
    {
        char *trailing = ctx->s + ctx->i;
        fprintf(stderr, "warning: ignoring %d trailing chars: %s\n",
                (int)(ctx->n - ctx->i), trailing);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3734
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rax
cmpq %rax, %rdx
jbe 0x3616
movq (%rbx), %rcx
cmpb $0x3b, (%rcx,%rax)
jne 0x3618
popq %rbx
retq
addq %rax, %rcx
movq 0x69d6(%rip), %rsi      # 0x9ff8
movq (%rsi), %rdi
subl %eax, %edx
leaq 0x2daf(%rip), %rsi      # 0x63dd
xorl %eax, %eax
popq %rbx
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/parse.c
// Function: parse_exprs
LakeList *parse_exprs(LakeCtx *lake_ctx, char *s, size_t n)
{
    Ctx ctx = {s, n, 0, 0, lake_ctx};
    LakeList *results = list_make();
    LakeVal *result;
    while (ctx.i < ctx.n)
    {
        result = _parse_expr(&ctx);
        if (result && result != VAL(PARSE_ERR))
        {
            list_append(results, result);
        }
        else
        {
            list_free(results);
            return NULL;
        }
    }
    warn_trailing(&ctx);
    return results;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsp, %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rdi, 0x20(%r14)
xorl %r12d, %r12d
callq 0x2d01
movq %rax, %rbx
cmpq %r15, %r12
jae 0x36a0
movq %r14, %rdi
callq 0x30fa
cmpq $-0x2, %rax
je 0x3694
testq %rax, %rax
je 0x3694
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2e14
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %r12
jmp 0x3665
movq %rbx, %rdi
callq 0x2cfc
xorl %ebx, %ebx
jmp 0x36a8
movq %rsp, %rdi
callq 0x35f7
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/parse.c
// Function: parse_naked_list
LakeList *parse_naked_list(LakeCtx *lake_ctx, char *s, size_t n)
{
    Ctx ctx = {s, n, 0, 0, lake_ctx};
    LakeList *list = list_make();
    char c;
    maybe_spaces(&ctx);
    while ((c = peek(&ctx)) != PARSE_EOF)
    {
        LakeVal *val = _parse_expr(&ctx);
        if (val == VAL(PARSE_ERR))
        {
            list_free(list);
            ctx.i = ctx.n;
            return NULL;
        }
        list_append(list, val);
    }
    warn_trailing(&ctx);
    return list;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsp, %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rdi, 0x20(%r14)
callq 0x2d01
movq %rax, %rbx
movq %r14, %rdi
callq 0x3734
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x3715
movq (%rsp), %rcx
cmpb $-0x1, (%rcx,%rax)
je 0x3715
movq %r14, %rdi
callq 0x30fa
cmpq $-0x2, %rax
je 0x371f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2e14
jmp 0x36e4
movq %rsp, %rdi
callq 0x35f7
jmp 0x3729
movq %rbx, %rdi
callq 0x2cfc
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/parse.c
// Function: parse_sym
static LakeVal *parse_sym(Ctx *ctx)
{
    LakeVal *val;
    static int size = 1024;
    char s[size];
    char c;
    int i = 0;
    while (is_sym_char(c = peek(ctx)) && i < size - 1)
    {
        s[i++] = c;
        consume1(ctx);
    }
    s[i] = '\0';
    if (strcmp(s, "#t") == 0)
    {
        val = VAL(ctx->lake_ctx->T);
    }
    else if (strcmp(s, "#f") == 0)
    {
        val = VAL(ctx->lake_ctx->F);
    }
    else
    {
        val = VAL(sym_intern(ctx->lake_ctx, s));
    }
    return val;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movb $-0x1, %bpl
cmpq 0x8(%rbx), %rax
jae 0x3806
movq (%rbx), %rcx
movb (%rcx,%rax), %bpl
movsbl %bpl, %edi
callq 0x38a4
testl %eax, %eax
je 0x382d
cmpq $0x3fe, %r14            # imm = 0x3FE
ja 0x382d
movb %bpl, (%rsp,%r14)
incq %r14
movq %rbx, %rdi
callq 0x3784
jmp 0x37f2
movb $0x0, (%rsp,%r14)
leaq 0x27cb(%rip), %rsi      # 0x6004
movq %rsp, %rdi
pushq $0x3
popq %rdx
callq 0x11b0
testl %eax, %eax
je 0x386c
leaq 0x27b8(%rip), %rsi      # 0x6007
movq %rsp, %rdi
pushq $0x3
popq %rdx
callq 0x11b0
movq 0x20(%rbx), %rdi
testl %eax, %eax
je 0x3876
movq %rsp, %rsi
callq 0x4c24
jmp 0x387a
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rax
jmp 0x387a
movq 0x20(%rdi), %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/parse.c
// Function: ch
static char ch(Ctx *ctx, char expected)
{
    char c = peek(ctx);
    if (c == expected)
    {
        consume1(ctx);
        return c;
    }
    DIE("parse error, expected '%c' got '%c'", expected, c);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x10(%rdi), %rcx
movb $-0x1, %al
cmpq 0x8(%rdi), %rcx
jae 0x38f1
movq (%rdi), %rax
movb (%rax,%rcx), %al
cmpb %bl, %al
jne 0x3901
callq 0x3784
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movzbl %bl, %ebx
movsbl %al, %ebp
movq 0x66ea(%rip), %r14      # 0x9ff8
movq (%r14), %rcx
leaq 0x2746(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r14), %rdi
leaq 0x2b2d(%rip), %rsi      # 0x645a
movl %ebx, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1170
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x1100
pushq $0x1
popq %rdi
callq 0x11e0
nop
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: prim_make
LakePrimitive *prim_make(char *name, int arity, lake_prim fn)
{
    LakePrimitive *prim = prim_alloc();
    prim->name = strdup(name);
    prim->arity = arity;
    prim->fn = fn;
    return prim;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x11a0
movq %rax, %r15
movl $0x7, (%rax)
movq $0x28, 0x8(%rax)
movq %r14, %rdi
callq 0x1200
movq %rax, 0x10(%r15)
movl %ebp, 0x18(%r15)
movq %rbx, 0x20(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: car
static LakeVal *_car(LakeCtx *ctx, LakeList *args)
{
    LakeList *list = LIST(LIST_VAL(args, 0));
    if (lake_is_type(TYPE_LIST, list) && LIST_N(list) > 0)
    {
        return LIST_VAL(list, 0);
    }
    if (lake_is_type(TYPE_DLIST, list))
    {
        return VAL(dlist_head(DLIST(list)));
    }
    ERR("not a pair: %s", lake_repr(list));
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x18(%rsi)
je 0x3fc0
movq 0x20(%rsi), %rax
movq (%rax), %rbx
jmp 0x3fc2
xorl %ebx, %ebx
pushq $0x5
popq %rdi
movq %rbx, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x3fe8
cmpq $0x0, 0x18(%rbx)
je 0x3fe8
movq 0x20(%rbx), %rax
movq (%rax), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x6
popq %rdi
movq %rbx, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x4004
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1454
movq 0x5fed(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x2049(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r15), %r14
movq %rbx, %rdi
callq 0x2a74
leaq 0x250e(%rip), %rsi      # 0x6540
xorl %ebx, %ebx
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1170
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
jmp 0x3fdf
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: cdr
static LakeVal *_cdr(LakeCtx *ctx, LakeList *args)
{
    LakeList *list = LIST(LIST_VAL(args, 0));
    if (lake_is_type(TYPE_LIST, list) && LIST_N(list) > 0)
    {
        LakeList *cdr = list_copy(list);
        list_shift(cdr);
        return VAL(cdr);
    }
    if (lake_is_type(TYPE_DLIST, list))
    {
        return dlist_tail(DLIST(list));
    }
    ERR("not a pair: %s", lake_repr(list));
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x18(%rsi)
je 0x4063
movq 0x20(%rsi), %rax
movq (%rax), %rbx
jmp 0x4065
xorl %ebx, %ebx
pushq $0x5
popq %rdi
movq %rbx, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x4097
cmpq $0x0, 0x18(%rbx)
je 0x4097
movq %rbx, %rdi
callq 0x2e8a
movq %rax, %rbx
movq %rax, %rdi
callq 0x2f38
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x6
popq %rdi
movq %rbx, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x40b3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1459
movq 0x5f3e(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x1f9a(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r15), %r14
movq %rbx, %rdi
callq 0x2a74
leaq 0x245f(%rip), %rsi      # 0x6540
xorl %ebx, %ebx
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1170
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
jmp 0x408e
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: nullP
static LakeVal *_nullP(LakeCtx *ctx, LakeList *args)
{
    LakeVal *val = list_shift(args);
    LakeBool *is_null = lake_bool_from_int(ctx, lake_is_type(TYPE_LIST, val) &&
                                                    LIST_N(LIST(val)) == 0);
    return VAL(is_null);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2f38
movq %rax, %r14
pushq $0x5
popq %rdi
movq %rax, %rsi
callq 0x2a6c
xorl %esi, %esi
testl %eax, %eax
je 0x4151
cmpq $0x0, 0x18(%r14)
sete %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13d8
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: pairP
static LakeVal *_pairP(LakeCtx *ctx, LakeList *args)
{
    LakeVal *val = list_shift(args);
    LakeBool *is_pair = lake_bool_from_int(ctx, lake_is_type(TYPE_LIST, val) &&
                                                    LIST_N(LIST(val)) > 0);
    return VAL(is_pair);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2f38
movq %rax, %r14
pushq $0x5
popq %rdi
movq %rax, %rsi
callq 0x2a6c
xorl %esi, %esi
testl %eax, %eax
je 0x418c
cmpq $0x0, 0x18(%r14)
setne %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13d8
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: add
static LakeVal *_add(LakeCtx *ctx, LakeList *args)
{
    int result = 0;
    size_t n = LIST_N(args);
    size_t i;
    for (i = 0; i < n; ++i)
    {
        LakeVal *v = LIST_VAL(args, i);
        ENSURE_INT(v, i);
        result += INT_VAL(INT(v));
    }
    return VAL(int_from_c(result));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x18(%rsi), %r13
xorl %r15d, %r15d
pushq $0x3
popq %rbp
xorl %ebx, %ebx
cmpq %rbx, %r13
je 0x426f
cmpq 0x18(%r14), %rbx
jae 0x4254
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %r12
jmp 0x4257
xorl %r12d, %r12d
movl %ebp, %edi
movq %r12, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x4285
addl 0x10(%r12), %r15d
incq %rbx
jmp 0x423f
movl %r15d, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29eb
movq 0x5d6c(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x1dc8(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r15), %r14
movq %r12, %rdi
callq 0x2a74
leaq 0x229c(%rip), %rsi      # 0x654f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1170
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: sub
static LakeVal *_sub(LakeCtx *ctx, LakeList *args)
{
    size_t n = LIST_N(args);

    if (n < 1)
    {
        ERR("- requires at least one argument");
        return NULL;
    }

    int result = 0;
    size_t i;
    for (i = 0; i < n; ++i)
    {
        LakeVal *v = LIST_VAL(args, i);
        ENSURE_INT(v, i);
        result -= INT_VAL(INT(v));
    }
    return VAL(int_from_c(result));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rsi), %r13
testq %r13, %r13
je 0x4344
movq %rsi, %r14
xorl %r15d, %r15d
pushq $0x3
popq %rbp
xorl %ebx, %ebx
cmpq %rbx, %r13
je 0x432e
cmpq 0x18(%r14), %rbx
jae 0x4313
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %r12
jmp 0x4316
xorl %r12d, %r12d
movl %ebp, %edi
movq %r12, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x437d
subl 0x10(%r12), %r15d
incq %rbx
jmp 0x42fe
movl %r15d, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29eb
movq 0x5cad(%rip), %r14      # 0x9ff8
movq (%r14), %rcx
leaq 0x1d09(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rcx
leaq 0x2205(%rip), %rdi      # 0x6572
pushq $0x20
popq %rsi
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rsi
jmp 0x43be
movq 0x5c74(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x1cd0(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r15), %r14
movq %r12, %rdi
callq 0x2a74
leaq 0x21a4(%rip), %rsi      # 0x654f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1170
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: mul
static LakeVal *_mul(LakeCtx *ctx, LakeList *args)
{
    int result = 1;
    size_t n = LIST_N(args);
    size_t i;
    for (i = 0; i < n; ++i)
    {
        LakeVal *v = LIST_VAL(args, i);
        ENSURE_INT(v, i);
        result *= INT_VAL(INT(v));
    }
    return VAL(int_from_c(result));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x18(%rsi), %r13
pushq $0x1
popq %rbp
xorl %ebx, %ebx
pushq $0x3
popq %r15
cmpq %rbx, %r13
je 0x4424
cmpq 0x18(%r14), %rbx
jae 0x4407
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %r12
jmp 0x440a
xorl %r12d, %r12d
movl %r15d, %edi
movq %r12, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x4439
imull 0x10(%r12), %ebp
incq %rbx
jmp 0x43f2
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29eb
movq 0x5bb8(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x1c14(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r15), %r14
movq %r12, %rdi
callq 0x2a74
leaq 0x20e8(%rip), %rsi      # 0x654f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1170
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: div
static LakeVal *_div(LakeCtx *ctx, LakeList *args)
{
    size_t n = LIST_N(args);

    if (n < 1)
    {
        ERR("/ requires at least one argument");
        return NULL;
    }

    LakeVal *v = LIST_VAL(args, 0);
    ENSURE_INT(v, (size_t)0);
    int result = INT_VAL(INT(v));

    if (n == 1)
    {
        if (result == 0)
        {
            DIVIDE_BY_ZERO();
            return NULL;
        }
        result = 1 / result;
    }
    else
    {
        size_t i;
        for (i = 1; i < n; ++i)
        {
            v = LIST_VAL(args, i);
            ENSURE_INT(v, i);
            int val = INT_VAL(INT(v));
            if (val == 0)
            {
                DIVIDE_BY_ZERO();
                return NULL;
            }
            result /= val;
        }
    }
    return VAL(int_from_c(result));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rsi), %r13
testq %r13, %r13
je 0x4548
movq %rsi, %r14
movq 0x20(%rsi), %rax
movq (%rax), %rbx
pushq $0x3
popq %rdi
movq %rbx, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x4575
movl 0x10(%rbx), %r15d
cmpq $0x1, %r13
jne 0x4501
testl %r15d, %r15d
je 0x45aa
leal 0x1(%r15), %eax
xorl %ecx, %ecx
cmpl $0x3, %eax
cmovbl %r15d, %ecx
movl %ecx, %r15d
movl %r15d, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29eb
pushq $0x1
popq %rbx
pushq $0x3
popq %rbp
cmpq %rbx, %r13
je 0x44eb
cmpq 0x18(%r14), %rbx
jae 0x451c
movq 0x20(%r14), %rax
movq (%rax,%rbx,8), %r12
jmp 0x451f
xorl %r12d, %r12d
movl %ebp, %edi
movq %r12, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x45e3
movl 0x10(%r12), %ecx
testl %ecx, %ecx
je 0x45aa
movl %r15d, %eax
cltd
idivl %ecx
incq %rbx
movl %eax, %r15d
jmp 0x4507
movq 0x5aa9(%rip), %r14      # 0x9ff8
movq (%r14), %rcx
leaq 0x1b05(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rcx
leaq 0x2022(%rip), %rdi      # 0x6593
pushq $0x20
jmp 0x45d5
movq 0x5a7c(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x1ad8(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r15), %r14
movq %rbx, %rdi
callq 0x2a74
leaq 0x1fac(%rip), %rsi      # 0x654f
movq %r14, %rdi
xorl %edx, %edx
jmp 0x4617
movq 0x5a47(%rip), %r14      # 0x9ff8
movq (%r14), %rcx
leaq 0x1aa3(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rcx
leaq 0x1fe1(%rip), %rdi      # 0x65b4
pushq $0xe
popq %rsi
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rsi
jmp 0x4624
movq 0x5a0e(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x1a6a(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r15), %r14
movq %r12, %rdi
callq 0x2a74
leaq 0x1f3e(%rip), %rsi      # 0x654f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1170
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: int_eq
static LakeVal *_int_eq(LakeCtx *ctx, LakeList *args)
{
    bool result = TRUE;
    size_t n = LIST_N(args);
    size_t i;
    int curr, prev;
    for (i = 0; i < n; ++i)
    {
        LakeVal *v = LIST_VAL(args, i);
        ENSURE_INT(v, i);
        curr = INT_VAL(INT(v));
        if (i > 0)
        {
            result = result && curr == prev;
        }
        prev = INT_VAL(INT(v));
    }
    return VAL(lake_bool_from_int(ctx, result));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, (%rsp)
movq 0x18(%rsi), %r14
pushq $0x1
popq %rbp
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x46a1
cmpq 0x18(%r15), %rbx
jae 0x466d
movq 0x20(%r15), %rax
movq (%rax,%rbx,8), %r13
jmp 0x4670
xorl %r13d, %r13d
pushq $0x3
popq %rdi
movq %r13, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x46ba
movl 0x10(%r13), %eax
testl %ebp, %ebp
setne %cl
cmpl %r12d, %eax
sete %dl
andb %cl, %dl
testq %rbx, %rbx
movzbl %dl, %ecx
cmovnel %ecx, %ebp
incq %rbx
movl %eax, %r12d
jmp 0x4658
movq (%rsp), %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13d8
movq 0x5937(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x1993(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r15), %r14
movq %r13, %rdi
callq 0x2a74
leaq 0x1e67(%rip), %rsi      # 0x654f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1170
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: int_lt
static LakeVal *_int_lt(LakeCtx *ctx, LakeList *args)
{
    bool result = TRUE;
    size_t n = LIST_N(args);
    size_t i;
    int curr, prev;

    if (n > 1)
    {
        for (i = 0; i < n; ++i)
        {
            LakeVal *v = LIST_VAL(args, i);
            ENSURE_INT(v, i);
            curr = INT_VAL(INT(v));
            if (i > 0)
            {
                result = result && prev < curr;
            }
            prev = INT_VAL(INT(v));
        }
    }
    return VAL(lake_bool_from_int(ctx, result));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rsi), %r14
cmpq $0x2, %r14
jb 0x477e
movq %rsi, %r15
movq %rdi, (%rsp)
pushq $0x1
popq %rbp
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x4783
cmpq 0x18(%r15), %rbx
jae 0x474a
movq 0x20(%r15), %rax
movq (%rax,%rbx,8), %r13
jmp 0x474d
xorl %r13d, %r13d
pushq $0x3
popq %rdi
movq %r13, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x479c
movl 0x10(%r13), %eax
testl %ebp, %ebp
setne %cl
cmpl %eax, %r12d
setl %dl
andb %cl, %dl
testq %rbx, %rbx
movzbl %dl, %ecx
cmovnel %ecx, %ebp
incq %rbx
movl %eax, %r12d
jmp 0x4735
pushq $0x1
popq %rbp
jmp 0x4787
movq (%rsp), %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13d8
movq 0x5855(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x18b1(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r15), %r14
movq %r13, %rdi
callq 0x2a74
leaq 0x1d85(%rip), %rsi      # 0x654f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1170
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: int_gt
static LakeVal *_int_gt(LakeCtx *ctx, LakeList *args)
{
    bool result = TRUE;
    size_t n = LIST_N(args);
    size_t i;
    int curr, prev;

    if (n > 1)
    {
        for (i = 0; i < n; ++i)
        {
            LakeVal *v = LIST_VAL(args, i);
            ENSURE_INT(v, i);
            curr = INT_VAL(INT(v));
            if (i > 0)
            {
                result = result && prev > curr;
            }
            prev = INT_VAL(INT(v));
        }
    }
    return VAL(lake_bool_from_int(ctx, result));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rsi), %r14
cmpq $0x2, %r14
jb 0x4860
movq %rsi, %r15
movq %rdi, (%rsp)
pushq $0x1
popq %rbp
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x4865
cmpq 0x18(%r15), %rbx
jae 0x482c
movq 0x20(%r15), %rax
movq (%rax,%rbx,8), %r13
jmp 0x482f
xorl %r13d, %r13d
pushq $0x3
popq %rdi
movq %r13, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x487e
movl 0x10(%r13), %eax
testl %ebp, %ebp
setne %cl
cmpl %eax, %r12d
setg %dl
andb %cl, %dl
testq %rbx, %rbx
movzbl %dl, %ecx
cmovnel %ecx, %ebp
incq %rbx
movl %eax, %r12d
jmp 0x4817
pushq $0x1
popq %rbp
jmp 0x4869
movq (%rsp), %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13d8
movq 0x5773(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x17cf(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r15), %r14
movq %r13, %rdi
callq 0x2a74
leaq 0x1ca3(%rip), %rsi      # 0x654f
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1170
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: set_carB
static LakeVal *_set_carB(LakeCtx *ctx, LakeList *args)
{
    LakeList *list = LIST(LIST_VAL(args, 0));
    if (lake_is_type(TYPE_LIST, list))
    {
        LakeVal *new_car = LIST_VAL(args, 1);
        if (LIST_N(list) == 0)
        {
            list_append(list, new_car);
        }
        else
        {
            list_set(list, 0, new_car);
        }
        return VAL(list);
    }
    ERR("not a pair: %s", lake_repr(list));
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
cmpq $0x0, 0x18(%rsi)
je 0x48f0
movq 0x20(%r14), %rax
movq (%rax), %rbx
jmp 0x48f2
xorl %ebx, %ebx
pushq $0x5
popq %rdi
movq %rbx, %rsi
callq 0x2a6c
testl %eax, %eax
je 0x493b
cmpq $0x2, 0x18(%r14)
jb 0x4912
movq 0x20(%r14), %rax
movq 0x8(%rax), %rdx
jmp 0x4914
xorl %edx, %edx
cmpq $0x0, 0x18(%rbx)
je 0x4927
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2e9a
jmp 0x4932
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2e14
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x56b6(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x1712(%rip), %rdi      # 0x605e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x11f0
movq (%r15), %r14
movq %rbx, %rdi
callq 0x2a74
leaq 0x1bd7(%rip), %rsi      # 0x6540
xorl %ebx, %ebx
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1170
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1100
jmp 0x4932
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/primitive.c
// Function: display
static LakeVal *_display(LakeCtx *ctx, LakeList *args)
{
    size_t n = LIST_N(args);
    size_t i;
    int space = 0;
    for (i = 0; i < n; ++i)
    {
        if (space) putchar(' ');
        printf("%s", lake_repr(LIST_VAL(args, i)));
        space = 1;
    }
    putchar('\n');
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rsi), %r15
movb $0x1, %r13b
xorl %r12d, %r12d
leaq 0x16d6(%rip), %r14      # 0x607a
pushq $0x20
popq %rbp
cmpq %r12, %r15
je 0x49e5
testb $0x1, %r13b
jne 0x49b9
movl %ebp, %edi
callq 0x1040
cmpq 0x18(%rbx), %r12
jae 0x49c9
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rdi
jmp 0x49cb
xorl %edi, %edi
callq 0x2a74
xorl %r13d, %r13d
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x10c0
incq %r12
jmp 0x49a7
pushq $0xa
popq %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/samsonjs[P]lake/src/sym.c
// Function: sym_intern
LakeSym *sym_intern(LakeCtx *ctx, char *s)
{
    LakeSym *sym = lake_hash_get(ctx->symbols, s);
    if (!sym)
    {
        sym = sym_alloc();
        sym->n = strlen(s);
        sym->s = strndup(s, sym->n);
        sym->hash = str_hash(s);
        lake_hash_put(ctx->symbols, sym->s, sym);
    }
    return sym;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x28af
movq %rax, %r15
testq %rax, %rax
jne 0x4ca0
pushq $0x28
popq %rdi
callq 0x11a0
movq %rax, %r15
movl $0x1, (%rax)
movq $0x28, 0x8(%rax)
movq %r14, %rdi
callq 0x10b0
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %rax, %rsi
callq 0x1130
movq %rax, 0x18(%r15)
movl $0x1505, %ecx           # imm = 0x1505
movsbl (%r14), %edx
testl %edx, %edx
je 0x4c8b
incq %r14
imull $0x21, %ecx, %ecx
xorl %edx, %ecx
jmp 0x4c79
movl %ecx, %ecx
movq %rcx, 0x20(%r15)
movq 0x8(%rbx), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x249c
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/samples/beatclock/beat.cpp
// Function: BeatClock::~BeatClock()
BeatClock::~BeatClock()
{
	timer->Stop();

	StoreConfig();

	DeleteObject(wnd);
	DeleteObject(title);
	DeleteObject(menubar);
	DeleteObject(timer);
	DeleteObject(dragcontrol);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x694b(%rip), %rax      # 0xc790
movq %rax, (%rdi)
movq 0x5d8(%rdi), %rdi
callq 0x51d0
movq 0x5b8(%rbx), %rdi
callq 0x5490
movq 0x5c0(%rbx), %rdi
callq 0x5490
movq 0x5c8(%rbx), %rdi
callq 0x5490
movq 0x5d8(%rbx), %rdi
callq 0x5490
movq 0x5d0(%rbx), %rdi
callq 0x5490
leaq 0x608(%rbx), %rdi
callq 0x54a0
movq %rbx, %rdi
popq %rbx
jmp 0x5280
movq %rax, %rdi
callq 0x6085
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/samples/beatclock/options.cpp
// Function: Options::OptionsBeats()
Void Options::OptionsBeats()
{
	display_check1->SetText("Show centibeats");
	misc_option1->SetText("Show/hide centibeats");
	alarm_text2->SetText("Internet Beats");
	alarm_edit1->SetText(String::FromInt(Math::Min(999, Time::SecondsToBeats(Time::TimeStringToSeconds(alarm_edit1->GetText())))));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x638(%rdi), %r14
leaq 0x18a8(%rip), %rsi      # 0x9250
movq %rsp, %r15
movq %r15, %rdi
callq 0x5400
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x54a0
movq 0x688(%rbx), %r14
leaq 0x1900(%rip), %rsi      # 0x92d8
movq %rsp, %r15
movq %r15, %rdi
callq 0x5400
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x54a0
movq 0x668(%rbx), %r14
leaq 0x182a(%rip), %rsi      # 0x9232
movq %rsp, %r15
movq %r15, %rdi
callq 0x5400
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x54a0
movq 0x660(%rbx), %rbx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa8(%rax)
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x53a0
movq %r14, %rdi
callq 0x849c
movl %eax, %edi
callq 0x8362
movl $0x3e7, %ecx            # imm = 0x3E7
cmpl %ecx, %eax
cmovll %eax, %ecx
movslq %ecx, %rsi
movq %rsp, %rdi
callq 0x5160
movq (%rbx), %rax
movq %rsp, %rsi
movq %rbx, %rdi
callq *0xa0(%rax)
movq %rsp, %rdi
callq 0x54a0
leaq 0x18(%rsp), %rdi
callq 0x54a0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54a0
jmp 0x7ab8
jmp 0x7aad
jmp 0x7aad
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x7abd
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x54a0
movq %rbx, %rdi
callq 0x5190
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/samples/beatclock/options.cpp
// Function: Options::OptionsSTF()
Void Options::OptionsSTF()
{
	display_check1->SetText("Show seconds");
	misc_option1->SetText("Show/hide seconds");
	alarm_text2->SetText("Hours/Minutes");
	alarm_edit1->SetText(Time::SecondsToTimeString(Math::Min(86340, Time::BeatsToSeconds(alarm_edit1->GetText().ToInt()))));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x638(%rdi), %r14
leaq 0x177c(%rip), %rsi      # 0x9260
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5400
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
leaq 0x8(%rsp), %rdi
callq 0x54a0
movq 0x688(%rbx), %r14
leaq 0x17d5(%rip), %rsi      # 0x92ed
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5400
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
leaq 0x8(%rsp), %rdi
callq 0x54a0
movq 0x668(%rbx), %r14
leaq 0x1755(%rip), %rsi      # 0x92a1
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5400
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xa0(%rax)
leaq 0x8(%rsp), %rdi
callq 0x54a0
movq 0x660(%rbx), %rbx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa8(%rax)
movq %rax, %rdi
callq 0x5140
movl %eax, %edi
callq 0x8350
movl $0x15144, %esi          # imm = 0x15144
cmpl %esi, %eax
cmovll %eax, %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8374
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0xa0(%rax)
leaq 0x8(%rsp), %rdi
callq 0x54a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7bd4
jmp 0x7bd4
jmp 0x7bd4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54a0
movq %rbx, %rdi
callq 0x5190
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/samples/beatclock/options.cpp
// Function: Options::OptionsOK()
Void Options::OptionsOK()
{
	if (timeformat == 0)
	{
		alarmbeats = Math::Min(999, (Int) alarm_edit1->GetText().ToInt());
		alarmsecs  = Time::BeatsToSeconds(alarmbeats);
	}
	else
	{
		alarmsecs  = Math::Min(86340, Time::TimeStringToSeconds(alarm_edit1->GetText()));
		alarmbeats = Time::SecondsToBeats(alarmsecs);
	}

	optionsdialog->Close();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x660(%rdi), %rdi
movq 0x6d0(%rbx), %rax
movl (%rax), %ebp
movq (%rdi), %rax
callq *0xa8(%rax)
testl %ebp, %ebp
je 0x7ca8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x53a0
movq %r14, %rdi
callq 0x849c
movl $0x15144, %ecx          # imm = 0x15144
cmpl %ecx, %eax
cmovll %eax, %ecx
movq 0x6f0(%rbx), %rax
movl %ecx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x54a0
movq 0x6f0(%rbx), %rax
movl (%rax), %edi
callq 0x8362
movl $0x6e8, %ecx            # imm = 0x6E8
jmp 0x7ccd
movq %rax, %rdi
callq 0x5140
movl $0x3e7, %edi            # imm = 0x3E7
cmpl %edi, %eax
cmovll %eax, %edi
movq 0x6e8(%rbx), %rax
movl %edi, (%rax)
callq 0x8350
movl $0x6f0, %ecx            # imm = 0x6F0
movq (%rbx,%rcx), %rcx
movl %eax, (%rcx)
movq 0x5e8(%rbx), %rdi
callq 0x5430
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54a0
movq %rbx, %rdi
callq 0x5190
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/samples/beatclock/options.cpp
// Function: Options::~Options()
Options::~Options()
{
	DeleteObject(optionsdialog);
	DeleteObject(optitle);

	DeleteObject(display);
	DeleteObject(alarm);
	DeleteObject(misc);
	DeleteObject(info);

	DeleteObject(main_button1);
	DeleteObject(main_button2);
	DeleteObject(main_reg1);

	DeleteObject(info_text1);
	DeleteObject(info_text2);

	DeleteObject(alarm_check1);
	DeleteObject(alarm_text1);
	DeleteObject(alarm_text2);
	DeleteObject(alarm_edit1);
	DeleteObject(alarm_option1);
	DeleteObject(alarm_option2);

	DeleteObject(misc_group1);
	DeleteObject(misc_option1);
	DeleteObject(misc_option2);
	DeleteObject(misc_option3);
	DeleteObject(misc_option4);

	DeleteObject(display_group1);
	DeleteObject(display_group2);
	DeleteObject(display_check1);
	DeleteObject(display_option1);
	DeleteObject(display_option2);
	DeleteObject(display_option3);
	DeleteObject(display_option4);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x4d0b(%rip), %rax      # 0xcab0
movq %rax, (%rdi)
movq 0x5e8(%rdi), %rdi
callq 0x5490
movq 0x610(%rbx), %rdi
callq 0x5490
movq 0x5f0(%rbx), %rdi
callq 0x5490
movq 0x5f8(%rbx), %rdi
callq 0x5490
movq 0x600(%rbx), %rdi
callq 0x5490
movq 0x608(%rbx), %rdi
callq 0x5490
movq 0x6b8(%rbx), %rdi
callq 0x5490
movq 0x6c0(%rbx), %rdi
callq 0x5490
movq 0x6c8(%rbx), %rdi
callq 0x5490
movq 0x6a8(%rbx), %rdi
callq 0x5490
movq 0x6b0(%rbx), %rdi
callq 0x5490
movq 0x650(%rbx), %rdi
callq 0x5490
movq 0x658(%rbx), %rdi
callq 0x5490
movq 0x668(%rbx), %rdi
callq 0x5490
movq 0x660(%rbx), %rdi
callq 0x5490
movq 0x670(%rbx), %rdi
callq 0x5490
movq 0x678(%rbx), %rdi
callq 0x5490
movq 0x680(%rbx), %rdi
callq 0x5490
movq 0x688(%rbx), %rdi
callq 0x5490
movq 0x690(%rbx), %rdi
callq 0x5490
movq 0x698(%rbx), %rdi
callq 0x5490
movq 0x6a0(%rbx), %rdi
callq 0x5490
movq 0x618(%rbx), %rdi
callq 0x5490
movq 0x620(%rbx), %rdi
callq 0x5490
movq 0x638(%rbx), %rdi
callq 0x5490
movq 0x628(%rbx), %rdi
callq 0x5490
movq 0x630(%rbx), %rdi
callq 0x5490
movq 0x640(%rbx), %rdi
callq 0x5490
movq 0x648(%rbx), %rdi
callq 0x5490
leaq 0x758(%rbx), %rdi
callq 0x808c
leaq 0x738(%rbx), %rdi
callq 0x54a0
movq %rbx, %rdi
popq %rbx
jmp 0x5080
movq %rax, %rdi
callq 0x6085
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/samples/beatclock/../../include/smooth/templates/signals/signal.h
// Function: int smooth::Signal0<void>::Connect<void>(smooth::Signal0<void>*)
Int Connect(SIGNALS_SIGNAL_CLASS_NAME<slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *sig)
			{
				if ((Signal *) sig == (Signal *) this) return Error();

				if (slotsN == NIL)
				{
					slotsN = new Array<Void *>();
					slotsN->EnableLocking();
				}

				slotsN->Add(new SIGNALS_SLOT_SIGNAL_CLASS_NAME<slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>(sig));

				return Success();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq %rdi, %rsi
je 0x8068
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
jne 0x803e
pushq $0x58
popq %rdi
callq 0x52d0
movq %rax, %r15
movq %rax, %rdi
callq 0x631a
movq %r15, 0x10(%r14)
movq %r15, %rdi
callq 0x51b0
movq 0x10(%r14), %r15
pushq $0x10
popq %rdi
callq 0x52d0
leaq 0x4c93(%rip), %rcx      # 0xcce0
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x6660
xorl %eax, %eax
jmp 0x806b
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r15, %rdi
callq 0x5050
movq %rbx, %rdi
callq 0x5190
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/samples/beatclock/time.cpp
// Function: Time::SecondsToTimeString(int)
String Time::SecondsToTimeString(Int seconds)
{
	String	 rstring;

	if (((Int) (seconds / 3600)) < 10) rstring.Append("0");

	rstring.Append(String::FromInt(seconds / 3600));
	rstring.Append(":");

	if (((Int) ((seconds % 3600) / 60)) < 10) rstring.Append("0");

	rstring.Append(String::FromInt((seconds % 3600) / 60));

	return rstring;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5270
movl $0xe10, %ecx            # imm = 0xE10
movl %r15d, %eax
cltd
idivl %ecx
movl %edx, %ebp
movl %eax, %r14d
cmpl $0x8c9f, %r15d          # imm = 0x8C9F
jg 0x83c6
leaq 0xcd1(%rip), %rsi       # 0x907c
movq %rsp, %rdi
callq 0x5400
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x50e0
movq %rsp, %rdi
callq 0x54a0
movslq %r14d, %rsi
movq %rsp, %rdi
callq 0x5160
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x50e0
movq %rsp, %rdi
callq 0x54a0
leaq 0xeb4(%rip), %rsi       # 0x929f
movq %rsp, %rdi
callq 0x5400
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x50e0
movq %rsp, %rdi
callq 0x54a0
movl %ebp, %eax
cwtd
movw $0x3c, %cx
idivw %cx
movl %eax, %r14d
cmpl $0x257, %ebp            # imm = 0x257
jg 0x843e
leaq 0xc59(%rip), %rsi       # 0x907c
movq %rsp, %rdi
callq 0x5400
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x50e0
movq %rsp, %rdi
callq 0x54a0
movswq %r14w, %rsi
movq %rsp, %rdi
callq 0x5160
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x50e0
movq %rsp, %rdi
callq 0x54a0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x847b
jmp 0x8488
jmp 0x847b
jmp 0x8488
jmp 0x847b
jmp 0x8488
jmp 0x847b
jmp 0x8488
movq %rax, %r14
movq %rsp, %rdi
callq 0x54a0
jmp 0x848b
movq %rax, %r14
movq %rbx, %rdi
callq 0x54a0
movq %r14, %rdi
callq 0x5190
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/samples/beatclock/time.cpp
// Function: Time::GetDayOfWeek(int, int, int)
Int Time::GetDayOfWeek(Int day, Int month, Int year)
{
	month += 10;
	year   = (month - 24) / 12 + year;
	day    = (((13 * (month - (month / 13) * 12) - 1) / 5 + day + 77 + 5 * (year - (year / 100) * 100) / 4 + year / 400 - (year / 100) * 2) % 7);

	return day;
}

// Assembly:
movl %edx, %r8d
leal 0xa(%rsi), %r9d
leal -0xe(%rsi), %eax
pushq $0xc
popq %rcx
cltd
idivl %ecx
movl %eax, %ecx
addl %r8d, %ecx
pushq $0xd
popq %r8
movl %r9d, %eax
cltd
idivl %r8d
imull $-0xc, %eax, %eax
addl %esi, %eax
addl $0xa, %eax
imull $0xd, %eax, %eax
decl %eax
pushq $0x5
popq %rsi
cltd
idivl %esi
movl %eax, %esi
pushq $0x64
popq %r8
movl %ecx, %eax
cltd
idivl %r8d
movl %eax, %r8d
imull $-0x64, %eax, %eax
addl %ecx, %eax
leal (%rax,%rax,4), %eax
pushq $0x4
popq %r9
cltd
idivl %r9d
movl %eax, %r9d
movl $0x190, %r10d           # imm = 0x190
movl %ecx, %eax
cltd
idivl %r10d
addl %edi, %eax
addl %r8d, %r8d
subl %r8d, %eax
addl %esi, %eax
addl %r9d, %eax
addl $0x4d, %eax
pushq $0x7
popq %rcx
cltd
idivl %ecx
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/samples/beatclock/time.cpp
// Function: Time::OutOfMonth(int, int, int)
Bool Time::OutOfMonth(Int day, Int month, Int year)
{
	if	(day > 31									  ) return True;
	else if (day > 30 && (month == 4 || month == 6 || month == 9 || month == 11)		  ) return True;
	else if (day > 29 && month == 2								  ) return True;
	else if (day > 28 && month == 2 && (year % 4 != 0 || (year % 100 == 0 && year % 400 != 0))) return True;

	return False;
}

// Assembly:
movb $0x1, %cl
cmpl $0x1f, %edi
jg 0x8622
movl %edx, %r8d
jne 0x85dc
leal -0x4(%rsi), %eax
cmpl $0x8, %eax
jae 0x85dc
movl $0xa5, %edx
btl %eax, %edx
jb 0x8622
cmpl $0x1e, %edi
setge %al
cmpl $0x2, %esi
sete %dl
testb %dl, %al
jne 0x8622
cmpl $0x2, %esi
setne %al
cmpl $0x1d, %edi
setl %dl
orb %al, %dl
jne 0x8620
testb $0x3, %r8b
jne 0x8622
pushq $0x64
popq %rsi
movl %r8d, %eax
cltd
idivl %esi
movl %edx, %esi
movl $0x190, %edi            # imm = 0x190
movl %r8d, %eax
cltd
idivl %edi
testl %esi, %esi
jne 0x8620
testl %edx, %edx
jne 0x8622
xorl %ecx, %ecx
movl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]push_swap_42/srcs_checker/ft_checker.c
// Function: main
int			main(int ac, char **av)
{
	t_stack	s;
	int		flag_v;
	int		flag_c;
	char	*s_arg;
	char	**arg;

	if (ac == 1)
		return (0);
	s.a = NULL;
	s.b = NULL;
	flag_v = 0;
	flag_c = 0;
	s_arg = ft_get_av_checker(av + 1);
	arg = ft_get_option(s_arg, &flag_v, &flag_c);
	s.size = ft_size_of_arg(arg);
	ft_set_a_and_b(&s, arg, s.size);
	ft_free_tab_str(arg);
	ft_exec(&s, flag_v, flag_c);
	ft_is_ok(s.a, s.size_a);
	ft_free_stack(&s);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x18(%rsp)
cmpl $0x1, %edi
je 0x1360
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andl $0x0, 0xc(%rsp)
andl $0x0, 0x8(%rsp)
xorl %ebp, %ebp
pushq $0x1
popq %r15
leaq 0x4ed0(%rip), %r12      # 0x6087
xorl %ebx, %ebx
movq 0x18(%rsp), %rax
movq 0x8(%rax,%rbp,8), %rdi
testq %rdi, %rdi
je 0x120e
pushq $0x20
popq %rsi
callq 0x1cb8
movq %rax, %r14
movq %rax, %r13
movq (%r13), %rsi
testq %rsi, %rsi
je 0x1201
movq %rbx, %rdi
movl %r15d, %edx
callq 0x1bed
movq %rax, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x1bed
movq %rax, %rbx
addq $0x8, %r13
jmp 0x11d6
movq %r14, %rdi
callq 0x1c54
incq %rbp
jmp 0x11b9
movq %rbx, 0x10(%rsp)
leaq 0x1(%rbx), %rcx
xorl %eax, %eax
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rsi
cltq
cmpb $0x2d, (%rbx,%rax)
jne 0x126a
movzbl 0x1(%rbx,%rax), %edi
cmpl $0x76, %edi
je 0x123a
cmpl $0x63, %edi
jne 0x126a
leaq 0x1(%rax), %r8
addq %rcx, %r8
addl $0x2, %eax
movq %rdx, %r9
cmpb $0x76, %dil
je 0x1259
movzbl %dil, %edi
cmpl $0x63, %edi
jne 0x1223
movq %rsi, %r9
movl $0x1, (%r9)
movb (%r8), %dil
incl %eax
incq %r8
jmp 0x1244
addq %rax, %rbx
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x1cb8
movq %rax, %rbx
testq %rax, %rax
je 0x1390
cmpq $0x0, (%rbx)
je 0x1390
leaq 0x10(%rsp), %rdi
callq 0x1c38
leaq 0x4d65(%rip), %r14      # 0x6004
movq %rbx, %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x12e8
movq %r14, %rsi
callq 0x1b14
testl %eax, %eax
jne 0x1371
movq (%r15), %rdi
callq 0x1c88
testl %eax, %eax
jne 0x12e2
movq (%r15), %rdi
cmpb $0x2d, (%rdi)
jne 0x1371
incq %rdi
callq 0x1c88
testl %eax, %eax
je 0x1371
addq $0x8, %r15
jmp 0x12a2
movq %rbx, %rdi
callq 0x1b00
movslq %eax, %rdx
leaq 0x20(%rsp), %r14
movq %rdx, 0x18(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a6d
movq %rbx, %rdi
callq 0x1c54
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
movq %r14, %rdi
callq 0x13ac
movq (%r14), %rax
movslq 0x20(%r14), %rcx
pushq $0x1
popq %rsi
leaq 0x4cdf(%rip), %rdi      # 0x600f
leaq 0x4cd5(%rip), %rdx      # 0x600c
cmpq %rcx, %rsi
jge 0x1351
movq -0x8(%rax,%rsi,8), %r8
leaq 0x1(%rsi), %r9
cmpq (%rax,%rsi,8), %r8
movq %r9, %rsi
jge 0x1337
movq %rdx, %rdi
callq 0x1eac
leaq 0x20(%rsp), %rdi
callq 0x18a0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x1c54
leaq 0x4c86(%rip), %rdi      # 0x6006
pushq $0x2
popq %rsi
callq 0x1ee4
pushq $0x1
popq %rdi
callq 0x1070
leaq 0x10(%rsp), %rdi
callq 0x1c38
movq %rbx, %rdi
callq 0x1c54
xorl %edi, %edi
callq 0x1070
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]push_swap_42/srcs_checker/ft_exec.c
// Function: ft_exec
void		ft_exec(t_stack *s, int flag_v, int flag_c)
{
	char	*line;
	int		step;

	step = 1;
	line = NULL;
	if (flag_v)
	{
		ft_printf("\033[2J\033[;H");
		ft_printf("---> \033[031mINIT\033[0m\n");
		ft_print_stack(s);
	}
	while (get_next_line(0, &line) > 0)
	{
		ft_process(s, &line);
		if (flag_v)
		{
			ft_printf("\033[2J\033[;H");
			ft_printf("---> \033[031mSTEP %d\033[0m\n", step++);
			ft_print_stack(s);
		}
		if (flag_c)
			ft_exec_flag_c(line, flag_v);
		ft_strdel(&line);
	}
	ft_strdel(&line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
andq $0x0, (%rsp)
testl %esi, %esi
je 0x13eb
leaq 0x4c44(%rip), %rdi      # 0x6012
xorl %eax, %eax
callq 0x2398
leaq 0x4c3f(%rip), %rdi      # 0x601b
xorl %eax, %eax
callq 0x2398
movq %r14, %rdi
callq 0x14e0
pushq $0x1
popq %r13
movq %rsp, %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x1f94
testl %eax, %eax
jle 0x14c8
movq (%rsp), %rsi
movzbl (%rsi), %eax
cmpl $0x70, %eax
je 0x142e
cmpl $0x72, %eax
je 0x1424
cmpl $0x73, %eax
jne 0x143a
movq %r14, %rdi
callq 0x1628
jmp 0x1436
movq %r14, %rdi
callq 0x175e
jmp 0x1436
movq %r14, %rdi
callq 0x16c9
testl %eax, %eax
jne 0x144a
movq %r15, %rdi
callq 0x1c38
movq %r14, %rdi
callq 0x18ca
testl %ebp, %ebp
je 0x149f
leaq 0x4bbd(%rip), %rdi      # 0x6012
xorl %eax, %eax
callq 0x2398
leal 0x1(%r13), %r12d
leaq 0x4bc9(%rip), %rdi      # 0x6030
movl %r13d, %esi
xorl %eax, %eax
callq 0x2398
movq %r14, %rdi
callq 0x14e0
testl %ebx, %ebx
je 0x14b8
movq (%rsp), %rsi
leaq 0x4bc0(%rip), %rdi      # 0x6048
xorl %eax, %eax
callq 0x2398
leaq 0x4be0(%rip), %rdi      # 0x6076
xorl %eax, %eax
callq 0x2398
jmp 0x14b8
testl %ebx, %ebx
je 0x14b5
movq (%rsp), %rsi
leaq 0x4bdb(%rip), %rdi      # 0x6089
xorl %eax, %eax
callq 0x2398
movl %r13d, %r12d
movq %r15, %rdi
callq 0x1c38
movl %r12d, %r13d
jmp 0x13f2
movq %rsp, %rdi
callq 0x1c38
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]push_swap_42/srcs_checker/ft_print_stack.c
// Function: ft_print_stack
void			ft_print_stack(t_stack *s)
{
	size_t	i;
	size_t	size_max;

	size_max = s->size;
	i = 0;
	ft_putstr("\n    |       \033[32mstack A\033[0m       |       ");
	ft_putendl("\033[32mstack B\033[0m       |");
	ft_putendl("    |                     |                     |");
	while (i < size_max)
	{
		ft_putstr("    |");
		ft_print_case(s->a, s->size_a, size_max - 1 - i);
		ft_putstr(" | ");
		ft_print_case(s->b, s->size_b, size_max - 1 - i);
		ft_putendl("|");
		i++;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x4bab(%rip), %rdi      # 0x60a2
callq 0x1e8c
leaq 0x4bcc(%rip), %rdi      # 0x60cf
callq 0x1eac
leaq 0x4bd9(%rip), %rdi      # 0x60e8
callq 0x1eac
decq %r14
leaq 0x4bf6(%rip), %r15      # 0x6114
leaq 0x4bf5(%rip), %r12      # 0x611a
leaq 0x4bec(%rip), %r13      # 0x6118
cmpq $-0x1, %r14
je 0x156e
movq %r15, %rdi
callq 0x1e8c
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq %r14, %rdx
callq 0x1578
movq %r12, %rdi
callq 0x1e8c
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq %r14, %rdx
callq 0x1578
movq %r13, %rdi
callq 0x1eac
decq %r14
jmp 0x152c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq