LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yupyub[P]PathFinding_Visual/Dijkstra.cpp
// Function: Dijkstra::sol_path(int, int)
void Dijkstra::sol_path(int x,int y){
    if(dist[x][y] == 0) return;
    vv.state[x][y] = 1;
    for(int i = 0;i<4;i++){
        int nx = x+dx[i];
        int ny = y+dy[i];
        if(nx<0||ny<0||nx>=vv.N||ny>=vv.M) continue;
        if(dist[nx][ny] == dist[x][y] -1){
            sol_path(nx,ny);
            return;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x4e208, %rax          # imm = 0x4E208
movslq -0xc(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x285d
jmp 0x2949
movq -0x28(%rbp), %rax
addq $0x27100, %rax          # imm = 0x27100
movslq -0xc(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x2949
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
movslq -0x14(%rbp), %rdx
addl 0x7531c(%rcx,%rdx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movslq -0x14(%rbp), %rdx
addl 0x7532c(%rcx,%rdx,4), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x28e1
cmpl $0x0, -0x1c(%rbp)
jl 0x28e1
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4e200(%rcx), %eax
jge 0x28e1
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x4e204(%rcx), %eax
jl 0x28e3
jmp 0x293b
movq -0x28(%rbp), %rcx
movq %rcx, %rax
addq $0x4e208, %rax          # imm = 0x4E208
movslq -0x18(%rbp), %rdx
imulq $0x320, %rdx, %rdx      # imm = 0x320
addq %rdx, %rax
movslq -0x1c(%rbp), %rdx
movl (%rax,%rdx,4), %eax
addq $0x4e208, %rcx          # imm = 0x4E208
movslq -0xc(%rbp), %rdx
imulq $0x320, %rdx, %rdx      # imm = 0x320
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2939
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x2820
jmp 0x2949
jmp 0x293b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2887
addq $0x30, %rsp
popq %rbp
retq
nop
// File: yupyub[P]PathFinding_Visual/DFS.cpp
// Function: DFS::Init(int, int)
void DFS::Init(int ts,int mnum){
    if(ts<10000) timeSet = 10000;
    timeSet = ts;
    scnt = 0;
    itr = 0;
    dx[0] = dx[2] = dy[1] = dy[3] = 0;
    dx[1] = dy[0] = 1;
    dx[3] = dy[2] = -1;
    vv.read_map(mnum);
    for(int i = 0;i<vv.N;i++){
        for(int j = 0;j<vv.M;j++){
            dist[i][j] = INF;
            vv.state[i][j] = 0;
            if(vv.map[i][j] == 2){
                sx = i;
                sy = j;
            }
            else if(vv.map[i][j] == 3){
                ex = i;
                ey = j;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x2710, -0xc(%rbp)     # imm = 0x2710
jge 0x5861
movq -0x20(%rbp), %rax
movl $0x2710, 0x75320(%rax)  # imm = 0x2710
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x75320(%rdi)
movl $0x0, 0x75318(%rdi)
movl $0x0, 0x7531c(%rdi)
movl $0x0, 0x75340(%rdi)
movl $0x0, 0x75338(%rdi)
movl $0x0, 0x7532c(%rdi)
movl $0x0, 0x75324(%rdi)
movl $0x1, 0x75334(%rdi)
movl $0x1, 0x75328(%rdi)
movl $0xffffffff, 0x7533c(%rdi) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x75330(%rdi) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %esi
callq 0x87b0
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x4e200(%rcx), %eax
jge 0x59dc
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4e204(%rcx), %eax
jge 0x59cc
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4e208, %rcx          # imm = 0x4E208
movslq -0x14(%rbp), %rdx
imulq $0x320, %rdx, %rdx      # imm = 0x320
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl $0x3ade68b1, (%rcx,%rdx,4) # imm = 0x3ADE68B1
movq %rax, %rcx
addq $0x27100, %rcx          # imm = 0x27100
movslq -0x14(%rbp), %rdx
imulq $0x320, %rdx, %rdx      # imm = 0x320
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movslq -0x14(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
cmpl $0x2, (%rax,%rcx,4)
jne 0x5988
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x75308(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x7530c(%rax)
jmp 0x59bc
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
cmpl $0x3, (%rax,%rcx,4)
jne 0x59ba
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x75310(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x75314(%rax)
jmp 0x59bc
jmp 0x59be
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x58fb
jmp 0x59ce
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x58e1
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yupyub[P]PathFinding_Visual/DFS.cpp
// Function: DFS::sol_path(int, int)
void DFS::sol_path(int x,int y){
    if(dist[x][y] == 0) return;
    vv.state[x][y] = 1;
    vector<tuple<int,int,int> > v;
    for(int i = 0;i<4;i++){
        int nx = x+dx[i];
        int ny = y+dy[i];
        if(nx<0||ny<0||nx>=vv.N||ny>=vv.M) continue;
        v.push_back(make_tuple(dist[nx][ny],nx,ny));
    }
    sort(v.begin(),v.end());
    sol_path(get<1>(v[0]),get<2>(v[0]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x4e208, %rax          # imm = 0x4E208
movslq -0xc(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x5a30
jmp 0x5bac
movq -0x68(%rbp), %rax
addq $0x27100, %rax          # imm = 0x27100
movslq -0xc(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
leaq -0x28(%rbp), %rdi
callq 0x5fc0
movl $0x0, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jge 0x5b29
movq -0x68(%rbp), %rcx
movl -0xc(%rbp), %eax
movslq -0x2c(%rbp), %rdx
addl 0x75324(%rcx,%rdx,4), %eax
movl %eax, -0x30(%rbp)
movl -0x10(%rbp), %eax
movslq -0x2c(%rbp), %rdx
addl 0x75334(%rcx,%rdx,4), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x30(%rbp)
jl 0x5abd
cmpl $0x0, -0x34(%rbp)
jl 0x5abd
movq -0x68(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl 0x4e200(%rcx), %eax
jge 0x5abd
movq -0x68(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x4e204(%rcx), %eax
jl 0x5abf
jmp 0x5b01
movq -0x68(%rbp), %rax
movslq -0x30(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x34(%rbp), %rcx
leaq 0x4e208(%rax,%rcx,4), %rsi
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x6010
jmp 0x5af0
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5fe0
jmp 0x5aff
jmp 0x5b01
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5a63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6150
jmp 0x5bb5
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x6090
movq -0x70(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x60c0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x6050
jmp 0x5b56
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x80(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6110
movq %rax, %rdi
callq 0x60f0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl (%rax), %eax
movl %eax, -0x74(%rbp)
callq 0x6110
movq %rax, %rdi
callq 0x6130
movq -0x68(%rbp), %rdi
movl -0x74(%rbp), %esi
movl (%rax), %edx
callq 0x59f0
jmp 0x5ba3
leaq -0x28(%rbp), %rdi
callq 0x6150
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22a0
nop
// File: yupyub[P]PathFinding_Visual/DFS.cpp
// Function: DFS::DFS_Run(int, int)
int DFS::DFS_Run(int tset, int mnum){
    Init(tset,mnum);
    dist[sx][sy] = 0;
    if(DFS_H(sx,sy,-1)){
        sol_path(ex,ey);
        vv.draw();
        printf("Total Iteration : %d / Path Distance : %d\n",itr,dist[ex][ey]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x5830
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x4e208, %rax          # imm = 0x4E208
movslq 0x75308(%rdi), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq 0x7530c(%rdi), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x75308(%rdi), %esi
movl 0x7530c(%rdi), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x5bc0
cmpl $0x0, %eax
je 0x5fb6
movq -0x18(%rbp), %rdi
movl 0x75310(%rdi), %esi
movl 0x75314(%rdi), %edx
callq 0x59f0
movq -0x18(%rbp), %rdi
callq 0x89a0
movq -0x18(%rbp), %rcx
movl 0x7531c(%rcx), %esi
movq %rcx, %rax
addq $0x4e208, %rax          # imm = 0x4E208
movslq 0x75310(%rcx), %rdx
imulq $0x320, %rdx, %rdx      # imm = 0x320
addq %rdx, %rax
movslq 0x75314(%rcx), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x422d(%rip), %rdi      # 0xa1dc
movb $0x0, %al
callq 0x2030
ud2
nopl (%rax,%rax)
// File: yupyub[P]PathFinding_Visual/visual.cpp
// Function: Visual::read_map(int)
int Visual::read_map(int mnum){
    FILE *fp;
    std::string name = "MAP/map";
    name += std::to_string(mnum);
    name += ".txt";
    fp = fopen(name.c_str(),"r");
    if(fp == NULL){
        printf("Map Open Error\n");
        return -1;
    }
    fscanf(fp,"%d %d",&N,&M);
    for(int i = 0;i<N;i++){
        for(int j = 0;j<M;j++){
            fscanf(fp,"%1d",&map[i][j]);
        }
    }
    fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x22b0
movq -0x80(%rbp), %rdx
leaq 0x1a68(%rip), %rsi      # 0xa24d
leaq -0x38(%rbp), %rdi
callq 0x8c20
jmp 0x87f0
leaq -0x39(%rbp), %rdi
callq 0x21a0
movl -0xc(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0x8cd0
jmp 0x8807
leaq -0x38(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2240
jmp 0x8816
leaq -0x70(%rbp), %rdi
callq 0x20c0
leaq 0x1a2f(%rip), %rsi      # 0xa255
leaq -0x38(%rbp), %rdi
callq 0x2150
jmp 0x8831
leaq -0x38(%rbp), %rdi
callq 0x2080
movq %rax, %rdi
leaq 0x17c4(%rip), %rsi      # 0xa008
callq 0x2210
movq %rax, -0x90(%rbp)
jmp 0x8852
movq -0x90(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x88d0
leaq 0x19ef(%rip), %rdi      # 0xa25a
xorl %eax, %eax
callq 0x2030
jmp 0x8874
leaq -0x38(%rbp), %rdi
callq 0x20c0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x21a0
jmp 0x898f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8986
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20c0
jmp 0x8986
movq -0x88(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq %rcx, %rdx
addq $0x4e200, %rdx          # imm = 0x4E200
addq $0x4e204, %rcx          # imm = 0x4E204
leaq 0x1977(%rip), %rsi      # 0xa26a
xorl %eax, %eax
callq 0x22d0
jmp 0x88fc
movl $0x0, -0x74(%rbp)
movq -0x88(%rbp), %rcx
movl -0x74(%rbp), %eax
cmpl 0x4e200(%rcx), %eax
jge 0x8979
movl $0x0, -0x78(%rbp)
movq -0x88(%rbp), %rcx
movl -0x78(%rbp), %eax
cmpl 0x4e204(%rcx), %eax
jge 0x896c
movq -0x88(%rbp), %rax
movq -0x18(%rbp), %rdi
movslq -0x74(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movslq -0x78(%rbp), %rcx
leaq (%rax,%rcx,4), %rdx
leaq 0x191a(%rip), %rsi      # 0xa270
xorl %eax, %eax
callq 0x22d0
jmp 0x895f
jmp 0x8961
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x891c
jmp 0x896e
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x8903
movq -0x18(%rbp), %rdi
callq 0x2160
jmp 0x8984
ud2
leaq -0x38(%rbp), %rdi
callq 0x20c0
movq -0x48(%rbp), %rdi
callq 0x22a0
nopl (%rax,%rax)
// File: yupyub[P]PathFinding_Visual/linuxfunc.cpp
// Function: init_keyboard()
void init_keyboard(){
    tcgetattr(0,&initial_settings);
    new_settings = initial_settings;
    new_settings.c_lflag &= ~ICANON;
    new_settings.c_lflag &= ~ECHO;
    new_settings.c_cc[VMIN] = 1;
    new_settings.c_cc[VTIME] = 0;
    tcsetattr(0, TCSANOW, &new_settings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
leaq 0x5f23(%rip), %rsi      # 0xf1a0
callq 0x21d0
leaq 0x5f53(%rip), %rdi      # 0xf1dc
leaq 0x5f10(%rip), %rsi      # 0xf1a0
movl $0x3c, %edx
callq 0x2120
movl 0x5f48(%rip), %eax      # 0xf1e8
andl $-0x3, %eax
movl %eax, 0x5f3f(%rip)      # 0xf1e8
movl 0x5f39(%rip), %eax      # 0xf1e8
andl $-0x9, %eax
movl %eax, 0x5f30(%rip)      # 0xf1e8
movb $0x1, 0x5f34(%rip)      # 0xf1f3
movb $0x0, 0x5f2c(%rip)      # 0xf1f2
xorl %esi, %esi
leaq 0x5f0d(%rip), %rdx      # 0xf1dc
movl %esi, %edi
callq 0x2230
popq %rbp
retq
nopl (%rax,%rax)
// File: yupyub[P]PathFinding_Visual/linuxfunc.cpp
// Function: kbhit()
int _kbhit(){
    unsigned char ch;
    int nread;
    if (peek_character != -1) return 1;
    new_settings.c_cc[VMIN]=0;
    tcsetattr(0, TCSANOW, &new_settings);
    nread = read(0,&ch,1);
    new_settings.c_cc[VMIN]=1;
    tcsetattr(0, TCSANOW, &new_settings);
    if(nread == 1) {
        peek_character = ch;
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $-0x1, 0x5e89(%rip)     # 0xf198
je 0x931a
movl $0x1, -0x4(%rbp)
jmp 0x937b
movb $0x0, 0x5ed2(%rip)      # 0xf1f3
xorl %esi, %esi
leaq 0x5eb2(%rip), %rdx      # 0xf1dc
movl %esi, %edi
callq 0x2230
xorl %edi, %edi
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x2270
movl %eax, -0xc(%rbp)
movb $0x1, 0x5ea8(%rip)      # 0xf1f3
xorl %esi, %esi
leaq 0x5e88(%rip), %rdx      # 0xf1dc
movl %esi, %edi
callq 0x2230
cmpl $0x1, -0xc(%rbp)
jne 0x9374
movzbl -0x5(%rbp), %eax
movl %eax, 0x5e2d(%rip)      # 0xf198
movl $0x1, -0x4(%rbp)
jmp 0x937b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yupyub[P]PathFinding_Visual/linuxfunc.cpp
// Function: getch()
int _getch(){
    char ch;
    if(peek_character != -1) {
        ch = peek_character;
        peek_character = -1;
        return ch;
    }
    read(0,&ch,1);
    return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $-0x1, 0x5df9(%rip)     # 0xf198
je 0x93bd
movl 0x5df1(%rip), %eax      # 0xf198
movb %al, -0x5(%rbp)
movl $0xffffffff, 0x5de4(%rip) # imm = 0xFFFFFFFF
movsbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x93d4
xorl %edi, %edi
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x2270
movsbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: nmmmnu[P]asyncore_cpp/net/test/test_iobuffer.cc
// Function: void testPush<net::IOBuffer<8ul, true>>(char const*, char const*, char const*, net::IOBuffer<8ul, true>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
void testPush(const char *module, const char *msg, const char *data, BUFFER &b, std::string &s, bool const expect = true){
	bool const result = b.push(data);

	if (expect)
		s += data;

	PRINTF_TEST(msg,	result == expect			);
	PRINTF_TEST("value",	s.compare(0, s.size(), b.data()) == 0	);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16d0
andb $0x1, %al
movb %al, -0x2a(%rbp)
testb $0x1, -0x29(%rbp)
je 0x1479
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x1080
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movb -0x2a(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
leaq 0xbea(%rip), %rcx       # 0x2083
leaq 0xbe0(%rip), %rax       # 0x2080
cmpl %r8d, %edi
cmoveq %rax, %rcx
leaq 0xbba(%rip), %rdi       # 0x2068
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1070
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1720
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
movq -0x38(%rbp), %rsi
movl %eax, %edx
leaq 0xb87(%rip), %rcx       # 0x2083
leaq 0xb7d(%rip), %rax       # 0x2080
cmpl $0x0, %edx
cmoveq %rax, %rcx
leaq 0xb57(%rip), %rdi       # 0x2068
leaq 0xb70(%rip), %rdx       # 0x2088
movb $0x0, %al
callq 0x1030
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: nmmmnu[P]asyncore_cpp/net/test/test_iobuffer.cc
// Function: void testPop<net::IOBuffer<8ul, true>>(char const*, char const*, unsigned long, net::IOBuffer<8ul, true>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
void testPop(const char *module, const char *msg, size_t const size, BUFFER &b, std::string &s, bool const expect = true){
	bool const result = b.pop(size);

	if (expect)
		s.erase(0, size);

	PRINTF_TEST(msg, result == expect);

	if (s.empty()){
		PRINTF_TEST("size zero",	b.size() == 0				);
		PRINTF_TEST("capacity",		b.capacity() == b.max_size()		);
	}else{
		PRINTF_TEST("value",		s.compare(0, s.size(), b.data()) == 0	);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17f0
andb $0x1, %al
movb %al, -0x2a(%rbp)
testb $0x1, -0x29(%rbp)
je 0x157d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x1040
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movb -0x2a(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
leaq 0xae6(%rip), %rcx       # 0x2083
leaq 0xadc(%rip), %rax       # 0x2080
cmpl %r8d, %edi
cmoveq %rax, %rcx
leaq 0xab6(%rip), %rdi       # 0x2068
movb $0x0, %al
callq 0x1030
movq -0x28(%rbp), %rdi
callq 0x10c0
testb $0x1, %al
jne 0x15cb
jmp 0x165f
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1870
movq -0x48(%rbp), %rsi
movq %rax, %rdx
leaq 0xa99(%rip), %rcx       # 0x2083
leaq 0xa8f(%rip), %rax       # 0x2080
cmpq $0x0, %rdx
cmoveq %rax, %rcx
leaq 0xa68(%rip), %rdi       # 0x2068
leaq 0xa87(%rip), %rdx       # 0x208e
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17d0
movq %rax, -0x40(%rbp)
callq 0x1890
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
movq %rax, %rdi
leaq 0xa49(%rip), %rcx       # 0x2083
leaq 0xa3f(%rip), %rax       # 0x2080
cmpq %rdi, %rdx
cmoveq %rax, %rcx
leaq 0xa19(%rip), %rdi       # 0x2068
leaq 0xa42(%rip), %rdx       # 0x2098
movb $0x0, %al
callq 0x1030
jmp 0x16c9
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1070
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1720
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
movq -0x50(%rbp), %rsi
movl %eax, %edx
leaq 0x9dd(%rip), %rcx       # 0x2083
leaq 0x9d3(%rip), %rax       # 0x2080
cmpl $0x0, %edx
cmoveq %rax, %rcx
leaq 0x9ad(%rip), %rdi       # 0x2068
leaq 0x9c6(%rip), %rdx       # 0x2088
movb $0x0, %al
callq 0x1030
addq $0x60, %rsp
popq %rbp
retq
nop
// File: nmmmnu[P]asyncore_cpp/net/iobuffer.h
// Function: net::IOBuffer<8ul, true>::push(unsigned long, void const*)
bool push(size_t const len, const void *ptr = nullptr){
		if (len == 0)
			return false;

		if (capacity() < len)
			return false;

		if (ptr)
			memmove(&buffer_[tail_], ptr, len);

		tail_ = (size_type) (tail_ + len);

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1769
movb $0x0, -0x1(%rbp)
jmp 0x17b8
movq -0x28(%rbp), %rdi
callq 0x17d0
cmpq -0x18(%rbp), %rax
jae 0x177e
movb $0x0, -0x1(%rbp)
jmp 0x17b8
cmpq $0x0, -0x20(%rbp)
je 0x17a4
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x4, %rdi
movzwl 0x2(%rax), %eax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10b0
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %ecx
addq -0x18(%rbp), %rcx
movw %cx, 0x2(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH01_GettingStarted/examples/add_item2.cc
// Function: main
int main() 
{
    Sales_item item1, item2;

    std::cin >> item1 >> item2;
	// first check that item1 and item2 represent the same book
	if (item1.isbn() == item2.isbn()) {
    	std::cout << item1 + item2 << std::endl;
    	return 0;   // indicate success
	} else {
    	std::cerr << "Data must refer to same ISBN" 
		          << std::endl;
    	return -1;  // indicate failure
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x17d0
leaq -0x68(%rbp), %rdi
callq 0x17d0
movq -0x100(%rbp), %rsi
movq 0x2a1f(%rip), %rdi      # 0x3fd8
callq 0x1370
movq %rax, -0xf8(%rbp)
jmp 0x15c7
movq -0xf8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1370
jmp 0x15d9
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1850
jmp 0x15eb
leaq -0xb8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1850
jmp 0x15fd
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1880
movb %al, -0x101(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x1090
leaq -0x98(%rbp), %rdi
callq 0x1090
movb -0x101(%rbp), %al
testb $0x1, %al
jne 0x163d
jmp 0x16eb
leaq -0xe8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x1310
jmp 0x1653
movq 0x296e(%rip), %rdi      # 0x3fc8
leaq -0xe8(%rbp), %rsi
callq 0x1420
movq %rax, -0x110(%rbp)
jmp 0x166f
movq -0x110(%rbp), %rdi
movq 0x293b(%rip), %rsi      # 0x3fb8
callq 0x10f0
jmp 0x1684
leaq -0xe8(%rbp), %rdi
callq 0x17b0
movl $0x0, -0x4(%rbp)
movl $0x1, -0xec(%rbp)
jmp 0x172d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x174b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1090
jmp 0x174b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x17b0
jmp 0x174b
movq 0x28fe(%rip), %rdi      # 0x3ff0
leaq 0x90d(%rip), %rsi       # 0x2006
callq 0x10e0
movq %rax, -0x118(%rbp)
jmp 0x1707
movq -0x118(%rbp), %rdi
movq 0x28a3(%rip), %rsi      # 0x3fb8
callq 0x10f0
jmp 0x171c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0xec(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x17b0
leaq -0x38(%rbp), %rdi
callq 0x17b0
movl -0x4(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x17b0
leaq -0x38(%rbp), %rdi
callq 0x17b0
movq -0x70(%rbp), %rdi
callq 0x1170
nopw %cs:(%rax,%rax)
// File: luigix25[P]SSLP/server_files/server.cpp
// Function: close_handler(int)
void close_handler(int s){
	cout<<endl<<"Terminating.."<<endl;
	client_socket.closeConnection();						
	KeyManager::destroyKeys();
	close(server_socket);
	exit(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0xdec6(%rip), %rdi      # 0x13fc8
movq 0xdeaf(%rip), %rsi      # 0x13fb8
callq 0x5550
movq %rax, %rdi
leaq 0x8eec(%rip), %rsi      # 0xf004
callq 0x5500
movq %rax, %rdi
movq 0xde91(%rip), %rsi      # 0x13fb8
callq 0x5550
leaq 0xe51d(%rip), %rdi      # 0x14650
callq 0x91c0
callq 0xe750
movl 0xe515(%rip), %edi      # 0x14658
callq 0x5aa0
movl -0x4(%rbp), %edi
callq 0x5690
// File: luigix25[P]SSLP/server_files/server.cpp
// Function: isClientAuthorized(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*)
bool isClientAuthorized(string& clientName, const char* filePath){

	ifstream file(filePath);
	if(!file){
		cerr<<"Error opening file"<<endl;
		return false;
	}

	while(!file.eof()){
		string name;
		file>>name;
		if(name == clientName){
			file.close();
			return true;
		}

	}

	file.close();
	return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x59f0
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x5280
movb %al, -0x251(%rbp)
jmp 0x6198
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x61a4
jmp 0x61ff
movq 0xde45(%rip), %rdi      # 0x13ff0
leaq 0x8e60(%rip), %rsi      # 0xf012
callq 0x5500
movq %rax, -0x260(%rbp)
jmp 0x61c0
movq -0x260(%rbp), %rdi
movq 0xddea(%rip), %rsi      # 0x13fb8
callq 0x5550
jmp 0x61d5
movb $0x0, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0x62f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x630b
jmp 0x6201
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x5a00
movb %al, -0x261(%rbp)
jmp 0x6221
movb -0x261(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6232
jmp 0x62d5
leaq -0x250(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0x57e0
movq -0x270(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x5700
jmp 0x625a
movq -0x10(%rbp), %rsi
leaq -0x250(%rbp), %rdi
callq 0x8590
testb $0x1, %al
jne 0x6270
jmp 0x62ae
leaq -0x220(%rbp), %rdi
callq 0x5100
jmp 0x627e
movb $0x1, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0x62b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x5330
jmp 0x630b
movl $0x0, -0x230(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x5330
movl -0x230(%rbp), %eax
testl %eax, %eax
jne 0x62f1
jmp 0x62d0
jmp 0x6201
leaq -0x220(%rbp), %rdi
callq 0x5100
jmp 0x62e3
movb $0x0, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x5160
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x5160
movq -0x228(%rbp), %rdi
callq 0x5980
nopw %cs:(%rax,%rax)
// File: luigix25[P]SSLP/server_files/server.cpp
// Function: select_command(int)
bool select_command(int cmd){

	switch (cmd){
		case LIST_COMMAND:
			return cmd_list();
		case GET_COMMAND:
			return cmd_get();
		case UPLOAD_COMMAND:
			return cmd_upload();
		default:
			return false;
		}


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x6d1c
jmp 0x6d08
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x6d28
jmp 0x6d12
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x6d34
jmp 0x6d40
callq 0x6330
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6d44
callq 0x66d0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6d44
callq 0x6a20
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6d44
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: luigix25[P]SSLP/server_files/server.cpp
// Function: initialize_server(int)
int initialize_server(int port){
	
	int listener;
	int status;

	if(port <= 0){
		cout<<"Port error"<<endl;
		exit(-1);
	}

	listener = socket(AF_INET, SOCK_STREAM, 0);
	if(listener < 0){
		cout<<"[Error] socket"<<endl;
		exit(-1);
	}

	struct sockaddr_in listenerAddress;
	memset(&listenerAddress,0,sizeof(listenerAddress));
	
	listenerAddress.sin_port = htons(port);
	listenerAddress.sin_family = AF_INET;
	inet_pton(AF_INET,"0.0.0.0",&listenerAddress.sin_addr);


	status = bind(listener, (struct sockaddr*)& listenerAddress, sizeof(listenerAddress));
	if(status < 0){
		perror("[Error] bind\n");
		exit(-1);
	}

	status = listen(listener,10);
	if(status < 0){
		perror("[Error] listen\n");
		exit(-1);
	}


	return listener;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jg 0x6d8d
movq 0xd260(%rip), %rdi      # 0x13fc8
leaq 0x8335(%rip), %rsi      # 0xf0a4
callq 0x5500
movq %rax, %rdi
movq 0xd23a(%rip), %rsi      # 0x13fb8
callq 0x5550
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5690
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x5150
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x6dd3
movq 0xd21a(%rip), %rdi      # 0x13fc8
leaq 0x82fa(%rip), %rsi      # 0xf0af
callq 0x5500
movq %rax, %rdi
movq 0xd1f4(%rip), %rsi      # 0x13fb8
callq 0x5550
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5690
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x52e0
movl -0x4(%rbp), %eax
movzwl %ax, %edi
callq 0x5080
movw %ax, -0x1a(%rbp)
movw $0x2, -0x1c(%rbp)
leaq -0x1c(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
leaq 0x82b2(%rip), %rsi      # 0xf0be
callq 0x5a30
movl -0x8(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x10, %edx
callq 0x50e0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x6e41
leaq 0x8294(%rip), %rdi      # 0xf0c6
callq 0x5490
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5690
movl -0x8(%rbp), %edi
movl $0xa, %esi
callq 0x55f0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x6e6d
leaq 0x8276(%rip), %rdi      # 0xf0d4
callq 0x5490
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5690
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: luigix25[P]SSLP/server_files/server.cpp
// Function: receive_command(int&)
bool receive_command(int &command){

	int len;
	char *raw_data = recvDataHMAC(client_socket,len);

	if(raw_data == NULL){
		cout<<"[Error] receive command"<<endl;
		return false;
	}

	EncryptedChunk ec;
	ec.size = len;
	ec.setCipherText(raw_data);

	Chunk c;

	DecryptManager dm;
	dm.DecryptUpdate(c,ec);
	dm.DecryptFinal(c);

	//il plaintext è un numero

	command = c.getInt();

	//delete[] c.plaintext;			//non mi serve più
	//delete[] ec.ciphertext;

	return true;


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xd7ba(%rip), %rdi      # 0x14650
leaq -0x14(%rbp), %rsi
callq 0x9c30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6ed5
movq 0xd117(%rip), %rdi      # 0x13fc8
leaq 0x822c(%rip), %rsi      # 0xf0e4
callq 0x5500
movq %rax, %rdi
movq 0xd0f1(%rip), %rsi      # 0x13fb8
callq 0x5550
movb $0x0, -0x1(%rbp)
jmp 0x6fac
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xebf0
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
callq 0xecc0
jmp 0x6ef7
leaq -0x60(%rbp), %rdi
callq 0xea40
jmp 0x6f02
leaq -0x68(%rbp), %rdi
callq 0xb990
jmp 0x6f0d
leaq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xba90
jmp 0x6f20
leaq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xbc50
jmp 0x6f2f
leaq -0x60(%rbp), %rdi
callq 0xebd0
movl %eax, -0x74(%rbp)
jmp 0x6f3d
movl -0x74(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xba60
leaq -0x60(%rbp), %rdi
callq 0xea60
leaq -0x38(%rbp), %rdi
callq 0xec10
jmp 0x6fac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6fa1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6f98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xba60
leaq -0x60(%rbp), %rdi
callq 0xea60
leaq -0x38(%rbp), %rdi
callq 0xec10
jmp 0x6fba
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5980
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/special.cc
// Function: main
int main()
{
	int i = 42;
	f(i);  // calls f(T), f(const T*) isn't viable

	f(&i); // calls f(T), which is an exact match,
	       // f(const T*) requires a conversion
	cout << "=====================" << endl;

	g(i);  // calls g(T), g(T*) isn't viable
	g(&i); // calls g(T*), both templates are viable,
	       // but g(T*) is more specialized

	cout << "=====================" << endl;

	int* p = &i;
	const int ci = 0;
	const int* p2 = &ci;
	g(42);   g(p);  // g(T) g(T*)
	g(ci);   g(p2); // g(T) g(T*)
	cout << "=====================" << endl;
	f(42);   f(p);  // f(T) f(T)
	f(ci);   f(p2); // f(T) f(T*)

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x2a, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x12c0
leaq -0x8(%rbp), %rdi
callq 0x1300
movq 0x2dfa(%rip), %rdi      # 0x3fd8
leaq 0xe1f(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq 0x2dd4(%rip), %rsi      # 0x3fc8
callq 0x1050
movl -0x8(%rbp), %edi
callq 0x1340
leaq -0x8(%rbp), %rdi
callq 0x1380
movq 0x2dc7(%rip), %rdi      # 0x3fd8
leaq 0xdec(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq 0x2da1(%rip), %rsi      # 0x3fc8
callq 0x1050
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x2a, %edi
callq 0x1340
movq -0x10(%rbp), %rdi
callq 0x1380
xorl %edi, %edi
callq 0x1340
movq -0x20(%rbp), %rdi
callq 0x13c0
movq 0x2d6b(%rip), %rdi      # 0x3fd8
leaq 0xd90(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq 0x2d45(%rip), %rsi      # 0x3fc8
callq 0x1050
movl $0x2a, %edi
callq 0x12c0
movq -0x10(%rbp), %rdi
callq 0x1300
xorl %edi, %edi
callq 0x12c0
movq -0x20(%rbp), %rdi
callq 0x1400
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/Image.cpp
// Function: Image::resize(int, int, int)
bool
Image::resize(int w_, int h_, int nc_)
{
  if (w == w_ && h == h_ && nc == nc_)
    return true;

  if (w_ < 0 || h_ < 0 || nc_ < 0)
  {
    std::cerr << "Image dimensions must be non-negative" << std::endl;
    return false;
  }

  std::free(buf);

  size_t num_bytes = (size_t)(w_ * h_ * nc_);
  if (num_bytes > 0)
    buf = (unsigned char *)std::malloc(num_bytes);
  else
    buf = NULL;

  w = w_;
  h = h_;
  nc = nc_;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x5db5
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x5db5
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x5db5
movb $0x1, -0x1(%rbp)
jmp 0x5e4f
cmpl $0x0, -0x14(%rbp)
jl 0x5dc7
cmpl $0x0, -0x18(%rbp)
jl 0x5dc7
cmpl $0x0, -0x1c(%rbp)
jge 0x5def
movq 0x56222(%rip), %rdi     # 0x5bff0
leaq 0x41289(%rip), %rsi     # 0x4705e
callq 0x53e0
movq %rax, %rdi
movq 0x561cc(%rip), %rsi     # 0x5bfb0
callq 0x5440
movb $0x0, -0x1(%rbp)
jmp 0x5e4f
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x54c0
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
cltq
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x5e2a
movq -0x28(%rbp), %rdi
callq 0x5550
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5e36
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/Image.cpp
// Function: Image::load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
bool
Image::load(std::string const & path, int req_nc)
{
  std::free(buf);
  buf = stbi_load(path.c_str(), &w, &h, &nc, req_nc);

  if (!buf)
  {
    std::cerr << "Could not load image from " << path << std::endl;
    return false;
  }

  if (req_nc != 0)
    nc = req_nc;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rax), %rdi
callq 0x54c0
movq -0x18(%rbp), %rdi
callq 0x51a0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
movq %rsi, %rdx
addq $0x4, %rdx
movq %rsi, %rcx
addq $0x8, %rcx
movl -0x1c(%rbp), %r8d
callq 0x274f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x10(%rax)
jne 0x5fb1
movq 0x5606c(%rip), %rdi     # 0x5bff0
leaq 0x41079(%rip), %rsi     # 0x47004
callq 0x53e0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x53c0
movq %rax, %rdi
movq 0x5600a(%rip), %rsi     # 0x5bfb0
callq 0x5440
movb $0x0, -0x1(%rbp)
jmp 0x5fc5
cmpl $0x0, -0x1c(%rbp)
je 0x5fc1
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: srajangarg[P]raytracer/src/core/MeshInfo.cpp
// Function: TriangleMesh::clear()
void
TriangleMesh::clear()
{
  for (auto it = triangles.begin(); it != triangles.end(); ++it)
  {
    delete *it;
  }

  for (auto it = vertices.begin(); it != vertices.end(); ++it)
  {
    delete *it;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x18, %rdi
callq 0x6e00
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x6e70
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6e30
testb $0x1, %al
jne 0x6725
jmp 0x6756
leaq -0x10(%rbp), %rdi
callq 0x6ea0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x6749
movq -0x38(%rbp), %rdi
movl $0xc, %esi
callq 0x5410
jmp 0x674b
leaq -0x10(%rbp), %rdi
callq 0x6ec0
jmp 0x6701
movq -0x30(%rbp), %rdi
callq 0x6ee0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6f50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6f10
testb $0x1, %al
jne 0x6783
jmp 0x67b4
leaq -0x20(%rbp), %rdi
callq 0x6f80
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x67a7
movq -0x40(%rbp), %rdi
movl $0x18, %esi
callq 0x5410
jmp 0x67a9
leaq -0x20(%rbp), %rdi
callq 0x6fa0
jmp 0x6763
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/MeshInfo.cpp
// Function: getFirstValue(std::__cxx11::basic_istringstream<char, std::char_traits<char>, std::allocator<char>>&, int&)
bool
getFirstValue(std::istringstream & ss, int & value)
{
  std::string s;

  if (ss >> s)
  {
    std::istringstream valuestream(s);
    if (valuestream >> value)
      return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x55a0
movq -0x1e0(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x5510
movq %rax, -0x1d8(%rbp)
jmp 0x67fc
movq -0x1d8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5500
movb %al, -0x1e1(%rbp)
jmp 0x681a
movb -0x1e1(%rbp), %al
testb $0x1, %al
jne 0x6829
jmp 0x68df
leaq -0x1c8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x8, %edx
callq 0x56a0
jmp 0x6840
movq -0x18(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x5280
movq %rax, -0x1f0(%rbp)
jmp 0x6859
movq -0x1f0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5500
movb %al, -0x1f1(%rbp)
jmp 0x6877
movb -0x1f1(%rbp), %al
testb $0x1, %al
jne 0x6883
jmp 0x68bb
movb $0x1, -0x1(%rbp)
movl $0x1, -0x1cc(%rbp)
jmp 0x68c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6904
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x51f0
jmp 0x6904
movl $0x0, -0x1cc(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x51f0
movl -0x1cc(%rbp), %eax
testl %eax, %eax
jne 0x68ed
jmp 0x68dd
jmp 0x68df
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1cc(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5290
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x5290
movq -0x40(%rbp), %rdi
callq 0x5720
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/Algebra3.hpp
// Function: operator>>(std::istream&, Vec3&)
inline std::istream & operator >> (std::istream & s, Vec3 & v)
{
  Vec3 v_tmp;
  char c = ' ';

  while (std::isspace(c))
    s >> c;

  // The vectors can be formatted either as x y z or | x y z |
  if (c == '|')
  {
    s >> v_tmp[0] >> v_tmp[1] >> v_tmp[2];
    while (s >> c && std::isspace(c)) ;
    if (c != '|')
      s.setstate(std::ios::badbit);
  }
  else
  {
    s.putback(c);
    s >> v_tmp[0] >> v_tmp[1] >> v_tmp[2];
  }

  if (s)
    v = v_tmp;

  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6fc0
movb $0x20, -0x29(%rbp)
movsbl -0x29(%rbp), %edi
callq 0x5080
cmpl $0x0, %eax
je 0x700a
movq -0x8(%rbp), %rdi
leaq -0x29(%rbp), %rsi
callq 0x5530
jmp 0x6fed
movsbl -0x29(%rbp), %eax
cmpl $0x7c, %eax
jne 0x70d9
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x7260
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x5360
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x7260
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5360
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x7260
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5360
movq -0x8(%rbp), %rdi
leaq -0x29(%rbp), %rsi
callq 0x5530
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x5500
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x709c
jmp 0x70ae
movsbl -0x29(%rbp), %edi
callq 0x5080
cmpl $0x0, %eax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x70b7
jmp 0x70b9
jmp 0x7072
movsbl -0x29(%rbp), %eax
cmpl $0x7c, %eax
je 0x70d7
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x1, %esi
callq 0x52b0
jmp 0x7141
movq -0x8(%rbp), %rdi
movsbl -0x29(%rbp), %esi
callq 0x5790
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x7260
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x5360
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x7260
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x5360
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x7260
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x5360
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x5500
testb $0x1, %al
jne 0x7157
jmp 0x7164
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x72d0
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/Scene.cpp
// Function: printNode(SceneInstance*, int)
void
printNode(SceneInstance * n, int level = 0)
{
  tab(level);
  std::cout << "Node " << n->getName() << " {" << std::endl;

  if (n->getChild())
  {
    SceneGroup * below = n->getChild();

    for (int i = 0; i < below->getChildCount(); i++)
    {
      printNode(below->getChild(i), level + 1);
    }
  }

  tab(level);
  std::cout << "}" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x83b0
movq 0x53bb7(%rip), %rdi     # 0x5bfc8
leaq 0x3eceb(%rip), %rsi     # 0x47103
callq 0x53e0
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x9ba0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x53c0
movq %rax, -0x58(%rbp)
jmp 0x8445
movq -0x58(%rbp), %rdi
leaq 0x3ecb9(%rip), %rsi     # 0x47109
callq 0x53e0
movq %rax, -0x70(%rbp)
jmp 0x845b
movq -0x70(%rbp), %rdi
movq 0x53b4a(%rip), %rsi     # 0x5bfb0
callq 0x5440
jmp 0x846d
leaq -0x30(%rbp), %rdi
callq 0x5290
movq -0x8(%rbp), %rdi
callq 0x9b80
cmpq $0x0, %rax
je 0x84ef
movq -0x8(%rbp), %rdi
callq 0x9b80
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x48(%rbp), %rdi
callq 0x8870
movl %eax, %ecx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jge 0x84ed
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x8890
movq %rax, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x83f0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x8499
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5290
jmp 0x8522
jmp 0x84ef
movl -0xc(%rbp), %edi
callq 0x83b0
movq 0x53aca(%rip), %rdi     # 0x5bfc8
leaq 0x3ec07(%rip), %rsi     # 0x4710c
callq 0x53e0
movq %rax, %rdi
movq 0x53a9c(%rip), %rsi     # 0x5bfb0
callq 0x5440
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5720
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneGroup.cpp
// Function: SceneGroup::SceneGroup()
SceneGroup::SceneGroup()
{
  name_ = "unassigned";
  sphere_ = NULL;
  light_ = NULL;
  camera_ = NULL;
  meshMaterial_ = NULL;
  mesh_ = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x5315d(%rip), %rax     # 0x5b818
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x20(%rbp)
callq 0x55a0
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0x8ab0
movq -0x20(%rbp), %rdi
leaq 0x3ea35(%rip), %rsi     # 0x4711c
callq 0x5580
jmp 0x86ee
movq -0x30(%rbp), %rax
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8ad0
movq -0x20(%rbp), %rdi
callq 0x5290
movq -0x10(%rbp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneGroup.cpp
// Function: SceneGroup::~SceneGroup()
SceneGroup::~SceneGroup()
{
  delete sphere_;
  delete light_;
  delete camera_;
  delete mesh_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x5309d(%rip), %rcx     # 0x5b808
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x8797
movq -0x10(%rbp), %rdi
callq 0x8b30
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x5410
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x87c0
movq -0x20(%rbp), %rdi
callq 0x8b60
movq -0x20(%rbp), %rdi
movl $0x30, %esi
callq 0x5410
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x87e9
movq -0x28(%rbp), %rdi
callq 0x8c30
movq -0x28(%rbp), %rdi
movl $0x38, %esi
callq 0x5410
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8812
movq -0x30(%rbp), %rdi
callq 0x8ca0
movq -0x30(%rbp), %rdi
movl $0x30, %esi
callq 0x5410
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x8ad0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x5290
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneGroup.cpp
// Function: SceneGroup::computeMesh(TriangleMesh*&, MaterialInfo&, int)
bool
SceneGroup::computeMesh(TriangleMesh *& mesh, MaterialInfo & material, int time)  /* get a Mesh and it's material */
{
  if (mesh_ == NULL || meshMaterial_ == NULL)
    return false;

  mesh = mesh_;
  material = meshMaterial_->getMaterial(time);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, 0x58(%rax)
je 0x8924
movq -0x80(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x892a
movb $0x0, -0x1(%rbp)
jmp 0x895a
movq -0x80(%rbp), %rax
movq 0x58(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x60(%rax), %rsi
movl -0x24(%rbp), %edx
leaq -0x78(%rbp), %rdi
callq 0x8d20
movq -0x20(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x8e40
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/SceneGroup.cpp
// Function: SceneGroup::computeSphere(double&, MaterialInfo&, int)
bool
SceneGroup::computeSphere(double & radius, MaterialInfo & material, int time)  /* get a sphere */
{
  if (sphere_ == NULL)
    return false;

  radius = sphere_->getRadius(time);
  material = sphere_->getMaterial(time);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, 0x40(%rax)
jne 0x899f
movb $0x0, -0x1(%rbp)
jmp 0x89dc
movq -0x80(%rbp), %rax
movq 0x40(%rax), %rdi
movl -0x24(%rbp), %esi
callq 0x8e90
movq -0x80(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd %xmm0, (%rcx)
movq 0x40(%rax), %rsi
movl -0x24(%rbp), %edx
leaq -0x78(%rbp), %rdi
callq 0x8ec0
movq -0x20(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x8e40
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)