LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/atsidaev[P]trx2x/DiskImage.cpp
// Function: reconst()
void reconst(void)
{
  int i, j, k;
  int f, l;

  /* collect leaf nodes in the first half of the table */
  /* and replace the freq by (freq + 1) / 2. */
  j = 0;
  for(i = 0; i < T; i++)
  {
    if(son[i] >= T)
    {
      freq[j] = (freq[i] + 1) / 2;
      son[j] = son[i];
      j++;
    }
  }
  /* begin constructing tree by connecting sons */
  for(i = 0, j = N_CHAR; j < T; i += 2, j++)
  {
    k = i + 1;
    f = freq[j] = freq[i] + freq[k];
    for(k = j - 1; f < freq[k]; k--);
    k++;
    l = (j - k) * sizeof(*freq);
    memcpy(&freq[k + 1], &freq[k], l);
    freq[k] = f;
    memcpy(&son[k + 1], &son[k], l);
    son[k] = i;
  }
  /* connect prnt */
  for (i = 0; i < T; i++)
    if ((k = son[i]) >= T) prnt[k] = i;
    else prnt[k] = prnt[k + 1] = i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
leaq 0x57fe(%rip), %r13      # 0xc2a0
xorl %ecx, %ecx
leaq 0x4ba5(%rip), %rdi      # 0xb650
cmpq $0x4e6, %rax            # imm = 0x4E6
je 0x6adc
movzwl (%rax,%r13), %edx
cmpw $0x273, %dx             # imm = 0x273
jb 0x6ad6
movzwl (%rax,%rdi), %esi
incl %esi
shrl %esi
movslq %ecx, %rcx
movw %si, (%rdi,%rcx,2)
movw %dx, (%r13,%rcx,2)
incl %ecx
addq $0x2, %rax
jmp 0x6aab
movl $0x13a, %ecx            # imm = 0x13A
movabsq $-0x13b00000000, %rdx   # imm = 0xFFFFFEC500000000
movabsq $-0x13c00000000, %rsi   # imm = 0xFFFFFEC400000000
leaq 0x4dc6(%rip), %rbp      # 0xb8c2
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
xorl %edi, %edi
cmpq $0x273, %rcx            # imm = 0x273
je 0x6bda
leaq 0x4b34(%rip), %rax      # 0xb650
movzwl 0x2(%rax,%rdi,2), %r13d
movq %rdi, 0x8(%rsp)
addw (%rax,%rdi,2), %r13w
movq %rcx, 0x20(%rsp)
movw %r13w, (%rax,%rcx,2)
xorl %eax, %eax
xorl %ebx, %ebx
movq %rax, %rcx
addq %r12, %rbx
addq $-0x2, %rax
cmpw (%rbp,%rcx), %r13w
jb 0x6b3a
pushq $-0x2
popq %rcx
subl %eax, %ecx
movq %rbx, %r15
subq %rsi, %r15
sarq $0x1f, %r15
leaq 0x4aee(%rip), %rax      # 0xb650
leaq (%rax,%r15), %rdi
subq %rdx, %rbx
sarq $0x1f, %rbx
movq %rsi, 0x10(%rsp)
leaq (%rax,%rbx), %rsi
movslq %ecx, %r14
movq %rdx, 0x18(%rsp)
movq %r14, %rdx
callq 0x10d0
leaq 0x4ac3(%rip), %rax      # 0xb650
movw %r13w, (%rbx,%rax)
leaq 0x5707(%rip), %r13      # 0xc2a0
addq %r13, %r15
leaq (%rbx,%r13), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x10d0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rdi
movw %di, (%rbx,%r13)
addq $0x2, %rdi
movq 0x20(%rsp), %rcx
incq %rcx
addq %r12, %rdx
addq %r12, %rsi
addq $0x2, %rbp
jmp 0x6b08
xorl %eax, %eax
leaq 0x4f5d(%rip), %rcx      # 0xbb40
cmpq $0x273, %rax            # imm = 0x273
je 0x6c10
movswq (%r13), %rdx
cmpq $0x273, %rdx            # imm = 0x273
jae 0x6c03
leal 0x1(%rdx), %esi
movzwl %si, %esi
movw %ax, (%rcx,%rsi,2)
movw %ax, (%rcx,%rdx,2)
incq %rax
addq $0x2, %r13
jmp 0x6be3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/atsidaev[P]trx2x/DiskImage.cpp
// Function: update(int)
void update(int c)
{
  int i, j, k, l;

  if(freq[R] == MAX_FREQ) reconst();

  c = prnt[c + T];
  do {
    k = ++freq[c];

    /* if the order is disturbed, exchange nodes */
    if (k > freq[l = c + 1])
    {
      while (k > freq[++l]);
      l--;
      freq[c] = freq[l];
      freq[l] = k;

      i = son[c];
      prnt[i] = l;
      if (i < T) prnt[i + 1] = l;

      j = son[l];
      son[l] = i;

      prnt[j] = c;
      if (j < T) prnt[j + 1] = c;
      son[c] = j;

      c = l;
    }
  } while ((c = prnt[c]) != 0);  /* repeat up to root */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %eax, %eax
cmpw 0x4f03(%rip), %ax       # 0xbb34
jno 0x6c38
callq 0x6a8b
addl $0x273, %ebx            # imm = 0x273
leaq 0x4efb(%rip), %rax      # 0xbb40
movzwl (%rax,%rbx,2), %edi
leaq 0x4a00(%rip), %rcx      # 0xb650
movabsq $0x100000000, %rdx      # imm = 0x100000000
leaq 0x563f(%rip), %rsi      # 0xc2a0
movswq %di, %r8
movzwl (%rcx,%r8,2), %r11d
incl %r11d
movw %r11w, (%rcx,%r8,2)
cmpw 0x2(%rcx,%r8,2), %r11w
jbe 0x6d07
movzwl %r8w, %r10d
movq %r8, %r9
shlq $0x20, %r9
leaq (%rcx,%r8,2), %r14
addq $0x4, %r14
xorl %ebx, %ebx
movq %rbx, %r15
addq %rdx, %r9
incq %rbx
cmpw (%r14,%r15,2), %r11w
ja 0x6c93
movq %r9, %r14
sarq $0x1f, %r14
movzwl (%r14,%rcx), %ebp
movw %bp, (%rcx,%r8,2)
movw %r11w, (%r14,%rcx)
movswq (%rsi,%r8,2), %r11
movq %r10, %r14
addq %rbx, %r14
movw %r14w, (%rax,%r11,2)
cmpq $0x272, %r11            # imm = 0x272
ja 0x6cdc
movzwl %r11w, %ebx
movw %r14w, 0x2(%rax,%rbx,2)
sarq $0x20, %r9
movswq (%rsi,%r9,2), %rbx
movw %r11w, (%rsi,%r9,2)
movw %di, (%rax,%rbx,2)
cmpq $0x272, %rbx            # imm = 0x272
ja 0x6d00
movzwl %bx, %edi
movw %r10w, 0x2(%rax,%rdi,2)
movw %bx, (%rsi,%r8,2)
jmp 0x6d0a
movq %r8, %r9
movzwl (%rax,%r9,2), %edi
testw %di, %di
jne 0x6c61
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/atsidaev[P]trx2x/DiskImage.cpp
// Function: DecodeChar()
int DecodeChar(void)
{
  int c;

  c = son[R];

  /* travel from root to leaf, */
  /* choosing the smaller child node (son[]) if the read bit is 0, */
  /* the bigger (son[]+1} if 1 */
  while(c < T) c = son[c + GetBit()];
  c -= T;
  update(c);
  return c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5a56(%rip), %rax      # 0xc784
leaq 0x556b(%rip), %r14      # 0xc2a0
movswl (%rax), %ebx
cmpl $0x272, %ebx            # imm = 0x272
ja 0x6d4d
callq 0x68e6
addl %ebx, %eax
leaq (%r14,%rax,2), %rax
jmp 0x6d35
addl $0xfffffd8d, %ebx       # imm = 0xFFFFFD8D
movl %ebx, %edi
callq 0x6c1f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/atsidaev[P]trx2x/DiskImage.cpp
// Function: DecodePosition()
int DecodePosition(void)
{
  int i, j, c;

  /* recover upper 6 bits from table */
  i = GetByte();
  c = (int)d_code[i] << 6;
  j = d_len[i];
  /* read lower 6 bits verbatim */
  j -= 2;
  while (j--) i = (i << 1) + GetBit();
  return c | (i & 0x3f);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x6957
movl %eax, %ebx
movl %eax, %eax
leaq 0x3658(%rip), %rcx      # 0xa3d0
movzbl (%rax,%rcx), %ebp
leaq 0x374d(%rip), %rcx      # 0xa4d0
movzbl (%rax,%rcx), %r14d
addl $-0x2, %r14d
subl $0x1, %r14d
jb 0x6d9c
callq 0x68e6
leal (%rax,%rbx,2), %ebx
jmp 0x6d8c
shll $0x6, %ebp
andl $0x3f, %ebx
orl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/atsidaev[P]trx2x/./utils.h
// Function: filelength(int)
inline long filelength(int fp) {
   long pos = lseek (fp, 0L, SEEK_CUR);
   long sz = lseek (fp, 0L, SEEK_END);
   lseek (fp, pos, SEEK_SET);
   return sz;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x11f0
movq %rax, %r14
pushq $0x2
popq %rdx
movl %ebx, %edi
xorl %esi, %esi
callq 0x11f0
movq %rax, %r15
movl %ebx, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x11f0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/soybin[P]idyll/src/main.cpp
// Function: renderRange(int, int, int, int, int, int, int, renderer*, std::vector<std::vector<math::vec3, std::allocator<math::vec3>>, std::allocator<std::vector<math::vec3, std::allocator<math::vec3>>>>*)
void renderRange(int startRow, int endRow, int startCol, int endCol, int width, int height, int chunk, renderer* r, std::vector<std::vector<math::vec3>>* image) {
	for (int y = startRow, x = startCol; y < height && (y < endRow || chunk > 0); ++y) {
		for (; x < width && (x < endCol || chunk > 0); ++x) {
			(*image)[y][x] = r->render((double)height - ((double)y + 0.5), (double)x + 0.5);
			--chunk;
		}
		x = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl 0x10(%rbp), %r12d
cvtsi2sd %r9d, %xmm0
movsd %xmm0, -0x30(%rbp)
movslq %r8d, %rax
movq %rax, -0x60(%rbp)
movslq %ecx, %rax
movq %rax, -0x50(%rbp)
movslq %edi, %rdi
movslq %r9d, %rax
movq %rax, -0x40(%rbp)
movslq %esi, %rax
movq %rax, -0x38(%rbp)
movslq %edx, %rbx
leaq -0x78(%rbp), %r14
cmpq -0x40(%rbp), %rdi
jge 0x3800
cmpq -0x38(%rbp), %rdi
setl %al
testl %r12d, %r12d
setg %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x3800
cvtsi2sd %edi, %xmm0
addsd 0x8889(%rip), %xmm0     # 0xc008
movsd -0x30(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x58(%rbp)
imulq $0x18, %rbx, %r15
movq %rdi, -0x48(%rbp)
imulq $0x18, %rdi, %r13
cmpq -0x60(%rbp), %rbx
jge 0x37f2
cmpq -0x50(%rbp), %rbx
setl %al
testl %r12d, %r12d
setg %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x37f2
cvtsi2sd %ebx, %xmm1
addsd 0x8849(%rip), %xmm1     # 0xc008
movq %r14, %rdi
movq 0x18(%rbp), %rsi
movsd -0x58(%rbp), %xmm0
callq 0x724c
movq 0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax,%r13), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x5d8a
decl %r12d
incq %rbx
addq $0x18, %r15
jmp 0x3799
movq -0x48(%rbp), %rdi
incq %rdi
xorl %ebx, %ebx
jmp 0x3751
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/soybin[P]idyll/src/gui.cpp
// Function: gui::update(int*, int)
void update(int* curV, int tarV) {
		double lockedValue = *curV;

		do {
			lockedValue = *curV;
			// width of logo is 34 characters. two of which
			// will be used for the extremes of the bar.
			// terminal colors are represented with expressions
			// like "\033[x;xx"
			std::cout << "\r\033[1;36m[";
			int quantity = 1 + 32 * lockedValue / tarV;
			for (int i = 0; i < 32; ++i) {
				std::cout << (i < quantity ? "\033[1;36m=" : "\033[0m-");
			}
			std::cout << "\033[1;36m]";
			std::cout.flush();
			std::this_thread::sleep_for(std::chrono::milliseconds(5));
		} while (lockedValue < tarV);
		std::cout << "\033[0;36m\n";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x40(%rbp)
cvtsi2sd %esi, %xmm0
movq 0xc4b1(%rip), %r14      # 0x11fb0
leaq 0x6d02(%rip), %r15      # 0xc808
leaq 0x6d04(%rip), %r12      # 0xc811
movsd %xmm0, -0x30(%rbp)
movq -0x40(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
movsd %xmm1, -0x38(%rbp)
movq %r14, %rdi
leaq 0x6cd5(%rip), %rsi      # 0xc7fe
callq 0x3290
movsd -0x38(%rbp), %xmm0
mulsd 0x6b35(%rip), %xmm0     # 0xc670
divsd -0x30(%rbp), %xmm0
addsd 0x6b30(%rip), %xmm0     # 0xc678
cvttsd2si %xmm0, %r13d
xorl %ebx, %ebx
cmpl $0x20, %ebx
je 0x5b6a
cmpl %r13d, %ebx
movq %r12, %rsi
cmovlq %r15, %rsi
movq %r14, %rdi
callq 0x3290
incl %ebx
jmp 0x5b4f
movq %r14, %rdi
leaq 0x6ca3(%rip), %rsi      # 0xc817
callq 0x3290
movq %r14, %rdi
callq 0x31b0
movq $0x5, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5bc4
movsd -0x30(%rbp), %xmm0
ucomisd -0x38(%rbp), %xmm0
ja 0x5b12
movq 0xc407(%rip), %rdi      # 0x11fb0
leaq 0x6c70(%rip), %rsi      # 0xc820
callq 0x3290
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/soybin[P]idyll/src/renderer.cpp
// Function: renderer::calculateRayDirection(double, double)
math::vec3 renderer::calculateRayDirection(double xcoord, double ycoord) {
	//
	// find direction vector
	//
	double x = xcoord - WIDTH / 2.0;
	double y = ycoord - HEIGHT / 2.0;
	double z = HEIGHT / std::tan(FOV * PI / 180.0 / 2.0);
	math::vec3 a = math::vec3(x, y, -z);
	//
	// apply rotations
	//
	a = math::vec3(
		RMx[0].x * a.x + RMx[1].x * a.y + RMx[2].x * a.z,
		RMx[0].y * a.x + RMx[1].y * a.y + RMx[2].y * a.z,
		RMx[0].z * a.x + RMx[1].z * a.y + RMx[2].z * a.z
	);
	a = math::vec3(
		RMy[0].x * a.x + RMy[1].x * a.y + RMy[2].x * a.z,
		RMy[0].y * a.x + RMy[1].y * a.y + RMy[2].y * a.z,
		RMy[0].z * a.x + RMy[1].z * a.y + RMy[2].z * a.z);

	return math::normalize(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r15
cvtsi2sdl (%rsi), %xmm2
movq %rdi, %rbx
movsd 0x599d(%rip), %xmm3     # 0xc008
mulsd %xmm3, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl 0x4(%rsi), %xmm2
movapd %xmm2, -0x40(%rbp)
mulsd %xmm3, %xmm2
cvtsi2sdl 0x8(%rsi), %xmm0
mulsd 0x622d(%rip), %xmm0     # 0xc8c0
subsd %xmm2, %xmm1
movsd %xmm1, -0x28(%rbp)
divsd 0x6224(%rip), %xmm0     # 0xc8c8
mulsd %xmm3, %xmm0
callq 0x3170
movapd -0x40(%rbp), %xmm2
xorpd 0x61d6(%rip), %xmm2     # 0xc890
divsd %xmm0, %xmm2
leaq -0x70(%rbp), %r14
movq %r14, %rdi
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x5c46
movq 0x90(%r15), %rax
movsd (%r14), %xmm3
movsd 0x8(%r14), %xmm4
movsd 0x18(%rax), %xmm0
mulsd %xmm4, %xmm0
movsd (%rax), %xmm1
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%r14), %xmm2
movsd 0x30(%rax), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x20(%rax), %xmm1
mulsd %xmm4, %xmm1
movsd 0x8(%rax), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm1, %xmm5
movsd 0x38(%rax), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm5, %xmm1
mulsd 0x28(%rax), %xmm4
mulsd 0x10(%rax), %xmm3
addsd %xmm4, %xmm3
mulsd 0x40(%rax), %xmm2
addsd %xmm3, %xmm2
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x5c46
movq %r14, %rdi
movq %r12, %rsi
callq 0x5d8a
movq 0xa8(%r15), %rax
movsd (%r14), %xmm3
movsd 0x8(%r14), %xmm4
movsd 0x18(%rax), %xmm0
mulsd %xmm4, %xmm0
movsd (%rax), %xmm1
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%r14), %xmm2
movsd 0x30(%rax), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x20(%rax), %xmm1
mulsd %xmm4, %xmm1
movsd 0x8(%rax), %xmm5
mulsd %xmm3, %xmm5
addsd %xmm1, %xmm5
movsd 0x38(%rax), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm5, %xmm1
mulsd 0x28(%rax), %xmm4
mulsd 0x10(%rax), %xmm3
addsd %xmm4, %xmm3
mulsd 0x40(%rax), %xmm2
addsd %xmm3, %xmm2
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x5c46
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d8a
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x5fdf
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/soybin[P]idyll/src/renderer.cpp
// Function: renderer::march(math::ray)
double renderer::march(math::ray r) {
	double t = MIN_DIST;
	for (; t < MAX_DIST; ) {
		double h = f->de(r.origin + r.direction * t);
		if (h < MIN_DIST) {
			break;
		}
		t += h;
	}
	if (t < MAX_DIST) return t;
	return -1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movsd 0x594e(%rip), %xmm0     # 0xc8e8
leaq 0x28(%rbp), %r15
leaq -0x60(%rbp), %r12
leaq -0x48(%rbp), %r13
movapd %xmm0, %xmm1
movsd 0x592e(%rip), %xmm0     # 0xc8e0
ucomisd %xmm1, %xmm0
jbe 0x7016
movq 0xc0(%rbx), %r14
movq %r12, %rdi
movq %r15, %rsi
movapd %xmm1, %xmm0
movsd %xmm1, -0x30(%rbp)
callq 0x5cf6
movq %r13, %rdi
leaq 0x10(%rbp), %rsi
movq %r12, %rdx
callq 0x5c5a
movq -0x38(%rbp), %rax
movq %rax, 0x10(%rsp)
movupd -0x48(%rbp), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x82e0
movsd 0x58e3(%rip), %xmm1     # 0xc8e8
ucomisd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm1
addsd %xmm1, %xmm0
jbe 0x6fa6
jmp 0x701e
movsd 0x5852(%rip), %xmm1     # 0xc870
movapd %xmm1, %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/soybin[P]idyll/src/renderer.cpp
// Function: renderer::brdf(math::vec3, math::vec3)
math::vec3 renderer::brdf(math::vec3 direction, math::vec3 normal) {
	if (s->d(0.0, 1.0) > GLOSSINESS_CHANCE) {
		//
		// diffuse reflection without tangent thanks to Edd 
		// Biddulph:
		// http://www.amietia.com/lambertnotangent.html
		//
		double a = s->d(0.0, 1.0);
		double b = s->d(0.0, 1.0);
		// not an arbitrary number, it's pi * 2
		double theta = 6.283185 * a;
		b = 2.0 * b - 1.0;
		double bsqrt = std::sqrt(1.0 - b * b);
		math::vec3 point(bsqrt * cos(theta), bsqrt * sin(theta), b);
		return math::normalize(normal + point);
	} else {
		//
		// glossy reflection
		//
		math::vec3 reflection = math::reflect(direction, normal);
		double a = PI;
		double b = 2 * PI;
		math::vec3 uniformVector(std::sin(b) * std::sin(a), std::cos(b) * std::sin(a), std::cos(a));
		return math::normalize(reflection + uniformVector) * GLOSSINESS_AMOUNT;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rbp), %r14
movq 0xc8(%rsi), %rdi
movsd 0x5619(%rip), %xmm1     # 0xc678
xorpd %xmm0, %xmm0
callq 0x966e
ucomisd 0x20(%r15), %xmm0
jbe 0x70f7
movq 0xc8(%r15), %rdi
xorpd %xmm0, %xmm0
movsd 0x55f1(%rip), %xmm1     # 0xc678
callq 0x966e
movsd %xmm0, -0x30(%rbp)
movq 0xc8(%r15), %rdi
xorpd %xmm0, %xmm0
movsd 0x55d4(%rip), %xmm1     # 0xc678
callq 0x966e
movsd -0x30(%rbp), %xmm1
mulsd 0x584a(%rip), %xmm1     # 0xc900
movsd %xmm1, -0x30(%rbp)
addsd %xmm0, %xmm0
addsd 0x57a9(%rip), %xmm0     # 0xc870
movsd %xmm0, -0x48(%rbp)
mulsd %xmm0, %xmm0
movsd 0x55a0(%rip), %xmm1     # 0xc678
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
ucomisd 0x5820(%rip), %xmm1     # 0xc908
jb 0x7196
sqrtsd %xmm0, %xmm0
jmp 0x719b
leaq 0x10(%rbp), %rax
movq 0x10(%r14), %rcx
movq %rcx, 0x28(%rsp)
movups (%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x6168
leaq -0xa8(%rbp), %r12
movsd 0x57b8(%rip), %xmm0     # 0xc8f0
movsd 0x57b8(%rip), %xmm1     # 0xc8f8
movsd 0x5728(%rip), %xmm2     # 0xc870
movq %r12, %rdi
callq 0x5c46
leaq -0x78(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5c5a
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
leaq -0x90(%rbp), %r14
movq %r14, %rdi
callq 0x5fdf
movsd 0x28(%r15), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5cf6
jmp 0x720d
callq 0x3210
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x34a0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x3090
movsd -0x38(%rbp), %xmm1
mulsd %xmm0, %xmm1
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movsd -0x40(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
callq 0x5c46
leaq -0xc0(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5c5a
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x5fdf
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/soybin[P]idyll/src/fractal.cpp
// Function: fractal::calculateShadow(math::ray)
double fractal::calculateShadow(math::ray r) {
	double res = 1.0;
	double ph = 1e20;
	double tmax = 16.0;
	double t = 0.0001;

	//
	// kinda like raymarching the shadow with some fancy modifiers
	// to make it soft and round
	//
	for(; t < tmax; ) {
		double h = de(r.origin + r.direction * t);
		if (h < 0.001) {
			return 0.0;
		}
		double y = h * h / (2.0 * ph);
		double d = std::sqrt(h * h - y * y);
		res = std::min(res, shadowSoftness * d / std::max(0.0, t - y));
		ph = h;
		t += h;
	}

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
movsd 0x46d2(%rip), %xmm3     # 0xca28
movsd 0x46d2(%rip), %xmm2     # 0xca30
movsd 0x4312(%rip), %xmm0     # 0xc678
leaq 0x28(%rbp), %r15
leaq -0x78(%rbp), %r12
leaq -0x60(%rbp), %r13
movsd 0x46be(%rip), %xmm1     # 0xca38
ucomisd %xmm2, %xmm1
jbe 0x845b
movsd %xmm3, -0x30(%rbp)
movsd %xmm0, -0x48(%rbp)
movq %r12, %rdi
movq %r15, %rsi
movsd %xmm2, -0x38(%rbp)
movapd %xmm2, %xmm0
callq 0x5cf6
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5c5a
movq -0x50(%rbp), %rax
movq %rax, 0x10(%rsp)
movupd -0x60(%rbp), %xmm0
movupd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x82e0
movapd %xmm0, %xmm3
movsd 0x4669(%rip), %xmm0     # 0xca40
ucomisd %xmm3, %xmm0
ja 0x8457
movapd %xmm3, %xmm0
mulsd %xmm3, %xmm0
movsd -0x30(%rbp), %xmm1
addsd %xmm1, %xmm1
movapd %xmm0, %xmm4
divsd %xmm1, %xmm4
movapd %xmm4, %xmm1
mulsd %xmm4, %xmm1
subsd %xmm1, %xmm0
ucomisd 0x44fe(%rip), %xmm0     # 0xc908
jb 0x8412
sqrtsd %xmm0, %xmm0
jmp 0x842b
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x40(%rbp)
callq 0x3210
movsd -0x40(%rbp), %xmm4
movsd -0x30(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
mulsd 0x48(%rbx), %xmm0
movapd %xmm2, %xmm1
subsd %xmm4, %xmm1
maxsd 0x44c3(%rip), %xmm1     # 0xc908
divsd %xmm1, %xmm0
minsd -0x48(%rbp), %xmm0
addsd %xmm3, %xmm2
jmp 0x8372
xorpd %xmm0, %xmm0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/soybin[P]idyll/src/fractal.cpp
// Function: PI0::iterate(math::vec3&)
inline void iterate(math::vec3& point) {
		point = math::absolute(point);
		math::rotation::x(point, xrs, xrc);
		math::rotation::z(point, zrs, zrc);
		math::fold::menger(point);
		math::rotation::z(point, zrs, zrc);
		math::rotation::x(point, xrs, xrc);
		math::fold::sierpinski(point);
		point.x += xs;
		point.z += zs;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
movups (%rsi), %xmm0
movups %xmm0, (%rsp)
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x6035
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5d8a
movsd 0x18(%r14), %xmm0
movsd 0x20(%r14), %xmm1
movq %rbx, %rdi
callq 0x62b5
movsd 0x28(%r14), %xmm0
movsd 0x30(%r14), %xmm1
movq %rbx, %rdi
callq 0x6317
movq %rbx, %rdi
callq 0x624b
movsd 0x28(%r14), %xmm0
movsd 0x30(%r14), %xmm1
movq %rbx, %rdi
callq 0x6317
movsd 0x18(%r14), %xmm0
movsd 0x20(%r14), %xmm1
movq %rbx, %rdi
callq 0x62b5
movq %rbx, %rdi
callq 0x61e1
movsd 0x8(%r14), %xmm0
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movsd 0x10(%r14), %xmm0
addsd 0x10(%rbx), %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/soybin[P]idyll/src/lib/TinyPngOut.cpp
// Function: TinyPngOut::crc32(unsigned char const*, unsigned long)
void TinyPngOut::crc32(const uint8_t data[], size_t len) {
	crc = ~crc;
	for (size_t i = 0; i < len; i++) {
		for (int j = 0; j < 8; j++) {  // Inefficient bitwise implementation, instead of table-based
			uint32_t bit = (crc ^ (data[i] >> j)) & 1;
			crc = (crc >> 1) ^ ((-bit) & UINT32_C(0xEDB88320));
		}
	}
	crc = ~crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x28(%rdi), %eax
notl %eax
movl %eax, 0x28(%rdi)
xorl %r8d, %r8d
movl %eax, %r9d
cmpq %rdx, %r8
je 0xb969
xorl %ecx, %ecx
cmpl $0x8, %ecx
je 0xb964
movzbl (%rsi,%r8), %eax
shrl %cl, %eax
xorl %r9d, %eax
andl $0x1, %eax
negl %eax
shrl %r9d
andl $0xedb88320, %eax       # imm = 0xEDB88320
xorl %r9d, %eax
movl %eax, 0x28(%rdi)
incl %ecx
movl %eax, %r9d
jmp 0xb93b
incq %r8
jmp 0xb934
notl %eax
movl %eax, 0x28(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/soybin[P]idyll/src/lib/TinyPngOut.cpp
// Function: TinyPngOut::adler32(unsigned char const*, unsigned long)
void TinyPngOut::adler32(const uint8_t data[], size_t len) {
	uint32_t s1 = adler & 0xFFFF;
	uint32_t s2 = adler >> 16;
	for (size_t i = 0; i < len; i++) {
		s1 = (s1 + data[i]) % 65521;
		s2 = (s2 + s1) % 65521;
	}
	adler = s2 << 16 | s1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rcx
movl 0x2c(%rdi), %r9d
movzwl %r9w, %r8d
shrl $0x10, %r9d
xorl %r10d, %r10d
movl $0xfff1, %r11d          # imm = 0xFFF1
cmpq %r10, %rcx
je 0xbc9d
movzbl (%rsi,%r10), %eax
addl %eax, %r8d
movl %r8d, %eax
xorl %edx, %edx
divl %r11d
movl %edx, %r8d
addl %edx, %r9d
movl %r9d, %eax
xorl %edx, %edx
divl %r11d
incq %r10
movl %edx, %r9d
jmp 0xbc72
shll $0x10, %r9d
orl %r8d, %r9d
movl %r9d, 0x2c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./src/testmain.cpp
// Function: main
int main(int argc, char* argv[])
{
	MyConf conf(argv[1]);
//	conf.show();
	ThreadPool apool(conf) ;
	MySocket socket(conf);
	apool.on();
	std::string word ;
	const int len = 1024 ;
	char buf[len];
	int iret ;
	while(true){
	memset(buf, 0, len);
	iret = socket.recv_message(buf, len) ;
	std::cout << "main" << buf <<"len: "<< iret << std::endl ;
	MyTask task(buf,socket.get_addr(), conf);
	apool.allocate_task(task);
	}
	apool.off();
	return 0 ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8b8, %rsp            # imm = 0x8B8
movq 0x8(%rsi), %rsi
leaq -0x8e0(%rbp), %rdi
leaq -0x258(%rbp), %rdx
callq 0x3110
leaq -0x4d8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x3872
leaq -0x8e0(%rbp), %rdi
callq 0x3140
leaq -0x258(%rbp), %rdi
leaq -0x4d8(%rbp), %rsi
pushq $0xc
popq %rdx
callq 0x3d2c
leaq -0x60(%rbp), %rdi
leaq -0x4d8(%rbp), %rsi
callq 0x3e20
leaq -0x258(%rbp), %rdi
callq 0x4076
leaq -0x90(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x8e0(%rbp), %rbx
leaq -0x80(%rbp), %r14
leaq -0x108(%rbp), %r12
leaq -0x258(%rbp), %r13
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
xorl %esi, %esi
callq 0x31a0
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x40c4
movl %eax, %r15d
movq 0xa862(%rip), %rdi      # 0xdfd0
leaq 0x588f(%rip), %rsi      # 0x9004
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
movq %rax, %rdi
leaq 0x587a(%rip), %rsi      # 0x9009
callq 0x3270
movq %rax, %rdi
movl %r15d, %esi
callq 0x3470
movq %rax, %rdi
callq 0x3160
movq %r14, %rdi
movq %rbx, %rsi
leaq -0x29(%rbp), %rdx
callq 0x3110
movups -0x5c(%rbp), %xmm0
movups %xmm0, -0x40(%rbp)
movq %r12, %rdi
movq %r14, %rsi
leaq -0x40(%rbp), %rdx
leaq -0x4d8(%rbp), %rcx
callq 0x4116
movq %r14, %rdi
callq 0x3140
movq %r13, %rdi
movq %r12, %rsi
callq 0x4166
movq %r12, %rdi
callq 0x41ca
jmp 0x3744
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x41ca
jmp 0x3818
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3140
jmp 0x3818
jmp 0x3815
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x3140
jmp 0x3829
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x41fa
jmp 0x3837
movq %rax, %rbx
leaq -0x258(%rbp), %rdi
callq 0x4210
jmp 0x3848
movq %rax, %rbx
leaq -0x4d8(%rbp), %rdi
callq 0x4256
jmp 0x386a
movq %rax, %rbx
leaq -0x8e0(%rbp), %rdi
callq 0x3140
jmp 0x386a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::ThreadPool(MyConf&, int)
ThreadPool(MyConf &conf, int size = 12)
            :vecThreads_(size),
             queueTaskslock_(), 
             queueTasksCond_(queueTaskslock_),
             isStarted_(false),
             conf_(conf),
             cacheThread_(size)
        {
            std::vector<MyThread>::iterator iter ;
            for(iter = vecThreads_.begin(); 
                iter != vecThreads_.end(); 
                ++iter)
            {
                iter -> get_related(this);       // 使线程池中的每一个工作线程持有线程池对象的指针
            }
                cacheThread_.get_related(this);      // 使线程池中的扫描线程持有线程池对象的指针
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movl %edx, -0x3c(%rbp)
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
movslq %edx, %rsi
leaq -0x29(%rbp), %rdx
movq %rbx, %rdi
callq 0x5368
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x53ba
leaq 0x70(%r15), %r12
movq %r12, %rdi
callq 0x53da
leaq 0x98(%r15), %rdi
movq %r12, %rsi
callq 0x5484
movb $0x0, 0xd0(%r15)
leaq 0xd8(%r15), %r13
leaq -0x3c(%rbp), %rsi
movq %r13, %rdi
callq 0x5536
movq 0x8(%r15), %rax
cmpq 0x10(%r15), %rax
je 0x3db1
movq %r15, 0x58(%rax)
addq $0xc0, %rax
jmp 0x3d9f
movq %r13, %rdi
movq %r15, %rsi
callq 0x7ffc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x38(%rbp)
movq %r13, %rdi
callq 0x5586
jmp 0x3ddd
movq %rax, -0x38(%rbp)
addq $0xa0, %r15
movq %r15, %rdi
callq 0x34b0
jmp 0x3df2
movq %rax, -0x38(%rbp)
movq %r12, %rdi
callq 0x32e0
jmp 0x3e00
movq %rax, -0x38(%rbp)
movq %r14, %rdi
callq 0x5d74
jmp 0x3e0e
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
callq 0x55b4
movq -0x38(%rbp), %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::on()
void on()
        {
            if(isStarted_)
            {
                return ;
            }
            isStarted_ = true ;
            std::vector<MyThread>::iterator iter ;
            for(iter = vecThreads_.begin(); iter != vecThreads_.end(); iter ++)
            {
                iter -> start();    // 开启工作线程
            }
            cacheThread_.start();   // 开启扫描线程
        }

// Assembly:
cmpb $0x0, 0xd0(%rdi)
je 0x4080
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0xd0(%rdi)
movq 0x8(%rdi), %r14
cmpq 0x10(%rbx), %r14
je 0x40ae
movq %r14, %rdi
xorl %esi, %esi
callq 0x5ef4
addq $0xc0, %r14
jmp 0x4095
addq $0xd8, %rbx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x5ef4
nop
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::allocate_task(MyTask&)
void allocate_task( MyTask& task)
        {
            queueTaskslock_.lock();
            std::cout << "Add Task" << std::endl ;
            queueTasks_.push(task);
            queueTaskslock_.unlock();
            queueTasksCond_.broadcast();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x70(%rdi), %r15
movq %r15, %rdi
callq 0x33b0
movq 0x9e47(%rip), %rdi      # 0xdfd0
leaq 0x4ff7(%rip), %rsi      # 0x9187
callq 0x3270
movq %rax, %rdi
callq 0x3160
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x605e
movq %r15, %rdi
callq 0x3210
addq $0xa0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./include/MyConf.h
// Function: MyConf::setIndex(int)
void setIndex(int vecDictIndex)
        {
            std::string word, letter; // 单词，以及单词中的每一个字母（汉字）
            word = vecDict_[vecDictIndex].first ; // 根据词典的下标来找每一个单词（词典的下标正是我们传给setIndex的参数）
            // 遍历单词的每一个字母，制作索引
            for(int index = 0; 
                index != word.size(); 
                ++index)
            {
                // 中文
                if(word[index] & (1 << 7))
                {
                    letter = word.substr(index, 2);
                    index ++ ;
                }else 
                {
                    letter = word.substr(index, 1) ;
                }
                mapIndex_[letter].insert(vecDictIndex); //将包含这个字母的单词 所在vector的下标放入set中
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movl %esi, -0x2c(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %r15d, %r15d
movb %r15b, (%rax)
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %r15b, (%rax)
movslq %esi, %rax
imulq $0x28, %rax, %rsi
addq 0x238(%rdi), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3190
addq $0x250, %rbx            # imm = 0x250
leaq -0x90(%rbp), %r14
leaq -0x70(%rbp), %r13
leaq -0x2c(%rbp), %r12
movslq %r15d, %rdx
cmpq %rdx, -0x48(%rbp)
je 0x43fa
movq -0x50(%rbp), %rax
cmpb $0x0, (%rax,%rdx)
js 0x43ba
movq %r14, %rdi
leaq -0x50(%rbp), %rsi
pushq $0x1
popq %rcx
callq 0x32a0
movq %r13, %rdi
movq %r14, %rsi
callq 0x3320
movq %r14, %rdi
callq 0x3140
jmp 0x43df
movq %r14, %rdi
leaq -0x50(%rbp), %rsi
pushq $0x2
popq %rcx
callq 0x32a0
movq %r13, %rdi
movq %r14, %rsi
callq 0x3320
movq %r14, %rdi
callq 0x3140
incl %r15d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4be8
movq %rax, %rdi
movq %r12, %rsi
callq 0x50ee
incl %r15d
jmp 0x4383
leaq -0x70(%rbp), %rdi
callq 0x3140
leaq -0x50(%rbp), %rdi
callq 0x3140
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4421
jmp 0x4421
jmp 0x4421
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x3140
leaq -0x50(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./include/MyLock.h
// Function: MyLock::MyLock()
MyLock()
        {
            // 初始化成功返回0
            if( pthread_mutex_init(&m_mutex, NULL) )
            {
                std::cout << __DATE__  << " " << __TIME__ << " " 
                          << __FILE__  << " " << __LINE__ << ":"
                          << "pthread_mutex_init failed!" << std::endl;
                exit (-1); 
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %esi, %esi
callq 0x33d0
testl %eax, %eax
jne 0x53f2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x8bd7(%rip), %rdi      # 0xdfd0
leaq 0x3c0f(%rip), %rsi      # 0x900f
callq 0x3270
leaq 0x3e13(%rip), %rbx      # 0x921f
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
leaq 0x3bfd(%rip), %rsi      # 0x901b
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
leaq 0x3c84(%rip), %rsi      # 0x90bc
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
pushq $0xe
popq %rsi
movq %rax, %rdi
callq 0x3470
leaq 0x3de0(%rip), %rsi      # 0x923d
movq %rax, %rdi
callq 0x3270
leaq 0x3c63(%rip), %rsi      # 0x90cf
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
callq 0x3160
pushq $-0x1
popq %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./include/MyCondition.h
// Function: MyCondition::MyCondition(MyLock&)
MyCondition(MyLock& lock)
            : m_mutex(lock.m_mutex)
        {
            if( pthread_cond_init(&m_cond, NULL))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ": " 
                          << "pthread_cond_init failed!" << std::endl;
                exit (-1);
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, (%rdi)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x32f0
testl %eax, %eax
jne 0x54a3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x8b26(%rip), %rdi      # 0xdfd0
leaq 0x3b5e(%rip), %rsi      # 0x900f
callq 0x3270
leaq 0x3d62(%rip), %rbx      # 0x921f
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
leaq 0x3b4c(%rip), %rsi      # 0x901b
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
leaq 0x3c01(%rip), %rsi      # 0x90ea
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
pushq $0xe
popq %rsi
movq %rax, %rdi
callq 0x3470
leaq 0x3d10(%rip), %rsi      # 0x921e
movq %rax, %rdi
callq 0x3270
leaq 0x3be5(%rip), %rsi      # 0x9102
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
callq 0x3160
pushq $-0x1
popq %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./include/Thread.h
// Function: Thread::Thread()
Thread()
            :threadId_(0),isRunning_(false)
        {
            if(pthread_attr_init(&threadAttr))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ":" 
                          << "pthread_attr_init" << std::endl;
                exit(-1) ;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x859f(%rip), %rax      # 0xdd30
movq %rax, (%rdi)
movb $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
addq $0x20, %rdi
callq 0x3310
testl %eax, %eax
jne 0x57b1
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x8818(%rip), %rdi      # 0xdfd0
leaq 0x3850(%rip), %rsi      # 0x900f
callq 0x3270
leaq 0x3a54(%rip), %rbx      # 0x921f
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
leaq 0x383e(%rip), %rsi      # 0x901b
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
leaq 0x38a0(%rip), %rsi      # 0x9097
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
pushq $0xf
popq %rsi
movq %rax, %rdi
callq 0x3470
leaq 0x3a21(%rip), %rsi      # 0x923d
movq %rax, %rdi
callq 0x3270
leaq 0x387f(%rip), %rsi      # 0x90aa
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
callq 0x3160
pushq $-0x1
popq %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./include/Thread.h
// Function: Thread::start(void*)
void start(void* arg = NULL)
        {
            if(isRunning_)
                return;
			
            m_arg = arg ;
            isRunning_ = true ;
            
            // 将线程设置为detach
            if(pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ":" 
                          << "pthread_attr_setdetachstate" << std::endl ;
                exit(-1) ;
            }
            
            // 创建线程
            if(pthread_create(&threadId_, &threadAttr, Thread::runInThread, this))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ":" 
                          << "pthread_create" << std::endl;
                exit(-1) ;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpb $0x0, 0x10(%rdi)
jne 0x5f3d
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movb $0x1, 0x10(%rdi)
leaq 0x20(%rdi), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3360
testl %eax, %eax
jne 0x5f42
leaq 0x18(%rbx), %rdi
leaq 0x126(%rip), %rdx       # 0x6050
movq %r14, %rsi
movq %rbx, %rcx
callq 0x3490
testl %eax, %eax
jne 0x5fbe
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8087(%rip), %rdi      # 0xdfd0
leaq 0x30bf(%rip), %rsi      # 0x900f
callq 0x3270
leaq 0x32c3(%rip), %rbx      # 0x921f
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
leaq 0x30ad(%rip), %rsi      # 0x901b
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
leaq 0x310f(%rip), %rsi      # 0x9097
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
pushq $0x26
popq %rsi
movq %rax, %rdi
callq 0x3470
leaq 0x3290(%rip), %rsi      # 0x923d
movq %rax, %rdi
callq 0x3270
leaq 0x318f(%rip), %rsi      # 0x914b
jmp 0x6038
movq 0x800b(%rip), %rdi      # 0xdfd0
leaq 0x3043(%rip), %rsi      # 0x900f
callq 0x3270
leaq 0x3247(%rip), %rbx      # 0x921f
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
leaq 0x3031(%rip), %rsi      # 0x901b
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
leaq 0x3093(%rip), %rsi      # 0x9097
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3270
pushq $0x2f
popq %rsi
movq %rax, %rdi
callq 0x3470
leaq 0x3214(%rip), %rsi      # 0x923d
movq %rax, %rdi
callq 0x3270
leaq 0x312f(%rip), %rsi      # 0x9167
movq %rax, %rdi
callq 0x3270
movq %rax, %rdi
callq 0x3160
pushq $-0x1
popq %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./src/MyThread.cpp
// Function: MyThread::run()
void MyThread::run()
{
	std::cout << "run" << std::endl ;
	cache_.read_from_file( (threadPoolPtr_ -> conf_).getMapConf()["my_cache"].c_str());
	while(true)
	{
        MyTask task(threadPoolPtr_-> conf_) ;
        if(!(threadPoolPtr_ -> get_task(task)) )
        {
            break ;
        }
        task.excute(cache_) ;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq 0x7a9a(%rip), %rdi      # 0xdfd0
leaq 0x2c8c(%rip), %rsi      # 0x91c9
callq 0x3270
movq %rax, %rdi
callq 0x3160
movq 0x58(%rbx), %rax
movq (%rax), %r14
leaq 0x2c75(%rip), %rsi      # 0x91cd
leaq -0x40(%rbp), %rdi
leaq -0x1a(%rbp), %rdx
callq 0x3110
addq $0x208, %r14            # imm = 0x208
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x42b2
movq (%rax), %rsi
leaq -0xa8(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3110
leaq 0x60(%rbx), %r14
leaq -0xa8(%rbp), %rsi
movq %r14, %rdi
callq 0x6642
leaq -0xa8(%rbp), %r15
movq %r15, %rdi
callq 0x3140
leaq -0x40(%rbp), %rdi
callq 0x3140
movq 0x58(%rbx), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x67e6
movq 0x58(%rbx), %rdi
movq %r15, %rsi
callq 0x6838
testb %al, %al
je 0x65ea
movq %r15, %rdi
movq %r14, %rsi
callq 0x70c8
movq %r15, %rdi
callq 0x41ca
jmp 0x65b6
leaq -0xa8(%rbp), %rdi
callq 0x41ca
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x3140
jmp 0x661a
jmp 0x6617
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3140
jmp 0x6639
movq %rax, %rbx
jmp 0x6639
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x41ca
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./include/MyCache.h
// Function: MyCache::read_from_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void read_from_file(const std::string &fileName)
        {
            std::ifstream infile(fileName.c_str());
            if(!infile)
            {
                std::cout << "cache file: " << fileName << std::endl ; 
                throw std::runtime_error("open cache file fail !");
            }
            std::string query , result;
            while(infile >> query >> result)
            {
                hashmap_.insert(std::make_pair(query, result));
            }
            infile.close();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x2b0(%rbp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x34a0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x290(%rbp,%rax)
jne 0x673f
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0x2b0(%rbp), %r14
leaq -0x68(%rbp), %r15
leaq -0x48(%rbp), %r12
leaq -0xa8(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x3330
movq %rax, %rdi
movq %r12, %rsi
callq 0x3330
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6703
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x46e2
movq %rbx, %rdi
movq %r13, %rsi
callq 0x68f0
movq %r13, %rdi
callq 0x4292
jmp 0x66bc
leaq -0x2b0(%rbp), %rdi
callq 0x30a0
leaq -0x48(%rbp), %rdi
callq 0x3140
leaq -0x68(%rbp), %rdi
callq 0x3140
leaq -0x2b0(%rbp), %rdi
callq 0x30c0
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x788a(%rip), %rdi      # 0xdfd0
leaq 0x2a89(%rip), %rsi      # 0x91d6
callq 0x3270
movq %rax, %rdi
movq %r14, %rsi
callq 0x3250
movq %rax, %rdi
callq 0x3160
pushq $0x10
popq %rdi
callq 0x3170
movq %rax, %r14
leaq 0x2a6c(%rip), %rsi      # 0x91e3
movq %rax, %rdi
callq 0x3100
movq 0x786a(%rip), %rsi      # 0xdff0
movq 0x783b(%rip), %rdx      # 0xdfc8
movq %r14, %rdi
callq 0x3460
movq %rax, %rbx
movq %r14, %rdi
callq 0x31f0
jmp 0x67d1
movq %rax, %rbx
jmp 0x67d1
jmp 0x67bc
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x4292
jmp 0x67bf
jmp 0x67bc
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3140
leaq -0x68(%rbp), %rdi
callq 0x3140
leaq -0x2b0(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::get_task(MyTask&)
bool get_task(MyTask &task)
        {
            queueTaskslock_.lock();
            while(isStarted_ && queueTasks_.empty())
            {
                queueTasksCond_.wait();
            }
            if(!isStarted_)
            { 
                queueTaskslock_.unlock();
                queueTasksCond_.broadcast();
                return false ;
            }
            task = queueTasks_.front();
            queueTasks_.pop();
            queueTaskslock_.unlock();
            queueTasksCond_.broadcast();
            std::cout << "get task" << std::endl ;
            return true ;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
leaq 0x70(%rdi), %r15
movq %r15, %rdi
callq 0x33b0
leaq 0x98(%r14), %r13
movb 0xd0(%r14), %bl
cmpb $0x1, %bl
jne 0x687f
movq 0x30(%r14), %rsi
cmpq %rsi, 0x50(%r14)
jne 0x6898
movq %r13, %rdi
callq 0x6d62
jmp 0x685f
movq %r15, %rdi
callq 0x3210
addq $0xa0, %r14
movq %r14, %rdi
callq 0x30e0
jmp 0x68de
leaq 0x20(%r14), %r13
movq %r12, %rdi
callq 0x6d74
movq %r13, %rdi
callq 0x7048
movq %r15, %rdi
callq 0x3210
addq $0xa0, %r14
movq %r14, %rdi
callq 0x30e0
movq 0x7706(%rip), %rdi      # 0xdfd0
leaq 0x2929(%rip), %rsi      # 0x91fa
callq 0x3270
movq %rax, %rdi
callq 0x3160
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./src/MyTask.cpp
// Function: MyTask::get_result()
void MyTask::get_result()
{
	std::string ch ;
	int index ;
	for(index = 0 ; index != queryWord_.size(); index ++ )
	{
		if(queryWord_[index] & (1 << 7))
		{
			ch = queryWord_.substr(index, 2) ;
			index ++ ;
		}else 
		{
			ch = queryWord_.substr(index, 1);
		}
		if( ( *mapIndexPtr_ ).count(ch) )
		{
			std::cout << "map_ cout return true " << std::endl ;
			satistic( (*mapIndexPtr_)[ch] ) ;
		}
	} 

	/*
	   std::cout <<__FILE__<<std::endl ;
	//	for_each((*m_dict).begin(), (*m_dict).end(), satistic );
	std::map<std::string , int>::iterator iter = (*m_dict).begin() ;
	//int line = 0 ;
	while(iter != (*m_dict).end())
	{
	//std::cout << "dict word: " << iter -> first << std::endl ;
	//std::cout <<"_________" << ++line << "_________________"<< std::endl ;
	satistic(*iter);
	iter ++ ;
	}
	*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r13d, %r13d
leaq -0x68(%rbp), %r14
leaq -0x48(%rbp), %r12
leaq 0x1fb4(%rip), %r15      # 0x9280
movslq %r13d, %rdx
cmpq %rdx, 0x8(%rbx)
je 0x7370
movq (%rbx), %rax
cmpb $0x0, (%rax,%rdx)
js 0x7305
movq %r14, %rdi
movq %rbx, %rsi
pushq $0x1
popq %rcx
callq 0x32a0
movq %r12, %rdi
movq %r14, %rsi
callq 0x3320
movq %r14, %rdi
callq 0x3140
jmp 0x7329
movq %r14, %rdi
movq %rbx, %rsi
pushq $0x2
popq %rcx
callq 0x32a0
movq %r12, %rdi
movq %r14, %rsi
callq 0x3320
movq %r14, %rdi
callq 0x3140
incl %r13d
movq 0x40(%rbx), %rdi
movq %r12, %rsi
callq 0x783a
testq %rax, %rax
je 0x7368
movq 0x6c8f(%rip), %rdi      # 0xdfd0
movq %r15, %rsi
callq 0x3270
movq %rax, %rdi
callq 0x3160
movq 0x40(%rbx), %rdi
movq %r12, %rsi
callq 0x4be8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x76d0
incl %r13d
jmp 0x72cc
leaq -0x48(%rbp), %rdi
callq 0x3140
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x738c
jmp 0x738c
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O2/jianxinzhou[P]Smart/./src/MyTask.cpp
// Function: MyTask::satistic(std::set<int, std::less<int>, std::allocator<int>>&)
void MyTask::satistic(std::set<int> & iset)
{
	std::set<int>::iterator iter ;
	for( iter = iset.begin() ;  iter != iset.end() ;  iter ++)
	{
		int dist = editdistance(  ((*vecDictPtr_)[ *iter ]).first  );
			if(dist < 3)
			{
				MyResult res ;
				res.word_ = ((*vecDictPtr_)[ *iter ]).first ;
				res.distance_ = dist ;
				res.frequence_ = ((*vecDictPtr_)[ *iter ]).second ; 
				result_.push( res );
			}
	}
	/*
	   std::cout << __LINE__ <<std::endl ;
	   std::cout << "value::first :" << value.first << std::endl ;
	   int dist = editdistance( value.first);
	   if(dist < 3)
	   {
	   MyResult res ;
	   res.m_word = value.first ;
	   res.m_frequence = value.second ;
	   res.m_dist = dist ;
	   m_result.push( res );
	   }
	   */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
addq $0x8, %rbx
leaq 0x48(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq -0x58(%rbp), %r13
cmpq %rbx, %r15
je 0x7789
movq 0x38(%r14), %rax
movslq 0x20(%r15), %rcx
imulq $0x28, %rcx, %rsi
addq (%rax), %rsi
movq %r14, %rdi
callq 0x73a0
cmpl $0x2, %eax
jg 0x7779
movl %eax, %r12d
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
andq $0x0, -0x50(%rbp)
movb $0x0, -0x48(%rbp)
movq 0x38(%r14), %rax
movslq 0x20(%r15), %rcx
imulq $0x28, %rcx, %rsi
addq (%rax), %rsi
movq %r13, %rdi
callq 0x3190
movl %r12d, -0x34(%rbp)
movq 0x38(%r14), %rax
movslq 0x20(%r15), %rcx
movq (%rax), %rax
imulq $0x28, %rcx, %rcx
movl 0x20(%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x781a
movq %r13, %rdi
callq 0x3140
movq %r15, %rdi
callq 0x32d0
movq %rax, %r15
jmp 0x76fb
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3480