// File: /workspace/github_c_makefile_star2_O3/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_canvas.c
// Function: lv_canvas_rotate
void lv_canvas_rotate(lv_obj_t * canvas, lv_img_dsc_t * img, int16_t angle, lv_coord_t offset_x, lv_coord_t offset_y,
                      int32_t pivot_x, int32_t pivot_y)
{
    LV_ASSERT_OBJ(canvas, LV_OBJX_NAME);
    LV_ASSERT_NULL(img);

    lv_canvas_ext_t * ext_dst = lv_obj_get_ext_attr(canvas);
    const lv_style_t * style  = lv_canvas_get_style(canvas, LV_CANVAS_STYLE_MAIN);
    int32_t sinma             = lv_trigo_sin(-angle);
    int32_t cosma             = lv_trigo_sin(-angle + 90); /* cos */

    int32_t img_width   = img->header.w;
    int32_t img_height  = img->header.h;
    int32_t dest_width  = ext_dst->dsc.header.w;
    int32_t dest_height = ext_dst->dsc.header.h;

    int32_t x;
    int32_t y;
    for(x = -offset_x; x < dest_width - offset_x; x++) {
        for(y = -offset_y; y < dest_height - offset_y; y++) {
            /*Get the target point relative coordinates to the pivot*/
            int32_t xt = x - pivot_x;
            int32_t yt = y - pivot_y;

            /*Get the source pixel from the upscaled image*/
            int32_t xs = ((cosma * xt - sinma * yt) >> (LV_TRIGO_SHIFT - 8)) + pivot_x * 256;
            int32_t ys = ((sinma * xt + cosma * yt) >> (LV_TRIGO_SHIFT - 8)) + pivot_y * 256;

            /*Get the integer part of the source pixel*/
            int xs_int = xs >> 8;
            int ys_int = ys >> 8;

            if(xs_int >= img_width)
                continue;
            else if(xs_int < 0)
                continue;

            if(ys_int >= img_height)
                continue;
            else if(ys_int < 0)
                continue;

            /*Get the fractional part of the source pixel*/
            int xs_fract = xs & 0xff;
            int ys_fract = ys & 0xff;

            /* If the fractional < 0x70 mix the source pixel with the left/top pixel
             * If the fractional > 0x90 mix the source pixel with the right/bottom pixel
             * In the 0x70..0x90 range use the unchanged source pixel */

            int xn;      /*x neightboor*/
            lv_opa_t xr; /*x mix ratio*/
            if(xs_fract < 0x70) {
                xn = xs_int - 1;
                xr = xs_fract * 2;
            } else if(xs_fract > 0x90) {
                xn = xs_int + 1;
                xr = (0xFF - xs_fract) * 2;
            } else {
                xn = xs_int;
                xr = 0xFF;
            }

            /*Handle under/overflow*/
            if(xn >= img_width)
                continue;
            else if(xn < 0)
                continue;

            int yn;      /*y neightboor*/
            lv_opa_t yr; /*y mix ratio*/
            if(ys_fract < 0x70) {
                yn = ys_int - 1;
                yr = ys_fract * 2;
            } else if(ys_fract > 0x90) {
                yn = ys_int + 1;
                yr = (0xFF - ys_fract) * 2;
            } else {
                yn = ys_int;
                yr = 0xFF;
            }

            /*Handle under/overflow*/
            if(yn >= img_height)
                continue;
            else if(yn < 0)
                continue;

            /*Get the mixture of the original source and the neightboor pixels in both directions*/
            lv_color_t c_dest_int = lv_img_buf_get_px_color(img, xs_int, ys_int, style);

            if(lv_img_color_format_is_chroma_keyed(img->header.cf)) {
                lv_color_t ct = LV_COLOR_TRANSP;
                if(c_dest_int.full == ct.full) continue;
            }

            lv_color_t c_dest_xn = lv_img_buf_get_px_color(img, xn, ys_int, style);
            lv_color_t c_dest_yn = lv_img_buf_get_px_color(img, xs_int, yn, style);
            lv_color_t x_dest    = lv_color_mix(c_dest_int, c_dest_xn, xr);
            lv_color_t y_dest    = lv_color_mix(c_dest_int, c_dest_yn, yr);
            lv_color_t color_res = lv_color_mix(x_dest, y_dest, LV_OPA_50);

            if(x + offset_x >= 0 && x + offset_x < dest_width && y + offset_y >= 0 && y + offset_y < dest_height) {
                /*If the image has no alpha channel just simple set the result color on the canvas*/
                if(lv_img_color_format_has_alpha(img->header.cf) == false) {
                    lv_img_buf_set_px_color(&ext_dst->dsc, x + offset_x, y + offset_y, color_res);
                } else {
                    /*Get result pixel opacity*/
                    lv_opa_t opa_int = lv_img_buf_get_px_alpha(img, xs_int, ys_int);
                    lv_opa_t opa_xn  = lv_img_buf_get_px_alpha(img, xn, ys_int);
                    lv_opa_t opa_yn  = lv_img_buf_get_px_alpha(img, xs_int, yn);
                    lv_opa_t opa_x   = (opa_int * xr + (opa_xn * (255 - xr))) >> 8;
                    lv_opa_t opa_y   = (opa_int * yr + (opa_yn * (255 - yr))) >> 8;
                    lv_opa_t opa_res = (opa_x + opa_y) / 2;
                    if(opa_res <= LV_OPA_MIN) continue;

                    lv_color_t bg_color = lv_img_buf_get_px_color(&ext_dst->dsc, x + offset_x, y + offset_y, style);

                    /*If the canvas has no alpha but the image has mix the image's color with
                     * canvas*/
                    if(lv_img_color_format_has_alpha(ext_dst->dsc.header.cf) == false) {
                        if(opa_res < LV_OPA_MAX) color_res = lv_color_mix(color_res, bg_color, opa_res);
                        lv_img_buf_set_px_color(&ext_dst->dsc, x + offset_x, y + offset_y, color_res);
                    }
                    /*Both the image and canvas has alpha channel. Some extra calculation is
                       required*/
                    else {
                        lv_opa_t bg_opa = lv_img_buf_get_px_alpha(&ext_dst->dsc, x + offset_x, y + offset_y);
                        /* Pick the foreground if it's fully opaque or the Background is fully
                         * transparent*/
                        if(opa_res >= LV_OPA_MAX || bg_opa <= LV_OPA_MIN) {
                            lv_img_buf_set_px_color(&ext_dst->dsc, x + offset_x, y + offset_y, color_res);
                            lv_img_buf_set_px_alpha(&ext_dst->dsc, x + offset_x, y + offset_y, opa_res);
                        }
                        /*Opaque background: use simple mix*/
                        else if(bg_opa >= LV_OPA_MAX) {
                            lv_img_buf_set_px_color(&ext_dst->dsc, x + offset_x, y + offset_y,
                                                    lv_color_mix(color_res, bg_color, opa_res));
                        }
                        /*Both colors have alpha. Expensive calculation need to be applied*/
                        else {

                            /*Info:
                             * https://en.wikipedia.org/wiki/Alpha_compositing#Analytical_derivation_of_the_over_operator*/
                            lv_opa_t opa_res_2 = 255 - ((uint16_t)((uint16_t)(255 - opa_res) * (255 - bg_opa)) >> 8);
                            if(opa_res_2 == 0) {
                                opa_res_2 = 1; /*never happens, just to be sure*/
                            }
                            lv_opa_t ratio = (uint16_t)((uint16_t)opa_res * 255) / opa_res_2;

                            lv_img_buf_set_px_color(&ext_dst->dsc, x + offset_x, y + offset_y,
                                                    lv_color_mix(color_res, bg_color, ratio));
                            lv_img_buf_set_px_alpha(&ext_dst->dsc, x + offset_x, y + offset_y, opa_res_2);
                        }
                    }
                }
            }
        }
    }

    lv_obj_invalidate(canvas);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, %ebx
movl %r8d, %r13d
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbp
movq %rdi, %r14
movl 0xf0(%rsp), %eax
movl %eax, 0x34(%rsp)
callq 0x80e4
testb %al, %al
je 0x18520
movq %rbp, %rdi
callq 0x80e4
testb %al, %al
je 0x18531
movq %rbp, 0x68(%rsp)
movq %r14, %rdi
callq 0x6af7
movq %rax, %rbp
movq %r14, 0x90(%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x17b73
movq %rax, 0x78(%rsp)
movl %r12d, %eax
negl %eax
movswl %ax, %edi
callq 0x2b4d8
movl %eax, %r14d
movl $0x5a, %eax
subl %r12d, %eax
movswl %ax, %edi
callq 0x2b4d8
movl $0x7ff, %ecx            # imm = 0x7FF
movq %rbp, 0x38(%rsp)
movl 0x18(%rbp), %edx
movl %edx, 0x5c(%rsp)
shrl $0xa, %edx
andl %ecx, %edx
movl %edx, 0x58(%rsp)
je 0x18542
movswl %r14w, %r12d
movswl %ax, %r8d
movq 0x68(%rsp), %rax
movl (%rax), %r9d
movl %r9d, %r10d
shrl $0xa, %r10d
andl %ecx, %r10d
shrl $0x15, %r9d
addq $0x18, 0x38(%rsp)
movl 0x5c(%rsp), %ecx
shrl $0x15, %ecx
movswl %r15w, %edx
movl 0x58(%rsp), %eax
subl %edx, %eax
movl %eax, 0x88(%rsp)
movl %edx, %eax
negl %eax
movq %rax, 0x70(%rsp)
movswl %r13w, %eax
movl %ecx, 0x84(%rsp)
movl %ecx, %r11d
subl %eax, %r11d
movl 0x34(%rsp), %ecx
movl %ecx, %esi
addl %eax, %ecx
negl %eax
movq %rax, 0xb0(%rsp)
movl %ebx, %eax
shll $0x8, %eax
movq %rax, 0xa8(%rsp)
shll $0x8, %esi
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
addl %edx, %ebx
negl %ebx
movl %ebx, %eax
imull %r8d, %eax
movl %ecx, %edx
negl %edx
imull %r12d, %ecx
addl %eax, %ecx
movl %ecx, 0x34(%rsp)
imull %r12d, %ebx
imull %r8d, %edx
addl %ebx, %edx
movl %edx, 0x60(%rsp)
movl %r12d, 0x24(%rsp)
movl %r8d, 0x1c(%rsp)
movl %r9d, 0x18(%rsp)
movl %r10d, 0x14(%rsp)
movl %r11d, 0x10(%rsp)
cmpl $0x200000, 0x5c(%rsp)   # imm = 0x200000
jae 0x17e91
movq 0x70(%rsp), %rax
incl %eax
addl %r8d, 0x34(%rsp)
addl %r12d, 0x60(%rsp)
movq %rax, 0x70(%rsp)
cmpl 0x88(%rsp), %eax
jl 0x17e63
jmp 0x18542
movq 0x98(%rsp), %rax
movq 0x70(%rsp), %rcx
addl %ecx, %eax
movl %eax, 0x50(%rsp)
xorl %r13d, %r13d
movl 0x60(%rsp), %ebp
movl 0x34(%rsp), %r15d
movl %r15d, %esi
sarl $0x7, %esi
movq 0xa8(%rsp), %rax
addl %esi, %eax
sarl $0x8, %eax
cmpl %r10d, %eax
jae 0x1834a
movl %ebp, %edx
sarl $0x7, %edx
movq 0xa0(%rsp), %rcx
addl %edx, %ecx
sarl $0x8, %ecx
cmpl %r9d, %ecx
jae 0x1834a
movl %esi, %edi
movl $0xff, %ebx
andl %ebx, %edi
cmpl $0x6f, %edi
ja 0x17efd
leal -0x1(%rax), %r14d
addl %esi, %esi
jmp 0x17f14
movl %eax, %r14d
cmpl $0x91, %edi
jb 0x17f16
leal 0x1(%rax), %r14d
addl %esi, %esi
xorl $0x1fe, %esi            # imm = 0x1FE
movl %esi, %ebx
movl %ebx, 0xc(%rsp)
cmpl %r10d, %r14d
jae 0x1834a
movl %edx, %esi
movl $0xff, %edi
andl %edi, %esi
cmpl $0x6f, %esi
ja 0x17f38
leal -0x1(%rcx), %ebx
addl %edx, %edx
jmp 0x17f4d
movl %ecx, %ebx
cmpl $0x91, %esi
jb 0x17f4f
leal 0x1(%rcx), %ebx
addl %edx, %edx
xorl $0x1fe, %edx            # imm = 0x1FE
movl %edx, %edi
movl %edi, 0x28(%rsp)
movl %ebx, 0x40(%rsp)
cmpl %r9d, %ebx
jae 0x1834a
movswl %ax, %esi
movswl %cx, %edx
movq 0x68(%rsp), %r12
movq %r12, %rdi
movl %esi, 0x54(%rsp)
movl %edx, 0x64(%rsp)
movq 0x78(%rsp), %rcx
callq 0x3c293
movl %eax, %ebx
movl (%r12), %edi
movl 0x24(%rsp), %r12d
andl $0x1f, %edi
callq 0x3c86a
movl 0x10(%rsp), %r11d
movl 0x14(%rsp), %r10d
movl 0x18(%rsp), %r9d
movl 0x1c(%rsp), %r8d
movzwl %bx, %ebx
testb %al, %al
je 0x17fba
cmpl $0x7e0, %ebx            # imm = 0x7E0
je 0x1834a
movswl %r14w, %esi
movq 0x68(%rsp), %r14
movq %r14, %rdi
movl %esi, 0x8c(%rsp)
movl 0x64(%rsp), %edx
movq 0x78(%rsp), %r12
movq %r12, %rcx
callq 0x3c293
movl %eax, 0x4c(%rsp)
movswl 0x40(%rsp), %edx
movq %r14, %rdi
movl 0x54(%rsp), %esi
movl %edx, 0x40(%rsp)
movq %r12, %rcx
movl 0x24(%rsp), %r12d
callq 0x3c293
movl 0x10(%rsp), %r11d
movl 0x14(%rsp), %r10d
movl 0x18(%rsp), %r9d
movl 0x1c(%rsp), %r8d
movl 0x50(%rsp), %ecx
cmpl 0x58(%rsp), %ecx
jae 0x1834a
cmpl 0x84(%rsp), %r13d
jae 0x1834a
movl 0x4c(%rsp), %r10d
movzwl %r10w, %edx
movzwl %ax, %ecx
movl %ebx, %esi
shrl $0xb, %esi
movl %esi, 0x20(%rsp)
movl $0xff, %r9d
movl 0xc(%rsp), %r14d
andl %r9d, %r14d
movl %r14d, %r8d
imull %esi, %r8d
movl %edx, %esi
shrl $0xb, %esi
movl %r14d, %r11d
xorl %r9d, %r11d
imull %r11d, %esi
addl %r8d, %esi
movl %ebx, %r8d
shrl $0x5, %r8d
andl $0x3f, %r8d
movl %r14d, %r9d
imull %r8d, %r9d
shrl $0x5, %edx
andl $0x3f, %edx
imull %r11d, %edx
addl %r9d, %edx
andl $0x1f, %ebx
movl %r14d, 0xc(%rsp)
movl %r14d, %r9d
imull %ebx, %r9d
andl $0x1f, %r10d
movl %r11d, 0x80(%rsp)
imull %r11d, %r10d
addl %r9d, %r10d
movl 0x28(%rsp), %r14d
movl $0xff, %edi
andl %edi, %r14d
movl 0x20(%rsp), %edi
imull %r14d, %edi
movl %edi, 0x20(%rsp)
movl %ecx, %r9d
shrl $0xb, %r9d
movl %r14d, %r11d
movl $0xff, %edi
xorl %edi, %r11d
imull %r11d, %r9d
addl 0x20(%rsp), %r9d
imull %r14d, %r8d
shrl $0x5, %ecx
andl $0x3f, %ecx
imull %r11d, %ecx
addl %r8d, %ecx
movl %r14d, 0x28(%rsp)
imull %r14d, %ebx
andl $0x1f, %eax
movl %r11d, 0x4c(%rsp)
imull %r11d, %eax
addl %ebx, %eax
shrl $0x8, %esi
andl $0x1f, %esi
movl %esi, %edi
shll $0x7, %edi
subl %esi, %edi
shrl %r9d
movl $0xf80, %r8d            # imm = 0xF80
andl %r8d, %r9d
addl %edi, %r9d
shrl $0x8, %edx
andl $0x3f, %edx
movl %edx, %esi
shll $0x7, %esi
subl %edx, %esi
shrl $0x8, %r10d
andl $0x1f, %r10d
shrl %ecx
andl $0x1f80, %ecx           # imm = 0x1F80
addl %esi, %ecx
movl %r10d, %edx
shll $0x7, %edx
subl %r10d, %edx
shrl %eax
andl %r8d, %eax
addl %edx, %eax
movl %r9d, 0x48(%rsp)
movl %r9d, %edx
andl $0xffff1f00, %edx       # imm = 0xFFFF1F00
shrl $0x3, %ecx
andl $0x7e0, %ecx            # imm = 0x7E0
movzbl %ah, %eax
leal (%rcx,%rdx,8), %ebx
movl %eax, 0x20(%rsp)
orl %eax, %ebx
movq 0x68(%rsp), %r14
movl (%r14), %edi
andl $0x1f, %edi
callq 0x3c87c
testb %al, %al
je 0x18321
movl %ebx, 0x30(%rsp)
movq %r14, %rdi
movl 0x54(%rsp), %esi
movl 0x64(%rsp), %ebx
movl %ebx, %edx
callq 0x3c3e6
movb %al, 0x2f(%rsp)
movq %r14, %rdi
movl 0x8c(%rsp), %esi
movl %ebx, %edx
callq 0x3c3e6
movl %eax, %ebx
movq %r14, %rdi
movl 0x54(%rsp), %esi
movl 0x40(%rsp), %edx
callq 0x3c3e6
movzbl 0x2f(%rsp), %ecx
movl 0xc(%rsp), %edi
imull %ecx, %edi
movzbl %bl, %edx
movl 0x80(%rsp), %esi
imull %edx, %esi
addl %edi, %esi
shrl $0x8, %esi
movl 0x28(%rsp), %edx
imull %ecx, %edx
movzbl %al, %eax
movl 0x4c(%rsp), %ecx
imull %eax, %ecx
addl %edx, %ecx
shrl $0x8, %ecx
movl $0xff, %eax
andl %eax, %esi
andl %eax, %ecx
addl %esi, %ecx
cmpl $0x22, %ecx
movl 0x1c(%rsp), %r8d
movl 0x18(%rsp), %r9d
movl 0x14(%rsp), %r10d
movl 0x10(%rsp), %r11d
jb 0x1834a
movl %ecx, %r12d
shrl %ecx
movl %ecx, 0xc(%rsp)
movswl 0x50(%rsp), %r14d
movswl %r13w, %edx
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movl %r14d, %esi
movq 0x78(%rsp), %rcx
callq 0x3c293
movq %rax, 0x40(%rsp)
movl (%rbx), %edi
andl $0x1f, %edi
callq 0x3c87c
testb %al, %al
je 0x18373
movswl %r13w, %edx
movq %rbx, 0x38(%rsp)
movq %rbx, %rdi
movl %r14d, 0x28(%rsp)
movl %r14d, %esi
callq 0x3c3e6
cmpl $0x1f5, %r12d           # imm = 0x1F5
ja 0x183fc
cmpb $0x10, %al
jbe 0x183fc
cmpb $-0x5, %al
jb 0x18447
movswl 0x48(%rsp), %eax
movzbl %ah, %esi
movl 0xc(%rsp), %r8d
imull %r8d, %esi
movq 0x40(%rsp), %rdi
movzwl %di, %eax
movl %eax, %ecx
shrl $0xb, %ecx
movl %r8d, %edx
xorl $0xff, %edx
imull %edx, %ecx
addl %esi, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl 0x30(%rsp), %esi
shrl $0x5, %esi
andl $0x3f, %esi
imull %r8d, %esi
shrl $0x5, %eax
andl $0x3f, %eax
imull %edx, %eax
addl %esi, %eax
shrl $0x3, %eax
andl $0x7e0, %eax            # imm = 0x7E0
movl 0x20(%rsp), %esi
imull %r8d, %esi
andl $0x1f, %edi
imull %edx, %edi
addl %esi, %edi
shrl $0x8, %edi
andl $0x1f, %edi
leal (%rdi,%rcx,8), %ecx
orl %eax, %ecx
movswl %r13w, %edx
movq 0x38(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x3c502
jmp 0x18516
movswl 0x50(%rsp), %esi
movswl %r13w, %edx
movq 0x38(%rsp), %rdi
movl %ebx, %ecx
callq 0x3c502
movl 0x1c(%rsp), %r8d
movl 0x18(%rsp), %r9d
movl 0x14(%rsp), %r10d
movl 0x10(%rsp), %r11d
movq 0xb0(%rsp), %rax
addl %r13d, %eax
incl %eax
movl %r13d, %ecx
incl %ecx
subl %r12d, %r15d
addl %r8d, %ebp
movl %ecx, %r13d
cmpl %r11d, %eax
jl 0x17eb0
jmp 0x17e6d
cmpl $0x1f5, %r12d           # imm = 0x1F5
ja 0x1842f
movswl 0x48(%rsp), %eax
movzbl %ah, %esi
movl 0xc(%rsp), %r9d
imull %r9d, %esi
movq 0x40(%rsp), %r8
movzwl %r8w, %eax
movl %eax, %ecx
shrl $0xb, %ecx
movl %r9d, %edx
xorl $0xff, %edx
imull %edx, %ecx
addl %esi, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl 0x30(%rsp), %esi
shrl $0x5, %esi
andl $0x3f, %esi
imull %r9d, %esi
shrl $0x5, %eax
andl $0x3f, %eax
imull %edx, %eax
addl %esi, %eax
shrl $0x3, %eax
andl $0x7e0, %eax            # imm = 0x7E0
movl 0x20(%rsp), %esi
imull %r9d, %esi
andl $0x1f, %r8d
imull %edx, %r8d
addl %esi, %r8d
shrl $0x8, %r8d
andl $0x1f, %r8d
leal (%r8,%rcx,8), %ecx
orl %eax, %ecx
movl 0x24(%rsp), %r12d
jmp 0x18438
movswl %r13w, %r12d
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movl 0x28(%rsp), %r14d
movl %r14d, %esi
movl %r12d, %edx
movl 0x30(%rsp), %ecx
callq 0x3c502
movzbl 0xc(%rsp), %ecx
movq %rbx, %rdi
movl %r14d, %esi
movl %r12d, %edx
jmp 0x18511
movl 0x24(%rsp), %r12d
movl 0x30(%rsp), %ecx
movswl %r13w, %edx
movq %rbx, %rdi
movl %r14d, %esi
jmp 0x18331
movl 0xc(%rsp), %esi
movl %esi, %ecx
movl $0xff, %r8d
xorl %r8d, %ecx
notb %al
movzbl %al, %edx
imull %ecx, %edx
shrl $0x8, %edx
notb %dl
movl %esi, %eax
shll $0x8, %eax
subl %esi, %eax
movzbl %dl, %ecx
movl %ecx, 0xc(%rsp)
xorl %edx, %edx
divw %cx
movswl 0x48(%rsp), %ecx
movzbl %ch, %edx
andl %r8d, %eax
imull %eax, %edx
movq 0x40(%rsp), %rcx
movzwl %cx, %r10d
movl %r10d, %esi
shrl $0xb, %esi
movl 0x30(%rsp), %r9d
shrl $0x5, %r9d
andl $0x3f, %r9d
imull %eax, %r9d
movzwl 0x20(%rsp), %edi
imull %eax, %edi
xorl %r8d, %eax
imull %eax, %esi
addl %edx, %esi
andl $0xffffff00, %esi       # imm = 0xFFFFFF00
shrl $0x5, %r10d
andl $0x3f, %r10d
imull %eax, %r10d
addl %r9d, %r10d
shrl $0x3, %r10d
andl $0x7e0, %r10d           # imm = 0x7E0
leal (%r10,%rsi,8), %edx
andl $0x1f, %ecx
imull %eax, %ecx
addl %edi, %ecx
shrl $0x8, %ecx
andl $0x1f, %ecx
orl %edx, %ecx
movswl %r13w, %r12d
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movl 0x28(%rsp), %r14d
movl %r14d, %esi
movl %r12d, %edx
callq 0x3c502
movq %rbx, %rdi
movl %r14d, %esi
movl %r12d, %edx
movl 0xc(%rsp), %ecx
callq 0x3c6a8
movl 0x24(%rsp), %r12d
jmp 0x18336
leaq 0x26cbd(%rip), %rdi     # 0x3f1e4
movq %r14, %rsi
callq 0x8294
jmp 0x1852f
leaq 0x26cac(%rip), %rdi     # 0x3f1e4
movq %rbp, %rsi
callq 0x8294
jmp 0x18540
movq 0x90(%rsp), %rdi
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4c4d