LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::constraintCol(unsigned int)
int Table::constraintCol(uint col_id) {
    if (col_ty[col_id].beNull() == false) {
        Pointer p(this);
        while (p.next()) if (p.get()[col_id].isNull()) return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x58, %rdi
movl -0x14(%rbp), %eax
imulq $0x38, %rax, %rax
addq %rax, %rdi
callq 0x53200
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4ca43
movq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x47150
leaq -0x30(%rbp), %rdi
callq 0x46fe0
testb $0x1, %al
jne 0x4c9dc
jmp 0x4ca41
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x471c0
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xc8f0
movq %rax, -0x68(%rbp)
jmp 0x4c9ff
movq -0x68(%rbp), %rdi
callq 0xc920
movb %al, -0x71(%rbp)
jmp 0x4ca0d
leaq -0x48(%rbp), %rdi
callq 0xc430
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x4ca1f
jmp 0x4ca3f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4ca4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc430
jmp 0x4ca56
jmp 0x4c9cd
jmp 0x4ca43
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6890
nop
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::printBack(unsigned int)
bool Table::printBack(uint num) {
    if (num == 0 || sel != 1) return false;
    std::vector<std::pair<std::string, int> > v;
    for (uint i = 0; i < col_num; i++) v.push_back(std::pair<std::string, int>(col_ty[i].name, std::max(col_ty[i].printLen(), (int)strlen(col_ty[i].name))));
    Print::title(v);
    for (uint it = record_num - num; it < record_num; it++) { 
        Print::row(data[it]);
    }
    Print::end();
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x4e6e3
movq -0xb8(%rbp), %rax
cmpl $0x1, 0x9fb0(%rax)
je 0x4e6ec
movb $0x0, -0x1(%rbp)
jmp 0x4e8e6
leaq -0x30(%rbp), %rdi
callq 0xc0d0
movl $0x0, -0x34(%rbp)
movq -0xb8(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x54(%rcx), %eax
jae 0x4e7df
movq -0xb8(%rbp), %rax
movl -0x34(%rbp), %ecx
imulq $0x38, %rcx, %rcx
leaq 0x58(%rax,%rcx), %rdi
leaq 0x5a(%rax,%rcx), %rax
movq %rax, -0xc8(%rbp)
callq 0x534e0
movl %eax, -0xbc(%rbp)
jmp 0x4e73b
movq -0xb8(%rbp), %rax
movl -0xbc(%rbp), %ecx
movl %ecx, -0x64(%rbp)
movl -0x34(%rbp), %ecx
imulq $0x38, %rcx, %rcx
leaq 0x5a(%rax,%rcx), %rdi
callq 0x6250
movl %eax, -0x78(%rbp)
leaq -0x64(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x534a0
movq %rax, -0xd0(%rbp)
jmp 0x4e775
movq -0xd0(%rbp), %rdx
movq -0xc8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x53580
jmp 0x4e78e
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xc0f0
jmp 0x4e79d
leaq -0x60(%rbp), %rdi
callq 0xc1a0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4e6fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4e8db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xc1a0
jmp 0x4e8db
leaq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc1c0
jmp 0x4e7f1
leaq -0x90(%rbp), %rdi
callq 0x45590
jmp 0x4e7ff
leaq -0x90(%rbp), %rdi
callq 0xc2b0
movq -0xb8(%rbp), %rax
movl 0x9fa0(%rax), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0xb8(%rbp), %rcx
movl -0x94(%rbp), %eax
cmpl 0x9fa0(%rcx), %eax
jae 0x4e8c5
movq -0xb8(%rbp), %rdi
addq $0x9fb8, %rdi           # imm = 0x9FB8
movl -0x94(%rbp), %eax
movl %eax, %esi
callq 0x52170
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0xc400
jmp 0x4e866
leaq -0xb0(%rbp), %rdi
callq 0x45a80
jmp 0x4e874
leaq -0xb0(%rbp), %rdi
callq 0xc430
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x4e821
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xc2b0
jmp 0x4e8db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xc430
jmp 0x4e8db
callq 0x45cd0
jmp 0x4e8cc
movb $0x1, -0x1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc2b0
jmp 0x4e8e6
leaq -0x30(%rbp), %rdi
callq 0xc2b0
jmp 0x4e8f4
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x6890
nopl (%rax)
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::cmpRecord(Anys, Anys, enumOp)
bool Table::cmpRecord(Anys a, Anys b, enumOp op) {
    switch (op) {
    case OP_EQ: return a == b;
    case OP_NEQ: return a != b;
    case OP_LE: return a <= b;
    case OP_LS: return a < b;
    case OP_GE: return a >= b;
    case OP_GT: return a > b;
    default: return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x5, %rax
ja 0x4f21c
movq -0x30(%rbp), %rax
leaq 0x349b1(%rip), %rcx     # 0x83b4c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0xc500
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4f220
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0xc5a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4f220
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0xc5d0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4f220
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0xc630
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4f220
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0xc600
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4f220
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0xc710
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4f220
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::cmpRecords(Anys, enumOp, bool, bool)
bool Table::cmpRecords(Anys data, enumOp op, bool any, bool all) {
    bool cmp;
    Anys _data;
    Pointer p(this);
    while (p.next()) {
        _data = p.get();
        cmp = cmpRecord(data, _data, op);
        if (any && cmp) return true;
        if (all && !cmp) return false;
    }
    // for (uint record_id = 0; record_id < record_num; record_id++) {
    //     if ((_data = queryRecord(record_id)).size() == 0) continue;
    //     cmp = cmpRecord(data, _data, op);
    //     if (any && cmp) return true;
    //     if (all && !cmp) return false;
    // }
    if (any) return false;
    if (all) return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xc0(%rbp)
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %cl
movb %cl, -0x1d(%rbp)
andb $0x1, %al
movb %al, -0x1e(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc310
movq -0xb8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x47150
jmp 0x4f286
jmp 0x4f288
leaq -0x50(%rbp), %rdi
callq 0x46fe0
movb %al, -0xc1(%rbp)
jmp 0x4f299
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x4f2a8
jmp 0x4f3cb
leaq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x471c0
jmp 0x4f2b7
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movq %rsi, -0xd0(%rbp)
callq 0x42450
movq -0xd0(%rbp), %rdi
callq 0xc430
movq -0xc0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0xc400
jmp 0x4f2ec
leaq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc400
jmp 0x4f2fe
movq -0xb8(%rbp), %rdi
movl -0x1c(%rbp), %ecx
leaq -0x90(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x4f160
movb %al, -0xd1(%rbp)
jmp 0x4f323
movb -0xd1(%rbp), %al
andb $0x1, %al
movb %al, -0x1f(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xc430
leaq -0x90(%rbp), %rdi
callq 0xc430
testb $0x1, -0x1d(%rbp)
je 0x4f3aa
testb $0x1, -0x1f(%rbp)
je 0x4f3aa
movb $0x1, -0x1(%rbp)
movl $0x1, -0xac(%rbp)
jmp 0x4f405
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x4f41c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x4f39c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xc430
leaq -0x90(%rbp), %rdi
callq 0xc430
jmp 0x4f41c
testb $0x1, -0x1e(%rbp)
je 0x4f3c6
testb $0x1, -0x1f(%rbp)
jne 0x4f3c6
movb $0x0, -0x1(%rbp)
movl $0x1, -0xac(%rbp)
jmp 0x4f405
jmp 0x4f288
testb $0x1, -0x1d(%rbp)
je 0x4f3e1
movb $0x0, -0x1(%rbp)
movl $0x1, -0xac(%rbp)
jmp 0x4f405
testb $0x1, -0x1e(%rbp)
je 0x4f3f7
movb $0x1, -0x1(%rbp)
movl $0x1, -0xac(%rbp)
jmp 0x4f405
movb $0x0, -0x1(%rbp)
movl $0x1, -0xac(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc430
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xc430
movq -0x58(%rbp), %rdi
callq 0x6890
nop
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::existentRecords()
vector<uint> Table::existentRecords() {
    vector<uint> ret;
    BufType buf;
    for (uint record_id = 0; record_id < record_num; record_id++) {
        if (record_id % record_onepg == 0) {
            buf = bpm->getPage(main_file, record_id / record_onepg);
        }
        if (exist(buf, record_id % record_onepg)) {
            ret.push_back(record_id);
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xec40
movl $0x0, -0x24(%rbp)
movq -0x40(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x9fa0(%rcx), %eax
jae 0x4fe81
movq -0x40(%rbp), %rcx
movl -0x24(%rbp), %eax
xorl %edx, %edx
divl 0x9fac(%rcx)
cmpl $0x0, %edx
jne 0x4fe16
movq -0x40(%rbp), %rcx
movq 0x48(%rcx), %rdi
movl 0x9fa4(%rcx), %esi
movl -0x24(%rbp), %eax
movl 0x9fac(%rcx), %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %edx
callq 0x70b0
movq %rax, -0x58(%rbp)
jmp 0x4fdf2
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4fe16
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xee40
jmp 0x4fe9e
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x24(%rbp), %eax
xorl %edx, %edx
divl 0x9fac(%rcx)
movq -0x68(%rbp), %rax
shrl $0x3, %edx
movl %edx, %edx
movzbl (%rax,%rdx), %eax
movl %eax, -0x5c(%rbp)
movl -0x24(%rbp), %eax
xorl %edx, %edx
divl 0x9fac(%rcx)
movl -0x5c(%rbp), %eax
movl %edx, %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x4fe71
movq -0x50(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x3d2d0
jmp 0x4fe6f
jmp 0x4fe71
jmp 0x4fe73
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4fda3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4fe94
movq -0x50(%rbp), %rdi
callq 0xee40
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6890
nopw (%rax,%rax)
// File: Konano[P]UselessDatabase/Table.cpp
// Function: Table::removeRecords(std::vector<WhereStmt, std::allocator<WhereStmt>>&)
int Table::removeRecords(vector<WhereStmt> &where) {
    vector<uint> cols = findWheres(where);
    for (auto i: cols) {
        Pointer p(this, i);
        if (checkWheres(p.get(), where)) {
            removeRecord(i);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x90(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x4feb0
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3d210
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3d240
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3d270
testb $0x1, %al
jne 0x50383
jmp 0x5043a
leaq -0x38(%rbp), %rdi
callq 0x3d2b0
movq -0x90(%rbp), %rsi
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %edx
leaq -0x60(%rbp), %rdi
callq 0x47150
jmp 0x503a6
leaq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x471c0
jmp 0x503b8
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x88(%rbp), %rsi
callq 0x4fbf0
movb %al, -0x91(%rbp)
jmp 0x503d7
leaq -0x88(%rbp), %rdi
callq 0xc430
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x503ef
jmp 0x5042a
movq -0x90(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x49de0
jmp 0x50400
jmp 0x5042a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5044e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xc430
jmp 0x5044e
jmp 0x5042c
leaq -0x38(%rbp), %rdi
callq 0x3d3b0
jmp 0x5036d
leaq -0x28(%rbp), %rdi
callq 0xee40
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0xee40
movq -0x68(%rbp), %rdi
callq 0x6890
// File: Konano[P]UselessDatabase/./Any.h
// Function: Any& Any::operator=<int>(int const&)
Any &operator=(const ValueType &value)
    {
        Any tmp(value);
        if (_pValue)
            delete _pValue;
        _pValue = tmp._pValue;
        tmp._pValue = nullptr;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xd1d0
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x52fac
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x52faa
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x52fac
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc3c0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Konano[P]UselessDatabase/./Type.h
// Function: Type::printLen()
int printLen() {
        switch (ty) {
        case INT: return 10;
        case CHAR: return std::min(char_len, (uint8_t)20);
        case VARCHAR: return std::min(char_len, (uint8_t)20);
        case DATE: return 10;
        case DECIMAL: return 10;
        default: return -1;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x24(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0x5356a
movq -0x20(%rbp), %rax
leaq 0x30668(%rip), %rcx     # 0x83b74
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xa, -0x4(%rbp)
jmp 0x53571
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movb $0x14, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0x56700
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x53571
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movb $0x14, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0x56700
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x53571
movl $0xa, -0x4(%rbp)
jmp 0x53571
movl $0xa, -0x4(%rbp)
jmp 0x53571
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Konano[P]UselessDatabase/./Key.h
// Function: Key::operator==(Key const&)
bool operator==(const Key& b) {
        if (v_size != b.size()) return false;
        for (uint i = 0; i < v_size; i++) {
            if (v[i] != b[i]) return false;
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x532e0
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
je 0x56646
movb $0x0, -0x1(%rbp)
jmp 0x5669c
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x56698
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x3cf40
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x566b0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
je 0x5668b
movb $0x0, -0x1(%rbp)
jmp 0x5669c
jmp 0x5668d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5664d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Konano[P]UselessDatabase/main.cpp
// Function: main
int main() {
    // test_0();
    // test_1();
    // test_2();
    // test_3();
    // test_4();
    // test_5();
    // test_6();
    // test_7();
    // test_8();
    // test_9();
    // import_data_csv();
    import_data_tbl();
    cout << "import finish" << endl; 
    yyparse();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x5b0c0
movq 0x4faed(%rip), %rdi     # 0xb0fb8
leaq 0x230eb(%rip), %rsi     # 0x845bd
callq 0x6480
movq %rax, %rdi
movq 0x4faa7(%rip), %rsi     # 0xb0f88
callq 0x64f0
callq 0x66730
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Konano[P]UselessDatabase/main.cpp
// Function: copyStr(char const*)
inline char* copyStr(const char* _str) {
    uint size = strlen(_str);
    char* str = new char[size + 1];
    strcpy(str, _str);
    str[size] = '\0';
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6250
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x6040
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6460
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Konano[P]UselessDatabase/lex.yy.c
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 213 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 212);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x4ebda(%rip), %rax     # 0xb15c8
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21e0f(%rip), %rax     # 0x84810
cmpw $0x0, (%rax,%rcx,2)
je 0x62a1c
movl -0x4(%rbp), %eax
movl %eax, 0x4ebc3(%rip)     # 0xb15d4
movq -0x10(%rbp), %rax
movq %rax, 0x4ebbc(%rip)     # 0xb15d8
jmp 0x62a1e
movslq -0x4(%rbp), %rcx
leaq 0x22367(%rip), %rax     # 0x84d90
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x21f83(%rip), %rax     # 0x849c0
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x62a76
movslq -0x4(%rbp), %rcx
leaq 0x224ef(%rip), %rax     # 0x84f40
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xd5, -0x4(%rbp)
jl 0x62a74
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x22682(%rip), %rax     # 0x850f0
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x62a1e
movslq -0x4(%rbp), %rcx
leaq 0x2230f(%rip), %rax     # 0x84d90
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x2269b(%rip), %rax     # 0x85130
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xd4, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x62abb
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x62ac1
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ridgelab[P]Kmer-SSR/test/src/ssr.cpp
// Function: main
int main()
{
	SSR ssr1();
	SSR ssr2("ACGT", 4, 32);

	//cout << ssr2.toString() << endl;

	cout << "\n\033[0;34mSSR Test: ";

	bool pass = true;

	if (pass)
	{
		cout << "\033[0;32mOK\033[0m" << endl;
	}
	else
	{
		cout << "\033[0;31mFAIL\033[0m" << endl;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x22f0
movq -0x70(%rbp), %rdx
leaq 0x1afa(%rip), %rsi      # 0x4004
leaq -0x50(%rbp), %rdi
callq 0x2630
jmp 0x2515
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x4, %edx
movl $0x20, %ecx
callq 0x29c0
jmp 0x252e
leaq -0x50(%rbp), %rdi
callq 0x20d0
leaq -0x51(%rbp), %rdi
callq 0x21d0
movq 0x3a91(%rip), %rdi      # 0x5fd8
leaq 0x1abb(%rip), %rsi      # 0x4009
callq 0x21a0
jmp 0x2555
movb $0x1, -0x65(%rbp)
testb $0x1, -0x65(%rbp)
je 0x25d1
movq 0x3a72(%rip), %rdi      # 0x5fd8
leaq 0x1aaf(%rip), %rsi      # 0x401c
callq 0x21a0
movq %rax, -0x78(%rbp)
jmp 0x2578
movq -0x78(%rbp), %rdi
movq 0x3a45(%rip), %rsi      # 0x5fc8
callq 0x21b0
jmp 0x258a
jmp 0x25fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x25af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x20d0
leaq -0x51(%rbp), %rdi
callq 0x21d0
jmp 0x261a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2a40
jmp 0x261a
movq 0x3a00(%rip), %rdi      # 0x5fd8
leaq 0x1a4b(%rip), %rsi      # 0x402a
callq 0x21a0
movq %rax, -0x80(%rbp)
jmp 0x25ea
movq -0x80(%rbp), %rdi
movq 0x39d3(%rip), %rsi      # 0x5fc8
callq 0x21b0
jmp 0x25fc
jmp 0x25fe
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2a40
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/OutputFile.cpp
// Function: OutputFile::setUp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void OutputFile::setUp(const string &file_name)
{
	this->setUp();

	this->out_file.open(file_name.c_str());
	
	if (!this->out_file.is_open())
	{
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x2de0
movq -0x10(%rbp), %rdi
callq 0x2090
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x2040
movq -0x18(%rbp), %rdi
callq 0x2130
testb $0x1, %al
jne 0x2eae
movl $0x1, %edi
callq 0x2220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/OutputFile.cpp
// Function: OutputFile::writeHeaders(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void OutputFile::writeHeaders(const vector<string> &headers)
{
	sem_wait(&(this->lock));
	for (uint32_t i = 0; i < headers.size(); i++)
	{
		this->out_file << headers[i];
		if ( (headers[i].size() > 0) && (headers[i].at(headers[i].size() - 1) != '\n') )
		{
			this->out_file << endl;
		}
	}
	sem_post(&(this->lock));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x200, %rdi            # imm = 0x200
callq 0x20c0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3690
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x3191
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x36b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x2180
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x36b0
movq %rax, %rdi
callq 0x20f0
cmpq $0x0, %rax
jbe 0x3181
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x36b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x36b0
movq %rax, %rdi
callq 0x20f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x2210
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x3181
movq -0x20(%rbp), %rdi
movq 0x2e4c(%rip), %rsi      # 0x5fc8
callq 0x21b0
jmp 0x3183
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x30db
movq -0x20(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0x22b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/OutputFile.cpp
// Function: OutputFile::changeFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void OutputFile::changeFile(const string &file_name)
{
	sem_wait(&(this->lock));
	if (this->out_file.is_open())
	{
		this->out_file.close();
	}
	this->out_file.open(file_name.c_str());
	if (!this->out_file.is_open())
	{
		exit(1);
	}
	sem_post(&(this->lock));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x200, %rdi            # imm = 0x200
callq 0x20c0
movq -0x18(%rbp), %rdi
callq 0x2130
testb $0x1, %al
jne 0x3223
jmp 0x322c
movq -0x18(%rbp), %rdi
callq 0x2260
movq -0x10(%rbp), %rdi
callq 0x2090
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x2040
movq -0x18(%rbp), %rdi
callq 0x2130
testb $0x1, %al
jne 0x325d
movl $0x1, %edi
callq 0x2220
movq -0x18(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0x22b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/OutputFile.cpp
// Function: OutputFile::obtainLock(bool)
bool OutputFile::obtainLock(bool block)
{
	int ret = 0;

	if (block)
	{
		ret = sem_wait(&(this->lock));
		return ret == 0 ? true : false;
	}

	ret = sem_trywait(&(this->lock));
	return ret == 0 ? true : false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
testb $0x1, -0x11(%rbp)
je 0x330d
movq -0x20(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0x20c0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
subl $0x1, %ecx
sbbl %eax, %eax
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x332f
movq -0x20(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0x2060
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
subl $0x1, %ecx
sbbl %eax, %eax
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2grd/msh2grd.cpp
// Function: main
int 
main(int argc, char **argv)
{
  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Read mesh file
  R3Mesh *mesh = ReadMesh(mesh_name);
  if (!mesh) exit(-1);

  // Create grid from mesh
  R3Grid *grid = CreateGrid(mesh);
  if (!grid) exit(-1);

  // Write grid
  int status = WriteGrid(grid, grid_name);
  if (!status) exit(-1);

  // Return success
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x12570
cmpl $0x0, %eax
jne 0x124f2
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
movq 0x16606f(%rip), %rdi    # 0x178568
callq 0x127c0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x12515
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
movq 0x10(%rsp), %rdi
callq 0x12920
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x12536
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
movq 0x8(%rsp), %rdi
movq 0x16602e(%rip), %rsi    # 0x178570
callq 0x133d0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x1255c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2grd/msh2grd.cpp
// Function: ReadMesh(char*)
static R3Mesh *
ReadMesh(char *mesh_name)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate mesh
  R3Mesh *mesh = new R3Mesh();
  assert(mesh);

  // Read mesh from file
  if (!mesh->ReadFile(mesh_name)) {
    delete mesh;
    return NULL;
  }

  // Print statistics
  if (print_verbose) {
    printf("Read mesh ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return success
  return mesh;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd0d10
movq 0x10(%rsp), %rdi
callq 0x13580
movl $0x138, %edi            # imm = 0x138
callq 0xf4c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x13e70
jmp 0x127fe
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq (%rdi), %rax
callq *0x180(%rax)
cmpl $0x0, %eax
jne 0x1286b
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1283b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x50(%rsp)
jmp 0x12905
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x138, %esi            # imm = 0x138
callq 0xf4d0
jmp 0x1290f
cmpl $0x0, 0x165d06(%rip)    # 0x178578
je 0x128fb
leaq 0x120833(%rip), %rdi    # 0x1330b2
movb $0x0, %al
callq 0xf070
leaq 0x38(%rsp), %rdi
callq 0xd0dd0
leaq 0x12082a(%rip), %rdi    # 0x1330c1
movb $0x1, %al
callq 0xf070
movq 0x30(%rsp), %rdi
callq 0x135a0
movl %eax, %esi
leaq 0x120827(%rip), %rdi    # 0x1330d8
movb $0x0, %al
callq 0xf070
movq 0x30(%rsp), %rdi
callq 0x135c0
movl %eax, %esi
leaq 0x12081d(%rip), %rdi    # 0x1330e8
movb $0x0, %al
callq 0xf070
movq 0x30(%rsp), %rdi
callq 0x135e0
movl %eax, %esi
leaq 0x120813(%rip), %rdi    # 0x1330f8
movb $0x0, %al
callq 0xf070
movq 0x15c69d(%rip), %rax    # 0x16ef90
movq (%rax), %rdi
callq 0xf5d0
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xf890
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/msh2grd/msh2grd.cpp
// Function: WriteGrid(gaps::R3Grid*, char const*)
static int 
WriteGrid(R3Grid *grid, const char *grid_name)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Write grid
  int status = grid->WriteFile(grid_name);

  // Print statistics
  if (print_verbose) {
    printf("Wrote grid ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Bytes = %d\n", status * (int) sizeof(RNScalar));
    fflush(stdout);
  }

  // Return status
  return status;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xd0d10
leaq 0x8(%rsp), %rdi
callq 0x13580
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x65e80
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x16516c(%rip)    # 0x178578
je 0x13458
leaq 0x11fdab(%rip), %rdi    # 0x1331c0
movb $0x0, %al
callq 0xf070
leaq 0x8(%rsp), %rdi
callq 0xd0dd0
leaq 0x11fc94(%rip), %rdi    # 0x1330c1
movb $0x1, %al
callq 0xf070
movl 0x4(%rsp), %esi
shll $0x3, %esi
leaq 0x11fd8e(%rip), %rdi    # 0x1331d0
movb $0x0, %al
callq 0xf070
movq 0x15bb40(%rip), %rax    # 0x16ef90
movq (%rax), %rdi
callq 0xf5d0
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2grd/msh2grd.cpp
// Function: ShortestEdgeLength(gaps::R3Mesh*, gaps::R3MeshFace*)
static RNLength
ShortestEdgeLength(R3Mesh *mesh, R3MeshFace *face)
{
  // Return shortest edge on face
  RNLength d0 = mesh->EdgeLength(mesh->EdgeOnFace(face, 0));
  RNLength d1 = mesh->EdgeLength(mesh->EdgeOnFace(face, 1));
  RNLength d2 = mesh->EdgeLength(mesh->EdgeOnFace(face, 2));
  RNLength d = FLT_MAX;
  if (d0 < d) d = d0;
  if (d1 < d) d = d1;
  if (d2 < d) d = d2;
  return d;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
xorl %edx, %edx
callq 0x13d30
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x13cc0
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x1, %edx
callq 0x13d30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x13cc0
movsd %xmm0, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x2, %edx
callq 0x13d30
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x13cc0
movsd %xmm0, 0x20(%rsp)
movsd 0x11fb0c(%rip), %xmm0   # 0x133020
movsd %xmm0, 0x18(%rsp)
movsd 0x30(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x13538
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x13556
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x13574
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addq $0x48, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/apps/msh2grd/../../pkgs/R3Shapes/R3Grid.h
// Function: gaps::R3Grid::RasterizeGridTriangle(gaps::R3Point const&, gaps::R3Point const&, gaps::R3Point const&, double, int)
inline void R3Grid::
RasterizeGridTriangle(const R3Point& p1, const R3Point& p2, const R3Point& p3, RNScalar value, int operation)
{
  // Splat value everywhere inside grid triangle
  int i1[3] = { (int) (p1[0] + 0.5), (int) (p1[1] + 0.5), (int) (p1[2] + 0.5) };
  int i2[3] = { (int) (p2[0] + 0.5), (int) (p2[1] + 0.5), (int) (p2[2] + 0.5) };
  int i3[3] = { (int) (p3[0] + 0.5), (int) (p3[1] + 0.5), (int) (p3[2] + 0.5) };
  RasterizeGridTriangle(i1, i2, i3, value, operation);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x13af0
movsd 0x11f4a0(%rip), %xmm1   # 0x133010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x13af0
movsd 0x11f47d(%rip), %xmm1   # 0x133010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x24(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
callq 0x13af0
movsd 0x11f45a(%rip), %xmm1   # 0x133010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x13af0
movsd 0x11f43a(%rip), %xmm1   # 0x133010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x13af0
movsd 0x11f417(%rip), %xmm1   # 0x133010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movl $0x2, %esi
callq 0x13af0
movsd 0x11f3f4(%rip), %xmm1   # 0x133010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x13af0
movsd 0x11f3d4(%rip), %xmm1   # 0x133010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x13af0
movsd 0x11f3b1(%rip), %xmm1   # 0x133010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x13af0
movq (%rsp), %rdi
movsd 0x11f38a(%rip), %xmm1   # 0x133010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
leaq 0x14(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movsd 0x30(%rsp), %xmm0
movl 0x2c(%rsp), %r8d
callq 0x607c0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::R3Mesh()
R3Mesh::
R3Mesh(void) 
  : vertex_block(NULL),
    edge_block(NULL),
    face_block(NULL),
    vbo_face_position_buffer(0),
    vbo_face_normal_buffer(0),
    vbo_face_texcoord_buffer(0),
    vbo_face_rgb_color_buffer(0),
    vbo_face_pick_color_buffer(0),
    vbo_vertex_position_buffer(0),
    vbo_vertex_normal_buffer(0),
    vbo_vertex_texcoord_buffer(0),
    vbo_vertex_rgb_color_buffer(0),
    vbo_vertex_pick_color_buffer(0),
    bbox(R3null_box),
    data(NULL)
{
  // Initialize name
  name[0] = '\0';

  // Just checking
  assert(IsValid());
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x157586(%rip), %rax    # 0x16b410
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
callq 0x36800
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x18(%rsp)
callq 0x36810
jmp 0x13eb0
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, (%rsp)
callq 0x36820
jmp 0x13ec4
movq 0x10(%rsp), %rdi
movq $0x0, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movq $0x0, 0x48(%rdi)
movl $0x0, 0x50(%rdi)
movl $0x0, 0x54(%rdi)
movl $0x0, 0x58(%rdi)
movl $0x0, 0x5c(%rdi)
movl $0x0, 0x60(%rdi)
movl $0x0, 0x64(%rdi)
movl $0x0, 0x68(%rdi)
movl $0x0, 0x6c(%rdi)
movl $0x0, 0x70(%rdi)
movl $0x0, 0x74(%rdi)
addq $0xf8, %rdi
leaq 0x1648b3(%rip), %rsi    # 0x1787e8
callq 0x428c0
jmp 0x13f3c
movq 0x10(%rsp), %rax
movq $0x0, 0x130(%rax)
movb $0x0, 0x78(%rax)
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x13f96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x13f8c
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x36830
movq 0x18(%rsp), %rdi
callq 0x36840
movq 0x8(%rsp), %rdi
callq 0x36850
movq 0x28(%rsp), %rdi
callq 0xf890
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::Centroid() const
R3Point R3Mesh::
Centroid(void) const
{
  // Return centroid of mesh
  RNArea area = 0;
  R3Point centroid(0,0,0);
  if (NFaces() > 0) {
    for (int i = 0; i < NFaces(); i++) {
      R3MeshFace *face = Face(i);
      RNArea face_area = FaceArea(face);
      R3Point face_centroid = FaceCentroid(face);
      centroid += face_area * face_centroid;
      area += face_area;
    }
  }
  else {
    for (int i = 0; i < NVertices(); i++) {
      R3MeshVertex *vertex = Vertex(i);
      centroid += VertexPosition(vertex);
      area += 1.0;
    }
  }

  // Return centroid
  if (area == 0) return centroid;
  else return centroid / area;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x90(%rsp)
leaq 0x78(%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x6eb50
movq 0x18(%rsp), %rdi
callq 0x135a0
cmpl $0x0, %eax
jle 0x14f25
movl $0x0, 0x74(%rsp)
movq 0x18(%rsp), %rdi
movl 0x74(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x135a0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x14f23
movq 0x18(%rsp), %rdi
movl 0x74(%rsp), %esi
callq 0x136d0
movq 0x18(%rsp), %rdi
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rsi
callq 0x36aa0
movq 0x18(%rsp), %rsi
movsd %xmm0, 0x60(%rsp)
movq 0x68(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x14ff0
movsd 0x60(%rsp), %xmm0
leaq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x36b10
leaq 0x78(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x6f820
movsd 0x60(%rsp), %xmm0
addsd 0x90(%rsp), %xmm0
movsd %xmm0, 0x90(%rsp)
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x14e7b
jmp 0x14f9f
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, (%rsp)
callq 0x135e0
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x14f9d
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x13630
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x13660
movq %rax, %rsi
leaq 0x78(%rsp), %rdi
callq 0x6f820
movsd 0x11e08a(%rip), %xmm0   # 0x133008
addsd 0x90(%rsp), %xmm0
movsd %xmm0, 0x90(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x14f2d
jmp 0x14f9f
movsd 0x90(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14fc4
jp 0x14fc4
movq 0x8(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x6eb90
jmp 0x14fdc
movq 0x8(%rsp), %rdi
movsd 0x90(%rsp), %xmm0
leaq 0x78(%rsp), %rsi
callq 0x6fc00
movq 0x10(%rsp), %rax
addq $0xa8, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::FaceCentroid(gaps::R3MeshFace const*) const
R3Point R3Mesh::
FaceCentroid(const R3MeshFace *f) const
{
  // Return face centroid
  R3Point centroid = R3zero_point;
  centroid += f->vertex[0]->position;
  centroid += f->vertex[1]->position;
  centroid += f->vertex[2]->position;
  return centroid / 3.0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x564494(%rip), %rsi    # 0x5794b0
callq 0x6eb90
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rsi
addq $0x18, %rsi
leaq 0x18(%rsp), %rdi
callq 0x6f820
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
addq $0x18, %rsi
leaq 0x18(%rsp), %rdi
callq 0x6f820
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rsi
addq $0x18, %rsi
leaq 0x18(%rsp), %rdi
callq 0x6f820
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movsd 0x11e168(%rip), %xmm0   # 0x1331e0
callq 0x6fc00
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::Area() const
RNArea R3Mesh::
Area(void) const
{
  // Return area of mesh
  RNArea area = 0;
  for (int i = 0; i < NFaces(); i++) {
    R3MeshFace *face = Face(i);
    RNArea face_area = FaceArea(face);
    area += face_area;
  }

  // Return total area
  return area;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x135a0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x15117
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x136d0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x36aa0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x150b4
movsd 0x28(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::AverageVertexValence() const
RNScalar R3Mesh::
AverageVertexValence(void) const
{
  // Check number of vertices
  if (NVertices() == 0) return 0;

  // Sum vertex valences
  RNScalar sum = 0.0;
  for (int i = 0; i < NVertices(); i++) {
    R3MeshVertex *vertex = Vertex(i);
    sum += VertexValence(vertex);
  }
  return sum / NVertices();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x135e0
cmpl $0x0, %eax
jne 0x153cb
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x15461
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x135e0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x15437
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x13630
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x36b50
cvtsi2sd %eax, %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x153dc
movq 0x18(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x135e0
movsd 0x8(%rsp), %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::AverageEdgeLength() const
RNLength R3Mesh::
AverageEdgeLength(void) const
{
  // Check number of edges
  if (NEdges() == 0) return 0;

  // Sum edge lengths
  RNLength sum = 0;
  for (int i = 0; i < NEdges(); i++) {
    R3MeshEdge *edge = Edge(i);
    sum += EdgeLength(edge);
  }

  // Return average
  return sum / NEdges();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x135c0
cmpl $0x0, %eax
jne 0x1549b
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x1552d
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x135c0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x15503
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x36930
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x13cc0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x154ac
movq 0x18(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x135c0
movsd 0x8(%rsp), %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::AverageEdgeInteriorAngle() const
RNAngle R3Mesh::
AverageEdgeInteriorAngle(void) const
{
  // Sum dihedral angles
  int count = 0;
  RNAngle sum = 0.0;
  for (int i = 0; i < NEdges(); i++) {
    R3MeshEdge *edge = Edge(i);
    RNAngle angle = EdgeInteriorAngle(edge);
    if (RNIsZero(angle)) continue;
    sum += angle;
    count++;
  }

  // Return average
  return (count > 0) ? sum / count : 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x3c(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x135c0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x155fa
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x36930
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x15630
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
leaq 0x162f23(%rip), %rax    # 0x1784e0
movsd (%rax), %xmm1
callq 0x36b80
cmpl $0x0, %eax
je 0x155cd
jmp 0x155ea
movsd 0x18(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1556c
cmpl $0x0, 0x3c(%rsp)
jle 0x15618
movsd 0x30(%rsp), %xmm0
cvtsi2sdl 0x3c(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
jmp 0x15622
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
jmp 0x15622
movsd (%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::EdgeInteriorAngle(gaps::R3MeshEdge const*) const
RNAngle R3Mesh:: 
EdgeInteriorAngle(const R3MeshEdge *e) const
{
  // Get attached faces
  R3MeshFace *f0 = FaceOnEdge(e, 0);
  R3MeshFace *f1 = FaceOnEdge(e, 1);
  if (!f0 || !f1) return 0.0;

  // Returns the dihedral angle between the attached faces (in range 0 to 2*PI)
  R3Vector cross_normals = FaceNormal(f0) % FaceNormal(f1);
  RNScalar cos_angle = FaceNormal(f0).Dot(FaceNormal(f1));
  RNScalar acos_angle = (RNIsEqual(cos_angle * cos_angle, 1.0, 1.0E-6)) ? 0.0 : acos(cos_angle);
  RNBoolean convex = (cross_normals.Dot(EdgeVector(e)) > 0);
  RNScalar angle = (convex) ? (RN_PI - acos_angle) : (RN_PI + acos_angle);
  assert((angle >= 0.0) && (angle <= RN_TWO_PI));
  return angle;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x98(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x90(%rsp), %rsi
xorl %edx, %edx
callq 0x37050
movq 0x28(%rsp), %rdi
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rsi
movl $0x1, %edx
callq 0x37050
movq %rax, 0x80(%rsp)
cmpq $0x0, 0x88(%rsp)
je 0x156a0
cmpq $0x0, 0x80(%rsp)
jne 0x156b1
xorps %xmm0, %xmm0
movsd %xmm0, 0xa0(%rsp)
jmp 0x15801
movq 0x28(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x13840
movq 0x28(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rsi
callq 0x13840
movq 0x18(%rsp), %rsi
movq %rax, %rdx
leaq 0x68(%rsp), %rdi
callq 0x70af0
movq 0x28(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x13840
movq 0x28(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x80(%rsp), %rsi
callq 0x13840
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x702c0
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
mulsd 0x60(%rsp), %xmm0
movsd 0x11d8cc(%rip), %xmm1   # 0x133008
movsd 0x11daa4(%rip), %xmm2   # 0x1331e8
callq 0x37170
cmpl $0x0, %eax
je 0x15759
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x1576a
movsd 0x60(%rsp), %xmm0
callq 0xf470
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rsi
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0x90(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x37120
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x702c0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
je 0x157cf
leaq 0x12111b(%rip), %rax    # 0x1368d8
movsd (%rax), %xmm0
subsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x157e6
leaq 0x121102(%rip), %rax    # 0x1368d8
movsd (%rax), %xmm0
addsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm0
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)