LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: readBytes(unsigned char, unsigned char, unsigned char, unsigned char*)
int8_t readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data) {
    int8_t count = 0;
#ifdef DEBUG
    printf("read %#x %#x %u\n",devAddr,regAddr,length);
#endif
    int fd = open("/dev/i2c-1", O_RDWR);

    if (fd < 0) {
        fprintf(stderr, "Failed to open device: %s\n", strerror(errno));
        return(-1);
    }
    if (ioctl(fd, I2C_SLAVE, devAddr) < 0) {
        fprintf(stderr, "Failed to select device: %s\n", strerror(errno));
        close(fd);
        return(-1);
    }
    if (write(fd, &regAddr, 1) != 1) {
        fprintf(stderr, "Failed to write reg: %s\n", strerror(errno));
        close(fd);
        return(-1);
    }
    count = read(fd, data, length);
    if (count < 0) {
        fprintf(stderr, "Failed to read device(%d): %s\n", count, strerror(errno));
        close(fd);
        return(-1);
    } else if (count != length) {
        fprintf(stderr, "Short read  from device, expected %d, got %d\n", length, count);
        close(fd);
        return(-1);
    }
    close(fd);

    return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movl %edi, %r15d
movb %sil, 0x7(%rsp)
leaq 0x19b6(%rip), %rdi      # 0x6218
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0x1070
testl %eax, %eax
js 0x48d7
movl %eax, %ebx
movzbl %r15b, %edx
movl $0x703, %esi            # imm = 0x703
movl %eax, %edi
xorl %eax, %eax
callq 0x10d0
testl %eax, %eax
js 0x4906
leaq 0x7(%rsp), %rsi
pushq $0x1
popq %rdx
movl %ebx, %edi
callq 0x1060
cmpq $0x1, %rax
jne 0x4925
movzbl %bpl, %r15d
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1100
movq %rax, %r14
movsbl %r14b, %ebp
testb %r14b, %r14b
js 0x4951
cmpl %r15d, %ebp
jne 0x497f
movl %ebx, %edi
callq 0x1120
jmp 0x49a6
movq 0x4702(%rip), %rax      # 0x8fe0
movq (%rax), %rbx
callq 0x1030
movl (%rax), %edi
callq 0x1050
leaq 0x192f(%rip), %rsi      # 0x6223
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10f0
jmp 0x49a3
movq 0x46d3(%rip), %rax      # 0x8fe0
movq (%rax), %r14
callq 0x1030
movl (%rax), %edi
callq 0x1050
leaq 0x191b(%rip), %rsi      # 0x623e
jmp 0x4942
movq 0x46b4(%rip), %rax      # 0x8fe0
movq (%rax), %r14
callq 0x1030
movl (%rax), %edi
callq 0x1050
leaq 0x1919(%rip), %rsi      # 0x625b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10f0
jmp 0x499c
movq 0x4688(%rip), %rax      # 0x8fe0
movq (%rax), %r14
callq 0x1030
movl (%rax), %edi
callq 0x1050
leaq 0x1906(%rip), %rsi      # 0x6274
movq %r14, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x10f0
jmp 0x499c
movq 0x465a(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
leaq 0x1903(%rip), %rsi      # 0x6293
movl %r15d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x10f0
movl %ebx, %edi
callq 0x1120
movb $-0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: readWords(unsigned char, unsigned char, unsigned char, unsigned short*)
int8_t readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data) {
    int8_t count = 0;

    printf("ReadWords() not implemented\n");
    // Use readBytes() and potential byteswap
    *data = 0; // keep the compiler quiet

    return count;
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
leaq 0x1987(%rip), %rdi      # 0x6346
callq 0x1110
andw $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: writeBit(unsigned char, unsigned char, unsigned char, unsigned char)
int writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data) {
    uint8_t b;
    readByte(devAddr, regAddr, &b);
    b = (data != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum));
    return writeByte(devAddr, regAddr, b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
leaq 0xf(%rsp), %r12
movq %r12, %rdx
callq 0x47af
movzbl (%r12), %eax
movl %eax, %ecx
btsl %ebp, %ecx
btrl %ebp, %eax
testl %ebx, %ebx
cmovnel %ecx, %eax
movzbl %al, %edx
movl %r15d, %edi
movl %r14d, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4a1b
// File: /workspace/github_c_makefile_star2_O2/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: writeBitW(unsigned char, unsigned char, unsigned char, unsigned short)
int writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data) {
    uint16_t w;
    readWord(devAddr, regAddr, &w);
    w = (data != 0) ? (w | (1 << bitNum)) : (w & ~(1 << bitNum));
    return writeWord(devAddr, regAddr, w);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
leaq 0x1901(%rip), %rdi      # 0x6346
callq 0x1110
pushq $0x1
popq %rax
movl %ebp, %ecx
shll %cl, %eax
testl %ebx, %ebx
cmovel %ebx, %eax
movzwl %ax, %edx
movl %r15d, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4a6e
// File: /workspace/github_c_makefile_star2_O2/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: writeBits(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char)
int writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data) {
    //      010 value to write
    // 76543210 bit numbers
    //    xxx   args: bitStart=4, length=3
    // 00011100 mask byte
    // 10101111 original value (sample)
    // 10100011 original & ~mask
    // 10101011 masked | value
    uint8_t b;
    if (readByte(devAddr, regAddr, &b) != 0) {
        uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
        data <<= (bitStart - length + 1); // shift data into correct position
        data &= mask; // zero all non-important bits in data
        b &= ~(mask); // zero all important bits in existing byte
        b |= data; // combine data with existing byte
        return writeByte(devAddr, regAddr, b);
    } else {
        return -1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %r14d
movl %ecx, %r12d
movl %edx, %r15d
movl %esi, %ebx
movl %edi, %ebp
leaq 0xf(%rsp), %rdx
callq 0x47af
testb %al, %al
je 0x4aec
movzbl %r12b, %ecx
pushq $-0x1
popq %rdx
shll %cl, %edx
notl %edx
movzbl %r15b, %eax
subl %ecx, %eax
incb %al
movzbl %r14b, %esi
andl %edx, %esi
movl %eax, %ecx
shll %cl, %edx
shll %cl, %esi
notb %dl
andb 0xf(%rsp), %dl
orb %dl, %sil
movzbl %sil, %edx
movzbl %bpl, %edi
movzbl %bl, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4a1b
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: writeBytes(unsigned char, unsigned char, unsigned char, unsigned char*)
int writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t* data) {
    int8_t count = 0;
    uint8_t buf[128];
    int fd;

#ifdef DEBUG
    printf("write %#x %#x\n",devAddr,regAddr);
#endif
    if (length > 127) {
        fprintf(stderr, "Byte write count (%d) > 127\n", length);
        return -1;
    }

    fd = open("/dev/i2c-1", O_RDWR);
    if (fd < 0) {
        fprintf(stderr, "Failed to open device: %s\n", strerror(errno));
        return -1;
    }
    if (ioctl(fd, I2C_SLAVE, devAddr) < 0) {
        fprintf(stderr, "Failed to select device: %s\n", strerror(errno));
        close(fd);
        return -1;
    }
    buf[0] = regAddr;
    memcpy(buf+1,data,length);
    count = write(fd, buf, length+1);
    if (count < 0) {
        fprintf(stderr, "Failed to write device(%d): %s\n", count, strerror(errno));
        close(fd);
        return -1;
    } else if (count != length+1) {
        fprintf(stderr, "Short write to device, expected %d, got %d\n", length+1, count);
        close(fd);
        return -1;
    }
    close(fd);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %edx, %r14d
testb %r14b, %r14b
js 0x4bad
movq %rcx, %r15
movl %esi, %ebp
movl %edi, %r12d
leaq 0x16e0(%rip), %rdi      # 0x6218
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0x1070
testl %eax, %eax
js 0x4bcd
movl %eax, %ebx
movzbl %r12b, %edx
movl $0x703, %esi            # imm = 0x703
movl %eax, %edi
xorl %eax, %eax
callq 0x10d0
testl %eax, %eax
js 0x4bf9
leaq 0x1(%rsp), %rdi
movb %bpl, -0x1(%rdi)
movzbl %r14b, %edx
movq %r15, %rsi
callq 0x1080
incl %r14d
movq %rsp, %rsi
movl %ebx, %edi
movq %r14, %rdx
callq 0x1060
movsbl %al, %ebp
testl %ebp, %ebp
js 0x4c25
cmpl %r14d, %ebp
jne 0x4c53
movl %ebx, %edi
callq 0x1120
xorl %eax, %eax
jmp 0x4c7a
movq 0x442c(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
leaq 0x1703(%rip), %rsi      # 0x62c1
movl %r14d, %edx
xorl %eax, %eax
callq 0x10f0
jmp 0x4c77
movq 0x440c(%rip), %rax      # 0x8fe0
movq (%rax), %rbx
callq 0x1030
movl (%rax), %edi
callq 0x1050
leaq 0x1639(%rip), %rsi      # 0x6223
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10f0
jmp 0x4c77
movq 0x43e0(%rip), %rax      # 0x8fe0
movq (%rax), %r14
callq 0x1030
movl (%rax), %edi
callq 0x1050
leaq 0x1628(%rip), %rsi      # 0x623e
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10f0
jmp 0x4c70
movq 0x43b4(%rip), %rax      # 0x8fe0
movq (%rax), %r14
callq 0x1030
movl (%rax), %edi
callq 0x1050
leaq 0x169c(%rip), %rsi      # 0x62de
movq %r14, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x10f0
jmp 0x4c70
movq 0x4386(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
leaq 0x169a(%rip), %rsi      # 0x62fe
movl %r14d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x10f0
movl %ebx, %edi
callq 0x1120
pushq $-0x1
popq %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/main.c
// Function: new_task
void new_task(void *(func)(void *), void *arg)
{
	int pid;

	parent_pid = getpid();

	pid = fork();
	if (pid < 0) {
		perror("fork");
		exit(1);
	}

	if (!pid) {
		struct sigaction sa;

		memset(&sa, 0, sizeof(sa));
		sa.sa_handler = watchdog;
		sa.sa_flags = SA_RESTART;
		sigaction(SIGALRM, &sa, NULL);
		alarm(1);

		func(arg);
	}

	pids[nr_pids++] = pid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x20e0
movl %eax, 0x2dd4(%rip)      # 0x51b0
callq 0x22b0
testl %eax, %eax
js 0x2455
movl %eax, %ebp
jne 0x242d
leaq 0x8(%rsp), %r15
movl $0x90, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x2150
leaq 0x65(%rip), %rax        # 0x2469
movq %rax, -0x8(%r15)
movl $0x10000000, 0x80(%r15) # imm = 0x10000000
pushq $0xe
popq %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0x20b0
pushq $0x1
popq %rdi
callq 0x2160
movq %r14, %rdi
callq *%rbx
movslq 0x6d8c(%rip), %rax      # 0x91c0
leal 0x1(%rax), %ecx
movl %ecx, 0x6d83(%rip)      # 0x91c0
leaq 0x2d7c(%rip), %rcx      # 0x51c0
movl %ebp, (%rcx,%rax,4)
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbd0(%rip), %rdi       # 0x302c
callq 0x2240
pushq $0x1
popq %rdi
callq 0x2290
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/main.c
// Function: new_task_affinity
void new_task_affinity(struct args *args)
{
	int pid;

	parent_pid = getpid();

	pid = fork();
	if (pid < 0) {
		perror("fork");
		exit(1);
	}

	if (!pid) {
		struct sigaction sa;

		memset(&sa, 0, sizeof(sa));
		sa.sa_handler = watchdog;
		sa.sa_flags = SA_RESTART;
		sigaction(SIGALRM, &sa, NULL);
		alarm(1);

		testcase_trampoline(args);
	}

	pids[nr_pids++] = pid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
callq 0x20e0
movl %eax, 0x2d07(%rip)      # 0x51b0
callq 0x22b0
testl %eax, %eax
js 0x2569
movl %eax, %ebp
jne 0x253f
leaq 0x10(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2150
leaq -0x70(%rip), %rax       # 0x2469
movq %rax, -0x8(%r14)
movl $0x10000000, 0x80(%r14) # imm = 0x10000000
pushq $0xe
popq %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x20b0
pushq $0x1
popq %rdi
callq 0x2160
movl 0x18(%rbx), %eax
movq %rsp, %r14
movl %eax, (%r14)
movl $0x1, 0x4(%r14)
pushq $0x1
popq %r15
pushq $-0x1
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x2210
cmpl $-0x1, %eax
jne 0x2535
callq 0x2070
cmpl $0x4, (%rax)
je 0x2518
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq *(%rbx)
movslq 0x6c7a(%rip), %rax      # 0x91c0
leal 0x1(%rax), %ecx
movl %ecx, 0x6c71(%rip)      # 0x91c0
leaq 0x2c6a(%rip), %rcx      # 0x51c0
movl %ebp, (%rcx,%rax,4)
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xabc(%rip), %rdi       # 0x302c
callq 0x2240
pushq $0x1
popq %rdi
callq 0x2290
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/writeseek2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = open(tmpfile, O_RDWR);

	assert(fd >= 0);

	while (1) {
		lseek(fd, 0, SEEK_SET);
		assert(write(fd, buf, BUFLEN) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
leaq 0x2506(%rip), %rdi      # 0x5180
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0x2230
testl %eax, %eax
js 0x2ccd
movl %eax, %ebp
movq %rsp, %r14
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2130
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
callq 0x20d0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2cb4
incq (%rbx)
jmp 0x2c8d
leaq 0x65e(%rip), %rdi       # 0x3319
leaq 0x5c1(%rip), %rsi       # 0x3283
leaq 0x61d(%rip), %rcx       # 0x32e6
pushq $0x21
jmp 0x2ce4
leaq 0x5a7(%rip), %rdi       # 0x327b
leaq 0x5a8(%rip), %rsi       # 0x3283
leaq 0x604(%rip), %rcx       # 0x32e6
pushq $0x1d
popq %rdx
callq 0x2140
// File: /workspace/github_c_makefile_star2_O2/ikbenlike[P]nngutils/src/unlink.c
// Function: main
int main(int argc, char **argv){
    if(argc > 2){
        fprintf(stderr, "%s: extra operand '%s'\n", argv[0], argv[2]);
        return 1;
    }
    else if(argc < 2){
        fprintf(stderr, "%s: missing operand\n", argv[0]);
        return 1;
    }
    else {
        if(unlink(argv[1]) == -1){
            fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x3, %edi
jge 0x1197
cmpl $0x2, %edi
jne 0x11b1
movq 0x8(%rbx), %rdi
callq 0x1040
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
je 0x11ce
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2e5a(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rbx), %rdx
movq 0x10(%rbx), %rcx
leaq 0xe55(%rip), %rsi       # 0x2004
jmp 0x11f7
movq 0x2e40(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0xe57(%rip), %rsi       # 0x201c
xorl %eax, %eax
callq 0x1050
jmp 0x11fe
movq 0x2e23(%rip), %rax      # 0x3ff8
movq (%rax), %r14
movq (%rbx), %rbx
callq 0x1030
movl (%rax), %edi
callq 0x1060
leaq 0xe43(%rip), %rsi       # 0x2031
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1050
pushq $0x1
popq %rax
jmp 0x1192
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed.c
// Function: main
int
main(int argc, char *argv[])
{
	if (pledge("stdio", NULL) == -1)
		err(1, "pledge");

	if (argc > 1)
		baseurl = argv[1];

	parser.xmlattr = xmlattr;
	parser.xmlattrend = xmlattrend;
	parser.xmlattrstart = xmlattrstart;
	parser.xmlcdata = xmlcdata;
	parser.xmldata = xmldata;
	parser.xmldataentity = xmldataentity;
	parser.xmltagend = xmltagend;
	parser.xmltagstart = xmltagstart;
	parser.xmltagstartparsed = xmltagstartparsed;

	/* NOTE: getnext is defined in xml.h for inline optimization */
	xml_parse(&parser);

	return 0;
}

// Assembly:
cmpl $0x2, %edi
jl 0x2307
movq 0x8(%rsi), %rax
movq %rax, 0x5e09(%rip)      # 0x8110
pushq %rax
leaq 0x87(%rip), %rax        # 0x2396
movq %rax, 0x5ffa(%rip)      # 0x8310
leaq 0x5ff3(%rip), %rdi      # 0x8310
leaq 0x345(%rip), %rax       # 0x2669
movq %rax, 0x5fed(%rip)      # 0x8318
leaq 0x36e(%rip), %rax       # 0x26a0
movq %rax, 0x5fe7(%rip)      # 0x8320
leaq 0x3d6(%rip), %rax       # 0x2716
movq %rax, 0x5ff1(%rip)      # 0x8338
leaq 0x3d9(%rip), %rax       # 0x2727
movq %rax, 0x600b(%rip)      # 0x8360
leaq 0x425(%rip), %rax       # 0x2781
movq %rax, 0x600d(%rip)      # 0x8370
leaq 0x467(%rip), %rax       # 0x27d1
movq %rax, 0x600f(%rip)      # 0x8380
leaq 0xda3(%rip), %rax       # 0x311b
movq %rax, 0x6009(%rip)      # 0x8388
leaq 0xf31(%rip), %rax       # 0x32b7
movq %rax, 0x6003(%rip)      # 0x8390
callq 0x3df3
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed.c
// Function: xmlattrstart
static void
xmlattrstart(XMLParser *p, const char *t, size_t tl, const char *n, size_t nl)
{
	if (!ISINCONTENT(ctx) || ctx.contenttype != ContentTypeHTML)
		return;

	/* handles transforming inline XML to data */
	if (!ctx.attrcount)
		xmldata(p, " ", 1);
	ctx.attrcount++;
	xmldata(p, n, nl);
	xmldata(p, "=\"", 2);
}

// Assembly:
cmpl $0x0, 0x85ed(%rip)      # 0xac94
je 0x2715
cmpl $0x0, 0x85e8(%rip)      # 0xac98
jne 0x2715
cmpl $0x2, 0x85e3(%rip)      # 0xac9c
jne 0x2715
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movl 0x85d5(%rip), %eax      # 0xaca4
testl %eax, %eax
jne 0x26eb
leaq 0x298e(%rip), %rsi      # 0x5068
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x2727
movl 0x85b9(%rip), %eax      # 0xaca4
incl %eax
movl %eax, 0x85b1(%rip)      # 0xaca4
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2727
leaq 0x2962(%rip), %rsi      # 0x506a
pushq $0x2
popq %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2727
retq
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed.c
// Function: xmldataentity
static void
xmldataentity(XMLParser *p, const char *data, size_t datalen)
{
	char buf[16];
	ssize_t len;

	if (!ctx.field)
		return;

	/* try to translate entity, else just pass as data to
	 * xml_data_handler. */
	if ((len = xml_entitytostr(data, buf, sizeof(buf))) > 0)
		xmldata(p, buf, (size_t)len);
	else
		xmldata(p, data, datalen);
}

// Assembly:
cmpq $0x0, 0x841f(%rip)      # 0xaba8
je 0x27d0
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x3c74
testl %eax, %eax
jle 0x27b9
movl %eax, %edx
movq %rsp, %rsi
movq %rbx, %rdi
jmp 0x27c2
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2727
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed.c
// Function: xmltagstartparsed
static void
xmltagstartparsed(XMLParser *p, const char *tag, size_t taglen, int isshort)
{
	if (ctx.iscontenttag) {
		ctx.iscontent = 1;
		ctx.iscontenttag = 0;
		return;
	}

	/* don't read field value in Atom <link> tag */
	if (ctx.tagid == AtomTagLink)
		ctx.field = NULL;

	if (!ISINCONTENT(ctx) || ctx.contenttype != ContentTypeHTML)
		return;

	if (isshort)
		xmldata(p, "/>", 2);
	else
		xmldata(p, ">", 1);
}

// Assembly:
cmpl $0x0, 0x79da(%rip)      # 0xac98
je 0x32cc
movq $0x1, 0x79c9(%rip) # 0xac94
retq
cmpl $0x13, 0x79bd(%rip)     # 0xac90
jne 0x32dd
andq $0x0, 0x78cb(%rip)      # 0xaba8
cmpl $0x0, 0x79b0(%rip)      # 0xac94
je 0x32cb
cmpl $0x2, 0x79af(%rip)      # 0xac9c
jne 0x32cb
testl %ecx, %ecx
je 0x32fe
leaq 0x1e88(%rip), %rsi      # 0x5182
pushq $0x2
jmp 0x3307
leaq 0x1e7e(%rip), %rsi      # 0x5183
pushq $0x1
popq %rdx
jmp 0x2727
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed.c
// Function: string_append
static void
string_append(String *s, const char *data, size_t len)
{
	if (!len)
		return;
	/* check if allocation is necesary, don't shrink buffer,
	 * should be more than bufsiz ofcourse. */
	if (s->len + len >= s->bufsiz)
		string_buffer_realloc(s, s->len + len + 1);
	memcpy(s->data + s->len, data, len);
	s->len += len;
	s->data[s->len] = '\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x339d
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq (%rdi,%rdx), %rax
cmpq 0x10(%r14), %rax
jae 0x3354
movq (%r14), %rax
jmp 0x3380
incq %rax
pushq $0x40
popq %rcx
movq %rcx, %r12
addq %rcx, %rcx
cmpq %rax, %r12
jbe 0x335a
movq (%r14), %rdi
movq %r12, %rsi
callq 0x21a0
movq %rax, (%r14)
testq %rax, %rax
je 0x33a9
movq %r12, 0x10(%r14)
movq 0x8(%r14), %rdi
addq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2150
addq 0x8(%r14), %rbx
movq %rbx, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1cb0(%rip), %rsi      # 0x5060
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x2170
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed.c
// Function: gettag
static enum TagId
gettag(enum FeedType feedtype, const char *name, size_t namelen)
{
	FeedTag f, *r = NULL;

	f.name = (char *)name;

	switch (feedtype) {
	case FeedTypeRSS:
		r = bsearch(&f, rsstags, sizeof(rsstags) / sizeof(rsstags[0]),
		        sizeof(rsstags[0]), tagcmp);
		break;
	case FeedTypeAtom:
		r = bsearch(&f, atomtags, sizeof(atomtags) / sizeof(atomtags[0]),
		        sizeof(atomtags[0]), tagcmp);
		break;
	default:
		break;
	}

	return r ? r->id : TagUnknown;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, 0x8(%rsp)
xorl %ebx, %ebx
cmpl $0x2, %edi
je 0x3405
cmpl $0x1, %edi
jne 0x342b
leaq 0x4d2b(%rip), %rsi      # 0x8120
leaq -0x1110(%rip), %r8      # 0x22ec
leaq 0x8(%rsp), %rdi
pushq $0xb
jmp 0x341a
leaq 0x4e24(%rip), %rsi      # 0x8230
leaq -0x1127(%rip), %r8      # 0x22ec
leaq 0x8(%rsp), %rdi
pushq $0x9
popq %rdx
pushq $0x18
popq %rcx
callq 0x21d0
testq %rax, %rax
je 0x342b
movl 0x10(%rax), %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed.c
// Function: string_print_trimmed
static void
string_print_trimmed(String *s)
{
	char *p, *e;

	if (!s->data || !s->len)
		return;

	p = ltrim(s->data);
	e = rtrim(p);

	for (; *p && p != e; p++) {
		if (isspace((unsigned char)*p))
			putchar(' '); /* any whitespace to space */
		else if (!iscntrl((unsigned char)*p))
			/* ignore other control chars */
			putchar(*p);
	}
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x34a3
cmpq $0x0, 0x8(%rax)
je 0x34a3
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x3517
movq %rax, %rbx
movq %rax, %rdi
callq 0x3547
movq %rax, %r14
pushq $0x20
popq %rbp
movsbl (%rbx), %r15d
testl %r15d, %r15d
je 0x3499
cmpq %r14, %rbx
je 0x3499
callq 0x21e0
movq (%rax), %rax
movzbl %r15b, %ecx
movzwl (%rax,%rcx,2), %eax
btl $0xd, %eax
movl %ebp, %edi
jb 0x348f
movl %r15d, %edi
testb $0x2, %al
jne 0x3494
callq 0x2030
incq %rbx
jmp 0x3462
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed.c
// Function: string_print_uri
void
string_print_uri(String *s)
{
	char link[4096], *p, *e;
	int c;

	if (!s->data || !s->len)
		return;

	p = ltrim(s->data);
	e = rtrim(p);
	c = *e;
	*e = '\0';
	if (absuri(link, sizeof(link), p, baseurl) != -1)
		fputs(link, stdout);
	*e = c; /* restore */
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3516
cmpq $0x0, 0x8(%rax)
je 0x3516
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
callq 0x3517
movq %rax, %r14
movq %rax, %rdi
callq 0x3547
movq %rax, %rbx
movb (%rax), %bpl
movb $0x0, (%rax)
movq 0x4c2f(%rip), %rcx      # 0x8110
movq %rsp, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdx
callq 0x37e9
cmpl $-0x1, %eax
je 0x3508
movq 0x4ae3(%rip), %rax      # 0x7fe0
movq (%rax), %rsi
movq %rsp, %rdi
callq 0x20c0
movb %bpl, (%rbx)
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/xml.c
// Function: xml_entitytostr
int
xml_entitytostr(const char *e, char *buf, size_t bufsiz)
{
	/* doesn't start with & */
	if (e[0] != '&')
		return 0;
	/* numeric entity */
	if (e[1] == '#')
		return numericentitytostr(e + 2, buf, bufsiz);
	else /* named entity */
		return namedentitytostr(e + 1, buf, bufsiz);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %r14d, %r14d
cmpb $0x26, (%rdi)
jne 0x3de2
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x23, 0x1(%rdi)
jne 0x3cc5
cmpq $0x5, %rdx
jb 0x3ccb
leaq 0x2(%r15), %r14
callq 0x2050
movq %rax, %r12
andl $0x0, (%rax)
cmpb $0x78, (%r14)
jne 0x3d16
addq $0x3, %r15
leaq 0x8(%rsp), %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
jmp 0x3d21
cmpq $0x2, %rdx
jae 0x3cd4
pushq $-0x1
popq %r14
jmp 0x3de2
incq %r15
xorl %r14d, %r14d
leaq 0x406f(%rip), %r12      # 0x7d50
xorl %ecx, %ecx
leaq 0x10(%rcx), %r13
cmpq $0xb0, %r13
je 0x3de2
movq (%rcx,%r12), %rsi
movq %r15, %rdi
callq 0x2100
movq %r13, %rcx
testl %eax, %eax
jne 0x3ce3
movb -0x8(%r13,%r12), %al
movb %al, (%rbx)
movb $0x0, 0x1(%rbx)
pushq $0x1
jmp 0x3ccd
leaq 0x8(%rsp), %rsi
pushq $0xa
popq %rdx
movq %r14, %rdi
callq 0x21b0
xorl %r14d, %r14d
cmpl $0x0, (%r12)
jne 0x3de2
movq 0x8(%rsp), %rcx
cmpb $0x3b, (%rcx)
setne %cl
cmpq $0x110000, %rax         # imm = 0x110000
setge %dl
orb %cl, %dl
jne 0x3de2
testq %rax, %rax
je 0x3d61
cmpq $0x7f, %rax
jg 0x3d66
movb %al, (%rbx)
pushq $0x1
jmp 0x3dd9
xorl %r14d, %r14d
jmp 0x3ddb
movl %eax, %ecx
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0x3d83
shrl $0x6, %ecx
orb $-0x40, %cl
movb %cl, (%rbx)
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rbx)
pushq $0x2
jmp 0x3dd9
cmpq $0xffff, %rax           # imm = 0xFFFF
ja 0x3dac
shrl $0xc, %ecx
orb $-0x20, %cl
movb %cl, (%rbx)
movl %eax, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rbx)
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rbx)
pushq $0x3
jmp 0x3dd9
shrl $0x12, %ecx
orb $-0x10, %cl
movb %cl, (%rbx)
movl %eax, %ecx
shrl $0xc, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rbx)
movl %eax, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x2(%rbx)
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x3(%rbx)
pushq $0x4
popq %r14
movl %r14d, %eax
movb $0x0, (%rbx,%rax)
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_load
STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
{
   FILE *f = stbi__fopen(filename, "rb");
   unsigned char *result;
   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
   result = stbi_load_from_file(f,x,y,comp,req_comp);
   fclose(f);
   return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0xe494(%rip), %rsi      # 0x10900
callq 0x21b0
testq %rax, %rax
je 0x249d
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x24b7
movq %rax, %rbx
movq %r13, %rdi
callq 0x2160
movq %rbx, %rax
jmp 0x24ad
leaq 0xe45f(%rip), %rax      # 0x10903
movq %rax, 0x12d6d(%rip)     # 0x15218
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_load_from_file
STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *result;
   stbi__context s;
   stbi__start_file(&s,f);
   result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
   if (result) {
      // need to 'unget' all the characters in the IO buffer
      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
   }
   return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2532
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x2541
movq %rax, %r14
testq %rax, %rax
je 0x251d
movl 0xb8(%rsp), %eax
subl 0xc0(%rsp), %eax
movslq %eax, %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__load_and_postprocess_8bit(stbi__context*, int*, int*, int*, int)
static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   stbi__result_info ri;
   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);

   if (result == NULL)
      return NULL;

   if (ri.bits_per_channel != 8) {
      STBI_ASSERT(ri.bits_per_channel == 16);
      result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
      ri.bits_per_channel = 8;
   }

   // @TODO: move stbi__convert_format to here

   if (stbi__vertically_flip_on_load) {
      int channels = req_comp ? req_comp : *comp;
      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
   }

   return (unsigned char *) result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movl $0x8, (%rsp)
leaq 0x1c(%rsp), %r9
callq 0x6033
testq %rax, %rax
je 0x25cf
movq %rax, %rbp
movl 0x1c(%rsp), %eax
cmpl $0x8, %eax
movq %r13, 0x10(%rsp)
je 0x25d4
cmpl $0x10, %eax
jne 0x2627
movl (%r15), %eax
movl (%r14), %r12d
movl %ebx, %ecx
testl %ebx, %ebx
jne 0x259b
movl (%r13), %ecx
imull %eax, %r12d
imull %ecx, %r12d
movslq %r12d, %rdi
callq 0x21f0
movq %rax, %r13
testq %rax, %rax
je 0x25e3
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
cmpq %rax, %r12
je 0x25d9
movb 0x1(%rbp,%rax,2), %cl
movb %cl, (%r13,%rax)
incq %rax
jmp 0x25bc
xorl %r13d, %r13d
jmp 0x2615
movq %rbp, %r13
jmp 0x25f1
movq %rbp, %rdi
callq 0x21c0
jmp 0x25f1
leaq 0xe4ef(%rip), %rax      # 0x10ad9
movq %rax, 0x12c27(%rip)     # 0x15218
cmpl $0x0, 0x12c28(%rip)     # 0x15220
je 0x2615
testl %ebx, %ebx
jne 0x2605
movq 0x10(%rsp), %rax
movl (%rax), %ebx
movl (%r15), %esi
movl (%r14), %edx
movq %r13, %rdi
movl %ebx, %ecx
callq 0x946e
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe31e(%rip), %rdi      # 0x1094c
leaq 0xe331(%rip), %rsi      # 0x10966
leaq 0xe338(%rip), %rcx      # 0x10974
movl $0x468, %edx            # imm = 0x468
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_load_from_file_16
STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
{
   stbi__uint16 *result;
   stbi__context s;
   stbi__start_file(&s,f);
   result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
   if (result) {
      // need to 'unget' all the characters in the IO buffer
      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
   }
   return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2532
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x26c1
movq %rax, %r14
testq %rax, %rax
je 0x26ac
movl 0xb8(%rsp), %eax
subl 0xc0(%rsp), %eax
movslq %eax, %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__load_and_postprocess_16bit(stbi__context*, int*, int*, int*, int)
static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   stbi__result_info ri;
   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);

   if (result == NULL)
      return NULL;

   if (ri.bits_per_channel != 16) {
      STBI_ASSERT(ri.bits_per_channel == 8);
      result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
      ri.bits_per_channel = 16;
   }

   // @TODO: move stbi__convert_format16 to here
   // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision

   if (stbi__vertically_flip_on_load) {
      int channels = req_comp ? req_comp : *comp;
      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
   }

   return (stbi__uint16 *) result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r12
movl $0x10, (%rsp)
leaq 0x1c(%rsp), %r9
callq 0x6033
testq %rax, %rax
je 0x2725
movq %rax, %r15
movl 0x1c(%rsp), %eax
cmpl $0x8, %eax
je 0x272d
cmpl $0x10, %eax
je 0x27a5
leaq 0xeb77(%rip), %rdi      # 0x11284
leaq 0xe252(%rip), %rsi      # 0x10966
leaq 0xeb82(%rip), %rcx      # 0x1129d
movl $0x480, %edx            # imm = 0x480
callq 0x20f0
xorl %r15d, %r15d
jmp 0x27c8
movl (%r12), %eax
movl (%r14), %r13d
movl %ebx, %ecx
testl %ebx, %ebx
jne 0x273d
movl (%rbp), %ecx
movq %rbp, 0x10(%rsp)
imull %eax, %r13d
imull %ecx, %r13d
leal (,%r13,2), %eax
movslq %eax, %rdi
callq 0x21f0
movq %rax, %rbp
testq %rax, %rax
je 0x278f
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
cmpq %rax, %r13
je 0x2785
movzbl (%r15,%rax), %ecx
imull $0x101, %ecx, %ecx      # imm = 0x101
movw %cx, (%rbp,%rax,2)
incq %rax
jmp 0x276b
movq %r15, %rdi
callq 0x21c0
jmp 0x279d
leaq 0xe343(%rip), %rax      # 0x10ad9
movq %rax, 0x12a7b(%rip)     # 0x15218
movq %rbp, %r15
movq 0x10(%rsp), %rbp
cmpl $0x0, 0x12a74(%rip)     # 0x15220
je 0x27c8
testl %ebx, %ebx
jne 0x27b5
movl (%rbp), %ebx
movl (%r12), %esi
movl (%r14), %edx
addl %ebx, %ebx
movq %r15, %rdi
movl %ebx, %ecx
callq 0x946e
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_load_16
STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
{
   FILE *f = stbi__fopen(filename, "rb");
   stbi__uint16 *result;
   if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
   result = stbi_load_from_file_16(f,x,y,comp,req_comp);
   fclose(f);
   return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0xe10a(%rip), %rsi      # 0x10900
callq 0x21b0
testq %rax, %rax
je 0x2827
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x2646
movq %rax, %rbx
movq %r13, %rdi
callq 0x2160
movq %rbx, %rax
jmp 0x2837
leaq 0xe0d5(%rip), %rax      # 0x10903
movq %rax, 0x129e3(%rip)     # 0x15218
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__start_callbacks(stbi__context*, stbi_io_callbacks*, void*)
static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
{
   s->io = *c;
   s->io_user_data = user;
   s->buflen = sizeof(s->buffer_start);
   s->read_from_callbacks = 1;
   s->img_buffer_original = s->buffer_start;
   stbi__refill_buffer(s);
   s->img_buffer_original_end = s->img_buffer_end;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rdi)
movups (%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movq %rdx, 0x28(%rdi)
movabsq $0x8000000001, %rax     # imm = 0x8000000001
movq %rax, 0x30(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, 0xc8(%rdi)
callq 0xaecd
movq 0xc0(%rbx), %rax
movq %rax, 0xd0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__loadf_main(stbi__context*, int*, int*, int*, int)
static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *data;
   #ifndef STBI_NO_HDR
   if (stbi__hdr_test(s)) {
      stbi__result_info ri;
      float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
      if (hdr_data)
         stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
      return hdr_data;
   }
   #endif
   data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
   if (data)
      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r14
callq 0x2fa9
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %ebx, %r8d
testl %eax, %eax
je 0x2d13
callq 0x95b8
movq %rax, %r14
testq %rax, %rax
je 0x2e46
cmpl $0x0, 0x12534(%rip)     # 0x15220
je 0x2e46
testl %ebx, %ebx
jne 0x2cfa
movl (%r13), %ebx
movl (%rbp), %esi
movl (%r12), %edx
shll $0x2, %ebx
movq %r14, %rdi
movl %ebx, %ecx
callq 0x946e
jmp 0x2e46
callq 0x2541
testq %rax, %rax
je 0x2e24
movq %rax, %r14
movl (%rbp), %r15d
movl (%r12), %r12d
testl %ebx, %ebx
jne 0x2d34
movl (%r13), %ebx
movl %r15d, %edi
movl %r12d, %esi
movl %ebx, %edx
callq 0xea7c
testq %rax, %rax
je 0x2e2d
movl %ebx, %ecx
andl $0x1, %ecx
xorl %ebp, %ebp
cmpl $0x1, %ecx
movl %ebx, %ecx
sbbl %ebp, %ecx
imull %r15d, %r12d
testl %ecx, %ecx
movl $0x0, %r15d
movl %ecx, (%rsp)
cmovgl %ecx, %r15d
movl %ebx, 0x4(%rsp)
movslq %ebx, %rcx
testl %r12d, %r12d
cmovlel %ebp, %r12d
movq %rcx, 0x8(%rsp)
leaq (,%rcx,4), %rcx
movq %rcx, 0x20(%rsp)
movq %rax, %rbx
movq %r14, 0x10(%rsp)
movq %rax, 0x18(%rsp)
cmpq %r12, %rbp
je 0x2de5
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x2dd6
movzbl (%r14,%r13), %eax
cvtsi2ss %eax, %xmm0
divss 0xd24e(%rip), %xmm0     # 0x10004
movss 0x123e2(%rip), %xmm1    # 0x151a0
callq 0x2270
mulss 0x123d9(%rip), %xmm0    # 0x151a4
movss %xmm0, (%rbx,%r13,4)
incq %r13
jmp 0x2da0
incq %rbp
addq 0x20(%rsp), %rbx
addq 0x8(%rsp), %r14
jmp 0x2d98
testb $0x1, 0x4(%rsp)
movq 0x18(%rsp), %r14
movq 0x10(%rsp), %rdi
jne 0x2e1d
movslq (%rsp), %rax
subq $0x1, %r12
jb 0x2e1d
movzbl (%rdi,%rax), %ecx
cvtsi2ss %ecx, %xmm0
divss 0xd1f4(%rip), %xmm0     # 0x10004
movss %xmm0, (%r14,%rax,4)
addq 0x8(%rsp), %rax
jmp 0x2dfa
callq 0x21c0
jmp 0x2e46
leaq 0xdba3(%rip), %rax      # 0x109ce
jmp 0x2e3c
movq %r14, %rdi
callq 0x21c0
leaq 0xdc9d(%rip), %rax      # 0x10ad9
movq %rax, 0x123d5(%rip)     # 0x15218
xorl %r14d, %r14d
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_loadf
STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
{
   float *result;
   FILE *f = stbi__fopen(filename, "rb");
   if (!f) return stbi__errpf("can't fopen", "Unable to open file");
   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
   fclose(f);
   return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0xda38(%rip), %rsi      # 0x10900
callq 0x21b0
testq %rax, %rax
je 0x2ef9
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x2f13
movq %rax, %rbx
movq %r13, %rdi
callq 0x2160
movq %rbx, %rax
jmp 0x2f09
leaq 0xda03(%rip), %rax      # 0x10903
movq %rax, 0x12311(%rip)     # 0x15218
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_is_hdr_from_memory
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
{
   #ifndef STBI_NO_HDR
   stbi__context s;
   stbi__start_mem(&s,buffer,len);
   return stbi__hdr_test(&s);
   #else
   STBI_NOTUSED(buffer);
   STBI_NOTUSED(len);
   return 0;
   #endif
}

// Assembly:
subq $0xd8, %rsp
movq %rsp, %rax
andq $0x0, 0x10(%rax)
andl $0x0, 0x30(%rax)
movq %rdi, 0xc8(%rax)
movq %rdi, 0xb8(%rax)
movslq %esi, %rcx
addq %rdi, %rcx
movq %rcx, 0xd0(%rax)
movq %rcx, 0xc0(%rax)
movq %rax, %rdi
callq 0x2fa9
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__hdr_test(stbi__context*)
static int stbi__hdr_test(stbi__context* s)
{
   int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
   stbi__rewind(s);
   if(!r) {
       r = stbi__hdr_test_core(s, "#?RGBE\n");
       stbi__rewind(s);
   }
   return r;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xe494(%rip), %rsi      # 0x11448
callq 0xf036
movups 0xc8(%rbx), %xmm0
movups %xmm0, 0xb8(%rbx)
testl %eax, %eax
je 0x2fd0
pushq $0x1
popq %rax
popq %rbx
retq
leaq 0xe47d(%rip), %rsi      # 0x11454
movq %rbx, %rdi
callq 0xf036
movups 0xc8(%rbx), %xmm0
movups %xmm0, 0xb8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_is_hdr
STBIDEF int      stbi_is_hdr          (char const *filename)
{
   FILE *f = stbi__fopen(filename, "rb");
   int result=0;
   if (f) {
      result = stbi_is_hdr_from_file(f);
      fclose(f);
   }
   return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0xd907(%rip), %rsi      # 0x10900
callq 0x21b0
testq %rax, %rax
je 0x301c
movq %rax, %rbx
movq %rax, %rdi
callq 0x3025
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2160
movl %ebp, %eax
jmp 0x301e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_is_hdr_from_file
STBIDEF int stbi_is_hdr_from_file(FILE *f)
{
   #ifndef STBI_NO_HDR
   long pos = ftell(f);
   int res;
   stbi__context s;
   stbi__start_file(&s,f);
   res = stbi__hdr_test(&s);
   fseek(f, pos, SEEK_SET);
   return res;
   #else
   STBI_NOTUSED(f);
   return 0;
   #endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
callq 0x2030
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2532
movq %r15, %rdi
callq 0x2fa9
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21a0
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_zlib_decode_malloc_guesssize
STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(initial_size);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer + len;
   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %rdi
callq 0x21f0
testq %rax, %rax
je 0x3143
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movslq %r15d, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
pushq $0x1
popq %rcx
movq %rax, %rsi
movl %ebp, %edx
movl %ecx, %r8d
callq 0x315a
testl %eax, %eax
je 0x3139
testq %rbx, %rbx
je 0x3153
movl 0x20(%rsp), %ecx
movq 0x28(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x3145
movq 0x28(%rsp), %rdi
callq 0x21c0
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rsp), %rax
jmp 0x3145
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_zlib_decode_malloc_guesssize_headerflag
STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(initial_size);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer + len;
   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %r8d, %ebp
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
movslq %edx, %rdi
callq 0x21f0
testq %rax, %rax
je 0x376b
movq %rsp, %rdi
movq %r15, (%rdi)
movslq %r12d, %rcx
addq %r15, %rcx
movq %rcx, 0x8(%rdi)
pushq $0x1
popq %rcx
movq %rax, %rsi
movl %r14d, %edx
movl %ebp, %r8d
callq 0x315a
testl %eax, %eax
je 0x3761
testq %rbx, %rbx
je 0x377d
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x376d
movq 0x20(%rsp), %rdi
callq 0x21c0
xorl %eax, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rax
jmp 0x376d
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_zlib_decode_noheader_malloc
STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(16384);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer+len;
   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x4000, %edi           # imm = 0x4000
callq 0x21f0
testq %rax, %rax
je 0x3836
movq %rsp, %rdi
movq %r14, (%rdi)
movslq %ebp, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
pushq $0x1
popq %rcx
movq %rax, %rsi
movl $0x4000, %edx           # imm = 0x4000
xorl %r8d, %r8d
callq 0x315a
testl %eax, %eax
je 0x382c
testq %rbx, %rbx
je 0x3844
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x3838
movq 0x20(%rsp), %rdi
callq 0x21c0
xorl %eax, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
movq 0x20(%rsp), %rax
jmp 0x3838
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_info
STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
{
    FILE *f = stbi__fopen(filename, "rb");
    int result;
    if (!f) return stbi__err("can't fopen", "Unable to open file");
    result = stbi_info_from_file(f, x, y, comp);
    fclose(f);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0xd045(%rip), %rsi      # 0x10900
callq 0x21b0
testq %rax, %rax
je 0x38e7
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3903
movl %eax, %ebx
movq %r12, %rdi
callq 0x2160
movl %ebx, %eax
jmp 0x38f7
leaq 0xd015(%rip), %rax      # 0x10903
movq %rax, 0x11923(%rip)     # 0x15218
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_info_from_file
STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
{
   int r;
   stbi__context s;
   long pos = ftell(f);
   stbi__start_file(&s, f);
   r = stbi__info_main(&s,x,y,comp);
   fseek(f,pos,SEEK_SET);
   return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2030
movq %rax, %r13
movq %rsp, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2532
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x396a
movl %eax, %ebx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x21a0
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq