LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_str_hash
static uint32_t
munit_str_hash(const char* name) {
  const char *p;
  uint32_t h = UINT32_C(5381);

  for (p = name; *p != '\0'; p++)
    h = (h << 5) + h + *p;

  return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1505, -0x14(%rbp)    # imm = 0x1505
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x13106
movl -0x14(%rbp), %eax
shll $0x5, %eax
addl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x130d7
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_test_runner_run_test_wild
static void
munit_test_runner_run_test_wild(MunitTestRunner* runner,
                                const MunitTest* test,
                                const char* test_name,
                                MunitParameter* params,
                                MunitParameter* p) {
  const MunitParameterEnum* pe;
  for (pe = test->parameters ; pe != NULL && pe->name != NULL ; pe++) {
    if (p->name == pe->name)
      break;
  }

  if (pe == NULL)
    return;

  for (char** values = pe->values ; *values != NULL ; values++) {
    MunitParameter* next = p + 1;
    p->value = *values;
    if (next->name == NULL) {
      munit_test_runner_run_test_with_params(runner, test, params);
    } else {
      munit_test_runner_run_test_wild(runner, test, test_name, params, next);
    }
    if (runner->fatal_failures && (runner->report.failed != 0 || runner->report.errored != 0))
      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x41(%rbp)
je 0x13152
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1315b
jmp 0x1317d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x1316d
jmp 0x1317d
jmp 0x1316f
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x13138
cmpq $0x0, -0x30(%rbp)
jne 0x13189
jmp 0x13227
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0x13227
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x131db
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x127f0
jmp 0x131f4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %r8
callq 0x13110
movq -0x8(%rbp), %rax
testb $0x1, 0x5b(%rax)
je 0x13214
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x13212
movq -0x8(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0x13214
jmp 0x13227
jmp 0x13216
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0x13195
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_replace_stderr
static int
munit_replace_stderr (FILE* stderr_buf) {
  if (stderr_buf != NULL) {
    const int orig_stderr = dup(STDERR_FILENO);

    int errfd = fileno(stderr_buf);
    if (MUNIT_UNLIKELY(errfd == -1)) {
      exit (EXIT_FAILURE);
      }

    dup2(errfd, STDERR_FILENO);

    return orig_stderr;
  }

  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1331f
movl $0x2, %edi
callq 0x3110
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3210
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x1330a
movl $0x1, %edi
callq 0x3290
movl -0x18(%rbp), %edi
movl $0x2, %esi
callq 0x30e0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13326
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_test_runner_print_color
static void
munit_test_runner_print_color(const MunitTestRunner* runner, const char* string, char color) {
  if (runner->colorize)
    fprintf(MUNIT_OUTPUT_FILE, "\x1b[3%cm%s\x1b[39m", color, string);
  else
    fputs(string, MUNIT_OUTPUT_FILE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x58(%rax)
je 0x13571
movq 0xba7a(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
movsbl -0x11(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x75f9(%rip), %rsi      # 0x1ab61
movb $0x0, %al
callq 0x31e0
jmp 0x13584
movq -0x10(%rbp), %rdi
movq 0xba54(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
callq 0x3120
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_splice
static void
munit_splice(int from, int to) {
  uint8_t buf[1024];
#if !defined(_WIN32)
  ssize_t len ;
  ssize_t bytes_written;
#else
  int len;
  int bytes_written;
#endif
  do {
    len = read(from, buf, sizeof(buf));
    if (len > 0) {
      bytes_written = 0;
      do {
        bytes_written += write(to, buf + bytes_written, len - bytes_written);
        if (bytes_written < 0)
          break;
      } while (bytes_written < len);
    }
    else
      break;
  } while (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x3170
movq %rax, -0x418(%rbp)
cmpq $0x0, -0x418(%rbp)
jle 0x13653
movq $0x0, -0x420(%rbp)
movl -0x8(%rbp), %edi
leaq -0x410(%rbp), %rsi
addq -0x420(%rbp), %rsi
movq -0x418(%rbp), %rdx
subq -0x420(%rbp), %rdx
callq 0x30b0
addq -0x420(%rbp), %rax
movq %rax, -0x420(%rbp)
cmpq $0x0, -0x420(%rbp)
jge 0x1363f
jmp 0x13651
jmp 0x13641
movq -0x420(%rbp), %rax
cmpq -0x418(%rbp), %rax
jl 0x13601
jmp 0x13655
jmp 0x13663
jmp 0x13657
movb $0x1, %al
testb $0x1, %al
jne 0x135d1
jmp 0x13663
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_wall_clock_get_time
static void
munit_wall_clock_get_time(MunitWallClock* wallclock) {
#if MUNIT_WALL_TIME_METHOD == MUNIT_WALL_TIME_METHOD_CLOCK_GETTIME
  if (clock_gettime(CLOCK_MONOTONIC, wallclock) != 0) {
    fputs("Unable to get wall clock time\n", stderr);
    exit(EXIT_FAILURE);
  }
#elif MUNIT_WALL_TIME_METHOD == MUNIT_WALL_TIME_METHOD_QUERYPERFORMANCECOUNTER
  QueryPerformanceCounter(wallclock);
#elif MUNIT_WALL_TIME_METHOD == MUNIT_WALL_TIME_METHOD_GETTIMEOFDAY
  if (gettimeofday(wallclock, NULL) != 0) {
    fputs("Unable to get wall clock time\n", stderr);
    exit(EXIT_FAILURE);
  }
#elif MUNIT_WALL_TIME_METHOD == MUNIT_WALL_TIME_METHOD_MACH_ABSOLUTE_TIME
  *wallclock = mach_absolute_time();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x1, %edi
callq 0x30a0
cmpl $0x0, %eax
je 0x136af
movq 0xb95a(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
leaq 0x7484(%rip), %rdi      # 0x1ab24
callq 0x3120
movl $0x1, %edi
callq 0x3290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pajlada[P]st/st.c
// Function: tlinelen
int
tlinelen(int y)
{
	int i = term.col;

	if (term.line[y][i - 1].mode & ATTR_WRAP)
		return i;

	while (i > 0 && term.line[y][i - 1].u == ' ')
		--i;

	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl 0x137e7(%rip), %eax     # 0x19d54
movl %eax, -0xc(%rbp)
movq 0x137e1(%rip), %rax     # 0x19d58
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x4(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x65a5
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x65f4
jmp 0x65a7
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
jle 0x65da
movq 0x1379f(%rip), %rax     # 0x19d58
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x20, (%rax)
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x65e3
jmp 0x65ee
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x65a7
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pajlada[P]st/st.c
// Function: ttywrite
void
ttywrite(const char *s, size_t n, int may_echo)
{
	const char *next;

	if (may_echo && IS_SET(MODE_ECHO))
		twrite(s, n, 1);

	if (!IS_SET(MODE_CRLF)) {
		ttywriteraw(s, n);
		return;
	}

	/* This is similar to how the kernel handles ONLCR for ttys */
	while (n > 0) {
		if (*s == '\r') {
			next = s + 1;
			ttywriteraw("\r\n", 2);
		} else {
			next = memchr(s, '\r', n);
			DEFAULT(next, s + n);
			ttywriteraw(s, next - s);
		}
		n -= next - s;
		s = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x6fcb
movl 0x12ded(%rip), %eax     # 0x19d9c
andl $0x10, %eax
cmpl $0x0, %eax
je 0x6fcb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movl $0x1, %edx
callq 0x6e70
movl 0x12dcb(%rip), %eax     # 0x19d9c
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x6feb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x70a0
jmp 0x7095
jmp 0x6fed
cmpq $0x0, -0x10(%rbp)
jbe 0x7095
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x7023
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
leaq 0xb8ef(%rip), %rdi      # 0x12906
movl $0x2, %esi
callq 0x70a0
jmp 0x7072
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xd, %esi
callq 0x5120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x704a
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x7056
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
subq %rax, %rsi
callq 0x70a0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6fed
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pajlada[P]st/st.c
// Function: drawregion
void
drawregion(int x1, int y1, int x2, int y2)
{
	int y;

	for (y = y1; y < y2; y++) {
		if (!term.dirty[y])
			continue;

		term.dirty[y] = 0;
		xdrawline(term.line[y], x1, y, x2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x841f
movq 0x1198f(%rip), %rax     # 0x19d68
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x83e5
jmp 0x8414
movq 0x1197c(%rip), %rax     # 0x19d68
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq 0x1195a(%rip), %rax     # 0x19d58
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x4(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0xca90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x83ca
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pajlada[P]st/st.c
// Function: tscrollup
void
tscrollup(int orig, int n)
{
	int i;
	Line temp;

	LIMIT(n, 0, term.bot-orig+1);

	tclearregion(0, orig, term.col-1, orig+n-1);
	tsetdirt(orig+n, term.bot);

	for (i = orig; i <= term.bot-n; i++) {
		temp = term.line[i];
		term.line[i] = term.line[i+n];
		term.line[i+n] = temp;
	}

	selscroll(orig, -n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xb12b
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb15b
movl -0x8(%rbp), %eax
movl 0xec64(%rip), %ecx      # 0x19d98
subl -0x4(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0xb14f
movl 0xec54(%rip), %eax      # 0x19d98
subl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb155
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %esi
movl 0xebea(%rip), %edx      # 0x19d54
subl $0x1, %edx
movl -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
subl $0x1, %ecx
xorl %edi, %edi
callq 0x7e60
movl -0x4(%rbp), %edi
addl -0x8(%rbp), %edi
movl 0xec0f(%rip), %esi      # 0x19d98
callq 0x6000
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl 0xebfb(%rip), %ecx      # 0x19d98
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jg 0xb1fd
movq 0xebad(%rip), %rax      # 0x19d58
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0xeb9a(%rip), %rax      # 0x19d58
movl -0xc(%rbp), %ecx
addl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0xeb86(%rip), %rax      # 0x19d58
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0xeb73(%rip), %rax      # 0x19d58
movl -0xc(%rbp), %ecx
addl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb194
movl -0x4(%rbp), %edi
xorl %esi, %esi
subl -0x8(%rbp), %esi
callq 0xbd20
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pajlada[P]st/st.c
// Function: tscrolldown
void
tscrolldown(int orig, int n)
{
	int i;
	Line temp;

	LIMIT(n, 0, term.bot-orig+1);

	tsetdirt(orig, term.bot-n);
	tclearregion(0, term.bot-n+1, term.col-1, term.bot);

	for (i = term.bot; i >= orig+n; i--) {
		temp = term.line[i];
		term.line[i] = term.line[i-n];
		term.line[i-n] = temp;
	}

	selscroll(orig, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xb22b
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb25b
movl -0x8(%rbp), %eax
movl 0xeb64(%rip), %ecx      # 0x19d98
subl -0x4(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0xb24f
movl 0xeb54(%rip), %eax      # 0x19d98
subl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb255
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl 0xeb2e(%rip), %esi      # 0x19d98
subl -0x8(%rbp), %esi
callq 0x6000
movl 0xeb20(%rip), %esi      # 0x19d98
subl -0x8(%rbp), %esi
addl $0x1, %esi
movl 0xead0(%rip), %edx      # 0x19d54
subl $0x1, %edx
movl 0xeb0b(%rip), %ecx      # 0x19d98
xorl %edi, %edi
callq 0x7e60
movl 0xeafe(%rip), %eax      # 0x19d98
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jl 0xb303
movq 0xeaa7(%rip), %rax      # 0x19d58
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0xea94(%rip), %rax      # 0x19d58
movl -0xc(%rbp), %ecx
subl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0xea80(%rip), %rax      # 0x19d58
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0xea6d(%rip), %rax      # 0x19d58
movl -0xc(%rbp), %ecx
subl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb29d
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0xbd20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pajlada[P]st/x.c
// Function: xloadcols
void
xloadcols(void)
{
	int i;
	static int loaded;
	Color *cp;

	if (loaded) {
		for (cp = dc.col; cp < &dc.col[dc.collen]; ++cp)
			XftColorFree(xw.dpy, xw.vis, xw.cmap, cp);
	} else {
		dc.collen = MAX(LEN(colorname), 256);
		dc.col = xmalloc(dc.collen * sizeof(Color));
	}

	for (i = 0; i < dc.collen; i++)
		if (!xloadcolor(i, NULL, &dc.col[i])) {
			if (colorname[i])
				die("could not allocate color '%s'\n", colorname[i]);
			else
				die("could not allocate color %d\n", i);
		}
	loaded = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0xff8d(%rip)      # 0x1c12c
je 0xc1f8
movq 0xff88(%rip), %rax      # 0x1c130
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xff79(%rip), %rcx      # 0x1c130
movq 0xff7a(%rip), %rdx      # 0x1c138
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0xc1f6
movq 0x10057(%rip), %rdi     # 0x1c228
movq 0x100c8(%rip), %rsi     # 0x1c2a0
movq 0x10051(%rip), %rdx     # 0x1c230
movq -0x10(%rbp), %rcx
callq 0x55c0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0xc1ac
jmp 0xc21a
movq $0x104, 0xff35(%rip) # imm = 0x104
movq 0xff2e(%rip), %rdi      # 0x1c138
shlq $0x4, %rdi
callq 0x5a30
movq %rax, 0xff16(%rip)      # 0x1c130
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq 0xff0c(%rip), %rax      # 0x1c138
jae 0xc2a5
movl -0x4(%rbp), %edi
movq 0xfef8(%rip), %rdx      # 0x1c130
movslq -0x4(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xc2c0
cmpl $0x0, %eax
jne 0xc295
movslq -0x4(%rbp), %rcx
leaq 0xb494(%rip), %rax      # 0x176f0
cmpq $0x0, (%rax,%rcx,8)
je 0xc282
movslq -0x4(%rbp), %rcx
leaq 0xb482(%rip), %rax      # 0x176f0
movq (%rax,%rcx,8), %rsi
leaq 0x6cd7(%rip), %rdi      # 0x12f50
movb $0x0, %al
callq 0x5a80
jmp 0xc293
movl -0x4(%rbp), %esi
leaq 0x6ce3(%rip), %rdi      # 0x12f6f
movb $0x0, %al
callq 0x5a80
jmp 0xc295
jmp 0xc297
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xc221
movl $0x1, 0xfe7d(%rip)      # 0x1c12c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pajlada[P]st/x.c
// Function: xgetcolor
int
xgetcolor(int x, unsigned char *r, unsigned char *g, unsigned char *b)
{
	if (!BETWEEN(x, 0, dc.collen))
		return 1;

	*r = dc.col[x].color.red >> 8;
	*g = dc.col[x].color.green >> 8;
	*b = dc.col[x].color.blue >> 8;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jg 0xc427
movslq -0x8(%rbp), %rax
cmpq 0xfd13(%rip), %rax      # 0x1c138
jbe 0xc430
movl $0x1, -0x4(%rbp)
jmp 0xc49a
movq 0xfcf9(%rip), %rax      # 0x1c130
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x8(%rax), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq 0xfcd8(%rip), %rax      # 0x1c130
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0xa(%rax), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq 0xfcb7(%rip), %rax      # 0x1c130
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0xc(%rax), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pajlada[P]st/x.c
// Function: xresize
void
xresize(int col, int row)
{
	win.tw = col * win.cw;
	win.th = row * win.ch;

	XFreePixmap(xw.dpy, xw.buf);
	xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,
			DefaultDepth(xw.dpy, xw.scr));
	XftDrawChange(xw.draw, xw.buf);
	xclear(0, 0, win.w, win.h);

	/* resize to new width */
	xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
imull 0xc49c(%rip), %eax      # 0x1c344
movl %eax, 0xc482(%rip)      # 0x1c330
movl -0x8(%rbp), %eax
imull 0xc488(%rip), %eax      # 0x1c340
movl %eax, 0xc476(%rip)      # 0x1c334
movq 0xc363(%rip), %rdi      # 0x1c228
movq 0xc374(%rip), %rsi      # 0x1c240
callq 0x57d0
movq 0xc350(%rip), %rdi      # 0x1c228
movq 0xc359(%rip), %rsi      # 0x1c238
movl 0xc453(%rip), %edx      # 0x1c338
movl 0xc451(%rip), %ecx      # 0x1c33c
movq 0xc336(%rip), %rax      # 0x1c228
movq 0xe8(%rax), %rax
movslq 0xc418(%rip), %r8       # 0x1c318
shlq $0x7, %r8
addq %r8, %rax
movl 0x38(%rax), %r8d
callq 0x5840
movq %rax, 0xc329(%rip)      # 0x1c240
movq 0xc37a(%rip), %rdi      # 0x1c298
movq 0xc31b(%rip), %rsi      # 0x1c240
callq 0x56b0
movl 0xc408(%rip), %edx      # 0x1c338
movl 0xc406(%rip), %ecx      # 0x1c33c
xorl %esi, %esi
movl %esi, %edi
callq 0xf2d0
movq 0xc302(%rip), %rdi      # 0x1c248
movslq -0x4(%rbp), %rsi
shlq $0x4, %rsi
callq 0x5b30
movq %rax, 0xc2ee(%rip)      # 0x1c248
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/bulk_extract/main.c
// Function: main
int
main(int argc, char * argv[])
{
	struct sock_addr ** sas;
	int s;
	struct wire_requestqueue * Q;

	WARNP_INIT;

	/* Check number of arguments. */
	if (argc != 2) {
		fprintf(stderr, "usage: bulk_insert %s\n", "<socketname>");
		exit(1);
	}

	/* Resolve the socket address and connect. */
	if ((sas = sock_resolve(argv[1])) == NULL) {
		warnp("Error resolving socket address: %s", argv[1]);
		exit(1);
	}
	if (sas[0] == NULL) {
		warn0("No addresses found for %s", argv[1]);
		exit(1);
	}
	if ((s = sock_connect(sas)) == -1)
		exit(1);

	/* Create a request queue. */
	if ((Q = wire_requestqueue_init(s)) == NULL) {
		warnp("Cannot create packet write queue");
		exit(1);
	}

	/* Start RANGE request(s). */
	if (bulkextract(Q))
		exit(1);

	/* Free the request queue. */
	wire_requestqueue_destroy(Q);
	wire_requestqueue_free(Q);

	/* Free socket addresses. */
	sock_addr_freelist(sas);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x246c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x65c0
jmp 0x246e
cmpl $0x2, -0x8(%rbp)
je 0x249d
movq 0x12b7d(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xcb7f(%rip), %rsi      # 0xf004
leaq 0xcb8f(%rip), %rdx      # 0xf01b
movb $0x0, %al
callq 0x21e0
movl $0x1, %edi
callq 0x22d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4a10
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2505
jmp 0x24b6
callq 0x20a0
cmpl $0x0, (%rax)
je 0x24e3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xcb59(%rip), %rdi      # 0xf028
movb $0x0, %al
callq 0x6680
callq 0x20a0
movl $0x0, (%rax)
jmp 0x24f9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xcb36(%rip), %rdi      # 0xf028
movb $0x0, %al
callq 0x68d0
jmp 0x24fb
movl $0x1, %edi
callq 0x22d0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x253c
jmp 0x2511
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xcb2b(%rip), %rdi      # 0xf04b
movb $0x0, %al
callq 0x68d0
callq 0x20a0
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x22d0
movq -0x18(%rbp), %rdi
callq 0x58e0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x2557
movl $0x1, %edi
callq 0x22d0
movl -0x1c(%rbp), %edi
callq 0x9190
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x25aa
jmp 0x256b
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2590
leaq 0xcae9(%rip), %rdi      # 0xf065
movb $0x0, %al
callq 0x6680
callq 0x20a0
movl $0x0, (%rax)
jmp 0x259e
leaq 0xcace(%rip), %rdi      # 0xf065
movb $0x0, %al
callq 0x68d0
jmp 0x25a0
movl $0x1, %edi
callq 0x22d0
movq -0x28(%rbp), %rdi
callq 0x25f0
cmpl $0x0, %eax
je 0x25c2
movl $0x1, %edi
callq 0x22d0
movq -0x28(%rbp), %rdi
callq 0x9760
movq -0x28(%rbp), %rdi
callq 0x97a0
movq -0x18(%rbp), %rdi
callq 0x5640
xorl %edi, %edi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/bulk_extract/main.c
// Function: bulkextract
static int
bulkextract(struct wire_requestqueue * Q)
{
	struct bulkextract_state C;

	/* Initialize state. */
	C.Q = Q;
	C.failed = C.done = 0;

	/* Create null key (used as start and end of range). */
	if ((C.nullkey = kvldskey_create(NULL, 0)) == NULL)
		goto err0;

	/* Prepare benchmark time handling. */
	if ((C.B = bench_init(BENCHMARK_START, BENCHMARK_SECONDS)) == NULL) {
		warn0("bench_init");
		goto err1;
	}

	/* Launch the first RANGE request. */
	if (startrange(&C))
		goto err2;

	/* Wait until we've finished. */
	if (events_spin(&C.done) || C.failed) {
		warnp("RANGE request failed");
		goto err2;
	}

	/* Print median number of pairs read in a single second. */
	printf("%" PRIu64 "\n", bench_median(C.B));

	/* Clean up. */
	bench_free(C.B);
	kvldskey_free(C.nullkey);

	/* Success! */
	return (0);

err2:
	bench_free(C.B);
err1:
	kvldskey_free(C.nullkey);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x70e0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x262d
jmp 0x2711
movl $0x32, %edi
movl $0xa, %esi
callq 0x6b10
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2666
jmp 0x2648
leaq 0xca37(%rip), %rdi      # 0xf086
movb $0x0, %al
callq 0x68d0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2708
leaq -0x30(%rbp), %rdi
callq 0x2730
cmpl $0x0, %eax
je 0x2679
jmp 0x26ff
leaq -0x30(%rbp), %rdi
addq $0x14, %rdi
callq 0x2b10
cmpl $0x0, %eax
jne 0x2691
cmpl $0x0, -0x20(%rbp)
je 0x26ca
jmp 0x2693
callq 0x20a0
cmpl $0x0, (%rax)
je 0x26b8
leaq 0xc9ed(%rip), %rdi      # 0xf091
movb $0x0, %al
callq 0x6680
callq 0x20a0
movl $0x0, (%rax)
jmp 0x26c6
leaq 0xc9d2(%rip), %rdi      # 0xf091
movb $0x0, %al
callq 0x68d0
jmp 0x26c8
jmp 0x26ff
movq -0x18(%rbp), %rdi
callq 0x6f80
movq %rax, %rsi
leaq 0xc9c9(%rip), %rdi      # 0xf0a6
movb $0x0, %al
callq 0x2150
movq -0x18(%rbp), %rdi
callq 0x70a0
movq -0x28(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x2718
movq -0x18(%rbp), %rdi
callq 0x70a0
movq -0x28(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/bulk_extract/main.c
// Function: callback_range
static int
callback_range(void * cookie,
    const struct kvldskey * key, const struct kvldskey * value)
{
	struct bulkextract_state * C = cookie;

	(void)key; /* UNUSED */
	(void)value; /* UNUSED */

	/* Notify the benchmarking code, and check if we should quit. */
	if (bench_tick(C->B, &C->done)) {
		warnp("bench_tick");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x14, %rsi
callq 0x6d10
cmpl $0x0, %eax
je 0x27df
jmp 0x27a8
callq 0x20a0
cmpl $0x0, (%rax)
je 0x27cd
leaq 0xc8f2(%rip), %rdi      # 0xf0ab
movb $0x0, %al
callq 0x6680
callq 0x20a0
movl $0x0, (%rax)
jmp 0x27db
leaq 0xc8d7(%rip), %rdi      # 0xf0ab
movb $0x0, %al
callq 0x68d0
jmp 0x27dd
jmp 0x27e8
movl $0x0, -0x4(%rbp)
jmp 0x27ef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/bulk_extract/main.c
// Function: callback_done
static int
callback_done(void * cookie, int failed)
{
	struct bulkextract_state * C = cookie;
	int rc = 0;

	/* Did we fail? */
	if (failed) {
		C->failed = 1;
		C->done = 1;
	}

	/* Restart the RANGE requests. */
	if (!C->done)
		rc = startrange(C);

	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x283a
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x2850
movq -0x18(%rbp), %rdi
callq 0x2730
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: strlcpy2
int strlcpy2(char *dst, const char *src, int size) {
    char *orig = dst;
    if (size) {
	while (--size && (*dst = *src)) {
	    src++; dst++;
	}
	*dst = 0;
    }
    return dst - orig;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2cb4
jmp 0x2c5f
movl -0x14(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x2c8a
movq -0x10(%rbp), %rax
movb (%rax), %al
movq -0x8(%rbp), %rcx
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x2c93
jmp 0x2cad
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2c5f
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: Alert
void Alert(char *fmt, ...) {
    va_list argp;
    struct timeval tv;
    struct tm *tm;

    if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
	va_start(argp, fmt);

	gettimeofday(&tv, NULL);
	tm=localtime(&tv.tv_sec);
	fprintf(stderr, "[ALERT] %03d/%02d%02d%02d (%d) : ",
		tm->tm_yday, tm->tm_hour, tm->tm_min, tm->tm_sec, (int)getpid());
	vfprintf(stderr, fmt, argp);
	fflush(stderr);
	va_end(argp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x2d7b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movl 0xe634(%rip), %eax      # 0x113dc
andl $0x10, %eax
cmpl $0x0, %eax
je 0x2dc4
movl 0xe626(%rip), %eax      # 0x113dc
andl $0xc0, %eax
cmpl $0x0, %eax
je 0x2ea7
leaq -0x20(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21a0
leaq -0x30(%rbp), %rdi
callq 0x2060
movq %rax, -0x38(%rbp)
movq 0xe1ef(%rip), %rax      # 0x10ff8
movq (%rax), %rax
movq %rax, -0x108(%rbp)
movq -0x38(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x100(%rbp)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xfc(%rbp)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xf8(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xf4(%rbp)
callq 0x20f0
movq -0x108(%rbp), %rdi
movl -0x100(%rbp), %edx
movl -0xfc(%rbp), %ecx
movl -0xf8(%rbp), %r8d
movl -0xf4(%rbp), %r9d
leaq 0xb401(%rip), %rsi      # 0xe274
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2250
movq 0xe174(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2380
movq 0xe15d(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
callq 0x22d0
leaq -0x20(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: qfprintf
void qfprintf(FILE *out, char *fmt, ...) {
    va_list argp;

    if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) {
	va_start(argp, fmt);
	vfprintf(out, fmt, argp);
	fflush(out);
	va_end(argp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3058
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0xe35a(%rip), %eax      # 0x113dc
andl $0x10, %eax
cmpl $0x0, %eax
je 0x3098
movl 0xe34c(%rip), %eax      # 0x113dc
andl $0x40, %eax
cmpl $0x0, %eax
je 0x30da
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2380
movq -0x8(%rbp), %rdi
callq 0x22d0
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: str2sa
struct sockaddr_in *str2sa(char *str) {
    static struct sockaddr_in sa;
    char *c;
    int port;

    memset(&sa, 0, sizeof(sa));
    str=strdup(str);

    if ((c=strrchr(str,':')) != NULL) {
	*c++=0;
	port=atol(c);
    }
    else
	port=0;

    if (*str == '*' || *str == '\0') { /* INADDR_ANY */
	sa.sin_addr.s_addr = INADDR_ANY;
    }
    else if (!inet_pton(AF_INET, str, &sa.sin_addr)) {
	struct hostent *he;

	if ((he = gethostbyname(str)) == NULL) {
	    Alert("Invalid server name: '%s'\n", str);
	}
	else
	    sa.sin_addr = *(struct in_addr *) *(he->h_addr_list);
    }
    sa.sin_port=htons(port);
    sa.sin_family=AF_INET;

    free(str);
    return &sa;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xe2f5(%rip), %rdi      # 0x113f8
xorl %esi, %esi
movl $0x10, %edx
callq 0x21c0
movq -0x8(%rbp), %rdi
callq 0x2420
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3a, %esi
callq 0x2190
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3154
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2350
movl %eax, -0x14(%rbp)
jmp 0x315b
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
je 0x3173
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x317f
movl $0x0, 0xe27f(%rip)      # 0x113fc
jmp 0x31db
movq -0x8(%rbp), %rsi
movl $0x2, %edi
leaq 0xe269(%rip), %rdx      # 0x113f8
addq $0x4, %rdx
callq 0x2280
cmpl $0x0, %eax
jne 0x31d9
movq -0x8(%rbp), %rdi
callq 0x2240
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x31c4
movq -0x8(%rbp), %rsi
leaq 0xb0ff(%rip), %rdi      # 0xe2ba
movb $0x0, %al
callq 0x2d40
jmp 0x31d7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, 0xe225(%rip)      # 0x113fc
jmp 0x31d9
jmp 0x31db
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x2140
movw %ax, 0xe20d(%rip)       # 0x113fa
movw $0x2, 0xe202(%rip)      # 0x113f8
movq -0x8(%rbp), %rdi
callq 0x2040
leaq 0xe1f2(%rip), %rax      # 0x113f8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: str2net
int str2net(char *str, struct in_addr *addr, struct in_addr *mask) {
    char *c;
    unsigned long len;

    memset(mask, 0, sizeof(*mask));
    memset(addr, 0, sizeof(*addr));
    str=strdup(str);

    if ((c = strrchr(str, '/')) != NULL) {
	*c++ = 0;
        /* c points to the mask */
	if (strchr(c, '.') != NULL) {	    /* dotted notation */
	    if (!inet_pton(AF_INET, c, mask))
		return 0;
	}
	else { /* mask length */
	    char *err;
	    len = strtol(c, &err, 10);
	    if (!*c || (err && *err) || (unsigned)len > 32)
		return 0;
	    if (len)
		mask->s_addr = htonl(0xFFFFFFFFUL << (32 - len));
	    else
		mask->s_addr = 0;
	}
    }
    else {
	mask->s_addr = 0xFFFFFFFF;
    }
    if (!inet_pton(AF_INET, str, addr)) {
	struct hostent *he;

	if ((he = gethostbyname(str)) == NULL) {
	    return 0;
	}
	else
	    *addr = *(struct in_addr *) *(he->h_addr_list);
    }
    free(str);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x21c0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x21c0
movq -0x10(%rbp), %rdi
callq 0x2420
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x2190
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3336
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, (%rax)
movq -0x28(%rbp), %rdi
movl $0x2e, %esi
callq 0x2160
cmpq $0x0, %rax
je 0x32b8
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x2, %edi
callq 0x2280
cmpl $0x0, %eax
jne 0x32b6
movl $0x0, -0x4(%rbp)
jmp 0x3398
jmp 0x3334
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0xa, %edx
callq 0x2260
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x32f3
cmpq $0x0, -0x38(%rbp)
je 0x32ea
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x32f3
movq -0x30(%rbp), %rax
cmpl $0x20, %eax
jbe 0x32ff
movl $0x0, -0x4(%rbp)
jmp 0x3398
cmpq $0x0, -0x30(%rbp)
je 0x3328
movl $0x20, %ecx
subq -0x30(%rbp), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shlq %cl, %rax
movl %eax, %edi
callq 0x21b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x3332
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
jmp 0x3334
jmp 0x3340
movq -0x20(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x2, %edi
callq 0x2280
cmpl $0x0, %eax
jne 0x3388
movq -0x10(%rbp), %rdi
callq 0x2240
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x3373
movl $0x0, -0x4(%rbp)
jmp 0x3398
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
jmp 0x3388
movq -0x10(%rbp), %rdi
callq 0x2040
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: tv_delta
unsigned long tv_delta(struct timeval *tv1, struct timeval *tv2) {
    int cmp;
    unsigned long ret;
  

    cmp = tv_cmp(tv1, tv2);
    if (!cmp)
	return 0; /* same dates, null diff */
    else if (cmp < 0) {
	struct timeval *tmp = tv1;
	tv1 = tv2;
	tv2 = tmp;
    }
    ret = (tv1->tv_sec - tv2->tv_sec) * 1000;
    if (tv1->tv_usec > tv2->tv_usec)
	ret += (tv1->tv_usec - tv2->tv_usec) / 1000;
    else
	ret -= (tv2->tv_usec - tv1->tv_usec) / 1000;
    return (unsigned long) ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x37f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x3743
movq $0x0, -0x8(%rbp)
jmp 0x37e2
cmpl $0x0, -0x1c(%rbp)
jge 0x3761
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3763
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
subq (%rcx), %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0x37b2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x8(%rcx), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x37da
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x8(%rcx), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: tv_cmp
static inline int tv_cmp(struct timeval *tv1, struct timeval *tv2) {
    if (tv1->tv_sec < tv2->tv_sec)
	return -1;
    else if (tv1->tv_sec > tv2->tv_sec)
	return 1;
    else if (tv1->tv_usec < tv2->tv_usec)
	return -1;
    else if (tv1->tv_usec > tv2->tv_usec)
	return 1;
    else
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x3815
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x386b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jle 0x382e
movl $0x1, -0x4(%rbp)
jmp 0x386b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x3849
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x386b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0x3864
movl $0x1, -0x4(%rbp)
jmp 0x386b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: tv_iseternity
static inline int tv_iseternity(struct timeval *tv) {
    if (tv->tv_sec == 0 && tv->tv_usec == 0)
	return 1;
    else
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3b46
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3b46
movl $0x1, -0x4(%rbp)
jmp 0x3b4d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: tv_cmp2
static int tv_cmp2(struct timeval *tv1, struct timeval *tv2) {
    if (tv_iseternity(tv1))
	if (tv_iseternity(tv2))
	    return 0; /* same */
	else
	    return 1; /* tv1 later than tv2 */
    else if (tv_iseternity(tv2))
	return -1; /* tv2 later than tv1 */
    
    if (tv1->tv_sec > tv2->tv_sec)
	return 1;
    else if (tv1->tv_sec < tv2->tv_sec)
	return -1;
    else if (tv1->tv_usec > tv2->tv_usec)
	return 1;
    else if (tv1->tv_usec < tv2->tv_usec)
	return -1;
    else
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b20
cmpl $0x0, %eax
je 0x3be4
movq -0x18(%rbp), %rdi
callq 0x3b20
cmpl $0x0, %eax
je 0x3bd8
movl $0x0, -0x4(%rbp)
jmp 0x3c6c
movl $0x1, -0x4(%rbp)
jmp 0x3c6c
movq -0x18(%rbp), %rdi
callq 0x3b20
cmpl $0x0, %eax
je 0x3bfb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3c6c
jmp 0x3bfd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jle 0x3c16
movl $0x1, -0x4(%rbp)
jmp 0x3c6c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x3c2f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3c6c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0x3c4a
movl $0x1, -0x4(%rbp)
jmp 0x3c6c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x3c65
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3c6c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: tv_delayfrom
static struct timeval *tv_delayfrom(struct timeval *tv, struct timeval *from, int ms) {
    if (!tv || !from)
	return NULL;
    tv->tv_usec = from->tv_usec + (ms%1000)*1000;
    tv->tv_sec  = from->tv_sec  + (ms/1000);
    while (tv->tv_usec >= 1000000) {
	tv->tv_usec -= 1000000;
	tv->tv_sec++;
    }
    return tv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x404d
cmpq $0x0, -0x18(%rbp)
jne 0x4057
movq $0x0, -0x8(%rbp)
jmp 0x40d4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0x1c(%rbp), %eax
movl $0x3e8, %esi            # imm = 0x3E8
cltd
idivl %esi
imull $0x3e8, %edx, %eax      # imm = 0x3E8
cltq
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movl -0x1c(%rbp), %eax
movl $0x3e8, %esi            # imm = 0x3E8
cltd
idivl %esi
cltq
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0xf4240, 0x8(%rax)     # imm = 0xF4240
jl 0x40cc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0xf4240, %rcx          # imm = 0xF4240
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x409b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: task_wakeup
static inline struct task *task_wakeup(struct task **q, struct task *t) {
    if (t->state == TASK_RUNNING)
	return t;
    else {
	t->rqnext = *q;
	t->state = TASK_RUNNING;
	return *q = t;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x4130
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4159
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: client_retnclose
void client_retnclose(struct session *s, int len, const char *msg) {
    my_fd_clr(s->cli_fd, StaticReadEvent);
    my_fd_set(s->cli_fd, StaticWriteEvent);
    tv_eternity(&s->crexpire);
    tv_delayfrom(&s->cwexpire, &now, s->proxy->clitimeout);
    shutdown(s->cli_fd, SHUT_RD);
    s->cli_state = CL_STDATA;
    strcpy(s->rep->data, msg);
    s->rep->l = len;
    s->rep->r = s->rep->h = s->rep->lr = s->rep->w = s->rep->data;
    s->rep->r += len;
    s->req->l = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %edi
movq 0xcce7(%rip), %rsi      # 0x11408
callq 0x3fd0
movq -0x8(%rbp), %rax
movl 0x48(%rax), %edi
movq 0x2ccfc(%rip), %rsi     # 0x31430
callq 0x4810
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x40e0
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x30(%rax), %edx
leaq 0xccb0(%rip), %rsi      # 0x11410
callq 0x4030
movq -0x8(%rbp), %rax
movl 0x48(%rax), %edi
xorl %esi, %esi
callq 0x2110
movq -0x8(%rbp), %rax
movl $0x3, 0x4c(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2090
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wtarreau[P]httpterm/httpterm.c
// Function: client_return
void client_return(struct session *s, int len, const char *msg) {
    my_fd_set(s->cli_fd, StaticWriteEvent);
    tv_delayfrom(&s->cwexpire, &now, s->proxy->clitimeout);
    strcpy(s->rep->data, msg);
    s->rep->l = len;
    s->rep->r = s->rep->h = s->rep->lr = s->rep->w = s->rep->data;
    s->rep->r += len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %edi
movq 0x2cbcf(%rip), %rsi     # 0x31430
callq 0x4810
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x30(%rax), %edx
leaq 0xcb90(%rip), %rsi      # 0x11410
callq 0x4030
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2090
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)