LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::not_condition_t::evaluate(wf::access_interface_t&, bool&)
bool not_condition_t::evaluate(access_interface_t &interface, bool &error)
{
    if ((error) || (child == nullptr))
    {
        error = true;
        return false;
    }

    return !child->evaluate(interface, error);
}

// Assembly:
cmpb $0x0, (%rdx)
jne 0x6898
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x6898
pushq %rax
movq (%rdi), %rax
callq *0x10(%rax)
xorb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
movb $0x1, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::not_condition_t::to_string[abi:cxx11]() const
std::string not_condition_t::to_string() const
{
    std::string out = "(!";
    if (child != nullptr)
    {
        out.append(child->to_string());
    }
    else
    {
        out.append("nullptr");
    }
    out.append(")");
    return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
leaq 0x10(%rdi), %r15
leaq 0x57b7(%rip), %rsi      # 0xc06c
leaq 0x57b2(%rip), %rdx      # 0xc06e
movq %rdi, %rbx
movq %r15, (%rdi)
callq 0x6386
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x6907
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x5090
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6916
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x6916
leaq 0x574e(%rip), %rsi      # 0xc05c
movq %rbx, %rdi
callq 0x53b0
leaq 0x6506(%rip), %rsi      # 0xce23
movq %rbx, %rdi
callq 0x53b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %rcx
movq %rax, %r14
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x6957
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x6957
jmp 0x6954
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x696a
movq (%r15), %rsi
incq %rsi
callq 0x5230
movq %r14, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/condition/test_condition.cpp
// Function: wf::equals_condition_t::evaluate(wf::access_interface_t&, bool&)
bool equals_condition_t::evaluate(access_interface_t &interface, bool &error)
{
    if (error)
    {
        return false;
    }

    auto value = interface.get(_identifier, error);

    if (error)
    {
        return false;
    }

    return value == _value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpb $0x0, (%rdx)
je 0x6b92
xorl %ebx, %ebx
jmp 0x6bfc
movq (%rsi), %rax
movq %rdx, %r14
leaq 0x8(%rdi), %rdx
leaq 0x18(%rsp), %r15
movq %rdi, %rbx
movq %r14, %rcx
movq %r15, %rdi
callq *0x10(%rax)
cmpb $0x0, (%r14)
je 0x6bb7
xorl %ebx, %ebx
jmp 0x6be4
leaq 0x7(%rsp), %rax
leaq 0x8(%rsp), %rdi
leaq 0xb408(%rip), %rcx      # 0x11fd0
movq %rax, (%rdi)
movb $0x1, (%rax)
movq %r15, 0x8(%rdi)
movzbl 0x48(%rbx), %eax
addq $0x28, %rbx
movq %rbx, %rsi
callq *(%rcx,%rax,8)
movb 0x7(%rsp), %bl
leaq 0x18(%rsp), %rsi
leaq 0xb130(%rip), %rcx      # 0x11d20
movzbl 0x20(%rsi), %eax
leaq 0x8(%rsp), %rdi
callq *(%rcx,%rax,8)
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x18(%rsp), %rdi
movq %rax, %rbx
callq 0x6356
movq %rbx, %rdi
callq 0x5390
movq %rax, %rdi
callq 0x6209
nop
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/condition/test_condition.cpp
// Function: wf::equals_condition_t::to_string[abi:cxx11]() const
std::string equals_condition_t::to_string() const
{
    std::string out = _identifier;
    out.append(" equals ");
    out.append(wf::to_string(_value));
    return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rdi), %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %r15, (%rdi)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x6214
leaq 0x546b(%rip), %rsi      # 0xc0be
movq %rbx, %rdi
callq 0x53b0
addq $0x28, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0xb376
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x5090
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c96
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %rcx
movq %rax, %r14
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x6cc8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x6cc8
jmp 0x6cc5
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6cdb
movq (%r15), %rsi
incq %rsi
callq 0x5230
movq %r14, %rdi
callq 0x5390
nop
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/condition/test_condition.cpp
// Function: wf::contains_condition_t::evaluate(wf::access_interface_t&, bool&)
bool contains_condition_t::evaluate(access_interface_t &interface, bool &error)
{
    if (error)
    {
        return false;
    }

    auto value = interface.get(_identifier, error);

    if (error)
    {
        return false;
    }

    // If the retrieved value or search value is not a string, this can't work.
    if ((!is_string(value)) || (!is_string(_value)))
    {
        error = true;
        return false;
    }

    return get_string(value).find(get_string(_value)) != std::string::npos;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
cmpb $0x0, (%rdx)
je 0x6d25
xorl %ebx, %ebx
jmp 0x6dec
movq (%rsi), %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rdx
leaq 0x20(%rsp), %rdi
movq %r14, %rcx
callq *0x10(%rax)
cmpb $0x0, (%r14)
jne 0x6dd4
leaq 0x20(%rsp), %rdi
callq 0xb344
testb %al, %al
je 0x6dd0
addq $0x28, %rbx
movq %rbx, %rdi
callq 0xb344
testb %al, %al
je 0x6dd0
leaq 0x20(%rsp), %rsi
movq %rsp, %rdi
callq 0xb34c
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0xb34c
leaq 0x58(%rsp), %r14
movq %rsp, %rdi
xorl %edx, %edx
movq -0x10(%r14), %rsi
movq -0x8(%r14), %rcx
callq 0x5380
movq -0x10(%r14), %rdi
cmpq $-0x1, %rax
setne %bl
cmpq %r14, %rdi
je 0x6db3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x5230
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6dd6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x6dd6
movb $0x1, (%r14)
xorl %ebx, %ebx
leaq 0x20(%rsp), %rsi
leaq 0xaf3e(%rip), %rcx      # 0x11d20
movzbl 0x20(%rsi), %eax
movq %rsp, %rdi
callq *(%rcx,%rax,8)
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x10(%rsp), %rcx
movq %rax, %rbx
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x6e1b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x6e1b
jmp 0x6e18
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6356
movq %rbx, %rdi
callq 0x5390
movq %rax, %rdi
callq 0x6209
nop
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/condition/test_condition.cpp
// Function: wf::contains_condition_t::to_string[abi:cxx11]() const
std::string contains_condition_t::to_string() const
{
    std::string out = _identifier;
    out.append(" contains ");
    out.append(wf::to_string(_value));
    return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rdi), %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %r15, (%rdi)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x6214
leaq 0x5264(%rip), %rsi      # 0xc0c7
movq %rbx, %rdi
callq 0x53b0
addq $0x28, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0xb376
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x5090
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ea6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %rcx
movq %rax, %r14
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x6ed8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5230
jmp 0x6ed8
jmp 0x6ed5
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6eeb
movq (%r15), %rsi
incq %rsi
callq 0x5230
movq %r14, %rdi
callq 0x5390
nop
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/lexer/lexer.cpp
// Function: wf::lexer_t::parse_symbol()
symbol_t lexer_t::parse_symbol()
{
    if (_reversed)
    {
        auto position = _history.size() - _reversed;
        auto pair = _history.at(position);
        auto symbol = std::get<symbol_t>(pair);

        --_reversed;

        return symbol;
    }
    else
    {
        if (_parse_position >= _size)
        {
            return symbol_t(symbol_t::type_t::END);
        }

        while (std::isspace(_text.at(_parse_position)))
        {
            ++_parse_position;
        }

        _symbol_position = _parse_position;
        symbol_t symbol = _parse_literal();

        _history.push_back({_symbol_position, symbol});

        return symbol;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq 0x38(%rsi), %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rax, %rax
je 0x7431
movq 0x40(%r14), %rcx
movq 0x48(%r14), %rsi
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
subq %rcx, %rsi
sarq $0x3, %rsi
imulq %rsi, %rdx
movq %rdx, %rsi
subq %rax, %rsi
jb 0x750f
imulq $0x38, %rsi, %rax
leaq 0x18(%rsp), %r15
movq %r15, %rdi
leaq 0x10(%rcx,%rax), %rsi
movq -0x10(%rsi), %rax
movq %rax, -0x10(%r15)
movl -0x8(%rsi), %eax
movl %eax, -0x8(%r15)
callq 0x62aa
movl -0x8(%r15), %eax
movq %rbx, %rdi
addq $0x8, %rdi
movl %eax, (%rbx)
movq %r15, %rsi
callq 0x62aa
decq 0x38(%r14)
leaq 0xa904(%rip), %rcx      # 0x11d20
movzbl 0x38(%rsp), %eax
leaq 0x7(%rsp), %rdi
movq %r15, %rsi
callq *(%rcx,%rax,8)
jmp 0x74fe
movq 0x28(%r14), %r15
cmpq (%r14), %r15
jae 0x7479
movq 0x10(%r14), %r12
cmpq %r15, %r12
jbe 0x7465
movq 0x8(%r14), %r13
movsbl (%r13,%r15), %edi
callq 0x5050
testl %eax, %eax
je 0x7485
incq %r15
movq %r15, 0x28(%r14)
cmpq %r15, %r12
jne 0x7447
movq %r12, %r15
leaq 0x4dfe(%rip), %rdi      # 0xc26a
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x5300
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8858
jmp 0x74fe
movq %r15, 0x30(%r14)
leaq 0x8(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdi
callq 0x75cc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x88c4
leaq 0x8(%rsp), %rsi
leaq 0xa870(%rip), %r12      # 0x11d20
movzbl 0x20(%rsi), %eax
leaq 0x7(%rsp), %rdi
callq *(%r12,%rax,8)
movq 0x30(%r14), %rax
movl (%rbx), %ecx
leaq 0x18(%rsp), %r15
leaq 0x8(%rbx), %rsi
movq %rax, -0x10(%r15)
movl %ecx, -0x8(%r15)
movq %r15, %rdi
callq 0x62aa
addq $0x40, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7dbc
movzbl 0x38(%rsp), %eax
leaq 0x7(%rsp), %rdi
movq %r15, %rsi
callq *(%r12,%rax,8)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4d0a(%rip), %rdi      # 0xc220
jmp 0x7472
jmp 0x754a
leaq 0x8(%rsp), %rdi
movq %rax, %r14
callq 0x759a
jmp 0x752f
movq %rax, %r14
movq %rbx, %rdi
callq 0x7568
jmp 0x755f
jmp 0x754a
leaq 0x8(%rsp), %rdi
movq %rax, %r14
callq 0x6356
jmp 0x755f
movq %rax, %rdi
callq 0x6209
leaq 0x8(%rsp), %rdi
movq %rax, %r14
callq 0x759a
movq %r14, %rdi
callq 0x5390
nop
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/lexer/lexer.cpp
// Function: wf::lexer_t::reverse()
void lexer_t::reverse()
{
    if (_reversed < _history.size())
    {
        ++_reversed;

        auto position = _history.size() - _reversed;
        auto pair = _history.at(position);
        _symbol_position = std::get<size_t>(pair);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x40(%rdi), %rcx
movq 0x48(%rdi), %rsi
movq 0x38(%rdi), %rax
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
subq %rcx, %rsi
sarq $0x3, %rsi
imulq %rsi, %rdx
cmpq %rdx, %rax
jae 0x787e
incq %rax
leaq 0x20(%rsp), %r14
movq %rdi, %rbx
subq %rax, %rdx
movq %rax, 0x38(%rdi)
movq %r14, %rdi
imulq $0x38, %rdx, %rdx
leaq 0x10(%rcx,%rdx), %rsi
movq -0x10(%rsi), %rax
movq %rax, -0x10(%r14)
movl -0x8(%rsi), %eax
movl %eax, -0x8(%r14)
callq 0x62aa
movq -0x10(%r14), %rax
leaq 0xa4b6(%rip), %rcx      # 0x11d20
movq %rax, 0x30(%rbx)
movzbl 0x20(%r14), %eax
leaq 0xf(%rsp), %rdi
movq %r14, %rsi
callq *(%rcx,%rax,8)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x6209
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/parser/condition_parser.cpp
// Function: wf::condition_parser_t::_expression(wf::lexer_t&)
void condition_parser_t::_expression(lexer_t &lexer)
{
    _term(lexer);
    while ((_symbol.type == symbol_t::type_t::OPERATOR) && (get_string(_symbol.value) == "|"))
    {
        auto or_condition = std::make_shared<or_condition_t>();
        or_condition->left = _root;
        _term(lexer);
        or_condition->right = _root;
        _root = or_condition;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x95a0
cmpl $0x3, 0x10(%r14)
jne 0x9577
leaq 0x18(%r14), %r15
leaq 0x8(%r14), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xb34c
leaq 0x2d22(%rip), %rsi      # 0xc1e3
movq %rbp, %rdi
callq 0x5080
movq 0x8(%rsp), %rdi
movl %eax, %r12d
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x94e8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5230
testl %r12d, %r12d
jne 0x9577
leaq 0x10(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq $0x0, 0x8(%rsp)
movq %rbp, %rsi
movq %r12, %rdi
callq 0x9f4a
movq 0x8(%rsp), %rdi
movq (%r14), %rax
movq %r13, %rsi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
callq 0x9d38
movq %r14, %rdi
movq %rbx, %rsi
callq 0x95a0
movq 0x8(%rsp), %rdi
movq (%r14), %rax
movq %r13, %rsi
movq %rax, 0x18(%rdi)
addq $0x20, %rdi
callq 0x9d38
movq 0x8(%rsp), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %rax, (%r14)
callq 0x9d38
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x956c
callq 0x6972
cmpl $0x3, 0x10(%r14)
je 0x94af
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x9598
callq 0x6972
movq %rbx, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/parser/condition_parser.cpp
// Function: wf::condition_parser_t::_term(wf::lexer_t&)
void condition_parser_t::_term(lexer_t &lexer)
{
    _factor(lexer);
    while ((_symbol.type == symbol_t::type_t::OPERATOR) && (get_string(_symbol.value) == "&"))
    {
        auto and_condition = std::make_shared<and_condition_t>();
        and_condition->left = _root;
        _factor(lexer);
        and_condition->right = _root;
        _root = and_condition;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x96c2
cmpl $0x3, 0x10(%r14)
jne 0x9699
leaq 0x18(%r14), %r15
leaq 0x8(%r14), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xb34c
leaq 0x2bfe(%rip), %rsi      # 0xc1e1
movq %rbp, %rdi
callq 0x5080
movq 0x8(%rsp), %rdi
movl %eax, %r12d
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x960a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5230
testl %r12d, %r12d
jne 0x9699
leaq 0x10(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq $0x0, 0x8(%rsp)
movq %rbp, %rsi
movq %r12, %rdi
callq 0xa016
movq 0x8(%rsp), %rdi
movq (%r14), %rax
movq %r13, %rsi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
callq 0x9d38
movq %r14, %rdi
movq %rbx, %rsi
callq 0x96c2
movq 0x8(%rsp), %rdi
movq (%r14), %rax
movq %r13, %rsi
movq %rax, 0x18(%rdi)
addq $0x20, %rdi
callq 0x9d38
movq 0x8(%rsp), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %rax, (%r14)
callq 0x9d38
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x968e
callq 0x6972
cmpl $0x3, 0x10(%r14)
je 0x95d1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x96ba
callq 0x6972
movq %rbx, %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/wayfire/rule/lambda_rule.cpp
// Function: wf::lambda_rule_t::apply(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, wf::access_interface_t&)
bool lambda_rule_t::apply(const std::string &signal, access_interface_t &access)
{
    if ((signal.empty()) || (_condition == nullptr) || (_if_lambda == nullptr))
    {
        return true;
    }

    bool error = false;
    if (signal == _signal)
    {
        auto check_result = _condition->evaluate(access, error);
        if (!error)
        {
            if (check_result)
            {
                error = _if_lambda();
            }
            else
            {
                if (_else_lambda != nullptr)
                {
                    error = _else_lambda();
                }
            }

        }
    }

    return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq 0x8(%rsi), %rdx
movb $0x1, %al
testq %rdx, %rdx
je 0xb008
movq 0x20(%rdi), %r15
movq %rdi, %rbx
testq %r15, %r15
je 0xb008
cmpq $0x0, 0x40(%rbx)
je 0xb008
movb $0x0, 0x7(%rsp)
cmpq 0x8(%rbx), %rdx
jne 0xb006
movq (%rbx), %rax
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x5240
testl %eax, %eax
je 0xb014
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r15), %rax
leaq 0x7(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movl %eax, %ecx
movb (%r12), %al
testb %al, %al
jne 0xb008
testb %cl, %cl
je 0xb048
cmpq $0x0, 0x40(%rbx)
je 0xb05d
leaq 0x30(%rbx), %rdi
movl $0x48, %eax
jmp 0xb058
cmpq $0x0, 0x60(%rbx)
je 0xb008
leaq 0x50(%rbx), %rdi
movl $0x68, %eax
callq *(%rbx,%rax)
jmp 0xb008
callq 0x50c0
// File: /workspace/github_cpp_makefile_star2_O3/WayfireWM[P]wf-utils/main.cpp
// Function: test_access_interface_t::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool&)
virtual wf::variant_t get(const std::string &identifier, bool &error) override
    {
        error = false;
        if (_test != nullptr)
        {
            if (identifier == "property_a")
            {
                return _test->property_a;
            }
            else if (identifier == "property_b")
            {
                return _test->get_property_b();
            }
            else if (identifier == "title")
            {
                return _test->title;
            }
        }

        error = true;
        return wf::variant_t("");
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movb $0x0, (%rcx)
movq %rcx, %r15
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0xbd79
movq %rsi, %r14
leaq 0x10ad(%rip), %rsi      # 0xcdf1
movq %rdx, %rdi
movq %rdx, %r12
callq 0x5080
testl %eax, %eax
je 0xbd9a
leaq 0x10a2(%rip), %rsi      # 0xcdfc
movq %r12, %rdi
callq 0x5080
testl %eax, %eax
je 0xbda6
leaq 0x109a(%rip), %rsi      # 0xce07
movq %r12, %rdi
callq 0x5080
testl %eax, %eax
je 0xbdc7
leaq 0x2eb(%rip), %rdx       # 0xc06b
leaq 0x10(%rbx), %rax
movb $0x1, (%r15)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, (%rbx)
callq 0x6386
movb $0x5, %al
jmp 0xbdb5
movq 0x8(%r14), %rax
movl (%rax), %eax
movl %eax, (%rbx)
xorl %eax, %eax
jmp 0xbdb5
movq 0x8(%r14), %rdi
callq 0xbde8
vmovsd %xmm0, (%rbx)
movb $0x4, %al
movb %al, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r14), %rax
leaq 0x10(%rbx), %rcx
movq %rbx, %rdi
movq %rcx, (%rbx)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
callq 0x6214
jmp 0xbd96
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/Main.cpp
// Function: FindString()
void FindString()
{
	constexpr uint_fast32_t DATA_SIZE = 400;
	constexpr uint_fast32_t CACHE_DATA_SIZE = 32;
	constexpr uint_fast32_t CACHE_SIZE = 12;
	
	std::vector<const char*> inputs = {
		""
	};
	std::vector<const char*> outputs = {
		"Hello, World!"
	};

	ProgramSearch<
		ProgramIterator<DATA_SIZE, CACHE_DATA_SIZE, CACHE_SIZE>,
		DataCache<CACHE_DATA_SIZE, CACHE_SIZE>>
	search(inputs, outputs);

	search.FindString();
}

// Assembly:
pushq %rbx
subq $0x85b10, %rsp          # imm = 0x85B10
leaq 0x70cf(%rip), %rax      # 0x96f1
leaq 0x68(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movl $0x1, %edx
movq %rbx, %rsi
callq 0x2aa6
leaq 0x6a38(%rip), %rax      # 0x9080
movq %rax, (%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
callq 0x2aa6
leaq 0x38(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2aec
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2aec
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x2b6c
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x26ad
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x26c4
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
leaq 0x68(%rsp), %rdi
callq 0x2d32
leaq 0x68(%rsp), %rdi
callq 0x2d74
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x26ef
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x2706
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
addq $0x85b10, %rsp          # imm = 0x85B10
popq %rbx
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x2d74
jmp 0x2759
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x273d
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
jmp 0x273d
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x2759
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
jmp 0x2759
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2775
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
jmp 0x2775
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x278c
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/RawSourceExecutor.h
// Function: RawSourceExecutor<400ul, 32ul>::Execute()
bool Execute()
	{
		uint_fast32_t program_idx = 0;
		data_idx = data_size / 2;
		memset(data, 0, data_size);

		while (program_idx < source.length())
		{
			switch (source[program_idx])
			{
				case '+':
					data[data_idx]++;
					program_idx++;
					break;
				case '-':
					data[data_idx]--;
					program_idx++;
					break;
				case '>':
					data_idx++;
					program_idx++;
					break;
				case '<':
					data_idx--;
					program_idx++;
					break;
				case '[':
				case ']':
					program_idx = data[data_idx] == 0 ? jumps[program_idx].zero : jumps[program_idx].nonzero;
					break;
			}
			if (data_idx < 0 || data_idx >= data_size)
			{
				return false;
			}
		}
		return true;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq $0xc8, 0x4b0(%rdi)
leaq 0x320(%rdi), %r14
xorl %r15d, %r15d
movl $0x190, %edx            # imm = 0x190
movq %r14, %rdi
xorl %esi, %esi
callq 0x2100
leaq 0x20(%rbx), %rax
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movl $0xc8, %edi
movq %r15, %rsi
cmpq %rcx, %r15
jae 0x2906
movzbl (%rdx,%rsi), %r8d
cmpl $0x3d, %r8d
jg 0x28a1
cmpl $0x2b, %r8d
je 0x28d4
cmpl $0x2d, %r8d
je 0x28ea
movq %rsi, %r15
cmpl $0x3c, %r8d
jne 0x28f2
decq %rdi
jmp 0x28dd
cmpl $0x3e, %r8d
je 0x28da
cmpl $0x5b, %r8d
je 0x28b6
movq %rsi, %r15
cmpl $0x5d, %r8d
jne 0x28f2
movq %rsi, %r8
shlq $0x4, %r8
leaq (%rax,%r8), %r9
cmpb $0x0, (%r14,%rdi)
leaq 0x8(%rax,%r8), %rdi
cmoveq %r9, %rdi
movq (%rdi), %r15
jmp 0x28f2
incb (%r14,%rdi)
jmp 0x28ee
incq %rdi
movq %rdi, 0x4b0(%rbx)
leaq 0x1(%rsi), %r15
jmp 0x28f9
decb (%r14,%rdi)
leaq 0x1(%rsi), %r15
movq 0x4b0(%rbx), %rdi
cmpq $0x190, %rdi            # imm = 0x190
jb 0x2870
cmpq %rcx, %rsi
setae %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/RawSourceExecutor.h
// Function: RawSourceExecutor<400ul, 32ul>::PrintData()
void PrintData()
	{
		uint_fast32_t data_bound_low = 0;
		uint_fast32_t data_bound_high = data_size - 1;
		while (data_bound_low < data_size) {
			if (data[data_bound_low] != 0)
			{
				break;
			}
			data_bound_low++;
		}
		while (data_bound_high > data_bound_low)
		{
			if (data[data_bound_high] != 0)
			{
				break;
			}
			data_bound_high--;
		}

		for (uint_fast32_t i = data_bound_low; i <= data_bound_high; i++)
		{
			std::cout << std::setw(4) << (int)data[i];
		}
		std::cout << std::endl << std::string((data_idx - data_bound_low) * 4, ' ') << "  ^" << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
cmpb $0x0, 0x320(%rbx,%r15)
jne 0x2944
incq %r15
cmpq $0x190, %r15            # imm = 0x190
jne 0x2925
movl $0x190, %r15d           # imm = 0x190
jmp 0x29bb
movl $0x18f, %r12d           # imm = 0x18F
cmpq $0x18e, %r15            # imm = 0x18E
ja 0x2980
movl $0x4af, %r12d           # imm = 0x4AF
cmpb $0x0, (%rbx,%r12)
jne 0x2979
leaq -0x1(%r12), %rax
addq $-0x321, %r12           # imm = 0xFCDF
cmpq %r15, %r12
movq %rax, %r12
ja 0x2959
movq %r15, %r12
jmp 0x2985
addq $-0x320, %r12           # imm = 0xFCE0
cmpq %r12, %r15
ja 0x29bb
incq %r12
movq 0xa649(%rip), %r14      # 0xcfd8
movq %r15, %r13
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x4, 0x10(%r14,%rax)
movzbl 0x320(%rbx,%r13), %esi
movq %r14, %rdi
callq 0x2390
incq %r13
cmpq %r13, %r12
jne 0x2992
movq 0xa616(%rip), %r14      # 0xcfd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq %rax, %r14
movq 0x4b0(%rbx), %rsi
subq %r15, %rsi
shlq $0x2, %rsi
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x20, %edx
callq 0x2280
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2270
movq %rax, %rbx
leaq 0x668c(%rip), %rsi      # 0x90b8
movl $0x3, %edx
movq %rax, %rdi
callq 0x2270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2a76
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2a9d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::FindString()
void FindString()
	{
		if (!LoadFindStringProgress())
		{
			programSize = SIZE_START;
			SetupSize();
		}
		
		FindStringSize();

		while (true)
		{
			programSize++;
			SetupSize();
			FindStringSize();
		}
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x484a
testb %al, %al
jne 0x2d52
movq $0x10, 0x85a20(%rbx)
movq %rbx, %rdi
callq 0x4be6
movq %rbx, %rdi
callq 0x4c86
incq 0x85a20(%rbx)
movq %rbx, %rdi
callq 0x4be6
movq %rbx, %rdi
callq 0x4c86
jmp 0x2d5a
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::GetStringSizes(std::vector<char const*, std::allocator<char const*>>)
static std::vector<uint_fast32_t> GetStringSizes(std::vector<const char*> strs)
	{
		std::vector<uint_fast32_t> result;
		for (uint_fast32_t i = 0; i < strs.size(); i++)
			result.push_back(strlen(strs[i]));
		return result;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r13
movq 0x8(%rsi), %rbp
cmpq %r13, %rbp
je 0x3116
movq %rsi, %r14
xorl %r12d, %r12d
movq %rsp, %r15
movq (%r13,%r12,8), %rdi
callq 0x20c0
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x30f2
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3104
movq %rbx, %rdi
movq %r15, %rdx
callq 0x33fe
movq (%r14), %r13
movq 0x8(%r14), %rbp
incq %r12
movq %rbp, %rax
subq %r13, %rax
sarq $0x3, %rax
cmpq %rax, %r12
jb 0x30cd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x313f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2230
movq %r14, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/DataCache.h
// Function: DataCache<32ul, 12ul>::Create()
void Create()
	{
		CreateZero();
		CreateOne();
		for (uint_fast32_t size = 2; size <= max_cache_size; size++)
		{
			CreateSize(size);
			std::cout << " Created cache size " << size << " / " << max_cache_size << "\r" << std::flush;
		}
		std::cout << std::endl;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movq %rax, 0x88(%rdi)
movq %rcx, 0xf8(%rdi)
xorl %eax, %eax
movq %rax, 0x1e8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x1a0(%rdi)
movups %xmm0, 0x1b0(%rdi)
movq %rax, 0x1c0(%rdi)
movq $0x10, 0x1c8(%rdi)
movq $-0x10, 0x1d0(%rdi)
callq 0x3c6a
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rax, 0x90(%rbx)
movq %rcx, 0x100(%rbx)
movq %rbx, %rdi
callq 0x3844
movl $0x2, %r15d
movq 0x9993(%rip), %r14      # 0xcfd8
leaq 0x5ad0(%rip), %r13      # 0x911c
leaq 0x5fdc(%rip), %rbp      # 0x962f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3918
movl $0x14, %edx
movq %r14, %rdi
leaq 0x5a9a(%rip), %rsi      # 0x9107
callq 0x2270
movq %r14, %rdi
movq %r15, %rsi
callq 0x2140
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2270
movl $0xc, %esi
movq %r12, %rdi
callq 0x2140
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2270
movq %r12, %rdi
callq 0x2150
incq %r15
cmpq $0xd, %r15
jne 0x3653
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::Setup()
void Setup()
	{
		programResult = std::string();
		for (uint_fast32_t i = 0; i < THREAD_COUNT; i++)
		{
			if (threads[i]) delete threads[i];
			threads[i] = nullptr;

			iterators[i].SetCache(&cache);
			iterators[i].SetDivisionTable(&divisionTable);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
addq $0x859f8, %rdi          # imm = 0x859F8
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x2290
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x3745
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
leaq 0x401f8(%rbx), %r14
leaq 0x8(%rbx), %r15
leaq 0x1f8(%rbx), %r12
leaq 0x40320(%rbx), %r13
xorl %ebp, %ebp
movq 0x85978(%rbx,%rbp,8), %rdi
testq %rdi, %rdi
je 0x377d
cmpq $0x0, (%rdi)
jne 0x37d5
movl $0x8, %esi
callq 0x2230
movq $0x0, 0x85978(%rbx,%rbp,8)
imulq $0x4578, %rbp, %rcx     # imm = 0x4578
leaq (%r14,%rcx), %rax
movq %r15, (%r14,%rcx)
xorl %ecx, %ecx
movq %r15, (%r13,%rcx)
addq $0x1e8, %rcx            # imm = 0x1E8
cmpq $0x3d00, %rcx           # imm = 0x3D00
jne 0x379a
movq %r12, 0x4460(%rax)
incq %rbp
addq $0x4578, %r13           # imm = 0x4578
cmpq $0x10, %rbp
jne 0x3760
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/DataCache.h
// Function: DataCache<32ul, 12ul>::CreateOne()
void CreateOne()
	{
		currentProgramSize = 1;
		memset(currentData, 0, data_size);
		
		currentDataIdx = 0;
		currentDataStart = 0;
		currentDataEnd = 1;
		
		currentProgram[0] = '+';
		currentData[zeroDataIdx] = 1;
		AddData();

		currentProgram[0] = '-';
		currentData[zeroDataIdx] = 255;
		AddData();

		currentData[zeroDataIdx] = 0;
		currentDataStart = data_size / 2;
		currentDataEnd = -static_cast<int>(data_size) / 2;
		
		currentProgram[0] = '>';
		currentDataIdx = 1;
		AddData();

		currentProgram[0] = '<';
		currentDataIdx = -1;
		AddData();

		bordersBalanced[2] = dataBalancedCount;
		bordersUnbalanced[2] = dataUnbalancedCount;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r14d
movq %r14, 0x1e8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x1a0(%rdi)
movups %xmm0, 0x1b0(%rdi)
movups %xmm0, 0x1c0(%rdi)
movq %r14, 0x1d0(%rdi)
movb $0x2b, 0x1d8(%rdi)
movq (%rdi), %rax
movb $0x1, 0x1a0(%rdi,%rax)
callq 0x3c6a
movb $0x2d, 0x1d8(%rbx)
movq (%rbx), %rax
movb $-0x1, 0x1a0(%rbx,%rax)
movq %rbx, %rdi
callq 0x3c6a
movq (%rbx), %rax
movb $0x0, 0x1a0(%rbx,%rax)
movq $0x10, 0x1c8(%rbx)
movq $-0x10, 0x1d0(%rbx)
movb $0x3e, 0x1d8(%rbx)
movq %r14, 0x1c0(%rbx)
movq %rbx, %rdi
callq 0x3c6a
movb $0x3c, 0x1d8(%rbx)
movq $-0x1, 0x1c0(%rbx)
movq %rbx, %rdi
callq 0x3c6a
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rax, 0x98(%rbx)
movq %rcx, 0x108(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/DataCache.h
// Function: DataCache<32ul, 12ul>::AddData()
void AddData()
	{
		auto lookup = LookupData<data_size>(currentDataIdx, currentData);
		if (dataSet.count(lookup) > 0)
			return;
		dataSet.insert(lookup);

		bool balanced = currentDataIdx == 0;
		std::vector<AlignedData<data_size>>& data = balanced ? dataBalanced : dataUnbalanced;
		std::vector<char>& programs = balanced ? programsBalanced : programsUnbalanced;
		uint_fast32_t& dataCount = balanced ? dataBalancedCount : dataUnbalancedCount;

		data.resize(dataCount + 1);
		programs.resize((dataCount + 1) * max_cache_size + 1);
		
		memcpy(&data[dataCount].data, currentData, data_size);
		data[dataCount].idx = currentDataIdx;
		data[dataCount].start = currentDataStart;
		data[dataCount].end = currentDataEnd;
		
		memcpy(&programs[dataCount * max_cache_size], currentProgram, currentProgramSize);
		programs[dataCount * max_cache_size + currentProgramSize] = '\0';

		dataCount++;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x1c0(%rdi), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movups 0x1a0(%rdi), %xmm0
movups 0x1b0(%rdi), %xmm1
movups %xmm0, 0x8(%rsi)
movups %xmm1, 0x18(%rsi)
leaq 0x168(%rdi), %r14
movq %r14, %rdi
callq 0x3e36
testq %rax, %rax
jne 0x3db9
leaq 0x1a0(%rbx), %r13
movq %rsp, %rdx
movq %r14, (%rdx)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3f08
leaq 0x40(%rbx), %rax
leaq 0x28(%rbx), %r15
leaq 0x70(%rbx), %rcx
xorl %r12d, %r12d
cmpq $0x0, 0x1c0(%rbx)
leaq 0x58(%rbx), %r14
setne %r12b
cmovneq %rax, %r15
cmovneq %rcx, %r14
movq 0x18(%rbx,%r12,8), %rsi
incq %rsi
movq %r15, %rdi
callq 0x3dc8
movq 0x18(%rbx,%r12,8), %rax
leaq (%rax,%rax,2), %rax
leaq 0xd(,%rax,4), %rsi
movq %r14, %rdi
callq 0x3e0a
movq (%r15), %rax
imulq $0x38, 0x18(%rbx,%r12,8), %rcx
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movq 0x1c0(%rbx), %rax
movq (%r15), %rcx
imulq $0x38, 0x18(%rbx,%r12,8), %rdx
movq %rax, 0x20(%rcx,%rdx)
movq 0x1c8(%rbx), %rax
imulq $0x38, 0x18(%rbx,%r12,8), %rdx
movq %rax, 0x28(%rcx,%rdx)
movq 0x1d0(%rbx), %rax
imulq $0x38, 0x18(%rbx,%r12,8), %rdx
movq %rax, 0x30(%rcx,%rdx)
movq 0x18(%rbx,%r12,8), %rax
leaq (%rax,%rax,2), %rdi
shlq $0x2, %rdi
addq (%r14), %rdi
leaq 0x1d8(%rbx), %rsi
movq 0x1e8(%rbx), %rdx
callq 0x2190
movq 0x18(%rbx,%r12,8), %rax
leaq (%rax,%rax,2), %rax
shlq $0x2, %rax
movq 0x1e8(%rbx), %rcx
addq (%r14), %rax
movb $0x0, (%rcx,%rax)
incq 0x18(%rbx,%r12,8)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::SetupSize()
void SetupSize()
	{
		std::cout << "Setting up size " << programSize << std::endl;

		sizeStart = std::chrono::system_clock::now();
		for (uint_fast32_t thread_idx = 0; thread_idx < THREAD_COUNT; thread_idx++)
		{
			auto& iterator = iterators[thread_idx];
			iterator.Start(programSize, thread_idx, THREAD_COUNT);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x83e3(%rip), %r14      # 0xcfd8
leaq 0x462d(%rip), %rsi      # 0x9229
movl $0x10, %edx
movq %r14, %rdi
callq 0x2270
movq 0x85a20(%rbx), %rsi
movq %r14, %rdi
callq 0x2140
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
callq 0x2040
movq %rax, 0x85a30(%rbx)
leaq 0x401f8(%rbx), %r14
xorl %r15d, %r15d
movq 0x85a20(%rbx), %rsi
movl $0x10, %ecx
movq %r14, %rdi
movq %r15, %rdx
callq 0x59e0
incq %r15
addq $0x4578, %r14           # imm = 0x4578
cmpq $0x10, %r15
jne 0x4c58
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::FindStringSize()
void FindStringSize()
	{
		CountSize();

		for (uint_fast32_t i = 0; i < THREAD_COUNT; i++)
		{
			if (threads[i]) delete threads[i];
			threads[i] = new std::thread(&ProgramSearch::FindStringThread, this, i);
		}
		for (uint_fast32_t i = 0; i < THREAD_COUNT; i++)
		{
			threads[i]->join();
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x5fb8
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
xorl %eax, %eax
leaq 0x1469(%rip), %rbp      # 0x611a
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
movq 0x85978(%rbx,%rax,8), %rdi
testq %rdi, %rdi
je 0x4cd8
cmpq $0x0, (%rdi)
jne 0x4d4c
movl $0x8, %esi
callq 0x2230
movl $0x8, %edi
callq 0x2220
movq %rax, %r13
movq %rbp, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %rbx, 0x10(%rsp)
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x6ea6
movq 0x8(%rsp), %rax
movq %r13, 0x85978(%rbx,%rax,8)
incq %rax
movq %rax, 0x8(%rsp)
cmpq $0x10, %rax
jb 0x4cbb
xorl %r14d, %r14d
movq 0x85978(%rbx,%r14,8), %rdi
callq 0x2380
incq %r14
cmpq $0x10, %r14
jne 0x4d27
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
movq %rax, %rbx
movl $0x8, %esi
movq %r13, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/ProgramSearch.h
// Function: ProgramSearch<ProgramIterator<400ul, 32ul, 12ul, 32ul>, DataCache<32ul, 12ul>>::StringToHex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string StringToHex(const std::string& input)
	{
		static const char hex_digits[] = "0123456789ABCDEF";

		std::string output;
		output.reserve(input.length() * 2);
		for (unsigned char c : input)
		{
			output.push_back(hex_digits[c >> 4]);
			output.push_back(hex_digits[c & 15]);
		}
		return output;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rsi
addq %rsi, %rsi
callq 0x2310
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x5756
movq (%r14), %r14
xorl %r13d, %r13d
leaq 0x408a(%rip), %rbp      # 0x97b0
movzbl (%r14,%r13), %r15d
movl %r15d, %eax
shrl $0x4, %eax
movsbl (%rax,%rbp), %esi
movq %rbx, %rdi
callq 0x21b0
andl $0xf, %r15d
movsbl (%r15,%rbp), %esi
movq %rbx, %rdi
callq 0x21b0
incq %r13
cmpq %r13, %r12
jne 0x5726
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x576a
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x5785
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2230
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::Deserialize(std::istream&)
bool Deserialize(std::istream& input)
	{
		input >> stackSize;
		input >> firstCacheSize;
		for (uint_fast32_t i = 0; i < max_stack_size; i++)
		{
			input >> indexStack[i];
		}
		for (uint_fast32_t i = 0; i < max_stack_size; i++)
		{
			input >> balancedStack[i];
		}
		input >> first;

		// Restore dataStack
		for (int i = stackSize - 1; i >= 0; i--) CalcData(i);

		return true;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x20f0
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x20f0
movl $0x18, %r15d
leaq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0x20f0
addq $0x8, %r15
cmpq $0x30, %r15
jne 0x5823
movl $0x30, %r15d
leaq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0x21c0
incq %r15
cmpq $0x33, %r15
jne 0x583f
leaq 0xe0(%rbx), %rsi
movq %r14, %rdi
callq 0x21c0
movl 0x8(%rbx), %eax
decl %eax
js 0x587e
movl %eax, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5886
addq $-0x1, %r14
jb 0x586d
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::CalcData(unsigned long)
void CalcData(uint_fast32_t idx)
	{
		AlignedData<data_size>& data = balancedStack[idx] ? cache->dataBalanced[indexStack[idx]] : cache->dataUnbalanced[indexStack[idx]];
		if (idx == stackSize - 1)
		{
			dataStack[idx] = data;
		}
		else
		{
			AddData<data_size>(dataStack[idx], dataStack[idx + 1], data);
		}
	}

// Assembly:
cmpb $0x0, 0x30(%rdi,%rsi)
movl $0x28, %eax
movl $0x40, %ecx
cmovneq %rax, %rcx
imulq $0x38, 0x18(%rdi,%rsi,8), %rdx
movq (%rdi), %rax
movq 0x8(%rdi), %r8
addq (%rax,%rcx), %rdx
decq %r8
imulq $0x38, %rsi, %rcx
leaq (%rdi,%rcx), %rax
addq $0x38, %rax
cmpq %rsi, %r8
jne 0x58dd
movq 0x30(%rdx), %rcx
movq %rcx, 0x30(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
retq
addq $0x38, %rdi
leaq (%rcx,%rdi), %rsi
addq $0x38, %rsi
movq %rax, %rdi
jmp 0x58f1
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::Start(unsigned long, unsigned long, unsigned long)
void Start(uint_fast32_t programSize, uint_fast32_t threadOffset, uint_fast32_t threadDelta)
	{
		this->programSize = programSize;
		this->currentCount = 0;
		
		this->threadOffset = threadOffset;
		this->threadDelta = threadDelta;

		memset(iteratorSizes, 0, max_program_size * sizeof(int_fast32_t));

		iteratorCount = 1;
		iteratorSizes[0] = programSize;
		firstIteratorWithNonZeroDataDelta = 0;
		lastExecutionMaxProgramIdx = 0;
		bracketIdx = 0;

		bracketIdx = 0;
		brackets[0].bracket = Bracket::EMPTY;
		brackets[0].depth = 0;
		jumps[0].zero = jumps[0].nonzero = 1;
		
		if (!NextValidIteratorSizes(threadOffset))
		{
			return;
		}
		bracketIdx = 0;
		while (!NextBrackets())
		{
			if (!NextValidIteratorSizes(threadDelta))
			{
				return;
			}
			bracketIdx = 0;
		}
		lastExecutionMaxProgramIdx = iteratorCount - 1;

		iteratorIdx = 0;
		iterators[0].Start(iteratorSizes[0]);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x18(%rdi)
xorl %r13d, %r13d
movq %r13, 0x4270(%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
addq $0x30, %rdi
movl $0xf8, %edx
xorl %esi, %esi
callq 0x2100
movl $0x1, %eax
movq %rax, 0x20(%rbx)
movq %r12, 0x28(%rbx)
movq %r13, 0x4240(%rbx)
movq %r13, 0x4470(%rbx)
movq %r13, 0x4230(%rbx)
movl $0x0, 0x3e30(%rbx)
movq %r13, 0x3e38(%rbx)
movq %rax, 0x4038(%rbx)
movq %rax, 0x4030(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5aca
testb %al, %al
je 0x5a8a
movq $0x0, 0x4230(%rbx)
movq %rbx, %rdi
callq 0x5bfe
testb %al, %al
jne 0x5a94
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x5a62
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rsi
decq %rax
movq %rax, 0x4470(%rbx)
movq $0x0, 0x4238(%rbx)
addq $0x128, %rbx            # imm = 0x128
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5dc8
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/ProgramIterator.h
// Function: ProgramIterator<400ul, 32ul, 12ul, 32ul>::NextValidIteratorSizes(unsigned long)
bool NextValidIteratorSizes(uint_fast32_t count)
	{
		for (int_fast32_t c = count; c > 0; c--)
		{
			while (!NextIteratorSizes())
			{
#ifdef SINGLE_ITER_COUNT
				if (iteratorCount == 1) iteratorCount = SINGLE_ITER_COUNT;
				else return false;
#else
				iteratorCount += 2;
#endif
				remainingSize = programSize - iteratorCount + 1;
				if (remainingSize <= 0) return false;

				for (uint_fast32_t i = 0; i < iteratorCount - 2; i++)
				{
					assert(i >= 0 && i < max_program_size);
					iteratorSizes[i] = 0;
				}
#ifdef INITIAL_ZERO
				iteratorSizes[0] = 1;
				remainingSize--;
				if (remainingSize < 0) return false;
#endif
				assert(iteratorCount - 2 >= 0 && iteratorCount - 2 < max_program_size);
				// Set to -1 so that after the first call to NextIteratorSizes it will be 0
				iteratorSizes[iteratorCount - 2] = -1;
				remainingSize++;
				firstIteratorWithNonZeroDataDelta = 0;
			}
		}
		return true;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %bl
testq %rsi, %rsi
jle 0x5bb1
movq %rsi, %r14
movq %rdi, %r15
movabsq $0x7ffffffffffffffe, %r12 # imm = 0x7FFFFFFFFFFFFFFE
movq %r15, %rdi
callq 0x5e6c
testb %al, %al
jne 0x5b9c
movq 0x18(%r15), %rcx
movq 0x20(%r15), %rax
leaq 0x2(%rax), %rdx
movq %rdx, 0x20(%r15)
subq %rdx, %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x3e28(%r15)
cmpq %r12, %rcx
ja 0x5baf
testq %rax, %rax
je 0x5b6d
xorl %ecx, %ecx
cmpq $0x20, %rcx
je 0x5bbf
movq $0x0, 0x28(%r15,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5b2b
movq 0x3e28(%r15), %rcx
movq $0x1, 0x28(%r15)
leaq -0x1(%rcx), %rdx
movq %rdx, 0x3e28(%r15)
testq %rcx, %rcx
jle 0x5baf
cmpq $0x20, %rax
jb 0x5b7c
jmp 0x5bde
movq $0x1, 0x28(%r15)
movq %rcx, 0x3e28(%r15)
movq $-0x1, 0x28(%r15,%rax,8)
incq 0x3e28(%r15)
movq $0x0, 0x4240(%r15)
jmp 0x5aed
leaq -0x1(%r14), %rax
cmpq $0x1, %r14
movq %rax, %r14
jg 0x5aed
jmp 0x5bb1
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3674(%rip), %rdi      # 0x923a
leaq 0x368c(%rip), %rsi      # 0x9259
leaq 0x369b(%rip), %rcx      # 0x926f
movl $0x103, %edx            # imm = 0x103
callq 0x2120
leaq 0x3723(%rip), %rdi      # 0x9308
leaq 0x366d(%rip), %rsi      # 0x9259
leaq 0x367c(%rip), %rcx      # 0x926f
movl $0x10b, %edx            # imm = 0x10B
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksabry[P]bfbrute/src/LinearIterator.h
// Function: LinearIterator<32ul, 12ul, 32ul>::Start(unsigned long)
void Start(uint_fast32_t programSize)
	{
		stackSize = programSize == 0 ? 1 : (programSize - 1) / cache_size + 1;
		firstCacheSize = programSize == 0 ? 0 : (programSize - 1) % cache_size + 1;
	
		indexStack[0] = cache->bordersBalanced[firstCacheSize];
		balancedStack[0] = true;
		for (uint_fast32_t i = 1; i < stackSize; i++)
		{
			indexStack[i] = cache->bordersBalanced[cache_size];
			balancedStack[i] = true;
		}
		first = true;
	}

// Assembly:
testq %rsi, %rsi
je 0x5e42
decq %rsi
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq %rsi, %rax
mulq %rcx
shrq $0x3, %rdx
leaq 0x1(%rdx), %rax
movq %rax, 0x8(%rdi)
shlq $0x2, %rdx
leaq (%rdx,%rdx,2), %rax
movq %rsi, %rcx
subq %rax, %rcx
incq %rcx
movq %rcx, 0x10(%rdi)
movq (%rdi), %rax
movl %ecx, %ecx
movq 0x88(%rax,%rcx,8), %rcx
movq %rcx, 0x18(%rdi)
movb $0x1, 0x30(%rdi)
cmpq $0xc, %rsi
jb 0x5e64
movq 0xe8(%rax), %rax
xorl %ecx, %ecx
movq %rax, 0x20(%rdi,%rcx,8)
movb $0x1, 0x31(%rdi,%rcx)
leaq 0x1(%rcx), %rdx
addq $0x2, %rcx
cmpq 0x8(%rdi), %rcx
movq %rdx, %rcx
jb 0x5e25
jmp 0x5e64
movq $0x1, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdi), %rax
movq 0x88(%rax), %rax
movq %rax, 0x18(%rdi)
movb $0x1, 0x30(%rdi)
movb $0x1, 0xe0(%rdi)
retq