LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/jwang11[P]intel_avx_perf/matrix_int.c
// Function: init
void init(void) {
  srand(time(0));
  for (int i = 0; i < row; i++) {
    for (int j = 0; j < col; j++) {
      mat[i][j] = (int)(rand() % (1024*32));
    }   
  }
  for (int j = 0; j < col; j++) {
    mutiplier[j] = (int)(rand() % (1024*32));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1070
movl %eax, %edi
callq 0x1060
leaq 0x2ec6(%rip), %r14      # 0x4070
movl $0x8000, %ebp           # imm = 0x8000
cmpq $0x40, %rbx
je 0x11de
xorl %r15d, %r15d
cmpq $0x800, %r15            # imm = 0x800
je 0x11d2
callq 0x1080
cltd
idivl %ebp
movl %edx, (%r14,%r15,4)
incq %r15
jmp 0x11b8
incq %rbx
addq $0x2000, %r14           # imm = 0x2000
jmp 0x11af
xorl %ebx, %ebx
movl $0x8000, %ebp           # imm = 0x8000
leaq 0x82e84(%rip), %r14     # 0x84070
cmpq $0x2000, %rbx           # imm = 0x2000
je 0x1207
callq 0x1080
cltd
idivl %ebp
movl %edx, (%rbx,%r14)
addq $0x4, %rbx
jmp 0x11ec
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jwang11[P]intel_avx_perf/matrix_int.c
// Function: calc_non
void calc_non(void) {
  for(int j = 0; j < row; j++) {
    int sum = 0;
    int *vec = mat[j];

    for(int i = 0; i < col; i++)
      sum += vec[i] * mutiplier[i];

    result[j] = sum;
  }
}

// Assembly:
leaq 0x2e57(%rip), %rax      # 0x4070
xorl %ecx, %ecx
leaq 0x84e4e(%rip), %rdx     # 0x86070
leaq 0x82e47(%rip), %rsi     # 0x84070
cmpq $0x40, %rcx
je 0x125e
xorl %edi, %edi
xorl %r8d, %r8d
cmpq $0x2000, %rdi           # imm = 0x2000
je 0x124f
movl (%rdi,%rsi), %r9d
imull (%rax,%rdi), %r9d
addl %r9d, %r8d
addq $0x4, %rdi
jmp 0x1234
movl %r8d, (%rdx,%rcx,4)
incq %rcx
addq $0x2000, %rax           # imm = 0x2000
jmp 0x1229
retq
// File: /workspace/github_c_makefile_star2_O2/jwang11[P]intel_avx_perf/matrix_int.c
// Function: calc_avx2
void calc_avx2(void) {
  #define VLEN (256/8/sizeof(int))
  const int col_aligned = col - col % VLEN;
  int *dst_arr;

  __m256i op0, op1, tmp_vec;
  volatile __m256i  tgt;

  for (int i = 0; i < row; i++) {
    int sum = 0;
    tgt = _mm256_setzero_si256();
    for (int j = 0; j < col_aligned; j += VLEN) {
      op0 = _mm256_load_si256((__m256i *)&mutiplier[j]);
      op1 = _mm256_load_si256((__m256i *)&mat[i][j]);
      tmp_vec = _mm256_mullo_epi32(op0, op1);
      tgt = _mm256_add_epi32(tmp_vec, tgt);
    }

    dst_arr = (int *)&tgt;
    for (int k = 0; k < VLEN; k++)
      sum += dst_arr[k];

    for (int l = col_aligned; l < col; l++)
      sum += mat[i][l] * mutiplier[l];

    result[i] = sum;
  }
  #undef VLEN
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x40, %rsp
leaq 0x2dfe(%rip), %rax      # 0x4070
xorl %ecx, %ecx
vxorps %xmm0, %xmm0, %xmm0
leaq 0x82df1(%rip), %rdx     # 0x84070
leaq 0x84dea(%rip), %rsi     # 0x86070
cmpq $0x40, %rcx
je 0x12e2
vmovaps %ymm0, (%rsp)
movq %rdx, %rdi
xorl %r8d, %r8d
cmpq $0x800, %r8             # imm = 0x800
jae 0x12bf
vmovdqa (%rax,%r8,4), %ymm1
vpmulld (%rdi), %ymm1, %ymm1
vpaddd (%rsp), %ymm1, %ymm1
vmovdqa %ymm1, (%rsp)
addq $0x8, %r8
addq $0x20, %rdi
jmp 0x1297
xorl %edi, %edi
xorl %r8d, %r8d
cmpq $0x8, %rdi
je 0x12d3
addl (%rsp,%rdi,4), %r8d
incq %rdi
jmp 0x12c4
movl %r8d, (%rsi,%rcx,4)
incq %rcx
addq $0x2000, %rax           # imm = 0x2000
jmp 0x1286
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/jwang11[P]intel_avx_perf/matrix_int.c
// Function: calc_avx512
void calc_avx512(void) {
  #define VLEN (512/8/sizeof(int))
  const int col_aligned = col - col % VLEN;
  int *dst_arr;

  __m512i op0, op1, tmp_vec;
  volatile __m512i  tgt;

  for (int i = 0; i < row; i++) {
    int sum = 0;

    tgt = _mm512_setzero_si512();
    for (int j = 0; j < col_aligned; j += VLEN) {
      op0 = _mm512_load_si512(&mutiplier[j]);
      op1 = _mm512_load_si512(&mat[i][j]);
      tmp_vec = _mm512_mullo_epi32(op0, op1);
      tgt = _mm512_add_epi32(tmp_vec, tgt);
    }

    dst_arr = (int *)&tgt;
    for (int k = 0; k < VLEN; k++)
      sum += dst_arr[k];

    for (int l = col_aligned; l < col; l++)
      sum += mat[i][l] * mutiplier[l];

    result[i] = sum;
  }
  #undef VLEN
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x40, %rsp
subq $0x80, %rsp
leaq 0x2d70(%rip), %rax      # 0x4070
xorl %ecx, %ecx
vxorps %xmm0, %xmm0, %xmm0
leaq 0x82d63(%rip), %rdx     # 0x84070
leaq 0x84d5c(%rip), %rsi     # 0x86070
cmpq $0x40, %rcx
je 0x1378
vmovaps %zmm0, (%rsp)
movq %rdx, %rdi
xorl %r8d, %r8d
cmpq $0x800, %r8             # imm = 0x800
jae 0x1355
vmovdqa64 (%rax,%r8,4), %zmm1
vpmulld (%rdi), %zmm1, %zmm1
vpaddd (%rsp), %zmm1, %zmm1
vmovdqa64 %zmm1, (%rsp)
addq $0x10, %r8
addq $0x40, %rdi
jmp 0x1327
xorl %edi, %edi
xorl %r8d, %r8d
cmpq $0x10, %rdi
je 0x1369
addl (%rsp,%rdi,4), %r8d
incq %rdi
jmp 0x135a
movl %r8d, (%rsi,%rcx,4)
incq %rcx
addq $0x2000, %rax           # imm = 0x2000
jmp 0x1314
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/jwang11[P]intel_avx_perf/matrix_int.c
// Function: main
int main() {
  init();
  TIME(LOOP(calc_non()));
  DEBUG
  TIME(LOOP(calc_avx2()));
  DEBUG
  TIME(LOOP(calc_avx512()));
  DEBUG
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x118c
leaq 0xc75(%rip), %rdi       # 0x2008
callq 0x1030
callq 0x1040
movq %rax, %rbx
leaq 0xc72(%rip), %rdi       # 0x2019
movl $0x186a0, %ebp          # imm = 0x186A0
movl $0x186a0, %esi          # imm = 0x186A0
xorl %eax, %eax
callq 0x1050
subl $0x1, %ebp
jb 0x13c4
callq 0x1212
jmp 0x13b8
callq 0x1040
vcvtsi2ss %rax, %xmm0, %xmm0
vcvtsi2ss %rbx, %xmm1, %xmm1
vsubss %xmm1, %xmm0, %xmm0
vdivss 0xc25(%rip), %xmm0, %xmm0 # 0x2004
vcvtss2sd %xmm0, %xmm0, %xmm0
leaq 0xc39(%rip), %rdi       # 0x2023
movb $0x1, %al
callq 0x1050
leaq 0x84c78(%rip), %r14     # 0x86070
leaq 0xc3e(%rip), %rbx       # 0x203d
xorl %r15d, %r15d
cmpq $0x20, %r15
je 0x141c
movl (%r15,%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1050
addq $0x4, %r15
jmp 0x1402
leaq 0xc45(%rip), %rdi       # 0x2068
callq 0x1030
leaq 0xc13(%rip), %rdi       # 0x2042
callq 0x1030
callq 0x1040
movq %rax, %rbx
leaq 0xbd6(%rip), %rdi       # 0x2019
movl $0x186a0, %ebp          # imm = 0x186A0
movl $0x186a0, %esi          # imm = 0x186A0
xorl %eax, %eax
callq 0x1050
subl $0x1, %ebp
jb 0x1460
callq 0x125f
jmp 0x1454
callq 0x1040
vcvtsi2ss %rax, %xmm2, %xmm0
vcvtsi2ss %rbx, %xmm2, %xmm1
vsubss %xmm1, %xmm0, %xmm0
vdivss 0xb89(%rip), %xmm0, %xmm0 # 0x2004
vcvtss2sd %xmm0, %xmm0, %xmm0
leaq 0xb9d(%rip), %rdi       # 0x2023
movb $0x1, %al
callq 0x1050
leaq 0xba9(%rip), %rbx       # 0x203d
xorl %r15d, %r15d
cmpq $0x20, %r15
je 0x14b1
movl (%r15,%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1050
addq $0x4, %r15
jmp 0x1497
leaq 0xbb0(%rip), %rdi       # 0x2068
callq 0x1030
leaq 0xb90(%rip), %rdi       # 0x2054
callq 0x1030
callq 0x1040
movq %rax, %rbx
leaq 0xb41(%rip), %rdi       # 0x2019
movl $0x186a0, %ebp          # imm = 0x186A0
movl $0x186a0, %esi          # imm = 0x186A0
xorl %eax, %eax
callq 0x1050
subl $0x1, %ebp
jb 0x14f5
callq 0x12ea
jmp 0x14e9
callq 0x1040
vcvtsi2ss %rax, %xmm2, %xmm0
vcvtsi2ss %rbx, %xmm2, %xmm1
vsubss %xmm1, %xmm0, %xmm0
vdivss 0xaf4(%rip), %xmm0, %xmm0 # 0x2004
vcvtss2sd %xmm0, %xmm0, %xmm0
leaq 0xb08(%rip), %rdi       # 0x2023
movb $0x1, %al
callq 0x1050
leaq 0xb14(%rip), %rbx       # 0x203d
xorl %r15d, %r15d
cmpq $0x20, %r15
je 0x1546
movl (%r15,%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1050
addq $0x4, %r15
jmp 0x152c
leaq 0xb1b(%rip), %rdi       # 0x2068
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: aes
static __m128i aes(__m128i *key, __m128i in, __m128i first_key) {
    in = vxor(in, first_key);
    in = _mm_aesenc_si128 (in,key[0]);
    in = _mm_aesenc_si128 (in,key[3]);
    in = _mm_aesenc_si128 (in,key[6]);
    in = _mm_aesenc_si128 (in,key[0]);
    in = _mm_aesenc_si128 (in,key[3]);
    in = _mm_aesenc_si128 (in,key[6]);
    in = _mm_aesenc_si128 (in,key[0]);
    in = _mm_aesenc_si128 (in,key[3]);
    in = _mm_aesenc_si128 (in,key[6]);
    return _mm_aesenc_si128 (in,key[0]);
}

// Assembly:
vpxor %xmm0, %xmm1, %xmm0
vmovdqa (%rdi), %xmm1
vmovdqa 0x30(%rdi), %xmm2
vmovdqa 0x60(%rdi), %xmm3
vaesenc %xmm1, %xmm0, %xmm0
vaesenc %xmm2, %xmm0, %xmm0
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm1, %xmm0, %xmm0
vaesenc %xmm2, %xmm0, %xmm0
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm1, %xmm0, %xmm0
vaesenc %xmm2, %xmm0, %xmm0
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm1, %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: aez_encrypt
void aez_encrypt(aez_ctx_t *ctx, char *n, unsigned nbytes,
                 char *ad, unsigned adbytes, unsigned abytes,
                 char *src, unsigned bytes, char *dst) {
    
    block t = aez_hash(ctx, n, nbytes, ad, adbytes, abytes);
    if (bytes==0) {
        unsigned i;
        t = aes((block*)ctx, t, vxor(ctx->J[0], ctx->J[1]));
        for (i=0; i<abytes; i++) dst[i] = ((char*)&t)[i];
    } else if (bytes+abytes < 32)
        cipher_aez_tiny(ctx, t, 0, src, bytes, abytes, dst);
    else
        cipher_aez_core(ctx, t, 0, src, bytes, abytes, dst);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r9d, %r14d
movq %rdi, %r12
movq 0x50(%rsp), %rbx
movl 0x48(%rsp), %r15d
movq 0x40(%rsp), %r13
callq 0x1080
testl %r15d, %r15d
je 0x2d41
leal (%r15,%r14), %eax
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movl %r15d, %ecx
movl %r14d, %r8d
movq %rbx, %r9
addq $0x10, %rsp
cmpl $0x1f, %eax
ja 0x2d7f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1040
vmovaps 0x40(%r12), %xmm1
vxorps 0x30(%r12), %xmm1, %xmm1
movq %r12, %rdi
callq 0x29a6
vmovaps %xmm0, (%rsp)
movl %r14d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x2d71
movb (%rsp,%rcx), %dl
movb %dl, (%rbx,%rcx)
incq %rcx
jmp 0x2d61
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: aez_decrypt
int aez_decrypt(aez_ctx_t *ctx, char *n, unsigned nbytes,
                char *ad, unsigned adbytes, unsigned abytes,
                char *src, unsigned bytes, char *dst) {
    
    block t;
    if (bytes < abytes) return -1;
    t = aez_hash(ctx, n, nbytes, ad, adbytes, abytes);
    if (bytes==abytes) {
        block claimed = zero_pad(load_partial(src,abytes), 16-abytes);
        t = zero_pad(aes((block*)ctx, t, vxor(ctx->J[0], ctx->J[1])), 16-abytes);
        return is_zero(vandnot(t, claimed)) - 1;  /* is_zero return 0 or 1 */
    } else if (bytes < 32) {
        return cipher_aez_tiny(ctx, t, 1, src, bytes, abytes, dst);
    } else {
        return cipher_aez_core(ctx, t, 1, src, bytes, abytes, dst);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl 0x48(%rsp), %ebp
cmpl %r9d, %ebp
jae 0x2da7
pushq $-0x1
popq %rax
jmp 0x2dfa
movl %r9d, %ebx
movq %rdi, %r14
movq 0x50(%rsp), %r12
movq 0x40(%rsp), %r15
callq 0x1080
cmpl %ebx, %ebp
jne 0x2e07
pushq $0x10
popq %rax
subl %ebp, %eax
leaq 0x12c4(%rip), %rcx      # 0x4090
vmovups (%rax,%rcx), %xmm2
vmovaps 0x40(%r14), %xmm1
vxorps 0x30(%r14), %xmm1, %xmm1
vandps (%r15), %xmm2, %xmm2
vmovaps %xmm2, (%rsp)
movq %r14, %rdi
callq 0x29a6
xorl %eax, %eax
vptest (%rsp), %xmm0
adcl $-0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
movq %r12, %r9
addq $0x10, %rsp
cmpl $0x1f, %ebp
ja 0x2e2e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
)
{
    aez_ctx_t ctx;
    (void)nsec;
    if (clen) *clen = mlen+16;
    aez_setup((unsigned char *)k, 48, &ctx);
    aez_encrypt(&ctx, (char *)npub, 12,
                 (char *)ad, (unsigned)adlen, 16,
                 (char *)m, (unsigned)mlen, (char *)c);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r13
movq 0xd0(%rsp), %rdi
testq %rsi, %rsi
je 0x2e6f
leaq 0x10(%r14), %rax
movq %rax, (%rsi)
pushq $0x30
popq %rsi
movq %rsp, %rbp
movq %rbp, %rdx
callq 0x1030
subq $0x8, %rsp
pushq $0xc
popq %rdx
pushq $0x10
popq %r9
movq %rbp, %rdi
movq 0xd0(%rsp), %rsi
movq %r12, %rcx
movl %r15d, %r8d
pushq %r13
pushq %r14
pushq %rbx
callq 0x10d0
addq $0x20, %rsp
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/log.c
// Function: log_write_stdout
static inline void log_write_stdout(int mask, int timestamp,
	const char* file, const char* func, int line,
	const char* fmt, va_list args)
{
	int level = log_level_comp(mask);
	FILE* pf = level <= LOG_ERR ? stderr : stdout;
	ttycolor_t color =
		(level >= 0 && level < (sizeof(colors) / sizeof(colors[0]))) ?
		colors[level] : COLOR_FWHITE;
	char* text = log_text(mask, timestamp, file, func, line, fmt, args);
#ifdef WINDOWS
	HANDLE h = level <= LOG_ERR ? hStderr : hStdout;
	if (h != INVALID_HANDLE_VALUE)
		SetConsoleTextAttribute(h, color);
	fprintf(pf, "%s", text);
	if (h != INVALID_HANDLE_VALUE)
		SetConsoleTextAttribute(h, wOldColorAttrs);
#else
	fprintf(pf, "%s%s", color, text);
#endif
	free(text);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movzbl %dil, %eax
movq 0x8a1b(%rip), %r10      # 0xafd8
movq (%r10), %r10
movq 0x89f1(%rip), %r11      # 0xafb8
movq (%r11), %rbx
cmpl $0x8, %eax
ja 0x25e2
movl %eax, %r11d
leaq 0x4ac3(%rip), %r15      # 0x709c
movslq (%r15,%r11,4), %r14
addq %r15, %r14
jmp 0x25e9
leaq 0x4a67(%rip), %r14      # 0x7050
cmpl $0x4, %eax
cmovbq %r10, %rbx
callq 0x269c
movq %rax, %r15
leaq 0x4a57(%rip), %rsi      # 0x7056
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2310
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2290
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/log.c
// Function: log_vprintf_writefile
void log_vprintf_writefile(int mask,
		const char *file, const char *func, int line,
		const char* fmt, va_list args)
{
	char *text = log_text(mask, 1, file, func, line, fmt, args);
	size_t len;
	if (text && (len = strlen(text)) > 0) {
		FILE* pf;
		pf = fopen(s_current_log_file, "a+");
		if (pf) {
			fwrite(text, 1, len, pf);
			fclose(pf);
		}
		else {
			printf("cannot open %s\n", s_current_log_file);
		}
	}
	free(text);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rdx
pushq $0x1
popq %rsi
callq 0x269c
movq %rax, %rbx
testq %rax, %rax
je 0x268f
movq %rbx, %rdi
callq 0x20e0
testq %rax, %rax
je 0x268f
movq %rax, %r14
movq 0x8bdd(%rip), %rdi      # 0xb228
leaq 0x49b2(%rip), %rsi      # 0x7004
callq 0x2280
testq %rax, %rax
je 0x267a
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x23a0
movq %r15, %rdi
callq 0x2210
jmp 0x268f
movq 0x8ba7(%rip), %rsi      # 0xb228
leaq 0x497f(%rip), %rdi      # 0x7007
xorl %eax, %eax
callq 0x2040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2290
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/log.c
// Function: log_text
static char *log_text(int mask, int timestamp,
		const char *file, const char *func, int line,
		const char *fmt, va_list args)
{
	int level = log_level_comp(mask);
	char date[32] = {0};
	const char *extra_msg;
	const char *fname;
	char *text, *retval;
	time_t now;

	if (timestamp) {
		int x;
		now = time(NULL);
		strftime(date, sizeof(date), LOG_TIMEFORMAT, localtime(&now));
		x = strlen(date);
		date[x++] = ' ';
		date[x++] = '\0';
	}
	extra_msg = log_priorityname(level);
	fname = get_filename(file);
	text = log_vmprintf(fmt, args);

	retval = log_mprintf("%s[%s] %s:%d %s", date, extra_msg, fname, line, text);

	free(text);
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movl %ecx, %ebx
movq %rdx, %r12
movl %edi, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
testl %esi, %esi
je 0x2709
xorl %edi, %edi
callq 0x21e0
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
callq 0x2160
leaq 0x4997(%rip), %rdx      # 0x7079
movq %rsp, %r13
pushq $0x20
popq %rsi
movq %r13, %rdi
movq %rax, %rcx
callq 0x2190
movq %r13, %rdi
callq 0x20e0
cltq
movb $0x20, (%rsp,%rax)
incl %eax
cltq
movb $0x0, (%rsp,%rax)
movzbl %bpl, %eax
cmpl $0x8, %eax
ja 0x2721
movl %eax, %eax
leaq 0x8655(%rip), %rcx      # 0xad70
movq (%rcx,%rax,8), %r13
jmp 0x2724
xorl %r13d, %r13d
testq %r12, %r12
je 0x274f
movq %r12, %rdi
callq 0x20e0
movq %rax, %rbp
addq %r12, %rbp
movzbl (%rbp), %eax
cmpq %r12, %rbp
jbe 0x2753
cmpl $0x2f, %eax
je 0x275d
cmpl $0x5c, %eax
je 0x275d
decq %rbp
jmp 0x2737
xorl %ebp, %ebp
jmp 0x2760
cmpl $0x2f, %eax
je 0x275d
cmpl $0x5c, %eax
jne 0x2760
incq %rbp
movq %r15, %rdi
movq %r14, %rsi
callq 0x28b2
movq %rax, %r14
movq %rsp, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movl %ebx, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x2935
movq %rax, %rbx
movq %r14, %rdi
callq 0x2290
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/log.c
// Function: log_vprintf_syslog
void log_vprintf_syslog(int mask,
		const char *file, const char *func, int line,
		const char* fmt, va_list args)
{
#ifdef WINDOWS
	logw("log_vprintf_syslog(): not implemented in Windows port");
#else
	char *text = log_text(mask, 0, file, func, line, fmt, args);
	int priority = log_level_comp(mask);
	syslog(priority, "%s", text);
	free(text);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movl %edi, %ebx
xorl %esi, %esi
callq 0x269c
movq %rax, %r14
movzbl %bl, %edi
leaq 0x48da(%rip), %rsi      # 0x7098
movq %rax, %rdx
xorl %eax, %eax
callq 0x2060
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2290
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/log.c
// Function: open_logfile
void open_logfile(const char* log_file)
{
	if (log_file && strlen(log_file)) {
		s_current_log_file = log_file;
		log_vprintf = log_vprintf_writefile;
		log_vprintf_with_timestamp = log_vprintf_writefile;
		s_is_use_logfile = 1;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x2804
cmpb $0x0, (%rdi)
je 0x2804
movq %rdi, 0x8a40(%rip)      # 0xb228
leaq -0x1d3(%rip), %rax      # 0x261c
movq %rax, 0x89fa(%rip)      # 0xb1f0
movq %rax, 0x89fb(%rip)      # 0xb1f8
movb $0x1, 0x8a2c(%rip)      # 0xb230
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/log.c
// Function: close_logfile
void close_logfile()
{
	if (s_is_use_logfile) {
		log_vprintf = log_vprintf_default;
		log_vprintf_with_timestamp = log_vprintf_with_timestamp_default;
		s_is_use_logfile = 0;
	}
}

// Assembly:
cmpb $0x1, 0x8a24(%rip)      # 0xb230
jne 0x2831
leaq -0x359(%rip), %rax      # 0x24bc
movq %rax, 0x89d4(%rip)      # 0xb1f0
leaq -0x35d(%rip), %rax      # 0x24c6
movq %rax, 0x89ce(%rip)      # 0xb1f8
movb $0x0, 0x89ff(%rip)      # 0xb230
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/log.c
// Function: open_syslog
void open_syslog(const char *ident)
{
#ifdef WINDOWS
	logw("use_syslog(): not implemented in Windows port");
#else
	if (!s_is_use_syslog) {
		openlog(ident, LOG_CONS | LOG_PID, LOG_DAEMON);
		s_is_use_syslog = 1;
		log_vprintf = log_vprintf_syslog;
		log_vprintf_with_timestamp = log_vprintf_syslog;
	}
#endif
}

// Assembly:
cmpb $0x0, 0x89fb(%rip)      # 0xb234
jne 0x2867
pushq %rax
pushq $0x3
popq %rsi
pushq $0x18
popq %rdx
callq 0x21c0
movb $0x1, 0x89e6(%rip)      # 0xb234
leaq -0xb4(%rip), %rax       # 0x27a1
movq %rax, 0x8994(%rip)      # 0xb1f0
movq %rax, 0x8995(%rip)      # 0xb1f8
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/log.c
// Function: log_vmprintf
static char *log_vmprintf(const char *fmt, va_list args)
{
	int cnt, sz;
	char *buf;
	va_list ap_try;

	sz = 1024;
	buf = (char*)malloc(sz);
	if (!buf)
		return NULL;
try_print:
	va_copy(ap_try, args);
	cnt = vsnprintf(buf, sz, fmt, ap_try);
	va_end(ap_try);
	if (cnt >= sz) {
		char *newbuf;
		sz *= 2;
		newbuf = (char*)realloc(buf, sz);
		if (!newbuf) {
			free(buf);
			return NULL;
		}
		buf = newbuf;
		goto try_print;
	}
	if (cnt < 0) {
		free(buf);
		return NULL;
	}
	return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x400, %edi            # imm = 0x400
callq 0x22e0
testq %rax, %rax
je 0x2923
movl $0x400, %ebp            # imm = 0x400
movq %rsp, %r12
movq %rax, %rbx
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movl %ebp, %esi
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2130
cmpl %ebp, %eax
jl 0x2917
addl %ebp, %ebp
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x2350
testq %rax, %rax
jne 0x28db
jmp 0x291b
testl %eax, %eax
jns 0x2925
movq %rbx, %rdi
callq 0x2290
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: try_parse_as_ip4
int try_parse_as_ip4(sockaddr_t* addr, const char* host, const char* port)
{
	struct sockaddr_in* in = (struct sockaddr_in*)(&addr->addr);

	if (inet_pton(AF_INET, host, &in->sin_addr) == 1) {
		in->sin_family = AF_INET;
		in->sin_port = htons(atoi(port));
		addr->addrlen = sizeof(struct sockaddr_in);
		return TRUE;
	}

	return FALSE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x4(%rdi), %rdx
pushq $0x2
popq %rdi
callq 0x2390
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x2a05
movw $0x2, (%rbx)
movq %r14, %rdi
callq 0x2320
rolw $0x8, %ax
movw %ax, 0x2(%rbx)
movl $0x10, 0x80(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: try_parse_as_ip6
int try_parse_as_ip6(sockaddr_t* addr, const char* host, const char* port)
{
	struct sockaddr_in6* in = (struct sockaddr_in6*)(&addr->addr);

	if (inet_pton(AF_INET6, host, &in->sin6_addr) == 1) {
		in->sin6_family = AF_INET6;
		in->sin6_port = htons(atoi(port));
		addr->addrlen = sizeof(struct sockaddr_in);
		return TRUE;
	}

	return FALSE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rdx
pushq $0xa
popq %rdi
callq 0x2390
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x2a4e
movw $0xa, (%rbx)
movq %r14, %rdi
callq 0x2320
rolw $0x8, %ax
movw %ax, 0x2(%rbx)
movl $0x10, 0x80(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: setnonblock
int setnonblock(sock_t sock)
{
#ifdef WINDOWS
	int iResult;
	/* If iMode!=0, non-blocking mode is enabled.*/
	u_long iMode = 1;
	iResult = ioctlsocket(sock, FIONBIO, &iMode);
	if (iResult != NO_ERROR) {
		loge("ioctlsocket() error: result=%ld, errno=%d, %s\n",
			iResult, errno, strerror(errno));
		return -1;
	}
#else
	int flags;
	flags = fcntl(sock, F_GETFL, 0);
	if (flags == -1) {
		loge("fcntl() error: errno=%d, %s\n", errno, strerror(errno));
		return -1;
	}
	if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) {
		loge("fcntl() error: errno=%d, %s\n", errno, strerror(errno));
		return -1;
	}
#endif

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebp
xorl %ebx, %ebx
pushq $0x3
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2120
pushq $-0x1
popq %r14
cmpl $-0x1, %eax
je 0x2ad2
orl $0x800, %eax            # imm = 0x800
pushq $0x4
popq %rsi
movl %ebp, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x2120
cmpl $-0x1, %eax
jne 0x2b1a
xorl %eax, %eax
callq 0x24d9
cmpl $0x3, (%rax)
jl 0x2b17
pushq $0x40
jmp 0x2ae0
xorl %eax, %eax
callq 0x24d9
cmpl $0x2, (%rax)
jle 0x2b17
pushq $0x3c
popq %rbx
callq 0x2030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x20c0
movq %rax, (%rsp)
leaq 0x464e(%rip), %rsi      # 0x7148
leaq 0x4656(%rip), %rdx      # 0x7157
leaq 0x465b(%rip), %r8       # 0x7163
pushq $0x3
popq %rdi
movl %ebx, %ecx
movl %ebp, %r9d
xorl %eax, %eax
callq 0x2512
movl %r14d, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: setreuseaddr
int setreuseaddr(sock_t sock)
{
	int opt = 1;

	if (setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char*)&opt, sizeof(opt)) != 0) {
		loge("setsockopt() error: errno=%d, %s\n", errno, strerror(errno));
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rcx
movl $0x1, (%rcx)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
pushq $0x4
popq %r8
callq 0x2360
testl %eax, %eax
je 0x2b91
xorl %eax, %eax
callq 0x24d9
pushq $-0x1
popq %rbx
cmpl $0x3, (%rax)
jl 0x2b93
callq 0x2030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x20c0
movq %rax, (%rsp)
leaq 0x45d7(%rip), %rsi      # 0x7148
leaq 0x4608(%rip), %rdx      # 0x7180
leaq 0x460e(%rip), %r8       # 0x718d
pushq $0x3
popq %rdi
pushq $0x4d
popq %rcx
movl %ebp, %r9d
xorl %eax, %eax
callq 0x2512
jmp 0x2b93
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: setnodelay
int setnodelay(sock_t sock)
{
	int opt = 1;

	if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char*)&opt, sizeof(opt)) != 0) {
		loge("setsockopt() error: errno=%d, %s\n", errno, strerror(errno));
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x14(%rsp), %rcx
movl $0x1, (%rcx)
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
pushq $0x4
popq %r8
callq 0x2360
testl %eax, %eax
je 0x2c08
xorl %eax, %eax
callq 0x24d9
pushq $-0x1
popq %rbx
cmpl $0x3, (%rax)
jl 0x2c0a
callq 0x2030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x20c0
movq %rax, (%rsp)
leaq 0x4560(%rip), %rsi      # 0x7148
leaq 0x45c0(%rip), %rdx      # 0x71af
leaq 0x4597(%rip), %r8       # 0x718d
pushq $0x3
popq %rdi
pushq $0x59
popq %rcx
movl %ebp, %r9d
xorl %eax, %eax
callq 0x2512
jmp 0x2c0a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: getsockerr
int getsockerr(sock_t sock)
{
	int err = 0;
	int len = sizeof(int);
	if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (char*)& err, &len) < 0)
		return errno;
	return err;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
andl $0x0, (%rbx)
leaq 0x8(%rsp), %r8
movl $0x4, (%r8)
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rcx
callq 0x2170
testl %eax, %eax
jns 0x2c46
callq 0x2030
movq %rax, %rbx
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: get_addrname
char* get_addrname(const struct sockaddr* addr)
{
	static char addrname[INET6_ADDRSTRLEN + 16];
	char sip[INET6_ADDRSTRLEN];
	if (addr->sa_family == AF_INET) {
		const struct sockaddr_in* addr_in = (const struct sockaddr_in*)addr;
		inet_ntop(AF_INET, &addr_in->sin_addr, sip, sizeof(sip));
		snprintf(addrname, sizeof(addrname), "%s:%d", sip,
			(int)(htons(addr_in->sin_port) & 0xFFFF));
	}
	else if (addr->sa_family == AF_INET6) {
		const struct sockaddr_in6* addr_in6 = (const struct sockaddr_in6*)addr;
		inet_ntop(AF_INET6, &addr_in6->sin6_addr, sip, sizeof(sip));
		snprintf(addrname, sizeof(addrname), "[%s]:%d", sip,
			(int)(htons(addr_in6->sin6_port) & 0xFFFF));
	}
	else {
		addrname[0] = '\0';
	}
	return addrname;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
cmpl $0xa, %eax
je 0x2cae
cmpl $0x2, %eax
jne 0x2cec
leaq 0x4(%rbx), %rsi
pushq $0x2
popq %rdi
movq %rsp, %r14
pushq $0x2e
popq %rcx
movq %r14, %rdx
callq 0x2220
movzwl 0x2(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %r8d
leaq 0x85cb(%rip), %rdi      # 0xb270
leaq 0x450e(%rip), %rdx      # 0x71ba
jmp 0x2cdd
leaq 0x8(%rbx), %rsi
pushq $0xa
popq %rdi
movq %rsp, %r14
pushq $0x2e
popq %rcx
movq %r14, %rdx
callq 0x2220
movzwl 0x2(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %r8d
leaq 0x859a(%rip), %rdi      # 0xb270
leaq 0x44e3(%rip), %rdx      # 0x71c0
pushq $0x3e
popq %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2330
jmp 0x2cf3
movb $0x0, 0x857d(%rip)      # 0xb270
leaq 0x8576(%rip), %rax      # 0xb270
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: get_sockname
char* get_sockname(sock_t sock)
{
	static char buffer[INET6_ADDRSTRLEN + 16] = { 0 };
	char sip[INET6_ADDRSTRLEN];
	struct sockaddr_storage addr;
	socklen_t len = sizeof(addr);
	memset(&addr, 0, len);
	int err = getpeername(sock, (struct sockaddr*) & addr, &len);
	if (err != 0)
		return NULL;
	if (addr.ss_family == AF_INET) {
		struct sockaddr_in* s = (struct sockaddr_in*) & addr;
		inet_ntop(AF_INET, &s->sin_addr, sip, sizeof(sip));
		snprintf(buffer, sizeof(buffer), "%s:%d", sip,
			(int)(htons(s->sin_port) & 0xFFFF));
		return buffer;
	}
	else if (addr.ss_family == AF_INET6) {
		struct sockaddr_in6* s = (struct sockaddr_in6*) & addr;
		inet_ntop(AF_INET6, &s->sin6_addr, sip, sizeof(sip));
		snprintf(buffer, sizeof(buffer), "[%s]:%d", sip,
			(int)(htons(s->sin6_port) & 0xFFFF));
		return buffer;
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
leaq 0xc(%rsp), %rdx
movl $0x80, (%rdx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
callq 0x2150
testl %eax, %eax
je 0x2d4e
xorl %r14d, %r14d
jmp 0x2db4
movzwl 0x10(%rsp), %edi
cmpl $0x2, %edi
je 0x2d6e
cmpl $0xa, %edi
jne 0x2d49
leaq 0x18(%rsp), %rsi
leaq 0x4457(%rip), %rbx      # 0x71c0
pushq $0xa
popq %rdi
jmp 0x2d7a
leaq 0x14(%rsp), %rsi
leaq 0x4440(%rip), %rbx      # 0x71ba
leaq 0x90(%rsp), %r15
pushq $0x2e
popq %rcx
movq %r15, %rdx
callq 0x2220
movzwl 0x12(%rsp), %eax
rolw $0x8, %ax
movzwl %ax, %r8d
leaq 0x850f(%rip), %r14      # 0xb2b0
pushq $0x3e
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2330
movq %r14, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: parse_host_port
int parse_host_port(char* s, char** host, char** port, int* ai_family)
{
	char* p;
	int cnt = 0;

	/* ipv6 */
	if (*s == '[') {
		p = strrchr(s, ']');
		if (p) {
			*host = s + 1;
			*p = '\0';
			p++;
			if (*p == ':')
				* port = p + 1;
			else
				*port = NULL;
			*ai_family = AF_INET6;
			return 0;
		}
		else {
			return -1;
		}
	}

	p = strrchr(s, ':');
	if (p) {
		*port = p + 1;
		*p = '\0';
	}
	else {
		*port = NULL;
	}

	*host = s;
	*ai_family = AF_INET;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpb $0x5b, (%rdi)
jne 0x2e0e
pushq $0x5d
popq %rsi
movq %r12, %rdi
callq 0x2250
testq %rax, %rax
je 0x2e2c
incq %r12
movq %r12, (%r15)
movb $0x0, (%rax)
movq %rax, %rcx
addq $0x2, %rcx
xorl %edx, %edx
cmpb $0x3a, 0x1(%rax)
cmoveq %rcx, %rdx
movq %rdx, (%r14)
pushq $0xa
jmp 0x2e3a
pushq $0x3a
popq %rsi
movq %r12, %rdi
callq 0x2250
testq %rax, %rax
je 0x2e31
movq %rax, %rcx
incq %rcx
movq %rcx, (%r14)
movb $0x0, (%rax)
jmp 0x2e35
pushq $-0x1
popq %rax
jmp 0x2e3f
andq $0x0, (%r14)
movq %r12, (%r15)
pushq $0x2
popq %rax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: host2addr
int host2addr(sockaddr_t* addr, const char* host, const char* port, int ai_family)
{
	struct addrinfo hints;
	struct addrinfo* addrinfo;
	int r;

	memset(&hints, 0, sizeof(hints));

	hints.ai_family = ai_family;
	hints.ai_socktype = SOCK_STREAM;

	r = getaddrinfo(host, port, &hints, &addrinfo);

	if (r != 0)
	{
		loge("retval=%d %s %s:%s\n",
			r, gai_strerror(r), host, port);
		return -1;
	}

	memcpy(&addr->addr, addrinfo->ai_addr, addrinfo->ai_addrlen);
	addr->addrlen = (int)addrinfo->ai_addrlen;

	freeaddrinfo(addrinfo);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movl %ecx, 0x4(%rdx)
movl $0x1, 0x8(%rdx)
leaq 0x8(%rsp), %rcx
movq %rsi, %rdi
movq %r14, %rsi
callq 0x22c0
testl %eax, %eax
je 0x2ee4
movl %eax, %r15d
xorl %eax, %eax
callq 0x24d9
pushq $-0x1
popq %rbp
cmpl $0x3, (%rax)
jl 0x2f0d
movl %r15d, %edi
callq 0x22f0
movq %rax, %r10
subq $0x8, %rsp
leaq 0x428f(%rip), %rsi      # 0x7148
leaq 0x4308(%rip), %rdx      # 0x71c8
leaq 0x430b(%rip), %r8       # 0x71d2
pushq $0x3
popq %rdi
movl $0xd8, %ecx
movl %r15d, %r9d
xorl %eax, %eax
pushq %r14
pushq %rbx
pushq %r10
callq 0x2512
addq $0x20, %rsp
jmp 0x2f0d
movq 0x8(%rsp), %rbx
movq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
movq %r12, %rdi
callq 0x21a0
movl 0x10(%rbx), %eax
movl %eax, 0x80(%r12)
movq %rbx, %rdi
callq 0x22d0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: str2addr
int str2addr(
	const char* s, sockaddr_t* addr,
	const char* default_port)
{
	char* copy = strdup(s);
	char* host, * port;
	int ai_family;
	int r;

	if (parse_host_port(copy, &host, &port, &ai_family)) {
		free(copy);
		return -1;
	}

	if (!port || strlen(port) == 0)
		port = (char*)default_port;

	r = host2addr(addr, host, port, ai_family);

	free(copy);

	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
callq 0x2380
movq %rax, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movq %rax, %rdi
callq 0x2dc4
testl %eax, %eax
je 0x2f54
pushq $-0x1
popq %rbp
jmp 0x2f79
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
je 0x2f63
cmpb $0x0, (%rdx)
jne 0x2f66
movq %r15, %rdx
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %ecx
movq %r14, %rdi
callq 0x2e4b
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2290
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: str2addrs
int str2addrs(
	const char* str,
	sockaddr_t* addrs,
	int max_num,
	int element_size,
	const char* default_port)
{
	char* s, * p, *saveptr = NULL;
	int i;
	sockaddr_t* addr;

	s = strdup(str);

	for (i = 0, p = strtok_r(s, ",", &saveptr);
		p && *p && i < max_num;
		p = strtok_r(NULL, ",", &saveptr)) {

		addr = (sockaddr_t*)(((char*)addrs) + (size_t)element_size * i);

		if (str2addr(p, addr, default_port)) {
			free(s);
			loge("resolve \"%s\" failed\n", str);
			return -1;
		}

		i++;
	}

	free(s);

	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movl %ecx, %r14d
movl %edx, 0xc(%rsp)
movq %rsi, %r12
leaq 0x20(%rsp), %r13
andq $0x0, (%r13)
movq %rdi, 0x18(%rsp)
callq 0x2380
leaq 0x4222(%rip), %rbx      # 0x71e6
movq %rax, 0x10(%rsp)
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2370
movslq %r14d, %rbp
movslq 0xc(%rsp), %r13
xorl %r14d, %r14d
testq %rax, %rax
je 0x301a
cmpb $0x0, (%rax)
je 0x301a
cmpq %r13, %r14
jge 0x301a
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2f1c
testl %eax, %eax
jne 0x3036
incq %r14
xorl %edi, %edi
movq %rbx, %rsi
leaq 0x20(%rsp), %rdx
callq 0x2370
addq %rbp, %r12
jmp 0x2fe2
movq 0x10(%rsp), %rdi
callq 0x2290
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
callq 0x2290
xorl %eax, %eax
callq 0x24d9
pushq $-0x1
popq %r14
cmpl $0x3, (%rax)
jl 0x3024
leaq 0x40f1(%rip), %rsi      # 0x7148
leaq 0x418a(%rip), %rdx      # 0x71e8
leaq 0x418d(%rip), %r8       # 0x71f2
pushq $0x3
popq %rdi
movl $0x111, %ecx            # imm = 0x111
movq 0x18(%rsp), %r9
xorl %eax, %eax
callq 0x2512
jmp 0x3024
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: str2proxies
int str2proxies(
	const char* str,
	proxy_t* proxies,
	int max_num)
{
	char* s, * p, *saveptr = NULL;
	int i;
	proxy_t* proxy;

	s = strdup(str);

	for (i = 0, p = strtok_r(s, ",", &saveptr);
		p && *p && i < max_num;
		p = strtok_r(NULL, ",", &saveptr)) {

		proxy = proxies + i;

		if (str2proxy(p, proxy)) {
			free(s);
			loge("resolve \"%s\" failed\n", str);
			return -1;
		}

		i++;
	}

	free(s);

	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movq %rsi, %r15
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
movq %rdi, 0x8(%rsp)
callq 0x2380
movq %rax, %r13
leaq 0x3ec8(%rip), %rbp      # 0x71e6
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x2370
movslq %r14d, %rbx
xorl %r14d, %r14d
testq %rax, %rax
je 0x3369
cmpb $0x0, (%rax)
je 0x3369
cmpq %rbx, %r14
jge 0x3369
movq %rax, %rdi
movq %r15, %rsi
callq 0x307b
testl %eax, %eax
jne 0x3383
incq %r14
xorl %edi, %edi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x2370
addq $0xf8, %r15
jmp 0x3332
movq %r13, %rdi
callq 0x2290
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x2290
xorl %eax, %eax
callq 0x24d9
pushq $-0x1
popq %r14
cmpl $0x3, (%rax)
jl 0x3371
leaq 0x3da6(%rip), %rsi      # 0x7148
leaq 0x3e8a(%rip), %rdx      # 0x7233
leaq 0x3e42(%rip), %r8       # 0x71f2
pushq $0x3
popq %rdi
movl $0x1a8, %ecx            # imm = 0x1A8
movq 0x8(%rsp), %r9
xorl %eax, %eax
callq 0x2512
jmp 0x3371
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: str2listens
int str2listens(
	const char* str,
	listen_t * listens,
	int max_num,
	int element_size,
	const char* default_port)
{
	int listen_num;

	memset(listens, 0, (size_t)element_size * max_num);

	listen_num = str2addrs(
		str,
		&listens[0].addr,
		max_num,
		element_size,
		default_port);

	if (listen_num == -1) {
		loge("parse \"%s\" failed\n",
			str);
		return -1;
	}

	return listen_num;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rsi, %r15
movq %rdi, %rbx
movslq %ecx, %r12
movslq %edx, %r13
movq %r12, %rdx
imulq %r13, %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x2110
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %r12d, %ecx
movq %r14, %r8
callq 0x2f8e
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x343f
xorl %eax, %eax
callq 0x24d9
cmpl $0x3, (%rax)
jl 0x343f
leaq 0x3d29(%rip), %rsi      # 0x7148
leaq 0x3e19(%rip), %rdx      # 0x723f
leaq 0x3e1e(%rip), %r8       # 0x724b
pushq $0x3
popq %rdi
movl $0x1c8, %ecx            # imm = 0x1C8
movq %rbx, %r9
xorl %eax, %eax
callq 0x2512
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: udp_listen
int udp_listen(listen_t* ctx)
{
	sockaddr_t* addr;
	struct sockaddr* sockaddr;
	sock_t sock;

	addr = &ctx->addr;
	sockaddr = (struct sockaddr*)(&addr->addr);

	sock = socket(sockaddr->sa_family, SOCK_DGRAM, IPPROTO_UDP);

	if (sock == -1) {
		loge("create socket error. errno=%d, %s\n", errno, strerror(errno));
		return -1;
	}

	if (setnonblock(sock) != 0) {
		loge("set sock non-block failed\n");
		close(sock);
		return -1;
	}

	if (setreuseaddr(sock) != 0) {
		loge("set sock reuse address failed\n");
		close(sock);
		return -1;
	}

#ifdef WINDOWS
	disable_udp_connreset(sock);
#endif

	if (bind(sock, sockaddr, addr->addrlen) != 0) {
		loge("bind() error: %s errno=%d, %s\n",
			get_sockaddrname(addr), errno, strerror(errno));
		close(sock);
		return -1;
	}

	ctx->usock = sock;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movzwl (%rdi), %edi
pushq $0x2
popq %rsi
pushq $0x11
popq %rdx
callq 0x20a0
cmpl $-0x1, %eax
je 0x368c
movl %eax, %ebx
movl %eax, %edi
callq 0x2a89
testl %eax, %eax
je 0x36e1
xorl %eax, %eax
callq 0x24d9
cmpl $0x3, (%rax)
jl 0x371c
leaq 0x3ad7(%rip), %rsi      # 0x7148
leaq 0x3c6b(%rip), %rdx      # 0x72e3
leaq 0x3bea(%rip), %r8       # 0x7269
pushq $0x3
popq %rdi
movl $0x20f, %ecx            # imm = 0x20F
jmp 0x3715
xorl %eax, %eax
callq 0x24d9
pushq $-0x1
popq %rbx
cmpl $0x3, (%rax)
jl 0x3726
callq 0x2030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x20c0
movq %rax, %r10
subq $0x8, %rsp
leaq 0x3a8d(%rip), %rsi      # 0x7148
leaq 0x3c21(%rip), %rdx      # 0x72e3
leaq 0x47c4(%rip), %r8       # 0x7e8d
pushq $0x3
popq %rdi
movl $0x20a, %ecx            # imm = 0x20A
movl %ebp, %r9d
xorl %eax, %eax
pushq %r10
callq 0x2512
popq %rax
popq %rcx
jmp 0x3726
movl %ebx, %edi
callq 0x2b25
testl %eax, %eax
je 0x372d
xorl %eax, %eax
callq 0x24d9
cmpl $0x3, (%rax)
jl 0x371c
leaq 0x3a49(%rip), %rsi      # 0x7148
leaq 0x3bdd(%rip), %rdx      # 0x72e3
leaq 0x3b77(%rip), %r8       # 0x7284
pushq $0x3
popq %rdi
movl $0x215, %ecx            # imm = 0x215
xorl %eax, %eax
callq 0x2512
movl %ebx, %edi
callq 0x23b0
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl 0x80(%r14), %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x2070
testl %eax, %eax
je 0x379c
xorl %eax, %eax
callq 0x24d9
cmpl $0x3, (%rax)
jl 0x371c
movq %r14, %rdi
callq 0x2c66
callq 0x2030
movl (%rax), %r14d
movl %r14d, %edi
callq 0x20c0
movq %rax, %r10
leaq 0x39d8(%rip), %rsi      # 0x7148
leaq 0x3b6c(%rip), %rdx      # 0x72e3
leaq 0x3b25(%rip), %r8       # 0x72a3
leaq 0x7aeb(%rip), %r9       # 0xb270
pushq $0x3
popq %rdi
movl $0x220, %ecx            # imm = 0x220
xorl %eax, %eax
pushq %r10
pushq %r14
callq 0x2512
popq %rax
popq %rcx
jmp 0x371c
movl %ebx, 0x8c(%r14)
xorl %ebx, %ebx
jmp 0x3726
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: init_listens
int init_listens(listen_t* listens, int listen_num)
{
	int i, num = listen_num, n = 0;
	listen_t* listen;

	for (i = 0; i < num; i++) {
		listen = listens + i;
		if (tcp_listen(listen) == 0) {
			n++;
		}
		if (udp_listen(listen) == 0) {
			n++;
		}
	}

	if (n == 0)
		return -1;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %ebx
subq $0x1, %rbx
jb 0x37eb
movq %r14, %rdi
callq 0x3450
xorl %r15d, %r15d
testl %eax, %eax
sete %r15b
movq %r14, %rdi
callq 0x362f
cmpl $0x1, %eax
adcl %r15d, %ebp
addq $0x90, %r14
jmp 0x37bd
xorl %eax, %eax
cmpl $0x1, %ebp
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: print_listens
void print_listens(const listen_t* listens, int listen_num)
{
	int i;
	for (i = 0; i < listen_num; i++) {
		logn("listen on %s [tcp sock=%d, udp sock=%d]\n",
			get_sockaddrname(&listens[i].addr),
			(int)listens[i].sock,
			(int)listens[i].usock);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %ebx
leaq 0x3ad3(%rip), %r12      # 0x72ee
leaq 0x3ada(%rip), %r13      # 0x72fc
leaq 0x7a47(%rip), %rbp      # 0xb270
pushq $0x5
popq %r15
subq $0x1, %rbx
jb 0x3883
xorl %eax, %eax
callq 0x24d9
cmpl $0x5, (%rax)
jl 0x387a
movq %r14, %rdi
callq 0x2c66
movl 0x88(%r14), %r10d
movl 0x8c(%r14), %r11d
movl %r15d, %edi
leaq 0x38e9(%rip), %rsi      # 0x7148
movq %r12, %rdx
movl $0x246, %ecx            # imm = 0x246
movq %r13, %r8
movq %rbp, %r9
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x2512
popq %rax
popq %rcx
addq $0x90, %r14
jmp 0x382d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: tcp_send
int tcp_send(sock_t sock, stream_t* s)
{
	int rsize = stream_rsize(s);
	int nsend;

	if (rsize == 0)
		return 0;

	nsend = send(sock, s->array + s->pos, rsize, 0);
	if (nsend == -1) {
		int err = errno;
		if (!is_eagain(err)) {
			loge("errno=%d, %s \n",
				err, strerror(err));
			return -1;
		}
		return 0;
	}
	else {
		s->pos += nsend;
		logv("send %d bytes\n", nsend);
		if (stream_quake(s)) {
			loge("stream_quake()\n");
			return -1;
		}
		return nsend;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movl 0x8(%rsi), %eax
movslq 0xc(%rsi), %rsi
xorl %ebx, %ebx
cmpl %esi, %eax
jne 0x3ae9
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
subl %esi, %eax
addq (%r14), %rsi
movslq %eax, %rdx
xorl %ecx, %ecx
callq 0x20f0
movq %rax, %rbx
cmpl $-0x1, %ebx
je 0x3b7b
addl %ebx, 0xc(%r14)
xorl %eax, %eax
callq 0x24d9
cmpl $0x8, (%rax)
jl 0x3b37
leaq 0x3631(%rip), %rsi      # 0x7148
leaq 0x3885(%rip), %rdx      # 0x73a3
leaq 0x3887(%rip), %r8       # 0x73ac
pushq $0x8
popq %rdi
movl $0x292, %ecx            # imm = 0x292
movl %ebx, %r9d
xorl %eax, %eax
callq 0x2512
movq %r14, %rdi
callq 0x41d5
testl %eax, %eax
je 0x3ade
xorl %eax, %eax
callq 0x24d9
pushq $-0x1
popq %rbx
cmpl $0x3, (%rax)
jl 0x3ade
leaq 0x35ef(%rip), %rsi      # 0x7148
leaq 0x3843(%rip), %rdx      # 0x73a3
leaq 0x3854(%rip), %r8       # 0x73bb
pushq $0x3
popq %rdi
movl $0x294, %ecx            # imm = 0x294
xorl %eax, %eax
callq 0x2512
jmp 0x3ade
callq 0x2030
movl (%rax), %ebp
cmpl $0xb, %ebp
je 0x3bdf
movl $0x0, %ebx
cmpl $0x73, %ebp
je 0x3ade
xorl %eax, %eax
callq 0x24d9
pushq $-0x1
popq %rbx
cmpl $0x3, (%rax)
jl 0x3ade
movl %ebp, %edi
callq 0x20c0
movq %rax, (%rsp)
leaq 0x358e(%rip), %rsi      # 0x7148
leaq 0x37e2(%rip), %rdx      # 0x73a3
leaq 0x43ed(%rip), %r8       # 0x7fb5
pushq $0x3
popq %rdi
movl $0x28b, %ecx            # imm = 0x28B
movl %ebp, %r9d
xorl %eax, %eax
callq 0x2512
jmp 0x3ade
xorl %ebx, %ebx
jmp 0x3ade
// File: /workspace/github_c_makefile_star2_O2/GangZhuo[P]dohclient/src/netutils.c
// Function: tcp_recv
int tcp_recv(sock_t sock, char* buf, int buflen)
{
	int nread;

	nread = recv(sock, buf, buflen, 0);
	if (nread == -1) {
		int err = errno;
		if (!is_eagain(err)) {
			loge("errno=%d, %s\n",
				err, strerror(err));
			return -1;
		}
		return 0;
	}
	else if (nread == 0) {
		logd("connection closed by peer\n");
		return -1;
	}
	else {
		logv("recv %d bytes\n", nread);

		return nread;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movslq %edx, %rdx
xorl %ecx, %ecx
callq 0x20b0
movq %rax, %rbx
testl %ebx, %ebx
je 0x3c5e
cmpl $-0x1, %ebx
jne 0x3c93
callq 0x2030
movl (%rax), %ebp
xorl %ebx, %ebx
cmpl $0xb, %ebp
je 0x3cc6
cmpl $0x73, %ebp
je 0x3cc6
xorl %eax, %eax
callq 0x24d9
pushq $-0x1
popq %rbx
cmpl $0x3, (%rax)
jl 0x3cc6
movl %ebp, %edi
callq 0x20c0
movq %rax, (%rsp)
leaq 0x3505(%rip), %rsi      # 0x7148
leaq 0x3781(%rip), %rdx      # 0x73cb
leaq 0x4405(%rip), %r8       # 0x8056
pushq $0x3
popq %rdi
movl $0x2a4, %ecx            # imm = 0x2A4
movl %ebp, %r9d
jmp 0x3cbf
xorl %eax, %eax
callq 0x24d9
pushq $-0x1
popq %rbx
cmpl $0x7, (%rax)
jl 0x3cc6
leaq 0x34d4(%rip), %rsi      # 0x7148
leaq 0x3750(%rip), %rdx      # 0x73cb
leaq 0x3752(%rip), %r8       # 0x73d4
pushq $0x7
popq %rdi
movl $0x2aa, %ecx            # imm = 0x2AA
xorl %eax, %eax
callq 0x2512
jmp 0x3cc6
xorl %eax, %eax
callq 0x24d9
cmpl $0x8, (%rax)
jl 0x3cc6
leaq 0x34a2(%rip), %rsi      # 0x7148
leaq 0x371e(%rip), %rdx      # 0x73cb
leaq 0x373b(%rip), %r8       # 0x73ef
pushq $0x8
popq %rdi
movl $0x2ae, %ecx            # imm = 0x2AE
movl %ebx, %r9d
xorl %eax, %eax
callq 0x2512
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq