LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nerves-project[P]nerves_initramfs/tests/fixture/init_fixture.c
// Function: fixup_path
static int fixup_path(const char *input, char *output)
{
    // All paths from init should be absolute
    if (input[0] != '/')
        errx(EXIT_FAILURE, "Non-absolute path detected: \"%s\"", input);

    // Prepend the working directory to the path
    sprintf(output, "%s%s%s", work, remounted_root ? "/mnt" : "", input);

    return 0;
}

// Assembly:
movq %rdi, %r8
cmpb $0x2f, (%rdi)
jne 0x234b
leaq 0x20de(%rip), %rax      # 0x43fc
leaq 0x1f4a(%rip), %rcx      # 0x426f
cmpb $0x0, 0x4d7c(%rip)      # 0x70a8
cmovneq %rax, %rcx
movq 0x4d69(%rip), %rdx      # 0x70a0
leaq 0x20b7(%rip), %rax      # 0x43f5
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
jmp 0x20e0
pushq %rax
leaq 0x2081(%rip), %rsi      # 0x43d4
pushq $0x1
popq %rdi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/crc32/main.c
// Function: perftest
static int
perftest(void)
{

	/* Inform user. */
	print_hardware("CRC32C time trial");
	printf("Hashing %zu bytes.\n", nbytes_perftest);
	fflush(stdout);

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 1, perftest_init, perftest_func, NULL, NULL)) {
		warn0("perftest_buffers");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x20a3(%rip), %rdi      # 0x34f3
leaq 0x1bb3(%rip), %rsi      # 0x300a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10f0
leaq 0x5d89(%rip), %r15      # 0x71f0
leaq 0x1cf5(%rip), %r14      # 0x3163
cmpl $0x0, (%r15)
jne 0x149f
leaq 0x5d79(%rip), %r12      # 0x71f4
cmpl $0x0, (%r12)
je 0x148b
leaq 0x1cc3(%rip), %r14      # 0x314c
jmp 0x149f
callq 0x1c1c
movl %eax, (%r15)
movl $0x1, (%r12)
testl %eax, %eax
je 0x1482
movq %r14, %rdi
callq 0x10b0
leaq 0x1b6e(%rip), %rdi      # 0x301c
movl $0x20000000, %esi       # imm = 0x20000000
xorl %eax, %eax
callq 0x10f0
movq 0x4b17(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
callq 0x1190
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
leaq 0x2e7(%rip), %rax       # 0x17bf
movq %rax, (%rsp)
leaq 0x1cad(%rip), %rsi      # 0x3190
leaq 0x2c6(%rip), %r9        # 0x17b0
pushq $0xb
popq %rdx
pushq $0x1
popq %rbp
movl $0x20000000, %edi       # imm = 0x20000000
movl $0x7d00000, %ecx        # imm = 0x7D00000
movl %ebp, %r8d
callq 0x24f0
testl %eax, %eax
je 0x151e
leaq 0x1b23(%rip), %rdi      # 0x3030
xorl %eax, %eax
callq 0x2ac8
callq 0x1080
andl $0x0, (%rax)
movl %ebp, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/crc32/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	CRC32C_CTX ctx;
	uint8_t cbuf[4];
	size_t i;

	(void)cookie; /* UNUSED */

	/* Do the hashing. */
	for (i = 0; i < nreps; i++) {
		CRC32C_Init(&ctx);
		CRC32C_Update(&ctx, buf, buflen);
		CRC32C_Final(cbuf, &ctx);
	}

	/* Success! */
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8(%rsp), %r12
leaq 0xc(%rsp), %r13
subq $0x1, %rbx
jb 0x1808
movq %r12, %rdi
callq 0x1818
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a51
movq %r13, %rdi
movq %r12, %rsi
callq 0x1b19
jmp 0x17df
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/kobolt[P]curses-collection/cgame/cgame.c
// Function: draw_screen
static void draw_screen(void)
{
  int i;

  erase();

  box(stdscr, '|', '-');

  for (i = 0; i < AMOUNT_OF_MONEY; i++)
    if (! money[i].taken)
      draw_object(&money[i]);
  for (i = 0; i < AMOUNT_OF_MINES; i++)
    draw_object(&mines[i]);
  for (i = 0; i < AMOUNT_OF_CRATES; i++)
    draw_object(&crates[i]);
  draw_object(&player);
  draw_object(&enemy);

  move(player.y, player.x);

  refresh();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x291c(%rip), %rbx      # 0x3fd8
movq (%rbx), %rdi
callq 0x1050
movq (%rbx), %rdi
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
pushq $0x7c
popq %rdx
pushq $0x2d
popq %rcx
xorl %r14d, %r14d
movl %edx, %esi
movl %ecx, %r8d
xorl %r9d, %r9d
callq 0x1070
leaq 0x29fe(%rip), %r15      # 0x40f0
cmpq $0x190, %r14            # imm = 0x190
je 0x1712
cmpl $0x0, 0x10(%r14,%r15)
jne 0x170c
leaq (%r15,%r14), %rdi
callq 0x194b
addq $0x14, %r14
jmp 0x16f2
xorl %r14d, %r14d
leaq 0x2b84(%rip), %r15      # 0x42a0
cmpq $0xc8, %r14
je 0x1734
leaq (%r15,%r14), %rdi
callq 0x194b
addq $0x14, %r14
jmp 0x171c
xorl %r14d, %r14d
leaq 0x2c32(%rip), %r15      # 0x4370
cmpq $0x64, %r14
je 0x1753
leaq (%r15,%r14), %rdi
callq 0x194b
addq $0x14, %r14
jmp 0x173e
leaq 0x2976(%rip), %rdi      # 0x40d0
callq 0x194b
leaq 0x2b1e(%rip), %rdi      # 0x4284
callq 0x194b
movq (%rbx), %rdi
movl 0x295c(%rip), %esi      # 0x40d0
movl 0x295a(%rip), %edx      # 0x40d4
callq 0x1130
movq (%rbx), %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/kobolt[P]curses-collection/cgame/cgame.c
// Function: find_empty_spot
static void find_empty_spot(int *y, int *x)
{
  do {
    move((random() % (GAME_ROWS - 2)) + 1, (random() % (GAME_COLS - 2)) + 1);
  } while ((inch() & A_CHARTEXT) != ' ');
  getyx(stdscr, *y, *x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %r14
movq 0x26f7(%rip), %r12      # 0x3fd8
pushq $0x16
popq %r13
pushq $0x4e
popq %rbx
movq (%r12), %r15
callq 0x1100
cqto
idivq %r13
leal 0x1(%rdx), %ebp
callq 0x1100
cqto
idivq %rbx
incl %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x1130
movq (%r12), %rdi
callq 0x1120
cmpb $0x20, %al
jne 0x18e8
movq (%r12), %rcx
testq %rcx, %rcx
je 0x192e
movswl (%rcx), %eax
movswl 0x2(%rcx), %ecx
jmp 0x1933
pushq $-0x1
popq %rax
movl %eax, %ecx
movl %eax, (%r14)
movq (%rsp), %rax
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kobolt[P]curses-collection/cgame/cgame.c
// Function: draw_object
static void draw_object(object_t *object)
{
  if (object->attributes != 0 && has_colors())
    wattrset(stdscr, object->attributes);
  mvaddch(object->y, object->x, object->symbol);
  if (object->attributes != 0 && has_colors())
    wattrset(stdscr, A_NORMAL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
je 0x1973
callq 0x1030
testb %al, %al
je 0x1973
movq 0x2670(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movl 0xc(%rbx), %esi
callq 0x1040
movq 0x265e(%rip), %r14      # 0x3fd8
movq (%r14), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x1998
movq (%r14), %rdi
movsbl 0x8(%rbx), %esi
callq 0x1140
cmpl $0x0, 0xc(%rbx)
je 0x19b8
callq 0x1030
testb %al, %al
je 0x19b8
movq (%r14), %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/misc/mkptyfl.c
// Function: raw
int
raw(int fd)
{
	struct termios tio;
	if(tcgetattr(fd, &tio) < 0) return -1;
	tiosaved = tio;
	cfmakeraw(&tio);
	if(tcsetattr(fd, TCSAFLUSH, &tio) < 0) return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edi, %ebx
leaq -0x4c(%rbp), %rsi
callq 0x1110
testl %eax, %eax
js 0x12e3
leaq -0x4c(%rbp), %r14
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x2c(%r14), %xmm3
movups %xmm3, 0x2e6c(%rip)     # 0x4120
movups %xmm2, 0x2e59(%rip)     # 0x4114
movups %xmm1, 0x2e42(%rip)     # 0x4104
movups %xmm0, 0x2e2b(%rip)     # 0x40f4
movq %r14, %rdi
callq 0x10f0
pushq $0x2
popq %rsi
movl %ebx, %edi
movq %r14, %rdx
callq 0x1120
sarl $0x1f, %eax
jmp 0x12e6
pushq $-0x1
popq %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/misc/mkptyfl.c
// Function: putfl
void
putfl(int c, int fd)
{
	char s[10];

	c = ucase*0100 + (c&0177);
	c = fl2ascii[c];
	switch(c){
	case -1: return;
	case FlColor:
		color = !color;
		if(color == 0){
			sprintf(s, "\e[39;49m");
			write(fd, s, 8);
		}else{
			sprintf(s, "\e[31m");
			write(fd, s, 5);
		}
		break;
	case FlStop:
		break;
	case FlUCase:
		ucase = 1;
		break;
	case FlLCase:
		ucase = 0;
		break;
	case FlNull:
		break;
	default:
		if(c == '\n'){
			s[0] = '\r';
			s[1] = '\n';
			write(fd, s, 2);
		}else{
			s[0] = c;
			write(fd, s, 1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movslq 0x2e18(%rip), %rax      # 0x4130
shlq $0x6, %rax
andl $0x7f, %edi
addq %rax, %rdi
leaq 0xd07(%rip), %rax       # 0x2030
movl (%rax,%rdi,4), %ecx
leal 0x6(%rcx), %eax
cmpl $0x5, %eax
ja 0x137a
leaq 0xcd5(%rip), %rcx       # 0x2010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
andl $0x0, 0x2de5(%rip)      # 0x4130
jmp 0x13be
xorl %eax, %eax
cmpl $0x0, 0x2dde(%rip)      # 0x4134
sete %al
movl %eax, 0x2dd5(%rip)      # 0x4134
je 0x13a1
movabsq $0x6d39343b39335b1b, %rcx # imm = 0x6D39343B39335B1B
leaq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
pushq $0x8
jmp 0x13b3
andl $-0x41, %edi
leaq -0x10(%rbp), %rax
cmpl $0x29, %edi
jne 0x139b
movw $0xa0d, (%rax)          # imm = 0xA0D
pushq $0x2
jmp 0x13b3
movl $0x1, 0x2d97(%rip)      # 0x4130
jmp 0x13be
movb %cl, (%rax)
pushq $0x1
jmp 0x13b3
leaq -0x10(%rbp), %rax
movw $0x6d, 0x4(%rax)
movl $0x31335b1b, (%rax)     # imm = 0x31335B1B
pushq $0x5
popq %rdx
movl %esi, %edi
movq %rax, %rsi
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/misc/mkptyfl.c
// Function: putascii
void
putascii(int c, int fd, int localfd)
{
	char s[2];
	int n;
	c = ascii2fl[c];
	if(c < 0)
		return;
	n = 0;
	if(c & 0300){
		if(c & 0100 && ucase)
			s[n++] = 075;
		else if(c & 0200 && !ucase)
			s[n++] = 071;
	}
	s[n++] = c & 077;
	write(fd, s, n);

// local echo
int i;
for(i = 0; i < n; i++)
	putfl(s[i], localfd);
}

// Assembly:
movslq %edi, %rax
leaq 0xe62(%rip), %rcx       # 0x2230
movl (%rcx,%rax,4), %eax
testl %eax, %eax
js 0x1463
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
xorl %r14d, %r14d
testb $-0x40, %al
je 0x1422
movl %eax, %edx
shrb $0x6, %dl
movl 0x2d39(%rip), %ecx      # 0x4130
testl %ecx, %ecx
setne %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x140c
movb $0x3d, -0x1a(%rbp)
jmp 0x141e
testl %ecx, %ecx
setne %cl
testb %al, %al
setns %dl
orb %cl, %dl
jne 0x1422
movb $0x39, -0x1a(%rbp)
pushq $0x1
popq %r14
andb $0x3f, %al
movl %r14d, %ecx
incl %r14d
movb %al, -0x1a(%rbp,%rcx)
leaq -0x1a(%rbp), %rax
movl %esi, %edi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1070
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x1459
movsbl -0x1a(%rbp,%r15), %edi
movl %ebx, %esi
callq 0x1309
incq %r15
jmp 0x1442
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/misc/mkptyfl.c
// Function: readwrite
void
readwrite(int ttyin, int ttyout, int ptyin, int ptyout)
{
	int n;
	struct pollfd pfd[2];
	char c;

	pfd[0].fd = ptyin;
	pfd[0].events = POLLIN;
	pfd[1].fd = ttyin;
	pfd[1].events = POLLIN;
	while(pfd[0].fd != -1){
		n = poll(pfd, 2, -1);
		if(n < 0){
			perror("error poll");
			return;
		}
		if(n == 0)
			return;
		if(pfd[0].revents & POLLHUP)
			nanosleep(&hupslp, NULL);
		/* read from pty, write to tty */
		if(pfd[0].revents & POLLIN){
			if(n = read(ptyin, &c, 1), n <= 0)
				return;
			else{
				c &= 077;
				putfl(c, ttyout);
				SLEEP;
			}
		}
		/* read from tty, write to pty */
		if(pfd[1].revents & POLLIN){
			if(n = read(ttyin, &c, 1), n <= 0)
				return;
			else{
				c &= 0177;	// needed?
				if(c == 035)
					return;
				putascii(c, ptyout, ttyout);
				SLEEP;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x30(%rbp)
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %r12d
leaq -0x40(%rbp), %r13
movl %edx, (%r13)
movw $0x1, %ax
movw %ax, 0x4(%r13)
movl %edi, 0x8(%r13)
movw %ax, 0xc(%r13)
pushq $-0x1
popq %rbx
movl %edx, %eax
cmpl $-0x1, %eax
je 0x1550
movq %r13, %rdi
pushq $0x2
popq %rsi
movl %ebx, %edx
callq 0x1100
testl %eax, %eax
js 0x1544
je 0x1550
movzwl -0x3a(%rbp), %eax
testb $0x10, %al
je 0x14de
leaq 0x2c0d(%rip), %rdi      # 0x40e0
xorl %esi, %esi
callq 0x10a0
movzwl -0x3a(%rbp), %eax
testb $0x1, %al
je 0x1508
movl %r14d, %edi
leaq -0x29(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x10c0
testl %eax, %eax
jle 0x1550
movzbl -0x29(%rbp), %edi
andl $0x3f, %edi
movb %dil, -0x29(%rbp)
movl %r15d, %esi
callq 0x1309
testb $0x1, -0x32(%rbp)
je 0x153c
movl %r12d, %edi
leaq -0x29(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x10c0
testl %eax, %eax
jle 0x1550
movzbl -0x29(%rbp), %edi
andl $0x7f, %edi
movb %dil, -0x29(%rbp)
cmpl $0x1d, %edi
je 0x1550
movl -0x30(%rbp), %esi
movl %r15d, %edx
callq 0x13c4
movl -0x40(%rbp), %eax
jmp 0x14a0
leaq 0xef4(%rip), %rdi       # 0x243f
callq 0x1140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/misc/mkptyfl.c
// Function: main
int
main(int argc, char *argv[])
{
	int fd;
	int slv;
	const char *ptylink;

	ptylink = NULL;
	if(argc > 1)
		ptylink = argv[1];

	fd = posix_openpt(O_RDWR);
	if(fd < 0)
		return 1;
	if(grantpt(fd) < 0)
		return 2;
	if(unlockpt(fd) < 0)
		return 3;

	if(ptylink){
		unlink(ptylink);
		if(symlink(ptsname(fd), ptylink) < 0)
			fprintf(stderr, "Error: %s\n", strerror(errno));
	}

	printf("%s\n", ptsname(fd));

	slv = open(ptsname(fd), O_RDWR);
	if(slv < 0)
		return 4;
	raw(slv);
	close(slv);

	raw(0);

	readwrite(0, 1, fd, fd);
	close(fd);

	printf("\e[39;49m");
	reset(0);

	if(ptylink)
		unlink(ptylink);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x2, %edi
jl 0x1575
movq 0x8(%rsi), %rbx
jmp 0x1577
xorl %ebx, %ebx
pushq $0x2
popq %r15
movl %r15d, %edi
callq 0x1170
testl %eax, %eax
js 0x1654
movl %eax, %r14d
movl %eax, %edi
callq 0x1150
testl %eax, %eax
js 0x1660
movl %r14d, %edi
callq 0x10d0
testl %eax, %eax
js 0x1658
testq %rbx, %rbx
je 0x15d5
movq %rbx, %rdi
callq 0x1050
movl %r14d, %edi
callq 0x1030
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1090
testl %eax, %eax
js 0x166c
movl %r14d, %edi
callq 0x1030
movq %rax, %rdi
callq 0x1060
movl %r14d, %edi
callq 0x1030
xorl %r15d, %r15d
pushq $0x2
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0x1130
testl %eax, %eax
js 0x165c
movl %eax, %r12d
movl %eax, %edi
callq 0x127c
movl %r12d, %edi
callq 0x10b0
xorl %edi, %edi
callq 0x127c
pushq $0x1
popq %rsi
xorl %edi, %edi
movl %r14d, %edx
movl %r14d, %ecx
callq 0x1464
movl %r14d, %edi
callq 0x10b0
leaq 0xdf7(%rip), %rdi       # 0x2430
xorl %eax, %eax
callq 0x1080
callq 0x12ef
testq %rbx, %rbx
je 0x1660
movq %rbx, %rdi
callq 0x1050
jmp 0x1660
pushq $0x1
jmp 0x165e
pushq $0x3
jmp 0x165e
pushq $0x4
popq %r15
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2985(%rip), %rax      # 0x3ff8
movq (%rax), %r15
callq 0x1040
movl (%rax), %edi
callq 0x1160
leaq 0xdc1(%rip), %rsi       # 0x244a
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10e0
jmp 0x15d5
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/tests/s3/main.c
// Function: readtests
static void
readtests(struct wire_requestqueue * Q, const char * bucket)
{

	/* GET with a large buffer. */
	opdone = 0;
	if (proto_s3_request_get(Q, bucket, "s3-testfile", 100,
	    callback_get, NULL) ||
	    events_spin(&opdone)) {
		warn0("GET failed");
		exit(1);
	}

	/* GET with a small buffer. */
	opdone = 0;
	if (proto_s3_request_get(Q, bucket, "s3-testfile", 10,
	    callback_get, NULL) ||
	    events_spin(&opdone)) {
		warn0("GET failed");
		exit(1);
	}

	/* RANGE. */
	opdone = 0;
	if (proto_s3_request_range(Q, bucket, "s3-testfile", 6, 5,
	    callback_range, NULL) ||
	    events_spin(&opdone)) {
		warn0("RANGE failed");
		exit(1);
	}

	/* HEAD. */
	opdone = 0;
	if (proto_s3_request_head(Q, bucket, "s3-testfile",
	    callback_head, NULL) ||
	    events_spin(&opdone)) {
		warn0("HEAD failed");
		exit(1);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, 0xbee8(%rip)      # 0xe554
leaq 0x69e4(%rip), %rdx      # 0x9057
leaq 0x114(%rip), %r8        # 0x278e
pushq $0x64
popq %rcx
xorl %r9d, %r9d
callq 0x4203
testl %eax, %eax
jne 0x275e
leaq 0xbec0(%rip), %rdi      # 0xe554
callq 0x2b63
testl %eax, %eax
jne 0x275e
andl $0x0, 0xbeac(%rip)      # 0xe554
leaq 0x69a8(%rip), %rdx      # 0x9057
leaq 0xd8(%rip), %r8         # 0x278e
pushq $0xa
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r9d, %r9d
callq 0x4203
testl %eax, %eax
jne 0x275e
leaq 0xbe7e(%rip), %rdi      # 0xe554
callq 0x2b63
testl %eax, %eax
jne 0x275e
andl $0x0, 0xbe6e(%rip)      # 0xe554
andq $0x0, (%rsp)
leaq 0x6965(%rip), %rdx      # 0x9057
leaq 0x101(%rip), %r9        # 0x27fa
pushq $0x6
popq %rcx
pushq $0x5
popq %r8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4495
testl %eax, %eax
jne 0x2767
leaq 0xbe3e(%rip), %rdi      # 0xe554
callq 0x2b63
testl %eax, %eax
jne 0x2767
andl $0x0, 0xbe2e(%rip)      # 0xe554
leaq 0x692a(%rip), %rdx      # 0x9057
leaq 0x132(%rip), %rcx       # 0x2866
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x4781
testl %eax, %eax
jne 0x2770
leaq 0xbe07(%rip), %rdi      # 0xe554
callq 0x2b63
testl %eax, %eax
jne 0x2770
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x68fe(%rip), %rdi      # 0x9063
jmp 0x2777
leaq 0x6900(%rip), %rdi      # 0x906e
jmp 0x2777
leaq 0x6904(%rip), %rdi      # 0x907b
xorl %eax, %eax
callq 0x3e48
callq 0x2090
andl $0x0, (%rax)
pushq $0x1
popq %rdi
callq 0x22b0
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/tests/s3/main.c
// Function: callback_get
static int
callback_get(void * cookie, int failed, size_t len, const uint8_t * buf)
{

	(void)cookie; /* UNUSED */

	/* Print status. */
	printf("GET failed = %d len = %zd\n", failed, (ssize_t)len);

	/* Print data. */
	if (buf != NULL) {
		printf("GET data = >>>");
		fwrite(buf, len, 1, stdout);
		printf("<<<\n");
	} else {
		printf("GET data = NULL\n");
	}

	/* We're done. */
	opdone = 1;
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
leaq 0x68e8(%rip), %rdi      # 0x9087
xorl %eax, %eax
callq 0x2140
testq %r14, %r14
je 0x27da
leaq 0x68f0(%rip), %rdi      # 0x90a2
xorl %eax, %eax
callq 0x2140
movq 0xb810(%rip), %rax      # 0xdfd0
movq (%rax), %rcx
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22d0
leaq 0x6992(%rip), %rdi      # 0x916a
jmp 0x27e1
leaq 0x6967(%rip), %rdi      # 0x9148
callq 0x20b0
movl $0x1, 0xbd64(%rip)      # 0xe554
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/tests/s3/main.c
// Function: callback_range
static int
callback_range(void * cookie, int failed, size_t buflen, const uint8_t * buf)
{

	(void)cookie; /* UNUSED */

	/* Print status. */
	printf("RANGE failed = %d buflen = %zd\n", failed, (ssize_t)buflen);

	/* Print data. */
	if (buf != NULL) {
		printf("RANGE data = >>>");
		fwrite(buf, buflen, 1, stdout);
		printf("<<<\n");
	} else {
		printf("RANGE data = NULL\n");
	}

	/* We're done. */
	opdone = 1;
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
leaq 0x68a6(%rip), %rdi      # 0x90b1
xorl %eax, %eax
callq 0x2140
testq %r14, %r14
je 0x2846
leaq 0x68b3(%rip), %rdi      # 0x90d1
xorl %eax, %eax
callq 0x2140
movq 0xb7a4(%rip), %rax      # 0xdfd0
movq (%rax), %rcx
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22d0
leaq 0x6926(%rip), %rdi      # 0x916a
jmp 0x284d
leaq 0x690b(%rip), %rdi      # 0x9158
callq 0x20b0
movl $0x1, 0xbcf8(%rip)      # 0xe554
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: callback_put
static int
callback_put(void * cookie, uint8_t * buf, size_t buflen)
{
	struct put_cookie * C = cookie;
	int failed = 1;
	uint32_t status;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Do we have the right packet length? */
		if (buflen != 4)
			BAD("PUT", "bogus length");

		/* Parse the packet. */
		status = be32dec(&buf[0]);

		/* Check status. */
		if ((status != 0) && ((status < 100) || (status > 599)))
			BAD("PUT", "Invalid HTTP status");

		/* Did the operation succeed? */
		if (status == 200)
			failed = 0;
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
testq %rsi, %rsi
je 0x41e8
cmpq $0x4, %rdx
jne 0x41b7
movq %rsi, %rdi
callq 0x4ba8
testl %eax, %eax
sete %cl
leal -0x258(%rax), %edx
cmpl $0xfffffe0c, %edx       # imm = 0xFFFFFE0C
setae %dl
orb %cl, %dl
jne 0x41dd
leaq 0x534f(%rip), %rdi      # 0x94f6
leaq 0x5365(%rip), %rsi      # 0x9513
leaq 0x536f(%rip), %rdx      # 0x9524
jmp 0x41cc
leaq 0x5338(%rip), %rdi      # 0x94f6
leaq 0x534e(%rip), %rsi      # 0x9513
leaq 0x534b(%rip), %rdx      # 0x9517
xorl %eax, %eax
callq 0x3e48
callq 0x2090
andl $0x0, (%rax)
jmp 0x41e8
xorl %ebp, %ebp
cmpl $0xc8, %eax
setne %bpl
movq 0x8(%rbx), %rdi
movl %ebp, %esi
callq *(%rbx)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: callback_get
static int
callback_get(void * cookie, uint8_t * buf, size_t buflen)
{
	struct get_cookie * C = cookie;
	int failed = 1;
	uint32_t status;
	uint32_t len;
	size_t lens = (size_t)(-1);
	uint8_t * dbuf = NULL;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Do we have the right packet length? */
		if (buflen < 8)
			BAD("GET", "bogus length");

		/* Parse the packet. */
		status = be32dec(&buf[0]);
		len = be32dec(&buf[4]);

		/* Check status. */
		if ((status != 0) && ((status < 100) || (status > 599)))
			BAD("GET", "Invalid HTTP status");

		/* Do we have the right packet length? */
		if (len != (uint32_t)(-1)) {
			if (buflen != 8 + len)
				BAD("GET", "bogus length");
		} else {
			if (buflen != 8)
				BAD("GET", "bogus length");
		}

		/* Did the operation succeed? */
		if (status == 200)
			failed = 0;

		/* Do we have data? */
		if ((failed == 0) && (len != (uint32_t)(-1))) {
			lens = len;
			dbuf = &buf[8];
		}
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed, lens, dbuf);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
pushq $-0x1
popq %r14
testq %rsi, %rsi
je 0x4469
movq %rdx, %r15
cmpq $0x7, %rdx
ja 0x43d0
leaq 0x5136(%rip), %rdi      # 0x94f6
leaq 0x5171(%rip), %rsi      # 0x9538
leaq 0x5149(%rip), %rdx      # 0x9517
jmp 0x4417
movq %rsi, %r12
movq %rsi, %rdi
callq 0x4ba8
movl %eax, %r13d
leaq 0x4(%r12), %rdi
callq 0x4ba8
testl %r13d, %r13d
sete %cl
leal -0x258(%r13), %edx
cmpl $0xfffffe0c, %edx       # imm = 0xFFFFFE0C
setae %dl
orb %cl, %dl
jne 0x442b
leaq 0x50ed(%rip), %rdi      # 0x94f6
leaq 0x5128(%rip), %rsi      # 0x9538
leaq 0x510d(%rip), %rdx      # 0x9524
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x3e48
callq 0x2090
andl $0x0, (%rax)
jmp 0x446c
cmpl $-0x1, %eax
je 0x4452
leal 0x8(%rax), %ecx
cmpq %r15, %rcx
jne 0x43b9
xorl %r15d, %r15d
cmpl $0xc8, %r13d
jne 0x446c
movl %eax, %r14d
addq $0x8, %r12
movq %r12, %r15
xorl %ebp, %ebp
jmp 0x446c
cmpq $0x8, %r15
jne 0x43b9
xorl %ebp, %ebp
cmpl $0xc8, %r13d
setne %bpl
xorl %r15d, %r15d
movq 0x8(%rbx), %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %r15, %rcx
callq *(%rbx)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: callback_range
static int
callback_range(void * cookie, uint8_t * buf, size_t buflen)
{
	struct get_cookie * C = cookie;
	int failed = 1;
	uint32_t status;
	uint32_t len;
	size_t lens = (size_t)(-1);
	uint8_t * dbuf = NULL;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Do we have the right packet length? */
		if (buflen < 8)
			BAD("RANGE", "bogus length");

		/* Parse the packet. */
		status = be32dec(&buf[0]);
		len = be32dec(&buf[4]);

		/* Check status. */
		if ((status != 0) && ((status < 100) || (status > 599)))
			BAD("RANGE", "Invalid HTTP status");

		/* Do we have the right packet length? */
		if (len != (uint32_t)(-1)) {
			if (buflen != 8 + len)
				BAD("RANGE", "bogus length");
		} else {
			if (buflen != 8)
				BAD("RANGE", "bogus length");
		}

		/* Warn about HTTP 200 responses. */
		if (status == 200)
			BAD("RANGE", "HTTP 200 response");

		/* Did the operation succeed? */
		if (status == 206)
			failed = 0;

		/* Do we have data? */
		if ((failed == 0) && (len != (uint32_t)(-1))) {
			lens = len;
			dbuf = &buf[8];
		}
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed, lens, dbuf);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r15
pushq $-0x1
popq %r14
testq %rsi, %rsi
je 0x468d
movq %rdx, %r13
cmpq $0x7, %rdx
ja 0x4692
leaq 0x4e79(%rip), %rdi      # 0x94f6
leaq 0x4eb8(%rip), %rsi      # 0x953c
leaq 0x4e8c(%rip), %rdx      # 0x9517
jmp 0x46d6
xorl %r12d, %r12d
jmp 0x46e8
movq %rsi, %r12
movq %rsi, %rdi
callq 0x4ba8
movl %eax, %ebp
leaq 0x4(%r12), %rdi
callq 0x4ba8
testl %ebp, %ebp
sete %cl
leal -0x258(%rbp), %edx
cmpl $0xfffffe0c, %edx       # imm = 0xFFFFFE0C
setae %dl
orb %cl, %dl
jne 0x4712
leaq 0x4e2e(%rip), %rdi      # 0x94f6
leaq 0x4e6d(%rip), %rsi      # 0x953c
leaq 0x4e4e(%rip), %rdx      # 0x9524
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x3e48
callq 0x2090
andl $0x0, (%rax)
movq 0x8(%rbx), %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %r12, %rcx
callq *(%rbx)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x1, %eax
je 0x4725
leal 0x8(%rax), %ecx
cmpq %r13, %rcx
jne 0x4676
jmp 0x472f
cmpq $0x8, %r13
jne 0x4676
cmpl $0xc8, %ebp
jne 0x474e
leaq 0x4db8(%rip), %rdi      # 0x94f6
leaq 0x4df7(%rip), %rsi      # 0x953c
leaq 0x4df6(%rip), %rdx      # 0x9542
jmp 0x46d6
cmpl $-0x1, %eax
sete %sil
xorl %ecx, %ecx
cmpl $0xce, %ebp
setne %dl
xorl %r15d, %r15d
orb %dl, %sil
jne 0x4774
movl %eax, %r14d
addq $0x8, %r12
jmp 0x46e8
movb %dl, %cl
xorl %r12d, %r12d
movl %ecx, %r15d
jmp 0x46e8
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: proto_s3_request_head
int
proto_s3_request_head(struct wire_requestqueue * Q, const char * bucket,
    const char * object,
    int (* callback)(void *, int, size_t), void * cookie)
{
	struct head_cookie * C;
	uint8_t *rbuf, *p;
	size_t rlen;

	/* Validate bucket and object name lengths. */
	if ((strlen(bucket) > 255) || (strlen(object) > 255)) {
		warn0("Bucket or object name is too long");
		goto err0;
	}

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct head_cookie))) == NULL)
		goto err0;
	C->callback = callback;
	C->cookie = cookie;

	/* Compute request packet size. */
	rlen = 6 + strlen(bucket) + strlen(object);

	/* Start writing a request. */
	if ((p = rbuf =
	    wire_requestqueue_add_getbuf(Q, rlen, callback_head, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(p, PROTO_S3_HEAD);
	p += 4;
	*p++ = (uint8_t)strlen(bucket);
	memcpy(p, bucket, strlen(bucket));
	p += strlen(bucket);
	*p++ = (uint8_t)strlen(object);
	memcpy(p, object, strlen(object));

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, rbuf, rlen))
		goto err1;

	/* Success! */
	return (0);

err1:
	free(C);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbp
movq %rsi, %rdi
callq 0x2110
cmpq $0xff, %rax
ja 0x47c3
movq %rax, %rbx
movq %r13, %rdi
callq 0x2110
cmpq $0x100, %rax            # imm = 0x100
jb 0x47ed
leaq 0x4cbb(%rip), %rdi      # 0x9485
xorl %eax, %eax
callq 0x3e48
callq 0x2090
andl $0x0, (%rax)
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, 0x18(%rsp)
movq %rbp, 0x20(%rsp)
pushq $0x10
popq %rdi
callq 0x2200
pushq $-0x1
popq %rbp
testq %rax, %rax
je 0x47dc
movq %r15, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq %r14, %rbx
addq $0x6, %rbx
leaq 0xba(%rip), %rdx        # 0x48de
movq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, 0x8(%rsp)
movq %rax, %rcx
callq 0x4dfb
testq %rax, %rax
je 0x48c8
movq %rax, %r13
movl $0x20000100, (%rax)     # imm = 0x20000100
movq %r12, %rdi
callq 0x2110
movq %rbx, 0x10(%rsp)
leaq 0x5(%r13), %rbx
movb %al, 0x4(%r13)
movq %r12, %rdi
callq 0x2110
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x21e0
movq %r12, %rdi
callq 0x2110
movq %rax, %rbx
movq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x2110
leaq (%rbx,%r13), %r14
addq $0x6, %r14
movb %al, 0x5(%r13,%rbx)
movq %r12, %rdi
callq 0x2110
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x21e0
movq %r15, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
callq 0x501d
testl %eax, %eax
je 0x48d7
movq 0x8(%rsp), %rdi
callq 0x2040
jmp 0x47dc
xorl %ebp, %ebp
jmp 0x47dc
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: callback_head
static int
callback_head(void * cookie, uint8_t * buf, size_t buflen)
{
	struct head_cookie * C = cookie;
	uint32_t status = 0;
	uint32_t len;
	size_t lens = (size_t)(-1);
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Do we have the right packet length? */
		if (buflen != 8)
			BAD("HEAD", "bogus length");

		/* Parse the packet. */
		status = be32dec(&buf[0]);
		len = be32dec(&buf[4]);

		/* Check status. */
		if ((status != 0) && ((status < 100) || (status > 599)))
			BAD("HEAD", "Invalid HTTP status");

		/* If status == 200 and len != -1, we have a length. */
		if ((status == 200) && (len != (uint32_t)(-1)))
			lens = len;
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, (int)status, lens);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $-0x1
popq %r14
testq %rsi, %rsi
je 0x4936
cmpq $0x8, %rdx
jne 0x493b
movq %rsi, %r12
movq %rsi, %rdi
callq 0x4ba8
movl %eax, %r15d
testl %eax, %eax
sete %al
leal -0x258(%r15), %ecx
cmpl $0xfffffe0c, %ecx       # imm = 0xFFFFFE0C
setae %cl
orb %al, %cl
jne 0x4964
leaq 0x4bd0(%rip), %rdi      # 0x94f6
leaq 0x4c27(%rip), %rsi      # 0x9554
leaq 0x4bf0(%rip), %rdx      # 0x9524
jmp 0x4953
xorl %r15d, %r15d
jmp 0x4993
leaq 0x4bb4(%rip), %rdi      # 0x94f6
leaq 0x4c0b(%rip), %rsi      # 0x9554
leaq 0x4bc7(%rip), %rdx      # 0x9517
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x3e48
callq 0x2090
andl $0x0, (%rax)
jmp 0x4993
addq $0x4, %r12
movq %r12, %rdi
callq 0x4ba8
movl $0xc8, %ecx
cmpl %ecx, %r15d
sete %dl
cmpl $-0x1, %eax
setne %sil
movl %eax, %eax
testb %sil, %dl
pushq $-0x1
popq %r14
cmovneq %rax, %r14
cmovnel %ecx, %r15d
movq 0x8(%rbx), %rdi
movl %r15d, %esi
movq %r14, %rdx
callq *(%rbx)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: proto_s3_request_delete
int
proto_s3_request_delete(struct wire_requestqueue * Q, const char * bucket,
    const char * object, int (* callback)(void *, int), void * cookie)
{
	struct delete_cookie * C;
	uint8_t *rbuf, *p;
	size_t rlen;

	/* Validate bucket and object name lengths. */
	if ((strlen(bucket) > 255) || (strlen(object) > 255)) {
		warn0("Bucket or object name is too long");
		goto err0;
	}

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct delete_cookie))) == NULL)
		goto err0;
	C->callback = callback;
	C->cookie = cookie;

	/* Compute request packet size. */
	rlen = 6 + strlen(bucket) + strlen(object);

	/* Start writing a request. */
	if ((p = rbuf =
	    wire_requestqueue_add_getbuf(Q, rlen, callback_delete, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(p, PROTO_S3_DELETE);
	p += 4;
	*p++ = (uint8_t)strlen(bucket);
	memcpy(p, bucket, strlen(bucket));
	p += strlen(bucket);
	*p++ = (uint8_t)strlen(object);
	memcpy(p, object, strlen(object));

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, rbuf, rlen))
		goto err1;

	/* Success! */
	return (0);

err1:
	free(C);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbp
movq %rsi, %rdi
callq 0x2110
cmpq $0xff, %rax
ja 0x49f6
movq %rax, %rbx
movq %r13, %rdi
callq 0x2110
cmpq $0x100, %rax            # imm = 0x100
jb 0x4a20
leaq 0x4a88(%rip), %rdi      # 0x9485
xorl %eax, %eax
callq 0x3e48
callq 0x2090
andl $0x0, (%rax)
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, 0x18(%rsp)
movq %rbp, 0x20(%rsp)
pushq $0x10
popq %rdi
callq 0x2200
pushq $-0x1
popq %rbp
testq %rax, %rax
je 0x4a0f
movq %r15, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq %r14, %rbx
addq $0x6, %rbx
leaq 0xba(%rip), %rdx        # 0x4b11
movq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, 0x8(%rsp)
movq %rax, %rcx
callq 0x4dfb
testq %rax, %rax
je 0x4afb
movq %rax, %r13
movl $0x30000100, (%rax)     # imm = 0x30000100
movq %r12, %rdi
callq 0x2110
movq %rbx, 0x10(%rsp)
leaq 0x5(%r13), %rbx
movb %al, 0x4(%r13)
movq %r12, %rdi
callq 0x2110
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x21e0
movq %r12, %rdi
callq 0x2110
movq %rax, %rbx
movq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x2110
leaq (%rbx,%r13), %r14
addq $0x6, %r14
movb %al, 0x5(%r13,%rbx)
movq %r12, %rdi
callq 0x2110
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x21e0
movq %r15, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
callq 0x501d
testl %eax, %eax
je 0x4b0a
movq 0x8(%rsp), %rdi
callq 0x2040
jmp 0x4a0f
xorl %ebp, %ebp
jmp 0x4a0f
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/liball/../lib/proto_s3/proto_s3_client.c
// Function: callback_delete
static int
callback_delete(void * cookie, uint8_t * buf, size_t buflen)
{
	struct delete_cookie * C = cookie;
	int failed = 1;
	uint32_t status;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Do we have the right packet length? */
		if (buflen != 4)
			BAD("DELETE", "bogus length");

		/* Parse the packet. */
		status = be32dec(&buf[0]);

		/* Check status. */
		if ((status != 0) && ((status < 100) || (status > 599)))
			BAD("DELETE", "Invalid HTTP status");

		/* Did the operation succeed? */
		if (status == 204)
			failed = 0;
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
testq %rsi, %rsi
je 0x4b8d
cmpq $0x4, %rdx
jne 0x4b5c
movq %rsi, %rdi
callq 0x4ba8
testl %eax, %eax
sete %cl
leal -0x258(%rax), %edx
cmpl $0xfffffe0c, %edx       # imm = 0xFFFFFE0C
setae %dl
orb %cl, %dl
jne 0x4b82
leaq 0x49aa(%rip), %rdi      # 0x94f6
leaq 0x4a06(%rip), %rsi      # 0x9559
leaq 0x49ca(%rip), %rdx      # 0x9524
jmp 0x4b71
leaq 0x4993(%rip), %rdi      # 0x94f6
leaq 0x49ef(%rip), %rsi      # 0x9559
leaq 0x49a6(%rip), %rdx      # 0x9517
xorl %eax, %eax
callq 0x3e48
callq 0x2090
andl $0x0, (%rax)
jmp 0x4b8d
xorl %ebp, %ebp
cmpl $0xcc, %eax
setne %bpl
movq 0x8(%rbx), %rdi
movl %ebp, %esi
callq *(%rbx)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_03/strcat.c
// Function: main
int main(void)
{
  char s[100] = "This is the first string";
  char t[] = ", this second string!";

  strcat_ptr(s, t);

  puts(s);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0xec8(%rip), %rsi       # 0x2010
pushq $0x64
popq %rcx
movq %rsp, %rbx
movq %rbx, %rdi
rep  movsb (%rsi), %es:(%rdi)
leaq 0xf26(%rip), %rsi       # 0x2080
movq %rbx, %rdi
callq 0x1172
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_03/strcat.c
// Function: strcat_ptr
void strcat_ptr(char *s, char *t)
{
  // Find the end of s
  while (*s)
      ++s;

  // copy t to the end of s
  while (*s++ = *t++)
    ;
}

// Assembly:
cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
jne 0x1172
xorl %eax, %eax
movb (%rsi,%rax), %cl
movb %cl, -0x1(%rdi,%rax)
incq %rax
testb %cl, %cl
jne 0x117d
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/dcshift/dcshift.c
// Function: writeCommentOut
void writeCommentOut(FILE *in, FILE *out)
    {
    int ch;

    while((ch = fgetc(in)) && (ch != EOF) && ch != '\n')
        {
        fprintf(out,"%c",ch);

        continue;
        }
    fprintf(out,"\n");      
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x803, %r15d           # imm = 0x803
movq %r14, %rdi
callq 0x10e0
leal 0x1(%rax), %ecx
cmpl $0xb, %ecx
ja 0x1388
btl %ecx, %r15d
jb 0x1394
movl %eax, %edi
movq %rbx, %rsi
callq 0x1100
jmp 0x1372
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/dcshift/dcshift.c
// Function: commentHandler
static void commentHandler(FILE *in, FILE *out)
    {
    int ch, count = 0;
    char s[512] = "";

    char *token = NULL;

    ch = fgetc(in);

    if(ch == 'a')
        {

        while(ch != '\n')
            {
            s[count++] = ch;
            ch = fgetc(in);
            }

        s[count] = '\0';

        token = strtok(s," ");

        fprintf(stderr,"%s\n",token);

        token = strtok(NULL, " ");

        fprintf(stderr,"%s\n",token);

        attenuation = (float)atoi(token);

        }
    else
        {
        ungetc(ch,in);
        outputComment(in,out);
        }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x220(%rbp), %rdi
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x10d0
movq %rbx, %rdi
callq 0x10e0
cmpl $0x61, %eax
je 0x1639
movl %eax, %edi
movq %rbx, %rsi
callq 0x1190
movq %rbx, %rdi
movq %r14, %rsi
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a69
pushq $0x61
popq %rax
xorl %r14d, %r14d
cmpl $0xa, %eax
je 0x1659
movb %al, -0x220(%rbp,%r14)
incq %r14
movq %rbx, %rdi
callq 0x10e0
jmp 0x163f
movl %r14d, %eax
movb $0x0, -0x220(%rbp,%rax)
leaq 0x2e05(%rip), %rbx      # 0x4470
leaq -0x220(%rbp), %rdi
movq %rbx, %rsi
callq 0x11d0
movq 0x5977(%rip), %r15      # 0x6ff8
movq (%r15), %rdi
leaq 0x2e04(%rip), %r14      # 0x448f
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1140
xorl %edi, %edi
movq %rbx, %rsi
callq 0x11d0
movq %rax, %rbx
movq (%r15), %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1140
movq %rbx, %rdi
callq 0x1200
cvtsi2ss %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x5a83(%rip)     # 0x7150
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/CSerxzm[P]WindowstoLinuxInterface/src/MD.c
// Function: main
int main(int argc, char* argv[]){
    char lines[argc+1][255];
    predealLine(argc, argv, lines);
    if(strcmp(lines[0],"MD")==0||strcmp(lines[0],"md")==0){
        for(int i=1;i<argc;i++){
            if(access(lines[i],R_OK)){
                char cm[255]="./";
                strcat(cm, lines[i]);
                mkdir(lines[i],S_IRWXU|S_IRGRP|S_IROTH);
            }
            else{
                printf("%s", lines[0]);
                printf("不能创建文件夹: %s :\n", lines[i]);
                printf("文件已经存在或权限不允许!\n");
            }
        }
    }
    else{
        printf("%s: ", lines[0]);
        printf("error\n");
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r14d
leal 0x1(%r14), %eax
movq %rsp, %r15
imulq $0xff, %rax, %r12
addq $0xf, %r12
andq $-0x10, %r12
movq %r15, %rbx
subq %r12, %rbx
movq %rbx, %rsp
negq %r12
movq %rbx, %rdx
callq 0x119c
movzbl (%r15,%r12), %eax
cmpl $0x6d, %eax
je 0x12c6
cmpl $0x4d, %eax
jne 0x12d2
cmpb $0x44, 0x1(%rbx)
je 0x12cc
jmp 0x12d2
cmpb $0x64, 0x1(%rbx)
jne 0x12d2
cmpb $0x0, 0x2(%rbx)
je 0x1300
leaq 0xd4b(%rip), %rdi       # 0x2024
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xd3f(%rip), %rdi       # 0x2029
callq 0x1040
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %r14d, %r13
leaq 0xff(%rbx), %r14
pushq $0x1
popq %r12
pushq $0x4
popq %r15
cmpq %r13, %r12
jge 0x12ef
movq %r14, %rdi
movl %r15d, %esi
callq 0x1070
testl %eax, %eax
je 0x1335
movq %r14, %rdi
movl $0x1e4, %esi            # imm = 0x1E4
callq 0x1030
jmp 0x1363
leaq 0xcc8(%rip), %rdi       # 0x2004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xcba(%rip), %rdi       # 0x2007
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xcd1(%rip), %rdi       # 0x202f
callq 0x1040
incq %r12
addq $0xff, %r14
jmp 0x1312
// File: /workspace/github_c_makefile_star2_O2/zecoxao[P]ps3_decrypt_tools/lib/aes.c
// Function: aes_setkey_dec
int aes_setkey_dec(aes_context *ctx, const unsigned char *key, unsigned int keysize) {
    int i, j;
    aes_context cty;
    unsigned long *RK;
    unsigned long *SK;
    int ret;

    switch (keysize) {
        case 128: ctx->nr = 10;
            break;
        case 192: ctx->nr = 12;
            break;
        case 256: ctx->nr = 14;
            break;
        default: return ( POLARSSL_ERR_AES_INVALID_KEY_LENGTH);
    }

    ctx->rk = RK = ctx->buf;

    ret = aes_setkey_enc(&cty, key, keysize);
    if (ret != 0)
        return ( ret);

    SK = cty.rk + cty.nr * 4;

    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;

    for (i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8) {
        for (j = 0; j < 4; j++, SK++) {
            *RK++ = RT0[ FSb[ (*SK) & 0xFF ] ] ^
                    RT1[ FSb[ (*SK >> 8) & 0xFF ] ] ^
                    RT2[ FSb[ (*SK >> 16) & 0xFF ] ] ^
                    RT3[ FSb[ (*SK >> 24) & 0xFF ] ];
        }
    }

    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;
    *RK++ = *SK++;

    memset(&cty, 0, sizeof ( aes_context));

    return ( 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
cmpl $0x80, %edx
je 0x1578
cmpl $0x100, %edx            # imm = 0x100
je 0x1574
cmpl $0xc0, %edx
jne 0x168a
pushq $0xc
jmp 0x157a
pushq $0xe
jmp 0x157a
pushq $0xa
popq %rax
movl %eax, (%rbx)
leaq 0x10(%rbx), %rax
movq %rax, 0x8(%rbx)
movq %rsp, %rdi
callq 0x126c
testl %eax, %eax
jne 0x168d
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
addq $-0x20, %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq 0x28(%rax), %rcx
movq %rcx, 0x18(%rbx)
movq 0x30(%rax), %rcx
movq %rcx, 0x20(%rbx)
movq 0x38(%rax), %rdx
leaq 0x30(%rbx), %rcx
movq %rdx, 0x28(%rbx)
movl (%rbx), %edx
leaq 0x5aaa(%rip), %rsi      # 0x7080
leaq 0x5ba3(%rip), %rdi      # 0x7180
movl $0xff, %r8d
leaq 0x6396(%rip), %r9       # 0x7980
leaq 0x6b8f(%rip), %r10      # 0x8180
leaq 0x7388(%rip), %r11      # 0x8980
cmpl $0x2, %edx
jl 0x1668
decl %edx
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpl $0x4, %r14d
je 0x165c
movq (%rax,%r14,8), %r15
movzbl %r15b, %r12d
movzbl (%r12,%rsi), %r12d
movl %r15d, %r13d
shrl $0x8, %r13d
andl %r8d, %r13d
movzbl (%r13,%rsi), %r13d
movq (%r9,%r13,8), %r13
xorq (%rdi,%r12,8), %r13
movl %r15d, %r12d
shrl $0x10, %r12d
andl %r8d, %r12d
movzbl (%r12,%rsi), %r12d
xorq (%r10,%r12,8), %r13
shrl $0x18, %r15d
movzbl (%r15,%rsi), %r15d
xorq (%r11,%r15,8), %r13
movq %r13, (%rcx,%r14,8)
incq %r14
addq $-0x8, %rbx
jmp 0x1604
subq %rbx, %rcx
subq %rbx, %rax
addq $-0x40, %rax
jmp 0x15f8
movq (%rax), %rdx
movq %rdx, (%rcx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rcx)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rcx)
xorl %eax, %eax
jmp 0x168d
pushq $-0x20
popq %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zecoxao[P]ps3_decrypt_tools/lib/aes.c
// Function: aes_crypt_cbc
int aes_crypt_cbc(aes_context *ctx,
        int mode,
        size_t length,
        unsigned char iv[16],
        const unsigned char *input,
        unsigned char *output) {
    int i;
    unsigned char temp[16];

    if (length % 16)
        return ( POLARSSL_ERR_AES_INVALID_INPUT_LENGTH);

    if (mode == AES_DECRYPT) {
        while (length > 0) {
            memcpy(temp, input, 16);
            aes_crypt_ecb(ctx, mode, input, output);

            for (i = 0; i < 16; i++)
                output[i] = (unsigned char) (output[i] ^ iv[i]);

            memcpy(iv, temp, 16);

            input += 16;
            output += 16;
            length -= 16;
        }
    } else {
        while (length > 0) {
            for (i = 0; i < 16; i++)
                output[i] = (unsigned char) (input[i] ^ iv[i]);

            aes_crypt_ecb(ctx, mode, output, output);
            memcpy(iv, output, 16);

            input += 16;
            output += 16;
            length -= 16;
        }
    }

    return ( 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
testb $0xf, %r12b
je 0x1e05
pushq $-0x22
popq %r13
jmp 0x1e5e
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %esi, %r13d
movq %rdi, %rbp
testl %esi, %esi
je 0x1e70
testq %r12, %r12
je 0x1e5b
xorl %eax, %eax
cmpq $0x10, %rax
je 0x1e35
movb (%r15,%rax), %cl
xorb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x1e1f
movq %rbp, %rdi
movl %r13d, %esi
movq %rbx, %rdx
movq %rbx, %rcx
callq 0x169e
movups (%rbx), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jmp 0x1e18
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
testq %r12, %r12
je 0x1e5e
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq %rbp, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x169e
xorl %eax, %eax
cmpq $0x10, %rax
je 0x1ea4
movb (%r15,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
jmp 0x1e92
movaps (%rsp), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jmp 0x1e73