LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: cas
static int
cas(struct wire_requestqueue * Q,
    const struct kvldskey * key, const struct kvldskey * oval,
    const struct kvldskey * value, int noop)
{

	/* Send the request. */
	op_done = 0;
	op_count = 1;
	if (proto_kvlds_request_cas(Q, key, oval, value, callback_donep, NULL)) {
		warnp("Error sending CAS request");
		goto err0;
	}

	/* Wait for it to finish. */
	if (events_spin(&op_done) || op_failed) {
		warnp("CAS request failed");
		goto err0;
	}

	/* Check for no-op. */
	if (noop && op_p) {
		warn0("CAS should have been a no-op");
		goto err0;
	}
	if (!noop && !op_p) {
		warn0("CAS should not have been a no-op");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl $0x0, 0x12f62(%rip)     # 0x16628
movq $0x1, 0x12f5f(%rip) # 0x16630
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x3c8(%rip), %r8        # 0x3ab0
xorl %eax, %eax
movl %eax, %r9d
callq 0x6a60
cmpl $0x0, %eax
je 0x3733
jmp 0x36f9
callq 0x20a0
cmpl $0x0, (%rax)
je 0x371e
leaq 0xcc4e(%rip), %rdi      # 0x10358
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x372c
leaq 0xcc33(%rip), %rdi      # 0x10358
movb $0x0, %al
callq 0x6120
jmp 0x372e
jmp 0x37e7
leaq 0x12eee(%rip), %rdi     # 0x16628
callq 0x3f10
cmpl $0x0, %eax
jne 0x374d
cmpl $0x0, 0x12ee1(%rip)     # 0x1662c
je 0x3786
jmp 0x374f
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3774
leaq 0xcc12(%rip), %rdi      # 0x10372
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3782
leaq 0xcbf7(%rip), %rdi      # 0x10372
movb $0x0, %al
callq 0x6120
jmp 0x3784
jmp 0x37e7
cmpl $0x0, -0x2c(%rbp)
je 0x37b2
cmpl $0x0, 0x12ea9(%rip)     # 0x1663c
je 0x37b2
jmp 0x3797
leaq 0xcbe7(%rip), %rdi      # 0x10385
movb $0x0, %al
callq 0x6120
callq 0x20a0
movl $0x0, (%rax)
jmp 0x37e7
cmpl $0x0, -0x2c(%rbp)
jne 0x37de
cmpl $0x0, 0x12e7d(%rip)     # 0x1663c
jne 0x37de
jmp 0x37c3
leaq 0xcbd8(%rip), %rdi      # 0x103a2
movb $0x0, %al
callq 0x6120
callq 0x20a0
movl $0x0, (%rax)
jmp 0x37e7
movl $0x0, -0x4(%rbp)
jmp 0x37ee
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: cad
static int
cad(struct wire_requestqueue * Q,
    const struct kvldskey * key, const struct kvldskey * oval, int noop)
{

	/* Send the request. */
	op_done = 0;
	op_count = 1;
	if (proto_kvlds_request_cad(Q, key, oval, callback_donep, NULL)) {
		warnp("Error sending CAD request");
		goto err0;
	}

	/* Wait for it to finish. */
	if (events_spin(&op_done) || op_failed) {
		warnp("CAD request failed");
		goto err0;
	}

	/* Check for no-op. */
	if (noop && op_p) {
		warn0("CAD should have been a no-op");
		goto err0;
	}
	if (!noop && !op_p) {
		warn0("CAD should not have been a no-op");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, 0x12e07(%rip)     # 0x16628
movq $0x1, 0x12e04(%rip) # 0x16630
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x271(%rip), %rcx       # 0x3ab0
xorl %eax, %eax
movl %eax, %r8d
callq 0x7190
cmpl $0x0, %eax
je 0x388a
jmp 0x3850
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3875
leaq 0xcb62(%rip), %rdi      # 0x103c3
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3883
leaq 0xcb47(%rip), %rdi      # 0x103c3
movb $0x0, %al
callq 0x6120
jmp 0x3885
jmp 0x393e
leaq 0x12d97(%rip), %rdi     # 0x16628
callq 0x3f10
cmpl $0x0, %eax
jne 0x38a4
cmpl $0x0, 0x12d8a(%rip)     # 0x1662c
je 0x38dd
jmp 0x38a6
callq 0x20a0
cmpl $0x0, (%rax)
je 0x38cb
leaq 0xcb26(%rip), %rdi      # 0x103dd
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x38d9
leaq 0xcb0b(%rip), %rdi      # 0x103dd
movb $0x0, %al
callq 0x6120
jmp 0x38db
jmp 0x393e
cmpl $0x0, -0x24(%rbp)
je 0x3909
cmpl $0x0, 0x12d52(%rip)     # 0x1663c
je 0x3909
jmp 0x38ee
leaq 0xcafb(%rip), %rdi      # 0x103f0
movb $0x0, %al
callq 0x6120
callq 0x20a0
movl $0x0, (%rax)
jmp 0x393e
cmpl $0x0, -0x24(%rbp)
jne 0x3935
cmpl $0x0, 0x12d26(%rip)     # 0x1663c
jne 0x3935
jmp 0x391a
leaq 0xcaec(%rip), %rdi      # 0x1040d
movb $0x0, %al
callq 0x6120
callq 0x20a0
movl $0x0, (%rax)
jmp 0x393e
movl $0x0, -0x4(%rbp)
jmp 0x3945
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: callback_get
static int
callback_get(void * cookie, int failed, struct kvldskey * value)
{
	struct kvldskey * value_correct = cookie;

	/* Record failure status. */
	if (failed) {
		op_failed = 1;
		op_done = 1;
	}

	/* Check that the value matches. */
	if (failed == 0) {
		if ((value == NULL) ^ (value_correct == NULL))
			goto bad;
		if ((value != NULL) &&
		    (value->len != value_correct->len))
			goto bad;
		if ((value != NULL) &&
		    memcmp(value->buf, value_correct->buf, value->len))
			goto bad;
		kvldskey_free(value);
	}

	/* Decrement the counter. */
	op_count -= 1;

	/* Are we done? */
	if (op_count == 0)
		op_done = 1;

	/* Success! */
	return (0);

bad:
	op_done = 1;
	op_badval = 1;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x39d5
movl $0x1, 0x12c61(%rip)     # 0x1662c
movl $0x1, 0x12c53(%rip)     # 0x16628
cmpl $0x0, -0x14(%rbp)
jne 0x3a4f
cmpq $0x0, -0x20(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x0, -0x28(%rbp)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x39ff
jmp 0x3a7e
cmpq $0x0, -0x20(%rbp)
je 0x3a1a
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x3a1a
jmp 0x3a7e
cmpq $0x0, -0x20(%rbp)
je 0x3a46
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %edx
callq 0x21b0
cmpl $0x0, %eax
je 0x3a46
jmp 0x3a7e
movq -0x20(%rbp), %rdi
callq 0x2040
movq 0x12bda(%rip), %rax     # 0x16630
subq $0x1, %rax
movq %rax, 0x12bcf(%rip)     # 0x16630
cmpq $0x0, 0x12bc7(%rip)     # 0x16630
jne 0x3a75
movl $0x1, 0x12bb3(%rip)     # 0x16628
movl $0x0, -0x4(%rbp)
jmp 0x3a99
movl $0x1, 0x12ba0(%rip)     # 0x16628
movl $0x1, 0x12ba6(%rip)     # 0x16638
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/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: callback_donep
static int
callback_donep(void * cookie, int failed, int status)
{

	(void)cookie; /* UNUSED */

	/* We're done! */
	op_failed = failed;
	op_p = status ? 0 : 1;
	op_done = 1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x12b65(%rip)     # 0x1662c
movl -0x10(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x12b5f(%rip)     # 0x1663c
movl $0x1, 0x12b41(%rip)     # 0x16628
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/kvlds/main.c
// Function: callback_range
static int
callback_range(void * cookie,
    const struct kvldskey * key, const struct kvldskey * value)
{
	struct wire_requestqueue * Q = cookie;

	(void)value; /* UNUSED */

	/* Delete the key-value pair. */
	op_count += 1;
	if (proto_kvlds_request_delete(Q, key, callback_done, NULL)) {
		warnp("Error sending DELETE request");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x12a4d(%rip), %rax     # 0x16630
addq $0x1, %rax
movq %rax, 0x12a42(%rip)     # 0x16630
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x2ad(%rip), %rdx      # 0x3950
xorl %eax, %eax
movl %eax, %ecx
callq 0x7090
cmpl $0x0, %eax
je 0x3c44
jmp 0x3c0d
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3c32
leaq 0xc6a6(%rip), %rdi      # 0x102c4
movb $0x0, %al
callq 0x5ed0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3c40
leaq 0xc68b(%rip), %rdi      # 0x102c4
movb $0x0, %al
callq 0x6120
jmp 0x3c42
jmp 0x3c4d
movl $0x0, -0x4(%rbp)
jmp 0x3c54
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x1060
movl %eax, %edi
callq 0x1050
movl $0x0, 0x14(%rsp)
cmpl $0x40, 0x14(%rsp)
jge 0x11f9
movl $0x0, 0x10(%rsp)
cmpl $0x800, 0x10(%rsp)      # imm = 0x800
jge 0x11ea
callq 0x1070
movl $0x8000, %ecx           # imm = 0x8000
cltd
idivl %ecx
movslq 0x14(%rsp), %rcx
leaq 0x2e92(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x11ab
jmp 0x11ec
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x119c
movl $0x0, 0xc(%rsp)
cmpl $0x800, 0xc(%rsp)       # imm = 0x800
jge 0x1234
callq 0x1070
movl $0x8000, %ecx           # imm = 0x8000
cltd
idivl %ecx
movslq 0xc(%rsp), %rcx
leaq 0x82e3c(%rip), %rax     # 0x84060
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1201
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movl $0x0, -0x4(%rsp)
cmpl $0x40, -0x4(%rsp)
jge 0x12da
movl $0x0, -0x8(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0x2df9(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x800, -0x14(%rsp)     # imm = 0x800
jge 0x12b7
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movslq -0x14(%rsp), %rdx
leaq 0x82dc2(%rip), %rcx     # 0x84060
imull (%rcx,%rdx,4), %eax
addl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x127b
movl -0x8(%rsp), %edx
movslq -0x4(%rsp), %rcx
leaq 0x84d99(%rip), %rax     # 0x86060
movl %edx, (%rax,%rcx,4)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x1248
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 $0x1a0, %rsp            # imm = 0x1A0
movl $0x800, 0xbc(%rsp) # imm = 0x800
movl $0x0, 0x1c(%rsp)
cmpl $0x40, 0x1c(%rsp)
jge 0x14f4
movl $0x0, 0x18(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %ymm0, 0xc0(%rsp)
vmovdqa 0xc0(%rsp), %ymm0
vmovdqa %ymm0, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x800, 0x14(%rsp)      # imm = 0x800
jge 0x143a
movslq 0x14(%rsp), %rcx
leaq 0x82d0d(%rip), %rax     # 0x84060
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0xf8(%rsp)
movq 0xf8(%rsp), %rax
vmovdqa (%rax), %ymm0
vmovdqa %ymm0, 0x80(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x2cdd(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
vmovdqa (%rax), %ymm0
vmovdqa %ymm0, 0x60(%rsp)
vmovdqa 0x80(%rsp), %ymm1
vmovdqa 0x60(%rsp), %ymm0
vmovdqa %ymm1, 0x120(%rsp)
vmovdqa %ymm0, 0x100(%rsp)
vmovdqa 0x120(%rsp), %ymm0
vmovdqa 0x100(%rsp), %ymm1
vpmulld %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x40(%rsp)
vmovdqa 0x40(%rsp), %ymm1
vmovdqa 0x20(%rsp), %ymm0
vmovdqa %ymm1, 0x160(%rsp)
vmovdqa %ymm0, 0x140(%rsp)
vmovdqa 0x160(%rsp), %ymm0
vmovdqa 0x140(%rsp), %ymm1
vpaddd %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x20(%rsp)
movslq 0x14(%rsp), %rax
addq $0x8, %rax
movl %eax, 0x14(%rsp)
jmp 0x1339
leaq 0x20(%rsp), %rax
movq %rax, 0xb0(%rsp)
movl $0x0, 0x10(%rsp)
movslq 0x10(%rsp), %rax
cmpq $0x8, %rax
jae 0x147f
movq 0xb0(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x144f
movl $0x800, 0xc(%rsp)       # imm = 0x800
cmpl $0x800, 0xc(%rsp)       # imm = 0x800
jge 0x14d1
movslq 0x1c(%rsp), %rcx
leaq 0x2bc3(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movslq 0xc(%rsp), %rdx
leaq 0x82ba8(%rip), %rcx     # 0x84060
imull (%rcx,%rdx,4), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1487
movl 0x18(%rsp), %edx
movslq 0x1c(%rsp), %rcx
leaq 0x84b7f(%rip), %rax     # 0x86060
movl %edx, (%rax,%rcx,4)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1302
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 $0x340, %rsp            # imm = 0x340
movl $0x800, 0x17c(%rsp) # imm = 0x800
movl $0x0, 0x3c(%rsp)
cmpl $0x40, 0x3c(%rsp)
jge 0x171d
movl $0x0, 0x38(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa64 %zmm0, 0x180(%rsp)
vmovdqa64 0x180(%rsp), %zmm0
vmovdqa64 %zmm0, 0x40(%rsp)
movl $0x0, 0x34(%rsp)
cmpl $0x800, 0x34(%rsp)      # imm = 0x800
jge 0x1663
movslq 0x34(%rsp), %rcx
leaq 0x82aed(%rip), %rax     # 0x84060
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x1f8(%rsp)
movq 0x1f8(%rsp), %rax
vmovdqa64 (%rax), %zmm0
vmovdqa64 %zmm0, 0x100(%rsp)
movslq 0x3c(%rsp), %rcx
leaq 0x2abc(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movslq 0x34(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x1f0(%rsp)
movq 0x1f0(%rsp), %rax
vmovdqa64 (%rax), %zmm0
vmovdqa64 %zmm0, 0xc0(%rsp)
vmovdqa64 0x100(%rsp), %zmm1
vmovdqa64 0xc0(%rsp), %zmm0
vmovdqa64 %zmm1, 0x240(%rsp)
vmovdqa64 %zmm0, 0x200(%rsp)
vmovdqa64 0x240(%rsp), %zmm0
vmovdqa64 0x200(%rsp), %zmm1
vpmulld %zmm1, %zmm0, %zmm0
vmovdqa64 %zmm0, 0x80(%rsp)
vmovdqa64 0x80(%rsp), %zmm1
vmovdqa64 0x40(%rsp), %zmm0
vmovdqa64 %zmm1, 0x2c0(%rsp)
vmovdqa64 %zmm0, 0x280(%rsp)
vmovdqa64 0x2c0(%rsp), %zmm0
vmovdqa64 0x280(%rsp), %zmm1
vpaddd %zmm1, %zmm0, %zmm0
vmovdqa64 %zmm0, 0x40(%rsp)
movslq 0x34(%rsp), %rax
addq $0x10, %rax
movl %eax, 0x34(%rsp)
jmp 0x1559
leaq 0x40(%rsp), %rax
movq %rax, 0x170(%rsp)
movl $0x0, 0x30(%rsp)
movslq 0x30(%rsp), %rax
cmpq $0x10, %rax
jae 0x16a8
movq 0x170(%rsp), %rax
movslq 0x30(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addl 0x38(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x1678
movl $0x800, 0x2c(%rsp)      # imm = 0x800
cmpl $0x800, 0x2c(%rsp)      # imm = 0x800
jge 0x16fa
movslq 0x3c(%rsp), %rcx
leaq 0x299a(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movslq 0x2c(%rsp), %rdx
leaq 0x8297f(%rip), %rcx     # 0x84060
imull (%rcx,%rdx,4), %eax
addl 0x38(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x16b0
movl 0x38(%rsp), %edx
movslq 0x3c(%rsp), %rcx
leaq 0x84956(%rip), %rax     # 0x86060
movl %edx, (%rax,%rcx,4)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x1522
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: aez_setup
void aez_setup(unsigned char *key, unsigned keylen, aez_ctx_t *ctx) {
    block tmp;
    if (keylen==48) {
        ctx->I[0] = loadu(key);
        ctx->J[0] = loadu(key+16);
        ctx->L    = loadu(key+32);
    } else {
        blake2b(ctx, 48, 0, 0, key, keylen);    /* Puts IJL into ctx */
        ctx->J[0] = ctx->I[1];                  /* Rearrange.        */
        ctx->L    = ctx->I[2];
    }
    /* Fill ctx with J doublings */
    ctx->I[1] = bswap16(tmp = double_block(bswap16(ctx->I[0])));
    ctx->I[2] = bswap16(tmp = double_block(tmp));
    ctx->J[1] = bswap16(tmp = double_block(bswap16(ctx->J[0])));
    ctx->J[2] = bswap16(tmp = double_block(tmp));
    ctx->delta3_cache = zero;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
cmpl $0x30, 0x24(%rsp)
jne 0x127e
movq 0x28(%rsp), %rdi
callq 0x1380
movq 0x18(%rsp), %rax
vmovdqa %xmm0, (%rax)
movq 0x28(%rsp), %rdi
addq $0x10, %rdi
callq 0x1380
movq 0x18(%rsp), %rax
vmovdqa %xmm0, 0x30(%rax)
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
callq 0x1380
movq 0x18(%rsp), %rax
vmovdqa %xmm0, 0x60(%rax)
jmp 0x12c8
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %r8
movl 0x24(%rsp), %eax
movl %eax, %r9d
movl $0x30, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x13a0
movq 0x18(%rsp), %rax
vmovdqa 0x10(%rax), %xmm0
movq 0x18(%rsp), %rax
vmovdqa %xmm0, 0x30(%rax)
movq 0x18(%rsp), %rax
vmovdqa 0x20(%rax), %xmm0
movq 0x18(%rsp), %rax
vmovdqa %xmm0, 0x60(%rax)
movq 0x18(%rsp), %rax
vmovdqa (%rax), %xmm0
callq 0x1450
callq 0x1590
vmovdqa %xmm0, (%rsp)
callq 0x1450
movq 0x18(%rsp), %rax
vmovdqa %xmm0, 0x10(%rax)
vmovdqa (%rsp), %xmm0
callq 0x1590
vmovdqa %xmm0, (%rsp)
callq 0x1450
movq 0x18(%rsp), %rax
vmovdqa %xmm0, 0x20(%rax)
movq 0x18(%rsp), %rax
vmovdqa 0x30(%rax), %xmm0
callq 0x1450
callq 0x1590
vmovdqa %xmm0, (%rsp)
callq 0x1450
movq 0x18(%rsp), %rax
vmovdqa %xmm0, 0x40(%rax)
vmovdqa (%rsp), %xmm0
callq 0x1590
vmovdqa %xmm0, (%rsp)
callq 0x1450
movq 0x18(%rsp), %rax
vmovdqa %xmm0, 0x50(%rax)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x30(%rsp), %xmm0
movq 0x18(%rsp), %rax
vmovdqa %xmm0, 0x70(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: blake2b
static int blake2b(void *out, size_t outlen,
                   const void *key, size_t keylen,
                   const void *in, size_t inlen)
{
    blake2b_ctx ctx;
    
    if (blake2b_init(&ctx, outlen, key, keylen))
        return -1;
    blake2b_update(&ctx, in, inlen);
    blake2b_final(&ctx, out);
    
    return 0;
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0xf8(%rsp)
movq %rcx, 0xf0(%rsp)
movq %r8, 0xe8(%rsp)
movq %r9, 0xe0(%rsp)
movq 0x100(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq 0xf0(%rsp), %rcx
movq %rsp, %rdi
callq 0x9b50
cmpl $0x0, %eax
je 0x1409
movl $0xffffffff, 0x114(%rsp) # imm = 0xFFFFFFFF
jmp 0x143c
movq 0xe8(%rsp), %rsi
movq 0xe0(%rsp), %rdx
movq %rsp, %rdi
callq 0x9cb0
movq 0x108(%rsp), %rsi
movq %rsp, %rdi
callq 0x9db0
movl $0x0, 0x114(%rsp)
movl 0x114(%rsp), %eax
addq $0x118, %rsp            # imm = 0x118
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: double_block
static __m128i double_block(__m128i bl) {
    const __m128i mask = _mm_set_epi32(135,1,1,1);
    __m128i tmp = _mm_srai_epi32(bl, 31);
    tmp = _mm_and_si128(tmp, mask);
    tmp = _mm_shuffle_epi32(tmp, _MM_SHUFFLE(2,1,0,3));
    bl = _mm_slli_epi32(bl, 1);
    return _mm_xor_si128(bl,tmp);
}

// Assembly:
subq $0x58, %rsp
vmovdqa %xmm0, -0x60(%rsp)
movl $0x87, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movl $0x1, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0x18(%rsp), %eax
vmovd 0xc(%rsp), %xmm0
vpinsrd $0x1, %edx, %xmm0, %xmm0
vpinsrd $0x2, %ecx, %xmm0, %xmm0
vpinsrd $0x3, %eax, %xmm0, %xmm0
vmovdqa %xmm0, -0x10(%rsp)
vmovdqa -0x10(%rsp), %xmm0
vmovdqa %xmm0, -0x70(%rsp)
vmovdqa -0x60(%rsp), %xmm0
vmovdqa %xmm0, 0x20(%rsp)
movl $0x1f, 0x1c(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovd 0x1c(%rsp), %xmm1
vpsrad %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
vmovdqa -0x70(%rsp), %xmm0
vmovdqa %xmm1, -0x20(%rsp)
vmovdqa %xmm0, -0x30(%rsp)
vmovdqa -0x20(%rsp), %xmm0
vmovdqa -0x30(%rsp), %xmm1
vpand %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm0
vpshufd $0x93, %xmm0, %xmm0     # xmm0 = xmm0[3,0,1,2]
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x60(%rsp), %xmm0
vmovdqa %xmm0, 0x40(%rsp)
movl $0x1, 0x3c(%rsp)
vmovdqa 0x40(%rsp), %xmm0
movl 0x3c(%rsp), %eax
vmovd %eax, %xmm1
vpslld %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x60(%rsp)
vmovdqa -0x60(%rsp), %xmm1
vmovdqa -0x80(%rsp), %xmm0
vmovdqa %xmm1, -0x40(%rsp)
vmovdqa %xmm0, -0x50(%rsp)
vmovdqa -0x40(%rsp), %xmm0
vpxor -0x50(%rsp), %xmm0, %xmm0
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: aes4
static __m128i aes4(__m128i in, __m128i a, __m128i b, __m128i c, __m128i d) {
    in = _mm_aesenc_si128(in,a);
    in = _mm_aesenc_si128(in,b);
    in = _mm_aesenc_si128(in,c);
    return _mm_aesenc_si128 (in,d);
}

// Assembly:
subq $0x58, %rsp
vmovdqa %xmm0, -0x40(%rsp)
vmovdqa %xmm1, -0x50(%rsp)
vmovdqa %xmm2, -0x60(%rsp)
vmovdqa %xmm3, -0x70(%rsp)
vmovdqa %xmm4, -0x80(%rsp)
vmovdqa -0x40(%rsp), %xmm1
vmovdqa -0x50(%rsp), %xmm0
vmovdqa %xmm1, 0x40(%rsp)
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x40(%rsp), %xmm0
vmovdqa 0x30(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x40(%rsp)
vmovdqa -0x40(%rsp), %xmm1
vmovdqa -0x60(%rsp), %xmm0
vmovdqa %xmm1, 0x20(%rsp)
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x40(%rsp)
vmovdqa -0x40(%rsp), %xmm1
vmovdqa -0x70(%rsp), %xmm0
vmovdqa %xmm1, (%rsp)
vmovdqa %xmm0, -0x10(%rsp)
vmovdqa (%rsp), %xmm0
vmovdqa -0x10(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x40(%rsp)
vmovdqa -0x40(%rsp), %xmm1
vmovdqa -0x80(%rsp), %xmm0
vmovdqa %xmm1, -0x20(%rsp)
vmovdqa %xmm0, -0x30(%rsp)
vmovdqa -0x20(%rsp), %xmm0
vmovdqa -0x30(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq 0x90(%rsp), %rax
movl 0x88(%rsp), %eax
movq 0x80(%rsp), %rax
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq %rcx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movl %r9d, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl 0x3c(%rsp), %edx
movq 0x30(%rsp), %rcx
movl 0x2c(%rsp), %r8d
movl 0x28(%rsp), %r9d
callq 0x1090
vmovdqa %xmm0, 0x10(%rsp)
cmpl $0x0, 0x88(%rsp)
jne 0x9724
movq 0x48(%rsp), %rdi
vmovdqa 0x10(%rsp), %xmm0
movq 0x48(%rsp), %rax
vmovdqa 0x30(%rax), %xmm2
movq 0x48(%rsp), %rax
vmovdqa 0x40(%rax), %xmm1
vmovdqa %xmm2, 0x60(%rsp)
vmovdqa %xmm1, 0x50(%rsp)
vmovdqa 0x60(%rsp), %xmm1
vpxor 0x50(%rsp), %xmm1, %xmm1
callq 0x8560
vmovdqa %xmm0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x28(%rsp), %eax
jae 0x9722
movl 0xc(%rsp), %eax
movb 0x10(%rsp,%rax), %dl
movq 0x90(%rsp), %rax
movl 0xc(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x96f4
jmp 0x9794
movl 0x88(%rsp), %eax
addl 0x28(%rsp), %eax
cmpl $0x20, %eax
jae 0x9764
movq 0x48(%rsp), %rdi
vmovdqa 0x10(%rsp), %xmm0
movq 0x80(%rsp), %rdx
movl 0x88(%rsp), %ecx
movl 0x28(%rsp), %r8d
movq 0x90(%rsp), %r9
xorl %esi, %esi
callq 0x1050
jmp 0x9792
movq 0x48(%rsp), %rdi
vmovdqa 0x10(%rsp), %xmm0
movq 0x80(%rsp), %rdx
movl 0x88(%rsp), %ecx
movl 0x28(%rsp), %r8d
movq 0x90(%rsp), %r9
xorl %esi, %esi
callq 0x10e0
jmp 0x9794
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xa8, %rsp
movq 0xc0(%rsp), %rax
movl 0xb8(%rsp), %eax
movq 0xb0(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movl %r9d, 0x30(%rsp)
movl 0xb8(%rsp), %eax
cmpl 0x30(%rsp), %eax
jae 0x97f5
movl $0xffffffff, 0x5c(%rsp) # imm = 0xFFFFFFFF
jmp 0x995b
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl 0x44(%rsp), %edx
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %r8d
movl 0x30(%rsp), %r9d
callq 0x1090
vmovdqa %xmm0, 0x20(%rsp)
movl 0xb8(%rsp), %eax
cmpl 0x30(%rsp), %eax
jne 0x98e5
movq 0xb0(%rsp), %rdi
callq 0x1380
movl 0x30(%rsp), %eax
movl $0x10, %edi
movl %edi, 0xc(%rsp)
subl %eax, %edi
callq 0x8510
vmovdqa %xmm0, 0x10(%rsp)
movq 0x50(%rsp), %rdi
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x30(%rdi), %xmm2
vmovdqa 0x40(%rdi), %xmm1
vmovdqa %xmm2, 0x70(%rsp)
vmovdqa %xmm1, 0x60(%rsp)
vmovdqa 0x70(%rsp), %xmm1
vmovdqa 0x60(%rsp), %xmm2
vpxor %xmm2, %xmm1, %xmm1
callq 0x8560
movl 0xc(%rsp), %edi
movl 0x30(%rsp), %eax
subl %eax, %edi
callq 0x8510
vmovdqa %xmm0, 0x20(%rsp)
vmovdqa 0x20(%rsp), %xmm1
vmovdqa 0x10(%rsp), %xmm0
vmovdqa %xmm1, 0x90(%rsp)
vmovdqa %xmm0, 0x80(%rsp)
vmovdqa 0x90(%rsp), %xmm0
vpternlogq $0xf, %xmm0, %xmm0, %xmm0
vpand 0x80(%rsp), %xmm0, %xmm0
callq 0x87e0
subl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x995b
cmpl $0x20, 0xb8(%rsp)
jae 0x9926
movq 0x50(%rsp), %rdi
vmovdqa 0x20(%rsp), %xmm0
movq 0xb0(%rsp), %rdx
movl 0xb8(%rsp), %ecx
movl 0x30(%rsp), %r8d
movq 0xc0(%rsp), %r9
movl $0x1, %esi
callq 0x1050
movl %eax, 0x5c(%rsp)
jmp 0x995b
movq 0x50(%rsp), %rdi
vmovdqa 0x20(%rsp), %xmm0
movq 0xb0(%rsp), %rdx
movl 0xb8(%rsp), %ecx
movl 0x30(%rsp), %r8d
movq 0xc0(%rsp), %r9
movl $0x1, %esi
callq 0x10e0
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xd8, %rsp
movq 0xf0(%rsp), %rax
movq 0xe8(%rsp), %rax
movq 0xe0(%rsp), %rax
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movq %r9, 0xa8(%rsp)
cmpq $0x0, 0xc8(%rsp)
je 0x99e1
movq 0xb8(%rsp), %rcx
addq $0x10, %rcx
movq 0xc8(%rsp), %rax
movq %rcx, (%rax)
movq 0xf0(%rsp), %rdi
movl $0x30, %esi
leaq 0x20(%rsp), %rdx
callq 0x1030
movq 0xe8(%rsp), %rsi
movq 0xb0(%rsp), %rcx
movq 0xa8(%rsp), %rax
movl %eax, %r8d
movq 0xc0(%rsp), %r11
movq 0xb8(%rsp), %rax
movl %eax, %r10d
movq 0xd0(%rsp), %rax
leaq 0x20(%rsp), %rdi
movl $0xc, %edx
movl $0x10, %r9d
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x10f0
xorl %eax, %eax
addq $0xd8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
)
{
    aez_ctx_t ctx;
    (void)nsec;
    if (mlen) *mlen = clen-16;
    aez_setup((unsigned char *)k, 48, &ctx);
    return aez_decrypt(&ctx, (char *)npub, 12,
                 (char *)ad, (unsigned)adlen, 16,
                 (char *)c, (unsigned)clen, (char *)m);
}

// Assembly:
subq $0xd8, %rsp
movq 0xf0(%rsp), %rax
movq 0xe8(%rsp), %rax
movq 0xe0(%rsp), %rax
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movq %r9, 0xa8(%rsp)
cmpq $0x0, 0xc8(%rsp)
je 0x9ad1
movq 0xb0(%rsp), %rcx
subq $0x10, %rcx
movq 0xc8(%rsp), %rax
movq %rcx, (%rax)
movq 0xf0(%rsp), %rdi
movl $0x30, %esi
leaq 0x20(%rsp), %rdx
callq 0x1030
movq 0xe8(%rsp), %rsi
movq 0xa8(%rsp), %rcx
movq 0xe0(%rsp), %rax
movl %eax, %r8d
movq 0xb8(%rsp), %r11
movq 0xb0(%rsp), %rax
movl %eax, %r10d
movq 0xd0(%rsp), %rax
leaq 0x20(%rsp), %rdi
movl $0xc, %edx
movl $0x10, %r9d
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x10c0
addq $0xd8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: blake2b_init
static int blake2b_init(blake2b_ctx *ctx, size_t outlen,
                        const void *key, size_t keylen)
{
    size_t i;
    
    if (outlen == 0 || outlen > 64 || keylen > 64)
        return -1;
    
    for (i = 0; i < 8; i++)
        ctx->h[i] = blake2b_iv[i];
    ctx->h[0] ^= 0x01010000 ^ (keylen << 8) ^ outlen;
    
    ctx->t[0] = 0;
    ctx->t[1] = 0;
    ctx->c = 0;
    ctx->outlen = outlen;
    
    for (i = keylen; i < 128; i++)
        ctx->b[i] = 0;
    if (keylen > 0) {
        blake2b_update(ctx, key, keylen);
        ctx->c = 128;
    }
    
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x9b80
cmpq $0x40, 0x20(%rsp)
ja 0x9b80
cmpq $0x40, 0x10(%rsp)
jbe 0x9b8d
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x9ca0
movq $0x0, 0x8(%rsp)
cmpq $0x8, 0x8(%rsp)
jae 0x9bd0
movq 0x8(%rsp), %rcx
leaq 0x1486(%rip), %rax      # 0xb030
movq (%rax,%rcx,8), %rdx
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, 0x80(%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x9b96
movq 0x10(%rsp), %rcx
shlq $0x8, %rcx
xorq $0x1010000, %rcx        # imm = 0x1010000
xorq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
xorq 0x80(%rax), %rcx
movq %rcx, 0x80(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0xc0(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0xc8(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0xd0(%rax)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0xd8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x80, 0x8(%rsp)
jae 0x9c6c
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x9c43
cmpq $0x0, 0x10(%rsp)
jbe 0x9c98
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x9cb0
movq 0x28(%rsp), %rax
movq $0x80, 0xd0(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: blake2b_update
static void blake2b_update(blake2b_ctx *ctx,
                           const void *in, size_t inlen)
{
    size_t i;
    
    for (i = 0; i < inlen; i++) {
        if (ctx->c == 128) {
            ctx->t[0] += ctx->c;
            if (ctx->t[0] < ctx->c)
                ctx->t[1]++;
            blake2b_compress(ctx, 0);
            ctx->c = 0;
        }
        ctx->b[ctx->c++] = ((const uint8_t *) in)[i];
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x9d9c
movq 0x20(%rsp), %rax
cmpq $0x80, 0xd0(%rax)
jne 0x9d5a
movq 0x20(%rsp), %rax
movq 0xd0(%rax), %rcx
movq 0x20(%rsp), %rax
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
movq 0x20(%rsp), %rax
movq 0xc0(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0xd0(%rcx), %rax
jae 0x9d3e
movq 0x20(%rsp), %rax
movq 0xc8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rax)
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x9ec0
movq 0x20(%rsp), %rax
movq $0x0, 0xd0(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movq 0x20(%rsp), %rsi
movq 0xd0(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0xd0(%rsi)
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x9ccc
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/aesni/encrypt.c
// Function: blake2b_final
static void blake2b_final(blake2b_ctx *ctx, void *out)
{
    size_t i;
    
    ctx->t[0] += ctx->c;
    if (ctx->t[0] < ctx->c)
        ctx->t[1]++;
    
    while (ctx->c < 128)
        ctx->b[ctx->c++] = 0;
    blake2b_compress(ctx, 1);
    
    for (i = 0; i < ctx->outlen; i++) {
        ((uint8_t *) out)[i] =
        (ctx->h[i >> 3] >> (8 * (i & 7))) & 0xFF;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rcx
movq 0x10(%rsp), %rax
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0xd0(%rcx), %rax
jae 0x9e0e
movq 0x10(%rsp), %rax
movq 0xc8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rax)
jmp 0x9e10
movq 0x10(%rsp), %rax
cmpq $0x80, 0xd0(%rax)
jae 0x9e47
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rdx
movq 0xd0(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rdx)
movb $0x0, (%rax,%rcx)
jmp 0x9e10
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x9ec0
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0xd8(%rcx), %rax
jae 0x9eb6
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
shrq $0x3, %rcx
movq 0x80(%rax,%rcx,8), %rax
movq (%rsp), %rcx
andq $0x7, %rcx
shlq $0x3, %rcx
shrq %cl, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x9e5e
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/log.c
// Function: log_vwrite
void log_vwrite(int mask,
		const char *file, const char *func, int line,
		const char *fmt, va_list args)
{
	if (log_level_comp(mask) <= loglevel) {
		if (mask & LOG_MASK_RAW) {
			log_vprintf(mask, file, func, line, fmt, args);
		}
		else if (s_log_flags & LOG_FLG_TIME) {
			log_vprintf_with_timestamp(mask, file, func, line, fmt, args);
		}
		else {
			log_vprintf(mask, file, func, line, fmt, args);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x34(%rbp)
callq 0x2560
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jg 0x262c
movl -0x4(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x25da
movq 0xbc30(%rip), %rax      # 0xe1f0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq *%rax
jmp 0x262a
movl 0xbc20(%rip), %eax      # 0xe200
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2609
movq 0xbc09(%rip), %rax      # 0xe1f8
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq *%rax
jmp 0x2628
movq 0xbbe0(%rip), %rax      # 0xe1f0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq *%rax
jmp 0x262a
jmp 0x262c
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/log.c
// Function: log_write
void log_write(int mask,
		const char *file, const char *func, int line,
		const char *fmt, ...)
{
	if (log_level_comp(mask) <= loglevel) {
		va_list args;
		va_start(args, fmt);
		log_vwrite(mask, file, func, line, fmt, args);
		va_end(args);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x267b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, -0xf4(%rbp)
callq 0x2560
movq %rax, %rcx
movl -0xf4(%rbp), %eax
cmpl (%rcx), %eax
jg 0x26f7
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x28, (%rax)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0x2570
leaq -0x40(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jg 0x2783
movq 0xb85e(%rip), %rax      # 0xdfd8
movq (%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x2791
movq 0xb82e(%rip), %rax      # 0xdfb8
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x27be
movslq -0x2c(%rbp), %rax
cmpq $0x9, %rax
jae 0x27be
movslq -0x2c(%rbp), %rcx
leaq 0xbaac(%rip), %rax      # 0xe260
movq (%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
jmp 0x27cb
leaq 0x788b(%rip), %rax      # 0xa050
movq %rax, -0x58(%rbp)
jmp 0x27cb
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x2900
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
leaq 0x7849(%rip), %rsi      # 0xa056
movb $0x0, %al
callq 0x2300
movq -0x48(%rbp), %rdi
callq 0x2290
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movl $0x1, %esi
movq %rax, (%rsp)
callq 0x2900
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x28e7
movq -0x38(%rbp), %rdi
callq 0x20f0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jbe 0x28e7
movq 0xba30(%rip), %rdi      # 0xe2c8
leaq 0x7765(%rip), %rsi      # 0xa004
callq 0x2280
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x28d0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl $0x1, %esi
callq 0x2390
movq -0x48(%rbp), %rdi
callq 0x2220
jmp 0x28e5
movq 0xb9f1(%rip), %rsi      # 0xe2c8
leaq 0x7729(%rip), %rdi      # 0xa007
movb $0x0, %al
callq 0x2040
jmp 0x28e7
movq -0x38(%rbp), %rdi
callq 0x2290
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2120
cmpl $0x0, -0x8(%rbp)
je 0x29b2
xorl %eax, %eax
movl %eax, %edi
callq 0x21f0
movq %rax, -0x78(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2170
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl $0x20, %esi
leaq 0x76fc(%rip), %rdx      # 0xa079
callq 0x21a0
leaq -0x50(%rbp), %rdi
callq 0x20f0
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x7c(%rbp)
cltq
movb $0x20, -0x50(%rbp,%rax)
movl -0x7c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x7c(%rbp)
cltq
movb $0x0, -0x50(%rbp,%rax)
movl -0x2c(%rbp), %edi
callq 0x2700
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2c10
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rdi
movq 0x10(%rbp), %rsi
callq 0x2cd0
movq %rax, -0x68(%rbp)
leaq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movq -0x68(%rbp), %r9
leaq 0x7694(%rip), %rdi      # 0xa08b
movb $0x0, %al
callq 0x2db0
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x2290
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
xorl %esi, %esi
movq %rax, (%rsp)
callq 0x2900
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %edi
movq -0x38(%rbp), %rdx
leaq 0x761b(%rip), %rsi      # 0xa098
movb $0x0, %al
callq 0x2070
movq -0x38(%rbp), %rdi
callq 0x2290
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2af3
movq -0x8(%rbp), %rdi
callq 0x20f0
cmpq $0x0, %rax
je 0x2af3
movq -0x8(%rbp), %rax
movq %rax, 0xb7fb(%rip)      # 0xe2c8
leaq -0x2a4(%rip), %rax      # 0x2830
movq %rax, 0xb715(%rip)      # 0xe1f0
leaq -0x2b2(%rip), %rax      # 0x2830
movq %rax, 0xb70f(%rip)      # 0xe1f8
movl $0x1, 0xb7dd(%rip)      # 0xe2d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0xb7c5(%rip)      # 0xe2d0
je 0x2b33
leaq -0x664(%rip), %rax      # 0x24b0
movq %rax, 0xb6d5(%rip)      # 0xe1f0
leaq -0x622(%rip), %rax      # 0x2500
movq %rax, 0xb6cf(%rip)      # 0xe1f8
movl $0x0, 0xb79d(%rip)      # 0xe2d0
popq %rbp
retq
nopw %cs:(%rax,%rax)