LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/bloom.c
// Function: bloom_dump
void
bloom_dump(BLOOM const *bp, FILE *fp)
{
    fprintf(fp, "{ hash_bits:%d npoints:%d point_bits:%d"
                    " hash_chunk:%d hash_mask:%d point_max:%d"
                    " ovfl_limit:%d ovfl_count:%d"
                "\n  pointv:( ",
                bp->hash_bits, bp->npoints, bp->point_bits,
                bp->hash_chunk, bp->hash_mask, bp->point_max,
                bp->ovfl_limit, bp->ovfl_count);
    int i, val;
    for (i = 0; i < bp->npoints; ++i)
        if ((val = point_val(bp, i)))
            fprintf(fp, "%s[%d]:%d ", !i || i%10 ? "" : "\n\t\t", i,
                    val + bp->ovfl[ovfl_find(bp,i)].count);

    fputs(")\n  ovfl:{", fp);
    for (i = 0; i <= bp->ovfl_limit; ++i)
        if (bp->ovfl[i].count)
            fprintf(fp, " %d:%d", bp->ovfl[i].point, bp->ovfl[i].count);

    fputs(" }\n}\n", fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edx
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %r8d
movl 0xc(%rdi), %r9d
movl 0x10(%rdi), %r10d
movl 0x14(%rdi), %r11d
movl 0x20(%rdi), %r15d
movl 0x24(%rdi), %r12d
leaq 0x23c3(%rip), %rsi      # 0x6100
movq %rbx, %rdi
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r11
pushq %r10
callq 0x3280
addq $0x20, %rsp
movl 0x4(%r14), %eax
testl %eax, %eax
jle 0x3e32
leaq 0x2420(%rip), %r13      # 0x6186
leaq 0x240b(%rip), %r15      # 0x6178
leaq 0x240f(%rip), %rbp      # 0x6183
xorl %r12d, %r12d
movq 0x18(%r14), %rcx
movzbl (%rcx,%r12), %r8d
testl %r8d, %r8d
je 0x3e23
testq %r12, %r12
je 0x3dd5
imull $0xcccccccd, %r12d, %eax # imm = 0xCCCCCCCD
rorl %eax
cmpl $0x1999999a, %eax       # imm = 0x1999999A
movq %r13, %rdx
cmovbq %rbp, %rdx
movq 0x28(%r14), %rax
movl 0x20(%r14), %esi
movl %esi, %ecx
andl %r12d, %ecx
cmpl $0x0, 0x4(%rax,%rcx,8)
je 0x3e07
leaq (%rax,%rcx,8), %rdi
movl (%rdi), %edi
cmpq %rdi, %r12
je 0x3e07
incl %ecx
andl %esi, %ecx
movslq %ecx, %rdi
leaq (%rax,%rdi,8), %rdi
cmpl $0x0, 0x4(%rdi)
jne 0x3dbb
jmp 0x3e07
movq 0x28(%r14), %rax
cmpl $0x0, 0x4(%rax)
je 0x3e02
movslq 0x20(%r14), %rdx
xorl %ecx, %ecx
movq %rax, %rsi
cmpl $0x0, (%rsi)
je 0x3e04
movslq %ecx, %rcx
incq %rcx
andq %rdx, %rcx
leaq (%rax,%rcx,8), %rsi
cmpl $0x0, 0x4(%rsi)
jne 0x3de8
jmp 0x3e04
xorl %ecx, %ecx
movq %r13, %rdx
movslq %ecx, %rcx
addl 0x4(%rax,%rcx,8), %r8d
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x3280
movl 0x4(%r14), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0x3d77
leaq 0x234e(%rip), %rdi      # 0x6187
movq %rbx, %rsi
callq 0x31e0
movl 0x20(%r14), %eax
testl %eax, %eax
js 0x3e85
movq $-0x1, %r12
leaq 0x233b(%rip), %r15      # 0x6192
movq 0x28(%r14), %rdx
movl 0xc(%rdx,%r12,8), %ecx
testl %ecx, %ecx
je 0x3e7a
movl 0x8(%rdx,%r12,8), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3280
movl 0x20(%r14), %eax
movslq %eax, %rcx
incq %r12
cmpq %rcx, %r12
jl 0x3e57
leaq 0x230d(%rip), %rdi      # 0x6199
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/TheZoq2[P]sweplusplus/sv.cpp
// Function: main
hel hufvud(hel arga, vidbränd dubbelpekare argv)
{
    bil i = 0;
    vidbränd dubbelpekare nuvarande = argv;

    medans (i < arga) {
        placeras(dereferera nuvarande);
        nuvarande++;
        i ökas_med_ett;
        om (i == 3) {
            uppfostra Barn("För många argument");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl %edi, %r14d
xorl %r15d, %r15d
testl %edi, %edi
cmovlel %r15d, %r14d
cmpl %r15d, %r14d
je 0x12b6
movq (%rbx,%r15,8), %rdi
callq 0x10a0
incq %r15
cmpl $0x3, %r15d
jne 0x123a
movl $0x20, %edi
callq 0x1030
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xd97(%rip), %rsi       # 0x2004
leaq 0xda4(%rip), %rdx       # 0x2018
leaq -0x40(%rbp), %rdi
callq 0x13b8
movq %rbx, %rax
addq $0x10, %rax
movq %rax, (%rbx)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
movb $0x1, %r12b
movq %rbx, %rdi
callq 0x131a
xorl %r12d, %r12d
leaq 0x2b09(%rip), %rsi      # 0x3db0
leaq 0x4a(%rip), %rdx        # 0x12f8
movq %rbx, %rdi
callq 0x10b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x12dd
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x1080
testb %r12b, %r12b
jne 0x12e7
jmp 0x12ef
movq %rax, %r14
movq %rbx, %rdi
callq 0x1050
movq %r14, %rdi
callq 0x10c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/IsseW[P]bytepusher/src/grid/grid.cpp
// Function: Grid::update_with_rule(void (*)(Grid&, unsigned int, unsigned int))
void Grid::update_with_rule(void (*rule)(Grid&, uint32_t x, uint32_t y)) {
  for (uint32_t y = 0; y < height; y++) {
    for (uint32_t x = 0; x < width; x++) {
      rule(*this, x, y);
    }
  }
  swap();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x2864
movq %rsi, %r14
movl (%rbx), %ecx
xorl %ebp, %ebp
testl %ecx, %ecx
movl $0x0, %ecx
je 0x285e
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq *%r14
incl %r15d
movl (%rbx), %ecx
cmpl %ecx, %r15d
jb 0x2846
movl 0x4(%rbx), %eax
incl %ebp
cmpl %eax, %ebp
jb 0x283a
movdqu 0x8(%rbx), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/IsseW[P]bytepusher/src/grid/grid.cpp
// Function: Grid::print()
void Grid::print() {
  for (uint32_t y = 0; y < height; y++) {
    for (uint32_t x = 0; x < width; x++) {
      std::cout << (get(x, y) == Tile::Alive ? '#' : '.');
    }
    std::cout << std::endl;
  }
}

// Assembly:
cmpl $0x0, 0x4(%rdi)
je 0x2945
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
movq 0x271a(%rip), %r14      # 0x4fd8
leaq 0xf(%rsp), %r15
movl (%rbx), %eax
testl %eax, %eax
je 0x290b
xorl %r12d, %r12d
movb $0x2e, %cl
cmpl %ebp, 0x4(%rbx)
jbe 0x28ed
movq 0x8(%rbx), %rcx
imull %ebp, %eax
addl %r12d, %eax
cmpb $-0x1, (%rcx,%rax)
movl $0x23, %ecx
je 0x28ed
movl $0x2e, %ecx
movb %cl, 0xf(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
incl %r12d
movl (%rbx), %eax
cmpl %eax, %r12d
jb 0x28cc
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
incl %ebp
cmpl 0x4(%rbx), %ebp
jb 0x28c3
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/IsseW[P]bytepusher/src/grid/grid.cpp
// Function: Grid::count_neighbors(unsigned int, unsigned int, Tile, unsigned int)
uint32_t Grid::count_neighbors(uint32_t x, uint32_t y, Tile to_count,
                               uint32_t extent) {

  uint32_t min_x = std::max<int32_t>(x - extent, 0);
  uint32_t max_x = std::min<int32_t>(x + extent, width - 1);
  uint32_t min_y = std::max<int32_t>(y - extent, 0);
  uint32_t max_y = std::min<int32_t>(y + extent, height - 1);

  uint32_t count = 0;
  for (uint32_t _y = min_y; _y <= max_y; _y++) {
    for (uint32_t _x = min_x; _x <= max_x; _x++) {
      if (_x == x && _y == y) {
        continue;
      }
      if (get(_x, _y) == to_count) {
        count++;
      }
    }
  }
  return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %r9d
subl %r8d, %r9d
xorl %eax, %eax
testl %r9d, %r9d
cmovlel %eax, %r9d
leal (%r8,%rsi), %r10d
movl (%rdi), %r11d
leal -0x1(%r11), %ebx
cmpl %r10d, %ebx
cmovll %ebx, %r10d
movl 0x4(%rdi), %ebx
movl %edx, %ebp
subl %r8d, %ebp
testl %ebp, %ebp
cmovlel %eax, %ebp
addl %edx, %r8d
leal -0x1(%rbx), %r14d
cmpl %r8d, %r14d
cmovll %r14d, %r8d
cmpl %r8d, %ebp
ja 0x2a1d
movq 0x8(%rdi), %rdi
movl %r11d, %r14d
imull %ebp, %r14d
xorl %eax, %eax
movl %r9d, %r15d
cmpl %r10d, %r9d
ja 0x2a13
movl %ebp, %r12d
xorl %edx, %r12d
movl %esi, %r13d
xorl %r15d, %r13d
orl %r12d, %r13d
je 0x2a0b
cmpl %ebp, %ebx
setbe %r12b
cmpl %r15d, %r11d
setbe %r13b
orb %r12b, %r13b
jne 0x29fb
leal (%r14,%r15), %r12d
movb (%rdi,%r12), %r12b
jmp 0x29fe
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpb %cl, %r12b
sete %r13b
addl %r13d, %eax
incl %r15d
cmpl %r10d, %r15d
jbe 0x29ce
incl %ebp
addl %r11d, %r14d
cmpl %r8d, %ebp
jbe 0x29c6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/IsseW[P]bytepusher/src/grid/rules.cpp
// Function: game_of_life_rule(Grid&, unsigned int, unsigned int)
void game_of_life_rule(Grid& grid, uint32_t x, uint32_t y) {
  Tile tile = grid.get(x, y);
  uint32_t count = grid.count_neighbors(x, y);
  if (tile == Tile::Alive) {
    if (count < 2 || count > 3) {
      tile = Tile::Dead;
    }
  } else if (tile == Tile::Dead && count == 3) {
    tile = Tile::Alive;
  }
  grid.set(x, y, tile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x2946
movl %eax, %r15d
movl $0xff, %r12d
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
movl $0xff, %ecx
movl $0x1, %r8d
callq 0x296e
cmpb $-0x1, %r15b
je 0x2a7e
cmpl $0x3, %eax
movzbl %r15b, %eax
cmovnel %eax, %r12d
testb %r15b, %r15b
cmovnel %eax, %r12d
jmp 0x2a8b
andl $-0x2, %eax
cmpl $0x2, %eax
sete %r12b
negb %r12b
movzbl %r12b, %ecx
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2960
// File: /workspace/github_cpp_makefile_star2_O3/IsseW[P]bytepusher/src/grid/rules.cpp
// Function: water_sim_rule(Grid&, unsigned int, unsigned int)
void water_sim_rule(Grid& grid, uint32_t x, uint32_t y) {
  Tile tile = grid.get(x, y);
  if (tile == Tile::Alive) {
    if (grid.get(x, y + 1) == Tile::Dead) {
      tile = Tile::Dead;
      grid.set(x, y + 1, Tile::Alive);
    } else if (grid.get(x + 1, y) == Tile::Dead && grid.get(x + 1, y + 1) == Tile::Dead) {
      tile = Tile::Dead;
      grid.set(x + 1, y + 1, Tile::Alive);
    } else if (grid.get(x - 1, y) == Tile::Dead && grid.get(x - 1, y + 1) == Tile::Dead) {
      tile = Tile::Dead;
      grid.set(x - 1, y + 1, Tile::Alive);
    }
  }
  grid.set(x, y, tile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
callq 0x2946
movl %eax, %r13d
cmpb $-0x1, %al
jne 0x2b3d
leal 0x1(%rbx), %ebp
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x2946
movl %r14d, %r12d
testb %al, %al
je 0x2b28
leal 0x1(%r14), %r12d
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %edx
callq 0x2946
testb %al, %al
jne 0x2aff
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x2946
testb %al, %al
je 0x2b28
leal -0x1(%r14), %r12d
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %edx
callq 0x2946
movb $-0x1, %r13b
testb %al, %al
jne 0x2b3d
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x2946
testb %al, %al
jne 0x2b3d
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
movl $0xff, %ecx
callq 0x2960
xorl %r13d, %r13d
movzbl %r13b, %ecx
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2960
// File: /workspace/github_cpp_makefile_star2_O3/IsseW[P]bytepusher/src/renderer/renderer.cpp
// Function: Renderer::Renderer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int, unsigned int, unsigned int)
Renderer::Renderer(
    const std::string& name, 
    uint32_t bw, uint32_t bh,
    uint32_t ww, uint32_t wh
):  bw{bw}, bh{bh},
    ww{ww}, wh{wh} 
{
    init_backend();
    SDL_CreateWindowAndRenderer(ww, wh, 0, &sdl_win, &sdl_rend);
    sdl_text = SDL_CreateTexture(sdl_rend, SDL_PIXELFORMAT_RGB332, SDL_TEXTUREACCESS_TARGET, bw, bh);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r12d
movl %r8d, %r13d
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %r14
movl %edx, (%rdi)
movl %ecx, 0x4(%rdi)
movl %r8d, 0x8(%rdi)
movl %r9d, 0xc(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
cmpb $0x0, 0x256c(%rip)      # 0x5132
jne 0x2bd9
movl $0x20, %edi
callq 0x2140
movb $0x1, 0x2559(%rip)      # 0x5132
leaq 0x28(%r14), %rcx
leaq 0x30(%r14), %rbx
movl %r13d, %edi
movl %r12d, %esi
xorl %edx, %edx
movq %rbx, %r8
callq 0x2080
movq (%rbx), %rdi
movl $0x14110801, %esi       # imm = 0x14110801
movl $0x2, %edx
movl %r15d, %ecx
movl %ebp, %r8d
callq 0x2220
movq %rax, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x2c36
movq (%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r15, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x26e8
// File: /workspace/github_cpp_makefile_star2_O3/IsseW[P]bytepusher/src/renderer/renderer.cpp
// Function: Renderer::poll_events()
bool Renderer::poll_events(){
    SDL_Event event;
    while(SDL_PollEvent(&event)){
        if(meh)
            meh(event);
        switch(event.type){
        case SDL_QUIT:
            destroy();
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x20c0
movl %eax, %ebp
testl %eax, %eax
je 0x2d51
cmpq $0x0, 0x48(%rbx)
je 0x2d40
movq %r14, %rdi
movq %r15, %rsi
callq *0x50(%rbx)
cmpl $0x100, (%rsp)          # imm = 0x100
jne 0x2d22
movq %rbx, %rdi
callq 0x2c76
testl %ebp, %ebp
sete %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/TaskQueue.cpp
// Function: TaskQueue::clear()
void TaskQueue::clear()
{
	sem_wait(&(this->lock));
	while (!this->tasks->empty())
	{
		delete this->tasks->front();
		this->tasks->pop();

		sem_wait(&(this->unfinished_business)); // this will never block (well, it shouldn't...if it does, that's a logic error)
		sem_post(&(this->space_available));
	}
	sem_post(&(this->lock));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x20b0
movq (%r14), %rcx
movq 0x10(%rcx), %rax
cmpq %rax, 0x30(%rcx)
je 0x3953
leaq 0x28(%r14), %r15
leaq 0x48(%r14), %r12
movq (%rax), %r13
testq %r13, %r13
je 0x3921
movq %r13, %rdi
callq 0x435c
movl $0x48, %esi
movq %r13, %rdi
callq 0x2180
movq (%r14), %rdi
callq 0x425a
movq %r15, %rdi
callq 0x20b0
movq %r12, %rdi
callq 0x2230
movq (%r14), %rcx
movq 0x10(%rcx), %rax
cmpq %rax, 0x30(%rcx)
jne 0x3911
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/TaskQueue.cpp
// Function: TaskQueue::add(Task*)
void TaskQueue::add(Task* task)
{
	sem_wait(&(this->space_available));
	sem_wait(&(this->lock));
	this->tasks->push(task);
	sem_post(&(this->lock));
	sem_post(&(this->unfinished_business));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
addq $0x48, %rdi
callq 0x20b0
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x20b0
movq (%rbx), %rdi
movq 0x30(%rdi), %rax
movq 0x40(%rdi), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x39f3
movq %r15, (%rax)
addq $0x8, 0x30(%rdi)
jmp 0x39fd
leaq 0x8(%rsp), %rsi
callq 0x4046
movq %r14, %rdi
callq 0x2230
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x2230
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/TaskQueue.cpp
// Function: TaskQueue::toString[abi:cxx11]()
string TaskQueue::toString()
{
	queue<Task*>* new_tasks = new queue<Task*>();

	string output = "TaskQueue: { ";

	sem_wait(&(this->lock));

	Task* front_task = this->tasks->front();
	
	while (!this->tasks->empty())
	{
		if (!front_task->equalTo(this->tasks->front()))
		{
			output += ", ";
		}
		
		output += this->tasks->front()->toString();
		
		new_tasks->push(this->tasks->front());
		this->tasks->pop();
	}

	output += " }";

	queue<Task*>* temp_ptr = this->tasks;
	this->tasks = new_tasks;
	delete temp_ptr;

	sem_post(&(this->lock));

	return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x50, %edi
callq 0x2170
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0x3ed0
leaq 0x10(%rbx), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rbx)
leaq 0x2402(%rip), %rsi      # 0x5ebc
leaq 0x2408(%rip), %rdx      # 0x5ec9
movq %rbx, %rdi
callq 0x35f8
leaq 0x8(%r15), %rdi
movq %rdi, 0x10(%rsp)
callq 0x20b0
movq (%r15), %rcx
movq 0x10(%rcx), %rax
cmpq %rax, 0x30(%rcx)
je 0x3b94
movq (%rax), %r13
leaq 0x28(%rsp), %r12
leaq 0x18(%rsp), %rbp
movq (%rax), %rsi
movq %r13, %rdi
callq 0x4640
testb %al, %al
jne 0x3b13
movq %rbx, %rdi
leaq 0x23bc(%rip), %rsi      # 0x5eca
callq 0x2270
movq (%r15), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
movq %rbp, %rdi
callq 0x4746
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x2050
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x3b4e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2180
movq (%r15), %rax
movq 0x10(%rax), %rsi
movq 0x30(%r14), %rax
movq 0x40(%r14), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x3b73
movq (%rsi), %rcx
movq %rcx, (%rax)
addq $0x8, 0x30(%r14)
jmp 0x3b7b
movq %r14, %rdi
callq 0x4046
movq (%r15), %rdi
callq 0x425a
movq (%r15), %rcx
movq 0x10(%rcx), %rax
cmpq %rax, 0x30(%rcx)
jne 0x3af5
leaq 0x2332(%rip), %rsi      # 0x5ecd
movq %rbx, %rdi
callq 0x2270
movq (%r15), %r12
movq %r14, (%r15)
testq %r12, %r12
je 0x3bb6
movq %r12, %rdi
callq 0x3e78
movl $0x50, %esi
movq %r12, %rdi
callq 0x2180
movq 0x10(%rsp), %rdi
callq 0x2230
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c0e
jmp 0x3c0e
movq %rax, %r15
movl $0x50, %esi
movq %r14, %rdi
jmp 0x3c26
jmp 0x3c0e
movq %rax, %r15
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x3c11
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x3c11
movq %rax, %r15
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x3c2b
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2180
movq %r15, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/Task.cpp
// Function: Task::equalTo(Task*) const
bool Task::equalTo(Task* other) const
{
	if (this->identifier != other->getID())
	{
		return false;
	}
	if (this->sequence != other->getSequence())
	{
		return false;
	}
	if (this->global_pos != other->getGlobalPosition())
	{
		return false;
	}
	if (this->global_seq_length != other->getGlobalSequenceLength())
	{
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x3502
movq 0x8(%r14), %rdx
cmpq 0x8(%r15), %rdx
jne 0x4697
movq (%rsp), %r15
testq %rdx, %rdx
je 0x46a0
movq (%r14), %rdi
movq %r15, %rsi
callq 0x2190
testl %eax, %eax
setne %bpl
jmp 0x46a2
movb $0x1, %bpl
movq (%rsp), %r15
jmp 0x46a2
xorl %ebp, %ebp
cmpq %r12, %r15
je 0x46b7
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x2180
testb %bpl, %bpl
jne 0x4736
movq %rsp, %r15
movq %r12, (%r15)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x3502
movq 0x28(%r14), %rdx
cmpq 0x8(%r15), %rdx
jne 0x46fc
movq (%rsp), %r15
testq %rdx, %rdx
je 0x4705
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0x2190
testl %eax, %eax
setne %bpl
jmp 0x4707
movb $0x1, %bpl
movq (%rsp), %r15
jmp 0x4707
xorl %ebp, %ebp
cmpq %r12, %r15
je 0x471c
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x2180
testb %bpl, %bpl
jne 0x4736
movl 0x40(%r14), %eax
cmpl 0x40(%rbx), %eax
jne 0x4736
movl 0x44(%r14), %eax
cmpl 0x44(%rbx), %eax
sete %al
jmp 0x4738
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dm4[P]huffman-homework/my_encode.cc
// Function: assignCLRecursive(int, char)
void assignCLRecursive(int index, char cl) {
    CLRecordEntry *entry = CLRecord[index];
    entry->cl = cl;
    if (entry->s1 < 0)
        assignCLRecursive(~entry->s1, cl + 1);
    if (entry->s2 < 0)
        assignCLRecursive(~entry->s2, cl + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x5c85(%rip), %rax      # 0x7130
movslq %edi, %rcx
movq (%rax,%rcx,8), %r14
movb %bl, 0x8(%r14)
movl (%r14), %edi
testl %edi, %edi
jns 0x14d1
notl %edi
leal 0x1(%rbx), %eax
movsbl %al, %esi
callq 0x149b
movq 0x5c5f(%rip), %rax      # 0x7130
movl 0x4(%r14), %edi
testl %edi, %edi
jns 0x14df
notl %edi
incb %bl
jmp 0x14ab
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dm4[P]huffman-homework/my_encode.cc
// Function: buildSymbolsCodeword()
void buildSymbolsCodeword() {
    unsigned int codeword = 0;
    symbols[0]->codeword = codeword;
    for (int i = 1; i < symbols.size(); i++) {
        int lengthDiff = symbols[i]->cl - symbols[i - 1]->cl;
        codeword += 1;
        codeword <<= lengthDiff;
        symbols[i]->codeword = codeword;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x5b42(%rip), %rax      # 0x7148
movq (%rax), %rcx
movl $0x0, (%rcx)
movq 0x5b3a(%rip), %rdx      # 0x7150
subq %rax, %rdx
sarq $0x3, %rdx
cmpq $0x2, %rdx
jb 0x164a
xorl %esi, %esi
movl $0x1, %edi
movq -0x8(%rax,%rdi,8), %r8
movq (%rax,%rdi,8), %r9
movl 0x4(%r9), %ecx
subl 0x4(%r8), %ecx
incl %esi
shll %cl, %esi
movl %esi, (%r9)
incq %rdi
cmpq %rdi, %rdx
jne 0x162a
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/thresholdSolver.cc
// Function: ThresholdSolver::init(int, int)
void ThresholdSolver::init(int readLength, int seedNum)
{
	this->seedNum = seedNum;
	vector< int > thresholdVec (seedNum);
	for(int i = 0; i < thresholdVec.size(); i++)
		thresholdVec[i] = readLength;
	this->thresholdVec = thresholdVec;
	this->frequencyVec.resize(thresholdVec.size(), -1);
	this->lengthVec.resize(thresholdVec.size(), 0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %edx, 0xc8(%rdi)
movslq %edx, %rsi
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x6d5c
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
je 0x5110
sarq $0x2, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
leaq 0x3(%rdx), %rcx
andq $-0x4, %rcx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x6fcd(%rip), %xmm1     # 0xc010
movdqa 0x6fd5(%rip), %xmm2     # 0xc020
xorl %edx, %edx
movdqa 0x6fdb(%rip), %xmm3     # 0xc030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x70ab(%rip), %xmm5     # 0xc110
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x509d
movl %ebp, (%rax,%rdx,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x50b0
movl %ebp, 0x4(%rax,%rdx,4)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %esi
testb $0x1, %sil
je 0x50ec
movl %ebp, 0x8(%rax,%rdx,4)
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x50fb
movl %ebp, 0xc(%rax,%rdx,4)
addq $0x4, %rdx
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
cmpq %rdx, %rcx
jne 0x5065
leaq 0x450(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6de8
movq 0x10(%rsp), %rsi
subq 0x8(%rsp), %rsi
leaq 0x480(%rbx), %rdi
sarq $0x2, %rsi
leaq 0x4(%rsp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
callq 0x4252
movq 0x10(%rsp), %rsi
subq 0x8(%rsp), %rsi
addq $0x468, %rbx            # imm = 0x468
sarq $0x2, %rsi
leaq 0x4(%rsp), %rdx
movl $0x0, (%rdx)
movq %rbx, %rdi
callq 0x4252
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5185
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3290
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x5192
jmp 0x5192
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x51ac
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x3470
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/thresholdSolver.cc
// Function: ThresholdSolver::analyzeRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ThresholdSolver::analyzeRead(string read) {
	int minLength = tree.getHashLength();
	int maxLength = tree.getFullLength();

	int pos = 0;

	for (int i = 0; i < thresholdVec.size(); i++) {
		string seed = read.substr(pos, maxLength);

		tree.query(seed, thresholdVec[i]);
		frequencyVec[i] = tree.frequency();
		lengthVec[i] = tree.effectiveLength();
		pos += tree.effectiveLength();

		if (pos > read.length() - minLength)
			break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xd0(%rdi), %r15
movq %r15, %rdi
callq 0x8430
movl %eax, %ebp
movq %r15, %rdi
callq 0x8434
movq 0x458(%r14), %rcx
cmpq 0x450(%r14), %rcx
je 0x5366
cltq
movq %rax, 0x50(%rsp)
movslq %ebp, %rax
movq %rax, 0x40(%rsp)
xorl %r12d, %r12d
xorl %ebp, %ebp
movq %r14, 0x48(%rsp)
movslq %ebp, %rdx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movq 0x50(%rsp), %rcx
callq 0x32a0
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x44a2
movq 0x450(%r14), %rax
movl (%rax,%r12,4), %edx
movq %r15, %rdi
movq %rsp, %rsi
callq 0x8438
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x52d6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
movq %r15, %rdi
callq 0x85c0
movq 0x480(%r14), %rcx
movl %eax, (%rcx,%r12,4)
movq %r15, %rdi
callq 0x85b8
movq 0x468(%r14), %rcx
movl %eax, (%rcx,%r12,4)
movq %r15, %rdi
callq 0x85b8
movl %eax, %r13d
movq %r15, %r14
movq %rbx, %r15
movq 0x8(%rbx), %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x532d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3290
addl %r13d, %ebp
movslq %ebp, %rax
subq 0x40(%rsp), %rbx
cmpq %rax, %rbx
movq %r15, %rbx
movq %r14, %r15
movq 0x48(%rsp), %r14
jb 0x5366
incq %r12
movq 0x458(%r14), %rax
subq 0x450(%r14), %rax
sarq $0x2, %rax
cmpq %r12, %rax
ja 0x5272
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5398
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
jmp 0x5398
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x53b4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x3470
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/thresholdSolver.cc
// Function: ThresholdSolver::printFreqTable()
void ThresholdSolver::printFreqTable() {
	cout << "Printing Frequency Table." << endl;
	for (int i = 0; i < freqTable.size(); i++)
	{
		for (int j = 0; j<freqTable[i].size(); j++)
			cout << freqTable[i][j] << " ";
		cout << "" << endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa7b7(%rip), %r14      # 0x10fc8
leaq 0x5adb(%rip), %rsi      # 0xc2f3
movl $0x19, %edx
movq %r14, %rdi
callq 0x32e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x6914
xorl %r13d, %r13d
leaq 0x5904(%rip), %r12      # 0xc168
leaq (,%r13,2), %r15
addq %r13, %r15
movq (%rax,%r15,8), %rcx
cmpq %rcx, 0x8(%rax,%r15,8)
je 0x68b3
xorl %ebp, %ebp
movl (%rcx,%rbp,4), %esi
movq %r14, %rdi
callq 0x3450
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x32e0
incq %rbp
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rcx
movq 0x8(%rax,%r15,8), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rbp, %rax
ja 0x687c
movq %r14, %rdi
leaq 0x5c5e(%rip), %rsi      # 0xc51b
xorl %edx, %edx
callq 0x32e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
incq %r13
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %r13, %rcx
ja 0x6864
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/thresholdSolver.cc
// Function: ThresholdSolver::printTotalFreqTable()
void ThresholdSolver::printTotalFreqTable() {
	cout << "seedNum: " << seedNum << endl;
	for(int i = 0; i < totalFrequency.size(); i++)
	{
		if(totalFrequency[i] != 0)
			cout << i-1 << ": " << totalFrequency[i] << endl;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xa691(%rip), %r14      # 0x10fc8
leaq 0x5771(%rip), %rsi      # 0xc0af
movl $0x9, %edx
movq %r14, %rdi
callq 0x32e0
movl 0xc8(%rbx), %esi
movq %r14, %rdi
callq 0x3450
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movq 0xa8(%rbx), %rax
movq 0xb0(%rbx), %rcx
cmpq %rax, %rcx
je 0x6a32
xorl %r13d, %r13d
movq 0xa624(%rip), %r14      # 0x10fc8
leaq 0x5c31(%rip), %r15      # 0xc5dc
cmpl $0x0, (%rax,%r13,4)
je 0x6a1c
leal -0x1(%r13), %esi
movq %r14, %rdi
callq 0x3450
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x32e0
movq 0xa8(%rbx), %rax
movl (%rax,%r13,4), %esi
movq %r12, %rdi
callq 0x3450
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movq 0xa8(%rbx), %rax
movq 0xb0(%rbx), %rcx
incq %r13
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r13, %rdx
ja 0x69ab
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/devvoid[P]vini/./vini.hpp
// Function: Vini::Vini(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Vini(std::string path) : ini_file() {
        std::ifstream file;

        file.open(path.c_str());

        std::stringstream stringbuffer;

        stringbuffer << file.rdbuf();

        file.close();
        
        parse_text(stringbuffer.str());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x3b0, %rsp            # imm = 0x3B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq -0x3c0(%rbp), %rdi
callq 0x2200
movq (%r14), %rsi
leaq -0x3c0(%rbp), %rdi
movl $0x8, %edx
callq 0x2110
leaq -0x1b8(%rbp), %rdi
callq 0x2140
leaq -0x1a8(%rbp), %rdi
leaq -0x3b0(%rbp), %rsi
callq 0x2080
leaq -0x3c0(%rbp), %rdi
callq 0x2070
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2250
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x32c2
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ea6
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x21d0
movq 0x410b(%rip), %rsi      # 0x6fb8
leaq -0x1b8(%rbp), %rdi
callq 0x2160
leaq -0x138(%rbp), %rdi
callq 0x20c0
leaq -0x3c0(%rbp), %rdi
callq 0x2090
addq $0x3b0, %rsp            # imm = 0x3B0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f0a
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x21d0
jmp 0x2f0a
jmp 0x2efd
movq %rax, %r14
jmp 0x2f29
movq %rax, %r14
jmp 0x2f35
movq %rax, %r14
movq 0x40a7(%rip), %rsi      # 0x6fb8
leaq -0x1b8(%rbp), %rdi
callq 0x2160
leaq -0x138(%rbp), %rdi
callq 0x20c0
leaq -0x3c0(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x469e
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/devvoid[P]vini/./vini.hpp
// Function: Vini::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string get(std::string section, std::string key, std::string default_value) {
        if (ini_file[section][key] != "")
            return ini_file[section][key];
        
        //If it can't find anything, return default value.
        set(section, key, default_value);

        return default_value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x37aa
movq %rax, %rdi
movq %r12, %rsi
callq 0x382a
leaq 0x218e(%rip), %rsi      # 0x5111
movq %rax, %rdi
callq 0x20b0
testl %eax, %eax
je 0x2fc3
movq %r15, %rdi
movq %r13, %rsi
callq 0x37aa
movq %rax, %rdi
movq %r12, %rsi
callq 0x382a
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4186
jmp 0x30c5
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x4186
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x4186
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x4186
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x37aa
leaq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0x382a
leaq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x2100
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x3057
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21d0
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x306f
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21d0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3088
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x30a7
movq %rdx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x30ad
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x30f9
movq %rax, %rbx
jmp 0x3111
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x30f9
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21d0
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x3111
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21d0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x312a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/devvoid[P]vini/./vini.hpp
// Function: Vini::save(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void save(std::string path) {
        std::ofstream file;

        file.open(path.c_str());

        for (vini_file::iterator it = ini_file.begin(); it != ini_file.end(); it++) {
            file << "[" << it->first << "]" << "\n";

            for (vini_content::iterator inner_it = it->second.begin(); inner_it != it->second.end(); inner_it++)
                file << inner_it->first << "=\"" << inner_it->second << "\"\n";
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
movq %rdi, %r13
leaq -0x238(%rbp), %r14
movq %r14, %rdi
callq 0x2280
movq (%rbx), %rsi
movq %r14, %rdi
movl $0x10, %edx
callq 0x2050
movq 0x18(%r13), %r14
addq $0x8, %r13
cmpq %r13, %r14
je 0x325e
leaq -0x238(%rbp), %r12
leaq 0x1f85(%rip), %r15      # 0x510f
movq %r13, -0x30(%rbp)
movl $0x1, %edx
movq %r12, %rdi
leaq 0x1f6b(%rip), %rsi      # 0x5108
callq 0x2210
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r12, %rdi
callq 0x2210
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1f46(%rip), %rsi      # 0x510a
callq 0x2210
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x1f38(%rip), %rsi      # 0x5110
callq 0x2210
movq 0x58(%r14), %rbx
movq %r14, -0x38(%rbp)
leaq 0x48(%r14), %r13
cmpq %r13, %rbx
je 0x3245
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r12, %rdi
callq 0x2210
movq %rax, %r14
movl $0x2, %edx
movq %rax, %rdi
leaq 0x1efc(%rip), %rsi      # 0x510c
callq 0x2210
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
movq %r14, %rdi
callq 0x2210
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2130
movq %rax, %rbx
cmpq %r13, %rax
jne 0x31ee
movq -0x38(%rbp), %rdi
callq 0x2130
movq %rax, %r14
movq -0x30(%rbp), %r13
cmpq %r13, %rax
jne 0x318e
movq 0x3d6b(%rip), %rax      # 0x6fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x230(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x238(%rbp,%rcx)
callq 0x2190
leaq -0x140(%rbp), %rdi
callq 0x20c0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32aa
jmp 0x32aa
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/devvoid[P]vini/./vini.hpp
// Function: Vini::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> split(const std::string &s, char delim) {
        std::vector<std::string> elems;

        std::stringstream ss(s);
        std::string item;

        while(std::getline(ss, item, delim)) {
            elems.push_back(item);
        }

        return elems;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %ecx, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x1d0(%rbp), %rdi
movq %rdx, %rsi
movl $0x18, %edx
callq 0x2260
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movsbl %r14b, %r14d
leaq -0x1d0(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x22b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3715
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3918
jmp 0x36ec
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x372a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq 0x3887(%rip), %rsi      # 0x6fb8
leaq -0x1d0(%rbp), %rdi
callq 0x2160
leaq -0x150(%rbp), %rdi
callq 0x20c0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x379a
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x377b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq 0x3836(%rip), %rsi      # 0x6fb8
leaq -0x1d0(%rbp), %rdi
callq 0x2160
leaq -0x150(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x38aa
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/StrFolder.cc
// Function: swap(Message&, Message&)
void swap(Message &lhs, Message &rhs)
{
	using std::swap;  // not strictly needed in this case, but good habit

	// remove pointers to each Message from their (original) respective Folders
	for (auto f : lhs.folders)
		f->remMsg(&lhs);
	for (auto f : rhs.folders)
		f->remMsg(&rhs);

	// swap the contents and Folder pointer sets
	swap(lhs.folders, rhs.folders);   // uses swap(set&, set&)
	swap(lhs.contents, rhs.contents); // swap(String&, String&)

	// add pointers to each Message to their (new) respective Folders
	for (auto f : lhs.folders)
		f->addMsg(&lhs);
	for (auto f : rhs.folders)
		f->addMsg(&rhs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, %r14
movq 0x28(%rdi), %r15
leaq 0x18(%rdi), %rbx
cmpq %rbx, %r15
je 0x13e3
leaq -0x30(%rbp), %r12
movq 0x20(%r15), %r13
movq %r14, -0x30(%rbp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x2c0a
movq %r13, %rdi
movq %rax, %rsi
callq 0x2c92
movq %r15, %rdi
callq 0x1150
movq %rax, %r15
cmpq %rbx, %rax
jne 0x13b5
movq %rbx, -0x58(%rbp)
leaq 0x10(%r14), %rax
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, -0x38(%rbp)
movq 0x28(%rbx), %r13
leaq 0x18(%rbx), %r15
cmpq %r15, %r13
je 0x1437
movq 0x20(%r13), %r12
movq %rbx, -0x30(%rbp)
movq %r12, %rdi
leaq -0x30(%rbp), %rsi
callq 0x2c0a
movq %r12, %rdi
movq %rax, %rsi
callq 0x2c92
movq %r13, %rdi
callq 0x1150
movq %rax, %r13
cmpq %r15, %rax
jne 0x1408
movq %r15, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2d18
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq (%r14), %rax
movq (%rbx), %rcx
movq %rcx, (%r14)
movq %rax, (%rbx)
movq 0x28(%r14), %r15
movq -0x58(%rbp), %r13
cmpq %r13, %r15
je 0x1495
leaq -0x30(%rbp), %r12
movq 0x20(%r15), %rdi
movq %r14, -0x30(%rbp)
movq %r12, %rsi
callq 0x1f04
movq %r15, %rdi
callq 0x1150
movq %rax, %r15
cmpq %r13, %rax
jne 0x1475
movq 0x28(%rbx), %r14
movq -0x48(%rbp), %r12
cmpq %r12, %r14
je 0x14c6
leaq -0x30(%rbp), %r15
movq 0x20(%r14), %rdi
movq %rbx, -0x30(%rbp)
movq %r15, %rsi
callq 0x1f04
movq %r14, %rdi
callq 0x1150
movq %rax, %r14
cmpq %r12, %rax
jne 0x14a6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: String::operator=(String const&)
String& String::operator=(const String& rhs)
{
	// copying the right-hand operand before deleting the left handles self-assignment
	auto newp = a.allocate(rhs.sz); // copy the underlying string from rhs
	uninitialized_copy(rhs.p, rhs.p + rhs.sz, newp);

	if (p)
		a.deallocate(p, sz); // free the memory used by the left-hand operand
	p = newp;    // p now points to the newly allocated string
	sz = rhs.sz; // update the size

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
js 0x446f
movq %rsi, %r14
callq 0x1110
movq %rax, %r15
movq (%r14), %r12
testq %r12, %r12
je 0x4448
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x1180
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x445c
movq (%rbx), %rsi
callq 0x1120
movq (%r14), %r12
movq %r15, 0x8(%rbx)
movq %r12, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: String::operator=(String&&)
String& String::operator=(String&& rhs) noexcept
{
	// explicit check for self-assignment
	if (this != &rhs) {
		if (p)
			a.deallocate(p, sz);  // do the work of the destructor
		p = rhs.p;    // take over the old memory
		sz = rhs.sz;

		rhs.p = 0;    // deleting rhs.p is safe
		rhs.sz = 0;
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x44ac
movq %rsi, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4497
movq (%rbx), %rsi
callq 0x1120
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: String::operator=(char const*)
String& String::operator=(const char* cp)
{
	if (p) a.deallocate(p, sz);
	p = a.allocate(sz = strlen(cp));
	uninitialized_copy(cp, cp + sz, p);
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x44d2
movq (%rbx), %rsi
callq 0x1120
movq %r14, %rdi
callq 0x1080
movq %rax, (%rbx)
testq %rax, %rax
js 0x4509
movq %rax, %rdi
callq 0x1110
movq %rax, 0x8(%rbx)
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x4501
movq %rax, %rdi
movq %r14, %rsi
callq 0x10e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: String::operator=(char)
String& String::operator=(char c)
{
	if(p) a.deallocate(p, sz);
	p = a.allocate(sz = 1);
	*p = c;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x452c
movq (%rbx), %rsi
callq 0x1120
movq $0x1, (%rbx)
movl $0x1, %edi
callq 0x1110
movq %rax, 0x8(%rbx)
movb %r14b, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: String::operator=(std::initializer_list<char>)
String& String::operator=(initializer_list<char> il)
{
	// no need to check for self-assignment
	if (p)
		a.deallocate(p, sz);        // do the work of the destructor
	p = a.allocate(sz = il.size()); // do the work of the copy constructor
	uninitialized_copy(il.begin(), il.end(), p);
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4570
movq (%rbx), %rsi
callq 0x1120
movq %r14, (%rbx)
testq %r14, %r14
js 0x45a5
movq %r14, %rdi
callq 0x1110
movq %rax, 0x8(%rbx)
testq %r14, %r14
je 0x4597
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: print(std::ostream&, String const&)
ostream& print(ostream& os, const String& s)
{
	auto p = s.begin();
	while (p != s.end())
		os << *p++ ;
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, (%rsi)
je 0x45f3
movq %rsi, %r14
movq 0x8(%rsi), %r12
leaq -0x21(%rbp), %r15
movb (%r12), %al
incq %r12
movb %al, -0x21(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1140
movq 0x8(%r14), %rax
addq (%r14), %rax
cmpq %rax, %r12
jne 0x45cd
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/String.cc
// Function: add(String const&, String const&)
String add(const String& lhs, const String& rhs)
{
	String ret;
	ret.sz = rhs.size() + lhs.size();   // size of the combined String
	ret.p = String::a.allocate(ret.sz); // allocate new space
	uninitialized_copy(lhs.begin(), lhs.end(), ret.p); // copy the operands
	uninitialized_copy(rhs.begin(), rhs.end(), ret.p + lhs.sz);
	return ret;  // return a copy of the newly created String
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
movq (%rsi), %rdi
addq (%rdx), %rdi
movq %rdi, (%rbx)
js 0x467a
movq %rdx, %r14
movq %rsi, %r13
callq 0x1110
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq (%r13), %r12
testq %r12, %r12
je 0x4651
movq 0x8(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x1180
movq (%r14), %rdx
testq %rdx, %rdx
je 0x4668
movq 0x8(%r14), %rsi
addq %r12, %r15
movq %r15, %rdi
callq 0x1180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1060