LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: RenderImagesWithGlut(char const*)
static int
RenderImagesWithGlut(const char *output_image_directory)
{
#ifdef USE_GLUT
  // Print message
  if (print_verbose) {
    printf("Rendering images with glut to %s\n", output_image_directory);
    fflush(stdout);
  }

  // Create output directory
  char cmd[1024];
  sprintf(cmd, "mkdir -p %s", output_image_directory);
  system(cmd);

  // Open window
  int argc = 1;
  char *argv[1];
  argv[0] = RNStrdup("scn2img");
  glutInit(&argc, argv);
  glutInitWindowPosition(100, 100);
  glutInitWindowSize(width, height);
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH | GLUT_MULTISAMPLE); 
  glutCreateWindow("Scene Image Capture");

  // Initialize grfx (after create context because calls glewInit)
  RNInitGrfx();

  // Initialize multisampling
  glEnable(GL_MULTISAMPLE);
  
  // Initialize GLUT callback functions 
  glutDisplayFunc(Redraw);

  // Run main loop  -- never returns 
  glutMainLoop();

  // Return success -- actually never gets here
  return 1;
#else
  // Not supported
  RNAbort("Program was not compiled with glut.  Recompile with make.\n");
  return 0;
#endif
}

// Assembly:
subq $0x418, %rsp            # imm = 0x418
movq %rdi, 0x410(%rsp)
cmpl $0x0, 0x1f10e6(%rip)    # 0x21ebdc
je 0x2db1d
movq 0x410(%rsp), %rsi
leaq 0x17fcbd(%rip), %rdi    # 0x1ad7c4
movb $0x0, %al
callq 0x23090
movq 0x1ea47b(%rip), %rax    # 0x217f90
movq (%rax), %rdi
callq 0x23bd0
leaq 0x10(%rsp), %rdi
movq 0x410(%rsp), %rdx
leaq 0x17fcb5(%rip), %rsi    # 0x1ad7e6
movb $0x0, %al
callq 0x23150
leaq 0x10(%rsp), %rdi
callq 0x23830
movl $0x1, 0xc(%rsp)
leaq 0x17fca1(%rip), %rdi    # 0x1ad7f2
callq 0x112da0
movq %rax, (%rsp)
movq %rsp, %rsi
leaq 0xc(%rsp), %rdi
callq 0x19a790
movl $0x64, %esi
movl %esi, %edi
callq 0x19af10
movl 0x1eaf37(%rip), %edi    # 0x218ab0
movl 0x1eaf35(%rip), %esi    # 0x218ab4
callq 0x19af50
movl $0x90, %edi
callq 0x19af90
leaq 0x17fc65(%rip), %rdi    # 0x1ad7fa
callq 0x1a37b0
callq 0x10e2a0
movl $0x809d, %edi           # imm = 0x809D
callq 0x238e0
leaq -0x5bc0(%rip), %rdi     # 0x27ff0
callq 0x198730
callq 0x19e590
movl $0x1, %eax
addq $0x418, %rsp            # imm = 0x418
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: RenderImagesWithRaycasting(char const*)
static int
RenderImagesWithRaycasting(const char *output_image_directory)
{
  // Statistics variables
  static RNTime start_time;
  start_time.Read(); 
  if (print_verbose) {
    printf("Rendering images with RAYCASTING to %s\n", output_image_directory);
    fflush(stdout);
  }
  
  // Create output directory
  char cmd[1024];
  sprintf(cmd, "mkdir -p %s", output_image_directory);
  system(cmd);

  // Raycast images for every camera
  for (int i = 0; i < cameras.NEntries(); i++) {
    R3Camera *camera = cameras.Kth(i);
    if (!RenderImagesWithRaycasting(*camera, scene, output_image_directory, i)) return 0;
  }

  // Print message
  if (print_verbose) {
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Images = %d\n", cameras.NEntries());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x448, %rsp            # imm = 0x448
movq %rdi, 0x438(%rsp)
cmpb $0x0, 0x1f1112(%rip)    # 0x21ed18
jne 0x2dc33
leaq 0x1f1109(%rip), %rdi    # 0x21ed18
callq 0x242f0
cmpl $0x0, %eax
je 0x2dc33
leaq 0x1f10e8(%rip), %rdi    # 0x21ed08
callq 0x10e120
jmp 0x2dc27
leaq 0x1f10ea(%rip), %rdi    # 0x21ed18
callq 0x23650
leaq 0x1f10ce(%rip), %rdi    # 0x21ed08
callq 0x2ed70
cmpl $0x0, 0x1f0f96(%rip)    # 0x21ebdc
je 0x2dc94
movq 0x438(%rsp), %rsi
leaq 0x17fbf7(%rip), %rdi    # 0x1ad84e
movb $0x0, %al
callq 0x23090
movq 0x1ea32b(%rip), %rax    # 0x217f90
movq (%rax), %rdi
callq 0x23bd0
jmp 0x2dc94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x430(%rsp)
movl %eax, 0x42c(%rsp)
leaq 0x1f108e(%rip), %rdi    # 0x21ed18
callq 0x23630
jmp 0x2dd9a
leaq 0x20(%rsp), %rdi
movq 0x438(%rsp), %rdx
leaq 0x17fb3e(%rip), %rsi    # 0x1ad7e6
movb $0x0, %al
callq 0x23150
leaq 0x20(%rsp), %rdi
callq 0x23830
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x1f0ed8(%rip), %rdi    # 0x21eba8
callq 0x2ed90
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2dd32
movl 0x1c(%rsp), %esi
leaq 0x1f0ebe(%rip), %rdi    # 0x21eba8
callq 0x2eda0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x1f0eb8(%rip), %rsi    # 0x21ebb8
movq 0x438(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq 0x2ddb0
cmpl $0x0, %eax
jne 0x2dd23
movl $0x0, 0x444(%rsp)
jmp 0x2dd8b
jmp 0x2dd25
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2dcc1
cmpl $0x0, 0x1f0ea3(%rip)    # 0x21ebdc
je 0x2dd80
leaq 0x1f0fc6(%rip), %rdi    # 0x21ed08
callq 0x10e1e0
leaq 0x17f382(%rip), %rdi    # 0x1ad0d0
movb $0x1, %al
callq 0x23090
leaq 0x1f0e4c(%rip), %rdi    # 0x21eba8
callq 0x2ed90
movl %eax, %esi
leaq 0x17f37d(%rip), %rdi    # 0x1ad0e7
movb $0x0, %al
callq 0x23090
movq 0x1ea218(%rip), %rax    # 0x217f90
movq (%rax), %rdi
callq 0x23bd0
movl $0x1, 0x444(%rsp)
movl 0x444(%rsp), %eax
addq $0x448, %rsp            # imm = 0x448
retq
movq 0x430(%rsp), %rdi
callq 0x24270
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
jge 0x237a
movl $0x0, -0x4(%rbp)
jmp 0x23fa
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %esi
subl $0x1, %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x23f4
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %esi
subl $0x1, %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rsi
movslq -0x2c(%rbp), %rdi
movslq (%rsi,%rdi,4), %rsi
movl (%rdx,%rsi,4), %edx
addl -0x30(%rbp), %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x23f0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x23f2
jmp 0x23f4
jmp 0x2381
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0xb71b00, %edi         # imm = 0xB71B00
callq 0x2180
movq %rax, 0x463b(%rip)      # 0x7178
movl $0x0, 0x4639(%rip)      # 0x7180
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
xorl %r9d, %r9d
movl %r9d, %r8d
movl %eax, (%rsp)
callq 0x2620
cmpl $0x0, 0x4611(%rip)      # 0x7180
jl 0x2c5c
movq 0x45fc(%rip), %rax      # 0x7178
movslq 0x45fd(%rip), %rcx      # 0x7180
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x3e8, 0x8(%rax)       # imm = 0x3E8
jge 0x2bf6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq 0x45ce(%rip), %rax      # 0x7178
movslq 0x45cf(%rip), %r8       # 0x7180
imulq $0xc, %r8, %r8
addq %r8, %rax
movl (%rax), %r8d
movq 0x45b6(%rip), %rax      # 0x7178
movslq 0x45b7(%rip), %r9       # 0x7180
imulq $0xc, %r9, %r9
addq %r9, %rax
movl 0x4(%rax), %r9d
movq 0x459d(%rip), %rax      # 0x7178
movslq 0x459e(%rip), %r10      # 0x7180
imulq $0xc, %r10, %r10
addq %r10, %rax
movl 0x8(%rax), %eax
movl %eax, (%rsp)
callq 0x2400
jmp 0x2c57
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq 0x456b(%rip), %rax      # 0x7178
movslq 0x456c(%rip), %r8       # 0x7180
imulq $0xc, %r8, %r8
addq %r8, %rax
movl (%rax), %r8d
movq 0x4553(%rip), %rax      # 0x7178
movslq 0x4554(%rip), %r9       # 0x7180
imulq $0xc, %r9, %r9
addq %r9, %rax
movl 0x4(%rax), %r9d
movq 0x453a(%rip), %rax      # 0x7178
movslq 0x453b(%rip), %r10      # 0x7180
imulq $0xc, %r10, %r10
addq %r10, %rax
movl 0x8(%rax), %eax
movl %eax, (%rsp)
callq 0x2620
jmp 0x2b68
movq 0x4515(%rip), %rdi      # 0x7178
callq 0x2160
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x2f95
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x38(%rbp), %r8d
callq 0x2350
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
movslq -0x38(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x2f71
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x38(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
addl 0x425a(%rip), %eax      # 0x7184
movl %eax, 0x4254(%rip)      # 0x7184
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x38(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
subl -0x3c(%rbp), %eax
addl 0x423c(%rip), %eax      # 0x7188
movl %eax, 0x4236(%rip)      # 0x7188
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x34(%rbp), %edx
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x38(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2ed1
movl -0x34(%rbp), %esi
addl $0x1, %esi
leaq 0x20bb(%rip), %rdi      # 0x505d
movb $0x0, %al
callq 0x2030
movl 0x41d5(%rip), %esi      # 0x7184
leaq 0x20c3(%rip), %rdi      # 0x5079
movb $0x0, %al
callq 0x2030
movl 0x41c5(%rip), %esi      # 0x7188
leaq 0x20db(%rip), %rdi      # 0x50a5
movb $0x0, %al
callq 0x2030
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq 0x416d(%rip), %rdi      # 0x7170
leaq 0x20b8(%rip), %rsi      # 0x50c2
callq 0x2150
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
leaq 0x411e(%rip), %rdi      # 0x713c
movl $0x4, %esi
movl $0x1, %edx
callq 0x2200
movslq 0x4108(%rip), %rdx      # 0x713c
movq -0x30(%rbp), %rcx
leaq 0x4151(%rip), %rdi      # 0x7190
addq $0x4, %rdi
movl $0x4, %esi
callq 0x2200
movslq 0x40e8(%rip), %rdx      # 0x713c
movq -0x30(%rbp), %rcx
leaq 0x4181(%rip), %rdi      # 0x71e0
addq $0x4, %rdi
movl $0x4, %esi
callq 0x2200
movq -0x8(%rbp), %rdi
movslq 0x40c4(%rip), %rcx      # 0x713c
leaq 0x4111(%rip), %rax      # 0x7190
movslq (%rax,%rcx,4), %rdx
movq -0x30(%rbp), %rcx
movl $0x4, %esi
callq 0x2200
movq -0x10(%rbp), %rdi
movslq 0x40a0(%rip), %rcx      # 0x713c
leaq 0x413d(%rip), %rax      # 0x71e0
movl (%rax,%rcx,4), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq -0x30(%rbp), %rcx
movl $0x4, %esi
callq 0x2200
movq -0x18(%rbp), %rdi
movslq 0x4077(%rip), %rcx      # 0x713c
leaq 0x4114(%rip), %rax      # 0x71e0
movslq (%rax,%rcx,4), %rdx
movq -0x30(%rbp), %rcx
movl $0x4, %esi
callq 0x2200
movq -0x30(%rbp), %rcx
leaq -0x24(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2200
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x4, %esi
callq 0x2200
movq -0x30(%rbp), %rdi
callq 0x2120
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
leaq 0x1f99(%rip), %rdi      # 0x50c4
movb $0x0, %al
callq 0x2030
leaq 0x1fad(%rip), %rdi      # 0x50e6
movb $0x0, %al
callq 0x2030
leaq 0x1fc4(%rip), %rdi      # 0x510b
movb $0x0, %al
callq 0x2030
leaq 0x1fd4(%rip), %rdi      # 0x5129
movb $0x0, %al
callq 0x2030
leaq 0x1ffc(%rip), %rdi      # 0x515f
movb $0x0, %al
callq 0x2030
leaq 0x1f98(%rip), %rdi      # 0x5109
movb $0x0, %al
callq 0x2030
leaq 0x1f8a(%rip), %rdi      # 0x5109
movb $0x0, %al
callq 0x2030
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: rozpo[P]enemy/data/characters/enemies/goblin/Goblin.cpp
// Function: Goblin::printCharacter()
void Goblin::printCharacter()
{
    std::cout << "      _" << '\n';
    std::cout << "     \\_/" << '\n';
    std::cout << "   |\\/|\\|" << '\n';
    std::cout << "   \\_\\| |" << '\n';
    std::cout << "     / \\" << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2a32d(%rip), %rdi     # 0x2efd0
leaq 0x1838c(%rip), %rsi     # 0x1d036
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq 0x2a30d(%rip), %rdi     # 0x2efd0
leaq 0x18374(%rip), %rsi     # 0x1d03e
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq 0x2a2ed(%rip), %rdi     # 0x2efd0
leaq 0x1835d(%rip), %rsi     # 0x1d047
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq 0x2a2cd(%rip), %rdi     # 0x2efd0
leaq 0x18347(%rip), %rsi     # 0x1d051
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq 0x2a2ad(%rip), %rdi     # 0x2efd0
leaq 0x18331(%rip), %rsi     # 0x1d05b
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x42f0
movq -0x58(%rbp), %rdx
leaq 0x182ed(%rip), %rsi     # 0x1d06c
leaq -0x28(%rbp), %rdi
callq 0x4f50
jmp 0x4d8a
movq -0x60(%rbp), %rdi
movq %rsp, %rax
movl $0x0, 0x18(%rax)
movl $0x3c, 0x10(%rax)
movl $0xa, 0x8(%rax)
movl $0xa, (%rax)
movl $0x1, %esi
movl $0x14, %edx
leaq -0x28(%rbp), %rcx
movl $0x19, %r8d
movl $0xa, %r9d
callq 0x4bb0
jmp 0x4dcd
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x60(%rbp), %rdi
leaq 0x2988e(%rip), %rax     # 0x2e678
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1c, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x0, (%rax)
addq $0x1c, %rdi
movl $0x1, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x0, (%rax)
addq $0x1c, %rdi
movl $0x2, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x0, (%rax)
addq $0x1c, %rdi
movl $0x3, %esi
callq 0x5000
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl $0x3, (%rcx)
movl $0xa, -0x4c(%rbp)
movl $0xa, -0x48(%rbp)
movl $0xa, -0x44(%rbp)
movl $0xa, -0x40(%rbp)
movq -0x4c(%rbp), %rcx
movq %rcx, 0x2c(%rax)
movq -0x44(%rbp), %rcx
movq %rcx, 0x34(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4eab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x38(%rbp), %rdi
callq 0x42e0
nopl (%rax)
// File: rozpo[P]enemy/data/characters/enemies/orc/Orc.cpp
// Function: Orc::printCharacter()
void Orc::printCharacter()
{
    std::cout << "      _" << '\n';
    std::cout << "     )_(" << '\n';
    std::cout << "   C|/|\\|D" << '\n';
    std::cout << "    | | |" << '\n';
    std::cout << "     / \\" << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x29cdd(%rip), %rdi     # 0x2efd0
leaq 0x17d3c(%rip), %rsi     # 0x1d036
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq 0x29cbd(%rip), %rdi     # 0x2efd0
leaq 0x17d8b(%rip), %rsi     # 0x1d0a5
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq 0x29c9d(%rip), %rdi     # 0x2efd0
leaq 0x17d74(%rip), %rsi     # 0x1d0ae
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq 0x29c7d(%rip), %rdi     # 0x2efd0
leaq 0x17d5f(%rip), %rsi     # 0x1d0b9
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq 0x29c5d(%rip), %rdi     # 0x2efd0
leaq 0x17ce1(%rip), %rsi     # 0x1d05b
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x42f0
movq -0x58(%rbp), %rdx
leaq 0x17cf4(%rip), %rsi     # 0x1d0c3
leaq -0x28(%rbp), %rdi
callq 0x4f50
jmp 0x53da
movq -0x60(%rbp), %rdi
movq %rsp, %rax
movl $0x0, 0x18(%rax)
movl $0x14, 0x10(%rax)
movl $0x5, 0x8(%rax)
movl $0xa, (%rax)
xorl %esi, %esi
movl $0x28, %edx
leaq -0x28(%rbp), %rcx
movl $0x32, %r8d
movl $0xf, %r9d
callq 0x4bb0
jmp 0x541a
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x60(%rbp), %rdi
leaq 0x29281(%rip), %rax     # 0x2e6b8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1c, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x0, (%rax)
addq $0x1c, %rdi
movl $0x1, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x0, (%rax)
addq $0x1c, %rdi
movl $0x2, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x2, (%rax)
addq $0x1c, %rdi
movl $0x3, %esi
callq 0x5000
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl $0x4, (%rcx)
movl $0xa, -0x4c(%rbp)
movl $0xa, -0x48(%rbp)
movl $0xa, -0x44(%rbp)
movl $0xa, -0x40(%rbp)
movq -0x4c(%rbp), %rcx
movq %rcx, 0x2c(%rax)
movq -0x44(%rbp), %rcx
movq %rcx, 0x34(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x54f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x38(%rbp), %rdi
callq 0x42e0
nopw (%rax,%rax)
// File: rozpo[P]enemy/data/characters/enemies/warlock/Warlock.cpp
// Function: Warlock::printCharacter()
void Warlock::printCharacter()
{
    std::cout << "      _" << '\n'
              << "    @(O)" << '\n'
              << "    |/|\\" << '\n'
              << "    | |" << '\n'
              << "    |/ \\" << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x29a1d(%rip), %rdi     # 0x2efd0
leaq 0x17a7c(%rip), %rsi     # 0x1d036
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq %rax, %rdi
leaq 0x17b06(%rip), %rsi     # 0x1d0dc
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq %rax, %rdi
leaq 0x17af3(%rip), %rsi     # 0x1d0e5
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq %rax, %rdi
leaq 0x17b90(%rip), %rsi     # 0x1d19e
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq %rax, %rdi
leaq 0x17ac4(%rip), %rsi     # 0x1d0ee
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x42f0
movq -0x58(%rbp), %rdx
leaq 0x17a80(%rip), %rsi     # 0x1d0ff
leaq -0x28(%rbp), %rdi
callq 0x4f50
jmp 0x568a
movq -0x60(%rbp), %rdi
movq %rsp, %rax
movl $0x0, 0x18(%rax)
movl $0x28, 0x10(%rax)
movl $0xf, 0x8(%rax)
movl $0xa, (%rax)
movl $0x2, %esi
movl $0x3c, %edx
leaq -0x28(%rbp), %rcx
movl $0x64, %r8d
movl $0x5, %r9d
callq 0x4bb0
jmp 0x56cd
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x60(%rbp), %rdi
leaq 0x2900e(%rip), %rax     # 0x2e6f8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1c, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x0, (%rax)
addq $0x1c, %rdi
movl $0x1, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x0, (%rax)
addq $0x1c, %rdi
movl $0x2, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x1, (%rax)
addq $0x1c, %rdi
movl $0x3, %esi
callq 0x5000
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl $0x6, (%rcx)
movl $0xa, -0x4c(%rbp)
movl $0xa, -0x48(%rbp)
movl $0xa, -0x44(%rbp)
movl $0xa, -0x40(%rbp)
movq -0x4c(%rbp), %rcx
movq %rcx, 0x2c(%rax)
movq -0x44(%rbp), %rcx
movq %rcx, 0x34(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x57ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x38(%rbp), %rdi
callq 0x42e0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x42f0
movq -0x58(%rbp), %rdx
leaq 0x17633(%rip), %rsi     # 0x1d0cf
leaq -0x28(%rbp), %rdi
callq 0x4f50
jmp 0x5aa7
movq -0x60(%rbp), %rdi
movq %rsp, %rax
movl $0x5, (%rax)
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
movl $0x64, %ecx
movl $0xf, %r8d
movl $0xa, %r9d
callq 0x58c0
jmp 0x5ad5
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x60(%rbp), %rdi
leaq 0x28c86(%rip), %rax     # 0x2e778
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1c, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x0, (%rax)
addq $0x1c, %rdi
movl $0x1, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x4, (%rax)
addq $0x1c, %rdi
movl $0x2, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x5, (%rax)
addq $0x1c, %rdi
movl $0x3, %esi
callq 0x5000
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl $0x1, (%rcx)
movl $0xa, -0x4c(%rbp)
movl $0xa, -0x48(%rbp)
movl $0xa, -0x44(%rbp)
movl $0xa, -0x40(%rbp)
movq -0x4c(%rbp), %rcx
movq %rcx, 0x2c(%rax)
movq -0x44(%rbp), %rcx
movq %rcx, 0x34(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x5bb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x38(%rbp), %rdi
callq 0x42e0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x42f0
movq -0x58(%rbp), %rdx
leaq 0x1742f(%rip), %rsi     # 0x1d17b
leaq -0x28(%rbp), %rdi
callq 0x4f50
jmp 0x5d57
movq -0x60(%rbp), %rdi
movq %rsp, %rax
movl $0xa, (%rax)
movl $0x2, %esi
leaq -0x28(%rbp), %rdx
movl $0x64, %ecx
movl $0xa, %r9d
movl %r9d, %r8d
callq 0x58c0
jmp 0x5d82
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x60(%rbp), %rdi
leaq 0x28a19(%rip), %rax     # 0x2e7b8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1c, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x0, (%rax)
addq $0x1c, %rdi
movl $0x1, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x2, (%rax)
addq $0x1c, %rdi
movl $0x2, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x3, (%rax)
addq $0x1c, %rdi
movl $0x3, %esi
callq 0x5000
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl $0x1, (%rcx)
movl $0xa, -0x4c(%rbp)
movl $0xa, -0x48(%rbp)
movl $0xa, -0x44(%rbp)
movl $0xa, -0x40(%rbp)
movq -0x4c(%rbp), %rcx
movq %rcx, 0x2c(%rax)
movq -0x44(%rbp), %rcx
movq %rcx, 0x34(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x5e5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x38(%rbp), %rdi
callq 0x42e0
nop
// File: rozpo[P]enemy/data/characters/players/mage/Mage.cpp
// Function: Mage::printCharacter()
void Mage::printCharacter()
{
    std::cout << "      _" << '\n'
              << "     (0)*" << '\n'
              << "     /|\\|" << '\n'
              << "      | |" << '\n'
              << "     / \\|" << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x290bd(%rip), %rdi     # 0x2efd0
leaq 0x1711c(%rip), %rsi     # 0x1d036
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq %rax, %rdi
leaq 0x17252(%rip), %rsi     # 0x1d188
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq %rax, %rdi
leaq 0x17240(%rip), %rsi     # 0x1d192
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq %rax, %rdi
leaq 0x1722e(%rip), %rsi     # 0x1d19c
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq %rax, %rdi
leaq 0x1721c(%rip), %rsi     # 0x1d1a6
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x42f0
movq -0x58(%rbp), %rdx
leaq 0x171dc(%rip), %rsi     # 0x1d1b8
leaq -0x28(%rbp), %rdi
callq 0x4f50
jmp 0x5fe7
movq -0x60(%rbp), %rdi
movq %rsp, %rax
movl $0xf, (%rax)
movl $0x3, %esi
leaq -0x28(%rbp), %rdx
movl $0x64, %ecx
movl $0x5, %r8d
movl $0xa, %r9d
callq 0x58c0
jmp 0x6015
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x60(%rbp), %rdi
leaq 0x287c6(%rip), %rax     # 0x2e7f8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1c, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x0, (%rax)
addq $0x1c, %rdi
movl $0x1, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x1, (%rax)
addq $0x1c, %rdi
movl $0x2, %esi
callq 0x5000
movq -0x60(%rbp), %rdi
movl $0x6, (%rax)
addq $0x1c, %rdi
movl $0x3, %esi
callq 0x5000
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl $0x7, (%rcx)
movl $0xa, -0x4c(%rbp)
movl $0xa, -0x48(%rbp)
movl $0xa, -0x44(%rbp)
movl $0xa, -0x40(%rbp)
movq -0x4c(%rbp), %rcx
movq %rcx, 0x2c(%rax)
movq -0x44(%rbp), %rcx
movq %rcx, 0x34(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x60f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x40f0
leaq -0x29(%rbp), %rdi
callq 0x4200
movq -0x38(%rbp), %rdi
callq 0x42e0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x1, %eax
je 0x624b
jmp 0x6237
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0x626c
jmp 0x6241
movl -0x44(%rbp), %eax
subl $0x3, %eax
je 0x628d
jmp 0x62ae
leaq -0x20(%rbp), %rdi
callq 0x63a0
movq -0x58(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6410
leaq -0x20(%rbp), %rdi
callq 0x6440
jmp 0x62bb
leaq -0x30(%rbp), %rdi
callq 0x6460
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x64d0
leaq -0x30(%rbp), %rdi
callq 0x6500
jmp 0x62bb
leaq -0x40(%rbp), %rdi
callq 0x6520
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6590
leaq -0x40(%rbp), %rdi
callq 0x65c0
jmp 0x62bb
movq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x65e0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
testl %eax, %eax
je 0x630a
jmp 0x62f6
movl -0x44(%rbp), %eax
subl $0x1, %eax
je 0x632b
jmp 0x6300
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0x634c
jmp 0x636d
leaq -0x20(%rbp), %rdi
callq 0x6600
movq -0x58(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6670
leaq -0x20(%rbp), %rdi
callq 0x66a0
jmp 0x637a
leaq -0x30(%rbp), %rdi
callq 0x66c0
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6730
leaq -0x30(%rbp), %rdi
callq 0x6760
jmp 0x637a
leaq -0x40(%rbp), %rdi
callq 0x6780
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x67f0
leaq -0x40(%rbp), %rdi
callq 0x6820
jmp 0x637a
movq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6840
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf60
movl 0x88(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rdi
callq 0xaf60
movl $0x5, 0x90(%rax)
movq -0x8(%rbp), %rdi
callq 0xaf60
movl 0x8(%rax), %ecx
addl $0x5, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0xaf60
movl 0xc(%rax), %ecx
addl $0x5, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
callq 0xaf60
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0xaf60
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
callq 0xaf60
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq 0x249a8(%rip), %rdi     # 0x2efd0
leaq 0x12dd1(%rip), %rsi     # 0x1d400
callq 0x41b0
movq %rax, %rdi
leaq 0x12dd0(%rip), %rsi     # 0x1d40e
callq 0x41b0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf60
movq -0x30(%rbp), %rdi
movl 0xc(%rax), %esi
callq 0x42d0
movq %rax, %rdi
leaq 0x12f74(%rip), %rsi     # 0x1d5da
callq 0x41b0
movq %rax, %rdi
leaq 0x12da6(%rip), %rsi     # 0x1d41b
callq 0x41b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf60
movq -0x28(%rbp), %rdi
movl 0x10(%rax), %esi
callq 0x42d0
movq %rax, %rdi
leaq 0x12f3d(%rip), %rsi     # 0x1d5da
callq 0x41b0
movq %rax, %rdi
leaq 0x12d7b(%rip), %rsi     # 0x1d427
callq 0x41b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf60
movq -0x20(%rbp), %rdi
movl 0x14(%rax), %esi
callq 0x42d0
movq %rax, %rdi
leaq 0x12f06(%rip), %rsi     # 0x1d5da
callq 0x41b0
movq %rax, %rdi
leaq 0x12d4f(%rip), %rsi     # 0x1d432
callq 0x41b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf60
movq -0x18(%rbp), %rdi
movl 0x18(%rax), %esi
callq 0x42d0
movq %rax, %rdi
leaq 0x12ecf(%rip), %rsi     # 0x1d5da
callq 0x41b0
movq %rax, %rdi
leaq 0x12d28(%rip), %rsi     # 0x1d442
callq 0x41b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf60
movq -0x10(%rbp), %rdi
movl 0x90(%rax), %esi
callq 0x42d0
movq %rax, %rdi
leaq 0x12e95(%rip), %rsi     # 0x1d5da
callq 0x41b0
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf60
cmpl $0x0, 0x8(%rax)
jl 0xa88f
movq -0x8(%rbp), %rdi
callq 0xaf60
movl 0x94(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x94(%rax)
movq 0x2483e(%rip), %rdi     # 0x2efd0
leaq 0x12cb9(%rip), %rsi     # 0x1d452
callq 0x41b0
movq %rax, %rdi
leaq 0x12cbb(%rip), %rsi     # 0x1d463
callq 0x41b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaf80
movq -0x30(%rbp), %rdi
movl 0x88(%rax), %esi
callq 0x42d0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq %rax, %rdi
leaq 0x12c92(%rip), %rsi     # 0x1d472
callq 0x41b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaf80
movq -0x28(%rbp), %rdi
movl 0x3c(%rax), %esi
callq 0x42d0
movq %rax, %rdi
leaq 0x12dd2(%rip), %rsi     # 0x1d5da
callq 0x41b0
movq -0x10(%rbp), %rdi
callq 0xaf80
movl 0x3c(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf60
movl -0x1c(%rbp), %ecx
addl 0x3c(%rax), %ecx
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rdi
callq 0xaf80
movl 0x88(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf60
movl -0x18(%rbp), %ecx
addl 0x8c(%rax), %ecx
movl %ecx, 0x8c(%rax)
movq -0x8(%rbp), %rdi
callq 0xaf60
movl 0x8c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf60
movq %rax, %rcx
movl -0x14(%rbp), %eax
imull $0x64, 0x88(%rcx), %ecx
cmpl %ecx, %eax
jl 0xa88d
movq -0x8(%rbp), %rdi
callq 0xa590
jmp 0xa8ba
movq 0x2473a(%rip), %rdi     # 0x2efd0
leaq 0x12bde(%rip), %rsi     # 0x1d47b
callq 0x41b0
movq -0x8(%rbp), %rdi
callq 0xaf60
movl 0x98(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x98(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x244d9(%rip), %rdi     # 0x2efd0
leaq 0x129ac(%rip), %rsi     # 0x1d4aa
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq -0x10(%rbp), %rdi
callq 0xaf80
movq %rax, %rsi
addq $0x40, %rsi
movq 0x244a9(%rip), %rdi     # 0x2efd0
callq 0x4190
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq -0x10(%rbp), %rdi
callq 0xaf80
movl 0x8(%rax), %esi
movq 0x24484(%rip), %rdi     # 0x2efd0
callq 0x42d0
movq %rax, %rdi
leaq 0x12616(%rip), %rsi     # 0x1d171
callq 0x41b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaf80
movq -0x20(%rbp), %rdi
movl 0xc(%rax), %esi
callq 0x42d0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq -0x10(%rbp), %rdi
callq 0xaf80
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x24431(%rip), %rdi     # 0x2efd0
movl $0xa, %esi
callq 0x4240
movq 0x24420(%rip), %rdi     # 0x2efd0
movl $0xa, %esi
callq 0x4240
movq -0x8(%rbp), %rdi
callq 0xaf60
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0xaf60
movq %rax, %rsi
addq $0x40, %rsi
movq 0x243ed(%rip), %rdi     # 0x2efd0
callq 0x4190
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq -0x8(%rbp), %rdi
callq 0xaf60
movl 0x8(%rax), %esi
movq 0x243c8(%rip), %rdi     # 0x2efd0
callq 0x42d0
movq %rax, %rdi
leaq 0x1255a(%rip), %rsi     # 0x1d171
callq 0x41b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaf60
movq -0x18(%rbp), %rdi
movl 0xc(%rax), %esi
callq 0x42d0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movq 0x24387(%rip), %rdi     # 0x2efd0
leaq 0x12871(%rip), %rsi     # 0x1d4c1
callq 0x41b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rozpo[P]enemy/data/game/battle/Battle.cpp
// Function: int Battle::characterDamage<Player>(std::shared_ptr<Player> const&, int)
int Battle::characterDamage(const std::shared_ptr<T1> &user, int type)
{
    switch(type)
    {
        case e_type_str:
            return user->strength;
        case e_type_agi:
            return user->agility;
        case e_type_int:
            return user->intelligence;
        default:
            return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0xbb4f
jmp 0xbb3b
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0xbb60
jmp 0xbb45
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0xbb71
jmp 0xbb82
movq -0x10(%rbp), %rdi
callq 0xaf60
movl 0x10(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xbb89
movq -0x10(%rbp), %rdi
callq 0xaf60
movl 0x14(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xbb89
movq -0x10(%rbp), %rdi
callq 0xaf60
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xbb89
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: rozpo[P]enemy/data/game/create/Create.cpp
// Function: Create::createPlayer(std::vector<std::shared_ptr<Player>, std::allocator<std::shared_ptr<Player>>>&, int&)
std::vector<std::shared_ptr<Player>> Create::createPlayer(std::vector<std::shared_ptr<Player>> &players, int &status)
{
    if (players.size () < 5)
    {
        if( status ==1 || status ==2 || status ==3)
        {
            players.push_back (Factory::getInstance().createPlayer(status));
            return players;
        }
        else
            return players;
    }
    else
    {
        std::cout << "Characters limit" << "\n";
        return players;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc7a0
cmpq $0x5, %rax
jae 0xc75e
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0xc6f1
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
je 0xc6f1
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0xc74f
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x61a0
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x6210
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xc7c0
jmp 0xc720
leaq -0x30(%rbp), %rdi
callq 0xc7f0
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc810
jmp 0xc78d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc7f0
jmp 0xc797
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc810
jmp 0xc78d
movq 0x2286b(%rip), %rdi     # 0x2efd0
leaq 0x10dcd(%rip), %rsi     # 0x1d539
callq 0x41b0
movq %rax, %rdi
leaq 0x10e5f(%rip), %rsi     # 0x1d5da
callq 0x41b0
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc810
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x42e0
// File: rozpo[P]enemy/data/game/select/Select.cpp
// Function: Select::print(std::vector<std::shared_ptr<Player>, std::allocator<std::shared_ptr<Player>>> const&)
void Select::print(const std::vector<std::shared_ptr<Player>> &players)
{
    if (players.empty () == 0)
    {
        std::cout << "---\n"
                  << name << "\n\n";
        for ( int i = 0 ; i < players.size () ; i ++ )
            std::cout << "[" << i + 1 << "]: " << players[ i ]->name << '\n';
        std::cout << '\n' << "---\n" << "[0]: " << this->map_Choices[0] << '\n';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdde0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xddb9
movq 0x2133a(%rip), %rdi     # 0x2efd0
leaq 0xf937(%rip), %rsi      # 0x1d5d4
callq 0x41b0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x30, %rsi
callq 0x4190
movq %rax, %rdi
leaq 0xf91d(%rip), %rsi      # 0x1d5d9
callq 0x41b0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc7a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xdd59
movq 0x212e4(%rip), %rdi     # 0x2efd0
leaq 0xfbcc(%rip), %rsi      # 0x1d8bf
callq 0x41b0
movq %rax, %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x42d0
movq %rax, %rdi
leaq 0xfa1e(%rip), %rsi      # 0x1d72e
callq 0x41b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xde20
movq %rax, %rdi
callq 0xaf60
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x40, %rsi
callq 0x4190
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xdcc8
movq 0x21270(%rip), %rdi     # 0x2efd0
movl $0xa, %esi
callq 0x4240
movq %rax, %rdi
leaq 0xf860(%rip), %rsi      # 0x1d5d4
callq 0x41b0
movq %rax, %rdi
leaq 0xf859(%rip), %rsi      # 0x1d5dc
callq 0x41b0
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xde40
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x4190
movq %rax, %rdi
movl $0xa, %esi
callq 0x4240
addq $0x40, %rsp
popq %rbp
retq
nop