// File: /workspace/github_c_makefile_star2_O2/OnionIoT[P]lv_example/lvgl/src/lv_objx/lv_slider.c
// Function: lv_slider_design
static bool lv_slider_design(lv_obj_t * slider, const lv_area_t * mask, lv_design_mode_t mode)
{
    /*Return false if the object is not covers the mask_p area*/
    if(mode == LV_DESIGN_COVER_CHK) {
        return false;
    }
    /*Draw the object*/
    else if(mode == LV_DESIGN_DRAW_MAIN) {
        lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);

        const lv_style_t * style_bg    = lv_slider_get_style(slider, LV_SLIDER_STYLE_BG);
        const lv_style_t * style_knob  = lv_slider_get_style(slider, LV_SLIDER_STYLE_KNOB);
        const lv_style_t * style_indic = lv_slider_get_style(slider, LV_SLIDER_STYLE_INDIC);

        lv_opa_t opa_scale = lv_obj_get_opa_scale(slider);

        lv_coord_t slider_w = lv_area_get_width(&slider->coords);
        lv_coord_t slider_h = lv_area_get_height(&slider->coords);

        /*Draw the bar*/
        lv_area_t area_bg;
        lv_area_copy(&area_bg, &slider->coords);

        /*Be sure at least LV_SLIDER_SIZE_MIN  size will remain*/
        lv_coord_t pad_top_bg    = style_bg->body.padding.top;
        lv_coord_t pad_bottom_bg = style_bg->body.padding.bottom;
        lv_coord_t pad_left_bg   = style_bg->body.padding.left;
        lv_coord_t pad_right_bg  = style_bg->body.padding.right;
        if(pad_top_bg + pad_bottom_bg + LV_SLIDER_SIZE_MIN > lv_area_get_height(&area_bg)) {
            pad_top_bg    = (lv_area_get_height(&area_bg) - LV_SLIDER_SIZE_MIN) >> 1;
            pad_bottom_bg = pad_top_bg;
        }
        if(pad_left_bg + pad_right_bg + LV_SLIDER_SIZE_MIN > lv_area_get_width(&area_bg)) {
            pad_left_bg  = (lv_area_get_width(&area_bg) - LV_SLIDER_SIZE_MIN) >> 1;
            pad_right_bg = (lv_area_get_width(&area_bg) - LV_SLIDER_SIZE_MIN) >> 1;
        }

        if(ext->knob_in) { /*Enable extra size if the knob is inside */
            area_bg.x1 += pad_left_bg;
            area_bg.x2 -= pad_right_bg;
            area_bg.y1 += pad_top_bg;
            area_bg.y2 -= pad_bottom_bg;
        } else {                                                   /*Let space only in the perpendicular directions*/
            area_bg.x1 += slider_w < slider_h ? pad_left_bg : 0;   /*Pad only for vertical slider*/
            area_bg.x2 -= slider_w < slider_h ? pad_right_bg : 0;  /*Pad only for vertical slider*/
            area_bg.y1 += slider_w > slider_h ? pad_top_bg : 0;    /*Pad only for horizontal slider*/
            area_bg.y2 -= slider_w > slider_h ? pad_bottom_bg : 0; /*Pad only for horizontal slider*/
        }

#if LV_USE_GROUP == 0
        lv_draw_rect(&area_bg, mask, style_bg, lv_obj_get_opa_scale(slider));
#else
        /* Draw the borders later if the slider is focused.
         * At value = 100% the indicator can cover to whole background and the focused style won't
         * be visible*/
        if(lv_obj_is_focused(slider)) {
            lv_style_t style_tmp;
            lv_style_copy(&style_tmp, style_bg);
            style_tmp.body.border.width = 0;
            lv_draw_rect(&area_bg, mask, &style_tmp, opa_scale);
        } else {
            lv_draw_rect(&area_bg, mask, style_bg, opa_scale);
        }
#endif

        /*Draw the indicator*/
        lv_area_t area_indic;
        lv_area_copy(&area_indic, &area_bg);

        /*Be sure at least ver pad/hor pad width indicator will remain*/
        lv_coord_t pad_top_indic    = style_indic->body.padding.top;
        lv_coord_t pad_bottom_indic = style_indic->body.padding.bottom;
        lv_coord_t pad_left_indic   = style_indic->body.padding.left;
        lv_coord_t pad_right_indic  = style_indic->body.padding.right;
        if(pad_top_indic + pad_bottom_indic + LV_SLIDER_SIZE_MIN > lv_area_get_height(&area_bg)) {
            pad_top_indic    = (lv_area_get_height(&area_bg) - LV_SLIDER_SIZE_MIN) >> 1;
            pad_bottom_indic = pad_top_indic;
        }
        if(pad_left_indic + pad_right_indic + LV_SLIDER_SIZE_MIN > lv_area_get_width(&area_bg)) {
            pad_left_indic  = (lv_area_get_width(&area_bg) - LV_SLIDER_SIZE_MIN) >> 1;
            pad_right_indic = pad_left_indic;
        }

        area_indic.x1 += pad_left_indic;
        area_indic.x2 -= pad_right_indic;
        area_indic.y1 += pad_top_indic;
        area_indic.y2 -= pad_bottom_indic;

        lv_coord_t cur_value = lv_slider_get_value(slider);
        lv_coord_t min_value = lv_slider_get_min_value(slider);
        lv_coord_t max_value = lv_slider_get_max_value(slider);

        /*If dragged draw to the drag position*/
        if(ext->drag_value != LV_SLIDER_NOT_PRESSED) cur_value = ext->drag_value;
        bool sym = false;
        if(ext->bar.sym && ext->bar.min_value < 0 && ext->bar.max_value > 0) sym = true;

        if(slider_w >= slider_h) {
            lv_coord_t indic_w = lv_area_get_width(&area_indic);
#if LV_USE_ANIMATION
            if(ext->bar.anim_state != LV_BAR_ANIM_STATE_INV) {
                /*Calculate the coordinates of anim. start and end*/
                lv_coord_t anim_start_x =
                    (int32_t)((int32_t)indic_w * (ext->bar.anim_start - min_value)) / (max_value - min_value);
                lv_coord_t anim_end_x =
                    (int32_t)((int32_t)indic_w * (ext->bar.anim_end - min_value)) / (max_value - min_value);

                /*Calculate the real position based on `anim_state` (between `anim_start` and
                 * `anim_end`)*/
                area_indic.x2 = anim_start_x + (((anim_end_x - anim_start_x) * ext->bar.anim_state) >> 8);
            } else
#endif
            {
                area_indic.x2 = (int32_t)((int32_t)indic_w * (cur_value - min_value)) / (max_value - min_value);
            }

            area_indic.x2 = area_indic.x1 + area_indic.x2 - 1;
            if(sym) {
                /*Calculate the coordinate of the zero point*/
                lv_coord_t zero;
                zero = area_indic.x1 + (-ext->bar.min_value * slider_w) / (ext->bar.max_value - ext->bar.min_value);
                if(area_indic.x2 > zero)
                    area_indic.x1 = zero;
                else {
                    area_indic.x1 = area_indic.x2;
                    area_indic.x2 = zero;
                }
            }

            /*Draw the indicator but don't draw an ugly 1px wide rectangle on the left on min.
             * value*/
            if(area_indic.x1 != area_indic.x2) lv_draw_rect(&area_indic, mask, style_indic, opa_scale);

        } else {
            lv_coord_t indic_h = lv_area_get_height(&area_indic);
#if LV_USE_ANIMATION
            if(ext->bar.anim_state != LV_BAR_ANIM_STATE_INV) {
                /*Calculate the coordinates of anim. start and end*/
                lv_coord_t anim_start_y =
                    (int32_t)((int32_t)indic_h * (ext->bar.anim_start - min_value)) / (max_value - min_value);
                lv_coord_t anim_end_y =
                    (int32_t)((int32_t)indic_h * (ext->bar.anim_end - min_value)) / (max_value - min_value);

                /*Calculate the real position based on `anim_state` (between `anim_start` and
                 * `anim_end`)*/
                area_indic.y1 = anim_start_y + (((anim_end_y - anim_start_y) * ext->bar.anim_state) >> 8);
            } else
#endif
            {
                area_indic.y1 = (int32_t)((int32_t)indic_h * (cur_value - min_value)) / (max_value - min_value);
            }

            area_indic.y1 = area_indic.y2 - area_indic.y1 + 1;

            if(sym) {
                /*Calculate the coordinate of the zero point*/
                lv_coord_t zero;
                zero = area_indic.y2 - (-ext->bar.min_value * slider_h) / (ext->bar.max_value - ext->bar.min_value);
                if(area_indic.y1 < zero)
                    area_indic.y2 = zero;
                else {
                    area_indic.y2 = area_indic.y1;
                    area_indic.y1 = zero;
                }
            }

            /*Draw the indicator but don't draw an ugly 1px height rectangle on the bottom on min.
             * value*/
            if(area_indic.x1 != area_indic.x2) lv_draw_rect(&area_indic, mask, style_indic, opa_scale);
        }

        /*Before the knob add the border if required*/
#if LV_USE_GROUP
        /* Draw the borders later if the bar is focused.
         * At value = 100% the indicator can cover to whole background and the focused style won't
         * be visible*/
        if(lv_obj_is_focused(slider)) {
            lv_style_t style_tmp;
            lv_style_copy(&style_tmp, style_bg);
            style_tmp.body.opa          = LV_OPA_TRANSP;
            style_tmp.body.shadow.width = 0;
            lv_draw_rect(&area_bg, mask, &style_tmp, opa_scale);
        }
#endif

        /*Draw the knob*/
        lv_area_t knob_area;
        lv_area_copy(&knob_area, &slider->coords);

        if(slider_w >= slider_h) {
            if(ext->knob_in == 0) {
                if(sym == false) {
                    knob_area.x1 = area_indic.x2 - slider_h / 2;
                } else {
                    if(cur_value > 0) knob_area.x1 = area_indic.x2 - slider_h / 2;
                    else knob_area.x1 = area_indic.x1 - slider_h / 2;
                }
                knob_area.x2 = knob_area.x1 + slider_h - 1;
            } else {
#if LV_USE_ANIMATION
                if(ext->bar.anim_state != LV_BAR_ANIM_STATE_INV) {
                    lv_coord_t w = slider_w - slider_h - 1;
                    lv_coord_t anim_start_x =
                        (int32_t)((int32_t)w * (ext->bar.anim_start - min_value)) / (max_value - min_value);
                    lv_coord_t anim_end_x =
                        (int32_t)((int32_t)w * (ext->bar.anim_end - min_value)) / (max_value - min_value);

                    /*Calculate the real position based on `anim_state` (between `anim_start` and
                     * `anim_end`)*/
                    knob_area.x1 = anim_start_x + (((anim_end_x - anim_start_x) * ext->bar.anim_state) >> 8);
                } else
#endif
                {
                    knob_area.x1 = (int32_t)((int32_t)(slider_w - slider_h - 1) * (cur_value - min_value)) /
                                   (max_value - min_value);
                }

                knob_area.x1 += slider->coords.x1;
                knob_area.x2 = knob_area.x1 + slider_h - 1;
            }

            knob_area.y1 = slider->coords.y1;
            knob_area.y2 = slider->coords.y2;
        } else {
            if(ext->knob_in == 0) {
                if(sym == false) {
                    knob_area.y1 = area_indic.y1 - slider_w / 2;
                } else {
                    if(cur_value > 0)  knob_area.y1 = area_indic.y1 - slider_w / 2;
                    else  knob_area.y1 = area_indic.y2 - slider_w / 2;
                }
                knob_area.y2 = knob_area.y1 + slider_w - 1;
            } else {
#if LV_USE_ANIMATION
                if(ext->bar.anim_state != LV_BAR_ANIM_STATE_INV) {
                    lv_coord_t h = slider_h - slider_w - 1;
                    lv_coord_t anim_start_x =
                        (int32_t)((int32_t)h * (ext->bar.anim_start - min_value)) / (max_value - min_value);
                    lv_coord_t anim_end_x =
                        (int32_t)((int32_t)h * (ext->bar.anim_end - min_value)) / (max_value - min_value);

                    /*Calculate the real position based on `anim_state` (between `anim_start` and
                     * `anim_end`)*/
                    knob_area.y2 = anim_start_x + (((anim_end_x - anim_start_x) * ext->bar.anim_state) >> 8);
                } else
#endif
                {
                    knob_area.y2 = (int32_t)((int32_t)(slider_h - slider_w - 1) * (cur_value - min_value)) /
                                   (max_value - min_value);
                }

                knob_area.y2 = slider->coords.y2 - knob_area.y2;
                knob_area.y1 = knob_area.y2 - slider_w - 1;
            }
            knob_area.x1 = slider->coords.x1;
            knob_area.x2 = slider->coords.x2;
        }
        lv_draw_rect(&knob_area, mask, style_knob, opa_scale);
    }
    /*Post draw when the children are drawn*/
    else if(mode == LV_DESIGN_DRAW_POST) {
    }

    return true;
}

