LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::check_PC(int)
bool Emulator::check_PC(int a)
{
    if(a<0 || a>pc_upper)
    {
        fault = true;
        string tmp = faults.find(0)->second;
        PC--;
        string tmp2 = current_state();
        PC++;

        fault_cause = tmp + " when executing " + tmp2;

        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, %ebx
cmpl $0x400, %esi            # imm = 0x400
jb 0x52c1
movq %rdi, %r14
movb $0x1, 0x51(%rdi)
movq 0x5053(%rip), %rdx      # 0xa1b8
leaq 0x5044(%rip), %rax      # 0xa1b0
movq %rax, %rcx
testq %rdx, %rdx
je 0x517d
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
jmp 0x516f
cmpq %rax, %rcx
je 0x5191
cmpl $0x0, 0x20(%rcx)
leaq 0x5023(%rip), %rax      # 0xa1b0
cmoveq %rcx, %rax
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x434c
decl 0x28(%r14)
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x4e0e
incl 0x28(%r14)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x434c
leaq 0x22f6(%rip), %rsi      # 0x74e2
leaq 0x8(%rsp), %rdi
callq 0x2290
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5231
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x5238
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
addq $0x58, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x21c0
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x5278
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x528f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52aa
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x52c1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
cmpl $0x400, %ebx            # imm = 0x400
setb %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x52de
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x52fd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x52fd
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x531d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x531d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x5334
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::check_SP(int)
bool Emulator::check_SP(int a)
{
    if(a>end_address || a<=data_upper)
    {
        fault = true;
        string tmp = faults.find(1)->second;
        PC--;
        string tmp2 = current_state();
        PC++;

        fault_cause = tmp + " when executing " + tmp2;
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpl $0x10000, %esi          # imm = 0x10000
setb %al
cmpl %esi, 0x38(%rdi)
setl %bl
andb %al, %bl
jne 0x576e
movq %rdi, %r14
movb $0x1, 0x51(%rdi)
movq 0x4bbc(%rip), %rdx      # 0xa1b8
leaq 0x4bad(%rip), %rax      # 0xa1b0
movq %rax, %rcx
testq %rdx, %rdx
je 0x562a
leaq 0x4b9e(%rip), %rcx      # 0xa1b0
xorl %esi, %esi
cmpl $0x0, 0x20(%rdx)
sete %sil
cmovneq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x5612
cmpq %rax, %rcx
je 0x563e
cmpl $0x2, 0x20(%rcx)
leaq 0x4b76(%rip), %rax      # 0xa1b0
cmovbq %rcx, %rax
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x434c
decl 0x28(%r14)
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x4e0e
incl 0x28(%r14)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x434c
leaq 0x1e49(%rip), %rsi      # 0x74e2
leaq 0x8(%rsp), %rdi
callq 0x2290
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x56de
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x56e5
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
addq $0x58, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x21c0
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x5725
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x573c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5757
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x576e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5784
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x57a3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x57a3
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57c3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x57c3
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x57da
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::reverse_decode[abi:cxx11](unsigned int) const
string Emulator::reverse_decode(unsigned a) const
{
    unsigned opcode = (a<<24)>>24;

    ostringstream oss;

    map<unsigned, pair<unsigned, string> >::const_iterator mt = decoder.find(opcode);

    string mnem = mt->second.second;    // storing the mnemonic

    oss<<mnem;

    if(mt->second.first==1)     // operand also present
    {
        int tmp = a & 0xffffff00;
        tmp /= 256;

        oss<<" "<<tmp;
    }

    return oss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %edx, %ebp
movq %rdi, %rbx
movzbl %bpl, %r14d
leaq 0x20(%rsp), %rdi
callq 0x2200
movq 0x4969(%rip), %rcx      # 0xa188
leaq 0x495a(%rip), %r15      # 0xa180
movq %r15, %rax
testq %rcx, %rcx
je 0x584c
leaq 0x494b(%rip), %rax      # 0xa180
xorl %edx, %edx
cmpl %r14d, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x5835
cmpq %r15, %rax
je 0x5860
cmpl 0x20(%rax), %r14d
leaq 0x4924(%rip), %r15      # 0xa180
cmovaeq %rax, %r15
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x30(%r15), %rsi
movq 0x38(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x434c
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x21b0
cmpl $0x1, 0x28(%r15)
jne 0x58bb
leaq 0x1c5e(%rip), %rsi      # 0x74fb
leaq 0x20(%rsp), %rdi
movl $0x1, %edx
callq 0x21b0
sarl $0x8, %ebp
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0x2260
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2230
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x58de
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x46e3(%rip), %rsi      # 0x9fc8
leaq 0x20(%rsp), %rdi
callq 0x20d0
leaq 0x90(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5914
movq %rax, %rbx
jmp 0x592d
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x592d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x4694(%rip), %rsi      # 0x9fc8
leaq 0x20(%rsp), %rdi
callq 0x20d0
leaq 0x90(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/flushlist.h
// Function: bool hm3::FlushList<hm3::SkipList, hm3::flusher::DiskFileFlusher<hm3::idgenerator::IDGeneratorDate>, std::nullptr_t>::putT_<hm3::Pair>(hm3::Pair&&)
bool putT_(UPAIR &&data){
		bool const result = list_.put( std::forward<UPAIR>(data) );

		if (list_.getBytes() > maxSize_){
			flush();
			list_.removeAll();
			notifyLoader_(loader_);
		}

		return result;
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3798
movl %eax, %ebp
movq (%rbx), %rsi
movq 0x210(%rsi), %rax
cmpq 0x60(%rbx), %rax
jbe 0x332f
leaq 0x8(%rbx), %rdi
callq 0x2bac
movq (%rbx), %rdi
callq 0x3546
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: CaptureInteger(gaps::R2Grid&)
static int
CaptureInteger(R2Grid& image)
{
  // Allocate pixel buffer
  unsigned char *pixels = new unsigned char [ 3 * width * height ];

  // Set packing parameters for glReadPixels
  if ((width % 4) != 0) glPixelStorei(GL_PACK_ALIGNMENT, 1);

  // Run main loop  -- never returns   // Read pixels
  glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels);

  // Fill image
  unsigned char *pixelp = pixels;
  for (int iy = 0; iy < height; iy++) {
    for (int ix = 0; ix < width; ix++) {
      unsigned int red = *pixelp++;
      unsigned int green = *pixelp++;
      unsigned int blue = *pixelp++;
      unsigned int value = 0;
      value |= red << 16;
      value |= green <<  8;
      value |= blue;
      image.SetGridValue(ix, iy, value);
    }
  }

  // Delete pixels
  delete [] pixels;
  
  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq 0x12e8f3(%rip), %r15    # 0x1569b0
movslq 0x12e8f0(%rip), %rax    # 0x1569b4
imulq %r15, %rax
leaq (%rax,%rax,2), %rdi
callq 0x22040
movq %rax, %rbx
testb $0x3, %r15b
je 0x280e9
movl $0xd05, %edi            # imm = 0xD05
movl $0x1, %esi
callq 0x223f0
movl 0x12e8c1(%rip), %edx    # 0x1569b0
movl 0x12e8bf(%rip), %ecx    # 0x1569b4
movq %rbx, (%rsp)
xorl %edi, %edi
xorl %esi, %esi
movl $0x1907, %r8d           # imm = 0x1907
movl $0x1401, %r9d           # imm = 0x1401
callq 0x223a0
movslq 0x12e89f(%rip), %rax    # 0x1569b4
testq %rax, %rax
jle 0x2817f
movl 0x12e890(%rip), %ecx    # 0x1569b0
movq 0xb8(%r14), %rdx
movslq 0xc8(%r14), %rsi
shlq $0x3, %rsi
xorl %edi, %edi
movq %rbx, %r8
testl %ecx, %ecx
jle 0x28174
xorl %r9d, %r9d
movzbl (%r8), %r10d
movzbl 0x1(%r8), %r11d
movzbl 0x2(%r8), %ebp
shll $0x10, %r10d
shll $0x8, %r11d
orl %r10d, %r11d
orl %ebp, %r11d
xorps %xmm0, %xmm0
cvtsi2sd %r11d, %xmm0
addq $0x3, %r8
movsd %xmm0, (%rdx,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x2813e
incq %rdi
addq %rsi, %rdx
cmpq %rax, %rdi
jne 0x28137
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22c10
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: DrawRootWithOpenGL(gaps::R3Camera const&, gaps::R3Scene*, int, int)
static void
DrawRootWithOpenGL(const R3Camera& camera, R3Scene *scene, int color_scheme, RNBoolean omit_objects = FALSE)
{
  // This is a hack to account for coincident front and back faces
  glDepthRange(0, 0.999999);
  glEnable(GL_CULL_FACE);
  R3null_material.Draw();
  DrawNodeWithOpenGL(camera, scene, scene->Root(), color_scheme, omit_objects);
  glDisable(GL_CULL_FACE);
  glDepthRange(0, 1);
  R3null_material.Draw();
  DrawNodeWithOpenGL(camera, scene, scene->Root(), color_scheme, omit_objects);
  R3null_material.Draw();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movsd 0xc3e5b(%rip), %xmm1    # 0xee0b0
xorps %xmm0, %xmm0
callq 0x23040
movl $0xb44, %edi            # imm = 0xB44
callq 0x227e0
leaq 0x131b82(%rip), %r12    # 0x15bdf0
movq %r12, %rdi
xorl %esi, %esi
callq 0x46d38
movq (%r14), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x2a2d4
movl $0xb44, %edi            # imm = 0xB44
callq 0x221e0
movsd 0xc3dd3(%rip), %xmm1    # 0xee070
xorps %xmm0, %xmm0
callq 0x23040
movq %r12, %rdi
xorl %esi, %esi
callq 0x46d38
movq (%r14), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x2a2d4
movq %r12, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x46d38
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: EstimateGroundY(gaps::R3Camera const&, gaps::R3Scene*)
static RNScalar
EstimateGroundY(const R3Camera& camera, R3Scene *scene)
{
  // Get convenient variables
  if (!scene) return 0;

  // Check if scene has a node named "Room#*" containing camera
  for (int i = 0; i < scene->NNodes(); i++) {
    R3SceneNode *node = scene->Node(i);
    if (node->Name() && !strncmp(node->Name(), "Room#", 5)) {
      if (R3Contains(node->BBox(), camera.Origin())) {
        return node->BBox().YMin();
      }
    }
  }

#if 0
  // Check first intersection with ray cast straight down
  if (R3Contains(scene->BBox(), camera.Origin())) {
    R3Ray ray(camera.Origin(), R3negy_vector);
    R3Point position;
    R3Vector normal;
    if (scene->Intersects(ray, NULL, NULL, NULL, &position, &normal)) {
      if (normal.Y() > 0.9) return position.Y();
    }
  }
#endif
  
  // If all else fails, return bounding box ymin
  return scene->BBox().YMin();
}

// Assembly:
testq %rsi, %rsi
je 0x2acc9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0x14(%rsi)
setg %bpl
jle 0x2accd
movq %rdi, %r14
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %r12
movq 0x1a0(%r12), %rdi
movb $0x1, %r15b
testq %rdi, %rdi
je 0x2acb2
movsd %xmm0, (%rsp)
movl $0x5, %edx
leaq 0xc36f3(%rip), %rsi     # 0xee369
callq 0x223c0
testl %eax, %eax
je 0x2ac86
movsd (%rsp), %xmm0
jmp 0x2acb2
movq %r12, %rdi
callq 0x3f3f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x4f57c
testl %eax, %eax
movsd (%rsp), %xmm0
je 0x2acb2
movq %r12, %rdi
callq 0x3f3f0
movsd 0x10(%rax), %xmm0
xorl %r15d, %r15d
testb %r15b, %r15b
je 0x2accd
incq %r13
movslq 0x14(%rbx), %rax
cmpq %rax, %r13
setl %bpl
jl 0x2ac4d
jmp 0x2accd
xorps %xmm0, %xmm0
retq
testb $0x1, %bpl
jne 0x2ace0
movq (%rbx), %rdi
callq 0x3f3f0
movsd 0x10(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: purselcp(unsigned int*, int*, int*, int*, int)
int purselcp(unsigned int *T,int *P,int *P_2,int *I,int p){
    //Get Longest Common Prefix of the purse No.i and the purse No.i-1
    // if i = 0 : return 0.
    if(p<1){return 0;} 
    int a = 0;
    while(a<P_2[I[p-1]]){ 
        if(T[P[I[p-1]]+a] == T[P[I[p]]+a]){ 
            a++;
        }
        else{
            break;
        }
    }
    return a; 
}

// Assembly:
xorl %eax, %eax
testl %r8d, %r8d
jle 0x236b
movl %r8d, %r8d
movslq -0x4(%rcx,%r8,4), %r9
movl (%rdx,%r9,4), %edx
testl %edx, %edx
jle 0x236b
movslq (%rsi,%r9,4), %rax
movslq (%rcx,%r8,4), %rcx
movslq (%rsi,%rcx,4), %rsi
leaq (%rdi,%rax,4), %rcx
leaq (%rdi,%rsi,4), %rsi
xorl %eax, %eax
movl (%rcx,%rax,4), %edi
cmpl (%rsi,%rax,4), %edi
jne 0x236b
incq %rax
cmpq %rax, %rdx
jne 0x2359
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: bbsort(unsigned int*, int*, int*, int*, int, int, int)
void bbsort(unsigned int *T,int *P,int *P_2,int *I,int a,int b,int c){
    //to sort [c] purse(s) with [a]-th character from position [b] in I.
    //[c is really small] 
    sortstack--;
    if(DEBUGFLAG==1){printf("\nbbsort(%d,%d,%d)",a,b,c);}
    for(int i = 0;i<c;i++){
        int k = i;
        //int bc = T[P[I[b+i]]+a]; //a-th character in I[b+i]
        if(a+1 > P_2[I[b+i]]){continue;} //
        for(int j = i; j<c; j++){
            if(a+1 > P_2[I[b+j]]){k = j;break;}  //if the purse [i] doesn't have a-th character,exactly it's smaller;
            else{ //check next cheracter until one of each purse reaches the end
                int d = a;
                while(1){
                    //printf("\n[%d]",d);
                    if(T[P[I[b+k]]+d] > T[P[I[b+j]]+d]){k = j;break;}
                    if(T[P[I[b+k]]+d] < T[P[I[b+j]]+d]){break;}
                    d++;
                    if(d+1 > P_2[I[b+k]]){break;}
                    if(d+1 > P_2[I[b+j]]){k=j;break;}
                }
            }
        }
        if(k!=i){
            //printf("swap!");
            int tem = I[b+i];
            I[b+i] = I[b+k];
            I[b+k] = tem;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl 0x38(%rsp), %eax
decl 0x3de6(%rip)            # 0x6170
testl %eax, %eax
jle 0x2461
movslq %r8d, %rcx
movslq -0x18(%rsp), %r9
movl %eax, %r10d
movq -0x20(%rsp), %rax
leaq (%rax,%r9,4), %r11
incq %rcx
movq %rcx, -0x8(%rsp)
xorl %ebx, %ebx
movslq (%r11,%rbx,4), %rax
cmpl %r8d, (%rdx,%rax,4)
jle 0x2455
movq %rax, -0x10(%rsp)
movq %rbx, %r12
movl %ebx, %r15d
movslq (%r11,%r12,4), %rax
movslq (%rdx,%rax,4), %r13
cmpl %r8d, %r13d
jle 0x242c
movq -0x18(%rsp), %rcx
leal (%r15,%rcx), %r9d
movslq %r9d, %r9
movq -0x20(%rsp), %rcx
movslq (%rcx,%r9,4), %rbp
movslq (%rsi,%rbp,4), %r9
movslq (%rsi,%rax,4), %rax
leaq (%rdi,%r9,4), %r14
leaq (%rdi,%rax,4), %rax
movq -0x8(%rsp), %r9
movl -0x4(%rax,%r9,4), %ecx
cmpl %ecx, -0x4(%r14,%r9,4)
ja 0x241f
jb 0x2422
incq %r9
movslq (%rdx,%rbp,4), %rcx
cmpq %rcx, %r9
jg 0x2422
cmpq %r13, %r9
jle 0x2400
movl %r12d, %r15d
incq %r12
cmpq %r10, %r12
jne 0x23c9
jmp 0x242f
movl %r12d, %r15d
movl %r15d, %eax
cmpq %rax, %rbx
movq -0x10(%rsp), %r14
je 0x2455
addl -0x18(%rsp), %r15d
movslq %r15d, %rax
movq -0x20(%rsp), %r9
movl (%r9,%rax,4), %ecx
movl %ecx, (%r11,%rbx,4)
movl %r14d, (%r9,%rax,4)
incq %rbx
cmpq %r10, %rbx
jne 0x23b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: purse(unsigned int*, int*, int*, long)
int purse(unsigned int *T,int *P,int *P_2,long int fsize){ //purse T and set P.
    std::cout << std::endl;
    int tn = -1; //temporary number
    int pn = 1;
    P[0] = 0;
    for (int i = 0 ; i < fsize-1 ; i++){
        if(T[i] > T[i+1]){ //T[i]がL 
            tn = i;
        }
        if(T[i] < T[i+1] && tn != -1){
            P[pn] = tn+1;
            P_2[pn-1] = P[pn] - P[pn-1];
            pn++;
            tn = -1;
        }
    }
    P[pn] = tn+1;
    P_2[pn-1] = fsize - P[pn-1]; //not to left last character
    
    int k = 0;
    for(int i = 0 ; i < fsize ; i++){
        if(P[k]==i){
            if(i+40 > fsize){printf("(%d,%d)",P[k],P_2[k]);}
            k++;
        }
        //if(i > fsize/2){exit(3);}
        if(i+40 > fsize){
            std::cout << std::hex << int(T[i]);
            std::cout << " ";
        }
    }
    return pn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq 0x394d(%rip), %r12      # 0x5fd8
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq %r15, (%rsp)
movl $0x0, (%r15)
cmpq $0x2, %rbx
jl 0x2716
leaq -0x1(%rbx), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ebp
xorl %edx, %edx
movq 0x8(%rsp), %rdi
movl %eax, %esi
movl (%rdi,%rdx,4), %eax
cmpl 0x4(%rdi,%rdx,4), %eax
movl %edx, %eax
cmovbel %esi, %eax
jae 0x270a
cmpl $-0x1, %eax
je 0x270a
incl %eax
movslq %ebp, %rbp
movq (%rsp), %rsi
movl %eax, (%rsi,%rbp,4)
subl -0x4(%rsi,%rbp,4), %eax
movl %eax, -0x4(%r14,%rbp,4)
incl %ebp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rcx
jne 0x26d9
incl %eax
jmp 0x271d
movl $0x1, %ebp
xorl %eax, %eax
movslq %ebp, %rcx
movq (%rsp), %rdx
movl %eax, (%rdx,%rcx,4)
movl -0x4(%rdx,%rcx,4), %eax
movl %ebx, %edx
subl %eax, %edx
movq %r14, 0x10(%rsp)
movl %edx, -0x4(%r14,%rcx,4)
testq %rbx, %rbx
jle 0x27d6
xorl %r15d, %r15d
xorl %r14d, %r14d
movslq %r14d, %rax
movq (%rsp), %rcx
movl (%rcx,%rax,4), %esi
cmpq %rsi, %r15
jne 0x2779
leaq 0x28(%r15), %rcx
cmpq %rbx, %rcx
jle 0x2776
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %edx
leaq 0x18a1(%rip), %rdi      # 0x4010
xorl %eax, %eax
callq 0x2040
incl %r14d
leaq 0x28(%r15), %r13
cmpq %rbx, %r13
jle 0x27c6
movq 0x384f(%rip), %r12      # 0x5fd8
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r12,%rax)
movq 0x8(%rsp), %rax
movl (%rax,%r15,4), %esi
movq %r12, %rdi
callq 0x21c0
movl $0x1, %edx
movq %r12, %rdi
leaq 0x1a6d(%rip), %rsi      # 0x422e
callq 0x2120
addq $-0x27, %r13
movq %r13, %r15
cmpq %rbx, %r13
jne 0x2748
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: pnsort(unsigned int*, int*, int*, int*, int)
void pnsort(unsigned int *T,int *P,int *P_2, int *I,int pn){ //Sort all purses
    nextsort = (int(*)[3])malloc(sizeof(int) * 1000000 * 3);
    sortstack = 0; 
    csort(T,P,P_2,I,0,0,pn); //sort (one time)
    while(sortstack >= 0){
        if(nextsort[sortstack][2]<1000){
            bbsort(T,P,P_2,I,nextsort[sortstack][0],nextsort[sortstack][1],nextsort[sortstack][2]);
        }
        else{
            csort(T,P,P_2,I,nextsort[sortstack][0],nextsort[sortstack][1],nextsort[sortstack][2]);
        }
    }
    free(nextsort);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0xb71b00, %edi         # imm = 0xB71B00
callq 0x2160
movq %rax, 0x3955(%rip)      # 0x6168
movl $0x0, 0x3953(%rip)      # 0x6170
movl %ebp, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x246c
movl 0x3933(%rip), %eax      # 0x6170
testl %eax, %eax
js 0x2889
movq 0x3920(%rip), %rcx      # 0x6168
movl %eax, %eax
leaq (%rax,%rax,2), %rdx
movl 0x8(%rcx,%rdx,4), %eax
movl (%rcx,%rdx,4), %r8d
movl 0x4(%rcx,%rdx,4), %r9d
cmpl $0x3e7, %eax            # imm = 0x3E7
jg 0x2878
movl %eax, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x236c
jmp 0x2837
movl %eax, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
jmp 0x2832
movq 0x38d8(%rip), %rdi      # 0x6168
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: makedic(unsigned int*, int*, int*, int*, unsigned int*, unsigned int*, int*, int*, int)
void makedic(unsigned int *T,int *P,int *P_2,int *K,unsigned int *NS,unsigned int *D,int *D_2,int *D_3,int f){ 
    //make dictionary
    printf("\nf = %d / dcs[%d]=%d dc2s[%d] = %d\n",f,f+1,dcs[f+1],f+1,dc2s[f+1]);
    int t = 0; //the number of the kind of different purse
    int starti = dc2s[f];
    int starts = dcs[f]; 
    int s = starts;
    if(DEBUGFLAG==1){printf("\n%d,%d,%d",dc2s[f+1],dcs[f+1],starts);}
    for(int i = starti;i<=dc2s[f+1];i++){ //t = dc2s[f+1]
        int a = 0;
        D_3[i] = 0;
        D_2[i] = s;
        if(DEBUGFLAG==1){printf("\n[%d]",i);}
        while(a<P_2[K[t]]){
            D[s] = T[P[K[t]]+a];
            if(DEBUGFLAG==1){printf("%x ",D[s]);}
            if(f>0){D_3[i]+= D_3[dc2s[f-1]+T[P[K[t]]+a]];}
            if(f==0){D_3[i]++;}
            s++;
            a++;
        }
        if(DEBUGFLAG==1){printf(" / %d:%d:%d /",i,D_2[i],D_3[i]);}
        t++;
    }
    dc2s[f+1]++;
    D_2[dc2s[f+1]] = s;
    printf("\ns = %d, t = %d, dc2s[f+1] = %d\n",s,t,dc2s[f+1]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %rcx, %r15
movq %rdx, 0x18(%rsp)
movq %rsi, %r13
movq %rdi, %rbp
movslq 0x70(%rsp), %r14
movq 0x68(%rsp), %r12
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x1(%r14), %rax
movq %rax, 0x10(%rsp)
leal 0x1(%r14), %edx
leaq 0x3896(%rip), %rax      # 0x6180
movl 0x4(%rax,%r14,4), %ecx
leaq 0x38da(%rip), %rax      # 0x61d0
movl 0x4(%rax,%r14,4), %r9d
leaq 0x1716(%rip), %rdi      # 0x4018
xorl %ebx, %ebx
movl %r14d, %esi
movl %edx, %r8d
xorl %eax, %eax
callq 0x2040
leaq 0x38b8(%rip), %r11      # 0x61d0
movslq (%r11,%r14,4), %rax
leaq 0x385d(%rip), %rcx      # 0x6180
movl (%rcx,%r14,4), %esi
movl 0x4(%r11,%r14,4), %edx
cmpl %edx, %eax
jle 0x293f
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rdi
jmp 0x29e4
leal -0x1(%r14), %ecx
xorl %ebx, %ebx
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %r10
movl $0x0, (%r12,%rax,4)
movl %esi, (%rdi,%rax,4)
movslq (%r15,%rbx,4), %r8
movq 0x18(%rsp), %rdx
cmpl $0x0, (%rdx,%r8,4)
jle 0x29c8
movslq %esi, %rdx
movq 0x20(%rsp), %rdi
leaq (%rdi,%rdx,4), %rdi
xorl %edx, %edx
movslq (%r13,%r8,4), %r8
addq %rdx, %r8
movl (%rbp,%r8,4), %r8d
movl %r8d, (%rdi,%rdx,4)
testl %r14d, %r14d
jle 0x29b0
movslq (%r15,%rbx,4), %r8
movslq (%r13,%r8,4), %r8
addq %rdx, %r8
movl (%rbp,%r8,4), %r8d
addl (%r11,%rcx,4), %r8d
movl (%r12,%r8,4), %r8d
addl %r8d, (%r12,%rax,4)
testl %r14d, %r14d
jne 0x29b9
incl (%r12,%rax,4)
movslq (%r15,%rbx,4), %r8
incq %rdx
cmpl (%r10,%r8,4), %edx
jl 0x297d
addl %edx, %esi
incq %rbx
leaq 0x1(%rax), %rdi
movslq (%r11,%r9,4), %rdx
cmpq %rdx, %rax
movq %rdi, %rax
movq 0x8(%rsp), %rdi
jl 0x2954
leal 0x1(%rdx), %eax
movl %eax, (%r11,%r9,4)
movslq %edx, %rax
movl %esi, 0x4(%rdi,%rax,4)
movl (%r11,%r9,4), %ecx
leaq 0x163f(%rip), %rdi      # 0x403c
movl %ebx, %edx
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: grammarmake(unsigned int*, int*, int*, int*, unsigned int*, int*, int)
int grammarmake(unsigned int *T,int *P,int *P_2,int *I,unsigned int *NS,int *K,int pn){ //文法を表示し，文法の総数tを返す．
    int t = -1; 
    for(int i = 0; i < pn; i++){ //check all purse in lexiorder
        int k = purselcp(T,P,P_2,I,i);
        if(k != P_2[I[i]]){
            codeA += P_2[I[i]];
            codeB += P_2[I[i]] - k;
            t++;
            K[t] = I[i]; //K[t] = t-th smallest purse in current round
        }
        NS[I[i]] = t; //transform T and put it into NS
    }
    printf("\nthe kind of all purse = %d",t+1);
    printf("\nsum of length of rightside characters = %d",codeA);
    printf("\n(when Front Encoding = %d)\n",codeB);
    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x30(%rsp), %eax
testl %eax, %eax
jle 0x2ac5
movl %eax, %eax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
movl $0x0, %r11d
testq %r10, %r10
je 0x2a7d
movslq -0x4(%rcx,%r10,4), %r15
movl (%rdx,%r15,4), %r14d
movl $0x0, %r11d
testl %r14d, %r14d
jle 0x2a7d
movslq (%rsi,%r15,4), %r11
movslq (%rcx,%r10,4), %r15
movslq (%rsi,%r15,4), %r15
leaq (%rdi,%r15,4), %r15
leaq (%rdi,%r11,4), %r12
xorl %r11d, %r11d
movl (%r12,%r11,4), %ebp
cmpl (%r15,%r11,4), %ebp
jne 0x2a7d
incq %r11
cmpq %r11, %r14
jne 0x2a68
movl %r14d, %r11d
movslq (%rcx,%r10,4), %r14
movl (%rdx,%r14,4), %ebp
cmpl %ebp, %r11d
je 0x2aaf
addl %ebp, 0x36e4(%rip)      # 0x6174
movslq (%rcx,%r10,4), %r14
movl (%rdx,%r14,4), %ebp
subl %r11d, %ebp
addl %ebp, 0x36d7(%rip)      # 0x6178
movl (%rcx,%r10,4), %r11d
movslq %ebx, %r14
incl %ebx
movl %r11d, 0x4(%r9,%r14,4)
movslq (%rcx,%r10,4), %r11
movl %ebx, (%r8,%r11,4)
incq %r10
cmpq %rax, %r10
jne 0x2a32
jmp 0x2aca
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leal 0x1(%rbx), %esi
leaq 0x1589(%rip), %rdi      # 0x405d
xorl %eax, %eax
callq 0x2040
movl 0x3693(%rip), %esi      # 0x6174
leaq 0x1591(%rip), %rdi      # 0x4079
xorl %eax, %eax
callq 0x2040
movl 0x3683(%rip), %esi      # 0x6178
leaq 0x15a9(%rip), %rdi      # 0x40a5
xorl %eax, %eax
callq 0x2040
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: write6(unsigned int*, int*, int*, unsigned int*, int)
int write6(unsigned int *D,int *D_2,int *D_3,unsigned int *NS,int NSsize){
    FILE *fp;
    //unsigned char chr;
    //unsigned int a;
    fp = fopen(wname, "w"); // open file or return null
    fwrite(&loops, sizeof(int),1, fp); //0:loops
    fwrite(&dcs[1], sizeof(int), loops, fp); //1:dcs[1][2][3]...
    fwrite(&dc2s[1], sizeof(int), loops, fp); //2:dc2s
    fwrite(D, sizeof(unsigned int), dcs[loops], fp); //3:D
    fwrite(D_2, sizeof(unsigned int), dc2s[loops]+1, fp); //4:D_2
    fwrite(D_3, sizeof(unsigned int), dc2s[loops], fp); //5:D_3
    fwrite(&NSsize, sizeof(int),1, fp); //6:NSsize
    fwrite(NS, sizeof(unsigned int),NSsize, fp); //7:NS
    fclose(fp); // open file or return null
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0xc(%rsp), %rax
movl %r8d, (%rax)
movq 0x3627(%rip), %rdi      # 0x6160
leaq 0x1582(%rip), %rsi      # 0x40c2
callq 0x2130
movq %rax, %r14
leaq 0x35dd(%rip), %rdi      # 0x612c
movl $0x4, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x21f0
movslq 0x35c4(%rip), %rdx      # 0x612c
leaq 0x3615(%rip), %rdi      # 0x6184
movl $0x4, %esi
movq %r14, %rcx
callq 0x21f0
leaq 0x35fd(%rip), %rbx      # 0x6180
movslq 0x35a2(%rip), %rdx      # 0x612c
leaq 0x3643(%rip), %rdi      # 0x61d4
movl $0x4, %esi
movq %r14, %rcx
callq 0x21f0
leaq 0x362b(%rip), %r15      # 0x61d0
movslq 0x3580(%rip), %rax      # 0x612c
movslq (%rbx,%rax,4), %rdx
movl $0x4, %esi
movq %rbp, %rdi
movq %r14, %rcx
callq 0x21f0
movslq 0x3565(%rip), %rax      # 0x612c
movslq (%r15,%rax,4), %rdx
incq %rdx
movl $0x4, %esi
movq %r13, %rdi
movq %r14, %rcx
callq 0x21f0
movslq 0x3547(%rip), %rax      # 0x612c
movslq (%r15,%rax,4), %rdx
movl $0x4, %esi
movq %r12, %rdi
movq %r14, %rcx
callq 0x21f0
movl $0x4, %esi
movl $0x1, %edx
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x21f0
movslq (%rbx), %rdx
movl $0x4, %esi
movq 0x10(%rsp), %rdi
movq %r14, %rcx
callq 0x21f0
movq %r14, %rdi
callq 0x2100
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_nep_build.cpp
// Function: shelp()
int shelp(){
    printf("--Simple Usage------------------\n");
    printf("\nRead <file> and make <indexfile>. \n");
    printf(": ./gcis_nep_build -i <file>\n");
    printf("\nYou can set the name of output by using option -o. \n");
    printf(": ./gcis_nep_build -i <file> -o <outputfile>\n");
    printf("\n");
    printf("\n");
    return 0;
}

// Assembly:
pushq %rax
leaq 0x15a2(%rip), %rdi      # 0x41eb
callq 0x21a0
leaq 0x15b7(%rip), %rdi      # 0x420c
callq 0x21a0
leaq 0x15cf(%rip), %rdi      # 0x4230
callq 0x21a0
leaq 0x15e0(%rip), %rdi      # 0x424d
callq 0x21a0
leaq 0x1609(%rip), %rdi      # 0x4282
callq 0x21a0
movl $0xa, %edi
callq 0x2180
movl $0xa, %edi
callq 0x2180
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/characters/enemies/goblin/Goblin.cpp
// Function: Goblin::Goblin()
Goblin::Goblin():Enemy(e_enemy_goblin, 20, "Goblin", 25, 10, 10, 10, 60, 0)
{
    skills[0] = e_move_attack;
    skills[1] = e_move_attack;
    skills[2] = e_move_attack;
    skills[3] = e_move_poison;
    uses = {10, 10, 10 ,10};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x75f4(%rip), %rsi      # 0xb0b6
leaq 0x75f3(%rip), %rdx      # 0xb0bc
movq %rsp, %r14
movq %r14, %rdi
callq 0x3bd8
movl $0xa, %eax
movq %rbx, %rdi
movl $0x1, %esi
movl $0x14, %edx
movq %r14, %rcx
movl $0x19, %r8d
movl $0xa, %r9d
pushq $0x0
pushq $0x3c
pushq %rax
pushq %rax
callq 0x3854
addq $0x20, %rsp
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3b1a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3120
leaq 0xcb77(%rip), %rax      # 0x10698
movq %rax, (%rbx)
movaps 0x7535(%rip), %xmm0     # 0xb060
movups %xmm0, 0x1c(%rbx)
movaps 0x753a(%rip), %xmm0     # 0xb070
movups %xmm0, 0x2c(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3b5d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3120
movq %rbx, %rdi
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/characters/enemies/orc/Orc.cpp
// Function: Orc::Orc()
Orc::Orc():Enemy(e_enemy_orc, 40, "Orc", 50, 15, 10, 5, 20, 0)
{
    skills[0] = e_move_attack;
    skills[1] = e_move_attack;
    skills[2] = e_move_throw;
    skills[3] = e_move_power_attack;
    uses = {10, 10, 10 ,10};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7398(%rip), %rsi      # 0xb0fe
leaq 0x7394(%rip), %rdx      # 0xb101
movq %rsp, %r14
movq %r14, %rdi
callq 0x3bd8
movq %rbx, %rdi
xorl %esi, %esi
movl $0x28, %edx
movq %r14, %rcx
movl $0x32, %r8d
movl $0xf, %r9d
pushq $0x0
pushq $0x14
pushq $0x5
pushq $0xa
callq 0x3854
addq $0x20, %rsp
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3db8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3120
leaq 0xc919(%rip), %rax      # 0x106d8
movq %rax, (%rbx)
movaps 0x7307(%rip), %xmm0     # 0xb0d0
movups %xmm0, 0x1c(%rbx)
movaps 0x729c(%rip), %xmm0     # 0xb070
movups %xmm0, 0x2c(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3dfb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3120
movq %rbx, %rdi
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/characters/enemies/warlock/Warlock.cpp
// Function: Warlock::Warlock()
Warlock::Warlock():Enemy(e_enemy_warlock, 60, "Warlock", 100, 5, 10, 15, 40, 0)
{
    skills[0] = e_move_attack;
    skills[1] = e_move_attack;
    skills[2] = e_move_heal;
    skills[3] = e_move_firebolt;
    uses = {10, 10, 10, 10};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x71d1(%rip), %rsi      # 0xb153
leaq 0x71d1(%rip), %rdx      # 0xb15a
movq %rsp, %r14
movq %r14, %rdi
callq 0x3bd8
movq %rbx, %rdi
movl $0x2, %esi
movl $0x3c, %edx
movq %r14, %rcx
movl $0x64, %r8d
movl $0x5, %r9d
pushq $0x0
pushq $0x28
pushq $0xf
pushq $0xa
callq 0x3854
addq $0x20, %rsp
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3fd7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3120
leaq 0xc73a(%rip), %rax      # 0x10718
movq %rax, (%rbx)
movaps 0x7138(%rip), %xmm0     # 0xb120
movups %xmm0, 0x1c(%rbx)
movaps 0x707d(%rip), %xmm0     # 0xb070
movups %xmm0, 0x2c(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x401a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3120
movq %rbx, %rdi
callq 0x31c0
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/characters/players/warrior/Warrior.cpp
// Function: Warrior::Warrior()
Warrior::Warrior() :Player(e_player_warrior,    //ID
                           "Warrior",           //NAME
                           100,                 //HP
                           15,                  //STRENGTH
                           10,                  //AGILITY
                           5)                   //INTELLIGENCE
{
    skills[0] = e_move_attack;
    skills[1] = e_move_power_attack;
    skills[2] = e_move_bash;
    skills[3] = e_move_heal;
    uses = {10, 10, 10 ,10};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6e40(%rip), %rsi      # 0xb10a
leaq 0x6e40(%rip), %rdx      # 0xb111
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3bd8
movl $0x5, (%rsp)
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
movl $0x64, %ecx
movl $0xf, %r8d
movl $0xa, %r9d
callq 0x40f0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x431d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3120
leaq 0xc474(%rip), %rax      # 0x10798
movq %rax, (%rbx)
movaps 0x6e52(%rip), %xmm0     # 0xb180
movups %xmm0, 0x1c(%rbx)
movaps 0x6d37(%rip), %xmm0     # 0xb070
movups %xmm0, 0x2c(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4361
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3120
movq %rbx, %rdi
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/characters/players/rogue/Rogue.cpp
// Function: Rogue::Rogue()
Rogue::Rogue() :Player(e_player_rogue,    //ID
                       "Rogue",           //NAME
                       100,               //HP
                       10,                //STRENGTH
                       10,                //AGILITY
                       10)                //INTELLIGENCE
{
    skills[0] = e_move_attack;
    skills[1] = e_move_throw;
    skills[2] = e_move_poison;
    skills[3] = e_move_heal;
    uses = {10, 10, 10 ,10};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6d29(%rip), %rsi      # 0xb203
leaq 0x6d27(%rip), %rdx      # 0xb208
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3bd8
movl $0xa, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
movl $0x64, %ecx
movl $0xa, %r8d
movl $0xa, %r9d
callq 0x40f0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x452d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3120
leaq 0xc2a4(%rip), %rax      # 0x107d8
movq %rax, (%rbx)
movaps 0x6c92(%rip), %xmm0     # 0xb1d0
movups %xmm0, 0x1c(%rbx)
movaps 0x6b27(%rip), %xmm0     # 0xb070
movups %xmm0, 0x2c(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4571
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3120
movq %rbx, %rdi
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/characters/players/mage/Mage.cpp
// Function: Mage::Mage()
Mage::Mage() :Player(e_player_mage,    //ID
                     "Mage",           //NAME
                     100,              //HP
                     5,                //STRENGTH
                     10,               //AGILITY
                     15)               //INTELLIGENCE
{
    skills[0] = e_move_attack;
    skills[1] = e_move_heal;
    skills[2] = e_move_firebolt;
    skills[3] = e_move_frost_nova;
    uses = {10, 10, 10 ,10};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6b5a(%rip), %rsi      # 0xb250
leaq 0x6b57(%rip), %rdx      # 0xb254
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3bd8
movl $0xf, (%rsp)
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rdx
movl $0x64, %ecx
movl $0x5, %r8d
movl $0xa, %r9d
callq 0x40f0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4749
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3120
leaq 0xc0c8(%rip), %rax      # 0x10818
movq %rax, (%rbx)
movaps 0x6ab6(%rip), %xmm0     # 0xb210
movups %xmm0, 0x1c(%rbx)
movaps 0x690b(%rip), %xmm0     # 0xb070
movups %xmm0, 0x2c(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x478d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3120
movq %rbx, %rdi
callq 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/factory/Factory.cpp
// Function: Factory::createPlayer(int)
std::shared_ptr<Player> Factory::createPlayer(int type)
{
    switch(type)
    {
        case e_player_warrior:
            return std::make_shared<Warrior>();
        case e_player_rogue:
            return std::make_shared<Rogue>();
        case e_player_mage:
            return std::make_shared<Mage>();
        default:
            return nullptr;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x3, %esi
je 0x4881
cmpl $0x2, %esi
je 0x4861
cmpl $0x1, %esi
jne 0x48b7
xorl %r15d, %r15d
leaq 0x18(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x496e
jmp 0x489f
xorl %r15d, %r15d
leaq 0x18(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x4a48
jmp 0x489f
xorl %r15d, %r15d
leaq 0x18(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x4b1a
movq (%r14), %rax
movq %rax, (%rbx)
movq %r15, 0x8(%rbx)
movq 0x8(%r14), %rax
movq %r15, 0x8(%r14)
movq %rax, 0x8(%rbx)
jmp 0x48bd
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/factory/Factory.cpp
// Function: Factory::createEnemy(int)
std::shared_ptr<Enemy> Factory::createEnemy(int type)
{
    switch(type)
    {
        case e_enemy_orc:
            return std::make_shared<Orc>();
        case e_enemy_goblin:
            return std::make_shared<Goblin>();
        case e_enemy_warlock:
            return std::make_shared<Warlock>();
        default:
            return nullptr;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x4924
cmpl $0x1, %esi
je 0x4904
testl %esi, %esi
jne 0x495a
xorl %r15d, %r15d
leaq 0x18(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x4bec
jmp 0x4942
xorl %r15d, %r15d
leaq 0x18(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x4cbe
jmp 0x4942
xorl %r15d, %r15d
leaq 0x18(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x4d90
movq (%r14), %rax
movq %rax, (%rbx)
movq %r15, 0x8(%rbx)
movq 0x8(%r14), %rax
movq %r15, 0x8(%r14)
movq %rax, 0x8(%rbx)
jmp 0x4960
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/game/battle/Battle.cpp
// Function: Battle::levelupPlayer(std::shared_ptr<Player>&)
void Battle::levelupPlayer(std::shared_ptr<Player> &player)
{
    player->level++;
    player->level_points=+5;

    player->hitpoints+=5;
    player->max_hitpoints+=5;

    player->strength+=1;
    player->agility+=1;
    player->intelligence+=1;

    std::cout << "  !LEVEL UP!\n"
              << "  hitpoints "     << player->max_hitpoints << "\n"
              << "  strength "      << player->strength << "\n"
              << "  agility "       << player->agility << "\n"
              << "  intelligence "  << player->intelligence << "\n"
              << "  level points "  << player->level_points << "\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
incl 0x88(%rax)
movl $0x5, 0x90(%rax)
addl $0x5, 0x8(%rax)
addl $0x5, 0xc(%rax)
incl 0x10(%rax)
incl 0x14(%rax)
incl 0x18(%rax)
movq 0xc139(%rip), %r14      # 0x10fd0
leaq 0x65fa(%rip), %rsi      # 0xb498
movl $0xd, %edx
movq %r14, %rdi
callq 0x3140
leaq 0x65f4(%rip), %rsi      # 0xb4a6
movl $0xc, %edx
movq %r14, %rdi
callq 0x3140
movq (%rbx), %rax
movl 0xc(%rax), %esi
movq %r14, %rdi
callq 0x31b0
movq %rax, %r15
leaq 0x679f(%rip), %r14      # 0xb676
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3140
leaq 0x65c5(%rip), %rsi      # 0xb4b3
movl $0xb, %edx
movq %r15, %rdi
callq 0x3140
movq (%rbx), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x31b0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3140
leaq 0x659c(%rip), %rsi      # 0xb4bf
movl $0xa, %edx
movq %r15, %rdi
callq 0x3140
movq (%rbx), %rax
movl 0x14(%rax), %esi
movq %r15, %rdi
callq 0x31b0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3140
leaq 0x6572(%rip), %rsi      # 0xb4ca
movl $0xf, %edx
movq %r15, %rdi
callq 0x3140
movq (%rbx), %rax
movl 0x18(%rax), %esi
movq %r15, %rdi
callq 0x31b0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3140
leaq 0x654d(%rip), %rsi      # 0xb4da
movl $0xf, %edx
movq %r15, %rdi
callq 0x3140
movq (%rbx), %rax
movl 0x90(%rax), %esi
movq %r15, %rdi
callq 0x31b0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3140
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/game/battle/Battle.cpp
// Function: Battle::endBattle(std::shared_ptr<Player>&, std::shared_ptr<Enemy>&)
void Battle::endBattle(std::shared_ptr<Player> &player,
                       std::shared_ptr<Enemy> &enemy)
{
    if (player->hitpoints >= 0)
    {
        player->win++;
        std::cout << "\n [ You win! ] \n"
                  << " Experience: +"
                  << enemy->get_exp << '\n'
                  << " Gold: +"
                  << enemy->gold
                  << "\n";
        player->gold += enemy->gold;
        player->experience += enemy->get_exp;
        if(player->experience >= player->level*100)
            levelupPlayer (player);
    }
    else
    {
        std::cout << "\n [ You lose! ] \n";
        player->lost++;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
cmpl $0x0, 0x8(%rax)
js 0x50a3
movq %rsi, %r14
incl 0x94(%rax)
movq 0xbfe7(%rip), %r15      # 0x10fd0
leaq 0x64fa(%rip), %rsi      # 0xb4ea
movl $0x10, %edx
movq %r15, %rdi
callq 0x3140
leaq 0x64f7(%rip), %rsi      # 0xb4fb
movl $0xe, %edx
movq %r15, %rdi
callq 0x3140
movq (%r14), %rax
movl 0x88(%rax), %esi
movq %r15, %rdi
callq 0x31b0
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3140
movq %rax, %r15
leaq 0x64c9(%rip), %rsi      # 0xb50a
movl $0x8, %edx
movq %rax, %rdi
callq 0x3140
movq (%r14), %rax
movl 0x3c(%rax), %esi
movq %r15, %rdi
callq 0x31b0
leaq 0x6613(%rip), %rsi      # 0xb676
movl $0x1, %edx
movq %rax, %rdi
callq 0x3140
movq (%r14), %rax
movl 0x3c(%rax), %ecx
movq (%rbx), %rdx
addl %ecx, 0x3c(%rdx)
movl 0x8c(%rdx), %ecx
addl 0x88(%rax), %ecx
movl %ecx, 0x8c(%rdx)
imull $0x64, 0x88(%rdx), %eax
cmpl %eax, %ecx
jl 0x50c4
movq %rbx, %rdi
callq 0x4e64
jmp 0x50c4
movq 0xbf26(%rip), %rdi      # 0x10fd0
leaq 0x6462(%rip), %rsi      # 0xb513
movl $0x11, %edx
callq 0x3140
movq (%rbx), %rax
incl 0x98(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rozpo[P]enemy/data/game/battle/Battle.cpp
// Function: Battle::printBattle(std::shared_ptr<Player> const&, std::shared_ptr<Enemy> const&)
void Battle::printBattle(const std::shared_ptr<Player> &player, const std::shared_ptr<Enemy> &enemy)
{
    std::cout << "------------------------------------" << '\n';
    std::cout << enemy->name << '\n';
    std::cout << enemy->hitpoints << "|" << enemy->max_hitpoints << '\n';
    enemy->printCharacter ();
    std::cout << '\n';
    std::cout << '\n';
    player->printCharacter ();
    std::cout << player->name << '\n';
    std::cout << player->hitpoints << "|" << player->max_hitpoints << '\n';
    std::cout << "-------------" << '\n';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movq 0xbd5a(%rip), %rbx      # 0x10fd0
leaq 0x62c5(%rip), %rsi      # 0xb542
movl $0x24, %edx
movq %rbx, %rdi
callq 0x3140
movb $0xa, %bpl
movq %rsp, %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3140
movq (%r12), %rax
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
movq %rbx, %rdi
callq 0x3140
leaq 0x1(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3140
movq (%r12), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
callq 0x31b0
movq %rax, %r13
leaq 0x5f17(%rip), %r15      # 0xb1f9
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3140
movq (%r12), %rax
movl 0xc(%rax), %esi
movq %r13, %rdi
callq 0x31b0
leaq 0x2(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3140
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x3(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3140
leaq 0x4(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3140
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r14), %rax
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
movq %rbx, %rdi
callq 0x3140
leaq 0x5(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3140
movq (%r14), %rax
movl 0x8(%rax), %esi
movq %rbx, %rdi
callq 0x31b0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3140
movq (%r14), %rax
movl 0xc(%rax), %esi
movq %r12, %rdi
callq 0x31b0
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3140
leaq 0x6193(%rip), %rsi      # 0xb559
movl $0xd, %edx
movq %rbx, %rdi
callq 0x3140
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop