LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: davidjosepha[P]slitherlink/src/shared/contour.cpp
// Function: Contour::Contour(int, int, int, int)
Contour::Contour(int starti, int startj, int endi, int endj) {
    start_.i = starti;
    start_.j = startj;
    end_.i = endi;
    end_.j = endj;
    length_ = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl $0x1, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/shared/contour.cpp
// Function: Contour::sharesEndpoint(Contour const&) const
bool Contour::sharesEndpoint(Contour const & contour) const {
    return ((start_.i == contour.start_.i && start_.j == contour.start_.j) ||
            (start_.i == contour.end_.i && start_.j == contour.end_.j) ||
            (end_.i == contour.start_.i && end_.j == contour.start_.j) ||
            (end_.i == contour.end_.i && end_.j == contour.end_.j));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x2585
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rdx
movb $0x1, %al
cmpl 0xc(%rdx), %ecx
movb %al, -0x19(%rbp)
je 0x25fe
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x25aa
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rdx
movb $0x1, %al
cmpl 0x14(%rdx), %ecx
movb %al, -0x19(%rbp)
je 0x25fe
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x25cf
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x10(%rbp), %rdx
movb $0x1, %al
cmpl 0xc(%rdx), %ecx
movb %al, -0x19(%rbp)
je 0x25fe
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x10(%rdx), %ecx
movb %al, -0x1a(%rbp)
jne 0x25f8
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/shared/contour.cpp
// Function: Contour::addContour(Contour&)
void Contour::addContour(Contour & contour) {
    if (start_.i == contour.start_.i && start_.j == contour.start_.j) {
        start_.i = contour.end_.i;
        start_.j = contour.end_.j;
        length_++;
    } else if (start_.i == contour.end_.i && start_.j == contour.end_.j) {
        start_.i = contour.start_.i;
        start_.j = contour.start_.j;
        length_++;
    } else if (end_.i == contour.start_.i && end_.j == contour.start_.j) {
        end_.i = contour.end_.i;
        end_.j = contour.end_.j;
        length_++;
    } else if (end_.i == contour.end_.i && end_.j == contour.end_.j) {
        end_.i = contour.start_.i;
        end_.j = contour.start_.j;
        length_++;
    }

    if (start_.i == end_.i && start_.j == end_.j) {
        closed_ = true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x2664
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x2664
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0xc(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x272e
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x26a8
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x26a8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x272c
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x26e9
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x26e9
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x272a
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x2728
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x2728
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0x14(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x272a
jmp 0x272c
jmp 0x272e
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %eax
cmpl 0x10(%rcx), %eax
jne 0x274e
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x274e
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
popq %rbp
retq
// File: davidjosepha[P]slitherlink/src/shared/export.cpp
// Function: Export::formatHLine(int, int) const
char Export::formatHLine(int i, int j) const {
    switch (lattice_->getHLine(i, j)) {
        case LINE:
            return HLINE;
        case NLINE:
            return EX;
        default:
            return BLANK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x5bf0
movl %eax, %ecx
movl %ecx, -0x1c(%rbp)
subl $0x1, %eax
je 0x29da
jmp 0x29d0
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x29e0
jmp 0x29e6
movb $0x2d, -0x1(%rbp)
jmp 0x29ea
movb $0x78, -0x1(%rbp)
jmp 0x29ea
movb $0x20, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/shared/export.cpp
// Function: Export::formatVLine(int, int) const
char Export::formatVLine(int i, int j) const {
    switch (lattice_->getVLine(i, j)) {
        case LINE:
            return VLINE;
        case NLINE:
            return EX;
        default:
            return BLANK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x5c90
movl %eax, %ecx
movl %ecx, -0x1c(%rbp)
subl $0x1, %eax
je 0x2a3a
jmp 0x2a30
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x2a40
jmp 0x2a46
movb $0x7c, -0x1(%rbp)
jmp 0x2a4a
movb $0x78, -0x1(%rbp)
jmp 0x2a4a
movb $0x20, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/shared/export.cpp
// Function: Export::formatNumber(int, int) const
char Export::formatNumber(int i, int j) const {
    switch (lattice_->getNumber(i, j)) {
        case ZERO:
            return '0';
        case ONE:
            return '1';
        case TWO:
            return '2';
        case THREE:
            return '3';
        default:
            return BLANK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x5b50
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x2abd
movq -0x20(%rbp), %rax
leaq 0x12568(%rip), %rcx     # 0x15004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x30, -0x1(%rbp)
jmp 0x2ac1
movb $0x31, -0x1(%rbp)
jmp 0x2ac1
movb $0x32, -0x1(%rbp)
jmp 0x2ac1
movb $0x33, -0x1(%rbp)
jmp 0x2ac1
movb $0x20, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: davidjosepha[P]slitherlink/src/shared/grid.cpp
// Function: Grid::~Grid()
Grid::~Grid() {
    if (init_) {
        for (int i = 0; i < m_; i++) {
            delete [] updateMatrix_[i];
        }
        delete [] updateMatrix_;

        for (int i = 0; i < m_; i++) {
            delete [] contraMatrix_[i];
        }
        delete [] contraMatrix_;

        for (int i = 0; i < m_+1; i++) {
            delete [] contourMatrix_[i];
        }
        delete [] contourMatrix_;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1920d(%rip), %rcx     # 0x1bd38
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0x49(%rax)
je 0x2c5d
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x2b7f
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2b72
movq -0x28(%rbp), %rdi
callq 0x2230
jmp 0x2b74
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2b43
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2b9a
movq -0x30(%rbp), %rdi
callq 0x2230
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x2bdd
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2bd0
movq -0x38(%rbp), %rdi
callq 0x2230
jmp 0x2bd2
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2ba1
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x2bf8
movq -0x40(%rbp), %rdi
callq 0x2230
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movl 0xc(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2c40
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x2c33
movq -0x48(%rbp), %rdi
callq 0x2230
jmp 0x2c35
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2bff
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x2c5b
movq -0x50(%rbp), %rdi
callq 0x2230
jmp 0x2c5d
movq -0x20(%rbp), %rdi
callq 0x56c0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: davidjosepha[P]slitherlink/src/shared/grid.cpp
// Function: Grid::numberSatisfied(int, int) const
bool Grid::numberSatisfied(int i, int j) const {
    assert(0 <= i && i < m_ && 0 <= j && j < n_);

    Number number = numbers_[i][j];

    /* determine number of lines around number */
    int numLines = (hlines_[i][j] == LINE)
                 + (hlines_[i+1][j] == LINE)
                 + (vlines_[i][j] == LINE)
                 + (vlines_[i][j+1] == LINE);

    switch (number) {
        case NONE:
            return true;
        case ZERO:
            return numLines == 0;
        case ONE:
            return numLines == 1;
        case TWO:
            return numLines == 2;
        case THREE:
            return numLines == 3;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpl -0x14(%rbp), %ecx
movb %al, -0x21(%rbp)
jg 0x4723
movq -0x30(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl 0xc(%rdx), %ecx
movb %al, -0x21(%rbp)
jge 0x4723
xorl %eax, %eax
xorl %ecx, %ecx
cmpl -0x18(%rbp), %ecx
movb %al, -0x21(%rbp)
jg 0x4723
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x10(%rcx), %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x472c
jmp 0x472e
jmp 0x474d
leaq 0x10a11(%rip), %rdi     # 0x15146
leaq 0x10919(%rip), %rsi     # 0x15055
movl $0xeb, %edx
leaq 0x10a23(%rip), %rcx     # 0x1516b
callq 0x2120
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x1c(%rbp)
movslq -0x14(%rbp), %rdx
movslq -0x18(%rbp), %rsi
movq 0x20(%rax), %rdi
movq 0x28(%rax), %rcx
movq (%rdi,%rdx,8), %rax
movq 0x8(%rdi,%rdx,8), %rdi
movl (%rax,%rsi,4), %eax
subl $0x1, %eax
sete %al
movzbl %al, %eax
movl (%rdi,%rsi,4), %edi
subl $0x1, %edi
sete %dil
movzbl %dil, %edi
addl %edi, %eax
movq (%rcx,%rdx,8), %rcx
movl (%rcx,%rsi,4), %edx
movl 0x4(%rcx,%rsi,4), %ecx
subl $0x1, %edx
sete %dl
movzbl %dl, %edx
addl %edx, %eax
subl $0x1, %ecx
sete %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x4, %rax
ja 0x481f
movq -0x38(%rbp), %rax
leaq 0x1083c(%rip), %rcx     # 0x15014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x4821
cmpl $0x0, -0x20(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4821
cmpl $0x1, -0x20(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4821
cmpl $0x2, -0x20(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4821
cmpl $0x3, -0x20(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4821
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: davidjosepha[P]slitherlink/src/shared/grid.cpp
// Function: Grid::isSolved() const
bool Grid::isSolved() const {
    if (numOpenLoops_ != 0 || numClosedLoops_ != 1) {
        return false;
    }

    for (int i = 0; i < m_; i++) {
        for (int j = 0; j < n_; j++) {
            if (!numberSatisfied(i,j)) {
                return false;
            }
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x4c(%rax)
jne 0x4854
movq -0x20(%rbp), %rax
cmpl $0x1, 0x50(%rax)
je 0x485a
movb $0x0, -0x1(%rbp)
jmp 0x48b7
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x48b3
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x48a6
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x46d0
testb $0x1, %al
jne 0x4899
movb $0x0, -0x1(%rbp)
jmp 0x48b7
jmp 0x489b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4874
jmp 0x48a8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4861
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/shared/import.cpp
// Function: Import::importNumberRow(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Import::importNumberRow(int i, std::string row) {
    for (std::string::size_type j = 0; j < row.size(); j++) {
        char c = row[j];
        switch (c) {
            case '0':
                lattice_->setNumber(i, j+1, ZERO);
                break;
            case '1':
                lattice_->setNumber(i, j+1, ONE);
                break;
            case '2':
                lattice_->setNumber(i, j+1, TWO);
                break;
            case '3':
                lattice_->setNumber(i, j+1, THREE);
                break;
            default:
                lattice_->setNumber(i, j+1, NONE);
                break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2140
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x5492
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22f0
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
addl $-0x30, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x3, %eax
ja 0x5464
movq -0x48(%rbp), %rax
leaq 0xfdbd(%rip), %rcx      # 0x15198
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
movl $0x1, %ecx
callq 0x5d90
jmp 0x547f
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
movl $0x2, %ecx
callq 0x5d90
jmp 0x547f
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
movl $0x3, %ecx
callq 0x5d90
jmp 0x547f
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
movl $0x4, %ecx
callq 0x5d90
jmp 0x547f
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x5d90
jmp 0x5481
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5387
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: davidjosepha[P]slitherlink/src/shared/import.cpp
// Function: Import::importHLineRow(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Import::importHLineRow(int i, std::string row) {
  lattice_->setHLine(i, 0, NLINE);
    for (std::string::size_type j = 0; j < row.size(); j++) {

        char c = row[j];
        switch (c) {
            case '-':
                lattice_->setHLine(i, j+1, LINE);
                break;
            case 'x':
                lattice_->setHLine(i, j+1, NLINE);
                break;
            default:
                lattice_->setHLine(i, j+1, EMPTY);
                break;
        }
    }
    lattice_->setHLine(i, row.size()+1, NLINE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
xorl %edx, %edx
movl $0x2, %ecx
callq *(%rax)
movq $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2140
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x5592
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22f0
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x2d, %eax
je 0x5524
jmp 0x551a
movl -0x44(%rbp), %eax
subl $0x78, %eax
je 0x5544
jmp 0x5564
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
movq (%rdi), %rax
movl $0x1, %ecx
callq *(%rax)
jmp 0x557f
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
movq (%rdi), %rax
movl $0x2, %ecx
callq *(%rax)
jmp 0x557f
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
movq (%rdi), %rax
xorl %ecx, %ecx
callq *(%rax)
jmp 0x5581
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x54d9
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x48(%rbp)
callq 0x2140
movq -0x50(%rbp), %rdi
movl -0x48(%rbp), %esi
addq $0x1, %rax
movl %eax, %edx
movq (%rdi), %rax
movl $0x2, %ecx
callq *(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: davidjosepha[P]slitherlink/src/shared/import.cpp
// Function: Import::importVLineRow(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Import::importVLineRow(int i, std::string row) {

    for (std::string::size_type j = 0; j < row.size(); j++) {
        char c = row[j];
        switch (c) {
            case '-':
                lattice_->setVLine(i, j+1, LINE);
                break;
            case 'x':
                lattice_->setVLine(i, j+1, NLINE);
                break;
            default:
                lattice_->setVLine(i, j+1, EMPTY);
                break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2140
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x56b3
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22f0
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x2d, %eax
je 0x5642
jmp 0x5638
movl -0x44(%rbp), %eax
subl $0x78, %eax
je 0x5663
jmp 0x5684
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
movq (%rdi), %rax
movl $0x1, %ecx
callq *0x8(%rax)
jmp 0x56a0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
movq (%rdi), %rax
movl $0x2, %ecx
callq *0x8(%rax)
jmp 0x56a0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
movq (%rdi), %rax
xorl %ecx, %ecx
callq *0x8(%rax)
jmp 0x56a2
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x55f7
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: davidjosepha[P]slitherlink/src/shared/lattice.cpp
// Function: Lattice::destroyArrays()
void Lattice::destroyArrays() {
    if (init_) {
        for (int i = 0; i < m_; i++) {
            delete [] numbers_[i];
            delete [] hlines_[i];
            delete [] vlines_[i];
        }
        // hlines_ needs one extra
        delete [] hlines_[m_];
        // and delete the outer arrays
        delete [] numbers_;
        delete [] hlines_;
        delete [] vlines_;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x8(%rax)
je 0x5810
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x579a
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5744
movq -0x20(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5767
movq -0x28(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x578a
movq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x578c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5715
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rax
movslq 0xc(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x57bd
movq -0x38(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x57d8
movq -0x40(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x57f3
movq -0x48(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x580e
movq -0x50(%rbp), %rdi
callq 0x2230
jmp 0x5810
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/shared/lattice.cpp
// Function: Lattice::initArrays(int, int)
void Lattice::initArrays(int m, int n) {
    assert(m > 0 && n > 0);

    destroyArrays();

    m_ = m;
    n_ = n;

    numbers_ = new Number*[m_];
    hlines_ = new Edge*[m_+1];
    vlines_ = new Edge*[m_];
    for (int i = 0; i < m_; i++) {
        numbers_[i] = new Number[n_];
        hlines_[i] = new Edge[n_];
        vlines_[i] = new Edge[n_+1];
    }
    // hlines_ needs one extra
    hlines_[m_] = new Edge[n_];

    init_ = true;

    cleanArrays();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x15(%rbp)
jle 0x584f
cmpl $0x0, -0x10(%rbp)
setg %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x5858
jmp 0x585a
jmp 0x5879
leaq 0xf95c(%rip), %rdi      # 0x151bd
leaq 0xf964(%rip), %rsi      # 0x151cc
movl $0x17, %edx
leaq 0xf96f(%rip), %rcx      # 0x151e3
callq 0x2120
movq -0x20(%rbp), %rdi
callq 0x56f0
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x10(%rax)
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl 0xc(%rax), %eax
addl $0x1, %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x59fb
movq -0x20(%rbp), %rax
movslq 0x10(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movslq 0x10(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rsi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x10(%rax), %eax
addl $0x1, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x592d
movq -0x20(%rbp), %rax
movslq 0x10(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movq 0x20(%rdi), %rax
movslq 0xc(%rdi), %rcx
movq %rdx, (%rax,%rcx,8)
movb $0x1, 0x8(%rdi)
callq 0x5a50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/shared/lattice.cpp
// Function: Lattice::cleanArrays()
void Lattice::cleanArrays() {
    if (init_) {
        for (int i = 0; i < m_; i++) {
            for (int j = 0; j < n_; j++) {
                numbers_[i][j] = NONE;
                hlines_[i][j] = EMPTY;
                vlines_[i][j] = EMPTY;
            }
            vlines_[i][n_] = EMPTY;
        }

        for (int j = 0; j < n_; j++) {
            hlines_[m_][j] = EMPTY;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x8(%rax)
je 0x5b4c
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x5b11
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x5ae8
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5a88
movq -0x20(%rbp), %rcx
movq 0x28(%rcx), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movslq 0x10(%rcx), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5a71
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x5b4a
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rax
movslq 0xc(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5b18
jmp 0x5b4c
popq %rbp
retq
nop
// File: davidjosepha[P]slitherlink/src/solver/contradiction.cpp
// Function: Contradiction::getNumberHeight(Orientation) const
int Contradiction::getNumberHeight(Orientation orient) const {
    switch (orient) {
        case UP:
        case DOWN:
        case UPFLIP:
        case DOWNFLIP:
            return m_;
        case LEFT:
        case RIGHT:
        case LEFTFLIP:
        case RIGHTFLIP:
            return n_;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x2, %eax
jb 0x6047
jmp 0x6020
movl -0x18(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x6052
jmp 0x602d
movl -0x18(%rbp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0x6047
jmp 0x603a
movl -0x18(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x6052
jmp 0x605e
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x6060
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x6060
ud2
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/solver/epq.cpp
// Function: EPQ::initEPQ(int, int)
void EPQ::initEPQ(int m, int n)  {
    assert(m > 0 && n > 0);

    m_ = m;
    n_ = n;

    for (int i = 1; i < m-1; i++) {
        for (int j = 1; j < n-1; j++) {
            pq_.push(createPrioEdge(0, i, j, true));
            pq_.push(createPrioEdge(0, i, j, false));
        }
        pq_.push(createPrioEdge(0, i, n-1, false));
    }

    for (int j = 1; j < n-1; j++) {
        pq_.push(createPrioEdge(0, m-1, j, true));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x81(%rbp)
jle 0x84bb
cmpl $0x0, -0x10(%rbp)
setg %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x84c7
jmp 0x84c9
jmp 0x84e8
leaq 0xcced(%rip), %rdi      # 0x151bd
leaq 0xce52(%rip), %rsi      # 0x15329
movl $0x7, %edx
leaq 0xce59(%rip), %rcx      # 0x1533c
callq 0x2120
movq -0x90(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x85fa
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x85af
movq -0x90(%rbp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, -0xa0(%rbp)
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq -0x30(%rbp), %rdi
xorps %xmm0, %xmm0
movl $0x1, %r8d
callq 0x8670
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8bc0
movq -0x90(%rbp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, -0x98(%rbp)
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq -0x48(%rbp), %rdi
xorps %xmm0, %xmm0
xorl %r8d, %r8d
callq 0x8670
movq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8bc0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8519
movq -0x90(%rbp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, -0xa8(%rbp)
movl -0x14(%rbp), %edx
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
leaq -0x60(%rbp), %rdi
xorps %xmm0, %xmm0
xorl %r8d, %r8d
callq 0x8670
movq -0xa8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8bc0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8501
movl $0x1, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x8659
movq -0x90(%rbp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, -0xb0(%rbp)
movl -0xc(%rbp), %edx
subl $0x1, %edx
movl -0x64(%rbp), %ecx
leaq -0x80(%rbp), %rdi
xorps %xmm0, %xmm0
movl $0x1, %r8d
callq 0x8670
movq -0xb0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x8bc0
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x8601
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/solver/epq.cpp
// Function: EPQ::copyPQToVector() const
std::vector<PrioEdge> EPQ::copyPQToVector() const {
    std::priority_queue<PrioEdge, std::vector<PrioEdge>, ComparePrioEdge> newPQ;
    std::vector<PrioEdge> outputvec(pq_.size());
    std::copy(&(pq_.top()), &(pq_.top()) + pq_.size(), &outputvec[0]);
    return outputvec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8d10
movq -0x58(%rbp), %rdi
movb $0x0, -0x31(%rbp)
addq $0x8, %rdi
callq 0x8c30
movq %rax, -0x50(%rbp)
jmp 0x88e6
leaq -0x45(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x8d40
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x8d60
jmp 0x8906
leaq -0x45(%rbp), %rdi
callq 0x8dd0
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x8c50
movq %rax, -0x78(%rbp)
jmp 0x8922
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x8c50
movq %rax, -0x80(%rbp)
jmp 0x8935
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x8c30
movq %rax, -0x88(%rbp)
jmp 0x894b
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rax
movq -0x88(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x90(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x8e30
movq -0x78(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq %rax, %rdx
callq 0x8df0
jmp 0x8987
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x89d8
jmp 0x89cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x89ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x45(%rbp), %rdi
callq 0x8dd0
jmp 0x89ee
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x8e50
jmp 0x89ee
movq -0x68(%rbp), %rdi
callq 0x8e50
leaq -0x30(%rbp), %rdi
callq 0x8eb0
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x8eb0
movq -0x40(%rbp), %rdi
callq 0x22c0
// File: davidjosepha[P]slitherlink/src/solver/epq.cpp
// Function: EPQ::copySubsetPQ(EPQ)
void EPQ::copySubsetPQ(EPQ orig) {
    PrioEdge pe = orig.top();
    std::vector<PrioEdge> prioEdgeVec = orig.copyPQToVector();
    for (int i = 0; i < prioEdgeVec.size(); i++) {
        PrioEdge cur = prioEdgeVec[i];
        if (cur.coords.i < pe.coords.i && cur.coords.j < pe.coords.j)
            pq_.push(prioEdgeVec[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x87a0
movq -0x78(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x88a0
movl $0x0, -0x44(%rbp)
movslq -0x44(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8ed0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x8b9d
movslq -0x44(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8e30
movq (%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x8b8d
movl -0x5c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x8b8d
movq -0x80(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x90(%rbp)
movslq -0x44(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8e30
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x8c70
jmp 0x8b74
jmp 0x8b8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8e50
jmp 0x8baf
jmp 0x8b8f
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x8aec
leaq -0x40(%rbp), %rdi
callq 0x8e50
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x22c0
nopl (%rax,%rax)
// File: davidjosepha[P]slitherlink/src/solver/rotate.cpp
// Function: rotateNumber(int, int, int, int, Orientation)
Coordinates rotateNumber(int i, int j, int m, int n, Orientation orient) {
    switch (orient) {
        case UPFLIP:
            i = m - i - 1;
        case UP:
            return Coordinates { i, j };
        case DOWNFLIP:
            i = m - i - 1;
        case DOWN:
            return Coordinates { m-i-1, n-j-1 };
        case LEFTFLIP:
            i = m - i - 1;
        case LEFT:
            return Coordinates { n-j-1, i };
        case RIGHTFLIP:
            i = m - i - 1;
        case RIGHT:
            return Coordinates { j, m-i-1 };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x7, %rax
ja 0xaa49
movq -0x28(%rbp), %rax
leaq 0xaa38(%rip), %rcx      # 0x153f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xaa4b
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x18(%rbp), %eax
subl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xaa4b
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x18(%rbp), %eax
subl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xaa4b
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xaa4b
ud2
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/solver/solver.cpp
// Function: Solver::Solver(Grid&, Rule*, Contradiction*, int*, int, int)
Solver::Solver(Grid & grid, Rule rules[NUM_RULES], Contradiction contradictions[NUM_CONTRADICTIONS], int selectedRules[], int selectLength, int depth) {
    grid_ = &grid;
    depth_ = depth;

    multipleSolutions_ = false;

    epq_.initEPQ(grid_->getHeight(), grid_->getWidth());

    rules_ = rules;
    contradictions_ = contradictions;
    selectedRules_ = selectedRules;
    ruleCounts_ = 0;

    int selectedPlusBasic[selectLength+NUM_CONST_RULES];
    for (int i = 0; i < selectLength; i++) {
        selectedPlusBasic[i] = selectedRules[i];
    }

    for (int i = 1; i <= NUM_CONST_RULES; i++) {
        selectedPlusBasic[selectLength+ NUM_CONST_RULES - i] = (NUM_RULES - i);
    }

    selectLength_ = selectLength + NUM_CONST_RULES;
    applyRules(selectedPlusBasic);
    selectLength_ = selectLength;

    solve();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x38, %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0xfba0
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x10(%rax)
movb $0x0, 0x64(%rax)
movq 0x8(%rax), %rdi
callq 0x2ad0
movl %eax, -0x5c(%rbp)
jmp 0xcc46
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2af0
movl %eax, -0x7c(%rbp)
jmp 0xcc58
movl -0x7c(%rbp), %edx
movl -0x5c(%rbp), %esi
movq -0x78(%rbp), %rdi
callq 0x8480
jmp 0xcc69
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x0, (%rax)
movl -0x2c(%rbp), %eax
addl $0x3, %eax
movq %rsp, %rcx
movq %rcx, -0x48(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x88(%rbp)
movq %rcx, %rsp
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0xcd02
movq -0x88(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x54(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
movslq -0x54(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xccbf
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xfbc0
jmp 0xcd70
movl $0x1, -0x58(%rbp)
cmpl $0x3, -0x58(%rbp)
jg 0xcd38
movq -0x88(%rbp), %rax
movl $0x21, %edx
subl -0x58(%rbp), %edx
movl -0x2c(%rbp), %ecx
addl $0x3, %ecx
subl -0x58(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0xcd09
movq -0x88(%rbp), %rsi
movq -0x68(%rbp), %rdi
movl -0x2c(%rbp), %eax
addl $0x3, %eax
movl %eax, 0x28(%rdi)
callq 0xcd80
jmp 0xcd53
movq -0x68(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, 0x28(%rdi)
callq 0xcf60
jmp 0xcd64
movq -0x48(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22c0
nopl (%rax)
// File: davidjosepha[P]slitherlink/src/solver/solver.cpp
// Function: Solver::solve()
void Solver::solve() {
    grid_->setUpdated(true);
    while (grid_->getUpdated() && !grid_->isSolved()) {
        applyRules(selectedRules_);

        for (int d = 0; d < depth_; d++) {
            if (!grid_->getUpdated() && !testContradictions() && !grid_->isSolved() && !multipleSolutions_) {
                solveDepth(d);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0xfc50
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfc70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0xcf9d
jmp 0xcfaf
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4830
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xcfb8
jmp 0xd02f
movq -0x18(%rbp), %rdi
movq 0x20(%rdi), %rsi
callq 0xcd80
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0xd02a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfc70
testb $0x1, %al
jne 0xd01d
movq -0x18(%rbp), %rdi
callq 0xd170
testb $0x1, %al
jne 0xd01d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4830
testb $0x1, %al
jne 0xd01d
movq -0x18(%rbp), %rax
testb $0x1, 0x64(%rax)
jne 0xd01d
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xd740
jmp 0xd01f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xcfcc
jmp 0xcf82
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/solver/solver.cpp
// Function: Solver::Solver(Grid&, Rule*, Contradiction*, int*, int, int, EPQ)
Solver::Solver(Grid & grid, Rule rules[NUM_RULES], Contradiction contradictions[NUM_CONTRADICTIONS], int selectedRules[], int selectLength, int depth, EPQ oldEPQ) {
    grid_ = &grid;
    depth_ = depth;

    epq_.copyPQ(oldEPQ);

    multipleSolutions_ = false;

    rules_ = rules;
    contradictions_ = contradictions;
    selectedRules_ = selectedRules;
    selectLength_ = selectLength;
    ruleCounts_ = 0;

    solve();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x38, %rdi
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0xfba0
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x10(%rax)
leaq -0x58(%rbp), %rdi
callq 0xfbe0
jmp 0xd0ae
movq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8a00
jmp 0xd0c0
leaq -0x58(%rbp), %rdi
callq 0xfbc0
movq -0x78(%rbp), %rdi
movb $0x0, 0x64(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x30(%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x20(%rdi)
movl -0x2c(%rbp), %eax
movl %eax, 0x28(%rdi)
movl $0x0, (%rdi)
callq 0xcf60
jmp 0xd0fc
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd128
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xfbc0
movq -0x80(%rbp), %rdi
callq 0xfbc0
movq -0x60(%rbp), %rdi
callq 0x22c0
nopw (%rax,%rax)
// File: davidjosepha[P]slitherlink/src/solver/solver.cpp
// Function: Solver::testContradictions() const
bool Solver::testContradictions() const {
    if (grid_->containsClosedContours() && !grid_->isSolved()) {
        return true;
    }
    for (int i = 0; i < grid_->getHeight(); i++) {
        for (int j = 0; j < grid_->getWidth(); j++) {
            if (grid_->getContraMatrix(i,j)) {
                for (int x = 0; x < NUM_CONTRADICTIONS; x++) {
                    for (Orientation orient: (Orientation[]){ UP, DOWN, LEFT, RIGHT, UPFLIP, DOWNFLIP, LEFTFLIP, RIGHTFLIP }) {
                        if (contradictionApplies(i, j, contradictions_[x], orient)) {
                            return true;
                        }
                    }
                }
                grid_->setContraMatrix(i, j, false);
            }
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x8(%rax), %rdi
callq 0x48d0
testb $0x1, %al
jne 0xd193
jmp 0xd1ad
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4830
testb $0x1, %al
jne 0xd1ad
movb $0x1, -0x1(%rbp)
jmp 0xd30a
movl $0x0, -0x14(%rbp)
movq -0x68(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x6c(%rbp)
movq 0x8(%rax), %rdi
callq 0x2ad0
movl %eax, %ecx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jge 0xd306
movl $0x0, -0x18(%rbp)
movq -0x68(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, -0x70(%rbp)
movq 0x8(%rax), %rdi
callq 0x2af0
movl %eax, %ecx
movl -0x70(%rbp), %eax
cmpl %ecx, %eax
jge 0xd2f6
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xfc20
testb $0x1, %al
jne 0xd217
jmp 0xd2e6
movl $0x0, -0x1c(%rbp)
cmpl $0xb, -0x1c(%rbp)
jge 0xd2d1
movq 0x81f5(%rip), %rax      # 0x15424
movq %rax, -0x48(%rbp)
movq 0x81f2(%rip), %rax      # 0x1542c
movq %rax, -0x40(%rbp)
movq 0x81ef(%rip), %rax      # 0x15434
movq %rax, -0x38(%rbp)
movq 0x81ec(%rip), %rax      # 0x1543c
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0xd2c1
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq 0x30(%rdi), %rcx
movslq -0x1c(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rcx
movl -0x5c(%rbp), %r8d
callq 0xd320
testb $0x1, %al
jne 0xd2ab
jmp 0xd2b1
movb $0x1, -0x1(%rbp)
jmp 0xd30a
jmp 0xd2b3
movq -0x50(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x50(%rbp)
jmp 0xd270
jmp 0xd2c3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd21e
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
xorl %ecx, %ecx
callq 0x4930
jmp 0xd2e8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd1db
jmp 0xd2f8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd1b4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)