LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::Generator(int, int, Difficulty)
Generator::Generator(int m, int n, Difficulty difficulty) {
    m_ = m;
    n_ = n;

    numberCount_ = m_*n_;

    buffer_ = 0;

    srand(time(NULL));
    setDifficulty(difficulty);
    createPuzzle();
    displayFinalPuzzle();
    destroyArrays();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x48, %rdi
movq %rdi, -0x40(%rbp)
callq 0xfc90
movq -0x38(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0x30(%rbp)
callq 0xfc90
jmp 0x105f0
movq -0x38(%rbp), %rdi
addq $0xf8, %rdi
movq %rdi, -0x50(%rbp)
callq 0x11d80
movq -0x38(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
movq %rdi, -0x48(%rbp)
callq 0x11d80
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl (%rax), %ecx
movl 0x4(%rax), %edx
imull %edx, %ecx
movl %ecx, 0x18(%rax)
movl $0x0, 0x20(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x2190
movl %eax, %edi
callq 0x21b0
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x106d0
jmp 0x10657
movq -0x38(%rbp), %rdi
callq 0x10740
jmp 0x10662
movq -0x38(%rbp), %rdi
callq 0x107d0
jmp 0x1066d
movq -0x38(%rbp), %rdi
callq 0x10830
jmp 0x10678
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x106b3
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x11da0
movq -0x50(%rbp), %rdi
callq 0x11da0
movq -0x30(%rbp), %rdi
callq 0x2b10
movq -0x40(%rbp), %rdi
callq 0x2b10
movq -0x20(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::setDifficulty(Difficulty)
void Generator::setDifficulty(Difficulty difficulty) {
    setRules(difficulty);
    if (difficulty == EASY) {
        factor_ = .52;
        guessDepth_ = 1;
    } else if (difficulty == HARD) {
        factor_ = .42;
        guessDepth_ = 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0x10910
cmpl $0x0, -0xc(%rbp)
jne 0x1070f
movq -0x18(%rbp), %rax
movsd 0x4f07(%rip), %xmm0     # 0x15608
movsd %xmm0, 0x10(%rax)
movl $0x1, 0x8(%rax)
jmp 0x1072f
cmpl $0x1, -0xc(%rbp)
jne 0x1072d
movq -0x18(%rbp), %rax
movsd 0x4edf(%rip), %xmm0     # 0x15600
movsd %xmm0, 0x10(%rax)
movl $0x1, 0x8(%rax)
jmp 0x1072f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::createPuzzle()
void Generator::createPuzzle() {
    smallestCount_ = numberCount_;
    bufferReachCount_ = 0;
    Import importer = Import(grid_, m_, n_);
    LoopGen loopgen = LoopGen(m_, n_, grid_);

    initArrays();
    setCounts();
    grid_.copy(smallestCountGrid_);
    reduceNumbers();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x18(%rax), %ecx
movl %ecx, 0x1c(%rax)
movl $0x0, 0x24(%rax)
movq %rax, %rsi
addq $0x48, %rsi
movl (%rax), %edx
movl 0x4(%rax), %ecx
leaq -0x18(%rbp), %rdi
callq 0x5160
movq -0x38(%rbp), %rcx
movl (%rcx), %esi
movl 0x4(%rcx), %edx
addq $0x48, %rcx
leaq -0x30(%rbp), %rdi
callq 0x13060
movq -0x38(%rbp), %rdi
callq 0x10a70
movq -0x38(%rbp), %rdi
callq 0x10bf0
movq -0x38(%rbp), %rsi
movq %rsi, %rdi
addq $0x48, %rdi
addq $0xa0, %rsi
callq 0x2ea0
movq -0x38(%rbp), %rdi
callq 0x10c90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::displayFinalPuzzle()
void Generator::displayFinalPuzzle() {
    checkIfSolved();
    displayPuzzle();
    std::cout << std::endl;
    grid_.resetGrid();
    displayPuzzle();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x10d90
movq -0x10(%rbp), %rdi
callq 0x11180
movq 0xb7df(%rip), %rdi      # 0x1bfd8
movq 0xb7c8(%rip), %rsi      # 0x1bfc8
callq 0x21e0
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x2c70
movq -0x10(%rbp), %rdi
callq 0x11180
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::destroyArrays()
void Generator::destroyArrays() {
    for (int i = 0; i < m_; i++) {
        delete [] canEliminate_[i];
        delete [] oldNumbers_[i];
    }
    delete [] canEliminate_;
    delete [] oldNumbers_;
    delete [] selectedRules_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x108af
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1087c
movq -0x20(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x108a2
movq -0x28(%rbp), %rdi
callq 0x2230
jmp 0x108a4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1084b
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x108cd
movq -0x30(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x108eb
movq -0x38(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x10906
movq -0x40(%rbp), %rdi
callq 0x2230
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::setRules(Difficulty)
void Generator::setRules(Difficulty difficulty) {
    if (difficulty == EASY) {
        numberOfRules_ = sizeof((int [])EASY_RULES) / sizeof(int);
        selectedRules_ = new int[numberOfRules_];

        for (int i = 0; i < numberOfRules_; i++) {
            selectedRules_[i] = (int [])EASY_RULES[i];
        }
    } else {
        numberOfRules_ = sizeof((int [])HARD_RULES) / sizeof(int);
        selectedRules_ = new int[numberOfRules_];

        for (int i = 0; i < numberOfRules_; i++) {
            selectedRules_[i] = (int [])HARD_RULES[i];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x109cd
movq -0xa0(%rbp), %rax
movl $0xc, 0x40(%rax)
movslq 0x40(%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, %rcx
movq -0xa0(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x0, -0x10(%rbp)
movq -0xa0(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x40(%rcx), %eax
jge 0x109c8
leaq -0x40(%rbp), %rdi
leaq 0x4ca3(%rip), %rsi      # 0x1563c
movl $0x30, %edx
callq 0x2170
movq -0xa0(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl -0x40(%rbp,%rcx,4), %edx
movq 0x38(%rax), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1097f
jmp 0x10a66
movq -0xa0(%rbp), %rax
movl $0x15, 0x40(%rax)
movslq 0x40(%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, %rcx
movq -0xa0(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x0, -0x44(%rbp)
movq -0xa0(%rbp), %rcx
movl -0x44(%rbp), %eax
cmpl 0x40(%rcx), %eax
jge 0x10a64
leaq -0x98(%rbp), %rdi
leaq 0x4c3a(%rip), %rsi      # 0x1566c
movl $0x54, %edx
callq 0x2170
movq -0xa0(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl -0x98(%rbp,%rcx,4), %edx
movq 0x38(%rax), %rax
movslq -0x44(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x10a15
jmp 0x10a66
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::initArrays()
void Generator::initArrays() {
    canEliminate_ = new bool*[m_];
    oldNumbers_ = new Number*[m_];
    for (int i = 0; i < m_; i++) {
        canEliminate_[i] = new bool[n_];
        oldNumbers_[i] = new Number[n_];

        for (int j = 0; j < n_; j++) {
            canEliminate_[i][j] = true;
            oldNumbers_[i][j] = grid_.getNumber(i+1, j+1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq (%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 -0x18(%rbp), %rax
movq %rcx, 0x138(%rax)
movslq (%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 -0x18(%rbp), %rax
movq %rcx, 0x140(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x10be5
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rdi
movq $-0x1, %rax
cmpq $0x0, %rdi
cmovlq %rax, %rdi
callq 0x2030
movq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movslq 0x4(%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, %rdx
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x10bd5
movq -0x18(%rbp), %rdi
movq 0x138(%rdi), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movb $0x1, (%rax,%rcx)
addq $0x48, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
addl $0x1, %edx
callq 0x5b50
movl %eax, %edx
movq -0x18(%rbp), %rax
movq 0x140(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10b72
jmp 0x10bd7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10aef
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::setCounts()
void Generator::setCounts() {
    zeroCount_ = 0;
    oneCount_ = 0;
    twoCount_ = 0;
    threeCount_ = 0;
    for (int i = 1; i <= m_; i++) {
        for (int j = 1; j <= n_; j++) {
            Number oldNum = grid_.getNumber(i, j);
            plusCounts(oldNum);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, 0x28(%rax)
movl $0x0, 0x2c(%rax)
movl $0x0, 0x30(%rax)
movl $0x0, 0x34(%rax)
movl $0x1, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jg 0x10c7f
movl $0x1, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jg 0x10c72
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x5b50
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x111b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10c39
jmp 0x10c74
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10c27
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::reduceNumbers()
void Generator::reduceNumbers() {

    // Remove numbers until this count has been reached
    while (numberCount_ > ((m_*n_)*factor_ + 3)) {

        /* Reset the smallest count and buffer incase the required amount
        of numbers cannot be removed. */
        if (smallestCount_ > numberCount_) {
            smallestCount_ = numberCount_;
            grid_.clearAndCopy(smallestCountGrid_);
            buffer_ = (numberCount_ + (m_*n_))/2 - 2;
        }

        if (numberCount_ == buffer_) {
            bufferReachCount_ ++;
        }

        /* If the count has past the buffer three times,
         * return the grid with the smallest count of
         * of numbers that is currently known. */
        if (bufferReachCount_ == 3) {
            smallestCountGrid_.clearAndCopy(grid_);
            break;
        }

        findNumberToRemove();
        eligibleCoordinates_.clear();

        grid_.resetGrid();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cvtsi2sdl 0x18(%rax), %xmm0
movl (%rax), %ecx
imull 0x4(%rax), %ecx
cvtsi2sd %ecx, %xmm1
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm1
movsd 0x4948(%rip), %xmm2     # 0x15610
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x10d89
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %eax
cmpl 0x18(%rcx), %eax
jle 0x10d22
movq -0x10(%rbp), %rsi
movl 0x18(%rsi), %eax
movl %eax, 0x1c(%rsi)
movq %rsi, %rdi
addq $0x48, %rdi
addq $0xa0, %rsi
callq 0x3580
movq -0x10(%rbp), %rdx
movl 0x18(%rdx), %eax
movl (%rdx), %ecx
imull 0x4(%rdx), %ecx
addl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x10(%rbp), %rax
subl $0x2, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0x20(%rcx), %eax
jne 0x10d3b
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x24(%rax)
jne 0x10d5e
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0xa0, %rdi
addq $0x48, %rsi
callq 0x3580
jmp 0x10d89
movq -0x10(%rbp), %rdi
callq 0x11290
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
callq 0x11e00
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x2c70
jmp 0x10ca4
addq $0x10, %rsp
popq %rbp
retq
nop
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::plusCounts(Number)
void Generator::plusCounts(Number num) {
    if (num == ZERO) {
        zeroCount_ ++;
    }else if (num == ONE) {
        oneCount_ ++;
    } else if (num == TWO) {
        twoCount_ ++;
    } else if (num == THREE) {
        threeCount_ ++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x111d8
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x1121b
cmpl $0x2, -0xc(%rbp)
jne 0x111ed
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0x11219
cmpl $0x3, -0xc(%rbp)
jne 0x11202
movq -0x18(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
jmp 0x11217
cmpl $0x4, -0xc(%rbp)
jne 0x11215
movq -0x18(%rbp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
jmp 0x11217
jmp 0x11219
jmp 0x1121b
popq %rbp
retq
nopl (%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::fillEligibleVector()
void Generator::fillEligibleVector() {
    for (int i = 1; i < m_+1; i++) {
        for (int j = 1; j < n_+1; j++) {
            if (eligible(i, j)) {
                Coordinates coords = { i, j };
                eligibleCoordinates_.push_back(coords);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x114e2
movl $0x1, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
movl 0x4(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x114d5
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x11830
testb $0x1, %al
jne 0x114a8
jmp 0x114c8
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
addq $0xf8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x11fe0
jmp 0x114ca
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11482
jmp 0x114d7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1146b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::isBalanced(int, int) const
bool Generator::isBalanced(int i, int j) const {
    float moa = 1.1;
    Number num = grid_.getNumber(i, j);
    if (num == THREE) {
        return (threeCount_*2*moa >= 3*oneCount_ & threeCount_*5*moa >= 3*twoCount_);
    } else if (num == TWO) {
        return (twoCount_*2.1+1 >= 5*oneCount_ & twoCount_*3*moa >= 5*threeCount_);
    } else if (num == ONE) {
        return (oneCount_*3*moa >= 2*threeCount_ & oneCount_*5*moa >= 2*twoCount_);
    } else {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movss 0x4126(%rip), %xmm0     # 0x15638
movss %xmm0, -0x1c(%rbp)
addq $0x48, %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x5b50
movl %eax, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jne 0x11587
movq -0x28(%rbp), %rcx
movl 0x34(%rcx), %eax
shll %eax
cvtsi2ss %eax, %xmm0
mulss -0x1c(%rbp), %xmm0
imull $0x3, 0x2c(%rcx), %eax
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
setae %al
andb $0x1, %al
movzbl %al, %eax
imull $0x5, 0x34(%rcx), %edx
cvtsi2ss %edx, %xmm0
mulss -0x1c(%rbp), %xmm0
imull $0x3, 0x30(%rcx), %ecx
cvtsi2ss %ecx, %xmm1
ucomiss %xmm1, %xmm0
setae %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11652
cmpl $0x3, -0x20(%rbp)
jne 0x115f2
movq -0x28(%rbp), %rcx
cvtsi2sdl 0x30(%rcx), %xmm0
movsd 0x407a(%rip), %xmm1     # 0x15618
mulsd %xmm1, %xmm0
movsd 0x3e6e(%rip), %xmm1     # 0x15418
addsd %xmm1, %xmm0
imull $0x5, 0x2c(%rcx), %eax
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movzbl %al, %eax
imull $0x3, 0x30(%rcx), %edx
cvtsi2ss %edx, %xmm0
mulss -0x1c(%rbp), %xmm0
imull $0x5, 0x34(%rcx), %ecx
cvtsi2ss %ecx, %xmm1
ucomiss %xmm1, %xmm0
setae %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11652
cmpl $0x2, -0x20(%rbp)
jne 0x1164e
movq -0x28(%rbp), %rcx
imull $0x3, 0x2c(%rcx), %eax
cvtsi2ss %eax, %xmm0
mulss -0x1c(%rbp), %xmm0
movl 0x34(%rcx), %eax
shll %eax
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
setae %al
andb $0x1, %al
movzbl %al, %eax
imull $0x5, 0x2c(%rcx), %edx
cvtsi2ss %edx, %xmm0
mulss -0x1c(%rbp), %xmm0
movl 0x30(%rcx), %ecx
shll %ecx
cvtsi2ss %ecx, %xmm1
ucomiss %xmm1, %xmm0
setae %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11652
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::removeNumber(int, int)
void Generator::removeNumber(int i, int j) {
    grid_.setNumber(i, j, NONE);
    grid_.resetGrid();
    Coordinates removed{ i, j };
    ineligibleCoordinates_.push_back(removed);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x48, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
xorl %ecx, %ecx
callq 0x5d90
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
callq 0x2c70
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
addq $0x110, %rdi            # imm = 0x110
leaq -0x18(%rbp), %rsi
callq 0x11fe0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::getNecessaryCoordinate()
void Generator::getNecessaryCoordinate() {
    bool found = false;

    while (!found) {
        Coordinates popped = ineligibleCoordinates_.back();
        if (grid_.getNumber(popped.i, popped.j) == NONE) {
            markNecessary(popped.i, popped.j);
            setOldNumber(popped.i, popped.j);
            ineligibleCoordinates_.push_back(popped);
            plusCounts(grid_.getNumber(popped.i, popped.j));
            found = true;
        } else {
            ineligibleCoordinates_.pop_back();
            markEligible(popped.i, popped.j);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x9(%rbp)
movb -0x9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11776
jmp 0x1181f
movq -0x20(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0x120f0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x14(%rbp)
addq $0x48, %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x5b50
cmpl $0x0, %eax
jne 0x117fb
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x11710
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x116c0
movq -0x20(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
leaq -0x14(%rbp), %rsi
callq 0x11fe0
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x5b50
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x111b0
movb $0x1, -0x9(%rbp)
jmp 0x1181a
movq -0x20(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0x12130
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x118a0
jmp 0x11768
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::eligible(int, int) const
bool Generator::eligible(int i, int j) const {
    if (canEliminate_[i-1][j-1] && (grid_.getNumber(i, j) != NONE)) {
        return true;
    } else {
        return false;
    }
}

// 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, -0x20(%rbp)
movq 0x138(%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
testb $0x1, (%rax,%rcx)
je 0x1188b
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x5b50
cmpl $0x0, %eax
je 0x1188b
movb $0x1, -0x1(%rbp)
jmp 0x1188f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::isBalanced(int, int, Number) const
bool Generator::isBalanced(int i, int j, Number num) const {
    if (eligible(i, j)) {
        if (num == ZERO) {
            return true;
        } if (num == THREE) {
            return (threeCount_*2.1+1 > 3*oneCount_ & threeCount_*5.2+1 > 3*twoCount_);
        } if (num == ONE) {
            return (oneCount_*3.2+1 > 2*threeCount_ & oneCount_*5.2+1 > 2*twoCount_);
        } if (num == TWO) {
            return (twoCount_*2.1+1 > 5*oneCount_ & twoCount_*3.1+1 > 5*threeCount_);
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x11830
testb $0x1, %al
jne 0x11be1
jmp 0x11d6e
cmpl $0x1, -0x1c(%rbp)
jne 0x11bf0
movb $0x1, -0x1(%rbp)
jmp 0x11d72
cmpl $0x4, -0x1c(%rbp)
jne 0x11c6f
movq -0x28(%rbp), %rcx
cvtsi2sdl 0x34(%rcx), %xmm0
movsd 0x3a11(%rip), %xmm1     # 0x15618
mulsd %xmm1, %xmm0
movsd 0x3805(%rip), %xmm1     # 0x15418
addsd %xmm1, %xmm0
imull $0x3, 0x2c(%rcx), %eax
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sdl 0x34(%rcx), %xmm0
movsd 0x39f0(%rip), %xmm1     # 0x15628
mulsd %xmm1, %xmm0
movsd 0x37d4(%rip), %xmm1     # 0x15418
addsd %xmm1, %xmm0
imull $0x3, 0x30(%rcx), %ecx
cvtsi2sd %ecx, %xmm1
ucomisd %xmm1, %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11d72
cmpl $0x2, -0x1c(%rbp)
jne 0x11cf0
movq -0x28(%rbp), %rcx
cvtsi2sdl 0x2c(%rcx), %xmm0
movsd 0x39aa(%rip), %xmm1     # 0x15630
mulsd %xmm1, %xmm0
movsd 0x3786(%rip), %xmm1     # 0x15418
addsd %xmm1, %xmm0
movl 0x34(%rcx), %eax
shll %eax
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sdl 0x2c(%rcx), %xmm0
movsd 0x3970(%rip), %xmm1     # 0x15628
mulsd %xmm1, %xmm0
movsd 0x3754(%rip), %xmm1     # 0x15418
addsd %xmm1, %xmm0
movl 0x30(%rcx), %ecx
shll %ecx
cvtsi2sd %ecx, %xmm1
ucomisd %xmm1, %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11d72
cmpl $0x3, -0x1c(%rbp)
jne 0x11d6c
movq -0x28(%rbp), %rcx
cvtsi2sdl 0x30(%rcx), %xmm0
movsd 0x3911(%rip), %xmm1     # 0x15618
mulsd %xmm1, %xmm0
movsd 0x3705(%rip), %xmm1     # 0x15418
addsd %xmm1, %xmm0
imull $0x5, 0x2c(%rcx), %eax
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sdl 0x30(%rcx), %xmm0
movsd 0x38e8(%rip), %xmm1     # 0x15620
mulsd %xmm1, %xmm0
movsd 0x36d4(%rip), %xmm1     # 0x15418
addsd %xmm1, %xmm0
imull $0x5, 0x34(%rcx), %ecx
cvtsi2sd %ecx, %xmm1
ucomisd %xmm1, %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11d72
jmp 0x11d6e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: davidjosepha[P]slitherlink/src/generator/loopgen.cpp
// Function: LoopGen::LoopGen(int, int, Grid&)
LoopGen::LoopGen(int m, int n, Grid & grid) {
    m_ = m;
    n_ = n;
    grid_ = &grid;
    srand(time(NULL));

    initArray();
    genLoop();
    fillGrid();
    destroyArray();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x2190
movl %eax, %edi
callq 0x21b0
movq -0x20(%rbp), %rdi
callq 0x130d0
movq -0x20(%rbp), %rdi
callq 0x131c0
movq -0x20(%rbp), %rdi
callq 0x13340
movq -0x20(%rbp), %rdi
callq 0x13450
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: davidjosepha[P]slitherlink/src/generator/loopgen.cpp
// Function: LoopGen::initArray()
void LoopGen::initArray() {
    loop_ = new LoopCell*[m_];
    for (int i = 0; i < m_; i++) {
        loop_[i] = new LoopCell[n_];

        for (int j = 0; j < n_; j++) {
            loop_[i][j] = UNKNOWN;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq 0x10(%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 -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x131ad
movq -0x18(%rbp), %rax
movslq 0x14(%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, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x1319d
movq -0x18(%rbp), %rax
movq (%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 0x1316c
jmp 0x1319f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1311a
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/loopgen.cpp
// Function: LoopGen::genLoop()
void LoopGen::genLoop() {
    Coordinates cur = { m_ / 2, n_ / 2 };
    Coordinates next;
    std::vector<Coordinates> avail;
    avail.push_back(cur);

    while (avail.size() > 0) {
        cur = pickCell(avail);

        if (cur.i == -1 || cur.j == -1) {
            return;
        }

        next = addCell(cur);

        if (loop_[cur.i][cur.j] == EXP) {
            addAvailable(cur, avail);
        }
        if (loop_[next.i][next.j] == EXP) {
            addAvailable(next, avail);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %edx, %ecx
sarl %ecx
movl %ecx, -0x10(%rbp)
movl 0x14(%rax), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %ecx, %eax
sarl %eax
movl %eax, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x11d80
movq -0x70(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x11fe0
jmp 0x13211
jmp 0x13213
leaq -0x30(%rbp), %rdi
callq 0x11e60
cmpq $0x0, %rax
jbe 0x1331d
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13820
movq %rax, -0x80(%rbp)
jmp 0x13239
movq -0x80(%rbp), %rax
movq %rax, -0x44(%rbp)
movq -0x44(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
je 0x13255
cmpl $-0x1, -0xc(%rbp)
jne 0x1327b
movl $0x1, -0x48(%rbp)
jmp 0x13324
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x11da0
jmp 0x13336
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
callq 0x13900
movq %rax, -0x88(%rbp)
jmp 0x13299
movq -0x78(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x132e2
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x13ab0
jmp 0x132e0
jmp 0x132e2
movq -0x78(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x13318
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x13ab0
jmp 0x13316
jmp 0x13318
jmp 0x13213
movl $0x0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x11da0
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22c0
nop
// File: davidjosepha[P]slitherlink/src/generator/loopgen.cpp
// Function: LoopGen::fillGrid()
void LoopGen::fillGrid() {
    int lines;
    for (int i = 1; i < m_ + 1; i++) {
        for (int j = 1; j < n_ + 1; j++) {
            lines = countLines(i - 1, j - 1);

            switch (lines) {
                case 0:
                    grid_->setNumber(i, j, ZERO);
                    break;
                case 1:
                    grid_->setNumber(i, j, ONE);
                    break;
                case 2:
                    grid_->setNumber(i, j, TWO);
                    break;
                case 3:
                    grid_->setNumber(i, j, THREE);
                    break;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
movl 0x10(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x13449
movl $0x1, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movl 0x14(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x13439
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
decl %esi
movl -0x14(%rbp), %edx
decl %edx
callq 0x134d0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x3, %rax
ja 0x13429
movq -0x28(%rbp), %rax
leaq 0x2352(%rip), %rcx      # 0x1570c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl $0x1, %ecx
callq 0x5d90
jmp 0x13429
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl $0x2, %ecx
callq 0x5d90
jmp 0x13429
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl $0x3, %ecx
callq 0x5d90
jmp 0x13429
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl $0x4, %ecx
callq 0x5d90
jmp 0x1342b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13377
jmp 0x1343b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1335b
addq $0x30, %rsp
popq %rbp
retq
nop
// File: davidjosepha[P]slitherlink/src/generator/loopgen.cpp
// Function: LoopGen::pickCell(std::vector<Coordinates, std::allocator<Coordinates>>&) const
Coordinates LoopGen::pickCell(std::vector<Coordinates> & avail) const {
    Coordinates guess;

    if (avail.size() > 0) {
        guess = avail.back();
        int guessindex = rand() % avail.size();
        guess = avail[guessindex];

        avail.erase(avail.begin() + guessindex);
        return guess;
    } else {
        return { -1, -1 };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11e60
cmpq $0x0, %rax
jbe 0x138da
movq -0x18(%rbp), %rdi
callq 0x120f0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x2070
cltq
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11e60
movq %rax, %rcx
movq -0x58(%rbp), %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x12570
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11f30
movq %rax, -0x40(%rbp)
movslq -0x24(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x11f60
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11fa0
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11ec0
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x138e8
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/loopgen.cpp
// Function: LoopGen::addAvailable(Coordinates, std::vector<Coordinates, std::allocator<Coordinates>>&) const
void LoopGen::addAvailable(Coordinates coords, std::vector<Coordinates> & avail) const {
    for (int i = 0; i < avail.size(); i++) {
        if (avail[i].i == coords.i && avail[i].j == coords.j) {
            return;
        }
    }

    avail.push_back(coords);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11e60
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x13b20
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x12570
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x13b13
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x12570
movl 0x4(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x13b13
jmp 0x13b2d
jmp 0x13b15
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13acb
movq -0x18(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x11fe0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/loopgen.cpp
// Function: LoopGen::isExpandable(Coordinates) const
bool LoopGen::isExpandable(Coordinates cur) const {
    assert(cur.i >= 0 && cur.i < m_ && cur.j >= 0 && cur.j < n_);

    AdjacencyList adjacencyList = getAdjacent(cur);

    if (!adjacencyList.u && !adjacencyList.d && !adjacencyList.l && !adjacencyList.r) {
        loop_[cur.i][cur.j] = NOEXP;
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x25(%rbp)
jl 0x13b8f
movq -0x30(%rbp), %rdx
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl 0x10(%rdx), %ecx
movb %al, -0x25(%rbp)
jge 0x13b8f
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x25(%rbp)
jl 0x13b8f
movq -0x30(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x14(%rcx), %eax
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x13b98
jmp 0x13b9a
jmp 0x13bb9
leaq 0x1b7b(%rip), %rdi      # 0x1571c
leaq 0x1ba9(%rip), %rsi      # 0x15751
movl $0x97, %edx
leaq 0x1be1(%rip), %rcx      # 0x15795
callq 0x2120
movq -0x30(%rbp), %rdi
movq -0xc(%rbp), %rax
movq %rax, -0x24(%rbp)
movq -0x24(%rbp), %rsi
callq 0x13c90
movl %eax, -0x1c(%rbp)
testb $0x1, -0x1c(%rbp)
jne 0x13c09
testb $0x1, -0x1b(%rbp)
jne 0x13c09
testb $0x1, -0x1a(%rbp)
jne 0x13c09
testb $0x1, -0x19(%rbp)
jne 0x13c09
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movl $0x2, (%rax,%rcx,4)
movb $0x0, -0x1(%rbp)
jmp 0x13c0d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/loopgen.cpp
// Function: LoopGen::pickDirection(Coordinates) const
Coordinates LoopGen::pickDirection(Coordinates cur) const {
    int vert = (rand() % 3) - 1;
    int hor = 0;
    if (vert == 0) {
        hor = (rand() % 2)*2 - 1;
    }
    return { cur.i + vert, cur.j + hor };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x2070
movl $0x3, %ecx
cltd
idivl %ecx
subl $0x1, %edx
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x13c67
callq 0x2070
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, %eax
shll %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidjosepha[P]slitherlink/src/generator/loopgen.cpp
// Function: LoopGen::getAdjacent(Coordinates) const
AdjacencyList LoopGen::getAdjacent(Coordinates cur) const {
    AdjacencyList adjacencyList = { .u = validCell({ cur.i - 1, cur.j }, cur),
                                    .d = validCell({ cur.i + 1, cur.j }, cur),
                                    .l = validCell({ cur.i, cur.j - 1 }, cur),
                                    .r = validCell({ cur.i, cur.j + 1 }, cur) };
    return adjacencyList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x13d70
movq -0x60(%rbp), %rdi
andb $0x1, %al
movb %al, -0x4(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x13d70
movq -0x60(%rbp), %rdi
andb $0x1, %al
movb %al, -0x3(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x13d70
movq -0x60(%rbp), %rdi
andb $0x1, %al
movb %al, -0x2(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x13d70
andb $0x1, %al
movb %al, -0x1(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: void unit_test_framework::Assertions::assert_equal<int, int>(int&&, int&&, int, char const*)
static void assert_equal(First&& first, Second&& second,
                             int line_number,
                             const char* assertion_text) {
      if (safe_equals<First, Second>::equals(first, second)) {
        return;
      }
      std::ostringstream reason;
      Diagnostic::print(reason, first);
      reason << " != ";
      Diagnostic::print(reason, second);
      throw TestFailure(reason.str(), line_number, assertion_text);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4f10
testb $0x1, %al
jne 0x4dcd
jmp 0x4dd6
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x3310
movq -0x1d8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4f40
jmp 0x4dfb
leaq 0x423b(%rip), %rsi      # 0x903d
leaq -0x198(%rbp), %rdi
callq 0x3220
jmp 0x4e10
movq -0x10(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x4f40
jmp 0x4e22
movb $0x1, -0x1c9(%rbp)
movl $0x30, %edi
callq 0x3110
movq %rax, -0x1e0(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3250
jmp 0x4e4f
movq -0x1e0(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
leaq -0x1c8(%rbp), %rsi
callq 0x4f70
jmp 0x4e6b
movq -0x1e0(%rbp), %rdi
movb $0x0, -0x1c9(%rbp)
leaq 0x8ec0(%rip), %rsi      # 0xdd40
leaq 0x129(%rip), %rdx       # 0x4fb0
callq 0x33b0
jmp 0x4f05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x4eed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x4ed4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x3160
testb $0x1, -0x1c9(%rbp)
jne 0x4edf
jmp 0x4eeb
movq -0x1e0(%rbp), %rdi
callq 0x31b0
jmp 0x4eed
leaq -0x198(%rbp), %rdi
callq 0x3080
movq -0x1a0(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
nop
// File: eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: unit_test_framework::TestSuite::TestSuite()
TestSuite() {
      auto func = []() {
        if (TestSuite::incomplete) {
          std::cout << "ERROR: premature call to exit()" << std::endl;
          std::abort();
        }
      };
      std::atexit(func);
#ifdef _GLIBCXX_HAVE_AT_QUICK_EXIT
      std::at_quick_exit(func);
#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x5070
movq -0x18(%rbp), %rax
movb $0x0, 0x30(%rax)
leaq -0x9(%rbp), %rdi
callq 0x5090
movq %rax, %rdi
callq 0x8690
leaq -0x9(%rbp), %rdi
callq 0x5090
movq %rax, %rdi
callq 0x86b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: unit_test_framework::TestCase::print(bool)
void print(bool quiet_mode) {
      if (quiet_mode) {
        std::cout << name << ": ";
      }
      else {
        std::cout << "** Test case \"" << name << "\": ";
      }

      if (not failure_msg.empty()) {
        std::cout << "FAIL" << std::endl;
        if (not quiet_mode) {
          std::cout << failure_msg << std::endl;
        }
      }
      else if (not exception_msg.empty()) {
        std::cout << "ERROR" << std::endl;
        if (not quiet_mode) {
          std::cout << exception_msg << std::endl;
        }
      }
      else {
        std::cout << "PASS" << std::endl;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x63a3
movq -0x18(%rbp), %rsi
movq 0x7c3b(%rip), %rdi      # 0xdfc8
callq 0x3210
movq %rax, %rdi
leaq 0x2f59(%rip), %rsi      # 0x92f5
callq 0x3220
jmp 0x63d1
movq 0x7c1e(%rip), %rdi      # 0xdfc8
leaq 0x2f34(%rip), %rsi      # 0x92e5
callq 0x3220
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x3210
movq %rax, %rdi
leaq 0x2f28(%rip), %rsi      # 0x92f4
callq 0x3220
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x33a0
testb $0x1, %al
jne 0x6432
movq 0x7bdf(%rip), %rdi      # 0xdfc8
leaq 0x2ee4(%rip), %rsi      # 0x92d4
callq 0x3220
movq %rax, %rdi
movq 0x7ba9(%rip), %rsi      # 0xdfa8
callq 0x3270
testb $0x1, -0x9(%rbp)
jne 0x642d
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
movq 0x7baf(%rip), %rdi      # 0xdfc8
callq 0x3210
movq %rax, %rdi
movq 0x7b80(%rip), %rsi      # 0xdfa8
callq 0x3270
jmp 0x64b4
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0x33a0
testb $0x1, %al
jne 0x6490
movq 0x7b7e(%rip), %rdi      # 0xdfc8
leaq 0x2e7d(%rip), %rsi      # 0x92ce
callq 0x3220
movq %rax, %rdi
movq 0x7b48(%rip), %rsi      # 0xdfa8
callq 0x3270
testb $0x1, -0x9(%rbp)
jne 0x648e
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
movq 0x7b4e(%rip), %rdi      # 0xdfc8
callq 0x3210
movq %rax, %rdi
movq 0x7b1f(%rip), %rsi      # 0xdfa8
callq 0x3270
jmp 0x64b2
movq 0x7b31(%rip), %rdi      # 0xdfc8
leaq 0x2e11(%rip), %rsi      # 0x92af
callq 0x3220
movq %rax, %rdi
movq 0x7afb(%rip), %rsi      # 0xdfa8
callq 0x3270
jmp 0x64b4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: unit_test_framework::Diagnostic::demangle[abi:cxx11](char const*)
static std::string demangle(const char* typeinfo_name) {
#if defined(__clang__) || defined(__GLIBCXX__) || defined(__GLIBCPP__)
      int status = 0;
      char* demangled =
        abi::__cxa_demangle(typeinfo_name, nullptr, nullptr, &status);
      if (status == 0) {
        std::string result = demangled;
        std::free(demangled);
        return result;
      }
      else {
        return typeinfo_name;
      }
#else
      return typeinfo_name;
#endif  // defined(__clang__) || defined(__GLIBCXX__) || defined(__GLIBCPP__)
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x14(%rbp), %rcx
movq %rdx, %rsi
callq 0x31f0
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x7ddc
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x22(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x33f0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x38c0
jmp 0x7d9c
leaq -0x22(%rbp), %rdi
callq 0x3290
movq -0x20(%rbp), %rdi
callq 0x32d0
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x7dda
jmp 0x7dd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x22(%rbp), %rdi
callq 0x3290
jmp 0x7e30
movq -0x48(%rbp), %rdi
callq 0x3160
jmp 0x7e26
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x35(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x33f0
movq -0x48(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x38c0
jmp 0x7e04
leaq -0x35(%rbp), %rdi
callq 0x3290
jmp 0x7e26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x35(%rbp), %rdi
callq 0x3290
jmp 0x7e30
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x33e0
nopl (%rax)