// File: /workspace/github_c_makefile_star2_O0/OnionIoT[P]lv_example/lvgl/src/lv_draw/lv_draw_rect.c
// Function: lv_draw_shadow_full
static void lv_draw_shadow_full(const lv_area_t * coords, const lv_area_t * mask, const lv_style_t * style,
                                lv_opa_t opa_scale)
{

    /* KNOWN ISSUE
     * The algorithm calculates the shadow only above the middle point of the radius (speaking about
     * the left top corner). It causes an error because it doesn't consider how long the straight
     * edge is which effects the value of bottom of the corner shadow. In addition the straight
     * shadow is drawn from the middles point of the radius however the ends of the straight parts
     * still should be effected by the corner shadow. It also causes an issue in opacity. A smaller
     * radius means smaller average shadow opacity. The solution should be to start `line` from `-
     * swidth` and handle if the straight part is short (or zero) and the value is taken from the
     * other corner. `col` also should start from `- swidth`
     */

    bool aa = lv_disp_get_antialiasing(lv_refr_get_disp_refreshing());

    lv_coord_t radius = style->body.radius;
    lv_coord_t swidth = style->body.shadow.width;

    lv_coord_t width  = lv_area_get_width(coords);
    lv_coord_t height = lv_area_get_height(coords);

    radius = lv_draw_cont_radius_corr(radius, width, height);

    radius += aa;

    /*Allocate a draw buffer the buffer required to draw the shadow*/
    int16_t filter_width = 2 * swidth + 1;
    uint32_t curve_x_size = ((radius + swidth + 1) + 3) & ~0x3; /*Round to 4*/
    curve_x_size *= sizeof(lv_coord_t);
    uint32_t line_1d_blur_size = (filter_width + 3) & ~0x3;     /*Round to 4*/
    line_1d_blur_size *= sizeof(uint32_t);
    uint32_t line_2d_blur_size = ((radius + swidth + 1) + 3) & ~0x3;     /*Round to 4*/
    line_2d_blur_size *= sizeof(lv_opa_t);

    uint8_t * draw_buf = lv_draw_get_buf(curve_x_size + line_1d_blur_size + line_2d_blur_size);

    /*Divide the draw buffer*/
    lv_coord_t  * curve_x = (lv_coord_t *)&draw_buf[0]; /*Stores the 'x' coordinates of a quarter circle.*/
    uint32_t * line_1d_blur = (uint32_t *)&draw_buf[curve_x_size];
    lv_opa_t * line_2d_blur = (lv_opa_t *)&draw_buf[curve_x_size + line_1d_blur_size];

    memset(curve_x, 0, curve_x_size);
    lv_point_t circ;
    lv_coord_t circ_tmp;
    lv_circ_init(&circ, &circ_tmp, radius);
    while(lv_circ_cont(&circ)) {
        curve_x[LV_CIRC_OCT1_Y(circ)] = LV_CIRC_OCT1_X(circ);
        curve_x[LV_CIRC_OCT2_Y(circ)] = LV_CIRC_OCT2_X(circ);
        lv_circ_next(&circ, &circ_tmp);
    }
    int16_t line;
    /*1D Blur horizontally*/
    lv_opa_t opa = opa_scale == LV_OPA_COVER ? style->body.opa : (uint16_t)((uint16_t)style->body.opa * opa_scale) >> 8;
    for(line = 0; line < filter_width; line++) {
        line_1d_blur[line] = (uint32_t)((uint32_t)(filter_width - line) * (opa * 2) << SHADOW_OPA_EXTRA_PRECISION) /
                             (filter_width * filter_width);
    }

    uint16_t col;

    lv_point_t point_rt;
    lv_point_t point_rb;
    lv_point_t point_lt;
    lv_point_t point_lb;
    lv_point_t ofs_rb;
    lv_point_t ofs_rt;
    lv_point_t ofs_lb;
    lv_point_t ofs_lt;
    ofs_rb.x = coords->x2 - radius - aa;
    ofs_rb.y = coords->y2 - radius - aa;

    ofs_rt.x = coords->x2 - radius - aa;
    ofs_rt.y = coords->y1 + radius + aa;

    ofs_lb.x = coords->x1 + radius + aa;
    ofs_lb.y = coords->y2 - radius - aa;

    ofs_lt.x = coords->x1 + radius + aa;
    ofs_lt.y = coords->y1 + radius + aa;
    bool line_ready;
    for(line = 0; line <= radius + swidth; line++) { /*Check all rows and make the 1D blur to 2D*/
        line_ready = false;
        for(col = 0; col <= radius + swidth; col++) { /*Check all pixels in a 1D blur line (from the origo to last
                                                         shadow pixel (radius + swidth))*/

            /*Sum the opacities from the lines above and below this 'row'*/
            int16_t line_rel;
            uint32_t px_opa_sum = 0;
            for(line_rel = -swidth; line_rel <= swidth; line_rel++) {
                /*Get the relative x position of the 'line_rel' to 'line'*/
                int16_t col_rel;
                if(line + line_rel < 0) { /*Below the radius, here is the blur of the edge */
                    col_rel = radius - curve_x[line] - col;
                } else if(line + line_rel > radius) { /*Above the radius, here won't be more 1D blur*/
                    break;
                } else { /*Blur from the curve*/
                    col_rel = curve_x[line + line_rel] - curve_x[line] - col;
                }

                /*Add the value of the 1D blur on 'col_rel' position*/
                if(col_rel < -swidth) { /*Outside of the blurred area. */
                    if(line_rel == -swidth)
                        line_ready = true; /*If no data even on the very first line then it wont't
                                              be anything else in this line*/
                    break;                 /*Break anyway because only smaller 'col_rel' values will come */
                } else if(col_rel > swidth)
                    px_opa_sum += line_1d_blur[0]; /*Inside the not blurred area*/
                else
                    px_opa_sum += line_1d_blur[swidth - col_rel]; /*On the 1D blur (+ swidth to align to the center)*/
            }

            line_2d_blur[col] = px_opa_sum >> SHADOW_OPA_EXTRA_PRECISION;
            if(line_ready) {
                col++; /*To make this line to the last one ( drawing will go to '< col')*/
                break;
            }
        }

        /*Flush the line*/
        point_rt.x = curve_x[line] + ofs_rt.x + 1;
        point_rt.y = ofs_rt.y - line;

        point_rb.x = curve_x[line] + ofs_rb.x + 1;
        point_rb.y = ofs_rb.y + line;

        point_lt.x = ofs_lt.x - curve_x[line] - 1;
        point_lt.y = ofs_lt.y - line;

        point_lb.x = ofs_lb.x - curve_x[line] - 1;
        point_lb.y = ofs_lb.y + line;

        uint16_t d;
        for(d = 1; d < col; d++) {

            if(point_lt.x < ofs_lt.x && point_lt.y < ofs_lt.y) {
                lv_draw_px(point_lt.x, point_lt.y, mask, style->body.shadow.color, line_2d_blur[d]);
            }

            if(point_lb.x < ofs_lb.x && point_lb.y > ofs_lb.y) {
                lv_draw_px(point_lb.x, point_lb.y, mask, style->body.shadow.color, line_2d_blur[d]);
            }

            if(point_rt.x > ofs_rt.x && point_rt.y < ofs_rt.y) {
                lv_draw_px(point_rt.x, point_rt.y, mask, style->body.shadow.color, line_2d_blur[d]);
            }

            if(point_rb.x > ofs_rb.x && point_rb.y > ofs_rb.y) {
                lv_draw_px(point_rb.x, point_rb.y, mask, style->body.shadow.color, line_2d_blur[d]);
            }

            point_rb.x++;
            point_lb.x--;

            point_rt.x++;
            point_lt.x--;
        }

        /* Put the first line to the edges too.
         * It is not correct because blur should be done below the corner too
         * but is is simple, fast and gives a good enough result*/
        if(line == 0) lv_draw_shadow_full_straight(coords, mask, style, line_2d_blur);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
callq 0xafe0
movq %rax, %rdi
callq 0xdb00
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movw 0x6(%rax), %ax
movw %ax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movw 0x12(%rax), %ax
movw %ax, -0x1e(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5ab30
movw %ax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5ab10
movw %ax, -0x22(%rbp)
movw -0x1c(%rbp), %cx
movw -0x20(%rbp), %ax
movzwl %cx, %edi
movswl %ax, %esi
movswl -0x22(%rbp), %edx
callq 0x5e0e0
movw %ax, -0x1c(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movswl -0x1c(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x1c(%rbp)
movswl -0x1e(%rbp), %eax
shll %eax
addl $0x1, %eax
movw %ax, -0x24(%rbp)
movswl -0x1c(%rbp), %eax
movswl -0x1e(%rbp), %ecx
addl %ecx, %eax
addl $0x1, %eax
addl $0x3, %eax
andl $-0x4, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
shlq %rax
movl %eax, -0x28(%rbp)
movswl -0x24(%rbp), %eax
addl $0x3, %eax
andl $-0x4, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
shlq $0x2, %rax
movl %eax, -0x2c(%rbp)
movswl -0x1c(%rbp), %eax
movswl -0x1e(%rbp), %ecx
addl %ecx, %eax
addl $0x1, %eax
addl $0x3, %eax
andl $-0x4, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
shlq $0x0, %rax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %edi
addl -0x2c(%rbp), %edi
addl -0x30(%rbp), %edi
callq 0x5a6a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movl -0x28(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movl -0x28(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2090
leaq -0x54(%rbp), %rdi
leaq -0x56(%rbp), %rsi
movswl -0x1c(%rbp), %edx
callq 0x42540
leaq -0x54(%rbp), %rdi
callq 0x42580
testb $0x1, %al
jne 0x5e50b
jmp 0x5e53c
movw -0x54(%rbp), %dx
movq -0x40(%rbp), %rax
movswq -0x52(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movw -0x52(%rbp), %dx
movq -0x40(%rbp), %rax
movswq -0x54(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
leaq -0x54(%rbp), %rdi
leaq -0x56(%rbp), %rsi
callq 0x425b0
jmp 0x5e4fc
movzbl -0x19(%rbp), %eax
cmpl $0xff, %eax
jne 0x5e557
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, -0x8c(%rbp)
jmp 0x5e575
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
movzwl %ax, %eax
movzbl -0x19(%rbp), %ecx
imull %ecx, %eax
movzwl %ax, %eax
sarl $0x8, %eax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
movb %al, -0x59(%rbp)
movw $0x0, -0x58(%rbp)
movswl -0x58(%rbp), %eax
movswl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5e5d1
movswl -0x24(%rbp), %eax
movswl -0x58(%rbp), %ecx
subl %ecx, %eax
movzbl -0x59(%rbp), %ecx
shll %ecx
imull %ecx, %eax
shll $0x8, %eax
movswl -0x24(%rbp), %ecx
movswl -0x24(%rbp), %edx
imull %edx, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %edx
movq -0x48(%rbp), %rax
movswq -0x58(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movw -0x58(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x58(%rbp)
jmp 0x5e584
movq -0x8(%rbp), %rax
movswl 0x4(%rax), %eax
movswl -0x1c(%rbp), %ecx
subl %ecx, %eax
movb -0x1a(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movw %ax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movswl 0x6(%rax), %eax
movswl -0x1c(%rbp), %ecx
subl %ecx, %eax
movb -0x1a(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movw %ax, -0x6e(%rbp)
movq -0x8(%rbp), %rax
movswl 0x4(%rax), %eax
movswl -0x1c(%rbp), %ecx
subl %ecx, %eax
movb -0x1a(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movw %ax, -0x74(%rbp)
movq -0x8(%rbp), %rax
movswl 0x2(%rax), %eax
movswl -0x1c(%rbp), %ecx
addl %ecx, %eax
movb -0x1a(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movw %ax, -0x72(%rbp)
movq -0x8(%rbp), %rax
movswl (%rax), %eax
movswl -0x1c(%rbp), %ecx
addl %ecx, %eax
movb -0x1a(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movw %ax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movswl 0x6(%rax), %eax
movswl -0x1c(%rbp), %ecx
subl %ecx, %eax
movb -0x1a(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movw %ax, -0x76(%rbp)
movq -0x8(%rbp), %rax
movswl (%rax), %eax
movswl -0x1c(%rbp), %ecx
addl %ecx, %eax
movb -0x1a(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movw %ax, -0x7c(%rbp)
movq -0x8(%rbp), %rax
movswl 0x2(%rax), %eax
movswl -0x1c(%rbp), %ecx
addl %ecx, %eax
movb -0x1a(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movw %ax, -0x7a(%rbp)
movw $0x0, -0x58(%rbp)
movswl -0x58(%rbp), %eax
movswl -0x1c(%rbp), %ecx
movswl -0x1e(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jg 0x5eab5
movb $0x0, -0x7d(%rbp)
movw $0x0, -0x5c(%rbp)
movzwl -0x5c(%rbp), %eax
movswl -0x1c(%rbp), %ecx
movswl -0x1e(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jg 0x5e855
movl $0x0, -0x84(%rbp)
movswl -0x1e(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, -0x80(%rbp)
movswl -0x80(%rbp), %eax
movswl -0x1e(%rbp), %ecx
cmpl %ecx, %eax
jg 0x5e818
movswl -0x58(%rbp), %eax
movswl -0x80(%rbp), %ecx
addl %ecx, %eax
cmpl $0x0, %eax
jge 0x5e74a
movswl -0x1c(%rbp), %eax
movq -0x40(%rbp), %rcx
movswq -0x58(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
subl %ecx, %eax
movzwl -0x5c(%rbp), %ecx
subl %ecx, %eax
movw %ax, -0x86(%rbp)
jmp 0x5e794
movswl -0x58(%rbp), %eax
movswl -0x80(%rbp), %ecx
addl %ecx, %eax
movswl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jle 0x5e761
jmp 0x5e818
movq -0x40(%rbp), %rax
movswl -0x58(%rbp), %ecx
movswl -0x80(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movswl (%rax,%rcx,2), %eax
movq -0x40(%rbp), %rcx
movswq -0x58(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
subl %ecx, %eax
movzwl -0x5c(%rbp), %ecx
subl %ecx, %eax
movw %ax, -0x86(%rbp)
jmp 0x5e794
movswl -0x86(%rbp), %eax
movswl -0x1e(%rbp), %edx
xorl %ecx, %ecx
subl %edx, %ecx
cmpl %ecx, %eax
jge 0x5e7bd
movswl -0x80(%rbp), %eax
movswl -0x1e(%rbp), %edx
xorl %ecx, %ecx
subl %edx, %ecx
cmpl %ecx, %eax
jne 0x5e7bb
movb $0x1, -0x7d(%rbp)
jmp 0x5e818
movswl -0x86(%rbp), %eax
movswl -0x1e(%rbp), %ecx
cmpl %ecx, %eax
jle 0x5e7e0
movq -0x48(%rbp), %rax
movl (%rax), %eax
addl -0x84(%rbp), %eax
movl %eax, -0x84(%rbp)
jmp 0x5e803
movq -0x48(%rbp), %rax
movswl -0x1e(%rbp), %ecx
movswl -0x86(%rbp), %edx
subl %edx, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl -0x84(%rbp), %eax
movl %eax, -0x84(%rbp)
jmp 0x5e805
jmp 0x5e807
movw -0x80(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x80(%rbp)
jmp 0x5e709
movl -0x84(%rbp), %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x50(%rbp), %rax
movzwl -0x5c(%rbp), %ecx
movb %dl, (%rax,%rcx)
testb $0x1, -0x7d(%rbp)
je 0x5e842
movw -0x5c(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x5c(%rbp)
jmp 0x5e855
jmp 0x5e844
movw -0x5c(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x5c(%rbp)
jmp 0x5e6dd
movq -0x40(%rbp), %rax
movswq -0x58(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
movswl -0x74(%rbp), %ecx
addl %ecx, %eax
addl $0x1, %eax
movw %ax, -0x60(%rbp)
movswl -0x72(%rbp), %eax
movswl -0x58(%rbp), %ecx
subl %ecx, %eax
movw %ax, -0x5e(%rbp)
movq -0x40(%rbp), %rax
movswq -0x58(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
movswl -0x70(%rbp), %ecx
addl %ecx, %eax
addl $0x1, %eax
movw %ax, -0x64(%rbp)
movswl -0x6e(%rbp), %eax
movswl -0x58(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0x62(%rbp)
movswl -0x7c(%rbp), %eax
movq -0x40(%rbp), %rcx
movswq -0x58(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
subl %ecx, %eax
subl $0x1, %eax
movw %ax, -0x68(%rbp)
movswl -0x7a(%rbp), %eax
movswl -0x58(%rbp), %ecx
subl %ecx, %eax
movw %ax, -0x66(%rbp)
movswl -0x78(%rbp), %eax
movq -0x40(%rbp), %rcx
movswq -0x58(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
subl %ecx, %eax
subl $0x1, %eax
movw %ax, -0x6c(%rbp)
movswl -0x76(%rbp), %eax
movswl -0x58(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0x6a(%rbp)
movw $0x1, -0x88(%rbp)
movzwl -0x88(%rbp), %eax
movzwl -0x5c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5ea84
movswl -0x68(%rbp), %eax
movswl -0x7c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5e95c
movswl -0x66(%rbp), %eax
movswl -0x7a(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5e95c
movw -0x68(%rbp), %di
movw -0x66(%rbp), %si
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x50(%rbp), %rax
movzwl -0x88(%rbp), %r8d
movb (%rax,%r8), %al
movswl %di, %edi
movswl %si, %esi
movzwl 0x10(%rcx), %ecx
movzbl %al, %r8d
callq 0x58ba0
movswl -0x6c(%rbp), %eax
movswl -0x78(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5e9a7
movswl -0x6a(%rbp), %eax
movswl -0x76(%rbp), %ecx
cmpl %ecx, %eax
jle 0x5e9a7
movw -0x6c(%rbp), %di
movw -0x6a(%rbp), %si
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x50(%rbp), %rax
movzwl -0x88(%rbp), %r8d
movb (%rax,%r8), %al
movswl %di, %edi
movswl %si, %esi
movzwl 0x10(%rcx), %ecx
movzbl %al, %r8d
callq 0x58ba0
movswl -0x60(%rbp), %eax
movswl -0x74(%rbp), %ecx
cmpl %ecx, %eax
jle 0x5e9f2
movswl -0x5e(%rbp), %eax
movswl -0x72(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5e9f2
movw -0x60(%rbp), %di
movw -0x5e(%rbp), %si
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x50(%rbp), %rax
movzwl -0x88(%rbp), %r8d
movb (%rax,%r8), %al
movswl %di, %edi
movswl %si, %esi
movzwl 0x10(%rcx), %ecx
movzbl %al, %r8d
callq 0x58ba0
movswl -0x64(%rbp), %eax
movswl -0x70(%rbp), %ecx
cmpl %ecx, %eax
jle 0x5ea3d
movswl -0x62(%rbp), %eax
movswl -0x6e(%rbp), %ecx
cmpl %ecx, %eax
jle 0x5ea3d
movw -0x64(%rbp), %di
movw -0x62(%rbp), %si
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x50(%rbp), %rax
movzwl -0x88(%rbp), %r8d
movb (%rax,%r8), %al
movswl %di, %edi
movswl %si, %esi
movzwl 0x10(%rcx), %ecx
movzbl %al, %r8d
callq 0x58ba0
movw -0x64(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x64(%rbp)
movw -0x6c(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x6c(%rbp)
movw -0x60(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x60(%rbp)
movw -0x68(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x68(%rbp)
movw -0x88(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x88(%rbp)
jmp 0x5e8fe
movswl -0x58(%rbp), %eax
cmpl $0x0, %eax
jne 0x5eaa2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x5ef10
jmp 0x5eaa4
movw -0x58(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x58(%rbp)
jmp 0x5e6bd
addq $0x90, %rsp
popq %rbp
retq
nop