LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getLightDistance()
float AppParams::getLightDistance()
{
    // default return 10. Range 2..30
    float value = 0.1 * UserDefaults::sharedInstance()->getInteger (kLightDistance, 10 * DEF_LIGHT_DISTANCE);

    if (value < MIN_DISTANCE) value = MIN_DISTANCE;
    if (value > MAX_DISTANCE) value = MAX_DISTANCE;

    return value;
}

// Assembly:
pushq %rax
callq 0x82e2
leaq 0x163d(%rip), %rsi      # 0x966c
movq %rax, %rdi
movl $0x64, %edx
callq 0x841a
cvtsi2sd %eax, %xmm0
mulsd 0x1268(%rip), %xmm0     # 0x92b0
cvtsd2ss %xmm0, %xmm0
movss 0x1580(%rip), %xmm1     # 0x95d4
maxss %xmm0, %xmm1
movss 0x1578(%rip), %xmm0     # 0x95d8
minss %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::isPaletteAlternative()
bool AppParams::isPaletteAlternative()
{
    int source = getPalette();

    if (source == PALETTE_STD) { return NO; }
    if (source == PALETTE_ALT) { return YES; }

    int v = rand() & 0x01;

    return (v == 0);
}

// Assembly:
pushq %rax
callq 0x82e2
leaq 0x1590(%rip), %rsi      # 0x9639
movq %rax, %rdi
movl $0x2, %edx
callq 0x841a
testl %eax, %eax
je 0x80c3
cmpl $0x1, %eax
jne 0x80c7
movb $0x1, %al
jmp 0x80d1
xorl %eax, %eax
jmp 0x80d1
callq 0x30e0
testb $0x1, %al
sete %al
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getLightMoving()
bool AppParams::getLightMoving()
{
    int source = getLightSource();

    if (source == LIGHT_MOVING) return true;
    if (source == LIGHT_FIXED) return false;

    int v = rand() & 0x01;

    return (v == 0);
}

// Assembly:
pushq %rax
callq 0x82e2
leaq 0x1565(%rip), %rsi      # 0x9646
movq %rax, %rdi
movl $0x2, %edx
callq 0x841a
cmpl $0x1, %eax
je 0x80fb
testl %eax, %eax
jne 0x80ff
xorl %eax, %eax
jmp 0x8109
movb $0x1, %al
jmp 0x8109
callq 0x30e0
testb $0x1, %al
sete %al
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getGlossLevel()
float AppParams::getGlossLevel (void)
{
    // from 0 to 10

    int value = UserDefaults::sharedInstance()->getInteger (kGlossyOption, DEF_GLOSS_LEVEL);

    if (value < MIN_GLOSS) value = MIN_GLOSS;
    if (value > MAX_GLOSS) value = MAX_GLOSS;

    return (float)value;
}

