LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir_resize
STBIRDEF int stbir_resize(         const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
                                   stbir_datatype datatype,
                                   int num_channels, int alpha_channel, int flags,
                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, 
                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,
                                   stbir_colorspace space, void *alloc_context)
{
    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
        output_pixels, output_w, output_h, output_stride_in_bytes,
        0,0,1,1,NULL,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical,
        edge_mode_horizontal, edge_mode_vertical, space);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq 0x68(%rbp), %rax
movl 0x60(%rbp), %eax
movl 0x58(%rbp), %eax
movl 0x50(%rbp), %eax
movl 0x48(%rbp), %eax
movl 0x40(%rbp), %eax
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movl %edx, -0x38(%rbp)
movl %ecx, -0x3c(%rbp)
movq %r8, -0x48(%rbp)
movl %r9d, -0x4c(%rbp)
movq 0x68(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %ecx
movl -0x3c(%rbp), %r8d
movq -0x48(%rbp), %r9
movl -0x4c(%rbp), %eax
movl %eax, -0x60(%rbp)
movl 0x10(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl 0x18(%rbp), %eax
movl %eax, -0x58(%rbp)
movl 0x28(%rbp), %eax
movl %eax, -0x54(%rbp)
movl 0x30(%rbp), %r13d
movl 0x38(%rbp), %r12d
movl 0x20(%rbp), %r15d
movl 0x50(%rbp), %r14d
movl 0x58(%rbp), %ebx
movl 0x40(%rbp), %r11d
movl 0x48(%rbp), %r10d
movl 0x60(%rbp), %eax
movl %eax, -0x50(%rbp)
xorps %xmm1, %xmm1
movss 0x1ceec(%rip), %xmm3    # 0x20004
xorl %eax, %eax
movl -0x60(%rbp), %eax
movl %eax, (%rsp)
movl -0x5c(%rbp), %eax
movl %eax, 0x8(%rsp)
movl -0x58(%rbp), %eax
movl %eax, 0x10(%rsp)
movl -0x54(%rbp), %eax
movaps %xmm1, %xmm0
movaps %xmm3, %xmm2
movq $0x0, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movl -0x50(%rbp), %eax
movl %r13d, 0x28(%rsp)
movl %r12d, 0x30(%rsp)
movl %r15d, 0x38(%rsp)
movl %r14d, 0x40(%rsp)
movl %ebx, 0x48(%rsp)
movl %r11d, 0x50(%rsp)
movl %r10d, 0x58(%rsp)
movl %eax, 0x60(%rsp)
callq 0x2910
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir_resize_region
STBIRDEF int stbir_resize_region(  const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
                                   stbir_datatype datatype,
                                   int num_channels, int alpha_channel, int flags,
                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, 
                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,
                                   stbir_colorspace space, void *alloc_context,
                                   float s0, float t0, float s1, float t1)
{
    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
        output_pixels, output_w, output_h, output_stride_in_bytes,
        s0,t0,s1,t1,NULL,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical,
        edge_mode_horizontal, edge_mode_vertical, space);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x68(%rbp), %rax
movl 0x60(%rbp), %eax
movl 0x58(%rbp), %eax
movl 0x50(%rbp), %eax
movl 0x48(%rbp), %eax
movl 0x40(%rbp), %eax
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movl %edx, -0x38(%rbp)
movl %ecx, -0x3c(%rbp)
movq %r8, -0x48(%rbp)
movl %r9d, -0x4c(%rbp)
movss %xmm0, -0x50(%rbp)
movss %xmm1, -0x54(%rbp)
movss %xmm2, -0x58(%rbp)
movss %xmm3, -0x5c(%rbp)
movq 0x68(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %ecx
movl -0x3c(%rbp), %r8d
movq -0x48(%rbp), %r9
movl -0x4c(%rbp), %eax
movl %eax, -0x70(%rbp)
movl 0x10(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl 0x18(%rbp), %eax
movl %eax, -0x68(%rbp)
movss -0x50(%rbp), %xmm0
movss -0x54(%rbp), %xmm1
movss -0x58(%rbp), %xmm2
movss -0x5c(%rbp), %xmm3
movl 0x28(%rbp), %eax
movl %eax, -0x64(%rbp)
movl 0x30(%rbp), %r13d
movl 0x38(%rbp), %r12d
movl 0x20(%rbp), %r15d
movl 0x50(%rbp), %r14d
movl 0x58(%rbp), %ebx
movl 0x40(%rbp), %r11d
movl 0x48(%rbp), %r10d
movl 0x60(%rbp), %eax
movl %eax, -0x60(%rbp)
xorl %eax, %eax
movl -0x70(%rbp), %eax
movl %eax, (%rsp)
movl -0x6c(%rbp), %eax
movl %eax, 0x8(%rsp)
movl -0x68(%rbp), %eax
movl %eax, 0x10(%rsp)
movl -0x64(%rbp), %eax
movq $0x0, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movl -0x60(%rbp), %eax
movl %r13d, 0x28(%rsp)
movl %r12d, 0x30(%rsp)
movl %r15d, 0x38(%rsp)
movl %r14d, 0x40(%rsp)
movl %ebx, 0x48(%rsp)
movl %r11d, 0x50(%rsp)
movl %r10d, 0x58(%rsp)
movl %eax, 0x60(%rsp)
callq 0x2910
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)
// File: lunasorcery[P]brailify/main.cpp
// Function: parseCommandLine(int, char**)
void parseCommandLine(int argc, char** argv)
{
	while (1) {
		static struct option long_options[] = {
			{ "invert",          no_argument, 0, 'i' },
			{ "width",     required_argument, 0, 'w' },
			{ "threshold", required_argument, 0, 't' },
			{ 0, 0, 0, 0 }
		};

		int option_index = 0;
		int c = getopt_long(argc, argv, "iw:t:", long_options, &option_index);

		if (c == -1)
			break;

		switch (c) {
			case 'i': {
				flagInvert = true;
				break;
			}
			case 'w': {
				resizeWidth = strtol(optarg, nullptr, 10);
				if (resizeWidth <= 0) {
					printf("Width must be greater than zero.\n");
					exit(1);
				}
				break;
			}
			case 't': {
				useThreshold = true;
				threshold = strtol(optarg, nullptr, 10);
				break;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x1cefc(%rip), %rdx     # 0x205f0
leaq 0x22a15(%rip), %rcx     # 0x26110
leaq -0x14(%rbp), %r8
callq 0x11a0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x3712
jmp 0x37a7
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x69, %eax
je 0x3733
jmp 0x371f
movl -0x1c(%rbp), %eax
subl $0x74, %eax
je 0x377d
jmp 0x3729
movl -0x1c(%rbp), %eax
subl $0x77, %eax
je 0x373c
jmp 0x37a2
movb $0x1, 0x2320a(%rip)     # 0x26944
jmp 0x37a2
movq 0x2288d(%rip), %rax     # 0x25fd0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1150
movl %eax, 0x231ee(%rip)     # 0x26948
cmpl $0x0, 0x231e7(%rip)     # 0x26948
jg 0x377b
leaq 0x1ce8c(%rip), %rdi     # 0x205f6
movb $0x0, %al
callq 0x1050
movl $0x1, %edi
callq 0x1100
jmp 0x37a2
movb $0x1, 0x231c1(%rip)     # 0x26945
movq 0x22845(%rip), %rax     # 0x25fd0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1150
movl %eax, 0x2295e(%rip)     # 0x26100
jmp 0x36df
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: lunasorcery[P]brailify/main.cpp
// Function: main
int main(int argc, char** argv)
{
	parseCommandLine(argc, argv);

	if (optind >= argc) {
		printf("No filepath provided.\n");
		return 1;
	}

	for (int i = optind; i < argc; ++i) {
		processFile(argv[i]);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x36d0
movq 0x225d7(%rip), %rax     # 0x25fe0
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jl 0x3a27
leaq 0x1cc1b(%rip), %rdi     # 0x20632
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
jmp 0x3a5e
movq 0x225b2(%rip), %rax     # 0x25fe0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x3a57
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x37b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3a33
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image.h
// Function: stbi__gif_load(stbi__context*, int*, int*, int*, int, stbi__result_info*)
static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
   stbi_uc *u = 0;
   stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
   memset(g, 0, sizeof(*g));
   STBI_NOTUSED(ri);

   u = stbi__gif_load_next(s, g, comp, req_comp);
   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
   if (u) {
      *x = g->w;
      *y = g->h;
      if (req_comp && req_comp != 4)
         u = stbi__convert_format(u, 4, req_comp, g->w, g->h);
   }
   else if (g->out)
      STBI_FREE(g->out);
   STBI_FREE(g);
   return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x4860, %edi           # imm = 0x4860
callq 0x2150
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x4860, %edx           # imm = 0x4860
callq 0x1070
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x158f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x4d00
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4d51
movq -0x40(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x24(%rbp)
je 0x4d4f
cmpl $0x4, -0x24(%rbp)
je 0x4d4f
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %edx
movq -0x40(%rbp), %rax
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movl 0x4(%rax), %r8d
movl $0x4, %esi
callq 0x123d0
movq %rax, -0x38(%rbp)
jmp 0x4d6b
movq -0x40(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4d69
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10f0
jmp 0x4d6b
movq -0x40(%rbp), %rdi
callq 0x10f0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: lunasorcery[P]brailify/./stb/stb_image.h
// Function: stbi__setup_jpeg(stbi__jpeg*)
static void stbi__setup_jpeg(stbi__jpeg *j)
{
   j->idct_block_kernel = stbi__idct_block;
   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;

#ifdef STBI_SSE2
   if (stbi__sse2_available()) {
      j->idct_block_kernel = stbi__idct_simd;
      #ifndef STBI_JPEG_OLD
      j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
      #endif
      j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
   }
#endif

#ifdef STBI_NEON
   j->idct_block_kernel = stbi__idct_simd;
   #ifndef STBI_JPEG_OLD
   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
   #endif
   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x209(%rip), %rcx       # 0x7040
movq %rcx, 0x4768(%rax)
movq -0x8(%rbp), %rax
leaq 0xb57(%rip), %rcx       # 0x79a0
movq %rcx, 0x4770(%rax)
movq -0x8(%rbp), %rax
leaq 0xcc5(%rip), %rcx       # 0x7b20
movq %rcx, 0x4778(%rax)
callq 0x7c50
cmpl $0x0, %eax
je 0x6ea2
movq -0x8(%rbp), %rax
leaq 0xde9(%rip), %rcx       # 0x7c60
movq %rcx, 0x4768(%rax)
movq -0x8(%rbp), %rax
leaq 0x4be7(%rip), %rcx      # 0xba70
movq %rcx, 0x4770(%rax)
movq -0x8(%rbp), %rax
leaq 0x5a75(%rip), %rcx      # 0xc910
movq %rcx, 0x4778(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image.h
// Function: stbi__ldr_to_hdr(unsigned char*, int, int, int)
static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
{
   int i,k,n;
   float *output;
   if (!data) return NULL;
   output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
   // compute number of non-alpha components
   if (comp & 1) n = comp; else n = comp-1;
   for (i=0; i < x*y; ++i) {
      for (k=0; k < n; ++k) {
         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
      }
      if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
   }
   STBI_FREE(data);
   return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17a79
movq $0x0, -0x8(%rbp)
jmp 0x17bc6
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x17500
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x17ac3
movq -0x10(%rbp), %rdi
callq 0x10f0
leaq 0x8d0f(%rip), %rdi      # 0x207b9
callq 0x13d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x17bc6
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x17ad6
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x17adf
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x17bb5
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x17b62
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x84e0(%rip), %xmm1     # 0x20008
divss %xmm1, %xmm0
movss 0xe5bc(%rip), %xmm1     # 0x260f0
callq 0x1f5e0
mulss 0xe5b3(%rip), %xmm0     # 0x260f4
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x17aff
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x17ba5
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x847d(%rip), %xmm1     # 0x20008
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x17ba7
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x17ae6
movq -0x10(%rbp), %rdi
callq 0x10f0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__setup(stbir__info*, int, int, int, int, int)
static void stbir__setup(stbir__info *info, int input_w, int input_h, int output_w, int output_h, int channels)
{
    info->input_w = input_w;
    info->input_h = input_h;
    info->output_w = output_w;
    info->output_h = output_h;
    info->channels = channels;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
popq %rbp
retq
nopl (%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__calculate_transform(stbir__info*, float, float, float, float, float*)
static void stbir__calculate_transform(stbir__info *info, float s0, float t0, float s1, float t1, float *transform)
{
    info->s0 = s0;
    info->t0 = t0;
    info->s1 = s1;
    info->t1 = t1;

    if (transform)
    {
        info->horizontal_scale = transform[0];
        info->vertical_scale   = transform[1];
        info->horizontal_shift = transform[2];
        info->vertical_shift   = transform[3];
    }
    else
    {
        info->horizontal_scale = ((float)info->output_w / info->input_w) / (s1 - s0);
        info->vertical_scale = ((float)info->output_h / info->input_h) / (t1 - t0);

        info->horizontal_shift = s0 * info->output_w / (s1 - s0);
        info->vertical_shift = t0 * info->output_h / (t1 - t0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x2c(%rax)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x30(%rax)
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x34(%rax)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x38(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x199fb
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x44(%rax)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x48(%rax)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x3c(%rax)
movq -0x20(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x40(%rax)
jmp 0x19aa7
movq -0x8(%rbp), %rax
cvtsi2ssl 0x20(%rax), %xmm0
movq -0x8(%rbp), %rax
cvtsi2ssl 0x8(%rax), %xmm1
divss %xmm1, %xmm0
movss -0x14(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x44(%rax)
movq -0x8(%rbp), %rax
cvtsi2ssl 0x24(%rax), %xmm0
movq -0x8(%rbp), %rax
cvtsi2ssl 0xc(%rax), %xmm1
divss %xmm1, %xmm0
movss -0x18(%rbp), %xmm1
subss -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x48(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
cvtsi2ssl 0x20(%rax), %xmm1
mulss %xmm1, %xmm0
movss -0x14(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x3c(%rax)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
cvtsi2ssl 0x24(%rax), %xmm1
mulss %xmm1, %xmm0
movss -0x18(%rbp), %xmm1
subss -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x40(%rax)
popq %rbp
retq
nopl (%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__choose_filter(stbir__info*, stbir_filter, stbir_filter)
static void stbir__choose_filter(stbir__info *info, stbir_filter h_filter, stbir_filter v_filter)
{
    if (h_filter == 0)
        h_filter = stbir__use_upsampling(info->horizontal_scale) ? STBIR_DEFAULT_FILTER_UPSAMPLE : STBIR_DEFAULT_FILTER_DOWNSAMPLE;
    if (v_filter == 0)
        v_filter = stbir__use_upsampling(info->vertical_scale)   ? STBIR_DEFAULT_FILTER_UPSAMPLE : STBIR_DEFAULT_FILTER_DOWNSAMPLE;
    info->horizontal_filter = h_filter;
    info->vertical_filter = v_filter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x19aeb
movq -0x8(%rbp), %rax
movss 0x44(%rax), %xmm0
callq 0x1a4f0
movl %eax, %edx
movl $0x5, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x19b14
movq -0x8(%rbp), %rax
movss 0x48(%rax), %xmm0
callq 0x1a4f0
movl %eax, %edx
movl $0x5, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x5c(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x60(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__get_filter_pixel_width(stbir_filter, float)
static int stbir__get_filter_pixel_width(stbir_filter filter, float scale)
{
    STBIR_ASSERT(filter != 0);
    STBIR_ASSERT(filter < STBIR__ARRAY_SIZE(stbir__filter_info_table));

    if (stbir__use_upsampling(scale))
        return (int)ceil(stbir__filter_info_table[filter].support(1/scale) * 2);
    else
        return (int)ceil(stbir__filter_info_table[filter].support(scale) * 2 / scale);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1a568
jmp 0x1a587
leaq 0x6cbc(%rip), %rdi      # 0x2122b
leaq 0x6bf4(%rip), %rsi      # 0x2116a
movl $0x36b, %edx            # imm = 0x36B
leaq 0x6d18(%rip), %rcx      # 0x2129a
callq 0x1090
movl -0x8(%rbp), %eax
cmpq $0x6, %rax
jae 0x1a592
jmp 0x1a5b1
leaq 0x6cad(%rip), %rdi      # 0x21246
leaq 0x6bca(%rip), %rsi      # 0x2116a
movl $0x36c, %edx            # imm = 0x36C
leaq 0x6cee(%rip), %rcx      # 0x2129a
callq 0x1090
movss -0xc(%rbp), %xmm0
callq 0x1a4f0
cmpl $0x0, %eax
je 0x1a600
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0xbee4(%rip), %rax      # 0x264b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movss 0x5a25(%rip), %xmm0     # 0x20004
divss -0xc(%rbp), %xmm0
callq *%rax
movss 0x5a36(%rip), %xmm1     # 0x20024
mulss %xmm1, %xmm0
callq 0x1f610
cvttss2si %xmm0, %eax
movl %eax, -0x4(%rbp)
jmp 0x1a63b
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0xbea4(%rip), %rax      # 0x264b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movss -0xc(%rbp), %xmm0
callq *%rax
movss 0x59fe(%rip), %xmm1     # 0x20024
mulss %xmm1, %xmm0
divss -0xc(%rbp), %xmm0
callq 0x1f610
cvttss2si %xmm0, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__filter_trapezoid(float, float)
static float stbir__filter_trapezoid(float x, float scale)
{
    float halfscale = scale / 2;
    float t = 0.5f + halfscale;
    STBIR_ASSERT(scale <= 1);

    x = (float)fabs(x);

    if (x >= t)
        return 0;
    else
    {
        float r = 0.5f - halfscale;
        if (x <= r)
            return 1;
        else
            return (t - x) / scale;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
movss 0x58a5(%rip), %xmm1     # 0x20024
divss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss 0x5880(%rip), %xmm0     # 0x20010
addss -0x10(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movss 0x5862(%rip), %xmm0     # 0x20004
ucomiss -0xc(%rbp), %xmm0
jb 0x1a7aa
jmp 0x1a7c9
leaq 0x6b20(%rip), %rdi      # 0x212d1
leaq 0x69b2(%rip), %rsi      # 0x2116a
movl $0x2f1, %edx            # imm = 0x2F1
leaq 0x6b18(%rip), %rcx      # 0x212dc
callq 0x1090
movss -0x8(%rbp), %xmm0
callq 0x1f630
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
ucomiss -0x14(%rbp), %xmm0
jb 0x1a7ed
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1a831
movss 0x581b(%rip), %xmm0     # 0x20010
subss -0x10(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x8(%rbp), %xmm1
movss -0x18(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x1a81d
movss 0x57ee(%rip), %xmm0     # 0x20004
movss %xmm0, -0x4(%rbp)
jmp 0x1a831
movss -0x14(%rbp), %xmm0
subss -0x8(%rbp), %xmm0
divss -0xc(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__filter_triangle(float, float)
static float stbir__filter_triangle(float x, float s)
{
    STBIR__UNUSED_PARAM(s);

    x = (float)fabs(x);

    if (x <= 1.0f)
        return 1 - x;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
callq 0x1f630
movss %xmm0, -0x8(%rbp)
movss 0x573b(%rip), %xmm0     # 0x20004
ucomiss -0x8(%rbp), %xmm0
jb 0x1a8e3
movss 0x572d(%rip), %xmm0     # 0x20004
subss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1a8eb
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__filter_cubic(float, float)
static float stbir__filter_cubic(float x, float s)
{
    STBIR__UNUSED_PARAM(s);

    x = (float)fabs(x);

    if (x < 1.0f)
        return (4 + x*x*(3*x - 6))/6;
    else if (x < 2.0f)
        return (8 + x*(-12 + x*(6 - x)))/6;

    return (0.0f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
callq 0x1f630
movss %xmm0, -0x8(%rbp)
movss 0x56bb(%rip), %xmm0     # 0x20004
ucomiss -0x8(%rbp), %xmm0
jbe 0x1a999
movss -0x8(%rbp), %xmm0
mulss -0x8(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss 0x56ba(%rip), %xmm2     # 0x20020
mulss %xmm2, %xmm1
movss 0x56c6(%rip), %xmm2     # 0x20038
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
movss 0x56b2(%rip), %xmm1     # 0x20034
addss %xmm1, %xmm0
movss 0x569a(%rip), %xmm1     # 0x20028
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1a9fb
movss 0x5683(%rip), %xmm0     # 0x20024
ucomiss -0x8(%rbp), %xmm0
jbe 0x1a9f1
movss -0x8(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss 0x566f(%rip), %xmm2     # 0x20028
subss -0x8(%rbp), %xmm2
mulss %xmm2, %xmm1
movss 0x5666(%rip), %xmm2     # 0x20030
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
movss 0x5652(%rip), %xmm1     # 0x2002c
addss %xmm1, %xmm0
movss 0x5642(%rip), %xmm1     # 0x20028
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1a9fb
jmp 0x1a9f3
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__filter_catmullrom(float, float)
static float stbir__filter_catmullrom(float x, float s)
{
    STBIR__UNUSED_PARAM(s);

    x = (float)fabs(x);

    if (x < 1.0f)
        return 1 - x*x*(2.5f - 1.5f*x);
    else if (x < 2.0f)
        return 2 - x*(4 + x*(0.5f*x - 2.5f));

    return (0.0f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
callq 0x1f630
movss %xmm0, -0x8(%rbp)
movss 0x55ab(%rip), %xmm0     # 0x20004
ucomiss -0x8(%rbp), %xmm0
jbe 0x1aaaa
movss -0x8(%rbp), %xmm0
mulss -0x8(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss 0x55ca(%rip), %xmm2     # 0x20040
mulss %xmm2, %xmm1
movss 0x55c2(%rip), %xmm2     # 0x20044
addss %xmm2, %xmm1
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm1, %xmm0
movss 0x5565(%rip), %xmm1     # 0x20004
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1ab1d
movss 0x5572(%rip), %xmm0     # 0x20024
ucomiss -0x8(%rbp), %xmm0
jbe 0x1ab13
movss -0x8(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss -0x8(%rbp), %xmm2
movss 0x5541(%rip), %xmm3     # 0x20010
mulss %xmm3, %xmm2
movss 0x5561(%rip), %xmm3     # 0x2003c
addss %xmm3, %xmm2
mulss %xmm2, %xmm1
movss 0x5549(%rip), %xmm2     # 0x20034
addss %xmm2, %xmm1
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm1, %xmm0
movss 0x551c(%rip), %xmm1     # 0x20024
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1ab1d
jmp 0x1ab15
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__filter_mitchell(float, float)
static float stbir__filter_mitchell(float x, float s)
{
    STBIR__UNUSED_PARAM(s);

    x = (float)fabs(x);

    if (x < 1.0f)
        return (16 + x*x*(21 * x - 36))/18;
    else if (x < 2.0f)
        return (32 + x*(-60 + x*(36 - 7*x)))/18;

    return (0.0f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
callq 0x1f630
movss %xmm0, -0x8(%rbp)
movss 0x54ab(%rip), %xmm0     # 0x20004
ucomiss -0x8(%rbp), %xmm0
jbe 0x1aba9
movss -0x8(%rbp), %xmm0
mulss -0x8(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss 0x54ea(%rip), %xmm2     # 0x20060
mulss %xmm2, %xmm1
movss 0x54e2(%rip), %xmm2     # 0x20064
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
movss 0x54ca(%rip), %xmm1     # 0x2005c
addss %xmm1, %xmm0
movss 0x54aa(%rip), %xmm1     # 0x20048
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1ac1b
movss 0x5473(%rip), %xmm0     # 0x20024
ucomiss -0x8(%rbp), %xmm0
jbe 0x1ac11
movss -0x8(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss -0x8(%rbp), %xmm2
movss 0x5486(%rip), %xmm3     # 0x20054
mulss %xmm3, %xmm2
movss 0x547e(%rip), %xmm3     # 0x20058
addss %xmm3, %xmm2
mulss %xmm2, %xmm1
movss 0x5466(%rip), %xmm2     # 0x20050
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
movss 0x5452(%rip), %xmm1     # 0x2004c
addss %xmm1, %xmm0
movss 0x5442(%rip), %xmm1     # 0x20048
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1ac1b
jmp 0x1ac13
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__calculate_sample_range_upsample(int, float, float, float, int*, int*, float*)
static void stbir__calculate_sample_range_upsample(int n, float out_filter_radius, float scale_ratio, float out_shift, int* in_first_pixel, int* in_last_pixel, float* in_center_of_out)
{
    float out_pixel_center = (float)n + 0.5f;
    float out_pixel_influence_lowerbound = out_pixel_center - out_filter_radius;
    float out_pixel_influence_upperbound = out_pixel_center + out_filter_radius;

    float in_pixel_influence_lowerbound = (out_pixel_influence_lowerbound + out_shift) / scale_ratio;
    float in_pixel_influence_upperbound = (out_pixel_influence_upperbound + out_shift) / scale_ratio;

    *in_center_of_out = (out_pixel_center + out_shift) / scale_ratio;
    *in_first_pixel = (int)(floor(in_pixel_influence_lowerbound + 0.5));
    *in_last_pixel = (int)(floor(in_pixel_influence_upperbound - 0.5));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss %xmm2, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cvtsi2ssl -0x4(%rbp), %xmm0
movss 0x4c7d(%rip), %xmm1     # 0x20010
addss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
subss -0x8(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x2c(%rbp), %xmm0
addss -0x8(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x30(%rbp), %xmm0
addss -0x10(%rbp), %xmm0
divss -0xc(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x34(%rbp), %xmm0
addss -0x10(%rbp), %xmm0
divss -0xc(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x2c(%rbp), %xmm0
addss -0x10(%rbp), %xmm0
divss -0xc(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movss -0x38(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x4ca6(%rip), %xmm1     # 0x200b0
addsd %xmm1, %xmm0
callq 0x11b0
cvttsd2si %xmm0, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movss -0x3c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x4c82(%rip), %xmm1     # 0x200b0
subsd %xmm1, %xmm0
callq 0x11b0
cvttsd2si %xmm0, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__calculate_sample_range_downsample(int, float, float, float, int*, int*, float*)
static void stbir__calculate_sample_range_downsample(int n, float in_pixels_radius, float scale_ratio, float out_shift, int* out_first_pixel, int* out_last_pixel, float* out_center_of_in)
{
    float in_pixel_center = (float)n + 0.5f;
    float in_pixel_influence_lowerbound = in_pixel_center - in_pixels_radius;
    float in_pixel_influence_upperbound = in_pixel_center + in_pixels_radius;

    float out_pixel_influence_lowerbound = in_pixel_influence_lowerbound * scale_ratio - out_shift;
    float out_pixel_influence_upperbound = in_pixel_influence_upperbound * scale_ratio - out_shift;

    *out_center_of_in = in_pixel_center * scale_ratio - out_shift;
    *out_first_pixel = (int)(floor(out_pixel_influence_lowerbound + 0.5));
    *out_last_pixel = (int)(floor(out_pixel_influence_upperbound - 0.5));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss %xmm2, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cvtsi2ssl -0x4(%rbp), %xmm0
movss 0x47fd(%rip), %xmm1     # 0x20010
addss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
subss -0x8(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x2c(%rbp), %xmm0
addss -0x8(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x30(%rbp), %xmm0
movss -0xc(%rbp), %xmm2
movss -0x10(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x34(%rbp), %xmm0
movss -0xc(%rbp), %xmm2
movss -0x10(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x2c(%rbp), %xmm0
movss -0xc(%rbp), %xmm2
movss -0x10(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movss -0x38(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x47e7(%rip), %xmm1     # 0x200b0
addsd %xmm1, %xmm0
callq 0x11b0
cvttsd2si %xmm0, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movss -0x3c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x47c3(%rip), %xmm1     # 0x200b0
subsd %xmm1, %xmm0
callq 0x11b0
cvttsd2si %xmm0, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__decode_and_resample_upsample(stbir__info*, int)
static void stbir__decode_and_resample_upsample(stbir__info* stbir_info, int n)
{
    // Decode the nth scanline from the source image into the decode buffer.
    stbir__decode_scanline(stbir_info, n);

    // Now resample it into the ring buffer.
    if (stbir__use_width_upsampling(stbir_info))
        stbir__resample_horizontal_upsample(stbir_info, n, stbir__add_empty_ring_buffer_entry(stbir_info, n));
    else
        stbir__resample_horizontal_downsample(stbir_info, n, stbir__add_empty_ring_buffer_entry(stbir_info, n));

    // Now it's sitting in the ring buffer ready to be used as source for the vertical sampling.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c7d0
movq -0x8(%rbp), %rdi
callq 0x1d080
cmpl $0x0, %eax
je 0x1bf34
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1d7b0
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movq %rax, %rdx
callq 0x1d0a0
jmp 0x1bf5d
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1d7b0
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq %rax, %rdx
callq 0x1d8b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__add_empty_ring_buffer_entry(stbir__info*, int)
static float* stbir__add_empty_ring_buffer_entry(stbir__info* stbir_info, int n)
{
    int ring_buffer_index;
    float* ring_buffer;

    if (stbir_info->ring_buffer_begin_index < 0)
    {
        ring_buffer_index = stbir_info->ring_buffer_begin_index = 0;
        stbir_info->ring_buffer_first_scanline = n;
    }
    else
    {
        ring_buffer_index = (stbir_info->ring_buffer_begin_index + (stbir_info->ring_buffer_last_scanline - stbir_info->ring_buffer_first_scanline) + 1) % stbir_info->vertical_filter_pixel_width;
        STBIR_ASSERT(ring_buffer_index != stbir_info->ring_buffer_begin_index);
    }

    ring_buffer = stbir__get_ring_buffer_entry(stbir_info->ring_buffer, ring_buffer_index, stbir_info->ring_buffer_length_bytes / sizeof(float));
    memset(ring_buffer, 0, stbir_info->ring_buffer_length_bytes);

    stbir_info->ring_buffer_last_scanline = n;

    return ring_buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xd4(%rax)
jge 0x1d7f0
movq -0x8(%rbp), %rax
movl $0x0, 0xd4(%rax)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xcc(%rax)
jmp 0x1d853
movq -0x8(%rbp), %rax
movl 0xd4(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0xd0(%rcx), %ecx
movq -0x8(%rbp), %rdx
subl 0xcc(%rdx), %ecx
addl %ecx, %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0xb4(%rcx)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xd4(%rcx), %eax
je 0x1d832
jmp 0x1d851
leaq 0x4344(%rip), %rdi      # 0x21b7d
leaq 0x392a(%rip), %rsi      # 0x2116a
movl $0x58c, %edx            # imm = 0x58C
leaq 0x436a(%rip), %rcx      # 0x21bb6
callq 0x1090
jmp 0x1d853
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rdi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movslq 0xc8(%rax), %rax
shrq $0x2, %rax
movl %eax, %edx
callq 0x1e3b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0xc8(%rax), %rdx
xorl %esi, %esi
callq 0x1070
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xd0(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__edge_wrap_slow(stbir_edge, int, int)
static int stbir__edge_wrap_slow(stbir_edge edge, int n, int max)
{
    switch (edge)
    {
    case STBIR_EDGE_ZERO:
        return 0; // we'll decode the wrong pixel here, and then overwrite with 0s later

    case STBIR_EDGE_CLAMP:
        if (n < 0)
            return 0;

        if (n >= max)
            return max - 1;

        return n; // NOTREACHED

    case STBIR_EDGE_REFLECT:
    {
        if (n < 0)
        {
            if (n < max)
                return -n;
            else
                return max - 1;
        }

        if (n >= max)
        {
            int max2 = max * 2;
            if (n >= max2)
                return 0;
            else
                return max2 - n - 1;
        }

        return n; // NOTREACHED
    }

    case STBIR_EDGE_WRAP:
        if (n >= 0)
            return (n % max);
        else
        {
            int m = (-n) % max;

            if (m != 0)
                m = max - m;

            return (m);
        }
        return n;  // NOTREACHED

    default:
        STBIR_ASSERT(!"Unimplemented edge type");
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x1e37d
movq -0x20(%rbp), %rax
leaq 0x2028(%rip), %rcx      # 0x202c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x1e39c
cmpl $0x0, -0xc(%rbp)
jge 0x1e2c7
movl $0x0, -0x4(%rbp)
jmp 0x1e39c
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x1e2dd
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1e39c
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1e39c
cmpl $0x0, -0xc(%rbp)
jge 0x1e311
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1e303
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1e39c
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1e39c
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x1e340
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x1e332
movl $0x0, -0x4(%rbp)
jmp 0x1e39c
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1e39c
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1e39c
cmpl $0x0, -0xc(%rbp)
jl 0x1e35a
movl -0xc(%rbp), %eax
cltd
idivl -0x10(%rbp)
movl %edx, -0x4(%rbp)
jmp 0x1e39c
xorl %eax, %eax
subl -0xc(%rbp), %eax
cltd
idivl -0x10(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x1e375
movl -0x10(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1e39c
leaq 0x365e(%rip), %rdi      # 0x219e2
leaq 0x2ddf(%rip), %rsi      # 0x2116a
movl $0x3d9, %edx            # imm = 0x3D9
leaq 0x3666(%rip), %rcx      # 0x219fd
callq 0x1090
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__saturate(float)
static stbir__inline float stbir__saturate(float x)
{
    if (x < 0)
        return 0;

    if (x > 1)
        return 1;

    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0x1ec4c
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1ec77
movss -0x8(%rbp), %xmm0
movss 0x13ab(%rip), %xmm1     # 0x20004
ucomiss %xmm1, %xmm0
jbe 0x1ec6d
movss 0x139e(%rip), %xmm0     # 0x20004
movss %xmm0, -0x4(%rbp)
jmp 0x1ec77
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nop
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__linear_to_srgb_uchar(float)
static stbir_uint8 stbir__linear_to_srgb_uchar(float in)
{
    static const stbir__FP32 almostone = { 0x3f7fffff }; // 1-eps
    static const stbir__FP32 minval = { (127-13) << 23 };
    stbir_uint32 tab,bias,scale,t;
    stbir__FP32 f;
 
    // Clamp to [2^(-13), 1-eps]; these two values map to 0 and 1, respectively.
    // The tests are carefully written so that NaNs map to 0, same as in the reference
    // implementation.
    if (!(in > minval.f)) // written this way to catch NaNs
        in = minval.f;
    if (in > almostone.f)
        in = almostone.f;
 
    // Do the table lookup and unpack bias, scale
    f.f = in;
    tab = fp32_to_srgb8_tab4[(f.u - minval.u) >> 20];
    bias = (tab >> 16) << 9;
    scale = tab & 0xffff;
 
    // Grab next-highest mantissa bits and perform linear interpolation
    t = (f.u >> 12) & 0xff;
    return (unsigned char) ((bias + scale*t) >> 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
ucomiss 0x177b(%rip), %xmm0     # 0x20410
ja 0x1eca4
movss 0x1771(%rip), %xmm0     # 0x20410
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
ucomiss 0x175c(%rip), %xmm0     # 0x2040c
jbe 0x1ecbf
movss 0x1752(%rip), %xmm0     # 0x2040c
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movl -0x18(%rbp), %eax
subl $0x39000000, %eax       # imm = 0x39000000
shrl $0x14, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x1741(%rip), %rax      # 0x20420
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x10, %eax
shll $0x9, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
shrl $0xc, %eax
andl $0xff, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl %ecx, %eax
shrl $0x10, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: lunasorcery[P]brailify/./stb/stb_image_resize.h
// Function: stbir__decode_and_resample_downsample(stbir__info*, int)
static void stbir__decode_and_resample_downsample(stbir__info* stbir_info, int n)
{
    // Decode the nth scanline from the source image into the decode buffer.
    stbir__decode_scanline(stbir_info, n);

    memset(stbir_info->horizontal_buffer, 0, stbir_info->output_w * stbir_info->channels * sizeof(float));

    // Now resample it into the horizontal buffer.
    if (stbir__use_width_upsampling(stbir_info))
        stbir__resample_horizontal_upsample(stbir_info, n, stbir_info->horizontal_buffer);
    else
        stbir__resample_horizontal_downsample(stbir_info, n, stbir_info->horizontal_buffer);

    // Now it's sitting in the horizontal buffer ready to be distributed into the ring buffers.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c7d0
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x4c(%rcx), %eax
movslq %eax, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1070
movq -0x8(%rbp), %rdi
callq 0x1d080
cmpl $0x0, %eax
je 0x1efaa
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdx
callq 0x1d0a0
jmp 0x1efc1
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdx
callq 0x1d8b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lukewagner[P]asmjs2wasm/src/list.h
// Function: List<asmjs_ast::Node>::compute_length() const
uint32_t compute_length() const
  {
    uint32_t len = 0;
    for (T* p = first_; p; p = p->next)
      len++;
    return len;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0xc(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3f77
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3f5a
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: lukewagner[P]asmjs2wasm/src/cashew/parser.h
// Function: cashew::Parser<asmjs_ast::Node*, Builder>::parseBlock(char*&, asmjs_ast::Node*, char const*, cashew::IString, cashew::IString)
NodeRef parseBlock(char*& src, NodeRef block=nullptr, const char* seps=";", IString keywordSep1=IString(), IString keywordSep2=IString()) {
    //dump("parseBlock", src);
    if (!block) block = builder.makeBlock();
    while (*src) {
      src = skipSpace(src);
      if (*src == 0) break;
      if (*src == ';') {
        src++; // skip a statement in this block
        continue;
      }
      if (hasChar(seps, *src)) break;
      if (!!keywordSep1) {
        Frag next(src);
        if (next.type == KEYWORD && next.str == keywordSep1) break;
      }
      if (!!keywordSep2) {
        Frag next(src);
        if (next.type == KEYWORD && next.str == keywordSep2) break;
      }
      NodeRef element = parseElementOrStatement(src, seps);
      builder.appendToBlock(block, element);
    }
    return block;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %r8, -0x8(%rbp)
movq %r9, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5b80
movq -0x60(%rbp), %rdi
addq $0x28, %rdi
callq 0x5cf0
movq %rax, -0x28(%rbp)
jmp 0x5b82
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x5c9c
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5bbc
jmp 0x5c9c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x5bdb
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5b82
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %esi
callq 0x5e70
testb $0x1, %al
jne 0x5bf4
jmp 0x5bf9
jmp 0x5c9c
leaq -0x8(%rbp), %rdi
callq 0x5ec0
testb $0x1, %al
jne 0x5c33
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x5f00
cmpl $0x0, -0x34(%rbp)
jne 0x5c31
leaq -0x40(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x6680
testb $0x1, %al
jne 0x5c2f
jmp 0x5c31
jmp 0x5c9c
jmp 0x5c33
leaq -0x10(%rbp), %rdi
callq 0x5ec0
testb $0x1, %al
jne 0x5c6d
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x5f00
cmpl $0x0, -0x44(%rbp)
jne 0x5c6b
leaq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x6680
testb $0x1, %al
jne 0x5c69
jmp 0x5c6b
jmp 0x5c9c
jmp 0x5c6d
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x66b0
movq -0x60(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x6790
jmp 0x5b82
movq -0x28(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)