// File: /workspace/github_c_makefile_star2_O3/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 0x1dfd0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r13
movq %rsi, 0x30(%rsp)
movl %edx, 0x4c(%rsp)
callq 0x6af7
movq %rax, %r12
movq %r13, %rdi
xorl %esi, %esi
callq 0x1e148
movq %rax, %rbx
movq %r13, %rdi
movl $0x2, %esi
callq 0x1e148
movq %rax, 0x58(%rsp)
movq %r13, %rdi
movl $0x1, %esi
callq 0x1e148
movq %rax, 0x50(%rsp)
movq %r13, %rdi
callq 0x69eb
movb %al, 0x4(%rsp)
movzwl 0x24(%r13), %r15d
movzwl 0x26(%r13), %ebp
subw 0x20(%r13), %r15w
subw 0x22(%r13), %bp
movq 0x20(%r13), %rcx
movswl 0x16(%rbx), %r10d
movswl 0x18(%rbx), %eax
movswl 0x1a(%rbx), %r11d
movq %rbx, 0x40(%rsp)
movswl 0x1c(%rbx), %esi
leal (%r10,%rax), %ebx
addl $0x4, %ebx
movl %ecx, %edi
shrl $0x10, %edi
movq %rcx, %rdx
shrq $0x30, %rdx
movl %edx, %r8d
subl %edi, %r8d
incl %r8d
movswl %r8w, %r14d
movl $0x1fffc, %r8d          # imm = 0x1FFFC
leal (%r14,%r8), %r9d
shrl %r9d
cmpl %r14d, %ebx
cmovgl %r9d, %eax
cmovlel %r10d, %r9d
leal (%r11,%rsi), %ebx
addl $0x4, %ebx
movq %rcx, %r10
shrq $0x20, %r10
movl %r10d, %r14d
subl %ecx, %r14d
incl %r14d
movswl %r14w, %r14d
addl %r14d, %r8d
shrl %r8d
cmpl %r14d, %ebx
cmovgl %r8d, %esi
cmovlel %r11d, %r8d
movq %r15, 0x28(%rsp)
leal 0x1(%r15), %ebx
movq %rbp, 0x38(%rsp)
leal 0x1(%rbp), %r11d
testb $0x1, 0x22(%r12)
movl %r11d, %r15d
jne 0x1da15
cmpw %r11w, %bx
movl $0x0, %r11d
cmovgel %r11d, %r8d
cmovgel %r11d, %esi
cmovlel %r11d, %r9d
cmovlel %r11d, %eax
addl %edi, %r9d
subl %esi, %r10d
addl %ecx, %r8d
movw %r8w, 0x18(%rsp)
movw %r10w, 0x1c(%rsp)
movw %r9w, 0x1a(%rsp)
subl %eax, %edx
movw %dx, 0x1e(%rsp)
movq %r13, %rdi
callq 0x6bc9
movzbl 0x4(%rsp), %ebp
testb %al, %al
movl %ebp, 0x4(%rsp)
je 0x1da77
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq 0x40(%rsp), %rsi
callq 0x799d
movw $0x0, 0xc(%r14)
leaq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %r14, %rdx
movq %rsi, %r14
jmp 0x1da89
leaq 0x18(%rsp), %rdi
movq 0x30(%rsp), %r14
movq %r14, %rsi
movq 0x40(%rsp), %rdx
movl %ebp, %ecx
callq 0x36968
movq 0x18(%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 0x21e66(%rip), %xmm3    # 0x3f930
movd 0x18(%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 0x21e33(%rip), %xmm5    # 0x3f940
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 %r13, %rdi
callq 0x1e0ae
movl %eax, %ebp
movq %r13, %rdi
callq 0x94e0
movw %ax, 0x2(%rsp)
movq %r13, %rdi
callq 0x950c
movl %eax, %r11d
movzwl 0x20(%r12), %eax
cmpl $0x8000, %eax           # imm = 0x8000
cmovnel %eax, %ebp
testb $0x1, 0xe(%r12)
jne 0x1db94
movl $0x0, 0x14(%rsp)
movl %r15d, %eax
jmp 0x1dbb8
cmpw $0x0, 0x2(%r12)
movl %r15d, %eax
js 0x1dbaa
movl $0x0, 0x14(%rsp)
jmp 0x1dbb8
cmpw $0x0, 0x4(%r12)
setg %cl
movl %ecx, 0x14(%rsp)
movswl %bx, %ecx
movl %ecx, 0x20(%rsp)
movswl %ax, %ecx
movl %ecx, 0x24(%rsp)
movswl 0xa(%r12), %edi
cmpw %ax, %bx
movw %r11w, 0x12(%rsp)
jge 0x1dc34
movzwl 0xe(%rsp), %esi
movl %esi, %eax
subw 0xa(%rsp), %ax
incl %eax
movswl %ax, %r8d
cmpw $-0x1, %di
je 0x1dc8f
movswl 0x6(%r12), %eax
movswl 0x2(%rsp), %r9d
subl %r9d, %eax
imull %r8d, %eax
movswl %r11w, %r10d
subl %r9d, %r10d
cltd
idivl %r10d
movl %eax, %ecx
movswl 0x8(%r12), %eax
subl %r9d, %eax
imull %r8d, %eax
cltd
idivl %r10d
movswl %cx, %ecx
cwtl
subl %ecx, %eax
imull %edi, %eax
sarl $0x8, %eax
addl %ecx, %eax
jmp 0x1dca6
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %eax
subl %esi, %eax
incl %eax
movswl %ax, %r9d
movswl 0x2(%rsp), %r10d
movswl %r11w, %r8d
cmpw $-0x1, %di
je 0x1dcdc
movswl 0x6(%r12), %eax
subl %r10d, %eax
imull %r9d, %eax
subl %r10d, %r8d
cltd
idivl %r8d
movl %eax, %ecx
movswl 0x8(%r12), %eax
subl %r10d, %eax
imull %r9d, %eax
cltd
idivl %r8d
movswl %cx, %ecx
cwtl
subl %ecx, %eax
imull %edi, %eax
sarl $0x8, %eax
addl %ecx, %eax
jmp 0x1dced
movswl %bp, %eax
movswl 0x2(%rsp), %ecx
subl %ecx, %eax
imull %r8d, %eax
movswl %r11w, %edi
subl %ecx, %edi
cltd
idivl %edi
movl %esi, %ecx
subl %eax, %ecx
incl %ecx
movw %cx, 0xa(%rsp)
cmpb $0x0, 0x14(%rsp)
je 0x1dd30
movswl 0x2(%r12), %eax
movswl 0x4(%r12), %edi
subl %eax, %edi
imull 0x24(%rsp), %eax
cltd
idivl %edi
addl %eax, %esi
cmpw %si, %cx
jge 0x1dd24
leaq 0xe(%rsp), %rax
jmp 0x1dd2d
movswl %bp, %eax
subl %r10d, %eax
imull %r9d, %eax
subl %r10d, %r8d
cltd
idivl %r8d
leal (%rsi,%rax), %ecx
decl %ecx
movw %cx, 0xc(%rsp)
cmpb $0x0, 0x14(%rsp)
je 0x1dd20
movswl 0x2(%r12), %eax
movswl 0x4(%r12), %edi
subl %eax, %edi
imull 0x20(%rsp), %eax
cltd
idivl %edi
subl %eax, %esi
cmpw %si, %cx
jle 0x1dd3e
movw %si, 0x8(%rsp)
movl %ecx, %eax
jmp 0x1dd4c
leaq 0xa(%rsp), %rax
movw %cx, 0x4(%rax)
movw %si, (%rax)
movzwl 0x8(%rsp), %eax
cmpw 0xc(%rsp), %ax
jne 0x1dd51
jmp 0x1dd67
movw %cx, 0x8(%rsp)
movw %si, 0xc(%rsp)
movl %esi, %eax
movl %ecx, %esi
cmpw %ax, %si
je 0x1dd67
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq 0x50(%rsp), %rdx
movl 0x4(%rsp), %ecx
callq 0x36968
movq %r13, %rdi
callq 0x6bc9
testb %al, %al
je 0x1ddac
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq 0x40(%rsp), %rsi
callq 0x799d
movb $0x0, 0x8(%r14)
movw $0x0, 0x12(%r14)
leaq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %r14, %rdx
movq 0x30(%rsp), %r14
movl 0x4(%rsp), %ecx
callq 0x36968
leaq 0x66(%rsp), %r8
movq 0x20(%r13), %rdi
movq %rdi, %rsi
shrq $0x30, %rsi
movq %rdi, -0x6(%r8)
movb 0x22(%r12), %al
cmpw %r15w, %bx
jge 0x1de0f
movq %rdi, %r9
shrq $0x20, %r9
testb $0x1, %al
jne 0x1de47
movzwl %bx, %eax
shrl $0xf, %eax
addl %ebx, %eax
movswl %ax, %esi
sarl %esi
negl %esi
cmpb $0x0, 0x14(%rsp)
je 0x1ddf5
testw %bp, %bp
jle 0x1dfd7
addw 0xa(%rsp), %si
movw %si, 0x62(%rsp)
movl 0x4(%rsp), %ecx
movq 0x28(%rsp), %rax
addl %eax, %esi
jmp 0x1df54
movl %edi, %r9d
shrl $0x10, %r9d
testb $0x1, %al
jne 0x1deb4
movzwl %r15w, %eax
shrl $0xf, %eax
addl %r15d, %eax
cwtl
sarl %eax
negl %eax
cmpb $0x0, 0x14(%rsp)
je 0x1de3d
testw %bp, %bp
jle 0x1dfe1
addw 0xc(%rsp), %ax
jmp 0x1df8d
movswl 0xa(%r12), %r8d
cmpl $-0x1, %r8d
je 0x1df13
movq 0x38(%rsp), %rcx
movq 0x28(%rsp), %r15
movl %r15d, %eax
notl %eax
addl %eax, %ecx
movswl %cx, %r10d
movswl 0x6(%r12), %eax
movswl 0x2(%rsp), %r11d
subl %r11d, %eax
imull %r10d, %eax
movswl 0x12(%rsp), %ebx
subl %r11d, %ebx
cltd
idivl %ebx
movl %eax, %ecx
movswl 0x8(%r12), %eax
subl %r11d, %eax
imull %r10d, %eax
cltd
idivl %ebx
movswl %cx, %edx
cwtl
subl %edx, %eax
imull %r8d, %eax
shrl $0x8, %eax
addl %ecx, %eax
movl 0x4(%rsp), %ecx
jmp 0x1df42
movswl 0xa(%r12), %r10d
cmpl $-0x1, %r10d
je 0x1df67
movq 0x38(%rsp), %rax
notl %eax
movq 0x28(%rsp), %rcx
addl %eax, %ecx
movswl %cx, %r11d
movswl 0x6(%r12), %eax
movswl 0x2(%rsp), %ebx
subl %ebx, %eax
imull %r11d, %eax
movswl 0x12(%rsp), %ebp
subl %ebx, %ebp
cltd
idivl %ebp
movl %eax, %ecx
movswl 0x8(%r12), %eax
subl %ebx, %eax
imull %r11d, %eax
cltd
idivl %ebp
movswl %cx, %ecx
cwtl
subl %ecx, %eax
imull %r10d, %eax
sarl $0x8, %eax
addl %ecx, %eax
jmp 0x1df8b
movl 0x20(%rsp), %eax
notl %eax
movl 0x24(%rsp), %edx
addl %eax, %edx
movswl %bp, %eax
movswl 0x2(%rsp), %ecx
subl %ecx, %eax
imull %edx, %eax
movswl 0x12(%rsp), %r8d
subl %ecx, %r8d
cltd
idivl %r8d
movl 0x4(%rsp), %ecx
movq 0x28(%rsp), %r15
leaq 0x62(%rsp), %r8
subl %eax, %esi
movw %si, 0x4(%r8)
subl %r15d, %esi
addl $-0x2, %esi
movw %si, (%r8)
leaq 0x64(%rsp), %r8
movw %di, -0x4(%r8)
movl %r9d, %esi
jmp 0x1dfa5
movl 0x24(%rsp), %edx
notl %edx
addl 0x20(%rsp), %edx
movswl %bp, %eax
movswl 0x2(%rsp), %ecx
subl %ecx, %eax
imull %edx, %eax
movswl 0x12(%rsp), %r10d
subl %ecx, %r10d
cltd
idivl %r10d
addl %edi, %eax
movw %ax, 0x60(%rsp)
movl 0x4(%rsp), %ecx
addl 0x38(%rsp), %eax
movw %ax, 0x64(%rsp)
movw %r9w, 0x62(%rsp)
movw %si, (%r8)
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
movq 0x58(%rsp), %rdx
callq 0x36968
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
addw 0xe(%rsp), %si
jmp 0x1ddfa
addw 0x8(%rsp), %ax
jmp 0x1df8d