// Assembly:
testl %edx, %edx
jne 0x1c138
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbp
movq %rsi, 0x20(%rsp)
movl %edx, 0x4c(%rsp)
callq 0x6747
movq %rax, %r15
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1c29c
movq %rax, %rbx
pushq $0x2
popq %rsi
movq %rbp, %rdi
callq 0x1c29c
movq %rax, 0x58(%rsp)
pushq $0x1
popq %rsi
movq %rbp, %rdi
callq 0x1c29c
movq %rax, 0x50(%rsp)
movq %rbp, %rdi
callq 0x6649
movb %al, 0x14(%rsp)
movzwl 0x24(%rbp), %r12d
movzwl 0x26(%rbp), %r13d
subw 0x20(%rbp), %r12w
subw 0x22(%rbp), %r13w
incl %r12d
incl %r13d
movq 0x20(%rbp), %rdx
movswl 0x16(%rbx), %r10d
movswl 0x18(%rbx), %eax
movswl 0x1a(%rbx), %r11d
movq %rbx, 0x40(%rsp)
movswl 0x1c(%rbx), %esi
leal (%r10,%rax), %r14d
addl $0x4, %r14d
movq %rdx, %rcx
shrq $0x30, %rcx
movl %edx, %r9d
shrl $0x10, %r9d
movl %ecx, %edi
subl %r9d, %edi
incl %edi
movswl %di, %ebx
movl $0x1fffc, %edi          # imm = 0x1FFFC
leal (%rbx,%rdi), %r8d
shrl %r8d
cmpl %ebx, %r14d
cmovgl %r8d, %eax
cmovlel %r10d, %r8d
leal (%r11,%rsi), %ebx
addl $0x4, %ebx
movq %rdx, %r10
shrq $0x20, %r10
movl %r10d, %r14d
subl %edx, %r14d
incl %r14d
movswl %r14w, %r14d
addl %r14d, %edi
shrl %edi
cmpl %r14d, %ebx
cmovgl %edi, %esi
cmovlel %r11d, %edi
testb $0x1, 0x22(%r15)
jne 0x1bb9f
cmpw %r13w, %r12w
movl $0x0, %r11d
cmovgel %r11d, %edi
cmovgel %r11d, %esi
cmovlel %r11d, %r8d
cmovlel %r11d, %eax
addl %r9d, %r8d
subl %esi, %r10d
addl %edx, %edi
movw %di, 0x28(%rsp)
movw %r10w, 0x2c(%rsp)
movw %r8w, 0x2a(%rsp)
subl %eax, %ecx
movw %cx, 0x2e(%rsp)
movq %rbp, %rdi
callq 0x6812
movzbl 0x14(%rsp), %r14d
testb %al, %al
movl %r14d, 0x14(%rsp)
je 0x1bbfc
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq 0x40(%rsp), %rsi
callq 0x74d4
andw $0x0, 0xc(%rbx)
leaq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
jmp 0x1bc0b
leaq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdx
movl %r14d, %ecx
callq 0x336d4
movq 0x28(%rsp), %rax
movq %rax, %rcx
shrq $0x30, %rcx
shrq $0x20, %rax
movq 0x50(%rsp), %rdx
movq 0x16(%rdx), %xmm0
pshuflw $0x28, %xmm0, %xmm1     # xmm1 = xmm0[0,2,2,0,4,5,6,7]
psrad $0x10, %xmm1
pshufd $0xe1, %xmm0, %xmm3     # xmm3 = xmm0[1,0,2,3]
psrad $0x10, %xmm3
paddd %xmm1, %xmm3
paddd 0x1fbe3(%rip), %xmm3    # 0x3b830
movd 0x28(%rsp), %xmm1
movdqa %xmm1, %xmm2
pinsrw $0x2, %eax, %xmm2
pinsrw $0x3, %ecx, %xmm2
movd %eax, %xmm4
pinsrw $0x1, %ecx, %xmm4
psubw %xmm1, %xmm4
pcmpeqd %xmm5, %xmm5
psubw %xmm5, %xmm4
punpcklwd %xmm4, %xmm4    # xmm4 = xmm4[0,0,1,1,2,2,3,3]
psrad $0x10, %xmm4
pcmpgtd %xmm4, %xmm3
pshuflw $0xa, %xmm3, %xmm3      # xmm3 = xmm3[2,2,0,0,4,5,6,7]
movdqa 0x1fbb0(%rip), %xmm5    # 0x3b840
movdqa %xmm4, %xmm6
pand %xmm5, %xmm6
pxor %xmm5, %xmm4
psrld $0x1, %xmm4
paddd %xmm6, %xmm4
pshuflw $0xa, %xmm4, %xmm4      # xmm4 = xmm4[2,2,0,0,4,5,6,7]
pand %xmm3, %xmm4
pandn %xmm0, %xmm3
por %xmm4, %xmm3
pshuflw $0x72, %xmm3, %xmm0     # xmm0 = xmm3[2,0,3,1,4,5,6,7]
paddw %xmm0, %xmm1
psubw %xmm0, %xmm2
pshufd $0x55, %xmm2, %xmm0     # xmm0 = xmm2[1,1,1,1]
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movq %xmm1, 0x8(%rsp)
movq %rbp, %rdi
callq 0x1c203
movl %eax, %r14d
movq %rbp, %rdi
callq 0x8cfd
movl %eax, %ebx
movq %rbp, %rdi
callq 0x8d29
movl 0x20(%r15), %ecx
cmpw $0x8000, %cx            # imm = 0x8000
cmovnel %ecx, %r14d
movl %r14d, 0x38(%rsp)
testb $0x1, 0xe(%r15)
je 0x1bd14
cmpw $0x0, 0x2(%r15)
js 0x1bdf7
xorl %r10d, %r10d
movswl %r12w, %ecx
movl %ecx, 0x30(%rsp)
movswl %r13w, %ecx
movl %ecx, 0x34(%rsp)
movswl 0xa(%r15), %edi
movswl %bx, %r11d
movswl %ax, %r9d
movswl 0x38(%rsp), %r14d
cmpw %r13w, %r12w
movl %r9d, 0x1c(%rsp)
movl %r11d, 0x18(%rsp)
movl %r14d, 0x3c(%rsp)
jge 0x1bda4
movzwl 0xe(%rsp), %esi
movl %esi, %eax
subw 0xa(%rsp), %ax
incl %eax
movswl %ax, %r8d
cmpw $-0x1, %di
movl 0x14(%rsp), %ebx
je 0x1be06
movswl 0x6(%r15), %eax
subl %r11d, %eax
imull %r8d, %eax
subl %r11d, %r9d
cltd
idivl %r9d
movl %eax, %ecx
movswl 0x8(%r15), %eax
subl %r11d, %eax
imull %r8d, %eax
cltd
idivl %r9d
movswl %cx, %ecx
cwtl
subl %ecx, %eax
imull %edi, %eax
sarl $0x8, %eax
addl %ecx, %eax
jmp 0x1be19
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %eax
subl %esi, %eax
incl %eax
movswl %ax, %r8d
cmpw $-0x1, %di
movl 0x14(%rsp), %ebx
je 0x1be4b
movswl 0x6(%r15), %eax
subl %r11d, %eax
imull %r8d, %eax
subl %r11d, %r9d
cltd
idivl %r9d
movl %eax, %ecx
movswl 0x8(%r15), %eax
subl %r11d, %eax
imull %r8d, %eax
cltd
idivl %r9d
movswl %cx, %ecx
cwtl
subl %ecx, %eax
imull %edi, %eax
sarl $0x8, %eax
addl %ecx, %eax
jmp 0x1be5e
cmpw $0x0, 0x4(%r15)
setg %r10b
jmp 0x1bd17
movl %r14d, %eax
subl %r11d, %eax
imull %r8d, %eax
movl %r9d, %ecx
subl %r11d, %ecx
cltd
idivl %ecx
movl %esi, %ecx
subl %eax, %ecx
incl %ecx
movw %cx, 0xa(%rsp)
testb %r10b, %r10b
je 0x1bea5
movswl 0x2(%r15), %eax
movswl 0x4(%r15), %edi
subl %eax, %edi
imull 0x34(%rsp), %eax
cltd
idivl %edi
addl %eax, %esi
cmpw %si, %cx
jge 0x1be99
leaq 0xe(%rsp), %rax
jmp 0x1bea2
movl %r14d, %eax
subl %r11d, %eax
imull %r8d, %eax
movl %r9d, %ecx
subl %r11d, %ecx
cltd
idivl %ecx
leal (%rsi,%rax), %ecx
decl %ecx
movw %cx, 0xc(%rsp)
testb %r10b, %r10b
je 0x1be92
movswl 0x2(%r15), %eax
movswl 0x4(%r15), %edi
subl %eax, %edi
imull 0x30(%rsp), %eax
cltd
idivl %edi
subl %eax, %esi
movl %r10d, %r14d
cmpw %si, %cx
jle 0x1beb6
movw %si, 0x8(%rsp)
jmp 0x1be95
movl %r10d, %r14d
movl %ecx, %eax
jmp 0x1bec4
leaq 0xa(%rsp), %rax
movw %cx, 0x4(%rax)
movw %si, (%rax)
movl %r10d, %r14d
movzwl 0x8(%rsp), %eax
cmpw 0xc(%rsp), %ax
jne 0x1bec9
jmp 0x1bedf
movw %cx, 0x8(%rsp)
movw %si, 0xc(%rsp)
movl %esi, %eax
movl %ecx, %esi
cmpw %ax, %si
je 0x1bedf
leaq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x50(%rsp), %rdx
movl %ebx, %ecx
callq 0x336d4
movq %rbp, %rdi
callq 0x6812
testb %al, %al
je 0x1bf1e
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq 0x40(%rsp), %rsi
callq 0x74d4
movb $0x0, 0x8(%rbx)
andw $0x0, 0x12(%rbx)
leaq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
movl 0x14(%rsp), %ebx
movl %ebx, %ecx
callq 0x336d4
leaq 0x66(%rsp), %r8
movq 0x20(%rbp), %rsi
movq %rsi, %rdi
shrq $0x30, %rdi
movq %rsi, -0x6(%r8)
movb 0x22(%r15), %al
cmpw %r13w, %r12w
jge 0x1bf79
movq %rsi, %r9
shrq $0x20, %r9
testb $0x1, %al
jne 0x1bfb8
movl %r12d, %eax
cwtd
movw $0xfffe, %cx            # imm = 0xFFFE
idivw %cx
testb %r14b, %r14b
je 0x1bf64
cmpw $0x0, 0x38(%rsp)
jle 0x1c0ea
addw 0xa(%rsp), %ax
movw %ax, 0x62(%rsp)
addl %eax, %r12d
decl %r12d
jmp 0x1c0a4
movl %esi, %r9d
shrl $0x10, %r9d
testb $0x1, %al
jne 0x1c011
movl %r13d, %eax
cwtd
movw $0xfffe, %cx            # imm = 0xFFFE
idivw %cx
testb %r14b, %r14b
je 0x1c069
cmpw $0x0, 0x38(%rsp)
movq 0x20(%rsp), %rsi
jle 0x1c0f4
addw 0xc(%rsp), %ax
jmp 0x1c0f9
movswl 0xa(%r15), %r8d
cmpl $-0x1, %r8d
je 0x1c070
notl %r12d
addl %r12d, %r13d
movswl %r13w, %r10d
movswl 0x6(%r15), %eax
movl 0x18(%rsp), %ebp
subl %ebp, %eax
imull %r10d, %eax
movl 0x1c(%rsp), %r11d
subl %ebp, %r11d
cltd
idivl %r11d
movl %eax, %ecx
movswl 0x8(%r15), %eax
subl %ebp, %eax
imull %r10d, %eax
cltd
idivl %r11d
movswl %cx, %edx
cwtl
subl %edx, %eax
imull %r8d, %eax
shrl $0x8, %eax
addl %ecx, %eax
jmp 0x1c095
movswl 0xa(%r15), %r10d
cmpl $-0x1, %r10d
je 0x1c0bc
movl %r13d, %eax
notl %eax
addl %eax, %r12d
movswl %r12w, %r11d
movswl 0x6(%r15), %eax
movl 0x18(%rsp), %r14d
subl %r14d, %eax
imull %r11d, %eax
movl 0x1c(%rsp), %ebp
subl %r14d, %ebp
cltd
idivl %ebp
movl %eax, %ecx
movswl 0x8(%r15), %eax
subl %r14d, %eax
imull %r11d, %eax
cltd
idivl %ebp
movswl %cx, %ecx
cwtl
subl %ecx, %eax
imull %r10d, %eax
sarl $0x8, %eax
addl %ecx, %eax
jmp 0x1c0dc
addw 0xc(%rsp), %ax
jmp 0x1c0de
movl 0x30(%rsp), %eax
notl %eax
movl 0x34(%rsp), %ecx
addl %eax, %ecx
movl 0x18(%rsp), %edx
movl 0x3c(%rsp), %eax
subl %edx, %eax
imull %ecx, %eax
movl 0x1c(%rsp), %ecx
subl %edx, %ecx
cltd
idivl %ecx
notl %r12d
leaq 0x62(%rsp), %r8
subl %eax, %edi
movw %di, 0x4(%r8)
addl %edi, %r12d
movw %r12w, (%r8)
leaq 0x64(%rsp), %r8
movw %si, -0x4(%r8)
movl %r9d, %edi
movq 0x20(%rsp), %rsi
jmp 0x1c10e
movl 0x34(%rsp), %ecx
notl %ecx
addl 0x30(%rsp), %ecx
movl 0x18(%rsp), %edx
movl 0x3c(%rsp), %eax
subl %edx, %eax
imull %ecx, %eax
movl 0x1c(%rsp), %ecx
subl %edx, %ecx
cltd
idivl %ecx
addl %esi, %eax
movw %ax, 0x60(%rsp)
movq 0x20(%rsp), %rsi
jmp 0x1c0fe
addw 0xe(%rsp), %ax
jmp 0x1bf69
addw 0x8(%rsp), %ax
movw %ax, 0x60(%rsp)
addl %r13d, %eax
decl %eax
movw %ax, 0x64(%rsp)
movw %r9w, 0x62(%rsp)
movw %di, (%r8)
leaq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rdx
movl %ebx, %ecx
callq 0x336d4
movl 0x4c(%rsp), %edx
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
cmpb $0x2, %dl
setne %al
retq