// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl (%r15), %eax
cmpl $0x9, %eax
jne 0x6c52
movq 0x8(%r15), %r15
jmp 0x6c44
cmpl $0xc, %eax
ja 0x72d9
movl %eax, %eax
leaq 0x36fc(%rip), %rcx      # 0xa360
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r15), %rsi
jmp 0x6f20
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c27
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74c5
movq %rax, %r12
movq %rax, %rdi
callq 0x8477
leaq 0x38bb(%rip), %rsi      # 0xa561
movq %rax, %rdi
callq 0x3180
testl %eax, %eax
je 0x6d81
leaq -0x140(%rbp), %r13
movb $0x0, (%r13)
movq %r13, %rdi
callq 0x3100
movabsq $0x28676e69727473, %rcx # imm = 0x28676E69727473
movq %rcx, -0x140(%rbp,%rax)
movq %r12, %rdi
callq 0x8477
movq %r13, %rdi
movq %rax, %rsi
callq 0x3280
movq %r13, %rdi
callq 0x3100
movw $0x29, -0x140(%rbp,%rax)
movq %r14, %rdi
movq %r13, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x80e4
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x77d5
movl %eax, -0x34(%rbp)
leaq 0x18(%rbx), %r13
movq %r14, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb $0x7, (%rax)
movq %r14, %rdi
movq %r13, %rsi
movl $0x2, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movl -0x34(%rbp), %edx
movb %dl, (%rax)
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb %dh, (%rax)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x82ed
movq %r14, %rdi
movq %r12, %rsi
callq 0x82ed
movq 0x10(%r15), %rdx
testq %rdx, %rdx
je 0x6f7d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c27
leaq 0x4098(%rip), %rsi      # 0xae43
movq %r14, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x80e4
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x77d5
movl %eax, %r13d
leaq 0x18(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb $0x7, (%rax)
movq %r14, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movl %r13d, %edx
movb %dl, (%rax)
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb %dh, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x82ed
jmp 0x6f7d
cmpl $0x0, 0x18(%r15)
jne 0x72f8
movq 0x8(%r15), %r13
cmpl $0x0, (%r13)
jne 0x7317
movq 0x8(%r13), %rdx
testq %rdx, %rdx
je 0x6e59
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c27
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c27
movq 0x8(%r13), %rdx
testq %rdx, %rdx
je 0x724b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74c5
movq %rax, %r12
movq (%rbx), %rsi
movq 0x10(%r13), %rcx
movq %r14, %rdi
movq %rax, %rdx
callq 0x772f
movl %eax, %r15d
movq %r14, %rdi
movq %r12, %rsi
callq 0x82ed
testl %r15d, %r15d
js 0x6f7d
leaq 0x18(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb $0x6, (%rax)
jmp 0x7001
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x6f20
movq %rsi, %rdi
callq 0x8322
movq %rax, %rsi
jmp 0x6f20
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c27
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c27
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x79bd
jmp 0x7171
movzbl 0x4(%r15), %esi
movq %rbx, %rdi
callq 0x7770
movl %eax, %r12d
leaq 0x18(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb $0x0, (%rax)
movq %r14, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movl %r12d, %edx
movb %dl, (%rax)
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb %dh, (%rax)
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x71f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c27
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74c5
movq %rax, %r12
movq (%rbx), %rsi
movq 0x10(%r15), %rcx
movq %r14, %rdi
movq %rax, %rdx
callq 0x772f
movl %eax, %r15d
movq %r14, %rdi
movq %r12, %rsi
callq 0x82ed
testl %r15d, %r15d
js 0x6f7d
leaq 0x18(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb $0x5, (%rax)
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb %r15b, (%rax)
jmp 0x6f7d
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c27
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x785e
jmp 0x7171
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c27
leaq 0x18(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb $0xa, (%rax)
movq 0x18(%rbx), %r13
movq %r14, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%rbx)
movb %cl, (%rax)
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c27
cmpq $0x0, 0x18(%r15)
je 0x7237
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb $0x8, (%rax)
movq 0x18(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %r14, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
xorl %ecx, %ecx
movb %cl, (%rax)
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%rbx)
movb %cl, (%rax)
movl 0x18(%rbx), %eax
subl %r13d, %eax
addl $-0x2, %eax
movw %ax, (%r13)
movq 0x18(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c27
movl 0x18(%rbx), %eax
movq -0x30(%rbp), %rcx
subl %ecx, %eax
addl $-0x2, %eax
movw %ax, (%rcx)
jmp 0x6f7d
movq 0x10(%r15), %r12
movq %r14, %rdi
movq %rbx, %rsi
testq %r12, %r12
je 0x7169
movq %r12, %rdx
callq 0x6c27
movq 0x10(%r12), %r12
jmp 0x714f
movq %r15, %rdx
callq 0x7ccb
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x77d5
movl %eax, %r13d
leaq 0x18(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb $0x7, (%rax)
movq %r14, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movl %r13d, %edx
movb %dl, (%rax)
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb %dh, (%rax)
movq %r14, %rdi
movq %r15, %rsi
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x82ed
movzbl 0x1a30(%rbx), %eax
testq %rax, %rax
je 0x7216
movq 0x10(%r15), %rcx
leaq 0x130(%rbx), %r12
cmpq %rcx, (%r12)
je 0x7219
addq $0x18, %r12
decq %rax
jne 0x7207
xorl %r12d, %r12d
testq %r12, %r12
je 0x7336
leaq 0x18(%rbx), %r15
movb 0x11(%r12), %r13b
xorb $0x1, %r13b
addb %r13b, %r13b
incb %r13b
jmp 0x7291
movl (%r12), %eax
subl %r13d, %eax
addl $-0x2, %eax
movw %ax, (%r13)
jmp 0x6f7d
movzbl 0x1a30(%rbx), %eax
testq %rax, %rax
je 0x7271
movq 0x10(%r13), %rcx
leaq 0x130(%rbx), %r12
cmpq %rcx, (%r12)
je 0x7274
addq $0x18, %r12
decq %rax
jne 0x7262
xorl %r12d, %r12d
testq %r12, %r12
je 0x7355
leaq 0x18(%rbx), %r15
movb 0x11(%r12), %r13b
xorb $0x1, %r13b
addb %r13b, %r13b
addb $0x2, %r13b
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb %r13b, (%rax)
movb 0x10(%r12), %r12b
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x7eaf
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
movb %r12b, (%rax)
jmp 0x6f7d
leaq 0x2de1(%rip), %rdi      # 0xa0c1
leaq 0x316b(%rip), %rsi      # 0xa452
leaq 0x3224(%rip), %rcx      # 0xa512
movl $0x20d, %edx            # imm = 0x20D
callq 0x3120
leaq 0x3269(%rip), %rdi      # 0xa568
leaq 0x314c(%rip), %rsi      # 0xa452
leaq 0x3205(%rip), %rcx      # 0xa512
movl $0x1f1, %edx            # imm = 0x1F1
callq 0x3120
leaq 0x3278(%rip), %rdi      # 0xa596
leaq 0x312d(%rip), %rsi      # 0xa452
leaq 0x31e6(%rip), %rcx      # 0xa512
movl $0x1f2, %edx            # imm = 0x1F2
callq 0x3120
leaq 0x31cf(%rip), %rdi      # 0xa50c
leaq 0x310e(%rip), %rsi      # 0xa452
leaq 0x31c7(%rip), %rcx      # 0xa512
movl $0x15b, %edx            # imm = 0x15B
callq 0x3120
leaq 0x31b0(%rip), %rdi      # 0xa50c
leaq 0x30ef(%rip), %rsi      # 0xa452
leaq 0x31a8(%rip), %rcx      # 0xa512
movl $0x204, %edx            # imm = 0x204
callq 0x3120