LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: bwrite(bool*, int, int, int)
int bwrite(bool *u,int s,int l,int a){ 
    int c = s+l-loga(a);
    int e=a;
    for(int i=s+l-1;i>=s;i--){
        if(i<c){u[i]=0;continue;}
        if(e%2==0){u[i]=0;}else{u[i]=1;e--;}
        e/=2;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %edi
callq 0x1320
movl %eax, %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x14ac
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1460
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x14a1
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x147e
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x1493
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1442
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: logb(unsigned int, int, bool*)
void logb(unsigned int u,int n,bool *ar){
    unsigned int e = u;
    bool c[n];
    for(int i=n-1;i>=0;i--){
        c[i] = e%2;
        e /=2;
    }
    for(int i=0;i<n;i++){ar[kad]=c[i];kad++;}
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x153a
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
andl $0x1, %ecx
cmpl $0x0, %ecx
setne %dl
movslq -0x2c(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x14(%rbp)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1507
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x157f
movq -0x38(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq 0x4c4d(%rip), %rcx      # 0x61ac
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl 0x4c41(%rip), %eax      # 0x61ac
addl $0x1, %eax
movl %eax, 0x4c38(%rip)      # 0x61ac
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1541
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: logg(unsigned int, bool*)
void logg(unsigned int u, bool *ar){ 
    if(u<1){printf("under 0(%d) cannot be express in elias ganma\n",u);return;}
    int l = loga(u);
    for(int i=1;i<l;i++){ar[kad]=0;kad++;}
    logb(u,l,ar);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x4(%rbp)
jae 0x15b8
movl -0x4(%rbp), %esi
leaq 0x2a55(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x1030
jmp 0x160a
movl -0x4(%rbp), %edi
callq 0x1320
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x15fb
movq -0x10(%rbp), %rax
movslq 0x4bcf(%rip), %rcx      # 0x61ac
movb $0x0, (%rax,%rcx)
movl 0x4bc5(%rip), %eax      # 0x61ac
addl $0x1, %eax
movl %eax, 0x4bbc(%rip)      # 0x61ac
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x15ca
movl -0x4(%rbp), %edi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x14c0
addq $0x20, %rsp
popq %rbp
retq
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: diff(unsigned int*, int, int)
void diff(unsigned int *T,int s,int n){
    for(int i=n-2;i>=0;i--){
        if(T[s+i+1]>=T[s+i]){T[s+i+1] = T[s+i+1] - T[s+i];}
        else{T[s+i+1] = T[s+i] - T[s+i+1];}
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x1744
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl -0x14(%rbp), %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jb 0x16fe
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
subl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1734
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
subl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1736
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1697
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: cd1(int, bool*)
int cd1(int x,bool *ar){ //unary x
    if(x==0){ar[kad2]=0;kad2++;return 0;}
    ar[kad2]=1;kad2++;
    return cd1(x-1,ar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x17cc
movq -0x10(%rbp), %rax
movslq 0x4a00(%rip), %rcx      # 0x61b0
movb $0x0, (%rax,%rcx)
movl 0x49f6(%rip), %eax      # 0x61b0
addl $0x1, %eax
movl %eax, 0x49ed(%rip)      # 0x61b0
movl $0x0, -0x4(%rbp)
jmp 0x17fc
movq -0x10(%rbp), %rax
movslq 0x49d9(%rip), %rcx      # 0x61b0
movb $0x1, (%rax,%rcx)
movl 0x49cf(%rip), %eax      # 0x61b0
addl $0x1, %eax
movl %eax, 0x49c6(%rip)      # 0x61b0
movl -0x8(%rbp), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rsi
callq 0x1790
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: fano(int*, int, int, int, bool*, bool*)
int fano(int *T,int s,int n,int p,bool *ar,bool *ar2){
    kad = 0;
    kad2 = 0;
    int topofs = 0;
    int t = ppow(p);
    //printf("\np=%d / t=%d",p,t);
    for(int i=s;i<n;i++){
        cd1(T[i]/t-topofs,ar2);
        topofs = T[i]/t;
        logb(T[i]%t,p,ar);
    }
    Sizelist[9] = kad2;
    Sizelist[10] = kad;
    return kad/8 + kad2/8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl $0x0, 0x4975(%rip)      # 0x61ac
movl $0x0, 0x496f(%rip)      # 0x61b0
movl $0x0, -0x2c(%rbp)
movl -0x14(%rbp), %edi
callq 0x1750
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x18b8
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cltd
idivl -0x30(%rbp)
movl %eax, %edi
subl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x1790
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cltd
idivl -0x30(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cltd
idivl -0x30(%rbp)
movl %edx, %edi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x14c0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1859
movl 0x48f2(%rip), %eax      # 0x61b0
movl %eax, 0x48a0(%rip)      # 0x6164
movl 0x48e2(%rip), %eax      # 0x61ac
movl %eax, 0x4898(%rip)      # 0x6168
movl 0x48d6(%rip), %eax      # 0x61ac
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x38(%rbp)
movl 0x48c9(%rip), %eax      # 0x61b0
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x38(%rbp), %eax
addl %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: fano0(unsigned int*, int*, bool*)
void fano0(unsigned int *D,int *D_2,bool *ar){
    kad = 0;
    ccs[kad]=0;cc2s[kad]=0;kad++;
    int r = 0;
    for(int i=0;i<dc2s[loops];i++){
        int h = D[D_2[i]];
        if(i>0){h = D[D_2[i]]-D[D_2[i-1]];}
        if(h<0){h=D[D_2[i]];cc2s[kad]=i+r;ccs[kad]=r;kad++;}
        cd1(h,ar); 
        r+=h;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, 0x488e(%rip)      # 0x61ac
movslq 0x4887(%rip), %rcx      # 0x61ac
leaq 0x4934(%rip), %rax      # 0x6260
movl $0x0, (%rax,%rcx,4)
movslq 0x4872(%rip), %rcx      # 0x61ac
leaq 0x496f(%rip), %rax      # 0x62b0
movl $0x0, (%rax,%rcx,4)
movl 0x485e(%rip), %eax      # 0x61ac
addl $0x1, %eax
movl %eax, 0x4855(%rip)      # 0x61ac
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movslq 0x47bd(%rip), %rdx      # 0x612c
leaq 0x489a(%rip), %rcx      # 0x6210
cmpl (%rcx,%rdx,4), %eax
jge 0x1a42
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0x19c9
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movl -0x20(%rbp), %esi
subl $0x1, %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x1a1f
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %edx
addl -0x1c(%rbp), %edx
movslq 0x47ba(%rip), %rcx      # 0x61ac
leaq 0x48b7(%rip), %rax      # 0x62b0
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movslq 0x47a6(%rip), %rcx      # 0x61ac
leaq 0x4853(%rip), %rax      # 0x6260
movl %edx, (%rax,%rcx,4)
movl 0x4796(%rip), %eax      # 0x61ac
addl $0x1, %eax
movl %eax, 0x478d(%rip)      # 0x61ac
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x1790
movl -0x24(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1965
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: dmlen(int, unsigned int*, int*)
int dmlen(int p,unsigned int *D,int *D_2){
    int u = 0;
    for(int i=D_2[p];i<D_2[p+1];i++){
        if(i!=D_2[p]){
            if(D[i]<D[i-1] && u==0){u=D_2[p+1]-i;break;}
        }
    }
    if(u==D_2[p+1]-D_2[p]-1){ //set for some exception
        for(int o = loops-1;o>0;o--){
            if(p>=dc2s[o]){
                exceptr[o] = p;
                break;
            }
        }
    }
    if(u>0){u = D_2[p+1]-D_2[p]-u;}
    else{u=1;}
    return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x1ae3
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x4(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x1ad6
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jae 0x1ad4
cmpl $0x0, -0x1c(%rbp)
jne 0x1ad4
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1ae3
jmp 0x1ad6
jmp 0x1ad8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1a74
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
movq -0x18(%rbp), %rdx
movslq -0x4(%rbp), %rsi
subl (%rdx,%rsi,4), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1b4f
movl 0x461e(%rip), %eax      # 0x612c
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x1b4d
movl -0x4(%rbp), %eax
movslq -0x24(%rbp), %rdx
leaq 0x46e8(%rip), %rcx      # 0x6210
cmpl (%rcx,%rdx,4), %eax
jl 0x1b40
movl -0x4(%rbp), %edx
movslq -0x24(%rbp), %rcx
leaq 0x47c5(%rip), %rax      # 0x6300
movl %edx, (%rax,%rcx,4)
jmp 0x1b4d
jmp 0x1b42
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1b14
jmp 0x1b4f
cmpl $0x0, -0x1c(%rbp)
jle 0x1b78
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x4(%rbp), %rdx
subl (%rcx,%rdx,4), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b7f
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: cmlen(int*, int, int, bool*)
int cmlen(int *m,int p,int l,bool *ar){ 
    kad = 0;
    int u = 0;
    for(int i=0;i<l;i++){
        if(i!=0){
            int tm = m[p+i]-m[p+i-1];
            if(tm<0){
                if(u==0){u=i;}
                tm=-tm;
            }
            logg(tm+1,ar);
        }
    }
    if(u<=0){u=1;}
    return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, 0x45fc(%rip)      # 0x61ac
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1c28
cmpl $0x0, -0x20(%rbp)
je 0x1c1b
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl -0x20(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x1c0c
cmpl $0x0, -0x1c(%rbp)
jne 0x1c04
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
addl $0x1, %edi
movq -0x18(%rbp), %rsi
callq 0x1590
jmp 0x1c1d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1bbe
cmpl $0x0, -0x1c(%rbp)
jg 0x1c35
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: gread(int, bool*)
int gread(int p,bool *ar){
    int i = 0;
    while(1){
        if(ar[p+i]==1){break;}
        i++;}
    int u = i;
    int a = 0;
    while(u>=0){
        a*=2;a+=ar[p+i];i++;u--;}
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1c6e
jmp 0x1c79
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c52
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x1cc3
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c86
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: rank1(bool*, int, int)
int rank1(bool *u,int ar,int s){ //bool配列u上の，sから始まってar文字までの1の個数を返す()．
    if(s<0){printf("[Error]rank1() with position s\n");exit(0);}
    if(ar<=0){return 0;}
    int e = 0;
    for(int i=s;i<s+ar;i++){
        if(u[i]==1){e++;}
    }
    return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x1cfd
leaq 0x2343(%rip), %rdi      # 0x4032
movb $0x0, %al
callq 0x1030
xorl %edi, %edi
callq 0x1120
cmpl $0x0, -0x14(%rbp)
jg 0x1d0c
movl $0x0, -0x4(%rbp)
jmp 0x1d57
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x18(%rbp), %ecx
addl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1d51
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1d44
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d46
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1d19
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: srank1(int, bool*, int*, unsigned short*, int, int)
int srank1(int c,bool *u,int *u2,unsigned short int *u3,int t2,int t3){
    if(c<=0){return 0;}
    int r = c/lpurse;
    int nk = (c - r*lpurse)/spurse;
    int s =0;int e = 0;
    if(r>0){
        s = lpurse*r;
        e = u2[r-1];}
    if(nk>0){
        e+=u3[r*spursesuu+nk];
        s+=nk*spurse;}
    for(int i=s;i<c;i++){if(u[i]==1){e++;}}
    return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
cmpl $0x0, -0x8(%rbp)
jg 0x1d8d
movl $0x0, -0x4(%rbp)
jmp 0x1e5a
movl -0x8(%rbp), %eax
cltd
idivl 0x4399(%rip)            # 0x6130
movl %eax, -0x2c(%rbp)
movl -0x8(%rbp), %eax
movl -0x2c(%rbp), %ecx
imull 0x4389(%rip), %ecx      # 0x6130
subl %ecx, %eax
cltd
idivl 0x4384(%rip)            # 0x6134
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x1de7
movl 0x4363(%rip), %eax      # 0x6130
imull -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x30(%rbp)
jle 0x1e1b
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
imull 0x4555(%rip), %ecx      # 0x6350
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x30(%rbp), %eax
imull 0x431f(%rip), %eax      # 0x6134
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1e54
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1e47
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1e49
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1e21
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: getd2(int)
int getd2(int tgm){
    int tgm2 = select0(d2top,d2topsub,d2topsub2,tgm+1,Sizelist[9],Sizelist[5],Sizelist[6]); //tgm2 = その位置までの1の数を見る．
    int tgm3 = srank1(tgm2,d2top,d2topsub,d2topsub2,Sizelist[5],Sizelist[6]);
    int tgm4 = bread(d2under,tgm*6,6);
    return tgm3*64+tgm4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x42ae(%rip), %rdi      # 0x63b0
movq 0x426f(%rip), %rsi      # 0x6378
movq 0x4250(%rip), %rdx      # 0x6360
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movl 0x4047(%rip), %r8d      # 0x6164
movl 0x4030(%rip), %r9d      # 0x6154
movl 0x402e(%rip), %eax      # 0x6158
movl %eax, (%rsp)
callq 0x1e60
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
movq 0x4271(%rip), %rsi      # 0x63b0
movq 0x4232(%rip), %rdx      # 0x6378
movq 0x4213(%rip), %rcx      # 0x6360
movl 0x4000(%rip), %r8d      # 0x6154
movl 0x3ffd(%rip), %r9d      # 0x6158
callq 0x1d60
movl %eax, -0xc(%rbp)
movq 0x423e(%rip), %rdi      # 0x63a8
imull $0x6, -0x4(%rbp), %esi
movl $0x6, %edx
callq 0x1380
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
shll $0x6, %eax
addl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: gethead(int)
int gethead(int tgm){
    int tgm2 = select0(k3,k3sub,k3sub2,tgm+1,Sizelist[8],Sizelist[3],Sizelist[4]); //tgm2 = その位置までの1の数を見る．
    int tgm3 = srank1(tgm2,k3,k3sub,k3sub2,Sizelist[3],Sizelist[4]); //その位置までの1の数 = 開始文字.
    for(int o = loops-1;o>0;o--){
            if(tgm2>=cc2s[o]){tgm3-=ccs[o];break;}
    }
    return tgm3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x41fe(%rip), %rdi      # 0x63a0
movq 0x41d7(%rip), %rsi      # 0x6380
movq 0x41b8(%rip), %rdx      # 0x6368
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movl 0x3fa3(%rip), %r8d      # 0x6160
movl 0x3f88(%rip), %r9d      # 0x614c
movl 0x3f86(%rip), %eax      # 0x6150
movl %eax, (%rsp)
callq 0x1e60
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
movq 0x41c1(%rip), %rsi      # 0x63a0
movq 0x419a(%rip), %rdx      # 0x6380
movq 0x417b(%rip), %rcx      # 0x6368
movl 0x3f58(%rip), %r8d      # 0x614c
movl 0x3f55(%rip), %r9d      # 0x6150
callq 0x1d60
movl %eax, -0xc(%rbp)
movl 0x3f23(%rip), %eax      # 0x612c
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x224d
movl -0x8(%rbp), %eax
movslq -0x10(%rbp), %rdx
leaq 0x408d(%rip), %rcx      # 0x62b0
cmpl (%rcx,%rdx,4), %eax
jl 0x2240
movslq -0x10(%rbp), %rcx
leaq 0x402d(%rip), %rax      # 0x6260
movl (%rax,%rcx,4), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x224d
jmp 0x2242
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x220f
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: psread(int, bool*, int, int, int)
int psread(int p,bool *ar,int D2start,int D2end,int basekey){
    printf("[%d]%d ",D2start,basekey);
    int a;
    int turnsl = 0;
    int st = D2start;
    for(int i = 0;i<1000;i++){
        a = gread(st,ar);
        st += 2*loga(a)-1;
        if(i>0){
            if(i>=turnsl){basekey-=a-1;}
            else{basekey += a-1;}
            printf("%d ",basekey);
        }
        else{
            turnsl = a;
            if(a==1){turnsl=65535;}
        }
        if(st>=D2end){break;}
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0x14(%rbp), %esi
movl -0x1c(%rbp), %edx
leaq 0x1dcc(%rip), %rdi      # 0x4052
movb $0x0, %al
callq 0x1030
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x3e8, -0x2c(%rbp)     # imm = 0x3E8
jge 0x233c
movl -0x28(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1c40
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x1320
shll %eax
subl $0x1, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x230d
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x22ee
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x22fa
movl -0x20(%rbp), %eax
subl $0x1, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
leaq 0x1d52(%rip), %rdi      # 0x4056
movb $0x0, %al
callq 0x1030
jmp 0x2322
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x20(%rbp)
jne 0x2320
movl $0xffff, -0x24(%rbp)    # imm = 0xFFFF
jmp 0x2322
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x232c
jmp 0x233c
jmp 0x232e
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x22a1
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: uhdisp(int)
void uhdisp(int tgm){
    printf("\n%d:",tgm);
    int D2start = getd2(tgm);
    int D2end = getd2(tgm+1);
    int tgm3 = gethead(tgm);
    psread(tgm,k,D2start,D2end,tgm3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq 0x1cf5(%rip), %rdi      # 0x405a
movb $0x0, %al
callq 0x1030
movl -0x4(%rbp), %edi
callq 0x20f0
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x20f0
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
callq 0x2190
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq 0x3ffe(%rip), %rsi      # 0x6398
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
callq 0x2260
addq $0x10, %rsp
popq %rbp
retq
nop
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: queryload(int*)
int queryload(int *m){
    char qname[] = "query.txt";
    char chr;
    FILE *fp;
    long long int 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;}
    }
    return (int)qsize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movabsq $0x78742e7972657571, %rax # imm = 0x78742E7972657571
movq %rax, -0x20(%rbp)
movw $0x74, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x20(%rbp), %rsi
movl $0x2, %edx
callq 0x3840
movq -0x80(%rbp), %rdi
callq 0x1140
movq %rax, -0x78(%rbp)
jmp 0x26b8
leaq -0x60(%rbp), %rdi
callq 0x3920
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq 0x19d1(%rip), %rsi      # 0x40a5
callq 0x1100
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2716
leaq -0x20(%rbp), %rsi
leaq 0x19b8(%rip), %rdi      # 0x40a7
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x277b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3920
jmp 0x2787
movl $0x0, -0x70(%rbp)
movl $0x0, -0x70(%rbp)
movslq -0x70(%rbp), %rax
cmpq -0x38(%rbp), %rax
jge 0x2774
movq -0x30(%rbp), %rdi
callq 0x1170
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x70(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jge 0x2767
movsbl -0x21(%rbp), %edx
addl $0x100, %edx            # imm = 0x100
movq -0x10(%rbp), %rax
movslq -0x70(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2769
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x2724
movq -0x38(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x1180
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: bfwrite(bool*, int, _IO_FILE*)
void bfwrite(bool *ar,int mx,FILE *fp){ //ビット列arをmx個書き込む
    int ps = 0;
    unsigned char a;
    while(ps<mx){
        a = ar[ps]*128;
        if(ps+1<mx){a += ar[ps+1]*64;}
        if(ps+2<mx){a += ar[ps+2]*32;}
        if(ps+3<mx){a += ar[ps+3]*16;}
        if(ps+4<mx){a += ar[ps+4]*8;}
        if(ps+5<mx){a += ar[ps+5]*4;}
        if(ps+6<mx){a += ar[ps+6]*2;}
        if(ps+7<mx){a += ar[ps+7]*1;}
        fwrite(&a, sizeof(unsigned char),1,fp);
        ps+=8;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2922
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
shll $0x7, %eax
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cmpl -0xc(%rbp), %eax
jge 0x27f8
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x6, %ecx
movzbl -0x1d(%rbp), %eax
addl %ecx, %eax
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
addl $0x2, %eax
cmpl -0xc(%rbp), %eax
jge 0x2824
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x5, %ecx
movzbl -0x1d(%rbp), %eax
addl %ecx, %eax
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
addl $0x3, %eax
cmpl -0xc(%rbp), %eax
jge 0x2850
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x4, %ecx
movzbl -0x1d(%rbp), %eax
addl %ecx, %eax
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
addl $0x4, %eax
cmpl -0xc(%rbp), %eax
jge 0x287c
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x3, %ecx
movzbl -0x1d(%rbp), %eax
addl %ecx, %eax
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
addl $0x5, %eax
cmpl -0xc(%rbp), %eax
jge 0x28a8
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x5, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x2, %ecx
movzbl -0x1d(%rbp), %eax
addl %ecx, %eax
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
addl $0x6, %eax
cmpl -0xc(%rbp), %eax
jge 0x28d3
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x6, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %ecx
shll %ecx
movzbl -0x1d(%rbp), %eax
addl %ecx, %eax
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
addl $0x7, %eax
cmpl -0xc(%rbp), %eax
jge 0x28ff
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x7, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %ecx
shll $0x0, %ecx
movzbl -0x1d(%rbp), %eax
addl %ecx, %eax
movb %al, -0x1d(%rbp)
movq -0x18(%rbp), %rcx
leaq -0x1d(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x11b0
movl -0x1c(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27aa
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: shelp()
int shelp(){
    printf("--Simple Usage------------------\n");
    printf("\nRead 'index' and make 'codeindex'. \n");
    printf("This file needs for locating in idx_uni. \n");
    printf("Make sure that running 'gcis' and make file 'index' first before running 'gcis_uni'. \n");
    printf(": ./gcis_uni_build \n");
    printf("\nYou can set the name of inputfile by using option -i. \n");
    printf(": ./gcis_uni_build -i <inputfile>\n");
    printf("\nYou can set the name of outputfile by using option -o. \n");
    printf(": ./gcis_uni_build -o <outputfile>\n");
    printf("\n");
    printf("\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x152b(%rip), %rdi      # 0x40c6
movb $0x0, %al
callq 0x1030
leaq 0x153f(%rip), %rdi      # 0x40e8
movb $0x0, %al
callq 0x1030
leaq 0x1557(%rip), %rdi      # 0x410e
movb $0x0, %al
callq 0x1030
leaq 0x1574(%rip), %rdi      # 0x4139
movb $0x0, %al
callq 0x1030
leaq 0x15bd(%rip), %rdi      # 0x4190
movb $0x0, %al
callq 0x1030
leaq 0x15c4(%rip), %rdi      # 0x41a5
movb $0x0, %al
callq 0x1030
leaq 0x15ef(%rip), %rdi      # 0x41de
movb $0x0, %al
callq 0x1030
leaq 0x1604(%rip), %rdi      # 0x4201
movb $0x0, %al
callq 0x1030
leaq 0x1630(%rip), %rdi      # 0x423b
movb $0x0, %al
callq 0x1030
leaq 0x1575(%rip), %rdi      # 0x418e
movb $0x0, %al
callq 0x1030
leaq 0x1567(%rip), %rdi      # 0x418e
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pstuifzand[P]magento-tools/src/magento-config.cpp
// Function: root_end_element_handler(void*, char const*)
void root_end_element_handler(void* udata, const XML_Char* name) {
    user_data* data = (user_data*)udata;
    switch (data->state) {
        case State::ROOT:
            break;
        case State::IN_CONFIG:
            if (strcmp(name, "config") == 0) data->state = State::ROOT;
            break;
        case State::IN_SECTIONS:
            if (strcmp(name, "sections") == 0) data->state = State::IN_CONFIG;
            break;
        case State::IN_SECTION:
            if (strcmp(name, data->section.c_str()) == 0) data->state = State::IN_SECTIONS;
            break;
        case State::IN_GROUPS:
            if (strcmp(name, "groups") == 0) data->state = State::IN_SECTION;
            break;
        case State::IN_GROUP:
            if (strcmp(name, data->group.c_str()) == 0) data->state = State::IN_GROUPS;
            break;
        case State::IN_FIELDS:
            if (strcmp(name, "fields") == 0) data->state = State::IN_GROUP;
            break;
        case State::IN_FIELD:
            if (strcmp(name, data->field.c_str()) == 0) data->state = State::IN_FIELDS;
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x7, %eax
ja 0x281e
movq -0x20(%rbp), %rax
leaq 0x3936(%rip), %rcx      # 0x6020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x281e
movq -0x10(%rbp), %rdi
leaq 0x39af(%rip), %rsi      # 0x60b2
callq 0x2270
cmpl $0x0, %eax
jne 0x2717
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x281e
movq -0x10(%rbp), %rdi
leaq 0x3992(%rip), %rsi      # 0x60b9
callq 0x2270
cmpl $0x0, %eax
jne 0x273b
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
jmp 0x281e
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x20b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x2270
cmpl $0x0, %eax
jne 0x2770
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
jmp 0x281e
movq -0x10(%rbp), %rdi
leaq 0x3942(%rip), %rsi      # 0x60c2
callq 0x2270
cmpl $0x0, %eax
jne 0x2794
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
jmp 0x281e
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x20b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x2270
cmpl $0x0, %eax
jne 0x27c9
movq -0x18(%rbp), %rax
movl $0x5, (%rax)
jmp 0x281e
movq -0x10(%rbp), %rdi
leaq 0x38f3(%rip), %rsi      # 0x60c9
callq 0x2270
cmpl $0x0, %eax
jne 0x27ea
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
jmp 0x281e
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x2270
cmpl $0x0, %eax
jne 0x281c
movq -0x18(%rbp), %rax
movl $0x7, (%rax)
jmp 0x281e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pstuifzand[P]magento-tools/src/magento-config.cpp
// Function: character_data_handler(void*, char const*, int)
void character_data_handler(void* udata, const XML_Char* s, int len) {
    user_data* data = (user_data*)udata;
    switch (data->state) {
        case State::ROOT:
            break;
        case State::IN_CONFIG:
            break;
        case State::IN_SECTIONS:
            break;
        case State::IN_SECTION:
            break;
        case State::IN_GROUPS:
            break;
        case State::IN_GROUP:
            break;
        case State::IN_FIELDS:
            break;
        case State::IN_FIELD:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x7, %eax
ja 0x287e
movq -0x28(%rbp), %rax
leaq 0x37db(%rip), %rcx      # 0x6040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x287e
jmp 0x287e
jmp 0x287e
jmp 0x287e
jmp 0x287e
jmp 0x287e
jmp 0x287e
jmp 0x287e
popq %rbp
retq
// File: pstuifzand[P]magento-tools/src/magento-config.cpp
// Function: parse_module_config::operator()(char const*)
void operator()(const char* filename) {
        XML_SetUserData(parser.handle(), &data);
        XML_SetElementHandler(parser.handle(), root_start_element_handler, root_end_element_handler);
        XML_SetCharacterDataHandler(parser.handle(), character_data_handler);

        data.filename = filename;

        std::ifstream in{data.filename};
        if (in) parse_xml(parser, in, &data);
        else std::cerr << "Can't open " << data.filename << "\n";

        parser.reset();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x230(%rbp)
callq 0x3320
movq -0x230(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x2050
movq -0x230(%rbp), %rdi
callq 0x3320
movq %rax, %rdi
leaq -0x9bc(%rip), %rsi      # 0x2430
leaq -0x743(%rip), %rdx      # 0x26b0
callq 0x2180
movq -0x230(%rbp), %rdi
callq 0x3320
movq %rax, %rdi
leaq -0x5de(%rip), %rsi      # 0x2830
callq 0x21f0
movq -0x230(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x22d0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x2220
movb %al, -0x225(%rbp)
jmp 0x2e57
movb -0x225(%rbp), %al
testb $0x1, %al
jne 0x2e63
jmp 0x2ea1
movq -0x230(%rbp), %rdi
movq %rdi, %rdx
addq $0x8, %rdx
leaq -0x218(%rbp), %rsi
callq 0x3340
jmp 0x2e7f
jmp 0x2ef4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x2070
jmp 0x2f17
movq 0x6148(%rip), %rdi      # 0x8ff0
leaq 0x3238(%rip), %rsi      # 0x60e7
callq 0x21a0
movq %rax, -0x238(%rbp)
jmp 0x2ebd
movq -0x238(%rbp), %rdi
movq -0x230(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x21a0
movq %rax, -0x240(%rbp)
jmp 0x2edd
movq -0x240(%rbp), %rdi
leaq 0x31ef(%rip), %rsi      # 0x60da
callq 0x21a0
jmp 0x2ef2
jmp 0x2ef4
movq -0x230(%rbp), %rdi
callq 0x34c0
jmp 0x2f02
leaq -0x218(%rbp), %rdi
callq 0x2070
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pstuifzand[P]magento-tools/src/xml.hpp
// Function: void parse_xml<user_data>(xml_parser&, std::basic_ifstream<char, std::char_traits<char>>&, user_data*)
void parse_xml(xml_parser& parser, std::ifstream& in, T* data) {
    const int size = 1024;
    char buf[size];
    while (in) {
        in.read(buf, size);
        XML_Status ret = XML_Parse(parser.handle(), buf, in.gcount(), in ? 0 : 1);
        if (!ret) {
            XML_Error error = XML_GetErrorCode(parser.handle());
            int line = XML_GetCurrentLineNumber(parser.handle());
            std::cerr << data->filename << ":" << line << ": error: " << XML_ErrorString(error) << "\n";
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x400, -0x1c(%rbp)     # imm = 0x400
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2220
testb $0x1, %al
jne 0x3377
jmp 0x34ab
movq -0x10(%rbp), %rdi
leaq -0x420(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2230
movq -0x8(%rbp), %rdi
callq 0x3320
movq %rax, -0x440(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x438(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22e0
movl %eax, -0x430(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2220
movq -0x440(%rbp), %rdi
movq -0x438(%rbp), %rsi
movl -0x430(%rbp), %edx
movb %al, %r8b
movl $0x1, %ecx
xorl %eax, %eax
testb $0x1, %r8b
cmovnel %eax, %ecx
callq 0x22c0
movl %eax, -0x424(%rbp)
cmpl $0x0, -0x424(%rbp)
jne 0x34a6
movq -0x8(%rbp), %rdi
callq 0x3320
movq %rax, %rdi
callq 0x2240
movl %eax, -0x428(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3320
movq %rax, %rdi
callq 0x2100
movl %eax, -0x42c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq 0x5bad(%rip), %rdi      # 0x8ff0
callq 0x21a0
movq %rax, %rdi
leaq 0x2ca1(%rip), %rsi      # 0x60f3
callq 0x21a0
movq %rax, %rdi
movl -0x42c(%rbp), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x2c86(%rip), %rsi      # 0x60f5
callq 0x21a0
movq %rax, -0x448(%rbp)
movl -0x428(%rbp), %edi
callq 0x2040
movq -0x448(%rbp), %rdi
movq %rax, %rsi
callq 0x21a0
movq %rax, %rdi
leaq 0x2c3b(%rip), %rsi      # 0x60da
callq 0x21a0
jmp 0x34ab
jmp 0x335e
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: swap(Message&, Message&)
void swap(Message& lhs, Message& rhs)
{
	using std::swap;  // not strictly needed in this case, but good habit

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2fa0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2fd0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3000
testb $0x1, %al
jne 0x23dc
jmp 0x2404
leaq -0x20(%rbp), %rdi
callq 0x3030
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3050
leaq -0x20(%rbp), %rdi
callq 0x3080
jmp 0x23c9
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2fa0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2fd0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3000
testb $0x1, %al
jne 0x243d
jmp 0x2465
leaq -0x40(%rbp), %rdi
callq 0x3030
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3050
leaq -0x40(%rbp), %rdi
callq 0x3080
jmp 0x242a
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x30b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x30e0
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x2fa0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x2fd0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3000
testb $0x1, %al
jne 0x24c0
jmp 0x24e8
leaq -0x60(%rbp), %rdi
callq 0x3030
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3110
leaq -0x60(%rbp), %rdi
callq 0x3080
jmp 0x24ad
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x2fa0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x2fd0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3000
testb $0x1, %al
jne 0x2527
jmp 0x2555
leaq -0x80(%rbp), %rdi
callq 0x3030
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3110
leaq -0x80(%rbp), %rdi
callq 0x3080
jmp 0x2511
addq $0x90, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Folder::move_Messages(Folder*)
void Folder::move_Messages(Folder* f)
{
	msgs = std::move(f->msgs); // move the set from f to this Folder
	f->msgs.clear(); // ensure that destroying f is harmless
	for (auto m : msgs) {  // for each Message in this Folder
		m->remFldr(f);     // remove the pointer to the old Folder
		m->addFldr(this);  // insert pointer to this Folder
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3180
movq -0x10(%rbp), %rdi
callq 0x31b0
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3200
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3230
testb $0x1, %al
jne 0x264f
jmp 0x2684
leaq -0x20(%rbp), %rdi
callq 0x3260
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3280
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x32b0
leaq -0x20(%rbp), %rdi
callq 0x32e0
jmp 0x263c
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Folder::operator=(Folder&&)
Folder& Folder::operator=(Folder&& f)
{
	if (this != &f) {
		remove_from_Msgs();  // remove this Folder from the current msgs
		move_Messages(&f);   // make each Message point to this Folder
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x26c4
movq -0x18(%rbp), %rdi
callq 0x26d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Message::move_Folders(Message*)
void Message::move_Folders(Message* m)
{
	folders = std::move(m->folders); // uses set move assignment
	for (auto f : folders) {  // for each Folder
		f->remMsg(m);    // remove the old Message from the Folder
		f->addMsg(this); // add this Message to that Folder
	}
	m->folders.clear();  // ensure that destroying m is harmless
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x33c0
movq -0x38(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2fa0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2fd0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3000
testb $0x1, %al
jne 0x2822
jmp 0x2857
leaq -0x20(%rbp), %rdi
callq 0x3030
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3050
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x3110
leaq -0x20(%rbp), %rdi
callq 0x3080
jmp 0x280f
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x33f0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Message::operator=(Message&&)
Message& Message::operator=(Message&& rhs)
{
	if (this != &rhs) {       // direct check for self-assignment
		remove_from_Folders();
		contents = std::move(rhs.contents); // move assignment
		move_Folders(&rhs); // reset the Folders to point to this Message
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x29f1
movq -0x18(%rbp), %rdi
callq 0x2a00
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2190
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x27c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Message::operator=(Message const&)
Message& Message::operator=(const Message& rhs)
{
	// handle self-assignment by removing pointers before inserting them
	remove_from_Folders();    // update existing Folders
	contents = rhs.contents;  // copy message contents from rhs
	folders = rhs.folders;    // copy Folder pointers from rhs
	add_to_Folders(rhs);      // add this Message to those Folders
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x2a00
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2030
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x3380
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2930
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Folder::operator=(Folder const&)
Folder& Folder::operator=(const Folder& f)
{
	remove_from_Msgs();  // remove this folder from each Message in msgs
	msgs = f.msgs;       // copy the set of Messages from f
	add_to_Messages(f);  // add this folder to each Message in msgs
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x26d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3440
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b30
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)