// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_compile_expr
static void fin_mod_compile_expr(fin_ctx_t* ctx, fin_mod_compiler_t* cmp, fin_ast_expr_t* expr) {
    switch (expr->type) {
        case fin_ast_expr_type_id: {
            fin_ast_id_expr_t* id_expr = (fin_ast_id_expr_t*)expr;
            if (id_expr->primary) {
                fin_mod_compile_expr(ctx, cmp, id_expr->primary);
                fin_str_t* type_name = fin_mod_resolve_type(ctx, cmp, id_expr->primary);
                int32_t field_idx = fin_mod_resolve_field(ctx, cmp->mod, type_name, id_expr->name);
                fin_str_destroy(ctx, type_name);
                if (field_idx >= 0) {
                    fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_load_field);
                    fin_mod_code_emit_uint8(ctx, &cmp->code, field_idx);
                    FIN_LOG("\tload_fld   %2d         // %s\n", field_idx, fin_str_cstr(id_expr->name));
                    break;
                }
            }
            else {
                fin_mod_local_t* local = fin_mod_resolve_local(cmp, id_expr->name);
                assert(local);
                fin_mod_code_emit_uint8(ctx, &cmp->code, local->is_param ? fin_op_load_arg : fin_op_load_local);
                fin_mod_code_emit_uint8(ctx, &cmp->code, local->idx);
                FIN_LOG("\t%s   %2d         // %s\n",
                    local->is_param ? "load_arg" : "load_loc", local->idx, fin_str_cstr(local->name));
            }
            break;
        }
        case fin_ast_expr_type_bool: {
            fin_ast_bool_expr_t* bool_expr = (fin_ast_bool_expr_t*)expr;
            fin_val_t val = { .b = bool_expr->value };
            int16_t idx = fin_mod_const_idx(cmp, val);
            fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_load_const);
            fin_mod_code_emit_uint16(ctx, &cmp->code, idx);
            FIN_LOG("\tload_const %2d         // %s\n", idx, bool_expr->value ? "true" : "false");
            break;
        }
        case fin_ast_expr_type_int: {
            fin_ast_int_expr_t* int_expr = (fin_ast_int_expr_t*)expr;
            fin_val_t val = { .i = int_expr->value };
            int16_t idx = fin_mod_const_idx(cmp, val);
            fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_load_const);
            fin_mod_code_emit_uint16(ctx, &cmp->code, idx);
            FIN_LOG("\tload_const %2d         // %d\n", idx, (int32_t)int_expr->value);
            break;
        }
        case fin_ast_expr_type_float: {
            fin_ast_float_expr_t* float_expr = (fin_ast_float_expr_t*)expr;
            fin_val_t val = { .f = float_expr->value };
            int16_t idx = fin_mod_const_idx(cmp, val);
            fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_load_const);
            fin_mod_code_emit_uint16(ctx, &cmp->code, idx);
            FIN_LOG("\tload_const %2d         // %f\n", idx, float_expr->value);
            break;
        }
        case fin_ast_expr_type_str: {
            fin_ast_str_expr_t* str_expr = (fin_ast_str_expr_t*)expr;
            fin_val_t val = { .s = str_expr->value };
            if (val.s)
                val.s = fin_str_clone(val.s);
            int16_t idx = fin_mod_const_idx(cmp, val);
            fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_load_const);
            fin_mod_code_emit_uint16(ctx, &cmp->code, idx);
            FIN_LOG("\tload_const %2d         // \"%s\"\n", idx, fin_str_cstr(str_expr->value));
            break;
        }
        case fin_ast_expr_type_str_interp: {
            fin_ast_str_interp_expr_t* interp_expr = (fin_ast_str_interp_expr_t*)expr;
            fin_mod_compile_expr(ctx, cmp, interp_expr->expr);
            fin_str_t* type = fin_mod_resolve_type(ctx, cmp, interp_expr->expr);
            if (strcmp(fin_str_cstr(type), "string") != 0) {
                char signature[256];
                signature[0] = '\0';
                strcat(signature, "string(");
                strcat(signature, fin_str_cstr(type));
                strcat(signature, ")");
                fin_str_t* sign = fin_str_create(ctx, signature, -1);
                int16_t idx = fin_mod_bind_idx(cmp, sign);
                fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_call);
                fin_mod_code_emit_uint16(ctx, &cmp->code, idx);
                FIN_LOG("\tcall       %2d         // %s\n", idx, fin_str_cstr(sign));
                fin_str_destroy(ctx, sign);
            }
            fin_str_destroy(ctx, type);
            if (interp_expr->next) {
                fin_mod_compile_expr(ctx, cmp, &interp_expr->next->base);
                fin_str_t* sign = fin_str_create(ctx, "__op_add(string,string)", -1);
                int16_t idx = fin_mod_bind_idx(cmp, sign);
                fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_call);
                fin_mod_code_emit_uint16(ctx, &cmp->code, idx);
                FIN_LOG("\tcall       %2d         // %s\n", idx, fin_str_cstr(sign));
                fin_str_destroy(ctx, sign);
            }
            break;
        }
        case fin_ast_expr_type_unary: {
            fin_ast_unary_expr_t* unary_expr = (fin_ast_unary_expr_t*)expr;
            fin_mod_compile_expr(ctx, cmp, unary_expr->expr);

            fin_str_t* sign = fin_mod_unary_get_signature(ctx, cmp, unary_expr);
            int16_t idx = fin_mod_bind_idx(cmp, sign);
            fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_call);
            fin_mod_code_emit_uint16(ctx, &cmp->code, idx);
            FIN_LOG("\tcall       %2d         // %s\n", idx, fin_str_cstr(sign));
            fin_str_destroy(ctx, sign);
            break;
        }
        case fin_ast_expr_type_binary: {
            fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)expr;
            fin_mod_compile_expr(ctx, cmp, bin_expr->lhs);
            fin_mod_compile_expr(ctx, cmp, bin_expr->rhs);

            fin_str_t* sign = fin_mod_binary_get_signature(ctx, cmp, bin_expr);
            int16_t idx = fin_mod_bind_idx(cmp, sign);
            fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_call);
            fin_mod_code_emit_uint16(ctx, &cmp->code, idx);
            FIN_LOG("\tcall       %2d         // %s\n", idx, fin_str_cstr(sign));
            fin_str_destroy(ctx, sign);
            break;
        }
        case fin_ast_expr_type_cond: {
            fin_ast_cond_expr_t* cond_expr = (fin_ast_cond_expr_t*)expr;
            fin_mod_compile_expr(ctx, cmp, cond_expr->cond);
            fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_branch_if_n);
            uint8_t* lbl_else = cmp->code.top;
            fin_mod_code_emit_uint16(ctx, &cmp->code, 0);
            FIN_LOG("\tbr_if_n     lbl_%d\n", (int32_t)(lbl_else - cmp->code.begin));
            fin_mod_compile_expr(ctx, cmp, cond_expr->true_expr);
            if (cond_expr->false_expr) {
                fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_branch);
                uint8_t* lbl_end = cmp->code.top;
                fin_mod_code_emit_uint16(ctx, &cmp->code, 0);
                FIN_LOG("\tbr          lbl_%d\n", (int32_t)(lbl_end - cmp->code.begin));
                FIN_LOG("lbl_%d:\n", (int32_t)(lbl_else - cmp->code.begin));
                uint16_t offset = cmp->code.top - lbl_else - 2;
                *lbl_else++ = offset & 0xFF;
                *lbl_else++ = (offset >> 8) & 0xFF;
                fin_mod_compile_expr(ctx, cmp, cond_expr->false_expr);
                FIN_LOG("lbl_%d:\n", (int32_t)(lbl_end - cmp->code.begin));
                offset = cmp->code.top - lbl_end - 2;
                *lbl_end++ = offset & 0xFF;
                *lbl_end++ = (offset >> 8) & 0xFF;
            }
            else {
                FIN_LOG("lbl_%d:\n", (int32_t)(lbl_else - cmp->code.begin));
                uint16_t offset = cmp->code.top - lbl_else - 2;
                *lbl_else++ = offset & 0xFF;
                *lbl_else++ = (offset >> 8) & 0xFF;
            }
            break;
        }
        case fin_ast_expr_type_arg: {
            fin_ast_arg_expr_t* arg_expr = (fin_ast_arg_expr_t*)expr;
            fin_mod_compile_expr(ctx, cmp, arg_expr->expr);
            break;
        }
        case fin_ast_expr_type_invoke: {
            fin_ast_invoke_expr_t* invoke_expr = (fin_ast_invoke_expr_t*)expr;
            for (fin_ast_arg_expr_t* e = invoke_expr->args; e; e = e->next)
                fin_mod_compile_expr(ctx, cmp, &e->base);
            fin_str_t* sign = fin_mod_invoke_get_signature(ctx, cmp, invoke_expr);
            int16_t idx = fin_mod_bind_idx(cmp, sign);
            fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_call);
            fin_mod_code_emit_uint16(ctx, &cmp->code, idx);
            FIN_LOG("\tcall       %2d         // %s\n", idx, fin_str_cstr(sign));
            fin_str_destroy(ctx, sign);
            break;
        }
        case fin_ast_expr_type_assign: {
            fin_ast_assign_expr_t* assign_expr = (fin_ast_assign_expr_t*)expr;
            assert(assign_expr->op == fin_ast_assign_type_assign); // rest not supported yet
            assert(assign_expr->lhs->type == fin_ast_expr_type_id);
            fin_ast_id_expr_t* id_expr = (fin_ast_id_expr_t*)assign_expr->lhs;
            if (id_expr->primary)
                fin_mod_compile_expr(ctx, cmp, id_expr->primary);
            fin_mod_compile_expr(ctx, cmp, assign_expr->rhs);
            if (id_expr->primary) {
                fin_str_t* type_name = fin_mod_resolve_type(ctx, cmp, id_expr->primary);
                int32_t field_idx = fin_mod_resolve_field(ctx, cmp->mod, type_name, id_expr->name);
                fin_str_destroy(ctx, type_name);
                if (field_idx >= 0) {
                    fin_mod_code_emit_uint8(ctx, &cmp->code, fin_op_store_field);
                    fin_mod_code_emit_uint8(ctx, &cmp->code, field_idx);
                    FIN_LOG("\tstore_fld  %2d         // %s\n", field_idx, fin_str_cstr(id_expr->name));
                    break;
                }
            }
            else {
                fin_mod_local_t* local = fin_mod_resolve_local(cmp, id_expr->name);
                assert(local);
                fin_mod_code_emit_uint8(ctx, &cmp->code, local->is_param ? fin_op_store_arg : fin_op_store_local);
                fin_mod_code_emit_uint8(ctx, &cmp->code, local->idx);
                FIN_LOG("\t%s  %2d         // %s\n",
                local->is_param ? "store_arg" : "store_loc", local->idx, fin_str_cstr(local->name));
            }
            break;
        }
        default:
            assert(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x278(%rbp)
subq $0xc, %rax
ja 0x9945
movq -0x278(%rbp), %rax
leaq 0x473c(%rip), %rcx      # 0xd5a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8f23
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x8e30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x9cb0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0xa0b0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xb0b0
cmpl $0x0, -0x2c(%rbp)
jl 0x8f1e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x5, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl -0x2c(%rbp), %eax
movzbl %al, %edx
callq 0x8d90
jmp 0x9964
jmp 0x8fa4
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x9c30
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x8f41
jmp 0x8f60
leaq 0x4816(%rip), %rdi      # 0xd75e
leaq 0x4755(%rip), %rsi      # 0xd6a4
movl $0x15b, %edx            # imm = 0x15B
leaq 0x4809(%rip), %rcx      # 0xd764
callq 0x3110
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x38(%rbp), %rax
movb 0x11(%rax), %dl
movl $0x3, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movzbl %al, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x38(%rbp), %rax
movzbl 0x10(%rax), %edx
callq 0x8d90
jmp 0x9964
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb 0x4(%rax), %al
andb $0x1, %al
movb %al, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xa140
movw %ax, -0x4a(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
xorl %edx, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movzwl -0x4a(%rbp), %edx
callq 0x9b10
jmp 0x9964
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xa140
movw %ax, -0x62(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
xorl %edx, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movzwl -0x62(%rbp), %edx
callq 0x9b10
jmp 0x9964
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xa140
movw %ax, -0x7a(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
xorl %edx, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movzwl -0x7a(%rbp), %edx
callq 0x9b10
jmp 0x9964
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
je 0x90db
movq -0x90(%rbp), %rdi
callq 0xb130
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xa140
movw %ax, -0x92(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
xorl %edx, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movzwl -0x92(%rbp), %edx
callq 0x9b10
jmp 0x9964
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0xa0(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x8e30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0xa0(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x9cb0
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
callq 0xb370
movq %rax, %rdi
leaq 0x4639(%rip), %rsi      # 0xd7b3
callq 0x3170
cmpl $0x0, %eax
je 0x924f
movb $0x0, -0x1b0(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq 0x461d(%rip), %rsi      # 0xd7ba
callq 0x3270
leaq -0x1b0(%rbp), %rax
movq %rax, -0x280(%rbp)
movq -0xa8(%rbp), %rdi
callq 0xb370
movq -0x280(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
leaq -0x1b0(%rbp), %rdi
leaq 0x4f3b(%rip), %rsi      # 0xe114
callq 0x3270
movq -0x8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xae20
movq %rax, -0x1b8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
callq 0xa1d0
movw %ax, -0x1ba(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x7, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movzwl -0x1ba(%rbp), %edx
callq 0x9b10
movq -0x8(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
callq 0xb0b0
movq -0x8(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0xb0b0
movq -0xa0(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x92fa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0xa0(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x8e30
movq -0x8(%rbp), %rdi
leaq 0x4e13(%rip), %rsi      # 0xe0a7
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xae20
movq %rax, -0x1c8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x1c8(%rbp), %rsi
callq 0xa1d0
movw %ax, -0x1ca(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x7, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movzwl -0x1ca(%rbp), %edx
callq 0x9b10
movq -0x8(%rbp), %rdi
movq -0x1c8(%rbp), %rsi
callq 0xb0b0
jmp 0x9964
movq -0x18(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x1d8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x8e30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x1d8(%rbp), %rdx
callq 0xa2a0
movq %rax, -0x1e0(%rbp)
movq -0x10(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
callq 0xa1d0
movw %ax, -0x1e2(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x7, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movzwl -0x1e2(%rbp), %edx
callq 0x9b10
movq -0x8(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
callq 0xb0b0
jmp 0x9964
movq -0x18(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x1f0(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x8e30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x1f0(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x8e30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x1f0(%rbp), %rdx
callq 0xa3f0
movq %rax, -0x1f8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x1f8(%rbp), %rsi
callq 0xa1d0
movw %ax, -0x1fa(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x7, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movzwl -0x1fa(%rbp), %edx
callq 0x9b10
movq -0x8(%rbp), %rdi
movq -0x1f8(%rbp), %rsi
callq 0xb0b0
jmp 0x9964
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x208(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x8e30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0xa, %edx
callq 0x8d90
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x210(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
xorl %edx, %edx
callq 0x9b10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x208(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x8e30
movq -0x208(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x95f2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x8, %edx
callq 0x8d90
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x218(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
xorl %edx, %edx
callq 0x9b10
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x210(%rbp), %rcx
subq %rcx, %rax
subq $0x2, %rax
movw %ax, -0x21a(%rbp)
movzwl -0x21a(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x210(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x210(%rbp)
movb %cl, (%rax)
movzwl -0x21a(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x210(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x210(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x208(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x8e30
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x218(%rbp), %rcx
subq %rcx, %rax
subq $0x2, %rax
movw %ax, -0x21a(%rbp)
movzwl -0x21a(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x218(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x218(%rbp)
movb %cl, (%rax)
movzwl -0x21a(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x218(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x218(%rbp)
movb %cl, (%rax)
jmp 0x965c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x210(%rbp), %rcx
subq %rcx, %rax
subq $0x2, %rax
movw %ax, -0x21c(%rbp)
movzwl -0x21c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x210(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x210(%rbp)
movb %cl, (%rax)
movzwl -0x21c(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x210(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x210(%rbp)
movb %cl, (%rax)
jmp 0x9964
movq -0x18(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x228(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x8e30
jmp 0x9964
movq -0x18(%rbp), %rax
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x238(%rbp)
cmpq $0x0, -0x238(%rbp)
je 0x96d8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x238(%rbp), %rdx
callq 0x8e30
movq -0x238(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x238(%rbp)
jmp 0x96a6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x230(%rbp), %rdx
callq 0xa6e0
movq %rax, -0x240(%rbp)
movq -0x10(%rbp), %rdi
movq -0x240(%rbp), %rsi
callq 0xa1d0
movw %ax, -0x242(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x7, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movzwl -0x242(%rbp), %edx
callq 0x9b10
movq -0x8(%rbp), %rdi
movq -0x240(%rbp), %rsi
callq 0xb0b0
jmp 0x9964
movq -0x18(%rbp), %rax
movq %rax, -0x250(%rbp)
movq -0x250(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x9767
jmp 0x9786
leaq 0x4054(%rip), %rdi      # 0xd7c2
leaq 0x3f2f(%rip), %rsi      # 0xd6a4
movl $0x1f1, %edx            # imm = 0x1F1
leaq 0x3fe3(%rip), %rcx      # 0xd764
callq 0x3110
movq -0x250(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
jne 0x9798
jmp 0x97b7
leaq 0x4051(%rip), %rdi      # 0xd7f0
leaq 0x3efe(%rip), %rsi      # 0xd6a4
movl $0x1f2, %edx            # imm = 0x1F2
leaq 0x3fb2(%rip), %rcx      # 0xd764
callq 0x3110
movq -0x250(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x258(%rbp)
movq -0x258(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x97ef
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x258(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x8e30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x250(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x8e30
movq -0x258(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x98b3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x258(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x9cb0
movq %rax, -0x260(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x260(%rbp), %rdx
movq -0x258(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0xa0b0
movl %eax, -0x264(%rbp)
movq -0x8(%rbp), %rdi
movq -0x260(%rbp), %rsi
callq 0xb0b0
cmpl $0x0, -0x264(%rbp)
jl 0x98ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x6, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl -0x264(%rbp), %eax
movzbl %al, %edx
callq 0x8d90
jmp 0x9964
jmp 0x9943
movq -0x10(%rbp), %rdi
movq -0x258(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x9c30
movq %rax, -0x270(%rbp)
cmpq $0x0, -0x270(%rbp)
je 0x98da
jmp 0x98f9
leaq 0x3e7d(%rip), %rdi      # 0xd75e
leaq 0x3dbc(%rip), %rsi      # 0xd6a4
movl $0x204, %edx            # imm = 0x204
leaq 0x3e70(%rip), %rcx      # 0xd764
callq 0x3110
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x270(%rbp), %rax
movb 0x11(%rax), %dl
movl $0x4, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movzbl %al, %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x270(%rbp), %rax
movzbl 0x10(%rax), %edx
callq 0x8d90
jmp 0x9964
leaq 0x38c9(%rip), %rdi      # 0xd215
leaq 0x3d51(%rip), %rsi      # 0xd6a4
movl $0x20d, %edx            # imm = 0x20D
leaq 0x3e05(%rip), %rcx      # 0xd764
callq 0x3110
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nopl (%rax)