// Assembly:
pushq %rbx
callq 0x82e2
leaq 0x147e(%rip), %rsi      # 0x9653
xorl %ebx, %ebx
movq %rax, %rdi
xorl %edx, %edx
callq 0x841a
testl %eax, %eax
cmovgl %eax, %ebx
cmpl $0xa, %ebx
movl $0xa, %eax
cmovll %ebx, %eax
cvtsi2ss %eax, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::destroy_slots()
void destroy_slots() {
        if (!capacity_) return;
        for (size_t i = 0; i != capacity_; ++i) {
            if (IsFull(ctrl_[i])) {
                PolicyTraits::destroy(&alloc_ref(), slots_ + i);
            }
        }
        auto layout = MakeLayout(capacity_);
        // Unpoison before returning the memory to the allocator.
        SanitizerUnpoisonMemoryRegion(slots_, sizeof(slot_type) * capacity_);
        Deallocate<Layout::Alignment()>(&alloc_ref(), ctrl_, layout.AllocSize());
        ctrl_ = EmptyGroup();
        slots_ = nullptr;
        size_ = 0;
        capacity_ = 0;
        growth_left() = 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1717
callq 0x1724
leaq 0x28(%rbx), %rdi
movq (%rbx), %rsi
addq $0x3, %rax
andq $-0x4, %rax
leaq (%rax,%rdx,8), %rdx
callq 0x175a
leaq 0x2cbd(%rip), %rax      # 0x43c0
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %rax, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/phmap/./phmap.h
// Function: std::pair<phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::iterator, bool> phmap::container_internal::raw_hash_map<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::try_emplace_impl<unsigned int>(unsigned int&&)
std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args) {
        auto res = this->find_or_prepare_insert(k);
        if (res.second)
            this->emplace_at(res.first, std::piecewise_construct,
                             std::forward_as_tuple(std::forward<K>(k)),
                             std::forward_as_tuple(std::forward<Args>(args)...));
        return {this->iterator_at(res.first), res.second};
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movl (%rdx), %eax
movabsq $-0x21a0462d9cfba717, %rcx # imm = 0xDE5FB9D2630458E9
mulq %rcx
movq %rdi, %r14
addq %rax, %rdx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x1870
movq %rax, %r12
movl %edx, %ebp
testb $0x1, %dl
je 0x17e3
leaq 0x8(%rsp), %rcx
movq %r15, (%rcx)
leaq 0x2bfd(%rip), %rdx      # 0x43d0
leaq 0x7(%rsp), %r8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x180c
movq (%rbx), %rax
addq %r12, %rax
shlq $0x3, %r12
addq 0x8(%rbx), %r12
movq %rax, (%r14)
movq %r12, 0x8(%r14)
movb %bpl, 0x10(%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/phmap/./phmap.h
// Function: void phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::emplace_at<std::piecewise_construct_t const&, std::tuple<unsigned int&&>, std::tuple<>>(unsigned long, std::piecewise_construct_t const&, std::tuple<unsigned int&&>&&, std::tuple<>&&)
void emplace_at(size_t i, Args&&... args) {
        PolicyTraits::construct(&alloc_ref(), slots_ + i,
                                std::forward<Args>(args)...);

        assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) ==
               iterator_at(i) &&
               "constructed value does not match the lookup key");
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
leaq (%rax,%rsi,8), %rsi
movq (%rcx), %rax
movl (%rax), %eax
movl %eax, (%rsi)
movabsq $-0x21a0462d9cfba717, %rcx # imm = 0xDE5FB9D2630458E9
mulq %rcx
movl $0x0, 0x4(%rsi)
addq %rax, %rdx
callq 0x1f8e
addq (%r14), %rbx
cmpq %rbx, %rax
jne 0x1851
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x28c6(%rip), %rdi      # 0x411e
leaq 0x1882(%rip), %rsi      # 0x30e1
leaq 0x2938(%rip), %rcx      # 0x419e
movl $0x803, %edx            # imm = 0x803
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::prepare_insert(unsigned long)
size_t prepare_insert(size_t hash) PHMAP_ATTRIBUTE_NOINLINE {
        auto target = find_first_non_full(hash);
        if (PHMAP_PREDICT_FALSE(growth_left() == 0 &&
                               !IsDeleted(ctrl_[target.offset]))) {
            rehash_and_grow_if_necessary();
            target = find_first_non_full(hash);
        }
        ++size_;
        growth_left() -= IsEmpty(ctrl_[target.offset]);
        set_ctrl(target.offset, H2(hash));
        infoz_.RecordInsert(hash, target.probe_length);
        return target.offset;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x19a8
movq %rax, %r15
movq (%r14), %rcx
movq 0x28(%r14), %rax
testq %rax, %rax
jne 0x195a
cmpb $-0x2, (%rcx,%r15)
jne 0x1988
xorl %eax, %eax
incq 0x10(%r14)
xorl %edx, %edx
cmpb $-0x80, (%rcx,%r15)
sete %dl
subq %rdx, %rax
movq %rax, 0x28(%r14)
andl $0x7f, %ebx
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x1aaa
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1a46
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19a8
movq %rax, %r15
movq (%r14), %rcx
movq 0x28(%r14), %rax
jmp 0x195a
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::find_first_non_full(unsigned long)
FindInfo find_first_non_full(size_t hash) {
        auto seq = probe(hash);
        while (true) {
            Group g{ctrl_ + seq.offset()};
            auto mask = g.MatchEmptyOrDeleted();
            if (mask) {
                return {seq.offset(mask.LowestBitSet()), seq.index()};
            }
            assert(seq.index() < capacity_ && "full table!");
            seq.next();
        }
    }

// Assembly:
pushq %rax
movq 0x18(%rdi), %rcx
leaq 0x1(%rcx), %rax
testq %rcx, %rax
jne 0x1a27
shrq $0x7, %rsi
movq (%rdi), %rax
andq %rcx, %rsi
movdqu (%rax,%rsi), %xmm0
pcmpeqd %xmm1, %xmm1
pcmpgtb %xmm0, %xmm1
pmovmskb %xmm1, %edi
xorl %edx, %edx
testl %edi, %edi
jne 0x19fd
cmpq %rcx, %rdx
jae 0x1a08
addq %rdx, %rsi
addq $0x10, %rsi
addq $0x10, %rdx
andq %rcx, %rsi
movdqu (%rax,%rsi), %xmm0
pcmpeqd %xmm1, %xmm1
pcmpgtb %xmm0, %xmm1
pmovmskb %xmm1, %edi
jmp 0x19d3
bsfl %edi, %eax
addq %rsi, %rax
andq %rcx, %rax
popq %rcx
retq
leaq 0x19cd(%rip), %rdi      # 0x33dc
leaq 0x16cb(%rip), %rsi      # 0x30e1
leaq 0x19e8(%rip), %rcx      # 0x3405
movl $0x7be, %edx            # imm = 0x7BE
callq 0x10a0
leaq 0x1934(%rip), %rdi      # 0x3362
leaq 0x16ac(%rip), %rsi      # 0x30e1
leaq 0x194f(%rip), %rcx      # 0x338b
movl $0x44, %edx
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::rehash_and_grow_if_necessary()
void rehash_and_grow_if_necessary() {
        if (capacity_ == 0) {
            resize(1);
        } else if (size() <= CapacityToGrowth(capacity()) / 2) {
            // Squash DELETED without growing if there is enough capacity.
            drop_deletes_without_resize();
        } else {
            // Otherwise grow the container.
            resize(capacity_ * 2 + 1);
        }
    }

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x1a7f
leaq 0x1(%rax), %rcx
testq %rax, %rcx
jne 0x1a89
movq %rax, %rcx
shrq $0x3, %rcx
movq %rax, %rdx
subq %rcx, %rdx
shrq %rdx
cmpq %rdx, 0x10(%rdi)
jbe 0x1bea
leaq 0x1(,%rax,2), %rsi
jmp 0x1aec
movl $0x1, %esi
jmp 0x1aec
pushq %rax
leaq 0x1636(%rip), %rdi      # 0x30c7
leaq 0x1649(%rip), %rsi      # 0x30e1
leaq 0x2200(%rip), %rcx      # 0x3c9f
movl $0x1d6, %edx            # imm = 0x1D6
callq 0x10a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::set_ctrl(unsigned long, signed char)
void set_ctrl(size_t i, ctrl_t h) {
        assert(i < capacity_);

        if (IsFull(h)) {
            SanitizerUnpoisonObject(slots_ + i);
        } else {
            SanitizerPoisonObject(slots_ + i);
        }

        ctrl_[i] = h;
        ctrl_[((i - Group::kWidth) & capacity_) + 1 +
              ((Group::kWidth - 1) & capacity_)] = h;
    }

// Assembly:
cmpq %rsi, 0x18(%rdi)
jbe 0x1acc
movq (%rdi), %rax
movb %dl, (%rax,%rsi)
addq $-0x10, %rsi
movq 0x18(%rdi), %rax
andq %rax, %rsi
andl $0xf, %eax
addq (%rdi), %rsi
movb %dl, 0x1(%rax,%rsi)
retq
pushq %rax
leaq 0x247d(%rip), %rdi      # 0x3f51
leaq 0x1606(%rip), %rsi      # 0x30e1
leaq 0x247d(%rip), %rcx      # 0x3f5f
movl $0x81e, %edx            # imm = 0x81E
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::initialize_slots()
void initialize_slots() {
        assert(capacity_);
        if (std::is_same<SlotAlloc, std::allocator<slot_type>>::value && 
            slots_ == nullptr) {
            infoz_ = Sample();
        }

        auto layout = MakeLayout(capacity_);
        char* mem = static_cast<char*>(
            Allocate<Layout::Alignment()>(&alloc_ref(), layout.AllocSize()));
        ctrl_ = reinterpret_cast<ctrl_t*>(layout.template Pointer<0>(mem));
        slots_ = layout.template Pointer<1>(mem);
        reset_ctrl();
        reset_growth_left();
        infoz_.RecordStorageChanged(size_, capacity_);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1e90
callq 0x1724
movq %rax, %r14
leaq 0x28(%rbx), %rdi
addq $0x3, %r14
andq $-0x4, %r14
leaq (%r14,%rdx,8), %rsi
callq 0x1ece
testb $0x3, %al
jne 0x1eaf
movq %rax, (%rbx)
addq %rax, %r14
movq %r14, 0x8(%rbx)
movq 0x18(%rbx), %rdx
addq $0x10, %rdx
movq %rax, %rdi
movl $0x80, %esi
callq 0x1080
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movb $-0x1, (%rax,%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f2c
leaq 0x20be(%rip), %rdi      # 0x3f55
leaq 0x1243(%rip), %rsi      # 0x30e1
leaq 0x18f9(%rip), %rcx      # 0x379e
movl $0x70b, %edx            # imm = 0x70B
callq 0x10a0
leaq 0x1b8d(%rip), %rdi      # 0x3a43
leaq 0x1bb6(%rip), %rsi      # 0x3a73
leaq 0x1bbe(%rip), %rcx      # 0x3a82
movl $0xfbe, %edx            # imm = 0xFBE
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/phmap/./phmap.h
// Function: void* phmap::container_internal::Allocate<4ul, std::allocator<std::pair<unsigned int const, unsigned int>>>(std::allocator<std::pair<unsigned int const, unsigned int>>*, unsigned long)
void* Allocate(Alloc* alloc, size_t n) {
  static_assert(Alignment > 0, "");
  assert(n && "n must be positive");
  struct alignas(Alignment) M {};
  using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
  using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
  A mem_alloc(*alloc);
  void* p = AT::allocate(mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
         "allocator does not respect alignment");
  return p;
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x1eee
addq $0x3, %rsi
shrq $0x2, %rsi
leaq 0x7(%rsp), %rdi
xorl %edx, %edx
callq 0x1f72
testb $0x3, %al
jne 0x1f0d
popq %rcx
retq
leaq 0x13b8(%rip), %rdi      # 0x32ad
leaq 0x11e5(%rip), %rsi      # 0x30e1
leaq 0x1a54(%rip), %rcx      # 0x3957
movl $0x2b4, %edx            # imm = 0x2B4
callq 0x10a0
leaq 0x1ad5(%rip), %rdi      # 0x39e9
leaq 0x11c6(%rip), %rsi      # 0x30e1
leaq 0x1a35(%rip), %rcx      # 0x3957
movl $0x2bb, %edx            # imm = 0x2BB
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::iterator phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::find<unsigned int>(unsigned int const&, unsigned long)
iterator find(const key_arg<K>& key, size_t hash) {
        auto seq = probe(hash);
        while (true) {
            Group g{ctrl_ + seq.offset()};
            for (int i : g.Match(H2(hash))) {
                if (PHMAP_PREDICT_TRUE(PolicyTraits::apply(
                                          EqualElement<K>{key, eq_ref()},
                                          PolicyTraits::element(slots_ + seq.offset(i)))))
                    return iterator_at(seq.offset(i));
            }
            if (PHMAP_PREDICT_TRUE(g.MatchEmpty())) 
                return end();
            seq.next();
        }
    }

// Assembly:
pushq %rax
movq 0x18(%rdi), %rcx
leaq 0x1(%rcx), %rax
testq %rcx, %rax
jne 0x2036
movq %rdx, %r8
shrq $0x7, %r8
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
andb $0x7f, %dl
movzbl %dl, %edx
movd %edx, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movl (%rsi), %edx
xorl %esi, %esi
movdqa 0x104e(%rip), %xmm1     # 0x3020
andq %rcx, %r8
movdqu (%rax,%r8), %xmm2
movdqa %xmm0, %xmm3
pcmpeqb %xmm2, %xmm3
pmovmskb %xmm3, %r9d
testl %r9d, %r9d
je 0x200d
movzwl %r9w, %r10d
bsfl %r10d, %r9d
addq %r8, %r9
andq %rcx, %r9
cmpl %edx, (%rdi,%r9,8)
je 0x2028
leal -0x1(%r10), %r9d
andl %r10d, %r9d
movl %r9d, %r10d
jne 0x1ff1
pcmpeqb %xmm1, %xmm2
pmovmskb %xmm2, %r9d
testl %r9d, %r9d
jne 0x202e
addq %rsi, %r8
addq $0x10, %r8
addq $0x10, %rsi
jmp 0x1fd2
leaq (%rdi,%r9,8), %rdx
jmp 0x2031
movq %rcx, %r9
addq %r9, %rax
popq %rcx
retq
leaq 0x1325(%rip), %rdi      # 0x3362
leaq 0x109d(%rip), %rsi      # 0x30e1
leaq 0x1340(%rip), %rcx      # 0x338b
movl $0x44, %edx
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O3/ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::~DataSet()
DataSet::~DataSet() {
	for(int i=0; i < num_entries; i++) {
		delete[] image_data[i];
		delete[] label_data[i];
	}
	delete[] image_data;
	delete[] label_data;
	delete[] labels;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x2fe8
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x2fcb
callq 0x2180
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x2fdd
callq 0x2180
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x2fb9
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2ff6
callq 0x2180
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3004
callq 0x2180
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x3019
popq %rbx
popq %r14
jmp 0x2180
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::label_for_vector(double*)
int DataSet::label_for_vector(double *vec) {
	int label = -1;
	switch(label_data_length) {
		case ASCII_LENGTH:
			label = label_for_vector_ascii(vec);
			break;
		case PACKED_LENGTH:
			label = label_for_vector_packed(vec);
			break;
		case FULL_LENGTH:
			label = label_for_vector_full(vec);
			break;
	}
	return label;
}

// Assembly:
movl 0x8(%rdi), %ecx
cmpl $0x4, %ecx
je 0x30b9
cmpl $0x8, %ecx
je 0x308c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0xa, %ecx
jne 0x30df
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorl %eax, %eax
movsd (%rsi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
cmoval %ecx, %eax
maxsd %xmm0, %xmm1
incq %rcx
movapd %xmm1, %xmm0
cmpq $0xa, %rcx
jne 0x306d
jmp 0x30df
xorl %ecx, %ecx
movsd 0x1f72(%rip), %xmm0     # 0x5008
xorl %eax, %eax
movsd (%rsi,%rcx,8), %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
shll %cl, %edx
orb %dl, %al
incq %rcx
cmpq $0x8, %rcx
jne 0x3098
movzbl %al, %eax
addl $-0x30, %eax
retq
xorl %ecx, %ecx
movsd 0x1f45(%rip), %xmm0     # 0x5008
xorl %eax, %eax
movsd (%rsi,%rcx,8), %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
shll %cl, %edx
orl %edx, %eax
incq %rcx
cmpq $0x4, %rcx
jne 0x30c5
retq
// File: /workspace/github_cpp_makefile_star2_O3/ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::print_image(int, int, int)
void DataSet::print_image(int n, int width, int height) {
	using namespace std;
	
	double *img = this->image_vector(n);
	for(int y=0; y < height; y ++) {
		for(int x=0; x < width; x ++) {
			double pixel = img[y * height + x];
			if(pixel == 0.0) {
				cout << "  ";
			} else if(pixel < 0.9) {
				cout << "..";
			} else {
				cout << "##";
			}
		}
		cout << endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, 0x4(%rsp)
testl %ecx, %ecx
jle 0x31fd
movq 0x10(%rdi), %rax
movslq %esi, %rdx
movq (%rax,%rdx,8), %r15
movl %ecx, %eax
movl 0x4(%rsp), %r13d
movq %rax, 0x10(%rsp)
leaq (,%rax,8), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movq 0x3ea9(%rip), %rcx      # 0x6fd0
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x4(%rsp)
movsd 0x1edf(%rip), %xmm1     # 0x5018
leaq 0x1fc4(%rip), %rdx      # 0x5104
movq %rcx, %rbp
leaq 0x1fbd(%rip), %rax      # 0x5107
xorpd %xmm2, %xmm2
leaq 0x1fac(%rip), %rcx      # 0x5101
jle 0x31ba
xorl %r12d, %r12d
movq %r15, 0x20(%rsp)
movsd (%r15,%r12,8), %xmm0
ucomisd %xmm0, %xmm1
movq %rax, %r14
cmovaq %rdx, %rax
ucomisd %xmm0, %xmm2
movq %rcx, %r15
movq %rcx, %rsi
cmovneq %rax, %rsi
cmovpq %rax, %rsi
movq %r13, %rbx
movq %rdx, %r13
movl $0x2, %edx
movq %rbp, %rdi
callq 0x2150
movq %r15, %rcx
movq 0x20(%rsp), %r15
xorpd %xmm2, %xmm2
movq %r14, %rax
movq %r13, %rdx
movq %rbx, %r13
movsd 0x1e66(%rip), %xmm1     # 0x5018
incq %r12
cmpq %r12, %rbx
jne 0x315f
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbp, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20b0
movq 0x18(%rsp), %rax
incq %rax
addq 0x8(%rsp), %r15
cmpq 0x10(%rsp), %rax
movq %rbp, %rcx
jne 0x3127
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::print_label(int)
void DataSet::print_label(int n) {
	using namespace std;
	
	double *label = this->label_vector(n);
	cout << "[" << label[0];
	for(int i=1; i < this->label_vector_length(); i++) {
		cout << ", " << label[i];
	}
	cout << "]" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %r13
movq 0x3da4(%rip), %rbx      # 0x6fd0
leaq 0x1ed7(%rip), %rsi      # 0x510a
movl $0x1, %ebp
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2150
movsd (%r13), %xmm0
movq %rbx, %rdi
callq 0x21a0
cmpl $0x2, 0x8(%r14)
jl 0x3293
movq 0x3d6f(%rip), %r15      # 0x6fd0
leaq 0x1ea4(%rip), %r12      # 0x510c
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2150
movsd (%r13,%rbp,8), %xmm0
movq %r15, %rdi
callq 0x21a0
incq %rbp
movslq 0x8(%r14), %rax
cmpq %rax, %rbp
jl 0x3268
leaq 0x1e75(%rip), %rsi      # 0x510f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/ghulette[P]neural-net-openmp/neuralnet.cpp
// Function: NeuralNet::~NeuralNet()
NeuralNet::~NeuralNet() {
  delete[] hidden_weights;
  delete[] hidden_weights_buffer;
  delete[] hidden_weight_deltas;
  delete[] hidden_values;

  delete[] output_weights;
  delete[] output_weights_buffer;
  delete[] output_weight_deltas;
  delete[] output_values;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x3e3c
callq 0x2180
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3e4a
callq 0x2180
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3e58
callq 0x2180
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x3e66
callq 0x2180
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x3e74
callq 0x2180
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x3e82
callq 0x2180
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x3e90
callq 0x2180
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x3e9f
popq %rbx
jmp 0x2180
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ghulette[P]neural-net-openmp/neuralnet.cpp
// Function: NeuralNet::run(double*)
double *NeuralNet::run(double *input) {
  double *iv = input;
  double *hv = hidden_values;
  double *ov = output_values;
  
  // Propagate from input to hidden layer
  #pragma omp parallel for
  for(int i=0; i < num_hidden; i++) {
    double sum = 0.0;
    for(int j=0; j < num_inputs; j++) {
      sum += iv[j] * hidden_weights[i][j];
    }
    hv[i] = sigmoid(sum);
  }
  
  // Propagate from hidden to output layer
  #pragma omp parallel for
  for(int i=0; i < num_outputs; i++) {
    double sum = 0.0;
    for(int j=0; j < num_hidden; j++) {
      sum += hv[j] * output_weights[i][j];
    }
    ov[i] = sigmoid(sum);
  }
  
  return ov;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r12
movq 0x48(%rdi), %r14
cmpl $0x0, 0x4(%rdi)
jle 0x3f24
movq %rsi, %r15
xorl %r13d, %r13d
movslq (%rbx), %rax
testq %rax, %rax
jle 0x3ef1
movq 0x10(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%r15,%rdx,8), %xmm1
mulsd (%rcx,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x3ed8
jmp 0x3ef5
xorpd %xmm0, %xmm0
xorpd 0x1383(%rip), %xmm0     # 0x5280
callq 0x21d0
movsd 0x1366(%rip), %xmm1     # 0x5270
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%r12,%r13,8)
incq %r13
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jl 0x3ec2
cmpl $0x0, 0x8(%rbx)
jle 0x3f90
xorl %r15d, %r15d
movslq 0x4(%rbx), %rax
testq %rax, %rax
jle 0x3f5d
movq 0x30(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%r12,%rdx,8), %xmm1
mulsd (%rcx,%rdx,8), %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x3f44
jmp 0x3f61
xorpd %xmm0, %xmm0
xorpd 0x1317(%rip), %xmm0     # 0x5280
callq 0x21d0
movsd 0x12fa(%rip), %xmm1     # 0x5270
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%r15,8)
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x3f2d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ghulette[P]neural-net-openmp/neuralnet.cpp
// Function: NeuralNet::train(double*, double*, double)
void NeuralNet::train(double *input, double *desired_output, double eta) {
  run(input);
  double *iv = input;
  double *hv = hidden_values;
  double *ov = output_values;
  double *dv = desired_output;
  
  // Calculate weight deltas for the output layer
  #pragma omp parallel for
  for(int i=0; i < num_outputs; i++) {
    output_weight_deltas[i] = (dv[i] - ov[i]) * ov[i] * (1.0 - ov[i]);
  }
    
  // Calculate weight deltas for the hidden layer
  #pragma omp parallel for
  for(int i=0; i < num_hidden; i++) {
    double sum = 0.0;
    for(int j=0; j < num_outputs; j++) {
      sum += output_weight_deltas[j] * output_weights[j][i];
    }
    hidden_weight_deltas[i] = sum * hv[i] * (1.0 - hv[i]);
  }
        
  // Update output layer weights
  #pragma omp parallel for
  for(int i=0; i < num_outputs; i++) {
    for(int j=0; j < num_hidden; j++) {
      output_weights[i][j] += eta * output_weight_deltas[i] * hv[j];
    }
  }
            
  // Update hidden layer weights
  #pragma omp parallel for
  for(int i=0; i < num_hidden; i++) {
    for(int j=0; j < num_inputs; j++) {
      hidden_weights[i][j] += eta * hidden_weight_deltas[i] * iv[j];
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3ea2
movq 0x28(%r14), %rcx
movl 0x8(%r14), %edx
testl %edx, %edx
jle 0x4005
movq 0x48(%r14), %rax
movq 0x40(%r14), %rsi
xorl %edi, %edi
movsd 0x1297(%rip), %xmm0     # 0x5270
movsd (%r15,%rdi,8), %xmm1
movsd (%rax,%rdi,8), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
mulsd %xmm1, %xmm3
movsd %xmm3, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0x3fd9
movl 0x4(%r14), %eax
testl %eax, %eax
jle 0x406f
movq 0x40(%r14), %rsi
movq 0x20(%r14), %rdi
movq 0x30(%r14), %r8
xorl %r9d, %r9d
movsd 0x124c(%rip), %xmm0     # 0x5270
xorpd %xmm1, %xmm1
testl %edx, %edx
jle 0x404b
xorl %r10d, %r10d
movsd (%rsi,%r10,8), %xmm2
movq (%r8,%r10,8), %r11
mulsd (%r11,%r9,8), %xmm2
addsd %xmm2, %xmm1
incq %r10
cmpq %r10, %rdx
jne 0x402f
movsd (%rcx,%r9,8), %xmm2
mulsd %xmm2, %xmm1
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
mulsd %xmm1, %xmm3
movsd %xmm3, (%rdi,%r9,8)
incq %r9
cmpq %rax, %r9
jne 0x4024
testl %edx, %edx
movsd 0x8(%rsp), %xmm1
jle 0x40bb
movq 0x30(%r14), %rsi
movq 0x40(%r14), %rdi
xorl %r8d, %r8d
testl %eax, %eax
jle 0x40b3
movq (%rsi,%r8,8), %r9
xorl %r10d, %r10d
movsd (%rdi,%r8,8), %xmm0
mulsd %xmm1, %xmm0
mulsd (%rcx,%r10,8), %xmm0
addsd (%r9,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rax
jne 0x408f
incq %r8
cmpq %rdx, %r8
jne 0x4084
testl %eax, %eax
jle 0x4102
movl (%r14), %ecx
movq 0x20(%r14), %rdx
movq 0x10(%r14), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0x40fa
movq (%rsi,%rdi,8), %r8
xorl %r9d, %r9d
movsd (%rdx,%rdi,8), %xmm0
mulsd %xmm1, %xmm0
mulsd (%rbx,%r9,8), %xmm0
addsd (%r8,%r9,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x40d7
incq %rdi
cmpq %rax, %rdi
jne 0x40cc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ghulette[P]neural-net-openmp/neuralnet.cpp
// Function: NeuralNet::mse(double*)
double NeuralNet::mse(double *desired_values) {
  double sum = 0.0;
  for(int i=0; i < num_outputs; i++) {
    double diff = desired_values[i] - output_values[i];
    sum += diff * diff;
  }
  return sum;
}

// Assembly:
movslq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x413a
movq 0x48(%rdi), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%rsi,%rdx,8), %xmm1
subsd (%rcx,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x411f
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/lotka[P]prologplusplus/main.cpp
// Function: main
int main()
{
	cout << "Prolog++" << endl;
	cout << "~~~~~~~~~~~~~~~~~~~~~" << endl;
	cout << "Preloaded facts: " << endl << endl;
	consult_test("equal(X,X).");
	consult_test("basic(a,b,c).");
	consult_test("person(alice).");
	consult_test("person(bob).");
	cout << endl;

	while(not cin.eof())
	{
		string input;
		cout << "| ?- ";
		cin >> input;
		query_test(input);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x4763(%rip), %rbx      # 0x6fd0
leaq 0x27a2(%rip), %rsi      # 0x5016
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
leaq 0x2770(%rip), %rsi      # 0x501f
movl $0x15, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
leaq 0x274b(%rip), %rsi      # 0x5035
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
leaq 0x26f8(%rip), %rdi      # 0x5047
callq 0x248c
leaq 0x26f8(%rip), %rdi      # 0x5053
callq 0x248c
leaq 0x26fa(%rip), %rdi      # 0x5061
callq 0x248c
leaq 0x26fd(%rip), %rdi      # 0x5070
callq 0x248c
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq 0x463a(%rip), %rbx      # 0x6fe0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
jne 0x2a56
leaq -0x38(%rbp), %r14
leaq -0x58(%rbp), %r15
leaq -0x48(%rbp), %r12
leaq -0x68(%rbp), %r13
movq %r14, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movl $0x5, %edx
movq 0x45ec(%rip), %rdi      # 0x6fd0
leaq 0x2692(%rip), %rsi      # 0x507d
callq 0x2150
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2180
movq %r15, -0x68(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x2b40
movq %r13, %rdi
callq 0x25b1
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x2a2f
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2130
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x2a44
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
je 0x29c8
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x2a84
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2130
jmp 0x2a84
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x2a99
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lotka[P]prologplusplus/atom.cpp
// Function: Atom::Atom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Atom::Atom(string n)
{
	name = n;
	if('A' <= n[0] and n[0] <= 'Z')
	{
		free_variable = true;
	}
	else
	{
		free_variable = false;
	}
	if(n.size() == 1 and n[0] == '_')
	{
		cout << "UNDERSCORE DETECTED" << endl;
		is_under_score = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x28(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movq %rax, 0x38(%rdi)
callq 0x2090
movq (%r15), %rax
movb (%rax), %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
setb 0x20(%rbx)
cmpq $0x1, 0x8(%r15)
jne 0x2e9b
cmpb $0x5f, (%rax)
jne 0x2e9b
movq 0x4178(%rip), %r15      # 0x6fd0
leaq 0x2268(%rip), %rsi      # 0x50c7
movl $0x13, %edx
movq %r15, %rdi
callq 0x2150
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq 0x4146(%rip), %rdi      # 0x6fd0
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movb $0x1, 0x21(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2ebc
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2224
movq %r15, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lotka[P]prologplusplus/atom.cpp
// Function: Atom::unifyWith(Atom*)
bool Atom::unifyWith(Atom * a)
{
  if(a->free_variable)
  {
    if(not free_variable)
    {
      a->possibilties.push_back(this);
    }
    else
    {
      cout << "not sure what to do here" << endl;
    }
    return true;
  }
  else if(*a == *this)
  {
    return true;
  }
  else
  {
    return false;
  }
}

// Assembly:
movq %rdi, %rax
cmpb $0x1, 0x20(%rsi)
jne 0x2f29
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpb $0x0, 0x20(%rax)
je 0x2f34
movq 0x40e4(%rip), %rbx      # 0x6fd0
leaq 0x21e8(%rip), %rsi      # 0x50db
movl $0x18, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
jmp 0x2f4a
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x2f54
addq $0x28, %rsi
leaq -0x10(%rbp), %rcx
movq %rax, (%rcx)
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x2fc0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lotka[P]prologplusplus/atom.cpp
// Function: Atom::operator==(Atom&)
bool Atom::operator == (Atom &b)
{
  if(b.free_variable or free_variable)
  {
    return true;
  }
  if(this->name == b.name)
  {
    return true;
  }
  else
  {
    return false;
  }
}

// Assembly:
movb $0x1, %al
cmpb $0x0, 0x20(%rsi)
jne 0x2f86
cmpb $0x0, 0x20(%rdi)
jne 0x2f86
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x2f87
testq %rdx, %rdx
je 0x2f86
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rsi
movq (%rdi), %rdi
callq 0x2140
testl %eax, %eax
sete %al
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/lotka[P]prologplusplus/parser.cpp
// Function: cropString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
string cropString(string &input_string, int n)
{
	string crop;
	int i = 0;
	for(i = 0; i < input_string.size(); ++i)
	{
		if(i == n)
		{
			break;
		}
		else
		{
			crop.push_back(input_string[i]);
		}
	}
	input_string.erase(0,i+1);
	return crop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x1, %edx
testl %eax, %eax
je 0x31ab
cmpq $0x0, 0x8(%r14)
je 0x31ab
movl %eax, %r12d
movl $0x1, %r13d
movq (%r14), %rax
movsbl -0x1(%rax,%r13), %esi
movq %rbx, %rdi
callq 0x20e0
leaq 0x1(%r13), %rax
cmpq %r13, %r12
je 0x31a9
cmpq %r13, 0x8(%r14)
movq %rax, %r13
ja 0x3186
movl %eax, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31c9
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x31df
movq (%r15), %rsi
incq %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/lotka[P]prologplusplus/parser.cpp
// Function: cropString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
string cropString(string &input_string, char delimiter)
{
	string crop;
	int i = 0;
	for(i = 0;i < input_string.size(); ++i)
	{
		if(input_string[i] == delimiter)
		{
			break;
		}
		else
		{
			crop.push_back(input_string[i]);
		}
	}
	input_string.erase(0,i+1);
	return crop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq $0x0, 0x8(%rsi)
je 0x3240
movl %edx, %r12d
xorl %r15d, %r15d
movq (%r14), %rax
movb (%rax,%r15), %al
cmpb %r12b, %al
je 0x323b
movsbl %al, %esi
movq %rbx, %rdi
callq 0x20e0
incq %r15
cmpq %r15, 0x8(%r14)
ja 0x321b
incl %r15d
jmp 0x3246
movl $0x1, %r15d
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3267
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x327e
movq (%r13), %rsi
incq %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/lotka[P]prologplusplus/parser.cpp
// Function: countChar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
int countChar(string s, char c)
{
	int count = 0;
	for(int i = 0; i < s.size(); ++i)
	{
		if(s[i]==c)
		{
			++count;
		}
	}
	return count;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x32b2
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
xorl %edi, %edi
xorl %eax, %eax
xorl %r8d, %r8d
cmpb %sil, (%rdx,%rdi)
sete %r8b
addl %r8d, %eax
incq %rdi
cmpq %rdi, %rcx
jne 0x329a
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/lotka[P]prologplusplus/parser.cpp
// Function: strip_ws(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string strip_ws(string s)
{
	string new_s;
	for(int i = 0; i < s.size(); ++i)
	{
		if(s[i]!=' ')
		{
			new_s.push_back(s[i]);
		}
	}
	return new_s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x3340
movq %rsi, %r14
xorl %r12d, %r12d
movq (%r14), %rcx
movb (%rcx,%r12), %cl
cmpb $0x20, %cl
je 0x3338
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x20e0
movq 0x8(%r14), %rax
incq %r12
cmpq %r12, %rax
ja 0x331d
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3362
movq (%r15), %rsi
incq %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_compilation_timeout.cpp
// Function: compilation_timeout_check::continue_compilation(exprtk::compilation_check::compilation_context&)
bool continue_compilation(compilation_context& context) override
   {
      if (++iterations_ >= max_iters_per_check)
      {
         if (std::chrono::steady_clock::now() >= timeout_tp_)
         {
            context.error_message = "Compilation has timed-out";
            return false;
         }

         iterations_ = 0;
      }

      return true;
   }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
incq %rax
movq %rax, 0x8(%rdi)
movb $0x1, %bl
cmpq $0x2710, %rax           # imm = 0x2710
jb 0x11bffa
movq %rsi, %r14
movq %rdi, %r15
callq 0x114490
cmpq 0x10(%r15), %rax
jge 0x11bfdd
movq $0x0, 0x8(%r15)
jmp 0x11bffa
movq 0x8(%r14), %rdx
leaq 0x189bab(%rip), %rcx    # 0x2a5b93
xorl %ebx, %ebx
movl $0x19, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x114240
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/dlbeer[P]summary_map/test_sum.cpp
// Function: range_test(std::mersenne_twister_engine<unsigned long, 32ul, 624ul, 397ul, 31ul, 2567483615ul, 11ul, 4294967295ul, 7ul, 2636928640ul, 15ul, 4022730752ul, 18ul, 1812433253ul>&, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>>> const&, std::vector<int, std::allocator<int>> const&, unsigned int)
static void range_test(std::mt19937& rnd, test_map& m,
		       const test_vector& vec,
		       const std::vector<int>& series,
		       unsigned int limit)
{
    int a = rnd() % (limit + 1);
    int b = rnd() % (limit + 1);

    if (a > b)
	std::swap(a, b);

    test_map::const_iterator ia = m.find(vec[a].first);
    test_map::const_iterator ib = m.find(vec[b].first);

    const int sa = a ? series[a - 1] : 0;
    const int sb = b ? series[b - 1] : 0;

    const int vsum = sb - sa;
    const int msum = m.sum(ia, ib).sum;

    assert(vsum == msum);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r12d
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
callq 0x2b84
incl %r12d
xorl %edx, %edx
divq %r12
movq %rdx, %rbp
movq %r13, %rdi
callq 0x2b84
xorl %edx, %edx
divq %r12
cmpl %edx, %ebp
movl %edx, %r12d
cmovgl %ebp, %r12d
cmovll %ebp, %edx
movslq %edx, %rbp
leaq (,%rbp,4), %rsi
addq %rbp, %rsi
shlq $0x3, %rsi
addq (%r15), %rsi
leaq 0x8(%rbx), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x2cf0
movq %rax, 0x8(%rsp)
movslq %r12d, %r14
leaq (%r14,%r14,4), %rsi
shlq $0x3, %rsi
addq (%r15), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x2cf0
movq 0x10(%rsp), %rdx
movl $0x0, %ecx
testl %ebp, %ebp
je 0x29db
movq (%rdx), %rcx
movl -0x4(%rcx,%rbp,4), %ecx
testl %r12d, %r12d
movl $0x0, %r15d
je 0x29ee
movq (%rdx), %rdx
movl -0x4(%rdx,%r14,4), %r15d
subl %ecx, %r15d
incq %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x2d50
cmpl %eax, %r15d
jne 0x2a18
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x270d(%rip), %rdi      # 0x512c
leaq 0x2657(%rip), %rsi      # 0x507d
leaq 0x270c(%rip), %rcx      # 0x5139
movl $0x2c, %edx
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::sum_between(aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary> const&, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static summary_type sum_between(const aggregator_type& ag,
				    node *first, node *last)
    {
	if (is_header(first))
	    return ag.nothing();

	// This special case works, because last is the parent of the
	// root. The sum will include the root's right subtree iff the
	// path to first is left of the root
	if (is_header(last))
	    return ag.combine(ag.summarize(first->value),
			      sum_from(ag, first, last));

	if (first == last)
	    return ag.nothing();

	node *c = concestor(first, last);

	summary_type sum = ag.summarize(first->value);

	sum = ag.combine(sum, sum_from(ag, first, c));

	if ((c != last) && (c != first))
	    sum = ag.combine(sum, c->value);

	sum = ag.combine(sum, sum_to(ag, last, c));

	return sum;
    }

// Assembly:
xorl %eax, %eax
cmpq $0x0, 0x40(%rsi)
je 0x2de9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x40(%rdx)
je 0x2dc7
cmpq %rbx, %r15
je 0x2ddb
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2e48
movq %rax, %r12
movl 0x20(%r15), %r13d
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2dea
movl %eax, %ebp
addl %r13d, %ebp
cmpq %rbx, %r12
sete %al
cmpq %r15, %r12
sete %cl
orb %al, %cl
jne 0x2db7
addl 0x20(%r12), %ebp
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2ea6
jmp 0x2dd9
movl 0x20(%r15), %ebp
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2dea
addl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq