// File: /workspace/github_c_makefile_star2_O2/algorithm-archivists[P]GathVL/src/objects/../../include/stb_image_resize.h
// Function: stbir__decode_scanline(stbir__info*, int)
static void stbir__decode_scanline(stbir__info* stbir_info, int n)
{
    int c;
    int channels = stbir_info->channels;
    int alpha_channel = stbir_info->alpha_channel;
    int type = stbir_info->type;
    int colorspace = stbir_info->colorspace;
    int input_w = stbir_info->input_w;
    size_t input_stride_bytes = stbir_info->input_stride_bytes;
    float* decode_buffer = stbir__get_decode_buffer(stbir_info);
    stbir_edge edge_horizontal = stbir_info->edge_horizontal;
    stbir_edge edge_vertical = stbir_info->edge_vertical;
    size_t in_buffer_row_offset = stbir__edge_wrap(edge_vertical, n, stbir_info->input_h) * input_stride_bytes;
    const void* input_data = (char *) stbir_info->input_data + in_buffer_row_offset;
    int max_x = input_w + stbir_info->horizontal_filter_pixel_margin;
    int decode = STBIR__DECODE(type, colorspace);

    int x = -stbir_info->horizontal_filter_pixel_margin;

    // special handling for STBIR_EDGE_ZERO because it needs to return an item that doesn't appear in the input,
    // and we want to avoid paying overhead on every pixel if not STBIR_EDGE_ZERO
    if (edge_vertical == STBIR_EDGE_ZERO && (n < 0 || n >= stbir_info->input_h))
    {
        for (; x < max_x; x++)
            for (c = 0; c < channels; c++)
                decode_buffer[x*channels + c] = 0;
        return;
    }

    switch (decode)
    {
    case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_LINEAR):
        for (; x < max_x; x++)
        {
            int decode_pixel_index = x * channels;
            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
            for (c = 0; c < channels; c++)
                decode_buffer[decode_pixel_index + c] = ((float)((const unsigned char*)input_data)[input_pixel_index + c]) / stbir__max_uint8_as_float;
        }
        break;

    case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_SRGB):
        for (; x < max_x; x++)
        {
            int decode_pixel_index = x * channels;
            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
            for (c = 0; c < channels; c++)
                decode_buffer[decode_pixel_index + c] = stbir__srgb_uchar_to_linear_float[((const unsigned char*)input_data)[input_pixel_index + c]];

            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
                decode_buffer[decode_pixel_index + alpha_channel] = ((float)((const unsigned char*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint8_as_float;
        }
        break;

    case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_LINEAR):
        for (; x < max_x; x++)
        {
            int decode_pixel_index = x * channels;
            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
            for (c = 0; c < channels; c++)
                decode_buffer[decode_pixel_index + c] = ((float)((const unsigned short*)input_data)[input_pixel_index + c]) / stbir__max_uint16_as_float;
        }
        break;

    case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_SRGB):
        for (; x < max_x; x++)
        {
            int decode_pixel_index = x * channels;
            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
            for (c = 0; c < channels; c++)
                decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear(((float)((const unsigned short*)input_data)[input_pixel_index + c]) / stbir__max_uint16_as_float);

            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
                decode_buffer[decode_pixel_index + alpha_channel] = ((float)((const unsigned short*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint16_as_float;
        }
        break;

    case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_LINEAR):
        for (; x < max_x; x++)
        {
            int decode_pixel_index = x * channels;
            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
            for (c = 0; c < channels; c++)
                decode_buffer[decode_pixel_index + c] = (float)(((double)((const unsigned int*)input_data)[input_pixel_index + c]) / stbir__max_uint32_as_float);
        }
        break;

    case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_SRGB):
        for (; x < max_x; x++)
        {
            int decode_pixel_index = x * channels;
            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
            for (c = 0; c < channels; c++)
                decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear((float)(((double)((const unsigned int*)input_data)[input_pixel_index + c]) / stbir__max_uint32_as_float));

            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
                decode_buffer[decode_pixel_index + alpha_channel] = (float)(((double)((const unsigned int*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint32_as_float);
        }
        break;

    case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_LINEAR):
        for (; x < max_x; x++)
        {
            int decode_pixel_index = x * channels;
            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
            for (c = 0; c < channels; c++)
                decode_buffer[decode_pixel_index + c] = ((const float*)input_data)[input_pixel_index + c];
        }
        break;

    case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_SRGB):
        for (; x < max_x; x++)
        {
            int decode_pixel_index = x * channels;
            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
            for (c = 0; c < channels; c++)
                decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear(((const float*)input_data)[input_pixel_index + c]);

            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
                decode_buffer[decode_pixel_index + alpha_channel] = ((const float*)input_data)[input_pixel_index + alpha_channel];
        }

        break;

    default:
        STBIR_ASSERT(!"Unknown type/colorspace/channels combination.");
        break;
    }

    if (!(stbir_info->flags & STBIR_FLAG_ALPHA_PREMULTIPLIED))
    {
        for (x = -stbir_info->horizontal_filter_pixel_margin; x < max_x; x++)
        {
            int decode_pixel_index = x * channels;

            // If the alpha value is 0 it will clobber the color values. Make sure it's not.
            float alpha = decode_buffer[decode_pixel_index + alpha_channel];
#ifndef STBIR_NO_ALPHA_EPSILON
            if (stbir_info->type != STBIR_TYPE_FLOAT) {
                alpha += STBIR_ALPHA_EPSILON;
                decode_buffer[decode_pixel_index + alpha_channel] = alpha;
            }
#endif
            for (c = 0; c < channels; c++)
            {
                if (c == alpha_channel)
                    continue;

                decode_buffer[decode_pixel_index + c] *= alpha;
            }
        }
    }

    if (edge_horizontal == STBIR_EDGE_ZERO)
    {
        for (x = -stbir_info->horizontal_filter_pixel_margin; x < 0; x++)
        {
            for (c = 0; c < channels; c++)
                decode_buffer[x*channels + c] = 0;
        }
        for (x = input_w; x < max_x; x++)
        {
            for (c = 0; c < channels; c++)
                decode_buffer[x*channels + c] = 0;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
movslq 0x4c(%rdi), %rbp
movslq 0x50(%rdi), %rax
movq %rax, 0x20(%rsp)
movl 0xc(%rdi), %edx
movl 0x58(%rdi), %ebx
movslq 0x8(%rdi), %r15
movslq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rdi), %r13
movl 0xb8(%rdi), %eax
imull %ebp, %eax
cltq
movq %rax, 0x60(%rsp)
movl 0x64(%rdi), %eax
movl %eax, 0xc(%rsp)
movl 0x68(%rdi), %r12d
addl %ebx, %ebx
addl 0x6c(%rdi), %ebx
movl %r12d, %edi
movl %esi, 0x18(%rsp)
callq 0x17a1d
cltq
imulq 0x10(%rsp), %rax
addq (%r14), %rax
movq %rax, 0x10(%rsp)
movq %r14, 0x50(%rsp)
movl 0xb8(%r14), %eax
movq %r15, 0x28(%rsp)
leal (%rax,%r15), %edi
negl %eax
cmpl $0x4, %r12d
jne 0x16883
cmpl $0x0, 0x18(%rsp)
js 0x16940
movq 0x50(%rsp), %rcx
movl 0x18(%rsp), %edx
cmpl %edx, 0xc(%rcx)
jle 0x16940
cmpl $0x7, %ebx
ja 0x170e3
movq 0x60(%rsp), %r9
leaq (,%r9,4), %r8
addq %r13, %r8
movl %ebx, %ecx
leaq 0x4e7f(%rip), %rdx      # 0x1b724
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
movq %rbp, 0x18(%rsp)
movl %edi, 0x6c(%rsp)
movq %r8, 0x70(%rsp)
jmpq *%rcx
xorl %ebx, %ebx
testl %ebp, %ebp
cmovgl %ebp, %ebx
movslq %eax, %r15
cmpl %edi, %eax
cmovlel %edi, %eax
movslq %eax, %r14
movq %rbp, %rax
imulq %r15, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r12
addq %r13, %r12
leaq (,%rbp,4), %rbp
cmpq %r14, %r15
je 0x16f75
movl 0xc(%rsp), %edi
movl %r15d, %esi
movq 0x28(%rsp), %rdx
callq 0x17a1d
movss 0x4aea(%rip), %xmm1     # 0x1b3f8
imull 0x18(%rsp), %eax
cltq
addq 0x10(%rsp), %rax
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x16938
movzbl (%rax,%rcx), %edx
cvtsi2ss %edx, %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%r12,%rcx,4)
incq %rcx
jmp 0x1691c
incq %r15
addq %rbp, %r12
jmp 0x168ec
xorl %ecx, %ecx
testl %ebp, %ebp
cmovgl %ebp, %ecx
cmpl %edi, %eax
cmovgl %eax, %edi
cltq
movslq %edi, %rdx
movq %rbp, %rsi
imulq %rax, %rsi
movq 0x60(%rsp), %rdi
shlq $0x2, %rdi
leaq (%rdi,%rsi,4), %rsi
addq %rsi, %r13
shlq $0x2, %rbp
cmpq %rdx, %rax
je 0x170d4
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x16987
andl $0x0, (%r13,%rsi,4)
incq %rsi
jmp 0x16977
incq %rax
addq %rbp, %r13
jmp 0x1696c
xorl %ebx, %ebx
testl %ebp, %ebp
cmovgl %ebp, %ebx
movslq %eax, %r15
cmpl %edi, %eax
cmovlel %edi, %eax
movslq %eax, %r14
movq %rbp, %rax
imulq %r15, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r12
addq %r13, %r12
leaq (,%rbp,4), %rbp
cmpq %r14, %r15
je 0x16f75
movl 0xc(%rsp), %edi
movl %r15d, %esi
movq 0x28(%rsp), %rdx
callq 0x17a1d
movsd 0x58cf(%rip), %xmm1     # 0x1c2b0
imull 0x18(%rsp), %eax
cltq
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x16a13
movl (%rax,%rcx,4), %edx
cvtsi2sd %rdx, %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r12,%rcx,4)
incq %rcx
jmp 0x169f3
incq %r15
addq %rbp, %r12
jmp 0x169bf
xorl %ebx, %ebx
testl %ebp, %ebp
cmovgl %ebp, %ebx
movslq %eax, %r15
cmpl %edi, %eax
cmovlel %edi, %eax
movslq %eax, %r14
movq %rbp, %rax
imulq %r15, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r12
addq %r13, %r12
leaq (,%rbp,4), %rbp
cmpq %r14, %r15
je 0x16f75
movl 0xc(%rsp), %edi
movl %r15d, %esi
movq 0x28(%rsp), %rdx
callq 0x17a1d
movss 0x4997(%rip), %xmm1     # 0x1b404
imull 0x18(%rsp), %eax
cltq
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,2), %rax
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x16a9b
movzwl (%rax,%rcx,2), %edx
cvtsi2ss %edx, %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%r12,%rcx,4)
incq %rcx
jmp 0x16a7f
incq %r15
addq %rbp, %r12
jmp 0x16a4b
xorl %r14d, %r14d
testl %ebp, %ebp
cmovgl %ebp, %r14d
movslq %eax, %rsi
cmpl %edi, %eax
cmovlel %edi, %eax
cltq
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
leaq (%r8,%rax,4), %rax
movq %rax, 0x58(%rsp)
movq %rbp, %rax
imulq %rsi, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %rbx
addq %r13, %rbx
leaq (,%rbp,4), %rax
movq %rax, 0x30(%rsp)
cmpq 0x38(%rsp), %rsi
je 0x16f75
movq %rsi, %rax
movq 0x18(%rsp), %r15
imulq %r15, %rax
movq %rax, 0x40(%rsp)
movl 0xc(%rsp), %edi
movq %rsi, 0x48(%rsp)
movq 0x28(%rsp), %rdx
callq 0x17a1d
movl %eax, %r12d
imull %r15d, %r12d
movslq %r12d, %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,2), %rbp
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x16b87
movzwl (%rbp,%r15,2), %eax
cvtsi2ss %eax, %xmm0
divss 0x48bc(%rip), %xmm0     # 0x1b404
movss 0x490c(%rip), %xmm1     # 0x1b45c
ucomiss %xmm0, %xmm1
jae 0x16b74
addss 0x4907(%rip), %xmm0     # 0x1b464
divss 0x4903(%rip), %xmm0     # 0x1b468
movss 0x48ff(%rip), %xmm1     # 0x1b46c
callq 0x5660
jmp 0x16b7c
divss 0x48e4(%rip), %xmm0     # 0x1b460
movss %xmm0, (%rbx,%r15,4)
incq %r15
jmp 0x16b31
movq 0x50(%rsp), %rax
testb $0x2, 0x54(%rax)
movq 0x48(%rsp), %rsi
jne 0x16bc3
addl 0x20(%rsp), %r12d
movslq %r12d, %rax
movq 0x10(%rsp), %rcx
movzwl (%rcx,%rax,2), %eax
cvtsi2ss %eax, %xmm0
divss 0x4850(%rip), %xmm0     # 0x1b404
movq 0x58(%rsp), %rax
movq 0x40(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
incq %rsi
addq 0x30(%rsp), %rbx
jmp 0x16aec
movslq %eax, %rsi
xorl %r14d, %r14d
testl %ebp, %ebp
cmovgl %ebp, %r14d
cmpl %edi, %esi
cmovlel %edi, %eax
cltq
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
leaq (%r8,%rax,4), %rax
movq %rax, 0x58(%rsp)
movq %rbp, %rax
imulq %rsi, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %rbx
addq %r13, %rbx
leaq (,%rbp,4), %rax
movq %rax, 0x30(%rsp)
cmpq 0x38(%rsp), %rsi
je 0x16f75
movq %rsi, %rax
movq 0x18(%rsp), %r15
imulq %r15, %rax
movq %rax, 0x40(%rsp)
movl 0xc(%rsp), %edi
movq %rsi, 0x48(%rsp)
movq 0x28(%rsp), %rdx
callq 0x17a1d
movl %eax, %r12d
imull %r15d, %r12d
movslq %r12d, %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,4), %r15
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x16ca6
movss (%r15,%rbp,4), %xmm0
movss 0x47ec(%rip), %xmm1     # 0x1b45c
ucomiss %xmm0, %xmm1
jae 0x16c94
addss 0x47e7(%rip), %xmm0     # 0x1b464
divss 0x47e3(%rip), %xmm0     # 0x1b468
movss 0x47df(%rip), %xmm1     # 0x1b46c
callq 0x5660
jmp 0x16c9c
divss 0x47c4(%rip), %xmm0     # 0x1b460
movss %xmm0, (%rbx,%rbp,4)
incq %rbp
jmp 0x16c5d
movq 0x50(%rsp), %rax
testb $0x2, 0x54(%rax)
movq 0x48(%rsp), %rsi
jne 0x16cd7
addl 0x20(%rsp), %r12d
movslq %r12d, %rax
movq 0x10(%rsp), %rcx
movss (%rcx,%rax,4), %xmm0
movq 0x58(%rsp), %rax
movq 0x40(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
incq %rsi
addq 0x30(%rsp), %rbx
jmp 0x16c19
xorl %ebx, %ebx
testl %ebp, %ebp
cmovgl %ebp, %ebx
movslq %eax, %rsi
cmpl %edi, %eax
cmovlel %edi, %eax
cltq
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rax
leaq (%r8,%rax,4), %rax
movq %rax, 0x30(%rsp)
movq %rbp, %rax
imulq %rsi, %rax
leaq (,%r9,4), %rcx
movq %rbp, %rdx
leaq (%rcx,%rax,4), %rbp
addq %r13, %rbp
leaq (,%rdx,4), %rax
movq %rax, 0x38(%rsp)
leaq 0x4fbb(%rip), %r14      # 0x1bcf0
movq 0x18(%rsp), %r12
cmpq 0x40(%rsp), %rsi
je 0x16f75
movq %rsi, %r15
imulq %r12, %r15
movl 0xc(%rsp), %edi
movq %rsi, 0x48(%rsp)
movq 0x28(%rsp), %rdx
callq 0x17a1d
imull %r12d, %eax
cltq
movq 0x10(%rsp), %rcx
addq %rax, %rcx
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x16d89
movzbl (%rcx,%rdx), %esi
movss (%r14,%rsi,4), %xmm0
movss %xmm0, (%rbp,%rdx,4)
incq %rdx
jmp 0x16d6f
movq 0x50(%rsp), %rcx
testb $0x2, 0x54(%rcx)
jne 0x16db9
addq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl (%rcx,%rax), %eax
cvtsi2ss %eax, %xmm0
divss 0x464a(%rip), %xmm0     # 0x1b3f8
movq 0x30(%rsp), %rax
movss %xmm0, (%rax,%r15,4)
movq 0x48(%rsp), %rsi
incq %rsi
addq 0x38(%rsp), %rbp
jmp 0x16d3a
xorl %r14d, %r14d
testl %ebp, %ebp
cmovgl %ebp, %r14d
movslq %eax, %rsi
cmpl %edi, %eax
cmovlel %edi, %eax
cltq
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
leaq (%r8,%rax,4), %rax
movq %rax, 0x58(%rsp)
movq %rbp, %rax
imulq %rsi, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %rbx
addq %r13, %rbx
leaq (,%rbp,4), %rax
movq %rax, 0x30(%rsp)
cmpq 0x38(%rsp), %rsi
je 0x16f75
movq %rsi, %rax
movq 0x18(%rsp), %r15
imulq %r15, %rax
movq %rax, 0x40(%rsp)
movl 0xc(%rsp), %edi
movq %rsi, 0x48(%rsp)
movq 0x28(%rsp), %rdx
callq 0x17a1d
movl %eax, %r12d
imull %r15d, %r12d
movslq %r12d, %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,4), %rbp
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x16eb3
movl (%rbp,%r15,4), %eax
cvtsi2sd %rax, %xmm0
divsd 0x5440(%rip), %xmm0     # 0x1c2b0
cvtsd2ss %xmm0, %xmm0
movss 0x45e0(%rip), %xmm1     # 0x1b45c
ucomiss %xmm0, %xmm1
jae 0x16ea0
addss 0x45db(%rip), %xmm0     # 0x1b464
divss 0x45d7(%rip), %xmm0     # 0x1b468
movss 0x45d3(%rip), %xmm1     # 0x1b46c
callq 0x5660
jmp 0x16ea8
divss 0x45b8(%rip), %xmm0     # 0x1b460
movss %xmm0, (%rbx,%r15,4)
incq %r15
jmp 0x16e59
movq 0x50(%rsp), %rax
testb $0x2, 0x54(%rax)
movq 0x48(%rsp), %rsi
jne 0x16ef3
addl 0x20(%rsp), %r12d
movslq %r12d, %rax
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %eax
cvtsi2sd %rax, %xmm0
divsd 0x53d0(%rip), %xmm0     # 0x1c2b0
cvtsd2ss %xmm0, %xmm0
movq 0x58(%rsp), %rax
movq 0x40(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
incq %rsi
addq 0x30(%rsp), %rbx
jmp 0x16e14
xorl %ebx, %ebx
testl %ebp, %ebp
cmovgl %ebp, %ebx
movslq %eax, %r15
cmpl %edi, %eax
cmovlel %edi, %eax
movslq %eax, %r14
movq %rbp, %rax
imulq %r15, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r12
addq %r13, %r12
leaq (,%rbp,4), %rbp
cmpq %r14, %r15
je 0x16f75
movl 0xc(%rsp), %edi
movl %r15d, %esi
movq 0x28(%rsp), %rdx
callq 0x17a1d
imull 0x18(%rsp), %eax
cltq
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x16f6d
movss (%rax,%rcx,4), %xmm0
movss %xmm0, (%r12,%rcx,4)
incq %rcx
jmp 0x16f58
incq %r15
addq %rbp, %r12
jmp 0x16f30
movq 0x50(%rsp), %r15
testb $0x1, 0x54(%r15)
movq 0x18(%rsp), %r11
movq 0x28(%rsp), %rbx
movq 0x60(%rsp), %r14
movl 0x6c(%rsp), %ebp
jne 0x1703a
xorl %eax, %eax
xorl %edx, %edx
subl 0xb8(%r15), %edx
movq 0x20(%rsp), %rdi
movl %edi, %ecx
testl %r11d, %r11d
cmovgl %r11d, %eax
movslq %edx, %rdx
cmpl %ebp, %edx
movl %ebp, %esi
cmovgl %edx, %esi
movslq %esi, %rsi
movq 0x70(%rsp), %r8
leaq (%r8,%rdi,4), %rdi
movq %r11, %r8
imulq %rdx, %r8
leaq (,%r14,4), %r9
leaq (%r9,%r8,4), %r8
addq %r13, %r8
leaq (,%r11,4), %r9
movss 0x4483(%rip), %xmm0     # 0x1b470
cmpq %rsi, %rdx
je 0x1703a
movq %rdx, %r10
imulq %r11, %r10
movss (%rdi,%r10,4), %xmm1
cmpl $0x3, 0x58(%r15)
je 0x17010
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%r10,4)
xorl %r10d, %r10d
cmpq %r10, %rax
je 0x17032
cmpq %r10, %rcx
je 0x1702d
movss (%r8,%r10,4), %xmm2
mulss %xmm1, %xmm2
movss %xmm2, (%r8,%r10,4)
incq %r10
jmp 0x17013
incq %rdx
addq %r9, %r8
jmp 0x16fed
cmpl $0x4, 0xc(%rsp)
jne 0x170d4
xorl %ecx, %ecx
xorl %edx, %edx
subl 0xb8(%r15), %edx
testl %r11d, %r11d
movl $0x0, %eax
cmovgl %r11d, %eax
movslq %edx, %rdx
testl %edx, %edx
cmovgl %edx, %ecx
movq %r11, %rsi
imulq %rdx, %rsi
shlq $0x2, %r14
leaq (%r14,%rsi,4), %rsi
addq %r13, %rsi
movq %r11, %rdi
shlq $0x2, %rdi
cmpq %rcx, %rdx
je 0x1709c
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x17094
andl $0x0, (%rsi,%r8,4)
incq %r8
jmp 0x17085
incq %rdx
addq %rdi, %rsi
jmp 0x1707d
movslq %ebp, %rcx
movq %rbx, %rdx
imulq %r11, %rdx
leaq (%r14,%rdx,4), %rdx
addq %rdx, %r13
leaq (,%r11,4), %rdx
cmpq %rcx, %rbx
jge 0x170d4
xorl %esi, %esi
cmpq %rsi, %rax
je 0x170cc
andl $0x0, (%r13,%rsi,4)
incq %rsi
jmp 0x170bc
incq %rbx
addq %rdx, %r13
jmp 0x170b5
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x651b(%rip), %rdi      # 0x1d605
leaq 0x5d25(%rip), %rsi      # 0x1ce16
leaq 0x653e(%rip), %rcx      # 0x1d636
movl $0x556, %edx            # imm = 0x556
callq 0x5130