LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
cmpl $0x0, (%rdi)
jle 0xcf40
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movl $0x1, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0xcf2c
xorl %r12d, %r12d
incl %r12d
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x42d4
movq %rbx, %rdi
movl %eax, %esi
callq 0xd28a
cmpl 0x4(%rbx), %r12d
jl 0xcf0b
leal 0x1(%r15), %eax
cmpl (%rbx), %r15d
movl %eax, %r15d
jl 0xcf02
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x4(%rdi), %ecx
movl 0x18(%rdi), %eax
cvtsi2sd %eax, %xmm0
imull (%rdi), %ecx
cvtsi2sd %ecx, %xmm1
mulsd 0x10(%rdi), %xmm1
addsd 0x2696(%rip), %xmm1     # 0xf600
ucomisd %xmm1, %xmm0
jbe 0xd013
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
leaq 0xa0(%rdi), %r15
cmpl %eax, 0x1c(%rbx)
jle 0xcfad
movl %eax, 0x1c(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2f9e
movl 0x4(%rbx), %eax
imull (%rbx), %eax
addl 0x18(%rbx), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl $-0x2, %ecx
movl %ecx, 0x20(%rbx)
movl 0x18(%rbx), %eax
cmpl 0x20(%rbx), %eax
jne 0xcfb8
incl 0x24(%rbx)
cmpl $0x3, 0x24(%rbx)
je 0xd01e
movq %rbx, %rdi
callq 0xd2ea
movq 0xf8(%rbx), %rax
cmpq %rax, 0x100(%rbx)
je 0xcfdd
movq %rax, 0x100(%rbx)
movq %r14, %rdi
callq 0x2b0e
movl 0x4(%rbx), %ecx
movl 0x18(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
imull (%rbx), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd 0x10(%rbx), %xmm1
addsd 0x25f7(%rip), %xmm1     # 0xf600
ucomisd %xmm1, %xmm0
ja 0xcf82
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2f9e
nop
// File: /workspace/github_cpp_makefile_star2_O1/davidjosepha[P]slitherlink/src/generator/generator.cpp
// Function: Generator::checkIfSolved()
bool Generator::checkIfSolved() {
    Rule rules_[NUM_RULES];
    initRules(rules_);
    Contradiction contradictions_[NUM_CONTRADICTIONS];
    initContradictions(contradictions_);
    grid_.resetGrid();

    Solver solver = Solver(grid_, rules_, contradictions_, selectedRules_, numberOfRules_, guessDepth_);
    if (grid_.isSolved()) {
        return true;
    } else {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1470, %rsp           # imm = 0x1470
movq %rdi, %rbx
movl $0x8, %eax
xorps %xmm0, %xmm0
movups %xmm0, -0x1410(%rbp,%rax)
movups %xmm0, -0x1420(%rbp,%rax)
movups %xmm0, -0x1430(%rbp,%rax)
movups %xmm0, -0x1440(%rbp,%rax)
movups %xmm0, -0x1450(%rbp,%rax)
movups %xmm0, -0x1460(%rbp,%rax)
movups %xmm0, -0x1470(%rbp,%rax)
movq $0x0, -0x1400(%rbp,%rax)
subq $-0x80, %rax
cmpq $0x1088, %rax           # imm = 0x1088
jne 0xd04d
leaq -0x1470(%rbp), %rdi
callq 0x62bc
movl $0x8, %eax
xorps %xmm0, %xmm0
movups %xmm0, -0x3c0(%rbp,%rax)
movups %xmm0, -0x3d0(%rbp,%rax)
movups %xmm0, -0x3e0(%rbp,%rax)
movups %xmm0, -0x3f0(%rbp,%rax)
movq $0x0, -0x3b0(%rbp,%rax)
addq $0x50, %rax
cmpq $0x378, %rax            # imm = 0x378
jne 0xd0b1
leaq -0x3f0(%rbp), %rdi
callq 0x4500
leaq 0x48(%rbx), %r14
movq %r14, %rdi
callq 0x2b0e
movq 0x38(%rbx), %r8
movl 0x40(%rbx), %r9d
movl 0x8(%rbx), %eax
movl %eax, (%rsp)
leaq -0x78(%rbp), %rdi
leaq -0x1470(%rbp), %rdx
leaq -0x3f0(%rbp), %rcx
movq %r14, %rsi
callq 0xaa7c
movq %r14, %rdi
callq 0x376a
movl %eax, %ebx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xd141
callq 0x2180
movl $0x328, %r14d           # imm = 0x328
movq -0x3c0(%rbp,%r14), %rdi
testq %rdi, %rdi
je 0xd159
callq 0x2180
movq -0x3d8(%rbp,%r14), %rdi
testq %rdi, %rdi
je 0xd16b
callq 0x2180
movq -0x3f0(%rbp,%r14), %rdi
testq %rdi, %rdi
je 0xd17d
callq 0x2180
addq $-0x50, %r14
cmpq $-0x48, %r14
jne 0xd147
movl $0x1008, %r14d          # imm = 0x1008
movq -0x1410(%rbp,%r14), %rdi
testq %rdi, %rdi
je 0xd19f
callq 0x2180
movq -0x1428(%rbp,%r14), %rdi
testq %rdi, %rdi
je 0xd1b1
callq 0x2180
movq -0x1440(%rbp,%r14), %rdi
testq %rdi, %rdi
je 0xd1c3
callq 0x2180
movq -0x1458(%rbp,%r14), %rdi
testq %rdi, %rdi
je 0xd1d5
callq 0x2180
movq -0x1470(%rbp,%r14), %rdi
testq %rdi, %rdi
je 0xd1e7
callq 0x2180
addq $-0x80, %r14
cmpq $-0x78, %r14
jne 0xd18d
movl %ebx, %eax
addq $0x1470, %rsp           # imm = 0x1470
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xd21c
callq 0x2180
jmp 0xd21c
jmp 0xd219
movq %rax, %rbx
jmp 0xd23c
movq %rax, %rbx
movl $0x320, %r14d           # imm = 0x320
leaq (%r14,%rbp), %rdi
addq $-0x3f0, %rdi           # imm = 0xFC10
callq 0xdc28
addq $-0x50, %r14
cmpq $-0x50, %r14
jne 0xd222
movl $0x1000, %r14d          # imm = 0x1000
leaq (%r14,%rbp), %rdi
addq $-0x1470, %rdi          # imm = 0xEB90
callq 0xdbd0
addq $-0x80, %r14
cmpq $-0x80, %r14
jne 0xd242
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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
decl %esi
cmpl $0x3, %esi
ja 0xd2b7
leaq 0x238c(%rip), %rax      # 0xf628
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
incl 0x28(%rdi)
jmp 0xd2b7
incl 0x30(%rdi)
jmp 0xd2b7
incl 0x34(%rdi)
jmp 0xd2b7
incl 0x2c(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, (%rdi)
jle 0xd558
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
leaq 0xf8(%rdi), %r15
movl $0x1, %r12d
cmpl $0x0, 0x4(%rbx)
jle 0xd536
xorl %r13d, %r13d
movq 0x138(%rbx), %rax
movq -0x8(%rax,%r12,8), %rax
cmpb $0x1, (%rax,%r13)
jne 0xd52a
leal 0x1(%r13), %edx
movq %r14, %rdi
movl %r12d, %esi
callq 0x42d4
testl %eax, %eax
je 0xd52a
movl %r12d, -0x30(%rbp)
leal 0x1(%r13), %eax
movl %eax, -0x2c(%rbp)
movq 0x100(%rbx), %rsi
cmpq 0x108(%rbx), %rsi
je 0xd51e
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x100(%rbx)
jmp 0xd52a
movq %r15, %rdi
leaq -0x30(%rbp), %rdx
callq 0xdc64
movslq 0x4(%rbx), %rax
incq %r13
cmpq %rax, %r13
jl 0xd4cc
leaq 0x1(%r12), %rax
movslq (%rbx), %rcx
cmpq %rcx, %r12
movq %rax, %r12
jl 0xd4c3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x48, %rdi
callq 0x42d4
cmpl $0x2, %eax
je 0xd611
cmpl $0x3, %eax
je 0xd5c0
cmpl $0x4, %eax
jne 0xd658
movl 0x34(%rbx), %eax
leal (%rax,%rax), %ecx
cvtsi2ss %ecx, %xmm0
movss 0x2147(%rip), %xmm1     # 0xf6dc
mulss %xmm1, %xmm0
movl 0x2c(%rbx), %ecx
movl 0x30(%rbx), %edx
leal (%rcx,%rcx,2), %ecx
cvtsi2ss %ecx, %xmm2
cmpleps %xmm0, %xmm2
leal (%rax,%rax,4), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
leal (%rdx,%rdx,2), %eax
cvtsi2ss %eax, %xmm3
jmp 0xd647
movl 0x30(%rbx), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x2039(%rip), %xmm0     # 0xf608
movl 0x2c(%rbx), %ecx
addsd 0x1e4e(%rip), %xmm0     # 0xf428
leal (%rcx,%rcx,4), %ecx
cvtsi2sd %ecx, %xmm1
ucomisd %xmm1, %xmm0
leal (%rax,%rax,2), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
setae %cl
mulss 0x20e2(%rip), %xmm0     # 0xf6dc
movl 0x34(%rbx), %eax
leal (%rax,%rax,4), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
setae %al
andb %cl, %al
jmp 0xd65a
movl 0x2c(%rbx), %eax
movl 0x30(%rbx), %ecx
leal (%rax,%rax,2), %edx
cvtsi2ss %edx, %xmm0
movss 0x20b6(%rip), %xmm1     # 0xf6dc
mulss %xmm1, %xmm0
movl 0x34(%rbx), %edx
addl %edx, %edx
cvtsi2ss %edx, %xmm2
cmpleps %xmm0, %xmm2
leal (%rax,%rax,4), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
addl %ecx, %ecx
cvtsi2ss %ecx, %xmm3
mulss %xmm1, %xmm0
cmpleps %xmm0, %xmm3
andps %xmm2, %xmm3
movd %xmm3, %eax
jmp 0xd65a
xorl %eax, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x48(%rdi), %r12
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x43d6
movq %r12, %rdi
callq 0x2b0e
movl %r15d, -0x28(%rbp)
movl %r14d, -0x24(%rbp)
movq 0x118(%rbx), %rsi
cmpq 0x120(%rbx), %rsi
je 0xd6bb
movq -0x28(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x118(%rbx)
jmp 0xd6ce
addq $0x110, %rbx            # imm = 0x110
leaq -0x28(%rbp), %rdx
movq %rbx, %rdi
callq 0xdc64
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x110(%rdi), %r14
leaq 0x48(%rdi), %r15
xorl %r13d, %r13d
leaq -0x30(%rbp), %r12
movq 0x118(%rbx), %rax
movq -0x8(%rax), %rsi
movq %rsi, -0x30(%rbp)
movl -0x2c(%rbp), %edx
movq %r15, %rdi
callq 0x42d4
testl %eax, %eax
je 0xd782
addq $-0x8, 0x118(%rbx)
movslq -0x30(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x138(%rbx), %rdx
movq -0x8(%rdx,%rax,8), %rax
movb $0x1, -0x1(%rax,%rcx)
jmp 0xd7fa
movslq -0x30(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
movq 0x138(%rbx), %rax
movq -0x8(%rax,%rsi,8), %rax
movb $0x0, -0x1(%rax,%rdx)
movq 0x140(%rbx), %rax
movq -0x8(%rax,%rsi,8), %rax
movl -0x4(%rax,%rdx,4), %ecx
movq %r15, %rdi
callq 0x43d6
movq 0x118(%rbx), %rsi
cmpq 0x120(%rbx), %rsi
je 0xd7d4
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x118(%rbx)
jmp 0xd7df
movq %r14, %rdi
movq %r12, %rdx
callq 0xdc64
movl -0x30(%rbp), %esi
movl -0x2c(%rbp), %edx
movq %r15, %rdi
callq 0x42d4
movq %rbx, %rdi
movl %eax, %esi
callq 0xd28a
movb $0x1, %r13b
testb $0x1, %r13b
je 0xd741
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %ecx, %r14d
movq 0x138(%rdi), %rax
movslq %esi, %rcx
movq -0x8(%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x1, -0x1(%rax,%rcx)
jne 0xdaf9
movq %rdi, %rbx
addq $0x48, %rdi
callq 0x42d4
testl %eax, %eax
je 0xdaf9
decl %r14d
cmpl $0x3, %r14d
ja 0xdaf9
leaq 0x1b5f(%rip), %rax      # 0xf648
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb $0x1, %al
jmp 0xdbc8
xorl %eax, %eax
jmp 0xdbc8
cvtsi2sdl 0x30(%rbx), %xmm0
movsd 0x1afb(%rip), %xmm1     # 0xf608
mulsd %xmm0, %xmm1
movsd 0x190f(%rip), %xmm2     # 0xf428
addsd %xmm2, %xmm1
movl 0x2c(%rbx), %eax
movl 0x34(%rbx), %ecx
leal (%rax,%rax,4), %eax
cvtsi2sd %eax, %xmm3
mulsd 0x1ade(%rip), %xmm0     # 0xf610
cmpltpd %xmm1, %xmm3
leal (%rcx,%rcx,4), %eax
jmp 0xdbb0
cvtsi2sdl 0x34(%rbx), %xmm0
movsd 0x1abf(%rip), %xmm1     # 0xf608
mulsd %xmm0, %xmm1
movsd 0x18d3(%rip), %xmm2     # 0xf428
addsd %xmm2, %xmm1
movl 0x2c(%rbx), %eax
movl 0x30(%rbx), %ecx
leal (%rax,%rax,2), %eax
cvtsi2sd %eax, %xmm3
mulsd 0x1ab2(%rip), %xmm0     # 0xf620
cmpltpd %xmm1, %xmm3
leal (%rcx,%rcx,2), %eax
jmp 0xdbb0
cvtsi2sdl 0x2c(%rbx), %xmm0
movsd 0x1a93(%rip), %xmm1     # 0xf618
mulsd %xmm0, %xmm1
movsd 0x1897(%rip), %xmm2     # 0xf428
addsd %xmm2, %xmm1
movl 0x30(%rbx), %eax
movl 0x34(%rbx), %ecx
addl %ecx, %ecx
cvtsi2sd %ecx, %xmm3
mulsd 0x1a77(%rip), %xmm0     # 0xf620
cmpltpd %xmm1, %xmm3
addl %eax, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
addsd %xmm2, %xmm0
cmpltpd %xmm0, %xmm1
andpd %xmm3, %xmm1
movd %xmm1, %eax
andb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x10(%rdi)
movl %edx, 0x14(%rdi)
movq %rcx, 0x8(%rdi)
xorl %edi, %edi
callq 0x2170
movl %eax, %edi
callq 0x2190
movq %rbx, %rdi
callq 0xdde8
movq %rbx, %rdi
callq 0xde7e
movq %rbx, %rdi
callq 0xdf94
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe03e
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x10(%rdi), %r12
leaq (,%r12,8), %rdi
testq %r12, %r12
movq $-0x1, %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, (%rbx)
testq %r12, %r12
jle 0xde6f
movslq 0x14(%rbx), %r13
leaq (,%r13,4), %r14
testq %r13, %r13
cmovsq %r15, %r14
movl %r13d, %eax
shlq $0x2, %rax
movq %rax, -0x30(%rbp)
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x2030
movq (%rbx), %rcx
movq %rax, (%rcx,%r15,8)
testl %r13d, %r13d
jle 0xde67
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
movq -0x30(%rbp), %rdx
callq 0x20e0
incq %r15
cmpq %r15, %r12
jne 0xde41
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x10(%rdi), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, -0x20(%rbp)
movl 0x14(%rdi), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, -0x1c(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rsi
testq %rsi, %rsi
je 0xded2
movq -0x20(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, -0x38(%rbp)
jmp 0xdedf
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0xdc64
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0xdf60
leaq -0x40(%rbp), %r14
movq %r14, %rsi
callq 0xe292
movq %rax, -0x20(%rbp)
cmpl $-0x1, %eax
je 0xdf60
cmpl $-0x1, -0x1c(%rbp)
je 0xdf60
movq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0xe310
movq %rax, %r15
movq (%rbx), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0xdf34
movq -0x20(%rbp), %rsi
movq %r14, %rdx
callq 0xe43a
movq (%rbx), %rax
movslq %r15d, %rcx
movq (%rax,%rcx,8), %rax
movq %r15, %rcx
sarq $0x20, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0xdf56
movq %r15, %rsi
movq %r14, %rdx
callq 0xe43a
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jne 0xdeed
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xdf6e
callq 0x2180
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdf7b
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xdf8c
callq 0x2180
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x10(%rdi)
jle 0xe03d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r14d
leaq 0x1770(%rip), %r13      # 0xf72c
cmpl $0x0, 0x14(%rbx)
jle 0xe022
leal -0x1(%r14), %r15d
movl $0x1, %r12d
leal -0x1(%r12), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0xe084
cmpl $0x3, %eax
ja 0xe014
movl %eax, %eax
movslq (%r13,%rax,4), %rax
addq %r13, %rax
movl $0x1, %ecx
jmpq *%rax
movl $0x2, %ecx
jmp 0xe005
movl $0x3, %ecx
jmp 0xe005
movl $0x4, %ecx
movq 0x8(%rbx), %rdi
movl %r14d, %esi
movl %r12d, %edx
callq 0x43d6
leal 0x1(%r12), %eax
cmpl 0x14(%rbx), %r12d
movl %eax, %r12d
jl 0xdfcc
leal 0x1(%r14), %eax
cmpl 0x10(%rbx), %r14d
movl %eax, %r14d
jl 0xdfbc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/davidjosepha[P]slitherlink/src/generator/loopgen.cpp
// Function: LoopGen::countLines(int, int) const
int LoopGen::countLines(int i, int j) const {
    bool inside = inLoop(i, j);

    int lines = ((!inBounds({ i + 1, j}) && inside) || (inBounds({ i + 1, j }) && inLoop(i + 1, j) != inside))
                + ((!inBounds({ i - 1, j}) && inside) || (inBounds({ i - 1, j }) && inLoop(i - 1, j) != inside))
                + ((!inBounds({ i, j + 1}) && inside) || (inBounds({ i, j + 1 }) && inLoop(i, j + 1) != inside))
                + ((!inBounds({ i, j - 1}) && inside) || (inBounds({ i, j - 1 }) && inLoop(i, j - 1) != inside));

    return lines;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movabsq $-0x7fffffff80000000, %r9 # imm = 0x8000000080000000
movq (%rdi), %rbx
movslq %esi, %r15
movq (%rbx,%r15,8), %rax
movslq %edx, %r14
movl (%rax,%r14,4), %ecx
decl %ecx
incl %r15d
movq %r14, %r11
shlq $0x20, %r11
leaq (%r15,%r11), %r8
testq %r9, %r8
setne %r8b
movl 0x10(%rdi), %r10d
cmpl %r15d, %r10d
setle %r12b
orb %r8b, %r12b
movb $0x1, %r13b
jne 0xe0dd
cmpl %edx, 0x14(%rdi)
setle %r13b
cmpl $0x2, %ecx
setb %r8b
andb %r13b, %r8b
orb %r8b, %r12b
jne 0xe116
cmpl %edx, 0x14(%rdi)
jle 0xe113
cmpl $0x2, %ecx
setb %r12b
movslq %r15d, %r8
movq (%rbx,%r8,8), %r8
movl (%r8,%r14,4), %r8d
decl %r8d
cmpl $0x2, %r8d
setb %r8b
xorb %r12b, %r8b
jmp 0xe116
xorl %r8d, %r8d
leal -0x1(%rsi), %r15d
orq %r15, %r11
testq %r9, %r11
setne %r11b
cmpl %esi, %r10d
setl %r12b
orb %r11b, %r12b
movb $0x1, %r13b
jne 0xe13a
cmpl %edx, 0x14(%rdi)
setle %r13b
cmpl $0x2, %ecx
setb %r11b
andb %r13b, %r11b
orb %r11b, %r12b
jne 0xe173
cmpl %edx, 0x14(%rdi)
jle 0xe170
cmpl $0x2, %ecx
setb %r12b
movslq %r15d, %r11
movq (%rbx,%r11,8), %r11
movl (%r11,%r14,4), %r11d
decl %r11d
cmpl $0x2, %r11d
setb %r11b
xorb %r12b, %r11b
jmp 0xe173
xorl %r11d, %r11d
leal 0x1(%rdx), %r15d
movq %r15, %rbx
shlq $0x20, %rbx
movl %esi, %r14d
orq %r14, %rbx
testq %r9, %rbx
setne %bl
cmpl %esi, %r10d
setle %r12b
orb %bl, %r12b
movb $0x1, %r13b
jne 0xe1a1
cmpl %r15d, 0x14(%rdi)
setle %r13b
cmpl $0x2, %ecx
setb %bl
andb %r13b, %bl
orb %bl, %r12b
jne 0xe1d1
cmpl %r15d, 0x14(%rdi)
jle 0xe1cf
cmpl $0x2, %ecx
setb %r12b
movslq %r15d, %rbx
movl (%rax,%rbx,4), %ebx
decl %ebx
cmpl $0x2, %ebx
setb %bl
xorb %r12b, %bl
jmp 0xe1d1
xorl %ebx, %ebx
leal -0x1(%rdx), %r15d
movq %r15, %r12
shlq $0x20, %r12
orq %r14, %r12
testq %r9, %r12
setne %r9b
cmpl %esi, %r10d
setle %sil
orb %r9b, %sil
movb $0x1, %r10b
jne 0xe1fc
cmpl %edx, 0x14(%rdi)
setl %r10b
cmpl $0x2, %ecx
setb %r9b
andb %r10b, %r9b
orb %r9b, %sil
jne 0xe22d
cmpl %edx, 0x14(%rdi)
jge 0xe215
xorl %r9d, %r9d
jmp 0xe22d
cmpl $0x2, %ecx
setb %cl
movslq %r15d, %rdx
movl (%rax,%rdx,4), %eax
decl %eax
cmpl $0x2, %eax
setb %r9b
xorb %cl, %r9b
movzbl %r9b, %eax
movzbl %bl, %ecx
addl %eax, %ecx
movzbl %r11b, %edx
movzbl %r8b, %eax
addl %edx, %eax
addl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0xe2fa
movq %rsi, %rbx
callq 0x2080
cltq
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
movq %rcx, %rsi
subq %rdi, %rsi
sarq $0x3, %rsi
xorl %edx, %edx
divq %rsi
movslq %edx, %rax
leaq (%rdi,%rax,8), %rsi
addq $0x8, %rsi
movl -0x8(%rsi), %r15d
movl -0x4(%rsi), %r14d
cmpq %rcx, %rsi
je 0xe2ec
leaq (%rdi,%rax,8), %rdi
subq %rsi, %rcx
movq %rcx, %rdx
callq 0x2240
addq $-0x8, 0x8(%rbx)
shlq $0x20, %r14
orq %r15, %r14
jmp 0xe301
movq $-0x1, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/davidjosepha[P]slitherlink/src/generator/loopgen.cpp
// Function: LoopGen::addCell(Coordinates)
Coordinates LoopGen::addCell(Coordinates cur) {
    assert(cur.i >= 0 && cur.i < m_ && cur.j >= 0 && cur.j < n_);

    /* check whether it's possible to expand in any direction */
    if (!isExpandable(cur)) {
        return cur;
    }

    /* pick some direction up/down/left/right from cur */
    Coordinates newpos = pickDirection(cur);

    /* and verify it's a valid choice */
    if (!inBounds(newpos) || loop_[newpos.i][newpos.j] != UNKNOWN) {
        return cur;
    }

    AdjacencyList adjacencyList = getAdjacent(newpos);

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

    loop_[newpos.i][newpos.j] = (validCell(newpos, cur)) ? EXP : OUT;
    return newpos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testl %r14d, %r14d
js 0xe41b
testq %r14, %r14
js 0xe41b
movq %rdi, %rbx
cmpl %r14d, 0x10(%rdi)
jle 0xe41b
movq %r14, %r13
shrq $0x20, %r13
cmpl %r13d, 0x14(%rbx)
jle 0xe41b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe4d0
testb %al, %al
je 0xe3aa
movq %r14, %rsi
callq 0xe558
movq %rax, %r15
movabsq $-0x7fffffff80000000, %rax # imm = 0x8000000080000000
testq %rax, %r15
jne 0xe3aa
cmpl %r15d, 0x10(%rbx)
jle 0xe3aa
movq %r15, %r12
shrq $0x20, %r12
cmpl %r12d, 0x14(%rbx)
jle 0xe3aa
movq (%rbx), %rax
movl %r15d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movq (%rax,%rcx,8), %rax
movq %r15, %rdx
shrq $0x20, %rdx
cmpl $0x0, (%rax,%rdx,4)
je 0xe3c9
movq %r14, %r15
movq %r13, %r12
shlq $0x20, %r12
movl %r15d, %eax
orq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, -0x30(%rbp)
movq %rcx, %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe5c0
movl %eax, %ecx
xorb $0x1, %cl
testl $0x1010100, %eax        # imm = 0x1010100
sete %dl
movl $0x3, %eax
testb %cl, %dl
jne 0xe40b
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe66e
xorb $0x1, %al
movzbl %al, %eax
leal 0x1(,%rax,2), %eax
movq (%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movq -0x30(%rbp), %rdx
movl %eax, (%rcx,%rdx,4)
jmp 0xe3b0
leaq 0x131a(%rip), %rdi      # 0xf73c
leaq 0x1348(%rip), %rsi      # 0xf771
leaq 0x135b(%rip), %rcx      # 0xf78b
movl $0x71, %edx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rsi, -0x18(%rbp)
movq (%rdx), %rcx
movq 0x8(%rdx), %rsi
movq %rsi, %rdi
subq %rcx, %rdi
setne %r8b
je 0xe4a7
sarq $0x3, %rdi
movl -0x18(%rbp), %r9d
movl -0x14(%rbp), %r10d
xorl %r11d, %r11d
cmpq $0x1, %rdi
sbbq %rdi, %r11
movl $0x1, %ebx
cmpl %r9d, -0x8(%rcx,%rbx,8)
jne 0xe488
cmpl %r10d, -0x4(%rcx,%rbx,8)
je 0xe4a1
cmpq %rbx, %rdi
seta %r8b
leaq (%r11,%rbx), %r14
incq %r14
incq %rbx
cmpq $0x1, %r14
jne 0xe47a
jmp 0xe4a7
testb $0x1, %r8b
jne 0xe4c6
cmpq 0x10(%rdx), %rsi
je 0xe4b7
movq %rax, (%rsi)
addq $0x8, 0x8(%rdx)
jmp 0xe4c6
leaq -0x18(%rbp), %rax
movq %rdx, %rdi
movq %rax, %rdx
callq 0xdc64
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %ebx, %ebx
js 0xe538
testq %rbx, %rbx
js 0xe538
movq %rdi, %r14
cmpl %ebx, 0x10(%rdi)
jle 0xe538
movq %rbx, %r15
shrq $0x20, %r15
cmpl %r15d, 0x14(%r14)
jle 0xe538
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe5c0
movl %eax, %ecx
testl $0x1010100, %eax        # imm = 0x1010100
setne %al
orb %cl, %al
testb $0x1, %al
jne 0xe52b
movq (%r14), %rcx
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movq (%rcx,%rbx,8), %rcx
movl $0x2, (%rcx,%r15,4)
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11fd(%rip), %rdi      # 0xf73c
leaq 0x122b(%rip), %rsi      # 0xf771
leaq 0x1268(%rip), %rcx      # 0xf7b5
movl $0x97, %edx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0x2080
movslq %eax, %rbx
imulq $0x55555556, %rbx, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
leal (%rax,%rax,2), %ecx
notl %ecx
xorl %eax, %eax
addl %ecx, %ebx
jne 0xe5a4
callq 0x2080
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
andl $0x7ffffffe, %ecx       # imm = 0x7FFFFFFE
subl %ecx, %eax
leal -0x1(,%rax,2), %eax
movq %r14, %rcx
shrq $0x20, %rcx
addl %r14d, %ebx
addl %eax, %ecx
shlq $0x20, %rcx
orq %rcx, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addl %eax, %esi
movabsq $-0x100000000, %r13     # imm = 0xFFFFFFFF00000000
movq %r15, %rbx
andq %r13, %rbx
movl %r15d, %r12d
orq %rbx, %rsi
movq %r15, %rdx
callq 0xe66e
movb %al, -0x2a(%rbp)
leal 0x1(%r15), %esi
orq %rbx, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xe66e
movb %al, -0x29(%rbp)
leaq (%rbx,%r12), %rsi
addq %r13, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xe66e
movl %eax, %r13d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
orq %rax, %rbx
leaq (%r12,%rbx), %rsi
incq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xe66e
movzbl %al, %ecx
shll $0x18, %ecx
movzbl %r13b, %edx
shll $0x10, %edx
movzbl -0x29(%rbp), %esi
shll $0x8, %esi
movzbl -0x2a(%rbp), %eax
orl %esi, %eax
orl %edx, %eax
orl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: unit_test_framework::TestSuite::TestSuite()::'lambda'()::__invoke()
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:
cmpb $0x1, 0x4df7(%rip)      # 0x81ea
je 0x33f6
retq
pushq %rax
movq 0x4bca(%rip), %rdi      # 0x7fc8
leaq 0x1c8c(%rip), %rsi      # 0x5091
callq 0x21f0
movq %rax, %rdi
callq 0x20f0
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
je 0x3d40
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x429b(%rip), %rdi      # 0x7fc8
callq 0x2230
leaq 0x1602(%rip), %rsi      # 0x533b
movl $0x2, %edx
jmp 0x3d76
movq 0x4281(%rip), %r14      # 0x7fc8
leaq 0x15dd(%rip), %rsi      # 0x532b
movl $0xe, %edx
movq %r14, %rdi
callq 0x2230
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2230
leaq 0x15c9(%rip), %rsi      # 0x533a
movl $0x3, %edx
movq %rax, %rdi
callq 0x2230
cmpq $0x0, 0x30(%rbx)
je 0x3dd6
movq 0x423c(%rip), %r14      # 0x7fc8
leaq 0x1587(%rip), %rsi      # 0x531a
movl $0x4, %edx
movq %r14, %rdi
callq 0x2230
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
testb %bpl, %bpl
jne 0x3e24
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
jmp 0x3e4e
cmpq $0x0, 0x50(%rbx)
je 0x3e29
movq 0x41e4(%rip), %r14      # 0x7fc8
leaq 0x1529(%rip), %rsi      # 0x5314
movl $0x5, %edx
movq %r14, %rdi
callq 0x2230
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
testb %bpl, %bpl
je 0x3e46
popq %rbx
popq %r14
popq %rbp
retq
movq 0x4198(%rip), %rbx      # 0x7fc8
leaq 0x14be(%rip), %rsi      # 0x52f5
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2230
jmp 0x3e5d
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdx
movq 0x4173(%rip), %rdi      # 0x7fc8
callq 0x2230
movq %rax, %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %r12
movl $0x0, (%r12)
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x21b0
cmpl $0x0, (%r12)
je 0x44d9
leaq 0x2(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2696
jmp 0x44f4
movq %rax, %r15
leaq 0x3(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2696
movq %r15, %rdi
callq 0x2240
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/main.cpp
// Function: prepare_default_conf()
void prepare_default_conf()
{
    LEAF::CONF::Conf &conf = LEAF::CONF::ConfManager::get();

    //generator
    conf.set<char *>("leaf.compiler.generator.outfile", "test/leaf.asm");

    //sections; grupo: leaf.compiler.asm.section.
    conf.set<bool>("leaf.compiler.asm.section.show_title", true); //general
    conf.set<bool>("leaf.compiler.asm.section.text.title.show", true);
    conf.set<bool>("leaf.compiler.asm.section.data.title.show", true);
    conf.set<bool>("leaf.compiler.asm.section.bss.title.show", true);
    conf.set<bool>("leaf.compiler.asm.section.extern.title.show", true);
    conf.set<bool>("leaf.compiler.asm.section.global.title.show", true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
callq 0x9062
movq %rax, %rbx
leaq 0x115ba(%rip), %rax     # 0x19022
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x115cd(%rip), %rax     # 0x19042
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7dfa
leaq 0x115c5(%rip), %rax     # 0x19050
movq %rax, (%r14)
movl $0x1, %r15d
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7dfa
leaq 0x115c8(%rip), %rax     # 0x19075
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7dfa
leaq 0x115d6(%rip), %rax     # 0x1909f
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7dfa
leaq 0x115e4(%rip), %rax     # 0x190c9
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7dfa
leaq 0x115f1(%rip), %rax     # 0x190f2
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7dfa
leaq 0x11601(%rip), %rax     # 0x1911e
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7dfa
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/ast/expressions.cpp
// Function: LEAF::AST::BinOp::BinOp(LEAF::AST::NODEU*, LEAF::AST::op_types, LEAF::AST::NODEU*)
BinOp::BinOp(ASTU l, op_types op, ASTU r)
{
    this->l = l;
    this->r = r;
    this->op = op;
    //obj->type=left->obj->type;
    this->obj->type = l->obj->type;

    //TODO: codigo para la coercion de tipos aritmeticos
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
callq 0x82fa
leaq 0x1ce7c(%rip), %rax     # 0x24df8
movq %rax, (%r15)
movq %r14, 0x28(%r15)
movq %rbx, 0x30(%r15)
movl %ebp, 0x38(%r15)
movq 0x8(%r14), %rax
movq 0x18(%rax), %rax
movq 0x8(%r15), %rcx
movq %rax, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/ast/statement.hpp
// Function: LEAF::AST::rand_label::newLabel[abi:cxx11](int)
static string *newLabel(int size)
    {

        char *r = (char *)malloc(sizeof(char) * size + 2);
        r[0] = '_';
        string tokens("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890_");
        for (int x = 1; x < size-1; x++)
        {

            r[x] = tokens[rand() % 63];
        }
        r[size - 1] = '_';
        r[size] = '\0';
        return new string(r);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movslq %edi, %r14
leaq 0x2(%r14), %rdi
callq 0x5370
movq %rax, %rbx
movb $0x5f, (%rax)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x10e77(%rip), %rsi     # 0x19239
leaq 0x10eaf(%rip), %rdx     # 0x19278
leaq 0x8(%rsp), %rdi
callq 0x84ba
leal -0x1(%r14), %ebp
cmpl $0x3, %r14d
jl 0x8424
movl %ebp, %r12d
movl $0x1, %r13d
callq 0x50b0
cltq
imulq $-0x7df7df7d, %rax, %rcx # imm = 0x82082083
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
movl %ecx, %edx
shll $0x6, %edx
subl %edx, %ecx
addl %eax, %ecx
movslq %ecx, %rax
movq 0x8(%rsp), %rcx
movb (%rcx,%rax), %al
movb %al, (%rbx,%r13)
incq %r13
cmpq %r13, %r12
jne 0x83e6
movslq %ebp, %rax
movb $0x5f, (%rbx,%rax)
movb $0x0, (%rbx,%r14)
movl $0x20, %edi
callq 0x5290
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x5120
movq %rbx, %rdx
addq %rax, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x84ba
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8474
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52a0
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x52a0
jmp 0x849b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x84b2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create(wchar_t const*, int)
wchar_t* coco_string_create(const wchar_t *value, int startIndex) {
	int valueLen = 0;
	int len = 0;

	if (value) {
		valueLen = wcslen(value);
		len = valueLen - startIndex;
	}

	return coco_string_create(value, startIndex, len);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
je 0x90fc
movq %r14, %rdi
callq 0x5200
movq %rax, %rdx
subl %ebx, %edx
jmp 0x90fe
xorl %edx, %edx
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x910f
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create(wchar_t const*, int, int)
wchar_t* coco_string_create(const wchar_t *value, int startIndex, int length) {
	int len = 0;
	wchar_t* data;

	if (value) { len = length; }
	data = new wchar_t[len + 1];
	wcsncpy(data, &(value[startIndex]), len);
	data[len] = 0;

	return data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %eax, %eax
testq %rdi, %rdi
cmovnel %edx, %eax
movslq %eax, %r15
leaq 0x4(,%r15,4), %rax
cmpl $-0x1, %r15d
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x5040
movq %rax, %r12
movslq %ebx, %rax
leaq (%r14,%rax,4), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x50a0
movl $0x0, (%r12,%r15,4)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create_upper(wchar_t const*)
wchar_t* coco_string_create_upper(const wchar_t* data) {
	if (!data) { return NULL; }

	int dataLen = 0;
	if (data) { dataLen = wcslen(data); }

	wchar_t *newData = new wchar_t[dataLen + 1];

	for (int i = 0; i <= dataLen; i++) {
		if ((L'a' <= data[i]) && (data[i] <= L'z')) {
			newData[i] = data[i] + (L'A' - L'a');
		}
		else { newData[i] = data[i]; }
	}

	newData[dataLen] = L'\0';
	return newData;
}

// Assembly:
testq %rdi, %rdi
je 0x91e8
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5200
movq %rax, %r14
movq %rax, %r15
shlq $0x20, %r15
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %r15, %rax
movq %rax, %rcx
sarq $0x1e, %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x5040
testl %r14d, %r14d
js 0x91d6
incl %r14d
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
leal -0x61(%rdx), %esi
leal -0x20(%rdx), %edi
cmpl $0x1a, %esi
cmovael %edx, %edi
movl %edi, (%rax,%rcx,4)
incq %rcx
cmpq %rcx, %r14
jne 0x91bc
sarq $0x1e, %r15
movl $0x0, (%rax,%r15)
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create_lower(wchar_t const*, int, int)
wchar_t* coco_string_create_lower(const wchar_t* data, int startIndex, int dataLen) {
	if (!data) { return NULL; }

	wchar_t* newData = new wchar_t[dataLen + 1];

	for (int i = 0; i <= dataLen; i++) {
		wchar_t ch = data[startIndex + i];
		if ((L'A' <= ch) && (ch <= L'Z')) {
			newData[i] = ch - (L'A' - L'a');
		}
		else { newData[i] = ch; }
	}
	newData[dataLen] = L'\0';
	return newData;
}

// Assembly:
testq %rdi, %rdi
je 0x927e
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq %edx, %r15
leaq 0x4(,%r15,4), %rax
cmpl $-0x1, %r15d
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x5040
testl %r15d, %r15d
js 0x926b
movslq %ebp, %rcx
incl %ebx
leaq (%r14,%rcx,4), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
leal -0x41(%rsi), %edi
movl %esi, %r8d
orl $0x20, %r8d
cmpl $0x1a, %edi
cmovael %esi, %r8d
movl %r8d, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rbx
jne 0x924b
movl $0x0, (%rax,%r15,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create_append(wchar_t const*, wchar_t const*)
wchar_t* coco_string_create_append(const wchar_t* data1, const wchar_t* data2) {
	wchar_t* data;
	int data1Len = 0;
	int data2Len = 0;

	if (data1) { data1Len = wcslen(data1); }
	if (data2) {data2Len = wcslen(data2); }

	data = new wchar_t[data1Len + data2Len + 1];

	if (data1) { wcscpy(data, data1); }
	if (data2) { wcscpy(data + data1Len, data2); }

	data[data1Len + data2Len] = 0;

	return data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movl $0x0, %r15d
testq %rdi, %rdi
je 0x92a9
movq %r14, %rdi
callq 0x5200
movq %rax, %r15
testq %rbx, %rbx
je 0x92b9
movq %rbx, %rdi
callq 0x5200
movq %rax, %r12
addl %r15d, %r12d
movslq %r12d, %r13
leaq 0x4(,%r13,4), %rax
cmpl $-0x1, %r13d
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x5040
movq %rax, %r12
testq %r14, %r14
je 0x92ee
movq %r12, %rdi
movq %r14, %rsi
callq 0x54a0
testq %rbx, %rbx
je 0x9302
movslq %r15d, %rax
leaq (%r12,%rax,4), %rdi
movq %rbx, %rsi
callq 0x54a0
movl $0x0, (%r12,%r13,4)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create_append(wchar_t const*, wchar_t)
wchar_t* coco_string_create_append(const wchar_t *target, const wchar_t appendix) {
	int targetLen = coco_string_length(target);
	wchar_t* data = new wchar_t[targetLen + 2];
	wcsncpy(data, target, targetLen);
	data[targetLen] = appendix;
	data[targetLen + 1] = 0;
	return data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
je 0x9333
movq %r14, %rdi
callq 0x5200
jmp 0x9335
xorl %eax, %eax
movslq %eax, %r15
leaq 0x8(,%r15,4), %rax
cmpl $-0x2, %r15d
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x5040
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x50a0
movl %ebx, (%r12,%r15,4)
movl $0x0, 0x4(%r12,%r15,4)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_merge(wchar_t*&, wchar_t const*)
void coco_string_merge(wchar_t* &target, const wchar_t* appendix) {
	if (!appendix) { return; }
	wchar_t* data = coco_string_create_append(target, appendix);
	delete [] target;
	target = data;
}

// Assembly:
testq %rsi, %rsi
je 0x9465
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x9281
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x945b
callq 0x5360
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq