LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: pscheck(unsigned int*, int*, int, int, int)
int pscheck(unsigned int *D,int *D_2,int start,int plen, int round){ 
    //配列mのstartからplen文字の完全一致を探す
    //if(DEBUGFLAG==1){
    //    printf("\npscheck[");
    //    for(int j = 0;j<plen;j++){printf("%d ",m[start+j]);}
    //    printf("]");
    //}
    int rofs = 0;if(round>1){rofs=dc2s[round-1];}
    int pos = 0;int posup = dc2s[round]-1;int posbt = dc2s[round+1]; //round内のみで計算する
    while(1){
        pos = posup + (posbt-posup)/2;
        //printf("\nテスト %d %d %d",pos,posbt,posup);
        int k = 0; // : the length of same prefix. if k == plen == the length of the purse, it's exactly the answer.
        int r = 0; // : for debuging
        for(int i = 0;i<plen;i++){
            if(i == D_2[pos+1]-D_2[pos]){k=-1;break;} //分割が短すぎる = この分割より後に出てくるはず
            if(m[start+i]-rofs==D[D_2[pos]+i]){k=0;}
            if(m[start+i]-rofs>D[D_2[pos]+i]){k=-1;break;} //pos should be larger than now
            if(m[start+i]-rofs<D[D_2[pos]+i]){k=1;break;} //pos should be smaller than now
        }
        if(k==-1){posup=pos;}
        if(k==1){posbt=pos;}
        if(k==0){
                if(D_2[pos+1]-D_2[pos]==plen){break;} //発見
                else{posbt=pos;} //パターンが短すぎる = もっと前に出てくるはず
        }
        //if(DEBUGFLAG==1){printf("\n >>  %d %d %d",pos,posbt,posup);}
        if(posbt-posup<2){pos=-1;break;} //もう探すところがない
    }
    //printf("位置%d ",pos);
    return pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %r9d, %r9d
leaq 0x81ca(%rip), %rax      # 0x96a0
movl $0x0, %r10d
cmpl $0x2, %r8d
jl 0x14ea
leal -0x1(%r8), %r10d
movl (%rax,%r10,4), %r10d
movslq %r8d, %r11
movl (%rax,%r11,4), %r8d
movl 0x4(%rax,%r11,4), %r14d
decl %r8d
movslq %edx, %r11
testl %ecx, %ecx
cmovgl %ecx, %r9d
shlq $0x2, %r11
addq 0x8203(%rip), %r11      # 0x9710
movl $0x2, %ebp
movl %r14d, %eax
subl %r8d, %eax
cltd
idivl %ebp
addl %r8d, %eax
movslq %eax, %rbx
movl 0x4(%rsi,%rbx,4), %edx
movslq (%rsi,%rbx,4), %rbx
subl %ebx, %edx
leaq (%rdi,%rbx,4), %r15
xorl %r12d, %r12d
cmpq %r12, %r9
je 0x155e
cmpq %r12, %rdx
je 0x1556
movl (%r11,%r12,4), %r13d
subl %r10d, %r13d
movl (%r15,%r12,4), %ebx
cmpl %ebx, %r13d
ja 0x1556
incq %r12
cmpl %ebx, %r13d
jae 0x1532
jmp 0x1562
movl %eax, %r8d
movl %r14d, %eax
jmp 0x1562
cmpl %ecx, %edx
je 0x1574
movl %eax, %edx
subl %r8d, %edx
movl %eax, %r14d
cmpl $0x1, %edx
jg 0x1512
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: psck(unsigned int*, int*, int*, int*, int*, int)
int psck(unsigned int *D,int *D_2,int *Rs,int *B2,int *e,int round){
    if(DEBUGFLAG==1){printf("\n[psck / round %d]",round);}
    if(round==-1){return 0;}
    int starti = Rs[round];
    int mlen = B2[round];
    int rofs=0;if(round>1){rofs=dc2s[round-1];}
    int cnt = 0;int a1[3] = {-1,-1,-1};int cnt2 = 0;
    //if(gate==16){printf("?_[%d][%d][%d]",a1[0],a1[1],a1[2]);}
    for(int i=0;i<3;i++){
        int l = e[i];if(l<0){break;}
         if(DEBUGFLAG==1){printf("\nopen -> [%d] :",l);}
        for(int j = D_2[l];j<D_2[l+1];j++){
            if(cnt<mlen){
                if(D[j]+rofs!=m[starti+cnt]){
                     if(DEBUGFLAG==1){printf("round %d で右不一致(%d !=%d)",round,D[j]+rofs,m[starti+cnt]);}
                    return -1;
                }
                if(DEBUGFLAG==1){printf("hit[%d(%d)]",D[j]+rofs,rofs);}
                cnt++;
            }
            else{
                if(round==0){/*printf("[完全正解+]");*/return 0;}
                a1[cnt2] = rofs+D[j];cnt2++;
                if(cnt2==3){
                    e[0] = a1[0];e[1] = a1[1];e[2] = a1[2];
                    //printf("[正解]");
                    //printf("next e2[%d,%d,%d] =>",e[0],e[1],e[2]);
                    return psck(D,D_2,Rs,B2,e,round-1);
                }
            }
        }
    }
    if(cnt<mlen){/*printf("不足・判別不可");*/return 1;}
    //if(gate==16){printf("?_[%d][%d][%d] -> [%d][%d][%d]",a1[0],a1[1],a1[2],e[0],e[1],e[2]);exit(4);}
    e[0] = a1[0];e[1] = a1[1];e[2] = a1[2];
    return psck(D,D_2,Rs,B2,e,round-1);
}

// Assembly:
cmpl $-0x1, %r9d
je 0x17b6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movslq %r9d, %rax
xorl %r10d, %r10d
movl $0x0, %r11d
cmpl $0x2, %r9d
jl 0x172f
leal -0x1(%r9), %ebx
leaq 0x7f75(%rip), %r11      # 0x96a0
movl (%r11,%rbx,4), %r11d
movq %rdx, 0x18(%rsp)
movslq (%rdx,%rax,4), %r14
movq %rcx, 0x20(%rsp)
movl (%rcx,%rax,4), %ebx
orl $-0x1, 0x10(%rsp)
orq $-0x1, 0x8(%rsp)
movq 0x7fbe(%rip), %r15      # 0x9710
xorl %eax, %eax
xorl %r13d, %r13d
cmpq $0x3, %rax
je 0x17c2
movslq (%r8,%rax,4), %r12
testq %r12, %r12
js 0x17c2
movslq (%rsi,%r12,4), %rbp
movslq 0x4(%rsi,%r12,4), %r12
cmpq %r12, %rbp
jge 0x17b1
cmpl %ebx, %r10d
jge 0x1790
movl (%rdi,%rbp,4), %ecx
addl %r11d, %ecx
movslq %r10d, %rdx
addq %r14, %rdx
cmpl (%r15,%rdx,4), %ecx
jne 0x17bd
incl %r10d
jmp 0x17ac
testl %r9d, %r9d
je 0x17b9
movl (%rdi,%rbp,4), %ecx
addl %r11d, %ecx
movslq %r13d, %r13
movl %ecx, 0x8(%rsp,%r13,4)
incl %r13d
cmpl $0x3, %r13d
je 0x17cb
incq %rbp
jmp 0x176f
incq %rax
jmp 0x1757
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x17ed
pushq $-0x1
popq %rax
jmp 0x17ed
cmpl %ebx, %r10d
jge 0x17cb
pushq $0x1
jmp 0x17bf
movq 0x8(%rsp), %rax
movq %rax, (%r8)
movl 0x10(%rsp), %eax
movl %eax, 0x8(%r8)
decl %r9d
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x16f6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: findintop(int*, int, int)
void findintop(int *D_3,int tg,int pofs){ //NS列からtgを探す
    if(DEBUGFLAG==1){printf("\n[%d]を探す(%d)",tg,dc2s[fround-1]);}
    int len = 0;
    for(int y1 = 0;y1<NSsize;y1++){
        if(DEBUGFLAG==1){printf("[%d]答え",NS[y1]);}
        if(NS[y1]==tg-dc2s[fround-1]){
            printf(" %d",len+pofs);
            if(ans<1000 && CHECKFLAG==1){checkans[ans]=len+pofs;}
            ans++;
        }
        len+= D_3[NS[y1]+dc2s[fround-1]];
    }
    //printf("\nend of searching.(%d)[%d]",len,tg);
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl 0x7c37(%rip), %eax      # 0x9720
leaq 0x7bb0(%rip), %r12      # 0x96a0
xorl %r13d, %r13d
xorl %r15d, %r15d
movslq %eax, %rcx
cmpq %rcx, %r13
jge 0x1b61
movq 0x7c13(%rip), %rcx      # 0x9718
movl (%rcx,%r13,4), %ecx
movslq 0x7c18(%rip), %rdx      # 0x9728
movl %ebp, %esi
subl -0x4(%r12,%rdx,4), %esi
cmpl %esi, %ecx
jne 0x1b4b
leal (%r15,%rbx), %esi
leaq 0x35fc(%rip), %rdi      # 0x5122
xorl %eax, %eax
callq 0x1030
incl 0x7bbd(%rip)            # 0x96f0
movl 0x7be7(%rip), %eax      # 0x9720
movq 0x7bd8(%rip), %rcx      # 0x9718
movl (%rcx,%r13,4), %ecx
movslq 0x7bdd(%rip), %rdx      # 0x9728
decq %rdx
movslq (%r12,%rdx,4), %rdx
movslq %ecx, %rcx
addq %rdx, %rcx
addl (%r14,%rcx,4), %r15d
incq %r13
jmp 0x1af6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: pschecks(unsigned int*, int*, int, int, int)
int pschecks(unsigned int *D,int *D_2,int start,int plen,int round){
    //mのstartmからmlenを，分割の最初から始まるものだけ探す
    //配列mのstartからplen文字一致する最も番号の小さいものを探す
    //printf("\n[");for(int y8=0;y8<plen;y8++){printf(" %d",m[start+y8]);}printf("]を探す");
    int rofs = 0;if(round>1){rofs=dc2s[round-1];}
    int pos = 0;int posup = dc2s[round]-1;int posbt = dc2s[round+1]; //round内のみで計算する
    while(1){
        pos = posup + (posbt-posup)/2;int k = 0;
        for(int i = 0;i<plen;i++){
            if(i == D_2[pos+1]-D_2[pos]){k=-1;break;} //分割が短すぎる = この分割より後に出てくるはず
            if(m[start+i]-rofs==D[D_2[pos]+i]){k=0;}
            if(m[start+i]-rofs>D[D_2[pos]+i]){k=-1;break;} //pos should be larger than now
            if(m[start+i]-rofs<D[D_2[pos]+i]){k=1;break;} //pos should be smaller than now
        }
        if(k==-1){posup=pos;}
        if(k==1){posbt=pos;}
        if(k==0){ //パターンと完全に一致するprefixを持っている
                posbt=pos;
        }
        if(posbt-posup<2){pos=-1;break;} //もう探すところがない
    }
    //printf("\n[最小:%d]",posbt);
    return posbt;
}

// Assembly:
xorl %eax, %eax
leaq 0x7b27(%rip), %r10      # 0x96a0
movl $0x0, %r9d
cmpl $0x2, %r8d
jl 0x1b8d
leal -0x1(%r8), %r9d
movl (%r10,%r9,4), %r9d
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %r8d, %r8
movl (%r10,%r8,4), %r11d
movl 0x4(%r10,%r8,4), %r8d
decl %r11d
movslq %edx, %r10
testl %ecx, %ecx
cmovlel %eax, %ecx
shlq $0x2, %r10
addq 0x7b59(%rip), %r10      # 0x9710
movl $0x2, %ebx
movl %r8d, %eax
subl %r11d, %eax
cltd
idivl %ebx
addl %r11d, %eax
movslq %eax, %rdx
xorl %r14d, %r14d
cmpq %r14, %rcx
je 0x1c00
movl 0x4(%rsi,%rdx,4), %r12d
movslq (%rsi,%rdx,4), %r15
subl %r15d, %r12d
cmpq %r12, %r14
je 0x1c05
movl (%r10,%r14,4), %ebp
subl %r9d, %ebp
leaq (%rdi,%r15,4), %r15
movl (%r15,%r14,4), %r15d
cmpl %r15d, %ebp
ja 0x1c05
incq %r14
cmpl %r15d, %ebp
jae 0x1bce
movl %eax, %r8d
jmp 0x1c08
movl %eax, %r11d
movl %r8d, %eax
subl %r11d, %eax
cmpl $0x1, %eax
jg 0x1bbc
movl %r8d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: leftopen(unsigned int*, int*, int*, int, int, int)
void leftopen(unsigned int *D,int *D_2,int *D_3,int round,int count,int tround){ //左の[0]をcount回開ける
    if(DEBUGFLAG==1){
         printf("\n[1-左%dオープン(%d)]",count,round);
         if(occart2[tround][0] > -1){alldr(D,D_2,D_3,occart2[tround][0],tround-1);}
    }
    int rofs=0;
    if(round>1){rofs=dc2s[round-1];}
    if(occart2[tround][0] > -1){
       occart2[tround][0] = rofs+D[D_2[1+occart2[tround][0]]-1];
       if(DEBUGFLAG==1){printf(" >> %d ",occart2[tround][0]);}
       if(count>1){leftopen(D,D_2,D_3,round-1,count-1,tround);}
    }
    return;
}

// Assembly:
movslq %r9d, %rax
imulq $0x28, %rax, %rdx
leaq 0x70fa(%rip), %r9       # 0x9170
leaq (%r9,%rdx), %rax
movl (%rdx,%r9), %r9d
leaq 0x761b(%rip), %rdx      # 0x96a0
xorl %r10d, %r10d
cmpl $0x2, %ecx
jl 0x2095
leal -0x1(%rcx), %r10d
movl (%rdx,%r10,4), %r10d
testl %r9d, %r9d
js 0x20ba
movl %r9d, %r9d
movslq 0x4(%rsi,%r9,4), %r9
addl -0x4(%rdi,%r9,4), %r10d
movl %r10d, (%rax)
cmpl $0x2, %r8d
jl 0x20ba
decl %ecx
decl %r8d
movl %r10d, %r9d
jmp 0x2085
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: leftopennd(unsigned int*, int*, int*, int, int, int)
int leftopennd(unsigned int *D,int *D_2,int *D_3,int round,int count,int tround){ //左の[0][1]をcount回開ける
     if(DEBUGFLAG==1){
         printf("\n[2-左%dオープン(%d)]",count,round);
         if(occart2[tround][1] > -1){alldr(D,D_2,D_3,occart2[tround][1],tround-1);}
         if(occart2[tround][0] > -1){alldr(D,D_2,D_3,occart2[tround][0],tround-1);}
    }
    int rofs=0;
    if(round>1){rofs=dc2s[round-1];}
    if(occart2[tround][1] > -1){ //左辺文字Aが指定されていれば
         if(DEBUGFLAG==1){printf("open [%d,%d--%d] >>",occart2[tround][1],dc2s[round],rofs);}
        int a1 = rofs+D[D_2[1+occart2[tround][1]] - 1];
        if(DEBUGFLAG==1){printf("\na1 = %d(%d)",a1,count);}
        if(count>1){occart2[tround][1] = a1;return leftopennd(D,D_2,D_3,round-1,count-1,tround);}
        int a2;
        if(D_2[occart2[tround][1]]<2){printf("a2を消す");a2 = -1;}
        a2 = rofs+D[D_2[1+occart2[tround][1]] - 2];
        occart2[tround][1] = a1;
        occart2[tround][0] = a2;
        if(DEBUGFLAG==1){printf("\n更新 = %d & %d",a1,a2);}
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq %r9d, %rax
imulq $0x28, %rax, %rax
leaq 0x7099(%rip), %rdx      # 0x9170
leaq (%rdx,%rax), %r15
movl 0x4(%rax,%rdx), %eax
leaq 0x75ba(%rip), %rdx      # 0x96a0
xorl %ebp, %ebp
cmpl $0x2, %ecx
jl 0x20f3
leal -0x1(%rcx), %esi
movl (%rdx,%rsi,4), %ebp
testl %eax, %eax
js 0x2145
movl %eax, %esi
movslq 0x4(%r14,%rsi,4), %rdi
movl -0x4(%rbx,%rdi,4), %r12d
addl %ebp, %r12d
cmpl $0x2, %r8d
jl 0x211a
movl %r12d, 0x4(%r15)
decl %ecx
decl %r8d
movl %r12d, %eax
jmp 0x20e6
cmpl $0x1, (%r14,%rsi,4)
jg 0x2133
leaq 0x2f9e(%rip), %rdi      # 0x50c6
xorl %eax, %eax
callq 0x1030
movl 0x4(%r15), %eax
cltq
movslq 0x4(%r14,%rax,4), %rax
addl -0x8(%rbx,%rax,4), %ebp
movl %r12d, 0x4(%r15)
movl %ebp, (%r15)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: findinround1(unsigned int*, int*, int*, int, int, int)
void findinround1(unsigned int *D,int *D_2,int *D_3,int tg,int round,int pofs){
    if(round==fround){return findintop(D_3,tg,pofs);}
    //あるラウンドから文字[tg]を探す
    //printf("%d(+%d)",tg,pofs); //引き継いだズレ値を記録
    int e2[2];
    int rofs = 0;
    if(round>1){rofs=dc2s[round-1];}
    for(int y8=dc2s[round];y8<dc2s[round+1];y8++){
        int ofs = 0;
        //printf("\n[%d(%d)]",y8,D_2[y8+1]-D_2[y8]);
        for(int y9=D_2[y8];y9<D_2[y8+1];y9++){
            //printf(" %d",rofs+D[y9]);
            if(rofs+D[y9]==tg){
                //if(round>15){printf("\n発見(%d,%d[+%d])",tg,ofs+pofs,ofs);}
                findinround1(D,D_2,D_3,y8,round+1,pofs+ofs);
            }
            if(round>0){ofs+=D_3[rofs+D[y9]];}else{ofs++;}
        }
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r12d
movq %rdx, %r13
cmpl %r8d, 0x73d7(%rip)      # 0x9728
jne 0x236e
movq %r13, %rdi
movl %ecx, %esi
movl %r12d, %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ad1
xorl %r11d, %r11d
leaq 0x7328(%rip), %r10      # 0x96a0
cmpl $0x2, %r8d
jl 0x2386
leal -0x1(%r8), %eax
movl (%r10,%rax,4), %r11d
movslq %r8d, %rax
movslq (%r10,%rax,4), %rbx
leal 0x1(%r8), %eax
movl %eax, 0x10(%rsp)
cltq
movq %rax, 0x18(%rsp)
pushq $0x1
popq %rbp
movl %ecx, 0x14(%rsp)
movq %r8, 0x20(%rsp)
movl %r11d, 0xc(%rsp)
movq 0x18(%rsp), %rax
movslq (%r10,%rax,4), %rax
cmpq %rax, %rbx
jge 0x2452
movslq (%rsi,%rbx,4), %r14
leaq 0x1(%rbx), %r10
xorl %r15d, %r15d
movq %rbx, 0x28(%rsp)
movslq (%rsi,%r10,4), %rax
cmpq %rax, %r14
jge 0x2443
movl (%rdi,%r14,4), %eax
addl %r11d, %eax
cmpl %ecx, %eax
jne 0x2428
leal (%r15,%r12), %r9d
movq %rdi, %rbp
movq %r15, 0x30(%rsp)
movq %rsi, %r15
movq %r13, %rdx
movl %ebx, %ecx
movl 0x10(%rsp), %r8d
movq %r10, %rbx
callq 0x2336
movq %rbx, %r10
movl 0xc(%rsp), %r11d
movq 0x28(%rsp), %rbx
movq %rbp, %rdi
pushq $0x1
popq %rbp
movq %r15, %rsi
movq 0x30(%rsp), %r15
movq 0x20(%rsp), %r8
movl 0x14(%rsp), %ecx
movl %ebp, %eax
testl %r8d, %r8d
jle 0x243b
movl (%rdi,%r14,4), %eax
addl %r11d, %eax
movl (%r13,%rax,4), %eax
addl %eax, %r15d
incq %r14
jmp 0x23cf
movq %r10, %rbx
leaq 0x7253(%rip), %r10      # 0x96a0
jmp 0x23ad
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: queryload()
int queryload(){
    //load[qname] file and put it in array [m]
    char qname[] = "query.txt";
    char chr;
    FILE *fp;
    long long int qsize = 400;
    qsize = std::filesystem::file_size(qname);
    fp = fopen(qname, "r"); // open file or return null
    if(fp == NULL) {
        printf("%s such file doesn't exist!\n", qname);
        return -1;
    }
    int i = 0;
    for(i=0;i<qsize;i++) {
        chr = fgetc(fp);
        m[i] = chr;
        if(chr<0){m[i]=chr + 256;}
        //printf("\n%d(%d)",m[i],i);
    }
    return (int)qsize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movabsq $0x78742e7972657571, %rax # imm = 0x78742E7972657571
movq %rsp, %rsi
movq %rax, (%rsi)
movw $0x74, 0x8(%rsi)
leaq 0x10(%rsp), %rbx
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x4b3c
movq %rbx, %rdi
callq 0x1170
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4ba8
leaq 0x140b(%rip), %rsi      # 0x5073
movq %rsp, %rdi
callq 0x1130
testq %rax, %rax
je 0x3ca5
movq %rax, %r14
xorl %r15d, %r15d
testq %rbx, %rbx
movq %rbx, %r12
cmovleq %r15, %r12
cmpq %r15, %r12
je 0x3cb9
movq %r14, %rdi
callq 0x11b0
movzbl %al, %eax
movq 0x5a74(%rip), %rcx      # 0x9710
movl %eax, (%rcx,%r15,4)
incq %r15
jmp 0x3c85
leaq 0x13c9(%rip), %rdi      # 0x5075
movq %rsp, %rsi
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4ba8
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O2/TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: qrmload(int, int, int*)
int qrmload(int c,int jo,int *anst){ //mの中に，english.001.2 の中からc文字をランダムに選択して保存する
    char chr;FILE *fp;
    long long int qsize = std::filesystem::file_size(qname); //qsizeには，ファイルのサイズが書かれているはず
    fp = fopen(qname, "r"); // open file or return null
    if(fp == NULL) {
        printf("%s such file doesn't exist!\n", qname);
        return -1;
    }
    int i = 0;
    jswt = 0;
    int rlen = rand()%(qsize-c);
    if(runmode==2){rlen = qstart;}
    anst[jo] = rlen;
    fseek(fp,rlen,SEEK_SET); //指定したシークまで移動する
    printf("\nquery%d : [%lld]rlen[%d]から[%d]文字(%lld)\n[",jo,qsize,rlen,c,qsize);
    if(CHECKFLAG == 1){checkpz[0]=rlen;checkpz[1]=c;}
    for(i=0;i<c;i++) { //c文字
        chr = fgetc(fp);
        m[i] = chr;
        if(chr<0){m[i]=chr + 256;}
        if(m[i]==10){jswt=1;}
        if(DEBUGFLAG==1){printf("%c",chr);}
    }
    printf("]");
    return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movl %esi, %ebp
movl %edi, %ebx
leaq 0x4294(%rip), %rsi      # 0x8170
movq %rsp, %r14
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x4bbe
movq %r14, %rdi
callq 0x1170
movq %rax, %r15
movq %rsp, %rdi
callq 0x4ba8
movq 0x426c(%rip), %rdi      # 0x8170
leaq 0x1168(%rip), %rsi      # 0x5073
callq 0x1130
testq %rax, %rax
je 0x3fd5
movq %rax, %r14
andl $0x0, 0x57e5(%rip)      # 0x9708
callq 0x1060
cltq
movslq %ebx, %rcx
movq %r15, %rsi
subq %rcx, %rsi
cqto
idivq %rsi
cmpl $0x2, 0x41f1(%rip)      # 0x8130
jne 0x3f47
movl 0x41f5(%rip), %edx      # 0x813c
movslq %ebp, %r13
movl %edx, (%r12,%r13,4)
movslq %edx, %r12
xorl %ebp, %ebp
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1120
leaq 0x1215(%rip), %rdi      # 0x517c
movl %r13d, %esi
movq %r15, %rdx
movl %r12d, %ecx
movl %ebx, %r8d
movq %r15, %r9
xorl %eax, %eax
callq 0x1030
testl %ebx, %ebx
movl $0x0, %r15d
cmovgl %ebx, %r15d
cmpq %rbp, %r15
je 0x3fcb
movq %r14, %rdi
callq 0x11b0
movsbl %al, %ecx
movq 0x5770(%rip), %rdx      # 0x9710
movl %ecx, (%rdx,%rbp,4)
testl %ecx, %ecx
js 0x3fbd
shll $0x18, %eax
cmpl $0xa000000, %eax        # imm = 0xA000000
jne 0x3fc6
movl $0x1, 0x574d(%rip)      # 0x9708
jmp 0x3fc6
addl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rdx,%rbp,4)
incq %rbp
jmp 0x3f89
pushq $0x5d
popq %rdi
callq 0x1180
jmp 0x3fed
movq 0x4194(%rip), %rsi      # 0x8170
leaq 0x1092(%rip), %rdi      # 0x5075
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4ba8
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/./banco_dados.cpp
// Function: BancoDados::salvarDados()
void BancoDados::salvarDados() {
    try {
        salvarFuncionarios();
        salvarAnimais();
    } catch(char const* msg) {
        cout << "Erro: " << msg << endl;
    }
    
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5dac
movq %rbx, %rdi
callq 0x61a4
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x5da4
movq %rbx, %rdi
callq 0x5120
movq %rax, %rbx
movq 0x20251(%rip), %rdi     # 0x25fc8
leaq 0x112c9(%rip), %rsi     # 0x17047
callq 0x5270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5270
movq %rax, %rdi
callq 0x5160
popq %rbx
jmp 0x53f0
movq %rax, %rbx
callq 0x53f0
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/./banco_dados.cpp
// Function: BancoDados::lerDados()
void BancoDados::lerDados() {
    try {
        lerFuncionarios();
        lerAnimais();
    } catch(char const* msg) {
        cout << "Erro: " << msg << endl << "Caso os arquivos existam,"
         << endl << "Verifique a integridade deles na pasta " << diretorio << endl;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6a12
movq %rbx, %rdi
callq 0x6ea6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x6a0a
movq %r14, %rdi
callq 0x5120
movq %rax, %r14
movq 0x1f62e(%rip), %rdi     # 0x25fc8
leaq 0x106a6(%rip), %rsi     # 0x17047
callq 0x5270
movq %rax, %rdi
movq %r14, %rsi
callq 0x5270
movq %rax, %rdi
callq 0x5160
leaq 0x10758(%rip), %rsi     # 0x17118
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
leaq 0x1075b(%rip), %rsi     # 0x17132
movq %rax, %rdi
callq 0x5270
addq $0x50, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5260
movq %rax, %rdi
callq 0x5160
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x53f0
movq %rax, %r14
callq 0x53f0
movq %r14, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/./banco_dados.cpp
// Function: BancoDados::lerDadosTestes()
void BancoDados::lerDadosTestes() {
    diretorio = "include/dadosDebug/";
    funcArq = diretorio + "funcionarios.csv";
    animalArq = diretorio + "animais.csv";

    try {
        lerFuncionarios();
        lerAnimais();
    } catch(char const* msg) {
        cout << "Erro: " << msg << endl << "Caso os arquivos existam,"
         << endl << "Verifique a integridade deles na pasta " << diretorio << endl;
    }

    diretorio = "dados/";
    funcArq = diretorio + "funcionarios.csv";
    animalArq = diretorio + "animais.csv";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r12
leaq 0x50(%rdi), %rbx
leaq 0xf89b(%rip), %rsi      # 0x1715a
movq %rbx, %rdi
callq 0x5490
leaq 0xf75c(%rip), %rdx      # 0x1702a
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7d4c
leaq 0x10(%r12), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x52f0
movq %r15, %rdi
callq 0x54c8
leaq 0xf740(%rip), %rdx      # 0x1703b
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7d4c
leaq 0x30(%r12), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x52f0
movq %r13, %rdi
callq 0x54c8
movq %r12, %rdi
callq 0x6a12
movq %r12, %rdi
callq 0x6ea6
leaq 0xf6eb(%rip), %rsi      # 0x17023
movq %rbx, %rdi
callq 0x5490
leaq 0xf6e3(%rip), %rdx      # 0x1702a
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7d4c
movq %r14, %rdi
movq %r12, %rsi
callq 0x52f0
movq %r12, %rdi
callq 0x54c8
leaq 0xf6cc(%rip), %rdx      # 0x1703b
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7d4c
movq %r15, %rdi
movq %r14, %rsi
callq 0x52f0
movq %r14, %rdi
callq 0x54c8
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
cmpl $0x1, %edx
jne 0x7a22
movq %r12, %rdi
callq 0x5120
movq %rax, %r12
movq 0x1e610(%rip), %rdi     # 0x25fc8
leaq 0xf688(%rip), %rsi      # 0x17047
callq 0x5270
movq %rax, %rdi
movq %r12, %rsi
callq 0x5270
movq %rax, %rdi
callq 0x5160
leaq 0xf73a(%rip), %rsi      # 0x17118
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
leaq 0xf73d(%rip), %rsi      # 0x17132
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5260
movq %rax, %rdi
callq 0x5160
callq 0x53f0
jmp 0x7931
movq %rax, %r12
callq 0x53f0
movq %r12, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::criarVeterinario()
void Petshop::criarVeterinario() {
    string nome;
    shared_ptr<Veterinario> veterinario = make_shared<Veterinario>();

    if(veterinario->setNome())
        nome = veterinario->getNome();
    else
        throw "Veterinário deve ter um nome válido!";

    if(this->findVeterinario(nome) != nullptr)
        throw "Funcionário já existe!";

    if(!veterinario->setTelefone())
        throw "Veterinário não pode ficar sem telefone";

    if(!veterinario->setEmail())
        throw "Veterinário não pode ficar sem e-mail";

    if(!veterinario->setCRMV())
        throw "Veterinário não pode ficar sem CRMV";

    if(this->adicionarVeterinario(veterinario))
        cout << "Veterinário adicionado ao cadastro." << endl;
    else
        cout << "Houve um erro na operação" << endl << "Cancelando..." << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
callq 0xe99a
movq (%rsp), %rdi
callq 0xfab4
testb %al, %al
je 0xb228
movq (%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0xfaa2
leaq 0x60(%rsp), %r14
leaq 0x40(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x52f0
movq %r15, %rdi
callq 0x54c8
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x5340
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
callq 0xb2b6
leaq 0x48(%rsp), %rdi
movq -0x8(%rdi), %r14
callq 0x8466
leaq 0x20(%rsp), %rdi
callq 0x54c8
testq %r14, %r14
jne 0xb231
movq (%rsp), %rdi
callq 0xfba2
testb %al, %al
je 0xb23a
movq (%rsp), %rdi
callq 0xfc90
testb %al, %al
je 0xb243
movq (%rsp), %rdi
callq 0x10500
testb %al, %al
je 0xb24c
leaq 0x10(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x85b8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe916
leaq 0x18(%rsp), %rdi
callq 0x8466
movq 0x1add5(%rip), %rdi     # 0x25fc8
leaq 0xcd84(%rip), %rsi      # 0x17f7e
callq 0x5270
movq %rax, %rdi
callq 0x5160
leaq 0x8(%rsp), %rdi
callq 0x8466
leaq 0x60(%rsp), %rdi
callq 0x54c8
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xcc97(%rip), %rbx      # 0x17ec6
jmp 0xb253
leaq 0xccb5(%rip), %rbx      # 0x17eed
jmp 0xb253
leaq 0xccc5(%rip), %rbx      # 0x17f06
jmp 0xb253
leaq 0xcce6(%rip), %rbx      # 0x17f30
jmp 0xb253
leaq 0xcd05(%rip), %rbx      # 0x17f58
pushq $0x8
popq %rdi
callq 0x5170
movq %rbx, (%rax)
movq 0x1ad4b(%rip), %rsi     # 0x25fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5410
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8466
jmp 0xb299
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x54c8
jmp 0xb299
jmp 0xb296
jmp 0xb296
movq %rax, %rbx
jmp 0xb2a3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8466
leaq 0x60(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::findVeterinario(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
shared_ptr<Veterinario> Petshop::findVeterinario(string nome) {
    for(auto& vet : this->veterinarios) {
        if(vet->getNome() == nome) {
            return vet;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r13
leaq 0x8(%rsp), %r12
cmpq %r13, %r15
je 0xb306
movq (%r15), %rsi
movq %r12, %rdi
callq 0xfaa2
movq %r12, %rdi
movq %r14, %rsi
callq 0x892c
movl %eax, %ebp
movq %r12, %rdi
callq 0x54c8
testb %bpl, %bpl
jne 0xb30e
addq $0x10, %r15
jmp 0xb2d6
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xb319
movq %rbx, %rdi
movq %r15, %rsi
callq 0x85b8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::criarTratador()
void Petshop::criarTratador() {
    string nome;
    shared_ptr<Tratador> tratador = make_shared<Tratador>();

    if(tratador->setNome())
        nome = tratador->getNome();
    else
        throw "Tratador deve ter um nome válido!";

    if(this->findTratador(nome) != nullptr)
        throw "Funcionário já existe!";

    if(!tratador->setTelefone())
        throw "Tratador não pode ficar sem telefone";

    if(!tratador->setEmail())
        throw "Tratador não pode ficar sem e-mail";

    if(!tratador->setUniforme())
        throw "Tratador não pode ficar sem nível de segurança";

    if(this->adicionarTratador(tratador))
        cout << "Tratador adicionado ao cadastro." << endl;
    else
        cout << "Houve um erro na operação" << endl << "Cancelando..." << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
callq 0xe9b5
movq (%rsp), %rdi
callq 0xfab4
testb %al, %al
je 0xb468
movq (%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0xfaa2
leaq 0x60(%rsp), %r14
leaq 0x40(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x52f0
movq %r15, %rdi
callq 0x54c8
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x5340
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
callq 0xb4f6
leaq 0x48(%rsp), %rdi
movq -0x8(%rdi), %r14
callq 0x8466
leaq 0x20(%rsp), %rdi
callq 0x54c8
testq %r14, %r14
jne 0xb471
movq (%rsp), %rdi
callq 0xfba2
testb %al, %al
je 0xb47a
movq (%rsp), %rdi
callq 0xfc90
testb %al, %al
je 0xb483
movq (%rsp), %rdi
callq 0xfeee
testb %al, %al
je 0xb48c
leaq 0x10(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x85cc
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe942
leaq 0x18(%rsp), %rdi
callq 0x8466
movq 0x1ab95(%rip), %rdi     # 0x25fc8
leaq 0xcc08(%rip), %rsi      # 0x18042
callq 0x5270
movq %rax, %rdi
callq 0x5160
leaq 0x8(%rsp), %rdi
callq 0x8466
leaq 0x60(%rsp), %rdi
callq 0x54c8
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xcb34(%rip), %rbx      # 0x17fa3
jmp 0xb493
leaq 0xca75(%rip), %rbx      # 0x17eed
jmp 0xb493
leaq 0xcb45(%rip), %rbx      # 0x17fc6
jmp 0xb493
leaq 0xcb62(%rip), %rbx      # 0x17fec
jmp 0xb493
leaq 0xcb7d(%rip), %rbx      # 0x18010
pushq $0x8
popq %rdi
callq 0x5170
movq %rbx, (%rax)
movq 0x1ab0b(%rip), %rsi     # 0x25fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5410
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8466
jmp 0xb4d9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x54c8
jmp 0xb4d9
jmp 0xb4d6
jmp 0xb4d6
movq %rax, %rbx
jmp 0xb4e3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8466
leaq 0x60(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::findTratador(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
shared_ptr<Tratador> Petshop::findTratador(string nome) {
    for(auto& trata : this->tratadores) {
        if(trata->getNome() == nome) {
            return trata;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %r15
movq 0x20(%rsi), %r13
leaq 0x8(%rsp), %r12
cmpq %r13, %r15
je 0xb547
movq (%r15), %rsi
movq %r12, %rdi
callq 0xfaa2
movq %r12, %rdi
movq %r14, %rsi
callq 0x892c
movl %eax, %ebp
movq %r12, %rdi
callq 0x54c8
testb %bpl, %bpl
jne 0xb54f
addq $0x10, %r15
jmp 0xb517
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xb55a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x85cc
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::findAnimal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
shared_ptr<Animal> Petshop::findAnimal(string nome, string especie) {
    for(auto& animal : this->animais) {
        if(animal->getNome() == nome && animal->getEspecie() == especie) {
            return animal;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rdi, 0x8(%rsp)
movq 0x30(%rsi), %r12
movq 0x38(%rsi), %r14
leaq 0x18(%rsp), %r13
leaq 0x38(%rsp), %rbp
cmpq %r14, %r12
je 0xbf34
movq (%r12), %rsi
movq %r13, %rdi
callq 0x10bbc
movq %r13, %rdi
movq %r15, %rsi
callq 0x892c
testb %al, %al
je 0xbf26
movq (%r12), %rsi
movq %rbp, %rdi
callq 0x10caa
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x892c
movl %eax, %ebx
movq %rbp, %rdi
callq 0x54c8
movq %r13, %rdi
callq 0x54c8
testb %bl, %bl
je 0xbf2e
jmp 0xbf41
movq %r13, %rdi
callq 0x54c8
addq $0x10, %r12
jmp 0xbed5
xorps %xmm0, %xmm0
movq 0x8(%rsp), %rbx
movups %xmm0, (%rbx)
jmp 0xbf51
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x84e2
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::excluirAnimal(std::shared_ptr<Animal>)
shared_ptr<Animal> Petshop::excluirAnimal(shared_ptr<Animal> removido) {
    int index = 0;

    for(auto& animal : this->animais) {
        if(animal == removido) {
            shared_ptr<Animal> ptr_removido = animal;
            this->animais.erase(this->animais.begin() + index);
            Debug("Animal: " << ptr_removido->getNome() << " removido do registro.");
            return ptr_removido;
        }
        index++;
    }

    return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x30(%rsi), %r14
movq 0x30(%rsi), %rsi
movq 0x38(%rax), %rax
xorl %r15d, %r15d
cmpq %rax, %rsi
je 0xdea3
movq (%rsi), %rcx
cmpq (%rdx), %rcx
je 0xdeab
addq $0x10, %rsi
addq $-0x10, %r15
jmp 0xde8c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xdec1
movq %rbx, %rdi
callq 0x84e2
movq (%r14), %rsi
subq %r15, %rsi
movq %r14, %rdi
callq 0xeabe
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x8466
movq %r14, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::excluirVeterinario(std::shared_ptr<Veterinario>)
shared_ptr<Veterinario> Petshop::excluirVeterinario(shared_ptr<Veterinario> removido) {
    int index = 0;

    for(auto& vet : this->veterinarios) {
        if(vet == removido) {
            shared_ptr<Veterinario> ptr_removido = vet;
            this->veterinarios.erase(this->veterinarios.begin() + index);
            Debug("Veterinario: " << ptr_removido->getNome() << " removido do registro.");
            return ptr_removido;
        }
        index++;
    }

    return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rax
xorl %r15d, %r15d
cmpq %rax, %rsi
je 0xe29a
movq (%rsi), %rcx
cmpq (%rdx), %rcx
je 0xe2a2
addq $0x10, %rsi
addq $-0x10, %r15
jmp 0xe283
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xe2b8
movq %rbx, %rdi
callq 0x85b8
movq (%r14), %rsi
subq %r15, %rsi
movq %r14, %rdi
callq 0xeab2
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x8466
movq %r14, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::excluirTratador(std::shared_ptr<Tratador>)
shared_ptr<Tratador> Petshop::excluirTratador(shared_ptr<Tratador> removido) {
    int index = 0;

    for(auto& tratador : this->tratadores) {
        if(tratador == removido) {
            shared_ptr<Tratador> ptr_removido = tratador;
            this->tratadores.erase(this->tratadores.begin() + index);
            Debug("Tratador: " << ptr_removido->getNome() << " removido do registro.");
            return ptr_removido;
        }
        index++;
    }

    return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x18(%rsi), %r14
movq 0x18(%rsi), %rsi
movq 0x20(%rax), %rax
xorl %r15d, %r15d
cmpq %rax, %rsi
je 0xe697
movq (%rsi), %rcx
cmpq (%rdx), %rcx
je 0xe69f
addq $0x10, %rsi
addq $-0x10, %r15
jmp 0xe680
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xe6b5
movq %rbx, %rdi
callq 0x85cc
movq (%r14), %rsi
subq %r15, %rsi
movq %r14, %rdi
callq 0xeab8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x8466
movq %r14, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/funcionarios/pessoa.cpp
// Function: Pessoa::setNome()
bool Pessoa::setNome() {
    string s;
    cout << endl << "Nome: " << endl;
    getline(cin, s);

    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->nome = s;
    
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x164f2(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x9317(%rip), %rsi      # 0x18df9
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x164e7(%rip), %rdi     # 0x25fe0
leaq 0x8(%rsp), %rsi
callq 0x5060
leaq 0x8(%rsp), %rdi
pushq $0x3b
popq %rsi
xorl %edx, %edx
callq 0x5320
cmpq $-0x1, %rax
jne 0xfb4d
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0xfb33
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5190
testq %r14, %r14
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x5170
leaq 0x92a4(%rip), %rcx      # 0x18e00
movq %rcx, (%rax)
movq 0x1644a(%rip), %rsi     # 0x25fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/funcionarios/pessoa.cpp
// Function: Pessoa::setTelefone()
bool Pessoa::setTelefone() {
    string s;
    cout << endl << "Telefone: " << endl;
    getline(cin, s);

    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->telefone = s;
    
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x16404(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x925c(%rip), %rsi      # 0x18e2c
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x163f9(%rip), %rdi     # 0x25fe0
leaq 0x8(%rsp), %rsi
callq 0x5060
leaq 0x8(%rsp), %rdi
pushq $0x3b
popq %rsi
xorl %edx, %edx
callq 0x5320
cmpq $-0x1, %rax
jne 0xfc3b
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0xfc21
addq $0x28, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5190
testq %r14, %r14
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x5170
leaq 0x91b6(%rip), %rcx      # 0x18e00
movq %rcx, (%rax)
movq 0x1635c(%rip), %rsi     # 0x25fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/funcionarios/pessoa.cpp
// Function: Pessoa::setEmail()
bool Pessoa::setEmail() {
    string s;
    cout << endl << "E-mail: " << endl;
    getline(cin, s);

    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->email = s;
    
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x16316(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x9179(%rip), %rsi      # 0x18e37
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x1630b(%rip), %rdi     # 0x25fe0
leaq 0x8(%rsp), %rsi
callq 0x5060
leaq 0x8(%rsp), %rdi
pushq $0x3b
popq %rsi
xorl %edx, %edx
callq 0x5320
cmpq $-0x1, %rax
jne 0xfd29
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0xfd0f
addq $0x48, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5190
testq %r14, %r14
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x5170
leaq 0x90c8(%rip), %rcx      # 0x18e00
movq %rcx, (%rax)
movq 0x1626e(%rip), %rsi     # 0x25fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/funcionarios/tratador.cpp
// Function: Tratador::setUniforme()
bool Tratador::setUniforme() {
    string s;
    cout << endl << "Nível de segurança do tratador: " << endl;
    cout << "V - verde" << endl;
    cout << "A - azul" << endl;
    cout << "M - vermelho" << endl;
    getline(cin, s);

    switch(toupper(s[0])) {
        case 'V':
            this->uniforme = Verde;
            break;
        case 'A':
            this->uniforme = Azul;
            break;
        case 'M':
            this->uniforme = Vermelho;
            break;
        default:
            return false;
            break;
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x160b9(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x8f2d(%rip), %rsi      # 0x18e48
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x16096(%rip), %rdi     # 0x25fc8
leaq 0x8f32(%rip), %rsi      # 0x18e6b
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x1607b(%rip), %rdi     # 0x25fc8
leaq 0x8f21(%rip), %rsi      # 0x18e75
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x16060(%rip), %rdi     # 0x25fc8
leaq 0x8f0f(%rip), %rsi      # 0x18e7e
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x1605d(%rip), %rdi     # 0x25fe0
leaq 0x8(%rsp), %rsi
callq 0x5060
movq 0x8(%rsp), %rax
movsbl (%rax), %edi
callq 0x5460
cmpl $0x41, %eax
je 0xffb1
cmpl $0x4d, %eax
je 0xffad
xorl %ebp, %ebp
cmpl $0x56, %eax
je 0xffb4
jmp 0xffba
pushq $0x2
jmp 0xffb3
pushq $0x1
popq %rbp
movl %ebp, 0x68(%rbx)
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x54c8
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/funcionarios/veterinario.cpp
// Function: Veterinario::setCRMV()
bool Veterinario::setCRMV() {
    string s;
    cout << endl << "CRMV: " << endl;
    getline(cin, s);

    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->CRMV = s;
    
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x15aa6(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x8b13(%rip), %rsi      # 0x19041
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x15a9b(%rip), %rdi     # 0x25fe0
leaq 0x8(%rsp), %rsi
callq 0x5060
leaq 0x8(%rsp), %rdi
pushq $0x3b
popq %rsi
xorl %edx, %edx
callq 0x5320
cmpq $-0x1, %rax
jne 0x10599
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x1057f
addq $0x68, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5190
testq %r14, %r14
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x5170
leaq 0x8858(%rip), %rcx      # 0x18e00
movq %rcx, (%rax)
movq 0x159fe(%rip), %rsi     # 0x25fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/animal.cpp
// Function: Animal::setEspecie()
bool Animal::setEspecie() {
    string s;
    cout << endl << "Espécie: " << endl;
    getline(cin, s);
    
    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->especie = s;
    
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x152ea(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x81cd(%rip), %rsi      # 0x18eb7
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x152df(%rip), %rdi     # 0x25fe0
leaq 0x8(%rsp), %rsi
callq 0x5060
leaq 0x8(%rsp), %rdi
pushq $0x3b
popq %rsi
xorl %edx, %edx
callq 0x5320
cmpq $-0x1, %rax
jne 0x10d55
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x10d3b
addq $0x28, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5190
testq %r14, %r14
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x5170
leaq 0x809c(%rip), %rcx      # 0x18e00
movq %rcx, (%rax)
movq 0x15242(%rip), %rsi     # 0x25fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/animal.cpp
// Function: Animal::setAmeacadoPor()
bool Animal::setAmeacadoPor() {
    string s;
    cout << endl << "Animal ameaçado de extinção por?: " << endl;
    getline(cin, s);
    
    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->ameacadoPor = s;
    
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x151fc(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x80ea(%rip), %rsi      # 0x18ec2
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5160
movq 0x151f1(%rip), %rdi     # 0x25fe0
leaq 0x8(%rsp), %rsi
callq 0x5060
leaq 0x8(%rsp), %rdi
pushq $0x3b
popq %rsi
xorl %edx, %edx
callq 0x5320
cmpq $-0x1, %rax
jne 0x10e43
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x10e29
addq $0x48, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5190
testq %r14, %r14
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x5170
leaq 0x7fae(%rip), %rcx      # 0x18e00
movq %rcx, (%rax)
movq 0x15154(%rip), %rsi     # 0x25fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5410
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430
nop
// File: /workspace/github_cpp_makefile_star2_O2/brashi[P]PetFera/src/animal/animal.cpp
// Function: Animal::setPerigoso()
bool Animal::setPerigoso() {
    string s;
    cout << endl << "É perigoso? (S/N): ";
    getline(cin, s);
    
    if(toupper(s[0]) == 'S')
        this->perigoso = true;
    else if(toupper(s[0]) == 'N')
        this->perigoso = false;
    else
        return false;

    return true;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x150e2(%rip), %rdi     # 0x25fc8
callq 0x5160
leaq 0x7ff6(%rip), %rsi      # 0x18ee8
movq %rax, %rdi
callq 0x5270
movq 0x150df(%rip), %rdi     # 0x25fe0
movq %rsp, %rsi
callq 0x5060
movq (%rsp), %rax
movsbl (%rax), %edi
callq 0x5460
cmpl $0x4e, %eax
je 0x10f25
movb $0x1, %cl
cmpl $0x53, %eax
je 0x10f27
xorl %ebx, %ebx
jmp 0x10f2f
xorl %ecx, %ecx
movb %cl, 0x88(%rbx)
movb $0x1, %bl
movq %rsp, %rdi
callq 0x54c8
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54c8
movq %rbx, %rdi
callq 0x5430