// File: /workspace/github_cpp_makefile_star2_O2/lunasorcery[P]brailify/./stb/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;
    int 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;
    int 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]) / 255;
        }
        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]) / 255;
        }
        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]) / 65535;
        }
        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]) / 65535);

            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]) / 65535;
        }
        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]) / 4294967295);
        }
        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]) / 4294967295));

            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]) / 4294967295);
        }
        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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r12
movslq 0x4c(%rdi), %rcx
movslq 0x50(%rdi), %rax
movq %rax, -0x58(%rbp)
movl 0x58(%rdi), %ebx
movslq 0x8(%rdi), %r14
movl 0xc(%rdi), %edx
movl 0x10(%rdi), %eax
movl %eax, -0x50(%rbp)
movq 0x98(%rdi), %r15
movl 0xb8(%rdi), %eax
movq %rcx, -0x40(%rbp)
imull %ecx, %eax
cltq
movq %rax, -0x98(%rbp)
movl 0x64(%rdi), %eax
movl %eax, -0x2c(%rbp)
movl 0x68(%rdi), %r13d
addl %ebx, %ebx
addl 0x6c(%rdi), %ebx
movl %r13d, %edi
movl %esi, -0x38(%rbp)
callq 0xeb16
movq (%r12), %rcx
movq %rcx, -0x48(%rbp)
movq %r12, -0x80(%rbp)
movl 0xb8(%r12), %ecx
movq %r14, -0x60(%rbp)
leal (%rcx,%r14), %r8d
negl %ecx
cmpl $0x4, %r13d
jne 0xd943
cmpl $0x0, -0x38(%rbp)
js 0xda0d
movq -0x80(%rbp), %rdx
movl -0x38(%rbp), %esi
cmpl %esi, 0xc(%rdx)
jle 0xda0d
cmpl $0x7, %ebx
ja 0xe1bd
movq -0x98(%rbp), %r9
leaq (%r15,%r9,4), %rdi
imull -0x50(%rbp), %eax
cltq
addq %rax, -0x48(%rbp)
movl %ebx, %eax
leaq 0x28da(%rip), %rdx      # 0x10244
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
movl %r8d, -0x8c(%rbp)
movq %rdi, -0xa0(%rbp)
jmpq *%rax
xorl %ebx, %ebx
movq -0x40(%rbp), %rdx
testl %edx, %edx
cmovgl %edx, %ebx
movslq %ecx, %r12
cmpl %r8d, %ecx
cmovlel %r8d, %ecx
movslq %ecx, %rax
movq %rax, -0x38(%rbp)
movq %rdx, %rax
imulq %r12, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r13
addq %r15, %r13
leaq (,%rdx,4), %r14
cmpq -0x38(%rbp), %r12
je 0xe049
movl -0x2c(%rbp), %edi
movl %r12d, %esi
movq -0x60(%rbp), %rdx
callq 0xeb16
movss 0x2628(%rip), %xmm1     # 0x10004
imull -0x40(%rbp), %eax
cltq
addq -0x48(%rbp), %rax
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0xda05
movzbl (%rax,%rcx), %edx
cvtsi2ss %edx, %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%r13,%rcx,4)
incq %rcx
jmp 0xd9e8
incq %r12
addq %r14, %r13
jmp 0xd9bb
xorl %eax, %eax
movq -0x40(%rbp), %rdi
testl %edi, %edi
cmovgl %edi, %eax
cmpl %r8d, %ecx
cmovgl %ecx, %r8d
movslq %ecx, %rcx
movslq %r8d, %rdx
movq %rdi, %rsi
imulq %rcx, %rsi
movq -0x98(%rbp), %r8
shlq $0x2, %r8
leaq (%r8,%rsi,4), %rsi
addq %rsi, %r15
shlq $0x2, %rdi
cmpq %rdx, %rcx
je 0xe1ae
xorl %esi, %esi
cmpq %rsi, %rax
je 0xda5c
andl $0x0, (%r15,%rsi,4)
incq %rsi
jmp 0xda4d
incq %rcx
addq %rdi, %r15
jmp 0xda42
xorl %ebx, %ebx
movq -0x40(%rbp), %rdx
testl %edx, %edx
cmovgl %edx, %ebx
movslq %ecx, %r12
cmpl %r8d, %ecx
cmovlel %r8d, %ecx
movslq %ecx, %rax
movq %rax, -0x38(%rbp)
movq %rdx, %rax
imulq %r12, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r13
addq %r15, %r13
leaq (,%rdx,4), %r14
cmpq -0x38(%rbp), %r12
je 0xe049
movl -0x2c(%rbp), %edi
movl %r12d, %esi
movq -0x60(%rbp), %rdx
callq 0xeb16
movsd 0x31c1(%rip), %xmm1     # 0x10c80
imull -0x40(%rbp), %eax
cltq
movq -0x48(%rbp), %rcx
leaq (%rcx,%rax,4), %rax
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0xdaf0
movl (%rax,%rcx,4), %edx
cvtsi2sd %rdx, %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r13,%rcx,4)
incq %rcx
jmp 0xdacf
incq %r12
addq %r14, %r13
jmp 0xda9e
xorl %ebx, %ebx
movq -0x40(%rbp), %rdx
testl %edx, %edx
cmovgl %edx, %ebx
movslq %ecx, %r12
cmpl %r8d, %ecx
cmovlel %r8d, %ecx
movslq %ecx, %rax
movq %rax, -0x38(%rbp)
movq %rdx, %rax
imulq %r12, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r13
addq %r15, %r13
leaq (,%rdx,4), %r14
cmpq -0x38(%rbp), %r12
je 0xe049
movl -0x2c(%rbp), %edi
movl %r12d, %esi
movq -0x60(%rbp), %rdx
callq 0xeb16
movss 0x24cd(%rip), %xmm1     # 0x10020
imull -0x40(%rbp), %eax
cltq
movq -0x48(%rbp), %rcx
leaq (%rcx,%rax,2), %rax
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0xdb80
movzwl (%rax,%rcx,2), %edx
cvtsi2ss %edx, %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%r13,%rcx,4)
incq %rcx
jmp 0xdb63
incq %r12
addq %r14, %r13
jmp 0xdb32
xorl %ebx, %ebx
movq -0x40(%rbp), %rdx
testl %edx, %edx
cmovgl %edx, %ebx
movslq %ecx, %rsi
cmpl %r8d, %ecx
cmovlel %r8d, %ecx
movslq %ecx, %rax
movq %rax, -0x70(%rbp)
movq -0x58(%rbp), %rax
leaq (%rdi,%rax,4), %rax
movq %rax, -0x88(%rbp)
movq %rdx, %rax
imulq %rsi, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r14
addq %r15, %r14
leaq (,%rdx,4), %rax
movq %rax, -0x68(%rbp)
cmpq -0x70(%rbp), %rsi
je 0xe049
movq %rsi, %rax
movq -0x40(%rbp), %r12
imulq %r12, %rax
movq %rax, -0x50(%rbp)
movl -0x2c(%rbp), %edi
movq %rsi, -0x38(%rbp)
movq -0x60(%rbp), %rdx
callq 0xeb16
imull %r12d, %eax
movl %eax, -0x78(%rbp)
cltq
movq -0x48(%rbp), %rcx
leaq (%rcx,%rax,2), %r12
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0xdc67
movzwl (%r12,%r13,2), %eax
cvtsi2ss %eax, %xmm0
divss 0x23f8(%rip), %xmm0     # 0x10020
movss 0x2444(%rip), %xmm1     # 0x10074
ucomiss %xmm0, %xmm1
jae 0xdc54
addss 0x243f(%rip), %xmm0     # 0x1007c
divss 0x243b(%rip), %xmm0     # 0x10080
movss 0x2437(%rip), %xmm1     # 0x10084
callq 0x1190
jmp 0xdc5c
divss 0x241c(%rip), %xmm0     # 0x10078
movss %xmm0, (%r14,%r13,4)
incq %r13
jmp 0xdc12
movq -0x80(%rbp), %rax
testb $0x2, 0x54(%rax)
movq -0x38(%rbp), %rsi
jne 0xdca1
movl -0x78(%rbp), %eax
addl -0x58(%rbp), %eax
cltq
movq -0x48(%rbp), %rcx
movzwl (%rcx,%rax,2), %eax
cvtsi2ss %eax, %xmm0
divss 0x238f(%rip), %xmm0     # 0x10020
movq -0x88(%rbp), %rax
movq -0x50(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
incq %rsi
addq -0x68(%rbp), %r14
jmp 0xdbd5
movslq %ecx, %rsi
xorl %ebx, %ebx
movq -0x40(%rbp), %rdx
testl %edx, %edx
cmovgl %edx, %ebx
cmpl %r8d, %esi
cmovlel %r8d, %ecx
movslq %ecx, %rax
movq %rax, -0x70(%rbp)
movq -0x58(%rbp), %rax
leaq (%rdi,%rax,4), %rax
movq %rax, -0x88(%rbp)
movq %rdx, %rax
imulq %rsi, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r14
addq %r15, %r14
leaq (,%rdx,4), %rax
movq %rax, -0x68(%rbp)
cmpq -0x70(%rbp), %rsi
je 0xe049
movq %rsi, %rax
movq -0x40(%rbp), %r12
imulq %r12, %rax
movq %rax, -0x50(%rbp)
movl -0x2c(%rbp), %edi
movq %rsi, -0x38(%rbp)
movq -0x60(%rbp), %rdx
callq 0xeb16
imull %r12d, %eax
movl %eax, -0x78(%rbp)
cltq
movq -0x48(%rbp), %rcx
leaq (%rcx,%rax,4), %r12
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0xdd81
movss (%r12,%r13,4), %xmm0
movss 0x232a(%rip), %xmm1     # 0x10074
ucomiss %xmm0, %xmm1
jae 0xdd6e
addss 0x2325(%rip), %xmm0     # 0x1007c
divss 0x2321(%rip), %xmm0     # 0x10080
movss 0x231d(%rip), %xmm1     # 0x10084
callq 0x1190
jmp 0xdd76
divss 0x2302(%rip), %xmm0     # 0x10078
movss %xmm0, (%r14,%r13,4)
incq %r13
jmp 0xdd37
movq -0x80(%rbp), %rax
testb $0x2, 0x54(%rax)
movq -0x38(%rbp), %rsi
jne 0xddb0
movl -0x78(%rbp), %eax
addl -0x58(%rbp), %eax
cltq
movq -0x48(%rbp), %rcx
movss (%rcx,%rax,4), %xmm0
movq -0x88(%rbp), %rax
movq -0x50(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
incq %rsi
addq -0x68(%rbp), %r14
jmp 0xdcfa
xorl %ebx, %ebx
movq -0x40(%rbp), %rdx
testl %edx, %edx
cmovgl %edx, %ebx
movslq %ecx, %rsi
cmpl %r8d, %ecx
cmovlel %r8d, %ecx
movslq %ecx, %rax
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rax
leaq (%rdi,%rax,4), %rax
movq %rax, -0x68(%rbp)
movq %rdx, %rax
imulq %rsi, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r13
addq %r15, %r13
leaq (,%rdx,4), %rax
movq %rax, -0x70(%rbp)
leaq 0x28a3(%rip), %r14      # 0x106b0
movq -0x40(%rbp), %r12
cmpq -0x78(%rbp), %rsi
je 0xe049
movq %rsi, %rax
imulq %r12, %rax
movq %rax, -0x50(%rbp)
movl -0x2c(%rbp), %edi
movq %rsi, -0x38(%rbp)
movq -0x60(%rbp), %rdx
callq 0xeb16
imull %r12d, %eax
cltq
movq -0x48(%rbp), %rcx
addq %rax, %rcx
xorl %edx, %edx
movq -0x80(%rbp), %rdi
cmpq %rdx, %rbx
je 0xde64
movzbl (%rcx,%rdx), %esi
movss (%r14,%rsi,4), %xmm0
movss %xmm0, (%r13,%rdx,4)
incq %rdx
jmp 0xde49
testb $0x2, 0x54(%rdi)
jne 0xde8f
addq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movzbl (%rcx,%rax), %eax
cvtsi2ss %eax, %xmm0
divss 0x2182(%rip), %xmm0     # 0x10004
movq -0x68(%rbp), %rax
movq -0x50(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x38(%rbp), %rsi
incq %rsi
addq -0x70(%rbp), %r13
jmp 0xde11
xorl %ebx, %ebx
movq -0x40(%rbp), %rdx
testl %edx, %edx
cmovgl %edx, %ebx
movslq %ecx, %rsi
cmpl %r8d, %ecx
cmovlel %r8d, %ecx
movslq %ecx, %rax
movq %rax, -0x70(%rbp)
movq -0x58(%rbp), %rax
leaq (%rdi,%rax,4), %rax
movq %rax, -0x88(%rbp)
movq %rdx, %rax
imulq %rsi, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r14
addq %r15, %r14
leaq (,%rdx,4), %rax
movq %rax, -0x68(%rbp)
cmpq -0x70(%rbp), %rsi
je 0xe049
movq %rsi, %rax
movq -0x40(%rbp), %r12
imulq %r12, %rax
movq %rax, -0x50(%rbp)
movl -0x2c(%rbp), %edi
movq %rsi, -0x38(%rbp)
movq -0x60(%rbp), %rdx
callq 0xeb16
imull %r12d, %eax
movl %eax, -0x78(%rbp)
cltq
movq -0x48(%rbp), %rcx
leaq (%rcx,%rax,4), %r12
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0xdf82
movl (%r12,%r13,4), %eax
cvtsi2sd %rax, %xmm0
divsd 0x2d41(%rip), %xmm0     # 0x10c80
cvtsd2ss %xmm0, %xmm0
movss 0x2129(%rip), %xmm1     # 0x10074
ucomiss %xmm0, %xmm1
jae 0xdf6f
addss 0x2124(%rip), %xmm0     # 0x1007c
divss 0x2120(%rip), %xmm0     # 0x10080
movss 0x211c(%rip), %xmm1     # 0x10084
callq 0x1190
jmp 0xdf77
divss 0x2101(%rip), %xmm0     # 0x10078
movss %xmm0, (%r14,%r13,4)
incq %r13
jmp 0xdf29
movq -0x80(%rbp), %rax
testb $0x2, 0x54(%rax)
movq -0x38(%rbp), %rsi
jne 0xdfc0
movl -0x78(%rbp), %eax
addl -0x58(%rbp), %eax
cltq
movq -0x48(%rbp), %rcx
movl (%rcx,%rax,4), %eax
cvtsi2sd %rax, %xmm0
divsd 0x2cd4(%rip), %xmm0     # 0x10c80
cvtsd2ss %xmm0, %xmm0
movq -0x88(%rbp), %rax
movq -0x50(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
incq %rsi
addq -0x68(%rbp), %r14
jmp 0xdeec
xorl %ebx, %ebx
movq -0x40(%rbp), %rdx
testl %edx, %edx
cmovgl %edx, %ebx
movslq %ecx, %r12
cmpl %r8d, %ecx
cmovlel %r8d, %ecx
movslq %ecx, %rax
movq %rax, -0x38(%rbp)
movq %rdx, %rax
imulq %r12, %rax
leaq (,%r9,4), %rcx
leaq (%rcx,%rax,4), %r13
addq %r15, %r13
leaq (,%rdx,4), %r14
cmpq -0x38(%rbp), %r12
je 0xe049
movl -0x2c(%rbp), %edi
movl %r12d, %esi
movq -0x60(%rbp), %rdx
callq 0xeb16
imull -0x40(%rbp), %eax
cltq
movq -0x48(%rbp), %rcx
leaq (%rcx,%rax,4), %rax
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0xe041
movss (%rax,%rcx,4), %xmm0
movss %xmm0, (%r13,%rcx,4)
incq %rcx
jmp 0xe02b
incq %r12
addq %r14, %r13
jmp 0xe006
movq -0x80(%rbp), %r12
testb $0x1, 0x54(%r12)
movq -0x40(%rbp), %r11
movq -0x60(%rbp), %rbx
movq -0x98(%rbp), %r14
jne 0xe111
xorl %eax, %eax
xorl %edx, %edx
subl 0xb8(%r12), %edx
movq -0x58(%rbp), %rdi
movl %edi, %ecx
testl %r11d, %r11d
cmovgl %r11d, %eax
movslq %edx, %rdx
movl -0x8c(%rbp), %esi
cmpl %esi, %edx
cmovgl %edx, %esi
movslq %esi, %rsi
movq -0xa0(%rbp), %r8
leaq (%r8,%rdi,4), %rdi
movq %r11, %r8
imulq %rdx, %r8
leaq (,%r14,4), %r9
leaq (%r9,%r8,4), %r8
addq %r15, %r8
leaq (,%r11,4), %r9
movss 0x1fc5(%rip), %xmm0     # 0x10088
cmpq %rsi, %rdx
je 0xe111
movq %rdx, %r10
imulq %r11, %r10
movss (%rdi,%r10,4), %xmm1
cmpl $0x3, 0x58(%r12)
je 0xe0e7
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%r10,4)
xorl %r10d, %r10d
cmpq %r10, %rax
je 0xe109
cmpq %r10, %rcx
je 0xe104
movss (%r8,%r10,4), %xmm2
mulss %xmm1, %xmm2
movss %xmm2, (%r8,%r10,4)
incq %r10
jmp 0xe0ea
incq %rdx
addq %r9, %r8
jmp 0xe0c3
cmpl $0x4, -0x2c(%rbp)
jne 0xe1ae
xorl %ecx, %ecx
xorl %edx, %edx
subl 0xb8(%r12), %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 %r15, %rsi
movq %r11, %rdi
shlq $0x2, %rdi
cmpq %rcx, %rdx
je 0xe173
xorl %r8d, %r8d
cmpq %r8, %rax
je 0xe16b
andl $0x0, (%rsi,%r8,4)
incq %r8
jmp 0xe15c
incq %rdx
addq %rdi, %rsi
jmp 0xe154
movslq -0x8c(%rbp), %rcx
movq %rbx, %rdx
imulq %r11, %rdx
leaq (%r14,%rdx,4), %rdx
addq %rdx, %r15
leaq (,%r11,4), %rdx
cmpq %rcx, %rbx
jge 0xe1ae
xorl %esi, %esi
cmpq %rsi, %rax
je 0xe1a6
andl $0x0, (%r15,%rsi,4)
incq %rsi
jmp 0xe197
incq %rbx
addq %rdx, %r15
jmp 0xe190
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3ddf(%rip), %rdi      # 0x11fa3
leaq 0x35c9(%rip), %rsi      # 0x11794
leaq 0x3e02(%rip), %rcx      # 0x11fd4
movl $0x54f, %edx            # imm = 0x54F
callq 0x1080