LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-ctrl.c
// Function: query_dec_mode
static bool query_dec_mode(int mode)
{
  printf("\x1b[?%d$p", mode);

  char *s = NULL;
  do {
    if(s)
      free(s);
    s = read_csi();

    /* expect "?" mode ";" value "$y" */

    int reply_mode, reply_value;
    char reply_cmd;
    /* If the sscanf format string ends in a literal, we can't tell from
     * its return value if it matches. Hence we'll %c the cmd and check it
     * explicitly
     */
    if(sscanf(s, "?%d;%d$%c", &reply_mode, &reply_value, &reply_cmd) < 3)
      continue;
    if(reply_cmd != 'y')
      continue;

    if(reply_mode != mode)
      continue;

    free(s);

    if(reply_value == 1 || reply_value == 3)
      return true;
    if(reply_value == 2 || reply_value == 4)
      return false;

    printf("Unrecognised reply to DECRQM: %d\n", reply_value);
    return false;
  } while(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0x67c(%rip), %rdi       # 0x22b1
movb $0x0, %al
callq 0x1050
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1c54
movq -0x10(%rbp), %rdi
callq 0x1030
callq 0x1d00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x651(%rip), %rsi       # 0x22b9
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x19(%rbp), %r8
movb $0x0, %al
callq 0x1090
cmpl $0x3, %eax
jge 0x1c82
jmp 0x1cdb
movsbl -0x19(%rbp), %eax
cmpl $0x79, %eax
je 0x1c8d
jmp 0x1cdb
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x1c97
jmp 0x1cdb
movq -0x10(%rbp), %rdi
callq 0x1030
cmpl $0x1, -0x18(%rbp)
je 0x1cac
cmpl $0x3, -0x18(%rbp)
jne 0x1cb2
movb $0x1, -0x1(%rbp)
jmp 0x1ce7
cmpl $0x2, -0x18(%rbp)
je 0x1cbe
cmpl $0x4, -0x18(%rbp)
jne 0x1cc4
movb $0x0, -0x1(%rbp)
jmp 0x1ce7
movl -0x18(%rbp), %esi
leaq 0x5f5(%rip), %rdi       # 0x22c3
movb $0x0, %al
callq 0x1050
movb $0x0, -0x1(%rbp)
jmp 0x1ce7
movb $0x1, %al
testb $0x1, %al
jne 0x1c44
jmp 0x1ce7
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-ctrl.c
// Function: read_csi
static char *read_csi(void)
{
  await_c1(0x9B); // CSI

  /* TODO: This really should be a more robust CSI parser
   */
  char csi[32];
  int i = 0;
  for(; i < sizeof(csi)-1; i++) {
    char c = csi[i] = getchar();
    if(c >= 0x40 && c <= 0x7e)
      break;
  }
  csi[++i] = 0;

  // TODO: returns longer than 32?

  return strdup(csi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x9b, %edi
callq 0x1d80
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq $0x1f, %rax
jae 0x1d54
callq 0x1070
movslq -0x24(%rbp), %rcx
movb %al, -0x20(%rbp,%rcx)
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x40, %eax
jl 0x1d47
movsbl -0x25(%rbp), %eax
cmpl $0x7e, %eax
jg 0x1d47
jmp 0x1d54
jmp 0x1d49
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1d19
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
cltq
movb $0x0, -0x20(%rbp,%rax)
leaq -0x20(%rbp), %rdi
callq 0x10e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-ctrl.c
// Function: await_c1
static void await_c1(unsigned char c1)
{
  unsigned char c;

  /* await CSI - 8bit or 2byte 7bit form */
  bool in_esc = false;
  while((c = getchar())) {
    if(c == c1)
      break;
    if(in_esc && c == (char)(c1 - 0x40))
      break;
    if(!in_esc && c == 0x1b)
      in_esc = true;
    else
      in_esc = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, -0x3(%rbp)
callq 0x1070
movb %al, -0x2(%rbp)
cmpb $0x0, %al
je 0x1de1
movzbl -0x2(%rbp), %eax
movzbl -0x1(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1dac
jmp 0x1de1
testb $0x1, -0x3(%rbp)
je 0x1dc6
movzbl -0x2(%rbp), %eax
movzbl -0x1(%rbp), %ecx
subl $0x40, %ecx
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x1dc6
jmp 0x1de1
testb $0x1, -0x3(%rbp)
jne 0x1ddb
movzbl -0x2(%rbp), %eax
cmpl $0x1b, %eax
jne 0x1ddb
movb $0x1, -0x3(%rbp)
jmp 0x1ddf
movb $0x0, -0x3(%rbp)
jmp 0x1d92
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-ctrl.c
// Function: read_dcs
static char *read_dcs(void)
{
  await_c1(0x90);

  char dcs[32];
  bool in_esc = false;
  int i = 0;
  for(; i < sizeof(dcs)-1; ) {
    unsigned char c = getchar();
    if(c == 0x9c) // ST
      break;
    if(in_esc && c == 0x5c)
      break;
    if(!in_esc && c == 0x1b)
      in_esc = true;
    else {
      dcs[i++] = c;
      in_esc = false;
    }
  }
  dcs[++i] = 0;

  return strdup(dcs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x90, %edi
callq 0x1d80
movb $0x0, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
cmpq $0x1f, %rax
jae 0x1e6c
callq 0x1070
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x9c, %eax
jne 0x1e2c
jmp 0x1e6c
testb $0x1, -0x21(%rbp)
je 0x1e3d
movzbl -0x29(%rbp), %eax
cmpl $0x5c, %eax
jne 0x1e3d
jmp 0x1e6c
testb $0x1, -0x21(%rbp)
jne 0x1e52
movzbl -0x29(%rbp), %eax
cmpl $0x1b, %eax
jne 0x1e52
movb $0x1, -0x21(%rbp)
jmp 0x1e6a
movb -0x29(%rbp), %cl
movl -0x28(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x28(%rbp)
cltq
movb %cl, -0x20(%rbp,%rax)
movb $0x0, -0x21(%rbp)
jmp 0x1e0d
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
cltq
movb $0x0, -0x20(%rbp,%rax)
leaq -0x20(%rbp), %rdi
callq 0x10e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-aof.c
// Function: consumeNewline
int consumeNewline(char *buf) {
    if (strncmp(buf,"\r\n",2) != 0) {
        ERROR("Expected \\r\\n, got: %02x%02x",buf[0],buf[1]);
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd7a(%rip), %rsi       # 0x2004
movl $0x2, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x12e9
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %ecx
leaq 0xd51(%rip), %rsi       # 0x2007
movb $0x0, %al
callq 0x1140
movq 0x321c(%rip), %rdx      # 0x44e0
leaq -0x410(%rbp), %rcx
leaq 0x2e0e(%rip), %rdi      # 0x40e0
leaq 0xd4b(%rip), %rsi       # 0x2024
movb $0x0, %al
callq 0x1140
movl $0x0, -0x4(%rbp)
jmp 0x12f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-aof.c
// Function: readLong
int readLong(FILE *fp, char prefix, long *target) {
    char buf[128], *eptr;

    epos = ftello(fp);

    // 读入行
    if (fgets(buf,sizeof(buf),fp) == NULL) {
        return 0;
    }

    // 确保前缀相同
    if (buf[0] != prefix) {
        ERROR("Expected prefix '%c', got: '%c'",buf[0],prefix);
        return 0;
    }

    // 将字符串转换成 long 值
    *target = strtol(buf+1,&eptr,10);

    return consumeNewline(eptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4b0, %rsp            # imm = 0x4B0
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, 0x31b7(%rip)      # 0x44e0
leaq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x80, %esi
callq 0x10b0
cmpq $0x0, %rax
jne 0x1350
movl $0x0, -0x4(%rbp)
jmp 0x13e0
movsbl -0xa0(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x13ab
leaq -0x4b0(%rbp), %rdi
movsbl -0xa0(%rbp), %edx
movsbl -0x11(%rbp), %ecx
leaq 0xcb9(%rip), %rsi       # 0x2031
movb $0x0, %al
callq 0x1140
movq 0x315a(%rip), %rdx      # 0x44e0
leaq -0x4b0(%rbp), %rcx
leaq 0x2d4c(%rip), %rdi      # 0x40e0
leaq 0xc89(%rip), %rsi       # 0x2024
movb $0x0, %al
callq 0x1140
movl $0x0, -0x4(%rbp)
jmp 0x13e0
leaq -0xa0(%rbp), %rdi
addq $0x1, %rdi
leaq -0xa8(%rbp), %rsi
movl $0xa, %edx
callq 0x10f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0xa8(%rbp), %rdi
callq 0x1270
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x4b0, %rsp            # imm = 0x4B0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-aof.c
// Function: readBytes
int readBytes(FILE *fp, char *target, long length) {
    long real;

    epos = ftello(fp);

    real = fread(target,1,length,fp);
    if (real != length) {
        ERROR("Expected to read %ld bytes, got %ld bytes",length,real);
        return 0;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, 0x30c9(%rip)      # 0x44e0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x1060
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x1484
leaq -0x430(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0xc00(%rip), %rsi       # 0x2051
movb $0x0, %al
callq 0x1140
movq 0x3081(%rip), %rdx      # 0x44e0
leaq -0x430(%rbp), %rcx
leaq 0x2c73(%rip), %rdi      # 0x40e0
leaq 0xbb0(%rip), %rsi       # 0x2024
movb $0x0, %al
callq 0x1140
movl $0x0, -0x4(%rbp)
jmp 0x148b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-aof.c
// Function: readString
int readString(FILE *fp, char** target) {

    // 读取字符串的长度
    long len;
    *target = NULL;
    if (!readLong(fp,'$',&len)) {
        return 0;
    }

    /* Increase length to also consume \r\n */
    len += 2;

    // 为字符串分配空间
    *target = (char*)malloc(len);

    // 读取内容
    if (!readBytes(fp,*target,len)) {
        return 0;
    }

    // 确认 \r\n
    if (!consumeNewline(*target+len-2)) {
        return 0;
    }

    (*target)[len-2] = '\0';

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x24, %esi
leaq -0x20(%rbp), %rdx
callq 0x1300
cmpl $0x0, %eax
jne 0x14db
movl $0x0, -0x4(%rbp)
jmp 0x1558
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1110
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x13f0
cmpl $0x0, %eax
jne 0x151c
movl $0x0, -0x4(%rbp)
jmp 0x1558
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq -0x20(%rbp), %rdi
addq $-0x2, %rdi
callq 0x1270
cmpl $0x0, %eax
jne 0x153e
movl $0x0, -0x4(%rbp)
jmp 0x1558
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x2, %rcx
movb $0x0, (%rax,%rcx)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/CD.c
// Function: main
int main(int argc, char *argv[])
{
    char lines[argc+1][255];
    char cwd[100];
    predealLine(argc, argv, lines);
    if(argc!=2)
    {
		printf("参数数目不正确.\n");
		return 0; 
    }
    if(!chdir(lines[1]))
    {
		printf("当前工作文件夹改变到：");
        if(getcwd(cwd,sizeof(cwd)) != NULL)
	{
		puts(cwd);  
	}
	else
	{
		perror("getcwd");
	}
    }
    else
    {
		perror("chdir"); 
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %rdx    # imm = 0x1FFFFFFFFF0
andq %rdx, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0xa0(%rbp)
movq %rdx, %rsp
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x11b0
cmpl $0x2, -0x8(%rbp)
je 0x13d7
leaq 0xc47(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1060
movl $0x0, -0x4(%rbp)
movl $0x1, -0x94(%rbp)
jmp 0x144d
movq -0xa0(%rbp), %rdi
addq $0xff, %rdi
callq 0x1050
cmpl $0x0, %eax
jne 0x1430
leaq 0xc26(%rip), %rdi       # 0x201c
movb $0x0, %al
callq 0x1060
leaq -0x90(%rbp), %rdi
movl $0x64, %esi
callq 0x1070
cmpq $0x0, %rax
je 0x1422
leaq -0x90(%rbp), %rdi
callq 0x1030
jmp 0x142e
leaq 0xc15(%rip), %rdi       # 0x203e
callq 0x1090
jmp 0x143c
leaq 0xc0e(%rip), %rdi       # 0x2045
callq 0x1090
movl $0x0, -0x4(%rbp)
movl $0x1, -0x94(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/main.c
// Function: main
int main(int argc, char *argv[])
{
	int ret;
	int sd;

	ret = parse_cmdline(argc, argv, &server_config);
	if (ret < 0)
		return 1;

	printf("port: %hu\n", server_config.port);

	ret = server_init();
	if (ret < 0)
		return 2;
	sd = setup_ctrl(&server_config);
	if (sd < 0)
		return 2;

	ret = server_loop(sd);
	if (ret < 0)
		return 3;
	if (ret > 0) /* child */
		ret = ctrl_main(sd);

	close(sd);
	return ret ? 3 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x3dac(%rip), %rdx      # 0x5160
callq 0x1470
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x13ce
movl $0x1, -0x4(%rbp)
jmp 0x145e
movzwl 0x3d8b(%rip), %esi      # 0x5160
leaq 0x1c36(%rip), %rdi      # 0x3012
movb $0x0, %al
callq 0x10c0
callq 0x15b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x13fa
movl $0x2, -0x4(%rbp)
jmp 0x145e
leaq 0x3d5f(%rip), %rdi      # 0x5160
callq 0x1600
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x1418
movl $0x2, -0x4(%rbp)
jmp 0x145e
movl -0x18(%rbp), %edi
callq 0x17a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1432
movl $0x3, -0x4(%rbp)
jmp 0x145e
cmpl $0x0, -0x14(%rbp)
jle 0x1443
movl -0x18(%rbp), %edi
callq 0x1830
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %edi
callq 0x1110
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl $0x3, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/main.c
// Function: parse_cmdline
static int parse_cmdline(int argc, char *argv[], struct server_config *config)
{
	unsigned long val;
	int ret;
	int c;

	while ((c = getopt_long(argc, argv, opts, long_opts, NULL)) != -1) {
		switch(c) {
                case 'h':
                        fputs(help_text, stdout);
                        exit(0);
		case 'p':
			ret = parse_ulong_range("port", optarg, &val,
						0, USHRT_MAX);
			if (ret < 0)
				return -EINVAL;
			config->port = val;
			break;
		case '?':
			fputs("\nUsage:", stdout);
			fputs(help_text, stdout);
			return -EINVAL;
		default:
			fprintf(stderr, "unknown option '-%c'\n", c);
			return -EINVAL;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq 0x3cc7(%rip), %rdx      # 0x5158
leaq 0x38d8(%rip), %rcx      # 0x4d70
xorl %eax, %eax
movl %eax, %r8d
callq 0x1090
movl %eax, -0x28(%rbp)
cmpl $-0x1, %eax
je 0x1593
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x3f, %eax
je 0x1535
jmp 0x14bb
movl -0x2c(%rbp), %eax
subl $0x68, %eax
je 0x14d2
jmp 0x14c5
movl -0x2c(%rbp), %eax
subl $0x70, %eax
je 0x14ef
jmp 0x156a
movq 0x3c8f(%rip), %rdi      # 0x5168
movq 0x3af0(%rip), %rax      # 0x4fd0
movq (%rax), %rsi
callq 0x10e0
xorl %edi, %edi
callq 0x1200
movq 0x3ae2(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1b0d(%rip), %rdi      # 0x300d
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0xffff, %r8d           # imm = 0xFFFF
callq 0x2980
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x1525
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x159a
movq -0x20(%rbp), %rax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
jmp 0x158e
movq 0x3a94(%rip), %rax      # 0x4fd0
movq (%rax), %rsi
leaq 0x1ad7(%rip), %rdi      # 0x301d
callq 0x10e0
movq 0x3c16(%rip), %rdi      # 0x5168
movq 0x3a77(%rip), %rax      # 0x4fd0
movq (%rax), %rsi
callq 0x10e0
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x159a
movq 0x3a87(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl -0x28(%rbp), %edx
leaq 0x1aa7(%rip), %rsi      # 0x3025
movb $0x0, %al
callq 0x1130
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x159a
jmp 0x1483
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/main.c
// Function: server_init
static int server_init(void)
{
	int ret;

	ret = ignore_signal(SIGPIPE);
	if (ret < 0)
		return ret;
	ret = ignore_signal(SIGCHLD);
	if (ret < 0)
		return ret;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xd, %edi
callq 0x2c00
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x15d3
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15f5
movl $0x11, %edi
callq 0x2c00
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x15ee
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15f5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/main.c
// Function: setup_ctrl
static int setup_ctrl(const struct server_config *config)
{
	struct sockaddr_in6 addr = {
		.sin6_family	= AF_INET6,
		.sin6_port	= htons(config->port),
		.sin6_addr	= IN6ADDR_ANY_INIT,
	};
	int val;
	int ret;
	int sd;

	sd = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
	if (sd < 0) {
		ret = -errno;
		perror("socket");
		return ret;
	}

	val = 0;
	ret = setsockopt(sd, SOL_IPV6, IPV6_V6ONLY, &val, sizeof(val));
	if (ret < 0) {
		ret = -errno;
		perror("setsockopt(IPV6_V6ONLY)");
		return ret;
	}
	val = 1;
	ret = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
	if (ret < 0) {
		ret = -errno;
		perror("setsockopt(SO_REUSEADDR)");
		return ret;
	}

	ret = bind(sd, (struct sockaddr *)&addr, sizeof(addr));
	if (ret < 0) {
		ret = -errno;
		perror("bind");
		return ret;
	}
	ret = listen(sd, 16);
	if (ret < 0) {
		ret = -errno;
		perror("listen");
		return ret;
	}

	return sd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
movl $0x1c, %edx
callq 0x1100
movw $0xa, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %edi
callq 0x10a0
movw %ax, -0x2a(%rbp)
movl $0xa, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x1270
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0x1675
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x34(%rbp)
leaq 0x1c7b(%rip), %rdi      # 0x32e0
callq 0x11a0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1792
movl $0x0, -0x30(%rbp)
movl -0x38(%rbp), %edi
movl $0x29, %esi
movl $0x1a, %edx
leaq -0x30(%rbp), %rcx
movl $0x4, %r8d
callq 0x1070
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x16c7
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x34(%rbp)
leaq 0x1c30(%rip), %rdi      # 0x32e7
callq 0x11a0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1792
movl $0x1, -0x30(%rbp)
movl -0x38(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x30(%rbp), %rcx
movl $0x4, %r8d
callq 0x1070
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x1716
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x34(%rbp)
leaq 0x1bf6(%rip), %rdi      # 0x32ff
callq 0x11a0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1792
movl -0x38(%rbp), %edi
leaq -0x2c(%rbp), %rsi
movl $0x1c, %edx
callq 0x1180
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x1753
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x34(%rbp)
leaq 0x1bd2(%rip), %rdi      # 0x3318
callq 0x11a0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1792
movl -0x38(%rbp), %edi
movl $0x10, %esi
callq 0x1140
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x178c
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x34(%rbp)
leaq 0x1b9e(%rip), %rdi      # 0x331d
callq 0x11a0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1792
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/main.c
// Function: server_loop
static int server_loop(int sd)
{
	pid_t cpid;
	int csd;
	int ret;

	while (true) {
		csd = accept(sd, NULL, NULL);
		if (csd < 0) {
			ret = -errno;
			perror("accept");
			return ret;
		}
		cpid = fork();
		if (cpid < 0) {
			perror("fork");
			continue;
		}
		if (cpid == 0) { /* child */
			close(sd);
			ctrl_main(csd);
			exit(0);
		}

		close(csd);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x11c0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x17e7
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x10(%rbp)
leaq 0x1b4b(%rip), %rdi      # 0x3324
callq 0x11a0
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
callq 0x1260
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x1803
leaq 0x1b2f(%rip), %rdi      # 0x332b
callq 0x11a0
jmp 0x17ab
cmpl $0x0, -0x8(%rbp)
jne 0x1820
movl -0x4(%rbp), %edi
callq 0x1110
movl -0xc(%rbp), %edi
callq 0x1830
xorl %edi, %edi
callq 0x1200
movl -0xc(%rbp), %edi
callq 0x1110
jmp 0x17ab
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/control.c
// Function: ctrl_main
int ctrl_main(int ctrl_sd)
{
	int ret;
	int sd;

	config.ctrl_sd = ctrl_sd;
	ret = ctrl_get_config(&config);
	if (ret < 0)
		goto out_close;
	ret = prepare_buffers(&config);
	if (ret < 0)
		goto out_close;
	sd = setup_listener(&config);
	if (sd < 0) {
		ret = sd;
		goto out_buffers;
	}
	ret = ctrl_send_start(&config);
	if (ret < 0) {
		close(sd);
		goto out_close;
	}
	ret = ctrl_run_test(sd, &config);
	close(sd);
	if (ret < 0)
		goto out_close;
	ret = ctrl_send_end(&config);

out_buffers:
	cleanup_buffers(&config);
out_close:
	close(ctrl_sd);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x3964(%rip)      # 0x51a8
leaq 0x392d(%rip), %rdi      # 0x5178
callq 0x1900
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x185e
jmp 0x18ee
leaq 0x3913(%rip), %rdi      # 0x5178
callq 0x1a40
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x1875
jmp 0x18ee
leaq 0x38fc(%rip), %rdi      # 0x5178
callq 0x1b70
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x1892
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x18e2
leaq 0x38df(%rip), %rdi      # 0x5178
callq 0x1dc0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x18b1
movl -0xc(%rbp), %edi
callq 0x1110
jmp 0x18ee
movl -0xc(%rbp), %edi
leaq 0x38bd(%rip), %rsi      # 0x5178
callq 0x1e60
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %edi
callq 0x1110
cmpl $0x0, -0x8(%rbp)
jge 0x18d3
jmp 0x18ee
leaq 0x389e(%rip), %rdi      # 0x5178
callq 0x1fe0
movl %eax, -0x8(%rbp)
leaq 0x388f(%rip), %rdi      # 0x5178
callq 0x2110
movl -0x4(%rbp), %edi
callq 0x1110
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/control.c
// Function: ctrl_get_config
static int ctrl_get_config(struct server_ctrl_config *config)
{
	long page_size;
	int ret;

	page_size = sysconf(_SC_PAGESIZE);
	if (page_size < 0)
		return -EFAULT;

	ret = ctrl_recv_msg(config->ctrl_sd, &client_msg, sizeof(client_msg));
	if (ret < 0) {
		close(config->ctrl_sd);
		return -EINVAL;
	}

	config->mode = ntohl(client_msg.mode);
	config->n_threads = ntohl(client_msg.n_threads);
	config->msg_size = ntohl(client_msg.msg_size);
	config->tcp_nodelay = client_msg.tcp_nodelay;
	config->buff_size = ROUND_UP(config->msg_size, page_size);
	config->buffers_size = config->n_threads * config->buff_size;
	config->buffers_size +=
		ROUND_UP(config->n_threads * sizeof(struct server_worker_data),
			 page_size);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1e, %edi
callq 0x11b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x192d
movl $0xfffffff2, -0x4(%rbp) # imm = 0xFFFFFFF2
jmp 0x1a2a
movq -0x10(%rbp), %rax
movl 0x30(%rax), %edi
leaq 0x3875(%rip), %rsi      # 0x51b0
movl $0x1c, %edx
callq 0x2e00
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x1966
movq -0x10(%rbp), %rax
movl 0x30(%rax), %edi
callq 0x1110
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x1a2a
movl 0x3850(%rip), %edi      # 0x51bc
callq 0x1230
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl 0x3841(%rip), %edi      # 0x51c0
callq 0x1230
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl 0x3831(%rip), %edi      # 0x51c4
callq 0x1230
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpb $0x0, 0x3820(%rip)      # 0x51c8
setne %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addq -0x18(%rbp), %rax
subq $0x1, %rax
cqto
idivq -0x18(%rbp)
movq %rax, %rcx
imulq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
imulq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shlq $0x7, %rax
addq -0x18(%rbp), %rax
subq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rax, %rcx
imulq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
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/mkubecek[P]nperf/server/control.c
// Function: prepare_buffers
static int prepare_buffers(struct server_ctrl_config *config)
{
	unsigned int i;
	int ret;

	config->buffers = mmap(NULL, config->buffers_size,
			       PROT_READ | PROT_WRITE,
			       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	if (config->buffers == MAP_FAILED) {
		ret = -errno;
		fprintf(stderr, "failed to allocate buffers\n");
		return ret;
	}
	config->workers_data = (struct server_worker_data *)
	       (config->buffers + config->n_threads * config->buff_size);

	for (i = 0; i < config->n_threads; i++) {
		struct server_worker_data *wdata = worker_data(config, i);

		wdata->id = i;
		wdata->buff = config->buffers + i * config->buff_size;
		wdata->msg_size = config->msg_size;
		wdata->reply = (config->mode == MODE_TCP_RR);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x1080
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, %rcx
cmpq %rcx, 0x10(%rax)
jne 0x1abf
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x18(%rbp)
movq 0x3555(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1883(%rip), %rsi      # 0x3330
movb $0x0, %al
callq 0x1130
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b64
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rdx
imulq 0x18(%rdx), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x1b5d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2140
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rdx
imulq 0x18(%rdx), %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
sete %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x18(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1ae9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/control.c
// Function: ctrl_send_start
static int ctrl_send_start(struct server_ctrl_config *config)
{
	struct server_start_msg msg = {
		.length		= htonl(sizeof(msg)),
		.version	= htonl(CTRL_VERSION),
		.test_id	= client_msg.test_id,
	};
	int ret;

	msg.port = htons(config->port);
	ret = ctrl_send_msg(config->ctrl_sd, &msg, sizeof(msg));
	if (ret < 0)
		return -EFAULT;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x10, %edi
callq 0x10f0
movl %eax, -0x20(%rbp)
movl $0x1, %edi
callq 0x10f0
movl %eax, -0x1c(%rbp)
movl 0x33cc(%rip), %eax      # 0x51b8
movl %eax, -0x18(%rbp)
movw $0x0, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
addq $0xe, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1100
movq -0x10(%rbp), %rax
movzwl 0xe(%rax), %edi
callq 0x10a0
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %edi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x2dd0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x1e41
movl $0xfffffff2, -0x4(%rbp) # imm = 0xFFFFFFF2
jmp 0x1e48
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/control.c
// Function: ctrl_run_test
static int ctrl_run_test(int sd, struct server_ctrl_config *config)
{
	unsigned int n_threads = config->n_threads;
	union sockaddr_any client_addr = {};
	socklen_t addr_len;
	unsigned int i, n;
	int csd;
	int ret;

	n = 0;
	while (n < n_threads) {
		struct server_worker_data *wdata;

		addr_len = sizeof(client_addr);
		csd = accept(sd, &client_addr.sa, &addr_len);
		if (csd < 0) {
			perror("accept");
			continue;
		}

		wdata = worker_data(config, n);
		ret = sockaddr_get_port(&client_addr);
		if (ret < 0) {
			close(csd);
			goto failed;
		}
		wdata->client_port = ret;
		wdata->sd = csd;
		ret = start_worker(wdata);
		if (ret < 0) {
			close(csd);
			goto failed;
		}

		n++;
	}

	for (i = 0; i < n_threads; i++)
		pthread_join(worker_data(config, i)->tid, NULL);

	return 0;
failed:
	close(sd);
	for (i = 0; i < n; i++) {
		pthread_cancel(worker_data(config, i)->tid);
	}
	return -EFAULT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movq 0x14f4(%rip), %rax      # 0x3374
movq %rax, -0x30(%rbp)
movq 0x14f1(%rip), %rax      # 0x337c
movq %rax, -0x28(%rbp)
movq 0x14ee(%rip), %rax      # 0x3384
movq %rax, -0x20(%rbp)
movl 0x14ec(%rip), %eax      # 0x338c
movl %eax, -0x18(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1f52
movl $0x1c, -0x34(%rbp)
movl -0x8(%rbp), %edi
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x11c0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jge 0x1ee4
leaq 0x1447(%rip), %rdi      # 0x3324
callq 0x11a0
jmp 0x1eaa
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x2140
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2160
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jge 0x1f10
movl -0x40(%rbp), %edi
callq 0x1110
jmp 0x1f8e
movl -0x44(%rbp), %eax
movw %ax, %cx
movq -0x50(%rbp), %rax
movw %cx, 0x8(%rax)
movl -0x40(%rbp), %ecx
movq -0x50(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x50(%rbp), %rdi
callq 0x2290
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jge 0x1f44
movl -0x40(%rbp), %edi
callq 0x1110
jmp 0x1f8e
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1eaa
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1f85
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x2140
movq 0x28(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1220
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1f59
movl $0x0, -0x4(%rbp)
jmp 0x1fcc
movl -0x8(%rbp), %edi
callq 0x1110
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0x1fc5
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x2140
movq 0x28(%rax), %rdi
callq 0x1250
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1f9d
movl $0xfffffff2, -0x4(%rbp) # imm = 0xFFFFFFF2
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/control.c
// Function: ctrl_send_end
static int ctrl_send_end(struct server_ctrl_config *config)
{
	struct server_end_msg msg = {
		.length		= htonl(sizeof(msg)),
		.version	= htonl(CTRL_VERSION),
		.test_id	= client_msg.test_id,
		.status		= htonl(config->status),
		.thread_length	= htonl(sizeof(struct server_thread_info)),
		.n_threads	= htonl(config->n_threads),
	};
	struct server_thread_info tinfo;
	int sd = config->ctrl_sd;
	unsigned int i;
	int ret;

	ret = ctrl_send_msg(sd, &msg, sizeof(msg));
	if (ret < 0)
		return -EFAULT;

	for (i = 0; i < config->n_threads; i++) {
		const struct server_worker_data *wd = worker_data(config, i);

		memset(&tinfo, '\0', sizeof(tinfo));
		xfer_stats_hton(&wd->stats, &tinfo.stats);
		tinfo.client_port = htons(wd->client_port);

		ret = ctrl_send_msg(sd, &tinfo, sizeof(tinfo));
		if (ret < 0)
			return ret;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl $0x18, %edi
callq 0x10f0
movl %eax, -0x28(%rbp)
movl $0x1, %edi
callq 0x10f0
movl %eax, -0x24(%rbp)
movl 0x31a9(%rip), %eax      # 0x51b8
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %edi
callq 0x10f0
movl %eax, -0x1c(%rbp)
movl $0x38, %edi
callq 0x10f0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x10f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %edi
leaq -0x28(%rbp), %rsi
movl $0x18, %edx
callq 0x2dd0
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jge 0x206d
movl $0xfffffff2, -0x4(%rbp) # imm = 0xFFFFFFF2
jmp 0x20f8
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x20f1
movq -0x10(%rbp), %rdi
movl -0x68(%rbp), %esi
callq 0x2140
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x1100
movq -0x78(%rbp), %rdi
addq $0x30, %rdi
leaq -0x60(%rbp), %rsi
callq 0x21d0
movq -0x78(%rbp), %rax
movzwl 0x8(%rax), %edi
callq 0x10a0
movw %ax, -0x2c(%rbp)
movl -0x64(%rbp), %edi
leaq -0x60(%rbp), %rsi
movl $0x38, %edx
callq 0x2dd0
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jge 0x20e4
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x20f8
jmp 0x20e6
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x2074
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/../common.h
// Function: sockaddr_get_port
static inline int sockaddr_get_port(const union sockaddr_any *addr)
{
	switch(addr->sa.sa_family) {
	case AF_INET:
		return ntohs(addr->sa4.sin_port);
		break;
	case AF_INET6:
		return ntohs(addr->sa6.sin6_port);
		break;
	default:
		return -EINVAL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
je 0x2187
jmp 0x217d
movl -0x14(%rbp), %eax
subl $0xa, %eax
je 0x219c
jmp 0x21b1
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x1170
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
jmp 0x21b8
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x1170
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
jmp 0x21b8
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/worker.c
// Function: start_worker
int start_worker(struct server_worker_data *data)
{
	pthread_attr_t attr;
	int ret;

	ret = pthread_attr_init(&attr);
	if (ret)
		return -ret;
	ret = pthread_attr_setstacksize(&attr, WORKER_STACK_SIZE);
	if (ret)
		return -ret;
	ret = pthread_create(&data->tid, &attr, worker_main, data);

	pthread_attr_destroy(&attr);
	return -ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1120
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x22b8
xorl %eax, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2309
leaq -0x48(%rbp), %rdi
movl $0x4000, %esi           # imm = 0x4000
callq 0x1280
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x22d9
xorl %eax, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2309
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rcx
leaq -0x48(%rbp), %rsi
leaq 0x30(%rip), %rdx        # 0x2320
callq 0x1190
movl %eax, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x11f0
xorl %eax, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/worker.c
// Function: worker_main
static void *worker_main(void *_data)
{
	struct server_worker_data *data = _data;
	bool do_write = data->reply;
	bool eof = false;
	int ret;

	pthread_cleanup_push(cleanup_close, data);

	while (!eof) {
		ret = recv_msg(data, &eof);
		if (ret < 0 || eof)
			break;
		if (do_write) {
			ret = send_msg(data);
			if (ret < 0)
				break;
		}
	}

	pthread_cleanup_pop(1);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
leaq 0xd2(%rip), %rax        # 0x2420
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0x1240
movl %eax, -0x94(%rbp)
movslq -0x94(%rbp), %rax
cmpq $0x0, %rax
je 0x2397
movq -0x88(%rbp), %rax
movq -0x90(%rbp), %rdi
callq *%rax
leaq -0x80(%rbp), %rdi
callq 0x1150
leaq -0x80(%rbp), %rdi
callq 0x1210
jmp 0x23a2
movb -0x12(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x23ad
jmp 0x23e9
movq -0x10(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0x2450
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x23c9
testb $0x1, -0x12(%rbp)
je 0x23cb
jmp 0x23e9
testb $0x1, -0x11(%rbp)
je 0x23e7
movq -0x10(%rbp), %rdi
callq 0x2550
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x23e5
jmp 0x23e9
jmp 0x23e7
jmp 0x23a2
jmp 0x23eb
jmp 0x23ed
jmp 0x23ef
leaq -0x80(%rbp), %rdi
callq 0x10d0
movq -0x88(%rbp), %rax
movq -0x90(%rbp), %rdi
callq *%rax
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/worker.c
// Function: recv_msg
static int recv_msg(struct server_worker_data *data, bool *eof)
{
	unsigned long len = data->msg_size;
	unsigned char *p = data->buff;
	ssize_t chunk;

	*eof = false;
	while (len > 0) {
		chunk = recv(data->sd, p, len, 0);
		if (chunk < 0) {
			if (errno == EINTR)
				continue;
			data->status = -errno;
			return data->status;
		}
		if (chunk == 0) {
			*eof = true;
			return 0;
		}

		p += chunk;
		len -= chunk;
		data->stats.rx.calls++;
		data->stats.rx.bytes += chunk;
	}

	data->stats.rx.msgs++;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0x20(%rbp)
jbe 0x252a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x1030
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x24d3
callq 0x1040
cmpl $0x4, (%rax)
jne 0x24b7
jmp 0x247f
callq 0x1040
xorl %ecx, %ecx
subl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2541
cmpq $0x0, -0x30(%rbp)
jne 0x24ea
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2541
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
jmp 0x247f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/server/worker.c
// Function: send_msg
static int send_msg(struct server_worker_data *data)
{
	unsigned long len = data->msg_size;
	unsigned char *p = data->buff;
	ssize_t chunk;

	while (len > 0) {
		chunk = send(data->sd, p, len, 0);
		if (chunk < 0) {
			if (errno == EINTR)
				continue;
			data->status = (errno == EPIPE) ? 0 : -errno;
			return -errno;
		}

		p += chunk;
		len -= chunk;
		data->stats.tx.calls++;
		data->stats.tx.bytes += chunk;
	}

	data->stats.tx.msgs++;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x2627
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x10b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x25e7
callq 0x1040
cmpl $0x4, (%rax)
jne 0x25ac
jmp 0x2574
callq 0x1040
cmpl $0x20, (%rax)
jne 0x25bd
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x25cc
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x60(%rax)
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x263e
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x58(%rax), %rcx
movq %rcx, 0x58(%rax)
jmp 0x2574
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/common.c
// Function: parse_ulong_range_delim
int parse_ulong_range_delim(const char *name, const char *str,
			    unsigned long *val, unsigned long min_val,
			    unsigned long max_val, char delimiter,
			    const char **next)
{
	int ret;

	ret = parse_ulong_delim(name, str, val, delimiter, next);
	if (ret < 0)
		return ret;
	if (*val < min_val) {
		fprintf(stderr, "value %lu of %s is lower than %lu\n",
			*val, name, min_val);
		return -EINVAL;
	}
	if (*val > max_val) {
		fprintf(stderr, "value %lu of %s is higher than %lu\n",
			*val, name, max_val);
		return -EINVAL;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x31(%rbp), %al
movq 0x10(%rbp), %r8
movsbl %al, %ecx
callq 0x2650
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0x28f5
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2976
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jae 0x2932
movq 0x26ef(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0xab6(%rip), %rsi       # 0x33d8
movb $0x0, %al
callq 0x1130
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x2976
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x30(%rbp), %rax
jbe 0x296f
movq 0x26b2(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq 0xa9c(%rip), %rsi       # 0x33fb
movb $0x0, %al
callq 0x1130
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x2976
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/common.c
// Function: parse_double_delim
int parse_double_delim(const char *name, const char *str, double *val,
		       char delimiter, const char **next)
{
	char *eptr;

	if (!*str)
		goto invalid;
	*val = strtod(str, &eptr);

	if (*eptr) {
	       if (*eptr != delimiter)
		       goto invalid;
	}

	if (next)
		*next = eptr;
	return 0;

invalid:
	fprintf(stderr, "invalid value '%s' of %s\n", str, name);
	return -EINVAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x29f8
jmp 0x2a44
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1060
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2a29
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
je 0x2a27
jmp 0x2a44
jmp 0x2a29
cmpq $0x0, -0x30(%rbp)
je 0x2a3b
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2a6b
movq 0x25ad(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x961(%rip), %rsi       # 0x33be
movb $0x0, %al
callq 0x1130
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/common.c
// Function: parse_double_range_delim
int parse_double_range_delim(const char *name, const char *str,
			     double *val, double min_val,
			     double max_val, char delimiter,
			     const char **next)
{
	int ret;

	ret = parse_double_delim(name, str, val, delimiter, next);
	if (ret < 0)
		return ret;
	if (*val < min_val) {
		fprintf(stderr, "value '%s' of %s is lower than %g\n",
			str, name, min_val);
		return -EINVAL;
	}
	if (*val > max_val) {
		fprintf(stderr, "value '%s' of %s is higher than %g\n",
			str, name, max_val);
		return -EINVAL;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movb %al, -0x31(%rbp)
movq %r8, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x31(%rbp), %al
movq -0x40(%rbp), %r8
movsbl %al, %ecx
callq 0x29d0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jge 0x2b16
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2b9b
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2b57
movq 0x24c8(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movsd -0x28(%rbp), %xmm0
leaq 0x8d8(%rip), %rsi       # 0x341f
movb $0x1, %al
callq 0x1130
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x2b9b
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x2b94
movq 0x248b(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movsd -0x30(%rbp), %xmm0
leaq 0x8be(%rip), %rsi       # 0x3442
movb $0x1, %al
callq 0x1130
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x2b9b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)