LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: readBitsW(unsigned char, unsigned char, unsigned char, unsigned char, unsigned short*)
int8_t readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data) {
    // 1101011001101001 read byte
    // fedcba9876543210 bit numbers
    //    xxx           args: bitStart=12, length=3
    //    010           masked
    //           -> 010 shifted
    uint8_t count;
    uint16_t w;
    if ((count = readWord(devAddr, regAddr, &w)) != 0) {
        uint16_t mask = ((1 << length) - 1) << (bitStart - length + 1);
        w &= mask;
        w >>= (bitStart - length + 1);
        *data = w;
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movb %dil, %sil
movb %sil, -0x1(%rbp)
movb %dl, -0x2(%rbp)
movb %cl, -0x3(%rbp)
movb %al, -0x4(%rbp)
movq %r8, -0x10(%rbp)
movb -0x1(%rbp), %al
leaq -0x14(%rbp), %rdx
movzbl %al, %edi
movzbl -0x2(%rbp), %esi
callq 0x6c70
movb %al, -0x11(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
je 0x6de2
movzbl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movzbl -0x3(%rbp), %ecx
movzbl -0x4(%rbp), %edx
subl %edx, %ecx
addl $0x1, %ecx
shll %cl, %eax
movw %ax, -0x16(%rbp)
movzwl -0x16(%rbp), %ecx
movzwl -0x14(%rbp), %eax
andl %ecx, %eax
movw %ax, -0x14(%rbp)
movzbl -0x3(%rbp), %ecx
movzbl -0x4(%rbp), %eax
subl %eax, %ecx
addl $0x1, %ecx
movzwl -0x14(%rbp), %eax
sarl %cl, %eax
movw %ax, -0x14(%rbp)
movw -0x14(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movb -0x11(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %dl
movb %dil, %sil
movb %sil, -0x1(%rbp)
movb %dl, -0x2(%rbp)
movb %al, -0x3(%rbp)
movq %rcx, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq 0x22a6(%rip), %rdi      # 0x929f
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movw $0x0, (%rax)
movb -0x11(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movb %dil, %sil
movb %sil, -0x1(%rbp)
movb %dl, -0x2(%rbp)
movb %cl, -0x3(%rbp)
movb %al, -0x4(%rbp)
movb -0x1(%rbp), %al
leaq -0x5(%rbp), %rdx
movzbl %al, %edi
movzbl -0x2(%rbp), %esi
callq 0x6bd0
movzbl -0x4(%rbp), %eax
cmpl $0x0, %eax
je 0x7073
movzbl -0x5(%rbp), %eax
movzbl -0x3(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x708c
movzbl -0x5(%rbp), %eax
movzbl -0x3(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0x5(%rbp)
movb -0x1(%rbp), %cl
movb -0x2(%rbp), %al
movzbl %cl, %edi
movzbl %al, %esi
movzbl -0x5(%rbp), %edx
callq 0x70b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movw %cx, %ax
movb %dl, %cl
movb %sil, %dl
movb %dil, %sil
movb %sil, -0x1(%rbp)
movb %dl, -0x2(%rbp)
movb %cl, -0x3(%rbp)
movw %ax, -0x6(%rbp)
movb -0x1(%rbp), %al
leaq -0x8(%rbp), %rdx
movzbl %al, %edi
movzbl -0x2(%rbp), %esi
callq 0x6c70
movzwl -0x6(%rbp), %eax
cmpl $0x0, %eax
je 0x7145
movzwl -0x8(%rbp), %eax
movzbl -0x3(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x715e
movzwl -0x8(%rbp), %eax
movzbl -0x3(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movw %ax, -0x8(%rbp)
movb -0x1(%rbp), %cl
movb -0x2(%rbp), %al
movzbl %cl, %edi
movzbl %al, %esi
movzwl -0x8(%rbp), %edx
callq 0x7180
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %r8b, %al
movb %dil, -0x5(%rbp)
movb %sil, -0x6(%rbp)
movb %dl, -0x7(%rbp)
movb %cl, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb -0x5(%rbp), %al
leaq -0xa(%rbp), %rdx
movzbl %al, %edi
movzbl -0x6(%rbp), %esi
callq 0x6bd0
movsbl %al, %eax
cmpl $0x0, %eax
je 0x7271
movzbl -0x8(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movzbl -0x7(%rbp), %ecx
movzbl -0x8(%rbp), %edx
subl %edx, %ecx
addl $0x1, %ecx
shll %cl, %eax
movb %al, -0xb(%rbp)
movzbl -0x7(%rbp), %ecx
movzbl -0x8(%rbp), %eax
subl %eax, %ecx
addl $0x1, %ecx
movzbl -0x9(%rbp), %eax
shll %cl, %eax
movb %al, -0x9(%rbp)
movzbl -0xb(%rbp), %ecx
movzbl -0x9(%rbp), %eax
andl %ecx, %eax
movb %al, -0x9(%rbp)
movzbl -0xb(%rbp), %ecx
xorl $-0x1, %ecx
movzbl -0xa(%rbp), %eax
andl %ecx, %eax
movb %al, -0xa(%rbp)
movzbl -0x9(%rbp), %ecx
movzbl -0xa(%rbp), %eax
orl %ecx, %eax
movb %al, -0xa(%rbp)
movb -0x5(%rbp), %cl
movb -0x6(%rbp), %al
movzbl %cl, %edi
movzbl %al, %esi
movzbl -0xa(%rbp), %edx
callq 0x70b0
movl %eax, -0x4(%rbp)
jmp 0x7278
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: writeBitsW(unsigned char, unsigned char, unsigned char, unsigned char, unsigned short)
int writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data) {
    //              010 value to write
    // fedcba9876543210 bit numbers
    //    xxx           args: bitStart=12, length=3
    // 0001110000000000 mask byte
    // 1010111110010110 original value (sample)
    // 1010001110010110 original & ~mask
    // 1010101110010110 masked | value
    uint16_t w;
    if (readWord(devAddr, regAddr, &w) != 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
        w &= ~(mask); // zero all important bits in existing word
        w |= data; // combine data with existing word
        return writeWord(devAddr, regAddr, w);
    } else {
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %r8w, %ax
movb %dil, -0x5(%rbp)
movb %sil, -0x6(%rbp)
movb %dl, -0x7(%rbp)
movb %cl, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movb -0x5(%rbp), %al
leaq -0xc(%rbp), %rdx
movzbl %al, %edi
movzbl -0x6(%rbp), %esi
callq 0x6c70
movsbl %al, %eax
cmpl $0x0, %eax
je 0x7347
movzbl -0x8(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movzbl -0x7(%rbp), %ecx
movzbl -0x8(%rbp), %edx
subl %edx, %ecx
addl $0x1, %ecx
shll %cl, %eax
movb %al, -0xd(%rbp)
movzbl -0x7(%rbp), %ecx
movzbl -0x8(%rbp), %eax
subl %eax, %ecx
addl $0x1, %ecx
movzwl -0xa(%rbp), %eax
shll %cl, %eax
movw %ax, -0xa(%rbp)
movzbl -0xd(%rbp), %ecx
movzwl -0xa(%rbp), %eax
andl %ecx, %eax
movw %ax, -0xa(%rbp)
movzbl -0xd(%rbp), %ecx
xorl $-0x1, %ecx
movzwl -0xc(%rbp), %eax
andl %ecx, %eax
movw %ax, -0xc(%rbp)
movzwl -0xa(%rbp), %ecx
movzwl -0xc(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xc(%rbp)
movb -0x5(%rbp), %cl
movb -0x6(%rbp), %al
movzbl %cl, %edi
movzbl %al, %esi
movzwl -0xc(%rbp), %edx
callq 0x7180
movl %eax, -0x4(%rbp)
jmp 0x734e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x10d0
movl %eax, 0x3dd2(%rip)      # 0x51c0
callq 0x12a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1412
leaq 0x1c29(%rip), %rdi      # 0x302c
callq 0x1230
movl $0x1, %edi
callq 0x1280
cmpl $0x0, -0x14(%rbp)
jne 0x1469
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x1140
leaq 0x6e(%rip), %rax        # 0x14a0
movq %rax, -0xb0(%rbp)
movl $0x10000000, -0x28(%rbp) # imm = 0x10000000
movl $0xe, %edi
leaq -0xb0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10a0
movl $0x1, %edi
callq 0x1150
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl -0x14(%rbp), %edx
movl 0x7d5e(%rip), %eax      # 0x91d0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x7d53(%rip)      # 0x91d0
movslq %eax, %rcx
leaq 0x3d49(%rip), %rax      # 0x51d0
movl %edx, (%rax,%rcx,4)
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
callq 0x10d0
movl %eax, 0x3cc6(%rip)      # 0x51c0
callq 0x12a0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x151e
leaq 0x1b1d(%rip), %rdi      # 0x302c
callq 0x1230
movl $0x1, %edi
callq 0x1280
cmpl $0x0, -0xc(%rbp)
jne 0x1574
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x1140
leaq -0x9e(%rip), %rax       # 0x14a0
movq %rax, -0xa8(%rbp)
movl $0x10000000, -0x20(%rbp) # imm = 0x10000000
movl $0xe, %edi
leaq -0xa8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10a0
movl $0x1, %edi
callq 0x1150
movq -0x8(%rbp), %rdi
callq 0x15a0
movl -0xc(%rbp), %edx
movl 0x7c53(%rip), %eax      # 0x91d0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x7c48(%rip)      # 0x91d0
movslq %eax, %rcx
leaq 0x3c3e(%rip), %rax      # 0x51d0
movl %edx, (%rax,%rcx,4)
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/main.c
// Function: kill_tasks
static void kill_tasks(void)
{
	int i;

	for (i = 0; i < nr_pids; i++)
		kill(pids[i], SIGTERM);
	for (i = 0; i < nr_pids; i++)
		waitpid(pids[i], NULL, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x71f8(%rip), %eax      # 0x91d0
jge 0x1ffd
movslq -0x4(%rbp), %rcx
leaq 0x31eb(%rip), %rax      # 0x51d0
movl (%rax,%rcx,4), %edi
movl $0xf, %esi
callq 0x11a0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1fcf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x71c3(%rip), %eax      # 0x91d0
jge 0x2033
movslq -0x4(%rbp), %rcx
leaq 0x31b6(%rip), %rax      # 0x51d0
movl (%rax,%rcx,4), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1210
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2004
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3076(%rip), %rdi      # 0x5190
movl $0x2, %esi
movb $0x0, %al
callq 0x1220
movl %eax, -0x1014(%rbp)
cmpl $0x0, -0x1014(%rbp)
jl 0x2137
jmp 0x2156
leaq 0x113d(%rip), %rdi      # 0x327b
leaq 0x113e(%rip), %rsi      # 0x3283
movl $0x1d, %edx
leaq 0x1195(%rip), %rcx      # 0x32e6
callq 0x1130
jmp 0x2158
movl -0x1014(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1120
movl -0x1014(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x10c0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x218a
jmp 0x21a9
leaq 0x1188(%rip), %rdi      # 0x3319
leaq 0x10eb(%rip), %rsi      # 0x3283
movl $0x21, %edx
leaq 0x1142(%rip), %rcx      # 0x32e6
callq 0x1130
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2158
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jle 0x11bf
movq 0x2e65(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0xe58(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
jmp 0x1251
cmpl $0x2, -0x8(%rbp)
jge 0x11ed
movq 0x2e2c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe3f(%rip), %rsi       # 0x201c
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
jmp 0x1251
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
cmpl $-0x1, %eax
jne 0x1246
movq 0x2df2(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x1060
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq %rax, %rcx
leaq 0xdfb(%rip), %rsi       # 0x2031
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
jmp 0x1251
jmp 0x1248
jmp 0x124a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x235b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x6db5(%rip)      # 0x9110
leaq 0x8e(%rip), %rax        # 0x23f0
movq %rax, 0x7177(%rip)      # 0x94e0
leaq 0x3b0(%rip), %rax       # 0x2720
movq %rax, 0x7171(%rip)      # 0x94e8
leaq 0x402(%rip), %rax       # 0x2780
movq %rax, 0x716b(%rip)      # 0x94f0
leaq 0x494(%rip), %rax       # 0x2820
movq %rax, 0x7175(%rip)      # 0x9508
leaq 0x4c6(%rip), %rax       # 0x2860
movq %rax, 0x718f(%rip)      # 0x9530
leaq 0x528(%rip), %rax       # 0x28d0
movq %rax, 0x7191(%rip)      # 0x9540
leaq 0x58a(%rip), %rax       # 0x2940
movq %rax, 0x7193(%rip)      # 0x9550
leaq 0x86c(%rip), %rax       # 0x2c30
movq %rax, 0x718d(%rip)      # 0x9558
leaq 0xa8e(%rip), %rax       # 0x2e60
movq %rax, 0x7187(%rip)      # 0x9560
leaq 0x7100(%rip), %rdi      # 0x94e0
callq 0x51d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed.c
// Function: xmlattrend
static void
xmlattrend(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 */
	xmldata(p, "\"", 1);
	ctx.attrcount = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, 0x9721(%rip)      # 0xbe64
je 0x2757
cmpl $0x0, 0x971c(%rip)      # 0xbe68
jne 0x2757
cmpl $0x2, 0x9717(%rip)      # 0xbe6c
je 0x2759
jmp 0x2778
movq -0x8(%rbp), %rdi
leaq 0x4907(%rip), %rsi      # 0x706b
movl $0x1, %edx
callq 0x2860
movl $0x0, 0x96fc(%rip)      # 0xbe74
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, 0x96c1(%rip)      # 0xbe64
je 0x27b7
cmpl $0x0, 0x96bc(%rip)      # 0xbe68
jne 0x27b7
cmpl $0x2, 0x96b7(%rip)      # 0xbe6c
je 0x27b9
jmp 0x280c
cmpl $0x0, 0x96b4(%rip)      # 0xbe74
jne 0x27d7
movq -0x8(%rbp), %rdi
leaq 0x489b(%rip), %rsi      # 0x7068
movl $0x1, %edx
callq 0x2860
movl 0x9697(%rip), %eax      # 0xbe74
addl $0x1, %eax
movl %eax, 0x968e(%rip)      # 0xbe74
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2860
movq -0x8(%rbp), %rdi
leaq 0x4868(%rip), %rsi      # 0x706a
movl $0x2, %edx
callq 0x2860
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed.c
// Function: xmldata
static void
xmldata(XMLParser *p, const char *s, size_t len)
{
	if (!ctx.field)
		return;

	/* add only data from <name> inside <author> tag
	 * or any other non-<author> tag */
	if (ctx.tagid != AtomTagAuthor || istag(p->tag, p->taglen, STRP("name")))
		string_append(ctx.field, s, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x94fc(%rip)      # 0xbd78
jne 0x2880
jmp 0x28c9
cmpl $0x16, 0x95d9(%rip)     # 0xbe60
jne 0x28b5
movq -0x8(%rbp), %rdi
addq $0x88, %rdi
movq -0x8(%rbp), %rax
movq 0x488(%rax), %rsi
leaq 0x47c7(%rip), %rdx      # 0x706d
movl $0x4, %ecx
callq 0x3070
cmpl $0x0, %eax
je 0x28c9
movq 0x94bc(%rip), %rdi      # 0xbd78
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2f50
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x948c(%rip)      # 0xbd78
jne 0x28f0
jmp 0x2932
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x10, %edx
callq 0x4fd0
cltq
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jle 0x2921
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x2860
jmp 0x2932
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2860
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, 0x8fea(%rip)      # 0xbe68
je 0x2e96
movl $0x1, 0x8fda(%rip)      # 0xbe64
movl $0x0, 0x8fd4(%rip)      # 0xbe68
jmp 0x2ef9
cmpl $0x13, 0x8fc3(%rip)     # 0xbe60
jne 0x2eaa
movq $0x0, 0x8ece(%rip) # 0xbd78
cmpl $0x0, 0x8fb3(%rip)      # 0xbe64
je 0x2ec5
cmpl $0x0, 0x8fae(%rip)      # 0xbe68
jne 0x2ec5
cmpl $0x2, 0x8fa9(%rip)      # 0xbe6c
je 0x2ec7
jmp 0x2ef9
cmpl $0x0, -0x1c(%rbp)
je 0x2ee4
movq -0x8(%rbp), %rdi
leaq 0x42aa(%rip), %rsi      # 0x7182
movl $0x2, %edx
callq 0x2860
jmp 0x2ef9
movq -0x8(%rbp), %rdi
leaq 0x4294(%rip), %rsi      # 0x7183
movl $0x1, %edx
callq 0x2860
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2f6d
jmp 0x2fdb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2f9c
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x2ff0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2170
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed.c
// Function: string_buffer_realloc
static void
string_buffer_realloc(String *s, size_t newlen)
{
	size_t alloclen;

	for (alloclen = 64; alloclen <= newlen; alloclen *= 2)
		;
	if (!(s->data = realloc(s->data, alloclen)))
		err(1, "realloc");
	s->bufsiz = alloclen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x40, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x3021
jmp 0x3014
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
jmp 0x3008
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21b0
movq -0x8(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x3051
movl $0x1, %edi
leaq 0x4016(%rip), %rsi      # 0x7060
movb $0x0, %al
callq 0x2190
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0x1, %eax
je 0x30fa
jmp 0x30f0
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x3121
jmp 0x3148
leaq -0x30(%rbp), %rdi
leaq 0x607b(%rip), %rsi      # 0x9180
movl $0xb, %edx
movl $0x18, %ecx
leaq -0xe16(%rip), %r8       # 0x2300
callq 0x21e0
movq %rax, -0x38(%rbp)
jmp 0x314a
leaq -0x30(%rbp), %rdi
leaq 0x6164(%rip), %rsi      # 0x9290
movl $0x9, %edx
movl $0x18, %ecx
leaq -0xe3d(%rip), %r8       # 0x2300
callq 0x21e0
movq %rax, -0x38(%rbp)
jmp 0x314a
jmp 0x314a
cmpq $0x0, -0x38(%rbp)
je 0x315d
movq -0x38(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x40(%rbp)
jmp 0x3164
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0x3164
movl -0x40(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed.c
// Function: printfields
static void
printfields(void)
{
	string_print_timestamp(&ctx.fields[FeedFieldTime].str);
	putchar(FieldSeparator);
	string_print_trimmed(&ctx.fields[FeedFieldTitle].str);
	putchar(FieldSeparator);
	string_print_uri(&ctx.fields[FeedFieldLink].str);
	putchar(FieldSeparator);
	string_print_encoded(&ctx.fields[FeedFieldContent].str);
	putchar(FieldSeparator);
	fputs(contenttypes[ctx.contenttype], stdout);
	putchar(FieldSeparator);
	string_print_trimmed(&ctx.fields[FeedFieldId].str);
	putchar(FieldSeparator);
	string_print_trimmed(&ctx.fields[FeedFieldAuthor].str);
	putchar(FieldSeparator);
	string_print_uri(&ctx.fields[FeedFieldEnclosure].str);
	putchar('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x8bcd(%rip), %rdi      # 0xbd78
addq $0x8, %rdi
callq 0x32b0
movl $0x9, %edi
callq 0x2030
leaq 0x8bb3(%rip), %rdi      # 0xbd78
addq $0x8, %rdi
addq $0x20, %rdi
callq 0x3300
movl $0x9, %edi
callq 0x2030
leaq 0x8b95(%rip), %rdi      # 0xbd78
addq $0x8, %rdi
addq $0x40, %rdi
callq 0x33e0
movl $0x9, %edi
callq 0x2030
leaq 0x8b77(%rip), %rdi      # 0xbd78
addq $0x8, %rdi
addq $0x60, %rdi
callq 0x34a0
movl $0x9, %edi
callq 0x2030
movl 0x8c4e(%rip), %eax      # 0xbe6c
movl %eax, %ecx
leaq 0x6149(%rip), %rax      # 0x9370
movq (%rax,%rcx,8), %rdi
movq 0x5dae(%rip), %rax      # 0x8fe0
movq (%rax), %rsi
callq 0x20c0
movl $0x9, %edi
callq 0x2030
leaq 0x8b2d(%rip), %rdi      # 0xbd78
addq $0x8, %rdi
addq $0x80, %rdi
callq 0x3300
movl $0x9, %edi
callq 0x2030
leaq 0x8b0c(%rip), %rdi      # 0xbd78
addq $0x8, %rdi
addq $0xa0, %rdi
callq 0x3300
movl $0x9, %edi
callq 0x2030
leaq 0x8aeb(%rip), %rdi      # 0xbd78
addq $0x8, %rdi
addq $0xc0, %rdi
callq 0x33e0
movl $0xa, %edi
callq 0x2030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed.c
// Function: string_print_timestamp
void
string_print_timestamp(String *s)
{
	time_t t;

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

	if (parsetime(s->data, &t) != -1)
		printf("%lld", (long long)t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x32d1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x32d3
jmp 0x32fa
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0x35c0
cmpl $-0x1, %eax
je 0x32fa
movq -0x10(%rbp), %rsi
leaq 0x3dfe(%rip), %rdi      # 0x70f1
movb $0x0, %al
callq 0x2090
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3321
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3326
jmp 0x33d6
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x41e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4250
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x3362
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x336b
jmp 0x33d6
callq 0x21f0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x3397
movl $0x20, %edi
callq 0x2030
jmp 0x33c3
callq 0x21f0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x33c1
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2030
jmp 0x33c3
jmp 0x33c5
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3343
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3404
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3409
jmp 0x3494
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x41e0
movq %rax, -0x1018(%rbp)
movq -0x1018(%rbp), %rdi
callq 0x4250
movq %rax, -0x1020(%rbp)
movq -0x1020(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1024(%rbp)
movq -0x1020(%rbp), %rax
movb $0x0, (%rax)
leaq -0x1010(%rbp), %rdi
movq -0x1018(%rbp), %rdx
movq 0x5cb2(%rip), %rcx      # 0x9110
movl $0x1000, %esi           # imm = 0x1000
callq 0x4720
cmpl $-0x1, %eax
je 0x3483
leaq -0x1010(%rbp), %rdi
movq 0x5b65(%rip), %rax      # 0x8fe0
movq (%rax), %rsi
callq 0x20c0
movl -0x1024(%rbp), %eax
movb %al, %cl
movq -0x1020(%rbp), %rax
movb %cl, (%rax)
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed.c
// Function: string_print_encoded
static void
string_print_encoded(String *s)
{
	const char *p, *e;

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

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

	for (; *p && p != e; p++) {
		switch (*p) {
		case '\n': fputs("\\n",  stdout); break;
		case '\\': fputs("\\\\", stdout); break;
		case '\t': fputs("\\t",  stdout); break;
		default:
			/* ignore control chars */
			if (!iscntrl((unsigned char)*p))
				putchar(*p);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x34c1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x34c6
jmp 0x35ba
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x41e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4250
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x3502
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x350e
jmp 0x35ba
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x9, %eax
je 0x3563
jmp 0x351f
movl -0x20(%rbp), %eax
subl $0xa, %eax
je 0x3533
jmp 0x3529
movl -0x20(%rbp), %eax
subl $0x5c, %eax
je 0x354b
jmp 0x357b
movq 0x5aa6(%rip), %rax      # 0x8fe0
movq (%rax), %rsi
leaq 0x3c33(%rip), %rdi      # 0x7177
callq 0x20c0
jmp 0x35a7
movq 0x5a8e(%rip), %rax      # 0x8fe0
movq (%rax), %rsi
leaq 0x3c1e(%rip), %rdi      # 0x717a
callq 0x20c0
jmp 0x35a7
movq 0x5a76(%rip), %rax      # 0x8fe0
movq (%rax), %rsi
leaq 0x3c09(%rip), %rdi      # 0x717d
callq 0x20c0
jmp 0x35a7
callq 0x21f0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x35a5
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2030
jmp 0x35a7
jmp 0x35a9
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x34e3
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x26, %eax
je 0x4ff9
movl $0x0, -0x4(%rbp)
jmp 0x5038
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x23, %eax
jne 0x5020
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5050
movl %eax, -0x4(%rbp)
jmp 0x5038
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5120
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/dxwc[P]sfeed/xml.c
// Function: numericentitytostr
static int
numericentitytostr(const char *e, char *buf, size_t bufsiz)
{
	long l;
	int len;
	char *end;

	/* buffer is too small */
	if (bufsiz < 5)
		return -1;

	errno = 0;
	/* hex (16) or decimal (10) */
	if (*e == 'x')
		l = strtoul(e + 1, &end, 16);
	else
		l = strtoul(e, &end, 10);
	/* invalid value or not a well-formed entity or too high codepoint */
	if (errno || *end != ';' || l > 0x10FFFF)
		return 0;
	len = codepointtoutf8(l, buf);
	buf[len] = '\0';

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x5, -0x20(%rbp)
jae 0x5077
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x510b
callq 0x2050
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x78, %eax
jne 0x50aa
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
leaq -0x38(%rbp), %rsi
movl $0x10, %edx
callq 0x21c0
movq %rax, -0x28(%rbp)
jmp 0x50c0
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0xa, %edx
callq 0x21c0
movq %rax, -0x28(%rbp)
callq 0x2050
cmpl $0x0, (%rax)
jne 0x50e0
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x50e0
cmpq $0x10ffff, -0x28(%rbp)  # imm = 0x10FFFF
jle 0x50e9
movl $0x0, -0x4(%rbp)
jmp 0x510b
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6280
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x2c(%rbp), %eax
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/dxwc[P]sfeed/xml.c
// Function: namedentitytostr
static int
namedentitytostr(const char *e, char *buf, size_t bufsiz)
{
	static const struct {
		const char *entity;
		int c;
	} entities[] = {
		{ "amp;",  '&'  },
		{ "lt;",   '<'  },
		{ "gt;",   '>'  },
		{ "apos;", '\'' },
		{ "quot;", '"'  },
		{ "AMP;",  '&'  },
		{ "LT;",   '<'  },
		{ "GT;",   '>'  },
		{ "APOS;", '\'' },
		{ "QUOT;", '"'  }
	};
	size_t i;

	/* buffer is too small */
	if (bufsiz < 2)
		return -1;

	for (i = 0; i < sizeof(entities) / sizeof(*entities); i++) {
		if (!strcmp(e, entities[i].entity)) {
			buf[0] = entities[i].c;
			buf[1] = '\0';
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x2, -0x20(%rbp)
jae 0x5144
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x51bb
movq $0x0, -0x28(%rbp)
cmpq $0xa, -0x28(%rbp)
jae 0x51b4
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rcx
leaq 0x3bee(%rip), %rax      # 0x8d50
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x2120
cmpl $0x0, %eax
jne 0x51a4
movq -0x28(%rbp), %rcx
leaq 0x3bcf(%rip), %rax      # 0x8d50
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x51bb
jmp 0x51a6
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x514c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/xml.c
// Function: codepointtoutf8
static int
codepointtoutf8(long r, char *s)
{
	if (r == 0) {
		return 0; /* NUL byte */
	} else if (r <= 0x7F) {
		/* 1 byte: 0aaaaaaa */
		s[0] = r;
		return 1;
	} else if (r <= 0x07FF) {
		/* 2 bytes: 00000aaa aabbbbbb */
		s[0] = 0xC0 | ((r & 0x0007C0) >>  6); /* 110aaaaa */
		s[1] = 0x80 |  (r & 0x00003F);        /* 10bbbbbb */
		return 2;
	} else if (r <= 0xFFFF) {
		/* 3 bytes: aaaabbbb bbcccccc */
		s[0] = 0xE0 | ((r & 0x00F000) >> 12); /* 1110aaaa */
		s[1] = 0x80 | ((r & 0x000FC0) >>  6); /* 10bbbbbb */
		s[2] = 0x80 |  (r & 0x00003F);        /* 10cccccc */
		return 3;
	} else {
		/* 4 bytes: 000aaabb bbbbcccc ccdddddd */
		s[0] = 0xF0 | ((r & 0x1C0000) >> 18); /* 11110aaa */
		s[1] = 0x80 | ((r & 0x03F000) >> 12); /* 10bbbbbb */
		s[2] = 0x80 | ((r & 0x000FC0) >>  6); /* 10cccccc */
		s[3] = 0x80 |  (r & 0x00003F);        /* 10dddddd */
		return 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x629f
movl $0x0, -0x4(%rbp)
jmp 0x63de
cmpq $0x7f, -0x10(%rbp)
jg 0x62be
movq -0x10(%rbp), %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x63de
cmpq $0x7ff, -0x10(%rbp)     # imm = 0x7FF
jg 0x6307
movq -0x10(%rbp), %rax
andq $0x7c0, %rax            # imm = 0x7C0
sarq $0x6, %rax
orq $0xc0, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x63de
cmpq $0xffff, -0x10(%rbp)    # imm = 0xFFFF
jg 0x636a
movq -0x10(%rbp), %rax
andq $0xf000, %rax           # imm = 0xF000
sarq $0xc, %rax
orq $0xe0, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
andq $0xfc0, %rax            # imm = 0xFC0
sarq $0x6, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movl $0x3, -0x4(%rbp)
jmp 0x63de
movq -0x10(%rbp), %rax
andq $0x1c0000, %rax         # imm = 0x1C0000
sarq $0x12, %rax
orq $0xf0, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
andq $0x3f000, %rax          # imm = 0x3F000
sarq $0xc, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
andq $0xfc0, %rax            # imm = 0xFC0
sarq $0x6, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1e189(%rip), %rsi     # 0x20770
callq 0x2650
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2614
leaq 0x1e175(%rip), %rdi     # 0x20773
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x2642
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x26a0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2200
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x2730
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
leaq -0x108(%rbp), %rdi
callq 0x2760
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x2718
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movslq %eax, %rsi
movl $0x1, %edx
callq 0x2280
movq -0x30(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq -0x38(%rbp), %r9
movl $0x8, (%rsp)
callq 0x8490
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x27b8
movq $0x0, -0x8(%rbp)
jmp 0x2880
cmpl $0x8, -0x38(%rbp)
je 0x2833
cmpl $0x10, -0x38(%rbp)
jne 0x27c6
jmp 0x27e5
leaq 0x1dfef(%rip), %rdi     # 0x207bc
leaq 0x1e002(%rip), %rsi     # 0x207d6
movl $0x468, %edx            # imm = 0x468
leaq 0x1e004(%rip), %rcx     # 0x207e4
callq 0x2140
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x2810
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x2816
movl -0x2c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x48(%rbp), %edx
movl -0x4c(%rbp), %esi
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %ecx
callq 0x8730
movq %rax, -0x40(%rbp)
movl $0x8, -0x38(%rbp)
cmpl $0x0, 0x23b06(%rip)     # 0x26340
je 0x2878
cmpl $0x0, -0x2c(%rbp)
je 0x284a
movl -0x2c(%rbp), %eax
movl %eax, -0x60(%rbp)
jmp 0x2853
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
movslq -0x44(%rbp), %rax
shlq $0x0, %rax
movl %eax, %ecx
callq 0x87e0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq -0x38(%rbp), %r9
movl $0x10, (%rsp)
callq 0x8490
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x2978
movq $0x0, -0x8(%rbp)
jmp 0x2a3f
cmpl $0x10, -0x38(%rbp)
je 0x29f3
cmpl $0x8, -0x38(%rbp)
jne 0x2986
jmp 0x29a5
leaq 0x1e760(%rip), %rdi     # 0x210ed
leaq 0x1de42(%rip), %rsi     # 0x207d6
movl $0x480, %edx            # imm = 0x480
leaq 0x1e766(%rip), %rcx     # 0x21106
callq 0x2140
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x29d0
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x29d6
movl -0x2c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x48(%rbp), %edx
movl -0x4c(%rbp), %esi
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %ecx
callq 0x1cf10
movq %rax, -0x40(%rbp)
movl $0x10, -0x38(%rbp)
cmpl $0x0, 0x23946(%rip)     # 0x26340
je 0x2a37
cmpl $0x0, -0x2c(%rbp)
je 0x2a0a
movl -0x2c(%rbp), %eax
movl %eax, -0x60(%rbp)
jmp 0x2a13
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
movslq -0x44(%rbp), %rax
shlq %rax
movl %eax, %ecx
callq 0x87e0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)