LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: koraa[P]sbcrack/cube/geom.cpp
// Function: glmatrixf::invert(glmatrixf const&, float)
bool glmatrixf::invert(const glmatrixf &m, float mindet)
{
    float a1 = m.v[0], b1 = m.v[4], c1 = m.v[8], d1 = m.v[12]; 
    adjoint(m);
    float det = a1*v[0] + b1*v[1] + c1*v[2] + d1*v[3]; // float det = m.determinant(); 
    if(fabs(det) < mindet) return false;
    float invdet = 1/det;
    loopi(16) v[i] *= invdet;
    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movss 0x10(%rax), %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x30(%rsp), %rax
movss 0x20(%rax), %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movss 0x30(%rax), %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x30(%rsp), %rsi
callq 0xc7d0
movq 0x8(%rsp), %rax
movss 0x28(%rsp), %xmm0
mulss (%rax), %xmm0
movss 0x24(%rsp), %xmm1
mulss 0x4(%rax), %xmm1
addss %xmm1, %xmm0
movss 0x20(%rsp), %xmm1
mulss 0x8(%rax), %xmm1
addss %xmm1, %xmm0
movss 0x1c(%rsp), %xmm1
mulss 0xc(%rax), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x18(%rsp)
movss 0x18(%rsp), %xmm0
callq 0xd870
movaps %xmm0, %xmm1
movss 0x2c(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xcee9
movb $0x0, 0x47(%rsp)
jmp 0xcf38
movss 0x12ab(%rip), %xmm0     # 0xe19c
divss 0x18(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x10, 0x10(%rsp)
jge 0xcf33
movq 0x8(%rsp), %rax
movss 0x14(%rsp), %xmm0
movslq 0x10(%rsp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xcf05
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: koraa[P]sbcrack/cube/geom.cpp
// Function: raysphereintersect(vec const&, float, vec const&, vec const&, float&)
bool raysphereintersect(const vec &center, float radius, const vec &o, const vec &ray, float &dist)
{
    vec c(center);
    c.sub(o);
    float v = c.dot(ray),
          inside = radius*radius - c.squaredlen();
    if(inside<0 && v<0) return false;
    float d = inside + v*v;
    if(d<0) return false;
    dist = v - sqrt(d);
    return true;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movss %xmm0, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x1c(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x1c(%rsp), %rdi
callq 0xd890
movq 0x30(%rsp), %rsi
leaq 0x1c(%rsp), %rdi
callq 0xd8f0
movss %xmm0, 0x18(%rsp)
movss 0x44(%rsp), %xmm0
mulss 0x44(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0x1c(%rsp), %rdi
callq 0xd940
movaps %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
xorps %xmm0, %xmm0
ucomiss 0x14(%rsp), %xmm0
jbe 0xcff0
xorps %xmm0, %xmm0
ucomiss 0x18(%rsp), %xmm0
jbe 0xcff0
movb $0x0, 0x57(%rsp)
jmp 0xd04f
movss 0x14(%rsp), %xmm0
movss 0x18(%rsp), %xmm1
mulss 0x18(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
ucomiss 0x10(%rsp), %xmm0
jbe 0xd01d
movb $0x0, 0x57(%rsp)
jmp 0xd04f
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x10(%rsp), %xmm0
callq 0xd970
movaps %xmm0, %xmm1
movss 0x8(%rsp), %xmm0
subss %xmm1, %xmm0
movq 0x28(%rsp), %rax
movss %xmm0, (%rax)
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: smallHW89[P]gobang/GoBang_ChessBoard.cpp
// Function: ChessBoard::ChessBoard(int)
ChessBoard::ChessBoard(int size):m_size(size)
{
    for(int i=0; i<=size+2; i++)   {
        for(int j=0; j<=size+2;  j++) {
            m_board[i][j] = Chess_Empty;
            if( i==0 || j==0 || i>size || j>size )
                m_board[i][j] = Chess_Edge;
        }
    }
    m_stepnum=0; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x194(%rdi)
addq $0x240, %rdi            # imm = 0x240
callq 0x4dc0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jg 0x12c7
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jg 0x12b7
movq -0x20(%rbp), %rax
addq $0x4, %rax
movslq -0x10(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movb $0x65, (%rax,%rcx)
cmpl $0x0, -0x10(%rbp)
je 0x128f
cmpl $0x0, -0x14(%rbp)
je 0x128f
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x128f
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x12aa
movq -0x20(%rbp), %rax
addq $0x4, %rax
movslq -0x10(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movb $0x2f, (%rax,%rcx)
jmp 0x12ac
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x124b
jmp 0x12b9
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1233
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: smallHW89[P]gobang/GoBang_ChessBoard.cpp
// Function: ChessBoard::PutChess(int, int, char)
int ChessBoard:: PutChess(int x, int y , ChessSide side)
{
    
    m_board[x][y] = side;
    StPos pos(x, y, side);
    m_chessList.push_back(pos);
    m_stepnum ++;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x11(%rbp), %dl
addq $0x4, %rax
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x30(%rbp), %rdi
movsbl -0x11(%rbp), %ecx
callq 0x4de0
movq -0x38(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
leaq -0x30(%rbp), %rsi
callq 0x4e20
movq -0x38(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallHW89[P]gobang/GoBang_ChessBoard.cpp
// Function: ChessBoard::UnPutChess(int, int)
ChessSide ChessBoard::UnPutChess(int x, int y)
{
    char  c = m_board[x][y];
    m_board[x][y] = Chess_Empty;
    m_chessList.pop_back(); 
    m_stepnum--;
    return c;
}

// 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, -0x20(%rbp)
movq %rdi, %rax
addq $0x4, %rax
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq %rdi, %rax
addq $0x4, %rax
movslq -0xc(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movb $0x65, (%rax,%rcx)
addq $0x240, %rdi            # imm = 0x240
callq 0x4e90
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movb -0x11(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
// File: smallHW89[P]gobang/GoBang_ChessBoard.cpp
// Function: ChessBoard::CalculatePosHeng(int, int, char)
BoardType ChessBoard:: CalculatePosHeng(int x, int y, ChessSide side)
{
    if( x==0 || y== 0 || x > m_size || y> m_size )  
        return 0;
    char * line = m_board[x]; 
    int pos =  y; 
    int rl , rr;
    return CalculateLine( line, m_size+2, pos,rl, rr );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x32f9
cmpl $0x0, -0x18(%rbp)
je 0x32f9
movq -0x40(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x194(%rcx), %eax
jg 0x32f9
movq -0x40(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x194(%rcx), %eax
jle 0x3302
movl $0x0, -0x4(%rbp)
jmp 0x3342
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x4, %rax
movslq -0x14(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
movl 0x194(%rdi), %edx
addl $0x2, %edx
movl -0x2c(%rbp), %ecx
leaq -0x30(%rbp), %r8
leaq -0x34(%rbp), %r9
callq 0x30c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: smallHW89[P]gobang/GoBang_ChessBoard.cpp
// Function: ChessBoard::CalculatePosShu(int, int, char)
BoardType ChessBoard:: CalculatePosShu(int x, int y, ChessSide side)
{
   if( x==0 || y== 0 || x > m_size || y> m_size )  
        return 0;
    char  line[30]; 
    int pos =0;
    for(int i=0;i<= m_size+1; i++ )
        line[i] = m_board[i][y];
    pos = x;

    int rl , rr;
    return CalculateLine( line, m_size+2, pos,rl, rr );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3399
cmpl $0x0, -0x18(%rbp)
je 0x3399
movq -0x58(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x194(%rcx), %eax
jg 0x3399
movq -0x58(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x194(%rcx), %eax
jle 0x33a2
movl $0x0, -0x4(%rbp)
jmp 0x341b
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x58(%rbp), %rcx
movl -0x48(%rbp), %eax
movl 0x194(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0x33f1
movq -0x58(%rbp), %rax
addq $0x4, %rax
movslq -0x48(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %cl
movslq -0x48(%rbp), %rax
movb %cl, -0x40(%rbp,%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x33b0
movq -0x58(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x40(%rbp), %rsi
movl 0x194(%rdi), %edx
addl $0x2, %edx
movl -0x44(%rbp), %ecx
leaq -0x4c(%rbp), %r8
leaq -0x50(%rbp), %r9
callq 0x30c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallHW89[P]gobang/./GoBang_ChessBoard.h
// Function: ChessBoard::SetAISide(char)
void       SetAISide(ChessSide s){
        m_aiside = s;
        if( s == Chess_Black)
            m_otherside = Chess_White;
        else
            m_otherside = Chess_Black;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb -0x9(%rbp), %cl
movb %cl, 0x198(%rax)
movsbl -0x9(%rbp), %eax
leaq 0xc7b(%rip), %rcx       # 0x8005
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x73a6
movq -0x18(%rbp), %rax
leaq 0xc6a(%rip), %rcx       # 0x8006
movb (%rcx), %cl
movb %cl, 0x199(%rax)
jmp 0x73b9
movq -0x18(%rbp), %rax
leaq 0xc54(%rip), %rcx       # 0x8005
movb (%rcx), %cl
movb %cl, 0x199(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: niksram[P]Cache-Mapping-Simulator/cache_mapper.cpp
// Function: cache_mock::cache_mock(long, long, long, long, long, long)
cache_mock::cache_mock(long int d, long int c, long int m, long int b, long int l, long int s) : desc(d), cache_size(c), mem_size(m), block_size(b), lru(l), set_size(s)
{
    if (d == 1)
        set_size = 1;
    else if (d == 2)
        set_size = c / b;
    no_sets = cache_size / (block_size * set_size);
    container_init();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x18(%rdi)
movq 0x10(%rbp), %rax
movq %rax, 0x20(%rdi)
movq -0x30(%rbp), %rax
movq %rax, 0x30(%rdi)
addq $0x38, %rdi
movq %rdi, -0x48(%rbp)
callq 0x2600
cmpq $0x1, -0x10(%rbp)
jne 0x19fd
movq -0x50(%rbp), %rax
movq $0x1, 0x20(%rax)
jmp 0x1a1b
cmpq $0x2, -0x10(%rbp)
jne 0x1a19
movq -0x18(%rbp), %rax
cqto
idivq -0x28(%rbp)
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x1a1b
movq -0x50(%rbp), %rdi
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rdx
imulq %rdx, %rcx
cqto
idivq %rcx
movq %rax, 0x28(%rdi)
callq 0x1a70
jmp 0x1a3f
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x2620
movq -0x38(%rbp), %rdi
callq 0x1140
nopw %cs:(%rax,%rax)
// File: niksram[P]Cache-Mapping-Simulator/cache_mapper.cpp
// Function: cache_mock::container_init()
void cache_mock::container_init()
{
    if (container.size())
        container.clear();
    long int size = cache_size / block_size;
    for (long int i = 0; i < size; i++)
    {
        vector<long int> block;
        block.push_back(i);
        block.push_back(-1);           //tag_bit
        block.push_back(0);            //dirty_bit
        block.push_back(i % set_size); //hierarchy
        for (long int j = 0; j < block_size; j++)
        {
            block.push_back(-1);
        }
        container.push_back(block);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x38, %rdi
callq 0x28f0
cmpq $0x0, %rax
je 0x1aa3
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
callq 0x28d0
movq -0x70(%rbp), %rcx
movq 0x8(%rcx), %rax
cqto
idivq 0x18(%rcx)
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x1bba
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2920
movq -0x78(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2940
jmp 0x1ae7
movq $-0x1, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x29b0
jmp 0x1afe
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x29b0
jmp 0x1b15
movq -0x70(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rcx), %rcx
cqto
idivq %rcx
movq %rdx, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x29b0
jmp 0x1b39
movq $0x0, -0x60(%rbp)
movq -0x70(%rbp), %rcx
movq -0x60(%rbp), %rax
cmpq 0x18(%rcx), %rax
jge 0x1b8d
movq $-0x1, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x29b0
jmp 0x1b66
jmp 0x1b68
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x1b41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2a50
jmp 0x1bc3
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
leaq -0x30(%rbp), %rsi
callq 0x29e0
jmp 0x1ba0
leaq -0x30(%rbp), %rdi
callq 0x2a50
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1abd
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1140
nopl (%rax)
// File: niksram[P]Cache-Mapping-Simulator/cache_mapper.cpp
// Function: cache_mock::cache_mock_copy(cache_mock&)
void cache_mock::cache_mock_copy(cache_mock &c)
{
    this->desc = c.desc;
    this->cache_size = c.cache_size;
    this->mem_size = c.mem_size;
    this->block_size = c.block_size;
    this->lru = c.lru;
    this->set_size = c.set_size;
    this->no_sets=c.no_sets;
    this->container = c.container;
    //copy(c.container.begin(), c.container.end(), this->container.begin());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rdi)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x30(%rdi)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rdi)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x28(%rdi)
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x2680
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: niksram[P]Cache-Mapping-Simulator/cache_mapper.cpp
// Function: cache_mock::container_display()
void cache_mock::container_display()
{
    if(!desc)
        printf("Set\t");
    printf("ID\tTag\tDirty\thierarchy\tBlock-Display\n");
    for (long int i = 0; i < container.size(); i++)
    {
        if (!desc)
        {
            if(!(i % set_size))
            {
                printf("\n");
                printf("%ld",i/set_size);
            }
            printf("\t");
        }
        for (long int j = 0; j < container[i].size(); j++)
        {
            printf("%ld\t", container[i][j]);
            if (j == 3)
            {
                printf("\t");
            }
        }
        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
jne 0x1cf8
leaq 0x4541(%rip), %rdi      # 0x6232
movb $0x0, %al
callq 0x1030
leaq 0x4538(%rip), %rdi      # 0x6237
movb $0x0, %al
callq 0x1030
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
callq 0x28f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1e33
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1d8c
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
cqto
idivq 0x20(%rcx)
cmpq $0x0, %rdx
jne 0x1d7e
leaq 0x4309(%rip), %rdi      # 0x6061
movb $0x0, %al
callq 0x1030
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
cqto
idivq 0x20(%rcx)
movq %rax, %rsi
leaq 0x44e6(%rip), %rdi      # 0x625d
movb $0x0, %al
callq 0x1030
leaq 0x44df(%rip), %rdi      # 0x6264
movb $0x0, %al
callq 0x1030
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x2ab0
movq %rax, %rdi
callq 0x2ad0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1e14
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x2ab0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2af0
movq (%rax), %rsi
leaq 0x4479(%rip), %rdi      # 0x6261
movb $0x0, %al
callq 0x1030
cmpq $0x3, -0x18(%rbp)
jne 0x1e04
leaq 0x4467(%rip), %rdi      # 0x6264
movb $0x0, %al
callq 0x1030
jmp 0x1e06
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1d94
leaq 0x4246(%rip), %rdi      # 0x6061
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1d0e
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: niksram[P]Cache-Mapping-Simulator/cache_mapper.cpp
// Function: cache_mock::find_hierarchy_max(long)
long int cache_mock::find_hierarchy_max(long int set)
{
    long int max = set * set_size;
    for (long int i = 0; i < set_size; i++)
    {
        if (container[set * set_size + i][3] > container[max][3])
        {
            max = set * set_size + i;
        }
    }
    return (max);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
imulq 0x20(%rcx), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x20(%rcx), %rax
jge 0x21c2
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
imulq 0x20(%rax), %rsi
addq -0x20(%rbp), %rsi
callq 0x2ab0
movq %rax, %rdi
movl $0x3, %esi
callq 0x2af0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x2ab0
movq %rax, %rdi
movl $0x3, %esi
callq 0x2af0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq (%rcx), %rax
jle 0x21af
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
imulq 0x20(%rcx), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x21b1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x212d
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: niksram[P]Cache-Mapping-Simulator/cache_mapper.cpp
// Function: cache_mock::find_hierarchy_min(long)
long int cache_mock::find_hierarchy_min(long int set)
{
    long int min = set * set_size;
    for (long int i = 0; i < set_size; i++)
    {
        if (container[set * set_size + i][3] < container[min][3])
        {
            min = set * set_size + i;
        }
    }
    return (min);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
imulq 0x20(%rcx), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x20(%rcx), %rax
jge 0x2292
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
imulq 0x20(%rax), %rsi
addq -0x20(%rbp), %rsi
callq 0x2ab0
movq %rax, %rdi
movl $0x3, %esi
callq 0x2af0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x2ab0
movq %rax, %rdi
movl $0x3, %esi
callq 0x2af0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq (%rcx), %rax
jge 0x227f
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
imulq 0x20(%rcx), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x2281
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x21fd
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Jacobious52[P]Tanks/Terrain.cpp
// Function: Terrain::update(int)
LOOPV(i, this)
    {
        get_child(i)->update(t);
        if (get_child(i)->should_remove_from_parent() == true)
        {
            delete get_children()->remove(i);
            --i;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xf2d0
movq %rax, %rdi
callq 0x6550
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xbb48
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf330
movq %rax, %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf330
movq %rax, %rdi
callq 0xf4a0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xbb35
movq -0x20(%rbp), %rdi
callq 0xf2d0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x7850
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xbb29
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xbb37
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xba9f
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Jacobious52[P]Tanks/Test.cpp
// Function: test_point()
void test_point()
{
    printf("Testing Point..\n\n");

    Point<int> p1(3, 4);
    assert(p1.length() == 5, "length");
    Point<int> p2(3, 4);
    assert(p1 == p2, "equality");
    Point<int> res(0, 0);
    assert(p1 - p2 == res, "minus");
    res.x = 6;
    res.y = 8;
    assert(p2 + p2 == res, "addition");
    res.x = 9;
    res.y = 16;
    assert(p1 * p2 == res, "times");
    res.x = 1;
    res.y = 1;
    assert(p1 / p2 == res, "divide");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x387f(%rip), %rdi      # 0x1436e
movb $0x0, %al
callq 0x3070
leaq -0x8(%rbp), %rdi
movl $0x3, %esi
movl $0x4, %edx
callq 0x3da0
leaq -0x8(%rbp), %rdi
callq 0x126e0
cmpl $0x5, %eax
sete %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x385b(%rip), %rsi      # 0x14380
callq 0x109f0
leaq -0x10(%rbp), %rdi
movl $0x3, %esi
movl $0x4, %edx
callq 0x3da0
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x12720
movzbl %al, %edi
andl $0x1, %edi
leaq 0x3830(%rip), %rsi      # 0x14387
callq 0x109f0
leaq -0x18(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3da0
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xbc00
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x12720
movzbl %al, %edi
andl $0x1, %edi
leaq 0x37fc(%rip), %rsi      # 0x14390
callq 0x109f0
movl $0x6, -0x18(%rbp)
movl $0x8, -0x14(%rbp)
leaq -0x10(%rbp), %rsi
movq %rsi, %rdi
callq 0x62a0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x12720
movzbl %al, %edi
andl $0x1, %edi
leaq 0x37c5(%rip), %rsi      # 0x14396
callq 0x109f0
movl $0x9, -0x18(%rbp)
movl $0x10, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x12760
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x12720
movzbl %al, %edi
andl $0x1, %edi
leaq 0x3790(%rip), %rsi      # 0x1439f
callq 0x109f0
movl $0x1, -0x18(%rbp)
movl $0x1, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x127a0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x12720
movzbl %al, %edi
andl $0x1, %edi
leaq 0x3758(%rip), %rsi      # 0x143a5
callq 0x109f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Jacobious52[P]Tanks/Test.cpp
// Function: test_view()
void test_view()
{
    printf("\nTesting views...\n");

    View *view = new View(0, 0, 600, 600);
    view->add_child(new View(0, 0, 20, 20));
    view->add_child(new View(40, 40, 30, 50));

    assert(view->get_children()->get_count() == 2, "children count");

    LOOPV(i, view)
    {
        View *v = view->get_child(i);
        assert(v->get_size().x == (i+2)*10, "iterate");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x2441(%rip), %rdi      # 0x144f0
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
callq 0x3070
movl $0x38, %edi
callq 0x3310
movl -0x3c(%rbp), %edx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl $0x258, %r8d            # imm = 0x258
movl %edx, %esi
movl %r8d, %ecx
callq 0x12e90
jmp 0x120e2
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x38, %edi
callq 0x3310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
xorl %edx, %edx
movl $0x14, %r8d
movl %edx, %esi
movl %r8d, %ecx
callq 0x12e90
jmp 0x1211a
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0xf2f0
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x38, %edi
callq 0x3310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movl $0x28, %edx
movl $0x1e, %ecx
movl $0x32, %r8d
movl %edx, %esi
callq 0x12e90
jmp 0x1215c
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0xf2f0
movq -0x8(%rbp), %rdi
callq 0xf2d0
movq %rax, %rdi
callq 0x6550
cmpq $0x2, %rax
sete %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x2375(%rip), %rsi      # 0x14503
callq 0x109f0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf2d0
movq %rax, %rdi
callq 0x6550
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x1225d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf330
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xf570
movq %rax, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x2, %rcx
imulq $0xa, %rcx, %rcx
cmpq %rcx, %rax
sete %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x230d(%rip), %rsi      # 0x14512
callq 0x109f0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1219b
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x32e0
jmp 0x12263
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x32e0
jmp 0x12263
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x32e0
jmp 0x12263
addq $0x70, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x34d0
nopl (%rax)
// File: Jacobious52[P]Tanks/Test.cpp
// Function: fexists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool fexists(std::string fname)
{
    bool exists = false;
    std::ifstream file(fname.c_str(), std::ios::binary);
    exists = file.good();
    file.close();
    return exists;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x3170
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x4, %edx
callq 0x3500
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3490
movb %al, -0x225(%rbp)
jmp 0x122bc
movb -0x225(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30c0
jmp 0x122d5
movb -0x9(%rbp), %al
movb %al, -0x226(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30f0
movb -0x226(%rbp), %al
andb $0x1, %al
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30f0
jmp 0x1231b
jmp 0x1231d
movq -0x220(%rbp), %rdi
callq 0x34d0
movq %rax, %rdi
callq 0x3d90
nopw %cs:(%rax,%rax)
// File: Jacobious52[P]Tanks/Test.cpp
// Function: main
int main(int argc, char const *argv[])
{
    ConsoleTools::clear_screen();

    TextureTools::load_texture_file("textures.txt");

    test_point();
    test_array();
    test_view();
    test_textures();
    test_sounds();

    test_timer();

    ConsoleTools::set_cursor(0, ConsoleTools::get_terminal_size().y-1);
    ConsoleTools::end_color();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3ab0
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34e0
movq -0x58(%rbp), %rdx
leaq 0x1f2a(%rip), %rsi      # 0x1455d
leaq -0x30(%rbp), %rdi
callq 0x33a0
jmp 0x1263e
leaq -0x30(%rbp), %rdi
callq 0xbdc0
jmp 0x12649
leaq -0x30(%rbp), %rdi
callq 0x31c0
jmp 0x12654
leaq -0x31(%rbp), %rdi
callq 0x3360
callq 0x10ae0
callq 0x10c60
callq 0x120a0
callq 0x117d0
callq 0x12340
callq 0x115a0
callq 0x3b80
movq %rax, -0x4c(%rbp)
movl -0x48(%rbp), %esi
subl $0x1, %esi
xorl %edi, %edi
callq 0x3ad0
callq 0x3a50
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x126c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31c0
jmp 0x126c3
jmp 0x126c5
leaq -0x31(%rbp), %rdi
callq 0x3360
movq -0x40(%rbp), %rdi
callq 0x34d0
movq %rax, %rdi
callq 0x3d90
nop
// File: Jacobious52[P]Tanks/./MutableArray.h
// Function: MutableArray<Timer*>::clear()
void clear()
    {
        for (int i = 0; i < _count; ++i)
        {
            if (_items[i] != 0)
            {
                remove(i);
            }
        }

        _count = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x129e5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x129d8
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x128b0
jmp 0x129da
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x129ab
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Jacobious52[P]Tanks/Test.cpp
// Function: TestTimerDelegate::TestTimerDelegate()
TestTimerDelegate()
    {
        timer1 = Timer(0.1, 20);
        timer1.set_delegate(this);

        timer2 = Timer(0.05, true);
        timer2.set_delegate(this);

        printf("\nTesting delegate timer\n\n");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x12f50
movq -0x68(%rbp), %rdi
leaq 0x90c4(%rip), %rax      # 0x1bd58
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x70(%rbp)
callq 0x12f70
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x60(%rbp)
callq 0x12f70
jmp 0x12cb7
leaq -0x38(%rbp), %rdi
movsd 0x168d(%rip), %xmm0     # 0x14350
movl $0x14, %esi
callq 0xbbc0
jmp 0x12ccf
movq -0x68(%rbp), %rax
movups -0x38(%rbp), %xmm0
movups -0x2e(%rbp), %xmm1
movups %xmm1, 0x12(%rax)
movups %xmm0, 0x8(%rax)
leaq -0x38(%rbp), %rdi
callq 0xbc40
jmp 0x12cee
movq -0x68(%rbp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
callq 0xda50
jmp 0x12d00
leaq -0x58(%rbp), %rdi
movsd 0x14e4(%rip), %xmm0     # 0x141f0
movl $0x1, %esi
callq 0x12c30
jmp 0x12d18
movq -0x68(%rbp), %rax
movups -0x58(%rbp), %xmm0
movups -0x4e(%rbp), %xmm1
movups %xmm1, 0x32(%rax)
movups %xmm0, 0x28(%rax)
leaq -0x58(%rbp), %rdi
callq 0xbc40
jmp 0x12d37
movq -0x68(%rbp), %rsi
movq %rsi, %rdi
addq $0x28, %rdi
callq 0xda50
jmp 0x12d49
leaq 0x181a(%rip), %rdi      # 0x1456a
xorl %eax, %eax
callq 0x3070
jmp 0x12d59
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x12d86
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xbc40
jmp 0x12d84
jmp 0x12d86
movq -0x70(%rbp), %rdi
callq 0xbc40
jmp 0x12d91
jmp 0x12d93
movq -0x10(%rbp), %rdi
callq 0x34d0
movq %rax, %rdi
callq 0x3d90
nopw %cs:(%rax,%rax)
nop
// File: Jacobious52[P]Tanks/Test.cpp
// Function: TestTimerDelegate::timer_did_tick(Timer*, int)
void timer_did_tick(Timer *sender, int t)
    {
        if (sender == &timer1)
        {
            ConsoleTools::move_cursor(ConsoleTools::up, 1);
            ConsoleTools::clear_line();
            printf("delegate tick 1: %d\n", t);
        }
        else if (sender == &timer2)
        {
            ConsoleTools::move_cursor(ConsoleTools::up, 1);
            ConsoleTools::clear_line();
            printf("delegate tick 2: %d\n", t);
            if (t == 15)
            {
                timer2.end();
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x12fef
movl $0x41, %edi
movl $0x1, %esi
callq 0x3b50
callq 0x3b00
movl -0x14(%rbp), %esi
leaq 0x159e(%rip), %rdi      # 0x14584
movb $0x0, %al
callq 0x3070
jmp 0x1303c
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x28, %rcx
cmpq %rcx, %rax
jne 0x1303a
movl $0x41, %edi
movl $0x1, %esi
callq 0x3b50
callq 0x3b00
movl -0x14(%rbp), %esi
leaq 0x157b(%rip), %rdi      # 0x14599
movb $0x0, %al
callq 0x3070
cmpl $0xf, -0x14(%rbp)
jne 0x13038
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0xd9f0
jmp 0x1303a
jmp 0x1303c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./point_cloud_segmenter.cc
// Function: PointCloudSegmenter::ResolveMerge(int, int)
void PointCloudSegmenter::ResolveMerge(int x, int y) {
  int u = this->rtable.at(x);
  int v = this->rtable.at(y);

  if (u < v) {
    MergeOperation(u, v);
  } else if (u > v) {
    MergeOperation(v, u);
  }
}

// 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, -0x20(%rbp)
addq $0xb8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x6bf0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x14(%rbp)
addq $0xb8, %rdi
movslq -0x10(%rbp), %rsi
callq 0x6bf0
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4e51
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x4e70
jmp 0x4e6a
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x4e68
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x4e70
jmp 0x4e6a
addq $0x20, %rsp
popq %rbp
retq
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./point_cloud_segmenter.cc
// Function: PointCloudSegmenter::MergeOperation(int, int)
void PointCloudSegmenter::MergeOperation(int u, int v) {
  int i = v;

  while (i != -1) {
    this->rtable[i] = u;
    i = this->next[i];
  }

  this->next[this->tail[u]] = v;
  this->tail[u] = this->tail[v];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x4ed0
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0xb8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x68c0
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rdi
movl %ecx, (%rax)
addq $0x88, %rdi
movslq -0x14(%rbp), %rsi
callq 0x68c0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x4e90
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq %rdi, %rax
addq $0x88, %rax
movq %rax, -0x38(%rbp)
addq $0xa0, %rdi
movslq -0xc(%rbp), %rsi
callq 0x68c0
movq -0x38(%rbp), %rdi
movslq (%rax), %rsi
callq 0x68c0
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rdi
movl %ecx, (%rax)
addq $0xa0, %rdi
movslq -0x10(%rbp), %rsi
callq 0x68c0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x28(%rbp)
addq $0xa0, %rdi
movslq -0xc(%rbp), %rsi
callq 0x68c0
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: mitchellsayer[P]FastPointCloudSegmentation/src/main.cc
// Function: parseInput(std::vector<Vec3, std::allocator<Vec3>>&, PointCloudSegmenter)
void parseInput(std::vector<Vec3>& in, PointCloudSegmenter seg) {
  std::ifstream infile("../velodyne_points_1/data/0000000001.txt");
  double x, y, z, v;
  int k = 0;

  while (infile >> x >> y >> z >> v)
  {
    Vec3 pt = Vec3(x, y, z);
    if (pt.r > 0) {
      if (pt.x < seg.max_x && pt.x > -seg.max_x && pt.y < seg.max_y && pt.y > -seg.max_y && pt.z > -2) {
        if (pt.theta < 3 && pt.theta > -25) {
          in.push_back(pt);
        }
      }
    }

  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rsi, -0x270(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x218(%rbp), %rdi
leaq 0xce0f(%rip), %rsi      # 0x12117
movl $0x8, %edx
callq 0x23b0
movl $0x0, -0x23c(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x2190
movq %rax, -0x278(%rbp)
jmp 0x5338
movq -0x278(%rbp), %rdi
leaq -0x228(%rbp), %rsi
callq 0x2190
movq %rax, -0x280(%rbp)
jmp 0x5354
movq -0x280(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x2190
movq %rax, -0x288(%rbp)
jmp 0x5370
movq -0x288(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x2190
movq %rax, -0x290(%rbp)
jmp 0x538c
movq -0x290(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2270
movb %al, -0x291(%rbp)
jmp 0x53aa
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x53b9
jmp 0x54fb
movsd -0x220(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movsd -0x228(%rbp), %xmm1
cvtsd2ss %xmm1, %xmm1
movsd -0x230(%rbp), %xmm2
cvtsd2ss %xmm2, %xmm2
leaq -0x268(%rbp), %rdi
callq 0x7290
jmp 0x53eb
movss -0x25c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x54f6
movq -0x270(%rbp), %rax
movss -0x268(%rbp), %xmm1
cvtsi2ssl 0x80(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x54f4
movq -0x270(%rbp), %rcx
movss -0x268(%rbp), %xmm0
xorl %eax, %eax
subl 0x80(%rcx), %eax
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x54f4
movq -0x270(%rbp), %rax
movss -0x264(%rbp), %xmm1
cvtsi2ssl 0x84(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x54f4
movq -0x270(%rbp), %rcx
movss -0x264(%rbp), %xmm0
xorl %eax, %eax
subl 0x84(%rcx), %eax
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x54f4
movss -0x260(%rbp), %xmm0
movss 0xcb85(%rip), %xmm1     # 0x12018
ucomiss %xmm1, %xmm0
jbe 0x54f4
movss 0xcb7c(%rip), %xmm0     # 0x1201c
ucomiss -0x258(%rbp), %xmm0
jbe 0x54f2
movss -0x258(%rbp), %xmm0
movss 0xcb67(%rip), %xmm1     # 0x12020
ucomiss %xmm1, %xmm0
jbe 0x54f2
movq -0x8(%rbp), %rdi
leaq -0x268(%rbp), %rsi
callq 0x5890
jmp 0x54d0
jmp 0x54f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x2050
jmp 0x5510
jmp 0x54f4
jmp 0x54f6
jmp 0x531c
leaq -0x218(%rbp), %rdi
callq 0x2050
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x248(%rbp), %rdi
callq 0x2370
nopl (%rax)
// File: mitchellsayer[P]FastPointCloudSegmentation/src/main.cc
// Function: generateOutput(std::vector<Vec3, std::allocator<Vec3>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void generateOutput(std::vector<Vec3>& pts, std::string file_name) {
  std::ofstream file;
  file.open (file_name);
  std::vector<Vec3>::iterator it;
  for (it = pts.begin(); it != pts.end(); it++) {
    file << it->x << " " << it->y << " " << it->z << " " << it->label << "\n";
  }
  file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rsi, -0x248(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x2340
movq -0x250(%rbp), %rdi
movq -0x248(%rbp), %rsi
movl $0x10, %edx
callq 0x20b0
jmp 0x5567
leaq -0x228(%rbp), %rdi
callq 0x57d0
movq -0x8(%rbp), %rdi
callq 0x57f0
movq %rax, -0x230(%rbp)
movq -0x230(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5860
movq %rax, -0x238(%rbp)
leaq -0x228(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x5820
testb $0x1, %al
jne 0x55bd
jmp 0x56f9
leaq -0x228(%rbp), %rdi
callq 0x5c60
movss (%rax), %xmm0
leaq -0x210(%rbp), %rdi
callq 0x2150
movq %rax, -0x258(%rbp)
jmp 0x55e2
movq -0x258(%rbp), %rdi
leaq 0xcb01(%rip), %rsi      # 0x120f1
callq 0x21d0
movq %rax, -0x260(%rbp)
jmp 0x55fe
leaq -0x228(%rbp), %rdi
callq 0x5c60
movq -0x260(%rbp), %rdi
movss 0x4(%rax), %xmm0
callq 0x2150
movq %rax, -0x268(%rbp)
jmp 0x5624
movq -0x268(%rbp), %rdi
leaq 0xcabf(%rip), %rsi      # 0x120f1
callq 0x21d0
movq %rax, -0x270(%rbp)
jmp 0x5640
leaq -0x228(%rbp), %rdi
callq 0x5c60
movq -0x270(%rbp), %rdi
movss 0x8(%rax), %xmm0
callq 0x2150
movq %rax, -0x278(%rbp)
jmp 0x5666
movq -0x278(%rbp), %rdi
leaq 0xca7d(%rip), %rsi      # 0x120f1
callq 0x21d0
movq %rax, -0x280(%rbp)
jmp 0x5682
leaq -0x228(%rbp), %rdi
callq 0x5c60
movq -0x280(%rbp), %rdi
movss 0x18(%rax), %xmm0
callq 0x2150
movq %rax, -0x288(%rbp)
jmp 0x56a8
movq -0x288(%rbp), %rdi
leaq 0xcb56(%rip), %rsi      # 0x1220c
callq 0x21d0
jmp 0x56bd
jmp 0x56bf
leaq -0x228(%rbp), %rdi
xorl %esi, %esi
callq 0x5920
movq %rax, -0x240(%rbp)
jmp 0x5591
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x22e0
jmp 0x571c
leaq -0x210(%rbp), %rdi
callq 0x22a0
jmp 0x5707
leaq -0x210(%rbp), %rdi
callq 0x22e0
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x2370
nopl (%rax,%rax)
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./point_cloud_segmenter.h
// Function: ScanlinePointCloud::ScanlinePointCloud(std::vector<Vec3, std::allocator<Vec3>>&)
ScanlinePointCloud(std::vector<Vec3> & pts) : scanline_points(pts) {
    // Filter out ground labels
    for (int i = 0; i < pts.size(); i++) {
      Vec3 point = pts[i];
      if (point.label != -3) {
        ScanlinePoint wrapper(point, i);
        filtered_points.push_back(wrapper);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x98(%rbp)
callq 0x7520
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5780
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jae 0x66bc
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x69e0
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movl 0x18(%rax), %eax
movl %eax, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movss 0xb9d2(%rip), %xmm1     # 0x1200c
ucomiss %xmm1, %xmm0
jne 0x6643
jp 0x6643
jmp 0x66ac
movups -0x30(%rbp), %xmm0
movups -0x24(%rbp), %xmm1
movups %xmm1, -0x74(%rbp)
movaps %xmm0, -0x80(%rbp)
movslq -0x14(%rbp), %rsi
movups -0x74(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, 0xc(%rax)
movaps -0x80(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x58(%rbp), %rdi
callq 0x7540
jmp 0x6674
movq -0xa0(%rbp), %rdi
addq $0x8, %rdi
leaq -0x58(%rbp), %rsi
callq 0x7580
jmp 0x668a
jmp 0x66ac
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
callq 0x75f0
jmp 0x66c5
jmp 0x66ae
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x65dc
addq $0xd0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::KDTreeSingleIndexAdaptor(int, ScanlinePointCloud const&, nanoflann::KDTreeSingleIndexAdaptorParams const&)
KDTreeSingleIndexAdaptor(const int dimensionality, const DatasetAdaptor& inputData, const KDTreeSingleIndexAdaptorParams& params = KDTreeSingleIndexAdaptorParams() ) :
			dataset(inputData), index_params(params), root_node(NULL), distance(inputData)
		{
			m_size = dataset.kdtree_get_point_count();
			m_size_at_index_build = m_size;
			dim = dimensionality;
			if (DIM>0) dim=DIM;
			m_leaf_max_size = params.leaf_max_size;

			// Create a permutable array of indices to the input vectors.
			init_vind();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0xf290
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rdi)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rdi)
movq $0x0, 0x48(%rdi)
addq $0x68, %rdi
movq %rdi, -0x38(%rbp)
callq 0xf2b0
jmp 0x6759
movq -0x48(%rbp), %rdi
addq $0x90, %rdi
movq -0x18(%rbp), %rsi
callq 0xf2d0
jmp 0x676f
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xf2f0
movq %rax, -0x50(%rbp)
jmp 0x6782
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, 0x30(%rdi)
movq 0x30(%rdi), %rax
movq %rax, 0x38(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x40(%rdi)
movl $0x3, 0x40(%rdi)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rdi)
callq 0xf310
jmp 0x67b5
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x67de
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8170
movq -0x40(%rbp), %rdi
callq 0x81a0
movq -0x28(%rbp), %rdi
callq 0x2370
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::buildIndex()
void buildIndex()
		{
			init_vind();
			freeIndex();
			m_size_at_index_build = m_size;
			if(m_size == 0) return;
			computeBoundingBox(root_bbox);
			root_node = divideTree(0, m_size, root_bbox );   // construct the tree
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xf310
movq -0x10(%rbp), %rdi
callq 0xfdf0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x38(%rax)
cmpq $0x0, 0x30(%rax)
jne 0x6827
jmp 0x685a
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x50, %rsi
callq 0xfe30
movq -0x10(%rbp), %rdi
movq 0x30(%rdi), %rdx
movq %rdi, %rcx
addq $0x50, %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x10050
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./vec3.h
// Function: Vec3::distance(Vec3) const
float distance(Vec3 v1) const {
      float x_new = this->x - v1.x;
      float y_new = this->y - v1.y;
      float z_new = this->z - v1.z;
      return sqrt(x_new * x_new + y_new * y_new + z_new * z_new);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movss (%rcx), %xmm0
subss (%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movss 0x4(%rcx), %xmm0
subss 0x4(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movss 0x8(%rcx), %xmm0
subss 0x8(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0xc(%rbp), %xmm1
movss -0xc(%rbp), %xmm2
movss -0x10(%rbp), %xmm0
mulss -0x10(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x14(%rbp), %xmm0
movss -0x14(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x5c00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KNNResultSet<float, unsigned long, unsigned long>::init(unsigned long*, float*)
inline void init(IndexType* indices_, DistanceType* dists_)
		{
			indices = indices_;
			dists = dists_;
			count = 0;
            if (capacity)
                dists[capacity-1] = (std::numeric_limits<DistanceType>::max)();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x18(%rax)
cmpq $0x0, 0x10(%rax)
je 0x6cc4
callq 0x11320
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movss %xmm0, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)