LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: xgp_char_data
void
xgp_char_data(XGP *xgp, uint8 data)
{
	if(xgp->cnt > 8) {
		xgp_output(xgp, data, 8);
		xgp->cnt -= 8;
	} else {
		xgp_output(xgp, data, xgp->cnt);
		xgp->mode = xgp_char;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x40(%rax), %eax
cmpl $0x8, %eax
jle 0x3b92
movq -0x8(%rbp), %rdi
movl $0x8, %edx
movzbl -0x9(%rbp), %esi
callq 0x3940
movq -0x8(%rbp), %rax
movzwl 0x40(%rax), %ecx
subl $0x8, %ecx
movw %cx, 0x40(%rax)
jmp 0x3bb8
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rcx
movzwl 0x40(%rcx), %edx
movzbl %al, %esi
callq 0x3940
movq -0x8(%rbp), %rax
leaq -0x474(%rip), %rcx      # 0x3740
movq %rcx, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: reset_xgp
void
reset_xgp(void *dev)
{
	XGP *xgp = dev;

	xgp->xcr = 0;
	xgp->mar = 0;
	xgp->xsr = 0;
	xgp->go = xgp_idle;
	xgp->mode = xgp_char;
	initclock(&xgp->clk, SYNC_PERIOD);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movw $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x2a(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x2c(%rax)
movq -0x10(%rbp), %rax
leaq -0x76d(%rip), %rcx      # 0x3490
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
leaq -0x4cc(%rip), %rcx      # 0x3740
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
movl $0x764170, %esi         # imm = 0x764170
callq 0x8da0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: xgp_read
void
xgp_read(XGP *xgp, Bus *bus)
{
	bus->addr = xgp->mar;
	xgp->mar += 2;
	if(dati_bus(bus)) goto be;
	xgp_byte(xgp, bus->data & 0xFF);
	xgp_byte(xgp, bus->data >> 8);
	return;	

be:
	xgp_done(xgp, FNXM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2a(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movzwl 0x2a(%rax), %ecx
addl $0x2, %ecx
movw %cx, 0x2a(%rax)
movq -0x10(%rbp), %rdi
callq 0x2480
cmpl $0x0, %eax
je 0x3cce
jmp 0x3d00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0xc(%rax), %eax
andl $0xff, %eax
movzbl %al, %esi
callq 0x3c50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0xc(%rax), %eax
sarl $0x8, %eax
movzbl %al, %esi
callq 0x3c50
jmp 0x3d0e
movq -0x8(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x38d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: svc_xgp
int
svc_xgp(Bus *bus, void *dev)
{
	XGP *xgp = dev;
	if(handleclock(&xgp->clk))
		xgp_sync(xgp);
	if(xgp->xcr & FGO)
		xgp->go(xgp, bus);
	if((xgp->xcr & (FDONE|FDIE)) == (FDONE|FDIE))
		return 5;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8df0
cmpl $0x0, %eax
je 0x3f3f
movq -0x20(%rbp), %rdi
callq 0x3d50
movq -0x20(%rbp), %rax
movzwl 0x28(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3f61
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x20(%rbp), %rax
movzwl 0x28(%rax), %eax
andl $0xc0, %eax
cmpl $0xc0, %eax
jne 0x3f7e
movl $0x5, -0x4(%rbp)
jmp 0x3f85
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/xgp.c
// Function: bg_xgp
int
bg_xgp(void *dev)
{
	XGP *xgp = dev;
	if((xgp->xcr & (FDONE|FDIE)) == (FDONE|FDIE))
		return XGP_VEC;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x28(%rax), %eax
andl $0xc0, %eax
cmpl $0xc0, %eax
jne 0x3fbd
movl $0xf8, -0x4(%rbp)
jmp 0x3fc4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/print.c
// Function: print_line
void print_line()
{
	if(lines >= PAPER_MAX)
		return;

	lines++;

	// Clear the line
	position = PAGE_WIDTH;
	do {
		--position;
		print_dot(0);
		--position;
	} while(position > 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0xabe0, 0x2e072(%rip)  # imm = 0xABE0
jl 0x94b2
jmp 0x94f9
movl 0x2e068(%rip), %eax     # 0x37520
addl $0x1, %eax
movl %eax, 0x2e05f(%rip)     # 0x37520
movl $0x6c0, 0x2e059(%rip)   # imm = 0x6C0
movl 0x2e053(%rip), %eax     # 0x37524
addl $-0x1, %eax
movl %eax, 0x2e04a(%rip)     # 0x37524
xorl %edi, %edi
callq 0x9500
movl 0x2e03d(%rip), %eax     # 0x37524
addl $-0x1, %eax
movl %eax, 0x2e034(%rip)     # 0x37524
cmpl $0x0, 0x2e02d(%rip)     # 0x37524
jg 0x94cb
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/print.c
// Function: print_dot
void print_dot(int bw)
{
	if(lines >= PAPER_MAX)
		return;
	if(position >= PAGE_WIDTH)
		return;

	paper[(lines-1) * PAGE_WIDTH + position] = bw ? 0x00 : 0xFF;
	position++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0xabe0, 0x2e00f(%rip)  # imm = 0xABE0
jl 0x9515
jmp 0x9566
cmpl $0x6c0, 0x2e005(%rip)   # imm = 0x6C0
jl 0x9523
jmp 0x9566
movl -0x4(%rbp), %edx
movl $0xff, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %dl
movl 0x2dfe5(%rip), %eax     # 0x37520
subl $0x1, %eax
imull $0x6c0, %eax, %eax      # imm = 0x6C0
addl 0x2dfda(%rip), %eax     # 0x37524
movslq %eax, %rcx
leaq 0x2dfdc(%rip), %rax     # 0x37530
movb %dl, (%rax,%rcx)
movl 0x2dfc7(%rip), %eax     # 0x37524
addl $0x1, %eax
movl %eax, 0x2dfbe(%rip)     # 0x37524
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/print.c
// Function: print_finish
int print_finish(int offset, char *file, size_t n)
{
	char time[100];
	int error;

	if(lines <= offset + 2) {
		*file = 0;
		return 0;
	}
	lines -= offset;

	timestamp(time, sizeof time);
	snprintf(file, n, "xgp-%s.png", time);
	if(fork()) {
		error = lines;
	} else {
		make_page();
		error = lodepng_encode32_file(file, page, PAGE_WIDTH, lines);
		exit(error == 0 ? 0 : 1);
	}

	memmove(paper, paper + PAGE_WIDTH*lines, PAGE_WIDTH*offset);
	lines = offset;

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl 0x2df94(%rip), %eax     # 0x37520
movl -0x8(%rbp), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jg 0x95a9
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x9676
movl -0x8(%rbp), %ecx
movl 0x2df6e(%rip), %eax     # 0x37520
subl %ecx, %eax
movl %eax, 0x2df66(%rip)     # 0x37520
leaq -0x80(%rbp), %rdi
movl $0x64, %esi
callq 0x8f60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x80(%rbp), %rcx
leaq 0x1730d(%rip), %rdx     # 0x208e8
movb $0x0, %al
callq 0x20d0
callq 0x22f0
cmpl $0x0, %eax
je 0x95fa
movl 0x2df2e(%rip), %eax     # 0x37520
movl %eax, -0x84(%rbp)
jmp 0x9638
callq 0x9690
movq -0x10(%rbp), %rdi
movl 0x2df17(%rip), %ecx     # 0x37520
leaq 0x48b0720(%rip), %rsi   # 0x48b9d30
movl $0x6c0, %edx            # imm = 0x6C0
callq 0x15f80
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %ecx
movl $0x1, %edi
xorl %eax, %eax
cmpl $0x0, %ecx
cmovel %eax, %edi
callq 0x22a0
imull $0x6c0, 0x2dede(%rip), %eax # imm = 0x6C0
cltq
leaq 0x2dee5(%rip), %rsi     # 0x37530
addq %rax, %rsi
imull $0x6c0, -0x8(%rbp), %eax # imm = 0x6C0
movslq %eax, %rdx
leaq 0x2ded1(%rip), %rdi     # 0x37530
callq 0x2220
movl -0x8(%rbp), %eax
movl %eax, 0x2deb3(%rip)     # 0x37520
movl -0x84(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/print.c
// Function: make_page
static void make_page(void)
{
	int n = lines;
	if(n > PAGE_MAX)
		n = PAGE_MAX;
	meatball(PAGE_WIDTH, n, paper, image, page);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x2de82(%rip), %eax     # 0x37520
movl %eax, -0x4(%rbp)
cmpl $0x19c8, -0x4(%rbp)     # imm = 0x19C8
jle 0x96b1
movl $0x19c8, -0x4(%rbp)     # imm = 0x19C8
movl -0x4(%rbp), %esi
movl $0x6c0, %edi            # imm = 0x6C0
leaq 0x2de70(%rip), %rdx     # 0x37530
leaq 0x7431e69(%rip), %rcx   # 0x743b530
leaq 0x48b0662(%rip), %r8    # 0x48b9d30
callq 0x1eee0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: lodepng_inflatev
static unsigned lodepng_inflatev(ucvector* out,
                                 const unsigned char* in, size_t insize,
                                 const LodePNGDecompressSettings* settings) {
  unsigned BFINAL = 0;
  LodePNGBitReader reader;
  unsigned error = LodePNGBitReader_init(&reader, in, insize);

  if(error) return error;

  while(!BFINAL) {
    unsigned BTYPE;
    if(reader.bitsize - reader.bp < 3) return 52; /*error, bit pointer will jump past memory*/
    ensureBits9(&reader, 3);
    BFINAL = readBits(&reader, 1);
    BTYPE = readBits(&reader, 2);

    if(BTYPE == 3) return 20; /*error: invalid BTYPE*/
    else if(BTYPE == 0) error = inflateNoCompression(out, &reader, settings); /*no compression*/
    else error = inflateHuffmanBlock(out, &reader, BTYPE, settings->max_output_size); /*compression, BTYPE 01 or 10*/
    if(!error && settings->max_output_size && out->size > settings->max_output_size) error = 109;
    if(error) break;
  }

  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x16690
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0xa3f4
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa4d7
jmp 0xa3f6
cmpl $0x0, -0x2c(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xa408
jmp 0xa4d1
movq -0x48(%rbp), %rax
subq -0x40(%rbp), %rax
cmpq $0x3, %rax
jae 0xa422
movl $0x34, -0x4(%rbp)
jmp 0xa4d7
leaq -0x58(%rbp), %rdi
movl $0x3, %esi
callq 0x16730
leaq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0x16800
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
movl $0x2, %esi
callq 0x16800
movl %eax, -0x60(%rbp)
cmpl $0x3, -0x60(%rbp)
jne 0xa461
movl $0x14, -0x4(%rbp)
jmp 0xa4d7
cmpl $0x0, -0x60(%rbp)
jne 0xa47d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x58(%rbp), %rsi
callq 0x16840
movl %eax, -0x5c(%rbp)
jmp 0xa498
movq -0x10(%rbp), %rdi
movl -0x60(%rbp), %edx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
leaq -0x58(%rbp), %rsi
callq 0x169c0
movl %eax, -0x5c(%rbp)
jmp 0xa49a
cmpl $0x0, -0x5c(%rbp)
jne 0xa4c4
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa4c4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0xa4c4
movl $0x6d, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0xa4cc
jmp 0xa4d1
jmp 0xa3f6
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: deflate
static unsigned deflate(unsigned char** out, size_t* outsize,
                        const unsigned char* in, size_t insize,
                        const LodePNGCompressSettings* settings) {
  if(settings->custom_deflate) {
    unsigned error = settings->custom_deflate(out, outsize, in, insize, settings);
    /*the custom deflate is allowed to have its own error codes, however, we translate it to code 111*/
    return error ? 111 : 0;
  } else {
    return lodepng_deflate(out, outsize, in, insize, settings);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xab4d
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edx
xorl %eax, %eax
movl $0x6f, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xab69
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xa4e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: lodepng_decompress_settings_init
void lodepng_decompress_settings_init(LodePNGDecompressSettings* settings) {
  settings->ignore_adler32 = 0;
  settings->ignore_nlen = 0;
  settings->max_output_size = 0;

  settings->custom_zlib = 0;
  settings->custom_inflate = 0;
  settings->custom_context = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: lodepng_crc32
unsigned lodepng_crc32(const unsigned char* data, size_t length) {
  /*Using the Slicing by Eight algorithm*/
  unsigned r = 0xffffffffu;
  while(length >= 8) {
    r = lodepng_crc32_table7[(data[0] ^ (r & 0xffu))] ^
        lodepng_crc32_table6[(data[1] ^ ((r >> 8) & 0xffu))] ^
        lodepng_crc32_table5[(data[2] ^ ((r >> 16) & 0xffu))] ^
        lodepng_crc32_table4[(data[3] ^ ((r >> 24) & 0xffu))] ^
        lodepng_crc32_table3[data[4]] ^
        lodepng_crc32_table2[data[5]] ^
        lodepng_crc32_table1[data[6]] ^
        lodepng_crc32_table0[data[7]];
    data += 8;
    length -= 8;
  }
  while(length--) {
    r = lodepng_crc32_table0[(r ^ *data++) & 0xffu] ^ (r >> 8);
  }
  return r ^ 0xffffffffu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
cmpq $0x8, -0x10(%rbp)
jb 0xadea
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl -0x14(%rbp), %ecx
andl $0xff, %ecx
xorl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x15e45(%rip), %rax     # 0x20b50
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movl -0x14(%rbp), %edx
shrl $0x8, %edx
andl $0xff, %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x16221(%rip), %rcx     # 0x20f50
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
movl -0x14(%rbp), %edx
shrl $0x10, %edx
andl $0xff, %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x165fd(%rip), %rcx     # 0x21350
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
movl -0x14(%rbp), %edx
shrl $0x18, %edx
andl $0xff, %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x169d9(%rip), %rcx     # 0x21750
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
movl %ecx, %edx
leaq 0x16dc5(%rip), %rcx     # 0x21b50
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
movl %ecx, %edx
leaq 0x171b1(%rip), %rcx     # 0x21f50
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
movl %ecx, %edx
leaq 0x1759d(%rip), %rcx     # 0x22350
xorl (%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
movl %ecx, %edx
leaq 0x17989(%rip), %rcx     # 0x22750
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xace3
jmp 0xadec
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0xae38
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movzbl (%rcx), %ecx
xorl %ecx, %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x17928(%rip), %rax     # 0x22750
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0xadec
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: lodepng_chunk_next
unsigned char* lodepng_chunk_next(unsigned char* chunk, unsigned char* end) {
  size_t available_size = (size_t)(end - chunk);
  if(chunk >= end || available_size < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    if(total_chunk_length > available_size) return end; /*outside of range*/
    return chunk + total_chunk_length;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xb160
cmpq $0xc, -0x20(%rbp)
jae 0xb16d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb22e
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x89, %eax
jne 0xb1e4
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x50, %eax
jne 0xb1e4
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x4e, %eax
jne 0xb1e4
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x47, %eax
jne 0xb1e4
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0xd, %eax
jne 0xb1e4
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
cmpl $0xa, %eax
jne 0xb1e4
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1a, %eax
jne 0xb1e4
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
cmpl $0xa, %eax
jne 0xb1e4
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xb22e
movq -0x10(%rbp), %rdi
callq 0xae40
movl %eax, %eax
movl %eax, %edi
movl $0xc, %esi
leaq -0x28(%rbp), %rdx
callq 0xb240
cmpl $0x0, %eax
je 0xb20e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb22e
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xb222
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb22e
movq -0x10(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: lodepng_chunk_next_const
const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk, const unsigned char* end) {
  size_t available_size = (size_t)(end - chunk);
  if(chunk >= end || available_size < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    if(total_chunk_length > available_size) return end; /*outside of range*/
    return chunk + total_chunk_length;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xb2b0
cmpq $0xc, -0x20(%rbp)
jae 0xb2bd
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb37e
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x89, %eax
jne 0xb334
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x50, %eax
jne 0xb334
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x4e, %eax
jne 0xb334
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x47, %eax
jne 0xb334
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0xd, %eax
jne 0xb334
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
cmpl $0xa, %eax
jne 0xb334
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1a, %eax
jne 0xb334
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
cmpl $0xa, %eax
jne 0xb334
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xb37e
movq -0x10(%rbp), %rdi
callq 0xae40
movl %eax, %eax
movl %eax, %edi
movl $0xc, %esi
leaq -0x28(%rbp), %rdx
callq 0xb240
cmpl $0x0, %eax
je 0xb35e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb37e
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xb372
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb37e
movq -0x10(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: lodepng_chunk_create
unsigned lodepng_chunk_create(unsigned char** out, size_t* outsize,
                              size_t length, const char* type, const unsigned char* data) {
  ucvector v = ucvector_init(*out, *outsize);
  unsigned error = lodepng_chunk_createv(&v, length, type, data);
  *out = v.data;
  *outsize = v.size;
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq -0x40(%rbp), %rdi
callq 0xa380
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0xb630
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: lodepng_chunk_createv
static unsigned lodepng_chunk_createv(ucvector* out,
                                      size_t length, const char* type, const unsigned char* data) {
  unsigned char* chunk;
  CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, length, type));

  /*3: the data*/
  lodepng_memcpy(chunk + 8, data, length);

  /*4: CRC (of the chunkname characters and the data)*/
  lodepng_chunk_generate_crc(chunk);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %rdi
callq 0x1aa10
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xb66e
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb693
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb820
movq -0x30(%rbp), %rdi
callq 0xb0e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: lodepng_info_init
void lodepng_info_init(LodePNGInfo* info) {
  lodepng_color_mode_init(&info->color);
  info->interlace_method = 0;
  info->compression_method = 0;
  info->filter_method = 0;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  info->background_defined = 0;
  info->background_r = info->background_g = info->background_b = 0;

  LodePNGText_init(info);
  LodePNGIText_init(info);

  info->time_defined = 0;
  info->phys_defined = 0;

  info->gama_defined = 0;
  info->chrm_defined = 0;
  info->srgb_defined = 0;
  info->iccp_defined = 0;
  info->iccp_name = NULL;
  info->iccp_profile = NULL;

  info->sbit_defined = 0;
  info->sbit_r = info->sbit_g = info->sbit_b = info->sbit_a = 0;

  LodePNGUnknownChunks_init(info);
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0xb6a0
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rdi
callq 0xc580
movq -0x8(%rbp), %rdi
callq 0xc5b0
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xa4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xb4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xbc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xe8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xf8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x104(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x114(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x110(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x108(%rax)
movq -0x8(%rbp), %rdi
callq 0xc600
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: LodePNGText_copy
static unsigned LodePNGText_copy(LodePNGInfo* dest, const LodePNGInfo* source) {
  size_t i = 0;
  dest->text_keys = NULL;
  dest->text_strings = NULL;
  dest->text_num = 0;
  for(i = 0; i != source->text_num; ++i) {
    CERROR_TRY_RETURN(lodepng_add_text(dest, source->text_keys[i], source->text_strings[i]));
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x48(%rcx), %rax
je 0xc8ac
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0xbd10
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xc89c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc8b3
jmp 0xc89e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc854
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: LodePNGIText_copy
static unsigned LodePNGIText_copy(LodePNGInfo* dest, const LodePNGInfo* source) {
  size_t i = 0;
  dest->itext_keys = NULL;
  dest->itext_langtags = NULL;
  dest->itext_transkeys = NULL;
  dest->itext_strings = NULL;
  dest->itext_num = 0;
  for(i = 0; i != source->itext_num; ++i) {
    CERROR_TRY_RETURN(lodepng_add_itext(dest, source->itext_keys[i], source->itext_langtags[i],
                                        source->itext_transkeys[i], source->itext_strings[i]));
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x60(%rcx), %rax
je 0xc99a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x20(%rbp), %r8
movq (%rax,%r8,8), %r8
callq 0xc040
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xc98a
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc9a1
jmp 0xc98c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc91f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: lodepng_decode_memory
unsigned lodepng_decode_memory(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in,
                               size_t insize, LodePNGColorType colortype, unsigned bitdepth) {
  unsigned error;
  LodePNGState state;
  lodepng_state_init(&state);
  state.info_raw.colortype = colortype;
  state.info_raw.bitdepth = bitdepth;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  /*disable reading things that this function doesn't output*/
  state.decoder.read_text_chunks = 0;
  state.decoder.remember_unknown_chunks = 0;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
  error = lodepng_decode(out, w, h, &state, in, insize);
  lodepng_state_cleanup(&state);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x129f0
movl -0x2c(%rbp), %eax
movl %eax, -0x1a8(%rbp)
movl 0x10(%rbp), %eax
movl %eax, -0x1a4(%rbp)
movl $0x0, -0x218(%rbp)
movl $0x0, -0x214(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0x250(%rbp), %rcx
callq 0x11bf0
movl %eax, -0x30(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x12a50
movl -0x30(%rbp), %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: lodepng_decoder_settings_init
void lodepng_decoder_settings_init(LodePNGDecoderSettings* settings) {
  settings->color_convert = 1;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  settings->read_text_chunks = 1;
  settings->remember_unknown_chunks = 0;
  settings->max_text_size = 16777216;
  settings->max_icc_size = 16777216; /* 16MB is much more than enough for any reasonable ICC profile */
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
  settings->ignore_crc = 0;
  settings->ignore_critical = 0;
  settings->ignore_end = 0;
  lodepng_decompress_settings_init(&settings->zlibsettings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movq $0x1000000, 0x40(%rax)  # imm = 0x1000000
movq -0x8(%rbp), %rax
movq $0x1000000, 0x48(%rax)  # imm = 0x1000000
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0xac80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: addChunk_PLTE
static unsigned addChunk_PLTE(ucvector* out, const LodePNGColorMode* info) {
  unsigned char* chunk;
  size_t i, j = 8;

  if(info->palettesize == 0 || info->palettesize > 256) {
    return 68; /*invalid palette size, it is only allowed to be 1-256*/
  }

  CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, info->palettesize * 3, "PLTE"));

  for(i = 0; i != info->palettesize; ++i) {
    /*add all channels except alpha channel*/
    chunk[j++] = info->palette[i * 4 + 0];
    chunk[j++] = info->palette[i * 4 + 1];
    chunk[j++] = info->palette[i * 4 + 2];
  }

  lodepng_chunk_generate_crc(chunk);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x8, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x151d1
movq -0x18(%rbp), %rax
cmpq $0x100, 0x10(%rax)      # imm = 0x100
jbe 0x151dd
movl $0x44, -0x4(%rbp)
jmp 0x152c6
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
imulq $0x3, 0x10(%rax), %rdx
leaq -0x20(%rbp), %rdi
leaq 0xdc38(%rip), %rcx      # 0x22e2d
callq 0x1aa10
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x1520e
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x152c6
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x152b6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
movb 0x1(%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
movb 0x2(%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x15216
movq -0x20(%rbp), %rdi
callq 0xb0e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: ensureBits9
static LODEPNG_INLINE void ensureBits9(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 1u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u);
    reader->buffer >>= (reader->bp & 7u);
  } else {
    reader->buffer = 0;
    if(start + 0u < size) reader->buffer = reader->data[start + 0];
    reader->buffer >>= (reader->bp & 7u);
  }
  (void)nbits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jae 0x167ad
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
movzbl 0x1(%rax,%rdx), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
jmp 0x167f6
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x0, %rax
cmpq -0x20(%rbp), %rax
jae 0x167dc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: ucvector_reserve
static unsigned ucvector_reserve(ucvector* p, size_t size) {
  if(size > p->allocsize) {
    size_t newsize = size + (p->allocsize >> 1u);
    void* data = lodepng_realloc(p->data, newsize);
    if(data) {
      p->allocsize = newsize;
      p->data = (unsigned char*)data;
    }
    else return 0; /*error: not enough memory*/
  }
  return 1; /*success*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x16fc3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xb590
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x16fb8
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16fc1
movl $0x0, -0x4(%rbp)
jmp 0x16fca
jmp 0x16fc3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: huffmanDecodeSymbol
static unsigned huffmanDecodeSymbol(LodePNGBitReader* reader, const HuffmanTree* codetree) {
  unsigned short code = peekBits(reader, FIRSTBITS);
  unsigned short l = codetree->table_len[code];
  unsigned short value = codetree->table_value[code];
  if(l <= FIRSTBITS) {
    advanceBits(reader, l);
    return value;
  } else {
    advanceBits(reader, FIRSTBITS);
    value += peekBits(reader, l - FIRSTBITS);
    advanceBits(reader, codetree->table_len[value] - FIRSTBITS);
    return codetree->table_value[value];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x16ec0
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movzwl -0x1a(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movw %ax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movzwl -0x1a(%rbp), %ecx
movw (%rax,%rcx,2), %ax
movw %ax, -0x1e(%rbp)
movzwl -0x1c(%rbp), %eax
cmpl $0x9, %eax
ja 0x177db
movq -0x10(%rbp), %rdi
movzwl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x16ef0
movzwl -0x1e(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1783c
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x16ef0
movq -0x10(%rbp), %rdi
movzwl -0x1c(%rbp), %eax
subl $0x9, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x16ec0
movl %eax, %ecx
movzwl -0x1e(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x1e(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movzwl -0x1e(%rbp), %ecx
movzbl (%rax,%rcx), %eax
subl $0x9, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x16ef0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movzwl -0x1e(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: ensureBits17
static LODEPNG_INLINE void ensureBits17(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 2u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u) |
                     ((unsigned)reader->data[start + 2] << 16u);
    reader->buffer >>= (reader->bp & 7u);
  } else {
    reader->buffer = 0;
    if(start + 0u < size) reader->buffer |= reader->data[start + 0];
    if(start + 1u < size) reader->buffer |= ((unsigned)reader->data[start + 1] << 8u);
    reader->buffer >>= (reader->bp & 7u);
  }
  (void)nbits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
cmpq -0x20(%rbp), %rax
jae 0x18442
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
movzbl 0x1(%rax,%rdx), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
movzbl 0x2(%rax,%rdx), %eax
shll $0x10, %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
jmp 0x184b9
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x0, %rax
cmpq -0x20(%rbp), %rax
jae 0x18474
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movq -0x8(%rbp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jae 0x1849f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %ecx
shll $0x8, %ecx
movq -0x8(%rbp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
andq $0x7, %rcx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: inflatev
static unsigned inflatev(ucvector* out, const unsigned char* in, size_t insize,
                        const LodePNGDecompressSettings* settings) {
  if(settings->custom_inflate) {
    unsigned error = settings->custom_inflate(&out->data, &out->size, in, insize, settings);
    out->allocsize = out->size;
    if(error) {
      /*the custom inflate is allowed to have its own error codes, however, we translate it to code 110*/
      error = 110;
      /*if there's a max output size, and the custom zlib returned error, then indicate that error instead*/
      if(settings->max_output_size && out->size > settings->max_output_size) error = 109;
    }
    return error;
  } else {
    return lodepng_inflatev(out, in, insize, settings);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1a913
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpl $0x0, -0x2c(%rbp)
je 0x1a90b
movl $0x6e, -0x2c(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1a909
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x1a909
movl $0x6d, -0x2c(%rbp)
jmp 0x1a90b
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a92b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xa3b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: zlib_decompress
static unsigned zlib_decompress(unsigned char** out, size_t* outsize, size_t expected_size,
                                const unsigned char* in, size_t insize, const LodePNGDecompressSettings* settings) {
  unsigned error;
  if(settings->custom_zlib) {
    error = settings->custom_zlib(out, outsize, in, insize, settings);
    if(error) {
      /*the custom zlib is allowed to have its own error codes, however, we translate it to code 110*/
      error = 110;
      /*if there's a max output size, and the custom zlib returned error, then indicate that error instead*/
      if(settings->max_output_size && *outsize > settings->max_output_size) error = 109;
    }
  } else {
    ucvector v = ucvector_init(*out, *outsize);
    if(expected_size) {
      /*reserve the memory to avoid intermediate reallocations*/
      ucvector_resize(&v, *outsize + expected_size);
      v.size = *outsize;
    }
    error = lodepng_zlib_decompressv(&v, in, insize, settings);
    *out = v.data;
    *outsize = v.size;
  }
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1ae50
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x1ae4e
movl $0x6e, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1ae4c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x1ae4c
movl $0x6d, -0x34(%rbp)
jmp 0x1ae4e
jmp 0x1aebb
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq -0x50(%rbp), %rdi
callq 0xa380
cmpq $0x0, -0x18(%rbp)
je 0x1ae8d
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x16f20
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x50(%rbp), %rdi
callq 0xa800
movl %eax, -0x34(%rbp)
movq -0x50(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: paethPredictor
static unsigned char paethPredictor(unsigned char a, unsigned char b, unsigned char c) {
  /* the subtractions of unsigned char cast it to a signed type.
  With gcc, short is faster than int, with clang int is as fast (as of april 2023)*/
  short pa = (b - c) < 0 ? -(b - c) : (b - c);
  short pb = (a - c) < 0 ? -(a - c) : (a - c);
  /* writing it out like this compiles to something faster than introducing a temp variable*/
  short pc = (a + b - c - c) < 0 ? -(a + b - c - c) : (a + b - c - c);
  /* return input value associated with smallest of pa, pb, pc (with certain priority if equal) */
  if(pb < pa) { a = b; pa = pb; }
  return (pc < pa) ? c : a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movb %dil, %dl
movb %dl, -0x1(%rbp)
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
movzbl -0x2(%rbp), %eax
movzbl -0x3(%rbp), %ecx
subl %ecx, %eax
cmpl $0x0, %eax
jge 0x1d147
movzbl -0x2(%rbp), %ecx
movzbl -0x3(%rbp), %eax
subl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x1d154
movzbl -0x2(%rbp), %eax
movzbl -0x3(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movw %ax, -0x6(%rbp)
movzbl -0x1(%rbp), %eax
movzbl -0x3(%rbp), %ecx
subl %ecx, %eax
cmpl $0x0, %eax
jge 0x1d17d
movzbl -0x1(%rbp), %ecx
movzbl -0x3(%rbp), %eax
subl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d18a
movzbl -0x1(%rbp), %eax
movzbl -0x3(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0x8(%rbp)
movzbl -0x1(%rbp), %eax
movzbl -0x2(%rbp), %ecx
addl %ecx, %eax
movzbl -0x3(%rbp), %ecx
subl %ecx, %eax
movzbl -0x3(%rbp), %ecx
subl %ecx, %eax
cmpl $0x0, %eax
jge 0x1d1cb
movzbl -0x1(%rbp), %ecx
movzbl -0x2(%rbp), %eax
addl %eax, %ecx
movzbl -0x3(%rbp), %eax
subl %eax, %ecx
movzbl -0x3(%rbp), %eax
subl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d1e4
movzbl -0x1(%rbp), %eax
movzbl -0x2(%rbp), %ecx
addl %ecx, %eax
movzbl -0x3(%rbp), %ecx
subl %ecx, %eax
movzbl -0x3(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, -0xa(%rbp)
movswl -0x8(%rbp), %eax
movswl -0x6(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1d205
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movw -0x8(%rbp), %ax
movw %ax, -0x6(%rbp)
movswl -0xa(%rbp), %eax
movswl -0x6(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1d21a
movzbl -0x3(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d221
movzbl -0x1(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/lodepng.c
// Function: zlib_compress
static unsigned zlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in,
                              size_t insize, const LodePNGCompressSettings* settings) {
  if(settings->custom_zlib) {
    unsigned error = settings->custom_zlib(out, outsize, in, insize, settings);
    /*the custom zlib is allowed to have its own error codes, however, we translate it to code 111*/
    return error ? 111 : 0;
  } else {
    return lodepng_zlib_compress(out, outsize, in, insize, settings);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1e6ed
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq *%rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edx
xorl %eax, %eax
movl $0x6f, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1e709
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xa950
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)